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
只要你有問題，什麼是最好的方式做X在PHP

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
它給我的$ i本身，這是一種痛苦。

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]