WEBVTT

00:00:01.187 --> 00:00:03.173
חזרנו עם התוכנית שלנו שיוצרת ווינסטונים

00:00:03.173 --> 00:00:07.589
אבל הוספתי טיפוס אובייקט חדש
שנקרא Hopper (הופר).

00:00:07.589 --> 00:00:11.924
אני מגדירה את הופר באותו אופן
שהגדרתי את ווינסטון

00:00:11.924 --> 00:00:15.843
התחלתי עם פונקציית בנאי, נתתי לו את אותם
המאפיינים ואת המתודה draw

00:00:15.843 --> 00:00:20.498
והמתודה talk, ואז הוספתי עוד מתודה שנקראת

00:00:20.498 --> 00:00:23.808
hooray (הידד), כי הופר אוהב לחגוג,
לעומת ווינסטון שלא אוהב את זה כלל.

00:00:23.808 --> 00:00:27.924
בתחתית הפונקציה יצרתי שני אובייקטי הופר חדשים

00:00:27.924 --> 00:00:31.174
שקראתי להם lilHopper ו- bigHopper

00:00:31.174 --> 00:00:35.347
וציירתי אותם, וקראתי למתודה talk על אחד,
ולמתודה hooray על האחר

00:00:35.347 --> 00:00:37.508
זה די מגניב

00:00:37.508 --> 00:00:39.928
אם נסתכל על הקוד הזה כאן למעלה

00:00:39.928 --> 00:00:41.823
אולי תשימו לב לדבר מעניין.

00:00:41.973 --> 00:00:52.324
הקוד עבור Hopper הוא מאוד דומה לקוד
עבור Winston. בייחוד הסתכלו על הבנאי.
זהו אותו קוד כמו הבנאי של ווינסטון.

00:00:52.324 --> 00:01:00.748
וגם הפונקציה talk היא בדיוק אותו קוד כמו
הפונקציה talk של ווינסטון.

00:01:00.763 --> 00:01:03.897
ולשניהם יש פונקציית draw זהה

00:01:03.897 --> 00:01:07.922
כך שיש הרבה דברים משותפים
לשני טיפוסי האובייקטים האלו

00:01:07.922 --> 00:01:11.341
וזה הגיוני, כי אתם מבינים ש-Hopper
ו-Winston הם שני טיפוסי אובייקטים

00:01:11.341 --> 00:01:15.299
דומים בעולם שלנו. אם תחשבו על העולם האמיתי

00:01:15.299 --> 00:01:20.009
מחוץ למחשב, רוב טיפוסי האובייקטים חולקים

00:01:20.009 --> 00:01:21.423
מאפיינים דומים עם טיפוסי אובייקטים אחרים.

00:01:21.423 --> 00:01:23.643
כמו למשל בממלכת החי. כל החיות

00:01:23.643 --> 00:01:26.812
דומות אחת לשניה בדרכים מסוימות.
ויש לנו סוגים שונים של חיות

00:01:26.812 --> 00:01:31.588
כמו למשל בני אדם.
ולבני אדם יש דברים משותפים עם שאר עולם החי

00:01:31.588 --> 00:01:34.331
אבל יש להם גם דברים שמשותפים
רק עם בני אדם אחרים.

00:01:34.331 --> 00:01:35.820
אז נוכל לומר

00:01:36.205 --> 00:01:38.967
שחיה היא טיפוס של אובייקט שהטיפוס
של בן אדם יורש ממנו פונקציונליות.

00:01:38.967 --> 00:01:46.864
אנחנו לא מתחילים מאפס, אנו מוסיפים על
הפונקציונליות שירשנו מהיותנו בעלי חיים.

00:01:46.864 --> 00:01:49.196
למשל, כל בעלי החיים משמיעים קולות

00:01:49.196 --> 00:01:51.407
אבל בני אדם משתמשים בשפה.

00:01:51.407 --> 00:01:54.673
הרעיון הזה של ירושה

00:01:54.673 --> 00:01:56.695
הוא מאוד שימושי גם בתכנות.

00:01:56.695 --> 00:01:59.865
אנו יוצרים שרשרת של ירושת אובייקטים
בקוד ה-Javascript שלנו.

00:01:59.865 --> 00:02:02.529
כדי לעשות זאת תחשבו על

00:02:02.529 --> 00:02:04.425
מה משותף לטיפוסי האובייקטים שלנו

00:02:04.425 --> 00:02:06.633
נמציא לדבר המשותף שם

00:02:06.633 --> 00:02:08.675
כי אנחנו הולכים ליצור טיפוס אובייקט חדש

00:02:08.675 --> 00:02:10.576
שמייצג את אובייקט הבסיס.

00:02:10.576 --> 00:02:12.094
הבה נקרא להם יצורים (creatures).

00:02:12.094 --> 00:02:13.873
הם שניהם יצורים.

00:02:13.873 --> 00:02:17.831
אז נאמר var Creature שווה..
ואז נרצה לשים את פונקציית הבנאי שלנו

00:02:17.831 --> 00:02:22.342
אז בואו פשוט נגנוב את זאת של Hopper
כי היא זהה גם לזו של Winston.

00:02:22.342 --> 00:02:23.762
אוקיי.

00:02:23.762 --> 00:02:27.172
ואז, בואו נראה..

00:02:27.172 --> 00:02:28.135
עכשיו אנחנו רוצים..

00:02:28.135 --> 00:02:29.506
מה נרצה לעשות עכשיו?

00:02:29.506 --> 00:02:31.966
אולי אנחנו רוצים להוסיף את הפונקציה
של דיבור (talk)

00:02:31.966 --> 00:02:39.303
אז גם עבור מתודת talk נגנוב את של Hopper.
אבל כמובן נרצה שהיא תהיה חלק מהאב טיפוס
של היצור (creature) במקום.

00:02:39.303 --> 00:02:41.683
אוקיי, יפה.

00:02:41.683 --> 00:02:45.300
אז עכשיו יש לנו את טיפוס האובייקט של יצור.

00:02:45.300 --> 00:02:47.810
אבל אנחנו צריכים לספר ל-Hopper שהוא צריך

00:02:47.810 --> 00:02:51.141
לבסס את הפונקציונליות שלו על זו של Creature

00:02:51.248 --> 00:02:51.249
נעשה זאת על ידי כך שנרשום את השורה הבאה

00:02:53.816 --> 00:02:58.595
נרשום Hopper.prototype

00:02:58.595 --> 00:03:01.967
שווה ל-Object.create

00:03:01.967 --> 00:03:04.977
Creature.prototype

00:03:04.977 --> 00:03:14.197
מה שהשורה הזו עושה הוא לספר ל-Javascript
שצריך לבסס את אב הטיפוס של Hopper,
כלומר את כל הפונקציונליות של Hopper,
על אב הטיפוס של Creature.

00:03:14.197 --> 00:03:22.342
זה אומר שבכל פעם שהשפה תחפש פונקציה של
הופר, היא מחפשת קודם באב טיפוס של הופר,

00:03:22.342 --> 00:03:26.429
אבל אחר כך, אם היא לא תמצא את הפונקציה
היא תחפש אותה באב טיפוס של Creature.

00:03:26.429 --> 00:03:29.196
הרעיון הזה נקרא שרשרת אבות טיפוס
(prototype chain)

00:03:29.196 --> 00:03:34.032
עכשיו, ברגע שעשינו זאת, אנחנו יכולים למחוק

00:03:34.032 --> 00:03:35.634
את המתודה talk מ-Hopper

00:03:35.634 --> 00:03:38.302
כי היא כבר קיימת אצל Creature

00:03:38.302 --> 00:03:40.231
שנמצא גבוה יותר בשרשרת אבות הטיפוס.

00:03:40.231 --> 00:03:42.541
מוכנים?

00:03:42.541 --> 00:03:43.924
זה עבד!

00:03:43.924 --> 00:03:46.804
זה עובד, כי מצאנו את הפונקציה באב הטיפוס
של Creature במקום.

00:03:46.804 --> 00:03:51.234
ננסה למחוק את הפונקציה הזו גם אצל ווינסטון.

00:03:51.234 --> 00:03:57.680
אוקיי, זה לא עבד - אין לאובייקט מתודת talk.

00:03:57.680 --> 00:04:01.263
מדוע? ובכן, יש לנו את הבנאי של ווינסטון

00:04:01.263 --> 00:04:03.517
ואת המתודה draw, ומחקנו את talk.

00:04:03.517 --> 00:04:07.924
שימו לב ששכחנו לספר גם לאב הטיפוס של ווינסטון

00:04:07.924 --> 00:04:09.409
שעליו להתבסס על אב הטיפוס של יצור.

00:04:09.409 --> 00:04:10.711
אז אנחנו צריכים את השורה החשובה הזו.

00:04:10.711 --> 00:04:13.043
Winston.prototype שווה
ל- Object.create

00:04:13.043 --> 00:04:15.194
ואז בסוגריים Creature.prototype

00:04:15.194 --> 00:04:19.290
יפה!

00:04:19.290 --> 00:04:20.426
שימו לב למשהו חשוב

00:04:20.426 --> 00:04:26.097
שמתי את השורה הזו אחרי פונקציית הבנאי,
אבל לפני שאני מוסיפה כל דבר אחר

00:04:26.097 --> 00:04:28.638
לאב הטיפוס של ווינסטון.
זה מה שבדרך כלל תרצו לעשות.

00:04:28.638 --> 00:04:29.334
אתם רוצים

00:04:29.334 --> 00:04:31.230
לספר לאובייקט מיד בהתחלה

00:04:31.230 --> 00:04:33.860
שזהו אב הטיפוס הראשוני שעליו האב טיפוס
הנוכחי יהיה מבוסס

00:04:33.860 --> 00:04:36.804
אבל אחר כך אנו מוסיפים עוד דברים לאב-טיפוס הזה

00:04:36.804 --> 00:04:41.673
כי יכול להיות משהו שהוא ייחודי
ל-Winston או ייחודי ל-Hopper

00:04:41.673 --> 00:04:43.909
שאין לאובייקטי Creature.

00:04:43.909 --> 00:04:45.405
זה ממש מגניב שאתם יכולים להגדיר כאלו דברים.

00:04:45.405 --> 00:04:50.256
אוקיי. אם תסתכלו על זה,
עדיין יש לנו קצת קוד שחוזר על עצמו

00:04:50.256 --> 00:04:51.524
הקוד של הבנאי.

00:04:51.524 --> 00:04:53.366
נכון? יש לנו אותו שלוש פעמים.

00:04:53.366 --> 00:04:56.638
האם אנחנו יכולים פשוט למחוק אותו?

00:04:56.638 --> 00:04:57.840
בואו ננסה.

00:04:57.840 --> 00:05:03.509
אוקיי.. לא נראה שזה עבד

00:05:03.509 --> 00:05:07.340
כי Hopper הופיע בפינה השמאלית העליונה,
כאילו הוא שכח את כל המאפיינים שלו

00:05:07.340 --> 00:05:15.264
זה כיוון ששפת Javascript לא מניחה שאתם
רוצים את אותו בנאי, גם אם אתם רוצים לבסס
את האב-טיפוס עליו

00:05:15.264 --> 00:05:19.359
כך שניתן להגדיר בנאי משלנו לאובייקטים האלו.

00:05:19.359 --> 00:05:23.978
אבל יש גם דרך קלה לקרוא לבנאי של אובייקט אחר

00:05:23.978 --> 00:05:28.926
נעשה זאת כך:

00:05:28.926 --> 00:05:35.470
(Creature.call(this, nickname, age, x, y

00:05:35.470 --> 00:05:40.598
ראיתם, זה עבד. מה שזה עושה

00:05:40.598 --> 00:05:43.679
זה לקרוא לבנאי של Creature.

00:05:43.679 --> 00:05:50.339
זה קורא לפונקציה הזו, וזה אומר לקוד לקרוא לבנאי

00:05:50.339 --> 00:05:53.764
כאילו הוא נקרא ישירות בתוך אובייקט Hopper

00:05:53.764 --> 00:05:56.968
וכאילו הוא נקרא עם הפרמטרים האלו

00:05:56.968 --> 00:05:59.427
אלו הם הפרמטרים שאיתם קראו ל-Hopper.

00:05:59.427 --> 00:06:03.589
וזה פשוט יבצע את הקוד הזה כאילו הוא היה כאן
בתוך הבנאי של האובייקט.

00:06:03.589 --> 00:06:05.397
זה בדיוק מה שאנחנו רוצים, וזה עבד.

00:06:05.397 --> 00:06:09.709
אנחנו יכולים

00:06:09.709 --> 00:06:11.515
להעתיק את השורה הזאת גם לתוך

00:06:11.515 --> 00:06:13.757
הבנאי של Winston.

00:06:13.757 --> 00:06:16.531
וזה עובד. יופי!

00:06:16.531 --> 00:06:24.901
אוקיי. תראו את זה. איחדנו את כל המאפיינים
המשותפים והפונקציונליות המשותפת לתוך
אובייקט בסיס יחיד, Creature

00:06:24.901 --> 00:06:28.207
ויצרנו שני טיפוסי אובייקטים שמרחיבים
את אובייקט הבסיס.

00:06:28.207 --> 00:06:30.981
הם יורשים פונקציונליות,
אבל הם גם מוסיפים דברים משלהם.

00:06:30.981 --> 00:06:36.339
ומה שנחמד זה שאנחנו יכולים לשנות את
הפונקציונליות המשותפת במקום אחד.

00:06:36.339 --> 00:06:40.302
למשל אם נרצה לשנות את הגיל כמו קודם,
נוכל לרשום '+' "yrs old"

00:06:40.302 --> 00:06:43.908
עכשיו לכולם רשום "yrs old" אחרי הגיל שלהם.

00:06:43.908 --> 00:06:49.871
או שאנחנו יכולים לשנות את המתודה talk, שיהיה כתוב "SUP"

00:06:49.871 --> 00:06:57.174
ועכשיו כל ה-Winstonים וה-Hopperים
אומרים "SUP".
עכשיו כשראיתם איך ליצור
טיפוסי אובייקטים ואיך לרשת מטיפוסי אובייקטים

00:06:57.174 --> 00:07:01.348
אתם יכולים להתחיל לחשוב על איך זה יכול להיות
שימושי בציורים, באנימציות, בסימולציות ובמשחקים.

00:07:01.348 --> 00:07:05.257
לדוגמה, אולי יש לכם משחק ויש בו הרבה סוגי דמויות

00:07:05.257 --> 00:07:07.683
וכולן יכולות לרוץ אבל רק חלקן יכולות לקפוץ

00:07:07.683 --> 00:07:11.970
זהו מקום מושלם בשביל כמה טיפוסי אובייקטים
ושימוש בירושה.

00:07:11.970 --> 00:07:15.970
אבל אני בטוחה שאתם יכולים לחשוב
על עוד הרבה שימושים אחרים.