1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [第8条] [舒适]

2
00:00:02,000 --> 00:00:04,000
内特 - 哈迪森] [哈佛大学]

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

4
00:00:08,000 --> 00:00:11,000
>> 欢迎来到我们的第二个到最后一节。

5
00:00:11,000 --> 00:00:13,000
在这一周中，我们将谈论PHP，然后下周

6
00:00:13,000 --> 00:00:17,000
我们会做一个小小的回顾测验1。

7
00:00:17,000 --> 00:00:20,000
我们要开始第3页的问题设置包，

8
00:00:20,000 --> 00:00:28,000
我们将继续努力通过部分的问题相当迅速。

9
00:00:28,000 --> 00:00:34,000
第3页，我们开始谈论C和PHP之间的这种差别

10
00:00:34,000 --> 00:00:38,000
在这个意义上，PHP是一种动态类型的语言，

11
00:00:38,000 --> 00:00:42,000
而C是静态类型的，

12
00:00:42,000 --> 00:00:46,000
有没有人真的很快做任​​何编码的东西像PHP

13
00:00:46,000 --> 00:00:51,000
或Python或Ruby之前，JavaScript的？

14
00:00:51,000 --> 00:00:53,000
全新的吗？好吧。

15
00:00:53,000 --> 00:00:56,000
>> 我刚才提到的所有这些语言

16
00:00:56,000 --> 00:01:01,000
有很大的不同的语言，如C和C + +和Java

17
00:01:01,000 --> 00:01:04,000
在这个意义上，当你声明一个变量时，你没有申报

18
00:01:04,000 --> 00:01:09,000
它是什么类型的变量，所以在C我们不得不总是说

19
00:01:09,000 --> 00:01:13,000
这将是一个int变量，这将是一个char *变量，

20
00:01:13,000 --> 00:01:16,000
而与PHP，Python和Ruby的，

21
00:01:16,000 --> 00:01:20,000
这些更现代的语言有很多，你没有这样做，在所有。

22
00:01:20,000 --> 00:01:24,000
你只申报的变量，而在PHP的情况下，

23
00:01:24,000 --> 00:01:28,000
你声明一个变量前面加上一个$符号，

24
00:01:28,000 --> 00:01:35,000
然后变量的类型确定的由持有任何值，

25
00:01:35,000 --> 00:01:38,000
这是一种很酷。

26
00:01:38,000 --> 00:01:44,000
要玩这个一点点，我们在这里有PHP代码示例

27
00:01:44,000 --> 00:01:47,000
之间的开始和结束标记。

28
00:01:47,000 --> 00:01:53,000
我们使用的是在这个意义上，这有点像HTML

29
00:01:53,000 --> 00:01:56,000
我们已经得到了这些尖括号这里打开和关闭。

30
00:01:56,000 --> 00:01:58,000
你会看到这一点HTML。

31
00:01:58,000 --> 00:02:03,000
你会看到相同的语法与XML。

32
00:02:03,000 --> 00:02:06,000
>> 这说明一个PHP代码块的开始。

33
00:02:06,000 --> 00:02:09,000
这PHP是特定的PHP。

34
00:02:09,000 --> 00:02:16,000
我们关闭了？以及一切。

35
00:02:16,000 --> 00:02:22,000
让我们打开一个文件可以使用任何你想在我们的设备。

36
00:02:22,000 --> 00:02:25,000
在这个包中，它说叫dynamic.php的。

37
00:02:25,000 --> 00:02:29,000
事实上，你可以把它无论你想要什么，但文件名会

38
00:02:29,000 --> 00:02:34,000
是重要的，所以后来只记得无论你怎么称呼它。

39
00:02:34,000 --> 00:02:36,000
我要切换的设备，

40
00:02:36,000 --> 00:02:43,000
我要创建一个目录

41
00:02:43,000 --> 00:02:48,000
第9条，我相信我们在现在。

42
00:02:48,000 --> 00:02:51,000
我们将进入第9，

43
00:02:51,000 --> 00:02:54,000
我将用gedit。

44
00:02:54,000 --> 00:02:59,000
让我们来看看，gedit的，我现在就打电话给我的dynamic.php。

45
00:02:59,000 --> 00:03:03,000
轰。

46
00:03:03,000 --> 00:03:06,000
在dynamic.php内，因为这是一个PHP文件

47
00:03:06,000 --> 00:03:09,000
我想通过PHP解释器来运行这个

48
00:03:09,000 --> 00:03:12,000
我需要一切重新开始关闭与打开的标签，

49
00:03:12,000 --> 00:03:17,000
所以我要马上启动这些，

50
00:03:17,000 --> 00:03:23,000
给自己一点空间在标签之间的，

51
00:03:23,000 --> 00:03:26,000
这个练习是玩弄

52
00:03:26,000 --> 00:03:34,000
这个函数调用的getType，这样的getType，这个功能在这里。

53
00:03:34,000 --> 00:03:38,000
>> 请注意，有没有下划线或空格或连字符或类似的东西

54
00:03:38,000 --> 00:03:42,000
分离的2个字，然后键入，只有一个词完全。

55
00:03:42,000 --> 00:03:46,000
但是，这是什么做的是，如果我通过在一个变量中的getType，

56
00:03:46,000 --> 00:03:51,000
说是$ var $ X，

57
00:03:51,000 --> 00:03:55,000
这会告诉我在调试格式

58
00:03:55,000 --> 00:03:59,000
该类型的名称是什么。

59
00:03:59,000 --> 00:04:03,000
我们将在这里进行试验。

60
00:04:03,000 --> 00:04:07,000
特别是，如果你回头看看在pset规范

61
00:04:07,000 --> 00:04:11,000
我们这里有几个不同的代码行。

62
00:04:11,000 --> 00:04:16,000
我们在第一行代码初始化这个变量，$ var的，

63
00:04:16,000 --> 00:04:21,000
等于7，然后我们有这个printf线

64
00:04:21,000 --> 00:04:25,000
说哎，printf的变种是空白。

65
00:04:25,000 --> 00:04:29,000
printf是一个在许多方面我们可以打印的东西在PHP。

66
00:04:29,000 --> 00:04:33,000
通常，你会看到的回声代替了printf函数，

67
00:04:33,000 --> 00:04:40,000
但输出，我们都熟悉的已编码在C一段时间。

68
00:04:40,000 --> 00:04:42,000
你其实可以做的是，让我们来看看，如果复制和粘贴工程。

69
00:04:42,000 --> 00:04:46,000
我要试试这个。

70
00:04:46,000 --> 00:04:52,000
我们会回去的设备。

71
00:04:52,000 --> 00:05:00,000
好了，我们走吧。

72
00:05:00,000 --> 00:05:05,000
间距是有点古怪，但在这里，我们走了。

73
00:05:05,000 --> 00:05:08,000
在这里，我们已经得到这个代码。

74
00:05:08,000 --> 00:05:11,000
>> [学生]：它没有良好的作风选项卡中吗？

75
00:05:11,000 --> 00:05:13,000
你说什么？

76
00:05:13,000 --> 00:05:15,000
[学生]：常规选项卡中吗？

77
00:05:15,000 --> 00:05:21,000
对，所以山姆问，如果是公约的选项卡或不。

78
00:05:21,000 --> 00:05:23,000
通常情况下是肯定的。

79
00:05:23,000 --> 00:05:26,000
在这种情况下，我选择了不。

80
00:05:26,000 --> 00:05:33,000
老实说，你会看到不同的东西，不同的程序员。

81
00:05:33,000 --> 00:05:40,000
通常经常使用的PHP与HTML相结合

82
00:05:40,000 --> 00:05:45,000
和其他语言，所以有时印刷看起来有点时髦

83
00:05:45,000 --> 00:05:50,000
如果你在PHP开始和结束标记的缩进。

84
00:05:50,000 --> 00:05:53,000
这真的视情况而定。

85
00:05:53,000 --> 00:05:56,000
在这种情况下，复制和粘贴没贴的标签，对我来说，

86
00:05:56,000 --> 00:06:02,000
但它绝对不会像你说的，使更清晰。

87
00:06:02,000 --> 00:06:06,000
好吧，如果你这段代码保存在dynamic.php

88
00:06:06,000 --> 00:06:10,000
然后你可以做什么，回落到终端窗口，我就在这里

89
00:06:10,000 --> 00:06:17,000
在gedit中，相当于做编译

90
00:06:17,000 --> 00:06:20,000
使用make，然后运行你的代码，在C

91
00:06:20,000 --> 00:06:25,000
所有你必须​​做的PHP文件是启动PHP解释器，

92
00:06:25,000 --> 00:06:30,000
这是一个小程序调用PHP，

93
00:06:30,000 --> 00:06:35,000
你给的解释，争论的焦点是你想要的文件解释。

94
00:06:35,000 --> 00:06:40,000
在这种情况下，dynamic.php。

95
00:06:40,000 --> 00:06:43,000
哎呀，我把它放在了吗？

96
00:06:43,000 --> 00:06:52,000
哦，我把它在第9，和我在这里。这就是为什么。

97
00:06:52,000 --> 00:06:57,000
>> 如果我现在，再次运行

98
00:06:57,000 --> 00:07:02,000
我们看到，在我的第一个GetType函数调用

99
00:07:02,000 --> 00:07:04,000
var是一个整数。

100
00:07:04,000 --> 00:07:12,000
在接下来的一个var是一个字符串，然后在第三个变种是一个布尔值。

101
00:07:12,000 --> 00:07:15,000
有什么有趣的，如果我们向后滚动，我们看到，

102
00:07:15,000 --> 00:07:18,000
这些都是类似的，我们已经在C.类型

103
00:07:18,000 --> 00:07:22,000
我们有整数在C

104
00:07:22,000 --> 00:07:26,000
我们有字符串在C，

105
00:07:26,000 --> 00:07:31,000
所以字符串是不是在这个意义上的完全合法的类型

106
00:07:31,000 --> 00:07:37,000
我们的CS50的字符串是真的什么？

107
00:07:37,000 --> 00:07:39,000
你说什么？大小姐吗？

108
00:07:39,000 --> 00:07:41,000
[大小姐] CHAR *。

109
00:07:41,000 --> 00:07:43,000
是啊，是我们的char *。

110
00:07:43,000 --> 00:07:47,000
在学期开始的时候，我们使用的字符串类型，

111
00:07:47,000 --> 00:07:52,000
但这确实是一个char *引擎盖下。

112
00:07:52,000 --> 00:07:58,000
我们刚刚定义的类型，而在PHP中，这些字符串是一个实际的类型。

113
00:07:58,000 --> 00:08:07,000
有没有更多的这char *类型的东西。

114
00:08:07,000 --> 00:08:10,000
>> 你会看到，我们可以做更多的事情与字符串

115
00:08:10,000 --> 00:08:14,000
更容易在PHP比我们在C，

116
00:08:14,000 --> 00:08:17,000
然后终于，我们有这样的布尔类型，与这里最大的区别是，

117
00:08:17,000 --> 00:08:21,000
如果我们滚动回落，我们看到，这些类型的名称

118
00:08:21,000 --> 00:08:28,000
是整数，字符串和布尔值的，而不是整型和bool

119
00:08:28,000 --> 00:08:31,000
你拿起不同的编程语言，

120
00:08:31,000 --> 00:08:36,000
假设在一些点在你的生命中，你会接触到

121
00:08:36,000 --> 00:08:40,000
不同的人，你会发现像这样的小怪癖

122
00:08:40,000 --> 00:08:44,000
其中，C调用整数int类型。

123
00:08:44,000 --> 00:08:46,000
有人称之为整数。

124
00:08:46,000 --> 00:08:51,000
还有其他的条件，你会碰到。

125
00:08:51,000 --> 00:08:55,000
大整数，我们今天看到的SQL。

126
00:08:55,000 --> 00:08:59,000
也有号码，然后布尔型，布尔型，

127
00:08:59,000 --> 00:09:03,000
所有各种差异有。

128
00:09:03,000 --> 00:09:07,000
>> 这是非常有趣的，但是现在，我去给你一点点的时间，

129
00:09:07,000 --> 00:09:13,000
如果我们放大的工作，通过这个练习在第3页的底部

130
00:09:13,000 --> 00:09:20,000
在要求什么类型对应于这些值在底部。

131
00:09:20,000 --> 00:09:24,000
我们有3.50。

132
00:09:24,000 --> 00:09:28,000
我们有这样的事情就在这里，这是有趣的。

133
00:09:28,000 --> 00:09:32,000
我们还没有看到过，但如果你一直跟着在讲座

134
00:09:32,000 --> 00:09:35,000
你可能已经知道那是什么。

135
00:09:35,000 --> 00:09:40,000
然后，我们有这样的，这是一种时髦的。

136
00:09:40,000 --> 00:09:42,000
您承认这一点。

137
00:09:42,000 --> 00:09:46,000
在C这是什么吗？

138
00:09:46,000 --> 00:09:50,000
山姆？这给你在C？

139
00:09:50,000 --> 00:09:54,000
这将打开一个称为dynamic.php的文件，并使其可读。

140
00:09:54,000 --> 00:09:58,000
是啊，会是什么类型的变量，我们将分配？明星>>文件。

141
00:09:58,000 --> 00:10:02,000
没错，我们会分配到一个文件中的明星。

142
00:10:02,000 --> 00:10:08,000
这是合法的PHP。

143
00:10:08,000 --> 00:10:12,000
运行。看看会发生什么时，其传递到的getType。

144
00:10:12,000 --> 00:10:19,000
然后还要检查null是什么，是什么可能是在PHP。

145
00:10:19,000 --> 00:10:21,000
我给你一两分钟。

146
00:10:21,000 --> 00:10:24,000
你可以从字面上复制和粘贴这些值，

147
00:10:24,000 --> 00:10:29,000
然后我们会做一个小的随机呼叫您

148
00:10:29,000 --> 00:10:34,000
看你得到了什么。

149
00:10:34,000 --> 00:10:36,000
>> [学生]：我有一个问题。“是啊。

150
00:10:36,000 --> 00:10:40,000
在一次演讲的大卫说有什么东西，你可以把你的文件的顶部

151
00:10:40,000 --> 00:10:43,000
所以，你不必每次输入PHP。

152
00:10:43,000 --> 00:10:45,000
那是什么？

153
00:10:45,000 --> 00:10:50,000
他可能是在谈论磅砰，哈希爆炸。

154
00:10:50,000 --> 00:10:57,000
这是一个指令，如果你标记你的文件，可执行文件

155
00:10:57,000 --> 00:11:01,000
那么它的作用是当你执行该文件时，

156
00:11:01,000 --> 00:11:06,000
它会告诉shell程序

157
00:11:06,000 --> 00:11:12,000
使用PHP解释器来解释该文件的内容。

158
00:11:12,000 --> 00:11:16,000
问题是，这个特殊的线是什么

159
00:11:16,000 --> 00:11:20,000
我们可以纳入我们的PHP文件的顶部没有包括

160
00:11:20,000 --> 00:11:26,000
这个PHP线或本的PHP命令时，我们要执行的文件吗？

161
00:11:26,000 --> 00:11:31,000
实际上，你可以做到这一点了一堆不同的文件。

162
00:11:31,000 --> 00:11:37,000
我认为这取决于PHP二进制文件存储在哪里，

163
00:11:37,000 --> 00:11:43,000
但往往usr / bin中/ PHP是一个良好的开端。

164
00:11:43,000 --> 00:11:45,000
您可以明白这一点正是由会回落到您的设备

165
00:11:45,000 --> 00:11:50,000
输入PHP。

166
00:11:50,000 --> 00:11:55,000
哪个命令时，你正在执行的二进制

167
00:11:55,000 --> 00:12:01,000
相应的文件或命令。

168
00:12:01,000 --> 00:12:06,000
这告诉我，PHP是真的走样二进制文件

169
00:12:06,000 --> 00:12:13,000
是存储在usr / bin中，这是那里有很多的系统的二进制文件的安装。

170
00:12:13,000 --> 00:12:21,000
例如，如果我滚动到顶部，现在我已经把这个＃！在这里

171
00:12:21,000 --> 00:12:27,000
我可以向下滚动，我可以尝试运行

172
00:12:27,000 --> 00:12:35,000
的dynamic.php，但我得到这个错误被拒绝的权限，

173
00:12:35,000 --> 00:12:42,000
是什么意思的是，该文件目前尚未提供可执行权限。

174
00:12:42,000 --> 00:12:46,000
它未标记为一个文件，有人可以运行。

175
00:12:46,000 --> 00:12:52,000
>> 当你运行make或铿锵，你有一个可执行文件

176
00:12:52,000 --> 00:12:56,000
编译器足够聪明，知道，嘿，我建立一个可执行文件。

177
00:12:56,000 --> 00:13:00,000
您可能要执行的，所以它会自动配置

178
00:13:00,000 --> 00:13:02,000
你的权限。

179
00:13:02,000 --> 00:13:06,000
虽然，这是没有的情况下，当你从头开始创建一个正常的文件，

180
00:13:06,000 --> 00:13:13,000
原因通常你不希望有任何文件在您的系统上的可执行文件，

181
00:13:13,000 --> 00:13:15,000
所以你确实有去和手动做到这一点。

182
00:13:15,000 --> 00:13:22,000
做到这一点最简单的方法是使用chmod命令，

183
00:13:22,000 --> 00:13:28,000
使用chmod + x表示添加的可执行位

184
00:13:28,000 --> 00:13:31,000
因为有读位，写入位的可执行位，

185
00:13:31,000 --> 00:13:35,000
R，w，和x，

186
00:13:35,000 --> 00:13:39,000
并说使用chmod + x打开的可执行位

187
00:13:39,000 --> 00:13:46,000
为然后文件我们指定在这种情况下，这将是dynamic.php。

188
00:13:46,000 --> 00:13:49,000
>> [学生]：是，转身就为大家吗？

189
00:13:49,000 --> 00:13:52,000
让我们检查了这一点，因此，如何将我检查的权限吗？

190
00:13:52,000 --> 00:13:54,000
你知不知道我怎么会检查，以查看权限的文件吗？

191
00:13:54,000 --> 00:13:56,000
[听不见的学生反应]

192
00:13:56,000 --> 00:13:58,000
你说什么？>> [学生]：XSD。

193
00:13:58,000 --> 00:14:03,000
XSD为我们提供了黑客中的文件。

194
00:14:03,000 --> 00:14:09,000
列出所有的文件，L，会告诉我我的目录中的所有文件

195
00:14:09,000 --> 00:14:13,000
种在长期，详细列表，所以在这里我们可以看到，

196
00:14:13,000 --> 00:14:17,000
这dynamic.php文件

197
00:14:17,000 --> 00:14:23,000
11月5日的最后修订在4:21 PM。

198
00:14:23,000 --> 00:14:26,000
这个文件的所有者是jharvard。

199
00:14:26,000 --> 00:14:28,000
这是用户登录

200
00:14:28,000 --> 00:14:31,000
这是我工作的用户，

201
00:14:31,000 --> 00:14:36,000
如果你在家电，你也工作用户jharvard。

202
00:14:36,000 --> 00:14:38,000
你在学生群体中，

203
00:14:38,000 --> 00:14:44,000
这些事情，你会经常看到。

204
00:14:44,000 --> 00:14:47,000
>> 我们可以在这里投入了大量的细节，

205
00:14:47,000 --> 00:14:50,000
但在大多数情况下，你想看看什么当你想看看

206
00:14:50,000 --> 00:14:55,000
不是一个文件是否是可执行的主要是

207
00:14:55,000 --> 00:14:58,000
谁拥有该文件的用户，所有者，

208
00:14:58,000 --> 00:15:03,000
所以这的jharvard，然后我们有

209
00:15:03,000 --> 00:15:07,000
在这里在左边的权限位，

210
00:15:07,000 --> 00:15:13,000
的方式来阅读，这是最后一位

211
00:15:13,000 --> 00:15:18,000
通常被用于标记是否未至少在这种情况下

212
00:15:18,000 --> 00:15:21,000
这最后一点往往会被设置为广告显示

213
00:15:21,000 --> 00:15:24,000
该文件是一个目录，而不是只是一个普通的文件。

214
00:15:24,000 --> 00:15:28,000
以下3位在这里

215
00:15:28,000 --> 00:15:34,000
确定文件所有者的权限，

216
00:15:34,000 --> 00:15:38,000
所以在这种情况jharvard，作为该文件的所有者，可以读取和写入这个文件，

217
00:15:38,000 --> 00:15:42,000
但有一个破折号说，jharvard无法执行此文件。

218
00:15:42,000 --> 00:15:46,000
接下来的3位组，所以这是学生群体，

219
00:15:46,000 --> 00:15:49,000
因此，如果有多个用户我的产品，

220
00:15:49,000 --> 00:15:52,000
我们有多个用户的学生组的一部分，

221
00:15:52,000 --> 00:15:55,000
他们都可以读取这个文件，但不能写，

222
00:15:55,000 --> 00:15:59,000
同样，任何人都，世界

223
00:15:59,000 --> 00:16:01,000
只能读取这个文件。

224
00:16:01,000 --> 00:16:03,000
关于这是一个良好的，长期的书面记录，

225
00:16:03,000 --> 00:16:05,000
这样你就可以在线阅读。

226
00:16:05,000 --> 00:16:10,000
问题集规格，我们进入更详细。

227
00:16:10,000 --> 00:16:12,000
>> [学生] 218指的是世界吗？

228
00:16:12,000 --> 00:16:17,000
218，我忘了，离我的头顶部

229
00:16:17,000 --> 00:16:20,000
但没有。

230
00:16:20,000 --> 00:16:29,000
让我们来看看。我消隐上是正确的。

231
00:16:29,000 --> 00:16:32,000
回到我们做这个使用chmod + x

232
00:16:32,000 --> 00:16:37,000
在这里我们想，给dynamic.php的可执行权限，

233
00:16:37,000 --> 00:16:40,000
问题是，这是否会给可执行文件的权限，每个人都

234
00:16:40,000 --> 00:16:44,000
或只是jharvard，我们可以看到这一点

235
00:16:44,000 --> 00:16:48,000
执行上面的命令，并输入ls-l，

236
00:16:48,000 --> 00:16:51,000
现在我们看到它标记为可执行。

237
00:16:51,000 --> 00:16:54,000
你可以看到，有颜色的变化。

238
00:16:54,000 --> 00:16:57,000
现在dynamic.php被列为绿色，

239
00:16:57,000 --> 00:17:01,000
它看起来像这个问题的答案是什么，夏洛特？

240
00:17:01,000 --> 00:17:04,000
夏洛特] jharvard。>> jharvard，是的。

241
00:17:04,000 --> 00:17:08,000
>> 如果我们想为大家打开可执行位

242
00:17:08,000 --> 00:17:10,000
我们是如何做到这一点呢？

243
00:17:10,000 --> 00:17:13,000
有什么想法？>> A + X？

244
00:17:13,000 --> 00:17:15,000
是的，没错。

245
00:17:15,000 --> 00:17:23,000
夏洛特说，我们所能做的属性A + X的dynamic.php，

246
00:17:23,000 --> 00:17:26,000
现在如果我们运行ls-l我们可以看到，可执行位

247
00:17:26,000 --> 00:17:30,000
确实就为大家打开。

248
00:17:30,000 --> 00:17:37,000
实际上，你可以做反向，所以你可以把它关掉为大家

249
00:17:37,000 --> 00:17:41,000
使用负。

250
00:17:41,000 --> 00:17:46,000
现在，它的关闭，现在我们可以把它为jharvard

251
00:17:46,000 --> 00:17:52,000
所以，我们实际上可以运行它，现在，

252
00:17:52,000 --> 00:17:58,000
现在你看到的，当我们运行这个特殊的代码＃！的顶行，

253
00:17:58,000 --> 00:18:04,000
＃！线，告诉外壳，

254
00:18:04,000 --> 00:18:08,000
告诉我们的终端哎，这个文件运行时，

255
00:18:08,000 --> 00:18:14,000
使用/ usr / bin中/ PHP来解释这个文件

256
00:18:14,000 --> 00:18:20,000
然后打印输出。

257
00:18:20,000 --> 00:18:22,000
[听不见的学生问题]

258
00:18:22,000 --> 00:18:25,000
当然，让我向后滚动。就这样。

259
00:18:25,000 --> 00:18:36,000
你会看到所有的这些指令开始的这一磅，然后惊叹号，

260
00:18:36,000 --> 00:18:39,000
有时也被称为一个家当，哈希爆炸。

261
00:18:39,000 --> 00:18:48,000
>> [学生]：我们可以运行它与PHP dynamic.php前，我们把它变成可执行？

262
00:18:48,000 --> 00:18:55,000
问题是我们如何可以运行使用PHP二进制

263
00:18:55,000 --> 00:18:58,000
，而dynamic.php是不可执行文件？

264
00:18:58,000 --> 00:19:01,000
这是超级重要的，因为这正是

265
00:19:01,000 --> 00:19:06,000
它在工作的时候你写的习题集7。

266
00:19:06,000 --> 00:19:09,000
大部分的时间PHP文件不是直接执行的。

267
00:19:09,000 --> 00:19:14,000
可行的方式，是因为它是PHP二进制文件的可执行文件。

268
00:19:14,000 --> 00:19:16,000
翻译是正在执行的东西，

269
00:19:16,000 --> 00:19:20,000
所以它在做什么是真正的slurping是在整个内容

270
00:19:20,000 --> 00:19:25,000
我们dynamic.php文件，一行行

271
00:19:25,000 --> 00:19:29,000
执行这些命令，所以它的使用我们的PHP文件

272
00:19:29,000 --> 00:19:31,000
作为指令的列表。

273
00:19:31,000 --> 00:19:36,000
它不直接执行它。

274
00:19:36,000 --> 00:19:40,000
这就是我们说，这些文件在运行时解释。

275
00:19:40,000 --> 00:19:46,000
这是一个运行时的语言，而不是在编译时确定的东西是，

276
00:19:46,000 --> 00:19:49,000
不是编译性语言比如C。

277
00:19:49,000 --> 00:19:54,000
>> 是否有一种方式来获得运行时语言，行动，如果它是一个编译时语言，

278
00:19:54,000 --> 00:19:58,000
就像如果你把所有的运行在服务器上完成

279
00:19:58,000 --> 00:20:00,000
，而不是你知道我的意思吗？

280
00:20:00,000 --> 00:20:04,000
是的，所以问题是，

281
00:20:04,000 --> 00:20:11,000
有一种方式来获得运行时的语言更像编译时类型的语言吗？

282
00:20:11,000 --> 00:20:18,000
还有，我的意思是，这是一个活跃的研究领域，这些公司的很多。

283
00:20:18,000 --> 00:20:22,000
我相信，Facebook已经做了很多工作，PHP

284
00:20:22,000 --> 00:20:25,000
并编译它，使其速度更快，优化

285
00:20:25,000 --> 00:20:29,000
因为他们的网站是建立在PHP。

286
00:20:29,000 --> 00:20:34,000
如果你已经node.js的一切，

287
00:20:34,000 --> 00:20:40,000
这是一种一个JavaScript解释器

288
00:20:40,000 --> 00:20:44,000
能够运行JavaScript的浏览器之外，您的Web浏览器之外，

289
00:20:44,000 --> 00:20:47,000
因为传统JavaScript的只是内部运行的Firefox或Chrome浏览器，

290
00:20:47,000 --> 00:20:52,000
，而且将被用来使很酷的动画在网页上发生

291
00:20:52,000 --> 00:20:55,000
使你的网页动态。

292
00:20:55,000 --> 00:20:59,000
这是谷歌做了很多工作，是建立在

293
00:20:59,000 --> 00:21:03,000
让JavaScript和C + +

294
00:21:03,000 --> 00:21:09,000
结合在一起，所以有很多活跃的研究领域，以

295
00:21:09,000 --> 00:21:13,000
这些语言交互，并对其进行优化，

296
00:21:13,000 --> 00:21:17,000
主要是因为这么多的人可以在PHP和JavaScript代码

297
00:21:17,000 --> 00:21:19,000
因为它是一个非常容易。

298
00:21:19,000 --> 00:21:21,000
这是一个非常和蔼。你没有指针。

299
00:21:21,000 --> 00:21:27,000
您不必四处飘荡的类型。

300
00:21:27,000 --> 00:21:31,000
他们希望获得的好处，这些编译时语言

301
00:21:31,000 --> 00:21:36,000
与所有类型检查的速度和更低的内存使用率和所有的

302
00:21:36,000 --> 00:21:42,000
同时仍然保持使用这些新的灵活性和易用性。

303
00:21:42,000 --> 00:21:46,000
>> 回到我们原来的计划的攻击。

304
00:21:46,000 --> 00:21:50,000
我们已经获得了一些对这些问题，在这里我们的问题集规格。

305
00:21:50,000 --> 00:21:54,000
让我们通过他们真的很快，我们会在房间里。

306
00:21:54,000 --> 00:21:59,000
夏洛特，是什么类型的3.50？

307
00:21:59,000 --> 00:22:01,000
[夏洛特]这是一个双重的。>>这是一个双。

308
00:22:01,000 --> 00:22:03,000
吉米，什么是下一个吗？>>阵列。

309
00:22:03,000 --> 00:22:09,000
一个数组，真棒，和Jared的fopen是什么？

310
00:22:09,000 --> 00:22:11,000
[贾里德这是一个资源。>>这是一个资源。

311
00:22:11,000 --> 00:22:15,000
这是一种新的，而不是一个文件明星，而不是一个文件。

312
00:22:15,000 --> 00:22:19,000
这是一个资源类型是在PHP，

313
00:22:19,000 --> 00:22:24,000
对不起，ELLA，最后空是什么？

314
00:22:24,000 --> 00:22:26,000
空。

315
00:22:26,000 --> 00:22:28,000
空，它是如何拼写的PHP？>>用同样的方法。

316
00:22:28,000 --> 00:22:30,000
用同样的方法，资金吗？>>呀。

317
00:22:30,000 --> 00:22:33,000
是啊，所有的权利。

318
00:22:33,000 --> 00:22:35,000
在这里，我们走了，我们已经得到了一个双重的，我们已经有了一个阵列，

319
00:22:35,000 --> 00:22:41,000
我们已经有了一个资源，然后我们已经得到了空。

320
00:22:41,000 --> 00:22:48,000
现在让我们来看看你见过

321
00:22:48,000 --> 00:22:51,000
让我们来看看，所以现在我想，我也希望做的是拉

322
00:22:51,000 --> 00:22:56,000
此网页在这里，php.net /手动，

323
00:22:56,000 --> 00:23:01,000
所以，如果你们复制，打开Web浏览器。

324
00:23:01,000 --> 00:23:07,000
我要拉了Chrome浏览器，，在。

325
00:23:07,000 --> 00:23:10,000
我想告诉你这不仅仅是因为

326
00:23:10,000 --> 00:23:13,000
我们可以谈论所有天左右，类型和所有有趣的东西

327
00:23:13,000 --> 00:23:19,000
而是因为这是PHP手册，

328
00:23:19,000 --> 00:23:23,000
有很多PHP程序员在那里。

329
00:23:23,000 --> 00:23:26,000
在那里有很多的PHP网站，

330
00:23:26,000 --> 00:23:31,000
，因此，有大量的文档，PHP，

331
00:23:31,000 --> 00:23:36,000
和手册，这php.net，是一个很好的地方去

332
00:23:36,000 --> 00:23:43,000
每当你遇到的问题，什么是最好的方式在PHP做X

333
00:23:43,000 --> 00:23:45,000
什么是一个功能是什么样子？

334
00:23:45,000 --> 00:23:49,000
只是一种熟悉，这看起来像什么，因为

335
00:23:49,000 --> 00:23:54,000
你会来到这里的时候，一个位问题7。

336
00:23:54,000 --> 00:23:57,000
>> 如果你最终做最后的项目，使用PHP

337
00:23:57,000 --> 00:24:04,000
这将是一个地方，你会变得非常熟悉。

338
00:24:04,000 --> 00:24:09,000
通常情况下，人们能做到这一点的是，他们使用谷歌搜索的网站，

339
00:24:09,000 --> 00:24:16,000
他们不使用的搜索框，在这里的右上角，这是一种微小的。

340
00:24:16,000 --> 00:24:19,000
如果你在谷歌搜索周围用PHP做的东西，你会看到

341
00:24:19,000 --> 00:24:24,000
本手册的链接弹出，通常可以依靠

342
00:24:24,000 --> 00:24:31,000
作为一个相当不错的资源。

343
00:24:31,000 --> 00:24:34,000
真棒，做出来的这些类型，只是出于好奇，

344
00:24:34,000 --> 00:24:37,000
哪些我们没有见过？

345
00:24:37,000 --> 00:24:40,000
我们还没有看到这里的内容吗？

346
00:24:40,000 --> 00:24:44,000
[学生]：资源。我们看到了资源与fopen的调用。

347
00:24:44,000 --> 00:24:48,000
[学生]：对象。对象是肯定的，我们还没有看到。

348
00:24:48,000 --> 00:24:51,000
回调我们还没有看到。

349
00:24:51,000 --> 00:24:54,000
有一些这些伪类型。

350
00:24:54,000 --> 00:24:57,000
我们确实只看到了整数和双。

351
00:24:57,000 --> 00:25:01,000
我们没有看到一些其他的，所以如果我们点击整数

352
00:25:01,000 --> 00:25:08,000
我们可以看到的是，他们在这里有任何其他的整数？

353
00:25:08,000 --> 00:25:11,000
难道他们全都是这样的整数，整数，整数。

354
00:25:11,000 --> 00:25:14,000
有些语言有更大的整数类型，

355
00:25:14,000 --> 00:25:23,000
就像我们今天在MySQL中看到的是int，然后大整数。

356
00:25:23,000 --> 00:25:25,000
酷。

357
00:25:25,000 --> 00:25:28,000
>> 所以，PHP手册。

358
00:25:28,000 --> 00:25:37,000
让我们回到我们的问题的一套规范，我们现在将向下滚动到第4页。

359
00:25:37,000 --> 00:25:41,000
发生的事情，当你收到这些语言之一

360
00:25:41,000 --> 00:25:49,000
没有这个静态类型的语言，所以这些，你必须声明

361
00:25:49,000 --> 00:25:52,000
类型的一个变量了前面

362
00:25:52,000 --> 00:26:00,000
你的情况下，你可能会开始有不同类型的变量

363
00:26:00,000 --> 00:26:04,000
彼此相互作用，

364
00:26:04,000 --> 00:26:09,000
和PHP做这件事情的，它试图做

365
00:26:09,000 --> 00:26:13,000
它认为是最明智的事情

366
00:26:13,000 --> 00:26:18,000
当你有2种不同类型彼此交互的。

367
00:26:18,000 --> 00:26:24,000
例如，如果我们看一下这几行代码在这里

368
00:26:24,000 --> 00:26:29,000
你看，我们已经得到了时会发生什么

369
00:26:29,000 --> 00:26:38,000
我们尝试添加串1的整数2。

370
00:26:38,000 --> 00:26:41,000
会发生什么，如果我们尝试添加一个字符串，它是不是一个数值

371
00:26:41,000 --> 00:26:48,000
而是实际的字符数50，CS吗？

372
00:26:48,000 --> 00:26:51,000
然后我们会看到有不同的情况出现

373
00:26:51,000 --> 00:26:56,000
而不是添加一个字符串到数字，我们要添加一个数字到字符串，

374
00:26:56,000 --> 00:27:00,000
等等等等的地步，我们要

375
00:27:00,000 --> 00:27:05,000
某种奇怪的东西，在这里我们已经得到了7 +真实。

376
00:27:05,000 --> 00:27:09,000
这到底是什么意思呢？

377
00:27:09,000 --> 00:27:19,000
>> 如果你们去一些代码并粘贴到您的设备。

378
00:27:19,000 --> 00:27:27,000
您保持在dynamic.php。

379
00:27:27,000 --> 00:27:30,000
我们将看看会发生什么。

380
00:27:41,000 --> 00:27:43,000
[学生]：只要使用打印，不是printf？

381
00:27:43,000 --> 00:27:52,000
是啊，所以你会发现，也是一个有效的打印功能打印PHP。

382
00:27:52,000 --> 00:27:54,000
有许多不同的方法做这件事。

383
00:27:54,000 --> 00:27:58,000
以后，一旦我们开始谈论我们会看到一对夫妇的例子

384
00:27:58,000 --> 00:28:02,000
唯一的问题是我们要编写的

385
00:28:02,000 --> 00:28:06,000
然后将浓度问题，我们要编写

386
00:28:06,000 --> 00:28:09,000
即使我们有FOPEN和fclose

387
00:28:09,000 --> 00:28:15,000
往往不读取一个文件的内容的最简单的方法。

388
00:28:15,000 --> 00:28:21,000
PHP有很多这些C-遗留下来的。

389
00:28:21,000 --> 00:28:28,000
[学生]：当我把所有的那些东西，我只得到一个数字作为输出。

390
00:28:28,000 --> 00:28:36,000
内特H.]当你把所有这些东西。

391
00:28:36,000 --> 00:28:39,000
让我们来看看它，因为它可能

392
00:28:39,000 --> 00:28:46,000
有一件事是在新的生产线，这些打印调用不会终止。

393
00:28:46,000 --> 00:28:49,000
有没有新的生产线分离每个这些打印电话，

394
00:28:49,000 --> 00:28:51,000
所以，也许你得到一个大的数量，

395
00:28:51,000 --> 00:28:58,000
它实际上只是汞合金的新行字符。

396
00:28:58,000 --> 00:29:00,000
[学生]：好了，怎么我确保

397
00:29:00,000 --> 00:29:03,000
那么，有一堆不同的方式。

398
00:29:03,000 --> 00:29:06,000
你可以手动将在一个新行字符打印，

399
00:29:06,000 --> 00:29:09,000
新行字符的回声，

400
00:29:09,000 --> 00:29:12,000
打印新的生产线。

401
00:29:12,000 --> 00:29:16,000
[学生]：所以回声如printf是一样的东西吗？

402
00:29:16,000 --> 00:29:21,000
>> printf是像C的printf

403
00:29:21,000 --> 00:29:24,000
您要打印的格式化字符串。

404
00:29:24,000 --> 00:29:32,000
你提供的格式字符串，然后所有的占位符变量。

405
00:29:32,000 --> 00:29:39,000
这是经常不使用的东西，

406
00:29:39,000 --> 00:29:42,000
让我们来看看，作为一个声明，

407
00:29:42,000 --> 00:29:48,000
我不太熟悉PHP比我其他的网络语言，

408
00:29:48,000 --> 00:29:53,000
当我在PHP编程，我通常不使用printf

409
00:29:53,000 --> 00:29:59,000
因为我发现它使用的字符串插值功能，它有更快，

410
00:29:59,000 --> 00:30:04,000
我们将去，我会告诉你，在短短一秒钟，

411
00:30:04,000 --> 00:30:08,000
而在C中，我们有做到这一点哈克的事情，得到它的正确打印。

412
00:30:08,000 --> 00:30:16,000
实际上，你可以直接把变量转换成字符串在PHP。

413
00:30:16,000 --> 00:30:22,000
printf是过于长，我通常做的那种。是的，艾拉。

414
00:30:22,000 --> 00:30:25,000
[云裳]一般来说，如果你得到分析错误是什么意思，

415
00:30:25,000 --> 00:30:30,000
像在C，它不会告诉你确切的错误是什么，它​​是，

416
00:30:30,000 --> 00:30:34,000
这是否意味着看看通过整个代码和数字呢？

417
00:30:34,000 --> 00:30:39,000
这是典型的比这更有针对性。

418
00:30:39,000 --> 00:30:48,000
在这种情况下，我认为这是一个有点偏离，

419
00:30:48,000 --> 00:30:51,000
所以，我认为，在这种情况下，我们缺少一个分号。

420
00:30:51,000 --> 00:30:54,000
它试图让一切的感觉，

421
00:30:54,000 --> 00:30:57,000
这样的解释型语言，解释是要尝试

422
00:30:57,000 --> 00:31:01,000
尽最大努力使一切工作适当。

423
00:31:01,000 --> 00:31:04,000
>> 你会看到，例如，在JavaScript中

424
00:31:04,000 --> 00:31:10,000
你会经常行语句结尾的分号，就像他们在PHP中，

425
00:31:10,000 --> 00:31:13,000
就像他们在C.

426
00:31:13,000 --> 00:31:15,000
在JavaScript中的JavaScript解释器

427
00:31:15,000 --> 00:31:20,000
在很多的浏览器会把你在分号

428
00:31:20,000 --> 00:31:23,000
如果你碰巧缺少。

429
00:31:23,000 --> 00:31:29,000
他们会尝试和适应上的一些疏漏。

430
00:31:29,000 --> 00:31:34,000
这可能尝试和努力，并试图把事情的工作，

431
00:31:34,000 --> 00:31:36,000
，然后最后会得到一个点，它说没关系，

432
00:31:36,000 --> 00:31:38,000
我不能让工作想逃，这就是你会得到一个行号

433
00:31:38,000 --> 00:31:44,000
这可能似乎有点偏离的确切地点。

434
00:31:44,000 --> 00:31:47,000
好吧，让我们通过这个真的很快。

435
00:31:47,000 --> 00:31:50,000
我们与Ella，让我们去大小姐，

436
00:31:50,000 --> 00:31:54,000
大小姐，是什么打印的串1加数字2给你吗？

437
00:31:54,000 --> 00:31:56,000
[大小姐] 3。>> 3。

438
00:31:56,000 --> 00:31:59,000
这是否有意义吗？排序的？

439
00:31:59,000 --> 00:32:02,000
它给你一个数字？它给你一个字符串？

440
00:32:02,000 --> 00:32:05,000
[大小姐]一个数字。这是一个数字。

441
00:32:05,000 --> 00:32:09,000
但它的印刷，所以它给你一些字符串排序。

442
00:32:09,000 --> 00:32:12,000
>> 有一件事我们可以做检查了这一点

443
00:32:12,000 --> 00:32:21,000
如果我们这样做是$ var = 1 + 2

444
00:32:21,000 --> 00:32:28,000
那么我们说的getType回声，

445
00:32:28,000 --> 00:32:33,000
因此，我们使用的是第三类印刷在这里。

446
00:32:33,000 --> 00:32:39,000
现在，我们可以看到这里发生的一切。

447
00:32:39,000 --> 00:32:42,000
在这里，我们得到的是我们得到了整数。

448
00:32:42,000 --> 00:32:45,000
即使我们添加字符串到数字，

449
00:32:45,000 --> 00:32:48,000
我们没有得到一个字符串，它只是像大小姐说。

450
00:32:48,000 --> 00:32:52,000
我们得到一个整数。

451
00:32:52,000 --> 00:32:57,000
好吧，让我们来看看，第二天起来，凯文。

452
00:32:57,000 --> 00:32:59,000
CS + 50？>> [凯文] 50。

453
00:32:59,000 --> 00:33:02,000
[内特H.] 50。这是否有意义吗？

454
00:33:02,000 --> 00:33:04,000
[凯文]是啊。

455
00:33:04,000 --> 00:33:06,000
[内特H.]为什么呢？为什么对你有意义吗？

456
00:33:06,000 --> 00:33:11,000
[凯文，因为它只是字符串的数值为零。

457
00:33:11,000 --> 00:33:16,000
是啊，太好了。

458
00:33:16,000 --> 00:33:20,000
这种模棱两可的情况下，但它的好，知道会发生什么。

459
00:33:20,000 --> 00:33:25,000
斯特拉，1 +字符串2号接下来会发生什么？

460
00:33:25,000 --> 00:33:27,000
[斯特拉] 3。>> 3。

461
00:33:27,000 --> 00:33:30,000
在这种情况下，我们得到了一个字符串或数字？

462
00:33:30,000 --> 00:33:36,000
>> 让我们试试这个。

463
00:33:36,000 --> 00:33:43,000
任何人比我更快得到答案？夏洛特？

464
00:33:43,000 --> 00:33:46,000
哦，我没说好了，让我们来看看，我们将做同样的事情

465
00:33:46,000 --> 00:33:49,000
在这里我们已经得到了一个号码加一个字符串，并且我们要响应的类型，

466
00:33:49,000 --> 00:33:51,000
看看我们。

467
00:33:51,000 --> 00:33:55,000
我们还得到一个整数。

468
00:33:55,000 --> 00:33:58,000
不要紧，哪一个是，哪一个是数量的字符串。

469
00:33:58,000 --> 00:34:00,000
我们仍然要得到一个整数。

470
00:34:00,000 --> 00:34:04,000
它仍然会做什么，我们所期望的。

471
00:34:04,000 --> 00:34:09,000
所有的权利，所以Sam，90 + 9瓶啤酒在墙壁上？

472
00:34:09,000 --> 00:34:12,000
[三] 99。>> 99。

473
00:34:12,000 --> 00:34:15,000
没有啤酒瓶在墙上，虽然。

474
00:34:15,000 --> 00:34:17,000
它为我们提供了一些信息发生了什么事。

475
00:34:17,000 --> 00:34:21,000
[三]如果你写的信中

476
00:34:21,000 --> 00:34:23,000
那么你将有90吧？

477
00:34:23,000 --> 00:34:26,000
[内特H.]是啊。

478
00:34:26,000 --> 00:34:30,000
现在的问题是，如果我们写N-I-N-E

479
00:34:30,000 --> 00:34:34,000
我们已经获得了99或90？

480
00:34:34,000 --> 00:34:38,000
我们会得到90。

481
00:34:38,000 --> 00:34:42,000
它实际上只是寻找数字字符。

482
00:34:42,000 --> 00:34:46,000
这是不足够的智慧认识数目字的东西。是。

483
00:34:46,000 --> 00:34:48,000
>> [学生]：是有这样的事情在PHP中类型强制转换？

484
00:34:48,000 --> 00:34:54,000
目前，它是完全相同的方式，你会做的C.

485
00:34:54,000 --> 00:34:56,000
什么关于10/7，夏洛特？

486
00:34:56,000 --> 00:34:58,000
[夏洛特1.4285。

487
00:34:58,000 --> 00:35:01,000
内特H.]是啊，所以可能是什么奇怪呢？

488
00:35:01,000 --> 00:35:04,000
会发生什么，如果你这样做同样的事情，在C，

489
00:35:04,000 --> 00:35:06,000
如果你做了10/7在C？

490
00:35:06,000 --> 00:35:08,000
夏洛特]只会给你，取决于你如何typecasted我想

491
00:35:08,000 --> 00:35:12,000
它会给你只有有限数量的小数点后的位数。

492
00:35:12,000 --> 00:35:16,000
是啊，所以数量有限的小数点后的位数。

493
00:35:16,000 --> 00:35:21,000
还有什么可能将它给你任何小数点后的数字吗？

494
00:35:21,000 --> 00:35:28,000
通常，如此反复，这取决于你如何映射

495
00:35:28,000 --> 00:35:31,000
它可能会或可能不会将它转换到一个浮点数。

496
00:35:31,000 --> 00:35:35,000
在这里，它是一种不错的，它没有。

497
00:35:35,000 --> 00:35:40,000
如果我们你回来的时候我们就开始做这种东西在C

498
00:35:40,000 --> 00:35:44,000
它可能会作出一些更有意义

499
00:35:44,000 --> 00:35:48,000
它不只是去1。

500
00:35:48,000 --> 00:35:51,000
最后，杰米，然后约7 +真实吗？

501
00:35:51,000 --> 00:35:53,000
[杰米] 8。>> 8。

502
00:35:53,000 --> 00:35:56,000
这是什么意思呢？

503
00:35:56,000 --> 00:35:58,000
我猜它只是提供了真正的值为1。

504
00:35:58,000 --> 00:36:01,000
是啊。如果我们改变为false，会发生什么情况呢？

505
00:36:01,000 --> 00:36:04,000
[学生]：7。

506
00:36:04,000 --> 00:36:09,000
是啊，所以请记住，我们谈论这些二进制值，

507
00:36:09,000 --> 00:36:12,000
1，0是关闭？

508
00:36:12,000 --> 00:36:17,000
现在我们有真正的值为1，0是假的，

509
00:36:17,000 --> 00:36:21,000
，你可能没有看到这在C的例子，我们已经做到了这一点过去的学期，

510
00:36:21,000 --> 00:36:27,000
bool类型在C，但在历史上，还没有一个真正的类型，

511
00:36:27,000 --> 00:36:32,000
所以人们用0和1的真假。

512
00:36:32,000 --> 00:36:35,000
这是一个体现的是。

513
00:36:35,000 --> 00:36:39,000
>> 好了，所以这一切的一个重要组成部分

514
00:36:39,000 --> 00:36:41,000
是，我们有这些不同的类型。

515
00:36:41,000 --> 00:36:43,000
它们可以彼此交互。

516
00:36:43,000 --> 00:36:49,000
他们往往可以互相交流的方式很不错的，因为我们在这里看到。

517
00:36:49,000 --> 00:36:53,000
真的很高兴能有串1和2号，加在一起，得到3。

518
00:36:53,000 --> 00:36:55,000
这是有道理的。

519
00:36:55,000 --> 00:36:59,000
然而，当你写的网站，尤其是当你正在处理

520
00:36:59,000 --> 00:37:04,000
用户输入的，所以说你写了一个Web表单

521
00:37:04,000 --> 00:37:09,000
收集来自用户的信息，然后进入处理它

522
00:37:09,000 --> 00:37:13,000
在后端，在你的PHP代码在服务器端

523
00:37:13,000 --> 00:37:18,000
如果你期待值，用户输入并提交

524
00:37:18,000 --> 00:37:23,000
形式是一个整数或浮点数的或类似的东西

525
00:37:23,000 --> 00:37:29,000
你需要明确地将它转换

526
00:37:29,000 --> 00:37:34,000
，然后做一些类型检查。

527
00:37:34,000 --> 00:37:41,000
>> 你不想仅仅依靠这种类型戏法的系统，以使事情成功，

528
00:37:41,000 --> 00:37:48,000
尤其是出于安全考虑，只为您的网站的鲁棒性。

529
00:37:48,000 --> 00:37:51,000
只是要记住，只要你处理表单数据，

530
00:37:51,000 --> 00:37:57,000
任何东西来后或GET和superglobals

531
00:37:57,000 --> 00:38:01,000
请确保您始终验证它，并把它转换和强制转换。

532
00:38:01,000 --> 00:38:04,000
就像我们谈论了一会儿前，类型转换

533
00:38:04,000 --> 00:38:08,000
在PHP是完全一样的，在C，你必须在括号

534
00:38:08,000 --> 00:38:14,000
然后该类型。

535
00:38:14,000 --> 00:38:16,000
记住这一点。

536
00:38:16,000 --> 00:38:19,000
一个功能，将派上用场，当你这样做

537
00:38:19,000 --> 00:38:22,000
我们已经使用，这是一种顺便说一句，

538
00:38:22,000 --> 00:38:27,000
我们一直在使用这个GetType函数在这里

539
00:38:27,000 --> 00:38:30,000
找出一个变量的类型，

540
00:38:30,000 --> 00:38:37,000
，而这是非常方便的进行调试，并看到一个变量的类型是什么

541
00:38:37,000 --> 00:38:42,000
你不希望使用这一点，例如，在一个条件

542
00:38:42,000 --> 00:38:57,000
你检查，看是否是$ var =整数的getType的做一些事情。

543
00:38:57,000 --> 00:39:01,000
这是一个坏，坏，坏。

544
00:39:01,000 --> 00:39:09,000
取而代之的是这些调用的函数是整数，字符串，

545
00:39:09,000 --> 00:39:14,000
是数组，你要使用，所以在这种情况下，

546
00:39:14,000 --> 00:39:18,000
我想这样做，而不是这家伙在这里

547
00:39:18,000 --> 00:39:31,000
是使用的是整数的变种。

548
00:39:31,000 --> 00:39:37,000
他们通常被称为是IS_ *在这个意义上，你可以更换*整数，

549
00:39:37,000 --> 00:39:43,000
字符串，等等，只是非常快的，以确保

550
00:39:43,000 --> 00:39:50,000
这是诠释PHP。

551
00:39:50,000 --> 00:39:59,000
看起来像你可以做的是int或有整数以及？

552
00:39:59,000 --> 00:40:06,000
是的，别名，所以int整数的别名。

553
00:40:06,000 --> 00:40:08,000
酷。

554
00:40:14,000 --> 00:40:17,000
>> 我们要怎么做呢？

555
00:40:17,000 --> 00:40:20,000
让我们加快脚步一点点。

556
00:40:20,000 --> 00:40:24,000
现在，我们要谈谈数组，所以你可以看到

557
00:40:24,000 --> 00:40:28,000
在我们谈论如何在PHP数组的下一个部分的规范

558
00:40:28,000 --> 00:40:31,000
略有不同，它们是在C

559
00:40:31,000 --> 00:40:34,000
事实上，他们的汞合金

560
00:40:34,000 --> 00:40:36,000
你已经认识到，爱在C的阵列

561
00:40:36,000 --> 00:40:40,000
那里的一切是相同的类型的

562
00:40:40,000 --> 00:40:43,000
连续和连续存储在内存中，

563
00:40:43,000 --> 00:40:46,000
你有这些数字指标。

564
00:40:46,000 --> 00:40:49,000
您有索引，索引1，索引2 0，

565
00:40:49,000 --> 00:40:53,000
存储在这些指标的值。

566
00:40:53,000 --> 00:40:57,000
您还可以在C，你写的拼写时，有不少人

567
00:40:57,000 --> 00:41:00,000
做了哈希表的做法，你看到我们在那里有

568
00:41:00,000 --> 00:41:03,000
不同类型的存储，我们映射

569
00:41:03,000 --> 00:41:07,000
一个键的值，所以当你试图存储在哈希表中的东西

570
00:41:07,000 --> 00:41:11,000
你必须指定你想存储与特定键，

571
00:41:11,000 --> 00:41:17,000
和确定该键的位置的值，并在将被存储。

572
00:41:17,000 --> 00:41:22,000
您已经种了这些概念都发生在同一时间在一个PHP数组，

573
00:41:22,000 --> 00:41:27,000
，因此，我们常说这些关联数组

574
00:41:27,000 --> 00:41:33,000
当我们一个键关联的值。

575
00:41:33,000 --> 00:41:39,000
在接下来的部分，我们讲一个简单的PHP数组

576
00:41:39,000 --> 00:41:45,000
在那里我们有键a，b，和c，

577
00:41:45,000 --> 00:41:53,000
所有字符串，映射到整数1，2，和3。

578
00:41:53,000 --> 00:41:57,000
你可以有不同类型的键。

579
00:41:57,000 --> 00:42:00,000
>> 你可以有一些键是字符串，有些键是整数。

580
00:42:00,000 --> 00:42:03,000
你可以有不同类型的值。

581
00:42:03,000 --> 00:42:06,000
你可以有一个值，该值是一个字符串，这是一个整数的值，

582
00:42:06,000 --> 00:42:11,000
值，这个值是一个对象或另一个数组，例如，

583
00:42:11,000 --> 00:42:16,000
在相同的数组对象，这是一种奇怪的。

584
00:42:16,000 --> 00:42:20,000
您不必有一个数组，只是得到了一个类型的元素。

585
00:42:20,000 --> 00:42:26,000
你可以有许多不同的东西在那里。

586
00:42:26,000 --> 00:42:33,000
另外要注意的是，当你看到这样的事情在你的代码，

587
00:42:33,000 --> 00:42:38,000
这是合法的PHP宣布就这样，阵列0，1，2，3，4，5，

588
00:42:38,000 --> 00:42:43,000
将宣布这个数组的初始化改编。

589
00:42:43,000 --> 00:42:48,000
但你实际上得到的引擎盖下是这种隐

590
00:42:48,000 --> 00:42:55,000
键，我们已经得到了0至0，1对1，2 2，3 3代。

591
00:42:55,000 --> 00:42:59,000
而事实证明，即使你做了这样的家伙在这里有一个数组

592
00:42:59,000 --> 00:43:03,000
在那里你有A，B和C的钥匙

593
00:43:03,000 --> 00:43:09,000
然后你开始使用数组push方法开始使用这个数组就像一个堆栈，

594
00:43:09,000 --> 00:43:12,000
所以你可以看到这个数组，这个数组对象，实在是过载。

595
00:43:12,000 --> 00:43:15,000
我们可以使用它作为一个数组。我们可以使用它作为一个哈希表。

596
00:43:15,000 --> 00:43:19,000
我们可以使用它作为一个堆栈。

597
00:43:19,000 --> 00:43:22,000
当你开始推动的事情到这个阵列

598
00:43:22,000 --> 00:43:30,000
你的第一件事情推到这个索引为0，然后索引1索引2。

599
00:43:30,000 --> 00:43:33,000
你可以得到这样的隐式密钥的生成的

600
00:43:33,000 --> 00:43:38,000
除非你明确指定。

601
00:43:38,000 --> 00:43:43,000
你明确指定键的方式，当然，使用这种支架符号，

602
00:43:43,000 --> 00:43:48,000
这是类似于数组除外，而不是只允许

603
00:43:48,000 --> 00:43:54,000
在这里的整数索引，现在我们允许任何东西。

604
00:43:54,000 --> 00:43:57,000
如果你想你的关键，是一个字符串，你会像这样指定。

605
00:43:57,000 --> 00:44:06,000
如果你希望它是一个int，您指定的诠释您要使用的。

606
00:44:06,000 --> 00:44:13,000
>> 的问题上，迄今为止吗？

607
00:44:13,000 --> 00:44:18,000
关于这个想法的好东西之一

608
00:44:18,000 --> 00:44:26,000
是，你永远只能有一个值存储与特定的关键。

609
00:44:26,000 --> 00:44:32,000
如果我们回到我们的设备让我删除了一些这方面的东西。

610
00:44:32,000 --> 00:44:47,000
比方说，我初始化为0，1，2，做一个阵列。

611
00:44:47,000 --> 00:44:55,000
如果我现在知道，例如，如果我echo $到达[0]

612
00:44:55,000 --> 00:44:59,000
我要打印出来的值为0，

613
00:44:59,000 --> 00:45:05,000
因为永远只能是一个值存储为一个特定的键

614
00:45:05,000 --> 00:45:11,000
如果我储存的东西在$改编[0]，说，

615
00:45:11,000 --> 00:45:16,000
后来我才知道，当我echo $改编[0]再次

616
00:45:16,000 --> 00:45:19,000
我不打算打印出来前得到0。

617
00:45:19,000 --> 00:45:24,000
我只是要得到一个。

618
00:45:24,000 --> 00:45:30,000
因此，这基本上是说，我可以没有到达[0]存储2个不同的值。

619
00:45:30,000 --> 00:45:34,000
它不能存储0和字符串a，像这样从字面上取代

620
00:45:34,000 --> 00:45:38,000
什么是在$ ARR [0]以前。

621
00:45:38,000 --> 00:45:43,000
我之所以提起这件事时，它会看看会发生什么。

622
00:45:43,000 --> 00:45:47,000
看到这里，我得到了0打印出来，然后在这里。

623
00:45:47,000 --> 00:45:51,000
有没有新的生产线，因为我是个懒人，并没有把它英寸

624
00:45:51,000 --> 00:45:54,000
什么是酷的是，我们可以用这样的一种方式

625
00:45:54,000 --> 00:46:00,000
捕捉到了这个念头一组

626
00:46:00,000 --> 00:46:07,000
我们不能在一个阵列中有多个密钥。

627
00:46:07,000 --> 00:46:10,000
我们不能有相同的键，在一个阵列。

628
00:46:10,000 --> 00:46:17,000
我不能让键0和值1和0键和值一

629
00:46:17,000 --> 00:46:21,000
或0键和值true。

630
00:46:21,000 --> 00:46:27,000
这些键都只有1数组中的键。

631
00:46:27,000 --> 00:46:32,000
即使你可以有相同的值存储

632
00:46:32,000 --> 00:46:35,000
阵列中的不同的密钥下多次

633
00:46:35,000 --> 00:46:42,000
在你的PHP数组具有相同的键多次，这是不可能的。

634
00:46:42,000 --> 00:46:47,000
>> 如果我们看一下在这个未来的问题，unique.php，

635
00:46:47,000 --> 00:46:51,000
我们要打开一个PHP文件

636
00:46:51,000 --> 00:46:54,000
包含一个字符串列表，每行一个字符串，

637
00:46:54,000 --> 00:47:01,000
我们要在该文件中找到的唯一的字符串

638
00:47:01,000 --> 00:47:06,000
我们要做的是使用这些PHP数组

639
00:47:06,000 --> 00:47:12,000
和在文件中使用的字符串到这个数组中的键

640
00:47:12,000 --> 00:47:17,000
并不断更新我们的数组，因为我们这些新的密钥存储。

641
00:47:17,000 --> 00:47:22,000
当我们读出来的文件的每一行，我们可以将其存储在数组中，

642
00:47:22,000 --> 00:47:28,000
并在年底，我们将有我们的钥匙在我们的数组

643
00:47:28,000 --> 00:47:34,000
所有在文件中唯一的字符串。

644
00:47:34,000 --> 00:47:37,000
这是否有意义吗？

645
00:47:37,000 --> 00:47:41,000
让我们来看看它是如何工作的。

646
00:47:41,000 --> 00:47:49,000
我们去开拓，根据该规范，创建一个新文件unique.php。

647
00:47:49,000 --> 00:47:58,000
打开。哎呀，对不起，新的文件。

648
00:47:58,000 --> 00:48:03,000
我们要开始了相同的开始和结束标记。

649
00:48:03,000 --> 00:48:17,000
我们将它保存在第9，和我们要调用它unique.php的。

650
00:48:17,000 --> 00:48:25,000
好了，现在放大。

651
00:48:25,000 --> 00:48:32,000
这里的想法是打开一个文件，

652
00:48:32,000 --> 00:48:38,000
读取文件中的行由行。

653
00:48:38,000 --> 00:48:46,000
对于文件中的每一行

654
00:48:46,000 --> 00:48:51,000
我们将有一个数组，其中有

655
00:48:51,000 --> 00:49:03,000
 作为我们的主要线路。

656
00:49:03,000 --> 00:49:09,000
然后，当我们到这里就结束了

657
00:49:09,000 --> 00:49:17,000
$改编的键是独特的线条

658
00:49:17,000 --> 00:49:25,000
从文件，因为我们知道，如果我把这个数组的行

659
00:49:25,000 --> 00:49:33,000
多次将只保留覆盖旧值，

660
00:49:33,000 --> 00:49:46,000
，我们实际上可以把阵列产品线，本身只是喜欢。

661
00:49:46,000 --> 00:49:48,000
>> 这是一种奇怪的。

662
00:49:48,000 --> 00:49:52,000
我们相同的键值对存储一遍又一遍，一遍，

663
00:49:52,000 --> 00:50:00,000
但是因为我们保证将只有1键称为行

664
00:50:00,000 --> 00:50:05,000
因此，如果我们有一个文件说，动物的声音的文件，汪，汪，

665
00:50:05,000 --> 00:50:11,000
喵，喵，哞，哞，每一次我们读的动物噪声在

666
00:50:11,000 --> 00:50:15,000
像纬，将其存储在数组中，我们得到纬，然后第二次

667
00:50:15,000 --> 00:50:20,000
我们存储纬它会覆盖第一次，我们把它保存。

668
00:50:20,000 --> 00:50:25,000
最后，我们将只有一个数组中的条目

669
00:50:25,000 --> 00:50:33,000
在我们的动物的声音文件中的每个动物的声音。

670
00:50:33,000 --> 00:50:41,000
你们是否有信心，你可以解决的开幕PHP中的文件吗？

671
00:50:41,000 --> 00:50:45,000
做到这一点的方法之一，让我们在这个快速的一种方式做到这一点

672
00:50:45,000 --> 00:50:50,000
是用fopen，就像我们在前面看到的。

673
00:50:50,000 --> 00:50:55,000
您可以的FOPEN some_file.txt。

674
00:50:55,000 --> 00:50:59,000
你可以打开阅读模式，就像在C

675
00:50:59,000 --> 00:51:02,000
这是一个非常好的办法做到这一点。

676
00:51:02,000 --> 00:51:05,000
您还可以读取文件中的行由行

677
00:51:05,000 --> 00:51:12,000
有相同的功能，他们中的很多，你在C.

678
00:51:12,000 --> 00:51:14,000
你有FGETS。

679
00:51:14,000 --> 00:51:17,000
你有FEOF，虽然我们不喜欢使用，

680
00:51:17,000 --> 00:51:22,000
因为，要记住，这不是伟大的C.

681
00:51:22,000 --> 00:51:25,000
你可以做同样的方式，

682
00:51:25,000 --> 00:51:34,000
但这里是一个非常酷的事情。

683
00:51:34,000 --> 00:51:41,000
对不起，我不希望做文件，但有一个函数在PHP调用文件，

684
00:51:41,000 --> 00:51:47,000
此功能在这里是冷静，因为它的全部内容读

685
00:51:47,000 --> 00:51:52,000
您指定的文件，所以some_file.txt的，

686
00:51:52,000 --> 00:51:56,000
到一个数组中读出的文件的全部内容

687
00:51:56,000 --> 00:52:03,000
然后让你遍历它，这是非常漂亮的。

688
00:52:03,000 --> 00:52:07,000
>> 如果我们走了，例如，我们的Web浏览器

689
00:52:07,000 --> 00:52:14,000
我们来看看谷歌的PHP文件

690
00:52:14,000 --> 00:52:23,000
在这里，你可以看到我们的说明书上说，文件读取整个文件到一个数组，

691
00:52:23,000 --> 00:52:27,000
我们可以file_get_contents返回一个文件的内容作为一个字符串，

692
00:52:27,000 --> 00:52:30,000
但通常只是作为一个数组是非常好的，因为它做什么

693
00:52:30,000 --> 00:52:33,000
它打破它，以便每个元素

694
00:52:33,000 --> 00:52:37,000
在阵列中的文件是一行，

695
00:52:37,000 --> 00:52:41,000
因此，如果我们看一下文件0，这是该文件的第一行。

696
00:52:41,000 --> 00:52:46,000
文件1，第二行，文件2，第三行，等等，等等。

697
00:52:46,000 --> 00:52:50,000
那岂不是很好，如果这是你必须做在C？

698
00:52:50,000 --> 00:52:53,000
相当漂亮的。

699
00:52:53,000 --> 00:52:59,000
大卫表明这在演讲中，他表现出的成语是

700
00:52:59,000 --> 00:53:03,000
在除了环PHP我们的标准，我们有这样的

701
00:53:03,000 --> 00:53:09,000
（$ I = 0; I <10; i + +），

702
00:53:09,000 --> 00:53:16,000
，你可以做到这一点在PHP中，同样的事情也

703
00:53:16,000 --> 00:53:27,000
我们也有这个很酷的结构，名为foreach的。

704
00:53:27,000 --> 00:53:32,000
foreach是非常方便的遍历数组或数据结构时，

705
00:53:32,000 --> 00:53:36,000
因为它可以让你拉出来的每个元素的数组

706
00:53:36,000 --> 00:53:42,000
而无需手动做自己的索引，

707
00:53:42,000 --> 00:53:46,000
而不必手动创建一个索引变量，增加它，

708
00:53:46,000 --> 00:53:51,000
拉出值在数组中的这一点，因为这是一个非常普遍的事情。

709
00:53:51,000 --> 00:53:54,000
>> 您可能已经这样做的时候，你在做C语言的吨

710
00:53:54,000 --> 00:54:00,000
在这学期，所以这个foreach

711
00:54:00,000 --> 00:54:06,000
我们可以在这个文件数组循环，

712
00:54:06,000 --> 00:54:12,000
和语法的是，我们想现在这一大堆的循环

713
00:54:12,000 --> 00:54:18,000
并指定该变量，我们将用它来存储

714
00:54:18,000 --> 00:54:27,000
本地这个阵列的元素，这个foreach循环的范围的局部，

715
00:54:27,000 --> 00:54:32,000
我们把它称为线。

716
00:54:32,000 --> 00:54:38,000
如果它是一个文件，只是有一个字行

717
00:54:38,000 --> 00:54:43,000
我们可以把它称为字为好，其实只是你给这个名称，

718
00:54:43,000 --> 00:54:49,000
无论你怎么称呼它，

719
00:54:49,000 --> 00:55:02,000
内循环，然后，你可以做任何你想做的这个变线。

720
00:55:02,000 --> 00:55:08,000
如果没有足够的值的数组，你也希望得到

721
00:55:08,000 --> 00:55:17,000
随着它的索引，你可以指定名称的索引

722
00:55:17,000 --> 00:55:22,000
以及价值，现在你有2个变量的访问。

723
00:55:22,000 --> 00:55:26,000
你有$ i和行

724
00:55:26,000 --> 00:55:30,000
其中，$ i是索引数组中，

725
00:55:30,000 --> 00:55:38,000
线是从文件中检索的行。

726
00:55:38,000 --> 00:55:49,000
例如，如果我们想打印出来的文件，因为这回声线0，

727
00:55:49,000 --> 00:55:57,000
就这样，我们能做到这一点，“行我的文件$行”

728
00:55:57,000 --> 00:56:02,000
这里是我们也没有见过的东西

729
00:56:02,000 --> 00:56:13,000
我只是完全跳过了整个％S％D业务

730
00:56:13,000 --> 00:56:16,000
我们不得不处理在C，相反，我已经走了直

731
00:56:16,000 --> 00:56:19,000
写在我的字符串中的变量线。

732
00:56:19,000 --> 00:56:23,000
>> 这就是所谓的变量插值，串插

733
00:56:23,000 --> 00:56:26,000
您在何处馅的变量，和PHP解释器

734
00:56:26,000 --> 00:56:31,000
是足够聪明，当它通过一个字符串，用双引号开始阅读

735
00:56:31,000 --> 00:56:34,000
而不是单引号，单引号字符串，你不能做到这一点，

736
00:56:34,000 --> 00:56:38,000
但与双引号字符串，因为它读取的变量，通过它的。

737
00:56:38,000 --> 00:56:42,000
它的狩猎下来，如果它认为变量将变量的值

738
00:56:42,000 --> 00:56:47,000
并把它的字符串，如果它可以将其转换成一个字符串表示，

739
00:56:47,000 --> 00:56:51,000
这是非常漂亮的。

740
00:56:51,000 --> 00:56:56,000
现在，让我们注释掉其余的一切，

741
00:56:56,000 --> 00:57:00,000
保存这一点，我们现在可以做的是，我们可以打开一个文件

742
00:57:00,000 --> 00:57:06,000
我们可以称之为some_file.txt让我们创建一个新的文件

743
00:57:06,000 --> 00:57:15,000
我们可以把一堆废话的东西，在这里只是为了测试所有的东西，

744
00:57:15,000 --> 00:57:25,000
保存它，把它some_file.txt，我做在顶部，

745
00:57:25,000 --> 00:57:33,000
现在，如果我缩小只是为了确保一切都在同一个目录

746
00:57:33,000 --> 00:57:36,000
它看起来像我有unique.php some_file.txt在同一个目录。

747
00:57:36,000 --> 00:57:42,000
如果我运行PHP unique.php的

748
00:57:42,000 --> 00:57:51,000
如何打印我的文件中的每一行和该行是什么呢？

749
00:57:51,000 --> 00:57:56,000
>> 这是非常强大的，对不对？

750
00:57:56,000 --> 00:58:03,000
瞧，这花了3行代码就可以打开一个文件。

751
00:58:03,000 --> 00:58:08,000
好了，4行代码。我不能指望今天，清楚。

752
00:58:08,000 --> 00:58:13,000
但真的只有2有趣的代码行，因为其他的花括号，

753
00:58:13,000 --> 00:58:17,000
但在这么多的代码中，我们可以打开一个文件，遍历它，

754
00:58:17,000 --> 00:58:20,000
拉出来的行号和该行本身

755
00:58:20,000 --> 00:58:24,000
并打印出来。

756
00:58:24,000 --> 00:58:26,000
很酷的东西。夏洛特。

757
00:58:26,000 --> 00:58:28,000
[夏洛特]我有一个问题关于语法。

758
00:58:28,000 --> 00:58:33,000
所以你打开的文件的每一行的foreach处理，

759
00:58:33,000 --> 00:58:37,000
然后当你想要做的事情的每一行，你只是做它作为

760
00:58:37,000 --> 00:58:39,000
然后关联的值。

761
00:58:39,000 --> 00:58:41,000
[内特H.]你可以做什么在这里的问题是

762
00:58:41,000 --> 00:58:46,000
在fo​​reach做的阵列，所以foreach语法

763
00:58:46,000 --> 00:58:51,000
真的是foreach和通知，有没有空间

764
00:58:51,000 --> 00:58:53,000
之间的和每一个或任何东西。

765
00:58:53,000 --> 00:58:56,000
他们去旁边对方，

766
00:58:56,000 --> 00:59:00,000
然后它在一个数组中，

767
00:59:00,000 --> 00:59:05,000
然后你有这被称为是有其他的关键字，

768
00:59:05,000 --> 00:59:11,000
，然后后，作为你可以把一个变量名，

769
00:59:11,000 --> 00:59:14,000
在这种情况下，你会被拉出数组元素的值，

770
00:59:14,000 --> 00:59:20,000
不是索引，或者如果你这样做，因为我们已经写在下面

771
00:59:20,000 --> 00:59:24,000
你得到的键和值。

772
00:59:24,000 --> 00:59:33,000
您有forEach元素的数组或对数组的键价值

773
00:59:33,000 --> 00:59:38,000
或为正义价值。

774
00:59:38,000 --> 00:59:40,000
根据你所需要的，如果你不需要的钥匙，

775
00:59:40,000 --> 00:59:42,000
那么你可以去的值。

776
00:59:42,000 --> 00:59:45,000
如果你想要的键，你可以和他们一起去了。

777
00:59:45,000 --> 00:59:48,000
>> [夏洛特]我也意识到，我们从未宣布过我或线。

778
00:59:48,000 --> 00:59:51,000
它是如何知道它们是什么？

779
00:59:51,000 --> 00:59:53,000
内特H.]你是什么意思的声明？

780
00:59:53,000 --> 00:59:57,000
[夏洛特]我们从来没有告诉他们我还是行的手段。

781
00:59:57,000 --> 01:00:01,000
[内特H.]我们从来没有告诉计算机什么，我行表示在

782
01:00:01,000 --> 01:00:05,000
[夏洛特，他们是索引，当当

783
01:00:05,000 --> 01:00:09,000
[内特H.]我们从来没有告诉它，这是应该的索引或键和值，

784
01:00:09,000 --> 01:00:13,000
这是因为这是PHP解释器。

785
01:00:13,000 --> 01:00:17,000
作为声明说，没关系，关键是要

786
01:00:17,000 --> 01:00:20,000
一个变量叫我存储在一个名为i的变量。

787
01:00:20,000 --> 01:00:24,000
该值将被存储在一个变量称为线

788
01:00:24,000 --> 01:00:28,000
所以作为这些变量的声明

789
01:00:28,000 --> 01:00:35,000
说$我是一个关键，$线的值。

790
01:00:35,000 --> 01:00:37,000
是啊，艾拉。

791
01:00:37,000 --> 01:00:41,000
[云裳]如果没有这样做的关键数字

792
01:00:41,000 --> 01:00:44,000
它是如何决定什么样的顺序要打印的一切吗？

793
01:00:44,000 --> 01:00:47,000
这是不是就是它被输入的顺序吗？

794
01:00:47,000 --> 01:00:51,000
[内特H.]让我们给它一个尝试。

795
01:00:51,000 --> 01:00:57,000
让我们创建一个变量称为改编，

796
01:00:57,000 --> 01:01:06,000
我们可以做一个“7。

797
01:01:06,000 --> 01:01:19,000
比方说，0到另一个阵列，1，2，或苹果。

798
01:01:19,000 --> 01:01:30,000
比方说，7变为1，B 2，

799
01:01:30,000 --> 01:01:39,000
和3〜4。

800
01:01:39,000 --> 01:01:44,000
这是一个疯狂的寻找例子，因为我们是混合

801
01:01:44,000 --> 01:01:47,000
字符串和整数的地方。

802
01:01:47,000 --> 01:01:50,000
这个数组有没有真正的订单。

803
01:01:50,000 --> 01:01:55,000
我的意思是，我们可以责令一切都在按字母顺序排列的键。

804
01:01:55,000 --> 01:01:57,000
我们可以责令一切按字母顺序排列的值。

805
01:01:57,000 --> 01:02:00,000
>> 我们可以尝试，并考虑到有些字符串，有些是整数，

806
01:02:00,000 --> 01:02:03,000
，我们可以尝试将它们转换为相同的类型，看看会发生什么，

807
01:02:03,000 --> 01:02:09,000
或者我们可以认为他们的价值，我们已经进入他们

808
01:02:09,000 --> 01:02:14,000
我们把这个家伙在第一，第二，这家伙这家伙在第三，

809
01:02:14,000 --> 01:02:19,000
这家伙在第四位，等等。

810
01:02:19,000 --> 01:02:23,000
让我们来看看运行此代码时会发生什么。

811
01:02:23,000 --> 01:02:29,000
如果我们向下滚动，并做了同样的事情，

812
01:02:29,000 --> 01:02:31,000
这里没有打印出新的生产线。

813
01:02:31,000 --> 01:02:35,000
当它读出来的文件，它的价值观，包括新的生产线，

814
01:02:35,000 --> 01:02:38,000
这就是为什么它打印出来很好，而这里没有，

815
01:02:38,000 --> 01:02:40,000
所以这就是为什么的一切都smushed一起。

816
01:02:40,000 --> 01:02:44,000
让我们添加新的行只是为了让这件事情。

817
01:02:44,000 --> 01:02:51,000
让我们重新运行它，所以在这里

818
01:02:51,000 --> 01:02:54,000
看看发生了什么事。

819
01:02:54,000 --> 01:03:00,000
打印中，我们把它放入数组中的顺序。

820
01:03:00,000 --> 01:03:10,000
它保持秩序，在这个意义上。

821
01:03:10,000 --> 01:03:15,000
>> 让我们回到这个问题的唯一

822
01:03:15,000 --> 01:03:20,000
我们希望能够遍历一个文件，

823
01:03:20,000 --> 01:03:24,000
我们会给它some_file.txt，

824
01:03:24,000 --> 01:03:27,000
我们要遍历这样的。

825
01:03:27,000 --> 01:03:31,000
我们说，我们要使用一个数组，以确保我们得到了所有的

826
01:03:31,000 --> 01:03:36,000
独特的线，我们能做到这一点真的很容易

827
01:03:36,000 --> 01:03:49,000
仅通过存储在一个数组，我们当然声明一个循环的范围之外，

828
01:03:49,000 --> 01:03:55,000
和我们说，如果我们使用的是文件中的行的钥匙在我们的数组

829
01:03:55,000 --> 01:03:59,000
如果我们输入了重复的行，我们会覆盖掉原来的值。

830
01:03:59,000 --> 01:04:08,000
这是以往任何时候都可能有2个按键在同一阵列中是相同的。

831
01:04:08,000 --> 01:04:13,000
我们可以做到这一点。

832
01:04:13,000 --> 01:04:17,000
我们可以摆脱这个echo语句就在这里。

833
01:04:17,000 --> 01:04:24,000
在这里，我们文件中的行存储在数组中

834
01:04:24,000 --> 01:04:28,000
使用的关键。

835
01:04:28,000 --> 01:04:32,000
没有它，事实证明，我们并不需要这个关键。

836
01:04:32,000 --> 01:04:38,000
我们不需要变量i。

837
01:04:38,000 --> 01:04:43,000
在这一点上，如果我们做的另一个foreach循环

838
01:04:43,000 --> 01:04:48,000
我们循环在每个改编

839
01:04:48,000 --> 01:04:56,000
和线路，如果现在我们ECHO-哎呀，对不起。

840
01:04:56,000 --> 01:05:00,000
我们不能用逗号。我们必须使用此关键字。

841
01:05:00,000 --> 01:05:05,000
现在，如果我们回声线，我们应该得到所有在该文件中的唯一的话。

842
01:05:05,000 --> 01:05:10,000
如果我们去了到some_file.txt，

843
01:05:10,000 --> 01:05:19,000
让我们说，我们做的苹果，香蕉，苹果，苹果，香蕉，

844
01:05:19,000 --> 01:05:22,000
如果我们打印出所有的独特的话，在这个文件中，我们应该只得到

845
01:05:22,000 --> 01:05:30,000
苹果和香蕉打印出来。

846
01:05:30,000 --> 01:05:36,000
如果我们现在在这里，我们将放大，

847
01:05:36,000 --> 01:05:44,000
PHP unique.php，和ta-DA。

848
01:05:44,000 --> 01:05:51,000
我们已经成功地uniqued的文件。

849
01:05:51,000 --> 01:05:55,000
>> 这个问题的最后一部分是问你这个数组进行排序，然后再打印出来

850
01:05:55,000 --> 01:05:58,000
因为在这个简单的例子中，我们刚刚做

851
01:05:58,000 --> 01:06:04,000
在这个意义上，我们很幸运的文件

852
01:06:04,000 --> 01:06:06,000
我们这样做是人为的例子，苹果和香蕉。

853
01:06:06,000 --> 01:06:08,000
它已经排序。

854
01:06:08,000 --> 01:06:19,000
但是，使用简单的排序功能，您可以排序的数组，这是相当漂亮的。

855
01:06:19,000 --> 01:06:24,000
最后一点我想谈谈你们真的很快

856
01:06:24,000 --> 01:06:31,000
是这样的PHP是一切都很好，这是超级方便

857
01:06:31,000 --> 01:06:43,000
知道该怎么办，如果你需要编程做小，见效快的事情。

858
01:06:43,000 --> 01:06:48,000
例如，如果我需要写一个程序，说，

859
01:06:48,000 --> 01:06:53,000
使大家我不打算去，并把它写在C段

860
01:06:53,000 --> 01:06:55,000
这将是长期的。

861
01:06:55,000 --> 01:06:57,000
这将是一种痛苦，特别是如果有涉及的文件，

862
01:06:57,000 --> 01:07:00,000
正如你们所看到的。

863
01:07:00,000 --> 01:07:05,000
它是如此漂亮，只是这么多的代码，在这里

864
01:07:05,000 --> 01:07:08,000
我们能够通过的文件中抓取音轨，使出浑身的独特价值

865
01:07:08,000 --> 01:07:11,000
和打印他们退了出去。

866
01:07:11,000 --> 01:07:16,000
>> 然而，对于分配给你的，你的项目，

867
01:07:16,000 --> 01:07:20,000
如果你建立的网站，PHP的力量是

868
01:07:20,000 --> 01:07:25,000
我们正在运行的PHP文件，通过这个解释，

869
01:07:25,000 --> 01:07:29,000
解释器处理的PHP标签内的所有内容，

870
01:07:29,000 --> 01:07:34,000
一切原封未动，吐出的结果。

871
01:07:34,000 --> 01:07:40,000
建立HTML编程方式，我们可以做到这一点。

872
01:07:40,000 --> 01:07:46,000
现在，如果我们回去的规范，最后一个问题，在规范中

873
01:07:46,000 --> 01:07:56,000
谈到这个想法的浓度

874
01:07:56,000 --> 01:08:01,000
并创建一个下拉菜单，

875
01:08:01,000 --> 01:08:06,000
您可能会或可能不希望这样做，这取决于您的最终项目正在做什么，

876
01:08:06,000 --> 01:08:13,000
，它允许用户选择从一个列表中的所有可能的浓度

877
01:08:13,000 --> 01:08:15,000
他们的浓度。

878
01:08:15,000 --> 01:08:21,000
现在，这是一种痛苦的键入此

879
01:08:21,000 --> 01:08:25,000
做这一切手动，特别是当你以确保

880
01:08:25,000 --> 01:08:28,000
你有所有的尖括号在正确的地方，所有的报价在正确的地方，

881
01:08:28,000 --> 01:08:34,000
与PHP中，你可以做到这一点编程，你可以做到这一点真的很快。

882
01:08:34,000 --> 01:08:36,000
>> 让我们来看看如何做到这一点。

883
01:08:36,000 --> 01:08:42,000
我们要去打开一个新的文件。

884
01:08:42,000 --> 01:08:46,000
我们打​​算把我们的PHP标签。

885
01:08:46,000 --> 01:08:53,000
我们将把它称为concentrations.php，

886
01:08:53,000 --> 01:08:58,000
，现在当你这样做的一件好事种思考

887
01:08:58,000 --> 01:09:02,000
当你想你的PHP和HTML混合和匹配

888
01:09:02,000 --> 01:09:08,000
搞清楚，什么是好了，我想以编程方式生成的部分吗？

889
01:09:08,000 --> 01:09:11,000
的一部分，我可以通过编程生成是什么？

890
01:09:11,000 --> 01:09:17,000
这是真的，你可以做你的HTML

891
01:09:17,000 --> 01:09:19,000
里面的PHP块。

892
01:09:19,000 --> 01:09:24,000
您可以重复所有的HTML作为字符串。

893
01:09:24,000 --> 01:09:30,000
例如，如果我要开始做选择的PHP标签里面

894
01:09:30,000 --> 01:09:46,000
我能说的回声，说选择名字浓度，

895
01:09:46,000 --> 01:09:49,000
然后向下跌破，我可以有另一种回声标签

896
01:09:49,000 --> 01:09:57,000
或其他回声称为近的选择。

897
01:09:57,000 --> 01:10:00,000
这是一个办法做到这一点，因为这是真正的做

898
01:10:00,000 --> 01:10:09,000
打印出该字符串通过PHP解释器时，它的运行，

899
01:10:09,000 --> 01:10:12,000
这样的结果将是HTML。

900
01:10:12,000 --> 01:10:18,000
如果我保存这个文件，因为它是现在

901
01:10:18,000 --> 01:10:24,000
和运行PHP concentrations.php的

902
01:10:24,000 --> 01:10:26,000
看看我得到了什么。

903
01:10:26,000 --> 01:10:30,000
我得到这个开放的关闭选择标签。

904
01:10:30,000 --> 01:10:36,000
>> 如果我要做到这一点，我是这样的结果保存到一个文件中，

905
01:10:36,000 --> 01:10:45,000
说，等待concentrations.html，它看起来像已经到另一侧的L-

906
01:10:45,000 --> 01:11:02,000
现在，如果我在这里开了concentrations.html你看，我有一个有效的HTML文件。

907
01:11:02,000 --> 01:11:05,000
那是一种奇怪的呢？

908
01:11:05,000 --> 01:11:09,000
我们正在使用PHP创建HTML，创建有效的HTML。

909
01:11:09,000 --> 01:11:13,000
我们正在做的是，我们的PHP打印

910
01:11:13,000 --> 01:11:16,000
我们希望它打印的HTML。

911
01:11:16,000 --> 01:11:20,000
这简直是​​PHP网站如何工作的。

912
01:11:20,000 --> 01:11:24,000
当你访问一个网站，把你喜欢的东西

913
01:11:24,000 --> 01:11:30,000
什么，什么，什么点com斜线的index.php

914
01:11:30,000 --> 01:11:33,000
该计算机是真正的调用index.php文件，

915
01:11:33,000 --> 01:11:38,000
执行它通过PHP解释器，以及任何垃圾出来

916
01:11:38,000 --> 01:11:49,000
它发回给浏览器，说哎，浏览器，将此解释为HTML。

917
01:11:49,000 --> 01:11:54,000
这种做法的好处是，它可以是一个痛苦的不断谱写回声，回声，回声，回声

918
01:11:54,000 --> 01:11:59,000
在这样的引号括一切，所以如果你想要写

919
01:11:59,000 --> 01:12:04,000
HTML，将是静态的，你可以像这样做，

920
01:12:04,000 --> 01:12:16,000
把它放到外面，关闭它，

921
01:12:16,000 --> 01:12:21,000
然后在这里你只把里面的PHP标签，你知道

922
01:12:21,000 --> 01:12:26,000
你想以编程方式生成，在这种情况下，这些选项标签

923
01:12:26,000 --> 01:12:31,000
是一个痛苦的产生。

924
01:12:31,000 --> 01:12:37,000
>> 例如，我们可以产生一千个选项标签

925
01:12:37,000 --> 01:12:48,000
做这样的事情，我<1000，+ +

926
01:12:48,000 --> 01:13:00,000
说echo参数值= $哎呦，我不能这样做。

927
01:13:00,000 --> 01:13:03,000
好了，让我们给它一个尝试，看看会发生什么。

928
01:13:03,000 --> 01:13:22,000
$ i，然后说我</选项。

929
01:13:22,000 --> 01:13:27,000
而不是输入该选项标签，一千个不同的时代

930
01:13:27,000 --> 01:13:33,000
我使用的PHP代码，它会自动生成，通过编程。

931
01:13:33,000 --> 01:13:38,000
一种漂亮。是啊。

932
01:13:38,000 --> 01:13:41,000
我记得这个被提到的讲座或演练，

933
01:13:41,000 --> 01:13:43,000
但在双引号之间的区别是什么，

934
01:13:43,000 --> 01:13:45,000
正常的，这些单一的东西吗？

935
01:13:45,000 --> 01:13:49,000
这是实际的东西，我已经做了不正确的，在这里，我要告诉你。

936
01:13:49,000 --> 01:13:52,000
单引号不允许任何特殊字符，

937
01:13:52,000 --> 01:13:57,000
所以一切都在一个单引号的字符串是字面上的解释。

938
01:13:57,000 --> 01:14:02,000
如果我有一个\ n里面的单引号和保存，例如，

939
01:14:02,000 --> 01:14:07,000
现在我走在这里，运行

940
01:14:07,000 --> 01:14:12,000
哎呀，我要去哪里？

941
01:14:12,000 --> 01:14:19,000
哦，那是因为我忘了$。

942
01:14:19,000 --> 01:14:25,000
>> 现在，如果我打开了，其实，在这里，我们将摆脱的输入到一个文件中。

943
01:14:25,000 --> 01:14:27,000
我们只需要读它。

944
01:14:27,000 --> 01:14:34,000
在这里，你看，我有这个文字\ n字符串中的一样，而不是实际的新的生产线，

945
01:14:34,000 --> 01:14:38,000
同样地，而不是实际内插这个变量的值

946
01:14:38,000 --> 01:14:42,000
它给了我我本身，这是一种痛苦。

947
01:14:42,000 --> 01:14:46,000
解决这个问题的方法是使用双引号，

948
01:14:46,000 --> 01:14:52,000
然后当你使用双引号，它实际上会

949
01:14:52,000 --> 01:14:56,000
正确插值所有这些变量的值，在这里

950
01:14:56,000 --> 01:14:59,000
也认识到这一点的\ n是新的生产线，这是

951
01:14:59,000 --> 01:15:02,000
\ n。

952
01:15:02,000 --> 01:15:07,000
使用单一的很好，当你有

953
01:15:07,000 --> 01:15:10,000
因为可能被解释为特殊字符的字符，那么你不有

954
01:15:10,000 --> 01:15:15,000
他们不断地逃避。

955
01:15:15,000 --> 01:15:18,000
事情可以变得凌乱，通常我做的方式，

956
01:15:18,000 --> 01:15:24,000
只是为了让事情变得简单，就是如果我有什么

957
01:15:24,000 --> 01:15:31,000
HTML喜欢在我的代码，我会包括编辑单引号内

958
01:15:31,000 --> 01:15:36,000
然后使用这个连接操作符

959
01:15:36,000 --> 01:15:43,000
要连接的变量中。

960
01:15:43,000 --> 01:15:47,000
这是这样做的另一种方式

961
01:15:47,000 --> 01:15:52,000
我们已经有了要连接的点，这是一个字符串

962
01:15:52,000 --> 01:15:56,000
与此与此与此，

963
01:15:56,000 --> 01:15:59,000
现在我没有逃避这些双引号。

964
01:15:59,000 --> 01:16:02,000
我没有使用这个家伙逃脱。

965
01:16:02,000 --> 01:16:08,000
他们会从字面上可以打印出来作为双引号括起来，然后这家伙就在这里。

966
01:16:08,000 --> 01:16:11,000
这是另一种方式混合起来。

967
01:16:11,000 --> 01:16:14,000
>> [学生]：另外，当你呼应的getType有没有引号。

968
01:16:14,000 --> 01:16:22,000
对，所以回声是一种特殊的，在这个意义上，你不需要括号。

969
01:16:22,000 --> 01:16:29,000
您不需要有一定的引号周围的变量，

970
01:16:29,000 --> 01:16:37,000
说回声$我喜欢它的有效，它要解释这是一个字符串。

971
01:16:37,000 --> 01:16:44,000
做演员，这是怎么回事，所以我们可以这样做，而且是有效的，但我们并不需要它。

972
01:16:44,000 --> 01:16:48,000
它是可选的。

973
01:16:48,000 --> 01:16:53,000
在本周的问题集中寻找出了很多这样的东西

974
01:16:53,000 --> 01:16:58,000
你混合并匹配HTML与PHP

975
01:16:58,000 --> 01:17:08,000
就这样，现在如果我们向后滚动，我们运行这个

976
01:17:08,000 --> 01:17:13,000
我们可以看到，我们有一大堆的选项值

977
01:17:13,000 --> 01:17:15,000
刚打印出来。

978
01:17:15,000 --> 01:17:20,000
我们有这一切都得到了生成的HTML，我们真的很快。

979
01:17:20,000 --> 01:17:22,000
我会离开它作为一个练习。

980
01:17:22,000 --> 01:17:24,000
这是非常类似的文件阅读我们先前做的。

981
01:17:24,000 --> 01:17:31,000
>> 是一个concentrations.txt的文件，你可以拉下来的CDN，

982
01:17:31,000 --> 01:17:34,000
你可以打开它的foreach使用相同的伎俩，我们先前做的，

983
01:17:34,000 --> 01:17:39,000
和foreach，你只需要呼应的选项和插件

984
01:17:39,000 --> 01:17:44,000
适当的值，相应的键和索引，

985
01:17:44,000 --> 01:17:49,000
然后你就滴下来，从字面上创建

986
01:17:49,000 --> 01:17:54,000
编程的你在哈佛的不同浓度。

987
01:17:54,000 --> 01:17:57,000
有一个方便的事情。

988
01:17:57,000 --> 01:18:02,000
这个任务有很多配置的东西。

989
01:18:02,000 --> 01:18:07,000
如果你没有这样做，它已经采取接下来的半小时，一小时，

990
01:18:07,000 --> 01:18:10,000
一段时间今晚肯定是肯定的，

991
01:18:10,000 --> 01:18:14,000
穿行问题集规格，

992
01:18:14,000 --> 01:18:20,000
看看是怎么回事设立的虚拟主机，本地主机，所有的东西。

993
01:18:20,000 --> 01:18:24,000
有一点需要指出的是，

994
01:18:24,000 --> 01:18:30,000
在大多数问题集，我们已经进入你的Dropbox文件夹

995
01:18:30,000 --> 01:18:34,000
的问题设定的zip文件，然后下载并解压缩。

996
01:18:34,000 --> 01:18:36,000
对于这个问题集，你不想。

997
01:18:36,000 --> 01:18:40,000
你想进入这个虚拟主机目录。

998
01:18:40,000 --> 01:18:45,000
您将要进入的虚拟主机，并进入本地主机目录内，

999
01:18:45,000 --> 01:18:50,000
这是你要拉下来的zip文件，

1000
01:18:50,000 --> 01:18:55,000
解压缩，然后准备好去。

1001
01:18:55,000 --> 01:18:57,000
你必须遵循的步骤密切。

1002
01:18:57,000 --> 01:19:02,000
>> 如果您有任何疑问，请发送电子邮件，将它张贴在讨论，来办公时间。

1003
01:19:02,000 --> 01:19:08,000
谢谢你们。下周，我们将有一个审查会议测验。

1004
01:19:08,000 --> 01:19:12,000
享受你的最后一个问题集。我希望这一切都非常好。

1005
01:19:12,000 --> 01:19:14,000
[CS50.TV]