Variable Scope

תמלול ההרצאה: Variable Scope

הטקסט המלא של הדקות הראשונות בהרצאה «Variable Scope» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.

1. 00:03

   המונח הבא שחשוב לנו להכיר בעולם הפונקציות זה סקופ. סקופ זה טווח הכרה. זה אומר מהיכן עד היכן ניתן להשתמש במשתנה שהגדרנו.

2. 00:18

   אז מה זה אומר? אם אנחנו מגדירים משתנה במיקום מסוים, איפה אני בעצם יכול להשתמש בו? אם אני עכשיו מגדיר פה int x ומכניס את החור ערך, אנחנו יודעים שאנחנו יכולים פשוט להציג פה את x.

3. 00:32

   בואו נציג את זה בצורה כזאת, נריץ ונראה שבאמת x מוצג על המסך. האם אנחנו יכולים גם להציג את x כאן? אז כמובן שאנחנו לא יכולים ואנחנו רואים איזושהי שגיאה.

4. 00:47

   אז יש פה קטע של, רגע, אם יש לי משתנה איפה אני יכול להשתמש איתו? אז ברור לנו שאנחנו יכולים להשתמש איתו מאותה פקודה והלאה.

5. 00:56

   רגע, אבל האם אני יכול להשתמש איתו גם בפונקציות אחרות? אז יש פה כלל קצת יותר ספציפי מבוא נשתמש איתו אחרי ההצהרה שלו.

6. 01:08

   והחוק הזה זה בעצם חוק שמתאר את הסקופינג שלו, איפה אפשר לגעת בו, והחוק אומר דבר כזה, ניתן להשתמש עם משתנה מאותה הנקודה שבה הוא הוגדר ועד לסוף הבלוק שבו הוא הוגדר, שימו לב לבלוק הזה.

7. 01:28

   אני רואה ש-X נמצא בתוך המיין, המיין מתחיל כאן ומסתיים כאן. זאת אומרת שאנחנו יכולים להשתמש עם X רק מהנקודה הזאת, ועד לסוף הבלוק הזה זאת כמובן שגיאה אם אנחנו מנסים להשתמש איתו לפני אוקיי בואו נראה משהו נוסף קצת שונה אם יש לנו לדוגמה איזשהו משפט תנאי בואו נגיד האם x גדול מ-100 שכרגע

8. 01:59

   זה יהיה true ואני בא ואני מגדיר פה עוד משתנה y שווה 4,5,6 ואני רוצה להטיס כמה זה y y שווה ל-4,5,6 אנחנו מריצים את זה ואנחנו רואים שהוא מדפיס לנו כמה זה x וכמה זה y.

9. 02:21

   עד כאן הכל בסדר, התכוונתי להדפיס y. ואנחנו עכשיו יכולים לכתוב את הקוד הזה. האם הקוד הזה יעבוד? אז כמובן שלא, כי לפי החוק שראינו כרגע אפשר להשתמש עם y מהנקודה שבה הוא הוגדר ועד לסוף הבלוק שלו.

10. 02:44

    אז ברור שאי אפשר להשתמש איתו לפני. זה כמובן אירו, אבל האם אפשר להשתמש עם y כאן? ואנחנו רואים שגם כאן יש לנו שגיאה, מפני שאני נמצא מחוץ לבלוק שבו y הוגדר, ויהיה אירור.

11. 03:05

    מה קורה בנוגע לפונקציות? בואו נבנה כאן פונקציה static void f כלשהי, בואו נקרא לה f1, ויש לנו כאן עוד משתנה int z שווה 7, 8, 9. ואני רוצה להדפיס כמה זה z בצורה כזאת.

12. 03:28

    בואו נקרא מפה ל-F1 ואם אנחנו נריץ את זה אנחנו כמובן נראה את Z מוצג על המסך. אז בואו נעשה כמה ניסויים. האם פה מותר לי להשתמש עם Z? כמובן שלא, לפי החוק מהנקודה שבה הוא הוגדר ועד לסוף הבלוק שלו.

13. 03:53

    אז זאת כמובן הופכת להיות שגיאה. בסדר, מה קורה אם יש לי כאן בלוק פנימי? אם Z גדול מ-100, בוא תציג לי שוב פעם את z, האם מותר לעשות את זה?

14. 04:15

    אז התשובה היא בהחלט כן, כי z הוגדר כאן ואנחנו פה עדיין נמצאים בתוך הבלוק הזה שנמצא פה, ואז אנחנו נראה את z מודפס פעמיים. אוקיי, בואו ננסה משהו אחר, static void f2, האם פה אני יכול להדפיס את z?

15. 04:39

    והתשובה היא כמובן שלא, מפני ש-z לא הוגדר בתוך הבלוק הזה, z הוגדר בתוך הפונקציה f1, אז אנחנו לא יכולים להשתמש איתו בצורה כזאת. אבל מה קורה אם יש לנו כאן איזשהו משתנה, בואו ניקח כאן a שווה 100, ופה יש לנו עוד משתנה וגם הוא נקרא a והוא שווה 200. האם אלו אותם משתנים?

16. 05:12

    והתשובה היא לא. כל משתנה לוקאלי של פונקציה הוא נפרד ושייך אך ורק לפונקציה. זאת אומרת שפיזית בזיכרון עצמו של המחשב,