1
00:00:01,187 --> 00:00:03,173
חזרנו עם התוכנית שלנו שיוצרת ווינסטונים

2
00:00:03,173 --> 00:00:07,589
אבל הוספתי טיפוס אובייקט חדש
שנקרא Hopper (הופר).

3
00:00:07,589 --> 00:00:11,924
אני מגדירה את הופר באותו אופן
שהגדרתי את ווינסטון

4
00:00:11,924 --> 00:00:15,843
התחלתי עם פונקציית בנאי, נתתי לו את אותם
המאפיינים ואת המתודה draw

5
00:00:15,843 --> 00:00:20,498
והמתודה talk, ואז הוספתי עוד מתודה שנקראת

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

7
00:00:23,808 --> 00:00:27,924
בתחתית הפונקציה יצרתי שני אובייקטי הופר חדשים

8
00:00:27,924 --> 00:00:31,174
שקראתי להם lilHopper ו- bigHopper

9
00:00:31,174 --> 00:00:35,347
וציירתי אותם, וקראתי למתודה talk על אחד,
ולמתודה hooray על האחר

10
00:00:35,347 --> 00:00:37,508
זה די מגניב

11
00:00:37,508 --> 00:00:39,928
אם נסתכל על הקוד הזה כאן למעלה

12
00:00:39,928 --> 00:00:41,823
אולי תשימו לב לדבר מעניין.

13
00:00:41,973 --> 00:00:52,324
הקוד עבור Hopper הוא מאוד דומה לקוד
עבור Winston. בייחוד הסתכלו על הבנאי.
זהו אותו קוד כמו הבנאי של ווינסטון.

14
00:00:52,324 --> 00:01:00,748
וגם הפונקציה talk היא בדיוק אותו קוד כמו
הפונקציה talk של ווינסטון.

15
00:01:00,763 --> 00:01:03,897
ולשניהם יש פונקציית draw זהה

16
00:01:03,897 --> 00:01:07,922
כך שיש הרבה דברים משותפים
לשני טיפוסי האובייקטים האלו

17
00:01:07,922 --> 00:01:11,341
וזה הגיוני, כי אתם מבינים ש-Hopper
ו-Winston הם שני טיפוסי אובייקטים

18
00:01:11,341 --> 00:01:15,299
דומים בעולם שלנו. אם תחשבו על העולם האמיתי

19
00:01:15,299 --> 00:01:20,009
מחוץ למחשב, רוב טיפוסי האובייקטים חולקים

20
00:01:20,009 --> 00:01:21,423
מאפיינים דומים עם טיפוסי אובייקטים אחרים.

21
00:01:21,423 --> 00:01:23,643
כמו למשל בממלכת החי. כל החיות

22
00:01:23,643 --> 00:01:26,812
דומות אחת לשניה בדרכים מסוימות.
ויש לנו סוגים שונים של חיות

23
00:01:26,812 --> 00:01:31,588
כמו למשל בני אדם.
ולבני אדם יש דברים משותפים עם שאר עולם החי

24
00:01:31,588 --> 00:01:34,331
אבל יש להם גם דברים שמשותפים
רק עם בני אדם אחרים.

25
00:01:34,331 --> 00:01:35,820
אז נוכל לומר

26
00:01:36,205 --> 00:01:38,967
שחיה היא טיפוס של אובייקט שהטיפוס
של בן אדם יורש ממנו פונקציונליות.

27
00:01:38,967 --> 00:01:46,864
אנחנו לא מתחילים מאפס, אנו מוסיפים על
הפונקציונליות שירשנו מהיותנו בעלי חיים.

28
00:01:46,864 --> 00:01:49,196
למשל, כל בעלי החיים משמיעים קולות

29
00:01:49,196 --> 00:01:51,407
אבל בני אדם משתמשים בשפה.

30
00:01:51,407 --> 00:01:54,673
הרעיון הזה של ירושה

31
00:01:54,673 --> 00:01:56,695
הוא מאוד שימושי גם בתכנות.

32
00:01:56,695 --> 00:01:59,865
אנו יוצרים שרשרת של ירושת אובייקטים
בקוד ה-Javascript שלנו.

33
00:01:59,865 --> 00:02:02,529
כדי לעשות זאת תחשבו על

34
00:02:02,529 --> 00:02:04,425
מה משותף לטיפוסי האובייקטים שלנו

35
00:02:04,425 --> 00:02:06,633
נמציא לדבר המשותף שם

36
00:02:06,633 --> 00:02:08,675
כי אנחנו הולכים ליצור טיפוס אובייקט חדש

37
00:02:08,675 --> 00:02:10,576
שמייצג את אובייקט הבסיס.

38
00:02:10,576 --> 00:02:12,094
הבה נקרא להם יצורים (creatures).

39
00:02:12,094 --> 00:02:13,873
הם שניהם יצורים.

40
00:02:13,873 --> 00:02:17,831
אז נאמר var Creature שווה..
ואז נרצה לשים את פונקציית הבנאי שלנו

41
00:02:17,831 --> 00:02:22,342
אז בואו פשוט נגנוב את זאת של Hopper
כי היא זהה גם לזו של Winston.

42
00:02:22,342 --> 00:02:23,762
אוקיי.

43
00:02:23,762 --> 00:02:27,172
ואז, בואו נראה..

44
00:02:27,172 --> 00:02:28,135
עכשיו אנחנו רוצים..

45
00:02:28,135 --> 00:02:29,506
מה נרצה לעשות עכשיו?

46
00:02:29,506 --> 00:02:31,966
אולי אנחנו רוצים להוסיף את הפונקציה
של דיבור (talk)

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

48
00:02:39,303 --> 00:02:41,683
אוקיי, יפה.

49
00:02:41,683 --> 00:02:45,300
אז עכשיו יש לנו את טיפוס האובייקט של יצור.

50
00:02:45,300 --> 00:02:47,810
אבל אנחנו צריכים לספר ל-Hopper שהוא צריך

51
00:02:47,810 --> 00:02:51,141
לבסס את הפונקציונליות שלו על זו של Creature

52
00:02:51,248 --> 00:02:51,249
נעשה זאת על ידי כך שנרשום את השורה הבאה

53
00:02:53,816 --> 00:02:58,595
נרשום Hopper.prototype

54
00:02:58,595 --> 00:03:01,967
שווה ל-Object.create

55
00:03:01,967 --> 00:03:04,977
Creature.prototype

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

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

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

59
00:03:26,429 --> 00:03:29,196
הרעיון הזה נקרא שרשרת אבות טיפוס
(prototype chain)

60
00:03:29,196 --> 00:03:34,032
עכשיו, ברגע שעשינו זאת, אנחנו יכולים למחוק

61
00:03:34,032 --> 00:03:35,634
את המתודה talk מ-Hopper

62
00:03:35,634 --> 00:03:38,302
כי היא כבר קיימת אצל Creature

63
00:03:38,302 --> 00:03:40,231
שנמצא גבוה יותר בשרשרת אבות הטיפוס.

64
00:03:40,231 --> 00:03:42,541
מוכנים?

65
00:03:42,541 --> 00:03:43,924
זה עבד!

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

67
00:03:46,804 --> 00:03:51,234
ננסה למחוק את הפונקציה הזו גם אצל ווינסטון.

68
00:03:51,234 --> 00:03:57,680
אוקיי, זה לא עבד - אין לאובייקט מתודת talk.

69
00:03:57,680 --> 00:04:01,263
מדוע? ובכן, יש לנו את הבנאי של ווינסטון

70
00:04:01,263 --> 00:04:03,517
ואת המתודה draw, ומחקנו את talk.

71
00:04:03,517 --> 00:04:07,924
שימו לב ששכחנו לספר גם לאב הטיפוס של ווינסטון

72
00:04:07,924 --> 00:04:09,409
שעליו להתבסס על אב הטיפוס של יצור.

73
00:04:09,409 --> 00:04:10,711
אז אנחנו צריכים את השורה החשובה הזו.

74
00:04:10,711 --> 00:04:13,043
Winston.prototype שווה
ל- Object.create

75
00:04:13,043 --> 00:04:15,194
ואז בסוגריים Creature.prototype

76
00:04:15,194 --> 00:04:19,290
יפה!

77
00:04:19,290 --> 00:04:20,426
שימו לב למשהו חשוב

78
00:04:20,426 --> 00:04:26,097
שמתי את השורה הזו אחרי פונקציית הבנאי,
אבל לפני שאני מוסיפה כל דבר אחר

79
00:04:26,097 --> 00:04:28,638
לאב הטיפוס של ווינסטון.
זה מה שבדרך כלל תרצו לעשות.

80
00:04:28,638 --> 00:04:29,334
אתם רוצים

81
00:04:29,334 --> 00:04:31,230
לספר לאובייקט מיד בהתחלה

82
00:04:31,230 --> 00:04:33,860
שזהו אב הטיפוס הראשוני שעליו האב טיפוס
הנוכחי יהיה מבוסס

83
00:04:33,860 --> 00:04:36,804
אבל אחר כך אנו מוסיפים עוד דברים לאב-טיפוס הזה

84
00:04:36,804 --> 00:04:41,673
כי יכול להיות משהו שהוא ייחודי
ל-Winston או ייחודי ל-Hopper

85
00:04:41,673 --> 00:04:43,909
שאין לאובייקטי Creature.

86
00:04:43,909 --> 00:04:45,405
זה ממש מגניב שאתם יכולים להגדיר כאלו דברים.

87
00:04:45,405 --> 00:04:50,256
אוקיי. אם תסתכלו על זה,
עדיין יש לנו קצת קוד שחוזר על עצמו

88
00:04:50,256 --> 00:04:51,524
הקוד של הבנאי.

89
00:04:51,524 --> 00:04:53,366
נכון? יש לנו אותו שלוש פעמים.

90
00:04:53,366 --> 00:04:56,638
האם אנחנו יכולים פשוט למחוק אותו?

91
00:04:56,638 --> 00:04:57,840
בואו ננסה.

92
00:04:57,840 --> 00:05:03,509
אוקיי.. לא נראה שזה עבד

93
00:05:03,509 --> 00:05:07,340
כי Hopper הופיע בפינה השמאלית העליונה,
כאילו הוא שכח את כל המאפיינים שלו

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

95
00:05:15,264 --> 00:05:19,359
כך שניתן להגדיר בנאי משלנו לאובייקטים האלו.

96
00:05:19,359 --> 00:05:23,978
אבל יש גם דרך קלה לקרוא לבנאי של אובייקט אחר

97
00:05:23,978 --> 00:05:28,926
נעשה זאת כך:

98
00:05:28,926 --> 00:05:35,470
(Creature.call(this, nickname, age, x, y

99
00:05:35,470 --> 00:05:40,598
ראיתם, זה עבד. מה שזה עושה

100
00:05:40,598 --> 00:05:43,679
זה לקרוא לבנאי של Creature.

101
00:05:43,679 --> 00:05:50,339
זה קורא לפונקציה הזו, וזה אומר לקוד לקרוא לבנאי

102
00:05:50,339 --> 00:05:53,764
כאילו הוא נקרא ישירות בתוך אובייקט Hopper

103
00:05:53,764 --> 00:05:56,968
וכאילו הוא נקרא עם הפרמטרים האלו

104
00:05:56,968 --> 00:05:59,427
אלו הם הפרמטרים שאיתם קראו ל-Hopper.

105
00:05:59,427 --> 00:06:03,589
וזה פשוט יבצע את הקוד הזה כאילו הוא היה כאן
בתוך הבנאי של האובייקט.

106
00:06:03,589 --> 00:06:05,397
זה בדיוק מה שאנחנו רוצים, וזה עבד.

107
00:06:05,397 --> 00:06:09,709
אנחנו יכולים

108
00:06:09,709 --> 00:06:11,515
להעתיק את השורה הזאת גם לתוך

109
00:06:11,515 --> 00:06:13,757
הבנאי של Winston.

110
00:06:13,757 --> 00:06:16,531
וזה עובד. יופי!

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

112
00:06:24,901 --> 00:06:28,207
ויצרנו שני טיפוסי אובייקטים שמרחיבים
את אובייקט הבסיס.

113
00:06:28,207 --> 00:06:30,981
הם יורשים פונקציונליות,
אבל הם גם מוסיפים דברים משלהם.

114
00:06:30,981 --> 00:06:36,339
ומה שנחמד זה שאנחנו יכולים לשנות את
הפונקציונליות המשותפת במקום אחד.

115
00:06:36,339 --> 00:06:40,302
למשל אם נרצה לשנות את הגיל כמו קודם,
נוכל לרשום '+' "yrs old"

116
00:06:40,302 --> 00:06:43,908
עכשיו לכולם רשום "yrs old" אחרי הגיל שלהם.

117
00:06:43,908 --> 00:06:49,871
או שאנחנו יכולים לשנות את המתודה talk, שיהיה כתוב "SUP"

118
00:06:49,871 --> 00:06:57,174
ועכשיו כל ה-Winstonים וה-Hopperים
אומרים "SUP".
עכשיו כשראיתם איך ליצור
טיפוסי אובייקטים ואיך לרשת מטיפוסי אובייקטים

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

120
00:07:01,348 --> 00:07:05,257
לדוגמה, אולי יש לכם משחק ויש בו הרבה סוגי דמויות

121
00:07:05,257 --> 00:07:07,683
וכולן יכולות לרוץ אבל רק חלקן יכולות לקפוץ

122
00:07:07,683 --> 00:07:11,970
זהו מקום מושלם בשביל כמה טיפוסי אובייקטים
ושימוש בירושה.

123
00:07:11,970 --> 00:07:15,970
אבל אני בטוחה שאתם יכולים לחשוב
על עוד הרבה שימושים אחרים.