1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [8]周

2
00:00:02,000 --> 00:00:04,000
[DAVID J马兰] [哈佛大学]

3
00:00:04,000 --> 00:00:07,000
这是CS50。[CS50.TV]

4
00:00:07,000 --> 00:00:09,000
>> 欢迎回来。

5
00:00:09,000 --> 00:00:11,000
这是CS50，这是开始的第8周。

6
00:00:11,000 --> 00:00:14,000
本周一对夫妇的机会，

7
00:00:14,000 --> 00:00:17,000
他们在这里说，在一些食品供应。

8
00:00:17,000 --> 00:00:20,000
欲了解更多详细信息，检查出在线的幻灯片。

9
00:00:20,000 --> 00:00:24,000
也由自己的托马斯Carriero的另一个事件本周。

10
00:00:24,000 --> 00:00:27,000
他是一个CS50的前负责教学研究员谁现在是在Dropbox的，

11
00:00:27,000 --> 00:00:29,000
他的家伙迷上了，你也知道什么，

12
00:00:29,000 --> 00:00:36,000
因此，如果您想了解更多的到他们的谈话，头今天下午Dropbox和更多。

13
00:00:36,000 --> 00:00:38,000
CS50午餐是这个星期五。

14
00:00:38,000 --> 00:00:41,000
你加入我们，如果你有能力，1:15，像往常一样，在火与冰。

15
00:00:41,000 --> 00:00:45,000
>> 现在，我们深入到一些所谓的研讨会。

16
00:00:45,000 --> 00:00:49,000
我们的CS50研讨会，召回，这些选修课程的教学研究员领导

17
00:00:49,000 --> 00:00:51,000
和课程助理和朋友的过程中，

18
00:00:51,000 --> 00:00:55,000
从一组在校园里的人，这是一组被称为ABCD

19
00:00:55,000 --> 00:00:58,000
技术爱好者，在校园里，以及一组名为HCS，

20
00:00:58,000 --> 00:01:02,000
哈佛大学计算机协会，本科生同样感兴趣计算的。

21
00:01:02,000 --> 00:01:08,000
今年的研讨会名册，包括研讨会上Android和iOS和JavaScript

22
00:01:08,000 --> 00:01:13,000
和PHP，UNIX，Vim的多，所以认识到，这些研讨会都上来了。

23
00:01:13,000 --> 00:01:16,000
如果你想RSVP，他们前往该网址那里。

24
00:01:16,000 --> 00:01:20,000
然后，我们将发布在本课程的网站，一旦他们确定的时间和地点。

25
00:01:20,000 --> 00:01:26,000
但是要知道前研讨会的有5年的价值可在网上，

26
00:01:26,000 --> 00:01:29,000
其中有许多是非常大的电流的技术，你可能

27
00:01:29,000 --> 00:01:36,000
要玩你的最后的项目，所以头上有一些影片。

28
00:01:36,000 --> 00:01:39,000
>> CSS，你已经熟悉CSS，

29
00:01:39,000 --> 00:01:42,000
什么是它概括？

30
00:01:42,000 --> 00:01:45,000
什么是CSS？

31
00:01:45,000 --> 00:01:48,000
它的级联样式表，这是什么意思呢？

32
00:01:48,000 --> 00:01:53,000
这是什么做对我们来说，CSS？

33
00:01:53,000 --> 00:01:57,000
好吧，让的热身一个简单的，HTML超文本标记语言。

34
00:01:57,000 --> 00:02:01,000
为我们做什么？

35
00:02:01,000 --> 00:02:04,000
任何人在吗？

36
00:02:04,000 --> 00:02:07,000
它变得非常尴尬的问这些问题。

37
00:02:07,000 --> 00:02:11,000
HTML超文本标记语言。

38
00:02:11,000 --> 00:02:14,000
是吗？不是吗？

39
00:02:14,000 --> 00:02:17,000
[听不见的学生反应]

40
00:02:17,000 --> 00:02:20,000
好了，好了，让我们来标记文本显示在Web浏览器。

41
00:02:20,000 --> 00:02:22,000
这是不是一种编程语言。

42
00:02:22,000 --> 00:02:25,000
的确，这是一种标记语言，这意味着它指示浏览器如何显示

43
00:02:25,000 --> 00:02:28,000
信息，所以最简单的化身，因为我们已经看到了

44
00:02:28,000 --> 00:02:32,000
是一些超级简单的像加粗，开放式支架B右括号说

45
00:02:32,000 --> 00:02:36,000
使这个文本加粗，而这实际上只是许多方法之一

46
00:02:36,000 --> 00:02:39,000
中，我们可以做到这一点，确实，这些天来一个更好的办法

47
00:02:39,000 --> 00:02:42,000
风格化您的网页，使事情粗体和斜体

48
00:02:42,000 --> 00:02:47,000
中心和合理的，不这样做仅仅通过HTML标签

49
00:02:47,000 --> 00:02:51,000
而是用了一种叫做CSS，层叠样式表。

50
00:02:51,000 --> 00:02:53,000
这是对自己的语言。

51
00:02:53,000 --> 00:02:55,000
它也不是一个编程语言，但

52
00:02:55,000 --> 00:02:58,000
大家好，这是丹，参加我们今天的。

53
00:02:58,000 --> 00:03:01,000
一些技术上的困难。不是一个问题。

54
00:03:01,000 --> 00:03:04,000
>> 让我们的样式CSS的页面

55
00:03:04,000 --> 00:03:07,000
通过设置被称为属性，所以让我们来看看这个

56
00:03:07,000 --> 00:03:09,000
由一些基本的实施例的方式。

57
00:03:09,000 --> 00:03:12,000
让我进入今天的家电。

58
00:03:12,000 --> 00:03:15,000
我在这里源周一目录的，

59
00:03:15,000 --> 00:03:18,000
我会去到一个目录中称为CSS，我们有一大堆

60
00:03:18,000 --> 00:03:21,000
在这里等待着我们的文件，

61
00:03:21,000 --> 00:03:27,000
在该文件夹中，我们有，例如，search0.html从最后一次。

62
00:03:27,000 --> 00:03:31,000
现在，回想与搜索0，我们留在本附注

63
00:03:31,000 --> 00:03:35,000
通过排序的实施谷歌还是真的只是它的前端，前一个星期左右，

64
00:03:35,000 --> 00:03:38,000
注意到，我们有一些新的标签。

65
00:03:38,000 --> 00:03:41,000
我们有一个大的，大胆的标题H1，

66
00:03:41,000 --> 00:03:45,000
形式，这使得我们有一个HTML表单的用户输入。

67
00:03:45,000 --> 00:03:48,000
行动的action属性，究竟是什么含义

68
00:03:48,000 --> 00:03:52,000
在HTML表单标签？

69
00:03:52,000 --> 00:03:58,000
这一点，行动的意义是什么？

70
00:03:58,000 --> 00:04:00,000
我就这样做。

71
00:04:00,000 --> 00:04:03,000
行动的目标是到哪里的形式将被提交。

72
00:04:03,000 --> 00:04:07,000
事实上，说“google.com /搜索”

73
00:04:07,000 --> 00:04:10,000
意味着，当用户单击提交按钮或等效

74
00:04:10,000 --> 00:04:14,000
任何形式的字段填写的将被发送到我们​​的服务器

75
00:04:14,000 --> 00:04:17,000
我们的设备，但在谷歌，而该特定URL。

76
00:04:17,000 --> 00:04:19,000
要使用它的方法被称为，

77
00:04:19,000 --> 00:04:25,000
而得到的，就目前而言，仅仅是一个技术传递到Web服务器的信息，以及

78
00:04:25,000 --> 00:04:29,000
通过URL的方式，让我们快速浏览一下这是如何工作的。

79
00:04:29,000 --> 00:04:31,000
>> 请注意，有一个输入其名称为q

80
00:04:31,000 --> 00:04:35,000
其类型是文本，然后类型提交的第二输入端

81
00:04:35,000 --> 00:04:39,000
它的值是CS50的搜索，而事实上，如果我们打开这个文件，在这里，

82
00:04:39,000 --> 00:04:42,000
sea​​rch0.html，这是一个超级简单的形式，

83
00:04:42,000 --> 00:04:45,000
如果我搜索的东西，如计算机科学

84
00:04:45,000 --> 00:04:50,000
然后按下回车键或点击CS50搜索

85
00:04:50,000 --> 00:04:53,000
注意，会发生什么情况超出去谷歌

86
00:04:53,000 --> 00:04:56,000
我特意结束了在这个URL在顶部，

87
00:04:56,000 --> 00:05:01,000
google.com /搜索Q =电脑+科学，

88
00:05:01,000 --> 00:05:04,000
计算机科学显然是我所输入的字词。

89
00:05:04,000 --> 00:05:06,000
+只是意味着一个空格字符，

90
00:05:06,000 --> 00:05:10,000
它的浏览器，以确保公正，有没有

91
00:05:10,000 --> 00:05:13,000
在实际的URL的混乱和空白。

92
00:05:13,000 --> 00:05:15,000
那么q，当然是参数名称。

93
00:05:15,000 --> 00:05:20,000
我们还没有看到我们如何，程​​序员，实际上可以进入Q还。

94
00:05:20,000 --> 00:05:23,000
我们可以假设，谷歌知道该怎么做在这里，

95
00:05:23,000 --> 00:05:25,000
但我们会在适当的时候。

96
00:05:25,000 --> 00:05:30,000
>> 但是，让我看看，而不是在search1.html，

97
00:05:30,000 --> 00:05:34,000
看起来有点不同，因为我决定，这种形式在这里只是有点跛。

98
00:05:34,000 --> 00:05:36,000
我的意思是，这是在左上角。

99
00:05:36,000 --> 00:05:40,000
真的没有美学，所以我想的样式

100
00:05:40,000 --> 00:05:43,000
有点像谷歌的网页，召回，

101
00:05:43,000 --> 00:05:47,000
即使你可能经常不能访问，今天看起来是这样的万圣节。

102
00:05:47,000 --> 00:05:53,000
而如果我们打开这个文件的第1版，搜索1.HTML，我中心。

103
00:05:53,000 --> 00:05:57,000
不过很丑陋，但至少现在我已经开始控制此页的美学，

104
00:05:57,000 --> 00:06:00,000
不只是标记物。

105
00:06:00,000 --> 00:06:04,000
让我们来看看在搜索，而且也真的只有一个区别就在这里，

106
00:06:04,000 --> 00:06:06,000
这可能跳出你，也许不是，

107
00:06:06,000 --> 00:06:11,000
但什么是一条线或片段的差异呢？

108
00:06:11,000 --> 00:06:14,000
>> 这种风格的属性，所以，在HTML

109
00:06:14,000 --> 00:06:19,000
大部分元素，大部分标签上的样式属性，

110
00:06:19,000 --> 00:06:23,000
在该样式属性是带引号的字符串，

111
00:06:23,000 --> 00:06:26,000
而且引号的字符串是CSS。

112
00:06:26,000 --> 00:06:29,000
在那里，你可以把级联样式表

113
00:06:29,000 --> 00:06:32,000
通过指定它作为属性名

114
00:06:32,000 --> 00:06:34,000
其次由一个冒号后面的值。

115
00:06:34,000 --> 00:06:37,000
几年前，这是一个不幸的设计决策

116
00:06:37,000 --> 00:06:40,000
CSS是你们自己的语言，

117
00:06:40,000 --> 00:06:43,000
但是从HTML语法上是非常不同的。

118
00:06:43,000 --> 00:06:46,000
在这种情况下，我们可以看到，我的网页上的内部，这是写在HTML中，

119
00:06:46,000 --> 00:06:51,000
我有CSS里面的这些报价，并约定CSS

120
00:06:51,000 --> 00:06:55,000
是，你有什么所谓的财产，其次，再次，一个冒号，

121
00:06:55,000 --> 00:06:58,000
其次，物业的价值，所以也没有等号。

122
00:06:58,000 --> 00:07:00,000
有没有额外的报价。

123
00:07:00,000 --> 00:07:03,000
只是这个冒号分隔的键值对，

124
00:07:03,000 --> 00:07:05,000
文本行不正是它说。

125
00:07:05,000 --> 00:07:09,000
它在体内的页对齐文本，这是真正的胆量的页面，

126
00:07:09,000 --> 00:07:11,000
在中心。

127
00:07:11,000 --> 00:07:13,000
>> 好了，那么，最终的结果是明确的，是这样的。

128
00:07:13,000 --> 00:07:17,000
不是所有的性感，但至少它为中心，有点像真正的谷歌。

129
00:07:17,000 --> 00:07:21,000
但是，如果我不是打开第2版

130
00:07:21,000 --> 00:07:25,000
并指出在这里完全一个新的标签？

131
00:07:25,000 --> 00:07:30,000
现在，在我的网页的头，这在以前只有标签

132
00:07:30,000 --> 00:07:32,000
在所有先前的例子吗？

133
00:07:32,000 --> 00:07:34,000
它只是有这个称号。

134
00:07:34,000 --> 00:07:38,000
刚才的head标签是这样的。

135
00:07:38,000 --> 00:07:40,000
现在，而不是它有它的style标签内，

136
00:07:40,000 --> 00:07:44,000
这也太，我很抱歉，语法看起来非常不同的（HTML）

137
00:07:44,000 --> 00:07:47,000
但你习惯了它，据此，里面的风格标签

138
00:07:47,000 --> 00:07:50,000
我现在可以分解出是刚才

139
00:07:50,000 --> 00:07:54,000
一个属性，样式属性，我可以把它在我的网页的最顶端。

140
00:07:54,000 --> 00:07:56,000
>> 为什么呢？

141
00:07:56,000 --> 00:08:00,000
那么，这是一步步走向清洁的东西，就像在写C代码

142
00:08:00,000 --> 00:08:04,000
我们有时会写功能分解出常见的功能。

143
00:08:04,000 --> 00:08:07,000
这只是一个小的清洁剂开始分解出的东西，如美学

144
00:08:07,000 --> 00:08:11,000
到一个中央位置，而不是它的所有点缀在你的HTML。

145
00:08:11,000 --> 00:08:14,000
这也没有说什么，即使有一点新的语法。

146
00:08:14,000 --> 00:08:19,000
我们在这里可以看到，这是一个选择，身体只是意味着选择body元素

147
00:08:19,000 --> 00:08:21,000
适用于下列属性。

148
00:08:21,000 --> 00:08:23,000
好了，财产是完全一样的。

149
00:08:23,000 --> 00:08:25,000
良好的措施，我添加了一个分号结束，

150
00:08:25,000 --> 00:08:29,000
这往往是惯例，我已经包装全部财产

151
00:08:29,000 --> 00:08:33,000
在大括号中，因为我其实可以有不同的东西在这里。

152
00:08:33,000 --> 00:08:39,000
我其实可以说的东西喜欢的颜色：蓝色;

153
00:08:39,000 --> 00:08:42,000
>> 现在，这也不会是一步步走向任何事情都漂亮，

154
00:08:42,000 --> 00:08:47,000
但如果我现在回去版本2我至少现在我的身体

155
00:08:47,000 --> 00:08:49,000
页的文本蓝色的。

156
00:08:49,000 --> 00:08:51,000
保持不变，因为这是一个输入的按钮。这不是纯文本。

157
00:08:51,000 --> 00:08:56,000
但一切是文本，像CS50搜索往上顶，其实是蓝色的。

158
00:08:56,000 --> 00:09:01,000
同样，我们现在所做的是删除从body标签，通知，

159
00:09:01,000 --> 00:09:04,000
的样式属性，我们已经考虑在这里。

160
00:09:04,000 --> 00:09:08,000
这是不是一个巨大的进步，但是如果我们采取这一步

161
00:09:08,000 --> 00:09:10,000
注意这里，我们可以在这第三个版本。

162
00:09:10,000 --> 00:09:14,000
>> ，在search3.html的网页几乎是相同的

163
00:09:14,000 --> 00:09:17,000
除非有什么新的标签，现在呢？

164
00:09:17,000 --> 00:09:20,000
链接，所以这个人是不是很恰当地命名为

165
00:09:20,000 --> 00:09:24,000
因为你不是在这个意义上的可点击的超链接连接起来。

166
00:09:24,000 --> 00:09:28,000
相反，你排序，这样做相当于在C＃

167
00:09:28,000 --> 00:09:31,000
其中的链接标签的href属性

168
00:09:31,000 --> 00:09:34,000
rel属性说，继续

169
00:09:34,000 --> 00:09:39,000
和复制的内容粘贴的文件名为的search3.css在这里，基本上。

170
00:09:39,000 --> 00:09:42,000
它不这样做，但它的精神。

171
00:09:42,000 --> 00:09:45,000
它说，去打开这个文件，search3.css，

172
00:09:45,000 --> 00:09:49,000
和对待它，就好像用户输入了正确的在页面头部的

173
00:09:49,000 --> 00:09:51,000
就像我在前面的例子。

174
00:09:51,000 --> 00:09:54,000
同时，Search3.css，是非常简单的。

175
00:09:54,000 --> 00:09:58,000
它实际上只是包含正是刚才

176
00:09:58,000 --> 00:10:03,000
标签的风格，但我已经考虑它在这里它自己的文件。

177
00:10:03,000 --> 00:10:07,000
>> 即使我们没有花太多的时间在所有的HTML或Web编程

178
00:10:07,000 --> 00:10:11,000
只是凭直觉是什么动机，也许，以剔除

179
00:10:11,000 --> 00:10:14,000
这个小片段，甚至CSS到自己的文件

180
00:10:14,000 --> 00:10:19,000
然后包括它这个链接标签吗？

181
00:10:19,000 --> 00:10:21,000
[听不见的学生反应]

182
00:10:21,000 --> 00:10:25,000
好吧，这是在这个意义上，你有你的CSS CSS文件中的更容易阅读。

183
00:10:25,000 --> 00:10:28,000
你有你的HTML在HTML文件中，所以在这个意义上，它更具可读性。

184
00:10:28,000 --> 00:10:30,000
什么是吸引力？是啊。

185
00:10:30,000 --> 00:10:32,000
[听不见的学生反应]

186
00:10:32,000 --> 00:10:35,000
是啊，所以你就可以包括了很多次，所以现在我们正在做的这些

187
00:10:35,000 --> 00:10:38,000
基本与单个文件的例子，但假设你实际上

188
00:10:38,000 --> 00:10:42,000
pset的7或您的项目最终也许像你这样的一个真正的网站，

189
00:10:42,000 --> 00:10:45,000
你想有多个网页，肯定是常见的

190
00:10:45,000 --> 00:10:48,000
现实世界的资讯网络，这将是一种跛脚

191
00:10:48,000 --> 00:10:52,000
复制和粘贴相同的蓝色

192
00:10:52,000 --> 00:10:56,000
和相同的文本对齐的中心，每一个这些网页。

193
00:10:56,000 --> 00:10:59,000
相反，它更有意义的因素，就像我们已经在C

194
00:10:59,000 --> 00:11:02,000
h文件，把它放在一个集中的地方，

195
00:11:02,000 --> 00:11:06,000
在这种情况下search3.css，然后允许任何文件

196
00:11:06,000 --> 00:11:11,000
在您的网站，其实这个标签在第16行中包含该文件。

197
00:11:11,000 --> 00:11:14,000
通常情况下，我们开始与版本0，哪种类型的作品

198
00:11:14,000 --> 00:11:18,000
但不一定是最好的，和每一个步骤，

199
00:11:18,000 --> 00:11:21,000
搜索1，搜索2，搜索我们已经采取了这些婴儿的步骤

200
00:11:21,000 --> 00:11:26,000
向设计，是一个小更清洁，更准备

201
00:11:26,000 --> 00:11:30,000
更复杂的页面，我们可以做的道路上。

202
00:11:30,000 --> 00:11:33,000
>> 让我打开最后一个例子，在这里只是为了说明

203
00:11:33,000 --> 00:11:36,000
更风格化的页面，但首先让我们来看看在HTML。

204
00:11:36,000 --> 00:11:41,000
这是search4.html，并注意在结构上几乎相同

205
00:11:41,000 --> 00:11:44,000
除了引入一个新的标签，DIV。

206
00:11:44,000 --> 00:11:48,000
Div是一个标签，引入了一个师的页面。

207
00:11:48,000 --> 00:11:51,000
你可以认为这是一种无形的矩形。

208
00:11:51,000 --> 00:11:54,000
它的创建在网页中一大片区域

209
00:11:54,000 --> 00:11:56,000
您可以设置样式的一次。

210
00:11:56,000 --> 00:11:58,000
我在这里做了如下。

211
00:11:58,000 --> 00:12:01,000
内我的身体标记，它一直在那里，一直以来，

212
00:12:01,000 --> 00:12:05,000
我说在这里创建一个分区的页面通过线45到47，

213
00:12:05,000 --> 00:12:09,000
这意味着，基本上是沿着页面顶部给我一种无形的矩形。

214
00:12:09,000 --> 00:12:14,000
然后给了我第二次​​的矩形，但无形的，下面，

215
00:12:14,000 --> 00:12:16,000
，并确定它的名字的内容，最后，

216
00:12:16,000 --> 00:12:19,000
给我一个第三师的页面底部

217
00:12:19,000 --> 00:12:21,000
叫ID。

218
00:12:21,000 --> 00:12:23,000
我们将看到为什么我在短短的时刻已经做到了这一点，

219
00:12:23,000 --> 00:12:26,000
但在概念上，我有一个头部门。

220
00:12:26,000 --> 00:12:30,000
我有一个内容划分，和我有一个页脚的页面划分

221
00:12:30,000 --> 00:12:32,000
即使这些都只是标记。

222
00:12:32,000 --> 00:12:35,000
用户不会看到3个矩形，

223
00:12:35,000 --> 00:12:37,000
但形式的结构有幕后

224
00:12:37,000 --> 00:12:39,000
他们是实际存在的。

225
00:12:39,000 --> 00:12:41,000
>> 现在，谁在乎呢？为什么要真正做到这一点呢？

226
00:12:41,000 --> 00:12:43,000
一切在页面上是一样的，因为我们之前已经看到了。

227
00:12:43,000 --> 00:12:47,000
这里是我的形式。下面是我的输入，我输入了一个换行符等等。

228
00:12:47,000 --> 00:12:50,000
不过，这里有一个图像，所以我们会看到这个来自一会儿就好了。

229
00:12:50,000 --> 00:12:52,000
这里有一个页脚，这是新的，只是因为我想介绍

230
00:12:52,000 --> 00:12:54,000
一些更多的内容。

231
00:12:54,000 --> 00:12:58,000
如果我们向上滚动注意到，这个div的ID是头。

232
00:12:58,000 --> 00:13:02,000
这个div的ID是内容​​，和这一个的ID是页脚。

233
00:13:02,000 --> 00:13:05,000
而作为顾名思义，当你有一个ID属性

234
00:13:05,000 --> 00:13:09,000
在HTML中，根据定义，它必须唯一地标识

235
00:13:09,000 --> 00:13:12,000
的元素之一，在您的网页的标签之一。

236
00:13:12,000 --> 00:13:16,000
完全是你要记住，你已经有一个头ID的负担。

237
00:13:16,000 --> 00:13:19,000
你有一个页脚。你已经有一个内容ID。

238
00:13:19,000 --> 00:13:22,000
电脑是不会找出一个可用的ID是你的，

239
00:13:22,000 --> 00:13:27,000
所以，你可能会意外地给2标签的ID的头，

240
00:13:27,000 --> 00:13:29,000
这将是错误的。

241
00:13:29,000 --> 00:13:31,000
>> 你必须记住，你已经创建了，

242
00:13:31,000 --> 00:13:34,000
但一旦你这样做，我们可以在这里做什么通知。

243
00:13:34,000 --> 00:13:38,000
我现在可以指定我的风格标签的顶部

244
00:13:38,000 --> 00:13:41,000
或等价的，如果我在我的CSS文件中仍然使用该版本，

245
00:13:41,000 --> 00:13:46,000
我可以说＃头，这是什么意思的是，任何标签

246
00:13:46,000 --> 00:13:49,000
在这个网页上有一个ID的头

247
00:13:49,000 --> 00:13:53,000
＃中，只需通过人的惯例，代表ID。

248
00:13:53,000 --> 00:13:56,000
井号或井号代表ID。

249
00:13:56,000 --> 00:13:58,000
头是我给它的名称。

250
00:13:58,000 --> 00:14:01,000
这意味着应用此CSS属性

251
00:14:01,000 --> 00:14:04,000
在此页面中的任何标记承担ID的头。

252
00:14:04,000 --> 00:14:06,000
同样的交易在这里。

253
00:14:06,000 --> 00:14:09,000
应用此属性的任何元素，而这恰好是相同的，

254
00:14:09,000 --> 00:14:11,000
其ID是内容​​，然后在这里

255
00:14:11,000 --> 00:14:14,000
请注意，我有一个小票友页脚。

256
00:14:14,000 --> 00:14:18,000
任何元素的ID是页脚，其中可以有一个定义，

257
00:14:18,000 --> 00:14:21,000
继续前进，其字体大小较小，

258
00:14:21,000 --> 00:14:24,000
其字体粗细大胆的，其保证金20像素。

259
00:14:24,000 --> 00:14:26,000
>> 这是什么意思呢？

260
00:14:26,000 --> 00:14:28,000
它只是一个缘的顶部，底部，左侧和右侧上。

261
00:14:28,000 --> 00:14:31,000
这意味着，给我一个20像素的无形的边缘时

262
00:14:31,000 --> 00:14:35,000
一切只是推离它一点点，像你可能在Word中，

263
00:14:35,000 --> 00:14:37,000
Microsoft Word或页面等。

264
00:14:37,000 --> 00:14:39,000
然后文本居中对齐。

265
00:14:39,000 --> 00:14:43,000
让我们来看看最终的结果，那么我们就回去了，这是剩下的CSS片段。

266
00:14:43,000 --> 00:14:48,000
这是第4版，我们的搜索的例子，和它的多，更性感。

267
00:14:48,000 --> 00:14:54,000
现在，为公平起见，我只是谷歌搜索“谷歌字体标识生成器”。

268
00:14:54,000 --> 00:14:58,000
这让我创建一​​个GIF图像格式，它看起来像有。

269
00:14:58,000 --> 00:15:00,000
事实上，你可以做到这一点。

270
00:15:00,000 --> 00:15:03,000
我们有“谷歌字体标发生器”。

271
00:15:03,000 --> 00:15:05,000
>> 让我们来看看，如果我们能做到这一点。

272
00:15:05,000 --> 00:15:07,000
好吧，我觉得这是我所使用的网站。

273
00:15:07,000 --> 00:15:11,000
例如，我们可以说，EC 10，和他们自己的。

274
00:15:11,000 --> 00:15:13,000
你可以玩这个整天长，然后用鼠标右键单击它

275
00:15:13,000 --> 00:15:16,000
然后下载实际的GIF，这是我做的这一切。

276
00:15:16,000 --> 00:15:19,000
事实上，这就是为什么在我的HTML，回想一下，在这里

277
00:15:19,000 --> 00:15:22,000
我有一个形象的标签，这是我们上周看到的

278
00:15:22,000 --> 00:15:24,000
其来源是logo.gif的。

279
00:15:24,000 --> 00:15:28,000
什么又是有这个alt属性的动机，

280
00:15:28,000 --> 00:15:31,000
这种替代属性呢？

281
00:15:31,000 --> 00:15:33,000
是啊。

282
00:15:33,000 --> 00:15:35,000
[听不见的学生反应]

283
00:15:35,000 --> 00:15:37,000
好，所以有2个原因真的，如果浏览器不能拉的形象

284
00:15:37,000 --> 00:15:40,000
因为你有一个缓慢的网络连接或图像已损坏

285
00:15:40,000 --> 00:15:44,000
或类似的东西，至少在人类可以看到“CS50搜索”，

286
00:15:44,000 --> 00:15:46,000
然后还访问性的原因。

287
00:15:46,000 --> 00:15:48,000
如果你有一个谁是盲目的，并使用屏幕阅读器的用户

288
00:15:48,000 --> 00:15:50,000
，因此，显然不能看到图像，他们至少可以

289
00:15:50,000 --> 00:15:52,000
如果他们的电脑说给他们听文本。

290
00:15:52,000 --> 00:15:56,000
>> 在一般情况下，这是最好的练习，当它涉及到网页的可访问性

291
00:15:56,000 --> 00:16:00,000
所以在这种情况下，即使用户可以听到或看到的，可以这么说，

292
00:16:00,000 --> 00:16:03,000
它是什么，您的网页上。

293
00:16:03,000 --> 00:16:05,000
还有一个其他的事情，我在这里做

294
00:16:05,000 --> 00:16:09,000
这是一个有点有趣，我们会看到更多关于这个问题，设置为7

295
00:16:09,000 --> 00:16:12,000
通过的教学研究员领导的短裤之一。

296
00:16:12,000 --> 00:16:15,000
但＃的内容是指该标记

297
00:16:15,000 --> 00:16:20,000
其ID是内容​​，但是有一个空格字符，然后有字的输入。

298
00:16:20,000 --> 00:16:25,000
那么，什么是有趣的CSS，你可以

299
00:16:25,000 --> 00:16:29,000
标签页面中的类的层次结构，

300
00:16:29,000 --> 00:16:33,000
这是什么代码片段的CSS的手段是找到标签

301
00:16:33,000 --> 00:16:37,000
其ID是内容​​，然后采用下列属性

302
00:16:37,000 --> 00:16:42,000
的所有内容的后代的输入标签，

303
00:16:42,000 --> 00:16:44,000
那就是它内部的缩进。

304
00:16:44,000 --> 00:16:48,000
再次，压痕，唯一重要的计算机，不以人的，

305
00:16:48,000 --> 00:16:51,000
但按照惯例，我们缩进的事情，因为我们去深入到一个页面，

306
00:16:51,000 --> 00:16:54,000
因此，这意味着申请保证金的5个像素任何输入元素

307
00:16:54,000 --> 00:16:57,000
这是某处内部或嵌套在

308
00:16:57,000 --> 00:16:59,000
 元素的ID是内容​​。

309
00:16:59,000 --> 00:17:01,000
>> 谁不适用？

310
00:17:01,000 --> 00:17:03,000
好了，其实只是这两个家伙在这里。

311
00:17:03,000 --> 00:17:05,000
请注意，内侧的形式有2个输入，

312
00:17:05,000 --> 00:17:07,000
因为可用于所有这些实施例的。

313
00:17:07,000 --> 00:17:11,000
但是请注意，这2个输入发生嵌套在

314
00:17:11,000 --> 00:17:13,000
虽然有点深，一对夫妇的缩进层次，

315
00:17:13,000 --> 00:17:16,000
里面的标签的ID是内容​​。

316
00:17:16,000 --> 00:17:18,000
这是什么意思呢？

317
00:17:18,000 --> 00:17:21,000
如果我们去到浏览器，在这里你可以看到非常轻微

318
00:17:21,000 --> 00:17:23,000
让我放大在按钮之间，有一个填充位

319
00:17:23,000 --> 00:17:25,000
之间的文本字段。

320
00:17:25,000 --> 00:17:27,000
>> 让我暂时把它们关掉。

321
00:17:27,000 --> 00:17:30,000
让我走我的CSS，并让我继续前进，只是

322
00:17:30,000 --> 00:17:34,000
改变这种保证金从5个像素为0像素。

323
00:17:34,000 --> 00:17:37,000
让我走前面，然后保存文件，返回的搜索引擎

324
00:17:37,000 --> 00:17:40,000
并重新加载，并观看页面中间的。

325
00:17:40,000 --> 00:17:43,000
一切都压缩在一起了，当我第一次鞭打这个例子

326
00:17:43,000 --> 00:17:46,000
我想，看起来愚蠢的文本字段，然后它下面的按钮。

327
00:17:46,000 --> 00:17:50,000
我要垫那么一点点的，所以我介绍的利润。

328
00:17:50,000 --> 00:17:55,000
我们不会做的是通过在课堂上的几十个

329
00:17:55,000 --> 00:17:58,000
CSS属性存在，因为，有一些事情，如字体大小，

330
00:17:58,000 --> 00:18:02,000
字体粗细，保证金，文字对齐，和几十个其他，

331
00:18:02,000 --> 00:18:06,000
和问题，我们将请您在7到各种在线教程

332
00:18:06,000 --> 00:18:08,000
和参考，让您选择这些东西。

333
00:18:08,000 --> 00:18:10,000
但什么是真正重要的，在一天结束的时候

334
00:18:10,000 --> 00:18:12,000
>> 了解如何应用这些东西。

335
00:18:12,000 --> 00:18:15,000
同样，如果我们有style标签内的

336
00:18:15,000 --> 00:18:19,000
可以去选择器的标识符指定

337
00:18:19,000 --> 00:18:21,000
向谁你想应用这些属性，

338
00:18:21,000 --> 00:18:24,000
然后你把键值对的属性

339
00:18:24,000 --> 00:18:28,000
由冒号分隔，然后用一个分号结束，

340
00:18:28,000 --> 00:18:32,000
或者您可以复制出来，并把它放在一个单独的CSS文件

341
00:18:32,000 --> 00:18:35,000
你们自己。

342
00:18:35,000 --> 00:18:39,000
所有的权利，任何问题的概念

343
00:18:39,000 --> 00:18:41,000
或大图片的CSS？

344
00:18:41,000 --> 00:18:43,000
你会再次看到更多的内容在pset中7，

345
00:18:43,000 --> 00:18:47,000
但我们会保持它通常是非常简单的。

346
00:18:47,000 --> 00:18:49,000
不是吗？好的。

347
00:18:49,000 --> 00:18:51,000
这是一个实际的编程语言，

348
00:18:51,000 --> 00:18:54,000
而我们再回过头来一点点的CSS中的一个例子。

349
00:18:54,000 --> 00:18:58,000
PHP实际上是一个奇妙的易懂的语言

350
00:18:58,000 --> 00:19:02,000
在于它是语法上几乎等同于下

351
00:19:02,000 --> 00:19:06,000
换句话说，如果你知道，你知道的大部分PHP，

352
00:19:06,000 --> 00:19:08,000
至少在语法上，即使有一些新的特点

353
00:19:08,000 --> 00:19:10,000
一些新的概念，我们将不得不看。

354
00:19:10,000 --> 00:19:13,000
>> 但在大多数情况下，现在我们从C过渡到PHP

355
00:19:13,000 --> 00:19:16,000
最新的东西，是真正的大画面，

356
00:19:16,000 --> 00:19:19,000
如何程序在网络上使用的语言，而不是

357
00:19:19,000 --> 00:19:23,000
在命令行或在闪烁提示，我们已经做了迄今为止。

358
00:19:23,000 --> 00:19:27,000
作为参考，特别是与pset的7和最终的项目开始，

359
00:19:27,000 --> 00:19:31,000
不利用这个URL，在这里，如果你想读的PHP手续。

360
00:19:31,000 --> 00:19:34,000
它实际上是喜欢一个免费的在线教材有效，

361
00:19:34,000 --> 00:19:37,000
你还会发现，什么是真正好的关于PHP

362
00:19:37,000 --> 00:19:41,000
是有数百功能，用它来，

363
00:19:41,000 --> 00:19:44,000
而在C中，你并不一定有机会获得

364
00:19:44,000 --> 00:19:47,000
更多的功能比的数学函数库，的CS50库。

365
00:19:47,000 --> 00:19:51,000
在PHP和大量的现代语言，Python和Ruby，其中，

366
00:19:51,000 --> 00:19:54,000
您可以访问那么多的功能，这意味着你写

367
00:19:54,000 --> 00:19:57,000
少了很多的代码，因为你可以站在别人的肩膀上

368
00:19:57,000 --> 00:19:59,000
已经写了一些你的东西。

369
00:19:59,000 --> 00:20:03,000
>> 让我们快速浏览PHP的语法，然后写了几个例子。

370
00:20:03,000 --> 00:20:06,000
什么是好的关于PHP的第一个和最重要的

371
00:20:06,000 --> 00:20:08,000
有没有没有主函数。

372
00:20:08,000 --> 00:20:10,000
如果你想在PHP编写一个程序，你刚开始写代码，

373
00:20:10,000 --> 00:20:12,000
你不必担心主。

374
00:20:12,000 --> 00:20:14,000
有没有诠释。有没有回报。

375
00:20:14,000 --> 00:20:17,000
有没有ARGV ARGC，当你写的程序。

376
00:20:17,000 --> 00:20:20,000
相反，您就可以开始编写代码，这是部分

377
00:20:20,000 --> 00:20:23,000
因为PHP是一种解释型语言。

378
00:20:23,000 --> 00:20:26,000
C的编译，它被编译在这个意义上，你开始

379
00:20:26,000 --> 00:20:29,000
源代码，运行它通过铛，这是一个编译器，

380
00:20:29,000 --> 00:20:33,000
并最终一些数量的步骤后，您可以在对象的代码，0s和1s。

381
00:20:33,000 --> 00:20:36,000
PHP，Python和Ruby和珠江三角洲及其他

382
00:20:36,000 --> 00:20:39,000
不同类型的语言，你不要把它们编译。

383
00:20:39,000 --> 00:20:42,000
你不要去从源代码到0和1。

384
00:20:42,000 --> 00:20:45,000
您只需运行的源代码，并且运行的源代码

385
00:20:45,000 --> 00:20:49,000
写在一个普通的文本文件，在这种情况下，PHP结束

386
00:20:49,000 --> 00:20:53,000
而不是C，该程序的功能在您的计算机上

387
00:20:53,000 --> 00:20:57,000
从字面上解释是由一行行的代码行。

388
00:20:57,000 --> 00:21:00,000
>> 换句话说，而不是写一个程序并运行程序

389
00:21:00,000 --> 00:21:04,000
直接，你来写一个程序，PHP结尾的文件。

390
00:21:04,000 --> 00:21:09,000
然后运行实际的程序中，名为php.exe的，如果你使用的是Windows，

391
00:21:09,000 --> 00:21:12,000
或只是PHP的，如果你在Mac OS或Linux，

392
00:21:12,000 --> 00:21:17,000
您提供的输入到PHP程序自己的源代码，

393
00:21:17,000 --> 00:21:20,000
在生活中，其目的是阅读你的代码从上到下，从左到右，

394
00:21:20,000 --> 00:21:23,000
，做任何你已经告诉它做的事。

395
00:21:23,000 --> 00:21:25,000
>> 让我们来看看这是什么将意味着语法。

396
00:21:25,000 --> 00:21:27,000
在PHP中，我们具备的条件。

397
00:21:27,000 --> 00:21:29,000
这张幻灯片是你所看到的，在第1周

398
00:21:29,000 --> 00:21:33,000
因为语法的条件下，如果和其他人如果和其他PHP

399
00:21:33,000 --> 00:21:35,000
看起来正是这样。

400
00:21:35,000 --> 00:21:38,000
当布尔表达式他们要去看看正是这样的。

401
00:21:38,000 --> 00:21:43,000
当涉及到安定为布尔值，它会完全一样的东西放在一起。

402
00:21:43,000 --> 00:21:46,000
开关看起来是一样的，你会得到额外的好处在PHP

403
00:21:46,000 --> 00:21:51,000
在C，交换机只能打开一个char或int。

404
00:21:51,000 --> 00:21:53,000
你可以打开一个字符串值。

405
00:21:53,000 --> 00:21:55,000
在PHP中，你其实可以有一个表达

406
00:21:55,000 --> 00:21:58,000
这是一个变量，其内容是一个字符串，

407
00:21:58,000 --> 00:22:01,000
实际上，你可以做字符串比较在现实直观的方式，

408
00:22:01,000 --> 00:22:06,000
没有指针的比较，以决定是否做的情况下，i或j或别的东西。

409
00:22:06,000 --> 00:22:09,000
不久，我们将看到潜在的。

410
00:22:09,000 --> 00:22:11,000
>> 循环过奇妙的是相同的。

411
00:22:11,000 --> 00:22:15,000
For循环的初始化，条件，和一定数量的更新。

412
00:22:15,000 --> 00:22:18,000
while循环，也存在于PHP。

413
00:22:18,000 --> 00:22:21,000
DO WHILE循环也存在于PHP，

414
00:22:21,000 --> 00:22:26,000
和数组存在于PHP，但这里的语法开始有一点不同的地方，

415
00:22:26,000 --> 00:22:29,000
但其概念是相同的，和概念真的是相同的

416
00:22:29,000 --> 00:22:32,000
因为他们是在第0周与划伤。

417
00:22:32,000 --> 00:22:34,000
首先是$符号。

418
00:22:34,000 --> 00:22:37,000
这是一个设计决定，PHP，任何变量

419
00:22:37,000 --> 00:22:41,000
在PHP的设计从$符号。

420
00:22:41,000 --> 00:22:46,000
有没有更多的X，Y，Z $ X $ Y $ Z只是因为。

421
00:22:46,000 --> 00:22:49,000
这件事情要记住，现在的右手边

422
00:22:49,000 --> 00:22:52,000
这看起来类似于数组，

423
00:22:52,000 --> 00:22:54,000
但我们在这里使用方括号。

424
00:22:54,000 --> 00:22:57,000
在PHP和JavaScript，因为我们最终会看到，

425
00:22:57,000 --> 00:23:01,000
声明一个数组，你做开括号和闭方括号，

426
00:23:01,000 --> 00:23:04,000
那么你有一个逗号分隔的值列表，无论是int型

427
00:23:04,000 --> 00:23:09,000
或字符串或字符，你想要什么，里面的表达有。

428
00:23:09,000 --> 00:23:11,000
>> 现在，怎么我们做这样的事情在C？

429
00:23:11,000 --> 00:23:16,000
已知的数字静态声明一个数组的语法是什么？

430
00:23:16,000 --> 00:23:19,000
这是大括号，这样微小的差别，但在PHP

431
00:23:19,000 --> 00:23:22,000
并最终器的，它只是使用方括号，所以真的

432
00:23:22,000 --> 00:23:25,000
唯一有趣的细节是$符号的变量名

433
00:23:25,000 --> 00:23:28,000
方括号中，也有一个很奇怪的事情

434
00:23:28,000 --> 00:23:32,000
被省略的，以及在左边的等号（=）。

435
00:23:32,000 --> 00:23:36,000
缺少了什么，我们已经要求了好几个星期呢？是啊。

436
00:23:36,000 --> 00:23:38,000
[听不见的学生反应]

437
00:23:38,000 --> 00:23:41,000
的大小，所以这里没有提到的数组的大小。

438
00:23:41,000 --> 00:23:45,000
坦率地说，这里没有提到的方括号的左侧

439
00:23:45,000 --> 00:23:47,000
等号（=），还有什么缺少的行吗？

440
00:23:47,000 --> 00:23:49,000
是啊。>> [听不见的学生反应]

441
00:23:49,000 --> 00:23:52,000
的类型，有什么有趣的，特别是关于PHP

442
00:23:52,000 --> 00:23:56,000
是，它是不是一个强类型语言，C是

443
00:23:56,000 --> 00:23:58,000
强类型的字符在这个意义上，你必须说，

444
00:23:58,000 --> 00:24:00,000
你必须说int，你必须说浮动。

445
00:24:00,000 --> 00:24:03,000
>> 任何时候你想要一个变量，其类型是什么，你要告诉铛。

446
00:24:03,000 --> 00:24:05,000
PHP是一个有点懒惰。

447
00:24:05,000 --> 00:24:08,000
在这个意义上它是松散类型的，

448
00:24:08,000 --> 00:24:11,000
你可以有花车和字符和字符串

449
00:24:11,000 --> 00:24:14,000
和整型等等，但语言本身

450
00:24:14,000 --> 00:24:17,000
并不真正关心什么，你把里面的变量。

451
00:24:17,000 --> 00:24:20,000
您没有提前告知什么样的数据类型

452
00:24:20,000 --> 00:24:22,000
在变量中。

453
00:24:22,000 --> 00:24:24,000
这完全取决于你，所以这是很好的

454
00:24:24,000 --> 00:24:27,000
，你不必担心，因为很多数据输入

455
00:24:27,000 --> 00:24:29,000
和担心你的论点是什么，等等。

456
00:24:29,000 --> 00:24:32,000
这也意味着最终PHP中的函数能够返回

457
00:24:32,000 --> 00:24:36,000
无论是一个int的时候，也许曾经在一段时间内

458
00:24:36,000 --> 00:24:40,000
例如，他们将返回一个布尔值，布尔值false，表示出事了。

459
00:24:40,000 --> 00:24:44,000
这给了我们一些不相上下，但它也将使我们的设计

460
00:24:44,000 --> 00:24:47,000
有点懒，当涉及到数据类型。

461
00:24:47,000 --> 00:24:50,000
>> 还有什么在这里要记住的？

462
00:24:50,000 --> 00:24:54,000
变量看起来很喜欢这一点，所以$ S =“你好，世界”。

463
00:24:54,000 --> 00:24:57,000
这也许能推理从前面的例子中，

464
00:24:57,000 --> 00:24:59,000
我们有另一种类型的循环。

465
00:24:59,000 --> 00:25:02,000
这一次，我们将真正看到曾经在一段时间内，因为它是非常方便的，

466
00:25:02,000 --> 00:25:04,000
foreach构造。

467
00:25:04,000 --> 00:25:11,000
在这种情况下，foreach循环需要其括号中的3个字的内侧通常情况下，

468
00:25:11,000 --> 00:25:16,000
美元的东西，这是你想要什么样的阵列遍历成员，

469
00:25:16,000 --> 00:25:19,000
然后字面上的关键字，然后最后，

470
00:25:19,000 --> 00:25:21,000
另一个变量的名称，你可以选择。

471
00:25:21,000 --> 00:25:23,000
它可以是富，酒吧，或元素，

472
00:25:23,000 --> 00:25:26,000
这是什么结构并

473
00:25:26,000 --> 00:25:29,000
如果阵列包含10个元素

474
00:25:29,000 --> 00:25:34,000
在每次迭代这个数组对不起，这个循环在每次迭代

475
00:25:34,000 --> 00:25:37,000
变量称为元素将被更新

476
00:25:37,000 --> 00:25:40,000
成为第一个数组中的元素，那么第二个数组中的元素，

477
00:25:40,000 --> 00:25:44,000
然后第三个元素的数组，从而无需

478
00:25:44,000 --> 00:25:46,000
做的有点恼人的方括号和

479
00:25:46,000 --> 00:25:49,000
$我为了到一个数组中的索引。

480
00:25:49,000 --> 00:25:53,000
PHP做所有的工作，并在每次迭代

481
00:25:53,000 --> 00:25:55,000
只是手从数组中的下一个元素

482
00:25:55,000 --> 00:26:01,000
没有你不必知道或关心它的数字索引位置。

483
00:26:01,000 --> 00:26:04,000
>> 最后，就目前而言，还有另外一个功能的PHP

484
00:26:04,000 --> 00:26:08,000
这将是巨大的，特别是当我们在网络上开始编程，

485
00:26:08,000 --> 00:26:10,000
而这被称为关联数组。

486
00:26:10,000 --> 00:26:13,000
因此，我们知道的阵列为20秒前

487
00:26:13,000 --> 00:26:17,000
在过去8周的数字索引数组，

488
00:26:17,000 --> 00:26:20,000
传统的阵列类型的指数是整数，

489
00:26:20,000 --> 00:26:23,000
0，1，2，所有的方式上升。

490
00:26:23,000 --> 00:26:25,000
关联数组功能更强大。

491
00:26:25,000 --> 00:26:28,000
他们让你有任意键，

492
00:26:28,000 --> 00:26:31,000
任意指数和任意值。

493
00:26:31,000 --> 00:26:34,000
而在传统的阵列，它是0，1，2，

494
00:26:34,000 --> 00:26:37,000
在一个关联数组，你可以有一个指数

495
00:26:37,000 --> 00:26:41,000
foo的一个关键，它的值是酒吧。

496
00:26:41,000 --> 00:26:46,000
然后，您可以有另外一个关键的名字是巴兹，其值QUX的。

497
00:26:46,000 --> 00:26:49,000
>> 同样的，愚蠢的计算机科学通用的变量名，

498
00:26:49,000 --> 00:26:55,000
但问题是，这个数组没有支架0或支架1。

499
00:26:55,000 --> 00:26:59,000
相反，它会，有支架foo和支架巴兹。

500
00:26:59,000 --> 00:27:03,000
这是一个很大的通用性，我们将能够联想到的

501
00:27:03,000 --> 00:27:07,000
与其他词的话，完全任意键的值，

502
00:27:07,000 --> 00:27:12,000
我们将是能够得到这些值在固定的时间

503
00:27:12,000 --> 00:27:14,000
因为引擎盖下的一个关联数组

504
00:27:14,000 --> 00:27:16,000
真的是一个哈希表。

505
00:27:16,000 --> 00:27:20,000
回想一下，一个哈希表，可以让你把一些输入

506
00:27:20,000 --> 00:27:25,000
喜欢把中的单词大卫，如果你要插入到某种字典大卫，

507
00:27:25,000 --> 00:27:27,000
然后你会得到一定的价值一般。

508
00:27:27,000 --> 00:27:29,000
拼写检查的情况下，真或假。

509
00:27:29,000 --> 00:27:33,000
大卫的字在字典中没有的。

510
00:27:33,000 --> 00:27:36,000
一个关联数组，其实只是一个哈希表，

511
00:27:36,000 --> 00:27:38,000
但它是一个更加用户友好的化身。

512
00:27:38,000 --> 00:27:41,000
正如我们将要看到的，这将允许我们做一些事情

513
00:27:41,000 --> 00:27:43,000
非常，非常容易。

514
00:27:43,000 --> 00:27:45,000
>> 让我们来看看一些基本的PHP

515
00:27:45,000 --> 00:27:47,000
例子，看看我们能做些什么这门语言。

516
00:27:47,000 --> 00:27:51,000
让我去进取，不断开拓今天在我们的源代码目录

517
00:27:51,000 --> 00:27:54,000
一个名为hello1.php。

518
00:27:54,000 --> 00:27:57,000
这个文件是更多的评论比它实际的代码，

519
00:27:57,000 --> 00:28:00,000
因此，让我真正从文件中删除所有的评论

520
00:28:00,000 --> 00:28:05,000
和现在的你也许是最简单的PHP程序在这里。

521
00:28:05,000 --> 00:28:07,000
5条线，并且其中一些是白色的空间，

522
00:28:07,000 --> 00:28:09,000
所以在这里发现一些关键的差别。

523
00:28:09,000 --> 00:28:12,000
该文件称为hello1.php。

524
00:28:12,000 --> 00:28:16,000
不过，第一行，<？PHP。

525
00:28:16,000 --> 00:28:18,000
类似的精神，HTML，

526
00:28:18,000 --> 00:28:21,000
该序列的字符告诉计算机

527
00:28:21,000 --> 00:28:25,000
“嘿，计算机，来我们在PHP程序。”

528
00:28:25,000 --> 00:28:28,000
它可以确保它不会混淆，它的一些其他语言。

529
00:28:28,000 --> 00:28:30,000
2号线是一个有趣的空白。

530
00:28:30,000 --> 00:28:32,000
printf的第3行是我们的老朋友，

531
00:28:32,000 --> 00:28:34,000
这时候在PHP的背景下。

532
00:28:34,000 --> 00:28:37,000
PHP有它自己的版本的printf的行为完全一样的，

533
00:28:37,000 --> 00:28:39,000
因此，这只是要打印“你好，世界”。

534
00:28:39,000 --> 00:28:46,000
然后此相反的标记在这里，>，这意味着这是我的PHP代码。

535
00:28:46,000 --> 00:28:48,000
>> 让我们来看看如何运行。

536
00:28:48,000 --> 00:28:50,000
我要回到我的终端窗口。

537
00:28:50,000 --> 00:28:52,000
我要进入​​我的PHP目录。

538
00:28:52,000 --> 00:28:56,000
请注意，我们有一大堆的文件，其中第一个是hello.php的。

539
00:28:56,000 --> 00:29:01,000
让我继续运行，hello1.php，进入。

540
00:29:01,000 --> 00:29:03,000
权限被拒绝。好吧。

541
00:29:03,000 --> 00:29:06,000
我们是如何固定的像这样的事情在过去的？

542
00:29:06,000 --> 00:29:08,000
那是什么？>> [听不见的学生反应]

543
00:29:08,000 --> 00:29:11,000
我们需要读取和写入，但让我做的ls-l。

544
00:29:11,000 --> 00:29:14,000
记住这个有点神秘的输出，此处为Hello1

545
00:29:14,000 --> 00:29:17,000
似乎是可读和可写的我

546
00:29:17,000 --> 00:29:19,000
但其他人可读的。

547
00:29:19,000 --> 00:29:22,000
事实证明，这实际上是不正确的方向前进的一个步骤。

548
00:29:22,000 --> 00:29:25,000
一种解释型语言差异，再次与

549
00:29:25,000 --> 00:29:27,000
你不要直接运行程序。

550
00:29:27,000 --> 00:29:30,000
你，而不是一个翻译，把它的代码

551
00:29:30,000 --> 00:29:33,000
你写的，所以它可以解释一行行。

552
00:29:33,000 --> 00:29:36,000
在这种情况下，解释器或程序，其实我是想运行

553
00:29:36,000 --> 00:29:38,000
是真正的PHP。

554
00:29:38,000 --> 00:29:41,000
>> 这个设备的硬盘驱动器上的某个地方有一个程序

555
00:29:41,000 --> 00:29:45,000
别人写PHP，或在Windows下的php.exe。

556
00:29:45,000 --> 00:29:48,000
我要在这里做什么是我要实际运行PHP

557
00:29:48,000 --> 00:29:51,000
但将它作为命令行参数，我写的代码，

558
00:29:51,000 --> 00:29:54,000
，然后我会放大并按下回车键。

559
00:29:54,000 --> 00:29:58,000
对我来说，它运行我的程序，从上到下，从左到右。

560
00:29:58,000 --> 00:30:01,000
让我去进取，不断开拓一个略有差异。

561
00:30:01,000 --> 00:30:05,000
在hello2.php通知，这太

562
00:30:05,000 --> 00:30:08,000
主要是注释，所以让我摆脱这些作为一种消遣，

563
00:30:08,000 --> 00:30:13,000
什么明显的不同有关此文件吗？

564
00:30:13,000 --> 00:30:15,000
这种新的生产线，在顶部略带神秘的。

565
00:30:15,000 --> 00:30:20,000
在第1行是＃！/ bin中/ PHP。

566
00:30:20,000 --> 00:30:24,000
斌是一个约定，Linux和Mac OS二进制文件，

567
00:30:24,000 --> 00:30:27,000
/ bin中表示这是一个文件夹，其中包含了一堆二进制文件

568
00:30:27,000 --> 00:30:29,000
被编程的，其中之一是PHP。

569
00:30:29,000 --> 00:30:32,000
＃！绰号家当，

570
00:30:32,000 --> 00:30:35,000
这是说，它的快捷方式，这是什么意思

571
00:30:35,000 --> 00:30:40,000
是，当你运行这个程序，现在有一个提示，在该文件的顶部

572
00:30:40,000 --> 00:30:44,000
告诉计算机使用什么样的解释。

573
00:30:44,000 --> 00:30:47,000
>> 它变得有点讨厌，如果你要告诉你的用户和您的客户

574
00:30:47,000 --> 00:30:50,000
“嘿，我们写了这的程序称为hello1.php。”

575
00:30:50,000 --> 00:30:54,000
所有你所要做的是永远运行PHP，然后这个程序的名称。

576
00:30:54,000 --> 00:30:58,000
坦率地说，它只是更好的运行hello1.php，

577
00:30:58,000 --> 00:31:00,000
而事实上，我们可以的，如果我们做以下。

578
00:31:00,000 --> 00:31:05,000
让我继续做ls-l的通知hello2它仍然只是读写

579
00:31:05,000 --> 00:31:10,000
，然后看了看了，所以我也还没有做到这一点，hello2.php。

580
00:31:10,000 --> 00:31:15,000
但是，我们推出了这款非常简要地最后一次，chmod命令。

581
00:31:15,000 --> 00:31:20,000
如果我不改变存取权限chmod a + x，这意味着所有的加可执行，

582
00:31:20,000 --> 00:31:26,000
然后hello2.php，然后执行ls-l的再次注意到有什么改变。

583
00:31:26,000 --> 00:31:29,000
一，Linux是显示我的文件名绿色传达的理念

584
00:31:29,000 --> 00:31:32,000
，它的可执行文件，但更重要的是，在左手侧

585
00:31:32,000 --> 00:31:36,000
注意到位代表x为可执行文件现在已经被设置。

586
00:31:36,000 --> 00:31:42,000
这意味着现在是我可以运行./hello2.php的像往常一样，

587
00:31:42,000 --> 00:31:45,000
点击进入，因为在最高层的文件的家当

588
00:31:45,000 --> 00:31:48,000
这是一个提示，再次，Linux的说

589
00:31:48,000 --> 00:31:51,000
使用这个解释器来运行这个文件。

590
00:31:51,000 --> 00:31:54,000
不要担心迫使用户输入。

591
00:31:54,000 --> 00:31:57,000
>> 什么是好的，现在是它的一种不相关的我的客户还是我的朋友

592
00:31:57,000 --> 00:32:01,000
什么语言，我写了这个程序，这样我就可以继续使用mv

593
00:32:01,000 --> 00:32:04,000
hello2，例如重命名这件事情。

594
00:32:04,000 --> 00:32:07,000
现在，如果我做./hello2

595
00:32:07,000 --> 00:32:10,000
放大了我的程序继续运行。

596
00:32:10,000 --> 00:32:13,000
这些文件的扩展名是一个人的约定，这是必要的

597
00:32:13,000 --> 00:32:15,000
为类似铛，寻找他们的。

598
00:32:15,000 --> 00:32:18,000
但对于PHP，我可以打电话给这个文件扩展名我想要的任何东西。

599
00:32:18,000 --> 00:32:22,000
我想，我真的很不错，在红宝石欺骗世界，

600
00:32:22,000 --> 00:32:25,000
我可以写hello2.rb，然后运行它，

601
00:32:25,000 --> 00:32:28,000
瞧，现在我的Ruby版本，这是一个彻头彻尾的谎言。

602
00:32:28,000 --> 00:32:30,000
但是，文件扩展名是没有意义的

603
00:32:30,000 --> 00:32:35,000
如果该文件是可执行文件，并在该文件的顶部，有这样的特别提示。

604
00:32:35,000 --> 00:32:38,000
>> 现在，顺便说一句，让我告诉你很快第3版，

605
00:32:38,000 --> 00:32:40,000
这是一个有用的技巧，知道排序。

606
00:32:40,000 --> 00:32:45,000
，在hello3我做了一些错误

607
00:32:45,000 --> 00:32:47,000
我会在线更新的源代码。

608
00:32:47,000 --> 00:32:50,000
在第3版事实证明，在大多数的Linux电脑

609
00:32:50,000 --> 00:32:53,000
有一个程序叫环境对环境，

610
00:32:53,000 --> 00:32:56,000
你可以在这里做的是，如果你不知道PHP

611
00:32:56,000 --> 00:33:00,000
安装在本地硬盘驱动器，因为它的确可以在电脑上根据

612
00:33:00,000 --> 00:33:03,000
有人正在使用，ENV只是说运行环境，

613
00:33:03,000 --> 00:33:07,000
这是在大多数系统上，并找出其中PHP是。

614
00:33:07,000 --> 00:33:11,000
只是一个普通的伎俩，以便找出其中一个方案是，你不必担心。

615
00:33:11,000 --> 00:33:14,000
但是，如果你做护理，找出程序是，你不关心迄今

616
00:33:14,000 --> 00:33:16,000
你可以使用命令。

617
00:33:16,000 --> 00:33:19,000
>> 让我放大和类型，也就是PHP，

618
00:33:19,000 --> 00:33:23,000
并注意到它告诉我，它实际上是在usr / bin中/ PHP。

619
00:33:23,000 --> 00:33:25,000
这是一个谎言。这也是在垃圾桶。

620
00:33:25,000 --> 00:33:27,000
这只是我的第一击。

621
00:33:27,000 --> 00:33:31,000
如果你想知道在Clang的是，这，这是在usr / bin中/铛铛，

622
00:33:31,000 --> 00:33:34,000
使usr / bin中/，而这一切是什么意思

623
00:33:34,000 --> 00:33:38,000
你可能会被输入usr / bin中/铛铛进入运行，

624
00:33:38,000 --> 00:33:41,000
但它是一种单调乏味的做到这一点，所以一些文件夹

625
00:33:41,000 --> 00:33:44,000
像usr / bin和垃圾桶都被假定为默认值

626
00:33:44,000 --> 00:33:50,000
这样，计算机就知道给你看。

627
00:33:50,000 --> 00:33:53,000
写一个超级，超级简单的Hello World程序的任何问题

628
00:33:53,000 --> 00:33:55,000
在PHP中，然后运行它呢？

629
00:33:55,000 --> 00:33:59,000
因为现在我们将开始推出更具吸引力的语法。

630
00:33:59,000 --> 00:34:01,000
好吧，我们开始吧。

631
00:34:01,000 --> 00:34:03,000
这些计划中，我们实际上已经看到了，所有的人前。

632
00:34:03,000 --> 00:34:07,000
>> 如果我打开了，例如，让我们做beer1.php，

633
00:34:07,000 --> 00:34:09,000
我们不会去通过几个版本的，但我做了什么

634
00:34:09,000 --> 00:34:13,000
我坐了下来浇或转换

635
00:34:13,000 --> 00:34:15,000
我的C代码PHP代码。

636
00:34:15,000 --> 00:34:18,000
大部分的顶部的文件是留下在这里。

637
00:34:18,000 --> 00:34:20,000
原来，有一个新的功能，我们需要调用的ReadLine。

638
00:34:20,000 --> 00:34:23,000
GetString的，回想一下，从0周开始，一个CS50事情。

639
00:34:23,000 --> 00:34:27,000
PHP中有其自己的用户友好的功能的ReadLine

640
00:34:27,000 --> 00:34:30,000
需要1个参数，该参数指定的提示

641
00:34:30,000 --> 00:34:33,000
要显示给用户，和什么的readline

642
00:34:33,000 --> 00:34:35,000
它返回任何用户键入的

643
00:34:35,000 --> 00:34:39,000
在这种情况下，我声明了一个变量名为$ N。

644
00:34:39,000 --> 00:34:42,000
我存储在它的返回值的ReadLine

645
00:34:42,000 --> 00:34:44,000
后提示用户使用此字符串。

646
00:34:44,000 --> 00:34:47,000
只要备份，以实际运行这件事情，让我继续前进

647
00:34:47,000 --> 00:34:50,000
并运行php beer1.php。

648
00:34:50,000 --> 00:34:53,000
会有多少瓶？让我们只是做这一次。

649
00:34:53,000 --> 00:34:55,000
输入。这就是全部。

650
00:34:55,000 --> 00:34:59,000
>> 从数周前的C版本的程序在功能上是相同的。

651
00:34:59,000 --> 00:35:01,000
但语法让我们来看看有什么不同。

652
00:35:01,000 --> 00:35:05,000
之后，我得到一个int从用户的通知，我做了一些错误检查，

653
00:35:05,000 --> 00:35:08,000
如果n小于1，我退出，我打印出来

654
00:35:08,000 --> 00:35:11,000
一个遗憾的消息给用户，并在退出时1。

655
00:35:11,000 --> 00:35:13,000
这也是有一点不同。

656
00:35:13,000 --> 00:35:16,000
 在C语言中我们做了什么？在C语言中，我们返回1。

657
00:35:16,000 --> 00:35:20,000
在PHP中退出，1，坦率地说，我认为一个更直观一点

658
00:35:20,000 --> 00:35:22,000
因为你从字面上退出程序。

659
00:35:22,000 --> 00:35:25,000
好吧，然后在这里讨厌的歌曲是相同的语法

660
00:35:25,000 --> 00:35:29,000
除了变量，这样下来在这里24日起

661
00:35:29,000 --> 00:35:31,000
注意到我的for循环几乎是相同的，

662
00:35:31,000 --> 00:35:34,000
但我在前面的i和n，

663
00:35:34,000 --> 00:35:37,000
什么也缺少从第26行，我们已经在过去

664
00:35:37,000 --> 00:35:39,000
声明变量时我吗？

665
00:35:39,000 --> 00:35:41,000
有没有类型。

666
00:35:41,000 --> 00:35:43,000
这是不正确的PHP说诠释。

667
00:35:43,000 --> 00:35:45,000
你根本不需要做到这一点。

668
00:35:45,000 --> 00:35:48,000
计算机，解释PHP是明智地意识到

669
00:35:48,000 --> 00:35:51,000
如果你把一些在我会把它

670
00:35:51,000 --> 00:35:53,000
你的号。

671
00:35:53,000 --> 00:35:57,000
再往下这里我们插在我，我，我 -  1。

672
00:35:57,000 --> 00:36:00,000
所有这一切都是一样的，然后在这里做了一个“哇，这是恼人的”printf

673
00:36:00,000 --> 00:36:02,000
然后退出（0）。

674
00:36:02,000 --> 00:36:05,000
>> 同样，这里的外卖是，即使我们要花费比较

675
00:36:05,000 --> 00:36:09,000
PHP的一点时间，肯定对我们所做的对C，

676
00:36:09,000 --> 00:36:12,000
这几乎是一样的，所以我们要做的今天和下周

677
00:36:12,000 --> 00:36:14,000
超越是真正关注一些新的想法。

678
00:36:14,000 --> 00:36:17,000
刚才看到另一件事情并翻译从C，

679
00:36:17,000 --> 00:36:20,000
这是一个超级简单的程序，我们在第1周

680
00:36:20,000 --> 00:36:22,000
或2的立方的值。

681
00:36:22,000 --> 00:36:25,000
但是，什么是这个程序的时间大约是有趣的，它

682
00:36:25,000 --> 00:36:28,000
介绍了一个自定义的函数的概念，我们自己写的。

683
00:36:28,000 --> 00:36:31,000
PHP中的语法几乎是相同的。

684
00:36:31,000 --> 00:36:33,000
下面是我的程序往上顶。

685
00:36:33,000 --> 00:36:35,000
请再次缺席是主任何概念。

686
00:36:35,000 --> 00:36:39,000
我开始编写代码，这是要被执行的解释。

687
00:36:39,000 --> 00:36:42,000
我打印出x为2，据推测。

688
00:36:42,000 --> 00:36:44,000
然后，我要求刺...

689
00:36:44,000 --> 00:36:47,000
然后，我所说的多维数据集函数，并通过在$ X

690
00:36:47,000 --> 00:36:50,000
的返回值分配给$ x。

691
00:36:50,000 --> 00:36:53,000
然后，我要求它的立方，然后我这样说，它希望

692
00:36:53,000 --> 00:36:55,000
会说x是8。

693
00:36:55,000 --> 00:36:59,000
PHP中的函数的语法是以往任何时候都略有不同。

694
00:36:59,000 --> 00:37:01,000
再次失踪的返回类型。

695
00:37:01,000 --> 00:37:05,000
再次失踪的返回类型，还缺少什么其他类型吗？

696
00:37:05,000 --> 00:37:07,000
[听不见的学生反应]

697
00:37:07,000 --> 00:37:10,000
好吧，好吧，这是很好的。让我们回到在第二。

698
00:37:10,000 --> 00:37:12,000
>> 我们不具备的，例如int在这里。

699
00:37:12,000 --> 00:37:15,000
例如，我们不有int，又因为在这里，在PHP

700
00:37:15,000 --> 00:37:18,000
你根本就没有必要，不应该这样做，

701
00:37:18,000 --> 00:37:20,000
而是有一个新的关键字调用的函数。

702
00:37:20,000 --> 00:37:23,000
在PHP中，它几乎是一个更清楚一点，因为当你想要一个函数

703
00:37:23,000 --> 00:37:26,000
你从字面上说功能时，你给它一个名字，然后以逗号分隔的列表

704
00:37:26,000 --> 00:37:28,000
如果它的任何参数。

705
00:37:28,000 --> 00:37:32,000
不用说无效或类似的东西，然后返回是一样的，

706
00:37:32,000 --> 00:37:35,000
$ * $ * $。

707
00:37:35,000 --> 00:37:38,000
什么也没有？森指出这一点在这里。

708
00:37:38,000 --> 00:37:43,000
在完全没有在PHP文件的顶部是一个原型。

709
00:37:43,000 --> 00:37:45,000
这也是设计。

710
00:37:45,000 --> 00:37:48,000
PHP等语言和口译更聪明比C是

711
00:37:48,000 --> 00:37:50,000
像铿锵的编译器。

712
00:37:50,000 --> 00:37:53,000
>> 回想一下，铛，如果你不告诉它的立方体存在，

713
00:37:53,000 --> 00:37:56,000
如果你不告诉它输出的原型存在

714
00:37:56,000 --> 00:38:00,000
或使用的＃include，好了，这是要骂你的，而不是编译你的代码。

715
00:38:00,000 --> 00:38:03,000
PHP和更现代的语言有很多聪明的，当它涉及到这一点。

716
00:38:03,000 --> 00:38:07,000
他们将承担起自己阅读你的代码

717
00:38:07,000 --> 00:38:11,000
然后骂你的，只有当它发现立方体无处。

718
00:38:11,000 --> 00:38:15,000
它并不重要，如果立方体是在底部或顶部，或什至在一些单独的文件中。

719
00:38:15,000 --> 00:38:18,000
PHP和类似的语言足够聪明，现在，放眼未来

720
00:38:18,000 --> 00:38:26,000
在之前的所有字句认为你犯了一个错误。

721
00:38:26,000 --> 00:38:28,000
在什么地方离开我们吗？

722
00:38:28,000 --> 00:38:32,000
>> 让我们做最后一个例子，这里的条件下，

723
00:38:32,000 --> 00:38:35,000
如果我打开了conditions2.php通知

724
00:38:35,000 --> 00:38:37,000
语法在这里几乎是相同的。

725
00:38:37,000 --> 00:38:40,000
我使用readline，而不是GetString的，但该行是一样的，

726
00:38:40,000 --> 00:38:42,000
“我想请一个整数。”

727
00:38:42,000 --> 00:38:45,000
然后，我有一个if条件，否则的话，然后一个else，

728
00:38:45,000 --> 00:38:48,000
但在功能上，这个程序也是相同的，我们所做的几个星期前，

729
00:38:48,000 --> 00:38:51,000
所以，如果我遇到这件事情，php的conditions2，

730
00:38:51,000 --> 00:38:54,000
我给它一些像23  - 

731
00:38:54,000 --> 00:38:57,000
我选了个正数。如果我给它-1我挑了负数。

732
00:38:57,000 --> 00:39:00,000
如果我给它0我确实拿起0。

733
00:39:00,000 --> 00:39:02,000
那么，谁在乎这一切吗？

734
00:39:02,000 --> 00:39:06,000
好了，其中一个在这里练习的乐趣排序

735
00:39:06,000 --> 00:39:10,000
至少对我来说是回去看看的速度有多快，我可以实现的pset 5，

736
00:39:10,000 --> 00:39:12,000
拼写错误pset中。

737
00:39:12,000 --> 00:39:15,000
回想一下，有这称为speller.c的文件，

738
00:39:15,000 --> 00:39:17,000
有一个名为dictionary.c。

739
00:39:17,000 --> 00:39:20,000
我所做的是我种的花了几分钟，我的C代码转换

740
00:39:20,000 --> 00:39:23,000
PHP代码，我们不会花太多时间在拼写检查

741
00:39:23,000 --> 00:39:26,000
因为就像在pset中，你也没有真正需要

742
00:39:26,000 --> 00:39:29,000
拼写检查器本身上花太多的时间，因为你的注意力都集中在词典。

743
00:39:29,000 --> 00:39:32,000
>> 我只想说，如果你读通过的拼写，

744
00:39:32,000 --> 00:39:35,000
这个文件在这里，这几乎是等价的C代码

745
00:39:35,000 --> 00:39:37,000
我们给你的pset 5。

746
00:39:37,000 --> 00:39:39,000
我只是增加了一些的地方。

747
00:39:39,000 --> 00:39:43,000
我已经改变了某些函数名，如果他们不存在于PHP。

748
00:39:43,000 --> 00:39:45,000
这里还有一个额外的东西，preg_match，

749
00:39:45,000 --> 00:39:48,000
这是一个小票友的做事方式，但我们会回来的，最终。

750
00:39:48,000 --> 00:39:51,000
但在短期，拼写检查器是几乎相同的，如果你看的最下方

751
00:39:51,000 --> 00:39:54,000
它最终吐出的是，在这里，

752
00:39:54,000 --> 00:39:57,000
拼写错误的词，词语的词典，词汇文本。

753
00:39:57,000 --> 00:40:00,000
好了，现在有什么有趣的是下面的。

754
00:40:00,000 --> 00:40:05,000
在我的文件顶部的，我要求dictionary.php。

755
00:40:05,000 --> 00:40:09,000
正如C＃PHP有一个特殊的函数调用需要

756
00:40:09,000 --> 00:40:14,000
这几乎做同样的事情，需要一个名为dictionary.php。

757
00:40:14,000 --> 00:40:18,000
我该如何去实施的pset 5？

758
00:40:18,000 --> 00:40:21,000
让我继续前进，在这里打开了一个文件。

759
00:40:21,000 --> 00:40:24,000
让我在这里需要一点参考。

760
00:40:24,000 --> 00:40:29,000
让我创建一​​个新的文件，并开始调用此dictionary.php。

761
00:40:29,000 --> 00:40:31,000
让我把它放在另一个文件夹，所以我们可以做这个活。

762
00:40:31,000 --> 00:40:33,000
我现在就放大。

763
00:40:33,000 --> 00:40:37,000
我要开始我的PHP文件，开放式支架PHP关闭支架。

764
00:40:37,000 --> 00:40:40,000
然后在这里有几个功能，我需要实现的pset 5，

765
00:40:40,000 --> 00:40:42,000
所以让我开始实施其中的一些，

766
00:40:42,000 --> 00:40:47,000
功能检查，其中有一个字作为参数。

767
00:40:47,000 --> 00:40:49,000
我们将做到这一点，它在某一时刻回来。

768
00:40:49,000 --> 00:40:53,000
>> 函数作为参数，负载了什么？

769
00:40:53,000 --> 00:40:56,000
字典，所以，我其实是想加载的文件。

770
00:40:56,000 --> 00:41:00,000
有功能的大小，但不带任何参数

771
00:41:00,000 --> 00:41:04,000
有功能是什么其他的吗？

772
00:41:04,000 --> 00:41:06,000
卸载，不带任何参数。

773
00:41:06,000 --> 00:41:10,000
这是4，我需要的功能，现在在PHP中实现，

774
00:41:10,000 --> 00:41:13,000
我什么都做的是继续这样做。

775
00:41:13,000 --> 00:41:16,000
很多你使用一个哈希表中的pset 5，

776
00:41:16,000 --> 00:41:21,000
所以，让我继续前进，在PHP中创建一个哈希表。

777
00:41:21,000 --> 00:41:23,000
完成。

778
00:41:23,000 --> 00:41:25,000
这给了我一个哈希表。好了，为什么呢？

779
00:41:25,000 --> 00:41:30,000
一，变量名为$表，只是想起了一个哈希表的想法。

780
00:41:30,000 --> 00:41:34,000
不过，方括号，记得，代表什么？

781
00:41:34,000 --> 00:41:37,000
一个数组，但是在PHP数组不具有数字索引。

782
00:41:37,000 --> 00:41:41,000
它们也可以是关联数组，

783
00:41:41,000 --> 00:41:44,000
这意味着你可以有任意键和值。

784
00:41:44,000 --> 00:41:49,000
>> 就像在pset的，那些你谁做到了哈希表的实现

785
00:41:49,000 --> 00:41:53,000
你可能插入的字，然后将其插入链表链，

786
00:41:53,000 --> 00:41:56,000
或者你存储的价值，真正的某个地方或东西的效果。

787
00:41:56,000 --> 00:41:59,000
你莫名其妙地想起了事实，这个词是有。

788
00:41:59,000 --> 00:42:01,000
就目前而言，那将是我的哈希表，

789
00:42:01,000 --> 00:42:06,000
所以现在去实施检查功能，

790
00:42:06,000 --> 00:42:09,000
我只需要看看里面的那个哈希表

791
00:42:09,000 --> 00:42:11,000
如果有一个字是有。

792
00:42:11,000 --> 00:42:15,000
我要的是我说的话，

793
00:42:15,000 --> 00:42:20,000
让我们使用isset，这是一个PHP函数，从字面上的意思只是说是关键的设置，

794
00:42:20,000 --> 00:42:24,000
所以使用isset（$ [$字]

795
00:42:24,000 --> 00:42:29,000
如果是的话返回true。

796
00:42:29,000 --> 00:42:32,000
就是这样。这是pset的PHP 5中。

797
00:42:32,000 --> 00:42:34,000
那么，在公平，好吧。

798
00:42:34,000 --> 00:42:37,000
否则返回false，所以它不存在。

799
00:42:37,000 --> 00:42:39,000
到底发生了什么吗？

800
00:42:39,000 --> 00:42:42,000
好了，如果表或哈希表一般

801
00:42:42,000 --> 00:42:46,000
是一个关联数组，这意味着你可以索引

802
00:42:46,000 --> 00:42:50,000
用一个词像“字，”你要回去一定的价值。

803
00:42:50,000 --> 00:42:52,000
>> 我们是种让自己领先一步。

804
00:42:52,000 --> 00:42:56,000
这将是一种不错的，如果我们实际加载的文件的第一个，

805
00:42:56,000 --> 00:42:58,000
所以负载是不是很简单，但让我继续前进，掀起

806
00:42:58,000 --> 00:43:00,000
 一个真正快速实现负载。

807
00:43:00,000 --> 00:43:07,000
让我继续前进，说的话获取文件字典。

808
00:43:07,000 --> 00:43:10,000
在PHP中打开一个文件，该文件的功能

809
00:43:10,000 --> 00:43:12,000
并返回给你一个数组在该文件中的所有的话，

810
00:43:12,000 --> 00:43:14,000
只是手给你。

811
00:43:14,000 --> 00:43:16,000
这是一个很大的痛苦，不是吗？

812
00:43:16,000 --> 00:43:21,000
现在的foreach，这是我们的新的结构时，foreach（$美元的字的话）。

813
00:43:21,000 --> 00:43:25,000
要开始这个循环遍历数组的话

814
00:43:25,000 --> 00:43:30,000
并分配给变量$字在文件中的每个字

815
00:43:30,000 --> 00:43:32,000
从第一到第二至第三到第四的所有方式

816
00:43:32,000 --> 00:43:35,000
所以我没有做恼人的[]符号等。

817
00:43:35,000 --> 00:43:38,000
我简单地做了这些字

818
00:43:38,000 --> 00:43:43,000
是我的表，它存储在索引到表

819
00:43:43,000 --> 00:43:47,000
，然后做真实的，因为要记住

820
00:43:47,000 --> 00:43:50,000
一个字是在我的字典里，所有我真正要做的

821
00:43:50,000 --> 00:43:55,000
种翻转了一下，说这个词在我的哈希表是存在的，真实的。

822
00:43:55,000 --> 00:43:58,000
如果它不存在，我没有明确地把假，

823
00:43:58,000 --> 00:44:01,000
否则，在宇宙中所有可能的话，我不得不把假。

824
00:44:01,000 --> 00:44:05,000
>> 总之，对我来说只是设置了索引值

825
00:44:05,000 --> 00:44:09,000
如果有一个字实际上是在我的哈希表。

826
00:44:09,000 --> 00:44:12,000
现在，我切割的角落，在这里，我要挥挥手，现在，

827
00:44:12,000 --> 00:44:15,000
但现在负载的功能就完成了。

828
00:44:15,000 --> 00:44:18,000
我到一个数组中，从文件中加载所有的话。

829
00:44:18,000 --> 00:44:21,000
我遍历超过该阵列，阵列中的每个单词

830
00:44:21,000 --> 00:44:24,000
我将它插入我的哈希表的一行代码。

831
00:44:24,000 --> 00:44:26,000
这很有趣。你知道我们现在可以实现规模吗？

832
00:44:26,000 --> 00:44:28,000
，大小总是很容易的，公平的。

833
00:44:28,000 --> 00:44:32,000
在这里，我们就可以返回计数表。

834
00:44:32,000 --> 00:44:34,000
这是很容易的事情，数一数，在表中。

835
00:44:34,000 --> 00:44:36,000
这实际上是一种不是最有效的。

836
00:44:36,000 --> 00:44:39,000
我也许应该有一个变量的大小，因此，我们可以做到这一点

837
00:44:39,000 --> 00:44:41,000
在固定的时间，但是这是很容易的。

838
00:44:41,000 --> 00:44:45,000
哦，然后卸载，如果我们真正想要的是肛门

839
00:44:45,000 --> 00:44:47,000
我们可以说，这就是你如何卸载的东西。

840
00:44:47,000 --> 00:44:49,000
你刚才设置的变量等于一个空数组，

841
00:44:49,000 --> 00:44:51,000
和摆脱一切有。

842
00:44:51,000 --> 00:44:53,000
无需拨打免费。

843
00:44:53,000 --> 00:44:56,000
>> 同样，我已经削减了一些角落，和我道歉分配问题集

844
00:44:56,000 --> 00:45:00,000
也许在C，但如果我们现在去继续运行，

845
00:45:00,000 --> 00:45:02,000
我要以实际运行的版本，我写了提前

846
00:45:02,000 --> 00:45:05,000
只是让我没有做任何任何语法错误。

847
00:45:05,000 --> 00:45:08,000
让我继续运行拼写检查器。的使用是相同的。

848
00:45:08,000 --> 00:45:12,000
这是一本字典文件，该文件只包含单词富。

849
00:45:12,000 --> 00:45:15,000
这里是一个文本文件，其中只包含foo的酒吧。

850
00:45:15,000 --> 00:45:19,000
让我们这一点，所以拼写检查拼写检查，使用这本字典文件，这个文本文件。

851
00:45:19,000 --> 00:45:21,000
有拼写错误的单词，酒吧，和瞧。

852
00:45:21,000 --> 00:45:23,000
完成的pset 5。

853
00:45:23,000 --> 00:45:30,000
在这里，让我们有5分钟的休息时间，我们会回来更多的PHP。

854
00:45:30,000 --> 00:45:32,000
好了，我们又回来了。

855
00:45:32,000 --> 00:45:34,000
让我们不恨我了一会儿。

856
00:45:34,000 --> 00:45:37,000
现在让我们来看看这是不是一个积极的

857
00:45:37,000 --> 00:45:39,000
这件事在实际执行PHP。

858
00:45:39,000 --> 00:45:43,000
当然，它花了45秒来实现。

859
00:45:43,000 --> 00:45:45,000
>> 但是，让我们继续和运行的东西。

860
00:45:45,000 --> 00:45:49,000
让我继续运行的C版本

861
00:45:49,000 --> 00:45:52,000
拼写检查，和我们将上运行它的一个最大的文件，

862
00:45:52,000 --> 00:45:54,000
这是国王詹姆斯圣经。

863
00:45:54,000 --> 00:45:57,000
这里是在让我们进入我们的C文件夹，

864
00:45:57,000 --> 00:46:01,000
国王詹姆斯第5的拼写上。

865
00:46:01,000 --> 00:46:03,000
很多拼写错误的单词。

866
00:46:03,000 --> 00:46:06,000
好的，那么你很可能得了即使有一点不同的输出，

867
00:46:06,000 --> 00:46:09,000
如果你把一切都正常工作，所以总的时间进行拼写检查

868
00:46:09,000 --> 00:46:13,000
在国王詹姆斯圣经“是0.38秒，相当不错的，所以使用该实现。

869
00:46:13,000 --> 00:46:16,000
现在让我到PHP版本，这是我们刚写。

870
00:46:16,000 --> 00:46:18,000
让我跑的拼写国王詹姆斯。

871
00:46:18,000 --> 00:46:21,000
哎呀，忽略这个错误。我在错误的目录。

872
00:46:21,000 --> 00:46:24,000
国王詹姆斯第5的拼写上。

873
00:46:46,000 --> 00:46:48,000
差不多完成了。

874
00:46:48,000 --> 00:46:51,000
>> 好了，精明的观察者会意识到这是3秒以上，有。

875
00:46:51,000 --> 00:46:54,000
这是真实的运行时间。

876
00:46:54,000 --> 00:46:58,000
事实证明，它需要时间来吐了大量的文字

877
00:46:58,000 --> 00:47:00,000
由于缓冲的问题，但长话短说，

878
00:47:00,000 --> 00:47:04,000
的加工时间为3.15秒，CPU时间，

879
00:47:04,000 --> 00:47:07,000
与刚才又是什么呢？

880
00:47:07,000 --> 00:47:09,000
像0.3。

881
00:47:09,000 --> 00:47:11,000
我的意思是，这是一个数量级的速度较慢，所以在哪里

882
00:47:11,000 --> 00:47:14,000
可笑的放缓从哪里来的呢？

883
00:47:14,000 --> 00:47:17,000
好了，因为一直的情况下，几乎所有的设计决定，我们已经取得了

884
00:47:17,000 --> 00:47:21,000
在过去9周中的类几乎总是权衡。

885
00:47:21,000 --> 00:47:24,000
有时候之间，有时只是空间之间的空间和时间，

886
00:47:24,000 --> 00:47:27,000
空间，时间和开发工作，并确实在这里，即使

887
00:47:27,000 --> 00:47:31,000
我们节省了大量的时间，可能有潜在10-20-30小时

888
00:47:31,000 --> 00:47:34,000
实施拼写检查器的开发时间

889
00:47:34,000 --> 00:47:36,000
通过鞭打，这种语言在短短45秒

890
00:47:36,000 --> 00:47:40,000
我们付出的代价是，它是慢了一个数量级，

891
00:47:40,000 --> 00:47:43,000
这是一般的情况下与大多数任何解释语言，

892
00:47:43,000 --> 00:47:46,000
PHP，Python和红宝石，珍珠或其他人据此

893
00:47:46,000 --> 00:47:49,000
如果你要运行它通过翻译和阅读你的代码

894
00:47:49,000 --> 00:47:52,000
一行行，从上到下，从左到右，

895
00:47:52,000 --> 00:47:55,000
，中间人会采取一些自己的时间，

896
00:47:55,000 --> 00:47:59,000
和你的感受是什么在3秒到0.3秒，而不是

897
00:47:59,000 --> 00:48:02,000
是的事实，这是中间人，从字面上理解我们的代码

898
00:48:02,000 --> 00:48:05,000
一行行，但愿，如果你是内循环

899
00:48:05,000 --> 00:48:08,000
一个巨大的文件，其中包含数十万字。

900
00:48:08,000 --> 00:48:11,000
>> 的开销加起来，加起来，加起来，并添加了。

901
00:48:11,000 --> 00:48:16,000
对于这样一个工具，它可能不是最好的语言，使用的实施

902
00:48:16,000 --> 00:48:20,000
如果直接是一个拼写检查您的用户和你的兴趣。

903
00:48:20,000 --> 00:48:23,000
但我们在某一时刻的奢侈品是，如果你

904
00:48:23,000 --> 00:48:27,000
使用的语言，如PHP或有很多解释型语言

905
00:48:27,000 --> 00:48:30,000
在网络的背景下，对于这个问题，你有益处

906
00:48:30,000 --> 00:48:34,000
互联网是比大多数的电脑慢了很多。

907
00:48:34,000 --> 00:48:38,000
您有在您的计算机上，2 GHz时，甚至更多，这些天GHz的CPU。

908
00:48:38,000 --> 00:48:41,000
但现实情况是，在互联网上有一个高的延迟量

909
00:48:41,000 --> 00:48:45,000
由此，对于浏览器到服务器，即使我们看到上周

910
00:48:45,000 --> 00:48:47,000
这是相当快的，一毫秒的一半左右，

911
00:48:47,000 --> 00:48:51,000
也增加了，而如果你下载的东西，如图像

912
00:48:51,000 --> 00:48:54,000
或Facebook的照片或即时消息，Facebook的喋喋不休，

913
00:48:54,000 --> 00:48:57,000
的Gchat或类似，所有的往返时间

914
00:48:57,000 --> 00:49:00,000
之间的浏览器和服务器开始增加，

915
00:49:00,000 --> 00:49:03,000
这使得在许多情况下，您的特定选择的语言

916
00:49:03,000 --> 00:49:07,000
不是所有的相关的，因此你使用一个稍微慢的语言

917
00:49:07,000 --> 00:49:10,000
如PHP或Python或Ruby

918
00:49:10,000 --> 00:49:13,000
但有巨大的积极给您和您的同事

919
00:49:13,000 --> 00:49:17,000
和你的朋友，因为你可以实现的事情，所以，如此之快。

920
00:49:17,000 --> 00:49:20,000
此外，你有一定的安全缺陷的风险要少得多。

921
00:49:20,000 --> 00:49:22,000
在PHP中有没有指针。

922
00:49:22,000 --> 00:49:25,000
段有没有故障，你可以很容易地诱发

923
00:49:25,000 --> 00:49:27,000
以同样的方式，你可以在C.

924
00:49:27,000 --> 00:49:29,000
C，你是超级的硬件。

925
00:49:29,000 --> 00:49:33,000
使用PHP和类似的语言，你是那种水平的提高，可以这么说，

926
00:49:33,000 --> 00:49:37,000
你和什么之间有很多的防御实际上是怎么回事

927
00:49:37,000 --> 00:49:39,000
在机器内部，它只是一个折衷。

928
00:49:39,000 --> 00:49:42,000
>> 我们已经得到的地步，这些更现代化的，高层次的语言

929
00:49:42,000 --> 00:49:47,000
像PHP，因为吸取的经验教训的语言，如PHP C.

930
00:49:47,000 --> 00:49:50,000
但是，如果你不明白什么已经持续引擎盖下的所有时间

931
00:49:50,000 --> 00:49:53,000
你肯定不能做出正确的设计决策，

932
00:49:53,000 --> 00:49:56,000
当然，当它涉及到像Facebook或谷歌在一个地方工作

933
00:49:56,000 --> 00:49:59,000
这些地方是越来越大的数据集

934
00:49:59,000 --> 00:50:01,000
即使你回去做医学预科，并正与一些MD

935
00:50:01,000 --> 00:50:04,000
在一些大的数据集，涉及患者和医生

936
00:50:04,000 --> 00:50:08,000
如使用正确的工具是巨大的令人信服的

937
00:50:08,000 --> 00:50:11,000
，否则你分析一些数据集可能需要几秒钟，

938
00:50:11,000 --> 00:50:14,000
或者它可能从字面上需要几个小时。

939
00:50:14,000 --> 00:50:17,000
这仅仅是一个例子，而不是阻挠你多少的努力，

940
00:50:17,000 --> 00:50:21,000
这是在C，但帮助您了解，当你实现的东西在C

941
00:50:21,000 --> 00:50:24,000
你真的理解，或在理论上，真正了解

942
00:50:24,000 --> 00:50:28,000
如何一切都应该工作，你几乎完全控制

943
00:50:28,000 --> 00:50:31,000
这是怎么回事引擎盖下的，并与这些高层次的语言

944
00:50:31,000 --> 00:50:34,000
你必须放弃更多的控制权的人，是谁发明的

945
00:50:34,000 --> 00:50:37,000
，并受到他们的设计决策比你。

946
00:50:37,000 --> 00:50:41,000
但是，如果我们想当然地认为表现

947
00:50:41,000 --> 00:50:44,000
是不是很重要的，因为这些问题在网络上，

948
00:50:44,000 --> 00:50:47,000
只是网络速度比CPU的速度慢一点，无论如何，

949
00:50:47,000 --> 00:50:50,000
所以我们可以排序，用得起一个稍微慢的语言

950
00:50:50,000 --> 00:50:55,000
如果有利的一面是，我们可以开发的东西10倍的速度或什至更多。

951
00:50:55,000 --> 00:50:57,000
>> 让我们来看看如何，我们就可以开始使用。

952
00:50:57,000 --> 00:51:00,000
让我去到一个文件夹

953
00:51:00,000 --> 00:51:03,000
在今天的例子称为frosh.ims，

954
00:51:03,000 --> 00:51:06,000
这实际上是亲自动机的第一件事的事实，即

955
00:51:06,000 --> 00:51:10,000
我写的Web年前后，CS50和CS51

956
00:51:10,000 --> 00:51:14,000
是一个网站的大一IMS程序，大一学生校内运动，

957
00:51:14,000 --> 00:51:16,000
这在当时，这是足以年前，当时

958
00:51:16,000 --> 00:51:19,000
有没有网站的程序，即使是一个网络，

959
00:51:19,000 --> 00:51:22,000
取而代之的是一个值日生威格尔斯沃据此，如果你想

960
00:51:22,000 --> 00:51:26,000
注册排球或足球或任何你填写一张纸。

961
00:51:26,000 --> 00:51:28,000
然后，您可以步行穿过院子。

962
00:51:28,000 --> 00:51:31,000
在他们的门或监考官的手，然后，你会敲他们的门和幻灯片

963
00:51:31,000 --> 00:51:34,000
在一张纸上，你的名字就可以了，你是否想成为一个球队的队长，

964
00:51:34,000 --> 00:51:37,000
你你想要做什么运动，什么宿舍英寸

965
00:51:37,000 --> 00:51:39,000
这是一个老同学的做事方式，这是一个主要

966
00:51:39,000 --> 00:51:41,000
自动化这个过程中有很多的机会。

967
00:51:41,000 --> 00:51:43,000
你刚才去的网站。您键入的东西英寸

968
00:51:43,000 --> 00:51:46,000
您会收到一封电子邮件，确认和繁荣，就大功告成了。

969
00:51:46,000 --> 00:51:49,000
>> 这是我做的第一件事，虽然在语言，称为珍珠，

970
00:51:49,000 --> 00:51:52,000
但它是比较容易做的PHP，这是形式的代表

971
00:51:52,000 --> 00:51:55,000
的问题，你就可以开始解决时，你可以表达自己的

972
00:51:55,000 --> 00:51:58,000
编程和没有依靠的东西，如谷歌网站

973
00:51:58,000 --> 00:52:01,000
或Excel或工具，就交给你了。

974
00:52:01,000 --> 00:52:03,000
你们现在有能力做这样的事情。

975
00:52:03,000 --> 00:52:06,000
这是一个超级丑陋的版本的一种形式，

976
00:52:06,000 --> 00:52:09,000
但让我们只用它的谈话，这是开始

977
00:52:09,000 --> 00:52:12,000
大概什么形式看起来就像几年前，我们

978
00:52:12,000 --> 00:52:14,000
使人们在网站上注册为大一IMS。

979
00:52:14,000 --> 00:52:18,000
我们要求一个名字，一个复选框，他们是否想当队长，

980
00:52:18,000 --> 00:52:21,000
男或女的，然后他们在什么宿舍，

981
00:52:21,000 --> 00:52:23,000
然后，他们将提交本表格。

982
00:52:23,000 --> 00:52:27,000
让我们先来看看下面的罩在表示这个网页的HTML。

983
00:52:27,000 --> 00:52:31,000
让我进入froshims0，

984
00:52:31,000 --> 00:52:35,000
顺便说一句，pset中7，我考虑是理所当然的

985
00:52:35,000 --> 00:52:37,000
我把事情英寸的目录和文件夹

986
00:52:37,000 --> 00:52:40,000
我们将引导您完成的确切位置飘然而至，在家电，

987
00:52:40,000 --> 00:52:43,000
国防部的命令，你必须运行的，所以不要担心所有的

988
00:52:43,000 --> 00:52:46,000
愚蠢的详细信息同步，从一开始就在这里。

989
00:52:46,000 --> 00:52:49,000
>> 好吧，这里的froshims0.php的。

990
00:52:49,000 --> 00:52:52,000
让我向下滚动，有什么好奇的，

991
00:52:52,000 --> 00:52:56,000
这是一个PHP文件，但它里面是什么，清楚吗？

992
00:52:56,000 --> 00:52:59,000
这是一个很多的HTML，PHP的起源

993
00:52:59,000 --> 00:53:02,000
真的是一个以网络为中心的语言。

994
00:53:02,000 --> 00:53:04,000
刚才我们用它来实现啤酒的例子，

995
00:53:04,000 --> 00:53:07,000
的条件，例如，你好例如，这很好。

996
00:53:07,000 --> 00:53:11,000
您可以使用PHP作为一种脚本语言

997
00:53:11,000 --> 00:53:15,000
脚本是真的只是一个快速和肮脏的程序给出的术语

998
00:53:15,000 --> 00:53:19,000
什么，你写的脚本或更普遍的一种解释型语言。

999
00:53:19,000 --> 00:53:22,000
PHP是超级有用的，因为你已经看到如何迅速

1000
00:53:22,000 --> 00:53:24,000
比较我们可以掀起的PHP程序。

1001
00:53:24,000 --> 00:53:27,000
但它真正目的是用于Web，

1002
00:53:27,000 --> 00:53:31,000
和设计为Web在某种意义上说，注意到在这里的文件的顶部

1003
00:53:31,000 --> 00:53:34,000
我开始<？PHP。

1004
00:53:34,000 --> 00:53:38,000
然后，我有一堆无用的意见，授予，但后来我关闭PHP模式。

1005
00:53:38,000 --> 00:53:41,000
但后来我下降到HTML模式。

1006
00:53:41,000 --> 00:53:45,000
>> 关于PHP有什么有趣的是，即使文件结束。PHP

1007
00:53:45,000 --> 00:53:48,000
它通常意味着要与HTML混在一起，

1008
00:53:48,000 --> 00:53:50,000
一些PHP代码，一些HTML。

1009
00:53:50,000 --> 00:53:53,000
我们最终会看到，我们就可以开始挑逗那些除了

1010
00:53:53,000 --> 00:53:56,000
，使我们的HTML独立于我们的PHP完全，

1011
00:53:56,000 --> 00:53:59,000
但PHP的起源真的是给你这样的灵活性，

1012
00:53:59,000 --> 00:54:02,000
如果你想一些HTML只写它，将是

1013
00:54:02,000 --> 00:54:04,000
吐出相同的浏览器。

1014
00:54:04,000 --> 00:54:07,000
但是，如果你需要一些编程技术，

1015
00:54:07,000 --> 00:54:12,000
一些编程的代码，你也可以把它变成完全相同的文件，我们很快就会看到。

1016
00:54:12,000 --> 00:54:14,000
这里是我的HTML。

1017
00:54:14,000 --> 00:54:16,000
我有一个标题为大一IMS。

1018
00:54:16,000 --> 00:54:20,000
我有一个body标签谁得到了它一些CSS中心在中间的一切，

1019
00:54:20,000 --> 00:54:23,000
然后在这里我有一个形式，这显然是将要提交

1020
00:54:23,000 --> 00:54:27,000
到一个新的称为register0.php的文件，所以我们会看到，在一个时刻。

1021
00:54:27,000 --> 00:54:31,000
它的使用方法后，我们会回来的，以及。

1022
00:54:31,000 --> 00:54:34,000
然后，我有某种形式的输入，一个所谓的名称，其类型是文本，

1023
00:54:34,000 --> 00:54:37,000
他的名字是队长，其类型是“复选框，

1024
00:54:37,000 --> 00:54:40,000
这一点，我们没有看到它之前，但它到底是什么说的。

1025
00:54:40,000 --> 00:54:42,000
你会得到一个复选框，而不是一个文本框。

1026
00:54:42,000 --> 00:54:46,000
在这里，你有一个单选按钮，这是那些圆形按钮

1027
00:54:46,000 --> 00:54:48,000
你可以选择这一个或那一个。

1028
00:54:48,000 --> 00:54:52,000
>> 请注意，这是故意的，我给了两个单选按钮的名称，性别。

1029
00:54:52,000 --> 00:54:55,000
这是你如何相互排斥，你必须按一下

1030
00:54:55,000 --> 00:54:58,000
无论是这一个或那一个，并点击

1031
00:54:58,000 --> 00:55:01,000
取消选中，所以你必须给他们同样的名称

1032
00:55:01,000 --> 00:55:03,000
如果你想它们是相互排斥的那样。

1033
00:55:03,000 --> 00:55:07,000
然后宿舍，我不认为我们已经看到了这一点，但它是一个选择菜单，下拉菜单中。

1034
00:55:07,000 --> 00:55:09,000
因为这是选择的标签。

1035
00:55:09,000 --> 00:55:11,000
然后，您可以在下拉菜单的名称，

1036
00:55:11,000 --> 00:55:13,000
然后你有一大堆的这些选项。

1037
00:55:13,000 --> 00:55:16,000
第一个，只是为了美观，是一个空字符串。

1038
00:55:16,000 --> 00:55:20,000
我只是想下拉列表中，默认情况下是空白的，

1039
00:55:20,000 --> 00:55:22,000
，然后有Apley，卡纳迪，灰色，等等。

1040
00:55:22,000 --> 00:55:24,000
注意到这里的二分法。

1041
00:55:24,000 --> 00:55:27,000
在下拉式菜单中的选项下有一个值，

1042
00:55:27,000 --> 00:55:30,000
但然后它有一个人类友好的名称，在该示例中

1043
00:55:30,000 --> 00:55:33,000
是相同的，但如果我们真正想要的是肛门，我们可以有

1044
00:55:33,000 --> 00:55:36,000
这一下降的价值下降只是短期的版本，

1045
00:55:36,000 --> 00:55:39,000
灰色，但我们真的可以说，人类的灰色厅实际看到的，

1046
00:55:39,000 --> 00:55:43,000
但不是所有的有趣，所以我只是保持简单和他们相同。

1047
00:55:43,000 --> 00:55:46,000
接着下来的底部，我们有一个提交按钮

1048
00:55:46,000 --> 00:55:49,000
这是我们见过的，但是请注意我只是给它一个不同的字。

1049
00:55:49,000 --> 00:55:53,000
而不是我给CS50搜索标签“注册”。

1050
00:55:53,000 --> 00:55:56,000
>> 最终的结果是这样的网页，并再次，

1051
00:55:56,000 --> 00:56:00,000
这得到提交？

1052
00:56:00,000 --> 00:56:04,000
它被提交一些文件，这个值的action属性，

1053
00:56:04,000 --> 00:56:07,000
这是register0.php。

1054
00:56:07,000 --> 00:56:09,000
让我们来看看到底发生了什么在这里。

1055
00:56:09,000 --> 00:56:13,000
让我继续前进，填写此表，说大卫，

1056
00:56:13,000 --> 00:56:16,000
男，马修斯，然后我会说注册。

1057
00:56:16,000 --> 00:56:18,000
让我放大，然后点击注册。

1058
00:56:18,000 --> 00:56:22,000
好了，这样一种无用的，但让我们来看看什么回事。

1059
00:56:22,000 --> 00:56:26,000
请注意，URL更改为register0.php。

1060
00:56:26,000 --> 00:56:34,000
奇怪的是不存在的URL，不过，即使我们只是提出的一种形式吗？

1061
00:56:34,000 --> 00:56:37,000
[听不见的学生反应]

1062
00:56:37,000 --> 00:56:39,000
好吧，这只是Chrome浏览器是用户友好的，这些天。

1063
00:56:39,000 --> 00:56:42,000
这是实际存在的。他们只是将其隐藏以节省空间。

1064
00:56:42,000 --> 00:56:44,000
但是，好的想法，好的想法。

1065
00:56:44,000 --> 00:56:46,000
朝另一端的URL，虽然缺少了什么？是啊。

1066
00:56:46,000 --> 00:56:48,000
[学生]的查询字符串。

1067
00:56:48,000 --> 00:56:51,000
查询字符串，所以记得从简单的谷歌搜索的例子。

1068
00:56:51,000 --> 00:56:54,000
当我点击提交按钮时，URL

1069
00:56:54,000 --> 00:57:00,000
带我去谷歌，但再有就是Q =计算机科学或什么的，我已经输入

1070
00:57:00,000 --> 00:57:04,000
这是因为我们的搜索示例使用GET方法。

1071
00:57:04,000 --> 00:57:06,000
>> 这一次，我们使用的是什么方法，而不是？

1072
00:57:06,000 --> 00:57:10,000
发布，并立即区别之一

1073
00:57:10,000 --> 00:57:14,000
GET和POST之间是后并没有把用户的输入的URL。

1074
00:57:14,000 --> 00:57:16,000
它隐藏它。它仍然将其发送。

1075
00:57:16,000 --> 00:57:19,000
事实上，我们所看到的在这里在浏览器中，我们将揭示在某一时刻

1076
00:57:19,000 --> 00:57:22,000
在寄存器，我只是看到的内容

1077
00:57:22,000 --> 00:57:25,000
的阵列，从浏览器向服务器提交。

1078
00:57:25,000 --> 00:57:29,000
但URL没有？，没有任何关键字

1079
00:57:29,000 --> 00:57:31,000
或在它的值，这是为什么呢？

1080
00:57:31,000 --> 00:57:35,000
好了，后允许您从形式到服务器提交数据，

1081
00:57:35,000 --> 00:57:38,000
但它并没有把它的URL，所以什么样的信息后

1082
00:57:38,000 --> 00:57:41,000
特别适合于也许当你问用户

1083
00:57:41,000 --> 00:57:44,000
输入输入的一种形式吗？

1084
00:57:44,000 --> 00:57:48,000
像密码一样的东西，像什么呢？

1085
00:57:48,000 --> 00:57:50,000
信用卡号码。

1086
00:57:50,000 --> 00:57:53,000
凡是轻度敏感的你可能不希望结束的URL

1087
00:57:53,000 --> 00:57:56,000
如果只是因为它意味着你的室友或家庭成员都可以只是吓吓

1088
00:57:56,000 --> 00:57:59,000
您的互联网历史记录，然后从字面上看您的密码，

1089
00:57:59,000 --> 00:58:02,000
从字面上看您的信用卡号码，因为大多数浏览器

1090
00:58:02,000 --> 00:58:05,000
记得在历史上的任何网址，你已经在

1091
00:58:05,000 --> 00:58:09,000
因此，如果仅仅是因为这将是一个糟糕的主意。

1092
00:58:09,000 --> 00:58:11,000
使用后隐藏，详细的用户。

1093
00:58:11,000 --> 00:58:14,000
>> 此外，如何上传到Facebook的照片吗？

1094
00:58:14,000 --> 00:58:17,000
好了，你真的可以使用的只有2个机制，

1095
00:58:17,000 --> 00:58:21,000
尽管有其他一些更神秘的​​，是GET和POST。

1096
00:58:21,000 --> 00:58:26,000
你怎么可能通过一个URL上传照片吗？

1097
00:58:26,000 --> 00:58:28,000
实际上，你可以做到这一点。

1098
00:58:28,000 --> 00:58:30,000
你可以把一个JPEG或位图或GIF，你可以代表它在十六进制

1099
00:58:30,000 --> 00:58:32,000
或一些所谓的基地64。

1100
00:58:32,000 --> 00:58:35,000
而不是基地16使用基本64，基本上看起来像

1101
00:58:35,000 --> 00:58:38,000
ASCII字符，实际上，你可以通过一个URL上传照片

1102
00:58:38,000 --> 00:58:41,000
后一个问号，但也有一般大小的限制。

1103
00:58:41,000 --> 00:58:44,000
大多数浏览器强制不超过1000个字符的URL，

1104
00:58:44,000 --> 00:58:47,000
也许2000个字符或类似的，所以你不能上传

1105
00:58:47,000 --> 00:58:50,000
10 MB Facebook的照片。

1106
00:58:50,000 --> 00:58:54,000
对，你使用后，现在得到了参数中的URL，

1107
00:58:54,000 --> 00:58:57,000
这是很好的，有用的，有时，但对于任何敏感或大

1108
00:58:57,000 --> 00:58:59,000
后是要走的路。

1109
00:58:59,000 --> 00:59:02,000
什么是寄存器实际上是在这里做什么？

1110
00:59:02,000 --> 00:59:05,000
好吧，如果我打开寄存器的注意，这是一个超级简单的页面，

1111
00:59:05,000 --> 00:59:09,000
但它证明了的事实，我可以混合，或好或坏，

1112
00:59:09,000 --> 00:59:12,000
HTML与PHP。

1113
00:59:12,000 --> 00:59:15,000
这整个文件，除了在顶部的意见，HTML

1114
00:59:15,000 --> 00:59:19,000
除了这家伙在这里。

1115
00:59:19,000 --> 00:59:22,000
>> 请注意，在我的PHP代码中，

1116
00:59:22,000 --> 00:59:26,000
在我的HTML中，我暂时有几分

1117
00:59:26,000 --> 00:59:28,000
进入PHP模式。

1118
00:59:28,000 --> 00:59:31,000
我调用一个特殊的称为印记R的函数。

1119
00:59:31,000 --> 00:59:34,000
这意味着打印递归的，它的作用是递归打印

1120
00:59:34,000 --> 00:59:38,000
任何变量，你把它分号，退出PHP模式。

1121
00:59:38,000 --> 00:59:40,000
和PRE标记为您提供了预先格式化的文本，

1122
00:59:40,000 --> 00:59:43,000
单空间的文字，使每一个空间，你真正看到它。

1123
00:59:43,000 --> 00:59:46,000
它并没有消失。是什么职位？

1124
00:59:46,000 --> 00:59:48,000
那么，什么是有趣的和引人注目的PHP

1125
00:59:48,000 --> 00:59:52,000
是当你提交一个表单使用GET或POST

1126
00:59:52,000 --> 00:59:56,000
任何提交您的浏览器

1127
00:59:56,000 --> 01:00:00,000
PHP本身计算出这些键值对，

1128
01:00:00,000 --> 01:00:02,000
数字，如果有相等的符号，数字，如果有一个问号。

1129
01:00:02,000 --> 01:00:07,000
它为你做所有的辛勤工作，然后将它交给你一个关联数组

1130
01:00:07,000 --> 01:00:10,000
含有用户输入到表单中的一切。

1131
01:00:10,000 --> 01:00:12,000
那么，哪些领域没有这种形式有哪些？

1132
01:00:12,000 --> 01:00:14,000
>> 它有4个领域。

1133
01:00:14,000 --> 01:00:16,000
一个是文本字段名为name的。

1134
01:00:16,000 --> 01:00:18,000
一个是称为队长的复选框。

1135
01:00:18,000 --> 01:00:22,000
一个是被称为性别的单选按钮，

1136
01:00:22,000 --> 01:00:24,000
，还有一个是叫宿舍的下拉菜单中，

1137
01:00:24,000 --> 01:00:27,000
所以注意到，当我打印递归

1138
01:00:27,000 --> 01:00:29,000
这个特殊变量的内容。

1139
01:00:29,000 --> 01:00:34,000
这是一个特殊的全局变量从字面上$ _POST，全部大写。

1140
01:00:34,000 --> 01:00:39,000
这是一个特殊的全局变量，PHP只是为你创造

1141
01:00:39,000 --> 01:00:42,000
和手给你，让你可以访问一切

1142
01:00:42,000 --> 01:00:45,000
由用户通过表单提交。

1143
01:00:45,000 --> 01:00:48,000
，调用print r上，你就不会这样做在一个正常的应用程序。

1144
01:00:48,000 --> 01:00:50,000
我们这样做是为了看到这个变量的内，

1145
01:00:50,000 --> 01:00:53,000
，什么是它的内部，以及，4个按键，

1146
01:00:53,000 --> 01:00:56,000
4 HTTP参数，可以这么说，

1147
01:00:56,000 --> 01:00:59,000
名，队长，性别，宿舍，然后用户的值

1148
01:00:59,000 --> 01:01:01,000
中键入一个例外。

1149
01:01:01,000 --> 01:01:03,000
我做了D-à-V-I-D型。

1150
01:01:03,000 --> 01:01:05,000
我检查了箱子，虽然，男性，这显然提交了一份价值

1151
01:01:05,000 --> 01:01:07,000
只是m为简洁。

1152
01:01:07,000 --> 01:01:10,000
>> 当我选择了马修斯的价值，进行了选择，

1153
01:01:10,000 --> 01:01:12,000
这个人是有点愚蠢，但它的惯例。

1154
01:01:12,000 --> 01:01:17,000
当我检查的框，值上，“，”得到提交的复选框。

1155
01:01:17,000 --> 01:01:21,000
如果我没有检查，没有任何价值将被送往任何责任。

1156
01:01:21,000 --> 01:01:26,000
这只是让我们深入了解这个特殊的全局变量里面有什么，

1157
01:01:26,000 --> 01:01:29,000
它是如此特别，它被称为超全局变量。

1158
01:01:29,000 --> 01:01:33,000
它的存在在你的代码中到处找你，所以，你其实可以访问它。

1159
01:01:33,000 --> 01:01:36,000
这是不令人满意的，让我们实际使用超全局

1160
01:01:36,000 --> 01:01:38,000
，实际尝试注册的人。

1161
01:01:38,000 --> 01:01:41,000
在froshims1我要做出一个改变。

1162
01:01:41,000 --> 01:01:44,000
我改变的行动是register1.php的，

1163
01:01:44,000 --> 01:01:46,000
和我做一件事。

1164
01:01:46,000 --> 01:01:48,000
我是通过我的网页上有质量的一种尴尬。

1165
01:01:48,000 --> 01:01:52,000
说实话，这是非常可怕的，所以它原来

1166
01:01:52,000 --> 01:01:56,000
在网络上，你可以很容易地使用

1167
01:01:56,000 --> 01:01:59,000
其他人的JavaScript代码，其他人的CSS

1168
01:01:59,000 --> 01:02:02,000
他们编写并开放了源代码，并提供图书馆，

1169
01:02:02,000 --> 01:02:06,000
可以这么说，例如，我在这里使用免费提供的库，

1170
01:02:06,000 --> 01:02:08,000
一堆别人写的代码。

1171
01:02:08,000 --> 01:02:11,000
>> Twitter的事写这段代码，这就是所谓的引导程序库，

1172
01:02:11,000 --> 01:02:15,000
它只是一个CSS样式表，一堆一堆的。css文件

1173
01:02:15,000 --> 01:02:19,000
别人写的，并计算出如何让一切都很好，漂亮

1174
01:02:19,000 --> 01:02:22,000
像我们这样的人可以少担心一点美学，重点更

1175
01:02:22,000 --> 01:02:24,000
在逻辑和实际的编程。

1176
01:02:24,000 --> 01:02:30,000
通过将包含该标签的，这是我用相同的标记记住的styles3.css早期，

1177
01:02:30,000 --> 01:02:34,000
我现在有一个称为bootstrap.min.css的文件的访问。

1178
01:02:34,000 --> 01:02:37,000
只是意味着，他们已经精缩最小，他们已经摆脱所有的白色空间等等

1179
01:02:37,000 --> 01:02:40,000
只是，以确保他们没有向我发送的字节数比我的实际需要。

1180
01:02:40,000 --> 01:02:45,000
但在有一大堆的CSS，所以如果我现在开的大一IMS版本1

1181
01:02:45,000 --> 01:02:49,000
请注意我的文件肯定是漂亮。

1182
01:02:49,000 --> 01:02:54,000
现在，它仍然只是黑色和白色，但是请注意，只是使用的样式表

1183
01:02:54,000 --> 01:02:58,000
使用某些功能，这是我的形式不惊人，

1184
01:02:58,000 --> 01:03:01,000
但它肯定比以前清洁，并在投影机不这样做正义。

1185
01:03:01,000 --> 01:03:05,000
周围的按钮和文本字段周围有小灰线就在这里，

1186
01:03:05,000 --> 01:03:07,000
但它肯定比以前更干净。

1187
01:03:07,000 --> 01:03:09,000
>> 现在，为公平起见，我没有改变我的标记位。

1188
01:03:09,000 --> 01:03:12,000
这是第1版，请注意，我已经使用了一些新的标签，

1189
01:03:12,000 --> 01:03:17,000
说实话，我不知道该怎么办，直到我读的文档

1190
01:03:17,000 --> 01:03:20,000
Twitter的引导库，他们告诉我，如果你想使用我们的图书馆

1191
01:03:20,000 --> 01:03:23,000
使用fieldset元素在你的形式，

1192
01:03:23,000 --> 01:03:27,000
把你要显示的字旁边一个领域内的一个标签，标签，

1193
01:03:27,000 --> 01:03:30,000
然后给你输入一个名字，就像之前，

1194
01:03:30,000 --> 01:03:34,000
的复选框，不仅你把它包在一个标签元素，

1195
01:03:34,000 --> 01:03:36,000
你使用一类的东西，所以我们还没有看到这之前，

1196
01:03:36,000 --> 01:03:39,000
但是你会看到在一个的pset中7的短裤。

1197
01:03:39,000 --> 01:03:43,000
CSS中的类可以让你做的东西非常相似的ID，

1198
01:03:43,000 --> 01:03:46,000
但在此之前，当我们有一个ID以＃符号

1199
01:03:46,000 --> 01:03:48,000
这是一个只有一个元素。

1200
01:03:48,000 --> 01:03:51,000
什么是一类很好多个元素具有相同的类

1201
01:03:51,000 --> 01:03:54,000
或相同的CSS的东西应用到它。

1202
01:03:54,000 --> 01:03:57,000
>> 但同样，对那些在短期内，剩下的这仅仅是复制和粘贴

1203
01:03:57,000 --> 01:04:00,000
从他们的文件，我添加了一个标签，在这里和那里。

1204
01:04:00,000 --> 01:04:03,000
在最后，因为我已经包含在上面的链接标签，

1205
01:04:03,000 --> 01:04:06,000
一切看起来更漂亮自动

1206
01:04:06,000 --> 01:04:10,000
通过简单的标记的方式，在我的网页

1207
01:04:10,000 --> 01:04:12,000
Twitter的预期，有这么多不同的方式

1208
01:04:12,000 --> 01:04:14,000
做到这一点，这确实是非常合适的。

1209
01:04:14,000 --> 01:04:17,000
在本学期在这一点上，你会看到在pset中7的规格，

1210
01:04:17,000 --> 01:04:20,000
谷歌搜索，阅读库，用别人的CSS

1211
01:04:20,000 --> 01:04:23,000
和JavaScript来解决配套问题

1212
01:04:23,000 --> 01:04:26,000
组本身的问题，肯定是鼓励和方式

1213
01:04:26,000 --> 01:04:29,000
网络是建立这些天来，站在别人的肩膀上

1214
01:04:29,000 --> 01:04:32,000
所以，你可以真正着眼于新的和有趣的问题。

1215
01:04:32,000 --> 01:04:34,000
但是，让我们现在的重点，再次，逻辑。

1216
01:04:34,000 --> 01:04:38,000
>> 这是一个快速迂回美学只是为了显示你的方向，你可以去。

1217
01:04:38,000 --> 01:04:40,000
我要恢复的丑陋，现在仅仅是因为

1218
01:04:40,000 --> 01:04:44,000
有与Twitter的东西，心无杂念，让我去进取，不断开拓

1219
01:04:44,000 --> 01:04:51,000
froshims2，再强调一下，只有在不同的动作，register2.php，

1220
01:04:51,000 --> 01:04:55,000
让我们来看看什么样的影响是在这里。

1221
01:04:55,000 --> 01:04:57,000
让我继续前进，输入大卫。

1222
01:04:57,000 --> 01:04:59,000
我不会队长这个时候。

1223
01:04:59,000 --> 01:05:01,000
我会说男性，马修斯，寄存器。

1224
01:05:01,000 --> 01:05:05,000
该死的。好吧，这是一个搞砸了我的一部分。

1225
01:05:05,000 --> 01:05:07,000
待机。

1226
01:05:07,000 --> 01:05:17,000
寄存器2，第22行，如果为空或遗憾。

1227
01:05:17,000 --> 01:05:19,000
让我们重新加载。

1228
01:05:19,000 --> 01:05:22,000
好了，在提交这种形式刚刚发生了什么？

1229
01:05:22,000 --> 01:05:25,000
我在大卫的输入，检查男马修斯，注册，点击。

1230
01:05:25,000 --> 01:05:27,000
您的注册。 （当然，不是真的。）

1231
01:05:27,000 --> 01:05:32,000
这显然​​是一个超越刚刚打印出来的一些变量的内容，

1232
01:05:32,000 --> 01:05:34,000
但是这是什么文件，实际上是在做什么？

1233
01:05:34,000 --> 01:05:37,000
在register2.php

1234
01:05:37,000 --> 01:05:40,000
请注意，我有一些新的代码。

1235
01:05:40,000 --> 01:05:44,000
我的身体标记内，我基本上是一个if else结构，

1236
01:05:44,000 --> 01:05:47,000
但是，因为我共同交融与一些HTML

1237
01:05:47,000 --> 01:05:51,000
我来回的进入和退出PHP模式，让我们看看我在做什么。

1238
01:05:51,000 --> 01:05:55,000
>> 在这里的第一线，我说如果是的情况下

1239
01:05:55,000 --> 01:06:00,000
后超全局的关键名称是空的，

1240
01:06:00,000 --> 01:06:04,000
换句话说，如果用户没有给我一个值名称的形式，

1241
01:06:04,000 --> 01:06:07,000
然后空返回true，因为值是空的。

1242
01:06:07,000 --> 01:06:11,000
或注意到的竖线如果性别是空的，

1243
01:06:11,000 --> 01:06:15,000
内部的这个特殊的超全局，其中，再次，表示内容的形式，

1244
01:06:15,000 --> 01:06:19,000
或在宿舍里是空的，然后我会继续前进，大声嚷嚷的用户。

1245
01:06:19,000 --> 01:06:22,000
怎么样？那么，请注意，我说，你必须提供您的姓名，性别，和宿舍。

1246
01:06:22,000 --> 01:06:24,000
让实际导致这样的错误。

1247
01:06:24,000 --> 01:06:27,000
让我回到我的形式。让我重新加载，以清除它。

1248
01:06:27,000 --> 01:06:30,000
，我只是给他们大卫，他们并不需要知道我住的地方。

1249
01:06:30,000 --> 01:06:33,000
注册。很显然，我需要告诉他们我住的地方。

1250
01:06:33,000 --> 01:06:35,000
您必须提供您的姓名，性别和宿舍。回去。

1251
01:06:35,000 --> 01:06:39,000
>> 我可以点击回到这种形式，但是这是为什么呢？

1252
01:06:39,000 --> 01:06:43,000
那么，在这种情况下，名称是空的，但性别的，和宿舍，

1253
01:06:43,000 --> 01:06:47,000
所以整个表达式的计算结果为true，即使是一点点新的语法，

1254
01:06:47,000 --> 01:06:51,000
再次，我们进入PHP if语句模式，熟悉，

1255
01:06:51,000 --> 01:06:54,000
但新的部分是冒号，我搞砸了，省略了括号

1256
01:06:54,000 --> 01:06:57,000
偶然的，而是注意冒号，这意味着

1257
01:06:57,000 --> 01:07:00,000
即使我们退出PHP模式一切

1258
01:07:00,000 --> 01:07:03,000
应吐出一字不漏的浏览器

1259
01:07:03,000 --> 01:07:07,000
直到你看到一个else块中，因为我们在这里做的，

1260
01:07:07,000 --> 01:07:10,000
在这种情况下，你应该吐了这一点

1261
01:07:10,000 --> 01:07:13,000
直到你看到的ENDIF，所以微微有些新的语法

1262
01:07:13,000 --> 01:07:16,000
，让我HTML和PHP之间的切换。

1263
01:07:16,000 --> 01:07:19,000
最终，我们可以清理它，但现在，

1264
01:07:19,000 --> 01:07:22,000
它是一种形式的错误检查一个令人信服的方式。

1265
01:07:22,000 --> 01:07:25,000
>> 现在，我说你不是真的，因为很明显，我们什么也没做，但数据注册，

1266
01:07:25,000 --> 01:07:28,000
让我们真正尝试做一些很酷的东西。

1267
01:07:28,000 --> 01:07:33,000
在froshims3唯一的区别是，我会向寄存器3，

1268
01:07:33,000 --> 01:07:35,000
所以HTML是相同的。

1269
01:07:35,000 --> 01:07:38,000
在寄存器3注意到这一点。

1270
01:07:38,000 --> 01:07:40,000
这是一种性感。

1271
01:07:40,000 --> 01:07:44,000
我顶使用require语句中的，所以这是如＃include。

1272
01:07:44,000 --> 01:07:46,000
这一次，它不是stdio.h中或类似的东西。

1273
01:07:46,000 --> 01:07:50,000
这是一个PHP库，以及一个被称为PHPMailer的。

1274
01:07:50,000 --> 01:07:53,000
我怎么知道正是这包括引号的字符串？

1275
01:07:53,000 --> 01:07:56,000
我读了它在文件中，所以当他们告诉我把这个顶部的文件

1276
01:07:56,000 --> 01:08:00,000
如果你想使用一个特殊的库称为PHPMailer的，做什么，它说。

1277
01:08:00,000 --> 01:08:03,000
它可以让你通过发送电子邮件的PHP。

1278
01:08:03,000 --> 01:08:05,000
现在，让我们继续向下滚动。

1279
01:08:05,000 --> 01:08:08,000
>> 请注意，开始我在PHP模式，

1280
01:08:08,000 --> 01:08:11,000
所以，现在发现在这里导入该库后，

1281
01:08:11,000 --> 01:08:13,000
 可以这么说，我做了一些合理性检查。

1282
01:08:13,000 --> 01:08:16,000
如果它是这个名字不为空的情况下，

1283
01:08:16,000 --> 01:08:19,000
和性别是不为空，注意感叹号

1284
01:08:19,000 --> 01:08:24,000
宿舍是不是空的，那么用户已在逻辑上填写的表格，至少要有足够。

1285
01:08:24,000 --> 01:08:28,000
我不在乎，如果他们的队长或没有。我只需要他们的姓名，性别，和宿舍。

1286
01:08:28,000 --> 01:08:31,000
如果他们填补这些了，没有这些字段是空的

1287
01:08:31,000 --> 01:08:33,000
这是稍微新的语法。

1288
01:08:33,000 --> 01:08:36,000
顺便说一句，PHP，是一个面向对象的编程语言

1289
01:08:36,000 --> 01:08:39,000
你们可能还记得从APCS或类似。

1290
01:08:39,000 --> 01:08:42,000
现在，如果不熟悉，只知道使用这个库

1291
01:08:42,000 --> 01:08:45,000
你必须写一行代码，像这样使用一个新的关键字，

1292
01:08:45,000 --> 01:08:47,000
从字面上一个新的关键字称为新的。

1293
01:08:47,000 --> 01:08:50,000
但除此之外，我们有一些熟悉的语法。

1294
01:08:50,000 --> 01:08:54,000
这是一个箭头操作符，我们使用的指针的上下文中的结构是类似的。

1295
01:08:54,000 --> 01:08:57,000
今天，PHP没有指针，

1296
01:08:57,000 --> 01:09:01,000
但现在知道这里面的邮件变量

1297
01:09:01,000 --> 01:09:05,000
本质上是善良的指针一个特殊的库

1298
01:09:05,000 --> 01:09:08,000
别人说，如果我想访问特定的功能

1299
01:09:08,000 --> 01:09:12,000
该库里面我做什么，和C一样，使用箭头操作符，

1300
01:09:12,000 --> 01:09:14,000
即使这些实际上不是指针。

1301
01:09:14,000 --> 01:09:16,000
这是PHP自己的版本。

1302
01:09:16,000 --> 01:09:20,000
这意味着，去图书馆，和调用的IsSMTP的功能。

1303
01:09:20,000 --> 01:09:23,000
从我们的战士的净SMTP，召回，是指到电子邮件，

1304
01:09:23,000 --> 01:09:28,000
这只是意味着使用这个大一IMS注册的电子邮件服务器。

1305
01:09:28,000 --> 01:09:30,000
>> 我要使用什么主机？

1306
01:09:30,000 --> 01:09:34,000
那么，哈佛，如果你谷歌周围，有的邮件服务器smtp.fas.harvard.edu。

1307
01:09:34,000 --> 01:09:37,000
如果你在家里打你住在一个Comcast网络

1308
01:09:37,000 --> 01:09:40,000
它可能类似smtp.comcast.net。

1309
01:09:40,000 --> 01:09:43,000
这完全取决于你住在哪里，你的ISP。

1310
01:09:43,000 --> 01:09:47,000
之后，我要我的地址任意jharvard@cs50.net。

1311
01:09:47,000 --> 01:09:52,000
然后，我打算设置解决jharvard@cs50.net的。

1312
01:09:52,000 --> 01:09:55,000
只有这样，我知道，这些功能被称为SetFrom和AddAddress

1313
01:09:55,000 --> 01:09:57,000
是，我再次阅读文档。

1314
01:09:57,000 --> 01:09:59,000
这是不样的神奇的所有程序员。

1315
01:09:59,000 --> 01:10:02,000
然后，我定下了一个主题为“登记”。

1316
01:10:02,000 --> 01:10:07,000
现在有点难看，因为这条线是什么点运算符的意思是在PHP？

1317
01:10:07,000 --> 01:10:09,000
任何人都知道吗？

1318
01:10:09,000 --> 01:10:11,000
串联。

1319
01:10:11,000 --> 01:10:14,000
在C语言中，这是一个痛苦在脖子上连接两个字符串。

1320
01:10:14,000 --> 01:10:17,000
你必须处理malloc或realloc或所有的东西

1321
01:10:17,000 --> 01:10:20,000
只是延长其长度的字符串。

1322
01:10:20,000 --> 01:10:22,000
在PHP，JavaScript和其他语言

1323
01:10:22,000 --> 01:10:24,000
通常，你可以做一个单一的字符。

1324
01:10:24,000 --> 01:10:28,000
在这种情况下，点是指字符串

1325
01:10:28,000 --> 01:10:30,000
并追加到这个字符串。

1326
01:10:30,000 --> 01:10:32,000
>> 哦，顺便说一下，追加到该字符串，

1327
01:10:32,000 --> 01:10:34,000
这恰好是，超全局变量里面的。

1328
01:10:34,000 --> 01:10:37,000
然后附加到一个新的生产线，因此所有的这些点仅仅意味着

1329
01:10:37,000 --> 01:10:39,000
继续作出越来越大，大字符串，

1330
01:10:39,000 --> 01:10:43,000
你不必关心在所有的malloc或类似这样的语言，

1331
01:10:43,000 --> 01:10:46,000
有其他的方法来做到这一点，但是这是一个最快的

1332
01:10:46,000 --> 01:10:48,000
的方式展示出来。

1333
01:10:48,000 --> 01:10:50,000
这是什么做的吗？

1334
01:10:50,000 --> 01:10:55,000
它创建一个电子邮件正文中，要说出名字：船长：性别：宿舍：

1335
01:10:55,000 --> 01:10:58,000
在单独的行，然后最后，

1336
01:10:58,000 --> 01:11:00,000
一行代码，而我现在将忽略此。

1337
01:11:00,000 --> 01:11:02,000
如果== FALSE意味着，如果出事了，

1338
01:11:02,000 --> 01:11:04,000
但魔术在这里发生的。

1339
01:11:04,000 --> 01:11:08,000
邮件发送方式发送这封电子邮件。

1340
01:11:08,000 --> 01:11:10,000
让我们来看看最终的结果是什么。

1341
01:11:10,000 --> 01:11:13,000
在该文件的底部，发现它会说你真的是注册

1342
01:11:13,000 --> 01:11:15,000
如果我走到这一步。

1343
01:11:15,000 --> 01:11:18,000
不过，如果用户螺丝，请注意，我们开始了这个

1344
01:11:18,000 --> 01:11:21,000
如果条件在这里，如果它不是空的，而不是空

1345
01:11:21,000 --> 01:11:24,000
，而不是空的，我们发送的邮件。

1346
01:11:24,000 --> 01:11:27,000
否则，我们将发送下面这行代码，

1347
01:11:27,000 --> 01:11:30,000
这是有效果，你会看到在pset中7，将用户重定向

1348
01:11:30,000 --> 01:11:35,000
回到他们原来的地方，froshims3.php。

1349
01:11:35,000 --> 01:11:38,000
>> 手指交叉，否则，这将是今天最令人失望的演示。

1350
01:11:38,000 --> 01:11:40,000
在这里，我们走了。

1351
01:11:40,000 --> 01:11:42,000
让我打开我的邮箱在Gmail的收件箱jharvard。

1352
01:11:42,000 --> 01:11:44,000
现在没有电子邮件。好的。

1353
01:11:44,000 --> 01:11:53,000
现在让我开了froshims3，这是第三个也是最后一个例子，我们来看看在这里。

1354
01:11:53,000 --> 01:11:55,000
好了，在这里，我们走了。

1355
01:11:55,000 --> 01:12:00,000
内特，他会是队长，男，说，Apley。

1356
01:12:00,000 --> 01:12:04,000
注册。好吧，你真的注册。

1357
01:12:04,000 --> 01:12:07,000
如果我现在滚动到我的邮箱，哦，我的上帝。

1358
01:12:07,000 --> 01:12:09,000
我刚才动态在网络上发送了一封电子邮件。

1359
01:12:09,000 --> 01:12:11,000
>> 让我们留在那笔记。

1360
01:12:11,000 --> 01:12:16,000
一个视频是即将到来的演讲中，我们错过了。下周见。

1361
01:12:16,000 --> 01:12:18,000
[CS50.TV]