1
00:00:00,000 --> 00:00:04,410
>> [音乐播放]

2
00:00:04,410 --> 00:00:12,250

3
00:00:12,250 --> 00:00:15,770
>> 扬声器1：这是CS50和
这是七周的端部。

4
00:00:15,770 --> 00:00:20,240
今天也许是我们
真的教你的语言。

5
00:00:20,240 --> 00:00:24,100
我们在过去的介绍
周HTML和CSS，这两者都不

6
00:00:24,100 --> 00:00:25,240
是编程语言。

7
00:00:25,240 --> 00:00:28,600
事实上，即使我们没有
看几乎所有的标签

8
00:00:28,600 --> 00:00:33,410
该HTML配备了几乎所有的
该CSS自带的性能，

9
00:00:33,410 --> 00:00:35,007
这是一种它的HTML和CSS。

10
00:00:35,007 --> 00:00:36,840
我们只是一般
开始假设你

11
00:00:36,840 --> 00:00:39,545
了解总体思路
的标签和属性，

12
00:00:39,545 --> 00:00:41,850
和发送页面
从客户端到服务器。

13
00:00:41,850 --> 00:00:45,280
>> 因为今天我们先来看看
另一种编程语言，PHP。

14
00:00:45,280 --> 00:00:47,110
我们要做这个超级快。

15
00:00:47,110 --> 00:00:50,910
我们不是要教你的PHP本身，
就像我们不向往来教你

16
00:00:50,910 --> 00:00:52,670
C，本身，而是编程。

17
00:00:52,670 --> 00:00:55,088
事实上，之一
本课程的目标

18
00:00:55,088 --> 00:00:57,820
是不是要教你C，
或HTML，或CSS或PHP，

19
00:00:57,820 --> 00:01:00,370
或任何数目的其他的
时髦的词或缩写，

20
00:01:00,370 --> 00:01:03,097
而计算机科学
如何从根本上编程。

21
00:01:03,097 --> 00:01:05,930
事实上，今天我们开始采取
这些培训轮子掉所有的

22
00:01:05,930 --> 00:01:10,600
进一步通过一个飞
语言叫做PHP，如下所示。

23
00:01:10,600 --> 00:01:13,640
>> 以下是这门语言的样子。

24
00:01:13,640 --> 00:01:17,790
事实证明，没有必要对
程序中的主要功能写

25
00:01:17,790 --> 00:01:19,470
在一个叫做PHP语言。

26
00:01:19,470 --> 00:01:22,585
所以这已经听起来有点简单
比C，与我们熟悉。

27
00:01:22,585 --> 00:01:25,370
事实证明，如果你
要声明一个变量，

28
00:01:25,370 --> 00:01:29,470
你做了几乎相同C.但
有明显的一个区别在这里

29
00:01:29,470 --> 00:01:31,850
当我宣布一个字符串，
或者两个的差异。

30
00:01:31,850 --> 00:01:32,725
什么样子有什么不同？

31
00:01:32,725 --> 00:01:35,810

32
00:01:35,810 --> 00:01:37,160
>> 听众：美元符号。

33
00:01:37,160 --> 00:01:39,951
>> 扬声器1：是的，有美元
签署，这是我们从来没有见过的。

34
00:01:39,951 --> 00:01:41,451
而缺少什么？

35
00:01:41,451 --> 00:01:41,950
是吗？

36
00:01:41,950 --> 00:01:42,820
>> 听众：[听不清]

37
00:01:42,820 --> 00:01:44,403
>> 扬声器1：是啊，有没有数据类型。

38
00:01:44,403 --> 00:01:48,410
所以，事实证明，PHP是我们
调用一个松散类型的语言，在这里

39
00:01:48,410 --> 00:01:49,959
C的强类型。

40
00:01:49,959 --> 00:01:52,500
弱类型只是意味着
有不同的数据类型，

41
00:01:52,500 --> 00:01:54,470
有字符串，整数和浮点数。

42
00:01:54,470 --> 00:01:56,330
但是，计算机的数字表示出来。

43
00:01:56,330 --> 00:01:58,664
您人类程序员
没有弄明白。

44
00:01:58,664 --> 00:02:00,580
因此，所有你需要做的
声明一个变量

45
00:02:00,580 --> 00:02:03,220
美元符号，名称您
变量，然后，例如，

46
00:02:03,220 --> 00:02:04,760
报价引文结束，世界你好。

47
00:02:04,760 --> 00:02:07,662
>> 嗯，这是什么
情况看起来像在PHP。

48
00:02:07,662 --> 00:02:08,328
任何差异？

49
00:02:08,328 --> 00:02:10,650

50
00:02:10,650 --> 00:02:11,150
第

51
00:02:11,150 --> 00:02:12,540
因此，原来这些是相同的。

52
00:02:12,540 --> 00:02:14,665
你可能有少
分支机构或多个分支，

53
00:02:14,665 --> 00:02:16,557
但是语法匝
出完全一样。

54
00:02:16,557 --> 00:02:18,390
布尔表达式可以
一起订购。

55
00:02:18,390 --> 00:02:20,400
布尔表达式
可相与在一起。

56
00:02:20,400 --> 00:02:21,430
你还有开关。

57
00:02:21,430 --> 00:02:23,790
即使您没有使用
这些，这些确实存在用C

58
00:02:23,790 --> 00:02:26,020
而且他们在功能
相当于在PHP。

59
00:02:26,020 --> 00:02:28,260
>> 而事实上，在PHP他们
更厉害一点。

60
00:02:28,260 --> 00:02:32,540
在C语言中，你只能比较特定的
像整数和字符数据类型，

61
00:02:32,540 --> 00:02:36,320
而在PHP中，你可以实际的比较
全功能完善的字符串，而无需

62
00:02:36,320 --> 00:02:38,460
担心指针等。

63
00:02:38,460 --> 00:02:39,430
所以这里有一个for循环。

64
00:02:39,430 --> 00:02:41,270
这仅仅是伪
代码，如果你愿意。

65
00:02:41,270 --> 00:02:43,400
但在结构上是相同的C.

66
00:02:43,400 --> 00:02:47,520
>> 这里有一个while循环，伪
therefore--相同C.

67
00:02:47,520 --> 00:02:49,390
这里有一个做，而loop--相同。

68
00:02:49,390 --> 00:02:51,390
所以有一种
这种模式在这里，由此

69
00:02:51,390 --> 00:02:54,400
还有一些其他的语法
特点我们确实要看到。

70
00:02:54,400 --> 00:02:57,340
事实上，这里是一个很好的
在PHP借此方式，

71
00:02:57,340 --> 00:02:59,350
如果你想要遍历
一个数组，你

72
00:02:59,350 --> 00:03:02,309
不希望跳跃通过
有心理和语法箍

73
00:03:02,309 --> 00:03:05,178
INT I等于0，我少
小于n，我加plus--这

74
00:03:05,178 --> 00:03:07,040
只是很多烦人的语法。

75
00:03:07,040 --> 00:03:10,654
你可以说多一点
流畅每个号码

76
00:03:10,654 --> 00:03:13,320
作为数字，其中在这种情况下，
美元符号的数字，我假设，

77
00:03:13,320 --> 00:03:15,400
就像是一个数组被叫号码。

78
00:03:15,400 --> 00:03:18,810
然后，我假设数，
奇异的，将是一个变量。

79
00:03:18,810 --> 00:03:22,940
>> 什么PHP会为我做，因为我遍历
移到该循环是，在每次迭代中，

80
00:03:22,940 --> 00:03:28,450
它会更新变量数
在数字的第i个元素，复数。

81
00:03:28,450 --> 00:03:30,060
所以它只是处理了这一切对我来说。

82
00:03:30,060 --> 00:03:32,750
没有方括号，无
美元符号，没有分号。

83
00:03:32,750 --> 00:03:34,117
这只是一个简单一点。

84
00:03:34,117 --> 00:03:35,950
好吧，如果你想要一个
阵列，原来你

85
00:03:35,950 --> 00:03:38,908
可以做一些非常相似
C.语法是有点不同。

86
00:03:38,908 --> 00:03:41,000
但在这里就是所谓的数组
美元符号数。

87
00:03:41,000 --> 00:03:44,261
而且我用的，在PHP中，方
括号，事实证明。

88
00:03:44,261 --> 00:03:47,260
而且我们将再次看到这些
在JavaScript--又一语言。

89
00:03:47,260 --> 00:03:49,968
我只是用方括号
有一个逗号分隔的列表

90
00:03:49,968 --> 00:03:51,530
的整数，在这种情况下。

91
00:03:51,530 --> 00:03:53,010
但是，这给了我一个阵列。

92
00:03:53,010 --> 00:03:56,270
>> 但是，即使在PHP更加强大，
我们也有一般有哪些

93
00:03:56,270 --> 00:03:57,640
所谓的关联数组。

94
00:03:57,640 --> 00:03:59,540
和很多语言
有这些为好。

95
00:03:59,540 --> 00:04:03,810
关于C数组的事情
是，索引

96
00:04:03,810 --> 00:04:06,940
一个数组，东西你
在方括号中使用，通过该

97
00:04:06,940 --> 00:04:08,600
您访问的元素，一定是什么呢？

98
00:04:08,600 --> 00:04:10,620
>> 听众：[听不清]

99
00:04:10,620 --> 00:04:14,220
>> 扬声器1：他们必须是数字或
整数，特别是从零就到了。

100
00:04:14,220 --> 00:04:17,140
那么，在PHP和，事实证明
出，在其他语言中，

101
00:04:17,140 --> 00:04:20,820
你可以开始有
索引是不是数字。

102
00:04:20,820 --> 00:04:23,880
但他们实际上是词或
短语，使得而非

103
00:04:23,880 --> 00:04:27,070
尽量记住一些东西
是，或者存储在变量i，

104
00:04:27,070 --> 00:04:31,720
你其实可以用一句话说
that--你能说这样的话。

105
00:04:31,720 --> 00:04:34,730
>> 因此，美元符号报价是
变量这里命名。

106
00:04:34,730 --> 00:04:39,360
这是一个有点时髦的语法
这是相关联的两个关键值

107
00:04:39,360 --> 00:04:41,250
对这个变量。

108
00:04:41,250 --> 00:04:45,490
具体而言，这是给我
一个数组的长度为2。

109
00:04:45,490 --> 00:04:47,660
但索引不是0和1。

110
00:04:47,660 --> 00:04:51,250
该指标是报价引文结束
符号和报价引文结束的价格。

111
00:04:51,250 --> 00:04:55,990
而这些指标的值，
分别是FB对于Facebook

112
00:04:55,990 --> 00:05:00,360
和$ 79.53，当我最后
查了代价。

113
00:05:00,360 --> 00:05:01,210
>> 这意味着什么？

114
00:05:01,210 --> 00:05:04,136
嗯，这意味着，
而不是编写代码

115
00:05:04,136 --> 00:05:09,612
这样，在这里我用来做什么
像美元sign--或者更确切地说，在C

116
00:05:09,612 --> 00:05:11,070
我甚至不会有一个美元符号。

117
00:05:11,070 --> 00:05:13,490
我会做一些
比如单引号，然后

118
00:05:13,490 --> 00:05:18,410
我会做支架我得到一些
任意数字索引值。

119
00:05:18,410 --> 00:05:21,430
从今天开始在PHP中，如果你
想获得一些价值，

120
00:05:21,430 --> 00:05:24,742
样的，我们有更多的
语义表现力。

121
00:05:24,742 --> 00:05:27,450
的说法只是一个奇特的方式，我们可以
只需要调用的东西是什么。

122
00:05:27,450 --> 00:05:29,800
>> 如果你想获得
在一些符号，

123
00:05:29,800 --> 00:05:32,180
现在你从字面上做
引用引文结束符号

124
00:05:32,180 --> 00:05:34,910
在方括号
这不只是数。

125
00:05:34,910 --> 00:05:36,450
所以这是一个很好的便利。

126
00:05:36,450 --> 00:05:38,140
这就是那种现在它。

127
00:05:38,140 --> 00:05:40,240
有一束束
在PHP中的其他功能。

128
00:05:40,240 --> 00:05:43,180
事实上，PHP中有
众所周知的厨房水槽。

129
00:05:43,180 --> 00:05:48,640
几十，几百的功能配备
PHP--这么多的超过带着C.

130
00:05:48,640 --> 00:05:51,360
>> 而这还不打算
压倒而是帮助

131
00:05:51,360 --> 00:05:53,900
你知道，我们没有
不再需要编写代码

132
00:05:53,900 --> 00:05:55,590
这是那种到这里概念。

133
00:05:55,590 --> 00:05:58,465
现在我们可以开始利用
远更先进的功能

134
00:05:58,465 --> 00:05:59,920
像PHP语言都有。

135
00:05:59,920 --> 00:06:02,630
所以我们不必担心
在内存中移动周围的事物。

136
00:06:02,630 --> 00:06:05,338
我们不担心的malloc
而所有这些较低的水平，

137
00:06:05,338 --> 00:06:09,390
强大的细节，你会摔跤
有，如果不与，pset5斗争，

138
00:06:09,390 --> 00:06:13,380
但你可以开始
很快理所当然的。

139
00:06:13,380 --> 00:06:17,770
>> 事实上，让我们写一个超级
在PHP中简单的程序，如下所示。

140
00:06:17,770 --> 00:06:21,550
我要去的头到CS50
IDE在这里，我要怎么做

141
00:06:21,550 --> 00:06:29,370
是创建一个新的文件，这很简单
将被称为你好点PHP。

142
00:06:29,370 --> 00:06:31,860
因此，而不是C点，它的
将被称为点的PHP。

143
00:06:31,860 --> 00:06:34,260
然后在这个文件中，
我可以开始输入。

144
00:06:34,260 --> 00:06:36,960
但事实是，
有一件事我必须知道

145
00:06:36,960 --> 00:06:41,470
是，一般而言，任何PHP文件，需要
开始与一些特殊的语法。

146
00:06:41,470 --> 00:06:44,570
类似的精神，HTML，但同样，
PHP是一种编程语言，而不是

147
00:06:44,570 --> 00:06:45,590
的标记语言。

148
00:06:45,590 --> 00:06:48,700
>> 因此，每一个文件，它的排序
愚蠢的样子，我得承认。

149
00:06:48,700 --> 00:06:50,480
打开支架，问号，PHP。

150
00:06:50,480 --> 00:06:53,060
而这仅仅是
说法语的方式，

151
00:06:53,060 --> 00:06:58,400
哎，计算机这里来一些代码
写在一个叫做PHP语言。

152
00:06:58,400 --> 00:07:01,900
然后在文件的最后，
你做种排序相反的。

153
00:07:01,900 --> 00:07:04,860
你不写一遍PHP，你只
做问号，尖括号。

154
00:07:04,860 --> 00:07:08,500
然后，任何你把里面的
这两个标签，可以这么说，

155
00:07:08,500 --> 00:07:11,490
将，或者应该是，PHP代码。

156
00:07:11,490 --> 00:07:13,180
>> 因此，让我们做一些超级简单。

157
00:07:13,180 --> 00:07:19,370
我要继续前进，做打印
闪避，世界你好，反斜杠N，保存。

158
00:07:19,370 --> 00:07:27,310
而现在，在我的提示下，我要去
这样做，使hello--不，我要做的事情，

159
00:07:27,310 --> 00:07:28,726
点斜线打招呼。

160
00:07:28,726 --> 00:07:31,250
不，点斜线，HM。

161
00:07:31,250 --> 00:07:32,990
因此就不同了。

162
00:07:32,990 --> 00:07:36,920
事实上，这是一个关键的区别
PHP和语言如C C的差别

163
00:07:36,920 --> 00:07:38,730
是所谓的编译型语言。

164
00:07:38,730 --> 00:07:40,929
这是什么意思对C进行编译？

165
00:07:40,929 --> 00:07:41,970
是什么寓意？

166
00:07:41,970 --> 00:07:42,898
是啊。

167
00:07:42,898 --> 00:07:45,220
>> 听众：把它写进机器代码
因此它可以由计算机来运行。

168
00:07:45,220 --> 00:07:46,011
>> 扬声器1：没错。

169
00:07:46,011 --> 00:07:49,075
我们必须首先把它转换成
所谓机器代码，0和1

170
00:07:49,075 --> 00:07:51,950
之前，它实际上是可执行
和理解由计算机。

171
00:07:51,950 --> 00:07:52,840
英特尔内部。

172
00:07:52,840 --> 00:07:54,530
由计算机内部的CPU。

173
00:07:54,530 --> 00:07:58,170
PHP，相反，是所谓
一种解释型语言，这

174
00:07:58,170 --> 00:08:02,230
意味着你没有编译
成零和一，机器码

175
00:08:02,230 --> 00:08:04,360
你，而不是把它作为源代码。

176
00:08:04,360 --> 00:08:08,130
而你，而不是把它作为输入
一个程序，一个解释

177
00:08:08,130 --> 00:08:11,960
别人写的
年前能理解它

178
00:08:11,960 --> 00:08:14,310
一行行，一个字符一个字符。

179
00:08:14,310 --> 00:08:16,120
因此，换句话说，
人类在那里写了

180
00:08:16,120 --> 00:08:19,670
一个程序，将看
在一行代码行，

181
00:08:19,670 --> 00:08:21,680
并找出什么
电脑应该做的，

182
00:08:21,680 --> 00:08:25,960
不转换
直接向零和一。

183
00:08:25,960 --> 00:08:28,370
>> 如果它看到一个for循环因此，
这个所谓的解释器

184
00:08:28,370 --> 00:08:30,630
将是一样，没事的，我应该
一遍又一遍，再做些什么。

185
00:08:30,630 --> 00:08:31,150
我该怎么办？

186
00:08:31,150 --> 00:08:32,159
让我看看下一行。

187
00:08:32,159 --> 00:08:33,367
让我看看下一行。

188
00:08:33,367 --> 00:08:35,350
它真正的逐行解释它行。

189
00:08:35,350 --> 00:08:37,220
因此，要执行它，我不使用化妆。

190
00:08:37,220 --> 00:08:39,409
我不使用点斜杠在这种情况下。

191
00:08:39,409 --> 00:08:43,530
我不是做PHP的，这是
的一个程序，也称为名称

192
00:08:43,530 --> 00:08:46,562
一个解释，那就是
预装CS50 IDE，

193
00:08:46,562 --> 00:08:48,770
现在我需要通过一个
命令行参数，这

194
00:08:48,770 --> 00:08:52,290
是的很简单的名字
文件我想诠释。

195
00:08:52,290 --> 00:08:54,740
或者更随便，我想运行。

196
00:08:54,740 --> 00:08:57,000
如果我敲回车，在那里，我们有它。

197
00:08:57,000 --> 00:08:57,825
你好，世界。

198
00:08:57,825 --> 00:08:59,950
现在事实证明，我
用过的打印清晰度故意

199
00:08:59,950 --> 00:09:01,600
从C弥合我们的PHP。

200
00:09:01,600 --> 00:09:05,150
大多数PHP程序员，你会看到，
甚至没有理会使用打印清晰度。

201
00:09:05,150 --> 00:09:08,290
他们只是用一个调用的函数
打印，这Ç没有。

202
00:09:08,290 --> 00:09:11,390
所以，如果我重新运行，现在，它实际上
行为功能上是相同。

203
00:09:11,390 --> 00:09:13,730
我不能用百分比小号
和百分比i和等等，

204
00:09:13,730 --> 00:09:16,250
但也有其他的方法
在这样做的PHP。

205
00:09:16,250 --> 00:09:18,100
但是这仅仅是对
说语法，

206
00:09:18,100 --> 00:09:21,850
比一些奇怪的事情了其他
顶部和一些奇怪的字符下降

207
00:09:21,850 --> 00:09:25,960
在底部，该概念现在的
在这个其他语言编程

208
00:09:25,960 --> 00:09:27,860
将要完全相同。

209
00:09:27,860 --> 00:09:30,120
>> 事实上，让我们做另外一个例子。

210
00:09:30,120 --> 00:09:32,520
所以我要继续前进
并关闭该文件。

211
00:09:32,520 --> 00:09:37,740
让我再创建一个
我会打电话给条件1点PHP。

212
00:09:37,740 --> 00:09:40,770
因此，没有零，因为我做了什么
是我回头一看，几个星期前，

213
00:09:40,770 --> 00:09:43,490
我们有一个名为
条件1点C.什么

214
00:09:43,490 --> 00:09:47,590
我所做的就是将它转换我
头，并在这里对纸，

215
00:09:47,590 --> 00:09:51,290
并很快在球场上的
网站，一行行到PHP。

216
00:09:51,290 --> 00:09:55,520
>> 所以在C版本中，我们做了一些
像字符串s得到得到的字符串。

217
00:09:55,520 --> 00:09:58,200
所以这是一个有点不同
要做到这一点在PHP。

218
00:09:58,200 --> 00:10:01,390
相反，我只是去
这样做，或者说，我

219
00:10:01,390 --> 00:10:05,870
可能做INT n得到得到
整型，在前面这个例子。

220
00:10:05,870 --> 00:10:12,600
而不是说那么，我该怎么办ñ
被读取，行，我想一个整数，

221
00:10:12,600 --> 00:10:13,670
请。

222
00:10:13,670 --> 00:10:15,110
所以，这只是我的提示。

223
00:10:15,110 --> 00:10:17,260
所以，事实证明，以及
我只知道这个

224
00:10:17,260 --> 00:10:20,480
从看过或见过的功能
之前，阅读功能在PHP线

225
00:10:20,480 --> 00:10:23,810
需要一个参数是一个提示
对于人，其人生目的

226
00:10:23,810 --> 00:10:26,220
是读一行文本
他或她在类型。

227
00:10:26,220 --> 00:10:29,160
然后将其存储了
文成变量n。

228
00:10:29,160 --> 00:10:32,200
>> 现在，我可能想要做的事
像我一样星期前，像周

229
00:10:32,200 --> 00:10:33,290
其中一个班的。

230
00:10:33,290 --> 00:10:36,600
如果n大于
零，那么，我会

231
00:10:36,600 --> 00:10:42,930
借用刚才我们看到的语法，
打印闪避，你挑一个正数，

232
00:10:42,930 --> 00:10:44,360
反斜线ñ。

233
00:10:44,360 --> 00:10:49,990
否则，如果n等于等于零，我
要继续前进，并说，打印清晰度，

234
00:10:49,990 --> 00:10:54,090
你选择了零反斜杠ñ。

235
00:10:54,090 --> 00:10:56,830
否则，这里的情况应该
当然可以，打印清晰度，

236
00:10:56,830 --> 00:10:58,620
你选择了一个负数。

237
00:10:58,620 --> 00:11:00,970
>> 我们当然可以实现
这件事情的逻辑

238
00:11:00,970 --> 00:11:03,390
在一堆不同
的方式，但这里的要点

239
00:11:03,390 --> 00:11:07,210
是语法，
几乎没有任何东西是新的。

240
00:11:07,210 --> 00:11:09,830
这只是美元符号和
一个新的功能和读线。

241
00:11:09,830 --> 00:11:12,090
但是从根本上，有什么新
现在我解释这一点。

242
00:11:12,090 --> 00:11:13,910
我把它当作输入
到其他程序。

243
00:11:13,910 --> 00:11:16,620
所以，如果我想，如果要运行它，
我没有犯任何错误，

244
00:11:16,620 --> 00:11:20,140
我要去的运行PHP，
条件1点PHP，回车，

245
00:11:20,140 --> 00:11:23,440
我会在50号输入，
让我们假设现在它的作品。

246
00:11:23,440 --> 00:11:25,940
因为逻辑是
同样的东西，一个星期。

247
00:11:25,940 --> 00:11:28,020
>> 好了，所以这是很
给人留下深刻印象，对不对？

248
00:11:28,020 --> 00:11:30,240
我们可以在任何这样做
语言的数量。

249
00:11:30,240 --> 00:11:33,200
让我们做一些事情的方式更强大。

250
00:11:33,200 --> 00:11:35,610
让我们来完成习题集五位。

251
00:11:35,610 --> 00:11:37,370
所以，我要继续前进，做到这一点。

252
00:11:37,370 --> 00:11:42,920
我要创建一个文件
所谓字典点PHP，

253
00:11:42,920 --> 00:11:45,424
和倾斜的，你可能会
要抢下来很多的笔记，

254
00:11:45,424 --> 00:11:47,340
票据只会帮助
你如果你被允许

255
00:11:47,340 --> 00:11:48,923
实现问题在PHP中设置五位。

256
00:11:48,923 --> 00:11:52,706
但是，我们将看到如何迅速，现在我们
可以实现同样的问题集。

257
00:11:52,706 --> 00:11:56,830
>> 因此，在字典点PHP，我会
假定已经有

258
00:11:56,830 --> 00:11:58,514
在世界上一个名为的拼写。

259
00:11:58,514 --> 00:12:01,430
事实上，我提前做了这个，
我们不会通过这条线走

260
00:12:01,430 --> 00:12:03,596
按行，但如果你
好奇后来真想

261
00:12:03,596 --> 00:12:06,250
环绕在你的心
C和PHP之间的差异，

262
00:12:06,250 --> 00:12:09,030
从字面上比较这文件，
拼写检查，从今天的源代码

263
00:12:09,030 --> 00:12:11,190
我们稍后将发布
今天，对p将

264
00:12:11,190 --> 00:12:15,309
5拼写检查C点，我们给你，
和它的几乎相同的线，由线。

265
00:12:15,309 --> 00:12:16,600
这里也有一些更多的美元符号。

266
00:12:16,600 --> 00:12:18,330
一对夫妇功能
有一点不同。

267
00:12:18,330 --> 00:12:20,038
但它是一个很好的方式，
排序的看到如何

268
00:12:20,038 --> 00:12:22,740
你翻译一种语言到另一种。

269
00:12:22,740 --> 00:12:24,812
这几乎相同的行线。

270
00:12:24,812 --> 00:12:27,770
但我会假设，
存在，就是我要在这里做

271
00:12:27,770 --> 00:12:31,310
是试图炸毁你的
通过重新实现介意

272
00:12:31,310 --> 00:12:36,210
问题的全部设置五路
比你快一直在做迄今。

273
00:12:36,210 --> 00:12:39,330
因此，举例来说，我会第一
声明呼吁大小全局变量，

274
00:12:39,330 --> 00:12:40,444
并设置它等于零。

275
00:12:40,444 --> 00:12:41,610
现在，没有太多的积蓄。

276
00:12:41,610 --> 00:12:44,170
可能你实现
大小几乎相同，

277
00:12:44,170 --> 00:12:48,440
或暗示暗示将于今晚或明天，
只使用一个叫做全局变量

278
00:12:48,440 --> 00:12:49,900
大小，并且将其设置为零。

279
00:12:49,900 --> 00:12:52,660
这不是一个特别
惊人的扰流板。

280
00:12:52,660 --> 00:12:57,180
>> 那么，什么是你的数据结构
选择，你们谁也跳入水中

281
00:12:57,180 --> 00:13:02,170
并读取规格，什么数据结构
有你们中的大多数已经使用？

282
00:13:02,170 --> 00:13:06,840
哈希表或尝试，也许
一些变体。

283
00:13:06,840 --> 00:13:10,490
这样至少执行哈希表，
是种了很多行代码，

284
00:13:10,490 --> 00:13:10,990
对？

285
00:13:10,990 --> 00:13:13,700
而且不是所有的人都可能是
官能此时的一周中，

286
00:13:13,700 --> 00:13:14,366
但是这很好。

287
00:13:14,366 --> 00:13:19,300
因为在PHP中，如果我
想要一个哈希表，完成。

288
00:13:19,300 --> 00:13:20,260
对？

289
00:13:20,260 --> 00:13:22,610
所以，我已经该变量
刚刚宣布显然是

290
00:13:22,610 --> 00:13:26,180
所谓的美元符号表，
每出台之前。

291
00:13:26,180 --> 00:13:28,902
>> 但我真的只是想，在
在一天结束时，一个阵列。

292
00:13:28,902 --> 00:13:31,610
但不是一个数字索引
阵列，因为那就像2周

293
00:13:31,610 --> 00:13:33,440
的东西，当我们谈到数组。

294
00:13:33,440 --> 00:13:34,850
我想要一个哈希表。

295
00:13:34,850 --> 00:13:38,070
但是一个哈希表是真的
的说法只是一种具体的方式，

296
00:13:38,070 --> 00:13:40,190
你想一个关联数组。

297
00:13:40,190 --> 00:13:43,270
你想成为能够
准键与值。

298
00:13:43,270 --> 00:13:44,200
键与值。

299
00:13:44,200 --> 00:13:45,640
什么是一本字典，真的吗？

300
00:13:45,640 --> 00:13:47,080
那么它是一个整体一串钥匙。

301
00:13:47,080 --> 00:13:50,320
话像苹果，梨，香蕉，
而所有这些英语单词

302
00:13:50,320 --> 00:13:51,490
我们交给你。

303
00:13:51,490 --> 00:13:54,820
>> 而价值观，你是有效的
插入到你的字典

304
00:13:54,820 --> 00:13:57,790
要么是真的，还是没有，假的。

305
00:13:57,790 --> 00:14:00,540
换句话说，你要插入
一大堆的键值对，

306
00:14:00,540 --> 00:14:03,720
苹果，真的，梨，真实，香蕉，真实。

307
00:14:03,720 --> 00:14:07,446
所以，当您检索或看
在您的哈希表的数据

308
00:14:07,446 --> 00:14:10,070
与你的检查功能，你
要么得到一个答案，

309
00:14:10,070 --> 00:14:13,260
是的，我发现它在我的复杂
哈希表，或者没有，它不存在，

310
00:14:13,260 --> 00:14:14,540
所以你返回false。

311
00:14:14,540 --> 00:14:19,440
>> 因此，要做到这一点，我需要的是数据
像我以前的结构建议。

312
00:14:19,440 --> 00:14:22,050
我只需要能够
要的话联系起来

313
00:14:22,050 --> 00:14:25,570
像，报价引文结束，符号，
用一个值一样，真实的。

314
00:14:25,570 --> 00:14:27,090
因此，有我的哈希表。

315
00:14:27,090 --> 00:14:28,180
让我们实际使用它。

316
00:14:28,180 --> 00:14:30,310
因此，有一些功能
我需要实现。

317
00:14:30,310 --> 00:14:33,300
我要继续前进，咬
关闭一个函数调用的大小。

318
00:14:33,300 --> 00:14:34,390
它不带任何参数。

319
00:14:34,390 --> 00:14:36,660
我没有打扰
这个词的，无效的，在PHP。

320
00:14:36,660 --> 00:14:38,770
我只是要回的大小。

321
00:14:38,770 --> 00:14:41,287
>> 而作为一个不谈，PHP有
这minorly恼人的细节，

322
00:14:41,287 --> 00:14:44,620
其中，如果事情是全球性的，你要
在告诉你正在使用的功能

323
00:14:44,620 --> 00:14:46,220
这，哎，这是一个全局变量。

324
00:14:46,220 --> 00:14:49,330
因此，小的愚蠢，但你
有仍然做到这一点。

325
00:14:49,330 --> 00:14:50,920
>> 那么，关于负荷？

326
00:14:50,920 --> 00:14:52,990
我要去实现
一个函数调用的负载

327
00:14:52,990 --> 00:14:56,790
这需要在字典中的名称，
就像在问题设置五位。

328
00:14:56,790 --> 00:14:59,554
而在我开始之前，
请注意，我没有

329
00:14:59,554 --> 00:15:00,970
打字已完全一样的东西。

330
00:15:00,970 --> 00:15:06,060
有什么明显的不同在PHP约
你如何定义一个函数对C？

331
00:15:06,060 --> 00:15:06,616
是啊。

332
00:15:06,616 --> 00:15:07,490
听众：[听不清]

333
00:15:07,490 --> 00:15:08,573
喇叭1：没有返回类型。

334
00:15:08,573 --> 00:15:12,350
而事实上，这样的话，PHP
只要它是松散类型，

335
00:15:12,350 --> 00:15:14,190
也是在这个意义上一点不马虎。

336
00:15:14,190 --> 00:15:17,680
你不指定作为编程
这是什么函数返回。

337
00:15:17,680 --> 00:15:20,490
你将不得不实际上看起来
在代码中找出答案。

338
00:15:20,490 --> 00:15:22,670
或者阅读评论
或文档中。

339
00:15:22,670 --> 00:15:24,870
因此长处和的利弊吧
这类决定。

340
00:15:24,870 --> 00:15:26,750
但是，我不得不说
关键字，功能。

341
00:15:26,750 --> 00:15:28,360
而当我们学习
JavaScript的在几个星期

342
00:15:28,360 --> 00:15:31,026
我们将看到同样的事情
再次，但它同样的想法。

343
00:15:31,026 --> 00:15:34,220
该函数的名称，它的参数
或参数或缺乏，现在

344
00:15:34,220 --> 00:15:35,630
这里是执行。

345
00:15:35,630 --> 00:15:38,860
>> 所以我要去只是削减一些角落
是戏剧性的只是一瞬间。

346
00:15:38,860 --> 00:15:40,485
但我要继续前进，并说这一点。

347
00:15:40,485 --> 00:15:44,890
这就是我可以加载
一个文件到一个数组。

348
00:15:44,890 --> 00:15:47,580
有一个在PHP函数调用的文件。

349
00:15:47,580 --> 00:15:49,300
你把它的文件的名称。

350
00:15:49,300 --> 00:15:53,950
它递给你回一个数组，里面
这是每一行的文件。

351
00:15:53,950 --> 00:15:56,480
从零个，一个，上向上
到n减去1行。

352
00:15:56,480 --> 00:15:57,210
就是这样，对吗？

353
00:15:57,210 --> 00:15:57,990
有没有F读。

354
00:15:57,990 --> 00:15:58,826
有没有F GET秒。

355
00:15:58,826 --> 00:15:59,700
有没有百分之秒。

356
00:15:59,700 --> 00:16:00,420
有没有头痛。

357
00:16:00,420 --> 00:16:01,220
有没有的feof。

358
00:16:01,220 --> 00:16:03,950
所有的东西与
你一直在摔跤也许，

359
00:16:03,950 --> 00:16:06,550
与对置四，五，消失。

360
00:16:06,550 --> 00:16:09,450
>> 所以，我刚才读的那些行成
该文件，然后你知道吗？

361
00:16:09,450 --> 00:16:15,510
如果我想遍历这些话，
我能做的，每个行的行。

362
00:16:15,510 --> 00:16:19,992
请记住，这是种聪明
迭代的一个数组，索引的方式

363
00:16:19,992 --> 00:16:25,090
由指数，并在每次迭代主叫
当前行，美元符号线。

364
00:16:25,090 --> 00:16:31,560
而且在这里我会去
说表，支架，线，得到真实的。

365
00:16:31,560 --> 00:16:35,880
>> 换句话说，这就是我
插入到PHP中我的哈希表。

366
00:16:35,880 --> 00:16:38,740
我说，美元符号表，
是我的关联数组，这是

367
00:16:38,740 --> 00:16:40,690
空每个代码向上线之上。

368
00:16:40,690 --> 00:16:42,790
然后我索引到它
不是，使用号码，

369
00:16:42,790 --> 00:16:45,300
但是从字面上使用
关键字，我在乎。

370
00:16:45,300 --> 00:16:47,730
也许这是苹果或梨
或香蕉也好，

371
00:16:47,730 --> 00:16:51,645
但具体我索引
进入它就像我刚才提出的。

372
00:16:51,645 --> 00:16:53,770
我取的名字我
关联数组，然后我

373
00:16:53,770 --> 00:16:56,450
使用报价引文结束在
方括号中有一个字符串，

374
00:16:56,450 --> 00:16:58,490
代替实际数目。

375
00:16:58,490 --> 00:17:00,250
>> 所以，就是这样。

376
00:17:00,250 --> 00:17:01,720
负载功能完成。

377
00:17:01,720 --> 00:17:05,119
一旦这个循环迭代，我已经把
万事成哈希表。

378
00:17:05,119 --> 00:17:07,810
现在小的免责声明，有一个
两件事情我也需要修复。

379
00:17:07,810 --> 00:17:10,030
和版本，我会在网上发布
将所有的细微差别，

380
00:17:10,030 --> 00:17:12,670
但它大多只是一些将要
错误检查和一些小的调整。

381
00:17:12,670 --> 00:17:14,044
但是，这确实是它的要点。

382
00:17:14,044 --> 00:17:16,750
如果我现在想实现
调用的函数

383
00:17:16,750 --> 00:17:19,869
检查，这需要一个
字作为其参数，

384
00:17:19,869 --> 00:17:22,099
怎么可能我去这样做？

385
00:17:22,099 --> 00:17:30,020
好吧，我只是会说，如果
我的表里面，在位置的话，

386
00:17:30,020 --> 00:17:30,652
如果已设置。

387
00:17:30,652 --> 00:17:32,360
因此，如果有is--
其实，你知道吗？

388
00:17:32,360 --> 00:17:34,830
我要做到这一点在
有些伪代码。

389
00:17:34,830 --> 00:17:36,020
但这个想法是一样的。

390
00:17:36,020 --> 00:17:41,640
如果等于true，返回true。

391
00:17:41,640 --> 00:17:43,890
好吧。

392
00:17:43,890 --> 00:17:46,851
那种Else--你能看到
这是going--返回false。

393
00:17:46,851 --> 00:17:47,350
完成。

394
00:17:47,350 --> 00:17:49,640
检查完成。

395
00:17:49,640 --> 00:17:50,940
>> 相当不错的，对不对？

396
00:17:50,940 --> 00:17:52,560
所以，这是什么真正的意思吗？

397
00:17:52,560 --> 00:17:53,680
这也太，我切一些角落。

398
00:17:53,680 --> 00:17:56,020
看版上线
对于所有的细微细微差别的。

399
00:17:56,020 --> 00:17:57,103
但是，这是它的要点。

400
00:17:57,103 --> 00:17:59,080
指数到您的
关联数组，又名

401
00:17:59,080 --> 00:18:02,910
哈希表，看看是否有一个值
还有，如果它设置为true，如果是的话，

402
00:18:02,910 --> 00:18:03,930
返回true。

403
00:18:03,930 --> 00:18:05,819
因此，我们削成下降
所有的复杂性。

404
00:18:05,819 --> 00:18:07,110
所以，那种心灵的吹了吧？

405
00:18:07,110 --> 00:18:09,680
我不会打扰卸载完成它，
因为在fa​​ct--哦，你知道吗？

406
00:18:09,680 --> 00:18:11,620
是啊，让我们与卸载完成它。

407
00:18:11,620 --> 00:18:18,940
>> 卸载在哈希表看起来
像功能卸载，返回。

408
00:18:18,940 --> 00:18:19,930
确定这样的卸载。

409
00:18:19,930 --> 00:18:21,350
因为没有什么
卸载，对不对？

410
00:18:21,350 --> 00:18:22,170
有没有malloc的。

411
00:18:22,170 --> 00:18:24,280
我没有明确要求
操作系统的任何事情。

412
00:18:24,280 --> 00:18:25,571
我刚开始使用的变量。

413
00:18:25,571 --> 00:18:30,510
所以，这也是的一种表现
更高层次的语言特点。

414
00:18:30,510 --> 00:18:32,940
如此反复，大多数这个词
我们一直在处理这儿

415
00:18:32,940 --> 00:18:34,280
与C超低水平。

416
00:18:34,280 --> 00:18:35,980
你可以看到计算机的内存。

417
00:18:35,980 --> 00:18:38,440
你可以触摸任何你
希望在您的计算机的RAM，

418
00:18:38,440 --> 00:18:39,440
是好还是坏。

419
00:18:39,440 --> 00:18:41,760
>> 在这里，我们将
放弃权力。

420
00:18:41,760 --> 00:18:44,730
但是，我的上帝，看看如何
更少的代码我写的。

421
00:18:44,730 --> 00:18:47,660
事实上，如果我不说话
并讨论了我的打字，

422
00:18:47,660 --> 00:18:50,190
我们已经进行
这个例子五分钟前。

423
00:18:50,190 --> 00:18:52,150
那么什么是价格被支付？

424
00:18:52,150 --> 00:18:54,100
那么让我们一起来看看。

425
00:18:54,100 --> 00:18:55,340
让我们一起来看看。

426
00:18:55,340 --> 00:18:59,340
我要继续前进并运行CS50。

427
00:18:59,340 --> 00:19:02,160
让我先进入
今天的例子，

428
00:19:02,160 --> 00:19:03,970
我像以前一样有文本的目录。

429
00:19:03,970 --> 00:19:08,520
我要运行的解决方案，
它与问题设置5名为

430
00:19:08,520 --> 00:19:11,190
拼写，这是在CS50的帐户。

431
00:19:11,190 --> 00:19:14,040
>> 而我要的东西运行
大像国王詹姆斯圣经，

432
00:19:14,040 --> 00:19:16,547
只是让我们真正把
员工的解决方案测试。

433
00:19:16,547 --> 00:19:19,130
现在有时互联网的一个
慢一点，快一点，

434
00:19:19,130 --> 00:19:20,338
可能需要一段时间来滚动。

435
00:19:20,338 --> 00:19:23,730
但它总共0.56秒花
拼写检查国王詹姆斯

436
00:19:23,730 --> 00:19:25,150
用圣经的工作人员解决方案。

437
00:19:25,150 --> 00:19:25,620
因此，相当不错。

438
00:19:25,620 --> 00:19:27,786
你的可能要慢得多，
而这完全罚款。

439
00:19:27,786 --> 00:19:30,090
但它是正确的在这里。

440
00:19:30,090 --> 00:19:32,440
所以这是工作人员的解决方案。

441
00:19:32,440 --> 00:19:34,785
如果我进去收拾PHP版本。

442
00:19:34,785 --> 00:19:36,990
而我会做一个小
像烘焙展的事情。

443
00:19:36,990 --> 00:19:39,720
我们将采取我写的代码
此前，所以这是完全正确的。

444
00:19:39,720 --> 00:19:42,678
因为我写的代码是不会
是完全正确的刚才。

445
00:19:42,678 --> 00:19:47,310
但是，如果我运行PHP版本，
我有什么，今天放弃了？

446
00:19:47,310 --> 00:19:49,980
我花了五分钟
实施P设定五，我要求。

447
00:19:49,980 --> 00:19:51,770
我已付出什么样的代价？

448
00:19:51,770 --> 00:19:52,270
是啊。

449
00:19:52,270 --> 00:19:52,937
>> 听众：速度。

450
00:19:52,937 --> 00:19:53,645
扬声器1：速度。

451
00:19:53,645 --> 00:19:54,380
什么意思？

452
00:19:54,380 --> 00:19:55,230
>> 听众：这将需要更长的时间。

453
00:19:55,230 --> 00:19:55,660
>> 扬声器1：所有权利。

454
00:19:55,660 --> 00:19:56,160
让我们来看看。

455
00:19:56,160 --> 00:19:59,590
这将需要更长的时间，
不写，但要运行它。

456
00:19:59,590 --> 00:20:00,090
是啊。

457
00:20:00,090 --> 00:20:00,960
因此，让我们试试这个。

458
00:20:00,960 --> 00:20:05,720
所以在这里我要继续前进，做
PHP拼写的，并且因为该文件的

459
00:20:05,720 --> 00:20:06,360
所谓的拼写。

460
00:20:06,360 --> 00:20:07,580
所以我没有运行
字典，召回，

461
00:20:07,580 --> 00:20:09,204
我跑叫拼写检查程序。

462
00:20:09,204 --> 00:20:12,450
我要通过在同一
文件中，国王詹姆斯的五分之一。

463
00:20:12,450 --> 00:20:14,377
它飞​​过。

464
00:20:14,377 --> 00:20:17,210
这可能仅仅是网速，
所以不要过度解读成。

465
00:20:17,210 --> 00:20:21,680
但它确实感觉不再是肯定的。

466
00:20:21,680 --> 00:20:23,280
1.26秒。

467
00:20:23,280 --> 00:20:25,150
>> 现在，仍然是相当
该死的快，不是吗？

468
00:20:25,150 --> 00:20:28,140
这感觉就像唯一的理由
更像三个或四个或五个

469
00:20:28,140 --> 00:20:30,515
秒，这只是因为
互联网是正在缓慢。

470
00:20:30,515 --> 00:20:33,980
花费的计算机时间为1.26
秒，相比之下，我认为0.56。

471
00:20:33,980 --> 00:20:35,880
这样的两倍以上的速度慢。

472
00:20:35,880 --> 00:20:39,170
现在，这还是相当不错的
速度快，但它是一个体现

473
00:20:39,170 --> 00:20:40,860
，果然，那具体价格。

474
00:20:40,860 --> 00:20:43,460
>> 因为我们解释
在由行代码行，

475
00:20:43,460 --> 00:20:46,740
并且该程序PHP正在读我的
代码从上到下，从左到右，

476
00:20:46,740 --> 00:20:47,940
它有做多思路。

477
00:20:47,940 --> 00:20:50,430
它有一种转换
它本身内部

478
00:20:50,430 --> 00:20:53,464
到相应的机
在飞行中的代码，可以这么说，

479
00:20:53,464 --> 00:20:55,380
即使力学
有一点不同。

480
00:20:55,380 --> 00:20:59,430
而不是只供给到对
英特尔CPU的原始零和一

481
00:20:59,430 --> 00:21:00,930
它理解本身。

482
00:21:00,930 --> 00:21:04,110
>> 那么绝对，相传，
我们已经付出了代价。

483
00:21:04,110 --> 00:21:09,120
和代码编写的语言
PHP之类往往要慢一些。

484
00:21:09,120 --> 00:21:10,050
但是，我的上帝。

485
00:21:10,050 --> 00:21:12,740
所以现在当我拼写检查我
文件，我花了一个额外的0.7

486
00:21:12,740 --> 00:21:17,280
秒左右VS 20小时以实现
更快的拼写检查，对吧？

487
00:21:17,280 --> 00:21:18,397
这是怎样的一个权衡的。

488
00:21:18,397 --> 00:21:20,980
如果你是刚刚启动P
置5，可能不会20小时。

489
00:21:20,980 --> 00:21:22,188
可能远高于更少。

490
00:21:22,188 --> 00:21:23,600
但是，这是一个权衡，真的。

491
00:21:23,600 --> 00:21:27,820
如果你是在真正的大运行的代码
数据集，或者在更老的硬件，

492
00:21:27,820 --> 00:21:32,650
这些种的差异
当然可以积少成多。

493
00:21:32,650 --> 00:21:34,880
>> 如有任何问题迄今？

494
00:21:34,880 --> 00:21:35,617
是啊。

495
00:21:35,617 --> 00:21:36,492
>> 听众：[听不清]

496
00:21:36,492 --> 00:21:38,187

497
00:21:38,187 --> 00:21:39,978
扬声器1：对不起，能
你说这一次？

498
00:21:39,978 --> 00:21:40,853
听众：[听不清]

499
00:21:40,853 --> 00:21:43,326

500
00:21:43,326 --> 00:21:44,700
扬声器1：你放弃自己的时间。

501
00:21:44,700 --> 00:21:45,283
好了，所以是。

502
00:21:45,283 --> 00:21:47,322
您节省时间
不必编译它，

503
00:21:47,322 --> 00:21:48,530
如果这就是你在问什么。

504
00:21:48,530 --> 00:21:50,710
事实上，在CS50，
大多数的节目，

505
00:21:50,710 --> 00:21:53,668
尽管他们可能需要一段时间
写，他们是比较短的。

506
00:21:53,668 --> 00:21:56,860
几十个，几百行代码，
所以他们编译很快。

507
00:21:56,860 --> 00:21:58,470
但是当你开始
写一些大一点的程序，

508
00:21:58,470 --> 00:22:01,511
就像如果你是微软或者你
谷歌和写作真正的大计划

509
00:22:01,511 --> 00:22:05,360
在C或C ++或类似方式进行编译
语言，可能需要数秒，

510
00:22:05,360 --> 00:22:08,577
甚至几分钟或更长的时间，以
编译数百万行代码。

511
00:22:08,577 --> 00:22:10,660
还有一点，就是
差别是要增加。

512
00:22:10,660 --> 00:22:12,840
>> 而事实上，一旦我们
今天的过渡，当天

513
00:22:12,840 --> 00:22:15,910
今天，以网络编程
使用PHP，你

514
00:22:15,910 --> 00:22:18,460
会发现它只是这么多
更愉快编写代码

515
00:22:18,460 --> 00:22:21,501
如果你没有做这些愚蠢的
样变到终端的步骤

516
00:22:21,501 --> 00:22:24,202
窗口中，键入make你好，重
运行它，重新加载窗口。

517
00:22:24,202 --> 00:22:25,910
只是这么多愚蠢
机械步骤

518
00:22:25,910 --> 00:22:28,480
刚刚获得这样做的方式
有趣的，好玩的工作。

519
00:22:28,480 --> 00:22:31,450
事实上，我们扔掉这些用PHP。

520
00:22:31,450 --> 00:22:34,960
我们可以互动
与它更迅速。

521
00:22:34,960 --> 00:22:35,495
是啊。

522
00:22:35,495 --> 00:22:36,370
听众：[听不清]

523
00:22:36,370 --> 00:22:40,294

524
00:22:40,294 --> 00:22:40,960
扬声器1：当然。

525
00:22:40,960 --> 00:22:42,876
我能澄清什么
装置将被解释？

526
00:22:42,876 --> 00:22:45,870
当您编译语言
像C，它的股价下跌

527
00:22:45,870 --> 00:22:48,140
因为我们机器说：
码，零和一。

528
00:22:48,140 --> 00:22:51,860
而Intel决定年前
零和一的某些模式

529
00:22:51,860 --> 00:22:56,220
代表此外，或减法，
或打印，或其它基本操作。

530
00:22:56,220 --> 00:23:00,250
在解释型语言的世界
如PHP或JavaScript，或者Python，

531
00:23:00,250 --> 00:23:03,120
或Ruby，或串
其他人，而不是一个人

532
00:23:03,120 --> 00:23:05,120
写了一本
interpreter--在这种情况下，

533
00:23:05,120 --> 00:23:09,770
它也被称为PHP，等同于
在language--的名字，基本上

534
00:23:09,770 --> 00:23:13,840
有一个大循环中它的迭代
在所有代码的行

535
00:23:13,840 --> 00:23:18,170
我给它的输入，像招呼
点PHP，或字典点PHP。

536
00:23:18,170 --> 00:23:21,760
>> 然后你可以把他们的大的
环路有很多的条件。

537
00:23:21,760 --> 00:23:26,340
而这些条件说，如果
人写的关键字，

538
00:23:26,340 --> 00:23:28,470
开始做他或她的
代码连连。

539
00:23:28,470 --> 00:23:31,360
或者，如果该人具有
写的代码行，

540
00:23:31,360 --> 00:23:34,880
如果只执行自己
下一行条件。

541
00:23:34,880 --> 00:23:37,740
因此，它是真正喜欢解释
它在一个人的感觉，线

542
00:23:37,740 --> 00:23:39,660
由线，那只是时间问题。

543
00:23:39,660 --> 00:23:41,340
这需要开销。

544
00:23:41,340 --> 00:23:44,189
所以这是一个price--
良好的问题 - 我们付出。

545
00:23:44,189 --> 00:23:46,480
因此，让我们做的是另演示
这是一个有点戏剧性。

546
00:23:46,480 --> 00:23:51,160
还有就是，我会说，一个大概这在
可怕的失败的概率为90％，

547
00:23:51,160 --> 00:23:53,869
但你会惊奇地发现
用10％的概率。

548
00:23:53,869 --> 00:23:55,660
所以每年我们尝试
要做到这一点，因此我们

549
00:23:55,660 --> 00:23:59,061
试着写一个程序，经过
问题设置为零，用于表示已

550
00:23:59,061 --> 00:24:02,060
提交你的电话号码和一个
许多其他的人口统计信息，

551
00:24:02,060 --> 00:24:06,030
我们编程
送你一条短信。

552
00:24:06,030 --> 00:24:08,540
然后，每个人的手机
开始发出蜂鸣声或振动，

553
00:24:08,540 --> 00:24:11,460
它只是令人惊讶的，因为
好了，看看电脑能做到。

554
00:24:11,460 --> 00:24:13,840
>> 这很少正常工作
看来，在很大程度上

555
00:24:13,840 --> 00:24:16,800
因为我通常得到列入黑名单
通过Gmail或其他服务

556
00:24:16,800 --> 00:24:19,630
对于真正想这样做的规模。

557
00:24:19,630 --> 00:24:24,940
但有趣的是太多，因为我们
今天没有在座的每一位，

558
00:24:24,940 --> 00:24:27,690
有趣的是我们最后一次
两年前试过，

559
00:24:27,690 --> 00:24:30,870
我想，我写了一个程序
是坐在一个循环迭代

560
00:24:30,870 --> 00:24:34,040
在所有的学生在课堂上，
和他们每个的文本消息的，

561
00:24:34,040 --> 00:24:37,534
它是这样说，
为什么不是你的演讲？

562
00:24:37,534 --> 00:24:39,170
爱，CS50机器人。

563
00:24:39,170 --> 00:24:42,580
>> 你不知道有多少歉意
而那种痛苦的电子邮​​件

564
00:24:42,580 --> 00:24:46,970
我在从接收的响应
ñ零下100人谁不在这里

565
00:24:46,970 --> 00:24:47,960
那天。

566
00:24:47,960 --> 00:24:52,116
而更有趣，更可耻story--
你知道，我们把它放在那里。

567
00:24:52,116 --> 00:24:53,740
它已经在的视频在几年前。

568
00:24:53,740 --> 00:24:56,810
所以，你很快就会看到我
其中写一个for循环，

569
00:24:56,810 --> 00:25:00,640
这是很容易写的，一个错误
for循环，使得在第一时间

570
00:25:00,640 --> 00:25:02,800
通过循环，则
发送一个短信。

571
00:25:02,800 --> 00:25:06,190
>> 通过循环我第二次
早该送多了一个短信，

572
00:25:06,190 --> 00:25:08,250
然后多一个文本
消息，和一个更多。

573
00:25:08,250 --> 00:25:11,490
但事实证明，如果你犯了一个错字
在编程时，有时你

574
00:25:11,490 --> 00:25:14,460
可以编写发送一个程序
短信，然后两条短信，

575
00:25:14,460 --> 00:25:18,742
然后3条短信给大家
谁是已经收到了一条短信。

576
00:25:18,742 --> 00:25:21,450
如你所知，做什么，
加的东西，再加上一些东西，

577
00:25:21,450 --> 00:25:25,910
加的东西，是很多大O
短信，或N的平方，

578
00:25:25,910 --> 00:25:29,830
或$ 0.10短信，$ 20,000。

579
00:25:29,830 --> 00:25:33,700
>> 值得庆幸的是我打控制-C在此之前，
事情发生了，但我没有欠至少一

580
00:25:33,700 --> 00:25:37,550
你的前任为$ 20的
200一些奇怪的文字消息，

581
00:25:37,550 --> 00:25:40,450
不仅去了他的电话，但
同时它像一个老翻盖手机

582
00:25:40,450 --> 00:25:43,520
所以喜欢排挤出他
每个内存等个人文本

583
00:25:43,520 --> 00:25:45,930
消息他实际上得到。

584
00:25:45,930 --> 00:25:49,250
因此，我们有一个目标
今天，不要那样做。

585
00:25:49,250 --> 00:25:50,620
也许打开飞行模式。

586
00:25:50,620 --> 00:25:51,120
好吧。

587
00:25:51,120 --> 00:25:56,590
因此，让我们进入一个
计划在这里callled--

588
00:25:56,590 --> 00:25:59,060
我会打电话给文本点PHP。

589
00:25:59,060 --> 00:26:01,074
而在前进，我有两个文件在这里。

590
00:26:01,074 --> 00:26:06,030
我做的只是工作人员的文件，这是有
所有员工的信息，所有的名字

591
00:26:06,030 --> 00:26:07,260
从课程的网站。

592
00:26:07,260 --> 00:26:09,756
然后现在我只是把
一些假号码555-1212。

593
00:26:09,756 --> 00:26:11,380
因此，这些不会真的去任何地方。

594
00:26:11,380 --> 00:26:15,140
但是请注意这个CSV文件里面，
我们之前谈到简要

595
00:26:15,140 --> 00:26:16,540
在文件IO的上下文中。

596
00:26:16,540 --> 00:26:18,730
>> 什么是CSV文件？

597
00:26:18,730 --> 00:26:19,970
逗号分隔的变量。

598
00:26:19,970 --> 00:26:24,400
这是一种像极
轻量级的数据库，如果你愿意。

599
00:26:24,400 --> 00:26:28,650
还有一种类四列
在这个文件中，且有锯齿，

600
00:26:28,650 --> 00:26:32,400
但逗号本质
代表在该文件中的列。

601
00:26:32,400 --> 00:26:35,400
第一列是对TF或CA的名称。

602
00:26:35,400 --> 00:26:37,800
第二列是他们的姓氏。

603
00:26:37,800 --> 00:26:39,820
第三列是他们的电话号码。

604
00:26:39,820 --> 00:26:44,760
第四列显然is--
第四列显然是什么呢？

605
00:26:44,760 --> 00:26:45,870
好了，这是他们的运营商。

606
00:26:45,870 --> 00:26:47,180
因此，Verizon公司，或冲刺，或什么不是。

607
00:26:47,180 --> 00:26:48,620
如果我前面misspoke，CSV。

608
00:26:48,620 --> 00:26:51,800
逗号分隔值是CSV在这里。

609
00:26:51,800 --> 00:26:54,260
>> 因此，我可以做这个？

610
00:26:54,260 --> 00:26:56,940
嗯，这只是一个大的文本文件，
并且它是一种长的，对不对？

611
00:26:56,940 --> 00:26:58,690
像这样的打算
是种讨厌。

612
00:26:58,690 --> 00:27:03,510
而事实证明，但是，如果我
要发送一条短信到，让我们

613
00:27:03,510 --> 00:27:05,180
亚历克斯说这里。

614
00:27:05,180 --> 00:27:09,690
让我进入我的浏览器
和退出全屏模式

615
00:27:09,690 --> 00:27:11,660
只是这样我就可以来回切换。

616
00:27:11,660 --> 00:27:20,280
事实证明，让我们来看看，如果我去的
在这里，并登录到Gmail中，所有的权利。

617
00:27:20,280 --> 00:27:22,950
别看这部分。

618
00:27:22,950 --> 00:27:23,880
只要我能看到。

619
00:27:23,880 --> 00:27:26,551

620
00:27:26,551 --> 00:27:28,800
当然livestream可以
仍然可以看到我在做什么。

621
00:27:28,800 --> 00:27:29,360
好吧。

622
00:27:29,360 --> 00:27:31,850
>> 因此，这里仅仅是Gmail的使用
约翰·哈佛的账户。

623
00:27:31,850 --> 00:27:34,000
所以，如果我想发送
短信亚历克斯，

624
00:27:34,000 --> 00:27:35,530
我当然可以撰写邮件。

625
00:27:35,530 --> 00:27:38,410
而事实证明，我已经
与亚历克斯测试之前，在这里，

626
00:27:38,410 --> 00:27:42,260
这样你就可以添加特定域
名人们的电话号码，

627
00:27:42,260 --> 00:27:45,850
因为世界上存在
东西叫做短信电子邮件网关。

628
00:27:45,850 --> 00:27:50,000
这是说，所有的一个奇特的方式
我们谁拥有那款手机

629
00:27:50,000 --> 00:27:53,200
当然有电话号码，
有可能是你的运营商，

630
00:27:53,200 --> 00:27:56,840
一定后缀像在
Vtext.com为Verizon短信

631
00:27:56,840 --> 00:28:00,320
点com，你可以添加到您的
自己的个人电话号码，然后

632
00:28:00,320 --> 00:28:03,540
您或朋友，或者你的父母会
文字你在那个特定的地址。

633
00:28:03,540 --> 00:28:07,380
>> 和Verizon拥有一台服务器，电子邮件
服务器，即在收到这封邮件，

634
00:28:07,380 --> 00:28:11,180
着眼于数字部分，然后
采用任何特殊行业的魔法

635
00:28:11,180 --> 00:28:14,540
他们必须真正发送出去了
电波您的特定细胞

636
00:28:14,540 --> 00:28:15,040
手机。

637
00:28:15,040 --> 00:28:18,030
现在，这是很好的，因为我不知道
真的知道如何发送短信

638
00:28:18,030 --> 00:28:20,460
或者写的代码，但
我的手机，

639
00:28:20,460 --> 00:28:23,580
你可能做到这些的
最终的项目，但现在所有的

640
00:28:23,580 --> 00:28:24,770
我已经是我的笔记本电脑在这里。

641
00:28:24,770 --> 00:28:29,830
所以我想遍历该CSV
文件，线，由线，由线，由线，

642
00:28:29,830 --> 00:28:35,160
抓住每一个员工的电话号码，
和它们的载体和编程，

643
00:28:35,160 --> 00:28:39,770
串联，也就是连接手机
用适当的域名数

644
00:28:39,770 --> 00:28:40,820
然后发送电子邮件。

645
00:28:40,820 --> 00:28:41,940
>> 所以这是一个很大的步骤。

646
00:28:41,940 --> 00:28:45,530
祝你好运这样做，在C.
这是一种情况噩梦

647
00:28:45,530 --> 00:28:48,350
打开文件，读它
线，由线，由线，为你

648
00:28:48,350 --> 00:28:51,100
看到，也可以很快看到
有问题的设置五，如果不

649
00:28:51,100 --> 00:28:53,560
问题设4，然后
动态地串联

650
00:28:53,560 --> 00:28:57,020
两个字符串，因为在C，
采取两个字符串，并结合他们，

651
00:28:57,020 --> 00:29:00,900
你是什​​么微创
最需要做的可能？

652
00:29:00,900 --> 00:29:03,020
需要声明更多的内存，对不对？

653
00:29:03,020 --> 00:29:04,710
而问，malloc的，我可以有更多的内存？

654
00:29:04,710 --> 00:29:07,060
因此，我可以把一半的
这里，一半的在这里。

655
00:29:07,060 --> 00:29:08,150
这只是这么多的步骤。

656
00:29:08,150 --> 00:29:10,310
而到那个时候，你已经失去了
在愚蠢的小演示的兴趣

657
00:29:10,310 --> 00:29:11,851
在这里你使大家的手机蜂鸣声。

658
00:29:11,851 --> 00:29:14,590
让我们做这样的PHP
风格，因此我们只

659
00:29:14,590 --> 00:29:16,210
开始使用更多的厨房水槽。

660
00:29:16,210 --> 00:29:18,050
>> 而天马行空
基本上是相同的，

661
00:29:18,050 --> 00:29:20,710
但我们也不必太担心
很多关于更低的水平。

662
00:29:20,710 --> 00:29:22,950
所以，让我们来看看我怎么可能
去这样做。

663
00:29:22,950 --> 00:29:26,664
而只是让我不
重复过去的错误，

664
00:29:26,664 --> 00:29:28,330
我在这里写一些笔记自己。

665
00:29:28,330 --> 00:29:31,070
而让我们看看我能走我们
通过一些基本步骤，

666
00:29:31,070 --> 00:29:33,861
然后换时间的缘故，我们将
也许是切到最后一些弯道。

667
00:29:33,861 --> 00:29:38,007
我要继续前进，做开放
支架PHP来启动该文件。

668
00:29:38,007 --> 00:29:39,590
而且我要继续前进，做到这一点。

669
00:29:39,590 --> 00:29:41,490
文件句柄，你会
很快就会看到，其实

670
00:29:41,490 --> 00:29:44,790
调用名为f开功能。

671
00:29:44,790 --> 00:29:46,280
请记住这将打开一个文件。

672
00:29:46,280 --> 00:29:48,800
而报价，引文结束，
R代表什么，再？

673
00:29:48,800 --> 00:29:49,800
只要打开它进行读取。

674
00:29:49,800 --> 00:29:51,210
现在，在对p设置，你这样做。

675
00:29:51,210 --> 00:29:54,500
和处理可以是任何东西，
富，酒吧，BAS，任何变量名。

676
00:29:54,500 --> 00:29:57,470
但一般的计算机
科学家称之为一个打开的文件，

677
00:29:57,470 --> 00:30:00,962
给你一个文件句柄，
一些守住这么说。

678
00:30:00,962 --> 00:30:02,670
我只是打算做
一些错误检查。

679
00:30:02,670 --> 00:30:07,260
因此，如果手柄是假的，就像
在C，我会做这样的事，

680
00:30:07,260 --> 00:30:09,545
无法打开文件，反斜杠ñ。

681
00:30:09,545 --> 00:30:11,420
然后，我只是去
继续前进并退出。

682
00:30:11,420 --> 00:30:14,340
而事实证明，在PHP中，
我不是一个函数内部。

683
00:30:14,340 --> 00:30:16,160
有没有主要的功能在这里。

684
00:30:16,160 --> 00:30:17,450
所以，我不回，本身。

685
00:30:17,450 --> 00:30:18,120
我退出。

686
00:30:18,120 --> 00:30:19,619
这是本质上是一回事。

687
00:30:19,619 --> 00:30:22,510
而我离开一个Y可能。

688
00:30:22,510 --> 00:30:24,220
一个仅仅意味着某种类型的错误。

689
00:30:24,220 --> 00:30:25,580
这是不为零，所以这是一个错误。

690
00:30:25,580 --> 00:30:30,220
>> 好吧，如果我下来，现在这里
在我的节目，我已经打开了该文件。

691
00:30:30,220 --> 00:30:34,250
我要继续前进，并宣布
叫地址的数组，

692
00:30:34,250 --> 00:30:38,610
而在C中我会知道
提前数组的大小，对不对？

693
00:30:38,610 --> 00:30:41,910
或者，我需要声明这个
是一个指针，然后使用malloc。

694
00:30:41,910 --> 00:30:44,720
然后我每次读
通过在文件中的另一行，

695
00:30:44,720 --> 00:30:46,620
我将需要对malloc
更多的内存，malloc的内存。

696
00:30:46,620 --> 00:30:47,703
这是在颈部疼痛。

697
00:30:47,703 --> 00:30:50,950
而幸运的是，PHP和Ruby，
和Python和JavaScript，它们

698
00:30:50,950 --> 00:30:53,880
会增加你的阵列
自动为您。

699
00:30:53,880 --> 00:30:54,830
没有更多的malloc。

700
00:30:54,830 --> 00:30:56,227
没有更多的内存管理。

701
00:30:56,227 --> 00:30:57,560
笔记本计算机在处理这件事。

702
00:30:57,560 --> 00:31:00,330
但价格你付出代价。

703
00:31:00,330 --> 00:31:01,350
这是一个有点慢。

704
00:31:01,350 --> 00:31:03,190
而对于这样的程序
我们不会注意到。

705
00:31:03,190 --> 00:31:04,720
我们将发送100条短信。

706
00:31:04,720 --> 00:31:06,136
举例来说不会感觉它。

707
00:31:06,136 --> 00:31:08,430
这真的只是开始
不管你选择的语言

708
00:31:08,430 --> 00:31:11,490
当您的数据或程序
得到真的，真的相当大的，

709
00:31:11,490 --> 00:31:14,120
如将是这种情况更是这样
我们基于Web的东西。

710
00:31:14,120 --> 00:31:15,450
>> 但现在，让我们奋进。

711
00:31:15,450 --> 00:31:20,120
虽然它原来有一个
在C函数所谓的F获得CSV。

712
00:31:20,120 --> 00:31:24,570
文件拿到CSV，采用一个
文件句柄作为参数，

713
00:31:24,570 --> 00:31:28,810
并前进然后，行，由
行，由行，读成一排。

714
00:31:28,810 --> 00:31:30,964
所以它只是读取一行
从该文件的文本。

715
00:31:30,964 --> 00:31:34,130
但是，什么是好的关于这个功能，
它不只是递给我了一行字。

716
00:31:34,130 --> 00:31:37,320
它看起来对那些逗号，
并分析了线。

717
00:31:37,320 --> 00:31:41,740
并解析行的意思分裂
它在这方面的某些值。

718
00:31:41,740 --> 00:31:45,510
>> 换句话说，美元符号
行是一个变量这是

719
00:31:45,510 --> 00:31:47,010
要给我一堆指标。

720
00:31:47,010 --> 00:31:49,635
这将是对
在我的CSV第一列。

721
00:31:49,635 --> 00:31:52,510
这将是第二
列，这将是第三次，

722
00:31:52,510 --> 00:31:53,968
这将是第四次。

723
00:31:53,968 --> 00:31:57,440
由于召回和Excel的不
配合我们最后一次这样做，

724
00:31:57,440 --> 00:32:03,350
但如果我下载的工作人员点CSV。

725
00:32:03,350 --> 00:32:04,940
哎呦，不要重命名。

726
00:32:04,940 --> 00:32:09,120
如果我下载的工作人员点
CSV，并尝试打开它，

727
00:32:09,120 --> 00:32:12,510
我已经registered--哦，我
因为上次没有更新Excel中。

728
00:32:12,510 --> 00:32:15,880
你会看到，工作人员点
CSV，我有四列。

729
00:32:15,880 --> 00:32:18,720
所以，当我阅读
对于艾比第一排位置，

730
00:32:18,720 --> 00:32:23,582
美元符号0行是艾比，
美元符号排的是里昂，

731
00:32:23,582 --> 00:32:27,740
美元符号排二是她的号码，
然后她的电话的运营商。

732
00:32:27,740 --> 00:32:28,410
>> 所以这就是所有。

733
00:32:28,410 --> 00:32:30,740
这是很好的，因为我
不必现在找出

734
00:32:30,740 --> 00:32:32,800
其中，所有这些逗号实际上是。

735
00:32:32,800 --> 00:32:35,300
所以，我要继续前进，
做到这一点，因为定义，

736
00:32:35,300 --> 00:32:38,960
我会说，她的名字是
行支架零的承诺。

737
00:32:38,960 --> 00:32:41,150
而且我要grab--和
其实，你知道吗？

738
00:32:41,150 --> 00:32:42,780
我不会担心
她的名字，在这种情况下。

739
00:32:42,780 --> 00:32:43,988
我要保持它的简单。

740
00:32:43,988 --> 00:32:48,610
我会做她的号码是
行支架二，我想。

741
00:32:48,610 --> 00:32:50,510
而她的载体在哪里？

742
00:32:50,510 --> 00:32:53,405
连续三年，一个比。

743
00:32:53,405 --> 00:32:54,280
所以没有什么新的存在。

744
00:32:54,280 --> 00:32:56,770
这只是零的索引到一个数组。

745
00:32:56,770 --> 00:32:58,760
>> 而现在，我要做到以下几点。

746
00:32:58,760 --> 00:33:03,930
如果承运人等于等于AT＆T--
我只是有一个loop--

747
00:33:03,930 --> 00:33:06,790
我想创建一个电子邮件
地址看起来是这样的。

748
00:33:06,790 --> 00:33:12,320
这将是617-555-1212
在，它是什么，text.ATT.net，

749
00:33:12,320 --> 00:33:13,490
就是我想做的事情。

750
00:33:13,490 --> 00:33:15,260
那么，如何做到这一点？

751
00:33:15,260 --> 00:33:16,730
我要做到以下几点。

752
00:33:16,730 --> 00:33:22,460
她的地址将是她的号码，
现在，让我继续前进，做到这一点。

753
00:33:22,460 --> 00:33:23,760
这是一些时髦的语法。

754
00:33:23,760 --> 00:33:27,250
我所能做的百分比把戏，
但我可以真正地做到这一点。

755
00:33:27,250 --> 00:33:29,900
>> 因此，这是一个PHP的事情，但
让我们来看看我在做什么。

756
00:33:29,900 --> 00:33:31,630
美元签下地址
左，只是一个变量。

757
00:33:31,630 --> 00:33:32,300
给我一个变量。

758
00:33:32,300 --> 00:33:33,390
我没有指定类型。

759
00:33:33,390 --> 00:33:34,570
PHP会看着办吧。

760
00:33:34,570 --> 00:33:36,580
在右手侧，
什么是数据类型

761
00:33:36,580 --> 00:33:38,399
在这整个事情
右手边？

762
00:33:38,399 --> 00:33:40,190
看起来像一个字符串，
因为有双

763
00:33:40,190 --> 00:33:42,280
报价在最左边和最右边。

764
00:33:42,280 --> 00:33:44,210
现在有在这里一些时髦的新语法。

765
00:33:44,210 --> 00:33:47,550
还有的花括号，
美元符号数。

766
00:33:47,550 --> 00:33:52,860
不过，要猜测那是什么语法
大概告诉PHP为我做？

767
00:33:52,860 --> 00:33:53,360
是啊。

768
00:33:53,360 --> 00:33:54,630
只需插入值出现。

769
00:33:54,630 --> 00:33:55,530
因此，没有百分之秒。

770
00:33:55,530 --> 00:33:58,160
我们可以使用打印楼或s
打印F或类似的东西，

771
00:33:58,160 --> 00:34:00,070
但是PHP和大量的
更高层次的语言，

772
00:34:00,070 --> 00:34:03,070
你会看到，你可以
做同样的事情在功能上，也许

773
00:34:03,070 --> 00:34:04,019
六种不同的方式。

774
00:34:04,019 --> 00:34:06,310
因此它开始成为
设计或风格的问题。

775
00:34:06,310 --> 00:34:09,902
所以，这只是一个神秘的寻找方法
的说法，给我一个电子邮件地址，

776
00:34:09,902 --> 00:34:12,110
但是插件中的数目
这些大括号之间。

777
00:34:12,110 --> 00:34:15,440
而且大括号不会
最终在最后地址。

778
00:34:15,440 --> 00:34:18,010
>> 现在我们可以跳过一些
这些线路时间的缘故。

779
00:34:18,010 --> 00:34:21,210
因此，如果在载体等于
等于verHorizo​​n--哎呦，

780
00:34:21,210 --> 00:34:24,989
Verizon--我想要做的事
非常相似的，其中的地址获取，

781
00:34:24,989 --> 00:34:27,569
报价，引文结束，数以text.ATT.net。

782
00:34:27,569 --> 00:34:30,380

783
00:34:30,380 --> 00:34:35,050
然后，我可以做同样的
为载流子的其余部分的事情。

784
00:34:35,050 --> 00:34:37,090
不过，我只是做点，点，点了吧。

785
00:34:37,090 --> 00:34:43,050
现在让我们假设
我想补充阵，推。

786
00:34:43,050 --> 00:34:45,969
我想添加到
阵列，称为地址。

787
00:34:45,969 --> 00:34:50,409
>> 这个地址，你这是怎么
添加的东西在PHP中的数组。

788
00:34:50,409 --> 00:34:51,610
你并不需要做的malloc。

789
00:34:51,610 --> 00:34:53,068
你不必调整数组。

790
00:34:53,068 --> 00:34:54,259
你刚才说的阵列，推动。

791
00:34:54,259 --> 00:34:57,300
你怎么想push--什么阵
你要推的东西上？

792
00:34:57,300 --> 00:34:58,000
地址。

793
00:34:58,000 --> 00:34:59,550
要推到地址是什么？

794
00:34:59,550 --> 00:35:00,350
地址。

795
00:35:00,350 --> 00:35:02,430
而事实上，如果你
真的要聪明一点，

796
00:35:02,430 --> 00:35:05,610
一些语法糖
为此，可以这么说，

797
00:35:05,610 --> 00:35:10,230
这只是意味着你怎么能做到这一点的
越漂亮的方式，将做到这一点。

798
00:35:10,230 --> 00:35:14,060
这也有越来越多的影响
地址数组的大小之一，

799
00:35:14,060 --> 00:35:17,130
然后扑通额外
电子邮件地址进去。

800
00:35:17,130 --> 00:35:17,630
是啊。

801
00:35:17,630 --> 00:35:19,730
>> 听众：[听不清]

802
00:35:19,730 --> 00:35:22,520
>> 扬声器1：上一个错字
其他if--哦，载体。

803
00:35:22,520 --> 00:35:23,070
没关系。

804
00:35:23,070 --> 00:35:26,971
它也不会喜欢我的失败
实施这一计划的一部分，

805
00:35:26,971 --> 00:35:27,470
稍后的。

806
00:35:27,470 --> 00:35:28,810
不过谢谢你的追赶。

807
00:35:28,810 --> 00:35:30,671
还有一个错误。

808
00:35:30,671 --> 00:35:31,170
谢谢。

809
00:35:31,170 --> 00:35:33,746
我们希望这是Vtext.com。

810
00:35:33,746 --> 00:35:34,340
是。

811
00:35:34,340 --> 00:35:34,839
好吧。

812
00:35:34,839 --> 00:35:36,330
那么，这给我们？

813
00:35:36,330 --> 00:35:38,224
我们已经写打开文件的代码。

814
00:35:38,224 --> 00:35:40,390
我们有一个循环迭代
在文件中的行。

815
00:35:40,390 --> 00:35:43,650
我们有增加的代码我
阵，一个在一时间，正确地

816
00:35:43,650 --> 00:35:44,790
格式的电子邮件地址。

817
00:35:44,790 --> 00:35:48,480
因此，所有真正的仍然是送
一个电子邮件给这些人。

818
00:35:48,480 --> 00:35:52,830
>> 所以，我已经先行一步，并
准备好自己如下。

819
00:35:52,830 --> 00:35:59,580
我打算在这里做is--，让我们
继续前进，跳到一些实际的代码，

820
00:35:59,580 --> 00:36:00,620
它看起来像这样。

821
00:36:00,620 --> 00:36:02,950
因此，这里的预焙
版本我前面写的。

822
00:36:02,950 --> 00:36:04,700
并注意我完成
实施冲刺。

823
00:36:04,700 --> 00:36:06,130
我完成了实施T-Mobile公司。

824
00:36:06,130 --> 00:36:08,020
我完成了实施维珍移动。

825
00:36:08,020 --> 00:36:09,622
我会提前道歉。

826
00:36:09,622 --> 00:36:12,080
有几个运营商的
一些学生在课堂上有

827
00:36:12,080 --> 00:36:14,640
我没有打扰枚举
在if条件在这里。

828
00:36:14,640 --> 00:36:16,015
所以，不是所有的文本都将熄灭。

829
00:36:16,015 --> 00:36:17,556
但是让我们看看还有什么我需要做的。

830
00:36:17,556 --> 00:36:19,660
我关闭文件，只需
像P设定四人。

831
00:36:19,660 --> 00:36:20,835
>> 这是新的语法。

832
00:36:20,835 --> 00:36:22,710
我们会看到一个小
这一点随着时间的推移，

833
00:36:22,710 --> 00:36:24,450
尤其是与对置七，八。

834
00:36:24,450 --> 00:36:28,140
但是，这是语法创建
一种特殊类型的结构。

835
00:36:28,140 --> 00:36:31,490
原来，有一个库，
自带PHP，称为PHP的邮件。

836
00:36:31,490 --> 00:36:33,840
其在生活中的目的是
编程方式发送电子邮件。

837
00:36:33,840 --> 00:36:36,840
它的代码别人写的
使得它更容易为我们发送电子邮件，

838
00:36:36,840 --> 00:36:39,131
所以我们没有保持
来回到Gmail，

839
00:36:39,131 --> 00:36:41,151
并粘贴在人们的电子邮件地址。

840
00:36:41,151 --> 00:36:44,150
有一大堆线在这里
那说实话，我只是种复制

841
00:36:44,150 --> 00:36:45,660
并粘贴在文档。

842
00:36:45,660 --> 00:36:47,409
而事实上，如果你
好奇，我将所有

843
00:36:47,409 --> 00:36:50,550
文件的网址
在代码中，我们将在以后发布。

844
00:36:50,550 --> 00:36:52,360
并注意中
的事情我做

845
00:36:52,360 --> 00:36:55,710
是的，我要告诉这个库，
使用Gmail的服务器，对不对？

846
00:36:55,710 --> 00:36:59,360
SMTP我们短暂交谈了解我们的时候
是在耶鲁大学关于是简单的邮件

847
00:36:59,360 --> 00:37:00,110
传输协议。

848
00:37:00,110 --> 00:37:02,920
这是协议
用于发送邮件的服务器，

849
00:37:02,920 --> 00:37:05,150
和that's--的Gmail拥有其中的一个。

850
00:37:05,150 --> 00:37:07,290
端口，这是TCP端口号。

851
00:37:07,290 --> 00:37:09,630
这是很好，如果你
还没有看到587之前。

852
00:37:09,630 --> 00:37:11,420
只是知道，从文档。

853
00:37:11,420 --> 00:37:12,250
这是我的用户名。

854
00:37:12,250 --> 00:37:13,670
我将使用CF50机器人。

855
00:37:13,670 --> 00:37:16,690
而就在那一刻，我只是要
输入机器人的实际密码。

856
00:37:16,690 --> 00:37:18,690
然后到这里，发现剩下。

857
00:37:18,690 --> 00:37:22,840
>> 我从地址设为我
在CS50.net进行BOT。

858
00:37:22,840 --> 00:37:26,240
我想我不会后悔发送
短信800人的

859
00:37:26,240 --> 00:37:30,590
说，想你，爱CS50机器人，也许
对于那些谁今天来不了了。

860
00:37:30,590 --> 00:37:33,160
然后在第76行，我该怎么办？

861
00:37:33,160 --> 00:37:39,010
这种看起来像C的所以对我
等于0，N equals--现在算上是新的。

862
00:37:39,010 --> 00:37:42,077
事实证明，如果你想获得
事情在一个阵列的数量，

863
00:37:42,077 --> 00:37:43,660
你不必再记住它。

864
00:37:43,660 --> 00:37:45,370
你可以只问
函数调用次数，

865
00:37:45,370 --> 00:37:48,320
它会告诉你有多少
地址是在该阵列。

866
00:37:48,320 --> 00:37:53,210
>> 然后，我要补充
地址的电子邮件。

867
00:37:53,210 --> 00:37:55,090
我知道这个来自
使用的文档。

868
00:37:55,090 --> 00:37:56,900
有一个附加地址的功能。

869
00:37:56,900 --> 00:37:58,980
现在发现有
是一块语法。

870
00:37:58,980 --> 00:38:01,470
我们以前见过这个
在C类似的精神。

871
00:38:01,470 --> 00:38:04,100
你可以认为美元符号
邮件作为一个变量，它是。

872
00:38:04,100 --> 00:38:08,100
但它的内部结构
这不仅属性，

873
00:38:08,100 --> 00:38:09,400
变量，如果你愿意。

874
00:38:09,400 --> 00:38:13,480
但事实证明，在PHP中，这
是一个面向对象的编程

875
00:38:13,480 --> 00:38:16,520
语言，像Java如果你把APCS。

876
00:38:16,520 --> 00:38:21,420
>> 美元符号的邮件，如果你想用于：
它也有功能在它的内部，

877
00:38:21,420 --> 00:38:22,380
或方法。

878
00:38:22,380 --> 00:38:24,720
因此，这是说
特殊的PHP邮件

879
00:38:24,720 --> 00:38:29,280
库，如果我有一个变量物，
如果我要调用一个函数，

880
00:38:29,280 --> 00:38:31,559
带有该库，
对于今天的目的，

881
00:38:31,559 --> 00:38:33,100
只知道你使用的箭头符号。

882
00:38:33,100 --> 00:38:34,150
有没有点符号。

883
00:38:34,150 --> 00:38:35,220
这只是箭头。

884
00:38:35,220 --> 00:38:36,380
但是，这不是一个指针。

885
00:38:36,380 --> 00:38:38,680
这只是从C的语法借来的。

886
00:38:38,680 --> 00:38:43,620
于是呼里面添加地址
这个库的对象或变量。

887
00:38:43,620 --> 00:38:44,440
>> 好吧。

888
00:38:44,440 --> 00:38:45,570
这就是神奇的线。

889
00:38:45,570 --> 00:38:46,740
这就是我如何发送电子邮件。

890
00:38:46,740 --> 00:38:50,040
这是开放的等效
Gmail的，打字出来，并击中发送。

891
00:38:50,040 --> 00:38:54,870
但它会代替发
通过电子邮件发送到这个地址，这身搭配，

892
00:38:54,870 --> 00:38:57,120
从CS50机器人。

893
00:38:57,120 --> 00:38:58,710
现在重点线。

894
00:38:58,710 --> 00:39:03,130
这条线是缺席像2011
当我想到我上次尝试这个。

895
00:39:03,130 --> 00:39:05,640
当然，这条线出现，
清除地址。

896
00:39:05,640 --> 00:39:07,920
因此，从逻辑上讲，如果我
不清除地址

897
00:39:07,920 --> 00:39:11,740
每次迭代后，第一
电子邮件或短信去爱丽丝，

898
00:39:11,740 --> 00:39:14,320
第二次去
Alice和Bob，第三

899
00:39:14,320 --> 00:39:17,870
去Alice和Bob和Charlie，
因此非常昂贵的错误

900
00:39:17,870 --> 00:39:18,760
我做了一年。

901
00:39:18,760 --> 00:39:21,080
>> 所以，让我们来看看。

902
00:39:21,080 --> 00:39:24,200
有什么问题
之前，我们向您发送的所有文字

903
00:39:24,200 --> 00:39:28,210
有10％的概率消息？

904
00:39:28,210 --> 00:39:28,940
任何问题？

905
00:39:28,940 --> 00:39:30,330
好吧。

906
00:39:30,330 --> 00:39:36,100
让我走在这里的变化
密码是什么应该工作，

907
00:39:36,100 --> 00:39:37,780
将有可能获得通过的Gmail列入黑名单。

908
00:39:37,780 --> 00:39:39,821
因此，他们可能不会都去
出来，因为他们可能

909
00:39:39,821 --> 00:39:42,960
不喜欢我们送800电子邮件
在fo​​r循环中的一次。

910
00:39:42,960 --> 00:39:45,140
因为这不是
特别是人的行为。

911
00:39:45,140 --> 00:39:47,460
>> 哦，我要改变一件事。

912
00:39:47,460 --> 00:39:50,850
在最顶端，我要去sent--
更改文件给学生点CSV。

913
00:39:50,850 --> 00:39:55,420
我不会开这一点，但是这是一个
相同的CSV文件，没有员工100人，

914
00:39:55,420 --> 00:39:58,970
但800名学生，刚
来自哈佛，耶鲁，因为

915
00:39:58,970 --> 00:40:00,207
有月休会这个星期。

916
00:40:00,207 --> 00:40:03,290
它似乎是那种一个混蛋的事
做文字所有的人，为什么

917
00:40:03,290 --> 00:40:04,750
他们不是在度假类。

918
00:40:04,750 --> 00:40:05,250
没关系。

919
00:40:05,250 --> 00:40:08,310
只是哈佛的学生
今天该文件的内部。

920
00:40:08,310 --> 00:40:12,320
现在，让我们回到
我的终端窗口。

921
00:40:12,320 --> 00:40:13,710
我有点紧张。

922
00:40:13,710 --> 00:40:22,000
>> 行，所以现在我要进入
目录，和PHP文本点PHP。

923
00:40:22,000 --> 00:40:24,950
如何约一勇敢的志愿者？

924
00:40:24,950 --> 00:40:26,690
所以，我不希望这在我身上。

925
00:40:26,690 --> 00:40:28,410
好了，上来吧。

926
00:40:28,410 --> 00:40:29,162
你叫什么名字？

927
00:40:29,162 --> 00:40:29,662
MAYA：玛雅。

928
00:40:29,662 --> 00:40:30,328
扬声器1：玛雅。

929
00:40:30,328 --> 00:40:31,610
上来吧，玛雅。

930
00:40:31,610 --> 00:40:34,120
好吧。

931
00:40:34,120 --> 00:40:35,389
让我们来看看，如果这个工程。

932
00:40:35,389 --> 00:40:38,430
我把我自己的电子邮件地址，在
file--文件在我自己的电话号码，

933
00:40:38,430 --> 00:40:40,110
让希望我会得到一个为好。

934
00:40:40,110 --> 00:40:40,819
很高兴见到你。

935
00:40:40,819 --> 00:40:41,443
MAYA：同样。

936
00:40:41,443 --> 00:40:44,510
扬声器1：所以你需要做的就是
按回车键发送800条短信，

937
00:40:44,510 --> 00:40:45,466
如果我没有搞砸。

938
00:40:45,466 --> 00:40:51,106

939
00:40:51,106 --> 00:40:51,606
美观大方。

940
00:40:51,606 --> 00:40:55,556

941
00:40:55,556 --> 00:40:58,430
可能需要一段时间，统计学，
直到我们得到一个电子邮件addr​​ess--

942
00:40:58,430 --> 00:41:00,573
一个短信说的
在房间里现在。

943
00:41:00,573 --> 00:41:03,880

944
00:41:03,880 --> 00:41:05,390
让我们流连忘返，看看。

945
00:41:05,390 --> 00:41:06,940
>> 听众：[呼啸]

946
00:41:06,940 --> 00:41:08,270
>> 扬声器1：哦，是的。

947
00:41:08,270 --> 00:41:09,230
>> 听众：哦，疑难杂症。

948
00:41:09,230 --> 00:41:16,720

949
00:41:16,720 --> 00:41:19,180
>> 扬声器1：For循环are--这
是不是因为PHP慢。

950
00:41:19,180 --> 00:41:21,810
这是缓慢的，因为Gmail的
节流是美国，而不是

951
00:41:21,810 --> 00:41:25,170
让我们比派遣更多
像每秒一个电子邮件。

952
00:41:25,170 --> 00:41:26,300
什么？

953
00:41:26,300 --> 00:41:29,990
这是一个很难的事情对我来说，测试在
家里只有我和我一个电话，就这样。

954
00:41:29,990 --> 00:41:37,630

955
00:41:37,630 --> 00:41:41,111
那是希望的机器人？

956
00:41:41,111 --> 00:41:41,610
是吗？

957
00:41:41,610 --> 00:41:42,110
没有？

958
00:41:42,110 --> 00:41:44,760

959
00:41:44,760 --> 00:41:46,620
说是的。

960
00:41:46,620 --> 00:41:47,479
没有？

961
00:41:47,479 --> 00:41:49,374
这是从一个朋友？

962
00:41:49,374 --> 00:41:49,874
尴尬。

963
00:41:49,874 --> 00:41:50,374
好。

964
00:41:50,374 --> 00:41:56,580

965
00:41:56,580 --> 00:42:00,090
很肯定它的工作虽然。

966
00:42:00,090 --> 00:42:00,910
嗯哦。

967
00:42:00,910 --> 00:42:03,190
他们black--哦，等一下。

968
00:42:03,190 --> 00:42:04,280
哦，你知道吗？

969
00:42:04,280 --> 00:42:06,100
稍等一会儿。

970
00:42:06,100 --> 00:42:07,802
只有Maya和我 - 米娅，是吗？

971
00:42:07,802 --> 00:42:08,301
MAYA：玛雅。

972
00:42:08,301 --> 00:42:12,110
扬声器1：玛雅，要
知道我做错了什么在这里。

973
00:42:12,110 --> 00:42:14,890
哦，等一下。

974
00:42:14,890 --> 00:42:23,320
我想我只是送100
短信555-1212。

975
00:42:23,320 --> 00:42:24,346
支持。

976
00:42:24,346 --> 00:42:28,080

977
00:42:28,080 --> 00:42:29,270
我不能赢得任何一年。

978
00:42:29,270 --> 00:42:30,180
好。

979
00:42:30,180 --> 00:42:30,680
玛雅？

980
00:42:30,680 --> 00:42:33,530

981
00:42:33,530 --> 00:42:36,219
修复了后期制作。

982
00:42:36,219 --> 00:42:36,718
该死！

983
00:42:36,718 --> 00:42:39,430

984
00:42:39,430 --> 00:42:40,390
从地址之后。

985
00:42:40,390 --> 00:42:41,301
OK，支持。

986
00:42:41,301 --> 00:42:41,800
抱歉。

987
00:42:41,800 --> 00:42:44,550

988
00:42:44,550 --> 00:42:47,080
这是痛苦的，每年。

989
00:42:47,080 --> 00:42:48,640
OK，一个瞬间。

990
00:42:48,640 --> 00:42:50,530
这是好事。

991
00:42:50,530 --> 00:42:54,010
我不是要做到这一点。

992
00:42:54,010 --> 00:42:55,470
打印地址。

993
00:42:55,470 --> 00:42:56,030
OK，支持。

994
00:42:56,030 --> 00:43:01,340
打印地址，支架我。

995
00:43:01,340 --> 00:43:02,710
是的，我喜欢这样。

996
00:43:02,710 --> 00:43:10,220
美元sign--好吧，我会解释什么，我
在做了一会儿，我已经运行此之后。

997
00:43:10,220 --> 00:43:11,670
每年。

998
00:43:11,670 --> 00:43:13,125
OK，我们开始吧。

999
00:43:13,125 --> 00:43:15,750
我有just--，我不希望
展现每个人的电话号码，

1000
00:43:15,750 --> 00:43:17,740
但是玛雅人可以确认
与点头，

1001
00:43:17,740 --> 00:43:20,800
她认为每个人的
在类的电话号码

1002
00:43:20,800 --> 00:43:26,750
我要去复制到
一个名为Gmail中。

1003
00:43:26,750 --> 00:43:30,860
如果在Gmail中，有什么事我们想说的？

1004
00:43:30,860 --> 00:43:32,137
想你。

1005
00:43:32,137 --> 00:43:33,220
Love--那不是我。

1006
00:43:33,220 --> 00:43:35,230
我还没有打送呢。

1007
00:43:35,230 --> 00:43:39,450
因此，让我们继续前进，做
这一点，如果我可以进行放大。

1008
00:43:39,450 --> 00:43:40,300
好。

1009
00:43:40,300 --> 00:43:42,480
所以我使用了一个名为Gmail的，现在的程序。

1010
00:43:42,480 --> 00:43:44,490
如果玛雅人，你想
单击发送按钮，

1011
00:43:44,490 --> 00:43:46,970
我们将模拟什么
代码应该做的。

1012
00:43:46,970 --> 00:43:54,630

1013
00:43:54,630 --> 00:43:55,254
>> 什么？

1014
00:43:55,254 --> 00:43:56,062
>> [BEEPS]

1015
00:43:56,062 --> 00:43:56,870
>> 听众：是的。

1016
00:43:56,870 --> 00:43:58,030
>> 扬声器1：是？

1017
00:43:58,030 --> 00:43:59,210
救赎？

1018
00:43:59,210 --> 00:44:00,427
>> 听众：是的。

1019
00:44:00,427 --> 00:44:01,260
扬声器1：小姐你。

1020
00:44:01,260 --> 00:44:02,718
而我要送出去休息。

1021
00:44:02,718 --> 00:44:06,060
我送出了一半，因为我没想到
Gmail的将让那些经历。

1022
00:44:06,060 --> 00:44:12,410
所以只记得，就在今天
你知道我可以使用Gmail。

1023
00:44:12,410 --> 00:44:14,977

1024
00:44:14,977 --> 00:44:15,810
这是可怕的。

1025
00:44:15,810 --> 00:44:17,140
一个大的掌声玛雅。

1026
00:44:17,140 --> 00:44:18,980
谢谢。

1027
00:44:18,980 --> 00:44:21,280
好吧，就这样。

1028
00:44:21,280 --> 00:44:22,210
什么

1029
00:44:22,210 --> 00:44:23,140
>> [BEEPS]

1030
00:44:23,140 --> 00:44:25,010

1031
00:44:25,010 --> 00:44:26,580
>> 我们得到了几个声，是吗？

1032
00:44:26,580 --> 00:44:27,080
好吧。

1033
00:44:27,080 --> 00:44:30,590
现在，我要得到700真
不幸的电子邮件从同学回来。

1034
00:44:30,590 --> 00:44:32,400
所以，至少我们会看到
如果这是值得的。

1035
00:44:32,400 --> 00:44:33,300
那么问题出在哪里？

1036
00:44:33,300 --> 00:44:35,300
我会想出了什么
事后错了，

1037
00:44:35,300 --> 00:44:38,340
但只是看多么容易
它是做在PHP。

1038
00:44:38,340 --> 00:44:44,598
那么，我们能不能​​做到，现在
我们有这个表现的PHP。

1039
00:44:44,598 --> 00:44:45,970
这was--这是可怕的。

1040
00:44:45,970 --> 00:44:46,480
好吧。

1041
00:44:46,480 --> 00:44:48,430
所以这是我应该出去了。

1042
00:44:48,430 --> 00:44:52,770
这是我今天早上测试我的
手机，我的手机的实际截图。

1043
00:44:52,770 --> 00:44:56,180
>> 但是，现在让我们来看看为什么
我们实际上引入

1044
00:44:56,180 --> 00:44:57,840
所有这些东西摆在首位。

1045
00:44:57,840 --> 00:45:01,625
所以目标不是
写这些程序

1046
00:45:01,625 --> 00:45:03,250
写在命令行，对吧？

1047
00:45:03,250 --> 00:45:05,000
所以我写了一个简单
你好程序，我写的

1048
00:45:05,000 --> 00:45:09,155
一个小程序，它条件语句，
和使用的读取线等等。

1049
00:45:09,155 --> 00:45:11,530
而从理论上讲，我只是写
一个程序发送出去

1050
00:45:11,530 --> 00:45:14,290
800条短信，给予或采取800。

1051
00:45:14,290 --> 00:45:16,830
并且该程序是所有
还是在命令行中运行。

1052
00:45:16,830 --> 00:45:18,538
这当然是
没有网络，对不对？

1053
00:45:18,538 --> 00:45:22,160
现在的目标是开始使用
什么我要求是一个更容易使用

1054
00:45:22,160 --> 00:45:24,720
语言，敢说更
强大的语言来讲

1055
00:45:24,720 --> 00:45:27,104
的功能
随之而来，开始

1056
00:45:27,104 --> 00:45:29,850
编写生成网页代码。

1057
00:45:29,850 --> 00:45:33,248
>> 所以，最后一次和最后一周，
我们谈到了HTTP和HTML。

1058
00:45:33,248 --> 00:45:36,350
什么是好的关于HTML
是，它只是单纯的文字。

1059
00:45:36,350 --> 00:45:38,220
而文字是肯定
东西，你可以

1060
00:45:38,220 --> 00:45:42,040
按字面调用打印打印
f函数，或打印功能。

1061
00:45:42,040 --> 00:45:46,160
事实上，这就是PHP是
现在要允许我们这样做。

1062
00:45:46,160 --> 00:45:48,610
所以这些例子中，我们
在今天的源代码，

1063
00:45:48,610 --> 00:45:51,610
除了一些代码
我把那里刚才，

1064
00:45:51,610 --> 00:45:55,440
我们有这样的实例程序。

1065
00:45:55,440 --> 00:45:58,760
Froshims，或新生
校内体育活动，竟是

1066
00:45:58,760 --> 00:46:01,500
第课外活动之一
我参与与年前。

1067
00:46:01,500 --> 00:46:03,750
而我和我的室友，与
一些其他的孩子在校园里，

1068
00:46:03,750 --> 00:46:05,280
用于运行froshims程序。

1069
00:46:05,280 --> 00:46:07,420
我收到我的短信了。

1070
00:46:07,420 --> 00:46:14,030
>> 现在，所以我们，早在一天，所以这
一项是1996年左右，有一个互联网，

1071
00:46:14,030 --> 00:46:17,395
但没有process--有
没有网站froshims。

1072
00:46:17,395 --> 00:46:20,270
所以，如果你想报名参加
足球或排球也好，

1073
00:46:20,270 --> 00:46:22,240
您填写这件事
称为一张纸，

1074
00:46:22,240 --> 00:46:25,060
你会穿过哈佛走
院子里，你会滑动

1075
00:46:25,060 --> 00:46:29,230
到邮件插槽监考官，谁
在威格尔斯沃，宿舍之一。

1076
00:46:29,230 --> 00:46:31,270
这是你注册的。

1077
00:46:31,270 --> 00:46:33,570
他或她会再
撰写一封电子邮件给您

1078
00:46:33,570 --> 00:46:36,514
手动，很像我
只是在这里做与Maya，

1079
00:46:36,514 --> 00:46:38,930
然后你会得到证实
为已被注册。

1080
00:46:38,930 --> 00:46:40,840
>> 因此，这就像低
挂果树，可以这么说。

1081
00:46:40,840 --> 00:46:42,930
这是一种愚蠢的
我们使用纸本。

1082
00:46:42,930 --> 00:46:45,024
我希望我们能
只是去一个网站上，

1083
00:46:45,024 --> 00:46:47,440
或有新生去一个
网站，注册为体育，

1084
00:46:47,440 --> 00:46:50,398
而只是自动完成很多东西
通过把他们的名字和电子邮件

1085
00:46:50,398 --> 00:46:51,850
等等到数据库中。

1086
00:46:51,850 --> 00:46:56,510
而事实上，在第一个版本
该网站，使用超级难看的HTML，

1087
00:46:56,510 --> 00:46:58,195
可能看起来是这样的。

1088
00:46:58,195 --> 00:47:01,070
它实际上是具有讽刺意味，更
尴尬的看着比这回

1089
00:47:01,070 --> 00:47:01,460
然后。

1090
00:47:01,460 --> 00:47:02,890
但我用的编程语言。

1091
00:47:02,890 --> 00:47:06,060
而不是PHP，而是叫Perl中，
这是一个较旧的语言，

1092
00:47:06,060 --> 00:47:07,251
但在精神上非常相似。

1093
00:47:07,251 --> 00:47:09,000
而我只是完全
教给自己。

1094
00:47:09,000 --> 00:47:12,208
我花了一段时间来弄明白，
问很多朋友的问题。

1095
00:47:12,208 --> 00:47:14,080
但是想法有
是完全一样的。

1096
00:47:14,080 --> 00:47:18,050
因为什么PHP真的设计
对于未在命令行的东西

1097
00:47:18,050 --> 00:47:20,450
我们只是打了，
但对于Web编程。

1098
00:47:20,450 --> 00:47:24,960
>> 这真是绑在它的功能
设置为Web，如下。

1099
00:47:24,960 --> 00:47:26,370
这是froshims。

1100
00:47:26,370 --> 00:47:28,720
如果我想
以这种形式注册，

1101
00:47:28,720 --> 00:47:30,930
这是相当难看，
当然，还让我继续前进

1102
00:47:30,930 --> 00:47:34,440
并且是一个不太舒服的学生，
和任何运动的马修斯，

1103
00:47:34,440 --> 00:47:35,630
点击注册。

1104
00:47:35,630 --> 00:47:39,780
我想要的是能够做的就是
从表单提交的信息，

1105
00:47:39,780 --> 00:47:42,400
没有谷歌的服务器一样
我们做了最后一次，完全

1106
00:47:42,400 --> 00:47:47,100
通过使用他们的后端欺骗，我
要实现自己的后端代码。

1107
00:47:47,100 --> 00:47:51,410
这意味着写PHP
即住在一个URL编码

1108
00:47:51,410 --> 00:47:54,180
这种形式的数据可以提交到。

1109
00:47:54,180 --> 00:47:57,510
>> 然后你的代码，
用PHP编写的一台服务器上，

1110
00:47:57,510 --> 00:47:59,400
然后可以响应该用户输入。

1111
00:47:59,400 --> 00:48:03,287
就像他或她的名字，还是舒适程度，
或宿舍，然后用它做什么。

1112
00:48:03,287 --> 00:48:05,120
在这种情况下，我只
愣神打印出来

1113
00:48:05,120 --> 00:48:06,750
为文本，这是不是所有的漂亮。

1114
00:48:06,750 --> 00:48:09,590
但是，你当然可以
想象一下，如果你知道HTML，

1115
00:48:09,590 --> 00:48:13,010
你很快就会知道如何产生
HTML与打印f和打印，

1116
00:48:13,010 --> 00:48:16,500
和类似的功能，你当然可以
生成一个漂亮的网页，上面写着：

1117
00:48:16,500 --> 00:48:17,929
嘿大卫，你现在注册。

1118
00:48:17,929 --> 00:48:20,220
你是一个不太舒服
学生从马修斯，对不对？

1119
00:48:20,220 --> 00:48:23,880
>> 你可以只用一大堆％SES的，
或大括号和美元符号

1120
00:48:23,880 --> 00:48:27,750
符号我用刚才，以
生成文本更人性化

1121
00:48:27,750 --> 00:48:28,567
莫过于此。

1122
00:48:28,567 --> 00:48:30,150
因此，让我们来看看这个文件。

1123
00:48:30,150 --> 00:48:34,666
Froshim零点PHP看起来是这样的。

1124
00:48:34,666 --> 00:48:37,860

1125
00:48:37,860 --> 00:48:43,500
当我重新加载CS50 IDE，
froshim零看起来是这样的。

1126
00:48:43,500 --> 00:48:45,700
这是froshim零点PHP。

1127
00:48:45,700 --> 00:48:47,730
而且你注意到你看这个文件？

1128
00:48:47,730 --> 00:48:49,506
>> 听众：[听不清]

1129
00:48:49,506 --> 00:48:50,922
扬声器1：对不起，大声一点好吗？

1130
00:48:50,922 --> 00:48:53,250
听众：[听不清]这一切都在HTML。

1131
00:48:53,250 --> 00:48:57,130
而事实上，这是因为
有趣的关于PHP

1132
00:48:57,130 --> 00:48:58,880
是，它被设计
是，为了更好的

1133
00:48:58,880 --> 00:49:02,110
不论好坏，间杂
与HTML代码。

1134
00:49:02,110 --> 00:49:05,850
而事实上，即使这
文件，froshim零点PHP，

1135
00:49:05,850 --> 00:49:11,470
在顶部一个PHP评论
它，这一切都只是HTML。

1136
00:49:11,470 --> 00:49:17,655
但相反的，如果我打开了，让我们
比方说，登记零点PHP，这

1137
00:49:17,655 --> 00:49:19,550
只是在顶部一个很大的评论。

1138
00:49:19,550 --> 00:49:26,500
这也看起来几乎完全
如HTML，但为了什么？

1139
00:49:26,500 --> 00:49:29,350
行，有什么，21显得有些怪异。

1140
00:49:29,350 --> 00:49:32,739
>> 但是请注意，我进入PHP模式
与开放式支架问号PHP。

1141
00:49:32,739 --> 00:49:33,780
然后，我已经得到了一些东西。

1142
00:49:33,780 --> 00:49:36,724
然后在该行的末尾
几乎我有，问号PHP。

1143
00:49:36,724 --> 00:49:38,390
这就是我所说的混合体。

1144
00:49:38,390 --> 00:49:41,910
你可以写HTML，你只是
希望服务器吐了出来。

1145
00:49:41,910 --> 00:49:45,090
但是，如果你想要做的事
通过页面动态中途，

1146
00:49:45,090 --> 00:49:47,699
像插入我的名字，
宿舍还是舒适度，

1147
00:49:47,699 --> 00:49:49,490
我可以用一个函数
像打印内容R，这是

1148
00:49:49,490 --> 00:49:52,492
打印递归的，这只是意味着
打印出这个变量，格式化

1149
00:49:52,492 --> 00:49:53,200
不过你想要的。

1150
00:49:53,200 --> 00:49:55,880
这真的不是
人类的目的，它只是

1151
00:49:55,880 --> 00:49:58,290
进行调试或诊断的目的。

1152
00:49:58,290 --> 00:49:59,460
所以这就是我是怎么做的。

1153
00:49:59,460 --> 00:50:06,100
>> 如果我不是去froshims双点PHP，
请注意，这种形式的操作

1154
00:50:06,100 --> 00:50:09,680
未注册零点PHP作为
old--前一个却呈。

1155
00:50:09,680 --> 00:50:11,222
但它注册了两个点PHP。

1156
00:50:11,222 --> 00:50:13,680
因此，让我们看看这个怎么一
行为方式略有不同。

1157
00:50:13,680 --> 00:50:15,140
如果我去成两个版本。

1158
00:50:15,140 --> 00:50:20,430
如果在这里，如果我注册为大卫少
舒适，从马修斯的宿舍，

1159
00:50:20,430 --> 00:50:21,480
注册。

1160
00:50:21,480 --> 00:50:23,770
所以这个时候它说，你
注册，不是真的。

1161
00:50:23,770 --> 00:50:25,370
让我们来看看我在这里做。

1162
00:50:25,370 --> 00:50:29,760
如果我看注册两个点
PHP，这有一些更多的PHP代码。

1163
00:50:29,760 --> 00:50:35,410
这是一个有点清洁剂，虽然它
仍然包裹在这条线有点长。

1164
00:50:35,410 --> 00:50:36,260
注意这里。

1165
00:50:36,260 --> 00:50:40,300
我打印出我的HTML标记，我的头标签，
我的标题标签，头部，身体。

1166
00:50:40,300 --> 00:50:45,410
>> 然后我开始说
像进入PHP模式。

1167
00:50:45,410 --> 00:50:48,540
而这样的标签，打开支架
PHP--问号PHP说，

1168
00:50:48,540 --> 00:50:53,460
哎，服务器，execute--解释
下面的东西，PHP

1169
00:50:53,460 --> 00:50:55,030
直到看到结束标记。

1170
00:50:55,030 --> 00:50:58,590
而且即使你可能不知道的任何
其他PHP比你见过迄今为止，

1171
00:50:58,590 --> 00:51:01,290
那种你可以阅读
它非常直观。

1172
00:51:01,290 --> 00:51:10,670
如果名称为空，或舒适性
空，或宿舍是空的，我该怎么办？

1173
00:51:10,670 --> 00:51:12,830
我说什么给用户？

1174
00:51:12,830 --> 00:51:15,330
您必须提供您的姓名，
舒适度，和宿舍，等等。

1175
00:51:15,330 --> 00:51:17,750
否则，我说你是
注册，这不是真的。

1176
00:51:17,750 --> 00:51:19,190
>> 我说的不是真的
因为没有数据库。

1177
00:51:19,190 --> 00:51:20,200
我不这样做与数据的任何东西。

1178
00:51:20,200 --> 00:51:22,408
我只是把它扔了
出于演示的目的。

1179
00:51:22,408 --> 00:51:24,320
现在我有点skimped超过22行。

1180
00:51:24,320 --> 00:51:26,400
还有更多的语法
有，但美元符号

1181
00:51:26,400 --> 00:51:28,320
强调文章是一种有趣的。

1182
00:51:28,320 --> 00:51:30,300
这是什么好的关于PHP。

1183
00:51:30,300 --> 00:51:35,610
在PHP中，你有什么被称为
几个超级全局变量。

1184
00:51:35,610 --> 00:51:38,430
他们是那种更
比全局变量非常重要的。

1185
00:51:38,430 --> 00:51:41,370
而这些，所有的资本
正因为如此，配备了PHP。

1186
00:51:41,370 --> 00:51:44,550
所以，如果你有一台服务器，有一个
Web服务器安装，如Apache，

1187
00:51:44,550 --> 00:51:49,390
你安装的语言
对于PHP，突然支持你

1188
00:51:49,390 --> 00:51:52,250
可以开始使用这些超级
在代码中的全局变量。

1189
00:51:52,250 --> 00:51:54,330
>> 什么是好的关于
PHP是，如果你只是

1190
00:51:54,330 --> 00:51:57,540
写在点结尾的文件
PHP，把它放在一个Web服务器上，

1191
00:51:57,540 --> 00:52:01,260
然后提交表单给它
通过这一行动标签和一个表单标签，

1192
00:52:01,260 --> 00:52:05,110
在该action属性
表单标签，PHP和Web

1193
00:52:05,110 --> 00:52:09,360
完全计算出如何抓住
所有这些键值对了

1194
00:52:09,360 --> 00:52:11,633
类似问题的URL
马克Q等于猫，

1195
00:52:11,633 --> 00:52:14,782
它会找出如何q和猫。

1196
00:52:14,782 --> 00:52:17,710
如果您提交的照片，或用户名，
或口令喜欢的Facebook，

1197
00:52:17,710 --> 00:52:21,360
PHP会找出适合你
其中所有的数据都是。

1198
00:52:21,360 --> 00:52:23,821
它会刚刚到手
你一个关联数组

1199
00:52:23,821 --> 00:52:27,560
所谓的美元符号下划线后，
或美元符号下划线得到，

1200
00:52:27,560 --> 00:52:30,590
这取决于你是否是
使用GET或POST提交。

1201
00:52:30,590 --> 00:52:32,950
而且它只会交给你
一个超级全局变量，

1202
00:52:32,950 --> 00:52:37,254
因此，如果你想获得的名字
用户通过该网络提交

1203
00:52:37,254 --> 00:52:41,894
表单，你真的只是说这个名字
超级全局变量，报价，

1204
00:52:41,894 --> 00:52:43,380
引文结束，名称。

1205
00:52:43,380 --> 00:52:46,144
和报价，引文结束的舒适度，
和报价，引文结束的宿舍。

1206
00:52:46,144 --> 00:52:48,810
而且我们要能够做到
这和这么多用PHP。

1207
00:52:48,810 --> 00:52:50,540
即使这是
一阵旋风在它一眼，

1208
00:52:50,540 --> 00:52:51,980
我们将更加下周深入研究。

1209
00:52:51,980 --> 00:52:54,247
我们就为大家介绍一个数据库
这样你实际上是

1210
00:52:54,247 --> 00:52:56,816
将开始实施
自己的电子交易based--

1211
00:52:56,816 --> 00:52:59,150
喜欢的网站，在短短一个星期的时间。

1212
00:52:59,150 --> 00:53:02,750
所以我们会看到你下一次，和
希望你有短信。

1213
00:53:02,750 --> 00:53:05,450
再见。

1214
00:53:05,450 --> 00:53:06,950
>> [音乐播放]

1215
00:53:06,950 --> 00:53:11,450

1216
00:53:11,450 --> 00:53:12,950
>> [门框]

1217
00:53:12,950 --> 00:53:14,475
>> 扬声器2：嘿。

1218
00:53:14,475 --> 00:53:15,350
扬声器3：这是怎么回事？

1219
00:53:15,350 --> 00:53:17,750
扬声器2：你在做什么？

1220
00:53:17,750 --> 00:53:19,850
扬声器3：一个问题工作组。

1221
00:53:19,850 --> 00:53:21,050
扬声器2：好的。

1222
00:53:21,050 --> 00:53:22,550
举手击掌。

1223
00:53:22,550 --> 00:53:23,150
>> [举手击掌]

1224
00:53:23,150 --> 00:53:25,584
>> 什么are--呃，你在这里做什么？

1225
00:53:25,584 --> 00:53:26,750
扬声器3：只是挂出。

1226
00:53:26,750 --> 00:53:28,134
刚从健身房回来。

1227
00:53:28,134 --> 00:53:30,050
我不由得
注意，当我们高击掌相庆，

1228
00:53:30,050 --> 00:53:32,450
你有很粗糙的手。

1229
00:53:32,450 --> 00:53:33,950
你去健身房？

1230
00:53:33,950 --> 00:53:35,150
>> 扬声器2：否。

1231
00:53:35,150 --> 00:53:36,650
第

1232
00:53:36,650 --> 00:53:38,450
>> 扬声器3：哥们，你看上去蛮大的。

1233
00:53:38,450 --> 00:53:45,950
这是不好的，因为每个人都知道
8球是大男人在校园里。

1234
00:53:45,950 --> 00:53:48,050
举手击掌。

1235
00:53:48,050 --> 00:53:49,550
>> 扬声器2：哦，不。

1236
00:53:49,550 --> 00:53:50,450
不，我想我很好。

1237
00:53:50,450 --> 00:53:52,300
我觉得我很好。

1238
00:53:52,300 --> 00:53:54,097