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
所以这是X​​code的。

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