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
>> DAN AMRMENDARIZ：每個人，
歡迎到CS50研討會上，

4
00:00:09,590 --> 00:00:11,690
iOS應用開發與斯威夫特。

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
整個CS50見於C，或
甚至一些其他語言

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
首先，你必須要使用
在Mac上，在實例運行

30
00:01:39,940 --> 00:01:43,880
我們將要使用的今天，
操作系統版本比較新

31
00:01:43,880 --> 00:01:46,580
十，在這種情況下，我跑X 10.5。

32
00:01:46,580 --> 00:01:48,600
您可以在運行10.11，如果你想要的。

33
00:01:48,600 --> 00:01:52,430
但一切，你要去
看到的是，涉及的Xcode 7及更高版本，

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
>> 很多語法是借來的
從C.它是基於並寫入C.

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
>> 但有些事情
讓它從C很大的不同

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，和
甚至有些服務器，甚至一些腳本。

81
00:04:26,290 --> 00:04:28,400
但是，我們會看到，
支持腳本

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
有很多的API
可用。

98
00:05:16,930 --> 00:05:21,170
這是一個很好的大本營您
尋找，具體的事情你

99
00:05:21,170 --> 00:05:23,020
想與涉及的iOS的API。

100
00:05:23,020 --> 00:05:26,350
如果你想使用相機
例如，你可以開始尋找在這裡，

101
00:05:26,350 --> 00:05:32,540
，還可以使用谷歌和堆棧
溢出，你通常會。

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
我們正在傳遞到它
字符串名為Hello 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
有沒有一個
克魯夫特，我們曾與C.

117
00:06:10,392 --> 00:06:15,020
當我們以這種方式使用SWIFT，
這僅僅是寫在一個文本文件

118
00:06:15,020 --> 00:06:18,340
並存儲在我的電腦上，然後
我可以編譯並運行它。

119
00:06:18,340 --> 00:06:20,920
>> 請注意，在這裡我
不使用CS50 IDE。

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
swiftc 1.swift。

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，
我們的Hello World應用程序相當。

130
00:06:51,090 --> 00:06:54,690
>> 注意一件事是
還有的是，在默認情況下，

131
00:06:54,690 --> 00:07:00,090
我們沒有輸入
A / 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
提供給它的一些數據 - 
這種情況下，串丹。

144
00:07:38,200 --> 00:07:40,630
但是，通過使用這讓
關鍵字，我們說

145
00:07:40,630 --> 00:07:43,860
這個變量 - 或
再次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
我們可能會
見慣了在C.

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
而我們要那麼串聯
兩個字符串，字符串Hello，

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
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
成績是一個可變的變量 - 
我們不使用let關鍵字。

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
相反，使用append
在數組類型的方法

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
同時，我們也有，在斯威夫特，概念
for循環，你會期望。

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，直到然而，許多1

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
在此有任何疑問for循環？

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
我們將接受
變量 - 或者更確切地說，在這種情況下，

384
00:21:12,840 --> 00:21:14,450
一個constant--叫成績冊。

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
有一個隱含的let關鍵字定義，
這意味著我不能修改這個

390
00:21:34,380 --> 00:21:39,850
在這裡成績簿變量。

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
如果成績簿是
空，在這種情況下

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
這是成績冊，而這一次
是否會返回一個double類型。

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
好吧，如果成績簿
是空的，好，那麼我們

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
計算的平均如果
我們有一個空的成績冊。

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
for循環，這使我們能夠迭代
在數組中的每一個項目

431
00:23:49,190 --> 00:23:53,630
並把每一個元素
到它自己的變量。

432
00:23:53,630 --> 00:23:56,200
通過在指定的等級
成績冊，我們在說什麼

433
00:23:56,200 --> 00:24:00,560
就是我們要含蓄
創建一個新的常數稱為

434
00:24:00,560 --> 00:24:05,180
等級，是要代表
在成績簿每一個獨特的項目

435
00:24:05,180 --> 00:24:06,769
每一次的for循環迭代。

436
00:24:06,769 --> 00:24:08,560
所以第一次
它的運行，成績將

437
00:24:08,560 --> 00:24:09,800
在成績簿中的第一項。

438
00:24:09,800 --> 00:24:12,300
第二次，它會是
第二個項目，等等等等

439
00:24:12,300 --> 00:24:15,970
直到成績冊有
用盡元素本身。

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
OK，什麼問題嗎？

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
DAN AMRMENDARIZ：你能
重複這個問題？

449
00:24:37,520 --> 00:24:39,587
聽眾：我可以這樣做
整數作為平均？

450
00:24:39,587 --> 00:24:41,670
DAN 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
DAN 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
>> DAN 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
>> DAN AMRMENDARIZ：所以
在情況下，這是部分

473
00:25:45,010 --> 00:25:50,580
對the--如此重複的問題，
因為這是自回歸隱

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
但是，are--

480
00:26:11,050 --> 00:26:12,560
>> 聽眾：[聽不清]箭頭？

481
00:26:12,560 --> 00:26:19,490
>> DAN 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
is--而種，它
給了我一個奇怪的錯誤。

492
00:26:54,900 --> 00:26:59,730
我需要通過這幾個
整數作為命令行參數。

493
00:26:59,730 --> 00:27:06,220
因此，讓我們來看看，150和80，然後按Enter
找出它實際上做。

494
00:27:06,220 --> 00:27:09,890
它接受各
這些數值為整數。

495
00:27:09,890 --> 00:27:12,040
它的輸入他們入成績冊。

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
和if語句的這一部分，
if語句的頂部部分

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
然後，它會返回nil，
這不是一個整數。

541
00:29:55,520 --> 00:29:57,570
而這個if語句以及再失敗。

542
00:29:57,570 --> 00:30:01,930
成績將不會因為存在
它沒有任何整數內容。

543
00:30:01,930 --> 00:30:06,391
它將運行這個else塊來代替。

544
00:30:06,391 --> 00:30:06,890
是？

545
00:30:06,890 --> 00:30:09,652
>> 聽眾：無為N-I-L？

546
00:30:09,652 --> 00:30:11,110
DAN AMRMENDARIZ：無為N-I-L，是的。

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

548
00:30:14,970 --> 00:30:20,310
>> 因此，這是可能之一
關於SWIFT最難的事情，

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
因此，重要的外賣是一個
可選的類型是那種一元類型的。

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
其中之一是詞典，它是
非常類似於Python字典。

571
00:31:41,290 --> 00:31:48,270
這有點類似於在哈希表中
C.它實質上是鍵的映射

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
它說，成績冊為三
等級，PSET1，pset0，考試。

587
00:32:33,740 --> 00:32:36,120
而成績簿有
這個特定的平均水平。

588
00:32:36,120 --> 00:32:38,370
所以，再一次，我們正在努力
這一成績冊的想法，

589
00:32:38,370 --> 00:32:44,650
但我們要繼續迭代
與我們的功能的複雜性。

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
你可能還記得，我有這樣的列表
的items-- PSET1，pset0和考試。

602
00:33:26,090 --> 00:33:29,130
實際上，你可以迅速
輕鬆地做到這一點

603
00:33:29,130 --> 00:33:34,490
通過採取成績簿，這是一個
字典具有鍵和值。

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
過去有一個
如果你的Python style--

613
00:34:08,730 --> 00:34:13,219
熟悉Python--一個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
如果實際成績冊什麼
已經在它沒有價值？

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
而我現在說這些話，但
這其實不使用選配。

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
但它可以讓你體驗
與Swift在一個非常簡單的方法。

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
這是Double類型。

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
這將接受
參數調用類型為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
我們正在創造一個新的功能
所謂的求冪，

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
並在這一點上，我們
返回求冪。

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在這個求冪函數

731
00:40:55,130 --> 00:40:56,410
的值將是2。

732
00:40:56,410 --> 00:41:01,290
但是我回到這個
求冪函數。

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
並返回一個double。

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
求冪，但這個值
Ÿ被包裹在它的內部。

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
DAN AMRMENDARIZ：所以看
在這裡的最後一行。

765
00:42:50,930 --> 00:42:55,930
它實際上是完全可能的
做鏈接如你所說。

766
00:42:55,930 --> 00:43:00,990
所以powerOf（5）意味著我們要去
以具有5的求冪在這裡。

767
00:43:00,990 --> 00:43:04,160
因此，這基本上將是
同樣的事情，4到第五電源，

768
00:43:04,160 --> 00:43:07,200
因為我們已經創建了一個指數
傳播到第五功率，

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
>> DAN 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
DAN 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
就像為什麼我定義這個
函數調用求冪

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
因此在這種情況下，在圖7B中，
我們可以發現正是。

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
它實際上並沒有一個名字，而
它被稱為求冪之前。

809
00:44:57,030 --> 00:45:00,229
但正如我們所看到的，只是真的
沒有提及求冪

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
DAN 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
>> 聽眾：請問Perl或一些有
這個美元符號，美元0在那裡呢？

850
00:47:11,119 --> 00:47:12,702
DAN Armendariz環：這呢，我很抱歉？

851
00:47:12,702 --> 00:47:15,360
聽眾：請問Perl的有
這種0美元，美元1--

852
00:47:15,360 --> 00:47:17,318
DAN Armendariz環：我不是
太熟悉了Perl中，

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
我們看到它的Python提示。

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
斯威夫特有一個指數
功能內置的。

867
00:48:02,120 --> 00:48:04,660
如果我輸入達爾文，這
只是庫

868
00:48:04,660 --> 00:48:09,680
擁有這種功能稱為戰俘，現
我能簡化我的功能功率

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表示是Double類型的引用。

875
00:48:29,320 --> 00:48:32,680
它會返回一個類型雙。

876
00:48:32,680 --> 00:48:35,760
但return語句
現在是隱含的。

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
OK，這是偉大的。

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
但是，我們定義這個綴
操作者，**，將允許我們，

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的3次冪。

910
00:50:29,490 --> 00:50:34,420
[令人興奮的聲音]本所
本身應該讓你像，

911
00:50:34,420 --> 00:50:37,960
OK，螺絲C.我要去
雨燕一路。

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
>> DAN 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
現在不幸的是，
最後7分鐘

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
for循環的簡單的
遍歷所有的人

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
DAN 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
如果該函數返回false，
它丟棄該項目。

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
>> 因此在另一個話，這是
同樣的想法，在成績冊。

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
那麼這將返回true，這意味著
該項目將被保存在這個過濾器。

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應用使用SWIFT創建。

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
我再通過，週期在我
應用程序，從我的web服務器映像。

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的
成實際的iPhone應用程序。

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
請注意，我們有if語句。

1094
01:01:17,950 --> 01:01:20,400
順便說，一個重要
有關if語句的事

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
你有一個if語句。

1098
01:01:32,360 --> 01:01:38,670
你不能有一個if語句
無斯威夫特花括號。

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
if語句。

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
從URL，這恰好文件

1112
01:02:23,450 --> 01:02:26,310
要運行在我的CS50的IDE。

1113
01:02:26,310 --> 01:02:28,580
我剛開始的Apache，
把我的JSON文件存在，

1114
01:02:28,580 --> 01:02:32,110
而我能夠再扳指
使用來自互聯網的數據

1115
01:02:32,110 --> 01:02:36,430
這個功能和這個URL，
這是由電話提供的。

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
並存儲該到一個URL
恆定，然後檢查

1125
01:03:16,640 --> 01:03:20,820
看是否URL為零，因為它
正想返回一個可選的類型。

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
但確保其
實際的情況是URL

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
但如果是的情況下
URL不是正確定義，

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
DAN Armendariz環：這是一種
就像如果當時別人，是的，

1139
01:04:07,130 --> 01:04:14,200
但此URL隨後
定義低於這個一切。

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
>> DAN 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
>> DAN Armendariz環：如果錯誤不是零，
讓is--，所以我必須滾動。

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
它是要返回void，所以
它不會返回任何東西。

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