1
00:00:00,000 --> 00:00:05,340

2
00:00:05,340 --> 00:00:07,370
>> 道格·劳埃德：所以我们
在C中做了很多工作，

3
00:00:07,370 --> 00:00:09,536
C是一个非常酷
语言，因为它给你

4
00:00:09,536 --> 00:00:12,840
潜水真正的能力
低电平到你的程序。

5
00:00:12,840 --> 00:00:16,810
我们可以做的事情为
真分钟为操纵

6
00:00:16,810 --> 00:00:18,800
内存单个字节。

7
00:00:18,800 --> 00:00:21,420
回想一下，真正的指针
让我们的灵活性。

8
00:00:21,420 --> 00:00:25,260
>> 但是，我们总是需要有
这细粒度的详细程度

9
00:00:25,260 --> 00:00:26,820
在我们的计划？

10
00:00:26,820 --> 00:00:28,210
或许不会，对不对？

11
00:00:28,210 --> 00:00:30,376
如果我们将有
作为之间的权衡

12
00:00:30,376 --> 00:00:32,911
能够做到真的，真的
分钟的事情，真的，真的

13
00:00:32,911 --> 00:00:35,910
我们没有想到大事情
约，我们没有实现

14
00:00:35,910 --> 00:00:40,290
这些真正的大想法，如果
他们已经内置了对我们来说，

15
00:00:40,290 --> 00:00:43,980
通常用于构建大
方案或大项目，

16
00:00:43,980 --> 00:00:49,130
我们可能会犯错就在身边
具有多语言的东西建

17
00:00:49,130 --> 00:00:51,300
对于我们，而不是有
低层次的东西。

18
00:00:51,300 --> 00:00:53,970
而这也正是PHP真正的用武之地。

19
00:00:53,970 --> 00:00:58,200
>> 现在，其原因之一
我们教CS50 PHP

20
00:00:58,200 --> 00:01:01,020
是它所辖严重的启发
C.而事实上，在我看来，

21
00:01:01,020 --> 00:01:05,140
这里实际有
祖种语言，

22
00:01:05,140 --> 00:01:08,200
是非常普遍的今天。

23
00:01:08,200 --> 00:01:10,110
C和LISP。

24
00:01:10,110 --> 00:01:13,280
而且他们祖先的语言
因为所有其他现代编程

25
00:01:13,280 --> 00:01:17,380
已经开发语言
自那时以来，受到启发

26
00:01:17,380 --> 00:01:20,330
由一个或其他语法上。

27
00:01:20,330 --> 00:01:26,160
PHP是非常相似的语法
到C，而像Scheme语言，

28
00:01:26,160 --> 00:01:27,900
例如，其
你可能听说过，

29
00:01:27,900 --> 00:01:32,070
在很大程度上受语言的启发
叫LISP，这是一个较旧的语言。

30
00:01:32,070 --> 00:01:34,220
>> 因此，我们当教师的原因
PHP在CS50的是，

31
00:01:34,220 --> 00:01:37,730
通过了解c以从根本上
因为你在这一点上，

32
00:01:37,730 --> 00:01:41,280
拿起PHP，它给你的
有能力做更高层次的东西

33
00:01:41,280 --> 00:01:44,710
比C呢，是不是
这么多的一道坎的，

34
00:01:44,710 --> 00:01:48,230
因为你已经有了
的语法的基本思想。

35
00:01:48,230 --> 00:01:50,590
C'S出现了将近
45年在这一点上。

36
00:01:50,590 --> 00:01:52,780
PHP的存在了大约20年。

37
00:01:52,780 --> 00:01:57,080
而在这25年
在程序员之间

38
00:01:57,080 --> 00:02:01,540
确定，他们将多
而有更高层次的能力，

39
00:02:01,540 --> 00:02:04,970
和错误和斗争
在20年间的

40
00:02:04,970 --> 00:02:08,210
导致PHP和其他现代语言。

41
00:02:08,210 --> 00:02:11,039
>> PHP的一个很好的选择
软件语言

42
00:02:11,039 --> 00:02:14,042
这allow--的
软件that--在那里你

43
00:02:14,042 --> 00:02:16,250
需要做的事情，在
C是实际上是复杂的。

44
00:02:16,250 --> 00:02:18,480
因此，例如，工作
在C字符串

45
00:02:18,480 --> 00:02:21,709
是非常复杂的，因为
因为我们知道，在C字符串

46
00:02:21,709 --> 00:02:23,250
真的字符只是阵列。

47
00:02:23,250 --> 00:02:25,230
这不是一个内建的数据类型。

48
00:02:25,230 --> 00:02:28,220
或许更重要的是，
这是我们甚至没有覆盖C，

49
00:02:28,220 --> 00:02:30,360
如果你需要做什么
一些计算机网络？

50
00:02:30,360 --> 00:02:30,860
好吧？

51
00:02:30,860 --> 00:02:34,920
>> C有这样做的能力，但它是如此
晦涩难懂，因此很难真正做到。

52
00:02:34,920 --> 00:02:37,580
那岂不是很好，如果
语言有一个内置的，简单的方法

53
00:02:37,580 --> 00:02:38,910
实现联网？

54
00:02:38,910 --> 00:02:43,420
和PHP是一种语言，使的是，
或便利的是，相当多的。

55
00:02:43,420 --> 00:02:47,740
正如我所说的，PHP是非常沉重的启发
由C.语法是非常相似的。

56
00:02:47,740 --> 00:02:51,760
所以它应该有希望使
过渡从一个到另一个

57
00:02:51,760 --> 00:02:54,710
比一些稍微有点软
其他语言可能。

58
00:02:54,710 --> 00:02:58,800
>> 开始写PHP，只需打开
文件以.php文件扩展名。

59
00:02:58,800 --> 00:03:00,670
从技术上讲，这不是
实际需要，

60
00:03:00,670 --> 00:03:04,495
但如果你想要像语法
突出了IDE，因此该类型

61
00:03:04,495 --> 00:03:07,620
名，或变量名，函数，
你知道，语言的关键字

62
00:03:07,620 --> 00:03:10,090
在突出显示
特定的颜色，你一般

63
00:03:10,090 --> 00:03:14,020
要使用命名您的文件
一个特定的文件扩展名。

64
00:03:14,020 --> 00:03:18,430
因此，我们已经命名我们的文件以.php
扩展名，但后来也用PHP，

65
00:03:18,430 --> 00:03:23,310
所有我们写的PHP代码
文件必须包含在这些PHP

66
00:03:23,310 --> 00:03:25,190
分隔符，我们看到
这里在屏幕上。

67
00:03:25,190 --> 00:03:27,910
尖括号？PHP的开始。

68
00:03:27,910 --> 00:03:30,860
然后我们写我们所有的PHP
我们要在两者之间的代码。

69
00:03:30,860 --> 00:03:32,260
接着 ？

70
00:03:32,260 --> 00:03:34,710
尖括号关闭。

71
00:03:34,710 --> 00:03:37,170
>> 如果我们不这样做，那么
什么会发生？

72
00:03:37,170 --> 00:03:38,170
它不会崩溃。

73
00:03:38,170 --> 00:03:39,410
它不会
真的毁了我们的计划。

74
00:03:39,410 --> 00:03:41,440
但它不会有
我们想要的效果。

75
00:03:41,440 --> 00:03:44,540
这是怎么回事发生，真的，
当我们尝试并运行这个程序，

76
00:03:44,540 --> 00:03:50,330
一切不是那些分隔符之间
将要被逐字打印出来。

77
00:03:50,330 --> 00:03:52,210
它不会
实际执行的代码，

78
00:03:52,210 --> 00:03:56,010
这将只
逐字打印出来。

79
00:03:56,010 --> 00:03:57,320
>> 现在为什么是这样？

80
00:03:57,320 --> 00:04:00,416
所以C是什么知
作为一种编译语言。

81
00:04:00,416 --> 00:04:03,040
你可能熟悉
使你的程序的步骤，

82
00:04:03,040 --> 00:04:07,820
打开.c文件和.h文件
与使一个单一的可执行文件，

83
00:04:07,820 --> 00:04:11,130
特别是使用
铛为我们的编译器。

84
00:04:11,130 --> 00:04:13,030
PHP，不过，不
有此等价的。

85
00:04:13,030 --> 00:04:15,600
PHP是所谓的
解释语言。

86
00:04:15,600 --> 00:04:16,760
什么意思呢？

87
00:04:16,760 --> 00:04:20,680
>> 嗯，这意味着我们不必转换
我们的源代码，以零和一

88
00:04:20,680 --> 00:04:21,470
预先。

89
00:04:21,470 --> 00:04:23,900
相反，有一个程序，
其也被称为

90
00:04:23,900 --> 00:04:29,771
PHP是一种理解PHP和
那种可以把它的飞行。

91
00:04:29,771 --> 00:04:32,520
这并不是真正的完全准确，
但是这是一个非常好的比喻

92
00:04:32,520 --> 00:04:33,760
发生的事情。

93
00:04:33,760 --> 00:04:37,230
它解释这些
零和一的飞行。

94
00:04:37,230 --> 00:04:40,160
因此，如果它不知道
如何处理事情，

95
00:04:40,160 --> 00:04:42,800
如果它不知道如何
过程PHP，你可能

96
00:04:42,800 --> 00:04:44,680
希望把该文本在那里，对不对？

97
00:04:44,680 --> 00:04:48,960
>> 你可能希望把代码
还有，即使它不是PHP--之间

98
00:04:48,960 --> 00:04:50,035
PHP的分隔符。

99
00:04:50,035 --> 00:04:51,910
但是 - 所以它不会
要删除帐户，

100
00:04:51,910 --> 00:04:53,576
它只是将基本放弃它。

101
00:04:53,576 --> 00:04:55,550
因此，这将打印
它输出到屏幕。

102
00:04:55,550 --> 00:04:57,150
>> 这似乎是这是一个坏
的事情，但实际上它是

103
00:04:57,150 --> 00:04:58,220
要成为一个真正的
一件好事，因为我们将

104
00:04:58,220 --> 00:05:00,390
看看当我们谈论
PHP网站开发，

105
00:05:00,390 --> 00:05:04,010
因为这意味着我们可以
点缀PHP和HTML。

106
00:05:04,010 --> 00:05:06,640
我们可以共同使用这些技术
创建一个更加动态的Web页面。

107
00:05:06,640 --> 00:05:10,650
但更多的，在
视频PHP的Web开发。

108
00:05:10,650 --> 00:05:12,021
>> 那么，什么是PHP语法？

109
00:05:12,021 --> 00:05:13,520
这就是这部影片的全部意义所在。

110
00:05:13,520 --> 00:05:14,850
让我们来谈谈吧。

111
00:05:14,850 --> 00:05:16,490
>> 所以，展开，取出，变量。

112
00:05:16,490 --> 00:05:18,030
PHP变量存在。

113
00:05:18,030 --> 00:05:20,067
只是有两个大
从C差异

114
00:05:20,067 --> 00:05:21,900
第一是，有
没有类型说明符。

115
00:05:21,900 --> 00:05:24,245
我们没有说INT，
char和float，所有的东西。

116
00:05:24,245 --> 00:05:25,620
我们没有做到这一点了。

117
00:05:25,620 --> 00:05:26,810
PHP是一种现代语言。

118
00:05:26,810 --> 00:05:28,910
它可以计算出你在做什么
试图做或做一个最好的

119
00:05:28,910 --> 00:05:30,451
想为你想要做的事。

120
00:05:30,451 --> 00:05:31,700
所以，这是相当不错的。

121
00:05:31,700 --> 00:05:35,330
>> 另一件事是，所有变量
名称必须以一个美元符号。

122
00:05:35,330 --> 00:05:36,940
这只是一些习惯。

123
00:05:36,940 --> 00:05:39,496
这是一个有点古怪，因为
它使PHP可以理解

124
00:05:39,496 --> 00:05:40,870
什么是可变的，什么不是。

125
00:05:40,870 --> 00:05:43,340
所以，每一个变量名
始于一个美元符号。

126
00:05:43,340 --> 00:05:46,884
因此，在C中，我们可能会说
这样，INT X = 54。

127
00:05:46,884 --> 00:05:48,550
我们不必这样做了在PHP。

128
00:05:48,550 --> 00:05:52,540
我们只能说$ X = 54。

129
00:05:52,540 --> 00:05:55,920
我们可以说，例如，在C，
如果我们磅包括CS50 .H

130
00:05:55,920 --> 00:06:00,314
头文件中，我们可以说
串词=“这是CS50。”

131
00:06:00,314 --> 00:06:01,980
我们没有做，在PHP中，虽然。

132
00:06:01,980 --> 00:06:04,865
我们只能说$短语
=“这是CS50。”

133
00:06:04,865 --> 00:06:08,760
而事实上，串现
在PHP一个内置数据类型，

134
00:06:08,760 --> 00:06:10,950
或者更确切地说，PHP懂得
什么是字符串。

135
00:06:10,950 --> 00:06:15,612
它是独立于阵列
字符的像它是在C

136
00:06:15,612 --> 00:06:17,570
所有您最喜爱的
从C条件语句

137
00:06:17,570 --> 00:06:19,520
仍然可以供您使用。

138
00:06:19,520 --> 00:06:21,140
所以没有什么大的转变存在。

139
00:06:21,140 --> 00:06:23,400
我们可以say--我们可以有
如果这样的语句。

140
00:06:23,400 --> 00:06:28,210
如果$ Y 43，或$ Z = 15。

141
00:06:28,210 --> 00:06:29,690
所以这是非常简单的。

142
00:06:29,690 --> 00:06:31,980
我们可以有，如果和其他人。

143
00:06:31,980 --> 00:06:34,210
我们可以有if和else if。

144
00:06:34,210 --> 00:06:36,430
>> 而发现一些
相当不错的位置，而这

145
00:06:36,430 --> 00:06:39,620
是那种那些之一
PHP的优势与C，通知

146
00:06:39,620 --> 00:06:41,510
我们没有使用什么功能吗？

147
00:06:41,510 --> 00:06:47,737
我们使用==来比较
变量$名称，为字符串。

148
00:06:47,737 --> 00:06:49,070
我们不能这样做，在C，对不对？

149
00:06:49,070 --> 00:06:53,200
我们不得不使用调用的函数
STRCOMP或StrEndComp或任何

150
00:06:53,200 --> 00:06:54,840
其相关的表兄弟。

151
00:06:54,840 --> 00:06:56,980
>> 所以，我们已经看到这些优势。

152
00:06:56,980 --> 00:07:00,930
我们并没有做什么
愚蠢或者不直观

153
00:07:00,930 --> 00:07:03,540
作为调用一个调用的函数
STRCOMP如果我只是想测试

154
00:07:03,540 --> 00:07:05,237
是否一个值等于一个字符串。

155
00:07:05,237 --> 00:07:07,820
我可以只使用等于等号，
就像我可以做任何事情。

156
00:07:07,820 --> 00:07:09,560
因此，有一个优势。

157
00:07:09,560 --> 00:07:13,350
>> 有时，顺便说一句，你可能
看到否则，如果为一个字，ELSEIF。

158
00:07:13,350 --> 00:07:14,910
而这在PHP中确定为好。

159
00:07:14,910 --> 00:07:17,020
所以，有时你可能会看到这一点。

160
00:07:17,020 --> 00:07:17,790
这不是一个错字。

161
00:07:17,790 --> 00:07:21,830
PHP实际上理解ELSEIF。

162
00:07:21,830 --> 00:07:23,980
我不知道他们为什么
决定实施的，

163
00:07:23,980 --> 00:07:28,220
但正如我们已经见过很多次
在我们的影片到目前为止，

164
00:07:28,220 --> 00:07:30,460
我们程序员喜欢它，如果
我们可以做的事情迅速，

165
00:07:30,460 --> 00:07:33,660
因此摆脱了空间
显然是一个很大的优势。

166
00:07:33,660 --> 00:07:34,800
>> 这就是，如果和ELSEIF。

167
00:07:34,800 --> 00:07:37,540
我们也有三元运算符，
召回问号冒号，

168
00:07:37,540 --> 00:07:43,262
对于非常短的形式，如果其他人
或有条件的分支。

169
00:07:43,262 --> 00:07:45,470
而且显然，在此，
我们想在这里做什么

170
00:07:45,470 --> 00:07:49,720
被分配变量
$信真或假，

171
00:07:49,720 --> 00:07:54,110
这取决于是否是$ var
为英文字母。

172
00:07:54,110 --> 00:07:57,320
因此，这是非常相似，因而isalpha
我们很熟悉的C.

173
00:07:57,320 --> 00:07:59,010
这有点相当于在PHP中。

174
00:07:59,010 --> 00:08:01,550
的功能是很明显
叫而ctype_alpha，

175
00:08:01,550 --> 00:08:03,450
但是这就是我们如何做到这一点在PHP。

176
00:08:03,450 --> 00:08:08,560
所以，这一切都将是是，如果
$ var是一个字母，$封信是真实的。

177
00:08:08,560 --> 00:08:13,820
如果是$ var是不是一个字母，
$信是假的。

178
00:08:13,820 --> 00:08:15,820
>> 我们也仍然有switch语句。

179
00:08:15,820 --> 00:08:17,870
我们还记得由C为好。

180
00:08:17,870 --> 00:08:22,480
在最高层那里，那我们怎么办
像GET int或得到字符串。

181
00:08:22,480 --> 00:08:23,845
因此，PHP有一个内置的。

182
00:08:23,845 --> 00:08:25,470
我们不需要CS50库了。

183
00:08:25,470 --> 00:08:27,237
我们可以只使用该功能的ReadLine。

184
00:08:27,237 --> 00:08:29,820
什么是会做的是打印
出消息，“你的状态，

185
00:08:29,820 --> 00:08:33,820
请“，然后闪烁提示
等待用户输入

186
00:08:33,820 --> 00:08:34,739
一些信息。

187
00:08:34,739 --> 00:08:36,530
现在注意什么
我们可以用开关做。

188
00:08:36,530 --> 00:08:39,105
如果你以前使用过它，
你可能还记得，开关

189
00:08:39,105 --> 00:08:44,960
仅限几乎为整数，并
人物，但现在我们可以使用字符串。

190
00:08:44,960 --> 00:08:50,190
而事实上，switch语句
在PHP是相当多的灵活

191
00:08:50,190 --> 00:08:54,880
比C.其表弟

192
00:08:54,880 --> 00:08:55,380
循环。

193
00:08:55,380 --> 00:08:58,130
就像条件句，所有的
你的老歌依然存在。

194
00:08:58,130 --> 00:09:00,740
我们有while循环的计算
从1到在这种情况下，100。

195
00:09:00,740 --> 00:09:03,940
我们已经做while循环
表示，计数从1到100，

196
00:09:03,940 --> 00:09:06,200
我们有for循环
表示，计数从1到100。

197
00:09:06,200 --> 00:09:07,220
所以没有什么大的飞跃那里。

198
00:09:07,220 --> 00:09:09,360
语法是相当
多完全一样，

199
00:09:09,360 --> 00:09:11,760
除了现在我们使用
美元符号变量，而不是

200
00:09:11,760 --> 00:09:17,260
声明整数变量或
这样的事情对我们的专柜。

201
00:09:17,260 --> 00:09:20,090
>> 这就是事情得到一个
很多优于C，虽然。

202
00:09:20,090 --> 00:09:21,020
阵列。

203
00:09:21,020 --> 00:09:23,020
所以，记得当时我们
谈到C，以

204
00:09:23,020 --> 00:09:25,560
为我们成长和收缩
信息集，

205
00:09:25,560 --> 00:09:28,310
我们需要进行排序默认
这一想法的一个链表，

206
00:09:28,310 --> 00:09:30,780
因为C数组是固定大小。

207
00:09:30,780 --> 00:09:31,800
我们不能缩小它们。

208
00:09:31,800 --> 00:09:32,930
我们不能生长他们。

209
00:09:32,930 --> 00:09:36,074
我们不得不重新分配内存
做这一切疯狂

210
00:09:36,074 --> 00:09:38,490
或使用链表，这
占用相当多的空间。

211
00:09:38,490 --> 00:09:41,590
但在PHP中，阵列
大小不是固定的了。

212
00:09:41,590 --> 00:09:43,240
他们可以成长，他们可以收缩。

213
00:09:43,240 --> 00:09:46,660
如此反复，这20年间所存在
C的第一个版本之间

214
00:09:46,660 --> 00:09:49,440
并首次发布PHP，
我们决定，你知道，

215
00:09:49,440 --> 00:09:51,670
这将是非常巨大的
如果我们能做到这一点。

216
00:09:51,670 --> 00:09:54,100
因此，我们实现这一点。

217
00:09:54,100 --> 00:09:58,040
>> 所以PHP数组是不固定的
大小，因为PHP并没有真正

218
00:09:58,040 --> 00:10:03,090
有程序员朝前
类型的概念，

219
00:10:03,090 --> 00:10:05,110
我们可以混合数据类型
在我们的阵列了。

220
00:10:05,110 --> 00:10:08,100
因此，我们甚至没有使用所有
整数或全部飘点，

221
00:10:08,100 --> 00:10:12,826
我们可以拥有所有的混合
不同种在一个阵列。

222
00:10:12,826 --> 00:10:14,700
声明数组是
很简单。

223
00:10:14,700 --> 00:10:16,116
这就像任何其他变量。

224
00:10:16,116 --> 00:10:20,020
$ NUMS =阵列（1，2，3，
4），阵列是一个功能

225
00:10:20,020 --> 00:10:22,760
这是内置到PHP的
将创建一个数组为您服务。

226
00:10:22,760 --> 00:10:28,315
这产生四个值的阵列，
在这种情况下的数字，称为$ NUMS。

227
00:10:28,315 --> 00:10:29,940
而且也做一个以上的方式。

228
00:10:29,940 --> 00:10:32,420
而且我们要
看到这个有很多，在PHP。

229
00:10:32,420 --> 00:10:36,380
PHP已经开发了许多不同的
人的发展和增长和增长。

230
00:10:36,380 --> 00:10:40,050
有平时不只是两个或
三种方式做一些事情在PHP中，

231
00:10:40,050 --> 00:10:42,170
通常有像10或20。

232
00:10:42,170 --> 00:10:45,300
这只是另一种常见的
方法来声明数组。

233
00:10:45,300 --> 00:10:48,310
$ NUMS =正方形支架1，2，3，4。

234
00:10:48,310 --> 00:10:53,170
因此，这是有点类似C的角度
br--大括号标记，而。 $  - 

235
00:10:53,170 --> 00:10:58,525
否则会是int NUMS方
括号等于大括号1，2，3，4。

236
00:10:58,525 --> 00:11:02,710
在PHP是$ NUMS =方
支架1，2，3，4。

237
00:11:02,710 --> 00:11:08,920
但是，这两个例子在这里给我
四个在这种情况下，整数的数组。

238
00:11:08,920 --> 00:11:10,920
>> 如果我想钉东西呢？

239
00:11:10,920 --> 00:11:14,760
嗯，我只能说$ NUMS 4，这
再次，我们仍然从0这里计数

240
00:11:14,760 --> 00:11:17,800
在PHP中，将第五
数组的元素。

241
00:11:17,800 --> 00:11:18,990
我只能这么说。

242
00:11:18,990 --> 00:11:22,860
我不会遭受SEG
故障，因为我的数组只是

243
00:11:22,860 --> 00:11:24,337
要增长以容纳。

244
00:11:24,337 --> 00:11:25,420
这是相当不错的，对不对？

245
00:11:25,420 --> 00:11:28,400
而事实上，我甚至都不需要
指定我想要把它。

246
00:11:28,400 --> 00:11:31,220
我只能说这个，只是
钉正确坚持到最后，

247
00:11:31,220 --> 00:11:34,099
或者，我可以甚至只是
说$ NUMS 20或1000。

248
00:11:34,099 --> 00:11:35,140
这其实并不重要。

249
00:11:35,140 --> 00:11:38,330
它仍然只是去
对上钉到年底。

250
00:11:38,330 --> 00:11:41,490
>> 因此，我可以成长，as--我们
不会掩盖它在这里，

251
00:11:41,490 --> 00:11:45,360
但我可以拼接或条状
元素从数组中为好，

252
00:11:45,360 --> 00:11:50,064
和数组将收​​缩以适应
现在缺失或空白区域。

253
00:11:50,064 --> 00:11:52,230
还有另一种方式来钉
东西上的阵列，

254
00:11:52,230 --> 00:11:54,330
这是一种称为array_push函数。

255
00:11:54,330 --> 00:11:57,860
如此反复，只是这种想法是
能够做到的事情很多不同的方式。

256
00:11:57,860 --> 00:12:01,950
因此，我们已经看到了三种不同的方式，现在
到粘性另一元件上的阵列。

257
00:12:01,950 --> 00:12:06,900
因此，这又增加了一个元素
到$ NUMS数组的末尾。

258
00:12:06,900 --> 00:12:08,340
我们可以混淆了我们的数据类型。

259
00:12:08,340 --> 00:12:13,110
所以，我有不是一个数组
1，2，3，4，但1，真实，3，4，

260
00:12:13,110 --> 00:12:16,420
其中true是一个布尔值，然后
如果我想钉在另一个元素

261
00:12:16,420 --> 00:12:20,860
该阵列，也许是一个字符串，
字符串“五，”我能做到这一点。

262
00:12:20,860 --> 00:12:26,110
现在我的数组会
是1，真实的，3，4，5。

263
00:12:26,110 --> 00:12:28,640
这个词五，而不是整数5。

264
00:12:28,640 --> 00:12:31,270
因此，具有很大的灵活性存在。

265
00:12:31,270 --> 00:12:33,290
>> 灵活性得到
更妙的是，虽然，

266
00:12:33,290 --> 00:12:37,530
因为PHP拥有的东西支持
称为关联数组。

267
00:12:37,530 --> 00:12:40,660
而我们那种隐约谈到
在C中有关关联数组

268
00:12:40,660 --> 00:12:44,740
在哈希表的情况下，因为
有什么关联数组是真正的所有

269
00:12:44,740 --> 00:12:48,950
关于正在关键
值对映射。

270
00:12:48,950 --> 00:12:53,410
而且在这种情况下，如果keys--
我们熟悉的C数组，

271
00:12:53,410 --> 00:12:55,440
键是索引编号。

272
00:12:55,440 --> 00:12:57,530
0，1，2，3。

273
00:12:57,530 --> 00:13:03,070
和值是什么，我们发现，
阵列0，阵列1，阵列2，依此类推。

274
00:13:03,070 --> 00:13:06,310
所以，键是索引，
和的值是

275
00:13:06,310 --> 00:13:10,060
什么是该数组中的位置，
通过该索引指定。

276
00:13:10,060 --> 00:13:15,130
>> 但在PHP中，我们没有做到这一点
概念阵列0，阵列1，阵列2

277
00:13:15,130 --> 00:13:15,830
了。

278
00:13:15,830 --> 00:13:21,025
我们现在可以用实际的话
以键映射到值。

279
00:13:21,025 --> 00:13:22,650
所以我可以说这样的事情。

280
00:13:22,650 --> 00:13:26,710
我可以用创建数组
方括号的语法如下。

281
00:13:26,710 --> 00:13:30,685
$比萨饼=括号
“奶酪”，然后

282
00:13:30,685 --> 00:13:37,210
这种双箭头符号，
8.99，“辣”，箭头10.99-- 9.99，

283
00:13:37,210 --> 00:13:37,880
等等。

284
00:13:37,880 --> 00:13:39,060
所以，这是怎么回事吗？

285
00:13:39,060 --> 00:13:41,040
什么是我真正在做什么？

286
00:13:41,040 --> 00:13:43,990
我创建键值对映射。

287
00:13:43,990 --> 00:13:49,060
因此，而不是说，例如，
比萨饼0，1片，比萨饼2，

288
00:13:49,060 --> 00:13:52,350
我现在可以说的比萨饼
奶酪，香肠比萨饼，

289
00:13:52,350 --> 00:13:55,120
并参考值
与之相关联。

290
00:13:55,120 --> 00:13:56,970
>> 因此，这里有我们的钥匙为绿色。

291
00:13:56,970 --> 00:13:59,870
奶酪，香肠，
蔬菜，水牛鸡。

292
00:13:59,870 --> 00:14:04,200
这里是使箭头
该键值对的映射。

293
00:14:04,200 --> 00:14:07,420
然后这里的值
在该阵列的位置。

294
00:14:07,420 --> 00:14:10,330
因此，这等于是说阵列0等于8.99。

295
00:14:10,330 --> 00:14:11,720
最关键的是0。

296
00:14:11,720 --> 00:14:13,600
该值是8.99。

297
00:14:13,600 --> 00:14:19,370
我现在可以说阵列奶酪，或在此
案例比萨奶酪，奶酪是关键，

298
00:14:19,370 --> 00:14:23,340
而且我发现在
比萨奶酪是8.99。

299
00:14:23,340 --> 00:14:25,540
这就是我发现那里的价值。

300
00:14:25,540 --> 00:14:28,124
>> 因此，我可以说这样的话。
$比萨奶酪= 7.99。

301
00:14:28,124 --> 00:14:29,040
说我有一个转让。

302
00:14:29,040 --> 00:14:31,750
我想dis--我要降
奶酪比萨饼的价格。

303
00:14:31,750 --> 00:14:35,620
或者，我可以用蔬菜
比萨饼的条件的一部分，

304
00:14:35,620 --> 00:14:39,990
或者我可以添加新的元素，我
阵列，就像我可以做以前。

305
00:14:39,990 --> 00:14:44,680
我可以添加新的元素，这
关联数组键“腊肉”

306
00:14:44,680 --> 00:14:49,250
和值13.49。

307
00:14:49,250 --> 00:14:53,820
>> 但这种引入了一个问题，
如果你想想看一秒钟。

308
00:14:53,820 --> 00:14:55,721
我们如何在这个数组中循环？

309
00:14:55,721 --> 00:14:56,220
对？

310
00:14:56,220 --> 00:14:59,820
在C语言中，我们只是有一个
for循环，典型地，该

311
00:14:59,820 --> 00:15:03,650
在从0运行至
减1的阵列的大小。

312
00:15:03,650 --> 00:15:08,060
阵列具有在n个元件，所述
有效的索引是0到n减去1。

313
00:15:08,060 --> 00:15:11,530
因此，我们可以使用一个for循环
逐步完成每一个元素。

314
00:15:11,530 --> 00:15:13,530
>> 但是，这不是真的
一样了，对不对？

315
00:15:13,530 --> 00:15:17,360
现在，我们有键值对
映射，其中键是的话，

316
00:15:17,360 --> 00:15:19,970
我们如何遍历所有的话吗？

317
00:15:19,970 --> 00:15:22,420
好了，幸运的是，PHP有
一个方法来处理这​​件事，

318
00:15:22,420 --> 00:15:24,580
所以我们会跳回
以循环为第二

319
00:15:24,580 --> 00:15:30,780
引入第四种循环的
存在于PHP称为foreach循环。

320
00:15:30,780 --> 00:15:34,430
什么foreach循环的作用是
它基本上是同样的想法。

321
00:15:34,430 --> 00:15:36,060
你可以用它为任何类型的数组。

322
00:15:36,060 --> 00:15:38,100
但它基本上是
同样的想法作为一个for循环，

323
00:15:38,100 --> 00:15:40,750
只是，而不是使用
索引号，你只要

324
00:15:40,750 --> 00:15:45,830
有这样的语法怪异在哪里
你叫的每一个元素

325
00:15:45,830 --> 00:15:47,550
一个名称这个循环的目的。

326
00:15:47,550 --> 00:15:49,258
>> 因此，在这种情况下，
的foreach（$数组$键）。

327
00:15:49,258 --> 00:15:52,900

328
00:15:52,900 --> 00:15:56,450
基本上，该评论指出，
这foreach循环内，

329
00:15:56,450 --> 00:16:00,466
它会走了过来每一个
$阵列，其通常的元件

330
00:16:00,466 --> 00:16:03,340
将是一个关联数组，
但真正能成为任何类型的数组

331
00:16:03,340 --> 00:16:05,419
要在PHP。

332
00:16:05,419 --> 00:16:07,210
而每一次，在
一个for循环你可能

333
00:16:07,210 --> 00:16:13,780
说$数组方括号
$我，你可以只说$键。

334
00:16:13,780 --> 00:16:22,340
这样$键变成一个别名为每
你的PHP关联数组的索引，

335
00:16:22,340 --> 00:16:23,710
所以你可以使用它这样。

336
00:16:23,710 --> 00:16:25,897
>> 因此，例如，我们已经
现在得到我们的比萨饼阵列。

337
00:16:25,897 --> 00:16:27,730
那种我塞到
到角落里有

338
00:16:27,730 --> 00:16:31,080
所以我们可以用它做一个简单的例子。

339
00:16:31,080 --> 00:16:36,420
如果我说的foreach（$比萨饼
$比萨饼），好了，发生了什么？

340
00:16:36,420 --> 00:16:42,400
好吧，我会遍历每个
数组$比萨饼的单个元素，

341
00:16:42,400 --> 00:16:46,670
并在这样做，我会打电话给
每一个元素，当我里面

342
00:16:46,670 --> 00:16:49,400
对身体的循环，$比萨饼。

343
00:16:49,400 --> 00:16:52,440
>> 所以这是形式的
替身，回忆，那$比萨饼

344
00:16:52,440 --> 00:16:59,140
是替身的说法
$比萨饼方括号$ I

345
00:16:59,140 --> 00:17:03,370
如果我们用一个for循环，在那里我们
可以去从$ i = 0到，在这种情况下，

346
00:17:03,370 --> 00:17:06,089
$ I = 3。

347
00:17:06,089 --> 00:17:09,780
如果我们没有键值对
这里，这将是元件0，1，2，3，

348
00:17:09,780 --> 00:17:16,390
我们会用一个for循环去
$比萨饼0，$比萨饼1​​，$比萨饼2，

349
00:17:16,390 --> 00:17:17,750
$比萨饼3。

350
00:17:17,750 --> 00:17:23,130
所以，现在只需$比萨饼代
该专用密钥。

351
00:17:23,130 --> 00:17:25,630
>> 那么，这是怎么回事打印出来？

352
00:17:25,630 --> 00:17:29,030
我打印出$比萨饼。

353
00:17:29,030 --> 00:17:35,270
我该怎么找at--
如果我打印出$比萨饼，$ I？

354
00:17:35,270 --> 00:17:35,770
对？

355
00:17:35,770 --> 00:17:38,680
如果我要打印出来
比萨饼的第i个元素，

356
00:17:38,680 --> 00:17:40,070
我该怎么打印？

357
00:17:40,070 --> 00:17:42,580
我要打印出来的
在该位置值，对不对？

358
00:17:42,580 --> 00:17:45,370
就像如果我们这样做
这在C的范围内，

359
00:17:45,370 --> 00:17:49,786
我们通常不会使用我们的迭代器
变量，INT I = 0，i为小于3，

360
00:17:49,786 --> 00:17:52,900
我+ +，打印出0，1，2，3。

361
00:17:52,900 --> 00:17:57,500
我们打​​印出数组0，
阵列1，阵列2，阵列3。

362
00:17:57,500 --> 00:17:59,580
所以这是什么打印出来是这样的。

363
00:17:59,580 --> 00:18:01,150
它的价格列表。

364
00:18:01,150 --> 00:18:05,750
8.99，9.99，10.99，11.99。

365
00:18:05,750 --> 00:18:06,900
>> 现在，快速注意到这里。

366
00:18:06,900 --> 00:18:10,900
foreach循环并不一定
为了打印出的东西。

367
00:18:10,900 --> 00:18:12,770
它不能保证。

368
00:18:12,770 --> 00:18:13,550
它通常不会。

369
00:18:13,550 --> 00:18:17,667
它通常设在顺序
该元素被添加到阵列中，

370
00:18:17,667 --> 00:18:18,750
因此只需牢记这一点。

371
00:18:18,750 --> 00:18:20,830
它可能不是为了。

372
00:18:20,830 --> 00:18:23,930
但foreach循环将遍历
横跨每一个元件

373
00:18:23,930 --> 00:18:25,060
所讨论的阵列。

374
00:18:25,060 --> 00:18:27,980
在这种情况下，再次，
该数组是$比萨饼。

375
00:18:27,980 --> 00:18:32,920
>> 如果我可以改变语法，不过，
我想同时得到键和值。

376
00:18:32,920 --> 00:18:37,179
与其说$比萨饼
为$比萨饼，我可以这样说。

377
00:18:37,179 --> 00:18:39,470
如果你看一下我所
这里以绿色突出显示，

378
00:18:39,470 --> 00:18:42,130
它看起来像一个键值对映射。

379
00:18:42,130 --> 00:18:45,980
所以，如果你 - 即使你是不是
完全知道它要干什么，

380
00:18:45,980 --> 00:18:49,300
你可能已经猜到
即$馅料是怎么回事

381
00:18:49,300 --> 00:18:53,800
要在这种情况下，键和
$价格将是价值。

382
00:18:53,800 --> 00:18:59,200
所以我现在替换的每一个元素
的$比萨作为一个键值对，

383
00:18:59,200 --> 00:19:03,900
现在我可以参考的关键和
值，这可能会派上用场，

384
00:19:03,900 --> 00:19:05,590
例如，如下所述。

385
00:19:05,590 --> 00:19:10,170
>> “一个整体” - 这是一个很大的
印刷回事这里 - “一个整体”

386
00:19:10,170 --> 00:19:17,300
一流“比萨饼成本$”的价格，然后
我打印出一个句点和一个反斜杠ñ。

387
00:19:17,300 --> 00:19:23,420
所以，现在，通知我再一次有机会获得
一个键，$摘心，和一个值，$价格。

388
00:19:23,420 --> 00:19:26,647
所以，你能猜出这是什么
将要打印出来？

389
00:19:26,647 --> 00:19:29,480
有很多打印报表，
但只有一个反斜杠N，

390
00:19:29,480 --> 00:19:33,410
所以它要打印的东西
在一个单一的代码行的entire--。

391
00:19:33,410 --> 00:19:36,965
>> 如果我可以参阅键
和的值，则现在，

392
00:19:36,965 --> 00:19:39,090
而不是仅仅能够
打印出来的价格，

393
00:19:39,090 --> 00:19:41,330
我可以打印出这样的事情。

394
00:19:41,330 --> 00:19:43,780
“整整一个奶酪比萨售价$ 8,99。”

395
00:19:43,780 --> 00:19:47,150
而现在，我使用所有的keys--的
奶酪，香肠，蔬菜，

396
00:19:47,150 --> 00:19:49,640
水牛chicken--和的值。

397
00:19:49,640 --> 00:19:53,980
8.99，9.99，10.99，11.99于是
这只是一种不同的方式

398
00:19:53,980 --> 00:19:57,840
做一个foreach循环，而不是
只是给你访问到的值，

399
00:19:57,840 --> 00:20:02,950
它只是给你 - 它给你
访问的键和值。

400
00:20:02,950 --> 00:20:04,411
>> 因此打印出的信息。

401
00:20:04,411 --> 00:20:07,410
我已经做了几个
不同的方式，你可能已经注意到。

402
00:20:07,410 --> 00:20:11,080
这两个函数，我们已经主要
看到的都是打印和回声。

403
00:20:11,080 --> 00:20:14,380
而对于几乎所有意图和
目的，他们是完全一样的。

404
00:20:14,380 --> 00:20:17,130
They're--有一个非常微妙
区别这不值得

405
00:20:17,130 --> 00:20:21,130
进入，但基本上无处不在
您可以使用打印你大概可以使用

406
00:20:21,130 --> 00:20:22,370
回声也是如此。

407
00:20:22,370 --> 00:20:23,610
>> 而这还不是只有两个。

408
00:20:23,610 --> 00:20:26,970
PHP有很多不同
方法来打印东西出来，

409
00:20:26,970 --> 00:20:30,520
它也有方法来整合
变量到字符串中间。

410
00:20:30,520 --> 00:20:32,860
因此，从C回想一下，你
记得有什么功能

411
00:20:32,860 --> 00:20:37,580
我们可以用它来替代变量
成的事情，我们要打印出来？

412
00:20:37,580 --> 00:20:40,160
你可能使用此
功能相当多。

413
00:20:40,160 --> 00:20:42,290
printf的，对不对？

414
00:20:42,290 --> 00:20:45,290
因此，这是我们以前里面有
我们foreach循环的上下文中。

415
00:20:45,290 --> 00:20:48,000
我们有这五个
单独的打印报表，

416
00:20:48,000 --> 00:20:50,330
因为这是唯一的
这样，我真的知道的时候

417
00:20:50,330 --> 00:20:52,450
如何打印出消息。

418
00:20:52,450 --> 00:20:59,560
我不知道如何整合
变量$摘心到我的PHP代码。

419
00:20:59,560 --> 00:21:03,700
好吧，如果我只是采取了胡乱猜测，
printf的，它实际上会起作用。

420
00:21:03,700 --> 00:21:08,980
printf的是，我可以用一个函数
在PHP中，就像我可以在C使用

421
00:21:08,980 --> 00:21:11,880
>> 所以这样的事情，printf的，
再次，我们很熟悉。

422
00:21:11,880 --> 00:21:16,420
第一个％s被替换
与$摘心的价值。

423
00:21:16,420 --> 00:21:19,700
第二个％s被替换
与$价格的价值。

424
00:21:19,700 --> 00:21:22,630
所以我interpellating，
这仅仅是一个奇特的方式

425
00:21:22,630 --> 00:21:25,400
对他说，我坚持了
变量到该位置。

426
00:21:25,400 --> 00:21:31,000
所以我堵在$摘心地方
红色％s是和$的价格，其中蓝色％S

427
00:21:31,000 --> 00:21:36,060
是，然后我就得到消息，
“整整一个奶酪比萨售价$ 8,99。”

428
00:21:36,060 --> 00:21:37,750
>> 不是我能做到这一点，但唯一的办法。

429
00:21:37,750 --> 00:21:39,760
也许我会想使用此方法。

430
00:21:39,760 --> 00:21:44,890
其实，这是什么是最常见的
所谓可变质询。

431
00:21:44,890 --> 00:21:45,690
我可以用一个回音。

432
00:21:45,690 --> 00:21:47,737
我可以使用打印也一样，我们拭目以待。

433
00:21:47,737 --> 00:21:48,820
但是，这里发生了什么？

434
00:21:48,820 --> 00:21:51,520
>> 首先，我要
逃离美元符号。

435
00:21:51,520 --> 00:21:55,140
因为还记得，当我们实际上
打印出的比萨饼的价格，

436
00:21:55,140 --> 00:21:59,370
实际上，我是他们的格式为
货币数字与一个美元符号。

437
00:21:59,370 --> 00:22:05,635
但是，我们使用的是美元符号也
代表在PHP中的变量名，

438
00:22:05,635 --> 00:22:08,010
特别是当我
使用卷曲的这种方法

439
00:22:08,010 --> 00:22:10,040
梅开二度变
质询方法，我需要

440
00:22:10,040 --> 00:22:13,490
逃离我的美元符号，因此不
以为我说的是一个变量。

441
00:22:13,490 --> 00:22:16,920
这将实际上，
从字面上打印一个美元符号。

442
00:22:16,920 --> 00:22:19,530
>> 排序所以类推到
你的尽头有看到。

443
00:22:19,530 --> 00:22:22,832
它实际上并不
打印反斜杠N，对不对？

444
00:22:22,832 --> 00:22:24,290
它打印出一个新行字符。

445
00:22:24,290 --> 00:22:26,750
这is--它不会
打印反斜线美元符号，

446
00:22:26,750 --> 00:22:30,130
它会打印出刚
一个美元符号字符。

447
00:22:30,130 --> 00:22:30,640
同样的想法。

448
00:22:30,640 --> 00:22:32,760
转义序列是什么
这些东西被调用。

449
00:22:32,760 --> 00:22:37,080
>> 但是请注意，我没有做
任何形式的％s的替换，

450
00:22:37,080 --> 00:22:40,050
我只是从字面上堵漏
在这些变量。

451
00:22:40,050 --> 00:22:45,110
所以在this--什么会发生在这里
是，$ topping--的价值再次，

452
00:22:45,110 --> 00:22:48,390
只是符合我们一直
谈论这样far--奶酪会得到

453
00:22:48,390 --> 00:22:49,720
插在那里。

454
00:22:49,720 --> 00:22:54,780
而$价格将是任何值
在比萨，方括号，奶酪，

455
00:22:54,780 --> 00:22:56,270
这是8.99。

456
00:22:56,270 --> 00:23:01,860
因此，这也将打印出
“整整一个奶酪比萨售价$ 8,99。”

457
00:23:01,860 --> 00:23:05,160
就像我说的，我可以用
打印取代echo这里，

458
00:23:05,160 --> 00:23:08,040
和功能是
几乎完全一样。

459
00:23:08,040 --> 00:23:09,660
它将打印出同样的事情。

460
00:23:09,660 --> 00:23:12,680
>> 还有另一种方式来做到这一点，
这是另一个优点

461
00:23:12,680 --> 00:23:14,710
PHP工作与字符串。

462
00:23:14,710 --> 00:23:17,130
我们可以做字符串连接。

463
00:23:17,130 --> 00:23:19,660
我们能做到这一点的C，也是如此，
使用称为strcat的函数，

464
00:23:19,660 --> 00:23:21,180
但同样，我们不得不
调用独立的功能。

465
00:23:21,180 --> 00:23:22,640
这是这整个乱七八糟的事情。

466
00:23:22,640 --> 00:23:24,590
我们不得不磅 - 包括string.h中。

467
00:23:24,590 --> 00:23:25,780
这是一家集生产，对不对？

468
00:23:25,780 --> 00:23:30,070
但现在我可以只用这个点运算符
连接字符串在一起。

469
00:23:30,070 --> 00:23:34,910
>> 所以我串联“一个整体”和
那么无论$摘心的价值，

470
00:23:34,910 --> 00:23:38,860
然后又是
字符串，“比萨饼成本$”

471
00:23:38,860 --> 00:23:42,340
然后连接任何
$价格的价值，

472
00:23:42,340 --> 00:23:45,670
然后在最后我
套结上期反斜杠ñ。

473
00:23:45,670 --> 00:23:47,926
所以，这也
打印出“一个整体” - 再次，

474
00:23:47,926 --> 00:23:50,550
如果我们谈论的第一个
这比萨饼array--元素

475
00:23:50,550 --> 00:23:54,710
“整整一个奶酪比萨售价$ 8,99。”

476
00:23:54,710 --> 00:24:01,260
期间，反斜杠N，再次用
在$摘心和$的价格代

477
00:24:01,260 --> 00:24:06,580
对于我们在我们的foreach已明确
环路的键值对映射。

478
00:24:06,580 --> 00:24:08,050
>> PHP能够处理的功能。

479
00:24:08,050 --> 00:24:11,250
功能进行了排序
整体为C，正如我们所看到的。

480
00:24:11,250 --> 00:24:14,870
像变量，我们并不需要
指定函数的返回类型，

481
00:24:14,870 --> 00:24:16,350
因为它其实并不重要。

482
00:24:16,350 --> 00:24:18,660
我们不指定
的任何参数的数据类型，

483
00:24:18,660 --> 00:24:21,410
因为他们并不真正
的事情，就像我们已经看到了PHP。

484
00:24:21,410 --> 00:24:24,510
每个功能介绍
用函数关键字。

485
00:24:24,510 --> 00:24:27,920
这就是我们指示PHP中
我们正在谈论的是一个函数。

486
00:24:27,920 --> 00:24:29,720
>> 我们不必
应对主所有，

487
00:24:29,720 --> 00:24:33,690
因为解释器，PHP
解释器，工作从上到下，

488
00:24:33,690 --> 00:24:34,190
而不管。

489
00:24:34,190 --> 00:24:35,640
如果它认为你可以
一个函数调用，它会

490
00:24:35,640 --> 00:24:37,850
去寻找函数调用，
即使是后话。

491
00:24:37,850 --> 00:24:40,360
但它会从顶部读
底部，所以我们并不需要指定，

492
00:24:40,360 --> 00:24:41,500
这里就是你开始。

493
00:24:41,500 --> 00:24:46,700
你开始对1号线的
PHP和从那里工作了。

494
00:24:46,700 --> 00:24:49,690
>> 因此，这里是我们如何创造
一个函数调用hard_square。

495
00:24:49,690 --> 00:24:54,100
这显然​​需要一个
参数，我打电话$ X。

496
00:24:54,100 --> 00:24:58,424
此功能是复杂的刚
说明各种东西。

497
00:24:58,424 --> 00:24:59,590
我们仍然有返回值。

498
00:24:59,590 --> 00:25:00,870
我使用一个for循环在这里。

499
00:25:00,870 --> 00:25:04,970
但它基本上只是，这是什么
达只是$ x次$ X。

500
00:25:04,970 --> 00:25:10,520
什么我实际上做的是刚刚加入
x可0 x次或$ X为零$ x次。

501
00:25:10,520 --> 00:25:15,850
但它有效地正是
同乘$ x次$ X。

502
00:25:15,850 --> 00:25:18,700
我仍然可以返回一个值，
在这种情况下$结果，

503
00:25:18,700 --> 00:25:22,060
我已经取得了PHP函数。

504
00:25:22,060 --> 00:25:24,160
>> 下面是如何使用它的上下文中。

505
00:25:24,160 --> 00:25:26,020
所以，也许我的一些PHP文件里。

506
00:25:26,020 --> 00:25:29,240
蓝色有该通知
我用我的PHP的分隔符，

507
00:25:29,240 --> 00:25:31,010
尖括号问号PHP。

508
00:25:31,010 --> 00:25:35,180
在这些之间的所有
我想写的PHP。

509
00:25:35,180 --> 00:25:37,840
所以我显然要get--
我要提示用户

510
00:25:37,840 --> 00:25:41,550
给我一个数字，商店
变量，存储在变量$ X，

511
00:25:41,550 --> 00:25:43,320
不管他们给了我。

512
00:25:43,320 --> 00:25:48,590
然后，我要呼应
hard_square该值的，

513
00:25:48,590 --> 00:25:50,370
显然打算
要钉在一个新行

514
00:25:50,370 --> 00:25:53,590
还有，再后来我就
定义hard_square因此函数

515
00:25:53,590 --> 00:25:55,550
当我做了
来电hard_square，

516
00:25:55,550 --> 00:25:58,160
它知道我在说什么。

517
00:25:58,160 --> 00:26:00,705
>> 现在，我也可以做
这样的事情。

518
00:26:00,705 --> 00:26:02,050
此略有不同。

519
00:26:02,050 --> 00:26:04,190
这几乎完全
同我们以前看到的，

520
00:26:04,190 --> 00:26:08,400
但不是说只是$ X
有作为参数传递给hard_square，

521
00:26:08,400 --> 00:26:11,730
我说的$ X = 10。

522
00:26:11,730 --> 00:26:14,330
因此，这是一个例子
防御性编程，

523
00:26:14,330 --> 00:26:17,070
守着你的程序
防范恶意用户。

524
00:26:17,070 --> 00:26:20,020
>> 这是做一些错误的一种方式
检查我们并没有真的

525
00:26:20,020 --> 00:26:24,670
有在C.一个选项，我们永远无法
指定的东西的默认值。

526
00:26:24,670 --> 00:26:27,010
我们总是不得不检查
是否，例如，

527
00:26:27,010 --> 00:26:30,820
如果我们打了一个电话给GetString，它是
最合适的，如果立即之后我们

528
00:26:30,820 --> 00:26:33,300
经检查发现，我们检查
是否字符串

529
00:26:33,300 --> 00:26:35,504
用户给了我们
不等于空，

530
00:26:35,504 --> 00:26:37,920
因为我们不希望启动
使用的是空字符串。

531
00:26:37,920 --> 00:26:39,670
>> 这里，这是一种
警惕这一点。

532
00:26:39,670 --> 00:26:43,480
如果用户没有为我们提供什么
不知怎么的，什么是我们该怎么办？

533
00:26:43,480 --> 00:26:46,080
好了，我们只想说什么
他们没有向我们提供，

534
00:26:46,080 --> 00:26:47,705
我们只是在10堵塞代替。

535
00:26:47,705 --> 00:26:52,030
所以，如果他们不给我们一个值，
只需使用10默认情况下。所以在这里，

536
00:26:52,030 --> 00:26:53,940
请注意，我在做
打电话给hard_square，

537
00:26:53,940 --> 00:26:55,980
但没有提示
给用户的，对不对？

538
00:26:55,980 --> 00:26:57,540
我只是做一个空的电话。

539
00:26:57,540 --> 00:27:00,860
>> 但我的功能hard_square
期望的参数。

540
00:27:00,860 --> 00:27:02,222
这是什么打算打印出来？

541
00:27:02,222 --> 00:27:03,680
这将打印出100，对不对？

542
00:27:03,680 --> 00:27:05,720
因为用户没有
给我任何东西。

543
00:27:05,720 --> 00:27:08,970
所以，我只是要承担
即10-- 10是默认值。

544
00:27:08,970 --> 00:27:13,760
所以这将打印
出100在自己的行。

545
00:27:13,760 --> 00:27:16,390
>> PHP文件不必
只是一个单一的文件。

546
00:27:16,390 --> 00:27:19,480
您可以将多个文件合并在一起，
就像你可以在C.方式

547
00:27:19,480 --> 00:27:24,330
我们这样做，在C是典型的做
＃包括让头文件拉到研究。

548
00:27:24,330 --> 00:27:26,180
我们不这样做，在PHP。

549
00:27:26,180 --> 00:27:29,110
我们做一些所谓的require_once。

550
00:27:29,110 --> 00:27:33,360
再有就是这整个
首先，这是什么__DIR__？

551
00:27:33,360 --> 00:27:36,510
这只是一个特殊的
变量或特殊常量，

552
00:27:36,510 --> 00:27:39,030
真的，指定什么
当前目录。

553
00:27:39,030 --> 00:27:41,320
所以它要看看
在当前目录

554
00:27:41,320 --> 00:27:44,900
对于一个名为cs50.php
这里在本例中，

555
00:27:44,900 --> 00:27:50,490
而且它要坚持该文件
在你的PHP程序的顶部，

556
00:27:50,490 --> 00:27:56,980
假设你把需要
一旦在你的PHP文件的第一行。

557
00:27:56,980 --> 00:28:01,474
>> 因此，PHP主要使用，
但不排他使用，

558
00:28:01,474 --> 00:28:03,140
作为基于网络的编程语言。

559
00:28:03,140 --> 00:28:05,270
那它到底是如何走过来的。

560
00:28:05,270 --> 00:28:06,980
但它是一个完整的
语言，因为我们已经看到了。

561
00:28:06,980 --> 00:28:10,105
我们已经看到了几乎所有的东西
它可以做类似于C，

562
00:28:10,105 --> 00:28:13,290
它可以做赫克
很多不止于此。

563
00:28:13,290 --> 00:28:16,950
>> 但由于它是一个完整的语言，我们
可以在里面做的命令行程序。

564
00:28:16,950 --> 00:28:18,630
我们可以运行命令行程序。

565
00:28:18,630 --> 00:28:22,580
所有这一切需要运行一个命令
这是写在PHP行程序

566
00:28:22,580 --> 00:28:24,260
是你有一个PHP解释器。

567
00:28:24,260 --> 00:28:27,460
所以，这有点类似于
有一个编译器在系统上

568
00:28:27,460 --> 00:28:31,100
如果你想编译C代码
把它变成可执行文件。

569
00:28:31,100 --> 00:28:33,810
你需要有一个PHP解释器
存在你的系统上

570
00:28:33,810 --> 00:28:37,330
这样就可以解释PHP文件。

571
00:28:37,330 --> 00:28:40,370
>> 假设你做什么，通常
这个解释被称为PHP，

572
00:28:40,370 --> 00:28:44,300
并且它通常捆绑在最
下载或PHP的安装

573
00:28:44,300 --> 00:28:47,430
你可以上网，而且肯定
PHP解释器的名称

574
00:28:47,430 --> 00:28:49,550
我们在CS50，IDE。

575
00:28:49,550 --> 00:28:51,819
你要做的就是类型的PHP文件。

576
00:28:51,819 --> 00:28:53,610
而你的程序的
要做的是它的

577
00:28:53,610 --> 00:28:55,360
经过运行
解释器，它的

578
00:28:55,360 --> 00:28:58,040
将忽略一切的
没有问题mark--之间

579
00:28:58,040 --> 00:29:03,160
或者，尖括号问号PHP的，
PHP的分隔符，并打印出来，

580
00:29:03,160 --> 00:29:07,660
它会解释和执行的
你的PHP定界符内部代码。

581
00:29:07,660 --> 00:29:12,850
>> 因此，让我们跳出交给CS50 IDE和
看看一对夫妇的PHP文件，

582
00:29:12,850 --> 00:29:19,850
跑了几个PHP文件，在
命令行CS50的IDE接口。

583
00:29:19,850 --> 00:29:22,100
所以在这里我们是在CS50的IDE，
我已经采取了自由

584
00:29:22,100 --> 00:29:25,800
中打开一个名为hello1.php文件。

585
00:29:25,800 --> 00:29:29,920
此，显然，其内容
文件只是PHP的分隔符有，

586
00:29:29,920 --> 00:29:32,220
而在，回声之间（“你好，世界”）。

587
00:29:32,220 --> 00:29:34,710
这是一个非常简单的PHP程序。

588
00:29:34,710 --> 00:29:37,670
我只是要向下滚动
我的终端窗口在这里，

589
00:29:37,670 --> 00:29:44,320
我要去键入PHP
hello1.php，按下回车键。

590
00:29:44,320 --> 00:29:44,950
你好，世界。

591
00:29:44,950 --> 00:29:48,110
这大概就是我们
希望它做的，对不对？

592
00:29:48,110 --> 00:29:51,140
>> 让我们去，并采取
另外看一个节目。

593
00:29:51,140 --> 00:29:52,924
hello2.php。

594
00:29:52,924 --> 00:29:55,090
几乎是同样的事情，
不是有很多事情在这里。

595
00:29:55,090 --> 00:29:57,190
这一次，虽然，我要提示
用户给我自己的名字。

596
00:29:57,190 --> 00:29:59,290
我再次使用了readline的功能。

597
00:29:59,290 --> 00:30:01,340
$名称= readline的。

598
00:30:01,340 --> 00:30:03,070
这提示，“你叫什么名字？”

599
00:30:03,070 --> 00:30:04,880
>> 显然，我打印
它在自己的行。

600
00:30:04,880 --> 00:30:07,220
然后，下面这样的线
这将是提示

601
00:30:07,220 --> 00:30:08,750
用户可以在其中输入他们的名字。

602
00:30:08,750 --> 00:30:12,030
然后，我使用了一点点
可变置疑这里第3行

603
00:30:12,030 --> 00:30:14,780
打印出“你好”和
无论用户类型。

604
00:30:14,780 --> 00:30:22,040
因此，这是在说，你好，
逗号，％S如果我们在C.用printf

605
00:30:22,040 --> 00:30:24,910
>> 因此，让我们去解释这个计划。

606
00:30:24,910 --> 00:30:27,400
所以，再一次，我会向下滚动
我的终端窗口。

607
00:30:27,400 --> 00:30:29,070
PHP hello2.php。

608
00:30:29,070 --> 00:30:31,920

609
00:30:31,920 --> 00:30:33,820
你叫什么？

610
00:30:33,820 --> 00:30:35,490
道格。

611
00:30:35,490 --> 00:30:36,526
您好，道格。

612
00:30:36,526 --> 00:30:39,440
我也有另一种
所谓的文件hello3.php。

613
00:30:39,440 --> 00:30:42,850
我要清楚我
屏幕控制L，

614
00:30:42,850 --> 00:30:46,210
我要去执行的。

615
00:30:46,210 --> 00:30:47,640
你叫什么？

616
00:30:47,640 --> 00:30:49,020
道格。

617
00:30:49,020 --> 00:30:49,780
您好，道格。

618
00:30:49,780 --> 00:30:56,540
所以该行为是相同
hello2.php，但为什么它hello3.php？

619
00:30:56,540 --> 00:30:58,040
>> 那么，这里的区别。

620
00:30:58,040 --> 00:31:00,620
在这种情况下，通知
上这里1号线，

621
00:31:00,620 --> 00:31:04,270
我有东西是不是
在PHP分隔符之间。

622
00:31:04,270 --> 00:31:07,760
我只是打印out--还是我
刚键入，“你叫什么名字？”

623
00:31:07,760 --> 00:31:12,060
当PHP解释器看到这一点，
已经不知道该怎么解释为PHP，

624
00:31:12,060 --> 00:31:15,060
等等，而不是失败，
它只是要吐了出来。

625
00:31:15,060 --> 00:31:19,010
>> 因此，第3行注意到，现在，我的呼吁
readline的，没有任何提示了。

626
00:31:19,010 --> 00:31:21,750
我只是真的要用于：当
PHP解释器看到这一点，

627
00:31:21,750 --> 00:31:23,400
它会打印出
“你叫什么？”

628
00:31:23,400 --> 00:31:25,941
然后，它认为，哦，好吧，here's--
一切将是

629
00:31:25,941 --> 00:31:29,970
解释为PHP的，所以
这就是为什么这个工程。

630
00:31:29,970 --> 00:31:34,990
我不必一定提示
的readline内的用户用于：，

631
00:31:34,990 --> 00:31:37,490
我可以把它外面
PHP的分隔符

632
00:31:37,490 --> 00:31:41,490
并允许解释器
刚刚打印出来给我。

633
00:31:41,490 --> 00:31:45,364
>> 所以，你实际上并不只
有一组PHP的分隔符

634
00:31:45,364 --> 00:31:46,030
在你的程序。

635
00:31:46,030 --> 00:31:49,887
实际上，你可以有几个人，
开，并根据需要关闭它们。

636
00:31:49,887 --> 00:31:51,720
因此，让我们一起来看看
在几个方案

637
00:31:51,720 --> 00:31:55,070
在CS50 IDE我们
说明这个道理具有

638
00:31:55,070 --> 00:31:58,376
多组分隔的PHP。

639
00:31:58,376 --> 00:32:02,010
>> 好了，我已经打开的文件
这里所谓的add1.php。

640
00:32:02,010 --> 00:32:03,390
同时注意这里发生了什么。

641
00:32:03,390 --> 00:32:08,077
与以前一样，我有一个
单一的PHP设置分隔符。

642
00:32:08,077 --> 00:32:10,660
我要打印出来的
消息，“请给我一个数字。”

643
00:32:10,660 --> 00:32:13,394
然后我会读线
其存储在变量$ NUM1。

644
00:32:13,394 --> 00:32:14,810
然后，我要打印出来了。

645
00:32:14,810 --> 00:32:16,310
给我第二个数字。

646
00:32:16,310 --> 00:32:20,450
阅读从用户，存储一行
无论他们输入在$ NUM2。

647
00:32:20,450 --> 00:32:23,980
添加在一起并存储
导致一个名为$总和变量，

648
00:32:23,980 --> 00:32:26,180
然后打印出“的
这两个数字的总和

649
00:32:26,180 --> 00:32:29,254
是“，然后interpellate
有变量$总和。

650
00:32:29,254 --> 00:32:31,170
因此，让我们只需要运行这个
通过翻译

651
00:32:31,170 --> 00:32:33,720
要确认这是我们所期望的。

652
00:32:33,720 --> 00:32:37,540
PHP add1.php。

653
00:32:37,540 --> 00:32:38,665
请给我一个数字，3。

654
00:32:38,665 --> 00:32:40,410
请给我第二个数字，4。

655
00:32:40,410 --> 00:32:43,370
这两个数字的总和是7。

656
00:32:43,370 --> 00:32:45,030
这就是3加4。

657
00:32:45,030 --> 00:32:45,530
好不好？

658
00:32:45,530 --> 00:32:47,770
所以没有什么可怕看中那里。

659
00:32:47,770 --> 00:32:51,080
>> 现在，让我们打开了add2.php。

660
00:32:51,080 --> 00:32:54,460
在这里，我有一对夫妇的PHP
分隔套在那里，对不对？

661
00:32:54,460 --> 00:32:59,107
线路1，3--线1和
3没有PHP的分隔符。

662
00:32:59,107 --> 00:33:00,940
所以当翻译
看到他们，这只是

663
00:33:00,940 --> 00:33:03,220
要吐了出来正好
我所输入那里。

664
00:33:03,220 --> 00:33:05,011
所以这就是我
做所有我的提示。

665
00:33:05,011 --> 00:33:11,220
上线2和4中，我们看到了非常
熟悉的$？的PHP类分隔符，

666
00:33:11,220 --> 00:33:15,210
所以这两个行是
将作为PHP执行。

667
00:33:15,210 --> 00:33:18,270
然后在第5行，我有这样的
奇怪的事情就在这里，对不对？

668
00:33:18,270 --> 00:33:20,480
这个角度支架
问号等号。

669
00:33:20,480 --> 00:33:22,660
我甚至会放大得远一点。

670
00:33:22,660 --> 00:33:29,270
你可以看到这就是我
说起在那里，这$？=。

671
00:33:29,270 --> 00:33:33,420
>> 事实证明，这是很常见的，
我们开辟了一套PHP的原因

672
00:33:33,420 --> 00:33:36,055
定界符是打印出的值。

673
00:33:36,055 --> 00:33:37,430
这就是我们要做的。

674
00:33:37,430 --> 00:33:39,220
但是，甚至还有速记的。

675
00:33:39,220 --> 00:33:46,490
$？=是PHP简写说
类似$？PHP的echo总和

676
00:33:46,490 --> 00:33:48,350
的NUM1与NUM2。

677
00:33:48,350 --> 00:33:51,900
因此，这只是另一种
速记的。

678
00:33:51,900 --> 00:33:55,550
>> 所以，如果我运行这个程序，PHP add2.php。

679
00:33:55,550 --> 00:33:57,530
我会放大下跌一点点。

680
00:33:57,530 --> 00:33:59,000
请给我一个数字，4。

681
00:33:59,000 --> 00:34:00,350
请给我第二个数字。

682
00:34:00,350 --> 00:34:04,650
而且因为我真的不关心
在PHP中的数据类型，我可以说4.8。

683
00:34:04,650 --> 00:34:07,160
这两个数字的总和是8.8。

684
00:34:07,160 --> 00:34:10,179
这个函数的行为非常
就如我们所期望的一样，

685
00:34:10,179 --> 00:34:10,989
为好。

686
00:34:10,989 --> 00:34:13,114
我有一个更加开放
在这里所谓的dice.php。

687
00:34:13,114 --> 00:34:25,625

688
00:34:25,625 --> 00:34:26,250
再试试这个。

689
00:34:26,250 --> 00:34:29,429

690
00:34:29,429 --> 00:34:33,280
我有一个更这里所说的
dice1.php，这也见，

691
00:34:33,280 --> 00:34:37,440
有一个尖括号问题
在那里庆祝等号符号，

692
00:34:37,440 --> 00:34:40,659
但是请注意，在这种情况下，我
调用函数兰特，你这

693
00:34:40,659 --> 00:34:42,790
可能期望产生一个随机数。

694
00:34:42,790 --> 00:34:46,889
“你滚了，”并且这将
计算一些随机数，模6 +

695
00:34:46,889 --> 00:34:47,389
1。

696
00:34:47,389 --> 00:34:49,989
所以这会给我一些
为1〜6的范围内。

697
00:34:49,989 --> 00:34:53,040
>> 请记住，国防部6会给我
一个数为0〜5的范围内，

698
00:34:53,040 --> 00:34:56,630
但如果我在模拟掷骰，
这就是我在这里做，

699
00:34:56,630 --> 00:35:00,040
我不希望这些骰子从0去
至5，我想骰子从1至6。

700
00:35:00,040 --> 00:35:02,800
所以这是一种方式来获得
我在1至6的范围内。

701
00:35:02,800 --> 00:35:04,720
我这样做两次。

702
00:35:04,720 --> 00:35:08,630
因此很明显，我压延
两个骰子此计划。

703
00:35:08,630 --> 00:35:15,210
>> 所以，我清楚我的屏幕，
我会做的PHP dice1.php。

704
00:35:15,210 --> 00:35:16,640
您掷出4和2。

705
00:35:16,640 --> 00:35:19,156
如果我运行的程序
再次，你滚5和5。

706
00:35:19,156 --> 00:35:21,780
所以，我每次运行程序时，
我得到不同的号码，

707
00:35:21,780 --> 00:35:24,280
因为每次我这样做
所以，它开始了。

708
00:35:24,280 --> 00:35:27,250
这将生成一个新的
设置随机数我的。

709
00:35:27,250 --> 00:35:29,790
>> 因此，如果我们已经习惯了
从C运行的程序，

710
00:35:29,790 --> 00:35:32,520
我们已经习惯了打字./的
一个程序的名字吧？

711
00:35:32,520 --> 00:35:35,090
这就是我们如何做的一切
我们在C程序为止。

712
00:35:35,090 --> 00:35:37,555
我们可以在PHP中做到这一点，以及
通过添加一种叫

713
00:35:37,555 --> 00:35:40,026
一个家当我们的PHP文件的顶部。

714
00:35:40,026 --> 00:35:41,400
我知道这是一种愚蠢的词。

715
00:35:41,400 --> 00:35:44,540
这是短期的哈希爆炸。

716
00:35:44,540 --> 00:35:46,300
这是前两个字符出现。

717
00:35:46,300 --> 00:35:50,030
还记得我们称之为感叹号
经常一声巨响计算机科学。

718
00:35:50,030 --> 00:35:51,690
这也可能是尖锐的爆炸。

719
00:35:51,690 --> 00:35:53,273
有一对夫妇的方式来解释它。

720
00:35:53,273 --> 00:35:57,320
但它基本上是一种特殊的
命令的PHP解释器

721
00:35:57,320 --> 00:36:00,160
理解为，哦，我想
您可以执行该程序，

722
00:36:00,160 --> 00:36:05,250
这显然​​是/用户/斌/ PHP的，这
实际上，其中的PHP解释器

723
00:36:05,250 --> 00:36:08,590
特别是住在我们的系统。

724
00:36:08,590 --> 00:36:12,530
所以it's--这里发生的事情是
解释明白，哦，

725
00:36:12,530 --> 00:36:17,270
我显然应该使用
这一计划运行此文件。

726
00:36:17,270 --> 00:36:20,010
所以，它可以让你
跳过步骤

727
00:36:20,010 --> 00:36:22,979
不必去说PHP something.php。

728
00:36:22,979 --> 00:36:25,020
还有另一个抓
在这里，这是，如果我们

729
00:36:25,020 --> 00:36:27,320
希望我们的节目
达到预期效果，我们

730
00:36:27,320 --> 00:36:30,220
需要做一些所谓的
文件权限的改变。

731
00:36:30,220 --> 00:36:33,380
我们将go--和我们谈一点
更多的有关文件权限更改

732
00:36:33,380 --> 00:36:37,550
在我们的视频MVC的，但我只想
说这就是你需要做的

733
00:36:37,550 --> 00:36:42,760
为了使您的
.php文件的可执行文件。

734
00:36:42,760 --> 00:36:49,330
因此，让我们来看看本作
我们在CS50 IDE最后的例子了。

735
00:36:49,330 --> 00:36:53,910
>> 所以在这里的IDE我在这两个文件
这似乎不是PHP目录

736
00:36:53,910 --> 00:36:55,310
所谓的.php。

737
00:36:55,310 --> 00:36:58,170
我有一个称为函数add--
我有一个名为ADD3

738
00:36:58,170 --> 00:37:00,650
并要求文件dice2。

739
00:37:00,650 --> 00:37:03,680
因此，让我们快速浏览
外观和开拓ADD3。

740
00:37:03,680 --> 00:37:08,300
正如你所看到的，在开始
我的文件我有这个家当，对不对？

741
00:37:08,300 --> 00:37:11,420
该散列标记感叹号。

742
00:37:11,420 --> 00:37:15,115
现在，你也可能
注意到，由于某种原因，

743
00:37:15,115 --> 00:37:16,990
我没有任何语法
突出了，

744
00:37:16,990 --> 00:37:20,198
这就是我前面提到，
这是说，如果我没有名字我的文件

745
00:37:20,198 --> 00:37:23,040
.PHP，我没有好处
语法高亮了。

746
00:37:23,040 --> 00:37:26,220
这个文件就被称为ADD3。

747
00:37:26,220 --> 00:37:30,960
所以，我可以在以后运行
以./ ADD3，而不是./ add3.php。

748
00:37:30,960 --> 00:37:33,680
>> 所以reason--它仍然
很好，它仍然是有效的PHP，

749
00:37:33,680 --> 00:37:37,000
但它没有语法高亮，因为
该文件不叫something.php。

750
00:37:37,000 --> 00:37:41,580
这是唯一的真正的区别
这里，加上家当。

751
00:37:41,580 --> 00:37:45,170
因此，让我们看看会发生什么时，
我尝试运行此程序。

752
00:37:45,170 --> 00:37:50,780
./ ADD3，就像我会与C猛砸。

753
00:37:50,780 --> 00:37:53,190
./ ADD3权限被拒绝。

754
00:37:53,190 --> 00:37:55,390
这是你将成为怎样
就看你忘了

755
00:37:55,390 --> 00:37:59,280
使用chmod命令更改
该文件的权限。

756
00:37:59,280 --> 00:38:03,845
>> 事实证明，常规PHP
文件不能只是执行。

757
00:38:03,845 --> 00:38:06,970
他们可以理解，但我们
做的东西在这里有点不同。

758
00:38:06,970 --> 00:38:07,761
我们正在执行它。

759
00:38:07,761 --> 00:38:12,970
所以我需要添加权限
执行，文件模式一+ X到ADD3。

760
00:38:12,970 --> 00:38:15,680
那么我可以说./ ADD3。

761
00:38:15,680 --> 00:38:16,860
请给我一个号码。

762
00:38:16,860 --> 00:38:18,060
5，6。

763
00:38:18,060 --> 00:38:20,490
这两个数字的总和为11。

764
00:38:20,490 --> 00:38:26,530
>> 同样的，我已经chmoded
dice2，这样我就可以只输入./ dice2，

765
00:38:26,530 --> 00:38:31,260
你推出一个1和一个1，你
轧制一个5和4，等等。

766
00:38:31,260 --> 00:38:33,680
>> 所以这是相当多的
一个PHP语法的想法，对吧？

767
00:38:33,680 --> 00:38:35,221
有很多打通，我知道了。

768
00:38:35,221 --> 00:38:39,160
但希望你现在已经看到PHP
是不是真的那么从C不同

769
00:38:39,160 --> 00:38:43,670
真是给了我们的能力
拿东西了一个或两个档次。

770
00:38:43,670 --> 00:38:48,230
我们真的不担心
太多about--我们真的不

771
00:38:48,230 --> 00:38:51,605
不得不过分担心
低级别的细节，我们

772
00:38:51,605 --> 00:38:52,980
不用担心用C，对不对？

773
00:38:52,980 --> 00:38:56,170
我们可以专注于更高
级别的东西，PHP

774
00:38:56,170 --> 00:39:01,090
使我们能够做的，并采取了
想当然地认为它会为我们工作。

775
00:39:01,090 --> 00:39:04,350
所以，它给了我们的能力，现在，
从C过渡到PHP，

776
00:39:04,350 --> 00:39:08,280
使该是多了很多方案
复杂，或许很多更稳健。

777
00:39:08,280 --> 00:39:13,070
>> 所以，我希望你有乐趣的工作
用PHP，我是道格·劳埃德。

778
00:39:13,070 --> 00:39:15,050
这是CS50。

779
00:39:15,050 --> 00:39:17,637