לוגו/משתנים

משתנים

כדי לצייר בלוגו ריבוע היה עלינו להורות לצב:

fd 100 rt 90
fd 100 rt 90
fd 100 rt 90
fd 100 rt 90

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

repeat 4 [fd 100 rt 90]

כאשר רצינו לצייר ריבוע נוסף, במקום אחר על המסך, היה עלינו להניע את הצב אל המקום החדש ואז לכתוב מחדש את פקודת הציור. כדי לחסוך את ההקלדה המיותרת הגדרנו "הליך" בשם square ("ריבוע"):

to square
repeat 4 [fd 100 rt 90]
end

בעזרת ההליך אנו יכולים לצייר ריבועים בכל עת: אנו מניעים את הצב לנקודה המבוקשת ואז מורים לו: "square". זהו שיפור, אך עדיין ישנה בעיה: ההליך שכתבנו מצייר ריבוע שאורך צלעו הוא תמיד 100. כדי לצייר ריבוע שאורך צלעו חמישים, למשל, נצטרך להגדיר הליך חדש, כזה:

to square_50
repeat 4 [fd 50 rt 90]
end

ההליך החדש, ששמו "square_50", פותר לנו את הבעיה במקרה אחד, אבל מה נעשה כשנרצה ריבוע שאורך צלעו הוא 200? האם נצטרך להגדיר עוד ועוד הליכים העושים, בעצם, את אותו הדבר???
התשובה היא, לשמחתנו, שלילית. ניתן ללמד את לוגו לצייר ריבוע בגודל שאותו נקבע בכל פעם מחדש, אך הדבר ידרוש מאיתנו להשתמש ב"משתנים" (Variables).

שימוש במשתנים בהגדרת הליך

לפני שנסביר בדיוק כיצד הוא עובד, הבה ונסתכל בהליך החדש שלנו:

to square :size
repeat 4 [fd :size rt 90]
end

מה קרה כאן? בכותרת ההליך החדש שכתבנו מופיע הצירוף size: צירוף זה מורכב מהמילה size (שפירושה "גודל") ומהסימן נקודתיים ":". המילה size משמשת כשמו של "משתנה". היא נבחרה על ידי המתכנת שכתב את ההליך. המתכנת יכול היה לתת למשתנה גם שם אחר (aaa, למשל), אבל נהוג לתת למשתנים שמות המצביעים על השימוש שייעשה בהם בתכנית. כמו בבחירת השם להליך חדש, גם כאן יש למתכנת בחירה מוגבלת, שכן שם המשתנה צריך לעמוד באותם כללים החלים על בחירת שם להליך. כזכור, המלצתנו היא לתת שם שיכיל אותיות אנגליות, ספרות אם צריך (אסור שהשם יתחיל בסיפרה!) וכן את סימן הקו התחתון "_", שישמש כמפריד בין מילים. במקום size יכול היה המתכנת שלנו להשתמש במילה godel, למשל, ומתכנתים דוברי-עברית היו מבינים שמדובר במשתנה האמור לקבוע "גודל" של דבר מה.
אבל מהו "משתנה"? משתנה הוא מעין "תיבה" בזיכרון המחשב. לתיבה זו יש שם (שם המשתנה) ותוכן (ערכו של המשתנה). כאשר אנו מקדימים לשם המשתנה את הסימן ":" משמעות הדבר היא "ערכו של המשתנה שזהו שמו", כלומר "מה שנמצא בתיבה שעליה כתוב שם זה".
כאשר נרצה להפעיל את ההליך החדש שכתבנו נצטרך להשתמש בפקודה הכוללת גם מספר - square 150, למשל. הסיבה לכך היא, שכאשר לוגו נתקלת במילה square ומוצאת את ההליך שלנו בזיכרון ההליכים שלה, היא מגלה שנחוץ לה ערך נוסף, ערך שאותו יש להציב במשתנה size. לוגו תיקח את המספר 150, תגדיר בזיכרון המחשב "תיבה" חדשה בשם "size" ואז "תציב" בתיבה זו את המספר 150. אם ננסה להפעיל את ההליך החדש ללא מספר אחרי המילה square, לוגו לא תוכל לצייר מאום. במקום זאת תודפס בחלון הפקודות הודעת שגיאה.
בשורה הראשונה של ההליך לוגו מבינה שעליה להגדיר משתנה, והיא נותנת לו שם וערך. בשורה השנייה של ההליך, כאשר הצירוף size: מופיע בפעם השניה בתוך ההליך, לוגו כבר מכירה את המשתנה size. היא יודעת למצוא אותו בזיכרון ולברר מה תוכנו. לוגו עושה זאת ומגלה שתוכן המשתנה הוא 150. כעת לוגו "מחליפה" את הצירוף size: בערך שקיבלה (150). כתוצאה מכך, הפקודה המופיעה בשורה השנייה תבוצע כאילו היה כתוב בה [repeat 4 [fd 150 rt 90 .
בשפות תיכנות רבות, שפת C, למשל, צריך "להכריז" על כל משתנה חדש ולהכריז על סוגו (בהכרזה אנו מודיעים למחשב האם ב"תיבה" החדשה בזיכרון המחשב ניתן יהיה לשים רק מספרים, רק אותיות, רק מילים וכדומה). בלוגו אין צורך לעשות זאת. שם המשתנה המופיע בהגדרת ההליך מוגדר אוטומטית כאשר ההליך מתחיל לפעול, והמשתנה יכול להכיל כל מה שנשים בתוכו.

שימוש במספר משתנים בהגדרת ההליך

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

to sikum :value1 :value2 :value3 :value4 :value5 :value6 :value7 :value8 :value9 :value10
print :value1+:value2+:value3+:value4+:value5+:value6+:value7+:value8+:value9+:value10
end

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

sikum 1 1 1 1 1 1 1 1 1 2

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

הגדרת משתנים בתוך ההליך

• ניתן להגדיר משתנים גם בתוך הליך, בעזרת הפקודה make. אופן השימוש בפקודה הוא כזה:

make "name value

הפקודה make מצפה לשני פריטי קלט: הראשון הוא שם המשתנה והשני הוא ערכו. לפני שם המשתנה יבוא הסימן גרשיים ("). כאשר לוגו נתקלת בסימן זה בתחילת רצף של תוים, היא יודעת שהרצף הזה אינו שם של פקודה או הליך, אלא פשוט רשימה של אותיות - מושג תיכנותי המכונה גם "מחרוזת". רשימת האותיות הזו תהפוך, בעזרת הפקודה, לשמו של משתנה חדש. לוגו תגדיר "תיבה" חדשה תחת השם שיוצרת ה"מחרוזת", ואז תציב באותה התיבה, כ"ערכו של המשתנה", את פריט הקלט השני שקיבלה.

• הפקודה ההפוכה ל make היא thing. אם נכתוב:

thing "name

התוצאה תהיה הדפסת ערכו של המשתנה ששמו name. מה שהפקודה thing עושה הוא לקחת את המחרוזת name ולחפש משתנה שזהו שמו (איך יודעים שזו מחרוזת? לפי סימן הגרשיים שבתחילתה!). כאשר לוגו מוצאת את המשתנה, היא מדפיסה את ערכו.
למעשה, נפגשנו כבר בפקודה thing, אבל בגירסה המקוצרת שלה - סימן הנקודתיים (":"). כאשר אנו כותבים name: מה שלוגו מבצעת הוא, בעצם, thing "name.

יצירת הליך מסודר בעזרת משתנים

דרך נוחה ליצור הליך מסודר (הליך שמצבו של הצב בתחילתו ובסופו הוא זהה), היא לשמור את ערכיו ההתחלתיים של הצב במשתנים, ובסוף להחזיר אותם למקומם:

to name
make "x xcor
make "y ycor
make "head heading
(כאן אנו מבצעים פעולות שונות המשנות את מיקומו וכיוון תנועתו של הצב)...
setx :x
sety :y
setheading :head
end

הערות לסיום

• המשתנים בלוגו הם גמישים, וכאמור לא צריך להכריז איזה סוג נתונים יכיל המשתנה. עם זאת, כדאי להכיר את טיפוסי הנתונים הנפוצים:

בוליאני - משתנה היכול להכיל true או false בלבד. משמש לתנאים.

מספרי - משתנה המכיל מספר כלשהו.

מחרוזת - רצף של תווים.

רשימה - אוסף של משתנים ורשימות אחרות. ניתן לפנות לאיבר בודד של הרשימה.

לוגו מכירה את כל סוגי המשתנים הללו, וסוגים נוספים שנכיר בהמשך.

• הפקודה make מאפשרת לנו להגדיר אוסף הוראות שיופעל ברגע שהקובץ נפתח. השימוש בתכונה זו נעשה בדיוק כמו הגדרת משתנה:

make "startup [רשימה של פקודות לוגו]

יש לכתוב שורה זו במסך העריכה הכללי (edall), להקפיד שלא למקם אותה בתוך הליך, ואז לשמור את התוכנית שכתבנו כקובץ. כאשר נפתח את מחדש את הקובץ, תבצע לוגו באופן אוטומטי את הפקודות המופיעות בין הסוגריים המרובעים. במצב רגיל, כל אדם המנסה להפעיל תכנית לוגו היה צריך לדעת מה שמו של ההליך שאותו עליו להפעיל ראשון. בשיטת ההפעלה האוטומטית, התוכנית עצמה מפעילה את ההליך הנכון באופן אוטומטי. כדי לשמור על תיכנות ברור ו"קריא", נהוג להגדיר עבור התוכנית הליך בשם main, שיהיה ההליך ה"אחראי" על הפעלת יתר ההליכים בתוכנית. שורת ה-startup צריכה לקרוא להליך זה, ולו בלבד:

make "startup [main]

הפרק הקודם: הליכים

משתנים

הפרק הבא: תנאים