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

2
00:00:02,610 --> 00:00:04,910
[罗布·鲍登 - 哈佛大学]

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

4
00:00:11,520 --> 00:00:14,160
>> 这周部分票据将是很短的，

5
00:00:14,160 --> 00:00:19,070
所以我只是要保持对话，你们要不断地问问题，

6
00:00:19,070 --> 00:00:22,720
我们会尝试尽可能填补尽可能多的时间。

7
00:00:22,720 --> 00:00:31,950
很多人认为，这pset的不一定是困难的，但它是很长的。

8
00:00:31,950 --> 00:00:37,070
在pset规范本身需要一个小时来阅读。

9
00:00:40,530 --> 00:00:45,730
我们给你一个你可能需要使用大量的SQL。

10
00:00:45,730 --> 00:00:50,520
我们走你通过它的很多，所以它不应该是太糟糕了。

11
00:00:50,520 --> 00:00:54,560
有没有人开始或完成了吗？

12
00:00:55,380 --> 00:00:59,710
这是最后的pset。哦，我的上帝。

13
00:00:59,710 --> 00:01:05,400
通常有一个JavaScript在此之后，但日历改变的事情

14
00:01:05,400 --> 00:01:09,560
一切较短的1周，我们不再有一个JavaScript的pset。

15
00:01:09,560 --> 00:01:12,310
我不知道它们是如何影响的JavaScript是否会出现在考试中

16
00:01:12,310 --> 00:01:15,510
测验1。

17
00:01:15,510 --> 00:01:22,260
我想它会像你需要知道的关于JavaScript的高层次的东西，

18
00:01:22,260 --> 00:01:26,460
但我怀疑我们刚刚给你直接的JavaScript代码

19
00:01:26,460 --> 00:01:28,720
因为你还没有在它的pset。

20
00:01:28,720 --> 00:01:33,000
但是，这将是下周测验复习的东西。

21
00:01:33,000 --> 00:01:36,320
>> 节的问题。

22
00:01:36,320 --> 00:01:43,870
很多这个东西是有点差劣，但我们将讨论为什么。

23
00:01:43,870 --> 00:01:50,220
不像C，PHP是一个“动态类型”的语言。这是什么意思，你问？

24
00:01:50,220 --> 00:01:53,830
好了，说再见了所有这些字符，浮点数，整数，和其他的关键字，你需要使用

25
00:01:53,830 --> 00:01:56,190
声明变量和函数在C

26
00:01:56,190 --> 00:02:00,420
在PHP中，变量的类型决定，它目前持有的价值。

27
00:02:00,420 --> 00:02:04,990
所以，我们输入这个代码进入一个名为dynamic.php，

28
00:02:04,990 --> 00:02:12,670
PHP是动态类型。这是真的。

29
00:02:12,670 --> 00:02:17,590
我不同意的事实，这意味着我们说再见字符，浮点型，整型，

30
00:02:17,590 --> 00:02:20,620
等关键词。

31
00:02:20,620 --> 00:02:25,510
动态类型和替代的确切区别，

32
00:02:25,510 --> 00:02:32,010
这是静态类型的，是动态类型，所有的类型检查和东西

33
00:02:32,010 --> 00:02:37,350
发生在运行时，而静态类型，它发生在编译​​时。

34
00:02:37,350 --> 00:02:43,030
静态的，一般这个词的意思似乎是编译时的事情。

35
00:02:43,030 --> 00:02:48,170
我想有它的其他用途，但在C当你声明一个静态变量，

36
00:02:48,170 --> 00:02:52,650
它的存储分配在编译的时候。

37
00:02:52,650 --> 00:02:59,260
在这里，只是意味着动态类型的 - 

38
00:02:59,260 --> 00:03:04,350
在C语言中，如果你尝试添加一个字符串和一个整数，在编译时，

39
00:03:04,350 --> 00:03:11,000
它会抱怨，因为它会说，你可以不加一个int和指针。

40
00:03:11,000 --> 00:03:14,710
这是不是一个有效的操作。

41
00:03:14,710 --> 00:03:21,170
那是另一回事，我们将在第二。

42
00:03:21,170 --> 00:03:24,860
但是，这一类的检查，事实上，它会在编译时，

43
00:03:24,860 --> 00:03:29,220
是静态类型检查。

44
00:03:29,220 --> 00:03:35,220
有语言时，您并不需要说字符型，浮点型，整型，所有这些东西，

45
00:03:35,220 --> 00:03:40,940
但语言从上下文的东西可以告诉它应该是什么类型，

46
00:03:40,940 --> 00:03:43,980
但它仍然是静态类型的。

47
00:03:43,980 --> 00:03:49,000
所以，如果你把51，OCaml的，你永远不需要使用任何类型，

48
00:03:49,000 --> 00:03:58,700
但它仍然会在编译的时候说，你不能这样做，因为你将一个int和一个字符串。

49
00:03:58,700 --> 00:04:05,650
动态类型的，只是意味着在运行期间的某个时候，你会得到一个投诉。

50
00:04:05,650 --> 00:04:13,430
如果您还使用了Java之前，一般情况下，几乎所有的C-型语言

51
00:04:13,430 --> 00:04:20,070
将被静态类型，因此C，C + +，Java中，所有这些都是静态类型的。

52
00:04:20,070 --> 00:04:22,910
在Java中，当你编译的东西，你在说什么

53
00:04:22,910 --> 00:04:26,670
字符串s等于新的东西，是不是一个字符串，

54
00:04:26,670 --> 00:04:28,950
的抱怨，因为这些类型的不匹配。

55
00:04:28,950 --> 00:04:31,180
这是在编译的时候会抱怨。

56
00:04:31,180 --> 00:04:36,750
但它也有一定的动态之类的东西，如果你投的东西

57
00:04:36,750 --> 00:04:40,500
的类型，更重要的是其目前的具体类型，

58
00:04:40,500 --> 00:04:45,610
没有什么可以在编译时检查是否该投是会成功的。

59
00:04:45,610 --> 00:04:51,130
Java也有一些动态类型检查，尽快，因为它得到该行的代码

60
00:04:51,130 --> 00:04:54,130
它实际上执行时，它会做演员，

61
00:04:54,130 --> 00:04:56,260
检查是有效的，如果强制摆在首位，

62
00:04:56,260 --> 00:04:59,890
，如果不是，那么它会抱怨，你有一个无效的类型。

63
00:04:59,890 --> 00:05:03,200
动态类型检查。

64
00:05:03,200 --> 00:05:07,010
输入到一个称为dynamic.php的文件。

65
00:05:10,130 --> 00:05:12,380
Dynamic.php。

66
00:05:14,580 --> 00:05:17,190
我会解压缩的格式。

67
00:05:18,750 --> 00:05:21,880
我们有一个变量，我们将它设置为整数7，

68
00:05:21,880 --> 00:05:27,930
然后，我们将打印和％s  - 

69
00:05:27,930 --> 00:05:32,830
哦，我们要打印的类型，这样的getType返回类型的变量。

70
00:05:32,830 --> 00:05:35,720
我们只是印刷的类型，一遍又一遍。

71
00:05:35,720 --> 00:05:39,440
我们只是php.dynamic.php。

72
00:05:39,440 --> 00:05:45,920
我们将看到，它的变化从整数到字符串，布尔，我们去通过。

73
00:05:45,920 --> 00:05:54,590
在C语言中没有布尔数据类型，有没有字符串数据类型。

74
00:05:54,590 --> 00:06:00,500
char *和布尔往往​​是int或char或东西。

75
00:06:00,500 --> 00:06:05,690
在PHP中，这些类型的存在，这是一个大的优势，PHP比C  - 

76
00:06:05,690 --> 00:06:13,290
在PHP字符串操作是无限更容易比他们只是工作。

77
00:06:13,290 --> 00:06:18,290
>> 因此，我们回来这里。

78
00:06:18,290 --> 00:06:21,260
我们跑了dynamic.php。

79
00:06:21,260 --> 00:06:26,710
这告诉PHP解释器，名为php，在dynamic.php运行PHP代码。

80
00:06:26,710 --> 00:06:30,250
如果您有任何文件中的错误，解释器会告诉你的！

81
00:06:30,250 --> 00:06:39,110
解释器，这是一个很大的区别PHP和C

82
00:06:39,110 --> 00:06:48,200
在C语言中，你必须编译的东西，然后你运行编译后的文件。

83
00:06:48,200 --> 00:06:50,490
在PHP中，你永远不会编译任何东西。

84
00:06:50,490 --> 00:06:57,200
因此，PHP解释器基本上只是读这条线的线。

85
00:06:57,200 --> 00:07:02,900
它击中变种= 7，然后它击中printf的然后它击中变种然后它击中printf和等。

86
00:07:02,900 --> 00:07:10,910
有位编译它，和它缓存的结果

87
00:07:10,910 --> 00:07:15,510
所以，如果你运行该脚本后，你可以做一些，

88
00:07:15,510 --> 00:07:19,280
但基本上是一条线，线之类的事情。

89
00:07:19,280 --> 00:07:25,280
这意味着，大量的优化，我们在C，

90
00:07:25,280 --> 00:07:31,920
类似编译，它只是一般的编译器可以为你做了很多的技巧。

91
00:07:31,920 --> 00:07:36,110
它可以使用的变量，它可以做所有这些事情，

92
00:07:36,110 --> 00:07:38,660
它可以做尾递归。

93
00:07:38,660 --> 00:07:42,550
在PHP中，你是不会得到这种优势

94
00:07:42,550 --> 00:07:45,690
因为它只是要开始执行的一行行，

95
00:07:45,690 --> 00:07:49,950
，它并没有真正认识到这些东西一样容易

96
00:07:49,950 --> 00:07:54,440
因为它不是大编译通过的东西，然后执行;

97
00:07:54,440 --> 00:07:56,860
它只是一行行。

98
00:08:00,730 --> 00:08:02,750
这样的解释。

99
00:08:02,750 --> 00:08:06,840
>> 回到我们的动态类型：很酷，不是吗？

100
00:08:06,840 --> 00:08:08,640
你绝对不能做，在C！

101
00:08:08,640 --> 00:08:11,860
现在，看看你能不能找出下列值中的每一个类型的。

102
00:08:11,860 --> 00:08:14,760
见，以供参考。

103
00:08:14,760 --> 00:08:19,420
因此，3.50元。你认为将是什么类型？

104
00:08:24,480 --> 00:08:26,370
下面是我们的类型。

105
00:08:26,370 --> 00:08:30,430
我们有bool值，整数，浮点数，字符串，数组，对象，

106
00:08:30,430 --> 00:08:38,370
和资源，这是一种模糊的。

107
00:08:38,370 --> 00:08:41,010
我认为这实际上是一个例子。

108
00:08:41,010 --> 00:08:43,740
再有就是NULL。 NULL是一个特殊的类型。

109
00:08:43,740 --> 00:08:47,140
不像C，其中NULL只是一个指针的地址为0，

110
00:08:47,140 --> 00:08:54,930
在PHP中，NULL是它自己的类型，该类型的唯一有效的东西是NULL。

111
00:08:57,560 --> 00:09:00,670
这是更为有用的错误检查。

112
00:09:00,670 --> 00:09:04,310
在C语言中，我们有这个问题，如果你返回NULL，

113
00:09:04,310 --> 00:09:08,660
这是否意味着你返回一个NULL指针或NULL表示错误

114
00:09:08,660 --> 00:09:12,380
所有的混乱，我们在一个点上。

115
00:09:12,380 --> 00:09:18,440
这里，返回NULL意味着错误。

116
00:09:20,860 --> 00:09:27,300
很多事情的错误也返回false。

117
00:09:27,300 --> 00:09:33,140
但有一点是NULL类型，唯一的NULL类型是NULL。

118
00:09:33,140 --> 00:09:40,090
然后的回调是像你可以定义一些匿名函数。

119
00:09:40,090 --> 00:09:46,420
你没有给函数的名称，但你不会在这​​里处理。

120
00:09:46,420 --> 00:09:53,940
寻找的类型，他们希望我们知道，

121
00:09:53,940 --> 00:09:59,000
你认为3.50的类型是什么？ >> [学生]持股量。

122
00:09:59,000 --> 00:10:00,370
是啊。

123
00:10:00,370 --> 00:10:06,290
那么，在这里，有什么你认为的类型是什么？ >> [学生]数组。

124
00:10:06,290 --> 00:10:09,890
是啊。第一个是浮动的，第二个是一个数组。

125
00:10:09,890 --> 00:10:14,500
请注意，这个数组是不是像一个C数组

126
00:10:14,500 --> 00:10:19,610
你有索引0有一定的价值，指数有一定的价值。

127
00:10:19,610 --> 00:10:26,320
这里的指数分别为a，b，和c的值是1，2，和3。

128
00:10:26,320 --> 00:10:33,980
在PHP中是一个关联数组没有什么区别，只是一个普通的阵列

129
00:10:33,980 --> 00:10:36,740
，你会觉得它在C.

130
00:10:36,740 --> 00:10:43,040
仅仅是这一点，引擎盖下的一个普​​通的数组仅仅是一个关联数组

131
00:10:43,040 --> 00:10:50,000
0映射到一定的价值以同样的方式映射到一定的价值。

132
00:10:50,000 --> 00:11:00,410
出于这个原因，PHP是非常糟糕的代码/基准的东西真快

133
00:11:00,410 --> 00:11:07,930
因为在C：当你使用一个数组，你知道访问的成员是固定的时间。

134
00:11:07,930 --> 00:11:11,860
在PHP访问的成员是谁知道多少时间？

135
00:11:11,860 --> 00:11:18,970
这也可能是常量，如果它的哈希值正确。

136
00:11:18,970 --> 00:11:21,620
谁知道什么是真正做引擎盖下的吗？

137
00:11:21,620 --> 00:11:25,600
你真的需要看看执行，看看它是如何去处理。

138
00:11:25,600 --> 00:11:28,550
那么FOPEN。

139
00:11:28,550 --> 00:11:36,420
我想在这里让我们看的返回类型是PHP手册FOPEN。

140
00:11:36,420 --> 00:11:41,260
我们看到，在这里你可以看一下PHP手册中的几乎所有功能

141
00:11:41,260 --> 00:11:47,540
这是PHP的手册页。

142
00:11:47,540 --> 00:11:51,060
返回类型是资源。

143
00:11:51,060 --> 00:11:56,050
这就是为什么我看着它，因为我们还没有真正定义资源。

144
00:11:56,050 --> 00:12:04,110
资源的想法，在C你种了一个FILE *或什么的;

145
00:12:04,110 --> 00:12:07,200
在PHP的资源是你的文件*。

146
00:12:07,200 --> 00:12:10,360
这就是你要读，它就是你写。

147
00:12:10,360 --> 00:12:20,710
它通常是外部的，所以它是一个资源，你可以拉东西，扔东西。

148
00:12:20,710 --> 00:12:26,520
最后，是什么类型的NULL吗？ >> [学生] NULL。

149
00:12:26,520 --> 00:12:30,650
是啊。因此，唯一的一点是NULL NULL。

150
00:12:30,650 --> 00:12:33,480
NULL NULL。

151
00:12:35,490 --> 00:12:41,170
>> PHP的类型系统（或好或坏）的一个特点是它能够玩弄类型。

152
00:12:41,170 --> 00:12:44,390
当你写一行PHP代码，结合不同类型的值，

153
00:12:44,390 --> 00:12:46,670
PHP会尝试做明智的事情。

154
00:12:46,670 --> 00:12:48,920
尝试下面的几行PHP代码。什么是打印出来呢？

155
00:12:48,920 --> 00:12:51,000
它是你所期望的是什么？为什么或者为什么不呢？

156
00:12:51,000 --> 00:12:58,600
关于PHP的这个事实是什么使得它就是我们所说的弱类型。

157
00:12:58,600 --> 00:13:04,610
弱类型和强类型的，

158
00:13:04,610 --> 00:13:06,840
这些条款有不同的用途，

159
00:13:06,840 --> 00:13:12,020
但大多数人使用弱类型和强类型，意味着这样的事情

160
00:13:12,020 --> 00:13:15,920
（“1”+ 2），该工程。

161
00:13:15,920 --> 00:13:18,290
在C语言中是行不通的。

162
00:13:18,290 --> 00:13:22,490
你能想象这不是工作。

163
00:13:22,490 --> 00:13:29,200
很多人混淆了动态类型和弱类型和静态类型和强类型。

164
00:13:29,200 --> 00:13:34,050
Python是动态类型的语言的另一个例子。

165
00:13:34,050 --> 00:13:41,770
你可以扔周围类型的变量，它会在运行时确定

166
00:13:41,770 --> 00:13:44,680
任何错误的核对。

167
00:13:44,680 --> 00:13:50,740
在Python中，它会执行这一点，它会看到（“1”+ 2）;

168
00:13:50,740 --> 00:13:55,920
这将失败，因为它说，你不能添加一个字符串和一个整数。

169
00:13:55,920 --> 00:14:00,860
在PHP中，这仅仅是动态类型的，这会不会失败。

170
00:14:00,860 --> 00:14:04,220
弱类型的事实，它做的事情与类型

171
00:14:04,220 --> 00:14:07,800
没有真正意义必然。

172
00:14:07,800 --> 00:14:17,420
因此，（“1”+ 2）我可以想像，12的字符串，我可以想像它的字符串3，

173
00:14:17,420 --> 00:14:20,710
我可以想像它是整数3。

174
00:14:20,710 --> 00:14:24,530
它不一定是很好的定义，我们可能会看到这里

175
00:14:24,530 --> 00:14:29,140
当我们打印时（“1”+ 2）;它可能会最终被不同

176
00:14:29,140 --> 00:14:32,320
比印刷（1 +“2”）。

177
00:14:32,320 --> 00:14:39,700
这往往是，在我看来，变得更糟。

178
00:14:39,700 --> 00:14:44,240
在这里，我们可以尝试这些。

179
00:14:44,240 --> 00:14:48,740
关于PHP的另一个小窍门是，你并不需要实际写入文件。

180
00:14:48,740 --> 00:14:52,790
它运行此命令模式。

181
00:14:52,790 --> 00:14:57,710
所以php-R的，那么我们就可以扔在这里的命令：

182
00:14:57,710 --> 00:15:06,610
“打印（'1'+ 2）;”我会抛出一个新的生产线。

183
00:15:19,550 --> 00:15:23,970
该印刷3。

184
00:15:31,100 --> 00:15:35,330
它看起来就像是打印，它是整数3。

185
00:15:35,330 --> 00:15:38,420
所以，现在让我们尝试其他方式：

186
00:15:38,420 --> 00:15:42,970
“打印（1 + '2'）;

187
00:15:45,560 --> 00:15:50,490
我们得到了3个，并且它也将是整数3？老实说，我不知道。

188
00:15:50,490 --> 00:15:54,030
这看起来是一致的。

189
00:15:54,030 --> 00:15:59,550
从来就没有什么机会，它是字符串的12或类似的东西，

190
00:15:59,550 --> 00:16:08,080
因为PHP不同，JavaScript和Java太，

191
00:16:08,080 --> 00:16:11,670
有单独操作串联的。

192
00:16:11,670 --> 00:16:14,930
PHP级联点。

193
00:16:14,930 --> 00:16:22,950
所以，印刷业（1 '2'）;是要给我们12。

194
00:16:25,790 --> 00:16:32,420
这往往会导致混乱，人们尝试做这样的事情STR + =

195
00:16:32,420 --> 00:16:37,840
一些其他的事情，他们希望添加到它们的字符串的结束，而这要失败的。

196
00:16:37,840 --> 00:16:40,770
你需要做的STR。

197
00:16:42,000 --> 00:16:46,240
所以，不要忘了串联PHP点。

198
00:16:46,240 --> 00:16:52,100
尝试其他的事情：打印（“CS”+ 50）;

199
00:16:55,750 --> 00:17:03,610
我告诉你，是没有希望的，这导致CS50

200
00:17:03,610 --> 00:17:06,119
由于串联是不+。

201
00:17:06,119 --> 00:17:08,440
你怎么看这是怎么回事结束了吗？

202
00:17:10,359 --> 00:17:13,460
老实说，我完全不知道。

203
00:17:14,250 --> 00:17:16,460
它看起来就像是只有50。

204
00:17:16,460 --> 00:17:21,490
它把字符串，我敢打赌，如果我们把123CS  - 

205
00:17:21,490 --> 00:17:29,640
它看到的第一个字符串，它会尝试读取一个整数或一个号码。

206
00:17:29,640 --> 00:17:31,710
在这种情况下它看到123CS。

207
00:17:31,710 --> 00:17:35,190
“这并没有多大意义，一个整数，所以我只是要想到123。”

208
00:17:35,190 --> 00:17:38,580
因此123 + 50将是173。

209
00:17:38,580 --> 00:17:40,740
在这里，它开始读这是一个整数。

210
00:17:40,740 --> 00:17:45,690
它没有看到任何东西，所以它只是把它作为0。所以0 + 50将是50。

211
00:17:45,690 --> 00:17:51,600
我假设做同样的事情。

212
00:17:51,600 --> 00:17:54,310
我想99。

213
00:17:54,310 --> 00:17:57,580
是的，因为它要采取的第一个 - 

214
00:18:12,880 --> 00:18:15,730
所以99。

215
00:18:15,730 --> 00:18:21,970
（10/7），如果是C，这回来吗？

216
00:18:23,700 --> 00:18:29,630
[学生] 1。是的，它会是1，因为10/7除以2的整数。

217
00:18:29,630 --> 00:18:32,910
一个整数除以整数返回一个整数。

218
00:18:32,910 --> 00:18:37,750
它不能返回1点什么，所以它只是将返回1。

219
00:18:37,750 --> 00:18:46,120
开始打印（10/7）;它要真正解释说。

220
00:18:46,120 --> 00:18:53,760
这意味着，如果你真的想要做的整数四舍五入之类的东西，

221
00:18:53,760 --> 00:18:59,950
你需要做的打印楼（10/7）;

222
00:18:59,950 --> 00:19:08,460
在C语言中，它可能是奇怪的，你可以经常依靠整数截断，

223
00:19:08,460 --> 00:19:12,260
但是在PHP中，你不能因为它会自动把它转化成一个Float。

224
00:19:13,430 --> 00:19:17,610
（7 +真），你认为这将是吗？

225
00:19:18,550 --> 00:19:23,640
我猜，如果它要解释真正为1。

226
00:19:23,640 --> 00:19:25,740
它看起来像它的8。

227
00:19:25,740 --> 00:19:31,710
>> 因此，在过去的10分钟，你绝对不会做任何事情，我们已经做了。

228
00:19:31,710 --> 00:19:39,870
你会看到，这样做的代码。

229
00:19:39,870 --> 00:19:42,700
它不具有的那样简单，因为这。

230
00:19:42,700 --> 00:19:47,240
你可以有2个变量，1个变量恰好是一个字符串

231
00:19:47,240 --> 00:19:51,310
和其他变量发生是一个int，然后再添加这些变量。

232
00:19:51,310 --> 00:20:00,120
由于PHP是动态类型的，它不会做任何类型检查

233
00:20:00,120 --> 00:20:03,640
并且由于它是弱类型的，因为它会自动把这些东西一起

234
00:20:03,640 --> 00:20:11,490
一切都只是工作，这是困难的，甚至知道，此变量必须是一个字符串，

235
00:20:11,490 --> 00:20:14,930
所以我不应该将它添加到这个变量，它是一个整数。

236
00:20:18,780 --> 00:20:24,560
最好的做法是，如果一个变量是一个字符串，永远保持它作为一个字符串。

237
00:20:24,560 --> 00:20:26,980
如果一个变量是一个int，将它作为一个int，直到永远。

238
00:20:26,980 --> 00:20:30,770
如果你要处理整数和字符串，

239
00:20:30,770 --> 00:20:36,970
，您可以使用varsint的 - 这是JavaScript的。

240
00:20:36,970 --> 00:20:42,520
INTVAL。我做这一切的时候。 PHP和JavaScript，我混合了一切。

241
00:20:42,520 --> 00:20:47,600
因此，INTVAL是要返回的整数变量的值。

242
00:20:47,600 --> 00:20:56,550
如果我们通过在“打印（INTVAL（'123'））; 123。

243
00:21:06,820 --> 00:21:15,850
INTVAL本身不会对我们来说，它是专门为整数做检查。

244
00:21:15,850 --> 00:21:20,460
PHP手册，有这么多的功能，

245
00:21:20,460 --> 00:21:26,560
所以在这里，我想我会用is_numeric第一。

246
00:21:26,560 --> 00:21:32,590
我猜，返回false。

247
00:21:32,590 --> 00:21:35,780
这是另一回事，我们去了是===。

248
00:21:37,850 --> 00:21:44,020
is_numeric（'123df），你不会想到，作为is_numeric。

249
00:21:44,020 --> 00:21:46,720
在C中，你就必须遍历所有字符

250
00:21:46,720 --> 00:21:50,410
和检查，如果每一个字符是数字或什么的。

251
00:21:50,410 --> 00:21:53,850
这里is_numeric对我们来说要做到这一点，

252
00:21:53,850 --> 00:21:56,520
它的返回false。

253
00:21:56,520 --> 00:22:02,120
所以，当我打印的，打印什么都没有，所以我在这里比较看，

254
00:22:02,120 --> 00:22:05,490
你这样是假的吗？所以现在的印刷1。

255
00:22:05,490 --> 00:22:10,060
显然，它打印1为真，而不是打印真正为真。

256
00:22:10,060 --> 00:22:15,790
我不知道如果我这样做的print_r。不，它依然是1。

257
00:22:15,790 --> 00:22:26,760
>> 让我们回到=== ==仍然存在，

258
00:22:26,760 --> 00:22:32,260
如果你跟汤米，他会说==是完全没有问题的。

259
00:22:32,260 --> 00:22:37,700
我会说，==是可怕的，你不应该使用==。

260
00:22:37,700 --> 00:22:44,870
不同的是，==比较的东西

261
00:22:44,870 --> 00:22:48,450
它可以是真实的，即使他们是不一样的类型，

262
00:22:48,450 --> 00:22:53,810
而===比较的东西，首先检查它们是同一类型的吗？

263
00:22:53,810 --> 00:22:58,010
是。好了，现在我要看看他们实际的比较是相等的。

264
00:22:58,010 --> 00:23:08,890
你得到奇怪的事情，比如10等于 - 让我们来看看，说什么。

265
00:23:08,890 --> 00:23:15,570
因此，（'10'== '1 E1'）;

266
00:23:15,570 --> 00:23:17,980
这则返回true。

267
00:23:17,980 --> 00:23:21,420
没有任何人有任何猜测为什么返回true？

268
00:23:25,180 --> 00:23:27,120
它不仅仅是关于该。也许，这是一个提示。

269
00:23:27,120 --> 00:23:33,170
但如果我改变的f  - 实在可恨！我一直在使用双引号。

270
00:23:33,170 --> 00:23:38,780
双引号骂我的原因是因为我已经把这个双引号括起来。

271
00:23:38,780 --> 00:23:43,850
所以，我可以在这里逃脱的双引号，但单引号更容易。

272
00:23:43,850 --> 00:23:49,120
因此，（'10'== '1 F1'）;打印不正确的。 （'10'== '1 E1'）;打印出真实的。

273
00:23:49,120 --> 00:23:56,330
[学生]是十六进制？ >>这是不是十六进制，但它很接近，它就像 - 

274
00:23:56,330 --> 00:24:01,060
1E1，科学记数法。

275
00:24:01,060 --> 00:24:07,950
承认1E1为1 * 10 ^ 1或什么的。

276
00:24:07,950 --> 00:24:11,510
这些都是平等的整数。

277
00:24:11,510 --> 00:24:15,930
如果我们这样做===那么它会是假的。

278
00:24:15,930 --> 00:24:28,490
如果我们这样做，其实我不知道==什么（10和'10abc“）;好的。所以，这是事实。

279
00:24:28,490 --> 00:24:35,940
所以就像当你做（10 + '10abc），这将是20，

280
00:24:35,940 --> 00:24:38,800
在这里（10 == '10abc）的，是真实的。

281
00:24:38,800 --> 00:24:45,350
更糟糕的是类的东西（假== NULL）;是真实的

282
00:24:45,350 --> 00:24:52,210
或（假== 0）;是真实的，（假== []）;

283
00:24:52,210 --> 00:25:00,970
有奇怪的箱子 - 这些奇怪的情况下，这是一个。

284
00:25:00,970 --> 00:25:08,110
请注意，（假== []）;是真实的。

285
00:25:08,110 --> 00:25:11,950
（0 == FALSE）;是真实的。

286
00:25:11,950 --> 00:25:16,090
（0 == []）;是假的。

287
00:25:16,090 --> 00:25:19,090
所以==是没有办法传递的。

288
00:25:19,090 --> 00:25:26,830
一个可以是等于b，a可​​以是等于c，

289
00:25:26,830 --> 00:25:29,340
但B可能不等于c。

290
00:25:29,340 --> 00:25:35,580
这是我所憎恶的，你应该总是使用===。

291
00:25:35,580 --> 00:25:38,590
[学生]：我们可以做的！==呢？ >> [鲍登]是的。

292
00:25:38,590 --> 00:25:44,600
相当于将=和！==。

293
00:25:44,600 --> 00:25:48,230
这实际上是在pset规范

294
00:25:48,230 --> 00:25:52,000
那里有很多的函数的返回值 - 

295
00:25:52,000 --> 00:25:53,890
PHP手册是良好的。

296
00:25:53,890 --> 00:25:59,140
它把一个红色的大盒子，“这将返回false，如果有一个错误。”

297
00:25:59,140 --> 00:26:03,940
但返回，返回0是一个完全合理的事情。

298
00:26:03,940 --> 00:26:08,250
想想任何函数返回一个整数。

299
00:26:11,250 --> 00:26:17,880
比方说，此功能在一个文件或东西应该算的行数。

300
00:26:17,880 --> 00:26:23,490
在正常情况下，这个函数传递一个文件

301
00:26:23,490 --> 00:26:27,120
和它的要返回的整数表示的行数。

302
00:26:27,120 --> 00:26:30,820
所以0是一个非常合理的数字，如果该文件是空的。

303
00:26:30,820 --> 00:26:36,810
但是，如果你把它传递一个无效的文件和功能发生了返回false

304
00:26:36,810 --> 00:26:38,860
如果你传递一个无效的文件吗？

305
00:26:38,860 --> 00:26:46,500
如果你只是做==你不区分无效的文件和空文件的情况下。

306
00:26:48,870 --> 00:26:51,350
始终使用===。

307
00:26:55,690 --> 00:26:58,000
这是所有这一切。

308
00:26:58,000 --> 00:27:01,660
>> 在PHP中，你已经习惯了在C数组类型是不同的

309
00:27:01,660 --> 00:27:06,650
事实上，你可能已经注意到了这一点，当你看到这是数组类型。

310
00:27:06,650 --> 00:27:15,640
括号的语法是新的，这是最新版本的PHP PHP 5.4。

311
00:27:15,640 --> 00:27:36,960
在此之前，你总是写阵列（'A' - > 1，'B' - > 2。

312
00:27:36,960 --> 00:27:41,160
这是一个数组的构造函数。

313
00:27:41,160 --> 00:27:45,950
现在，PHP终于回过头漂亮的只有方括号的语法，

314
00:27:45,950 --> 00:27:50,900
这仅仅是如此明显优于阵列。

315
00:27:50,900 --> 00:27:54,480
但是，考虑到PHP 5.4是最新的版本，

316
00:27:54,480 --> 00:27:59,090
你可能会遇到的地方，甚至没有PHP 5.3。

317
00:27:59,090 --> 00:28:08,220
在这个夏天，我们遇到了这个问题，PHP 5.3是我们在设备上，

318
00:28:08,220 --> 00:28:14,480
但服务器，我们部署我们的成绩簿，并提交所有的东西

319
00:28:14,480 --> 00:28:16,750
PHP 5.4。

320
00:28:16,750 --> 00:28:23,060
不知道这一点，我们开发了5.3，推到5.4，

321
00:28:23,060 --> 00:28:25,660
现在所有的突然没有我们的代码工作

322
00:28:25,660 --> 00:28:28,680
因为有发生了变化，在5.3和5.4之间

323
00:28:28,680 --> 00:28:31,030
这是不向后兼容，

324
00:28:31,030 --> 00:28:35,770
我们必须去解决我们的东西，不工作的PHP 5.4。

325
00:28:39,210 --> 00:28:42,320
对于这个类，家电确实有PHP 5.4，

326
00:28:42,320 --> 00:28:45,490
这是完全正常的使用方括号。

327
00:28:47,240 --> 00:28:50,440
但是，如果你正在寻找的东西在互联网，

328
00:28:50,440 --> 00:28:54,880
如果你正在寻找的某种阵列东西，最有可能的是，你会看到

329
00:28:54,880 --> 00:29:02,020
拼出来的数组构造函数的语法以来，一直以来PHP诞生

330
00:29:02,020 --> 00:29:07,340
在过去的几个月一直围绕和方括号的语法

331
00:29:07,340 --> 00:29:10,020
或当5.4来了。

332
00:29:10,020 --> 00:29:12,710
这是你的索引。

333
00:29:12,710 --> 00:29:30,610
就像在C，你将如何达阵[0]，$数组[1]，[2]，阵列的方括号，如指数

334
00:29:30,610 --> 00:29:36,320
指数相同的方式，如果你碰巧有你的指数是字符串。

335
00:29:36,320 --> 00:29:40,440
所以数组['']，数组['B']。

336
00:29:40,440 --> 00:29:47,410
$阵列[B]。为什么这是错的？

337
00:29:52,490 --> 00:29:59,870
它可能会产生一个警告，但仍能正常工作。 PHP容易做到这一点。

338
00:29:59,870 --> 00:30:04,890
它往往只是，“我要警告你，但我只是要继续

339
00:30:04,890 --> 00:30:07,550
“，并尽我所能。”

340
00:30:07,550 --> 00:30:11,500
它可能会转化为一个字符串，

341
00:30:11,500 --> 00:30:15,000
但它是可能的，在一些点在过去有人所述

342
00:30:15,000 --> 00:30:20,180
定义b为'HELLO WORLD“。

343
00:30:20,180 --> 00:30:28,740
所以，现在b可以是一个常数，数组[B]其实做'HELLO WORLD“。

344
00:30:28,740 --> 00:30:32,380
我认为在这一点上，或者至少是我们的PHP设置，

345
00:30:32,380 --> 00:30:37,870
如果您尝试对数组的索引键不存在，它将会失败。

346
00:30:37,870 --> 00:30:40,150
我不认为它只是提醒你。

347
00:30:40,150 --> 00:30:44,560
或者至少你可以设置它，以便它不只是提醒你，它只是直失败。

348
00:30:44,560 --> 00:30:49,290
>> 你检查，看看如果确实是这样的索引方式是使用isset。

349
00:30:49,290 --> 00:30:54,690
因此，使用isset（$数组['HELLO WORLD']）将返回false。

350
00:30:54,690 --> 00:30:59,160
使用isset（$阵列['B']）将返回true。

351
00:31:06,830 --> 00:31:09,880
您可以将这些语法。

352
00:31:15,060 --> 00:31:22,440
我敢肯定，这个阵列会结束 - 我们可以对其进行测试。

353
00:31:43,290 --> 00:31:45,700
哦，我需要PHPWord的。

354
00:31:53,960 --> 00:32:00,260
这是混合您指定的语法，其中的关键是什么

355
00:32:00,260 --> 00:32:03,330
你不指定的关键是什么。

356
00:32:03,330 --> 00:32:05,520
因此，3这里是一个值。

357
00:32:05,520 --> 00:32:08,080
你还没有明确表示其关键是要的。

358
00:32:08,080 --> 00:32:11,670
你认为它的关键将是什么？

359
00:32:11,670 --> 00:32:21,410
[学生] 0。 >>我猜只是因为这是第一个我们还没有指定。

360
00:32:21,410 --> 00:32:23,500
事实上，我们可以做一对夫妇的这种情况下。

361
00:32:23,500 --> 00:32:28,030
因此，的print_r打印递归。这将打印整个数组。

362
00:32:28,030 --> 00:32:32,700
这将打印，如果有任何的子数组的数组。

363
00:32:32,700 --> 00:32:36,630
所以的print_r（阵列）; php.test.php：：

364
00:32:36,630 --> 00:32:38,810
它看起来像它给了它0。

365
00:32:38,810 --> 00:32:43,530
记住这里有实际的东西，但我们会在第二。

366
00:32:43,530 --> 00:32:45,850
但是，如果我发生，使该指数1，该怎么办呢？

367
00:32:45,850 --> 00:32:51,170
PHP不区分字符串的索引和整数索引，

368
00:32:51,170 --> 00:33:00,280
所以在这一点上，我只定义了一个索引1，我可以做都达阵[1]，数组['1']

369
00:33:00,280 --> 00:33:06,250
这将是相同的索引和相同的密钥。

370
00:33:06,250 --> 00:33:13,000
所以，现在你有什么感想3将是吗？ >> [学生] 2。 >> [鲍登我猜2。

371
00:33:16,000 --> 00:33:18,690
是啊。这是2。

372
00:33:18,690 --> 00:33:24,790
如果我们这样做是10，这是4？你认为该指数的3个将是什么？

373
00:33:27,360 --> 00:33:29,110
我想11。

374
00:33:29,110 --> 00:33:33,060
我的猜测，什么PHP  - 我想我已经看到了这个 - 

375
00:33:33,060 --> 00:33:39,760
它只是跟踪最高的数字指标，用它至今是。

376
00:33:39,760 --> 00:33:44,230
这是从来没有要为其分配一个字符串索引3。这将永远是一个数字索引。

377
00:33:44,230 --> 00:33:47,690
因此，它可以跟踪最高的国家之一，它的分配，到目前为止，这正好是10，

378
00:33:47,690 --> 00:33:52,540
这将给予11日至3。

379
00:33:52,540 --> 00:34:02,110
我之前说的，注意的方式是打印这个数组。

380
00:34:02,110 --> 00:34:06,850
它打印键10键，11键，4键d。

381
00:34:06,850 --> 00:34:09,790
甚至让我们做 - 

382
00:34:15,760 --> 00:34:22,489
我想我没有把一个0，但它的打印1，2，3，4。

383
00:34:22,489 --> 00:34:29,330
如果我转吗？还是让我们切换这2个。

384
00:34:29,330 --> 00:34:31,940
现在它打印2，1，3，4。

385
00:34:31,940 --> 00:34:41,270
PHP的数组是不是就像你经常哈希表。

386
00:34:41,270 --> 00:34:45,570
这是完全合理的，认为他们是哈希表99％的时间。

387
00:34:45,570 --> 00:34:53,790
但在哈希表是没有意义的事情的顺序插入。

388
00:34:53,790 --> 00:34:56,639
因此，只要将它插入你的哈希表，

389
00:34:56,639 --> 00:35:00,590
假设有没有链表，你可以判断一个链表内

390
00:35:00,590 --> 00:35:03,980
这是第一次插入。

391
00:35:03,980 --> 00:35:10,060
但在这里我们插入2第一，它知道什么时候它打印出该数组是第一位的。

392
00:35:10,060 --> 00:35:13,090
它不把它打印出来，在短短任何顺序。

393
00:35:13,090 --> 00:35:17,550
技术数据结构，它的使用是一个有序的地图，

394
00:35:17,550 --> 00:35:24,690
所以键映射到相应的值，它会记住这些键的顺序插入。

395
00:35:24,690 --> 00:35:31,600
基本上，它的一些并发症，它是讨厌的实际 - 

396
00:35:31,600 --> 00:35:34,510
比方说，你有一个阵列0，1，2，3，4，5

397
00:35:34,510 --> 00:35:37,700
你要拿出指数2。

398
00:35:37,700 --> 00:35:47,750
这样做的一个方式，让我们来看看是什么样子。

399
00:35:47,750 --> 00:35:50,410
0，2，1，3，4。

400
00:35:50,410 --> 00:35:54,880
未设置发生未设置变量和数组的索引。

401
00:35:54,880 --> 00:35:58,630
所以，用unset（$阵列[2]）;

402
00:35:58,630 --> 00:36:03,430
现在这是什么的样子？二是刚刚过去，所以这是完全正常的。

403
00:36:03,430 --> 00:36:11,670
更可气的是，如果你想要的东西，其实是像一个数组。

404
00:36:11,670 --> 00:36:14,910
我会把随机数。

405
00:36:14,910 --> 00:36:20,400
现在发现我的指标。

406
00:36:20,400 --> 00:36:26,860
我希望它只是像一个C数组是从0到length  -  1

407
00:36:26,860 --> 00:36:30,810
我可以遍历它是这样的。

408
00:36:30,810 --> 00:36:38,520
但取消设置的第二个索引，什么是指数3，只要我现在不成为指数2。

409
00:36:38,520 --> 00:36:44,790
相反，它只是删除该索引，而现在你去0，1，3，4。

410
00:36:44,790 --> 00:36:48,740
这是完全合理的。

411
00:36:48,740 --> 00:36:53,950
这只是恼人的，你所要做的事情，比如阵列拼接。是啊。

412
00:36:53,950 --> 00:36:57,200
>> [学生]会发生什么，如果你有一个for循环

413
00:36:57,200 --> 00:36:59,630
你想要去的所有元素？

414
00:36:59,630 --> 00:37:02,290
2，当它击中了它会产生永远不会消失？

415
00:37:02,290 --> 00:37:10,150
遍历数组。有2种方式，你可以做到这一点。

416
00:37:10,150 --> 00:37:12,770
您可以使用常规的for循环。

417
00:37:12,770 --> 00:37:22,000
这又是一个复杂的PHP。

418
00:37:22,000 --> 00:37:27,420
大多数语言中，我会说，有某种长度，len或东西

419
00:37:27,420 --> 00:37:30,470
指示的长度的一个数组。

420
00:37:30,470 --> 00:37:32,820
在PHP中，它的计数。

421
00:37:32,820 --> 00:37:36,160
所以count（$），$ i + +）

422
00:37:36,160 --> 00:37:42,950
让我们只需打印（$ [$一]）;

423
00:37:45,920 --> 00:37:48,820
注意：未定义抵消：2。

424
00:37:48,820 --> 00:37:51,610
这只是要失败的。

425
00:37:51,610 --> 00:38:03,020
这是原因是，在大多数情况下，你永远需要遍历一个这样的数组。

426
00:38:03,020 --> 00:38:07,110
这可能是一个有点夸张，但你永远需要遍历一个这样的数组

427
00:38:07,110 --> 00:38:19,410
因为PHP提供的foreach语法中的foreach（$美元的项目）。

428
00:38:19,410 --> 00:38:31,830
现在，如果我们打印（项目） - 将就此进行讨论它在一秒钟 - 工作完全正常。

429
00:38:31,830 --> 00:38:38,960
foreach是工作的方式，是第一个参数是你遍历数组。

430
00:38:38,960 --> 00:38:44,060
第二个参数，项目，通过for循环的每个通

431
00:38:44,060 --> 00:38:52,690
它要采取的下一个数组中的事情。所以请记住阵列有一个订单。

432
00:38:52,690 --> 00:38:55,690
第一次通过for循环中，项目将是123

433
00:38:55,690 --> 00:38:59,540
那么这将是12，那么这将是13，那么这将是23，那么这将是213。

434
00:38:59,540 --> 00:39:04,670
事情变得很奇怪，当你做类似的foreach。

435
00:39:04,670 --> 00:39:07,480
让我们看看会发生什么，因为你永远不应该这样做。

436
00:39:07,480 --> 00:39:13,320
如果我们用unset（$数组[1]）;

437
00:39:20,410 --> 00:39:26,030
这是可能的预期。

438
00:39:26,030 --> 00:39:30,950
你遍历这个数组，每一次你注销的第一个索引。

439
00:39:30,950 --> 00:39:39,720
因此，索引0，第一件事情，项目需要的价值为0，所以这将是123。

440
00:39:39,720 --> 00:39:44,630
但里面的循环中，我们未设置索引为1，这样就意味着12已经一去不复返了。

441
00:39:44,630 --> 00:39:57,480
因此，打印。 PHP_EOL。

442
00:39:57,480 --> 00:40:03,580
PHP_EOL是刚换行的，但它在技术上更便携

443
00:40:03,580 --> 00:40:08,890
因为换行符在Windows在Mac和UNIX的换行符是不同的。

444
00:40:08,890 --> 00:40:18,040
在Windows换行符\ r \ n，而在其他地方往往只是\ n。

445
00:40:18,040 --> 00:40:25,150
PHP_EOL配置，使其使用任何你的系统是换行。

446
00:40:25,150 --> 00:40:29,310
打印。让我们在最后的print_r（$阵列）。

447
00:40:32,830 --> 00:40:37,390
我不知道，这将是的行为。

448
00:40:41,740 --> 00:40:48,960
物品仍然需要，即使我们取消设置之前，我们得从数组中的值12。

449
00:40:52,770 --> 00:40:58,840
不要把我的话，但它看起来像的foreach的数组创建一个副本

450
00:40:58,840 --> 00:41:02,160
然后项后，该副本的所有值。

451
00:41:02,160 --> 00:41:07,760
所以，即使你修改数组内的循环，

452
00:41:07,760 --> 00:41:17,240
它不会在意的。项目将采取的原始值。

453
00:41:17,240 --> 00:41:19,240
让我们尝试注销。

454
00:41:19,240 --> 00:41:24,460
如果这是数组[1] =“你好”;

455
00:41:24,460 --> 00:41:31,770
尽管我们将“Hello”到数组里，项目从来没有考虑该值。

456
00:41:31,770 --> 00:41:37,430
还有另一种语法foreach循环

457
00:41:37,430 --> 00:41:45,900
你把箭头分离的2个变量。

458
00:41:45,900 --> 00:41:49,680
该第一变量将是该值的键，

459
00:41:49,680 --> 00:41:53,050
和这个第二可变将是相同的确切资料。

460
00:41:53,050 --> 00:42:01,610
这是无趣的，但如果我们回到我们原来的情况下，'A' - > 1，

461
00:42:01,610 --> 00:42:06,090
'b'的 - > 1，

462
00:42:06,090 --> 00:42:14,470
在这里，如果我们只是遍历为每个数组作为项目，项目将是每一次。

463
00:42:14,470 --> 00:42:18,170
但是，如果我们也想知道与该项目相关的关键

464
00:42:18,170 --> 00:42:25,230
然后，我们做美元的关键 - >项目。

465
00:42:25,230 --> 00:42:31,980
所以，现在我们可以做打印（$关键。“：”。

466
00:42:31,980 --> 00:42:39,380
现在，它的遍历和打印每个键及其关联的值。

467
00:42:39,380 --> 00:42:47,030
>> 我们可以在foreach循环是一个额外的东西，你可能会看到这个语法。

468
00:42:47,030 --> 00:42:54,770
＆符号变量名前往往是PHP如何做参考。

469
00:42:54,770 --> 00:43:00,460
如果引用是非常类似的指针，

470
00:43:00,460 --> 00:43:04,820
你没有指针，所以你永远不会直接处理内存。

471
00:43:04,820 --> 00:43:12,620
但是，你有1变量指的是同样的事情，另一个变量的引用。

472
00:43:12,620 --> 00:43:21,450
内部，在这里，让我们做$项目。让我们回到1，10。

473
00:43:21,450 --> 00:43:28,800
让我们做项目+ +中仍存在PHP。你仍然可以做+ +。

474
00:43:28,800 --> 00:43:38,260
php.test.php。我要打印出来。的print_r（$阵列）;

475
00:43:38,260 --> 00:43:42,730
我们打​​印2，11。

476
00:43:42,730 --> 00:43:49,560
如果我刚刚做的foreach（$ $项目）项目将值1

477
00:43:49,560 --> 00:43:54,190
第一次通过循环。这将增加1到2，然后我们就大功告成了。

478
00:43:54,190 --> 00:43:57,260
那么它会通过第二次的循环，该项目是10个。

479
00:43:57,260 --> 00:44:01,570
它增加项目至11日，然后这只是扔掉。

480
00:44:01,570 --> 00:44:06,670
然后，我们的print_r（$阵列），让我们看看，这仅仅是1，10。

481
00:44:06,670 --> 00:44:09,070
所以，我们所做的就是失去的增量。

482
00:44:09,070 --> 00:44:13,410
但foreach（$美元阵列为＆$项）

483
00:44:13,410 --> 00:44:21,910
现在，这个项目是相同的项目在这里。这是同样的事情。

484
00:44:21,910 --> 00:44:26,820
所以项目+ +修改阵列0。

485
00:44:29,330 --> 00:44:41,850
基本上，你也可以做$ K  - > $项目，你可以做$阵列[K] + +;

486
00:44:41,850 --> 00:44:48,650
>> 因此，另一种方式这样做，我们可以自由修改项目，

487
00:44:48,650 --> 00:44:54,070
但不会修改我们的原始数组。

488
00:44:54,070 --> 00:44:59,720
但是，如果我们使用k，这是我们的关键，那么我们就可以到我们的数组索引使用该密钥

489
00:44:59,720 --> 00:45:01,530
和增量。

490
00:45:01,530 --> 00:45:05,410
这更直接地改变我们原来的数组。

491
00:45:05,410 --> 00:45:10,690
你甚至可以这样做，如果由于某种原因，你想要修改的能力 - 

492
00:45:10,690 --> 00:45:13,510
其实，这是完全合理的。

493
00:45:13,510 --> 00:45:16,020
你不想写阵列[$ K] + +，

494
00:45:16,020 --> 00:45:27,890
你只是想写美元项目+ +，但是你仍然想要说的话（$ K ==='A'）

495
00:45:27,890 --> 00:45:30,620
然后增加项目，然后打印我们的数组。

496
00:45:30,620 --> 00:45:36,290
所以，我们现在该怎么办的print_r做？应印有什么样的价值观？

497
00:45:36,290 --> 00:45:43,770
[学生] 2和10。 >> [鲍登]如果其中的关键是一个'我们实际打印。

498
00:45:51,940 --> 00:45:55,670
>> 你可能很少，如果有的话，将需要定义函数在PHP中，

499
00:45:55,670 --> 00:46:03,370
但你可能会看到类似的东西，你定义了一个类似的功能任何功能。

500
00:46:03,370 --> 00:46:09,900
通常，你会说（$ foo的吧），然后确定它是什么。

501
00:46:09,900 --> 00:46:17,580
但如果我这样做，那么这意味着，无论要求什么，

502
00:46:17,580 --> 00:46:25,110
任何调用baz，将第一个参数传递给巴兹是可以改变的。

503
00:46:25,110 --> 00:46:38,100
让我们做$ foo的+ +;

504
00:46:38,100 --> 00:46:48,020
内，在这里让我们做巴兹（项目）;

505
00:46:48,020 --> 00:46:52,250
现在，我们调用一个函数。

506
00:46:52,250 --> 00:46:56,780
参考的参数，这意味着如果我们修改

507
00:46:56,780 --> 00:47:00,390
我们要修改的东西传入

508
00:47:00,390 --> 00:47:04,420
打印此我们所期望的 - 除非我搞砸了语法 - 我们得到了2，11，

509
00:47:04,420 --> 00:47:06,300
所以，它实际上是递增的。

510
00:47:06,300 --> 00:47:08,790
请注意，我们需要在两个地方引用。

511
00:47:08,790 --> 00:47:13,050
如果我这样做呢？这是什么意思呢？

512
00:47:13,050 --> 00:47:15,810
[学生]：这将改变。 >>呀。

513
00:47:15,810 --> 00:47:18,290
项目仅仅是一个数组中的值的副本。

514
00:47:18,290 --> 00:47:26,670
因此，项目将改变为2，但数组['A'将仍然是1。

515
00:47:26,670 --> 00:47:32,560
或者，如果我这样做，该怎么办呢？

516
00:47:32,560 --> 00:47:39,260
现在项目被发送作为复制到巴兹。

517
00:47:39,260 --> 00:47:46,330
因此，复制的说法将增加为2，

518
00:47:46,330 --> 00:47:49,240
但项目本身从未增加了2。

519
00:47:49,240 --> 00:47:52,880
产品阵列支架任何同样的事情，

520
00:47:52,880 --> 00:47:55,380
因此，阵列没有增加。

521
00:47:55,380 --> 00:47:57,960
因此，这两个地方都需要它。

522
00:47:57,960 --> 00:48:03,830
>> PHP通常是非常聪明的。

523
00:48:03,830 --> 00:48:06,570
你可能会认为我想通过引用传递 - 

524
00:48:06,570 --> 00:48:09,560
这实际上是一个pset时的问题。

525
00:48:09,560 --> 00:48:14,480
这是一个questions.txt的事情，它说，

526
00:48:14,480 --> 00:48:19,280
你为什么想通过这个结构的参考？

527
00:48:19,280 --> 00:48:21,250
这个问题的答案是什么呢？

528
00:48:21,250 --> 00:48:25,100
[学生]所以你不必复制的东西大。 >>呀。

529
00:48:25,100 --> 00:48:32,920
一个结构可以任意大，而当你作为一个参数传递结构

530
00:48:32,920 --> 00:48:36,800
它需要复制整个结构，把它传递给功能，

531
00:48:36,800 --> 00:48:40,410
而如果你只是传递结构参考

532
00:48:40,410 --> 00:48:46,530
那么它只是需要复制一个4字节的地址作为参数传递给函数。

533
00:48:48,520 --> 00:48:52,320
PHP是一个有点聪明得多。

534
00:48:52,320 --> 00:49:00,650
如果我有一些功能，我传递给它的数组1,000件事情，

535
00:49:00,650 --> 00:49:03,990
这是否意味着它要复制的那些事1000

536
00:49:03,990 --> 00:49:10,450
把它传递到函数吗？它没有马上做到这一点。

537
00:49:10,450 --> 00:49:15,940
如果里面的这个功能，它从来没有真正修改foo的，

538
00:49:15,940 --> 00:49:22,660
因此，如果（$ foo的==='你好'）返回true。

539
00:49:22,660 --> 00:49:26,460
请注意，我们从来没有真正被修改了这个函数的参数内的，

540
00:49:26,460 --> 00:49:30,010
这意味着，无论是通过为foo从来没有需要复制

541
00:49:30,010 --> 00:49:32,100
是因为它没有修改它。

542
00:49:32,100 --> 00:49:39,240
因此，PHP的工作原理是参数总是通过引用传递

543
00:49:39,240 --> 00:49:42,170
直到你真正尝试对其进行修改。

544
00:49:42,170 --> 00:49:51,160
现在，如果我说的$ foo的+ +;现在，原来的foo的一个副本，修改副本。

545
00:49:51,160 --> 00:49:53,090
这可以节省一些时间。

546
00:49:53,090 --> 00:49:58,210
如果你从来没有接触这个庞大的阵列，你从来没有真正进行修改，

547
00:49:58,210 --> 00:50:02,360
它并不需要，使复印件，

548
00:50:02,360 --> 00:50:06,640
而如果我们只是把这个符号，这意味着它甚至不把它复制

549
00:50:06,640 --> 00:50:08,640
即使你修改它。

550
00:50:08,640 --> 00:50:10,680
这种行为被称为写时拷贝。

551
00:50:10,680 --> 00:50:17,380
你会看到它在其他地方，特别是如果你需要一个操作系统课程。

552
00:50:17,380 --> 00:50:23,880
写时复制是一个非常平常的模式，你并不需要的东西进行复制

553
00:50:23,880 --> 00:50:26,650
除非它实际上是不断变化的。是啊。

554
00:50:26,650 --> 00:50:29,520
[学生]如果你有增量内部测试，

555
00:50:29,520 --> 00:50:33,700
所以只出了1000元将需要改变？

556
00:50:33,700 --> 00:50:38,770
我不太肯定。

557
00:50:38,770 --> 00:50:51,250
我认为这将复制整个事情，但它可能是足够聪明， - 

558
00:50:51,250 --> 00:51:00,020
其实，我的想法是想象，我们有一个看起来像这样的数组：数组= [

559
00:51:00,020 --> 00:51:11,000
然后索引'a'是一个数组中的[1 2 3 4]，和索引'b'的，无论是一个数组。

560
00:51:11,000 --> 00:51:15,380
我需要所有这些逗号之间。试想一下，有逗号。

561
00:51:15,380 --> 00:51:21,210
然后'C'的值是3。

562
00:51:24,210 --> 00:51:26,290
好吧。

563
00:51:26,290 --> 00:51:33,440
现在，让我们说，我们做巴兹（数组）;

564
00:51:33,440 --> 00:51:36,540
巴兹不以供参考。

565
00:51:43,510 --> 00:51:47,370
所以，$ foo的['C'] + +;

566
00:51:47,370 --> 00:51:52,340
这是一个例子，我们通过数组作为​​参数

567
00:51:52,340 --> 00:51:57,010
然后它被修改特定的数组索引通过递增。

568
00:51:57,010 --> 00:52:01,090
老实说，我不知道PHP是要干什么。

569
00:52:01,090 --> 00:52:07,200
它可以很容易地使整个事情的副本，但如果它的智能，

570
00:52:07,200 --> 00:52:15,030
这将有其独特的价值，它会复制这些键

571
00:52:15,030 --> 00:52:20,620
但仍然可以指向同一个数组1,2,3,4

572
00:52:20,620 --> 00:52:22,320
这仍然可以指向同一个数组。

573
00:52:22,320 --> 00:52:24,170
我的iPad。

574
00:52:28,900 --> 00:52:45,950
我们通过这个数组中，这家伙点，这家伙点[1,2,3,4]，

575
00:52:45,950 --> 00:52:51,350
这家伙[34]

576
00:52:51,350 --> 00:52:58,590
现在我们已经将它传递到巴兹，我们正在修改。

577
00:52:58,590 --> 00:53:03,550
如果PHP是智能的，它可以这样做 - 

578
00:53:11,850 --> 00:53:18,230
我们仍然有一些内存复制，但如果有这些巨大的嵌套子阵

579
00:53:18,230 --> 00:53:21,560
我们并不需要复制这些。

580
00:53:21,560 --> 00:53:27,530
我不知道这是什么，但我可以想像它这样做。

581
00:53:29,050 --> 00:53:36,690
这也是一个相当大的优势的C PHP。

582
00:53:36,690 --> 00:53:40,320
>> PHP使生活变得更轻松了很多东西，

583
00:53:40,320 --> 00:53:45,060
，但你绝对不知道它会执行

584
00:53:45,060 --> 00:53:52,530
因为我不知道这些副本的东西时，它的引擎盖下的，

585
00:53:52,530 --> 00:53:55,170
哦，那将会是一个固定的时间复制，

586
00:53:55,170 --> 00:54:01,140
它只是要改变1个指针，它会是一个可笑的困难线性副本吗？

587
00:54:01,140 --> 00:54:03,000
什么，如果它不能找到空间？

588
00:54:03,000 --> 00:54:06,760
是否需要执行垃圾收集得到一些更多的空间？

589
00:54:06,760 --> 00:54:11,210
垃圾收集可以任意长。

590
00:54:11,210 --> 00:54:13,600
在C语言中，你不必担心这些事情。

591
00:54:13,600 --> 00:54:19,780
你给你写的每一行相当多的原因，它是如何去执行。

592
00:54:26,800 --> 00:54:29,150
>> 让我们回头看看这些。

593
00:54:35,400 --> 00:54:37,520
有意思的是，你不必处理散列函数，

594
00:54:37,520 --> 00:54:39,010
链接列表，或类似的东西吗？

595
00:54:39,010 --> 00:54:41,980
由于工作与哈希表是很容易的，现在，这里是一个有趣的益智工作。

596
00:54:41,980 --> 00:54:45,920
打开一个文件名为unique.php，在写一个PHP程序

597
00:54:45,920 --> 00:54:48,330
（也被称为“脚本”）。

598
00:54:48,330 --> 00:54:55,700
我们往往称他们为脚本，如果他们短的东西，你在命令行中运行。

599
00:54:55,700 --> 00:55:02,950
基本上，你没有任何语言，编译，但你要运行的可执行文件

600
00:55:02,950 --> 00:55:05,920
在命令行中，你可以调用可执行脚本。

601
00:55:05,920 --> 00:55:08,510
我也完全可以写一个C程序，这样做，

602
00:55:08,510 --> 00:55:12,300
但我不把它的脚本，因为我第一次编译，然后运行二进制文件。

603
00:55:12,300 --> 00:55:15,480
但这个PHP程序中，我们要调用脚本。

604
00:55:15,480 --> 00:55:23,830
或者，如果我们写的Python或Perl或Node.js的任何事情，

605
00:55:23,830 --> 00:55:26,500
我们会打电话给他们，因为你所有的脚本运行在命令行

606
00:55:26,500 --> 00:55:30,040
但我们不编译它们。

607
00:55:30,860 --> 00:55:33,400
我们能做到这一点很快得到解决。

608
00:55:36,960 --> 00:55:41,480
我们不打算使用argv。让我们通过这个打击。

609
00:55:41,480 --> 00:55:45,730
说它独特，写一个程序。

610
00:55:45,730 --> 00:55:49,400
你可以假设，输入将包含每行一个单词。

611
00:55:49,400 --> 00:55:52,020
其实，ARGV将变得非常简单使用。

612
00:56:03,730 --> 00:56:06,720
unique.php。

613
00:56:08,550 --> 00:56:13,750
第一件事，第一，我们要检查，如果我们已经通过命令行参数。

614
00:56:13,750 --> 00:56:20,900
正如你所期望的argc和argv在C，我们还有那些在PHP。

615
00:56:20,900 --> 00:56:33,900
因此，如果（$ ARGC！== 2），那么我将不会处理与打印一条消息或任何。

616
00:56:33,900 --> 00:56:37,340
我就退出，错误代码1。

617
00:56:37,340 --> 00:56:41,340
我还可以返回1。

618
00:56:41,340 --> 00:56:53,180
在PHP中，你很少在这种状态下，我们在哪里 - 

619
00:56:53,180 --> 00:56:57,820
通常你在一个函数中调用一个函数调用的函数调用的函数。

620
00:56:57,820 --> 00:57:02,070
而且，如果出现错误，你只是想完全退出一切，

621
00:57:02,070 --> 00:57:05,680
退出刚刚结束的程序。

622
00:57:05,680 --> 00:57:08,160
这也存在C中

623
00:57:08,160 --> 00:57:10,700
如果你在一个函数中的函数，在函数中的函数

624
00:57:10,700 --> 00:57:17,540
你只想杀程序，你可以调用exit，它只会退出。

625
00:57:17,540 --> 00:57:23,120
但在PHP中更是罕见，我们在这个顶层。

626
00:57:23,120 --> 00:57:26,090
通常我们内部的某种功能，所以我们调用exit

627
00:57:26,090 --> 00:57:29,650
所以，我们不必返回了1件事，然后实现有一个错误

628
00:57:29,650 --> 00:57:32,270
因此，返回，如果承认有错误。

629
00:57:32,270 --> 00:57:35,270
我们不想去面对这一切，所以退出（1）;

630
00:57:35,270 --> 00:57:38,240
返回（1），在这种情况下将是等同的。

631
00:57:38,240 --> 00:57:44,000
>> 那么我们要打开我们想要的FOPEN。

632
00:57:44,000 --> 00:57:46,760
参数看起来很相似。

633
00:57:46,760 --> 00:57:51,600
我们要FOPEN（$ ARGV [1]，我们想打开它的阅读。

634
00:57:51,600 --> 00:57:55,720
返回一个资源，我们要调用f。

635
00:57:55,720 --> 00:58:02,180
这看起来非常相似，如何做，但我们并没有说FILE *。

636
00:58:02,180 --> 00:58:06,170
相反，我们只是说$ F。好吧。

637
00:58:06,170 --> 00:58:17,190
其实，我觉得这甚至给我们一个提示，以PHP函数调用的文件。 PHP文件。

638
00:58:17,190 --> 00:58:23,990
这是什么做的是读取整个文件到一个数组中。

639
00:58:23,990 --> 00:58:29,770
你甚至都不需要FOPEN它。它会为你做的。

640
00:58:37,450 --> 00:58:43,700
因此，$线=文件（$ ARGV [1]）;

641
00:58:43,700 --> 00:58:49,680
现在，所有的文件的行的行中。现在，我们要排序的行。

642
00:58:49,680 --> 00:58:52,180
我们如何可以排序的行吗？

643
00:58:52,180 --> 00:58:54,920
我们的行进行排序。

644
00:58:54,920 --> 00:58:58,080
现在，我们可以打印出来或者什么的。

645
00:58:58,080 --> 00:59:05,580
也许最简单的方法是的foreach（$回声$线线线）;

646
00:59:05,580 --> 00:59:10,960
[学生]不，我们甚至交叉线通过引用到排序的东西吗？

647
00:59:10,960 --> 00:59:28,850
这是那种会被定义为函数sort（$阵列）。

648
00:59:28,850 --> 00:59:32,650
当你调用这个函数，你不把它传递以供参考。

649
00:59:32,650 --> 00:59:36,900
这是的功能定义它，把它作为参考。

650
00:59:36,900 --> 00:59:40,900
其实，这是到底出了什么错

651
00:59:40,900 --> 00:59:46,220
当我们把所有的东西到我们的服务器，我们去的时候，从5.3到5.4。

652
00:59:46,220 --> 00:59:53,800
直到5.4，这是完全合理的。

653
00:59:53,800 --> 00:59:58,740
功能不希望把它作为参考，但你可以把它作为参考

654
00:59:58,740 --> 01:00:02,860
因此，如果不发生修改它，它仍然有修改的。

655
01:00:02,860 --> 01:00:05,850
5.4，你不应该这样做。

656
01:00:05,850 --> 01:00:11,740
所以现在唯一的办法是，如果你通过引用传递明确它的功能。

657
01:00:11,740 --> 01:00:19,840
如果你不想要它，修改它，然后你需要做的$ = $线，并通过复制复制。

658
01:00:19,840 --> 01:00:24,820
所以，现在线将被保留，副本将被改变。

659
01:00:27,670 --> 01:00:31,460
php.unique.php。我可能会弄乱的东西了。

660
01:00:31,460 --> 01:00:33,190
意外的'排序'。

661
01:00:38,320 --> 01:00:43,850
有要的东西，这对我们来说。

662
01:00:43,850 --> 01:00:45,820
它甚至不存在。

663
01:00:45,820 --> 01:00:52,140
请注意，当您阅读本手册的第一个参数是一个数组

664
01:00:52,140 --> 01:00:56,490
和它的所采取的参考。

665
01:00:58,160 --> 01:01:03,540
这是为什么向我抱怨吗？因为我有这样的功能，的排序仍然在这里，我不想。

666
01:01:03,540 --> 01:01:09,210
好了，php.unique.php。我没有传递给它一个说法，因为我没有一个文件。

667
01:01:09,210 --> 01:01:13,560
这是对test.php的php.unique.php。

668
01:01:13,560 --> 01:01:19,080
这里是一个很好的排序顺序打印出来的test.php的。

669
01:01:19,080 --> 01:01:24,600
请注意，排序是一种奇怪的代码文件

670
01:01:24,600 --> 01:01:27,460
因为我们所有的空行是要来首次

671
01:01:27,460 --> 01:01:30,190
然后要来我们所有的1级缩进

672
01:01:30,190 --> 01:01:33,360
然后来我们没有凹陷。

673
01:01:33,360 --> 01:01:38,620
是啊。 >>的源代码[学生]因此，它不是通过引用传递？

674
01:01:38,620 --> 01:01:42,240
一般是按值传递？

675
01:01:42,240 --> 01:01:50,240
波顿当你调用一个函数，它从来没有确定它是否是通过引用传递。

676
01:01:50,240 --> 01:01:53,960
这是确定它是否是通过引用传递函数的定义。

677
01:01:53,960 --> 01:01:59,450
在函数定义的排序，或者只是在看，

678
01:01:59,450 --> 01:02:02,820
它需要的参数，以供参考。

679
01:02:02,820 --> 01:02:07,160
所以，不管你是否希望它把它的参考，它以供参考。

680
01:02:07,160 --> 01:02:10,200
它会修改数组中的地方。

681
01:02:10,200 --> 01:02:17,400
这仅仅是不允许的。你没有做到这一点。 >> [学生]：哦，好吧。

682
01:02:17,400 --> 01:02:22,410
鲍登]这一点，是要采取排序的参考和修改。

683
01:02:22,410 --> 01:02:26,850
再者，如果你不希望它这样做，你可以制作一个副本的排序。

684
01:02:26,850 --> 01:02:35,850
即使在这种情况下，复制是不实际的行的副本。

685
01:02:35,850 --> 01:02:40,620
它只是指出了同样的事情，直到它第一次被修改，

686
01:02:40,620 --> 01:02:44,430
它第一次被修改的排序功能，

687
01:02:44,430 --> 01:02:50,940
的地方，因为它的副本上写的，现在要进行复制的副本。

688
01:02:57,500 --> 01:03:04,250
您也可以做到这一点。这是在其他地方，你可以看到符号。

689
01:03:04,250 --> 01:03:07,190
你看，它在foreach循环中，你会看到它在函数声明中，

690
01:03:07,190 --> 01:03:10,040
你看到它的时候才分配变量。

691
01:03:10,040 --> 01:03:12,350
现在，我们已经这样做一事无成

692
01:03:12,350 --> 01:03:15,600
因为复制和线的字面意思是同样的事情。

693
01:03:15,600 --> 01:03:19,940
您可以使用和复制交替。

694
01:03:19,940 --> 01:03:25,430
你可以做未设置（副本）;不未设置线，

695
01:03:25,430 --> 01:03:29,120
你只是失去了同样的事情。

696
01:03:29,120 --> 01:03:33,440
所以，这一点，现在线是唯一的方法，你可以访问行。

697
01:03:36,450 --> 01:03:38,770
>> 有问题吗？

698
01:03:41,000 --> 01:03:42,460
是啊。

699
01:03:42,460 --> 01:03:45,880
[学生]完全偏离主题，但您不必关闭PHP  -  >>你没有。

700
01:03:45,880 --> 01:03:47,730
好吧。

701
01:03:47,730 --> 01:03:53,790
鲍登我会去尽量说这是不好的做法，将其关闭。

702
01:03:53,790 --> 01:03:57,580
这可能是夸张，尤其是在脚本中，

703
01:03:57,580 --> 01:04:03,740
但让我们看看会发生什么，如果我这样做。

704
01:04:03,740 --> 01:04:08,890
这什么都没做。如果我想 -  [叹气]

705
01:04:13,870 --> 01:04:16,960
我需要传递的参数。

706
01:04:19,000 --> 01:04:22,050
拍摄。我把它叫做错误。

707
01:04:24,340 --> 01:04:28,310
参数所以php.unique.php。

708
01:04:28,310 --> 01:04:30,980
现在，我什至都不需要这个。

709
01:04:34,520 --> 01:04:37,740
我会通过一个有效的参数。

710
01:04:37,740 --> 01:04:42,050
这无论是印刷打印。

711
01:04:45,260 --> 01:04:50,080
我在印刷复制和拷贝不存在。所以线。

712
01:04:53,650 --> 01:04:58,270
它打印的每一件事，然后发现这一切垃圾到这里，

713
01:04:58,270 --> 01:05:06,690
因为在PHP什么是PHP标签之外

714
01:05:06,690 --> 01:05:09,520
只是要打印的字面。

715
01:05:09,520 --> 01:05:18,050
这就是为什么HTML，它是如此的好，我可以做格嗒嗒，嗒嗒，嗒嗒类或其他，

716
01:05:18,050 --> 01:05:25,140
等等，等等，等等，然后做一些PHP代码，然后做终端的分区。

717
01:05:25,140 --> 01:05:36,460
而现在印刷这个，我得到我漂亮的分区往上顶，一切PHP印刷，DIV底部。

718
01:05:36,460 --> 01:05:43,510
这样的事情发生灾害时，这是很常见的，

719
01:05:43,510 --> 01:05:47,930
只是一个流浪在底部的文件换行符。

720
01:05:47,930 --> 01:05:50,940
你可能不会想到这将是大不了的

721
01:05:50,940 --> 01:05:58,660
直到你考虑的事实是，与浏览器 - 

722
01:05:58,660 --> 01:06:03,880
>> 如何重定向工作或基本任何头的工作，

723
01:06:03,880 --> 01:06:07,980
当你让你连接到一个网站，它发回所有这些报头和活动

724
01:06:07,980 --> 01:06:12,020
像200或响应重定向或任何响应

725
01:06:12,020 --> 01:06:18,230
头是唯一有效的，直到第一个字节的数据被发送。

726
01:06:18,230 --> 01:06:23,140
您可以重定向几千倍，但只要作为第一个字节的数据被发送

727
01:06:23,140 --> 01:06:26,120
你不应该再次重定向。

728
01:06:26,120 --> 01:06:31,860
>> 如果你有一个流浪在底部的文件换行符

729
01:06:31,860 --> 01:06:37,260
比方说，您使用此功能，那么你要 - 

730
01:06:41,580 --> 01:06:52,870
比方说，这是另一种的index.php文件，你require_once的东西 - 

731
01:06:52,870 --> 01:06:56,920
我不认为它的​​一个很好的例子。

732
01:06:56,920 --> 01:07:04,740
问题发生时，这条线在底部得到呼应。

733
01:07:04,740 --> 01:07:08,660
你什么也不想。

734
01:07:10,820 --> 01:07:15,700
即使你不打算在任何问题上得到呼应，东西都回荡

735
01:07:15,700 --> 01:07:17,990
所以现在你不应该发送任何更多的头文件

736
01:07:17,990 --> 01:07:20,030
你会得到投诉。

737
01:07:22,170 --> 01:07:24,420
你只是不需要那些关闭的标签。

738
01:07:24,420 --> 01:07:27,420
如果你打算做一些与HTML  - 

739
01:07:27,420 --> 01:07:30,490
，这是完全合理的，在这里做下来格

740
01:07:30,490 --> 01:07:39,450
，然后在这一点上，你或你可以不包括他们。

741
01:07:39,450 --> 01:07:41,590
这其实并不重要。

742
01:07:41,590 --> 01:07:45,450
但是在PHP脚本中，很少将其关闭。

743
01:07:45,450 --> 01:07:50,400
当一切PHP，绝对好用，

744
01:07:50,400 --> 01:07:55,460
你并不真的需要关闭它/你不应该关闭它。

745
01:08:02,030 --> 01:08:05,720
>> 处理字符串的好得多，比C.

746
01:08:05,720 --> 01:08:09,470
在PHP中，你可以指定一个字符串用单引号或双引号括起来。

747
01:08:09,470 --> 01:08:12,820
用单引号，您不能使用“escape”序列。

748
01:08:12,820 --> 01:08:17,640
不断逃跑，等等，等等，等等。

749
01:08:19,920 --> 01:08:24,010
因此我们知道printf在PHP中是非常罕见的。

750
01:08:24,010 --> 01:08:32,290
我想我会使用printf，如果我想要做的事情 - 在pset中5，你用sprintf或者任何一种。

751
01:08:32,290 --> 01:08:36,060
不过，你想要做001.JPG 002.JPG。

752
01:08:36,060 --> 01:08:40,300
因此，对于诸如此类的事情，其实我想我会用printf来格式化文本。

753
01:08:40,300 --> 01:08:44,689
但是，除此之外，我只想用字符串连接操作。

754
01:08:44,689 --> 01:08:47,000
我从来没有真正使用printf。

755
01:08:49,229 --> 01:09:00,170
我们只是区分单引号和双引号之间的细节。

756
01:09:00,170 --> 01:09:07,490
最大的区别在于，单引号，它会被打印字面上。

757
01:09:07,490 --> 01:09:15,390
没有char数据类型在PHP，C不一样，所以这是相当于。

758
01:09:15,390 --> 01:09:17,970
他们两个字符串。

759
01:09:17,970 --> 01:09:29,180
有关单引号字符串是很好的事情，我可以说'你好，世界！“等等，等等，等等，

760
01:09:29,180 --> 01:09:33,340
$ $ WOOO。

761
01:09:33,340 --> 01:09:38,260
会发生什么事，当我打印，这是它会打印出它的字面。

762
01:09:38,260 --> 01:09:40,680
让我们摆脱我们的东西。

763
01:09:40,680 --> 01:09:44,700
所以回声$ str1的;

764
01:09:48,569 --> 01:09:56,570
它的字面打印所有这些事情：美元符号，

765
01:09:56,570 --> 01:09:58,770
反斜杠n，您会觉得这是换行符 - 

766
01:09:58,770 --> 01:10:01,500
所有这些东西打印字面上。

767
01:10:01,500 --> 01:10:05,650
你唯一需要转义单引号

768
01:10:05,650 --> 01:10:09,470
因为否则会认为这是结束的单引号。

769
01:10:09,470 --> 01:10:15,050
双引号，完全不同的。

770
01:10:20,300 --> 01:10:25,870
我们已经看到的语法高亮cluing我们去可怕的错误。

771
01:10:25,870 --> 01:10:36,190
php.unique。未定义的变量：WOOO，因为这被解释为变量的Wooo。

772
01:10:36,190 --> 01:10:42,400
双引号，让你插入变量 - 

773
01:10:42,400 --> 01:10:52,730
比方说，$名称=“抢”;

774
01:10:52,730 --> 01:10:58,020
所以回声“嗨，我的名字是名字！”;

775
01:10:58,020 --> 01:11:09,260
认识到这一点作为一个变量。

776
01:11:09,260 --> 01:11:21,210
当我运行的 - 我将插入一个新行 - 嗨，我的名字是Rob！和世界你好！

777
01:11:21,210 --> 01:11:24,910
这是因为我从来没有删除上面印刷的Wooo。

778
01:11:24,910 --> 01:11:30,020
有进一步的步骤，你可以做的。

779
01:11:30,020 --> 01:11:39,250
$阵列= [1，2，3];

780
01:11:39,250 --> 01:11:43,270
如果我要打印第一个索引的数组？

781
01:11:43,270 --> 01:11:45,150
您做$数组[0]。

782
01:11:45,150 --> 01:11:49,280
语法突出显示是一个线索。这是什么怎么办呢？

783
01:11:52,320 --> 01:11:54,510
php.unique。

784
01:11:54,510 --> 01:11:59,860
嗨，我的名字是！这不是我想要的。

785
01:11:59,860 --> 01:12:05,050
语法高亮对我撒了谎。

786
01:12:05,050 --> 01:12:13,020
让我们尝试“ - > 1，'B' - > 2。

787
01:12:18,450 --> 01:12:21,440
这是我会怎么写。

788
01:12:26,350 --> 01:12:32,160
意外的单引号（T_ENCAPSED废话，废话，废话，废话，废话）。

789
01:12:32,160 --> 01:12:41,780
我们的想法是，它没有认识到这一点作为阵列的一部分。

790
01:12:41,780 --> 01:12:46,620
它没有认识到这一点作为数组的索引字母a。

791
01:12:46,620 --> 01:12:49,870
你想干什么，大括号，

792
01:12:49,870 --> 01:12:54,730
现在无论是在这个大括号将插，

793
01:12:54,730 --> 01:13:00,340
这是我们到正确的地方，神奇地将这些变量的使用的字。

794
01:13:00,340 --> 01:13:04,280
现在这样做，php.unique，嗨，我的名字是1！果然

795
01:13:04,280 --> 01:13:07,720
“或”嗨，我的名字是Rob！

796
01:13:14,110 --> 01:13:23,130
有一件事，是一种不错的关于单引号是 - 

797
01:13:23,130 --> 01:13:28,480
这里也有一些成本插值。

798
01:13:30,520 --> 01:13:35,100
如果使用双引号，解释过这串，

799
01:13:35,100 --> 01:13:41,500
肯定地说，“哦，这里有一个变量，现在我需要去获得这个变量，并将其插入。”

800
01:13:41,500 --> 01:13:48,930
即使你不使用任何变量，

801
01:13:48,930 --> 01:13:52,220
这些双引号里面什么都没有，需要进行插值，

802
01:13:52,220 --> 01:13:56,800
但它仍然会比较慢，因为它需要在双引号

803
01:13:56,800 --> 01:14:00,130
寻找的东西，需要进行插值。

804
01:14:00,130 --> 01:14:05,360
因此，单引号可以快一点，如果没有什么需要进行插值，

805
01:14:05,360 --> 01:14:15,650
我倾向于甚至可以使用单引号，'嗨，我的名字是'。数组['A']了。

806
01:14:15,650 --> 01:14:20,430
这是怎么回事，我们以前是等价的。

807
01:14:24,840 --> 01:14:28,440
但是，这是一个见仁见智的问题。

808
01:14:28,440 --> 01:14:34,750
如果你使用PHP，你可能不关心速度的差异。

809
01:14:34,750 --> 01:14:39,480
没有足够的理他们开始。

810
01:14:39,480 --> 01:14:43,030
>> 任何最后的问题吗？

811
01:14:47,430 --> 01:14:51,710
>> 实际上，我们没有，甚至通过所有的，但这个东西很无聊。

812
01:14:51,710 --> 01:14:59,080
最后一件事，是一种不错的PHP是当你要处理的HTML，

813
01:14:59,080 --> 01:15:06,450
打印变量，你就可以使用它了一下，所以很好的快捷方式语法。

814
01:15:32,400 --> 01:15:36,730
没有让PHP在这里，这就是所谓的短标签。

815
01:15:36,730 --> 01:15:44,330
正式的PHP 5.4，这已经过时了。

816
01:15:44,330 --> 01:15:48,640
建议您把PHP。

817
01:15:48,640 --> 01:15:55,770
这仍然是支持的，这么短的标签<？还是完全没有问题的。

818
01:15:55,770 --> 01:16:02,480
它在默认情况下是支持的，所以您可以使用这些如你所愿，和他们吃起来十分方便。

819
01:16:02,480 --> 01:16:05,700
>> 有什么问题吗？

820
01:16:07,780 --> 01:16:09,270
好的。

821
01:16:10,840 --> 01:16:13,800
>> 保持优雅，圣地亚哥。

822
01:16:13,800 --> 01:16:16,070
[笑]

823
01:16:18,620 --> 01:16:22,660
再见。 [笑]

824
01:16:24,350 --> 01:16:28,470
[掌声] [笑]

825
01:22:46,460 --> 01:22:49,460
>> [CS50.TV]