1
00:00:00,000 --> 00:00:03,332
>> [音乐播放]

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

3
00:00:06,200 --> 00:00:09,590
>> DAN AMRMENDARIZ：每个人，
欢迎到CS50研讨会上，

4
00:00:09,590 --> 00:00:11,690
iOS应用开发与斯威夫特。

5
00:00:11,690 --> 00:00:15,690
我是丹Armendariz环，我就是一个导师
你们是哈佛计算机科学。

6
00:00:15,690 --> 00:00:21,510
>> 而接下来的一个小时将是
尽可能多的东西旋风之旅

7
00:00:21,510 --> 00:00:25,160
关于这个话题，因为我们能适应。

8
00:00:25,160 --> 00:00:29,170
我将发布所有的源代码
你会今天在网上看到的。

9
00:00:29,170 --> 00:00:31,990
我们可能不能够
其实去了一切

10
00:00:31,990 --> 00:00:34,810
我是说我
显示你在这个时候。

11
00:00:34,810 --> 00:00:37,580
但至少希望通过
的源代码的注释，

12
00:00:37,580 --> 00:00:40,830
你就可以揣摩什么
究竟发生了那些事

13
00:00:40,830 --> 00:00:42,950
我们不太去。

14
00:00:42,950 --> 00:00:46,970
>> 的整体，该结构
今天的演讲将是如下。

15
00:00:46,970 --> 00:00:52,820
我们将开始做了一些基本的
语法与雨燕的语言，

16
00:00:52,820 --> 00:00:56,290
进入一些更高级
雨燕语言的语法。

17
00:00:56,290 --> 00:00:59,560
由于语言
真的是现代，它

18
00:00:59,560 --> 00:01:02,110
有很多高水平
功能事情，我们还没有

19
00:01:02,110 --> 00:01:06,600
整个CS50见于C，或
甚至一些其他语言

20
00:01:06,600 --> 00:01:09,310
我们已经开始
使用CS50，如PHP，

21
00:01:09,310 --> 00:01:12,670
所以我将不得不尝试
还介绍了一些主题，

22
00:01:12,670 --> 00:01:18,580
相关的高级语言
你可能不深入看到CS50，

23
00:01:18,580 --> 00:01:21,380
但你会在后面看到的
计算机科学课程。

24
00:01:21,380 --> 00:01:25,290
因此，这将是一个
紧凑小时。

25
00:01:25,290 --> 00:01:28,897
请随时让我
知道，如果你有任何问题。

26
00:01:28,897 --> 00:01:30,730
所以，如果你有兴趣
在做开发

27
00:01:30,730 --> 00:01:34,442
与雨燕，还是真的
任何iOS应用的开发，

28
00:01:34,442 --> 00:01:35,900
有一对夫妇的要求。

29
00:01:35,900 --> 00:01:39,940
首先，你必须要使用
在Mac上，在实例运行

30
00:01:39,940 --> 00:01:43,880
我们将要使用的今天，
操作系统版本比较新

31
00:01:43,880 --> 00:01:46,580
十，在这种情况下，我跑X 10.5。

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

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

34
00:01:52,430 --> 00:01:56,271
它具有最新的版本
斯威夫特，这也是雨燕2.0​​。

35
00:01:56,271 --> 00:01:58,270
这其实是一个相当
重要区别。

36
00:01:58,270 --> 00:02:01,510
很多语法有
漂亮显著改变

37
00:02:01,510 --> 00:02:05,890
在某些情况下，从夫特1.0，
这是去年发布的，

38
00:02:05,890 --> 00:02:08,514
以雨燕2.0​​，这
刚出来的时候，今年秋天。

39
00:02:08,514 --> 00:02:09,889
所以，我们要展现雨燕2.0​​。

40
00:02:09,889 --> 00:02:13,020
很多的东西，
你搜索在线

41
00:02:13,020 --> 00:02:18,040
当你试图获得更多的
关于各种事物的信息，

42
00:02:18,040 --> 00:02:20,710
你可能想明确地
搜索斯威夫特2

43
00:02:20,710 --> 00:02:24,950
而不是只是普通的老斯威夫特使
确保你得到正确的语法。

44
00:02:24,950 --> 00:02:26,920
>> 事实上，这通常是真实的。

45
00:02:26,920 --> 00:02:31,210
有较快的发展量
发生在雨燕语言

46
00:02:31,210 --> 00:02:35,110
自从苹果公司发布了它，我觉得
是什么，它​​是一个一年多一点

47
00:02:35,110 --> 00:02:36,370
现在。

48
00:02:36,370 --> 00:02:39,080
而一切都变了
急剧那个时间。

49
00:02:39,080 --> 00:02:42,160
所以，不要感到沮丧
如果，当你环顾四周

50
00:02:42,160 --> 00:02:48,310
对雨燕或主题如何完成
一些使用一些示例代码

51
00:02:48,310 --> 00:02:51,210
或东西，它不
在雨燕2.0​​的实际工作。

52
00:02:51,210 --> 00:02:53,790
请确保你正在寻找
针对该版本

53
00:02:53,790 --> 00:02:58,690
以尽量减少不同的效果
版本和那些各种各样的事情。

54
00:02:58,690 --> 00:03:02,470
>> 我会尝试指出只是一些事情
这是不同的旧版本。

55
00:03:02,470 --> 00:03:03,970
但是，这件事情要注意。

56
00:03:03,970 --> 00:03:06,770
这可能将是
最令人头痛的一个

57
00:03:06,770 --> 00:03:11,010
你将与​​雨燕是寻找
示例代码是旧的，甚至只是

58
00:03:11,010 --> 00:03:14,050
通过几个月，欲以
它在你的更现代的项目。

59
00:03:14,050 --> 00:03:15,430
它只是根本不起作用。

60
00:03:15,430 --> 00:03:18,530
你得到编译器错误，语法
错误，各种疯狂的东西。

61
00:03:18,530 --> 00:03:21,580
因此，只要有耐心
这一点，你会希望

62
00:03:21,580 --> 00:03:24,200
有一个相当不错的体验
与雨燕的整体。

63
00:03:24,200 --> 00:03:28,430
>> 现在，您可以真正join--，我希望
我们其实还是有这本year--

64
00:03:28,430 --> 00:03:30,910
CS 50的苹果应用程序
开发团队，

65
00:03:30,910 --> 00:03:34,680
将允许你安装任何应用程序
您在您的iOS设备上创建。

66
00:03:34,680 --> 00:03:39,190
因此，看看这个网址，如果
你有兴趣这样做。

67
00:03:39,190 --> 00:03:41,450
>> 所以，只是一对夫妇的
东西约雨燕本身。

68
00:03:41,450 --> 00:03:43,580
它是编译型语言。

69
00:03:43,580 --> 00:03:45,870
但你会看到一些
那我们使用的功能

70
00:03:45,870 --> 00:03:50,650
允许它也用于比特
像一个解释的方式为好。

71
00:03:50,650 --> 00:03:56,350
>> 很多语法是借来的
从C.它是基于并写入C.

72
00:03:56,350 --> 00:04:00,400
因此，我们会看到，
有很多外卖的

73
00:04:00,400 --> 00:04:04,450
从现有的知识
从C，我们可以移植到斯威夫特。

74
00:04:04,450 --> 00:04:07,290
>> 但有些事情
让它从C很大的不同

75
00:04:07,290 --> 00:04:08,860
这是非常强类型。

76
00:04:08,860 --> 00:04:10,380
有自动内存管理。

77
00:04:10,380 --> 00:04:13,170
你不会有
用malloc或免费的任何地方。

78
00:04:13,170 --> 00:04:15,110
它是专为通用性。

79
00:04:15,110 --> 00:04:19,480
所以，换句话说，你可以用它
种种情境，从Apple关注

80
00:04:19,480 --> 00:04:26,290
到iPhone一路攀升到OS X，和
甚至有些服务器，甚至一些脚本。

81
00:04:26,290 --> 00:04:28,400
但是，我们会看到，
支持脚本

82
00:04:28,400 --> 00:04:31,360
是还没有应用的
这是在其他语言。

83
00:04:31,360 --> 00:04:34,930
因此，最有可能你会使用
这个专为开发

84
00:04:34,930 --> 00:04:37,060
在你的Mac或iPhone。

85
00:04:37,060 --> 00:04:40,150
>> 而且它有很多的现代特色。

86
00:04:40,150 --> 00:04:43,380
和很多这些东西的东西，
我们要试着今天在这里讲话，

87
00:04:43,380 --> 00:04:47,590
但坦率地说也是我们的主题，
我们可以投入全部课程。

88
00:04:47,590 --> 00:04:50,140
事实上，CS 51，这是
提供下学期，

89
00:04:50,140 --> 00:04:53,990
集中了大量有关这些主题
这说明如下。

90
00:04:53,990 --> 00:04:56,781
所以，你可以花一整个学期
了解这些东西。

91
00:04:56,781 --> 00:04:58,530
但是，我们要尝试
打通他们

92
00:04:58,530 --> 00:05:00,800
至少够你
可以理解的

93
00:05:00,800 --> 00:05:03,700
外出时你看看
在斯威夫特程序

94
00:05:03,700 --> 00:05:07,310
并能够破解你的方式
通过它进行最后的项目。

95
00:05:07,310 --> 00:05:10,780
>> 现在的最佳方法之一，你可以
获取更多相关信息

96
00:05:10,780 --> 00:05:14,700
坦率地说只是通过苹果
为雨燕提供的文档。

97
00:05:14,700 --> 00:05:16,930
有很多的API
可用。

98
00:05:16,930 --> 00:05:21,170
这是一个很好的大本营您
寻找，具体的事情你

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

100
00:05:23,020 --> 00:05:26,350
如果你想使用相机
例如，你可以开始寻找在这里，

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

102
00:05:32,540 --> 00:05:36,670
>> 在此有任何疑问
之前，我们在正确的跳？

103
00:05:36,670 --> 00:05:37,880
好吧。

104
00:05:37,880 --> 00:05:38,700
让我们继续。

105
00:05:38,700 --> 00:05:42,620
>> 因此，首先，我有一个
的示例文件数量。

106
00:05:42,620 --> 00:05:46,040
我要去尝试步骤
通过他们比较快。

107
00:05:46,040 --> 00:05:49,190
这是世界您好文件斯威夫特。

108
00:05:49,190 --> 00:05:51,050
这很简单。

109
00:05:51,050 --> 00:05:54,360
有办法更多评论
不是有实际的代码。

110
00:05:54,360 --> 00:05:57,100
请注意实际的代码是在
最底层的14行。

111
00:05:57,100 --> 00:05:57,980
它说，打印。

112
00:05:57,980 --> 00:05:59,820
然后它是一个函数调用。

113
00:05:59,820 --> 00:06:03,010
我们正在传递到它
字符串名为Hello CS50。

114
00:06:03,010 --> 00:06:04,750
请注意，有没有分号。

115
00:06:04,750 --> 00:06:07,010
请注意，没有INT为主。

116
00:06:07,010 --> 00:06:10,392
有没有一个
克鲁夫特，我们曾与C.

117
00:06:10,392 --> 00:06:15,020
当我们以这种方式使用SWIFT，
这仅仅是写在一个文本文件

118
00:06:15,020 --> 00:06:18,340
并存储在我的电脑上，然后
我可以编译并运行它。

119
00:06:18,340 --> 00:06:20,920
>> 请注意，在这里我
不使用CS50 IDE。

120
00:06:20,920 --> 00:06:24,460
这是假设我
运行，并且我在OS X中，

121
00:06:24,460 --> 00:06:27,870
而且我已经安装的Xcode
本机为了使该上

122
00:06:27,870 --> 00:06:29,080
实际功能。

123
00:06:29,080 --> 00:06:33,349
但是，这仅仅是一个普通的文本文件
我们就可以编译和编辑。

124
00:06:33,349 --> 00:06:34,890
所以，让我们来看看这实际上是如何工作的。

125
00:06:34,890 --> 00:06:37,430
如果我想编译它？

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

127
00:06:40,450 --> 00:06:42,960
经过一个或两个时刻，
可以看到，我们现在有

128
00:06:42,960 --> 00:06:45,360
编译成一个名为1的文件这一点。

129
00:06:45,360 --> 00:06:51,090
现在我们已经印制了CS50，
我们的Hello World应用程序相当。

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

131
00:06:54,690 --> 00:07:00,090
我们没有输入
A / N打印新的生产线。

132
00:07:00,090 --> 00:07:05,315
默认情况下，在打印功能
斯威夫特将打印新的生产线为您服务。

133
00:07:05,315 --> 00:07:09,284
您可以通过可选的附加
参数来告诉它不这样做。

134
00:07:09,284 --> 00:07:10,950
但谷歌关于它的更多信息。

135
00:07:10,950 --> 00:07:13,450
默认情况下，它会做的打印线。

136
00:07:13,450 --> 00:07:16,420
>> 好吧，让我们继续前进
然后向一些其他的事情。

137
00:07:16,420 --> 00:07:18,620
那么怎样才能真正定义变量？

138
00:07:18,620 --> 00:07:21,960
我们可以做使用的
一个两种方法。

139
00:07:21,960 --> 00:07:26,122
而我要的人告诉你
关于第一个是这让定义。

140
00:07:26,122 --> 00:07:27,830
这一点很重要
因为有效

141
00:07:27,830 --> 00:07:30,240
我们正在做的事情是定义一个常数。

142
00:07:30,240 --> 00:07:34,010
我们将创建一个变量，
或者更确切地说，一个恒定的叫名字，

143
00:07:34,010 --> 00:07:38,200
提供给它的一些数据 - 
这种情况下，串丹。

144
00:07:38,200 --> 00:07:40,630
但是，通过使用这让
关键字，我们说

145
00:07:40,630 --> 00:07:43,860
这个变量 - 或
再次constant--称为

146
00:07:43,860 --> 00:07:46,220
名字是永远不会改变。

147
00:07:46,220 --> 00:07:50,120
这将在整个是不可变的
这一计划的持续时间

148
00:07:50,120 --> 00:07:53,100
或在整个
上下文的持续时间

149
00:07:53,100 --> 00:07:55,390
即该变量是可用的。

150
00:07:55,390 --> 00:08:00,096
>> 这是非常重要的，当
你有一些数据，是不是

151
00:08:00,096 --> 00:08:02,970
要在你的程序改变，
你会看到各种各样的例子

152
00:08:02,970 --> 00:08:06,790
什么时候我们要使用
让相对于其它语法，

153
00:08:06,790 --> 00:08:11,040
您使用让它非常重要
只要有可能，因为这将通知

154
00:08:11,040 --> 00:08:13,740
它是语言
不会改变，

155
00:08:13,740 --> 00:08:16,590
和它实际上可以执行
很多优化工作

156
00:08:16,590 --> 00:08:19,560
提高速度和
你的程序的安全性。

157
00:08:19,560 --> 00:08:24,480
而到安全，我的意思是不能让
疯狂的错误，它崩溃

158
00:08:24,480 --> 00:08:27,910
我们可能会
见惯了在C.

159
00:08:27,910 --> 00:08:32,460
>> 然后我们可以使用字符串插值
要在字符串中封装此。

160
00:08:32,460 --> 00:08:35,200
因此，我们可以在此看到
打印线，打印你好，

161
00:08:35,200 --> 00:08:38,950
然后用反斜杠开括号，
然后我的变量的名称，

162
00:08:38,950 --> 00:08:41,809
在这种情况下恒定，
关闭括号。

163
00:08:41,809 --> 00:08:46,400
我本质上再敷上
这个变量叫名字的内容

164
00:08:46,400 --> 00:08:50,240
内的字符串，然后
印刷有结果。

165
00:08:50,240 --> 00:08:54,070
>> 还有另一个改变这个文件
这就是我，在最高层，

166
00:08:54,070 --> 00:08:57,340
放在一个家当线，
基本上只是规定

167
00:08:57,340 --> 00:09:00,180
我想使用
斯威夫特解释器，

168
00:09:00,180 --> 00:09:04,190
意味着我不再有
编译这个特定的程序。

169
00:09:04,190 --> 00:09:06,567
我可以运行它像它自己的脚本。

170
00:09:06,567 --> 00:09:09,400
但是，这是，在这种情况下，后面
该场景被编译，然后

171
00:09:09,400 --> 00:09:10,030
正在运行。

172
00:09:10,030 --> 00:09:13,540
这只是看不见我们。

173
00:09:13,540 --> 00:09:15,880
>> 好吧，让我们继续前进。

174
00:09:15,880 --> 00:09:19,650
所以这是一个有点挂羊头卖狗肉
刚刚发生过。

175
00:09:19,650 --> 00:09:23,230
我给你我
可以定义一个常数。

176
00:09:23,230 --> 00:09:25,490
我可以提供一些数据来做到这一点。

177
00:09:25,490 --> 00:09:29,240
但在这种情况下，请注意，我没有
实际上指定数据的类型

178
00:09:29,240 --> 00:09:29,820
这是。

179
00:09:29,820 --> 00:09:32,780
这是因为
编译器，雨燕能

180
00:09:32,780 --> 00:09:36,910
推断只是基于数据的类型
对，我把它放在数据。

181
00:09:36,910 --> 00:09:41,760
因为它知道，通过评估该
变量就在这里，这个数据正确

182
00:09:41,760 --> 00:09:43,370
这里，它知道它是一个字符串。

183
00:09:43,370 --> 00:09:48,690
所以这个常数的名字因此
将是一个字符串，以及。

184
00:09:48,690 --> 00:09:52,730
>> 但是，我们也可以明确
关于这类型

185
00:09:52,730 --> 00:09:55,790
我们将用于
常数或变量

186
00:09:55,790 --> 00:10:01,590
通过使用此语法instead--
让名冒号字符串等于

187
00:10:01,590 --> 00:10:05,530
丹，在这种情况下意味着我们
要定义常量叫名字。

188
00:10:05,530 --> 00:10:07,150
这将是String类型。

189
00:10:07,150 --> 00:10:10,550
并且该值将是丹。

190
00:10:10,550 --> 00:10:12,550
现在其他的方式
我们可以创建variables--

191
00:10:12,550 --> 00:10:15,549
而这些都是可变变量，这
意味着我们，事实上，将

192
00:10:15,549 --> 00:10:19,670
某个时候改变自己的内容
在上下文的持续时间

193
00:10:19,670 --> 00:10:23,890
即该变量defined--我们
使用var关键字，而不是让。

194
00:10:23,890 --> 00:10:27,400
但同样，在默认情况下，除非你知道
你需要处理的数据，

195
00:10:27,400 --> 00:10:30,510
尝试使用我们的
性能改进。

196
00:10:30,510 --> 00:10:33,740
>> 在这种情况下，我可以再
指定的数据的类型

197
00:10:33,740 --> 00:10:37,650
我们期望得到的内部
这家名为标签的新变量。

198
00:10:37,650 --> 00:10:38,800
这将是一个字符串。

199
00:10:38,800 --> 00:10:43,030
而我们要那么串联
两个字符串，字符串Hello，

200
00:10:43,030 --> 00:10:48,070
和字符串所代表
变量，或者更确切地说，常量名。

201
00:10:48,070 --> 00:10:50,660
>> 因此，这是很好的，因为这
是有点像PHP的，因为我们

202
00:10:50,660 --> 00:10:52,250
有非常简单的字符串连接。

203
00:10:52,250 --> 00:10:56,350
我们不必以自动
使用任何类型的内存管理

204
00:10:56,350 --> 00:11:00,580
以增加的大小和做
任何形式的有趣的事情出现。

205
00:11:00,580 --> 00:11:05,040
这个工程，因为我们实际上期望。

206
00:11:05,040 --> 00:11:09,370
>> 好吧，这个问题吗？

207
00:11:09,370 --> 00:11:12,520
>> 现在其他的原因，
我们需要你有足够的能力

208
00:11:12,520 --> 00:11:15,490
能够定义什么
数据变量的类型是

209
00:11:15,490 --> 00:11:18,170
是因为有时候我们不
要初始化变量

210
00:11:18,170 --> 00:11:21,080
以在一些数据
点的定义。

211
00:11:21,080 --> 00:11:23,500
因此，在这种情况下，让我们说
我要开始输入

212
00:11:23,500 --> 00:11:25,040
部分牌号为一年级的书。

213
00:11:25,040 --> 00:11:27,530
嗯，我知道了一个
我想成为变量

214
00:11:27,530 --> 00:11:30,280
将是一个可变的档次。

215
00:11:30,280 --> 00:11:33,010
我们也知道，我们
希望它是一个整数。

216
00:11:33,010 --> 00:11:36,030
但也许我们还不
有级可用。

217
00:11:36,030 --> 00:11:39,570
>> 在斯威夫特，你必须
定义数据的类型

218
00:11:39,570 --> 00:11:44,000
是与一个相关联的
变量或常量让

219
00:11:44,000 --> 00:11:47,840
之前，你其实可以
使用该变量。

220
00:11:47,840 --> 00:11:51,170
因为它是强类型，
你有一个类型关联

221
00:11:51,170 --> 00:11:52,890
这些变量。

222
00:11:52,890 --> 00:11:56,120
>> 因此，在这种情况下，如果我没有正确
初始化先用一定的价值，

223
00:11:56,120 --> 00:12:00,520
那么我要告诉斯威夫特什么
我期望得到的数据类型。

224
00:12:00,520 --> 00:12:02,650
而且它会继续保持
相同的数据类型

225
00:12:02,650 --> 00:12:05,780
整个项目的历史。

226
00:12:05,780 --> 00:12:10,050
>> 现在，你可能会尽快诱惑
我创造了这个级别的变量

227
00:12:10,050 --> 00:12:13,530
并提供了它的一个
如果我的100的整数，现在

228
00:12:13,530 --> 00:12:18,540
想尝试来连接
一个字符串，该整数，

229
00:12:18,540 --> 00:12:21,610
也许会仍然使用
该字符串连接运算符

230
00:12:21,610 --> 00:12:24,500
像我们以前那样，只需几行。

231
00:12:24,500 --> 00:12:26,460
但不幸的是，
这实际上不是

232
00:12:26,460 --> 00:12:29,270
工作，因为你是
本质上表演

233
00:12:29,270 --> 00:12:32,380
上两种不同类型的操作。

234
00:12:32,380 --> 00:12:36,856
>> 现在，这是其他非常不同
语言如PHP这是真的

235
00:12:36,856 --> 00:12:38,480
loosey鹅与他们的那种类型。

236
00:12:38,480 --> 00:12:40,030
他们只是想，是啊，
什么，我不在乎。

237
00:12:40,030 --> 00:12:42,710
只要给我一个类型，
也许我会做正确的事。

238
00:12:42,710 --> 00:12:46,060
>> 在这种情况下，雨燕
极为严格的有关类型

239
00:12:46,060 --> 00:12:47,350
你正在处理。

240
00:12:47,350 --> 00:12:50,700
这求和运算符
或连接运算符

241
00:12:50,700 --> 00:12:54,400
基本上具有几个
不同的可行方案。

242
00:12:54,400 --> 00:12:56,970
你可以做总和
与整数，或者你

243
00:12:56,970 --> 00:13:00,870
可以做字符串连接，并
也许一些其他的事情也是如此。

244
00:13:00,870 --> 00:13:05,550
但如果运营商不承认
什么是在它的两侧

245
00:13:05,550 --> 00:13:10,452
或者更确切地说，这些的组合
两种类型，是不是它的预期，

246
00:13:10,452 --> 00:13:11,910
然后它会导致失败。

247
00:13:11,910 --> 00:13:16,690
>> 因此，在这种情况下，这是什么意思
以有一个字符串加上整数？

248
00:13:16,690 --> 00:13:18,880
孔中的上下文
这一点，我们可能需要

249
00:13:18,880 --> 00:13:21,990
做字符串连接操作。

250
00:13:21,990 --> 00:13:26,420
但当然计算机
没有那种背景。

251
00:13:26,420 --> 00:13:29,950
因此，我们需要提供
该附加信息

252
00:13:29,950 --> 00:13:32,390
让它知道这是什么
就是我们想要做的。

253
00:13:32,390 --> 00:13:36,860
>> 因此，换句话说，事实
该斯威夫特是强类型

254
00:13:36,860 --> 00:13:39,520
意味着你必须做
额外工作一点

255
00:13:39,520 --> 00:13:42,100
得到它来操作
你想办法。

256
00:13:42,100 --> 00:13:43,710
但是，结果，它是安全。

257
00:13:43,710 --> 00:13:46,290
一旦你有拿
考虑到这些类型，

258
00:13:46,290 --> 00:13:49,300
事情就坦言启动
工作得很好。

259
00:13:49,300 --> 00:13:52,520
>> 所以在这种情况下，我们将然后
执行字符串连接

260
00:13:52,520 --> 00:13:56,040
通过明确铸造
整数为字符串

261
00:13:56,040 --> 00:13:58,490
通过包装它在这
大写字母S字符串函数，

262
00:13:58,490 --> 00:14:03,510
然后使用字符串连接
运营商来修改我们的标签变量，

263
00:14:03,510 --> 00:14:06,280
然后打印出来。

264
00:14:06,280 --> 00:14:08,420
>> 到目前为止，一切都很好？

265
00:14:08,420 --> 00:14:12,020
好吧，让我们继续前进。

266
00:14:12,020 --> 00:14:16,300
>> 现在有各种数据
类型，我们可以在斯威夫特使用。

267
00:14:16,300 --> 00:14:21,620
当你已经习惯了，
我们可以创建一个可变的数组。

268
00:14:21,620 --> 00:14:26,140
而这阵只能
含有单一类型。

269
00:14:26,140 --> 00:14:30,360
>> 因此，在这种情况下，我们要创建
一个整数的可变数组，

270
00:14:30,360 --> 00:14:34,800
我们将调用档次，我们将能够
存储在这个方括号

271
00:14:34,800 --> 00:14:38,650
格式你已经长大习惯
在多种其它语言的。

272
00:14:38,650 --> 00:14:41,150
但是请注意，在这里我们是
确定几件事情。

273
00:14:41,150 --> 00:14:45,350
成绩是一个可变的变量 - 
我们不使用let关键字。

274
00:14:45,350 --> 00:14:49,620
因此，这意味着我们可以修改
这个数组的内容。

275
00:14:49,620 --> 00:14:53,420
这是数组类型为int，
我们可以告诉大家，

276
00:14:53,420 --> 00:14:56,260
基于这些方括号这里。

277
00:14:56,260 --> 00:14:58,930
>> 现在，人们的好东西
这个是我们

278
00:14:58,930 --> 00:15:02,310
有机会获得大量的
附加信息

279
00:15:02,310 --> 00:15:07,110
有关阵列只使用
一些简单的点表示法。

280
00:15:07,110 --> 00:15:10,500
因此，例如，
grades.count提供给我们

281
00:15:10,500 --> 00:15:14,820
项目中存在的数
数组，我们就可以访问漂亮

282
00:15:14,820 --> 00:15:19,090
轻松简单的使用点符号。

283
00:15:19,090 --> 00:15:21,830
>> 如果要添加其他
项目这个数组，

284
00:15:21,830 --> 00:15:27,220
你不能这样做PHP的风格
在这里你只要明确定义，

285
00:15:27,220 --> 00:15:30,910
一个给定的索引处，一些价值
要插入。

286
00:15:30,910 --> 00:15:37,210
相反，使用append
在数组类型的方法

287
00:15:37,210 --> 00:15:40,920
追加该项目，95，到这个列表。

288
00:15:40,920 --> 00:15:45,990
>> 所以，现在这个数组具有以下
contents-- 100，0，90，85。

289
00:15:45,990 --> 00:15:49,270
现在，我们已经追加
95到这一点。

290
00:15:49,270 --> 00:15:51,830
>> 还有其他的方法
我们可以附加的东西。

291
00:15:51,830 --> 00:15:55,030
实际上，你可以使用
求和运算符，

292
00:15:55,030 --> 00:15:59,200
这将被解释为
数组追加操作。

293
00:15:59,200 --> 00:16:04,680
你也可以再追加另
阵列，其内容是70和80，

294
00:16:04,680 --> 00:16:05,560
该阵列。

295
00:16:05,560 --> 00:16:08,250
所以，现在我们有
在这个变量的内容

296
00:16:08,250 --> 00:16:17,220
grades-- 100，0，90，85，95，70，和80。

297
00:16:17,220 --> 00:16:21,850
这仅仅是一个不错的语法
糖是斯威夫特提供给我们。

298
00:16:21,850 --> 00:16:23,850
>> 因此，如果我们想求和
成绩，我们也许

299
00:16:23,850 --> 00:16:27,340
会想迭代
在这个循环的每个项目。

300
00:16:27,340 --> 00:16:32,150
同时，我们也有，在斯威夫特，概念
for循环，你会期望。

301
00:16:32,150 --> 00:16:35,350
但是，我们要说明的方式
一个范围略有不同。

302
00:16:35,350 --> 00:16:37,790
所以在这种情况下，到
总之一切，我们将

303
00:16:37,790 --> 00:16:40,650
要创建一个临时的
变量称为总和，以便我们

304
00:16:40,650 --> 00:16:42,580
保持这个数量。

305
00:16:42,580 --> 00:16:44,430
>> 并注意我们的
这里环路建设。

306
00:16:44,430 --> 00:16:46,820
对于指数在0 ... <grade.count。

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

308
00:16:51,480 --> 00:16:57,390
所以该结构，0 .. <grades.count
是一系列的操作我们在哪里

309
00:16:57,390 --> 00:17:01,860
他说，我们要创建
从0整数范围

310
00:17:01,860 --> 00:17:05,750
但不包括grades.count。

311
00:17:05,750 --> 00:17:09,577
因此，这将是0，1，2，3，4，
5，直到然而，许多1

312
00:17:09,577 --> 00:17:10,410
前grades.count。

313
00:17:10,410 --> 00:17:14,160
>> 因此，这是不是有什么不同，我们
将通常用于循环

314
00:17:14,160 --> 00:17:18,569
你会在那里有一些指标
变量，将其设置为0在第一，

315
00:17:18,569 --> 00:17:25,480
然后集成的，直到一些
值小于项的计

316
00:17:25,480 --> 00:17:27,140
该数组。

317
00:17:27,140 --> 00:17:29,820
>> 因此，有一个修改
这一点，其实，

318
00:17:29,820 --> 00:17:35,010
这使我们能够很容易
设置不同类型的范围。

319
00:17:35,010 --> 00:17:40,570
如果您更改此范围内
三个点，0 ... grade.count，

320
00:17:40,570 --> 00:17:45,120
这代表范围为0
到grades.count包容性，

321
00:17:45,120 --> 00:17:49,260
这意味着该号码也
然后包含在该范围内。

322
00:17:49,260 --> 00:17:52,110
>> 但是，这是非常方便的
对于这些具体的事情，

323
00:17:52,110 --> 00:17:54,590
当我们要进行
在迭代循环

324
00:17:54,590 --> 00:17:59,630
因为这些指标都是零索引，
正如我们所看到的其他语言

325
00:17:59,630 --> 00:18:02,360
为好。

326
00:18:02,360 --> 00:18:05,210
在此有任何疑问for循环？

327
00:18:05,210 --> 00:18:10,660
>> 因此，有隐含的定义
该指数的变量，

328
00:18:10,660 --> 00:18:14,350
其值从0开始，并
继续在每个循环迭代

329
00:18:14,350 --> 00:18:17,950
1至增加，直到点
等于grades.count，

330
00:18:17,950 --> 00:18:20,380
在这一点，循环中止。

331
00:18:20,380 --> 00:18:23,730
>> 请注意，在我们的字符串
内插在这里，

332
00:18:23,730 --> 00:18:26,910
我们实际上可以执行一些简单的
操纵这些值。

333
00:18:26,910 --> 00:18:31,230
因此，指数加1将实际
执行该值的总和

334
00:18:31,230 --> 00:18:34,780
由于指数是在
这种情况下，一个整数。

335
00:18:34,780 --> 00:18:37,810
在这一点上，它将
然后被转换成一个串

336
00:18:37,810 --> 00:18:42,230
插值成该字符串在这里，
并打印出来，因为我们所期望的。 。

337
00:18:42,230 --> 00:18:44,520
>> 而好处
关于阵列这里

338
00:18:44,520 --> 00:18:50,730
我们也能有
取值和设定值

339
00:18:50,730 --> 00:18:54,080
用方括号作为
我们已经看到在其他语言。

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

341
00:18:57,130 --> 00:19:01,030
>> 所有的权利，所以从这里，我们现在
我们计算所有等级的总和。

342
00:19:01,030 --> 00:19:02,780
现在的排序下一个
合乎逻辑的步骤将是

343
00:19:02,780 --> 00:19:07,580
做除法运算找到
从这些成绩的平均值。

344
00:19:07,580 --> 00:19:10,150
但是，一些重要的东西
这里正在发生哪些

345
00:19:10,150 --> 00:19:15,020
是，这笔钱也许是一个整数。

346
00:19:15,020 --> 00:19:18,020
但是，我们需要执行一些
那种双师。

347
00:19:18,020 --> 00:19:20,600
而这将是
非常重要的，当

348
00:19:20,600 --> 00:19:24,140
我们要执行此操作，
因为我们在说什么

349
00:19:24,140 --> 00:19:28,430
是我们需要真正
在两个双打进行划分。

350
00:19:28,430 --> 00:19:31,370
再次，由于斯威夫特
非常强类型，

351
00:19:31,370 --> 00:19:36,760
我们必须明确地设置所有的
其实在我们的项目双打

352
00:19:36,760 --> 00:19:38,300
执行该操作。

353
00:19:38,300 --> 00:19:40,550
>> 因此，为了让我们
执行双师，

354
00:19:40,550 --> 00:19:43,730
这是不够的只是一个
这些项目是一个双。

355
00:19:43,730 --> 00:19:46,400
他们都必须是
双重为了迅速

356
00:19:46,400 --> 00:19:50,860
可以肯定，这
就是我们想要做的。

357
00:19:50,860 --> 00:19:54,360
因此，我们会再明确类型转换
而我们上面计算的总和

358
00:19:54,360 --> 00:19:58,970
和档次双打的数量，和
然后执行该操作和存储

359
00:19:58,970 --> 00:20:02,390
这到这个新的变量，或者更确切地说，
这个新常数叫平均，

360
00:20:02,390 --> 00:20:06,810
这将有什么类型的，你能想象吗？

361
00:20:06,810 --> 00:20:07,587
双，是啊。

362
00:20:07,587 --> 00:20:09,420
所以在这种情况下，我们
不必指定它

363
00:20:09,420 --> 00:20:13,450
因为它可以从被推断
操作什么样的数据平均类型

364
00:20:13,450 --> 00:20:14,730
会是。

365
00:20:14,730 --> 00:20:19,025
而雨燕一般是相当不错的
对能够推断出的类型。

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

367
00:20:22,116 --> 00:20:24,200
>> 难道你想看到这个
运行，或者我可以继续前进？

368
00:20:24,200 --> 00:20:25,640
我想继续下去。

369
00:20:25,640 --> 00:20:28,130
在任何这有问题吗？

370
00:20:28,130 --> 00:20:28,630
大。

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

372
00:20:31,160 --> 00:20:35,010
>> 现在我们要开始去
好stuff--定义功能，

373
00:20:35,010 --> 00:20:39,090
和一对夫妇的其他类型是
独特的雨燕，你有没有

374
00:20:39,090 --> 00:20:41,620
看到其他语言
直到这一点，

375
00:20:41,620 --> 00:20:46,290
但它们存在于其它
语言，你可能会发现以后。

376
00:20:46,290 --> 00:20:48,210
因此，首先，如果你想
定义一个函数，

377
00:20:48,210 --> 00:20:52,170
你用时髦的词定义它
函数，然后函数名，

378
00:20:52,170 --> 00:20:56,710
然后在括号中的参数
您希望这个函数接受。

379
00:20:56,710 --> 00:21:00,280
这些参数也必须
specify-- generally--

380
00:21:00,280 --> 00:21:05,010
还必须指定数据的类型是
它们是，除非它们可以推断。

381
00:21:05,010 --> 00:21:07,500
我们会看到那个小
需要注意的只是一点点。

382
00:21:07,500 --> 00:21:09,920
>> 因此，在这种情况下，我们有一个
函数调用printGradeCount。

383
00:21:09,920 --> 00:21:12,840
我们将接受
变量 - 或者更确切地说，在这种情况下，

384
00:21:12,840 --> 00:21:14,450
一个constant--叫成绩册。

385
00:21:14,450 --> 00:21:18,517
而这将是对
键入整数数组。

386
00:21:18,517 --> 00:21:20,600
现在有什么东西
这是非常重要的在这里

387
00:21:20,600 --> 00:21:21,849
我希望你能理解。

388
00:21:21,849 --> 00:21:27,560
也就是说，默认情况下，这些参数
输入时该功能的

389
00:21:27,560 --> 00:21:34,380
有一个隐含的let关键字定义，
这意味着我不能修改这个

390
00:21:34,380 --> 00:21:39,850
在这里成绩簿变量。

391
00:21:39,850 --> 00:21:43,360
而排序是有道理的，
因为你传递的数据研究。

392
00:21:43,360 --> 00:21:45,860
你也许不希望它
从下你变了。

393
00:21:45,860 --> 00:21:50,800
它可以明确地提
这是一个变量通过将

394
00:21:50,800 --> 00:21:52,070
这里var关键字。

395
00:21:52,070 --> 00:21:56,832
但是，这是我们已经一个疑难杂症
人们注意到，在过去做

396
00:21:56,832 --> 00:21:59,790
是，他们以为这是怎么回事
是变量时，事实上，它

397
00:21:59,790 --> 00:22:02,640
是一个常数。

398
00:22:02,640 --> 00:22:07,340
>> 好了，所以在这里的话，在这种情况下，
我们没有指定任何返回类型。

399
00:22:07,340 --> 00:22:09,460
我们会告诉你怎么做
在短短的时刻。

400
00:22:09,460 --> 00:22:12,340
但是请注意，在这里，我们有
只是一个简单的，如果条件。

401
00:22:12,340 --> 00:22:14,560
如果成绩簿是
空，在这种情况下

402
00:22:14,560 --> 00:22:19,310
是这个整数的只是财产
阵列，那么我们打印出一些东西。

403
00:22:19,310 --> 00:22:23,100
否则，我们做别的事情。

404
00:22:23,100 --> 00:22:25,000
>> 很简单，到目前为止，我认为。

405
00:22:25,000 --> 00:22:27,960
但是，如果你有任何问题，阻止我。

406
00:22:27,960 --> 00:22:33,350
>> 现在这个功能，平均，也需要
一些参数，或者说一个参数，

407
00:22:33,350 --> 00:22:37,507
这是成绩册，而这一次
是否会返回一个double类型。

408
00:22:37,507 --> 00:22:39,340
因为它是计算
的平均值和它的

409
00:22:39,340 --> 00:22:45,010
要真正返回
计算出的平均呼叫线路。

410
00:22:45,010 --> 00:22:50,070
>> 在这种情况下，我们指定
箭头后返回类型。

411
00:22:50,070 --> 00:22:53,260
而这可能会感到
那种怪异的在第一。

412
00:22:53,260 --> 00:22:55,610
你已经习以为常
于设置返回

413
00:22:55,610 --> 00:22:57,720
函数的名称前输入。

414
00:22:57,720 --> 00:23:00,310
但是，如果你觉得这
在数学方面，

415
00:23:00,310 --> 00:23:03,320
就像当你有数学
定义一个函数，

416
00:23:03,320 --> 00:23:06,807
你有一些功能
输入，它产生一个输出。

417
00:23:06,807 --> 00:23:08,890
而这正是
这是应该模仿。

418
00:23:08,890 --> 00:23:12,460
还有一对夫妇其他语言
具有类似的语法为好，

419
00:23:12,460 --> 00:23:15,674
但可能没有一个
你见过在CS50。

420
00:23:15,674 --> 00:23:17,090
但还是不要被它迷惑。

421
00:23:17,090 --> 00:23:21,650
箭头表示是怎么回事
在这种情况下，要返回。

422
00:23:21,650 --> 00:23:23,650
好了，我们怎么
计算这个平均值？

423
00:23:23,650 --> 00:23:25,649
好吧，如果成绩簿
是空的，好，那么我们

424
00:23:25,649 --> 00:23:30,731
会返回一个0，这可能
一个合理的方式来对待这一点。

425
00:23:30,731 --> 00:23:32,980
我不知道，让我们来
回到那个在一点点。

426
00:23:32,980 --> 00:23:34,688
这可能不是实际
是一种合理的方式

427
00:23:34,688 --> 00:23:38,310
计算的平均如果
我们有一个空的成绩册。

428
00:23:38,310 --> 00:23:41,260
>> 然后，我们就进行了总结。

429
00:23:41,260 --> 00:23:43,900
请注意，在这里我们实际上
有一个替代版本

430
00:23:43,900 --> 00:23:49,190
for循环，这使我们能够迭代
在数组中的每一个项目

431
00:23:49,190 --> 00:23:53,630
并把每一个元素
到它自己的变量。

432
00:23:53,630 --> 00:23:56,200
通过在指定的等级
成绩册，我们在说什么

433
00:23:56,200 --> 00:24:00,560
就是我们要含蓄
创建一个新的常数称为

434
00:24:00,560 --> 00:24:05,180
等级，是要代表
在成绩簿每一个独特的项目

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

436
00:24:06,769 --> 00:24:08,560
所以第一次
它的运行，成绩将

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

438
00:24:09,800 --> 00:24:12,300
第二次，它会是
第二个项目，等等等等

439
00:24:12,300 --> 00:24:15,970
直到成绩册有
用尽元素本身。

440
00:24:15,970 --> 00:24:20,390
然后，我们就可以总结说
等级到我们的总和变数

441
00:24:20,390 --> 00:24:22,570
并返回我们的平均
正如我们之前看到的。

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

443
00:24:25,670 --> 00:24:26,950
OK，什么问题吗？

444
00:24:26,950 --> 00:24:27,699
是？

445
00:24:27,699 --> 00:24:28,990
听众：我有两个问题。

446
00:24:28,990 --> 00:24:33,586
第一，假设，可以
你在这一个运行的整数？

447
00:24:33,586 --> 00:24:35,604
不必须是一个
双，是正确的？

448
00:24:35,604 --> 00:24:37,520
DAN AMRMENDARIZ：你能
重复这个问题？

449
00:24:37,520 --> 00:24:39,587
听众：我可以这样做
整数作为平均？

450
00:24:39,587 --> 00:24:41,670
DAN AMRMENDARIZ：你能
做整数作为平均？

451
00:24:41,670 --> 00:24:45,015
因此，返回一个整数
平均而不是双？

452
00:24:45,015 --> 00:24:48,204
>> 听众：Return--您
有这个权利，现在下面。

453
00:24:48,204 --> 00:24:49,870
DAN AMRMENDARIZ：就在这里，返回0.0？

454
00:24:49,870 --> 00:24:51,790
听众：是啊，刚刚返回0。

455
00:24:51,790 --> 00:24:56,590
所以这将是要么
80或85，但不是85.2。

456
00:24:56,590 --> 00:24:59,465
>> DAN AMRMENDARIZ：所以在这种情况下，
所以有几种不同的方法

457
00:24:59,465 --> 00:25:00,090
要回答这个问题。

458
00:25:00,090 --> 00:25:02,760
我来回答他们的订单。

459
00:25:02,760 --> 00:25:06,740
所以，如果我只是让这个返回
0，0是一个整数值。

460
00:25:06,740 --> 00:25:09,730
因此，这将导致一个
型误差对于这种情况

461
00:25:09,730 --> 00:25:13,210
因为它期待一个双
但随后返回一个整数。

462
00:25:13,210 --> 00:25:16,770
如果我想返回一个整数，我可以。

463
00:25:16,770 --> 00:25:20,450
我可以设置的返回类型
为int，这里返回0，

464
00:25:20,450 --> 00:25:22,047
而不是执行双师。

465
00:25:22,047 --> 00:25:23,880
但是，我们将
做整数除法。

466
00:25:23,880 --> 00:25:27,080
所以我们以后就不会得到
一般，我们将可能期望。

467
00:25:27,080 --> 00:25:29,210
但是，是的，我们可以通过修改
以这种方式的类型。

468
00:25:29,210 --> 00:25:32,598
>> 听众：其次，你
有一个双顶部。

469
00:25:32,598 --> 00:25:35,502
但向下跌破，当你
做回双人大床，

470
00:25:35,502 --> 00:25:38,280
这已经自动
返回双格式。

471
00:25:38,280 --> 00:25:42,278
为什么你还需要将它定义
在顶部有一个双箭头？

472
00:25:42,278 --> 00:25:45,010
>> DAN AMRMENDARIZ：所以
在情况下，这是部分

473
00:25:45,010 --> 00:25:50,580
对the--如此重复的问题，
因为这是自回归隐

474
00:25:50,580 --> 00:25:56,030
这里的类型，什么类型的这实际上
是，我们需要明确与斯威夫特

475
00:25:56,030 --> 00:25:59,970
什么，我们要
返回该功能的出

476
00:25:59,970 --> 00:26:02,690
这样，当它执行类型
检查时，可确保

477
00:26:02,690 --> 00:26:05,850
这就是我们实际上写
楼下居然符合这一点。

478
00:26:05,850 --> 00:26:10,225
因此，这有点像检查
与自己的排序情况。

479
00:26:10,225 --> 00:26:11,050
但是，are--

480
00:26:11,050 --> 00:26:12,560
>> 听众：[听不清]箭头？

481
00:26:12,560 --> 00:26:19,490
>> DAN AMRMENDARIZ：有情况下，当
我们可以指定我们可以隐

482
00:26:19,490 --> 00:26:21,550
设置返回类型。

483
00:26:21,550 --> 00:26:23,940
但在这种情况下，我不
认为这工作。

484
00:26:23,940 --> 00:26:26,190
还有一些其他的语法
以后我们会看到。

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

486
00:26:30,320 --> 00:26:35,280
>> 好了，所以这个来源
代码是有点不同

487
00:26:35,280 --> 00:26:41,839
因为这种分析的参数
我们正在调用该函数。

488
00:26:41,839 --> 00:26:44,130
让我告诉你它是如何工作
之前，我们实际上前进

489
00:26:44,130 --> 00:26:48,050
一些有趣的事情
这是发生在斯威夫特。

490
00:26:48,050 --> 00:26:51,870
>> 因此，在这种情况下，如果我只是运行此
代码，请注意，它是做什么

491
00:26:51,870 --> 00:26:54,900
is--而种，它
给了我一个奇怪的错误。

492
00:26:54,900 --> 00:26:59,730
我需要通过这几个
整数作为命令行参数。

493
00:26:59,730 --> 00:27:06,220
因此，让我们来看看，150和80，然后按Enter
找出它实际上做。

494
00:27:06,220 --> 00:27:09,890
它接受各
这些数值为整数。

495
00:27:09,890 --> 00:27:12,040
它的输入他们入成绩册。

496
00:27:12,040 --> 00:27:14,470
然后，它执行
该平均值计算

497
00:27:14,470 --> 00:27:16,650
并输出，作为我们期望的那样。

498
00:27:16,650 --> 00:27:19,950
>> 不过，显然有什么东西会
与此拒绝的东西

499
00:27:19,950 --> 00:27:23,300
东西作为一个整数。

500
00:27:23,300 --> 00:27:27,300
正如你可能还记得，当我们
处理命令行参数

501
00:27:27,300 --> 00:27:32,640
在C和其他语言，第一个
在命令行参数0个项目

502
00:27:32,640 --> 00:27:35,774
列表是命令的名称
我们实际执行。

503
00:27:35,774 --> 00:27:38,690
因此，在这种情况下，我只是循环
在所有的命令行参数。

504
00:27:38,690 --> 00:27:41,650
但我没有做任何形式的花哨
检查跳过的第一个。

505
00:27:41,650 --> 00:27:45,920
我只是或明或我隐
检查这些类型的

506
00:27:45,920 --> 00:27:49,900
是整数之前，我其实
执行此计算。

507
00:27:49,900 --> 00:27:52,420
>> 这就是本质
这里发生了什么。

508
00:27:52,420 --> 00:27:55,860
对于每一个参数
该过程的参数，

509
00:27:55,860 --> 00:27:59,210
我要进行一些检查。

510
00:27:59,210 --> 00:28:01,970
在这种情况下，我要去
试着先转换

511
00:28:01,970 --> 00:28:07,620
这样的说法成整数由
执行明确的类型转换，

512
00:28:07,620 --> 00:28:12,310
因为它是，在输入一个字符串
并没有实际上的整数。

513
00:28:12,310 --> 00:28:18,140
>> 但是，这是怎样的一个奇怪的语法，
如果让坡度等于INT（参数）。

514
00:28:18,140 --> 00:28:21,120
实际发生的事情
这里是非常

515
00:28:21,120 --> 00:28:24,390
重要的是你用斯威夫特。

516
00:28:24,390 --> 00:28:27,610
这是用什么
所谓的可选类型。

517
00:28:27,610 --> 00:28:34,790
>> 所以这个功能，INT（参数），
返回不只是一个整数，但返回

518
00:28:34,790 --> 00:28:37,470
什么所谓的可选整数。

519
00:28:37,470 --> 00:28:41,200
所以这是有点
一个类型上的类型的顶部。

520
00:28:41,200 --> 00:28:45,900
那种你能想象它像
它的返回像包。

521
00:28:45,900 --> 00:28:47,750
而当你打开
封装，无论是

522
00:28:47,750 --> 00:28:53,930
具有整数，这是结果，或
它具有绝对没有在它。

523
00:28:53,930 --> 00:28:58,140
而这是作为一个错误检查有用
机构，因为在这种情况

524
00:28:58,140 --> 00:29:02,080
我们可以看出，这是
类型转换成功？

525
00:29:02,080 --> 00:29:05,810
如果是，那么它是实际上
将不得不内的整数。

526
00:29:05,810 --> 00:29:08,750
否则，这将有一些
值，我们称之为零，这

527
00:29:08,750 --> 00:29:10,920
代表没有整数可言。

528
00:29:10,920 --> 00:29:13,270
这是真正代表什么。

529
00:29:13,270 --> 00:29:18,130
>> 所以这一点，如果建
使我们能够解开那个包，

530
00:29:18,130 --> 00:29:19,850
那个可选择绑定。

531
00:29:19,850 --> 00:29:25,560
如果我们能够解开这
打包并发现里面的整数，

532
00:29:25,560 --> 00:29:27,720
然后我们在说什么
这里要说的是，我们之后会

533
00:29:27,720 --> 00:29:33,090
允许设置该值成
这个常数称为档次。

534
00:29:33,090 --> 00:29:36,590
和if语句的这一部分，
if语句的顶部部分

535
00:29:36,590 --> 00:29:40,390
将运行，因为那
展开是成功的。

536
00:29:40,390 --> 00:29:43,290
>> 如果它只是恰巧，
有可能是一个错误

537
00:29:43,290 --> 00:29:47,040
在这种显式类型转换
从字符串的整数，也许

538
00:29:47,040 --> 00:29:49,160
它的值ABC为例。

539
00:29:49,160 --> 00:29:52,120
而这实际上是不打算
转换成整数。

540
00:29:52,120 --> 00:29:55,520
然后，它会返回nil，
这不是一个整数。

541
00:29:55,520 --> 00:29:57,570
而这个if语句以及再失败。

542
00:29:57,570 --> 00:30:01,930
成绩将不会因为存在
它没有任何整数内容。

543
00:30:01,930 --> 00:30:06,391
它将运行这个else块来代替。

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

545
00:30:06,890 --> 00:30:09,652
>> 听众：无为N-I-L？

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

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

548
00:30:14,970 --> 00:30:20,310
>> 因此，这是可能之一
关于SWIFT最难的事情，

549
00:30:20,310 --> 00:30:23,690
尤其是当你在
在iOS应用程序的杂草

550
00:30:23,690 --> 00:30:27,442
而你实际上是试图
做一些开发那里。

551
00:30:27,442 --> 00:30:29,400
这将是大呼小叫
你对可选的。

552
00:30:29,400 --> 00:30:33,050
这将要求你的
问号和惊叹号。

553
00:30:33,050 --> 00:30:37,100
但是，一旦你的身影out--，如果你
花一些时间来搞清楚

554
00:30:37,100 --> 00:30:41,990
什么是可选的种类回事，
你会节省大量的头痛

555
00:30:41,990 --> 00:30:46,040
当你试图
写在斯威夫特的应用程序。

556
00:30:46,040 --> 00:30:47,660
>> 它实际上是一个非常强大的功能。

557
00:30:47,660 --> 00:30:49,826
而你只需要
把我的话它现在。

558
00:30:49,826 --> 00:30:52,620
但是，我们会看到这种结构
有的人喜欢它

559
00:30:52,620 --> 00:30:56,740
在其他一些源代码
我们会告诉你的只是一点点。

560
00:30:56,740 --> 00:31:00,440
>> 是否有任何初始的问题在这里？

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

562
00:31:03,790 --> 00:31:08,690
因此，重要的外卖是一个
可选的类型是那种一元类型的。

563
00:31:08,690 --> 00:31:12,500
它或者具有值，
如果确实如此，那么它

564
00:31:12,500 --> 00:31:18,110
也许会有关联的值
有了它，或者任何有没有价值，

565
00:31:18,110 --> 00:31:19,620
它是由零来表示。

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

567
00:31:24,210 --> 00:31:28,870
这剩下的也许是
正如你所期望的。

568
00:31:28,870 --> 00:31:32,900
>> 因此，让我们斜坡上升
困难再一次。

569
00:31:32,900 --> 00:31:37,070
而这个时候，让我们来看看一些
实际存在的其他数据类型。

570
00:31:37,070 --> 00:31:41,290
其中之一是词典，它是
非常类似于Python字典。

571
00:31:41,290 --> 00:31:48,270
这有点类似于在哈希表中
C.它实质上是键的映射

572
00:31:48,270 --> 00:31:49,820
其中，键可以是字符串。

573
00:31:49,820 --> 00:31:52,670
而当你仰望这些键，
这些密钥将有一个值。

574
00:31:52,670 --> 00:31:56,020
所以它不是很数组，但
相反，联系更紧密

575
00:31:56,020 --> 00:31:58,810
一个散列映射或哈希表。

576
00:31:58,810 --> 00:32:02,420
>> 让我们来看看这是怎么认为
我们以前的工作实际

577
00:32:02,420 --> 00:32:05,210
进入源代码本身。

578
00:32:05,210 --> 00:32:07,680
如果我只是运行它，
没有什么发生。

579
00:32:07,680 --> 00:32:12,430
它告诉我，我期待
以下类型的一些参数。

580
00:32:12,430 --> 00:32:16,050
所以，我要提供给
它的一些问题集的名字，

581
00:32:16,050 --> 00:32:18,490
所以pset0，也许我得了100。

582
00:32:18,490 --> 00:32:20,790
而PSET1，我得到了5。

583
00:32:20,790 --> 00:32:24,630
然后在考试，我
确实非常好，得到了30。

584
00:32:24,630 --> 00:32:27,180
而哎呀，我在这里打了一个空间。

585
00:32:27,180 --> 00:32:30,940
>> 当我敲回车，就可以看到
它执行一些计算。

586
00:32:30,940 --> 00:32:33,740
它说，成绩册为三
等级，PSET1，pset0，考试。

587
00:32:33,740 --> 00:32:36,120
而成绩簿有
这个特定的平均水平。

588
00:32:36,120 --> 00:32:38,370
所以，再一次，我们正在努力
这一成绩册的想法，

589
00:32:38,370 --> 00:32:44,650
但我们要继续迭代
与我们的功能的复杂性。

590
00:32:44,650 --> 00:32:47,650
>> 因此，在一开始，我们只是
要创建一个函数，

591
00:32:47,650 --> 00:32:49,390
负责印刷的用法。

592
00:32:49,390 --> 00:32:51,920
还有的这一退出
功能，将只

593
00:32:51,920 --> 00:32:53,710
强制退出应用程序。

594
00:32:53,710 --> 00:32:56,530
这是不是一件
你会在iOS应用使用。

595
00:32:56,530 --> 00:32:59,750
这是唯一的，在这种情况下，
用命令行参数。

596
00:32:59,750 --> 00:33:01,990
接下来，我们将开始走向Xcode中。

597
00:33:01,990 --> 00:33:07,760
但是，这是具体的命令
线型方案斯威夫特。

598
00:33:07,760 --> 00:33:11,490
>> 让我们来看看一些
这里的有趣的事情。

599
00:33:11,490 --> 00:33:15,150
让我们来看看，只有一对夫妇的
有趣的事情提也许

600
00:33:15,150 --> 00:33:19,930
是，我的功能
印刷等级的数目，

601
00:33:19,930 --> 00:33:26,090
你可能还记得，我有这样的列表
的items-- PSET1，pset0和考试。

602
00:33:26,090 --> 00:33:29,130
实际上，你可以迅速
轻松地做到这一点

603
00:33:29,130 --> 00:33:34,490
通过采取成绩簿，这是一个
字典具有键和值。

604
00:33:34,490 --> 00:33:38,730
找到所有的关键就是通过
这里的关键点的方法，

605
00:33:38,730 --> 00:33:43,180
然后用这个joinWithSeparator，
它随后将采取所有的关键

606
00:33:43,180 --> 00:33:48,590
我们已经输入了，pset1--或
抱歉，pset0，PSET1和exam--

607
00:33:48,590 --> 00:33:53,030
并连接在一起
使用逗号和空格

608
00:33:53,030 --> 00:33:55,400
创建一个长字符串。

609
00:33:55,400 --> 00:34:00,190
这种连接操作仅仅是惊人
有用在各种情况下。

610
00:34:00,190 --> 00:34:03,450
因此，这是这个joinWithSeparator。

611
00:34:03,450 --> 00:34:06,939
>> 这是一件事是
改变从斯威夫特1斯威夫特2。

612
00:34:06,939 --> 00:34:08,730
过去有一个
如果你的Python style--

613
00:34:08,730 --> 00:34:13,219
熟悉Python--一个Python
风格的加入对字符串的方法。

614
00:34:13,219 --> 00:34:15,699
但是，这已不再是
在斯威夫特2的情况。

615
00:34:15,699 --> 00:34:19,400
你想，如果你想用这个
来连接东西的数组

616
00:34:19,400 --> 00:34:23,380
连同一个字符串。

617
00:34:23,380 --> 00:34:27,889
>> 因此，也许那么在我们
平均前讨论，

618
00:34:27,889 --> 00:34:32,659
它使一点点意义
为我们设定的平均功能

619
00:34:32,659 --> 00:34:36,610
是任选的，而双
不仅仅是一个明确的两倍。

620
00:34:36,610 --> 00:34:39,239
因为我们有这样的
不寻常的情况，其中，

621
00:34:39,239 --> 00:34:41,550
如果实际成绩册什么
已经在它没有价值？

622
00:34:41,550 --> 00:34:44,280
又该平均回报？

623
00:34:44,280 --> 00:34:46,350
>> 嗯，也许在C中你
会做什么

624
00:34:46,350 --> 00:34:50,040
等提供的标记值，如
0.0，或者负数，

625
00:34:50,040 --> 00:34:53,690
什么刚表示事实
说明有一些错误条件

626
00:34:53,690 --> 00:34:57,910
你也许实际上并不
计算该平均的能力。

627
00:34:57,910 --> 00:35:05,590
那么指定的美丽
可选的类型会做到这一点。

628
00:35:05,590 --> 00:35:09,540
而我现在说这些话，但
这其实不使用选配。

629
00:35:09,540 --> 00:35:12,970
但是，我们可以看到，在刚刚
分钟，在这里我们可以设置平均

630
00:35:12,970 --> 00:35:17,230
为使一个可选的数据类型
如果它实际上返回一些数据，然后

631
00:35:17,230 --> 00:35:18,470
我们将返回的数据。

632
00:35:18,470 --> 00:35:20,570
否则，我们将返回
零，说这

633
00:35:20,570 --> 00:35:22,200
没有有意义的计算。

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

635
00:35:25,650 --> 00:35:28,570
>> 让我们转移到别的东西。

636
00:35:28,570 --> 00:35:35,910
所以从这里开始，我们一直在寻找
所有这些例子中的命令行。

637
00:35:35,910 --> 00:35:39,470
不过说真的，你打算什么
待处理的Xcode的。

638
00:35:39,470 --> 00:35:43,720
而关于漂亮的事情之一
Xcode是，特别是在雨燕，

639
00:35:43,720 --> 00:35:47,450
是，我们有这个
东西叫做一个游乐场。

640
00:35:47,450 --> 00:35:51,470
和一个操场是
不是在所有的iOS应用程序。

641
00:35:51,470 --> 00:35:54,751
但它可以让你体验
与Swift在一个非常简单的方法。

642
00:35:54,751 --> 00:35:56,000
您可以输入所有的代码。

643
00:35:56,000 --> 00:35:58,140
它很好的语法高亮显示在这里。

644
00:35:58,140 --> 00:36:01,600
当你创建一个新的文件，它会询问
你，如果你想创建一个游乐场。

645
00:36:01,600 --> 00:36:08,720
但对游乐场的好处
是在你的窗口的右侧，

646
00:36:08,720 --> 00:36:12,020
它实际上告诉你
从您的代码的输出。

647
00:36:12,020 --> 00:36:16,110
所以，如果我向下滚动，我们可以看到什么
各个行的代码的输出

648
00:36:16,110 --> 00:36:17,200
实际情况是。

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

650
00:36:19,850 --> 00:36:26,790
>> 因此，在这种情况下，我们要
改变方向，只是一点点

651
00:36:26,790 --> 00:36:30,960
与谈这真的
重要的是这种高层次的方法

652
00:36:30,960 --> 00:36:34,020
该夫特操作，并且它
这种想法倒闭。

653
00:36:34,020 --> 00:36:36,960
你可能已经看到了这一点
在JavaScript中一点点。

654
00:36:36,960 --> 00:36:40,770
对于那些你
在CS50，封闭

655
00:36:40,770 --> 00:36:47,240
在做非常受欢迎，非常好的方法
高层次的东西在现代语言。

656
00:36:47,240 --> 00:36:50,270
但它也是一种很难
包装你的头左右的第一次。

657
00:36:50,270 --> 00:36:52,269
所以，如果你在看这个
第一次，没关系。

658
00:36:52,269 --> 00:36:56,740
只要看看源代码，看看
如果你自己看着办吧在家里。

659
00:36:56,740 --> 00:37:01,050
>> 因此，在这种情况下，让我们说，我们
要创造了许多代表人物

660
00:37:01,050 --> 00:37:04,134
与一些固定值。

661
00:37:04,134 --> 00:37:05,800
因此，在这种情况下，我可以创造一个功能。

662
00:37:05,800 --> 00:37:09,270
我打算把它的力量
在生活中2，其唯一目的

663
00:37:09,270 --> 00:37:15,770
是采取一些输入和双
它，并返回该值。

664
00:37:15,770 --> 00:37:21,210
请注意，我在这里
接受一种类型的数据。

665
00:37:21,210 --> 00:37:23,137
这将是一个变量x。

666
00:37:23,137 --> 00:37:23,970
这是Double类型。

667
00:37:23,970 --> 00:37:26,190
我还会回到这里一个双。

668
00:37:26,190 --> 00:37:29,100
而我只是打算做
很坦率地说，漂亮

669
00:37:29,100 --> 00:37:32,650
加倍这个数值的幼稚方式。

670
00:37:32,650 --> 00:37:35,600
我会告诉你为什么
是在短短的第二个有用。

671
00:37:35,600 --> 00:37:40,418
>> 请注意，在这里，我们有这个范围内
再次。的东西在1点

672
00:37:40,418 --> 00:37:44,130
点点，2，这意味着
这种循环将运行两次。

673
00:37:44,130 --> 00:37:46,480
但是，这代表了一个虚拟变量。

674
00:37:46,480 --> 00:37:49,650
这意味着我不是真的要
在任何地方使用该变量

675
00:37:49,650 --> 00:37:51,070
在这个循环中。

676
00:37:51,070 --> 00:37:55,380
我只是希望这条线
的代码运行两次，

677
00:37:55,380 --> 00:37:58,980
无需知道
该范围的值。

678
00:37:58,980 --> 00:38:02,570
>> 因此，在这种情况下，我运行的结果
次两次x，它本质

679
00:38:02,570 --> 00:38:06,560
意味着我现蕾此值。

680
00:38:06,560 --> 00:38:10,230
而这恰好
工作作为我们期望的那样。

681
00:38:10,230 --> 00:38:16,410
2的幂，传递的价值
2.0给我们4的输出。

682
00:38:16,410 --> 00:38:18,810
3.2工程10.24。

683
00:38:18,810 --> 00:38:22,660
>> 现在，我们可以做一个类似的
对于3次方的事情。

684
00:38:22,660 --> 00:38:25,330
但现在只更改范围。

685
00:38:25,330 --> 00:38:28,840
对于1哑变量
通过3，乘3次，

686
00:38:28,840 --> 00:38:29,830
做同样的事情。

687
00:38:29,830 --> 00:38:32,240
>> 因此，这可能会觉得有点做作。

688
00:38:32,240 --> 00:38:34,270
但是，还有一个重要的
这里的东西

689
00:38:34,270 --> 00:38:37,770
是看着这些
两种功能，有

690
00:38:37,770 --> 00:38:43,600
只有一件事是不同的，
这是在范围此值。

691
00:38:43,600 --> 00:38:46,910
一切有关这两个
功能的3次方和2的幂，

692
00:38:46,910 --> 00:38:50,440
是，其实是因为相同的
它们以同样的方式工作。

693
00:38:50,440 --> 00:38:53,460
>> 所以在这一点上，一个小
警钟应该去了。

694
00:38:53,460 --> 00:38:56,200
希望你在说什么，
要知道，这种感觉有点

695
00:38:56,200 --> 00:38:59,250
喜欢重复劳动。

696
00:38:59,250 --> 00:39:02,950
也许有一种方法，我会
能够封装所有的这

697
00:39:02,950 --> 00:39:06,630
并提供一个功能
或者创建一个函数，

698
00:39:06,630 --> 00:39:11,550
不正是我想要不
需要给它明确地打字了。

699
00:39:11,550 --> 00:39:15,732
这是什么力量
一个封闭的让我们做。

700
00:39:15,732 --> 00:39:16,940
因此，让我们来看看这个。

701
00:39:16,940 --> 00:39:18,700
我会花几个
分钟在此，因为这

702
00:39:18,700 --> 00:39:20,310
对于斯威夫特非常重要的。

703
00:39:20,310 --> 00:39:22,900
我们看到这一切的时候。

704
00:39:22,900 --> 00:39:24,550
我们要定义一个函数。

705
00:39:24,550 --> 00:39:26,380
这将被称为powerOf。

706
00:39:26,380 --> 00:39:29,470
这将接受
参数调用类型为int年。

707
00:39:29,470 --> 00:39:32,220
但看一看的返回类型。

708
00:39:32,220 --> 00:39:38,730
返回类型是，在
括号，双箭头双。

709
00:39:38,730 --> 00:39:43,370
这意味着这种功能，
这个功能powerOf，

710
00:39:43,370 --> 00:39:46,550
正在恢复的功能。

711
00:39:46,550 --> 00:39:50,845
这是接受双
并返回一个双。

712
00:39:50,845 --> 00:39:53,720
所以这听起来疯狂的那种，
但让我们向下滚动一点点

713
00:39:53,720 --> 00:39:55,060
看看，看看会发生什么。

714
00:39:55,060 --> 00:39:57,910
我们这个功能powerOf内。

715
00:39:57,910 --> 00:40:00,760
我们正在创造一个新的功能
所谓的求幂，

716
00:40:00,760 --> 00:40:02,900
但不要紧它是什么。

717
00:40:02,900 --> 00:40:06,410
>> 请注意，这有
x的输入值。

718
00:40:06,410 --> 00:40:09,910
而且它正在一个双
并返回一个双。

719
00:40:09,910 --> 00:40:16,320
这是相同的代码，我们
看了上面的，不同的是2的值

720
00:40:16,320 --> 00:40:20,060
的3或值，即
上限在该范围内，

721
00:40:20,060 --> 00:40:23,210
已被替换
此值y，该

722
00:40:23,210 --> 00:40:27,230
为初始参数
我们powerOf功能。

723
00:40:27,230 --> 00:40:31,700
并在这一点上，我们
返回求幂。

724
00:40:31,700 --> 00:40:33,345
我们返回的功能。

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

726
00:40:36,300 --> 00:40:39,550
>> 这有点像一个小令人兴奋。

727
00:40:39,550 --> 00:40:44,360
但让我们想象一下
当我调用这个函数powerOf

728
00:40:44,360 --> 00:40:47,610
并传递到它的一些价值如2。

729
00:40:47,610 --> 00:40:50,020
这意味着的是，
现在，我的价值

730
00:40:50,020 --> 00:40:55,130
2 y的，这意味着，这个值
y在这个求幂函数

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

732
00:40:56,410 --> 00:41:01,290
但是我回到这个
求幂函数。

733
00:41:01,290 --> 00:41:05,900
>> 所以注意什么斯威夫特说我
在这种情况下，已经创建。

734
00:41:05,900 --> 00:41:10,550
让广场上的定义，它是
可以接受双击功能

735
00:41:10,550 --> 00:41:12,610
并返回一个double。

736
00:41:12,610 --> 00:41:16,590
我创建了一个功能
该广场的东西

737
00:41:16,590 --> 00:41:19,782
使用这种机制就在这里。

738
00:41:19,782 --> 00:41:22,490
而真正发生的事情是
它返回该功能

739
00:41:22,490 --> 00:41:26,390
求幂，但这个值
Ÿ被包裹在它的内部。

740
00:41:26,390 --> 00:41:31,080
所以现在每次我用这个
变量或常量这个叫

741
00:41:31,080 --> 00:41:35,180
广场，这是怎么回事
表现为一个函数。

742
00:41:35,180 --> 00:41:39,960
所以我可以调用这个变量
就像我会调用一个函数，

743
00:41:39,960 --> 00:41:43,830
并传递到它的一些，
像在这种情况下，3。

744
00:41:43,830 --> 00:41:45,910
我会再平方此值。

745
00:41:45,910 --> 00:41:53,340
因此，3平方然后将
成为9，因为我们可以在这里看到。

746
00:41:53,340 --> 00:41:56,530
>> 但现在真的疯了，
让我有机会

747
00:41:56,530 --> 00:41:59,040
创建其他powerOf功能。

748
00:41:59,040 --> 00:42:03,680
就像我可以说，好，现在我想
创建一个新的功能，powerOf（3），

749
00:42:03,680 --> 00:42:06,290
并存储到一个
常称为多维数据集。

750
00:42:06,290 --> 00:42:10,220
现在，多维数据集将是一个
独立的功能，将随后

751
00:42:10,220 --> 00:42:14,800
需要一定的值作为输入和多维数据集
价值，我们可以在底线见

752
00:42:14,800 --> 00:42:16,420
这里。

753
00:42:16,420 --> 00:42:18,590
2立方体将会导致8。

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

755
00:42:21,330 --> 00:42:22,680
>> 希望整齐漂亮的东西。

756
00:42:22,680 --> 00:42:25,920
你以前从来没有见过这个。

757
00:42:25,920 --> 00:42:29,990
我鼓励你寻找到关闭
并调查这多一点点。

758
00:42:29,990 --> 00:42:33,570
它真正强大的东西，我们看到了很多
在JavaScript和其他语言。

759
00:42:33,570 --> 00:42:37,160
这是真正重要的
理解的API以及

760
00:42:37,160 --> 00:42:38,620
我们会得到，在短短一秒钟。

761
00:42:38,620 --> 00:42:39,456
是？

762
00:42:39,456 --> 00:42:43,740
>> 听众：当你做
powerOf（2）中，括号，然后

763
00:42:43,740 --> 00:42:48,764
另一个括号，另一个input--
你基本上取代了广场。

764
00:42:48,764 --> 00:42:50,930
DAN AMRMENDARIZ：所以看
在这里的最后一行。

765
00:42:50,930 --> 00:42:55,930
它实际上是完全可能的
做链接如你所说。

766
00:42:55,930 --> 00:43:00,990
所以powerOf（5）意味着我们要去
以具有5的求幂在这里。

767
00:43:00,990 --> 00:43:04,160
因此，这基本上将是
同样的事情，4到第五电源，

768
00:43:04,160 --> 00:43:07,200
因为我们已经创建了一个指数
传播到第五功率，

769
00:43:07,200 --> 00:43:09,920
我们正在传递到
该功能的值4。

770
00:43:09,920 --> 00:43:12,619
而我们得到的价值
我们预计，1024。

771
00:43:12,619 --> 00:43:14,785
听众：它不是一个
名字，所以它可以更容易

772
00:43:14,785 --> 00:43:16,570
阅读，广场等等。

773
00:43:16,570 --> 00:43:17,903
>> DAN AMRMENDARIZ：对，没错。

774
00:43:17,903 --> 00:43:21,120
所以，之前我只是把它
为恒定在这里，所以

775
00:43:21,120 --> 00:43:23,808
它可以轻松使用该名称。

776
00:43:23,808 --> 00:43:24,308
是？

777
00:43:24,308 --> 00:43:26,942
>> 听众：在这方面
powerOf，它的一部分

778
00:43:26,942 --> 00:43:30,774
编程语言的
相对于这样你

779
00:43:30,774 --> 00:43:33,952
想powerOf在[听不清]？

780
00:43:33,952 --> 00:43:35,660
DAN AMRMENDARIZ：所以
在这种情况下，powerOf

781
00:43:35,660 --> 00:43:39,280
是的简单的名称
我这里定义了功能。

782
00:43:39,280 --> 00:43:41,801
因此，它不是与生俱来
语言本身，

783
00:43:41,801 --> 00:43:43,550
但相反，它只是
一个函数具有

784
00:43:43,550 --> 00:43:45,628
这个名字是因为我给它的名字。

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

786
00:43:48,770 --> 00:43:51,920
其他问题吗？

787
00:43:51,920 --> 00:43:52,800
好吧。

788
00:43:52,800 --> 00:43:54,750
>> 现在，这是伟大的。

789
00:43:54,750 --> 00:43:58,170
但你不会看到一个
很多倒闭的功能，

790
00:43:58,170 --> 00:44:03,440
都是这样的，你定义，里面
的一个功能，另一个函数。

791
00:44:03,440 --> 00:44:04,320
你可以做到这一点。

792
00:44:04,320 --> 00:44:06,430
但它是一种不
真的有必要，对不对？

793
00:44:06,430 --> 00:44:09,189
就像为什么我定义这个
函数调用求幂

794
00:44:09,189 --> 00:44:10,480
然后立即返回。

795
00:44:10,480 --> 00:44:15,220
为什么我不能只是马上
回到这个功能吗？

796
00:44:15,220 --> 00:44:18,890
>> 而事实上，这正是
背后一个概念的想法称为

797
00:44:18,890 --> 00:44:22,410
匿名函数，其中，
匿名函数实际上并不

798
00:44:22,410 --> 00:44:25,270
有，因为它们的名称
不需要有一个。

799
00:44:25,270 --> 00:44:28,700
因此在这种情况下，在图7B中，
我们可以发现正是。

800
00:44:28,700 --> 00:44:31,470
这一切都相同的代码，
不完全一样的东西，

801
00:44:31,470 --> 00:44:35,570
但现在我们已经稍微改变它，
这powerOf函数立即

802
00:44:35,570 --> 00:44:37,750
返回一个函数。

803
00:44:37,750 --> 00:44:44,150
请注意，回国后，
有一个开放的大括号。

804
00:44:44,150 --> 00:44:46,410
该公司预计，该输入双。

805
00:44:46,410 --> 00:44:48,560
该公司预计，该输出双。

806
00:44:48,560 --> 00:44:52,175
然后在关键字
分离代码本身。

807
00:44:52,175 --> 00:44:53,550
所以这是一个匿名函数。

808
00:44:53,550 --> 00:44:57,030
它实际上并没有一个名字，而
它被称为求幂之前。

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

810
00:45:00,229 --> 00:45:01,270
外面的功能。

811
00:45:01,270 --> 00:45:02,470
因此，这并不重要。

812
00:45:02,470 --> 00:45:06,300
所以，这个匿名函数
所谓的，因为它是无名的，

813
00:45:06,300 --> 00:45:09,107
但它仍然被使用
本规范的范围内。

814
00:45:09,107 --> 00:45:13,690

815
00:45:13,690 --> 00:45:16,079
>> 在接下来的那些我
要继续希望

816
00:45:16,079 --> 00:45:17,370
吹你的心一点点。

817
00:45:17,370 --> 00:45:20,410
我们可以简化此，甚至更多。

818
00:45:20,410 --> 00:45:24,490
因为因为是敏锐
早前指出，

819
00:45:24,490 --> 00:45:29,100
也许我们其实都知道，由
从这个代码推断，是什么

820
00:45:29,100 --> 00:45:31,750
这段代码的输出将是。

821
00:45:31,750 --> 00:45:38,180
而事实上，在此匿名函数，
我们可以在推断出实际上的数据的类型。

822
00:45:38,180 --> 00:45:41,650
>> 所以在这一块，我们不再
需要明确定义

823
00:45:41,650 --> 00:45:44,850
数据的真实存在的类型
输入和输出从该函数

824
00:45:44,850 --> 00:45:45,890
一对夫妇的原因。

825
00:45:45,890 --> 00:45:51,390
一个是我们定义，最多的
原型的封闭功能，

826
00:45:51,390 --> 00:45:55,770
什么类型的数据这个匿名的
功能应的输入和输出。

827
00:45:55,770 --> 00:45:57,900
而从另一方面，我们
可从代码推断

828
00:45:57,900 --> 00:46:01,930
到这里，我们正在接受
输入，类型为双

829
00:46:01,930 --> 00:46:03,670
并返回一个双。

830
00:46:03,670 --> 00:46:07,890
>> 请注意，在这里我们还没有明确的
定义的参数名称

831
00:46:07,890 --> 00:46:11,220
这个函数接受。

832
00:46:11,220 --> 00:46:16,180
因此，我们看到，我们可以参考一下
使用$ 0，$ 1所参数，

833
00:46:16,180 --> 00:46:20,140
等等，等等，这取决于
使用的参数的数目

834
00:46:20,140 --> 00:46:20,850
在此功能。

835
00:46:20,850 --> 00:46:23,370

836
00:46:23,370 --> 00:46:29,740
>> 这一点，你会
看到很多是这样的开放式大括号

837
00:46:29,740 --> 00:46:32,797
定义后跟
$ 0，然后一些操作，

838
00:46:32,797 --> 00:46:34,130
然后封闭大括号。

839
00:46:34,130 --> 00:46:38,630
这是一个匿名函数
执行此操作。

840
00:46:38,630 --> 00:46:42,940
它有这个参数在哪里
它的类型推断。

841
00:46:42,940 --> 00:46:44,860
这第一个参数为$ 0

842
00:46:44,860 --> 00:46:49,010
而一些操作
发生在那个$ 0

843
00:46:49,010 --> 00:46:52,100
>> 听众：所以，美元符号
是指基本的参数，

844
00:46:52,100 --> 00:46:53,429
，0表示第一个？

845
00:46:53,429 --> 00:46:54,720
DAN Armendariz环：这是正确的。

846
00:46:54,720 --> 00:46:59,100
因此，美元符号的基本意思
参数，和0表示的第一个。

847
00:46:59,100 --> 00:47:02,760
但是，它的工作原理特别是在
这种情况下，我还没有命名

848
00:47:02,760 --> 00:47:07,940
在我的匿名函数的参数。

849
00:47:07,940 --> 00:47:11,119
>> 听众：请问Perl或一些有
这个美元符号，美元0在那里呢？

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

851
00:47:12,702 --> 00:47:15,360
听众：请问Perl的有
这种0美元，美元1--

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

853
00:47:17,318 --> 00:47:21,340
但是PHP什么定义变量
基于美元的迹象。

854
00:47:21,340 --> 00:47:26,120
而且可能有一些语言
具有这样的功能。

855
00:47:26,120 --> 00:47:28,240
事实上，斯威夫特借用一个
很多这样的功能

856
00:47:28,240 --> 00:47:29,489
从很多其他语言。

857
00:47:29,489 --> 00:47:32,380
我们看到它的Python提示。

858
00:47:32,380 --> 00:47:35,800
型的这种定义
似乎来自OCaml的。

859
00:47:35,800 --> 00:47:38,932
而我们刚才一大堆
东西从各种不同的语言。

860
00:47:38,932 --> 00:47:40,640
这就是很好的一个
关于斯威夫特的事情

861
00:47:40,640 --> 00:47:43,390
是，它需要大量的最好
从一堆语言的想法

862
00:47:43,390 --> 00:47:47,229
和它们鞋拔一起
成一个超级语言。

863
00:47:47,229 --> 00:47:49,520
事实上，如果你让我
继续吹你的头脑，

864
00:47:49,520 --> 00:47:51,000
所以我们一直在做这一切。

865
00:47:51,000 --> 00:47:56,690
我们也许可以简化一点
通过实现那当然位，

866
00:47:56,690 --> 00:48:02,120
斯威夫特有一个指数
功能内置的。

867
00:48:02,120 --> 00:48:04,660
如果我输入达尔文，这
只是库

868
00:48:04,660 --> 00:48:09,680
拥有这种功能称为战俘，现
我能简化我的功能功率

869
00:48:09,680 --> 00:48:11,830
要如下。

870
00:48:11,830 --> 00:48:15,860
它是将要返回
该匿名函数。

871
00:48:15,860 --> 00:48:17,950
>> 但是看看多么简单，这是现在。

872
00:48:17,950 --> 00:48:22,780
这是一个匿名函数
正在接受某些类型的数据，

873
00:48:22,780 --> 00:48:26,600
它是要为一个
论点明确，

874
00:48:26,600 --> 00:48:29,320
为$ 0表示是Double类型的引用。

875
00:48:29,320 --> 00:48:32,680
它会返回一个类型双。

876
00:48:32,680 --> 00:48:35,760
但return语句
现在是隐含的。

877
00:48:35,760 --> 00:48:39,990
>> 而正是这种精确的风格，
非常，斯威夫特非常普遍，

878
00:48:39,990 --> 00:48:40,790
到处都是。

879
00:48:40,790 --> 00:48:43,190
我们要看到这
所有的时间在斯威夫特。

880
00:48:43,190 --> 00:48:46,150
所以，我展示这一切要
你是因为这个语法。

881
00:48:46,150 --> 00:48:49,070
这是很常见
看，这意味着它

882
00:48:49,070 --> 00:48:51,420
是一个匿名函数
正在执行

883
00:48:51,420 --> 00:48:54,640
对这些参数的一些操作。

884
00:48:54,640 --> 00:48:56,940
还有一个隐含的回报。

885
00:48:56,940 --> 00:49:01,850
所以它绝对是一回事
我们这样说，就在这里。

886
00:49:01,850 --> 00:49:05,730

887
00:49:05,730 --> 00:49:08,150
>> 由于这种花
支架是一个功能，

888
00:49:08,150 --> 00:49:10,480
我们执行此操作
第一个参数。

889
00:49:10,480 --> 00:49:12,170
我们将返回。

890
00:49:12,170 --> 00:49:14,815
但这种外部回报
在返回的整体功能，

891
00:49:14,815 --> 00:49:19,855
这整个匿名函数
我们刚刚创建的。

892
00:49:19,855 --> 00:49:21,689
其他问题吗？

893
00:49:21,689 --> 00:49:23,980
好吧，我不知道
你们是为此做好准备，

894
00:49:23,980 --> 00:49:27,455
但我们还可以走的疯狂与斯威夫特。

895
00:49:27,455 --> 00:49:28,560
你准备好了吗？

896
00:49:28,560 --> 00:49:29,930
OK，这是伟大的。

897
00:49:29,930 --> 00:49:35,310
>> 现在，我们实际上有能力
要在斯威夫特，因为如何模块化

898
00:49:35,310 --> 00:49:39,650
以及如何基于协议是，以
定义我们自己再用运营商。

899
00:49:39,650 --> 00:49:44,060
像在这种情况下，我们没有
运营商exponentiation--好，

900
00:49:44,060 --> 00:49:47,990
用于执行一些权力。

901
00:49:47,990 --> 00:49:53,632
但我可以在斯威夫特，定义一个新的
运营商，做正是。

902
00:49:53,632 --> 00:49:55,590
因此，在这种情况下，有
一堆语法在这里。

903
00:49:55,590 --> 00:49:59,980
我会允许你看它
在家的时候，你看这个。

904
00:49:59,980 --> 00:50:06,890
但是，我们定义这个缀
操作者，**，将允许我们，

905
00:50:06,890 --> 00:50:09,840
通过定义是什么
功能**实际

906
00:50:09,840 --> 00:50:15,010
确实，以接受一个左手
侧和右手侧，

907
00:50:15,010 --> 00:50:21,190
然后，返回的，该指数
左手侧到右手侧。

908
00:50:21,190 --> 00:50:24,850
>> 所以，现在突然我的
已经创建了一个新的分子。

909
00:50:24,850 --> 00:50:29,490
所以2 ** 3装置2的3次幂。

910
00:50:29,490 --> 00:50:34,420
[令人兴奋的声音]本所
本身应该让你像，

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

912
00:50:37,960 --> 00:50:38,740
这很棒。

913
00:50:38,740 --> 00:50:40,140
这是非常奇妙的。

914
00:50:40,140 --> 00:50:42,240
>> 虽然这是一个很好的例子。

915
00:50:42,240 --> 00:50:45,570
但我从来没有一次外
本实施例的实际

916
00:50:45,570 --> 00:50:46,800
定义自己的操作符。

917
00:50:46,800 --> 00:50:49,710
但尽管如此，它显示了
很多雨燕的动力

918
00:50:49,710 --> 00:50:54,050
为什么这实际上是
真的非常酷。

919
00:50:54,050 --> 00:50:55,832
好了，是吗？

920
00:50:55,832 --> 00:50:57,790
听众：如果你是
定义你自己的运营商，

921
00:50:57,790 --> 00:51:02,940
你怎么知道你不小心
尝试创建一个操作符是

922
00:51:02,940 --> 00:51:06,040
在某处C，像
在斯威夫特的地方隐藏起来，

923
00:51:06,040 --> 00:51:12,210
就像一个不起眼的一个，你
可能以前没看过。

924
00:51:12,210 --> 00:51:15,050
>> DAN Armendariz环：所以，如果你想
定义你自己的操作，

925
00:51:15,050 --> 00:51:20,970
有限定的危险
一个比现有的运营商。

926
00:51:20,970 --> 00:51:24,870
这将详细的水平
我不认为我们有时间去了。

927
00:51:24,870 --> 00:51:27,620
但是，这是一个危险。

928
00:51:27,620 --> 00:51:31,320
而这实际上是非常的原因
我没有使用插入符号符号，这

929
00:51:31,320 --> 00:51:36,210
当我们输入了动力，我们通常
用4个小尖号5或东西

930
00:51:36,210 --> 00:51:40,560
这样，就在我们
Gchatting哥们或什么的。

931
00:51:40,560 --> 00:51:43,660
但在这种情况下，实际
会造成冲突。

932
00:51:43,660 --> 00:51:46,450
所以我避免它只是因为
我碰巧知道在这种情况下，

933
00:51:46,450 --> 00:51:50,430
，这将导致该冲突。

934
00:51:50,430 --> 00:51:52,270
>> 好吧。

935
00:51:52,270 --> 00:51:55,080
现在不幸的是，
最后7分钟

936
00:51:55,080 --> 00:51:57,410
我必须继续吹
你的心一点点。

937
00:51:57,410 --> 00:52:00,230
所以，请允许我向您展示
一些其他的事情也是如此。

938
00:52:00,230 --> 00:52:03,710
>> 我们已经展示了这个想法
具有这些匿名函数，

939
00:52:03,710 --> 00:52:07,040
这些盖子，让您
那种传递函数左右。

940
00:52:07,040 --> 00:52:08,100
你可以归还。

941
00:52:08,100 --> 00:52:09,490
你可以操纵它们。

942
00:52:09,490 --> 00:52:11,790
你可以做各种疯狂的事情。

943
00:52:11,790 --> 00:52:14,850
>> 但有其他的事情，
恰好是有用

944
00:52:14,850 --> 00:52:19,740
被的能力，而不是
久违这些功能

945
00:52:19,740 --> 00:52:25,146
在一个函数，传递函数
作为参数传递给另一个功能。

946
00:52:25,146 --> 00:52:30,430
你可能会在地球上的思维以及为什么
我希望做这样的事情？

947
00:52:30,430 --> 00:52:33,660
>> 好吧，让我们说，我想
借此运营商，我

948
00:52:33,660 --> 00:52:40,260
辛辛苦苦创建和应用
它以一串不同数量的

949
00:52:40,260 --> 00:52:41,770
在数组中。

950
00:52:41,770 --> 00:52:46,700
因此，在这种情况下，我有一个数组
integers-- 1,4，7,2，5，10，56。

951
00:52:46,700 --> 00:52:48,080
而且我要加倍他们。

952
00:52:48,080 --> 00:52:50,430
的方式，我们将一般
做到这一点是只写

953
00:52:50,430 --> 00:52:53,440
for循环的简单的
遍历所有的人

954
00:52:53,440 --> 00:52:57,140
并执行某种
方操作过他们，

955
00:52:57,140 --> 00:53:02,700
输入这些新值到一个新的
可变的，或者说，在这里一个新的数组。

956
00:53:02,700 --> 00:53:07,370
和的输出的值
结果是那么所有这些阵列，

957
00:53:07,370 --> 00:53:10,200
或者更确切地说，所有这些
元素现在平方。

958
00:53:10,200 --> 00:53:12,680
>> 我们可以做同样的
对多维数据这东西，

959
00:53:12,680 --> 00:53:15,360
但有点警钟
应该将关闭

960
00:53:15,360 --> 00:53:17,360
说，也许有
某种程度上，我们将

961
00:53:17,360 --> 00:53:19,860
可以这样简化一点。

962
00:53:19,860 --> 00:53:21,130
而事实上是有的。

963
00:53:21,130 --> 00:53:25,320
如果我们能够创建什么
一个可以让我们

964
00:53:25,320 --> 00:53:28,350
接受，作为一种食肉动物，一个功能？

965
00:53:28,350 --> 00:53:30,350
所以在这种情况下，采取一
看看这些参数。

966
00:53:30,350 --> 00:53:33,220
我们将接受双打的名单。

967
00:53:33,220 --> 00:53:35,030
然后我们要去
接受功能

968
00:53:35,030 --> 00:53:40,990
在一个所谓的F这个变量是怎么回事
采取双，并返回一个双。

969
00:53:40,990 --> 00:53:43,320
而整个输出
这整个功能

970
00:53:43,320 --> 00:53:47,310
称为映射器将会
回到所谓的双阵列。

971
00:53:47,310 --> 00:53:52,380
>> 这是什么会，然后让我
做的是遍历该列表

972
00:53:52,380 --> 00:53:56,350
做同样的事情，但现在
应用该功能在每个

973
00:53:56,350 --> 00:53:58,970
在该列表中的各个值。

974
00:53:58,970 --> 00:54:00,750
所以，我真的不知道什么f是。

975
00:54:00,750 --> 00:54:02,010
不要紧，对我来说。

976
00:54:02,010 --> 00:54:06,530
但是，只要它需要在一个双，
它执行一些操作，

977
00:54:06,530 --> 00:54:08,640
然后返回一个
双，我将被

978
00:54:08,640 --> 00:54:13,415
能够映射功能跨越
列表中的每一个元素。

979
00:54:13,415 --> 00:54:16,270

980
00:54:16,270 --> 00:54:20,930
>> 而这种类型的节目是
所谓高阶函数，

981
00:54:20,930 --> 00:54:24,440
在这里我们传递功能
周围的参数

982
00:54:24,440 --> 00:54:26,430
和做事情的功能。

983
00:54:26,430 --> 00:54:29,640
这有点像把所有的这些
我们在CS50所学的想法

984
00:54:29,640 --> 00:54:31,390
并考虑他们排序
的下一级。

985
00:54:31,390 --> 00:54:34,140
而这一切都是CS51风格的东西。

986
00:54:34,140 --> 00:54:37,080
因此，我们会去深入
更多的类这样的。

987
00:54:37,080 --> 00:54:38,930
>> 但是这也是
这里很重要，因为我们

988
00:54:38,930 --> 00:54:42,010
看到很多功能
这是在斯威夫特使用

989
00:54:42,010 --> 00:54:45,590
基本上不
这一点，我们有

990
00:54:45,590 --> 00:54:48,300
一些数字，数字的一些阵列。

991
00:54:48,300 --> 00:54:50,850
我们将传递
数组转换成我们的映射器。

992
00:54:50,850 --> 00:54:55,770
而我们也将
通过一些函数，它

993
00:54:55,770 --> 00:54:57,950
我们已经确定在这里。

994
00:54:57,950 --> 00:54:59,690
这将是正方形。

995
00:54:59,690 --> 00:55:02,220
而我们要那么
方所有这些数字

996
00:55:02,220 --> 00:55:04,710
并存储到这个结果在这里。

997
00:55:04,710 --> 00:55:07,280

998
00:55:07,280 --> 00:55:11,000
>> 所以，这种情况下，我们已经定义了我们
自己的函数调用映射。

999
00:55:11,000 --> 00:55:15,370
但这个确切的事情是，
事实上，内置斯威夫特。

1000
00:55:15,370 --> 00:55:18,960
有各种各样的
函数调用的地图。

1001
00:55:18,960 --> 00:55:21,520
有一个地图功能，
有一个减少功能，

1002
00:55:21,520 --> 00:55:25,630
并有一个过滤功能，
这基本上是应用功能

1003
00:55:25,630 --> 00:55:30,782
在一个每一个元件
列表来修改它们以某种方式。

1004
00:55:30,782 --> 00:55:34,510
>> 听众：所以因为你正在改变
将数据转换成另一种格式

1005
00:55:34,510 --> 00:55:36,134
通过function--

1006
00:55:36,134 --> 00:55:37,050
DAN Armendariz环：对。

1007
00:55:37,050 --> 00:55:39,420
是啊，这样的功能
我们正在接受

1008
00:55:39,420 --> 00:55:41,790
正在改变以某种方式的数据。

1009
00:55:41,790 --> 00:55:44,700
在这种情况下，我们要么
现蕾，或者我们多维数据吧，

1010
00:55:44,700 --> 00:55:50,060
还是真的，我们可以执行
它没有任何操作的。

1011
00:55:50,060 --> 00:55:54,150
>> 但让我告诉你再如何
是要看看在实践中。

1012
00:55:54,150 --> 00:55:56,681
再次，我快
时间位。所以我不

1013
00:55:56,681 --> 00:55:59,430
要能够走在所有
这里详细的源代码。

1014
00:55:59,430 --> 00:56:00,721
但我鼓励你这样做。

1015
00:56:00,721 --> 00:56:03,850
我们会尽快将它张贴
可能在这之后的谈话。

1016
00:56:03,850 --> 00:56:07,610
>> 但是，如果你看看这个，
假设我们有号码列表，

1017
00:56:07,610 --> 00:56:10,260
号在此的数组
变量被叫号码。

1018
00:56:10,260 --> 00:56:16,670
然后，我们要执行这个
这些数字过滤操作。

1019
00:56:16,670 --> 00:56:19,730
因此，过滤器是一个较高
为了功能

1020
00:56:19,730 --> 00:56:24,660
接受一个数组，并且也是功能。

1021
00:56:24,660 --> 00:56:28,760
而在每一个元素
阵列，它执行该功能。

1022
00:56:28,760 --> 00:56:31,990
>> 如果该函数返回
真的，它使该项目。

1023
00:56:31,990 --> 00:56:36,100
如果该函数返回false，
它丢弃该项目。

1024
00:56:36,100 --> 00:56:40,480
然后它返回一个列表
随后被由所有

1025
00:56:40,480 --> 00:56:44,360
的那些已被过滤的项目。

1026
00:56:44,360 --> 00:56:47,150
>> 因此在另一个话，这是
同样的想法，在成绩册。

1027
00:56:47,150 --> 00:56:50,800
我们可能有各种档次
这个值被叫号码。

1028
00:56:50,800 --> 00:56:55,590
可以是100和70，和
40，等等，等等。

1029
00:56:55,590 --> 00:56:59,110
这是什么做过滤的通知
这是语法糖

1030
00:56:59,110 --> 00:57:01,310
一个匿名函数。

1031
00:57:01,310 --> 00:57:05,980
这是一个匿名函数说
这是我接受的参数

1032
00:57:05,980 --> 00:57:09,690
将是，如果它
大于70，

1033
00:57:09,690 --> 00:57:15,837
那么这将返回true，这意味着
该项目将被保存在这个过滤器。

1034
00:57:15,837 --> 00:57:17,920
因此，让我们一点点
这个更具体。

1035
00:57:17,920 --> 00:57:25,760
如果我有一个数字数组
它包括100，70和40，

1036
00:57:25,760 --> 00:57:29,730
我执行这个过滤器
操作这些中的每一个。

1037
00:57:29,730 --> 00:57:33,270
使第一个是100这个值。

1038
00:57:33,270 --> 00:57:36,770
100大于或等于
70是真的，这

1039
00:57:36,770 --> 00:57:41,950
意味着100被保持在
该数组的新副本。

1040
00:57:41,950 --> 00:57:44,290
70也通过。

1041
00:57:44,290 --> 00:57:46,020
但40没有。

1042
00:57:46,020 --> 00:57:54,290
那么在passingCount返回
是元件100和阵列70--

1043
00:57:54,290 --> 00:57:57,410
100，逗号，70。

1044
00:57:57,410 --> 00:57:59,870
这些是仅有的两个
被保留的项目。

1045
00:57:59,870 --> 00:58:03,740
这样一来，我之所以很快就通过
很多这类高阶的

1046
00:58:03,740 --> 00:58:08,680
事情是因为这是普通
您将在斯威夫特看到漂亮的东西

1047
00:58:08,680 --> 00:58:16,810
频繁，正在进行操作
使用该匿名函数的语法。

1048
00:58:16,810 --> 00:58:18,450
>> 这里也有一些很酷的东西。

1049
00:58:18,450 --> 00:58:24,730
交换机是在斯威夫特果然厉害，
我的意思是，就像疯了，疯强大。

1050
00:58:24,730 --> 00:58:28,250
你可以使用交换机，
实际上你可以应用它们

1051
00:58:28,250 --> 00:58:33,160
到的范围，这是那种疯狂，
做花哨的东西一样。

1052
00:58:33,160 --> 00:58:37,540
>> 但在最后几分钟，
我想跳过前面很远

1053
00:58:37,540 --> 00:58:46,940
并告诉你如何具体例子
我们可以在iOS应用使用SWIFT创建。

1054
00:58:46,940 --> 00:58:49,040
所以，当你在做
这一点，你必须采取

1055
00:58:49,040 --> 00:58:51,990
一看at--苹果的
文档，它们

1056
00:58:51,990 --> 00:58:56,084
有很多真正好的教程
创建第一个应用程序。

1057
00:58:56,084 --> 00:58:58,250
我鼓励你做
是因为他们带你

1058
00:58:58,250 --> 00:59:04,110
通过精确地所有步骤的什么
点击创建iOS应用程序。

1059
00:59:04,110 --> 00:59:07,290
>> 但在这里，我们有这个iOS应用程序。

1060
00:59:07,290 --> 00:59:10,960
而这是一个非常简单的应用程序真的。

1061
00:59:10,960 --> 00:59:13,840
如果我运行这个，让我告诉
你是什​​么样子。

1062
00:59:13,840 --> 00:59:19,480
所有这本质上确实是它
从互联网的JSON文件拉

1063
00:59:19,480 --> 00:59:22,300
我已经存储在服务器上。

1064
00:59:22,300 --> 00:59:26,310
这JSON文件
定义图像，使

1065
00:59:26,310 --> 00:59:31,680
我再通过，周期在我
应用程序，从我的web服务器映像。

1066
00:59:31,680 --> 00:59:32,880
>> 所以，我这里有getNextImage。

1067
00:59:32,880 --> 00:59:37,100
它加载图像从互联网上，
然后在屏幕上显示出来。

1068
00:59:37,100 --> 00:59:38,200
>> 所以这是非常简单的。

1069
00:59:38,200 --> 00:59:41,550
但这里的目的是展示
你如何才能结合起来的东西

1070
00:59:41,550 --> 00:59:47,820
从后者几周CS50的
成实际的iPhone应用程序。

1071
00:59:47,820 --> 00:59:53,140
换句话说，或许中的一个
的事情，你会想要做

1072
00:59:53,140 --> 00:59:56,340
是有一个iOS的应用程序
可以从互联网提取数据

1073
00:59:56,340 --> 00:59:59,070
和显示用户的某些信息。

1074
00:59:59,070 --> 01:00:03,130
这完全是点
这里这个源代码。

1075
01:00:03,130 --> 01:00:07,890
>> 因此，有很多可说的对
如何做实际的iOS开发。

1076
01:00:07,890 --> 01:00:12,860
有很多疯狂的语法
我们还没有看到相当，但

1077
01:00:12,860 --> 01:00:15,580
像类，一类实际上是什么。

1078
01:00:15,580 --> 01:00:19,470
我们可以在很大程度上忽略
该暂时。

1079
01:00:19,470 --> 01:00:23,250
>> 但是请注意，我们已经包含
在这各种各样的事情

1080
01:00:23,250 --> 01:00:27,720
我们已经看到像
具有特定名称的函数。

1081
01:00:27,720 --> 01:00:32,650
而当我们给那些
功能正确的名称

1082
01:00:32,650 --> 01:00:36,530
这是由iOS的预期，事实上
这种感觉有点不可思议。

1083
01:00:36,530 --> 01:00:40,300
当你创建一个，但
iOS的应用程序，有

1084
01:00:40,300 --> 01:00:47,590
具体函数名
由手机本身被称为

1085
01:00:47,590 --> 01:00:52,440
作为应用程序加载尝试
实际创造的过程

1086
01:00:52,440 --> 01:00:54,787
运行你的应用程序。

1087
01:00:54,787 --> 01:00:58,120
如此反复，有很多的事情，我
有掩饰这里，以便我们

1088
01:00:58,120 --> 01:01:00,570
谈论这个特别。

1089
01:01:00,570 --> 01:01:06,050
但我建议你看一下也许
在其他iOS研讨会上，但也有一些

1090
01:01:06,050 --> 01:01:09,290
该在线教程里面做的
描述一个更好的工作

1091
01:01:09,290 --> 01:01:11,030
的特定信息。

1092
01:01:11,030 --> 01:01:15,760
>> 但是，我们可以看到一对夫妇的事情，
从这里代码有意思。

1093
01:01:15,760 --> 01:01:17,950
请注意，我们有if语句。

1094
01:01:17,950 --> 01:01:20,400
顺便说，一个重要
有关if语句的事

1095
01:01:20,400 --> 01:01:24,860
是周围的括号
布尔表达式是可选的。

1096
01:01:24,860 --> 01:01:30,800
不过，花括号是不可选的，
无论多么少或者多行代码

1097
01:01:30,800 --> 01:01:32,360
你有一个if语句。

1098
01:01:32,360 --> 01:01:38,670
你不能有一个if语句
无斯威夫特花括号。

1099
01:01:38,670 --> 01:01:41,000
>> 这是很好，有点傻。

1100
01:01:41,000 --> 01:01:43,910
但有历史原因的。

1101
01:01:43,910 --> 01:01:46,180
它应该拯救你自己。

1102
01:01:46,180 --> 01:01:49,899
像这样的例子，你不能
消除围绕着大括号

1103
01:01:49,899 --> 01:01:50,440
if语句。

1104
01:01:50,440 --> 01:01:52,730
这些其实都是必需的。

1105
01:01:52,730 --> 01:01:54,480
所以，我鼓励你
看看这个。

1106
01:01:54,480 --> 01:01:56,230
但是有一个更
构造，我想

1107
01:01:56,230 --> 01:02:02,640
向您提供迅捷的
是新雨燕2.0​​对比

1108
01:02:02,640 --> 01:02:08,460
旧版本的雨燕，
这是下面的内容。

1109
01:02:08,460 --> 01:02:11,620
让我们看看在哪里我把它放在这儿？

1110
01:02:11,620 --> 01:02:16,630
>> 因此，在这个函数中调用
fetchJSON，该功能

1111
01:02:16,630 --> 01:02:23,450
负责拉的JSON
从URL，这恰好文件

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

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

1114
01:02:28,580 --> 01:02:32,110
而我能够再扳指
使用来自互联网的数据

1115
01:02:32,110 --> 01:02:36,430
这个功能和这个URL，
这是由电话提供的。

1116
01:02:36,430 --> 01:02:40,490
它由一个提供
库您使用时

1117
01:02:40,490 --> 01:02:43,140
你正在做一些iOS应用程序的开发。

1118
01:02:43,140 --> 01:02:49,690
>> 请注意这里是有这个不寻常
语法结构被称为后卫。

1119
01:02:49,690 --> 01:02:53,530
而真正的这一切都是在
雨燕是验证的一种方式

1120
01:02:53,530 --> 01:02:56,870
有些事情有
在你得到满足

1121
01:02:56,870 --> 01:03:00,000
继续执行功能的其余部分。

1122
01:03:00,000 --> 01:03:04,260
所以我可以有，使用
这个可选的类型，

1123
01:03:04,260 --> 01:03:10,530
我能找到的网址
运行此NSURL功能

1124
01:03:10,530 --> 01:03:16,640
并存储该到一个URL
恒定，然后检查

1125
01:03:16,640 --> 01:03:20,820
看是否URL为零，因为它
正想返回一个可选的类型。

1126
01:03:20,820 --> 01:03:25,660
如果它是零，那么我会
打印出一个错误，然后返回。

1127
01:03:25,660 --> 01:03:29,970
>> 但是，相反，什么后卫让
我们做的是非常的事，

1128
01:03:29,970 --> 01:03:34,550
但确保其
实际的情况是URL

1129
01:03:34,550 --> 01:03:38,020
已正确由NSURL设置。

1130
01:03:38,020 --> 01:03:41,810
并且如果是的话，它
跳过这一点，它

1131
01:03:41,810 --> 01:03:46,110
可以让你继续
网址已被正确定义。

1132
01:03:46,110 --> 01:03:48,830
但如果是的情况下
URL不是正确定义，

1133
01:03:48,830 --> 01:03:52,550
如果这个函数返回一个错误
或其他一些意想不到的事

1134
01:03:52,550 --> 01:03:58,030
实际发生，该保护结构
让我们再输出错误

1135
01:03:58,030 --> 01:04:00,390
并立即返回。

1136
01:04:00,390 --> 01:04:00,890
是？

1137
01:04:00,890 --> 01:04:04,839
>> 听众：所以这是一种
像一个，如果再别的吗？

1138
01:04:04,839 --> 01:04:07,130
DAN Armendariz环：这是一种
就像如果当时别人，是的，

1139
01:04:07,130 --> 01:04:14,200
但此URL随后
定义低于这个一切。

1140
01:04:14,200 --> 01:04:20,420
如果通过这种控卫的话，
实际上将填充数据

1141
01:04:20,420 --> 01:04:29,500
并在剩余的可使用
在你的函数的源代码。

1142
01:04:29,500 --> 01:04:33,790
因此，我怀疑你会
开始看到这个后卫也是如此。

1143
01:04:33,790 --> 01:04:36,670
同时也要注意这一点。

1144
01:04:36,670 --> 01:04:46,270
>> 所以只要看几个其他的
的事情，在这里这个权利是什么，

1145
01:04:46,270 --> 01:04:53,377
你觉得，只是基于什么
我们之前在谈论什么？

1146
01:04:53,377 --> 01:04:56,650
>> 听众：认为它会在列表中运行？

1147
01:04:56,650 --> 01:04:59,100
>> DAN Armendariz环：所以很接近。

1148
01:04:59,100 --> 01:05:02,360
这是一个我们所定义的功能。

1149
01:05:02,360 --> 01:05:07,240
我们正在输入的功能
作为参数传递给这个函数在这里。

1150
01:05:07,240 --> 01:05:09,120
>> 听众：[听不清]如果不是零。

1151
01:05:09,120 --> 01:05:11,470
因此，它在列表中，对不对？

1152
01:05:11,470 --> 01:05:15,450
>> DAN Armendariz环：如果错误不是零，
让is--，所以我必须滚动。

1153
01:05:15,450 --> 01:05:18,060
好吧，让我们来看看，我真的不能
滚动到这里的权利。

1154
01:05:18,060 --> 01:05:23,161
误差是正被一个参数
传递给这个匿名函数。

1155
01:05:23,161 --> 01:05:24,410
这是一个匿名函数。

1156
01:05:24,410 --> 01:05:25,480
它没有名字。

1157
01:05:25,480 --> 01:05:29,850
但是，我们接受这三个
参数，数据，响应和错误。

1158
01:05:29,850 --> 01:05:33,590
它是要返回void，所以
它不会返回任何东西。

1159
01:05:33,590 --> 01:05:37,910
这是内容
的该功能。

1160
01:05:37,910 --> 01:05:41,961
然后我们有内部的访问
功能到每个这些参数。

1161
01:05:41,961 --> 01:05:45,650

1162
01:05:45,650 --> 01:05:48,679
>> 所以这是一个旋风
巡演的语言。

1163
01:05:48,679 --> 01:05:50,470
但我希望这一点，
你把希望

1164
01:05:50,470 --> 01:05:54,490
看看一些教程
具体到iOS开发与斯威夫特，

1165
01:05:54,490 --> 01:05:57,481
特别是如果你去
苹果的开发者网站page--

1166
01:05:57,481 --> 01:05:59,980
他们有很多真正的好
让你开始教程。

1167
01:05:59,980 --> 01:06:05,010
但希望只是这一小时的谈话
关于语法本身已经给

1168
01:06:05,010 --> 01:06:08,760
你有足够的开始使用了。

1169
01:06:08,760 --> 01:06:12,950
>> 我们将发布所有这些源
研讨会上网站代码

1170
01:06:12,950 --> 01:06:17,800
尽快，并且还幻灯片
所以你必须对所有这些参考。

1171
01:06:17,800 --> 01:06:20,530
不过，好运与您的项目。

1172
01:06:20,530 --> 01:06:23,640
并感谢大家的光临。

1173
01:06:23,640 --> 01:06:26,990
>> [掌声]

1174
01:06:26,990 --> 01:06:28,026