1
00:00:00,000 --> 00:00:03,332
>> [השמעת מוסיקה]

2
00:00:03,332 --> 00:00:06,200

3
00:00:06,200 --> 00:00:09,590
>> דן AMRMENDARIZ: כולם,
ברוכים הבאים לסמינר CS50,

4
00:00:09,590 --> 00:00:11,690
iOS App פיתוח עם סוויפט.

5
00:00:11,690 --> 00:00:15,690
אני דן Armendariz, ואני מוֹרֶה
של מדעי מחשב, כאן בהרווארד.

6
00:00:15,690 --> 00:00:21,510
>> והשעה הקרובה הולכת להיות
סיור מערבולת של כמה שיותר דברים

7
00:00:21,510 --> 00:00:25,160
על נושא זה כפי שאנו יכולים להתאים.

8
00:00:25,160 --> 00:00:29,170
אני אפרסם את כל קוד המקור
שאתה רואה היום באינטרנט.

9
00:00:29,170 --> 00:00:31,990
אנחנו אולי לא נוכל
בעצם ללכת על הכל

10
00:00:31,990 --> 00:00:34,810
שאני שאני
מראה לך בשעה זו.

11
00:00:34,810 --> 00:00:37,580
אבל לפחות אני מקווה שדרך
ההערות של קוד המקור,

12
00:00:37,580 --> 00:00:40,830
תוכל לנסות להבין מה
בדיוק קורה לדברים האלה

13
00:00:40,830 --> 00:00:42,950
כי אנחנו לא די להגיע ל.

14
00:00:42,950 --> 00:00:46,970
>> בסך הכל, את המבנה של
השיחה של היום תהיה כדלקמן.

15
00:00:46,970 --> 00:00:52,820
נתחיל את עושה קצת בסיסי
תחביר בשפת סוויפט,

16
00:00:52,820 --> 00:00:56,290
הולך לחלק ממתקדם יותר
תחביר של שפת סוויפט.

17
00:00:56,290 --> 00:00:59,560
בגלל השפה
הוא באמת מודרני ו

18
00:00:59,560 --> 00:01:02,110
יש הרבה ברמה הגבוהה
תכונות, דברים שיש לנו לא

19
00:01:02,110 --> 00:01:06,600
ראה בC ברחבי CS50, או
אפילו כמה שפות האחרות

20
00:01:06,600 --> 00:01:09,310
שאנחנו כבר התחלנו
באמצעות בCS50 כמו PHP,

21
00:01:09,310 --> 00:01:12,670
אז אני הולך לצריך לנסות
להציג גם כמה נושאים ש

22
00:01:12,670 --> 00:01:18,580
קשורים לשפות ברמה גבוהות יותר
שייתכן שלא תראו בעומק בCS50,

23
00:01:18,580 --> 00:01:21,380
אבל אתה תראה בהמשך
כיתות מדעי מחשב.

24
00:01:21,380 --> 00:01:25,290
אז זה הולך להיות
צפוף שעה.

25
00:01:25,290 --> 00:01:28,897
ואל תהסס לתת לי
יודע אם יש לך שאלות.

26
00:01:28,897 --> 00:01:30,730
אז אם אתה מעוניין
בעושה פיתוח

27
00:01:30,730 --> 00:01:34,442
עם סוויפט, או באמת
כל פיתוח אפליקציה iOS,

28
00:01:34,442 --> 00:01:35,900
יש כמה דרישות.

29
00:01:35,900 --> 00:01:39,940
קודם כל, אתה צריך להיות באמצעות
מק, פועל בדוגמאות

30
00:01:39,940 --> 00:01:43,880
שאנחנו הולכים להיות באמצעות היום,
גרסה חדשה יחסית של מערכת הפעלה

31
00:01:43,880 --> 00:01:46,580
X. במקרה זה, אני רץ X 10.5.

32
00:01:46,580 --> 00:01:48,600
אתה יכול להיות ריצת 10.11 אם אתה רוצה.

33
00:01:48,600 --> 00:01:52,430
אבל כל מה שאתה הולך
רואה הוא מעורב 7 Xcode ומאוחר יותר,

34
00:01:52,430 --> 00:01:56,271
שבו יש את הגרסה האחרונה
של סוויפט, שהוא 2.0 סוויפט.

35
00:01:56,271 --> 00:01:58,270
זהו למעשה די
הבחנה חשובה.

36
00:01:58,270 --> 00:02:01,510
הרבה התחביר יש
השתנה באופן משמעותי למדי

37
00:02:01,510 --> 00:02:05,890
בחלק ממקרים מסוויפט 1.0,
ששוחרר בשנה שעברה,

38
00:02:05,890 --> 00:02:08,514
2.0 סוויפט, ש
רק יצאתי בסתיו קרוב.

39
00:02:08,514 --> 00:02:09,889
אז אנחנו הולכים להראות סוויפט 2.0.

40
00:02:09,889 --> 00:02:13,020
הרבה מהדברים ש
אתה מחפש באינטרנט

41
00:02:13,020 --> 00:02:18,040
כאשר אתה מנסה להשיג נוסף
מידע על מגוון רחב של דברים,

42
00:02:18,040 --> 00:02:20,710
ייתכן שתרצה באופן מפורש
לחפש את סוויפט 2

43
00:02:20,710 --> 00:02:24,950
ולא סוויפט פשוט ישן לעשות
בטוח שאתה מקבל נכון התחביר.

44
00:02:24,950 --> 00:02:26,920
>> למעשה, זה בדרך כלל נכון.

45
00:02:26,920 --> 00:02:31,210
יש כמות מהירה של פיתוח
קורה בשפת סוויפט

46
00:02:31,210 --> 00:02:35,110
מאז אפל פרסמה את זה, אני חושב ש
מה, זה היה קצת יותר משנה

47
00:02:35,110 --> 00:02:36,370
עַכשָׁיו.

48
00:02:36,370 --> 00:02:39,080
ודברים השתנו
באופן דרמטי בזמן הזה.

49
00:02:39,080 --> 00:02:42,160
וכך לא להיות מתוסכל
אם, כאשר אתה מסתכל מסביב

50
00:02:42,160 --> 00:02:48,310
לנושאים על סוויפט או איך להשיג
משהו באמצעות כמה דוגמא קוד

51
00:02:48,310 --> 00:02:51,210
או משהו שזה לא
ממש לעבוד על סוויפט 2.0.

52
00:02:51,210 --> 00:02:53,790
ודא שאתה מחפש
במיוחד עבור גרסה ש

53
00:02:53,790 --> 00:02:58,690
כדי לנסות למזער את ההשפעות של שונה
גרסאות ואלה מיני דברים.

54
00:02:58,690 --> 00:03:02,470
>> אני אנסה להצביע רק כמה דברים
כי הם שונים לגרסאות ישנות יותר.

55
00:03:02,470 --> 00:03:03,970
אבל זה משהו שצריך להיזהר.

56
00:03:03,970 --> 00:03:06,770
זה כנראה הולך להיות
אחד מכאבי הראש הגדולים ביותר

57
00:03:06,770 --> 00:03:11,010
שיהיה לך עם סוויפט הוא מציאת
דוגמא קוד שהוא מבוגר, אפילו רק

58
00:03:11,010 --> 00:03:14,050
בכמה חודשים, מנסה להשתמש
זה בפרויקט המודרני יותר שלך.

59
00:03:14,050 --> 00:03:15,430
וזה פשוט לא עובד.

60
00:03:15,430 --> 00:03:18,530
אתה מקבל שגיאות מהדר, תחביר
טעויות, כל מיני דברים מטורפים.

61
00:03:18,530 --> 00:03:21,580
כל כך פשוט להיות סבלני עם
זה, ואתה יהיה בתקווה

62
00:03:21,580 --> 00:03:24,200
יש ניסיון די נחמד
עם כולל סוויפט.

63
00:03:24,200 --> 00:03:28,430
>> עכשיו אתה באמת יכול join-- ואני מקווה ש
עדיין יש לנו בעצם year-- זה זה

64
00:03:28,430 --> 00:03:30,910
האפליקציה של אפל CS 50
צוות פיתוח, ש

65
00:03:30,910 --> 00:03:34,680
יאפשר לך להתקין את כל יישומים
שאתה יוצר במכשירי iOS שלך.

66
00:03:34,680 --> 00:03:39,190
אז תסתכל על כתובת אתר זו אם
אתה מעוניין בכך.

67
00:03:39,190 --> 00:03:41,450
>> אז רק כמה
דברים על סוויפט עצמו.

68
00:03:41,450 --> 00:03:43,580
זוהי שפה שנאספה.

69
00:03:43,580 --> 00:03:45,870
אבל אתה תראה שחלק
של התכונות שאנו משתמשים בי

70
00:03:45,870 --> 00:03:50,650
לאפשר לו לשמש גם בקצת
כמו פירש דרך גם כן.

71
00:03:50,650 --> 00:03:56,350
>> הרבה התחביר מושאל
מג הוא מבוסס ונכתב בג

72
00:03:56,350 --> 00:04:00,400
וכך אנו רואים ש
יש הרבה של מזון מהיר

73
00:04:00,400 --> 00:04:04,450
מהידע הקיים שלך
מC שאנחנו יכולים יציאה לסוויפט.

74
00:04:04,450 --> 00:04:07,290
>> אבל יש דברים ש
לעשות את זה שונה מאוד מג

75
00:04:07,290 --> 00:04:08,860
זה מאוד מאוד הקליד.

76
00:04:08,860 --> 00:04:10,380
יש ניהול זיכרון אוטומטי.

77
00:04:10,380 --> 00:04:13,170
אתה לא תצטרך
להשתמש malloc או בכל מקום בחינם.

78
00:04:13,170 --> 00:04:15,110
זה מיועד לכלליות.

79
00:04:15,110 --> 00:04:19,480
אז במילים אחרות, אתה יכול להשתמש בו ב
כל מיני הקשרים, מבית Apple הצפייה

80
00:04:19,480 --> 00:04:26,290
ל- iPhone כל הדרך עד לOS X, ו
אפילו כמה שרתים, אפילו כמה scripting.

81
00:04:26,290 --> 00:04:28,400
אבל נראה ש
התמיכה scripting

82
00:04:28,400 --> 00:04:31,360
לא ממש שם עדיין כ
זה בשפות אחרות.

83
00:04:31,360 --> 00:04:34,930
אז ככל הנראה תהיה באמצעות
זה אך ורק לפיתוח

84
00:04:34,930 --> 00:04:37,060
ב- Mac שלך או iPhone שלך.

85
00:04:37,060 --> 00:04:40,150
>> ויש לו הרבה תכונות מודרניות.

86
00:04:40,150 --> 00:04:43,380
והרבה מהדברים האלה הם דברים ש
אנחנו הולכים לנסות לטפל היום,

87
00:04:43,380 --> 00:04:47,590
אבל גם הנושאים שלנו, כי בכנות,
אנחנו יכולים להקדיש את כל הקורסים.

88
00:04:47,590 --> 00:04:50,140
למעשה, CS 51, שהוא
הסמסטר הבא מוצע,

89
00:04:50,140 --> 00:04:53,990
מתמקד הרבה בנושאים אלה
שיתואר להלן.

90
00:04:53,990 --> 00:04:56,781
אז אתה יכול להשקיע כל סמסטר
הבנת הדברים האלה.

91
00:04:56,781 --> 00:04:58,530
אבל אנחנו הולכים לנסות
לעבור אותם

92
00:04:58,530 --> 00:05:00,800
מספיק לפחות ש
יכול להבין מה זה

93
00:05:00,800 --> 00:05:03,700
קורה כאשר אתה מסתכל
בתכנית סוויפט

94
00:05:03,700 --> 00:05:07,310
ולהיות מסוגל לפרוץ את הדרך שלך
דרכו לפרויקט הגמר.

95
00:05:07,310 --> 00:05:10,780
>> עכשיו אחת הדרכים הטובות ביותר שאתה יכול
לקבל מידע נוסף על זה

96
00:05:10,780 --> 00:05:14,700
הוא בכנות פשוט דרך אפל של
סיפק תיעוד לסוויפט.

97
00:05:14,700 --> 00:05:16,930
יש הרבה של APIs
שזמינים.

98
00:05:16,930 --> 00:05:21,170
וזה בסיס טוב לביתך
לחפש, דברים ספציפיים שאתה

99
00:05:21,170 --> 00:05:23,020
רוצה לעשות עם ה- API מעורב iOS.

100
00:05:23,020 --> 00:05:26,350
אם אתה רוצה להשתמש במצלמה ל
למשל, אתה יכול להתחיל לחפש כאן,

101
00:05:26,350 --> 00:05:32,540
וגם להשתמש ב- Google וסטאק
גלישה באופן רגיל.

102
00:05:32,540 --> 00:05:36,670
>> כל שאלות על זה
לפני שאנחנו קופצים תקין ב?

103
00:05:36,670 --> 00:05:37,880
בסדר.

104
00:05:37,880 --> 00:05:38,700
בואו נעבור הלאה.

105
00:05:38,700 --> 00:05:42,620
>> אז קודם כל, יש לי
מספר קבצי דוגמא.

106
00:05:42,620 --> 00:05:46,040
ואני הולך לנסות לשלב
דרכם במהירות יחסית.

107
00:05:46,040 --> 00:05:49,190
זהו קובץ שלום העולם לסוויפט.

108
00:05:49,190 --> 00:05:51,050
זה פשוט מאוד.

109
00:05:51,050 --> 00:05:54,360
יש דרך נוספת הערות
מ יש קוד בפועל.

110
00:05:54,360 --> 00:05:57,100
שים לב לקוד בפועל הוא ב
מאוד תחתון בקו 14.

111
00:05:57,100 --> 00:05:57,980
זה אומר הדפסה.

112
00:05:57,980 --> 00:05:59,820
ואז זה קריאה לפונקציה.

113
00:05:59,820 --> 00:06:03,010
אנחנו עוברים אליו
מחרוזת נקראת cs50 שלום.

114
00:06:03,010 --> 00:06:04,750
שים לב שאין נקודה-פסיק.

115
00:06:04,750 --> 00:06:07,010
שים לב שאין עיקרי int.

116
00:06:07,010 --> 00:06:10,392
יש אף אחד מ
קראפט שהיה לנו עם ג

117
00:06:10,392 --> 00:06:15,020
כאשר אנו משתמשים בסוויפט בדרך זו,
שרק כתובה בקובץ טקסט

118
00:06:15,020 --> 00:06:18,340
ומאוחסן במחשב שלי, אז
אני יכול לקמפל אותו ולהפעיל אותו.

119
00:06:18,340 --> 00:06:20,920
>> שים לב שאני כאן
לא באמצעות IDE CS50.

120
00:06:20,920 --> 00:06:24,460
זאת בהנחה שאני
ריצה ושאני על OS X,

121
00:06:24,460 --> 00:06:27,870
וכי יש לי Xcode כבר מותקן
במחשב זה כדי שזה

122
00:06:27,870 --> 00:06:29,080
בעצם פונקציה.

123
00:06:29,080 --> 00:06:33,349
אבל זה רק קובץ טקסט רגיל
כי אז אנחנו יכולים ללקט ולערוך.

124
00:06:33,349 --> 00:06:34,890
אז בואו לראות איך זה באמת עובד.

125
00:06:34,890 --> 00:06:37,430
מה אם אני רוצה לקמפל את זה?

126
00:06:37,430 --> 00:06:40,450
1.swift swiftc.

127
00:06:40,450 --> 00:06:42,960
אחרי רגע או שתיים, זה
יראה שיש לנו עכשיו

128
00:06:42,960 --> 00:06:45,360
הידור זה לקובץ בשם 1.

129
00:06:45,360 --> 00:06:51,090
ועכשיו יש לנו מודפס CS50,
יישום שלום העולם שלנו ולא.

130
00:06:51,090 --> 00:06:54,690
>> שים לב דבר אחד אחר כ
גם הוא כי כברירת מחדל,

131
00:06:54,690 --> 00:07:00,090
לא היה לנו לקלט
/ n להדפיס קו חדש.

132
00:07:00,090 --> 00:07:05,315
כברירת מחדל, פונקצית ההדפסה ב
סוויפט יודפס שורה חדשה בשבילך.

133
00:07:05,315 --> 00:07:09,284
אתה יכול לעבור נוסף אופציונאלי
פרמטר לספר אותו שלא לעשות כן.

134
00:07:09,284 --> 00:07:10,950
אבל גוגל לקבלת מידע נוסף על זה.

135
00:07:10,950 --> 00:07:13,450
כברירת מחדל, זה יעשה את קו ההדפסה.

136
00:07:13,450 --> 00:07:16,420
>> בסדר, אז בואו נעבור על
אז לכמה דברים אחרים.

137
00:07:16,420 --> 00:07:18,620
אז איך אנחנו יכולים למעשה להגדיר משתנים?

138
00:07:18,620 --> 00:07:21,960
אנחנו יכולים לעשות את זה באמצעות
אחת משתי שיטות.

139
00:07:21,960 --> 00:07:26,122
ואת זה אני רוצה להגיד לך
על הגדרה ראשונה הוא לתת לזה.

140
00:07:26,122 --> 00:07:27,830
וזה חשוב
בגלל יעילות

141
00:07:27,830 --> 00:07:30,240
מה שאנחנו עושים הוא הגדרה קבועה.

142
00:07:30,240 --> 00:07:34,010
אנחנו הולכים ליצור משתנים,
או לייתר דיוק שם נקרא קבוע,

143
00:07:34,010 --> 00:07:38,200
לספק לה כמה data-- ב
מקרה זה, את המחרוזת דן.

144
00:07:38,200 --> 00:07:40,630
אבל באמצעות לתת לזה
מילת המפתח, אנחנו אומרים

145
00:07:40,630 --> 00:07:43,860
כי זה variable-- או
שוב constant-- נקרא

146
00:07:43,860 --> 00:07:46,220
שם אף פעם לא הולך להיות שונה.

147
00:07:46,220 --> 00:07:50,120
זה הולך להיות בלתי ניתן לשינוי בכל
משך תכנית זו

148
00:07:50,120 --> 00:07:53,100
או בכל
משך ההקשר

149
00:07:53,100 --> 00:07:55,390
שמשתנים כי הוא זמין.

150
00:07:55,390 --> 00:08:00,096
>> זה באמת חשוב שכאשר
יש לך כמה נתונים שאינם

151
00:08:00,096 --> 00:08:02,970
הולך לשנות בתכנית שלך,
ותראה מגוון רחב של דוגמאות

152
00:08:02,970 --> 00:08:06,790
מתי אנחנו רוצים להשתמש
תן לעומת התחביר האחר,

153
00:08:06,790 --> 00:08:11,040
זה חשוב כי אתה משתמש בוא
בכל מקום אפשרי, כי זו תודיע

154
00:08:11,040 --> 00:08:13,740
השפה שזה
לא הולך להיות שונה,

155
00:08:13,740 --> 00:08:16,590
וזה באמת יכול לבצע
הרבה אופטימיזציות

156
00:08:16,590 --> 00:08:19,560
כדי לשפר את המהירות ו
הבטיחות של התכנית שלך.

157
00:08:19,560 --> 00:08:24,480
ועל ידי בטיחות, אני מתכוון לא נותן לי
התרסקותו עם טעויות מטורפות

158
00:08:24,480 --> 00:08:27,910
שאולי
רגיל לראות בג

159
00:08:27,910 --> 00:08:32,460
>> אז אנחנו יכולים להשתמש באינטרפולציה המחרוזת
כדי לתמצת את זה במחרוזת.

160
00:08:32,460 --> 00:08:35,200
אז אנחנו יכולים לראות בזה
קו הדפסה, להדפיס שלום,

161
00:08:35,200 --> 00:08:38,950
ולאחר מכן באמצעות סימני פתח סוגר קו נטוי,
ולאחר מכן את השם שלי משתנה,

162
00:08:38,950 --> 00:08:41,809
במקרה זה קבוע,
לסגור את הסוגריים.

163
00:08:41,809 --> 00:08:46,400
אני בעצם לאחר מכן לשים
תוכן של שם משתנה בשם זה

164
00:08:46,400 --> 00:08:50,240
בתוך המחרוזת ולאחר מכן
הדפסת התוצאה שם.

165
00:08:50,240 --> 00:08:54,070
>> יש שינוי אחר אחד בקובץ זה
והוא שיש לי, בחלקו העליון,

166
00:08:54,070 --> 00:08:57,340
להכניס לקו עֵסֶק, ש
בעצם רק מציין

167
00:08:57,340 --> 00:09:00,180
כי אני רוצה להשתמש ב
מתורגמן סוויפט, ש

168
00:09:00,180 --> 00:09:04,190
משמעות הדבר היא שאני כבר לא צריך
לקמפל תכנית מסוימת זו.

169
00:09:04,190 --> 00:09:06,567
אני רק יכול להפעיל אותו כמו תסריט משלו.

170
00:09:06,567 --> 00:09:09,400
אבל זה, במקרה הזה, מאחורי
הסצנות שלוקטו ולאחר מכן

171
00:09:09,400 --> 00:09:10,030
להיות ארוך.

172
00:09:10,030 --> 00:09:13,540
זה פשוט בלתי נראה לנו.

173
00:09:13,540 --> 00:09:15,880
>> בסדר, אז בואו נמשיך הלאה.

174
00:09:15,880 --> 00:09:19,650
אז יש קצת תחבולות
שרק קרו בעבר.

175
00:09:19,650 --> 00:09:23,230
הראיתי לך אני ש
יכול להגדיר קבוע.

176
00:09:23,230 --> 00:09:25,490
ואני יכול לספק כמה נתונים לעשות את זה.

177
00:09:25,490 --> 00:09:29,240
אבל במקרה הזה, שם לב שאני לא
למעשה לציין את סוג הנתונים

178
00:09:29,240 --> 00:09:29,820
שזה.

179
00:09:29,820 --> 00:09:32,780
וזה בגלל ש
מהדר, סוויפט יכול

180
00:09:32,780 --> 00:09:36,910
להסיק את סוג הנתונים מבוסס רק
על נתונים שאני מכניס אותו.

181
00:09:36,910 --> 00:09:41,760
כי הוא יודע שעל ידי הערכה זו
משתנה ממש כאן, ממש נתונים זה

182
00:09:41,760 --> 00:09:43,370
כאן, הוא יודע שזה הוא מחרוזת.

183
00:09:43,370 --> 00:09:48,690
ולכן שם קבוע זה הוא אפוא
הולך להיות מחרוזת, כמו גם.

184
00:09:48,690 --> 00:09:52,730
>> אבל אנחנו גם יכולים להיות מפורשים
על הסוג זה

185
00:09:52,730 --> 00:09:55,790
אנחנו הולכים להשתמש ל
קבועים או משתנה

186
00:09:55,790 --> 00:10:01,590
על ידי שימוש בתחביר זה instead--
בואו מחרוזת שם מעי גס שווה

187
00:10:01,590 --> 00:10:05,530
דן, אשר במקרה זה אומר שאנחנו
הולך להגדיר שם בשם קבוע.

188
00:10:05,530 --> 00:10:07,150
זה הולך להיות מטיפוס String.

189
00:10:07,150 --> 00:10:10,550
והערך הולך להיות דן.

190
00:10:10,550 --> 00:10:12,550
עכשיו הדרך אחרת ש
אנחנו יכולים ליצור variables--

191
00:10:12,550 --> 00:10:15,549
ואלה הם משתנים משתנים, ש
משמעות הדבר היא שאנחנו, למעשה, הולכים

192
00:10:15,549 --> 00:10:19,670
כדי לשנות את תוכנם מתישהו
במשך ההקשר

193
00:10:19,670 --> 00:10:23,890
שמשתנה שdefined--
להשתמש במילת מפתח var במקום לתת.

194
00:10:23,890 --> 00:10:27,400
אבל שוב, כברירת מחדל, אלא אם כן אתה יודע
כי אתה צריך לטפל נתונים ש,

195
00:10:27,400 --> 00:10:30,510
מנסה להשתמש תן ל
שיפורי ביצועים.

196
00:10:30,510 --> 00:10:33,740
>> במקרה זה, אז אני יכול
לציין את סוג הנתונים

197
00:10:33,740 --> 00:10:37,650
שאנו מצפים להיות בתוך
משתנה זה חדש בשם תווית.

198
00:10:37,650 --> 00:10:38,800
זה הולך להיות מחרוזת.

199
00:10:38,800 --> 00:10:43,030
ואז אנחנו הולכים ללשרשר
יחד שתי מחרוזות, מחרוזת שלום,

200
00:10:43,030 --> 00:10:48,070
והמחרוזת מיוצגת על ידי
משתנה, או לייתר דיוק את השם הקבוע.

201
00:10:48,070 --> 00:10:50,660
>> אז זה נחמד כי זה
הוא קצת PHP כמו בנו ש

202
00:10:50,660 --> 00:10:52,250
יש שרשור מחרוזת קל מאוד.

203
00:10:52,250 --> 00:10:56,350
אין לנו באופן אוטומטי
להשתמש בכל סוג של ניהול זיכרון

204
00:10:56,350 --> 00:11:00,580
כדי להגדיל את הגודל ולעשות
כל סוג של דברים מצחיקים שיש.

205
00:11:00,580 --> 00:11:05,040
זה עובד כפי שהיינו מצפה דווקא.

206
00:11:05,040 --> 00:11:09,370
>> בסדר, שאלות על זה?

207
00:11:09,370 --> 00:11:12,520
>> עכשיו הסיבה אחרת ש
אנחנו צריכים יש לך את היכולת

208
00:11:12,520 --> 00:11:15,490
כדי להיות מסוגל להגדיר מה
סוג של משתני הנתונים

209
00:11:15,490 --> 00:11:18,170
הוא כי לפעמים אנחנו עושים לא
רוצה לאתחל משתנים

210
00:11:18,170 --> 00:11:21,080
עם כמה נתונים ב
נקודה של הגדרה.

211
00:11:21,080 --> 00:11:23,500
אז במקרה הזה, נניח
כי אני רוצה להתחיל המזינים

212
00:11:23,500 --> 00:11:25,040
כמה ציונים לספר בכיתה.

213
00:11:25,040 --> 00:11:27,530
ובכן, אני יודע שאחד מ
משתנים שאני רוצה להיות

214
00:11:27,530 --> 00:11:30,280
הולך להיות בכיתה משתנה.

215
00:11:30,280 --> 00:11:33,010
ואנחנו גם יודעים שאנחנו
רוצה שזה יהיה מספר שלם.

216
00:11:33,010 --> 00:11:36,030
אבל אולי אנחנו עושים עדיין לא
יש כיתה שזמינה.

217
00:11:36,030 --> 00:11:39,570
>> בסוויפט, שיש לך
מגדיר את סוג הנתונים

218
00:11:39,570 --> 00:11:44,000
המשויך ל
משתנה או קבוע לתת

219
00:11:44,000 --> 00:11:47,840
לפני למעשה אתה יכול
להשתמש במשתנה ש.

220
00:11:47,840 --> 00:11:51,170
בגלל זה הוא מסוג חזק,
אתה צריך לשייך סוג

221
00:11:51,170 --> 00:11:52,890
עם המשתנים הללו.

222
00:11:52,890 --> 00:11:56,120
>> אז במקרה הזה, אם יש לי לא כראוי
אותחל הראשון עם ערך כלשהו,

223
00:11:56,120 --> 00:12:00,520
אז אני צריך לספר מה סוויפט
אני מצפה לסוג הנתונים להיות.

224
00:12:00,520 --> 00:12:02,650
וזה הולך להישאר
שאותו סוג הנתונים

225
00:12:02,650 --> 00:12:05,780
לאורך ההיסטוריה של תכנית זו.

226
00:12:05,780 --> 00:12:10,050
>> עכשיו אתה עשוי להתפתות בהקדם
אני יצרתי משתנה כיתה זו

227
00:12:10,050 --> 00:12:13,530
ובלבד ש
מספר שלם של 100, עכשיו אם אני

228
00:12:13,530 --> 00:12:18,540
רוצה לנסות לשרשר
מחרוזת עם מספר שלם ש,

229
00:12:18,540 --> 00:12:21,610
עשוי להתפתות עדיין להשתמש
שמפעיל שרשור מחרוזת

230
00:12:21,610 --> 00:12:24,500
כמו שעשינו רק כמה שורות לפני.

231
00:12:24,500 --> 00:12:26,460
אבל לרוע המזל,
למעשה זה לא יהיה

232
00:12:26,460 --> 00:12:29,270
לעבוד, בגלל שאתה
בעצם ביצוע

233
00:12:29,270 --> 00:12:32,380
ניתוח בשני סוגים שונים.

234
00:12:32,380 --> 00:12:36,856
>> עכשיו זה שונה מאוד מאחר
שפות כמו PHP שהם באמת

235
00:12:36,856 --> 00:12:38,480
Goosey loosey עם הסוג של סוגיהם.

236
00:12:38,480 --> 00:12:40,030
הם פשוט אוהבים, כן,
מה, לא אכפת לי.

237
00:12:40,030 --> 00:12:42,710
רק תן לי סוג אחד, ו
אולי אני אעשה את הדבר הנכון.

238
00:12:42,710 --> 00:12:46,060
>> במקרה זה, סוויפט הוא
מאוד קפדן על הסוגים

239
00:12:46,060 --> 00:12:47,350
שיש לך עסק.

240
00:12:47,350 --> 00:12:50,700
מפעיל סיכום זה
או מפעיל שרשור

241
00:12:50,700 --> 00:12:54,400
יש בעצם שני
אופציות אפשריות שונות.

242
00:12:54,400 --> 00:12:56,970
אתה יכול לעשות את סיכום
עם מספרים שלמים, או שאתה

243
00:12:56,970 --> 00:13:00,870
יכול לעשות שרשור מחרוזת, ו
אולי כמה דברים אחרים גם כן.

244
00:13:00,870 --> 00:13:05,550
אבל אם המפעיל שאינו מכיר
מה הוא משני צדיו,

245
00:13:05,550 --> 00:13:10,452
או לייתר דיוק השילוב של אלה
שני סוגים, זה לא מה שמצפה,

246
00:13:10,452 --> 00:13:11,910
אז זה הולך לגרום לכישלון.

247
00:13:11,910 --> 00:13:16,690
>> אז במקרה הזה, מה זה אומר
יש מחרוזת בתוספת מספר שלם?

248
00:13:16,690 --> 00:13:18,880
ובכן, בהקשר של
זה, אנחנו כנראה רוצים

249
00:13:18,880 --> 00:13:21,990
לעשות פעולת שרשור מחרוזת.

250
00:13:21,990 --> 00:13:26,420
אבל כמובן המחשב
אין סוג כזה של קשר.

251
00:13:26,420 --> 00:13:29,950
ולכן אנחנו צריכים לספק
כי מידע נוסף

252
00:13:29,950 --> 00:13:32,390
לתת לו יודע מה זה
הוא שאנחנו רוצים לעשות.

253
00:13:32,390 --> 00:13:36,860
>> אז במילים אחרות, העובדה
שסוויפט הוא מסוג חזק

254
00:13:36,860 --> 00:13:39,520
אומר שאתה צריך לעשות
קצת עבודה נוספת

255
00:13:39,520 --> 00:13:42,100
כדי לקבל אותו לפעול
דרך שאתה רוצה.

256
00:13:42,100 --> 00:13:43,710
אבל כתוצאה מכך, זה בטוח יותר.

257
00:13:43,710 --> 00:13:46,290
וברגע שיש לך לקחת
בחשבון סוגים אלה,

258
00:13:46,290 --> 00:13:49,300
דברים רק בכנות להתחיל
לעובד די טוב.

259
00:13:49,300 --> 00:13:52,520
>> אז במקרה הזה, אז אנחנו הייתם
לבצע שרשור מחרוזת

260
00:13:52,520 --> 00:13:56,040
על ידי במפורש ליהוק
המספר השלם למחרוזת

261
00:13:56,040 --> 00:13:58,490
על ידי לפפה אותו בזה
הון פונקצית S מחרוזת,

262
00:13:58,490 --> 00:14:03,510
ולאחר מכן באמצעות שרשור המחרוזת
מפעיל לשנות משתנה התווית שלנו,

263
00:14:03,510 --> 00:14:06,280
ואז להדפיס אותו.

264
00:14:06,280 --> 00:14:08,420
>> בינתיים בסדר?

265
00:14:08,420 --> 00:14:12,020
בסדר, בואו תמשיכו הלאה.

266
00:14:12,020 --> 00:14:16,300
>> עכשיו יש מגוון של נתונים
סוגים שאנחנו יכולים להשתמש בסוויפט.

267
00:14:16,300 --> 00:14:21,620
כפי שאתה התרגלתם,
אנחנו יכולים ליצור מערך משתנה.

268
00:14:21,620 --> 00:14:26,140
ומערך שרק יכול
מכיל סוג אחד.

269
00:14:26,140 --> 00:14:30,360
>> אז במקרה הזה, אנחנו הולכים ליצור
מערכים משתנים של מספרים שלמים, ש

270
00:14:30,360 --> 00:14:34,800
אנו קוראים לציונים, ונוכל
לאחסון שבסוגריים מרובעים זה

271
00:14:34,800 --> 00:14:38,650
פורמט כמו שהתרגל
במגוון רחב של שפות אחרות.

272
00:14:38,650 --> 00:14:41,150
אבל שם לב שכאן אנחנו
הגדרה כמה דברים.

273
00:14:41,150 --> 00:14:45,350
ציונים הוא variable-- משתנה
אנו לא להשתמש במילת המפתח בואו.

274
00:14:45,350 --> 00:14:49,620
אז זה אומר שאנחנו יכולים לשנות ולאחר מכן
התוכן של מערך זה.

275
00:14:49,620 --> 00:14:53,420
זה של Int מערך הסוג,
ואנחנו יכולים להגיד ש

276
00:14:53,420 --> 00:14:56,260
המבוסס על סוגריים מרובעים אלה כאן.

277
00:14:56,260 --> 00:14:58,930
>> עכשיו אחד הדברים נחמדים
על זה הוא שאנחנו ש

278
00:14:58,930 --> 00:15:02,310
יש להם גישה להרבה
מידע נוסף

279
00:15:02,310 --> 00:15:07,110
על המערך רק באמצעות
כמה סימון נקודה פשוט.

280
00:15:07,110 --> 00:15:10,500
כך למשל,
grades.count מספק לנו

281
00:15:10,500 --> 00:15:14,820
מספר הפריטים שקיימים שב
מערך, שאותם אנו יכולים לגשת די

282
00:15:14,820 --> 00:15:19,090
בקלות פשוט באמצעות שסימון הנקודה.

283
00:15:19,090 --> 00:15:21,830
>> אם ברצונך להוסיף נוסף
פריטים למערך זה,

284
00:15:21,830 --> 00:15:27,220
אתה לא יכול לעשות את סגנון PHP
שבו אתה רק במפורש להגדיר,

285
00:15:27,220 --> 00:15:30,910
במדד נתון, ערך כלשהו
שברצונך להוסיף.

286
00:15:30,910 --> 00:15:37,210
במקום זאת, השתמש צרף
שיטה בסוג המערך

287
00:15:37,210 --> 00:15:40,920
לצרף פריט ש, 95, לרשימה זו.

288
00:15:40,920 --> 00:15:45,990
>> אז עכשיו מערך זה יש הבא
contents-- 100, 0, 90, 85.

289
00:15:45,990 --> 00:15:49,270
ועכשיו אנחנו כבר צירפנו
95 גם לזה.

290
00:15:49,270 --> 00:15:51,830
>> יש דרכים אחרות
אנחנו יכולים לצרף את הדברים.

291
00:15:51,830 --> 00:15:55,030
למעשה אתה יכול להשתמש
מפעיל סיכום,

292
00:15:55,030 --> 00:15:59,200
שיתפרש כ
פעולת צרף מערך.

293
00:15:59,200 --> 00:16:04,680
ואז אתה יכול לצרף עוד
מערך, תוכן שהם 70 ו -80,

294
00:16:04,680 --> 00:16:05,560
למערך זה.

295
00:16:05,560 --> 00:16:08,250
אז עכשיו יש לנו את
תוכן במשתנה זה

296
00:16:08,250 --> 00:16:17,220
grades-- 100, 0, 90, 85, 95, 70, ו -80.

297
00:16:17,220 --> 00:16:21,850
זוהי רק תחבירית קטנה ונחמדה
סוכר שסוויפט מספק לנו.

298
00:16:21,850 --> 00:16:23,850
>> אז אם אנחנו רוצים לסכם
ציונים, אנחנו אולי

299
00:16:23,850 --> 00:16:27,340
הולך רוצה לחזר
על כל פריט בלולאה זה.

300
00:16:27,340 --> 00:16:32,150
ויש לנו, בסוויפט, הרעיון
של ללולאה כפי שהיית מצפה.

301
00:16:32,150 --> 00:16:35,350
אבל האופן שבו אנחנו מצביעים
מגוון הוא מעט שונה.

302
00:16:35,350 --> 00:16:37,790
אז במקרה הזה, ל
סיכום הכל, אנחנו

303
00:16:37,790 --> 00:16:40,650
הולך ליצור זמני
סכום משתנה בשם על מנת ש

304
00:16:40,650 --> 00:16:42,580
כדי לשמור על ספירה זו.

305
00:16:42,580 --> 00:16:44,430
>> ושים לב לנו
בניית לולאה כאן.

306
00:16:44,430 --> 00:16:46,820
למדד ב0 .. <grade.count.

307
00:16:46,820 --> 00:16:51,480

308
00:16:51,480 --> 00:16:57,390
אז בנייה זו, 0 .. <grades.count
היא פעולת טווח שבו אנו נמצאים

309
00:16:57,390 --> 00:17:01,860
אומר שאנחנו הולכים ליצור
טווח של מספרים שלמים בין 0 עד

310
00:17:01,860 --> 00:17:05,750
לאך למעט grades.count.

311
00:17:05,750 --> 00:17:09,577
אז זה יהיה 0, 1, 2, 3, 4,
5, עד אולם רב אחד

312
00:17:09,577 --> 00:17:10,410
לפני grades.count.

313
00:17:10,410 --> 00:17:14,160
>> אז זה שונה מאופן בו אנו
בדרך כלל היה משמש ללולאות

314
00:17:14,160 --> 00:17:18,569
שבו היית צריך כמה מדד
משתנה, להגדיר אותו שווה 0 בהתחלה,

315
00:17:18,569 --> 00:17:25,480
ולאחר מכן לשלב שעד כמה
ערך פחות מהספירה של פריטים

316
00:17:25,480 --> 00:17:27,140
במערך זה.

317
00:17:27,140 --> 00:17:29,820
>> אז יש שינוי
לזה, למעשה,

318
00:17:29,820 --> 00:17:35,010
אשר מאפשר לנו בקלות רבה
להגדיר סוגים שונים של טווחים.

319
00:17:35,010 --> 00:17:40,570
אם תשנה את הטווח הזה ל
שלוש נקודות, 0 ... grade.count,

320
00:17:40,570 --> 00:17:45,120
זה מייצג את מגוון 0
לgrades.count כלול,

321
00:17:45,120 --> 00:17:49,260
כלומר מספר שהוא גם
לאחר מכן נכלל בטווח זה.

322
00:17:49,260 --> 00:17:52,110
>> אבל זה מאוד נוח
לדברים המדויקים אלה,

323
00:17:52,110 --> 00:17:54,590
כאשר אנו צריכים לבצע
חזרות על לולאה

324
00:17:54,590 --> 00:17:59,630
כי מדדים אלה אפס אינדקס,
כפי שראינו בשפות אחרות

325
00:17:59,630 --> 00:18:02,360
גם כן.

326
00:18:02,360 --> 00:18:05,210
כל שאלות על זה ללולאה?

327
00:18:05,210 --> 00:18:10,660
>> אז יש הגדרה משתמעת
של משתנה מדד זה,

328
00:18:10,660 --> 00:18:14,350
הערך שמתחיל ב 0, ו
ממשיך בכל איטרציה לולאה

329
00:18:14,350 --> 00:18:17,950
כדי להגדיל על ידי 1 עד נקודה
כי הוא שווה לgrades.count,

330
00:18:17,950 --> 00:18:20,380
ובשלב זה, לולאת ביטולים.

331
00:18:20,380 --> 00:18:23,730
>> שים לב כי במחרוזת שלנו
אינטרפולציה כאן,

332
00:18:23,730 --> 00:18:26,910
אנחנו באמת יכולים לבצע כמה פשוט
מניפולציות לערכים אלה.

333
00:18:26,910 --> 00:18:31,230
אז מדד בתוספת 1 למעשה
לבצע סיכום של ערך ש

334
00:18:31,230 --> 00:18:34,780
כי מדד הוא, ב
מקרה זה, מספר שלם.

335
00:18:34,780 --> 00:18:37,810
ובשלב זה, זה יהיה
להיות לאחר מכן להמיר למחרוזת

336
00:18:37,810 --> 00:18:42,230
ואינטרפולציה למחרוזת זה כאן,
והדפיס כפי שהיינו מצפה. .

337
00:18:42,230 --> 00:18:44,520
>> והדבר נחמד
על המערכים כאן הוא

338
00:18:44,520 --> 00:18:50,730
כי אנחנו גם מסוגלים לקבל
ערכים מקסים וערכי הגדרה

339
00:18:50,730 --> 00:18:54,080
באמצעות סימון הסוגר המרובע כ
שראינו בשפות אחרות גם כן.

340
00:18:54,080 --> 00:18:57,130

341
00:18:57,130 --> 00:19:01,030
>> בסדר, אז מכאן, אנחנו עכשיו
לחשב הסכום של כל הציונים שלנו שלנו.

342
00:19:01,030 --> 00:19:02,780
עכשיו סוג של הבא
צעד הגיוני יהיה

343
00:19:02,780 --> 00:19:07,580
לעשות פעולת החלוקה למצוא
את הממוצע של ציונים אלה.

344
00:19:07,580 --> 00:19:10,150
אבל משהו חשוב
כאן קורה ש

345
00:19:10,150 --> 00:19:15,020
הוא שסכום זה הוא אולי מספר שלם.

346
00:19:15,020 --> 00:19:18,020
אבל אנחנו צריכים לבצע כמה
סוג של חלוקה כפולה.

347
00:19:18,020 --> 00:19:20,600
וזה הולך להיות
חשוב מאוד כאשר

348
00:19:20,600 --> 00:19:24,140
אנחנו רוצים לבצע פעולה זו,
כי מה שאנחנו אומרים

349
00:19:24,140 --> 00:19:28,430
הוא שאנחנו צריכים בעצם
לבצע חלוקה בשני זוגות.

350
00:19:28,430 --> 00:19:31,370
ושוב, כי סוויפט
הוא מאוד חזק מאופיין,

351
00:19:31,370 --> 00:19:36,760
עלינו להגדיר באופן מפורש כל
פריטים לזוגות לפני שאנחנו באמת

352
00:19:36,760 --> 00:19:38,300
לבצע את הפעולה ש.

353
00:19:38,300 --> 00:19:40,550
>> אז כדי לנו
לבצע חלוקה כפולה,

354
00:19:40,550 --> 00:19:43,730
זה לא מספיק רק אחד
של פריטים אלה להיות כפולים.

355
00:19:43,730 --> 00:19:46,400
שניהם צריכים להיות
כפול על מנת מהיר

356
00:19:46,400 --> 00:19:50,860
כדי להיות בטוח שזה
זה מה שאנחנו רוצים לעשות.

357
00:19:50,860 --> 00:19:54,360
אז אנחנו אז חומר מודפס באופן מפורש
הסכום שבו אנו כבר מחושבים מעל

358
00:19:54,360 --> 00:19:58,970
והספירה של ציונים לזוגות, ו
לאחר מכן לבצע פעולה ושחנות

359
00:19:58,970 --> 00:20:02,390
כי למשתנה חדשה, או לייתר דיוק
קבוע זה חדש בשם ממוצע,

360
00:20:02,390 --> 00:20:06,810
שתהיה לי איזה סוג, אתה יכול לדמיין?

361
00:20:06,810 --> 00:20:07,587
זוגי, כן.

362
00:20:07,587 --> 00:20:09,420
אז במקרה הזה, אנחנו
לא צריך לציין את זה

363
00:20:09,420 --> 00:20:13,450
כי זה יכול להיות מוסק מ
פעולה איזה סוג של נתונים ממוצע

364
00:20:13,450 --> 00:20:14,730
יהיה.

365
00:20:14,730 --> 00:20:19,025
וסוויפט הוא בדרך כלל די טוב
על היכולת להסיק הסוגים.

366
00:20:19,025 --> 00:20:22,116

367
00:20:22,116 --> 00:20:24,200
>> האם אתה רוצה לראות את זה
לרוץ, או שאני יכול להמשיך הלאה?

368
00:20:24,200 --> 00:20:25,640
אני רוצה להמשיך.

369
00:20:25,640 --> 00:20:28,130
כל שאלות על כל זה?

370
00:20:28,130 --> 00:20:28,630
גדול.

371
00:20:28,630 --> 00:20:31,160

372
00:20:31,160 --> 00:20:35,010
>> עכשיו אנחנו הולכים להתחיל להגיע ל
הפונקציות המגדירות stuff-- טובות,

373
00:20:35,010 --> 00:20:39,090
וכמה סוגים אחרים, כי הם
ייחודי לסוויפט שיש לך לא

374
00:20:39,090 --> 00:20:41,620
ראה בשפות אחרות
עד לנקודה זו,

375
00:20:41,620 --> 00:20:46,290
אבל הם נמצאים באחרים
שפות שאתה עלול למצוא בהמשך.

376
00:20:46,290 --> 00:20:48,210
אז קודם כל, אם אתה רוצה
להגדיר פונקציה,

377
00:20:48,210 --> 00:20:52,170
אתה מגדיר את זה עם מילת פאנקי
פונקציה, ולאחר מכן את שם הפונקציה,

378
00:20:52,170 --> 00:20:56,710
ולאחר מכן בסוגריים, הטיעונים
שאתה רוצה פונקציה שלקבל.

379
00:20:56,710 --> 00:21:00,280
הטענות גם חייבת
specify-- generally--

380
00:21:00,280 --> 00:21:05,010
צריך גם לציין את סוג הנתונים ש
הם, אלא אם כן הם יכולים להיות מוסק.

381
00:21:05,010 --> 00:21:07,500
ואנו רואים שקטנים
אזהרה בקצת.

382
00:21:07,500 --> 00:21:09,920
>> אז במקרה הזה יש לנו
פונקציה שנקראת printGradeCount.

383
00:21:09,920 --> 00:21:12,840
אנחנו הולכים לקבל
variable-- או לייתר דיוק במקרה הזה,

384
00:21:12,840 --> 00:21:14,450
constant-- נקרא gradebook.

385
00:21:14,450 --> 00:21:18,517
וזה הולך להיות של
הקלד מערך של מספרים שלמים.

386
00:21:18,517 --> 00:21:20,600
עכשיו יש משהו ש
זה באמת חשוב כאן

387
00:21:20,600 --> 00:21:21,849
כי אני רוצה שתבין.

388
00:21:21,849 --> 00:21:27,560
זה שכברירת מחדל, טענות אלה
כי הם תשומות לפונקציה זו

389
00:21:27,560 --> 00:21:34,380
מוגדר עם מילת המפתח בואו משתמע,
מה שאומר שאני לא יכול לשנות את זה

390
00:21:34,380 --> 00:21:39,850
משתנה gradebook כאן.

391
00:21:39,850 --> 00:21:43,360
וזה סוג של הגיוני,
בגלל שאתה עובר בנתונים.

392
00:21:43,360 --> 00:21:45,860
ואתה אולי לא רוצה אותו
להיות שונה מתחתיך.

393
00:21:45,860 --> 00:21:50,800
אפשר לדבר באופן מפורש
שזה משתנה על ידי הצבת

394
00:21:50,800 --> 00:21:52,070
מילת המפתח var כאן.

395
00:21:52,070 --> 00:21:56,832
אבל זה תפסתי אותך שיש לנו
אנשים שמו לב שעשו בעבר

396
00:21:56,832 --> 00:21:59,790
הוא שהם הניחו שזה הולך
להיות משתנה כאשר, למעשה, זה

397
00:21:59,790 --> 00:22:02,640
הוא קבוע.

398
00:22:02,640 --> 00:22:07,340
>> בסדר, אז הנה אז, במקרה זה,
אנחנו לא מפרטים כל סוג תמורה.

399
00:22:07,340 --> 00:22:09,460
אנחנו אראה לך איך לעשות את
כי ברגע.

400
00:22:09,460 --> 00:22:12,340
אבל שם לב שיש לנו כאן
רק אם מצב פשוט.

401
00:22:12,340 --> 00:22:14,560
אם gradebook הוא
ריק, אשר במקרה זה

402
00:22:14,560 --> 00:22:19,310
רק הרכוש של מספר שלם זה
מערך, אז אנחנו להדפיס משהו.

403
00:22:19,310 --> 00:22:23,100
אחרת אנו עושים משהו אחר.

404
00:22:23,100 --> 00:22:25,000
>> די פשוט עד כה אני חושב.

405
00:22:25,000 --> 00:22:27,960
אבל לעצור אותי אם יש לך שאלות.

406
00:22:27,960 --> 00:22:33,350
>> עכשיו בפונקציה זו, ממוצעת, גם לוקחת
כמה טיעונים, או לייתר דיוק ויכוח אחד,

407
00:22:33,350 --> 00:22:37,507
אשר הוא gradebook, והפעם
הוא הולך לחזור סוג כפול.

408
00:22:37,507 --> 00:22:39,340
בגלל זה הוא מחשוב
ממוצע וזה

409
00:22:39,340 --> 00:22:45,010
הולך לחזור למעשה ש
ממוצע מחושב לקו הקורא.

410
00:22:45,010 --> 00:22:50,070
>> במקרה זה, אנו מגדירים את
לחזור סוג לאחר חץ.

411
00:22:50,070 --> 00:22:53,260
וזה עלול להרגיש
קצת מוזר בהתחלה.

412
00:22:53,260 --> 00:22:55,610
אתה כבר התרגל
לקביעת התמורה

413
00:22:55,610 --> 00:22:57,720
הקלד לפני השם של הפונקציה.

414
00:22:57,720 --> 00:23:00,310
אבל אם אתה חושב על זה
במונחים של מתמטיקה,

415
00:23:00,310 --> 00:23:03,320
כמו כאשר יש לך מתמטיקה
שמגדיר פונקציה,

416
00:23:03,320 --> 00:23:06,807
יש לך פונקציה עם כמה
תשומות, והיא מייצרת פלט.

417
00:23:06,807 --> 00:23:08,890
וזה בדיוק מה ש
זה אמור לחקות.

418
00:23:08,890 --> 00:23:12,460
ויש כמה שפות אחרות
שיש לי תחביר דומה, כמו גם,

419
00:23:12,460 --> 00:23:15,674
אבל כנראה שאף אחד
שראית בCS50.

420
00:23:15,674 --> 00:23:17,090
אבל עדיין לא להתבלבל על ידי זה.

421
00:23:17,090 --> 00:23:21,650
החץ מתכוון למה שהוא הולך
ליוחזר במקרה זה.

422
00:23:21,650 --> 00:23:23,650
אוקיי, אז איך אנחנו הולכים
כדי לחשב ממוצע זה?

423
00:23:23,650 --> 00:23:25,649
ובכן, אם gradebook
הוא ריק, גם אז אנחנו

424
00:23:25,649 --> 00:23:30,731
הולך לחזור 0, שאולי
דרך סבירה לטיפול זה.

425
00:23:30,731 --> 00:23:32,980
אני לא יודע, בואו נבוא
אחזור לזה בקצת.

426
00:23:32,980 --> 00:23:34,688
לא זו עשויה למעשה
להיות דרך סבירה

427
00:23:34,688 --> 00:23:38,310
כדי לחשב ממוצע אם
יש לנו gradebook ריק.

428
00:23:38,310 --> 00:23:41,260
>> אז פשוט לבצע הסיכום שלנו.

429
00:23:41,260 --> 00:23:43,900
שימו לב שכאן אנחנו באמת
יש גרסה חלופית של

430
00:23:43,900 --> 00:23:49,190
ללולאה, אשר מאפשרת לנו לחזר
על כל פריט יחיד במערך

431
00:23:49,190 --> 00:23:53,630
ולמקם כל אלמנט
למשתנה שלו.

432
00:23:53,630 --> 00:23:56,200
על ידי ציון לכיתה ב
gradebook, מה שאנחנו אומרים

433
00:23:56,200 --> 00:24:00,560
הוא שאנחנו הולכים במשתמע
ליצור קבוע חדש בשם

434
00:24:00,560 --> 00:24:05,180
כיתה שהולכת לייצג
כל פריט ייחודי בgradebook

435
00:24:05,180 --> 00:24:06,769
בכל פעם שלסובב לולאה.

436
00:24:06,769 --> 00:24:08,560
אז בפעם הראשונה ש
זה לרוץ, תהיה כיתה

437
00:24:08,560 --> 00:24:09,800
להיות הפריט הראשון בgradebook.

438
00:24:09,800 --> 00:24:12,300
בפעם השנייה זה יהיה
פריט שני, כן הלאה וכן הלאה

439
00:24:12,300 --> 00:24:15,970
עד gradebook יש
מיצה את עצמה מאלמנטים.

440
00:24:15,970 --> 00:24:20,390
אז נוכל לסכם ש
כיתה למשתנה הסיכום שלנו

441
00:24:20,390 --> 00:24:22,570
ותשואה הממוצעת שלנו
כפי שראינו בעבר.

442
00:24:22,570 --> 00:24:25,670

443
00:24:25,670 --> 00:24:26,950
אישור, כל שאלות?

444
00:24:26,950 --> 00:24:27,699
כֵּן?

445
00:24:27,699 --> 00:24:28,990
קהל: יש לי שתי שאלות.

446
00:24:28,990 --> 00:24:33,586
מספר אחד, באופן היפותטי, יכול
אתה מפעיל מספר שלם על זה?

447
00:24:33,586 --> 00:24:35,604
לא צריך להיות
כפול, האם זה נכון?

448
00:24:35,604 --> 00:24:37,520
דן AMRMENDARIZ: האם אתה יכול
לחזור על שאלה הזאת?

449
00:24:37,520 --> 00:24:39,587
קהל: האם אני יכול לעשות
מספר שלם כממוצע?

450
00:24:39,587 --> 00:24:41,670
דן AMRMENDARIZ: האם אתה יכול
לעשות שלם כממוצע?

451
00:24:41,670 --> 00:24:45,015
אז לחזור שלם
ממוצע במקום כפול?

452
00:24:45,015 --> 00:24:48,204
>> קהל: Return--
יש לי שעכשיו מתחת.

453
00:24:48,204 --> 00:24:49,870
דן AMRMENDARIZ: ממש כאן, לחזור 0.0?

454
00:24:49,870 --> 00:24:51,790
קהל: כן, רק לחזור 0.

455
00:24:51,790 --> 00:24:56,590
אז זה יהיה או
80 או 85, אבל לא 85.2.

456
00:24:56,590 --> 00:24:59,465
>> דן AMRMENDARIZ: אז במקרה זה,
כך שיש כמה דרכים שונות

457
00:24:59,465 --> 00:25:00,090
לענות על זה.

458
00:25:00,090 --> 00:25:02,760
תן לי לענות עליהן במטרה.

459
00:25:02,760 --> 00:25:06,740
אז אם אני רק עושה תמורה זו
0, 0 הוא ערך שלם.

460
00:25:06,740 --> 00:25:09,730
וכדי שיגרום ל
טעות מסוג למקרה זה

461
00:25:09,730 --> 00:25:13,210
משום שהוא מצפה כפול
אבל אז הוא חוזר שלם.

462
00:25:13,210 --> 00:25:16,770
אם אני רוצה לחזור שלם, שאני יכול.

463
00:25:16,770 --> 00:25:20,450
אני יכול להגדיר את סוג ההחזרה
לint, לחזור 0 כאן,

464
00:25:20,450 --> 00:25:22,047
ולא לבצע חלוקה כפולה.

465
00:25:22,047 --> 00:25:23,880
אבל אז נהיה
עושה חלוקה של מספרים שלמים.

466
00:25:23,880 --> 00:25:27,080
וכך אנו אז לא היינו מקבלים
ממוצע שהיינו אולי מצפה.

467
00:25:27,080 --> 00:25:29,210
אבל כן אנחנו יכולים לשנות
הסוגים שבדרך.

468
00:25:29,210 --> 00:25:32,598
>> קהל: ושנית, אתה
יש אחד זוגית בחלק העליון.

469
00:25:32,598 --> 00:25:35,502
אבל למטה, כאשר אתה
לעשות לחזור זוגי זוגי,

470
00:25:35,502 --> 00:25:38,280
זה כבר באופן אוטומטי
חוזר פורמט זוגי.

471
00:25:38,280 --> 00:25:42,278
למה אתה עדיין צריך להגדיר את זה
עם חץ על גבי עם זוגי?

472
00:25:42,278 --> 00:25:45,010
>> דן AMRMENDARIZ: אז
במקרה, זה חלק

473
00:25:45,010 --> 00:25:50,580
של כל-- כך לחזור על השאלה,
כי זה משתמע מהתמורה

474
00:25:50,580 --> 00:25:56,030
סוגים כאן, איזה סוג זה למעשה
הוא, שאנחנו צריכים להיות מפורשים עם סוויפט

475
00:25:56,030 --> 00:25:59,970
על מה שאנחנו רוצים
לחזור מפונקציה זו

476
00:25:59,970 --> 00:26:02,690
כך שכאשר הוא מבצע להקליד
בדיקה, זה יכול לוודא

477
00:26:02,690 --> 00:26:05,850
כי מה יש לנו בעצם נכתב
למטה ממש תואם את זה.

478
00:26:05,850 --> 00:26:10,225
אז זה קצת כמו צ'ק
עם עצמך סוג של מצב.

479
00:26:10,225 --> 00:26:11,050
אבל יש הן--

480
00:26:11,050 --> 00:26:12,560
>> קהל: [לא ברור] חץ?

481
00:26:12,560 --> 00:26:19,490
>> דן AMRMENDARIZ: יש מקרים שבם
אנו יכולים לציין כי במובלע שאנחנו יכולים

482
00:26:19,490 --> 00:26:21,550
להגדיר את סוג התמורה.

483
00:26:21,550 --> 00:26:23,940
אבל במקרה הזה, אני לא
חושב שזה יעבוד.

484
00:26:23,940 --> 00:26:26,190
יש כמה תחביר אחר
שנראה בהמשך.

485
00:26:26,190 --> 00:26:30,320

486
00:26:30,320 --> 00:26:35,280
>> בסדר, אז מקור זה
הקוד הוא קצת שונה

487
00:26:35,280 --> 00:26:41,839
בגלל זה מנתח טענות מ
הפונקציה שאנחנו קוראים.

488
00:26:41,839 --> 00:26:44,130
תן לי להראות לך איך זה עובד
לפני שאנחנו באמת להעביר ב

489
00:26:44,130 --> 00:26:48,050
לכמה דברים מעניינים
שקורה בסוויפט.

490
00:26:48,050 --> 00:26:51,870
>> אז במקרה הזה, אם אני רק להפעיל את זה
קוד, תבחין כי מה שהיא עושה

491
00:26:51,870 --> 00:26:54,900
הוא-- זמן, זה סוג של
נותן לי שגיאה מוזרה.

492
00:26:54,900 --> 00:26:59,730
אני צריך להעביר את זה כמה
מספרים שלמים כטיעון שורת הפקודה.

493
00:26:59,730 --> 00:27:06,220
אז בואו לראות, 150 ו -80, ופגעת הזן
כדי לברר מה זה בעצם עושה.

494
00:27:06,220 --> 00:27:09,890
זה לקבל כל אחד מ
ערכים אלה כמספרים שלמים.

495
00:27:09,890 --> 00:27:12,040
זה מזין אותם לgradebook.

496
00:27:12,040 --> 00:27:14,470
ואז זה ביצוע
כי חישוב ממוצע

497
00:27:14,470 --> 00:27:16,650
ופלט שכפי שהיינו מצפה.

498
00:27:16,650 --> 00:27:19,950
>> אבל ברור שיש משהו הולך
על עם משהו דחייה זו

499
00:27:19,950 --> 00:27:23,300
משהו כמו מספר שלם.

500
00:27:23,300 --> 00:27:27,300
כפי שאתם אולי זוכרים מכשהיינו
התמודדות עם טיעוני שורת הפקודה

501
00:27:27,300 --> 00:27:32,640
ב- C ושפות אחרות, הראשון
פריט 0-ה בטענת שורת הפקודה ש

502
00:27:32,640 --> 00:27:35,774
רשימה היא השם של הפקודה
שבוצענו בפועל.

503
00:27:35,774 --> 00:27:38,690
אז במקרה הזה, אני רק לולאה
על כל טיעוני שורת הפקודה.

504
00:27:38,690 --> 00:27:41,650
אבל אני לא עושה את כל סוג של הזיה
לבדוק לדלג על שראשון.

505
00:27:41,650 --> 00:27:45,920
אני רק במפורש או במשתמע אני
בדיקה שמהסוגים אלה

506
00:27:45,920 --> 00:27:49,900
הם מספרים שלמים לפני שאני באמת
לבצע חישוב זה.

507
00:27:49,900 --> 00:27:52,420
>> וזה בעצם
מה שקורה כאן.

508
00:27:52,420 --> 00:27:55,860
לכל ויכוח ב
טיעוניו של התהליך,

509
00:27:55,860 --> 00:27:59,210
אני הולך לבצע כמה בדיקה.

510
00:27:59,210 --> 00:28:01,970
ובמקרה הזה, אני הולך
כדי לנסות להמיר ראשון

511
00:28:01,970 --> 00:28:07,620
הטענה כי למספר שלם על ידי
ביצוע הסבה מפורשת,

512
00:28:07,620 --> 00:28:12,310
בגלל זה הוא, על קלט, מחרוזת
ולא בעובדה מספר שלם.

513
00:28:12,310 --> 00:28:18,140
>> אבל זה סוג של תחביר מוזר,
אם כיתה תן שווה Int (טיעון).

514
00:28:18,140 --> 00:28:21,120
מה שקורה בפועל
כאן הוא מאוד

515
00:28:21,120 --> 00:28:24,390
חשוב סוויפט באמצעותך.

516
00:28:24,390 --> 00:28:27,610
זה משתמש מה
נקרא סוג אופציונאלי.

517
00:28:27,610 --> 00:28:34,790
>> אז פונקציה זו, Int (טיעון),
חוזר לא רק שלם, אבל חוזר

518
00:28:34,790 --> 00:28:37,470
מה שנקרא שלם אופציונלית.

519
00:28:37,470 --> 00:28:41,200
ואז זה סוג של
סוג על גבי סוג.

520
00:28:41,200 --> 00:28:45,900
סוג של אתה יכול לדמיין את זה כמו
זה חוזר כמו חבילה.

521
00:28:45,900 --> 00:28:47,750
וכאשר אתה פותח ש
חבילה, זה גם

522
00:28:47,750 --> 00:28:53,930
יש מספר שלם, שהוא התוצאה, או
יש לו שום דבר באופן מוחלט בכל.

523
00:28:53,930 --> 00:28:58,140
וזה שימושי כמו בדיקת שגיאות
מנגנון, כי במקרה זה

524
00:28:58,140 --> 00:29:02,080
אנחנו יכולים לגלות, היה זה
המרת סוג מוצלחת?

525
00:29:02,080 --> 00:29:05,810
אם זה היה, אז זה למעשה
הולך להיות מספר שלם בפנים.

526
00:29:05,810 --> 00:29:08,750
אחרת זה הולך להיות קצת
ערך שנתקשר אל אפסית, ש

527
00:29:08,750 --> 00:29:10,920
הוא נציג של לא שלם בכל.

528
00:29:10,920 --> 00:29:13,270
זה באמת נציג של דבר.

529
00:29:13,270 --> 00:29:18,130
>> ולכן אם בנייה זו
מאפשר לנו לגולל חבילה ש,

530
00:29:18,130 --> 00:29:19,850
שאופציונלי מחייב.

531
00:29:19,850 --> 00:29:25,560
ואם אנו יכולים לגולל ש
חבילה ולמצוא מספר שלם בפנים,

532
00:29:25,560 --> 00:29:27,720
אז מה שאנחנו אומרים
כאן הוא שאנחנו אז יהיו

533
00:29:27,720 --> 00:29:33,090
מאפשר ערך שכדי להיות מוגדר ל
קבוע הזה שנקרא כיתה.

534
00:29:33,090 --> 00:29:36,590
וחלק זה של אם ההצהרה,
החלק העליון של אם ההצהרה

535
00:29:36,590 --> 00:29:40,390
יפעל, כי זה
לגולל היה מוצלח.

536
00:29:40,390 --> 00:29:43,290
>> אם זה פשוט כל כך קורה ש
הייתה שגיאה אולי

537
00:29:43,290 --> 00:29:47,040
בהמרת סוג זה מפורש
ממחרוזת למספר שלם, אולי

538
00:29:47,040 --> 00:29:49,160
זה ABC הערך לדוגמא.

539
00:29:49,160 --> 00:29:52,120
וזה ממש לא הולך
להמיר למספר שלם.

540
00:29:52,120 --> 00:29:55,520
ואז זה יחזור אפסי,
שהוא לא שלם.

541
00:29:55,520 --> 00:29:57,570
ואם הצהרה זו גם אז להיכשל.

542
00:29:57,570 --> 00:30:01,930
כיתה לא קיימת כי
אין לה תוכן שלם.

543
00:30:01,930 --> 00:30:06,391
וזה יפעל לחסום אחר זה במקום.

544
00:30:06,391 --> 00:30:06,890
כֵּן?

545
00:30:06,890 --> 00:30:09,652
>> קהל: Nil הוא N-אני-L?

546
00:30:09,652 --> 00:30:11,110
דן AMRMENDARIZ: אפסי הוא N-אני-L, כן.

547
00:30:11,110 --> 00:30:14,970

548
00:30:14,970 --> 00:30:20,310
>> אז זה אולי אחד מ
הדברים הקשים ביותר על סוויפט,

549
00:30:20,310 --> 00:30:23,690
במיוחד כאשר אתה ב
העשבים על יישום iOS

550
00:30:23,690 --> 00:30:27,442
ואתה בעצם מנסה
כדי לעשות קצת פיתוח שם.

551
00:30:27,442 --> 00:30:29,400
זה הולך להיות לצעוק
בך על שמירת.

552
00:30:29,400 --> 00:30:33,050
זה הולך להיות מבקש ממך
סימני שאלה וסימני קריאה.

553
00:30:33,050 --> 00:30:37,100
אבל ברגע שאתה להבין out-- אם אתה
להקדיש קצת זמן כדי להבין

554
00:30:37,100 --> 00:30:41,990
מה קורה עם סוגים אופציונליים,
תוכל לחסוך לעצמך הרבה כאב ראש

555
00:30:41,990 --> 00:30:46,040
כפי שאתה מנסה
לכתוב אפליקציה בסוויפט.

556
00:30:46,040 --> 00:30:47,660
>> זה בעצם תכונה חזקה מאוד.

557
00:30:47,660 --> 00:30:49,826
ואתה רק צריך
לקחת מילה על זה לעת עתה.

558
00:30:49,826 --> 00:30:52,620
אבל נראה בנייה זו
וכמה אחרים אוהבים את זה

559
00:30:52,620 --> 00:30:56,740
בחלק מקוד המקור האחר ש
אנחנו אראה לך בקצת.

560
00:30:56,740 --> 00:31:00,440
>> האם יש שאלות ראשוניות כאן?

561
00:31:00,440 --> 00:31:03,790

562
00:31:03,790 --> 00:31:08,690
אז ממסעדה החשובה היא ש
סוג אופציונאלי הוא סוג של metatype.

563
00:31:08,690 --> 00:31:12,500
יש לו גם ערך,
ואם כן, אז זה

564
00:31:12,500 --> 00:31:18,110
יהיה אולי יש ערך שקשור
עם זה, או שיש לו שהיא לא ערך,

565
00:31:18,110 --> 00:31:19,620
והוא מיוצג על ידי אפסי.

566
00:31:19,620 --> 00:31:24,210

567
00:31:24,210 --> 00:31:28,870
שאר זה הוא אולי
כפי שהיית מצפה.

568
00:31:28,870 --> 00:31:32,900
>> אז בואו להגביר
קושי שוב.

569
00:31:32,900 --> 00:31:37,070
והפעם, בואו נסתכל על כמה
סוגי נתונים אחרים שקיימים בפועל.

570
00:31:37,070 --> 00:31:41,290
אחד מהם הוא מילונים, שהוא
דומה מאוד למילונים פייתון.

571
00:31:41,290 --> 00:31:48,270
זה קצת דומה לשולחן חשיש ב
ג זה בעצם מיפוי של מקשים

572
00:31:48,270 --> 00:31:49,820
איפה מפתחות יכולים להיות מחרוזות.

573
00:31:49,820 --> 00:31:52,670
כאשר אתה מסתכל למעלה המפתחות האלה ו,
מפתחות אלה יהיו ערך.

574
00:31:52,670 --> 00:31:56,020
אז זה לא ממש מערך, אבל
במקום זאת, קשור באופן הדוק יותר

575
00:31:56,020 --> 00:31:58,810
למפת חשיש או שולחן חשיש.

576
00:31:58,810 --> 00:32:02,420
>> בואו לראות איך זה אמור
לעבודה לפני שאנחנו באמת

577
00:32:02,420 --> 00:32:05,210
להיכנס לקוד המקור עצמו.

578
00:32:05,210 --> 00:32:07,680
אם אני רק להפעיל את זה,
שום דבר לא קורה באמת.

579
00:32:07,680 --> 00:32:12,430
זה אומר לי שאני מצפה
כמה פרמטרים מהסוג הבא.

580
00:32:12,430 --> 00:32:16,050
אז אני הולך לספק ל
זה כמה שמות בעיה להגדיר,

581
00:32:16,050 --> 00:32:18,490
כך pset0, אולי יש לי 100.

582
00:32:18,490 --> 00:32:20,790
וpset1, יש לי 5.

583
00:32:20,790 --> 00:32:24,630
ולאחר מכן בבחינה, אני
עשה ממש טוב ויש לי 30.

584
00:32:24,630 --> 00:32:27,180
ואופס, אני מכה חלל כאן.

585
00:32:27,180 --> 00:32:30,940
>> כשפגעתי הזן, אתה יכול לראות
הוא מבצע כמה חישוב.

586
00:32:30,940 --> 00:32:33,740
זה אומר gradebook הוא שלוש
ציונים, pset1, pset0, בחינה.

587
00:32:33,740 --> 00:32:36,120
ויש gradebook
ממוצע ספציפי זה.

588
00:32:36,120 --> 00:32:38,370
אז שוב, אנחנו עובדים
עם רעיון gradebook זה,

589
00:32:38,370 --> 00:32:44,650
אבל אנחנו הולכים להמשיך iterating
עם המורכבות של הפונקציה שלנו.

590
00:32:44,650 --> 00:32:47,650
>> אז בתחילת, אנחנו רק
הולך ליצור פונקציה ש

591
00:32:47,650 --> 00:32:49,390
הוא אחראי על הדפסת השימוש.

592
00:32:49,390 --> 00:32:51,920
ויש יציאה זו
פונקציה שתהיה רק

593
00:32:51,920 --> 00:32:53,710
בכוח לצאת מהיישום.

594
00:32:53,710 --> 00:32:56,530
זה לא משהו ש
תוכל להשתמש באפליקציה iOS.

595
00:32:56,530 --> 00:32:59,750
זה רק, במקרה זה,
עם טיעון שורת הפקודה.

596
00:32:59,750 --> 00:33:01,990
הבא נתחיל לנוע לכיוון Xcode.

597
00:33:01,990 --> 00:33:07,760
אבל זה ספציפי לפקודה
תכנית בסגנון קו בסוויפט.

598
00:33:07,760 --> 00:33:11,490
>> בואו נסתכל על כמה מ
הדברים המעניינים כאן.

599
00:33:11,490 --> 00:33:15,150
בואו לראות, רק כמה
דברים מעניינים להזכיר אולי

600
00:33:15,150 --> 00:33:19,930
הוא שבתפקיד שלי
הדפסת מספר הכיתות,

601
00:33:19,930 --> 00:33:26,090
אולי אתה זוכר שהיה לי רשימה ש
של pset1 items--, pset0, ובחינה.

602
00:33:26,090 --> 00:33:29,130
למעשה אתה יכול במהירות
ולעשות זאת בקלות

603
00:33:29,130 --> 00:33:34,490
על ידי לקיחת gradebook, שהוא
מילון שבו יש מפתחות וערכים.

604
00:33:34,490 --> 00:33:38,730
מצא את כל המפתח הוא דרך
שיטת מפתחות נקודה כאן,

605
00:33:38,730 --> 00:33:43,180
ולאחר מכן להשתמש joinWithSeparator זה,
אשר לאחר מכן לקחת את כל המפתחות

606
00:33:43,180 --> 00:33:48,590
שהדפסנו ב, או pset1--
מצטער, pset0, pset1, וexam--

607
00:33:48,590 --> 00:33:53,030
ולשרשר אותם יחד
באמצעות פסיק וחלל

608
00:33:53,030 --> 00:33:55,400
כדי ליצור מחרוזת אחת ארוכה.

609
00:33:55,400 --> 00:34:00,190
פעולה להצטרף זוהי רק להדהים
שימושי במגוון של הקשרים.

610
00:34:00,190 --> 00:34:03,450
וכך הוא joinWithSeparator זה.

611
00:34:03,450 --> 00:34:06,939
>> וזה דבר אחד שהוא
השתנה מיום 1 בסוויפט לסוויפט 2.

612
00:34:06,939 --> 00:34:08,730
בעבר היה
style-- פייתון אם אתה

613
00:34:08,730 --> 00:34:13,219
מכיר Python-- פייתון
סגנון להצטרף שיטה על מיתרים.

614
00:34:13,219 --> 00:34:15,699
אבל זה כבר לא
המקרה בסוויפט 2.

615
00:34:15,699 --> 00:34:19,400
אתה רוצה להשתמש בזה אם אתה רוצה
ללשרשר מערך של דברים

616
00:34:19,400 --> 00:34:23,380
יחד עם מחרוזת.

617
00:34:23,380 --> 00:34:27,889
>> אז אולי אז בנו
דיון בממוצע לפני,

618
00:34:27,889 --> 00:34:32,659
זה עושה קצת יותר הגיוני
לנו להגדיר את הפונקציה הממוצעת

619
00:34:32,659 --> 00:34:36,610
להיות כפול אופציונאלי ולא
מאשר רק כפול מפורש.

620
00:34:36,610 --> 00:34:39,239
בגלל שהיו לנו ש
מצב יוצא דופן שבו,

621
00:34:39,239 --> 00:34:41,550
מה אם gradebook למעשה
אין ערכים בתוכו?

622
00:34:41,550 --> 00:34:44,280
מה צריך התשואה הממוצעת?

623
00:34:44,280 --> 00:34:46,350
>> טוב, אולי בC
היה עושה משהו

624
00:34:46,350 --> 00:34:50,040
כמו סיפק ערך זקיף, כמו
0.0, או אולי מספר שלילי,

625
00:34:50,040 --> 00:34:53,690
או משהו פשוט מייצג את העובדה
שיש איזה מצב שגיאה

626
00:34:53,690 --> 00:34:57,910
ואולי לא באמת יש לך
היכולת לחשב ממוצע ש.

627
00:34:57,910 --> 00:35:05,590
ובכן היופי של ציון
סוג אופציונאלי יהיה לעשות את זה.

628
00:35:05,590 --> 00:35:09,540
ועכשיו אני אומר את כל הדברים האלה, אבל
זה בעצם לא להשתמש optionals.

629
00:35:09,540 --> 00:35:12,970
אבל נראה שרק
דקות שבו אנחנו יכולים להגדיר ממוצע

630
00:35:12,970 --> 00:35:17,230
להיות סוג נתונים אופציונאלי כך ש
אם זה באמת מחזיר חלק מנתונים, ולאחר מכן

631
00:35:17,230 --> 00:35:18,470
נחזור נתונים ש.

632
00:35:18,470 --> 00:35:20,570
אחרת נחזור
אפסי, ואמר כי זו

633
00:35:20,570 --> 00:35:22,200
אין חישוב משמעותי.

634
00:35:22,200 --> 00:35:25,650

635
00:35:25,650 --> 00:35:28,570
>> בואו נעבור למשהו אחר.

636
00:35:28,570 --> 00:35:35,910
אז מכאן, אנחנו כבר מסתכלים על
כל דוגמאות האלה בשורת הפקודה.

637
00:35:35,910 --> 00:35:39,470
אבל באמת מה שאתה הולך
להתמודדות עם היא Xcode.

638
00:35:39,470 --> 00:35:43,720
ואחד הדברים נחמדים על
Xcode הוא, ובמיוחד בסוויפט,

639
00:35:43,720 --> 00:35:47,450
הוא שיש לנו זה
דבר נקרא משחקים.

640
00:35:47,450 --> 00:35:51,470
ומשחקים הוא
לא בכל יישום iOS.

641
00:35:51,470 --> 00:35:54,751
אבל זה מאפשר לך להתנסות
עם סוויפט בצורה קלה מאוד.

642
00:35:54,751 --> 00:35:56,000
ניתן להקליד כל הקוד שלך.

643
00:35:56,000 --> 00:35:58,140
זה יפה תחביר מודגש כאן.

644
00:35:58,140 --> 00:36:01,600
כאשר אתה יוצר קובץ חדש, הוא יבקש
אם ברצונך ליצור משחקים.

645
00:36:01,600 --> 00:36:08,720
אבל הדבר נחמד על משחקים
הוא שמצד הימין של החלון שלך,

646
00:36:08,720 --> 00:36:12,020
זה בעצם להראות לך
פלט מהקוד שלך.

647
00:36:12,020 --> 00:36:16,110
אז אם אני לגלול למטה, אנחנו יכולים לראות מה
הפלט של קווים שונים של קוד

648
00:36:16,110 --> 00:36:17,200
קורה בפועל להיות.

649
00:36:17,200 --> 00:36:19,850

650
00:36:19,850 --> 00:36:26,790
>> אז במקרה הזה, אנחנו הולכים
לשנות כיוונים קצת

651
00:36:26,790 --> 00:36:30,960
ולדבר על משהו שהוא באמת
חשוב דרך רמה גבוהה זה

652
00:36:30,960 --> 00:36:34,020
שסוויפט פועל, וזה
הוא הרעיון הזה של סגרים.

653
00:36:34,020 --> 00:36:36,960
ואתה כנראה כבר ראית את זה
קצת ב- JavaScript.

654
00:36:36,960 --> 00:36:40,770
לאלו מכם ש
נמצא בCS50, סגרים

655
00:36:40,770 --> 00:36:47,240
הם דרך פופולרית מאוד, טובה מאוד לעשות
דברים ברמה גבוהה בשפות מודרניות.

656
00:36:47,240 --> 00:36:50,270
אבל זה גם סוג של קשה ל
לעטוף את הראש סביב בפעם הראשונה.

657
00:36:50,270 --> 00:36:52,269
אז אם אתה מסתכל על זה
פעם ראשונה, זה בסדר.

658
00:36:52,269 --> 00:36:56,740
רק תסתכל על קוד המקור ולראות
אם אתה יכול להבין את זה בבית.

659
00:36:56,740 --> 00:37:01,050
>> אז במקרה הזה, נניח ש
רוצה ליצור הרבה מעריכים

660
00:37:01,050 --> 00:37:04,134
עם כמה ערך קבוע.

661
00:37:04,134 --> 00:37:05,800
אז במקרה הזה אני יכול ליצור פונקציה.

662
00:37:05,800 --> 00:37:09,270
אני הולך לקרוא לזה כוחו של
2 שמטרתו יחידה בחיים

663
00:37:09,270 --> 00:37:15,770
הוא לקחת כמה קלט וכפול
זה, ולהחזיר ערך ש.

664
00:37:15,770 --> 00:37:21,210
שים לב שאני כאן
קבלת סוג אחד של נתונים.

665
00:37:21,210 --> 00:37:23,137
זה הולך להיות משתנה בשם x.

666
00:37:23,137 --> 00:37:23,970
זה מסוג זוגי.

667
00:37:23,970 --> 00:37:26,190
ואני הולך לחזור זוגי כאן.

668
00:37:26,190 --> 00:37:29,100
ואני רק הולך לעשות
מאוד, בכנות, די

669
00:37:29,100 --> 00:37:32,650
דרך נאיבית של הכפלת ערך זה.

670
00:37:32,650 --> 00:37:35,600
ואני אראה לך למה זה
שימושי רק שני.

671
00:37:35,600 --> 00:37:40,418
>> שים לב שכאן יש לנו מגוון זה
שׁוּב. משהו ב1, נקודה

672
00:37:40,418 --> 00:37:44,130
נקודת נקודה, 2, מה שאומר ש
לולאה זו תפעל פעמיים.

673
00:37:44,130 --> 00:37:46,480
אבל זה מייצג משתנה דמי.

674
00:37:46,480 --> 00:37:49,650
זה אומר שאני לא באמת הולך
אשתמש בכל מקום שמשתנה

675
00:37:49,650 --> 00:37:51,070
בתוך לולאה זה.

676
00:37:51,070 --> 00:37:55,380
אני רק רוצה את הקו הזה
קוד לרוץ פעמיים,

677
00:37:55,380 --> 00:37:58,980
ללא צורך לדעת
הערך של טווח זה.

678
00:37:58,980 --> 00:38:02,570
>> אז במקרה הזה אני רץ תוצאה
פעמים x פעמיים, אשר למעשה

679
00:38:02,570 --> 00:38:06,560
משמעות הדבר היא שאני מתישב ערך זה.

680
00:38:06,560 --> 00:38:10,230
וזה קורה לי
עובד כפי שהיינו מצפה.

681
00:38:10,230 --> 00:38:16,410
כוחה של 2, עובר ערך של
2.0 נותן לנו תפוקה של 4.

682
00:38:16,410 --> 00:38:18,810
3.2 עבודות ל10.24.

683
00:38:18,810 --> 00:38:22,660
>> עכשיו אנחנו יכולים לעשות דומים
דבר לכוח של 3.

684
00:38:22,660 --> 00:38:25,330
אבל עכשיו לשנות רק את הטווח.

685
00:38:25,330 --> 00:38:28,840
למשתנה דמי 1
דרך 3, להכפיל פי 3,

686
00:38:28,840 --> 00:38:29,830
ולעשות את אותו הדבר.

687
00:38:29,830 --> 00:38:32,240
>> אז זה עלול להרגיש קצת מאולץ.

688
00:38:32,240 --> 00:38:34,270
אבל יש חשוב
דבר כאן ש

689
00:38:34,270 --> 00:38:37,770
הוא שמסתכל על אלה
שתי פונקציות, יש

690
00:38:37,770 --> 00:38:43,600
רק דבר אחד זה שונה,
שערך זה בטווח.

691
00:38:43,600 --> 00:38:46,910
הכל על שני אלה אחר
פונקציות, עוצמה של 3 וכוח של 2,

692
00:38:46,910 --> 00:38:50,440
הם, למעשה, זהים משום ש
הם עובדים באותה הצורה.

693
00:38:50,440 --> 00:38:53,460
>> לכן בשלב זה, קטן
פעמון אזעקה צריך ללכת משם.

694
00:38:53,460 --> 00:38:56,200
אני מקווה שמה שאתה אומר,
אתה יודע, זה מרגיש קצת

695
00:38:56,200 --> 00:38:59,250
כמו שכפול של מאמץ.

696
00:38:59,250 --> 00:39:02,950
אולי יש דרך שאני היית עושה
תוכל לתמצת את כל זה

697
00:39:02,950 --> 00:39:06,630
ולספק פונקציה
או ליצור פונקציה ש

698
00:39:06,630 --> 00:39:11,550
עושה בדיוק מה שאני רוצה בלי
צורך להקליד את זה באופן מפורש.

699
00:39:11,550 --> 00:39:15,732
וזה מה שהכח
של סגירה מאפשרת לנו לעשות.

700
00:39:15,732 --> 00:39:16,940
אז בואו נסתכל על זה.

701
00:39:16,940 --> 00:39:18,700
ואני לבלות כמה
דקות על זה, כי זה

702
00:39:18,700 --> 00:39:20,310
הוא די חשוב לסוויפט.

703
00:39:20,310 --> 00:39:22,900
אנחנו רואים את זה כל הזמן.

704
00:39:22,900 --> 00:39:24,550
אנחנו הולכים להגדיר פונקציה.

705
00:39:24,550 --> 00:39:26,380
זה הולך להיקרא powerOf.

706
00:39:26,380 --> 00:39:29,470
זה הולך לקבל
פרמטר שנקרא y של Int הסוג.

707
00:39:29,470 --> 00:39:32,220
אבל תסתכל על סוג התמורה.

708
00:39:32,220 --> 00:39:38,730
סוג השיבה הוא, ב
סוגריים, זוגיים חץ כפול.

709
00:39:38,730 --> 00:39:43,370
מה שאומר שפונקציה זו,
powerOf זה פונקציה,

710
00:39:43,370 --> 00:39:46,550
חוזר לתפקד.

711
00:39:46,550 --> 00:39:50,845
כי הוא מקבל זוגי
וחוזר זוגי.

712
00:39:50,845 --> 00:39:53,720
כך שאולי נשמעים סוג של משוגע,
אבל בואו לגלול למטה קצת

713
00:39:53,720 --> 00:39:55,060
ולחפש כדי לראות מה קורה.

714
00:39:55,060 --> 00:39:57,910
אנחנו בתוך של powerOf פונקציה זו.

715
00:39:57,910 --> 00:40:00,760
אנחנו יוצרים פונקציה חדשה
נקרא exponentiator,

716
00:40:00,760 --> 00:40:02,900
אבל זה לא משנה מה זה.

717
00:40:02,900 --> 00:40:06,410
>> שימו לב שיש ל
ערך קלט של x.

718
00:40:06,410 --> 00:40:09,910
וזה לוקח בחדר זוגי
וחוזר זוגי.

719
00:40:09,910 --> 00:40:16,320
וזה אותו הקוד ש
ראה לעיל, פרט לכך שהערך של 2

720
00:40:16,320 --> 00:40:20,060
או את הערך של 3, ש
הגבול העליון בטווח ש,

721
00:40:20,060 --> 00:40:23,210
הוחלף ב
ערך זה של y, ש

722
00:40:23,210 --> 00:40:27,230
היה הפרמטר הראשוני
של פונקצית powerOf.

723
00:40:27,230 --> 00:40:31,700
ובשלב זה, אנחנו
לחזור exponentiator.

724
00:40:31,700 --> 00:40:33,345
אנחנו חוזרים לתפקד.

725
00:40:33,345 --> 00:40:36,300

726
00:40:36,300 --> 00:40:39,550
>> זה כמו סוג של תקיעת מוח קטנה.

727
00:40:39,550 --> 00:40:44,360
אבל בואו נדמיין מה קורה
כאשר אני קורא פונקציה זו powerOf

728
00:40:44,360 --> 00:40:47,610
ותעבור לזה ערך כלשהו כמו 2.

729
00:40:47,610 --> 00:40:50,020
מה שזה אומר הוא ש
עכשיו יש לי הערך

730
00:40:50,020 --> 00:40:55,130
2 לy, מה שאומר שערך זה
y בפונקציה זו exponentiator

731
00:40:55,130 --> 00:40:56,410
יהיה הערך ש2.

732
00:40:56,410 --> 00:41:01,290
אבל אני חוזר זה
פונקצית exponentiator.

733
00:41:01,290 --> 00:41:05,900
>> אז שם לב מה סוויפט אומר אני
יצר במקרה זה.

734
00:41:05,900 --> 00:41:10,550
בואו הכיכר הגדרה, זה
פונקציה שמקבלת זוגי

735
00:41:10,550 --> 00:41:12,610
ומחזיר זוגי.

736
00:41:12,610 --> 00:41:16,590
אני יצרתי פונקציה
שמשהו ריבועים

737
00:41:16,590 --> 00:41:19,782
באמצעות מנגנון זה ממש כאן.

738
00:41:19,782 --> 00:41:22,490
ובאמת מה שקורה הוא
שהוא חוזר בפונקציה זו

739
00:41:22,490 --> 00:41:26,390
exponentiator, אבל ערך זה
y הוא עטוף בתוכו.

740
00:41:26,390 --> 00:41:31,080
אז עכשיו בכל פעם שאני משתמש בזה
משתנה או קבוע הזה שנקרא

741
00:41:31,080 --> 00:41:35,180
כיכר, זה שזה הולך
להתנהג כפונקציה.

742
00:41:35,180 --> 00:41:39,960
ואז אני יכול ואז להתקשר משתנה ש
כמו שאני מכנה פונקציה,

743
00:41:39,960 --> 00:41:43,830
ולהעביר לתוכו מספר,
כמו במקרה זה 3.

744
00:41:43,830 --> 00:41:45,910
ואז אני יהיה בריבוע ערך זה.

745
00:41:45,910 --> 00:41:53,340
3 יהיו בריבוע אז
הפך 9, כפי שניתן לראות כאן.

746
00:41:53,340 --> 00:41:56,530
>> באמת מטורף, אבל זה עכשיו
מאפשר לי את ההזדמנות

747
00:41:56,530 --> 00:41:59,040
כדי ליצור פונקציות powerOf אחרות.

748
00:41:59,040 --> 00:42:03,680
כמו שאני יכול להגיד, בסדר, גם עכשיו אני רוצה
כדי ליצור פונקציה חדשה, powerOf (3),

749
00:42:03,680 --> 00:42:06,290
ולאחסן את זה ב
קובייה בשם קבועה.

750
00:42:06,290 --> 00:42:10,220
ועכשיו קובייה הולכת להיות
פונקציה נפרדת שאז תהיה

751
00:42:10,220 --> 00:42:14,800
לקחת קצת ערך כקלט וקובייה ש
ערך כפי שאנו יכולים לראות בשורה התחתונה

752
00:42:14,800 --> 00:42:16,420
כאן.

753
00:42:16,420 --> 00:42:18,590
קובייה של 2 הולכת לגרום 8.

754
00:42:18,590 --> 00:42:21,330

755
00:42:21,330 --> 00:42:22,680
>> דברים אני מקווה שדי מסודרים.

756
00:42:22,680 --> 00:42:25,920
אף פעם לא ראו את זה קודם.

757
00:42:25,920 --> 00:42:29,990
אני ממליץ לך לבדוק את הסגרים
ולחקור את זה קצת יותר.

758
00:42:29,990 --> 00:42:33,570
זה דברים ממש חזקים שאנו רואים הרבה
ב- JavaScript וכמה שפות אחרות.

759
00:42:33,570 --> 00:42:37,160
זה ממש חיוני ל
הבנת ממשקי API, כמו גם

760
00:42:37,160 --> 00:42:38,620
שנגיע במרחק שני.

761
00:42:38,620 --> 00:42:39,456
כֵּן?

762
00:42:39,456 --> 00:42:43,740
>> קהל: כאשר אתה עושה
powerOf (2), סוגריים, ולאחר מכן

763
00:42:43,740 --> 00:42:48,764
סוגריים אחר, input-- אחר
אתה בעצם מחליף את הכיכר.

764
00:42:48,764 --> 00:42:50,930
דן AMRMENDARIZ: אז לחפש
בשורה האחרון כאן.

765
00:42:50,930 --> 00:42:55,930
זה בעצם לגמרי אפשרי ל
לעשות את זה כמו שאתה הציע שרשור.

766
00:42:55,930 --> 00:43:00,990
אז powerOf (5) אומר שאנחנו הולכים
יש exponentiator של 5 עד כאן.

767
00:43:00,990 --> 00:43:04,160
אז זה בעצם הולך להיות
אותו דבר כמו 4 לכח החמישי,

768
00:43:04,160 --> 00:43:07,200
בגלל שיצרנו exponentiating
לתפקד לכח החמישי,

769
00:43:07,200 --> 00:43:09,920
ואנחנו עוברים ל
המתפקד הערך 4.

770
00:43:09,920 --> 00:43:12,619
ואנחנו מקבלים ערך ש
שאנו מצפים, 1024.

771
00:43:12,619 --> 00:43:14,785
קהל: וזה לא
שם, כך שזה עושה את זה קל יותר

772
00:43:14,785 --> 00:43:16,570
לקרוא, הכיכר מה.

773
00:43:16,570 --> 00:43:17,903
>> דן AMRMENDARIZ: נכון, בדיוק.

774
00:43:17,903 --> 00:43:21,120
אז לפני שאני פשוט לשים אותו
לקבוע כאן כל כך

775
00:43:21,120 --> 00:43:23,808
שזה עשה את זה קל להשתמש בשם זה.

776
00:43:23,808 --> 00:43:24,308
כֵּן?

777
00:43:24,308 --> 00:43:26,942
>> קהל: בהקשר זה
powerOf, זה חלק

778
00:43:26,942 --> 00:43:30,774
של שפת תכנות
בניגוד לדרך בה אתה

779
00:43:30,774 --> 00:43:33,952
חושב על powerOf ב[ לא ברור]?

780
00:43:33,952 --> 00:43:35,660
דן AMRMENDARIZ: אז
במקרה זה, powerOf

781
00:43:35,660 --> 00:43:39,280
הוא פשוט השם
פונקציה שהגדרתי כאן.

782
00:43:39,280 --> 00:43:41,801
אז זה לא טבוע
לשפה עצמה,

783
00:43:41,801 --> 00:43:43,550
אך במקום זאת, זה רק
פונקציה שיש

784
00:43:43,550 --> 00:43:45,628
שם זה כי אני נותן לו את השם הזה.

785
00:43:45,628 --> 00:43:48,770

786
00:43:48,770 --> 00:43:51,920
כל שאלות אחרות?

787
00:43:51,920 --> 00:43:52,800
בסדר.

788
00:43:52,800 --> 00:43:54,750
>> עכשיו זה נהדר.

789
00:43:54,750 --> 00:43:58,170
אבל אתה לא הולך לראות
הרבה פונקציות סגר ש

790
00:43:58,170 --> 00:44:03,440
הם כזה שבו אתה מגדיר, בתוך
של פונקציה אחת, פונקציה אחרת.

791
00:44:03,440 --> 00:44:04,320
ואתה יכול לעשות את זה.

792
00:44:04,320 --> 00:44:06,430
אבל זה סוג של לא
באמת הכרחי, נכון?

793
00:44:06,430 --> 00:44:09,189
כמו למה אני מגדיר את זה
exponentiator נקרא פונקציה

794
00:44:09,189 --> 00:44:10,480
ולאחר מכן להחזיר אותו באופן מיידי.

795
00:44:10,480 --> 00:44:15,220
למה אני לא יכול פשוט מייד
לחזור בפונקציה זו?

796
00:44:15,220 --> 00:44:18,890
>> ולמעשה, זה בדיוק
הרעיון מאחורי מושג שנקרא

797
00:44:18,890 --> 00:44:22,410
פונקציות אנונימי, שבו
פונקציות אנונימי לא ממש

798
00:44:22,410 --> 00:44:25,270
יש שם כי הם
לא צריך להיות אחד.

799
00:44:25,270 --> 00:44:28,700
ולכן במקרה זה, ב7 ב,
אנחנו יכולים למצוא בדיוק את זה.

800
00:44:28,700 --> 00:44:31,470
זה כל אותו הקוד,
עושה בדיוק את אותו הדבר,

801
00:44:31,470 --> 00:44:35,570
אבל עכשיו אנחנו כבר שינינו אותו מעט כל כך
שפונקציה powerOf זה מייד

802
00:44:35,570 --> 00:44:37,750
חוזר לתפקד.

803
00:44:37,750 --> 00:44:44,150
שים לב שלאחר חזרה,
יש הסוגר מסולסל פתוח.

804
00:44:44,150 --> 00:44:46,410
זה מצפה קלט זה זוגי.

805
00:44:46,410 --> 00:44:48,560
זה מצפה פלט שזוגי.

806
00:44:48,560 --> 00:44:52,175
ולאחר מכן במילים מפתח
מפריד את הקוד עצמו.

807
00:44:52,175 --> 00:44:53,550
אז זה פונקציה אנונימית.

808
00:44:53,550 --> 00:44:57,030
זה לא באמת יש שם, ואילו
לפני שנקרא exponentiator.

809
00:44:57,030 --> 00:45:00,229
אבל כפי שראינו, רק באמת
לא התייחס לexponentiator

810
00:45:00,229 --> 00:45:01,270
מחוץ לפונקציה ש.

811
00:45:01,270 --> 00:45:02,470
אז זה לא משנה.

812
00:45:02,470 --> 00:45:06,300
אז פונקציה אנונימית זה
מה שנקרא כי זה חסר שם,

813
00:45:06,300 --> 00:45:09,107
אבל זה עדיין בשימוש
בהקשר של קוד זה.

814
00:45:09,107 --> 00:45:13,690

815
00:45:13,690 --> 00:45:16,079
>> זוג אלה הבאים אני
הולך להמשיך בתקווה

816
00:45:16,079 --> 00:45:17,370
נושבת הראש שלך קצת.

817
00:45:17,370 --> 00:45:20,410
אנחנו יכולים לפשט את זה עוד יותר.

818
00:45:20,410 --> 00:45:24,490
כי כפי שהיה בתבונה
ציין קודם לכן,

819
00:45:24,490 --> 00:45:29,100
אולי אנחנו באמת יודעים, על ידי
הסיק מקוד זה, מה

820
00:45:29,100 --> 00:45:31,750
הפלט של קוד זה הולך להיות.

821
00:45:31,750 --> 00:45:38,180
ואכן, בפונקציה אנונימית זה,
אנחנו יכולים למעשה להסיק את סוגי הנתונים.

822
00:45:38,180 --> 00:45:41,650
>> אז בזה, אנחנו כבר לא
צריך להגדיר במפורש

823
00:45:41,650 --> 00:45:44,850
הסוג של נתונים זה להיות
קלט ופלט מפונקציה זו

824
00:45:44,850 --> 00:45:45,890
במשך כמה סיבות.

825
00:45:45,890 --> 00:45:51,390
אחת מהן הוא שאנחנו כבר מוגדרים, עד ב
אב טיפוס של פונקצית התוחם,

826
00:45:51,390 --> 00:45:55,770
איזה סוג של מידע זה בעילום שם
פונקציה צריכה קלט ופלט.

827
00:45:55,770 --> 00:45:57,900
ומן הצד השני, אנחנו
ניתן להסיק מהקוד

828
00:45:57,900 --> 00:46:01,930
כאן שאנחנו מקבלים
קלט שהוא מהסוג זוגי

829
00:46:01,930 --> 00:46:03,670
וחוזר זוגי.

830
00:46:03,670 --> 00:46:07,890
>> שים לב שכאן יש לנו לא באופן מפורש
הגדיר את השמות של הטיעונים

831
00:46:07,890 --> 00:46:11,220
פונקציה זו מקבלת.

832
00:46:11,220 --> 00:46:16,180
וכך אנו רואים שאנו יכולים להתייחס ל
פרמטרים אלו המשתמשים 0 $, $ 1,

833
00:46:16,180 --> 00:46:20,140
כך הלאה וכך הלאה, בהתאם ל
מספר הפרמטר שמשמש

834
00:46:20,140 --> 00:46:20,850
בפונקציה זו.

835
00:46:20,850 --> 00:46:23,370

836
00:46:23,370 --> 00:46:29,740
>> זה משהו שאתה הולך
לראות הרבה הוא הסוגר מסולסל פתוח זה

837
00:46:29,740 --> 00:46:32,797
הגדרה ואחריו
0 $, ולאחר מכן כמה פעולה,

838
00:46:32,797 --> 00:46:34,130
ולאחר מכן הסוגר מסולסל סגור.

839
00:46:34,130 --> 00:46:38,630
כלומר פונקציה אנונימית
שמבצע פעולה זו.

840
00:46:38,630 --> 00:46:42,940
יש לו פרמטר שבו זה
זה הסוג הוא מוסק.

841
00:46:42,940 --> 00:46:44,860
כי הפרמטר הראשון הוא $ 0.

842
00:46:44,860 --> 00:46:49,010
וכמה היא פעולה
קורה שב$ 0.

843
00:46:49,010 --> 00:46:52,100
>> קהל: אז סימן הדולר
משמעות פרמטר בעצם,

844
00:46:52,100 --> 00:46:53,429
ו0 פירוש הראשון?

845
00:46:53,429 --> 00:46:54,720
דן ARMENDARIZ: זה נכון.

846
00:46:54,720 --> 00:46:59,100
אז סימן הדולר בעצם אומר
פרמטר, ו0 הפירוש ראשון.

847
00:46:59,100 --> 00:47:02,760
אבל זה עובד באופן ספציפי ב
מקרה זה שבו אני לא בשם

848
00:47:02,760 --> 00:47:07,940
הטיעונים בפונקציה אנונימית שלי.

849
00:47:07,940 --> 00:47:11,119
>> קהל: האם פרל או משהו שיש לי
סימן זה דולר, דולר 0 שם?

850
00:47:11,119 --> 00:47:12,702
דן ARMENDARIZ: האם ש, אני מצטער?

851
00:47:12,702 --> 00:47:15,360
קהל: האם יש לי פרל
דולר זה 0, דולר 1--

852
00:47:15,360 --> 00:47:17,318
דן ARMENDARIZ: אני לא
מוכר מדי עם פרל,

853
00:47:17,318 --> 00:47:21,340
אבל PHP מה שמגדיר משתנים
המבוסס על סימני דולר.

854
00:47:21,340 --> 00:47:26,120
וייתכן שיש כמה שפות
שתומכים בתכונות כמו זה.

855
00:47:26,120 --> 00:47:28,240
למעשה, סוויפט לווה
הרבה תכונות כמו זה

856
00:47:28,240 --> 00:47:29,489
מהרבה שפות אחרות.

857
00:47:29,489 --> 00:47:32,380
אנו רואים רמזים לפייתון בזה.

858
00:47:32,380 --> 00:47:35,800
הגדרה זו של סוג
נראה לבוא מOCaml.

859
00:47:35,800 --> 00:47:38,932
ויש לנו רק חבורה של כל
דברים מהרבה שפות שונות.

860
00:47:38,932 --> 00:47:40,640
זה אחד נחמד
דברים על סוויפט

861
00:47:40,640 --> 00:47:43,390
הוא שזה לוקח הרבה הטוב ביותר
רעיונות מחבורה של שפות

862
00:47:43,390 --> 00:47:47,229
וכף נעליים כולם יחד
לשפה אחת סופר.

863
00:47:47,229 --> 00:47:49,520
למעשה, אם תרשה לי
תמשיך נושבת הראש שלך,

864
00:47:49,520 --> 00:47:51,000
אז אנחנו כבר עושים את כל זה.

865
00:47:51,000 --> 00:47:56,690
אנחנו יכולים אולי לפשט את זה קצת
קצת על ידי שהבין כי, כמובן,

866
00:47:56,690 --> 00:48:02,120
יש סוויפט exponentiating
פונקציה מובנית ב.

867
00:48:02,120 --> 00:48:04,660
אם אני מייבא דרווין, ש
רק הספרייה ש

868
00:48:04,660 --> 00:48:09,680
תכונות pow פונקציה שנקראת זה, עכשיו
אני יכול לפשט הכח של פונקציה שלי

869
00:48:09,680 --> 00:48:11,830
להיות הבא.

870
00:48:11,830 --> 00:48:15,860
זה הולך להיות חוזר
פונקציה אנונימית זה.

871
00:48:15,860 --> 00:48:17,950
>> אבל תסתכל על כמה פשוט זה עכשיו.

872
00:48:17,950 --> 00:48:22,780
זה פונקציה אנונימית ש
מקבל איזה סוג של נתונים,

873
00:48:22,780 --> 00:48:26,600
וזה הולך להיות אחד
טיעון במיוחד,

874
00:48:26,600 --> 00:48:29,320
הפניה ב 0 $ שהם מהסוג זוגי.

875
00:48:29,320 --> 00:48:32,680
זה הולך לחזור סוג זוגי.

876
00:48:32,680 --> 00:48:35,760
אבל הצהרת התמורה
עכשיו משתמע.

877
00:48:35,760 --> 00:48:39,990
>> וזה סגנון מדויק זה ש
מאוד, מאוד נפוץ בסוויפט,

878
00:48:39,990 --> 00:48:40,790
בכל המקום.

879
00:48:40,790 --> 00:48:43,190
אנחנו הולכים לראות את זה
כל הזמן בסוויפט.

880
00:48:43,190 --> 00:48:46,150
אז אני מראה את כל זה ל
שלך בגלל תחביר זה.

881
00:48:46,150 --> 00:48:49,070
זה נפוץ מאוד
כדי לראות, מה שאומר ש

882
00:48:49,070 --> 00:48:51,420
היא פונקציה אנונימית
שמבצע

883
00:48:51,420 --> 00:48:54,640
כמה ניתוח בטענות אלה.

884
00:48:54,640 --> 00:48:56,940
ויש תמורה סמויה.

885
00:48:56,940 --> 00:49:01,850
אז זה בהחלט אותו הדבר
לנו להגיד את זה, ממש כאן.

886
00:49:01,850 --> 00:49:05,730

887
00:49:05,730 --> 00:49:08,150
>> בגלל זה מתולתל
הסוגר הוא פונקציה,

888
00:49:08,150 --> 00:49:10,480
אנחנו לבצע פעולה זו
על הטענה הראשונה.

889
00:49:10,480 --> 00:49:12,170
אנחנו הולכים לחזור ש.

890
00:49:12,170 --> 00:49:14,815
אבל תמורה חיצונית זה
חוזר שכל פונקציה,

891
00:49:14,815 --> 00:49:19,855
שהפונקציה אנונימית כל
כי אנחנו כבר עתה יצרנו.

892
00:49:19,855 --> 00:49:21,689
כל שאלות אחרות?

893
00:49:21,689 --> 00:49:23,980
בסדר, אני לא יודע אם
אתם מוכנים לזה,

894
00:49:23,980 --> 00:49:27,455
אבל אנחנו יכולים ללכת אפילו יותר מטורפים עם סוויפט.

895
00:49:27,455 --> 00:49:28,560
אתה מוכן?

896
00:49:28,560 --> 00:49:29,930
אישור, זה נהדר.

897
00:49:29,930 --> 00:49:35,310
>> עכשיו יש לנו למעשה את היכולת
ל, בסוויפט, בגלל איך מודולרי

898
00:49:35,310 --> 00:49:39,650
ואיך המבוסס פרוטוקול זה, ל
להגדיר המפעילים מפחיד שלנו.

899
00:49:39,650 --> 00:49:44,060
כמו במקרה זה, לא היה לנו
מפעיל לexponentiation-- גם,

900
00:49:44,060 --> 00:49:47,990
לביצוע סמכויותיו של משהו.

901
00:49:47,990 --> 00:49:53,632
אבל אני יכול, בסוויפט, להגדיר חדש
מפעיל שעושה בדיוק את זה.

902
00:49:53,632 --> 00:49:55,590
אז במקרה הזה יש
חבורה של תחביר כאן.

903
00:49:55,590 --> 00:49:59,980
ואני נאפשר לך להסתכל על זה
בבית כשאתה מסתכל על זה.

904
00:49:59,980 --> 00:50:06,890
אבל אנחנו מגדירים infix זה
מפעיל, **, אשר לאחר מכן מאפשר לנו,

905
00:50:06,890 --> 00:50:09,840
על ידי הגדרה מה ש
פונקציה ** למעשה

906
00:50:09,840 --> 00:50:15,010
אין, לקבל יד שמאל
צד וצד ימין,

907
00:50:15,010 --> 00:50:21,190
ולאחר מכן להחזיר את המעריך של ש
צד שמאל לצד ימין.

908
00:50:21,190 --> 00:50:24,850
>> אז עכשיו כולי פתאומי
יצר מונה חדש.

909
00:50:24,850 --> 00:50:29,490
אז 2 ** 3 פירוש 2 בחזקה השלישית.

910
00:50:29,490 --> 00:50:34,420
[SOUND נושבת MIND] זה על ידי
עצמו צריך לגרום לך להיות כמו,

911
00:50:34,420 --> 00:50:37,960
אישור, ג הבורג אני הולך
סוויפט כל הדרך.

912
00:50:37,960 --> 00:50:38,740
זה נהדר.

913
00:50:38,740 --> 00:50:40,140
זה די מדהים.

914
00:50:40,140 --> 00:50:42,240
>> אמנם זה הוא דוגמא מצוינת.

915
00:50:42,240 --> 00:50:45,570
אבל יש לי לא פעם אחת מחוץ
של דוגמא זו למעשה

916
00:50:45,570 --> 00:50:46,800
הגדרת המפעיל שלי.

917
00:50:46,800 --> 00:50:49,710
אבל עדיין, זה מראה
הרבה הכח של סוויפט

918
00:50:49,710 --> 00:50:54,050
ולמה זה בעצם
באמת מאוד מגניב.

919
00:50:54,050 --> 00:50:55,832
אישור, כן?

920
00:50:55,832 --> 00:50:57,790
קהל: אם אתה
הגדרת המפעיל שלך,

921
00:50:57,790 --> 00:51:02,940
איך אתה יודע שאתה לא בטעות
לנסות וליצור מפעיל זה

922
00:51:02,940 --> 00:51:06,040
במקום כלשהו ב- C, כמו
חבוי אי שם בסוויפט,

923
00:51:06,040 --> 00:51:12,210
כמו מעורפל אחד שאתה
אולי לא ראיתי לפני כן.

924
00:51:12,210 --> 00:51:15,050
>> דן ARMENDARIZ: אז אם אתה מנסה
להגדיר מפעילים שלך,

925
00:51:15,050 --> 00:51:20,970
יש את הסיכון של הגדרה
אחד על מפעיל הקיים.

926
00:51:20,970 --> 00:51:24,870
כי נכנס רמת הפירוט ש
אני לא חושב שיש לנו זמן לעבור על.

927
00:51:24,870 --> 00:51:27,620
אבל זה סיכון.

928
00:51:27,620 --> 00:51:31,320
וכי היא למעשה הסיבה מדוע מאוד
אני לא השתמשתי בסמל תו, ש

929
00:51:31,320 --> 00:51:36,210
כאשר אנחנו מקלידים את כוח, אנחנו בדרך כלל
להשתמש 4 תו קטן 5 או משהו

930
00:51:36,210 --> 00:51:40,560
כמו ש, רק כשאנחנו
Gchatting חברים או משהו כזה.

931
00:51:40,560 --> 00:51:43,660
אבל במקרה זה, שלמעשה
היה גורם להתנגשות.

932
00:51:43,660 --> 00:51:46,450
וכך נמנעתי מזה רק בגלל ש
יצאתי לי לדעת במקרה זה

933
00:51:46,450 --> 00:51:50,430
שיגרום התנגשות ש.

934
00:51:50,430 --> 00:51:52,270
>> בסדר.

935
00:51:52,270 --> 00:51:55,080
עכשיו למרבה הצער, ל
שבע דקות האחרונות,

936
00:51:55,080 --> 00:51:57,410
אני צריך לשמור על תקיעה
הדעה שלך קצת.

937
00:51:57,410 --> 00:52:00,230
לאפשר אז אני אראה לך
כמה דברים אחרים גם כן.

938
00:52:00,230 --> 00:52:03,710
>> אנחנו כבר הראינו לך את הרעיון הזה של
יש פונקציות אנונימי אלה,

939
00:52:03,710 --> 00:52:07,040
סגרים אלה שמאפשרים לך
סוג של פונקציות לעבור מסביב.

940
00:52:07,040 --> 00:52:08,100
אתה יכול להחזיר אותם.

941
00:52:08,100 --> 00:52:09,490
אתה יכול לתפעל אותם.

942
00:52:09,490 --> 00:52:11,790
אתה יכול לעשות כל מיני דברים מטורפים.

943
00:52:11,790 --> 00:52:14,850
>> אבל דבר אחד שאחר
קורה להיות שימושי

944
00:52:14,850 --> 00:52:19,740
היא היכולת, בניגוד
לחוזר פונקציות אלה

945
00:52:19,740 --> 00:52:25,146
בפונקציה, להעביר פונקציה
כפרמטר לפונקציה אחרת.

946
00:52:25,146 --> 00:52:30,430
ייתכן שאתה חושב גם מדוע על פני כדור הארץ
הייתי רוצה לעשות משהו כזה?

947
00:52:30,430 --> 00:52:33,660
>> ובכן, נניח שאני רוצה
לקחת מפעיל זה שאני

948
00:52:33,660 --> 00:52:40,260
עבד כל כך קשה כדי ליצור וליישם
שלו לחבורה של מספרים שונים

949
00:52:40,260 --> 00:52:41,770
במערך.

950
00:52:41,770 --> 00:52:46,700
אז במקרה הזה יש לי מערך של
integers-- 1, 4, 7, 2, 5, 10, 56.

951
00:52:46,700 --> 00:52:48,080
ואני רוצה להכפיל את כולם.

952
00:52:48,080 --> 00:52:50,430
הדרך שאנחנו בדרך כלל הייתם
לעשות את זה הוא רק כדי לכתוב

953
00:52:50,430 --> 00:52:53,440
פשוט ללולאה ש
סובב מעל כולם

954
00:52:53,440 --> 00:52:57,140
ולבצע איזשהו
מבצע רבוע עליהם,

955
00:52:57,140 --> 00:53:02,700
הזנת ערכים החדשים אלה לתוך חדשים
משתנה, או לייתר דיוק, מערך חדש כאן.

956
00:53:02,700 --> 00:53:07,370
וערך התפוקה של
תוצאה היא אז כל מערכים אלה,

957
00:53:07,370 --> 00:53:10,200
או לייתר דיוק את כל אלה
אלמנטים עכשיו בריבוע.

958
00:53:10,200 --> 00:53:12,680
>> ואנחנו יכולים לעשות את אותו הדבר
דבר לעִקוּב זה,

959
00:53:12,680 --> 00:53:15,360
אבל פעמון אזעקה קטן
צריך ללכת מ

960
00:53:15,360 --> 00:53:17,360
אומר שאולי יש
הדרך שהיית חלק

961
00:53:17,360 --> 00:53:19,860
תוכל לפשט את זה קצת.

962
00:53:19,860 --> 00:53:21,130
ואכן יש.

963
00:53:21,130 --> 00:53:25,320
מה אם היינו יכול ליצור
פונקציה המאפשרת לנו

964
00:53:25,320 --> 00:53:28,350
לקבל, כטורף, פונקציה?

965
00:53:28,350 --> 00:53:30,350
אז במקרה הזה, לקחת
מסתכל על טענות אלה.

966
00:53:30,350 --> 00:53:33,220
אנחנו הולכים לקבל את הרשימה של זוגות.

967
00:53:33,220 --> 00:53:35,030
ואז אנחנו הולכים
לקבל פונקציה

968
00:53:35,030 --> 00:53:40,990
במשתנה שנקראת F כי הוא הולך
לקחת זוגי ולחזור זוגי.

969
00:53:40,990 --> 00:53:43,320
וכל הפלט
של כל פונקציה זו

970
00:53:43,320 --> 00:53:47,310
ממפה נקראת הולכת
להחזיר מערך שנקרא כפול.

971
00:53:47,310 --> 00:53:52,380
>> מה זה אז יאפשר לי
לעשות הוא לחזר על רשימה ש

972
00:53:52,380 --> 00:53:56,350
ולעשות את אותו הדבר, אבל עכשיו
תחול פונקציה שעל כל אחד

973
00:53:56,350 --> 00:53:58,970
של הערכים הבודדים ברשימה ש.

974
00:53:58,970 --> 00:54:00,750
אז אני לא ממש יודע מה הוא f.

975
00:54:00,750 --> 00:54:02,010
זה לא משנה לי.

976
00:54:02,010 --> 00:54:06,530
אבל כל עוד זה לוקח בחדר זוגי,
מבצע פעולה מסוימת על זה,

977
00:54:06,530 --> 00:54:08,640
ואז חוזר
זוגי, הייתי אז

978
00:54:08,640 --> 00:54:13,415
תוכל למפות פונקציה שפני
כל אלמנט ברשימה.

979
00:54:13,415 --> 00:54:16,270

980
00:54:16,270 --> 00:54:20,930
>> וזה סוג של תכנות הוא
פונקציות מסדר גבוהות יותר שנקראים,

981
00:54:20,930 --> 00:54:24,440
לאן אנחנו עוברים פונקציות
סביב כפרמטרים

982
00:54:24,440 --> 00:54:26,430
ולעשות דברים עם פונקציות.

983
00:54:26,430 --> 00:54:29,640
זה כמו סוג של לקיחה כל אלה
רעיונות שלמדנו בCS50

984
00:54:29,640 --> 00:54:31,390
ולוקח אותם סוג
של לרמה הבאה.

985
00:54:31,390 --> 00:54:34,140
וזה כל הדברים בסגנון CS51.

986
00:54:34,140 --> 00:54:37,080
ואז נלך לעומק
יותר בשיעורים כאלה.

987
00:54:37,080 --> 00:54:38,930
>> אבל זה גם
כי חשוב לנו כאן

988
00:54:38,930 --> 00:54:42,010
רואה הרבה פונקציות
המשמשים בסוויפט

989
00:54:42,010 --> 00:54:45,590
כי בעצם עושה
זה, שבו יש לנו

990
00:54:45,590 --> 00:54:48,300
כמה מספרים, כמה מערך של מספרים.

991
00:54:48,300 --> 00:54:50,850
אנחנו הולכים לעבור את זה
מערך לממפתנו.

992
00:54:50,850 --> 00:54:55,770
ואנחנו גם הולכים
עובר כמה פונקציה, ש

993
00:54:55,770 --> 00:54:57,950
אנחנו כבר הוגדרו כאן.

994
00:54:57,950 --> 00:54:59,690
זה הולך להיות מרובע.

995
00:54:59,690 --> 00:55:02,220
ואנחנו הולכים אז
לרבע את כל המספרים האלה

996
00:55:02,220 --> 00:55:04,710
ולאחסן את זה בתוצאה זו כאן.

997
00:55:04,710 --> 00:55:07,280

998
00:55:07,280 --> 00:55:11,000
>> אז המקרה הזה אנחנו כבר מוגדרים שלנו
פונקציה שנקראת ממפה.

999
00:55:11,000 --> 00:55:15,370
אבל הדבר הזה בדיוק הוא,
למעשה, בנה לסוויפט.

1000
00:55:15,370 --> 00:55:18,960
יש מגוון של
פונקציות הנקראות מפה.

1001
00:55:18,960 --> 00:55:21,520
יש פונקצית מפה,
יש להפחית פונקציה,

1002
00:55:21,520 --> 00:55:25,630
ויש פונקצית מסנן,
אשר למעשה להחיל פונקציות

1003
00:55:25,630 --> 00:55:30,782
לכל אלמנט ב
רשימה לשנות אותם בדרך כלשהי.

1004
00:55:30,782 --> 00:55:34,510
>> קהל: אז מכיוון שאתה משנה
הנתונים לפורמט אחר

1005
00:55:34,510 --> 00:55:36,134
דרך function--

1006
00:55:36,134 --> 00:55:37,050
דן ARMENDARIZ: ימין.

1007
00:55:37,050 --> 00:55:39,420
כן, אז הפונקציה
שאנחנו מקבלים

1008
00:55:39,420 --> 00:55:41,790
משנה את המידע בדרך מסוימת.

1009
00:55:41,790 --> 00:55:44,700
במקרה זה, היינו גם
מתישב זה, או שהיינו זה לפתור את קובייה,

1010
00:55:44,700 --> 00:55:50,060
או באמת, אנחנו יכולים לבצע
אין פעולה על זה בכלל.

1011
00:55:50,060 --> 00:55:54,150
>> אבל תן לי להראות לך אז איך זה
הולך להיראות בפועל.

1012
00:55:54,150 --> 00:55:56,681
ושוב, אני רץ
קצת זמן. אז אני לא

1013
00:55:56,681 --> 00:55:59,430
הולך להיות מסוגל לעבור על כל
של קוד המקור כאן בפירוט.

1014
00:55:59,430 --> 00:56:00,721
אבל אני ממליץ לך לעשות את זה.

1015
00:56:00,721 --> 00:56:03,850
אנחנו נפרסם אותו בהקדם
אפשרי לאחר שיחה זו.

1016
00:56:03,850 --> 00:56:07,610
>> אבל אם אתה תסתכל על זה,
תניח שיש לנו רשימה של מספרים,

1017
00:56:07,610 --> 00:56:10,260
מערך של מספרים בזה
מספרים נקראים משתנה.

1018
00:56:10,260 --> 00:56:16,670
אז אנחנו רוצים לבצע את זה
פעולת סינון על המספרים האלה.

1019
00:56:16,670 --> 00:56:19,730
אז המסנן הוא גבוה יותר
פונקציה כדי ש

1020
00:56:19,730 --> 00:56:24,660
מקבל מערך וגם פונקציה.

1021
00:56:24,660 --> 00:56:28,760
ועל כל אלמנט שב
מערך, הוא מבצע פונקציה ש.

1022
00:56:28,760 --> 00:56:31,990
>> אם זה חוזר פונקציה
נכון, זה שומר פריט ש.

1023
00:56:31,990 --> 00:56:36,100
אם הפונקציה שמחזירה שווא,
זה זורק פריט ש.

1024
00:56:36,100 --> 00:56:40,480
ואז זה מחזיר רשימה
כי אז הוא עשה את כל

1025
00:56:40,480 --> 00:56:44,360
של אותם הפריטים שסוננו.

1026
00:56:44,360 --> 00:56:47,150
>> אז במילים אחרת, זה הוא
אותו הרעיון, gradebook.

1027
00:56:47,150 --> 00:56:50,800
אולי יש לנו מגוון רחב של ציונים
למספרי ערך נקרא זה.

1028
00:56:50,800 --> 00:56:55,590
יכול להיות 100, ו- 70, ו
40, כן הלאה וכן הלאה.

1029
00:56:55,590 --> 00:56:59,110
מה המשמעות של זה הוא מסנן הודעה
כי זה הוא שסוכר תחבירי

1030
00:56:59,110 --> 00:57:01,310
לפונקציה אנונימית.

1031
00:57:01,310 --> 00:57:05,980
זה פונקציה אנונימית אומרת
כי הפרמטר שאני מקבל

1032
00:57:05,980 --> 00:57:09,690
הולך להיות, אם זה
הוא יותר מ -70,

1033
00:57:09,690 --> 00:57:15,837
אז זה יחזור אמיתי, כלומר,
פריט שיישמר במסנן זה.

1034
00:57:15,837 --> 00:57:17,920
אז בואו יהיה קצת
יותר קונקרטי על זה.

1035
00:57:17,920 --> 00:57:25,760
אם יש לי מערך של מספרים
וזה כולל 100, 70, ו -40,

1036
00:57:25,760 --> 00:57:29,730
אני מופיע במסנן זה
פעולה בכל אחד מאלה.

1037
00:57:29,730 --> 00:57:33,270
כך שראשון הוא ערך זה של 100.

1038
00:57:33,270 --> 00:57:36,770
100 גדול או שווה
70 הוא אמיתי, ש

1039
00:57:36,770 --> 00:57:41,950
משמעות הדבר היא כי 100 נשמר ב
עותק חדש של מערך זה.

1040
00:57:41,950 --> 00:57:44,290
גם 70 עוברים.

1041
00:57:44,290 --> 00:57:46,020
אבל 40 לא.

1042
00:57:46,020 --> 00:57:54,290
אז מה הוא חזר בpassingCount
הוא המערך של אלמנטים 100 ו70--

1043
00:57:54,290 --> 00:57:57,410
100, פסיק, 70.

1044
00:57:57,410 --> 00:57:59,870
אלה היו שני רק
פריטים שנשמרו.

1045
00:57:59,870 --> 00:58:03,740
וכך הסיבה שעברתי במהירות
הרבה סוג של סדר גבוה אלה

1046
00:58:03,740 --> 00:58:08,680
דברים בגלל זה הוא שנפוץ
דבר שתראה בסוויפט יפה

1047
00:58:08,680 --> 00:58:16,810
לעתים קרובות, מבצע פעולה מסוימת
באמצעות תחביר פונקציה אנונימית זה.

1048
00:58:16,810 --> 00:58:18,450
>> יש כמה דברים מגניבים.

1049
00:58:18,450 --> 00:58:24,730
מתגים הם באמת חזקים בסוויפט,
אני מתכוון בדיוק כמו משוגע, חזק מטורף.

1050
00:58:24,730 --> 00:58:28,250
אתה יכול להשתמש במתג, ו
למעשה אתה יכול ליישם אותם

1051
00:58:28,250 --> 00:58:33,160
לטווחים, שהוא סוג של משוגע,
ולעשות דברים מפוארים כמו ש.

1052
00:58:33,160 --> 00:58:37,540
>> אבל בדקות האחרונות,
אני רוצה לדלג קדימה די רחוק

1053
00:58:37,540 --> 00:58:46,940
ולהראות לך דוגמא ספציפית של איך
אנחנו יכולים ליצור ביישום iOS באמצעות סוויפט.

1054
00:58:46,940 --> 00:58:49,040
לכן, כאשר אתה עושה
זה, תצטרך לקחת

1055
00:58:49,040 --> 00:58:51,990
נראה at-- על אפל
תיעוד, הם

1056
00:58:51,990 --> 00:58:56,084
יש לי הרבה הדרכות ממש טובות
ליצירת היישום הראשון שלך.

1057
00:58:56,084 --> 00:58:58,250
ואני ממליץ לך לעשות
כי הם ייקחו אותך

1058
00:58:58,250 --> 00:59:04,110
דרך כל השלבים של מה בדיוק ל
לחץ על כדי ליצור יישום iOS.

1059
00:59:04,110 --> 00:59:07,290
>> אבל כאן יש לנו אפליקציה iOS זה.

1060
00:59:07,290 --> 00:59:10,960
וזה יישום די פשוט באמת.

1061
00:59:10,960 --> 00:59:13,840
אם אני מפעיל את זה, תן לי להראות
שלך מה שזה נראה.

1062
00:59:13,840 --> 00:59:19,480
כל זה בעצם עושה זה
מושך מהאינטרנט קובץ JSON

1063
00:59:19,480 --> 00:59:22,300
כי יש לי מאוחסן בשרת.

1064
00:59:22,300 --> 00:59:26,310
ושקובץ JSON
מגדיר תמונות המאפשרות

1065
00:59:26,310 --> 00:59:31,680
לי ואז לעבור, עליי
אפליקציה, תמונות מהשרת האינטרנט שלי.

1066
00:59:31,680 --> 00:59:32,880
>> אז יש לי כאן getNextImage.

1067
00:59:32,880 --> 00:59:37,100
הוא טוען תמונה מהאינטרנט,
ואז מציג אותו על המסך.

1068
00:59:37,100 --> 00:59:38,200
>> אז זה די פשוט.

1069
00:59:38,200 --> 00:59:41,550
אבל המטרה כאן היא להראות
לך איך אנחנו יכולים לשלב דברים

1070
00:59:41,550 --> 00:59:47,820
מהשבועות האחרונים של CS50
ליישום iOS בפועל.

1071
00:59:47,820 --> 00:59:53,140
במילים אחרות, אולי אחד מ
דברים שאתה רוצה לעשות

1072
00:59:53,140 --> 00:59:56,340
הוא להיות יישום iOS ש
יכול למשוך נתונים מהאינטרנט

1073
00:59:56,340 --> 00:59:59,070
ולהראות למשתמש קצת מידע.

1074
00:59:59,070 --> 01:00:03,130
זה לגמרי הנקודה
של קוד מקור זה כאן.

1075
01:00:03,130 --> 01:00:07,890
>> אז יש הרבה מה לומר על
איך לעשות את פיתוח iOS בפועל.

1076
01:00:07,890 --> 01:00:12,860
יש הרבה של תחביר מטורף
שלא ראו עדיין די

1077
01:00:12,860 --> 01:00:15,580
כמו בכיתה, מה הוא בעצם מעמד.

1078
01:00:15,580 --> 01:00:19,470
אנחנו במידה רבה יכולים להתעלם
כי לעת עתה.

1079
01:00:19,470 --> 01:00:23,250
>> אבל שם לב שיש לנו בי
בתוך זה מגוון של דברים

1080
01:00:23,250 --> 01:00:27,720
שכבר ראו כמו
פונקציות שיש לי שמות ספציפיים.

1081
01:00:27,720 --> 01:00:32,650
וכאשר אנחנו נותנים אותם
מתפקד שמות הנכונים

1082
01:00:32,650 --> 01:00:36,530
כי צפויים ידי iOS, למעשה
זה מרגיש קצת קסום.

1083
01:00:36,530 --> 01:00:40,300
אבל כאשר אתה יוצר
יישום iOS, יש

1084
01:00:40,300 --> 01:00:47,590
שמות פונקציה מסוימים ש
נקראים על ידי הטלפון עצמו

1085
01:00:47,590 --> 01:00:52,440
כבקשת טעינה לנסות
כדי ליצור תהליך שלמעשה

1086
01:00:52,440 --> 01:00:54,787
פועל היישום שלך.

1087
01:00:54,787 --> 01:00:58,120
אז שוב, יש הרבה דברים שאני
צריך לחפות על כאן על מנת ש

1088
01:00:58,120 --> 01:01:00,570
לדבר על זה באופן ספציפי.

1089
01:01:00,570 --> 01:01:06,050
אבל אני ממליץ לך להסתכל אולי
סמינר iOS האחר, אבל גם כמה

1090
01:01:06,050 --> 01:01:09,290
של אינטרנט הדרכות שיעשו
עבודה הרבה יותר טובה לתאר

1091
01:01:09,290 --> 01:01:11,030
המידע הספציפי.

1092
01:01:11,030 --> 01:01:15,760
>> אבל אנחנו יכולים לראות כמה דברים ש
מעניינים מהקוד כאן.

1093
01:01:15,760 --> 01:01:17,950
שים לב שיש לנו, אם הצהרות.

1094
01:01:17,950 --> 01:01:20,400
אגב, אחד חשוב
דבר על אם דוחות

1095
01:01:20,400 --> 01:01:24,860
הוא שהסוגריים סביב
ביטוי בוליאני הוא אופציונליים.

1096
01:01:24,860 --> 01:01:30,800
אבל הסוגריים המסולסלים אינם אופציונליים,
לא משנה כמה מעט או קווים רבים של קוד

1097
01:01:30,800 --> 01:01:32,360
יש לך באם הצהרה.

1098
01:01:32,360 --> 01:01:38,670
אתה לא יכול להיות אם דוחות
ללא סוגריים מסולסלים בסוויפט.

1099
01:01:38,670 --> 01:01:41,000
>> וזה גם הוא,, קצת מטופש.

1100
01:01:41,000 --> 01:01:43,910
אבל יש סיבות היסטוריות לכך.

1101
01:01:43,910 --> 01:01:46,180
זה אמור להציל אותך מעצמך.

1102
01:01:46,180 --> 01:01:49,899
כמו זה למשל, אתה לא יכול
לחסל את הסוגריים המסולסלים סביב ש

1103
01:01:49,899 --> 01:01:50,440
אם הצהרה.

1104
01:01:50,440 --> 01:01:52,730
אלה למעשה נדרשו.

1105
01:01:52,730 --> 01:01:54,480
אז אני ממליץ לך
תסתכל על זה.

1106
01:01:54,480 --> 01:01:56,230
אבל יש אחד יותר
לבנות שאני רוצה

1107
01:01:56,230 --> 01:02:02,640
כדי להראות לך על סוויפט ש
חדש לסוויפט 2.0 בהשוואה

1108
01:02:02,640 --> 01:02:08,460
לגרסאות ישנות יותר של סוויפט,
אשר הוא הבא.

1109
01:02:08,460 --> 01:02:11,620
בואו לראות איפה שמתי את זה כאן?

1110
01:02:11,620 --> 01:02:16,630
>> אז בפונקציה זו נקראת
fetchJSON, פונקציה זו

1111
01:02:16,630 --> 01:02:23,450
הוא אחראי על משיכת שJSON
קובץ מכתובת אתר, שפשוט כל כך קורה

1112
01:02:23,450 --> 01:02:26,310
להיות פועל על IDE CS50.

1113
01:02:26,310 --> 01:02:28,580
אני רק התחלתי אפאצ'י,
לשים קובץ JSON שלי שם,

1114
01:02:28,580 --> 01:02:32,110
ואני יכול אז למשוך את זה
נתונים מהאינטרנט באמצעות

1115
01:02:32,110 --> 01:02:36,430
פונקציה זו ואת כתובת האתר הזה,
הניתן על ידי הטלפון.

1116
01:02:36,430 --> 01:02:40,490
זה ניתן על ידי
ספרייה שאתה משתמש בי

1117
01:02:40,490 --> 01:02:43,140
אתה עושה קצת פיתוח האפליקציה iOS.

1118
01:02:43,140 --> 01:02:49,690
>> שים לב כאן שיש זה יוצא דופן
מבנה תחבירי נקרא שומר.

1119
01:02:49,690 --> 01:02:53,530
ובאמת כל זה הוא ב
סוויפט הוא דרך של אימות

1120
01:02:53,530 --> 01:02:56,870
כי יש כמה דברים
כבר נפגש לפניך

1121
01:02:56,870 --> 01:03:00,000
להמשיך עם שאר הפונקציות.

1122
01:03:00,000 --> 01:03:04,260
אז אני יכול לקבל, באמצעות
סוג זה אופציונאלי,

1123
01:03:04,260 --> 01:03:10,530
אני יכול למצוא את כתובת האתר על ידי
ריצת פונקצית NSURL זה

1124
01:03:10,530 --> 01:03:16,640
ואחסון שלכתובת אתר
קבוע, ולאחר מכן בדיקה

1125
01:03:16,640 --> 01:03:20,820
כדי לראות אם כתובת האתר היה אפסית, משום שהיא
הולך לחזור סוג אופציונאלי.

1126
01:03:20,820 --> 01:03:25,660
ואם זה היה אפסי, אז הייתי
להדפיס את שגיאה ולאחר מכן לחזור.

1127
01:03:25,660 --> 01:03:29,970
>> אבל במקום זה, מה שמאפשר לי השומר
שלנו הוא שמאוד דבר,

1128
01:03:29,970 --> 01:03:34,550
אבל לוודא שהוא
למעשה מקרה שכתובת אתר

1129
01:03:34,550 --> 01:03:38,020
נקבע כראוי על ידי NSURL.

1130
01:03:38,020 --> 01:03:41,810
ואם כן, אז זה
מדלג על זה, וזה

1131
01:03:41,810 --> 01:03:46,110
יאפשר לך להמשיך ב
כתובת אתר שהוגדר כראוי.

1132
01:03:46,110 --> 01:03:48,830
אבל אם זה המקרה ש
כתובת אתר אינו מוגדר כהלכה,

1133
01:03:48,830 --> 01:03:52,550
אם פונקציה זו מחזירה שגיאה
או משהו בלתי צפוי אחר

1134
01:03:52,550 --> 01:03:58,030
למעשה מתרחש, מבנה שומר זה
מאפשר לנו אז פלט ששגיאה

1135
01:03:58,030 --> 01:04:00,390
ולחזור מייד.

1136
01:04:00,390 --> 01:04:00,890
כֵּן?

1137
01:04:00,890 --> 01:04:04,839
>> קהל: אז זה סוג
כמו אם אז אחר?

1138
01:04:04,839 --> 01:04:07,130
דן ARMENDARIZ: זהו סוג של
כמו אם לאחר מכן אחר, כן,

1139
01:04:07,130 --> 01:04:14,200
פרט לכך שכתובת אתר זו היא אז
מוגדר לכל דבר מתחת לזה.

1140
01:04:14,200 --> 01:04:20,420
אם הוא עובר שומר זה, אז זה
יהיה למעשה מלאים בנתונים

1141
01:04:20,420 --> 01:04:29,500
ושמיש שבנותר
קוד מקור בתפקוד שלך.

1142
01:04:29,500 --> 01:04:33,790
אז אני חושד שאתה הולך
מתחיל לראות שומר זה גם כן.

1143
01:04:33,790 --> 01:04:36,670
ולהיות מודע לכך.

1144
01:04:36,670 --> 01:04:46,270
>> אז פשוט מסתכל על כמה אחרים
דברים, זכות זו הנה מה,

1145
01:04:46,270 --> 01:04:53,377
אתה חושב, רק על סמך מה ש
אנחנו מדברים על לפני?

1146
01:04:53,377 --> 01:04:56,650
>> קהל: חושב שזה יהיה לרוץ ברשימה?

1147
01:04:56,650 --> 01:04:59,100
>> דן ARMENDARIZ: אז זה קרוב.

1148
01:04:59,100 --> 01:05:02,360
זוהי פונקציה שאנו מגדירים.

1149
01:05:02,360 --> 01:05:07,240
ואנחנו מזינים פונקציה ש
כטיעון לפונקציה זו כאן.

1150
01:05:07,240 --> 01:05:09,120
>> קהל: [לא ברור] אם לא אפסי.

1151
01:05:09,120 --> 01:05:11,470
אז זה ברשימה, נכון?

1152
01:05:11,470 --> 01:05:15,450
>> דן ARMENDARIZ: אם השגיאה היא לא אפסית,
כך שהוא-- אז אני צריך לגלול.

1153
01:05:15,450 --> 01:05:18,060
ובכן, בוא נראה, אני באמת לא יכול
גלול לכאן.

1154
01:05:18,060 --> 01:05:23,161
שגיאה היא טענה שהוא להיות
עבר לפונקציה אנונימית זה.

1155
01:05:23,161 --> 01:05:24,410
זה פונקציה אנונימית.

1156
01:05:24,410 --> 01:05:25,480
אין לה שם.

1157
01:05:25,480 --> 01:05:29,850
אבל אנחנו מקבלים את שלושה אלה
טיעונים, נתונים, תגובה, ושגיאה.

1158
01:05:29,850 --> 01:05:33,590
וזה הולך לחזור חלל, כך
זה לא הולך לחזור כל דבר.

1159
01:05:33,590 --> 01:05:37,910
וזה התוכן
של פונקציה ש.

1160
01:05:37,910 --> 01:05:41,961
ואז יש לנו גישה בתוך ש
פונקציה לכל אחת מטענות אלה.

1161
01:05:41,961 --> 01:05:45,650

1162
01:05:45,650 --> 01:05:48,679
>> אז זה סופה
סיור בשפה.

1163
01:05:48,679 --> 01:05:50,470
אבל אני מקווה שעם זה,
אני מקווה שאתה לוקח

1164
01:05:50,470 --> 01:05:54,490
תסתכל על חלק של הדרכות
ספציפי לפיתוח iOS עם סוויפט,

1165
01:05:54,490 --> 01:05:57,481
במיוחד אם אתה הולך ל
page-- מפתח האינטרנט של אפל

1166
01:05:57,481 --> 01:05:59,980
יש להם הרבה של ממש טוב
הדרכות כדי להתחיל.

1167
01:05:59,980 --> 01:06:05,010
אבל אני מקווה שרק שעה זו של דיבור
על התחביר עצמו נתן

1168
01:06:05,010 --> 01:06:08,760
שלך מספיק כדי להתחיל עם זה.

1169
01:06:08,760 --> 01:06:12,950
>> אנו נפרסם כל מקור זה
קוד באתר האינטרנט של הסמינר

1170
01:06:12,950 --> 01:06:17,800
בהקדם האפשרי, וגם את השקופיות
אז יש לך התייחסות לכל אלה.

1171
01:06:17,800 --> 01:06:20,530
אבל מזל טוב עם הפרויקטים שלך.

1172
01:06:20,530 --> 01:06:23,640
ותודה רבה לכולכם שבאתם.

1173
01:06:23,640 --> 01:06:26,990
>> [תְשׁוּאוֹת]

1174
01:06:26,990 --> 01:06:28,026