1
00:00:00,000 --> 00:00:11,270

2
00:00:11,270 --> 00:00:14,340
>> DANIEL Armendariz環：大家好，
歡迎到iOS應用程序開發

3
00:00:14,340 --> 00:00:15,020
與迅速。

4
00:00:15,020 --> 00:00:15,870
我是丹Armendariz環。

5
00:00:15,870 --> 00:00:18,920
我的電腦precepter
科學在這裡的學校

6
00:00:18,920 --> 00:00:21,200
工程與應用科學。

7
00:00:21,200 --> 00:00:24,310
和迅速實際上是一種
一個真正整潔的語言。

8
00:00:24,310 --> 00:00:27,190
我有一些計劃今天。

9
00:00:27,190 --> 00:00:31,430
所以，在接下來的一個小時左右，我們要去
來看看iOS應用開發本身

10
00:00:31,430 --> 00:00:36,640
使用Xcode中，實際上創造一些
很基本，很簡單的應用程序。

11
00:00:36,640 --> 00:00:40,070
看著路上，你
居然拿這些應用程序，

12
00:00:40,070 --> 00:00:42,887
並建立他們，實際上
把他們的iOS設備上。

13
00:00:42,887 --> 00:00:44,970
有些事情，
我們不會看

14
00:00:44,970 --> 00:00:47,540
將包括像
實際上正在申請

15
00:00:47,540 --> 00:00:48,940
並把它放在應用程序商店。

16
00:00:48,940 --> 00:00:52,930
有很多教程網上說
將幫助你以它這方面。

17
00:00:52,930 --> 00:00:56,230
而且還因為作為
CS50的一部分，你會得到

18
00:00:56,230 --> 00:00:59,780
加入蘋果開發
團隊，CS50的應用程序開發團隊。

19
00:00:59,780 --> 00:01:02,790
如果你還沒有做到這一點還沒有和
您結盟CS50，

20
00:01:02,790 --> 00:01:04,810
我建議您
這樣做，因為這

21
00:01:04,810 --> 00:01:08,820
是你如何是能夠創建
有些程序在Xcode，

22
00:01:08,820 --> 00:01:11,890
打造他們，居然把
他們對你的一些iOS設備

23
00:01:11,890 --> 00:01:14,087
如果你確實有
物理的iOS設備。

24
00:01:14,087 --> 00:01:16,670
如果你沒有一個物理的iOS
設備不僅僅是罰款。

25
00:01:16,670 --> 00:01:19,810
實際上，你可以開發針對iOS。

26
00:01:19,810 --> 00:01:22,390
和Xcode中有一個
模擬器，可以讓你

27
00:01:22,390 --> 00:01:26,570
看到你的應用程序
您的計算機上的操作。

28
00:01:26,570 --> 00:01:30,440
排序，但它是一個整潔的事情
實際播放和互動

29
00:01:30,440 --> 00:01:34,235
與應用程序
上的實際設備。

30
00:01:34,235 --> 00:01:37,360
因此，有一對夫婦的要求，
真正做到這一切的發展。

31
00:01:37,360 --> 00:01:39,151
其中之一是該
你必須有一台Mac。

32
00:01:39,151 --> 00:01:44,770
它必須運行10.9.4或更高
為了做到發​​展與迅速。

33
00:01:44,770 --> 00:01:47,770
>> 您可以使用較早
版本開發

34
00:01:47,770 --> 00:01:50,810
與iOS和Mac的目標C。

35
00:01:50,810 --> 00:01:53,990
但我建議，很多的
舉例說，我們會看到今天，

36
00:01:53,990 --> 00:01:55,700
使用10.10優勝美地。

37
00:01:55,700 --> 00:02:00,910
所以，如果你還沒有升級，
這是一個很好的藉口這樣做。

38
00:02:00,910 --> 00:02:05,480
現在的Xcode 6.1是最新版本的
集成開發環境

39
00:02:05,480 --> 00:02:08,979
蘋果提供了免費的
您可以下載過的應用程序商店。

40
00:02:08,979 --> 00:02:11,220
我建議您
還運行的最新版本。

41
00:02:11,220 --> 00:02:14,700
>> 如果你碰巧運行較早
版本的Xcode 5只以下

42
00:02:14,700 --> 00:02:16,741
根本不支持任何迅速。

43
00:02:16,741 --> 00:02:19,490
而公測版本6個，其中
被釋放在今年夏天，

44
00:02:19,490 --> 00:02:21,770
做支持迅速，但有
是一個巨大的數字

45
00:02:21,770 --> 00:02:25,220
變化的語言的，足以
所以，你是代碼

46
00:02:25,220 --> 00:02:28,320
去看看和你
可能會發現在互聯網上

47
00:02:28,320 --> 00:02:33,294
實際上不會正確編譯
在Xcode這些以前的版本。

48
00:02:33,294 --> 00:02:35,460
如此反复，如果你還沒有
有一個開發者賬戶，

49
00:02:35,460 --> 00:02:38,560
我建議你去
developer.apple.com。

50
00:02:38,560 --> 00:02:42,240
註冊，創建一個開發者賬戶，
並加入了CS50的應用程序開發團隊。

51
00:02:42,240 --> 00:02:45,530
這將提供給你一個機會
編譯應用程序

52
00:02:45,530 --> 00:02:47,840
並把他們的設備上。

53
00:02:47,840 --> 00:02:49,222
好了，讓我們開始吧。

54
00:02:49,222 --> 00:02:50,930
的第一件事
我們要做的是

55
00:02:50,930 --> 00:02:55,140
實際創建一個非常
在Xcode簡單的項目

56
00:02:55,140 --> 00:02:59,530
這將允許你
提出申請。

57
00:02:59,530 --> 00:03:03,170
>> 所以，如果你還沒有的Xcode
開放，繼續前進，打開它

58
00:03:03,170 --> 00:03:04,270
並創建一個新的項目。

59
00:03:04,270 --> 00:03:06,570
一個特殊的啟動畫面
將打開，會給你

60
00:03:06,570 --> 00:03:08,800
關於什麼的一些選項
這是你想做的事情。

61
00:03:08,800 --> 00:03:12,170
只要說你想要創建
一個新的項目，新的應用程序。

62
00:03:12,170 --> 00:03:15,650
該窗口會彈出，
假設你使用的Xcode 6.1。

63
00:03:15,650 --> 00:03:17,650
現在，並為
本次研討會的持續時間，

64
00:03:17,650 --> 00:03:19,990
我們將使用
單一視圖的應用程序，只需

65
00:03:19,990 --> 00:03:22,590
排序的基本應用
讓你的腳弄濕。

66
00:03:22,590 --> 00:03:25,200
你可以另闢蹊徑
從那裡你自己。

67
00:03:25,200 --> 00:03:27,660
>> 點擊下一步，在這一點上。

68
00:03:27,660 --> 00:03:30,796
現在，這裡有幾件事情
你可能想進入。

69
00:03:30,796 --> 00:03:32,670
該產品的名稱是
項目的名稱。

70
00:03:32,670 --> 00:03:34,859
在這種情況下，我只是
要叫它Seminar1

71
00:03:34,859 --> 00:03:36,150
因為這是我們的第一個例子。

72
00:03:36,150 --> 00:03:38,290
組織名稱，在
這種情況下，僅僅是我的名字。

73
00:03:38,290 --> 00:03:41,760
你當然可以改變它
以你自己的名字，或者CS50。

74
00:03:41,760 --> 00:03:46,160
組織標識符，如果你
碰巧有一個網站，只取

75
00:03:46,160 --> 00:03:49,940
在域名
反向，com.yourname。

76
00:03:49,940 --> 00:03:54,200
該產品然後將名稱
會自動出現

77
00:03:54,200 --> 00:03:55,820
之後，隨著包標識符。

78
00:03:55,820 --> 00:03:59,200
>> 顯然，我們是語言
將要使用的今天迅速。

79
00:03:59,200 --> 00:04:02,590
當然，你可以使用目標C
對於這一點，但今天將是迅速的。

80
00:04:02,590 --> 00:04:04,920
我們將現在說
萬向設備，所以

81
00:04:04,920 --> 00:04:06,900
它可以同時在iPad和iPhone。

82
00:04:06,900 --> 00:04:10,040
我們將離開核心
數據選中保持

83
00:04:10,040 --> 00:04:12,830
該項目相對
簡單的暫時。

84
00:04:12,830 --> 00:04:14,430
因此，讓我們繼續前進，然後單擊下一步。

85
00:04:14,430 --> 00:04:16,471
而且它會問我
在這裡我要保存它。

86
00:04:16,471 --> 00:04:19,250
我只是將它保存到我的桌面了。

87
00:04:19,250 --> 00:04:22,267
>> 好了，所以現在這是什麼將
發生在你真正開放的Xcode。

88
00:04:22,267 --> 00:04:24,100
並注意
你看到的第一件事

89
00:04:24,100 --> 00:04:28,770
這是感嘆號的
說沒有找到簽約的身份。

90
00:04:28,770 --> 00:04:31,520
我故意這樣做
在我的電腦，我

91
00:04:31,520 --> 00:04:34,220
希望我要去
能夠真正解決這個問題，

92
00:04:34,220 --> 00:04:37,860
因為我想讓你看看這個
實際上在自己的機器工作。

93
00:04:37,860 --> 00:04:40,400
>> 來吧，點擊修復問題。

94
00:04:40,400 --> 00:04:45,400
它會問你，如果你有一個
現有的蘋果開發者賬號。

95
00:04:45,400 --> 00:04:48,330
這是在加入
CS50的應用程序開發團隊

96
00:04:48,330 --> 00:04:51,240
很重要，這樣你不會
只有一個應用程序的帳戶，

97
00:04:51,240 --> 00:04:53,690
但你也有
能力簽署的應用程序

98
00:04:53,690 --> 00:04:56,420
並把他們的iOS設備上。

99
00:04:56,420 --> 00:04:58,957
這是不是 - 點擊
修復的問題是沒有必要的

100
00:04:58,957 --> 00:05:01,040
如果你只是要
建立和發展本地，

101
00:05:01,040 --> 00:05:03,520
完全在了iOS模擬器。

102
00:05:03,520 --> 00:05:05,820
>> 但現在我要去
制定並把它們

103
00:05:05,820 --> 00:05:08,160
在我的iPad上，這將是
能夠播放為好。

104
00:05:08,160 --> 00:05:10,770
所以，我想實際添加此。

105
00:05:10,770 --> 00:05:13,670
而且它會問
我要我的Apple ID。

106
00:05:13,670 --> 00:05:15,700
因此，這將是這一點。

107
00:05:15,700 --> 00:05:18,940
我要去找我
密碼，這是在這裡。

108
00:05:18,940 --> 00:05:27,760
所以給我一秒地發現，
和複製，並粘貼在這裡結束了。

109
00:05:27,760 --> 00:05:28,580
>> 單擊添加。

110
00:05:28,580 --> 00:05:31,095
它會問我
哪支球隊，我想加入。

111
00:05:31,095 --> 00:05:33,240
我會做工程的學校。

112
00:05:33,240 --> 00:05:35,680
點擊加入。

113
00:05:35,680 --> 00:05:37,780
哎呀，那是錯誤的。

114
00:05:37,780 --> 00:05:40,730
讓我們做這一塊。

115
00:05:40,730 --> 00:05:42,060
希望這一個生效。

116
00:05:42,060 --> 00:05:44,220
一個仍然不能正常工作。

117
00:05:44,220 --> 00:05:46,610
我們正在運行的好的位置。

118
00:05:46,610 --> 00:05:48,260
OK，這個應該工作。

119
00:05:48,260 --> 00:05:50,816
現在關閉了。

120
00:05:50,816 --> 00:05:54,450
現在，讓我們做學校
工程，單擊選擇。

121
00:05:54,450 --> 00:06:00,190
>> 現在希望經過
幾秒鐘內，你can-- OK，

122
00:06:00,190 --> 00:06:02,550
我會撤銷，並要求。

123
00:06:02,550 --> 00:06:05,410
噢，伙計，這將無法正常工作。

124
00:06:05,410 --> 00:06:08,890
OK，我會嘗試不同的。

125
00:06:08,890 --> 00:06:11,167
讓我們在這裡做這件事。

126
00:06:11,167 --> 00:06:17,020

127
00:06:17,020 --> 00:06:19,310
現場演示失敗了我。

128
00:06:19,310 --> 00:06:22,540
我們可能要恢復到剛
建設完全在本地，

129
00:06:22,540 --> 00:06:25,050
但是這將是在這種情況下確定。

130
00:06:25,050 --> 00:06:28,560
>> 所以在這裡，而這實際上是
工作中，我們要做的只是

131
00:06:28,560 --> 00:06:31,190
創建一個非常簡單的
Hello World應用程序。

132
00:06:31,190 --> 00:06:32,340
所以這是Xcode的。

133
00:06:32,340 --> 00:06:37,300
如果你還沒有看到它，它
可以是一個有點嚇人在第一。

134
00:06:37,300 --> 00:06:41,430
有很多窗格，有一個
很多在各個領域的裝飾物。

135
00:06:41,430 --> 00:06:44,300
但是，僅僅認識到有
真的幾種主要成分

136
00:06:44,300 --> 00:06:46,580
這一開發環境。

137
00:06:46,580 --> 00:06:51,090
最左邊是所有的文件
這適用於你的程序

138
00:06:51,090 --> 00:06:52,997
或您的特定項目。

139
00:06:52,997 --> 00:06:55,080
我們將圍繞點擊
對他們中的一些，我們將

140
00:06:55,080 --> 00:06:57,660
指出最
重要的一段時間。

141
00:06:57,660 --> 00:06:59,650
最右邊，我們
有一組屬性。

142
00:06:59,650 --> 00:07:02,920
而所有這些屬性中，有
各種窗格的屬性。

143
00:07:02,920 --> 00:07:06,770
窗格會根據變化
的主要內容的範圍內，這

144
00:07:06,770 --> 00:07:08,290
恰好是在中間。

145
00:07:08,290 --> 00:07:11,740
現在，中間可以實際顯示
你各種各樣的事情，例如

146
00:07:11,740 --> 00:07:13,290
你的代碼本身。

147
00:07:13,290 --> 00:07:17,070
或者你可能實際上have--時
你點擊其中的故事板

148
00:07:17,070 --> 00:07:21,270
是，通過該方式，僅僅一個圖形
您的用戶的代表性

149
00:07:21,270 --> 00:07:25,350
接口為您application--
那麼屬性窗格

150
00:07:25,350 --> 00:07:27,334
在很遠的權利
實際上將發生改變。

151
00:07:27,334 --> 00:07:29,750
現在有幾個其他的
的事情，我想指出。

152
00:07:29,750 --> 00:07:33,360
排序，你可以探索周圍
在自己的環境中。

153
00:07:33,360 --> 00:07:35,730
不過的事情之一
這是非常有益的

154
00:07:35,730 --> 00:07:38,470
是這個按鈕這裡，該
窗口的右上角。

155
00:07:38,470 --> 00:07:41,230
有此按鈕
看起來像遠

156
00:07:41,230 --> 00:07:46,090
離開它有一個段
其次是兩個圓圈和排序

157
00:07:46,090 --> 00:07:49,540
兩個箭頭指向
彼此遠離。

158
00:07:49,540 --> 00:07:52,640
如果你們之間的切換
標準的編輯器，

159
00:07:52,640 --> 00:07:55,560
是最左邊之一，所述一個
這是默認選擇，

160
00:07:55,560 --> 00:08:01,040
而兩個圓重疊
對方，你實際上得到了什麼

161
00:08:01,040 --> 00:08:02,210
是一個雙窗格視圖。

162
00:08:02,210 --> 00:08:04,240
>> 這實際上是
將是對我們有用

163
00:08:04,240 --> 00:08:07,330
當我們需要鏈接項目
在UI的代碼。

164
00:08:07,330 --> 00:08:09,330
我們將更多地討論
在短短的時刻。

165
00:08:09,330 --> 00:08:12,050
但要意識到，如果你得到
更窗格這樣，

166
00:08:12,050 --> 00:08:15,830
你可以簡化您的看法
通過單擊後退一點點

167
00:08:15,830 --> 00:08:20,680
你單編輯器。

168
00:08:20,680 --> 00:08:21,580
到目前為止，一切都很好。

169
00:08:21,580 --> 00:08:24,560
所以基本上，我們對代碼
左，屬性在右側，

170
00:08:24,560 --> 00:08:28,260
而無論它是我們正在努力
在這裡的中心。

171
00:08:28,260 --> 00:08:30,390
>> 所以在這裡，我點擊
在主要故事情節。

172
00:08:30,390 --> 00:08:33,350
和故事板，
再次，是在Xcode的方式

173
00:08:33,350 --> 00:08:38,110
你其實可以創建用戶
只使用拖放界面

174
00:08:38,110 --> 00:08:39,130
技術。

175
00:08:39,130 --> 00:08:41,190
所以我們非常
第一個應用該

176
00:08:41,190 --> 00:08:42,720
正是我們要做的。

177
00:08:42,720 --> 00:08:45,950
我們要深入到
很遠右下部

178
00:08:45,950 --> 00:08:49,900
在屏幕上，它包含了
各種用戶的元素

179
00:08:49,900 --> 00:08:53,270
然後你可以點擊並拖動
創建用戶界面。

180
00:08:53,270 --> 00:08:55,550
>> 現在，所有這些
元素被稱為意見

181
00:08:55,550 --> 00:08:57,370
因為他們提供某種觀點。

182
00:08:57,370 --> 00:09:00,190
有一個圖像視圖，用於
例如，為了實際顯示

183
00:09:00,190 --> 00:09:01,740
在用戶界面上的圖像。

184
00:09:01,740 --> 00:09:04,310
有一個表視圖
實際顯示的表。

185
00:09:04,310 --> 00:09:05,190
等等等等。

186
00:09:05,190 --> 00:09:08,250
有各種各樣的
意見，你可以在這裡選擇。

187
00:09:08,250 --> 00:09:11,100
所以，只是現在我們要去
要搜索的一個標籤。

188
00:09:11,100 --> 00:09:13,550
你可以滾動
所有在那裡的名單。

189
00:09:13,550 --> 00:09:15,460
但有搜索
酒吧在最底層

190
00:09:15,460 --> 00:09:19,460
這使得它更容易識別
具體意見，你實際上

191
00:09:19,460 --> 00:09:22,020
要拖動到你的用戶界面。

192
00:09:22,020 --> 00:09:23,560
>> 發現我的標籤。

193
00:09:23,560 --> 00:09:28,430
我要在這裡拖，直接
到我的示例應用程序。

194
00:09:28,430 --> 00:09:30,130
正確的，在中間看起來不錯。

195
00:09:30,130 --> 00:09:33,180
而且我要輸入的“Hello World！”

196
00:09:33,180 --> 00:09:33,810
按Enter鍵。

197
00:09:33,810 --> 00:09:34,877
現在我有一個標籤。

198
00:09:34,877 --> 00:09:36,960
它看起來並不像它的
很恰當中心。

199
00:09:36,960 --> 00:09:38,500
這樣我就可以嘗試重新中心吧。

200
00:09:38,500 --> 00:09:42,100
幸運的是它提供了這些
引導，使事情變得更加容易。

201
00:09:42,100 --> 00:09:44,130
我要去嘗試編譯它。

202
00:09:44,130 --> 00:09:46,570
希望這實際上會在這裡工作。

203
00:09:46,570 --> 00:09:52,870
如果不是這樣，在短短的一瞬間
它會在事實上出現在我的iPad。

204
00:09:52,870 --> 00:09:54,360
就是這裡。

205
00:09:54,360 --> 00:09:55,060
它就在那裡。

206
00:09:55,060 --> 00:09:56,590
>> OK，所以就是這樣。

207
00:09:56,590 --> 00:09:57,160
我們就大功告成了。

208
00:09:57,160 --> 00:09:58,868
我們已經創建了很
首次應用。

209
00:09:58,868 --> 00:10:01,330
現在很明顯，這並不做任何事情。

210
00:10:01,330 --> 00:10:02,280
這只是一個標籤。

211
00:10:02,280 --> 00:10:07,350
有沒有關係
用戶界面和代碼。

212
00:10:07,350 --> 00:10:10,130
因此，如果我們真正想要的
創建這種連接，

213
00:10:10,130 --> 00:10:14,790
如果我們真的希望有某種
元件之間的通信的

214
00:10:14,790 --> 00:10:17,540
對存在
屏幕和代碼

215
00:10:17,540 --> 00:10:19,810
使我們能夠控制
這些元素，則

216
00:10:19,810 --> 00:10:23,570
我們確實需要
看看代碼本身。

217
00:10:23,570 --> 00:10:27,000
>> 所以，這就是被稱為
ViewController.swift。

218
00:10:27,000 --> 00:10:30,080
以及用於，特別是用於
你的第幾個節目，

219
00:10:30,080 --> 00:10:33,120
這將是排序的
散裝您enter--的代碼

220
00:10:33,120 --> 00:10:35,980
將是本文檔中在這裡。

221
00:10:35,980 --> 00:10:38,390
有很多東西
這是在這裡，到目前為止，對不對？

222
00:10:38,390 --> 00:10:42,660
有進口UI套件類，重寫，
[？臨陣脫逃，？]所有這些不同的東西。

223
00:10:42,660 --> 00:10:45,820
它不是很清楚什麼
這是這一切的意思。

224
00:10:45,820 --> 00:10:48,570
因此，讓我們退後一步走
從Xcode中一點點

225
00:10:48,570 --> 00:10:52,420
並期待在語言本身，快捷。

226
00:10:52,420 --> 00:10:56,370
>> 因此，與迅速，它是在
設計和開發

227
00:10:56,370 --> 00:10:58,645
在蘋果公司約四
幾年來我的理解。

228
00:10:58,645 --> 00:11:01,270
並有幾個特點
它是很整潔。

229
00:11:01,270 --> 00:11:03,910
首先，它的編譯
語言，就像C.

230
00:11:03,910 --> 00:11:06,120
所以，你首先要
編譯，然後運行它

231
00:11:06,120 --> 00:11:09,580
之前，你實際上可以
執行該結果的代碼。

232
00:11:09,580 --> 00:11:14,250
但，不像C，一個互動
提示，你可以實際運行

233
00:11:14,250 --> 00:11:16,680
並鍵入任意命令到。

234
00:11:16,680 --> 00:11:20,280
而且很像一個JavaScript控制台，
你可能很熟悉了，

235
00:11:20,280 --> 00:11:24,506
它實際上會評估這些
命令和提供給您的輸出。

236
00:11:24,506 --> 00:11:26,380
而且他們甚至採取了
該下一級

237
00:11:26,380 --> 00:11:29,100
他們已經創造了什麼
在Xcode叫遊樂場

238
00:11:29,100 --> 00:11:31,720
允許您
與視覺上的代碼工作。

239
00:11:31,720 --> 00:11:34,910
我們將真正看到一些例子
那在只是一點點。

240
00:11:34,910 --> 00:11:41,680
它是基於C.çunderlies
它，因為所有的編譯器

241
00:11:41,680 --> 00:11:46,820
創建代碼出C和
創建該對象的代碼。

242
00:11:46,820 --> 00:11:49,240
但它確實股份
相對較小的語法。

243
00:11:49,240 --> 00:11:50,721
它看起來相當不同。

244
00:11:50,721 --> 00:11:51,970
就會有一些相似之處。

245
00:11:51,970 --> 00:11:54,140
但也有將要
不少分歧

246
00:11:54,140 --> 00:11:57,200
相比較，比如說，JavaScript的或PHP。

247
00:11:57,200 --> 00:11:59,070
我們將這些點
在短短的時刻。

248
00:11:59,070 --> 00:12:01,420
>> 現在，人們的最大的事情
關於SWIFT這很好

249
00:12:01,420 --> 00:12:05,650
是，尤其是相
以C，它的意思是安全的。

250
00:12:05,650 --> 00:12:08,100
在它的一切是為了
要非常強類型英寸

251
00:12:08,100 --> 00:12:10,780
事實上，它幾乎是煩人
首先，當你第一次

252
00:12:10,780 --> 00:12:15,610
開始迅速工作，就如何
很多它強制類型無處不在。

253
00:12:15,610 --> 00:12:17,860
任何一個字符串
必須保持的字符串。

254
00:12:17,860 --> 00:12:22,100
這是非常難以理清的轉換
它或者強制其一些其他形式。

255
00:12:22,100 --> 00:12:23,800
>> 再次，我們將展示這方面的例子。

256
00:12:23,800 --> 00:12:26,830
但最終認識到，
這是為了保護你，

257
00:12:26,830 --> 00:12:32,010
並通過你，我的意思是你的代碼，從
崩潰在某些可怕的方式時，

258
00:12:32,010 --> 00:12:34,330
你有一些不匹配的類型。

259
00:12:34,330 --> 00:12:36,040
再次，努力吧。

260
00:12:36,040 --> 00:12:40,210
因為這將是令人沮喪的第一
當你試圖找出到底為什麼

261
00:12:40,210 --> 00:12:43,070
你得到這個不尋常
錯誤處理類型。

262
00:12:43,070 --> 00:12:45,350
不過，這將是值得它到底。

263
00:12:45,350 --> 00:12:47,267
>> 它不處理自動
內存管理，

264
00:12:47,267 --> 00:12:49,100
所以不再做你
要處理的事情

265
00:12:49,100 --> 00:12:51,400
就像malloc和free和所有
這些各種各樣的事情。

266
00:12:51,400 --> 00:12:53,066
而且它的設計也為泛泛而談。

267
00:12:53,066 --> 00:12:58,360
因此，儘管我們可以用Xcode中來
創建iOS應用程序和Mac應用程序，

268
00:12:58,360 --> 00:13:00,380
我們也可以只使用它
作為腳本語言。

269
00:13:00,380 --> 00:13:03,660
因此，我們可以用它排序
代替PHP或代替

270
00:13:03,660 --> 00:13:07,800
Python中的實際
快速分析和處理

271
00:13:07,800 --> 00:13:09,800
一些數據，我們有我們的計算機上。

272
00:13:09,800 --> 00:13:13,290
>> 它具有多種現代
特點，自選，可變性，

273
00:13:13,290 --> 00:13:17,900
泛型，關閉，和很多這個
東西你可能會或可能無法識別。

274
00:13:17,900 --> 00:13:22,810
和它的排序只是一個不幸的
該語言的一部分，其中一些

275
00:13:22,810 --> 00:13:26,700
樣的未來，現代元素
被包含在所述元素是

276
00:13:26,700 --> 00:13:34,520
這樣根深蒂固的，我居然會
有教你CS50.5一點點。

277
00:13:34,520 --> 00:13:37,305
>> 我們必須學習多一點
一些功能，以便

278
00:13:37,305 --> 00:13:40,180
要真正了解這是怎麼回事
上，這樣你可以看看代碼

279
00:13:40,180 --> 00:13:42,450
並沒有感到完全喪失。

280
00:13:42,450 --> 00:13:44,820
你就會明白我的意思
由在短短的一分鐘。

281
00:13:44,820 --> 00:13:47,830
OK，所以let's--夠本
那種理論的東西。

282
00:13:47,830 --> 00:13:52,450
讓我們來實際看看我們
最初的迅速程序。

283
00:13:52,450 --> 00:13:53,590
它的一行代碼。

284
00:13:53,590 --> 00:13:57,690
14號線就在這裡，它
說打印L N打招呼CS50。

285
00:13:57,690 --> 00:14:01,160
>> 因此，有幾件事情那
這個對比非常不同

286
00:14:01,160 --> 00:14:04,140
的事情，你可能會
從C用於，例如。

287
00:14:04,140 --> 00:14:08,390
其中之一是，有沒有
intmain，沒有包括部分，

288
00:14:08,390 --> 00:14:10,790
有沒有這額外的東西。

289
00:14:10,790 --> 00:14:13,790
在包括像標準
的I / O，如庫

290
00:14:13,790 --> 00:14:16,580
實際提供的
語言的標準功能，

291
00:14:16,580 --> 00:14:19,180
被自動納入
SWIFT的標準庫的一部分

292
00:14:19,180 --> 00:14:20,680
並自動導入。

293
00:14:20,680 --> 00:14:23,740
你不必做
手動的進口。

294
00:14:23,740 --> 00:14:27,360
>> Intmain不存在的，因為
主入口點代碼

295
00:14:27,360 --> 00:14:29,470
實際上是在
開頭的代碼。

296
00:14:29,470 --> 00:14:32,000
讓你有任何代碼
從頭開始

297
00:14:32,000 --> 00:14:34,940
實際上將在開始執行。

298
00:14:34,940 --> 00:14:36,520
所以這真的是大大簡化了。

299
00:14:36,520 --> 00:14:38,470
通知還，有沒有分號。

300
00:14:38,470 --> 00:14:41,040
有這種語言沒有分號。

301
00:14:41,040 --> 00:14:43,261
你把聲明
上的單個線

302
00:14:43,261 --> 00:14:45,510
然後下一行
代表其他聲明。

303
00:14:45,510 --> 00:14:47,420
如果你想要把
網上多發性陳述，

304
00:14:47,420 --> 00:14:49,086
那麼你必須用分號分隔它。

305
00:14:49,086 --> 00:14:50,940
但在大多數情況下，
良好的作風，我們

306
00:14:50,940 --> 00:14:56,530
永遠不會看到分號的
分離報表的目的，

307
00:14:56,530 --> 00:14:58,420
在快捷。

308
00:14:58,420 --> 00:14:59,820
那麼，這怎樣的實際工作？

309
00:14:59,820 --> 00:15:04,080
以及非常像C我們
實際上編譯這個。

310
00:15:04,080 --> 00:15:10,640
因此，我們可以做到這一點通過使用
迅速c和再1.swift。

311
00:15:10,640 --> 00:15:13,850
再經過一對夫婦
分鐘，這將編譯

312
00:15:13,850 --> 00:15:16,340
然後我可以運行的項目之一。

313
00:15:16,340 --> 00:15:19,691
而比它只會說“你好CS50。”

314
00:15:19,691 --> 00:15:20,690
真棒，所以我們走。

315
00:15:20,690 --> 00:15:22,273
還有我們的第一個Hello World程序。

316
00:15:22,273 --> 00:15:24,790
讓我們繼續前進到第二位。

317
00:15:24,790 --> 00:15:30,450
>> 現在在this--這種情況已經改變
咯，因為正常而你

318
00:15:30,450 --> 00:15:34,720
do--其實總是你有來
編譯，然後迅速的應用

319
00:15:34,720 --> 00:15:37,180
實際運行它 -  1
的強大功能

320
00:15:37,180 --> 00:15:40,230
我之前提到的是，
SWIFT實際上可以在排序中使用

321
00:15:40,230 --> 00:15:43,390
的偽解釋方式，存在
其實像一個解釋。

322
00:15:43,390 --> 00:15:46,690
但是，這將做的是有
是的，其實，迅速應用

323
00:15:46,690 --> 00:15:47,520
你可以運行。

324
00:15:47,520 --> 00:15:51,050
>> 因此，例如，如果你只需要輸入
迅速在這裡，會發生什麼

325
00:15:51,050 --> 00:15:52,330
是，你會得到一個提示。

326
00:15:52,330 --> 00:15:59,040
你可以輸入你的SWIFT
碼，打印打招呼，並運行它。

327
00:15:59,040 --> 00:16:01,867
它實際上將print--
同時，它並沒有在這種情況下，打印

328
00:16:01,867 --> 00:16:04,450
因為它打印到中心
出來，這是不可見這裡。

329
00:16:04,450 --> 00:16:06,660
但它實際上是能夠發揮作用。

330
00:16:06,660 --> 00:16:09,580
所以在這種情況下，我只是
將使用這個作為一個腳本。

331
00:16:09,580 --> 00:16:11,259
我可以實際運行這段代碼出現。

332
00:16:11,259 --> 00:16:13,800
所以，我實際運行的方式
它會略有不同，

333
00:16:13,800 --> 00:16:15,710
但你會看到，在短短的時刻。

334
00:16:15,710 --> 00:16:18,890
現在，在這種情況下，我們要去
做的是先定義一個變量。

335
00:16:18,890 --> 00:16:22,160
所以這是我們如何定義
在一個迅速變化，

336
00:16:22,160 --> 00:16:25,900
在我們使用let關鍵字，其次
由變量的名稱，

337
00:16:25,900 --> 00:16:29,280
然後我們提供了一些
可選初始化數據。

338
00:16:29,280 --> 00:16:34,660
所以，這種情況下，我們定義
一個叫名字不變，

339
00:16:34,660 --> 00:16:37,775
我們打算使用，在
我們的印刷線的輸出

340
00:16:37,775 --> 00:16:39,590
在最底層，你好名。

341
00:16:39,590 --> 00:16:43,260
>> 現在可以看到，而不是用％s，
我們可以封裝這個名字

342
00:16:43,260 --> 00:16:49,960
在/變量（），並能夠
串聯在這個內容

343
00:16:49,960 --> 00:16:51,790
字符串這個字符串。

344
00:16:51,790 --> 00:16:56,510
現在不像C，字符串是一個
實際真正的類型迅速。

345
00:16:56,510 --> 00:16:59,240
所以它旁邊坐
整數和旁邊

346
00:16:59,240 --> 00:17:02,220
很容易雙打
自然比較

347
00:17:02,220 --> 00:17:05,450
的一些其它的
我們已經看到的語言。

348
00:17:05,450 --> 00:17:07,980
因此，這實際上起作用
就像你所期望的。

349
00:17:07,980 --> 00:17:10,540
>> 我可以運行2.swift。

350
00:17:10,540 --> 00:17:14,390
而且我們看到，我的名字是
實際上拼接，“你好丹”。

351
00:17:14,390 --> 00:17:16,050
OK，真棒。

352
00:17:16,050 --> 00:17:17,485
移動到第三位。

353
00:17:17,485 --> 00:17:19,359
現在是一點點
一個善意的謊言中，我

354
00:17:19,359 --> 00:17:23,369
說，我們申報的方式
變量是使用let關鍵字。

355
00:17:23,369 --> 00:17:27,640
因為你可能可以做很多次
想用讓，因為那是什麼呢

356
00:17:27,640 --> 00:17:29,280
是它定義一個常數。

357
00:17:29,280 --> 00:17:33,010
並告訴迅疾之能
優化您的應用程序的速度

358
00:17:33,010 --> 00:17:36,230
因為它知道了
變量是不會改變的。

359
00:17:36,230 --> 00:17:38,760
>> 所以仔細評估
當你要使用

360
00:17:38,760 --> 00:17:41,382
為可變
目的改變它。

361
00:17:41,382 --> 00:17:43,340
而當你要
只要創建一個變量

362
00:17:43,340 --> 00:17:47,010
舉辦一些數據，這是
實際上並不打算改變。

363
00:17:47,010 --> 00:17:50,150
所以永恆的概念，
它實際上並不打算改變，

364
00:17:50,150 --> 00:17:53,740
是一個重要的甚至
遠了界定變量。

365
00:17:53,740 --> 00:17:56,870
所以在這裡我們定義了一個名字，
讓名，在此情況下

366
00:17:56,870 --> 00:18:02,120
這是一個常數，即類型
字符串，它等於丹。

367
00:18:02,120 --> 00:18:05,580
>> 如此，而在現有
版本，它infers--和“它”

368
00:18:05,580 --> 00:18:08,220
我的意思是swift--迅速
推斷的數據的類型

369
00:18:08,220 --> 00:18:10,850
我們已經進入了變數。

370
00:18:10,850 --> 00:18:12,930
在這種情況下，我們可以明確的。

371
00:18:12,930 --> 00:18:17,590
因此，讓這則名
變量的名字，然後一個冒號。

372
00:18:17,590 --> 00:18:21,350
和冒號後面我們做的
指定的數據的類型。

373
00:18:21,350 --> 00:18:24,694
因此，不再是INT名稱或
字符串名稱或類似的東西。

374
00:18:24,694 --> 00:18:26,860
而是讓標籤，我們
定義是否

375
00:18:26,860 --> 00:18:29,090
它是恆定的或可變的，
其次是名稱，

376
00:18:29,090 --> 00:18:31,870
接著由類型任選。

377
00:18:31,870 --> 00:18:34,730
>> 因此，在這種情況下，我們定義
這個名字是一個字符串。

378
00:18:34,730 --> 00:18:35,790
我們說的是丹。

379
00:18:35,790 --> 00:18:39,270
現在我有另一個變量，
在這種情況下，它被稱為標籤。

380
00:18:39,270 --> 00:18:42,090
但是請注意，這是
前面加上var關鍵字。

381
00:18:42,090 --> 00:18:44,430
var關鍵字手段
這個變量可以

382
00:18:44,430 --> 00:18:48,720
在稍後的點被改變
時間，在代碼中某處

383
00:18:48,720 --> 00:18:52,480
我們能不能改變它，它
不會給我們任何特定的錯誤。

384
00:18:52,480 --> 00:18:56,760
>> 我們可以做標準的串聯
運營商在這裡使用的加號

385
00:18:56,760 --> 00:19:00,130
實際添加我們
命名為這個字符串。

386
00:19:00,130 --> 00:19:02,921
然後我們就可以打印出
正如我們所看到剛才。

387
00:19:02,921 --> 00:19:04,920
現在，讓我們說你
要創建一個變量

388
00:19:04,920 --> 00:19:06,586
但你不想初始化它。

389
00:19:06,586 --> 00:19:08,590
你還沒有想
把其中的任何數據。

390
00:19:08,590 --> 00:19:11,760
那麼你要告訴
數據迅速什麼類型

391
00:19:11,760 --> 00:19:16,430
將是之前你可以
其實正確的定義。

392
00:19:16,430 --> 00:19:20,360
>> 因此，在這種情況下，當我們定義
一個變量稱為檔次，我們必須要

393
00:19:20,360 --> 00:19:24,450
明確的關於它的類型，因為
它不能推斷只是尋找

394
00:19:24,450 --> 00:19:27,300
在初始化數據
您提供給它。

395
00:19:27,300 --> 00:19:30,050
它將給我們，如果你一個錯誤
剛型變種等級，例如，

396
00:19:30,050 --> 00:19:31,830
因為它沒有類型因此。

397
00:19:31,830 --> 00:19:33,353
所以，品位= 100。

398
00:19:33,353 --> 00:19:35,790
使100是一個整數，它
適合非常漂亮成。

399
00:19:35,790 --> 00:19:36,998
它將繼續發揮作用。

400
00:19:36,998 --> 00:19:40,350

401
00:19:40,350 --> 00:19:43,022
我們可以看到那我們
可以串聯這一點。

402
00:19:43,022 --> 00:19:44,730
現在，你可能會
動心了，如果你真的

403
00:19:44,730 --> 00:19:48,610
想串接
等級到另一個文本字符串，

404
00:19:48,610 --> 00:19:52,560
到另一個字符串，你只想
使用該相同的串聯操作者。

405
00:19:52,560 --> 00:19:54,630
而且，通常會是正確的。

406
00:19:54,630 --> 00:20:00,540
但是，迅速將不允許
隱式修改的數據的類型。

407
00:20:00,540 --> 00:20:03,440
因此，在這種情況下，該
線，25，將失敗

408
00:20:03,440 --> 00:20:06,650
因為等級是
整數，而不是字符串。

409
00:20:06,650 --> 00:20:08,760
所以有不匹配set of類型。

410
00:20:08,760 --> 00:20:11,780
所以，你必須時要明確
要改變這種數據，

411
00:20:11,780 --> 00:20:14,080
當你想強迫該
數據轉換成另一種類型

412
00:20:14,080 --> 00:20:17,250
並說，OK，我要帶
這個檔次的，這是一個整數，

413
00:20:17,250 --> 00:20:19,050
並將其轉換為一個字符串。

414
00:20:19,050 --> 00:20:23,970
>> 所以我採取資本弦樂所有
類型，你會發現，有資本，

415
00:20:23,970 --> 00:20:26,280
INT，雙，字符串，等等等等。

416
00:20:26,280 --> 00:20:28,930
所有這些都是資本
只是為了讓事情變得更容易。

417
00:20:28,930 --> 00:20:32,240
我們會說資本
字符串傳遞進去檔次。

418
00:20:32,240 --> 00:20:35,020
它會創建一個
串出的整數。

419
00:20:35,020 --> 00:20:37,970
然後我們可以連接
兩個非常漂亮。

420
00:20:37,970 --> 00:20:40,500
對這個東西至今有任何疑問？

421
00:20:40,500 --> 00:20:43,770
好吧，讓我們來犁
通過對排名第四。

422
00:20:43,770 --> 00:20:47,870
>> 現在，讓我們來談談一些更高級
結構，像數組和循環。

423
00:20:47,870 --> 00:20:54,920
不像C，陣列迅速
不是由指針表示。

424
00:20:54,920 --> 00:20:58,730
在迅速的三分球，
儘管它們存在，稱為

425
00:20:58,730 --> 00:21:02,840
像不安全的指針或
一些相似的類型是這樣，

426
00:21:02,840 --> 00:21:04,950
他們沒有接觸到你正常。

427
00:21:04,950 --> 00:21:07,300
所以就變得非常困難
為您操作

428
00:21:07,300 --> 00:21:10,020
直接在您的計算機的內存中。

429
00:21:10,020 --> 00:21:11,670
>> 這樣的陣列僅僅是數據類型。

430
00:21:11,670 --> 00:21:16,830
而他們正在使用這種引用
現在標準的方括號

431
00:21:16,830 --> 00:21:18,280
那你以前見過。

432
00:21:18,280 --> 00:21:21,130
但是，當你真正想要
定義類型的變量的

433
00:21:21,130 --> 00:21:24,330
由於一些陣列
特殊類型，那麼你

434
00:21:24,330 --> 00:21:27,150
把這種類型的方括號中。

435
00:21:27,150 --> 00:21:30,260
還等什麼，我想說的是，
我創建了一個名為變量

436
00:21:30,260 --> 00:21:33,930
等級類型為int數組。

437
00:21:33,930 --> 00:21:37,380
和我設置了等於一些
初始化的數據，在這種情況下

438
00:21:37,380 --> 00:21:42,960
是100時，0，90，85，這僅僅是一個
收集任意等級這裡。

439
00:21:42,960 --> 00:21:46,480
現在，在這種情況下，我可以，
請記住，刪除類型，

440
00:21:46,480 --> 00:21:49,580
並且這將是能夠推斷它
基於所述初始化數據。

441
00:21:49,580 --> 00:21:51,990
但是，如果我刪除這一點，
我需要以後設置，

442
00:21:51,990 --> 00:21:56,840
那麼我將不得不確保
我有存在的類型。

443
00:21:56,840 --> 00:21:58,750
好吧，讓我們沿著。

444
00:21:58,750 --> 00:22:03,010
所以我們can--陣列
向我們提供了多種

445
00:22:03,010 --> 00:22:07,130
通過這點符號方法
你可能現在熟悉了。

446
00:22:07,130 --> 00:22:10,360
所以grades.count例如
告訴我們恰恰數量

447
00:22:10,360 --> 00:22:13,680
那些元素
包含在此數組中。

448
00:22:13,680 --> 00:22:17,260
>> 如果我想補充additional--
現在發現，這是一個變種

449
00:22:17,260 --> 00:22:20,140
而不是 - 這是一個變量
而不是一個常數，它

450
00:22:20,140 --> 00:22:24,410
意味著我可以改變的內容
這陣，我可以添加對象吧。

451
00:22:24,410 --> 00:22:28,870
但我不能只說成績
然後在方括號

452
00:22:28,870 --> 00:22:33,280
4，因為這將是一個
出在這種情況下，邊界錯誤。

453
00:22:33,280 --> 00:22:36,190
如果我想真正改變
此數組的大小，

454
00:22:36,190 --> 00:22:41,140
我必須使用點追加方法
添加的東西到它的盡頭。

455
00:22:41,140 --> 00:22:46,900
我可以，但是，變化
個人指標。

456
00:22:46,900 --> 00:22:48,920
>> 所以，我可以用成績
然後括號

457
00:22:48,920 --> 00:22:52,480
零操縱這首指數
等等，就像你通常會期望。

458
00:22:52,480 --> 00:22:56,530
我可以做同樣的實際
接收來自該數據為好。

459
00:22:56,530 --> 00:23:00,420
現在，這裡還有幾分看中方法
中這樣做，等級加等號

460
00:23:00,420 --> 00:23:02,525
然後另一個索引，
這將append--

461
00:23:02,525 --> 00:23:04,400
或者沒有其它index--
但另一個名單，

462
00:23:04,400 --> 00:23:07,340
將追加該列表
以牌號的背面。

463
00:23:07,340 --> 00:23:09,780
和等級將
那麼包含了這一切。

464
00:23:09,780 --> 00:23:13,850
但是，這是某種額外的東西
說我只是顯示你的樂趣。

465
00:23:13,850 --> 00:23:14,910
>> 現在有一個for循環。

466
00:23:14,910 --> 00:23:18,970
這就是，其中的起始
事情開始改變一點點。

467
00:23:18,970 --> 00:23:22,920
請注意這個for循環
來自於C.循環不同

468
00:23:22,920 --> 00:23:26,470
現在，我會注意到，
在斯威夫特循環可以

469
00:23:26,470 --> 00:23:30,650
做出看起來像在C環，但
還有很多更實用構造

470
00:23:30,650 --> 00:23:37,840
，基本上消除了
要對VAR i等於0分號我

471
00:23:37,840 --> 00:23:40,340
小於一定長度，
等等等等，對不對？

472
00:23:40,340 --> 00:23:42,940
並且該構建僅僅是其中之一。

473
00:23:42,940 --> 00:23:49,030
>> 對於指數，指數新
可變的，在這種情況下，在範圍內。

474
00:23:49,030 --> 00:23:52,730
而且我說的是，有
範圍從0一路攀升至

475
00:23:52,730 --> 00:23:55,870
但不包括grades.count。

476
00:23:55,870 --> 00:23:58,470
所以這點少點
比符號代表

477
00:23:58,470 --> 00:24:05,040
從零開始的值的範圍
一路攀升至grades.count減1。

478
00:24:05,040 --> 00:24:07,070
有一個單獨的
運營商存在，

479
00:24:07,070 --> 00:24:13,320
這是點點點，這將
意思是，我想零的範圍

480
00:24:13,320 --> 00:24:16,310
以等級計的包容性。

481
00:24:16,310 --> 00:24:19,130
>> 但在這種情況下，因為這些
數組是零索引，我們當然

482
00:24:19,130 --> 00:24:23,290
不想去的
等級的最大數量。

483
00:24:23,290 --> 00:24:26,390
我總結了成績，你可能
預計，輸出這一切的東西。

484
00:24:26,390 --> 00:24:29,620
OK，繼續前進。

485
00:24:29,620 --> 00:24:32,270
現在，讓我們來談談功能。

486
00:24:32,270 --> 00:24:35,465
為了定義函數
你用芬克關鍵字。

487
00:24:35,465 --> 00:24:38,090
再次，在斯威夫特你必須
要非常小心的類型。

488
00:24:38,090 --> 00:24:41,530
您提供給它的參數
通過定義，例如，

489
00:24:41,530 --> 00:24:45,440
參數的名稱和
然後在科林，數據的類型

490
00:24:45,440 --> 00:24:47,690
你期望
參數接受。

491
00:24:47,690 --> 00:24:50,700
>> 所以在這種情況下，我們有一個
函數調用印刷級計數。

492
00:24:50,700 --> 00:24:54,630
它接受一個名為成績冊的變量，
或者更確切地說，一個參數叫成績冊。

493
00:24:54,630 --> 00:24:59,267
而我們期待的成績簿
是一個整數數組。

494
00:24:59,267 --> 00:25:01,350
如果成績簿是空的，
我們將打印一件事。

495
00:25:01,350 --> 00:25:06,090
否則，我們將打印出的號碼
的成績，這實際上有。

496
00:25:06,090 --> 00:25:09,470
>> 現在，如果我們想返回
一些值，則方法

497
00:25:09,470 --> 00:25:14,595
我們修改這個定義
實際使用此箭頭關鍵字，

498
00:25:14,595 --> 00:25:16,870
或使用本箭頭指。

499
00:25:16,870 --> 00:25:19,440
所以在這裡我們要定義
一個函數調用的平均水平。

500
00:25:19,440 --> 00:25:21,940
我們要接受一個數字列表。

501
00:25:21,940 --> 00:25:25,430
而且我們要返回
雙，這將有望

502
00:25:25,430 --> 00:25:31,270
在這個數組的平均值。

503
00:25:31,270 --> 00:25:34,570
並且為了做到這一點，為了
去實際計算該平均值，

504
00:25:34,570 --> 00:25:38,651
我們將採取我們的總和，並
當然，總結所有的對象

505
00:25:38,651 --> 00:25:39,400
這個數組中。

506
00:25:39,400 --> 00:25:41,480
>> 請注意，有一個新的
風格的for循環在這裡。

507
00:25:41,480 --> 00:25:45,450
我們不必是明確約
遍歷每一個元素，

508
00:25:45,450 --> 00:25:48,280
但我們可以說的，而不是為
等級和成績冊，意義

509
00:25:48,280 --> 00:25:50,930
對於每一個
項目，我們在這一點，

510
00:25:50,930 --> 00:25:53,482
提供這該項目
變量稱為檔次。

511
00:25:53,482 --> 00:25:54,940
我想用它做什麼。

512
00:25:54,940 --> 00:26:00,350
所以我要來概括所有數據
實際上返回雙師。

513
00:26:00,350 --> 00:26:04,436
>> 現在注意這裡再次出現了
概念斯威夫特整數除法。

514
00:26:04,436 --> 00:26:06,810
如果你想雙師
因為你想小數，

515
00:26:06,810 --> 00:26:09,460
那麼你必須要明確，
不只是一個側面，

516
00:26:09,460 --> 00:26:14,030
因為它不會讓你
強迫在這兩邊的數據，

517
00:26:14,030 --> 00:26:17,030
你必須真正當然
雙方進入雙打均

518
00:26:17,030 --> 00:26:19,440
讓你很
明確關於確保

519
00:26:19,440 --> 00:26:23,370
你做雙師。

520
00:26:23,370 --> 00:26:26,150
>> 讓我們繼續前進。

521
00:26:26,150 --> 00:26:31,150
所以，如果我真的想accept--
所以在這個特定例子中，

522
00:26:31,150 --> 00:26:34,260
這仍然是一個命令
行的應用程序。

523
00:26:34,260 --> 00:26:37,920
我們已經開始看到一些
年輕的語言的局限性

524
00:26:37,920 --> 00:26:41,850
中，雖然我們可以
通過訪問這些參數

525
00:26:41,850 --> 00:26:44,940
這process.arguments，它的
仍未必最乾淨

526
00:26:44,940 --> 00:26:46,200
我們見過的東西。

527
00:26:46,200 --> 00:26:49,142
但基本上，我鼓勵你
要排序看這個代碼

528
00:26:49,142 --> 00:26:51,100
和揣摩
究竟是怎麼回事。

529
00:26:51,100 --> 00:26:55,030
>> 從本質上發生了什麼事是，
我們正在採取的參數列表

530
00:26:55,030 --> 00:26:57,610
並強迫他們進入
整數，然後我們

531
00:26:57,610 --> 00:27:03,620
將要使用，作為一種方式來打印
我們所有的等級的平均值。

532
00:27:03,620 --> 00:27:06,150

533
00:27:06,150 --> 00:27:07,350
前進。

534
00:27:07,350 --> 00:27:11,190
現在有另一種類型的數據 - 
另一種數據類型，而不是數組

535
00:27:11,190 --> 00:27:14,940
稱為字典，這是非常
類似哈希表或哈希地圖

536
00:27:14,940 --> 00:27:18,560
和類似也
PHP的關聯數組。

537
00:27:18,560 --> 00:27:20,770
因此，他們有想法
的密鑰和值。

538
00:27:20,770 --> 00:27:23,780
>> 而且他們還與定義
此方括號，

539
00:27:23,780 --> 00:27:26,750
但不同的是
該字典有

540
00:27:26,750 --> 00:27:29,370
裡面的方括號，冒號。

541
00:27:29,370 --> 00:27:33,850
和結腸分離數據
鍵入是鍵和值。

542
00:27:33,850 --> 00:27:38,540
因此，在這種情況下，我要創建
字典接受一些成績。

543
00:27:38,540 --> 00:27:44,200
它將會是
字符串類型：INT，

544
00:27:44,200 --> 00:27:46,940
這意味著所有的
密鑰將是字符串，

545
00:27:46,940 --> 00:27:53,080
和所有那些的值的
密鑰將是整數。

546
00:27:53,080 --> 00:27:55,780
>> 這意味著，我可以
然後引用該特定數據

547
00:27:55,780 --> 00:28:00,490
我想用這些鍵，而
比使用數字索引像我

548
00:28:00,490 --> 00:28:04,350
將有一個標準的陣列。

549
00:28:04,350 --> 00:28:06,470
現在，讓我們來看看，有
一個重要的事情

550
00:28:06,470 --> 00:28:10,790
我也想提一提
這個代碼特定序列。

551
00:28:10,790 --> 00:28:12,910
那就是有
另一種類型的數據，

552
00:28:12,910 --> 00:28:15,580
或者說有這
數據的想法是

553
00:28:15,580 --> 00:28:18,340
包含在斯威夫特叫自選。

554
00:28:18,340 --> 00:28:21,270
>> 什麼自選的意思是
它承認的事實

555
00:28:21,270 --> 00:28:27,500
有時你不打算
讓你真正期望的數據。

556
00:28:27,500 --> 00:28:31,400
所以我的意思是is--我們
看看這個代碼序列

557
00:28:31,400 --> 00:28:38,910
它遍歷所有的
傳遞給這個代碼參數

558
00:28:38,910 --> 00:28:43,460
並試圖將它們轉換，嘗試
分裂成各種字符串，

559
00:28:43,460 --> 00:28:47,310
因為它接受一個非常
特定類型的說法。

560
00:28:47,310 --> 00:28:51,530
然後它會嘗試強制
表示數字的字符串

561
00:28:51,530 --> 00:28:55,460
到整數的成績，
我可以再計算。

562
00:28:55,460 --> 00:28:58,230
>> 所以基本上我要
使用這種拆分功能

563
00:28:58,230 --> 00:29:00,080
內部存在
雨燕標準庫。

564
00:29:00,080 --> 00:29:03,720
我將傳遞到它的
我想分裂字符串。

565
00:29:03,720 --> 00:29:06,980
然後在使用該
那種時髦的語法，這

566
00:29:06,980 --> 00:29:09,670
我不知道我們是否會
拿地，但也許，我們

567
00:29:09,670 --> 00:29:14,320
實際上指定精確
字符，我們要分割的。

568
00:29:14,320 --> 00:29:16,030
那麼，這實際上是什麼樣子的？

569
00:29:16,030 --> 00:29:18,740
讓我們來看看
實際運行這段代碼。

570
00:29:18,740 --> 00:29:22,000
>> 因此，舉例來說，假設我有
一個測驗，我得到了50上。

571
00:29:22,000 --> 00:29:23,960
我有一個pset和
我上了一百年。

572
00:29:23,960 --> 00:29:29,180
我got--還有另外一個
測驗，我得到了40上。

573
00:29:29,180 --> 00:29:33,520
我敲回車，並最終什麼
會發生的是，它在做什麼

574
00:29:33,520 --> 00:29:37,730
正在這些參數，分裂
這些冒號的字符串，

575
00:29:37,730 --> 00:29:41,390
認識到有
在每一個兩個元件，

576
00:29:41,390 --> 00:29:43,700
和它的本質
跟踪每一個。

577
00:29:43,700 --> 00:29:49,226
>> 所以，我有我的字典測驗，其
值由數字50表示，

578
00:29:49,226 --> 00:29:54,290
我有一個PSET有100個值，
和一個測驗1，其具有40的值。

579
00:29:54,290 --> 00:29:57,400
後來在我的代碼
實際上平均所有這些值

580
00:29:57,400 --> 00:30:01,160
並列出所有的鑰匙
特定的字典。

581
00:30:01,160 --> 00:30:03,217
但是，這是很重要
這樣您就可以看到

582
00:30:03,217 --> 00:30:06,050
正在發生的事情，是我們
想要做的就是採取這種字符串

583
00:30:06,050 --> 00:30:11,450
並在這個角色拆分它，
我們可以用這個分裂再做

584
00:30:11,450 --> 00:30:15,690
使用這種功能
有趣的語法，在這裡存在。

585
00:30:15,690 --> 00:30:17,880
>> 只是現在認為這是確定。

586
00:30:17,880 --> 00:30:19,980
我們將看到更多的這種
在短短的一小會兒。

587
00:30:19,980 --> 00:30:23,230
但是現在有一個有趣的
我們實際上是縱橫

588
00:30:23,230 --> 00:30:27,250
想嘗試將其轉換
字符串轉換為整數。

589
00:30:27,250 --> 00:30:29,720
但在其他語言
什麼可能發生的情況是

590
00:30:29,720 --> 00:30:33,440
我們可能會嘗試
要做到這一點，要么拿回

591
00:30:33,440 --> 00:30:36,185
一些定點
價值像負一層

592
00:30:36,185 --> 00:30:39,420
或者一個空或類似的東西。

593
00:30:39,420 --> 00:30:41,070
或者，也許它只是導致了錯誤。

594
00:30:41,070 --> 00:30:42,820
我們將不得不
再搭上這個錯誤

595
00:30:42,820 --> 00:30:44,820
然後嘗試做
一些基於這樣的事實

596
00:30:44,820 --> 00:30:48,280
這種轉換
為整數失敗。

597
00:30:48,280 --> 00:30:50,460
這就是這個想法
自選的用武之地。

598
00:30:50,460 --> 00:30:56,120
實際上，你可以創建一個數據類型
是一個int問號，例如。

599
00:30:56,120 --> 00:30:59,140

600
00:30:59,140 --> 00:31:01,910
這意味著，該整數
是，實際上，可選的。

601
00:31:01,910 --> 00:31:05,980
並會發生什麼事是，它可能
包含一個整數，也可能不會。

602
00:31:05,980 --> 00:31:10,650
它可以是，事實上，是這樣的其他
的想法，完全是被稱為NILL。

603
00:31:10,650 --> 00:31:14,900
其中這意味著有
沒有任何價值在於此。

604
00:31:14,900 --> 00:31:16,810
它甚至不是零，
這裡還有沒有價值。

605
00:31:16,810 --> 00:31:18,790
有代表完全沒有價值。

606
00:31:18,790 --> 00:31:21,650
>> 而這正是該行71在做什麼。

607
00:31:21,650 --> 00:31:25,990
是，它是說，我
想嘗試設置的值，

608
00:31:25,990 --> 00:31:31,790
一個名為分級變量，等於
這種轉換成字符串一個int。

609
00:31:31,790 --> 00:31:34,010
所以，我已經採取了這個字符串，
這第一個組件，

610
00:31:34,010 --> 00:31:37,680
或者更確切地說，第二
元件，因為這

611
00:31:37,680 --> 00:31:40,770
是零索引的這一點，
字符串，我已經分裂。

612
00:31:40,770 --> 00:31:42,930
我想轉換
該為整數。

613
00:31:42,930 --> 00:31:46,730
但它並不總是進行
通常情況下，因為想像

614
00:31:46,730 --> 00:31:50,710
如果會發生什麼，而不是類型
一個數字，I型，當然像航空自衛隊。

615
00:31:50,710 --> 00:31:51,534
>> 它會失敗。

616
00:31:51,534 --> 00:31:54,200
它實際上並不將會
能夠將其轉換成一個整數

617
00:31:54,200 --> 00:31:55,510
正如我所期望的。

618
00:31:55,510 --> 00:31:58,660
因此，而不是開球
某種錯誤的，

619
00:31:58,660 --> 00:32:01,210
我們有這樣的想法可選的。

620
00:32:01,210 --> 00:32:04,240
這意味著，使用
這個問號，我可以說，

621
00:32:04,240 --> 00:32:09,100
OK，是有可能，我可以帶
這一點，將它轉換成一個int，

622
00:32:09,100 --> 00:32:12,630
並把它變成一個變量，
這也將是一個int。

623
00:32:12,630 --> 00:32:15,420
如果是這樣，則該裝置
說，這是成功的

624
00:32:15,420 --> 00:32:18,720
與該第一部
該塊可以繼續。

625
00:32:18,720 --> 00:32:21,040
>> 否則，它將失敗。

626
00:32:21,040 --> 00:32:25,840
有一個在grade--沒有價值或
而沒有在現有的沒有價值，

627
00:32:25,840 --> 00:32:30,220
實際上我不得不嘗試
處理這種錯誤情況。

628
00:32:30,220 --> 00:32:33,340
你會看到這
問號所有的時間

629
00:32:33,340 --> 00:32:35,990
在斯威夫特和對雨燕的示例代碼。

630
00:32:35,990 --> 00:32:40,980
而事實上NILL運營商，這種
的問號，在自選部分，

631
00:32:40,980 --> 00:32:45,057
將是大概1
更困難的事情

632
00:32:45,057 --> 00:32:47,640
排序的周圍包裹你的頭
當你真正使用它。

633
00:32:47,640 --> 00:32:48,490
>> 它可能是有意義了。

634
00:32:48,490 --> 00:32:50,760
而事實上，當我
編寫示例代碼這一點，

635
00:32:50,760 --> 00:32:52,780
我當然明白
發生了什麼事情，

636
00:32:52,780 --> 00:32:55,570
但還是被抓住了我
驚喜每隔一段時間

637
00:32:55,570 --> 00:32:58,370
當我發現，
一些數據實際上是

638
00:32:58,370 --> 00:33:04,024
一個零的版本，可選的版本
數據是我所期待的。

639
00:33:04,024 --> 00:33:06,190
因此，只要意識到，如果
有一個可選的版本

640
00:33:06,190 --> 00:33:09,360
你必須解開的
從這個框數據。

641
00:33:09,360 --> 00:33:15,870
>> 因此，這有點像我 - 想像一下，如果你
有一個盒子，它包含的東西。

642
00:33:15,870 --> 00:33:18,490
而你需要做的
是要問的問題，

643
00:33:18,490 --> 00:33:22,800
有沒有可能，這個盒子其實
包含了我要找的數據？

644
00:33:22,800 --> 00:33:28,180
如果是這樣，則拔出該數據輸出和
把它放到這個變量存在。

645
00:33:28,180 --> 00:33:32,080
如果沒有，那麼我只需要
忽略此框的內容

646
00:33:32,080 --> 00:33:34,310
完全是因為它
從字面上包含什麼。

647
00:33:34,310 --> 00:33:36,880

648
00:33:36,880 --> 00:33:40,400
>> 這方面的問題嗎？

649
00:33:40,400 --> 00:33:44,430
OK，讓我們遠離本
排序基於命令行的事

650
00:33:44,430 --> 00:33:47,610
並開始尋找
一些技術

651
00:33:47,610 --> 00:33:53,060
這Xcode提供給我們
在操場的形式。

652
00:33:53,060 --> 00:33:56,669
所以這是一個很大的
這裡的能力與斯威夫特。

653
00:33:56,669 --> 00:33:59,210
如果你打開Xcode中，它
問你想要做什麼，

654
00:33:59,210 --> 00:34:01,340
你可以打開操場
和剛玩

655
00:34:01,340 --> 00:34:06,200
有很多不同結構的
語言和方面

656
00:34:06,200 --> 00:34:11,800
之前，你甚至開始接觸
iOS的SDK或Mac的SDK。

657
00:34:11,800 --> 00:34:15,670
>> 所以這種情況下，讓我們說，我have--
我有一個相對人為的例子

658
00:34:15,670 --> 00:34:18,460
在這裡，但我承擔，因為我們排序
通過本實施例的工作。

659
00:34:18,460 --> 00:34:22,639
比方說，我們做了很多
指數與一固定值，

660
00:34:22,639 --> 00:34:26,397
就像我們知道我們將需要
做了很多方形的權力，例如。

661
00:34:26,397 --> 00:34:28,980
因此，我們要採取一些價值
X，我們要正視它，

662
00:34:28,980 --> 00:34:30,540
我們要採取一些價值
y和我們要正視它。

663
00:34:30,540 --> 00:34:31,780
等等等等。

664
00:34:31,780 --> 00:34:35,549
>> 現在，我們實際上可能只是創建一個
2功能，這種力量，對不對？

665
00:34:35,549 --> 00:34:37,090
所以我們會創建2功能的電源。

666
00:34:37,090 --> 00:34:38,600
我們將接受一個雙。

667
00:34:38,600 --> 00:34:41,489
我們將output--否則我們將
返回double類型。

668
00:34:41,489 --> 00:34:46,159
我們將這一結果
然後兩次

669
00:34:46,159 --> 00:34:52,040
其實我們需要的結果，這
被初始化到1的值，

670
00:34:52,040 --> 00:34:53,090
並用x乘以它。

671
00:34:53,090 --> 00:34:56,540
因此，在本質上，我們有x次X在這裡。

672
00:34:56,540 --> 00:35:01,860
>> 所以後來我能的話，因為我們可能
期待，取2本，運行功率，

673
00:35:01,860 --> 00:35:03,680
提供給它的一些數據，我喜歡2.0。

674
00:35:03,680 --> 00:35:05,756
我們能看到這裡4.0的結果。

675
00:35:05,756 --> 00:35:09,200
運行2開機3.2，我們
能看到我們的結果，10.24。

676
00:35:09,200 --> 00:35:10,840
到目前為止好，對不對？

677
00:35:10,840 --> 00:35:12,070
現在，我們正在想，好了，OK。

678
00:35:12,070 --> 00:35:15,530
現在，我確實需要
做了很多3權力。

679
00:35:15,530 --> 00:35:19,180
所以我會複製粘貼所有這些代碼，
改變從所述函數的名稱

680
00:35:19,180 --> 00:35:24,440
2電源的功率3，和一切
將除該值相同

681
00:35:24,440 --> 00:35:26,740
這裡，該範圍內，1 ... 2。

682
00:35:26,740 --> 00:35:29,590
>> 因此，而不是重複
這個循環兩次，

683
00:35:29,590 --> 00:35:31,880
我想重複這個循環三次。

684
00:35:31,880 --> 00:35:36,330
所以，我只是改變從價值
1至3--或是從2至3。

685
00:35:36,330 --> 00:35:39,230
如此反复，同樣的代碼，
這是唯一的改變。

686
00:35:39,230 --> 00:35:40,080
現在，這也適用。

687
00:35:40,080 --> 00:35:43,860
3功率在2一些價值提供。

688
00:35:43,860 --> 00:35:44,420
我們得到8。

689
00:35:44,420 --> 00:35:45,370
所以，2立方。

690
00:35:45,370 --> 00:35:48,060
和3.2立方是32.768。

691
00:35:48,060 --> 00:35:50,597
到目前為止那麼好，對不對？

692
00:35:50,597 --> 00:35:52,930
但希望這是一個小
紅旗為你的位

693
00:35:52,930 --> 00:35:55,530
在我們現在有
一些代碼重複

694
00:35:55,530 --> 00:35:58,800
除了一些很輕微的
改變從一個到下一個。

695
00:35:58,800 --> 00:36:02,170
所以，有一些方式，
我們也許能夠簡化

696
00:36:02,170 --> 00:36:06,080
這個問題，在這裡我們實際上可以，
在運行時，找出了一些，

697
00:36:06,080 --> 00:36:11,320
向我們提供了一些功能有
正是我們想要的權力。

698
00:36:11,320 --> 00:36:13,960
>> 並有這個想法
關閉，這是真的，真的

699
00:36:13,960 --> 00:36:18,180
在斯威夫特的情況下重要的是，
而且在許多其他語言。

700
00:36:18,180 --> 00:36:21,580
但可能你會看到
它使用更多的是在斯威夫特

701
00:36:21,580 --> 00:36:23,650
因為它的嵌入
在語言中

702
00:36:23,650 --> 00:36:28,280
比你在其他
同時現代語言。

703
00:36:28,280 --> 00:36:31,140
所以一個封閉的想法
是這樣的，就是我們

704
00:36:31,140 --> 00:36:35,430
可以具有意指一個函數
是一個通用的功能，通用電源

705
00:36:35,430 --> 00:36:36,860
功能。

706
00:36:36,860 --> 00:36:41,010
>> 並且這個功能是要接受
這一指數，我們實際上

707
00:36:41,010 --> 00:36:42,990
要創建。

708
00:36:42,990 --> 00:36:46,550
因此，例如，第一個
例如，我們希望是2的冪。

709
00:36:46,550 --> 00:36:50,050
因此，我們將提供電力
然後在括號2。

710
00:36:50,050 --> 00:36:52,490
現在注意什麼
這實際上返回。

711
00:36:52,490 --> 00:36:57,680
這需要一個引物的一個輸入端
所謂ÿ該是一個整數，

712
00:36:57,680 --> 00:37:03,090
並返回這個瘋狂的尋找
在parentheses--括號內的事情

713
00:37:03,090 --> 00:37:06,230
雙然後雙箭頭。

714
00:37:06,230 --> 00:37:10,270
>> 這是什麼意思是，我
要返回的函數。

715
00:37:10,270 --> 00:37:13,510
我不回
另一種類型的數據，我

716
00:37:13,510 --> 00:37:16,350
事實上返回一個函數
具有此參數，即

717
00:37:16,350 --> 00:37:22,680
接受一個雙輸入和
輸出一個雙作為返回值。

718
00:37:22,680 --> 00:37:29,750
而作為一個結果，因為現在我已經叫
動力，傳遞一些Y值，

719
00:37:29,750 --> 00:37:32,280
和我創建這個其他
function--通知，有

720
00:37:32,280 --> 00:37:35,980
這是正在創建另一個功能
this--裡面我在做什麼

721
00:37:35,980 --> 00:37:37,830
是我可以再改
該值，即1

722
00:37:37,830 --> 00:37:41,010
我已經改變價值
從2到3，我現在使它y的

723
00:37:41,010 --> 00:37:42,500
>> 而這種情況繼續下去。

724
00:37:42,500 --> 00:37:48,530
所以每次我打電話電源時間
的，基本上會發生什麼

725
00:37:48,530 --> 00:37:51,030
是，我得到返回的功能。

726
00:37:51,030 --> 00:37:54,310
請注意，這裡我定義
一個新的變量叫做廣場。

727
00:37:54,310 --> 00:37:59,340
我已經將它等同於權力，
提供這種價值2的力量。

728
00:37:59,340 --> 00:38:02,030
而這是什麼返回的功能。

729
00:38:02,030 --> 00:38:05,970
所以方時，變量
廣場上，是功能型的，現在

730
00:38:05,970 --> 00:38:11,390
有this--哎呀，滾動了
小bit--有此簽名，

731
00:38:11,390 --> 00:38:15,560
接受雙重輸出雙。

732
00:38:15,560 --> 00:38:17,330
>> 所以，現在我做了什麼
是我已經基本上

733
00:38:17,330 --> 00:38:22,890
創建一個函數調用正方形
接受任何價值，將廣場吧。

734
00:38:22,890 --> 00:38:24,960
我們可以看看會發生什麼到這裡。

735
00:38:24,960 --> 00:38:29,960
廣場3為例，意味著我要去
取值3平方吧。

736
00:38:29,960 --> 00:38:32,010
那麼究竟是如何工作的呢？

737
00:38:32,010 --> 00:38:37,800
當我傳遞2--電源，當我
經過2到功能這個權力，

738
00:38:37,800 --> 00:38:44,430
這個變量y是
填充了值2。

739
00:38:44,430 --> 00:38:46,340
並且在內存中的排序舉行。

740
00:38:46,340 --> 00:38:49,430
那種認為就像在舉行
狀態，在計算機的某處，

741
00:38:49,430 --> 00:38:51,980
我們並不真正關心如何
或如在這一點上。

742
00:38:51,980 --> 00:38:54,692
>> 但我回到這個功能
所謂exponentiate。

743
00:38:54,692 --> 00:38:57,400
再次，它其實並不重要
這是什麼函數被調用，

744
00:38:57,400 --> 00:39:01,730
我們真的可以把它叫做什麼，那
接受雙擊並返回一個double，

745
00:39:01,730 --> 00:39:05,640
但使用此值y它裡面。

746
00:39:05,640 --> 00:39:09,290
因此，即使它的這個功能，
該冪運算功能的

747
00:39:09,290 --> 00:39:13,600
被返回到我
變量，我叫方，

748
00:39:13,600 --> 00:39:17,980
它包含在其內
這個概念是什麼y為。

749
00:39:17,980 --> 00:39:19,070
它會記住。

750
00:39:19,070 --> 00:39:24,810
>> 所以，我每次調用函數，
現在叫方，它使用。

751
00:39:24,810 --> 00:39:27,990
但是，這也意味著我可以
創建使用另一個變量

752
00:39:27,990 --> 00:39:29,120
不同的權力。

753
00:39:29,120 --> 00:39:33,240
這樣我就可以創建一個立方體變量，
例如，提供給它的3次方。

754
00:39:33,240 --> 00:39:37,230
現在立方體實際上採取一些
價值和多維數據集並返回。

755
00:39:37,230 --> 00:39:39,570
所以我們可以看到，我得到
值8出來的。

756
00:39:39,570 --> 00:39:42,720
>> 但是，y值也沒有
改變，因為他們是

757
00:39:42,720 --> 00:39:44,980
在排序自變量舉行。

758
00:39:44,980 --> 00:39:47,480
排序他們舉行
在顯存獨立的空間。

759
00:39:47,480 --> 00:39:51,290
所以立方將永遠有
x到3的功率。

760
00:39:51,290 --> 00:39:55,380
和方總會有
x到2的冪，該

761
00:39:55,380 --> 00:39:58,470
意味著廣場將永遠
平方數，如我所料。

762
00:39:58,470 --> 00:40:01,794
和立方體將始終立方
數字，如我所料。

763
00:40:01,794 --> 00:40:04,960
這也意味著，有時候你可以
得到某種時髦的尋找語法

764
00:40:04,960 --> 00:40:09,030
在這裡你有權力在最
屏幕下方位置，5個電源。

765
00:40:09,030 --> 00:40:11,410
並傳遞到結果。

766
00:40:11,410 --> 00:40:14,670
你調用該函數這
被送回的數目4。

767
00:40:14,670 --> 00:40:17,440
還等什麼本質上這
是4至第五功率，

768
00:40:17,440 --> 00:40:20,830
我們可以看到的結果出現。

769
00:40:20,830 --> 00:40:23,690
隨著我這麼遠嗎？

770
00:40:23,690 --> 00:40:26,620
>> 所以這個想法被稱為閉合，
因為什麼我們基本上做

771
00:40:26,620 --> 00:40:30,610
是我們封裝
一些數據into--排序

772
00:40:30,610 --> 00:40:33,050
包圍該數據的
成一個功能，我們

773
00:40:33,050 --> 00:40:36,240
能夠重複使用此功能。

774
00:40:36,240 --> 00:40:41,480
現在這個語法，雖然實際上可以
簡化大量。

775
00:40:41,480 --> 00:40:45,005
而且有很多的可能性，
在斯威夫特的這種簡化。

776
00:40:45,005 --> 00:40:47,780
那就是什麼樣的
後來的實際看看。

777
00:40:47,780 --> 00:40:51,400
因此，在圖7b的例子中，我們
藉此完全相同的代碼。

778
00:40:51,400 --> 00:40:54,360
>> 但現在，而不是
實際上定義一個函數

779
00:40:54,360 --> 00:40:57,910
這款電源的內部
功能，並給它一個名稱，

780
00:40:57,910 --> 00:41:00,150
然後返回的名稱
該功能，其中

781
00:41:00,150 --> 00:41:02,357
然後被用作一部分
這種封閉，而不是我們

782
00:41:02,357 --> 00:41:03,440
只是要簡化它。

783
00:41:03,440 --> 00:41:06,580
我們不需要此功能來命名。

784
00:41:06,580 --> 00:41:09,760
因此，這是一個企業的概念，
匿名函數在這裡我們可以再

785
00:41:09,760 --> 00:41:15,180
接受作為輸入，括號中的此處，
變量x是double類型。

786
00:41:15,180 --> 00:41:17,250
>> 我們要返回double類型。

787
00:41:17,250 --> 00:41:19,830
然後關鍵字，n為
此功能的開始。

788
00:41:19,830 --> 00:41:22,180
所以看到這一切的
是大括號中

789
00:41:22,180 --> 00:41:25,310
與我們定義的
匿名函數在這裡。

790
00:41:25,310 --> 00:41:29,910
只是一個簡單的方法
定義確切的同樣的事情。

791
00:41:29,910 --> 00:41:30,810
好不好？

792
00:41:30,810 --> 00:41:36,740
但對於斯威夫特居然讓我們
更進一步，簡化甚至更多，

793
00:41:36,740 --> 00:41:40,180
因為我們真的不
關心這個參數是

794
00:41:40,180 --> 00:41:41,700
命名任何特別的事情。

795
00:41:41,700 --> 00:41:48,090
它可以真正被稱為什麼，
我們仍然可以使用第一個參數。

796
00:41:48,090 --> 00:41:53,800
>> 所以其實有這個特殊的
在匿名函數的數據類型，

797
00:41:53,800 --> 00:41:57,710
有這個特別的名字
在匿名函數變量

798
00:41:57,710 --> 00:42:00,280
該下手了
美元符號和代表

799
00:42:00,280 --> 00:42:03,785
參數號，零
索引，對於該功能。

800
00:42:03,785 --> 00:42:05,410
因此，有幾件事情怎麼回事。

801
00:42:05,410 --> 00:42:08,550
在這裡，我要回來，然後
大括號代表的功能，

802
00:42:08,550 --> 00:42:09,050
對不對？

803
00:42:09,050 --> 00:42:13,920
>> 我不定義通知
參數類型或返回類型。

804
00:42:13,920 --> 00:42:16,460
它實際上可以推斷
因為簽名的

805
00:42:16,460 --> 00:42:18,360
這種原始的功能。

806
00:42:18,360 --> 00:42:20,500
因此，我們可以消除
作為一個可能性。

807
00:42:20,500 --> 00:42:25,120
不過，我也可以用美元符號零
代表這個第一個參數那

808
00:42:25,120 --> 00:42:28,200
通過這個匿名函數。

809
00:42:28,200 --> 00:42:31,630
因此簡化甚至更多。

810
00:42:31,630 --> 00:42:32,750
好不好？

811
00:42:32,750 --> 00:42:33,820
到目前為止，一切都很好？

812
00:42:33,820 --> 00:42:36,980
>> 現在，這種類型 - 你
記住這個美元符號為零

813
00:42:36,980 --> 00:42:40,130
我們在這個大括號看到
我們看到的只是一小會兒

814
00:42:40,130 --> 00:42:43,870
以前在這個斯威夫特6的例子嗎？

815
00:42:43,870 --> 00:42:46,560
就在這裡。

816
00:42:46,560 --> 00:42:48,430
請注意，這正是
我們正在尋找，

817
00:42:48,430 --> 00:42:51,580
是，我們已通過
這個split函數

818
00:42:51,580 --> 00:42:55,140
匿名函數
檢查第一個參數

819
00:42:55,140 --> 00:42:57,830
看它是否等於結腸符號。

820
00:42:57,830 --> 00:42:59,830
而這正是什麼
情況的發生，是所有

821
00:42:59,830 --> 00:43:02,320
我們doing--回報
關鍵字暗示

822
00:43:02,320 --> 00:43:05,800
在這個case--我們返回
這個數值在那裡我們比較

823
00:43:05,800 --> 00:43:10,020
針對第一個參數
這種性格結腸。

824
00:43:10,020 --> 00:43:11,730
所以排序的神秘面紗了。

825
00:43:11,730 --> 00:43:17,210
而且你會看到這個結構
很多雨燕的語法，所以做了保留

826
00:43:17,210 --> 00:43:19,400
在當你的頭腦
採取看看這個。

827
00:43:19,400 --> 00:43:21,970
現在，我們可以下車
導軌一點點

828
00:43:21,970 --> 00:43:25,460
去真正看中的那個節目
甚至一些更斯威夫特的權力。

829
00:43:25,460 --> 00:43:27,950
你甚至可以看到一些
這些樣本代碼。

830
00:43:27,950 --> 00:43:29,790
所以這就是為什麼我要去
顯示這個給你。

831
00:43:29,790 --> 00:43:37,260
>> 基本上我們可以做的是，首先
所有的人，這是一種不必要的我

832
00:43:37,260 --> 00:43:41,710
實現這一切權力
如果導入達爾文的代碼，因為

833
00:43:41,710 --> 00:43:46,490
圖書館，它實際上包含一個函數
所謂的戰俘，這是否適合你。

834
00:43:46,490 --> 00:43:50,570
因此，我們可以簡化甚至更多，
有我們的電的功能，現在只需

835
00:43:50,570 --> 00:43:54,890
是一個美妙的單行，我們只需
返回此匿名函數

836
00:43:54,890 --> 00:44:00,780
接受美元符號0作為其
鹼和y為指數。

837
00:44:00,780 --> 00:44:02,582
>> 但是，我們可以得到真正的，
真正看中的，當我們

838
00:44:02,582 --> 00:44:04,790
意識到斯威夫特有
大量的電力引擎蓋下。

839
00:44:04,790 --> 00:44:07,010
很多經營者認為
我們一直在處理，

840
00:44:07,010 --> 00:44:11,270
加號和除法的符號和
所有這些事情，你通常

841
00:44:11,270 --> 00:44:15,620
與數據類型進行操作
在編程語言中，

842
00:44:15,620 --> 00:44:17,600
實際上是可擴展的斯威夫特。

843
00:44:17,600 --> 00:44:21,460
因此，在我們意味著什麼
可以定義我們自己的運營商。

844
00:44:21,460 --> 00:44:26,020
>> 所以，現在我累了打字的這一切
POW然後一個括號，然後

845
00:44:26,020 --> 00:44:26,520
基。

846
00:44:26,520 --> 00:44:27,520
我不想這樣做。

847
00:44:27,520 --> 00:44:30,190
其實我是想有一個
運營商，可以讓我這樣做。

848
00:44:30,190 --> 00:44:34,510
所以，我可以告訴雨燕，我想
創建操作員，星

849
00:44:34,510 --> 00:44:39,472
通過我不能用克拉的方式star--
因為克拉是一個操作符

850
00:44:39,472 --> 00:44:40,680
做別的東西完全。

851
00:44:40,680 --> 00:44:42,720
所以我不想排序
對碰撞的。

852
00:44:42,720 --> 00:44:45,750
還等什麼，你在各種看看
語言，包括Python，

853
00:44:45,750 --> 00:44:48,810
就像星級星級運營商
代表指數。

854
00:44:48,810 --> 00:44:50,730
>> 所以這是唯一的原因
為什麼我已經做到了。

855
00:44:50,730 --> 00:44:53,067
它的將是
中綴式操作。

856
00:44:53,067 --> 00:44:54,900
我不得不提供
它的一些信息

857
00:44:54,900 --> 00:44:58,386
關於這個優先
運營商因此它的左結合。

858
00:44:58,386 --> 00:45:00,260
這就像比較
高優先級比較

859
00:45:00,260 --> 00:45:02,432
求和或乘法。

860
00:45:02,432 --> 00:45:04,140
這是更高的優先級
比所有這些。

861
00:45:04,140 --> 00:45:04,931
等等等等。

862
00:45:04,931 --> 00:45:07,410
然後我定義
實際上功能

863
00:45:07,410 --> 00:45:10,070
決定了這個符不。

864
00:45:10,070 --> 00:45:14,150
所以，假設我有一個左
手側和右手側，

865
00:45:14,150 --> 00:45:17,330
這將是一個可能
更好的變量名這一點。

866
00:45:17,330 --> 00:45:20,690
左手側和右手側。

867
00:45:20,690 --> 00:45:26,740
那麼我可以採取的這種力量
左手側到右手側

868
00:45:26,740 --> 00:45:28,980
並返回該值。

869
00:45:28,980 --> 00:45:30,370
所以，現在它的超級甜蜜。

870
00:45:30,370 --> 00:45:33,790
所有我們所要做的就是2星3星
那就是2的3次冪，

871
00:45:33,790 --> 00:45:35,290
我們得到的值8。

872
00:45:35,290 --> 00:45:40,280
2星級10星是2到
10次​​方，我們得到1024。

873
00:45:40,280 --> 00:45:43,630
>> 所以，現在我們的功能力，
這再次是不同的，

874
00:45:43,630 --> 00:45:47,030
因為這背後的整體思路
是，我們有一個功能

875
00:45:47,030 --> 00:45:50,700
總是需要一定的價值，
乘以它 - 或者更確切地說，

876
00:45:50,700 --> 00:45:53,240
以指數以相同的功率。

877
00:45:53,240 --> 00:45:54,300
所以，現在是更簡單。

878
00:45:54,300 --> 00:45:57,070
所以，現在它只是美元
簽字0星級星年。

879
00:45:57,070 --> 00:46:01,190
我們甚至不必再使用戰俘。

880
00:46:01,190 --> 00:46:03,020
>> OK，誰的損失？

881
00:46:03,020 --> 00:46:03,700
我們是做的不錯？

882
00:46:03,700 --> 00:46:05,090
對這個東西有任何疑問？

883
00:46:05,090 --> 00:46:05,815
是嗎？

884
00:46:05,815 --> 00:46:09,500
>> 聽眾：當你 -  [聽不清]
Ÿ雙重的恐懼力量。

885
00:46:09,500 --> 00:46:11,441
因此，當你返回的功能。

886
00:46:11,441 --> 00:46:13,190
DANIEL Armendariz環：
Ÿ雙電源臨陣脫逃。

887
00:46:13,190 --> 00:46:14,270
哦，是的，我不知道
是什麼在y數字。

888
00:46:14,270 --> 00:46:15,708
我們對此深感抱歉。

889
00:46:15,708 --> 00:46:19,420
>> 聽眾：你為什麼要回國
函數[聽不清]外殼。

890
00:46:19,420 --> 00:46:24,214
是不是美元的零星級
明星Y [聽不清]

891
00:46:24,214 --> 00:46:29,710
發現與該操作者
返回雙[聽不清]翻番？

892
00:46:29,710 --> 00:46:32,742
>> DANIEL Armendariz環：因此，讓
我回答你的問題

893
00:46:32,742 --> 00:46:35,950
我是如何理解它，你能告訴我
如果我沒有理解你的問題。

894
00:46:35,950 --> 00:46:42,850
所以這個結構中，大括號
美元符號零星級星級Y，

895
00:46:42,850 --> 00:46:44,280
是一個函數。

896
00:46:44,280 --> 00:46:50,080
它接受一個參數是
這個美元符號零表示。

897
00:46:50,080 --> 00:46:55,830
return關鍵字是隱含在這
很短，匿名函數的語法。

898
00:46:55,830 --> 00:46:57,870
>> 這意味著，基本上
這是什麼說法

899
00:46:57,870 --> 00:47:01,270
是，我定義
function--然後我會

900
00:47:01,270 --> 00:47:05,320
只是把它something--
在那裡我有一些值y。

901
00:47:05,320 --> 00:47:08,300
我有Y，這是雙。

902
00:47:08,300 --> 00:47:10,750
而我回了雙。

903
00:47:10,750 --> 00:47:19,010
我有回報中y--對不起，
我不應該叫這個y-- X。

904
00:47:19,010 --> 00:47:20,240
哦，親愛的，哦，親愛的，哦，親愛的。

905
00:47:20,240 --> 00:47:27,440
X-- nope--明星明星年。

906
00:47:27,440 --> 00:47:29,720
>> 所以，這只是一個
這個簡化版本。

907
00:47:29,720 --> 00:47:33,990
等等原因，我有美元
標誌零的是，使用這個外殼

908
00:47:33,990 --> 00:47:41,050
意味著我不再有
鍵入戰俘，或不再做

909
00:47:41,050 --> 00:47:45,570
我要做的事情
像三星級星級2。

910
00:47:45,570 --> 00:47:48,530
我可以有一個
函數調用方

911
00:47:48,530 --> 00:47:50,820
這將始終以
一些價值作為輸入

912
00:47:50,820 --> 00:47:52,980
實際上返回到那個正方形。

913
00:47:52,980 --> 00:47:56,460
>> 這樣封閉的全部目的是
只是有點封裝事實

914
00:47:56,460 --> 00:47:59,920
我總是想用y時
我調用該函數為動力

915
00:47:59,920 --> 00:48:01,710
採取這一指數時。

916
00:48:01,710 --> 00:48:04,650
所以回國以後，一
函數接受

917
00:48:04,650 --> 00:48:08,460
雙，這是基礎，並
返回該指數的結果

918
00:48:08,460 --> 00:48:10,740
是這裡的關鍵。

919
00:48:10,740 --> 00:48:12,790
這就是主要的區別。

920
00:48:12,790 --> 00:48:14,430
只是有一個有點蓬勃發展。

921
00:48:14,430 --> 00:48:17,970
>> 這是不是有什麼不同
相比於現有的例子，

922
00:48:17,970 --> 00:48:20,530
但它只是一點點
一個蓬勃發展，我們實際上可以

923
00:48:20,530 --> 00:48:24,500
創建斯威夫特操作
實際上做的東西吧，

924
00:48:24,500 --> 00:48:26,396
這是一種一件很酷的事情。

925
00:48:26,396 --> 00:48:27,520
難道我回答你的問題？

926
00:48:27,520 --> 00:48:28,390
甜蜜。

927
00:48:28,390 --> 00:48:31,350
任何其他事情之前，我們繼續前進？

928
00:48:31,350 --> 00:48:33,570
好不好。

929
00:48:33,570 --> 00:48:36,430
>> 那種現在這個乞求
問題是that--以及OK，

930
00:48:36,430 --> 00:48:40,870
現在我們有能力為
要返回的功能。

931
00:48:40,870 --> 00:48:48,950
我們也可以將函數作為數據
或作為參數傳遞給其他的功能呢？

932
00:48:48,950 --> 00:48:50,710
而事實上，我們可以。

933
00:48:50,710 --> 00:48:53,480
因此，讓我們說，我們有
所有相同的代碼。

934
00:48:53,480 --> 00:48:56,120
我們有方形變
將方這段代碼。

935
00:48:56,120 --> 00:48:59,320
我們有立方體變量
將立方體的一些數據。

936
00:48:59,320 --> 00:49:02,440
而我們真正想要申請
大範圍的數字。

937
00:49:02,440 --> 00:49:06,870
>> 所以，我們也許會做，
當然，這當然是有效的，

938
00:49:06,870 --> 00:49:15,430
是迭代的數字列表
並運用我的職能平方和立方

939
00:49:15,430 --> 00:49:22,270
並獲得作為結果兩個新名單
這是該平方原始列表

940
00:49:22,270 --> 00:49:24,970
和立方，分別。

941
00:49:24,970 --> 00:49:26,880
完全可以接受。

942
00:49:26,880 --> 00:49:29,130
但有什麼東西，
我們在這裡看到的是，我們有，

943
00:49:29,130 --> 00:49:31,310
再次，我們的代碼重複。

944
00:49:31,310 --> 00:49:34,310
並有可能是一個機會
讓我們來簡化這個一點點。

945
00:49:34,310 --> 00:49:41,260
如果有一種方式讓我們什麼
實際上總是遍歷一些列表

946
00:49:41,260 --> 00:49:45,450
，只是傳遞給這片神奇
函數的變量

947
00:49:45,450 --> 00:49:47,350
代表一個功能
我們希望應用

948
00:49:47,350 --> 00:49:50,336
到該列表中的每一個項目。

949
00:49:50,336 --> 00:49:53,210
這帶來了的概念是什麼
被稱為高階函數。

950
00:49:53,210 --> 00:49:57,150
而這本質上是這是什麼
是，是，我們可以創建一個函數。

951
00:49:57,150 --> 00:50:00,210
>> 在這種情況下，它被稱為
映射器，只是為了給它一個名字，只是

952
00:50:00,210 --> 00:50:02,510
在每一個映射
在一個列表中的單個項目。

953
00:50:02,510 --> 00:50:06,191
在那裡我把名單
我需要的功能。

954
00:50:06,191 --> 00:50:08,440
和該函數，當然，
具有一定的簽名。

955
00:50:08,440 --> 00:50:11,980
它接受作為參數雙
它會輸出是一個雙。

956
00:50:11,980 --> 00:50:14,310
而整個結果
這個功能是將

957
00:50:14,310 --> 00:50:18,921
成為一個新的列表是double類型。

958
00:50:18,921 --> 00:50:19,420
好不好？

959
00:50:19,420 --> 00:50:22,650
>> 而我什麼都做
是將此函數f

960
00:50:22,650 --> 00:50:24,960
在我的列表中的每個元素。

961
00:50:24,960 --> 00:50:30,280
和reply--和回報，而這個新
列表作為其結果，這是非常涼爽。

962
00:50:30,280 --> 00:50:31,820
現在我可以通過周圍的功能。

963
00:50:31,820 --> 00:50:35,290
而這個想法高階
功能是非常重要的。

964
00:50:35,290 --> 00:50:39,260
這映射實際上只是
窮人的實施

965
00:50:39,260 --> 00:50:43,130
這是建立一個功能
到斯威夫特稱圖。

966
00:50:43,130 --> 00:50:45,690
而它正是這樣，
甚至更好一點。

967
00:50:45,690 --> 00:50:48,260
>> 這有點只是一個通用的，
簡化版本

968
00:50:48,260 --> 00:50:51,270
讓我們看到了
概念適用於這裡。

969
00:50:51,270 --> 00:50:54,630
現在，順便看看我
實際上可以申請我的平方

970
00:50:54,630 --> 00:50:57,850
和我的多維數據集函數
到的數字列表。

971
00:50:57,850 --> 00:50:58,780
我跑我的映射。

972
00:50:58,780 --> 00:51:00,280
我給它提供了我的號碼列表。

973
00:51:00,280 --> 00:51:02,155
我提供給它的
函數是怎麼回事

974
00:51:02,155 --> 00:51:04,170
適用於每一個這些指標。

975
00:51:04,170 --> 00:51:07,120
它將會是
輸出作為結果。

976
00:51:07,120 --> 00:51:11,810
我會看到我的平方
和我的立方數作為結果。

977
00:51:11,810 --> 00:51:14,660
>> 當然，映射器會
任何形式的匿名函數。

978
00:51:14,660 --> 00:51:17,640
我們甚至可以看到，我已經創建
一個新的匿名函數

979
00:51:17,640 --> 00:51:20,220
只是需要一些參數
和除以2吧。

980
00:51:20,220 --> 00:51:24,340
我們可以看到，我已經在事實上，
由2分，而不是我的名單。

981
00:51:24,340 --> 00:51:25,250
很酷吧？

982
00:51:25,250 --> 00:51:27,340
到目前為止，一切都很好？

983
00:51:27,340 --> 00:51:29,650
好了，現在讓我們
回到這個想法。

984
00:51:29,650 --> 00:51:36,160
讓我們實現這個早在
一個成績簿的上下文中。

985
00:51:36,160 --> 00:51:41,860
>> 如果我這樣做，我們可以看到，我可以
適用於各種各樣的這些選項 - 中

986
00:51:41,860 --> 00:51:44,330
或多種這些
高階函數

987
00:51:44,330 --> 00:51:51,450
實際上簡化了我的能力做
各種對數的列表的東西。

988
00:51:51,450 --> 00:51:53,660
因此，舉例來說，如果我
取號碼的列表，

989
00:51:53,660 --> 00:51:57,060
的高階功能之一
存在被稱為降低。

990
00:51:57,060 --> 00:52:00,080
有什麼不減少，而
比圖，減小將

991
00:52:00,080 --> 00:52:03,710
取兩個元素在列表中，
將採取一些函數

992
00:52:03,710 --> 00:52:07,420
的兩個元件相比較
列表，它將再

993
00:52:07,420 --> 00:52:09,610
排序output--的
該函數的輸出

994
00:52:09,610 --> 00:52:13,790
將是另一個元素
那麼你和別人比較。

995
00:52:13,790 --> 00:52:18,190
>> 所以，你可以使用這個實際
總之在你的列表中的數字。

996
00:52:18,190 --> 00:52:20,640
例如，如果你有
清單1，2，3，4，5，

997
00:52:20,640 --> 00:52:22,940
你拿的第一要素，1和2。

998
00:52:22,940 --> 00:52:27,270
您可以將它的另外
函數，它的兩個元素

999
00:52:27,270 --> 00:52:30,980
並吐出這些元素之一，
這將是的值3。

1000
00:52:30,980 --> 00:52:35,684
然後我們採取的價值3下一個
列表的元素，求和這兩個，

1001
00:52:35,684 --> 00:52:37,100
然後不斷下降的列表。

1002
00:52:37,100 --> 00:52:40,410
>> 我們正在減少
列表以一個單一的值。

1003
00:52:40,410 --> 00:52:42,700
它只是恰巧
該加符號

1004
00:52:42,700 --> 00:52:44,670
是一個操作符，就像我們剛才看到的。

1005
00:52:44,670 --> 00:52:47,500
這是運營商
實際上是一個函數，

1006
00:52:47,500 --> 00:52:53,100
正是有這個名單，我們
希望，而這些屬性

1007
00:52:53,100 --> 00:52:54,770
我們希望。

1008
00:52:54,770 --> 00:52:56,760
所以，我鼓勵你
看看這個。

1009
00:52:56,760 --> 00:52:59,290
我要排序的舉動
從一些這個代碼

1010
00:52:59,290 --> 00:53:05,330
所以我們實際上可以看一些
實際的，真實的，真正的斯威夫特在Xcode，

1011
00:53:05,330 --> 00:53:06,880
在iOS開發。

1012
00:53:06,880 --> 00:53:08,630
但是看看
這一點，看看能不能

1013
00:53:08,630 --> 00:53:11,171
通過分析這是怎麼回事
這其中的一些高階

1014
00:53:11,171 --> 00:53:13,790
功能，包括過濾器，
減少的，你甚至會

1015
00:53:13,790 --> 00:53:17,060
看到某處這裡映射為好。

1016
00:53:17,060 --> 00:53:17,910
就是這裡。

1017
00:53:17,910 --> 00:53:20,410
其中，這將需要一個序列
等級的，它實際上會

1018
00:53:20,410 --> 00:53:24,230
使用開關結構映射它們，
你可能從C承認，

1019
00:53:24,230 --> 00:53:27,640
但實際上這是一個很大的
比開關構造強大

1020
00:53:27,640 --> 00:53:29,810
我們有C.

1021
00:53:29,810 --> 00:53:31,930
>> 我們將它應用到
列表中的每一個元素

1022
00:53:31,930 --> 00:53:34,540
實際上提供
每個字母等級

1023
00:53:34,540 --> 00:53:40,780
使用所有這些概念的等級
我們剛剛談到之前。

1024
00:53:40,780 --> 00:53:44,760
現在，讓我們迴避的只是一個
分鐘，談結構。

1025
00:53:44,760 --> 00:53:49,680
所以結構是用C等待我們
能夠定義一個新類型的數據。

1026
00:53:49,680 --> 00:53:53,590
結構內斯威夫特存在。

1027
00:53:53,590 --> 00:53:58,980
所以做了很多其他的構造
所謂枚舉和類，那真的

1028
00:53:58,980 --> 00:54:01,175
拿這個想法一
完全不同的水平。

1029
00:54:01,175 --> 00:54:05,300
>> 基本上它只是一種方式
的定義新類型的數據。

1030
00:54:05,300 --> 00:54:11,010
所以，如果你get--如果你來
跨類或結構或枚舉，

1031
00:54:11,010 --> 00:54:13,290
不要混淆了它。

1032
00:54:13,290 --> 00:54:16,280
它定義了現在的樣子
一些新的特定類型的數據。

1033
00:54:16,280 --> 00:54:20,230
這是非常重要的，當
我們談論的iOS應用程序開發

1034
00:54:20,230 --> 00:54:24,630
因為一切
在iOS應用中存在

1035
00:54:24,630 --> 00:54:27,460
實質上是某種類型的對象。

1036
00:54:27,460 --> 00:54:31,980
和對象基本上是一個
類或枚舉或結構。

1037
00:54:31,980 --> 00:54:34,760
>> 因此，在這種情況下，我
定義一個新的數據類型

1038
00:54:34,760 --> 00:54:37,740
那我打電話評估
這是一些特性，包括

1039
00:54:37,740 --> 00:54:41,040
名稱和等級的序列。

1040
00:54:41,040 --> 00:54:43,470
所以，一種類型的評估
我可能有一點

1041
00:54:43,470 --> 00:54:44,760
會測驗，例如。

1042
00:54:44,760 --> 00:54:48,180
我希望有一個
評價這是一個測驗

1043
00:54:48,180 --> 00:54:51,460
並有各種檔次
與該相關聯的，對於測驗1，

1044
00:54:51,460 --> 00:54:52,840
測驗二，等等等等。

1045
00:54:52,840 --> 00:54:55,720
>> 或者我可能有不同的類型
評估問題套。

1046
00:54:55,720 --> 00:54:56,650
我可以做的事情。

1047
00:54:56,650 --> 00:54:59,860
其實我可以有
這種類型的內部功能

1048
00:54:59,860 --> 00:55:02,645
的數據，這是現在所謂的方法。

1049
00:55:02,645 --> 00:55:04,520
所以，如果你曾經看到的
單詞的方法，它真的

1050
00:55:04,520 --> 00:55:08,190
就是這樣一個應用功能
一個非常具體的類，

1051
00:55:08,190 --> 00:55:10,100
或將數據的一個非常具體的類型。

1052
00:55:10,100 --> 00:55:12,350
它使我們在修改數據。

1053
00:55:12,350 --> 00:55:15,510
>> 因此，換句話說，如果我想
增加一個年級到我的判斷，

1054
00:55:15,510 --> 00:55:18,630
那麼所有我需要做的是
追加這是輸入分數

1055
00:55:18,630 --> 00:55:22,660
這個功能
我的內部屬性。

1056
00:55:22,660 --> 00:55:25,880
還有一個整齊的結構在這裡
在斯威夫特，這是本點點點

1057
00:55:25,880 --> 00:55:31,780
操作者，這意味著可以​​分數
現在接受任何數量的整數。

1058
00:55:31,780 --> 00:55:33,940
和分數將是一個
整數數組

1059
00:55:33,940 --> 00:55:39,030
已經傳遞給我的功能，
意味著我可以做這樣的東西。

1060
00:55:39,030 --> 00:55:42,360
>> 我可以做補充牌號，只是提供
任意數量的整數進去

1061
00:55:42,360 --> 00:55:47,420
並且實際上可以提供一個數組
在我的函數的值

1062
00:55:47,420 --> 00:55:50,270
還是在我的方法，就是這種情況。

1063
00:55:50,270 --> 00:55:54,040
現在，這是重要的，因為
一切都在Xcode中，一切都在iOS上，

1064
00:55:54,040 --> 00:55:56,250
實際上是一個對象。

1065
00:55:56,250 --> 00:55:59,630
所以，記住這一點
當我們胸圍開放的Xcode

1066
00:55:59,630 --> 00:56:04,890
並跳到超越iOS的
二三版本和

1067
00:56:04,890 --> 00:56:08,820
居然去四個版本。

1068
00:56:08,820 --> 00:56:11,940
>> 再次，這一切都將
張貼研討會頁面上。

1069
00:56:11,940 --> 00:56:16,980
的iOS 4是那種一個完全成熟
實現一個非常基本的應用程序。

1070
00:56:16,980 --> 00:56:23,920
什麼這個程序的作用是它
加載UI，它看起來像這樣。

1071
00:56:23,920 --> 00:56:28,680
同樣，如果我們點擊故事板，我們可以
看就知道是什麼樣子。

1072
00:56:28,680 --> 00:56:31,320
這是UI。

1073
00:56:31,320 --> 00:56:33,676
它有一個冠軍在最高層。

1074
00:56:33,676 --> 00:56:34,800
我把它叫做Web畫廊。

1075
00:56:34,800 --> 00:56:38,400
>> 在中間有一個元素
所謂的UI圖像視圖。

1076
00:56:38,400 --> 00:56:41,340
並在底部有一個
工具欄用一個按鈕

1077
00:56:41,340 --> 00:56:46,850
具有彈性的空間，從而使其
中心在此工具欄的中間。

1078
00:56:46,850 --> 00:56:51,780
什麼情況是，當這
加載它下載一個JSON文件，該文件是

1079
00:56:51,780 --> 00:56:55,540
其他地方的服務器上載，
分析認為JSON文件，

1080
00:56:55,540 --> 00:56:58,130
和JSON文件看起來有點像這樣。

1081
00:56:58,130 --> 00:57:02,770

1082
00:57:02,770 --> 00:57:06,230
JSON文件看起來是這樣的。

1083
00:57:06,230 --> 00:57:08,650
它就在那裡。

1084
00:57:08,650 --> 00:57:11,730
>> 它有一個專輯名稱，
它有照片的陣列。

1085
00:57:11,730 --> 00:57:13,490
每個這樣的照片
有一個名字，也

1086
00:57:13,490 --> 00:57:19,460
這代表了一​​個URL本身
JPEG版本的單張照片。

1087
00:57:19,460 --> 00:57:24,780
那麼什麼發生的是，這個程序的時候
負載，它下載JSON文件，

1088
00:57:24,780 --> 00:57:30,590
解析它，使這一切成為
在iOS中的數組相當於

1089
00:57:30,590 --> 00:57:33,020
應用程序的開發，這是一個NSArray。

1090
00:57:33,020 --> 00:57:37,520
然後我就可以加載
該數據到應用程序

1091
00:57:37,520 --> 00:57:41,100
並加載它在我的屏幕上。

1092
00:57:41,100 --> 00:57:44,760
>> 有被加載的圖像
與在最底層的按鈕。

1093
00:57:44,760 --> 00:57:49,190
如果我點擊獲取下一個圖像，然後它
拉的形象從互聯網

1094
00:57:49,190 --> 00:57:53,370
並替換該圖像
在UI圖像圖。

1095
00:57:53,370 --> 00:57:57,820
所以，你可以下載這個，實際上
看看在您的計算機上。

1096
00:57:57,820 --> 00:58:00,940
並構建它，實際上
它編譯到您的設備。

1097
00:58:00,940 --> 00:58:04,710
但實際上這個過程是
這一點，創建storyboard--

1098
00:58:04,710 --> 00:58:08,080
或者更確切地說，沒有create--
但選擇的故事情節。

1099
00:58:08,080 --> 00:58:15,030
實際上we'll--如果你不mind--
我們將只需幾秒鐘

1100
00:58:15,030 --> 00:58:18,390
實際上告訴你如何做。

1101
00:58:18,390 --> 00:58:22,430

1102
00:58:22,430 --> 00:58:27,820
>> 為了讓我們如何能真正
實現這一目標是由多一點點

1103
00:58:27,820 --> 00:58:28,360
顯而易見的。

1104
00:58:28,360 --> 00:58:30,651
單一視圖的應用程序，我
要調用這個研討會

1105
00:58:30,651 --> 00:58:35,330
4表示此
特別號碼。

1106
00:58:35,330 --> 00:58:36,335
將它保存在桌面上。

1107
00:58:36,335 --> 00:58:39,890

1108
00:58:39,890 --> 00:58:42,110
OK，去點擊的故事情節。

1109
00:58:42,110 --> 00:58:47,030
而我什麼都做
是找我的形象來看，

1110
00:58:47,030 --> 00:58:50,940
將其拖動到我的用戶
接口和中心吧。

1111
00:58:50,940 --> 00:58:54,850
現在只是圍繞這很不幸
是不是打算做了一大堆，

1112
00:58:54,850 --> 00:58:58,680
除用於在屏幕
這是這個確切大小。

1113
00:58:58,680 --> 00:59:03,950
>> 因此，我們可以通過說服了自己，
點擊這個雙圈的事，

1114
00:59:03,950 --> 00:59:08,290
打倒這個流行
菜單在這裡和改變

1115
00:59:08,290 --> 00:59:11,110
預覽，我們實際上會
有機會預覽如何

1116
00:59:11,110 --> 00:59:13,530
這實際上
看看在其他設備上。

1117
00:59:13,530 --> 00:59:16,500
正如我們所看到的，我們甚至不
看到它在這種特殊情況下。

1118
00:59:16,500 --> 00:59:18,500
所以，我要關閉這個現在。

1119
00:59:18,500 --> 00:59:22,100
>> 我要去選擇
該圖標下來很

1120
00:59:22,100 --> 00:59:23,910
在屏幕的底部。

1121
00:59:23,910 --> 00:59:26,584
它說，解決自動佈局問題。

1122
00:59:26,584 --> 00:59:28,000
對不起，它在底部切斷。

1123
00:59:28,000 --> 00:59:36,360
但是，如果我點擊了，我
得到的是這種流行up--消失。

1124
00:59:36,360 --> 00:59:39,740

1125
00:59:39,740 --> 00:59:51,220
我得到的是這種彈出的
允許我補充缺失的制約。

1126
00:59:51,220 --> 00:59:53,780
通過這樣做，它
排序然​​後將其鎖定

1127
00:59:53,780 --> 00:59:56,640
成的中心部分
屏幕就像我所期望的。

1128
00:59:56,640 --> 01:00:00,520
>> 現在，為了得到這個按鈕
它的上面，我需要去編輯。

1129
01:00:00,520 --> 01:00:05,010
去嵌入和點擊
導航控制器。

1130
01:00:05,010 --> 01:00:08,900
什麼，會做的是，將增加
這整個的其他組件來了，

1131
01:00:08,900 --> 01:00:11,310
但它實際上鏈接
這回我原來的UI。

1132
01:00:11,310 --> 01:00:14,450
和細節，再一次，我們不
真正需要關心現在。

1133
01:00:14,450 --> 01:00:16,710
但我希望有一個
在工具欄的最底部。

1134
01:00:16,710 --> 01:00:18,530
所以我會檢查顯示工具欄。

1135
01:00:18,530 --> 01:00:21,870
>> 這提供了在我看來，
這是目前其他地方，

1136
01:00:21,870 --> 01:00:23,900
我們可以看到它掛在這裡。

1137
01:00:23,900 --> 01:00:28,710
它現在提供了一個工具欄
在我的UI的底部。

1138
01:00:28,710 --> 01:00:34,770
所以，現在，而不是選擇一個
圖像視圖，我能找到一個標籤，

1139
01:00:34,770 --> 01:00:41,140
或者更確切地說，一個toolbar--
讓我們來看看，這裡是什麼？

1140
01:00:41,140 --> 01:00:41,890
什麼是它叫什麼名字？

1141
01:00:41,890 --> 01:00:49,760
一個button--項目bar-- item--
sorry--欄按鈕的項目。

1142
01:00:49,760 --> 01:00:54,590
撲通有和應用一對夫婦
在任一側的靈活的空間

1143
01:00:54,590 --> 01:00:57,429
真正的中心。

1144
01:00:57,429 --> 01:00:58,970
所以，現在我已經創建了我的UI，基本上是這樣。

1145
01:00:58,970 --> 01:01:01,428
我可以給它一個名字
雙擊在最高層

1146
01:01:01,428 --> 01:01:04,880
這裡說的網絡畫廊等。

1147
01:01:04,880 --> 01:01:08,100
現在再次，這些都是元素
通過自己的存在。

1148
01:01:08,100 --> 01:01:10,400
我有連接
他們給我的代碼，

1149
01:01:10,400 --> 01:01:14,297
我可以再次把做
了這個雙圓圈圖標，

1150
01:01:14,297 --> 01:01:15,380
從預覽變化。

1151
01:01:15,380 --> 01:01:18,950
其中，順便說一句，現在我們可以看到的是
很好地為中心，會好看

1152
01:01:18,950 --> 01:01:23,720
上的各種設備。

1153
01:01:23,720 --> 01:01:27,280
>> 切換到自動，這將
調出的ViewController代碼。

1154
01:01:27,280 --> 01:01:29,030
而現在這部分是非常重要的。

1155
01:01:29,030 --> 01:01:34,590
為了讓您連接這些
兩個元素，你的代碼的UI，

1156
01:01:34,590 --> 01:01:36,680
您選擇的項
要連接。

1157
01:01:36,680 --> 01:01:39,570
因此，在這種情況下，我們
其實想編碼

1158
01:01:39,570 --> 01:01:43,520
更改的包含圖像
在這個UI圖像視圖。

1159
01:01:43,520 --> 01:01:47,070
因此，從如果你控制點擊
圖像視圖和阻力，

1160
01:01:47,070 --> 01:01:51,960
你會發現，你得到一個小酒吧，
當你放手這一切流行

1161
01:01:51,960 --> 01:01:53,550
起來會發生。

1162
01:01:53,550 --> 01:01:56,470
>> 它說，我們將
創建一個連接。

1163
01:01:56,470 --> 01:01:59,300
從這裡我想給它
一個名字，像畫廊。

1164
01:01:59,300 --> 01:02:00,240
按Enter鍵。

1165
01:02:00,240 --> 01:02:03,040
這實際上提供
一個變量稱為畫廊

1166
01:02:03,040 --> 01:02:08,600
我就可以在我的代碼引用
改變圖像，例如。

1167
01:02:08,600 --> 01:02:10,430
那麼，如何該代碼實際上看？

1168
01:02:10,430 --> 01:02:13,030
好了，我不想
花太多時間就可以了。

1169
01:02:13,030 --> 01:02:15,430
我鼓勵你
下載看一看。

1170
01:02:15,430 --> 01:02:18,330
但其中最1
重要的方面是代碼

1171
01:02:18,330 --> 01:02:20,980
實際獲取的圖像。

1172
01:02:20,980 --> 01:02:26,470
>> 因此，在這種情況下，我想
在我的照片，以達到

1173
01:02:26,470 --> 01:02:28,520
陣列，載
在我的課。

1174
01:02:28,520 --> 01:02:33,390
我想定義名稱和URL
這是被解析出這個JSON的。

1175
01:02:33,390 --> 01:02:39,810
其實要求的設備，以獲得
URL，從這個獲取URL，

1176
01:02:39,810 --> 01:02:44,060
然後取從數據
該URL的內容。

1177
01:02:44,060 --> 01:02:49,430
然後將這些數據轉換成圖像
通過它傳遞到UI圖像。

1178
01:02:49,430 --> 01:02:52,880
如此反复，這些都是不同類型的
的目的，不同類型的類。

1179
01:02:52,880 --> 01:02:58,410
>> 然後我就可以把我的
gallery.image等於該數據。

1180
01:02:58,410 --> 01:03:00,750
這就是那種肉
它實際上是再

1181
01:03:00,750 --> 01:03:08,250
能夠改變數據from--變化
圖像從一個到下一個。

1182
01:03:08,250 --> 01:03:10,660
如此反复，現在希望
大量的構建體

1183
01:03:10,660 --> 01:03:12,240
將多一點點感覺。

1184
01:03:12,240 --> 01:03:15,260
請注意，有一些
感嘆號這裡。

1185
01:03:15,260 --> 01:03:19,810
感嘆號點
本質上涉及到自選。

1186
01:03:19,810 --> 01:03:22,657
>> 什麼我基本上說的是
那甚至不用檢查

1187
01:03:22,657 --> 01:03:24,490
看看是否有數據
在此可選，

1188
01:03:24,490 --> 01:03:27,140
我要繼續前進，承擔
有和解開它。

1189
01:03:27,140 --> 01:03:31,340
請記住，我們使用的比喻
排序包為自選的

1190
01:03:31,340 --> 01:03:34,700
我們需要解開
包拉出來的數據。

1191
01:03:34,700 --> 01:03:37,570
感嘆號
力量竟然發生。

1192
01:03:37,570 --> 01:03:39,590
>> 但我知道，這是
安全的，因為我檢查

1193
01:03:39,590 --> 01:03:42,070
看是否圖像數據等於
為nil，我實際上檢查

1194
01:03:42,070 --> 01:03:45,420
如果可選看到
，事實上，失敗了。

1195
01:03:45,420 --> 01:03:47,110
如果有，其實已經失敗。

1196
01:03:47,110 --> 01:03:52,450
所以我敢肯定，一旦我得到這個
點我可以肯定地解開這些數據。

1197
01:03:52,450 --> 01:03:55,710
你也可以看到它在
問號的形式。

1198
01:03:55,710 --> 01:03:59,100
因此，如果我們向下滾動到哪裡
需要實際解析數據。

1199
01:03:59,100 --> 01:04:01,850
>> 所以，不要被推遲
這些排序冗長的名字。

1200
01:04:01,850 --> 01:04:06,580
您可以在蘋果找到
開發網站很多

1201
01:04:06,580 --> 01:04:09,620
引用的所有的
對象和所有進程的

1202
01:04:09,620 --> 01:04:11,170
這實際上使這一切成為可能。

1203
01:04:11,170 --> 01:04:15,990
但是請注意，這是本質
在那裡我通過它的一些數據的功能。

1204
01:04:15,990 --> 01:04:18,410
我找回一些類型的數據。

1205
01:04:18,410 --> 01:04:24,190
我需要以此為關鍵字來
將其轉換成該NSDictionary的？

1206
01:04:24,190 --> 01:04:26,490
這又是，一個
可選的NSDictionary。

1207
01:04:26,490 --> 01:04:31,070
然後我需要
檢查，看它是否存在。

1208
01:04:31,070 --> 01:04:37,130
>> 這樣我就可以使用，如果讓
成功等於解析，

1209
01:04:37,130 --> 01:04:40,620
後來我知道，那可選
實際上包含了一些數據。

1210
01:04:40,620 --> 01:04:43,840
或者是我在這裡做是為了
只是假設，如果有

1211
01:04:43,840 --> 01:04:49,067
沒有錯誤，它實際上是安全的。

1212
01:04:49,067 --> 01:04:51,400
好吧，我要感謝
大家的光臨。

1213
01:04:51,400 --> 01:04:53,540
我知道這是很多，
但它只有一個小時

1214
01:04:53,540 --> 01:04:55,920
談一些
很先進的東西。

1215
01:04:55,920 --> 01:04:59,640
所以希望你會得到一個
機會來下載所有的代碼

1216
01:04:59,640 --> 01:05:01,657
並採取更好，更
深入了解一下吧。

1217
01:05:01,657 --> 01:05:04,240
排序說服所有的自己
的東西，是怎麼回事。

1218
01:05:04,240 --> 01:05:06,800
我要感謝你
所有的再次光臨。

1219
01:05:06,800 --> 01:05:08,760
祝你好運與您的最終項目。

1220
01:05:08,760 --> 01:05:10,600
祝你有美好的一天。

1221
01:05:10,600 --> 01:05:11,467