0:00:02.743,0:00:05.312
בשפה האנגלית יש לנו חלקים שונים של דיבור,

0:00:05.312,0:00:08.281
כמו שם עצם, שם תואר, מילות יחס, פעלים.

0:00:08.281,0:00:12.051
וכמו כן יש גם אוסף של חוקים שאומרים לנו מתי ואיך להשתמש בכל אחד מחלקי הדיבור האלו ביחד

0:00:12.051,0:00:21.939
אני יכולה להגיד משהו כמו ״שיעורים הכלב את אכל לי״, ואתם תגידו ״על מה לעזאזל את מדברת?!״

0:00:21.939,0:00:25.580
ואם לא הבנתם את זה כבר, מסתבר שאסור לשים שני שמות עצם

0:00:25.580,0:00:28.755
לפני שם תואר או לפני פועל. לא עובד.

0:00:28.755,0:00:37.008
אבל אם הייתי מחליפה את הסדר ואומרת ״הכלב אכל לי את השיעורים״ אז הייתם מבינים למה אני מתכוונת.

0:00:37.008,0:00:42.882
אפילו הייתי יכולה להחליף את המילה ״אכל״ עם פועל אחר כמו, נגיד, ״זרק״

0:00:42.882,0:00:47.880
ועדיין זה היה הגיוני מבחינת דקדוק, אפילו אם קשה לדמיין כלב זורק ספר.

0:00:47.880,0:00:51.794
אז בתכנות, במקום החלקים השונים של הדיבור, יש לנו דברים כאלו שנקראים ״טיפוסים״ או באנגלית ״types".

0:00:51.794,0:00:56.713
כבר ראיתם אותם בעבר: מספרים. אנחנו משתמשים במספרים כל הזמן בקוד הציור שלנו.

0:00:56.713,0:01:01.263
ובדיוק כמו באנגלית, יש זמנים שבהם זה הגיוני להשתמש במספר, ויש כאלו שלא.

0:01:01.263,0:01:08.550
אם אני אתחיל להקליד בפונקציית ה-background הזו, ״100 מינוס״ אז  כדאי שהדבר הבא יהיה מספר

0:01:08.550,0:01:14.279
או לפחות משהו שהערך שלו הוא מספר כמו ״14 + 15״

0:01:14.279,0:01:20.341
מצד שני, אם אני פשוט אקליד ״100 רווח״, אני לא יכולה להקליד מספר אחרי זה

0:01:20.341,0:01:23.465
כי ״100 רווח 10״ לא באמת אומר משהו.

0:01:23.465,0:01:27.772
יש טיפוס נוסף בתכנות, נקרא לו טיפוס בוליאני.

0:01:27.772,0:01:33.937
והוא נקרא בוליאני מכיוון שבחור כלשהו בשם ג׳ורג׳ בול המציא אותו.

0:01:33.937,0:01:37.635
ובניגוד למספר, שיש לו מלא ערכים אפשריים,

0:01:37.635,0:01:42.628
לטיפוס בוליאני יכול להיות רק אחד מתוך שני ערכים: אמת (true) או שקר (false)

0:01:42.628,0:01:47.054
ושימו לב שכשאני מקלידה אותם, הם הופכים להיות כחולים, מה שאומרים שהם מילה סופר מיוחדת ושמורה.

0:01:47.054,0:01:50.557
בטוח שכבר ראיתם מקום אחד שמשתמש בבוליאנים, למרות שאולי לא הבנתם את זה:

0:01:50.557,0:01:51.522
הצהרות if!

0:01:51.522,0:01:53.246
בואו נזכר ממש מהר איך זה עובד.

0:01:53.246,0:01:59.381
אני הולכת להגדיר משתנה בשם ״number״, ולתת לו ערך, נגיד 40.

0:01:59.381,0:02:08.600
ולכתוב הצהרת if שאומרת "אם המספר נמוך מ-50 אז...

0:02:08.600,0:02:11.130
... אז אני אצייר את האליפסה הראשונה הזו״.

0:02:11.130,0:02:15.951
אני הולכת להעתיק את ההצהרת if הזו וליישר אותה על ידי בחירה של הכל ולחיצה על מקש ה-TAB.

0:02:17.613,0:02:23.127
אז עכשיו ההצהרה הזו אומרת, ״אם המספר נמוך מ-50 (והוא נמוך!) אז נצייר את האליפסה העליונה״.

0:02:23.127,0:02:28.338
ואם אני אהפוך את המספר ליותר מ-50 אז אתם יכולים לראות שהאפליסה נעלמת.

0:02:28.338,0:02:32.962
אוקיי, אז הדבר הזה בתוך הסוגריים הוא למעשה ביטוי בוליאני.

0:02:32.962,0:02:40.407
זכרו שביטוי מתמטי הוא כל דבר שניתן לחשב את ערכו כמספר, לדוגמא: 3 ועוד 2 ועוד 4 כפול 8.

0:02:40.407,0:02:43.672
אז ביטוי בוליאני הוא כל דבר שניתן להעריכו כבוליאני (אמת או שקר)

0:02:43.672,0:02:47.109
דרך טובה לבדוק אם ביטוי הוא בוליאני היא באמצעות המילה ״האם״

0:02:47.109,0:02:50.630
בתחילת הביטוי, ולהציג את הביטוי כמו שאלה.

0:02:50.630,0:02:53.882
אם זה נשמע כמו שאלת כן/לא פשוטה אז תדעו שזה ביטוי בוליאני.

0:02:53.882,0:03:00.384
כאן למשל אנחנו יכולים להגיד, ״האם number קטן מ-50?״ כן! אז כן, זה ביטוי בוליאני.

0:03:00.384,0:03:04.732
מצד שני, אם היה לנו משהו כמו ״4 + 4״, והיינו מנסים לשאול,

0:03:04.732,0:03:10.803
״האם 4 + 4?״ לא. זה לא ביטוי בוליאני.

0:03:10.803,0:03:13.217
אז בחזרה להצהרת ה-if שלנו. אני למעשה יכולה לשים הכל

0:03:13.217,0:03:17.369
בתוך הסוגריים, כל עוד זה משתנה בוליאני או ביטוי בוליאני.

0:03:17.369,0:03:20.942
אז אני יכולה לכתוב ״if true״, ואז האליפסה תמיד תצוייר.

0:03:20.942,0:03:24.636
או שאני יכול להגיד ״if false״ ואז האליפסה לעולם לא תצוייר.

0:03:24.636,0:03:29.601
אני גם יכולה לעשות משהו כמו ״אם 3 קטן מ-4״, שזה ביטוי בוליאני

0:03:29.601,0:03:33.295
שתמיד יהיה נכון, שזה קצת חסר טעם,

0:03:33.295,0:03:37.950
האליפסה תמיד תצוייר. או למשל ״3 גדול מ-4״ מה שתמיד יהיה שקר.

0:03:37.950,0:03:40.575
ואני יכולה לתת ערך בוליאני למשתנה, ככה

0:03:40.575,0:03:48.339
אז אני הולכת להגדיר משתנה חדש, נראה לו winstonIsCool, ונציב לו ערך

0:03:48.339,0:03:54.549
בוליאני, אז או אמת או שקר. נניח אמת מכיוון שוינסון באמת מגניב.

0:03:54.549,0:03:58.801
ועכשיו שלמשתנה הזה יש ערך בוליאני, אני יכולה להעתיק לאותו

0:03:58.801,0:04:02.874
ולשים אותו בתוך הצהרת ה-if

0:04:02.874,0:04:06.052
ועכשיו אתם יכולים לראות שהאליפסה אכן מצויירת, מכיוון שהערך של המשתנה winstonIsCool

0:04:06.052,0:04:08.629
הוא אמת.

0:04:08.629,0:04:10.737
אני יכול להחליף את זה עם ביטוי בוליאני,

0:04:10.737,0:04:15.397
למשל ״2 קטן מ-4״.

0:04:15.412,0:04:18.109
עכשיו אם אתם מגדירים משתנה שמיועד להיות בוליאני,

0:04:18.109,0:04:21.341
כדאי שתתנו לו שם שמתאר את התנאי שלו כשהמשתנה נכון (true).

0:04:21.341,0:04:24.020
דרך טובה לבדוק אם בחרת שם טוב עבור המשתנה שלכם

0:04:24.020,0:04:27.618
היא לשים אותו בהצהרת if ולראות אם הוא הגיוני בתור תנאי.

0:04:27.618,0:04:31.214
תשכחו רגע את winstonIsCool, אנחנו כבר יודעים שזה נכון.

0:04:31.214,0:04:34.636
נניח שהיה לנו משתנה בשם "muffins״.

0:04:34.636,0:04:37.222
אוקיי, אם muffins, המממ,

0:04:37.222,0:04:41.392
אתם יודעים מה, השם הזה לא אומר לי כלום, אז כנראה שזה שם רע למשתנה.

0:04:41.392,0:04:45.966
אבל אם היה לי תנאי עם משתנה כמו למשל "if muffinsAreBaking״, אז זה היה כבר אומר לי משהו

0:04:45.981,0:04:50.830
כשהמשתנה הזה היה נכון, הייתי יודעת שהמאפינס כרגע באפייה (the muffins are baking).

0:04:50.830,0:04:54.105
ואל תשאלו אותי אילו מאפינס, זה לא חשוב.

0:04:54.105,0:04:58.887
בואו נחזור רגע ל״אם המספר נמוך מ-50״.

0:04:58.887,0:05:00.036
מגניב.

0:05:00.036,0:05:02.403
בואו נסתכל על כמה ביטויים בוליאנים נוספים.

0:05:02.403,0:05:05.426
כבר ראיתם את ״גדול מ״ ו״קטן מ״.

0:05:05.426,0:05:08.837
אבל אפשר גם לבדוק אם משהו ״קטן או שווה למשהו״ באמצעות הסימן =>

0:05:08.837,0:05:12.671
אז בואו ננסה, אם המספר קטן או שווה ל-48,

0:05:12.671,0:05:19.901
ואנחנו גם יכולים להגיד, אם המספר גדול או שווה ל-48, באמצעות הסימן =<.

0:05:19.901,0:05:23.883
אם זה כך, נצייר את האליפסה העליונה הימנית.

0:05:25.837,0:05:27.318
ניישר את זה.

0:05:27.318,0:05:31.675
ואם תרצו לבדוק אם שני דברים שווים בדיוק אחד לשני, תוכלו להגיד:

0:05:31.675,0:05:37.622
אם המספר === 48, או בקוד: if number === 48.

0:05:38.484,0:05:41.550
שזה לפחות שני סימני שווה יותר ממה שהשתמשתם בהם במתמטיקה,

0:05:41.550,0:05:44.412
עכשיו יש לכם שלושה בשורה.

0:05:44.412,0:05:46.423
זה קצת מוגזם לא?

0:05:46.423,0:05:50.972
אפשר גם לבדוק אם משהו לא שווה למשהו,

0:05:50.972,0:05:59.769
אם זה בהחלט לא שווה, אז אפשר לכתוב ״אם המספר ==! 48״ או בקוד: if number !== 48.

0:05:59.769,0:06:03.019
ואז נצייר את האליפסה האחרונה.

0:06:03.866,0:06:07.757
אוקיי, אז אם נחזור רגע להתחלה, יש לנו מספר שהוא 48,

0:06:07.757,0:06:12.009
שהוא גם ״שווה או קטן״ ל-48, ולכן האליפסה השמאלית העליונה מצויירת.

0:06:12.009,0:06:16.514
הוא גם ״גדול או שווה״ ל-48, הוא גם שווה ל-48

0:06:16.514,0:06:20.975
אבל הוא לא ״לא שווה״ ל-48, ולכן חסרה לנו האליפסה הימנית התחתונה.

0:06:20.975,0:06:26.363
ואם נשחק עם המספר קצת, נוכל את השינויים באליפסות שמצויירות.

0:06:26.363,0:06:29.705
ועכשיו אתם מכירים בוליאנים!

0:06:29.705,0:06:33.340
ובדיוק כמו ביטויים מתמטיים, ביטויים בוליאנים יכולים להיות מאוד מסובכים.

0:06:33.340,0:06:37.000
אבל נדבר על זה כבר בפעם אחרת. בהצלחה!