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]