1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [8]週

2
00:00:02,000 --> 00:00:04,000
[DAVID J馬蘭] [哈佛大學]

3
00:00:04,000 --> 00:00:07,000
這是CS50。[CS50.TV]

4
00:00:07,000 --> 00:00:09,000
>> 歡迎回來。

5
00:00:09,000 --> 00:00:11,000
這是CS50，這是開始的第8週。

6
00:00:11,000 --> 00:00:14,000
本週一對夫婦的機會，

7
00:00:14,000 --> 00:00:17,000
他們在這裡說，在一些食品供應。

8
00:00:17,000 --> 00:00:20,000
欲了解更多詳細信息，檢查出在線的幻燈片。

9
00:00:20,000 --> 00:00:24,000
也由自己的托馬斯Carriero的另一個事件本週。

10
00:00:24,000 --> 00:00:27,000
他是一個CS50的前負責教學研究員誰現在是在Dropbox的，

11
00:00:27,000 --> 00:00:29,000
他的傢伙迷上了，你也知道什麼，

12
00:00:29,000 --> 00:00:36,000
因此，如果您想了解更多的到他們的談話，頭今天下午Dropbox和更多。

13
00:00:36,000 --> 00:00:38,000
CS50午餐是這個星期五​​。

14
00:00:38,000 --> 00:00:41,000
你加入我們，如果你有能力，1:15，像往常一樣，在火與冰。

15
00:00:41,000 --> 00:00:45,000
>> 現在，我們深入到一些所謂的研討會。

16
00:00:45,000 --> 00:00:49,000
我們的CS50研討會，召回，這是可選的類教學研究員的帶領下

17
00:00:49,000 --> 00:00:51,000
和課程助理和朋友的過程中，

18
00:00:51,000 --> 00:00:55,000
從一組在校園裡的人，這是一組被稱為ABCD

19
00:00:55,000 --> 00:00:58,000
技術愛好者，在校園裡，以及一組名為HCS，

20
00:00:58,000 --> 00:01:02,000
哈佛大學計算機協會，本科生同樣感興趣計算的。

21
00:01:02,000 --> 00:01:08,000
今年的研討會名冊，包括研討會上Android和iOS和JavaScript

22
00:01:08,000 --> 00:01:13,000
和PHP，UNIX，Vim的多，所以認識到，這些研討會都上來了。

23
00:01:13,000 --> 00:01:16,000
如果你想RSVP，他們前往該網址那裡。

24
00:01:16,000 --> 00:01:20,000
然後，我們將發布在本課程的網站，一旦他們確定的時間和地點。

25
00:01:20,000 --> 00:01:26,000
但是要知道前研討會的有5年的價值可在網上，

26
00:01:26,000 --> 00:01:29,000
其中有許多是非常大的電流的技術，你可能

27
00:01:29,000 --> 00:01:36,000
要玩你的最後的項目，所以頭上有一些影片。

28
00:01:36,000 --> 00:01:39,000
>> CSS，你已經熟悉CSS，

29
00:01:39,000 --> 00:01:42,000
什麼是它概括？

30
00:01:42,000 --> 00:01:45,000
什麼是CSS？

31
00:01:45,000 --> 00:01:48,000
它的級聯樣式表，這是什麼意思呢？

32
00:01:48,000 --> 00:01:53,000
這是什麼做對我們來說，CSS？

33
00:01:53,000 --> 00:01:57,000
好吧，讓的熱身一個簡單的，HTML超文本標記語言。

34
00:01:57,000 --> 00:02:01,000
為我們做什麼？

35
00:02:01,000 --> 00:02:04,000
任何人在嗎？

36
00:02:04,000 --> 00:02:07,000
它變得非常尷尬的問這些問題。

37
00:02:07,000 --> 00:02:11,000
HTML超文本標記語言。

38
00:02:11,000 --> 00:02:14,000
是嗎？不是嗎？

39
00:02:14,000 --> 00:02:17,000
[聽不見的學生反應]

40
00:02:17,000 --> 00:02:20,000
好了，好了，讓我們來標記文本顯示在Web瀏覽器。

41
00:02:20,000 --> 00:02:22,000
這是不是一種編程語言。

42
00:02:22,000 --> 00:02:25,000
的確，這是一種標記語言，這意味著它指示瀏覽器如何顯示

43
00:02:25,000 --> 00:02:28,000
信息，所以最簡單的化身，因為我們已經看到了

44
00:02:28,000 --> 00:02:32,000
是一些超級簡單的像加粗，開放式支架B右括號說

45
00:02:32,000 --> 00:02:36,000
使這個文本加粗，而這實際上只是許多方法之一

46
00:02:36,000 --> 00:02:39,000
中，我們可以做到這一點，確實，這些天來一個更好的辦法

47
00:02:39,000 --> 00:02:42,000
風格化您的網頁，使事情粗體和斜體

48
00:02:42,000 --> 00:02:47,000
中心和合理的，不這樣做僅僅通過HTML標籤

49
00:02:47,000 --> 00:02:51,000
而是用了一種叫做CSS，層疊樣式表。

50
00:02:51,000 --> 00:02:53,000
這是對自己的語言。

51
00:02:53,000 --> 00:02:55,000
它也不是一個編程語言，但

52
00:02:55,000 --> 00:02:58,000
大家好，這是丹，參加我們今天的。

53
00:02:58,000 --> 00:03:01,000
一些技術上的困難。不是一個問題。

54
00:03:01,000 --> 00:03:04,000
>> 讓我們的樣式CSS的頁面

55
00:03:04,000 --> 00:03:07,000
通過設置被稱為屬性，所以讓我們來看看這個

56
00:03:07,000 --> 00:03:09,000
由一些基本的實施例的方式。

57
00:03:09,000 --> 00:03:12,000
讓我進入今天的家電。

58
00:03:12,000 --> 00:03:15,000
我在這裡源週一目錄的，

59
00:03:15,000 --> 00:03:18,000
我會去到一個目錄中稱為CSS，我們有一大堆

60
00:03:18,000 --> 00:03:21,000
在這裡等待著我們的文件，

61
00:03:21,000 --> 00:03:27,000
在該文件夾中，我們有，例如，search0.html從最後一次。

62
00:03:27,000 --> 00:03:31,000
現在，回想與搜索0，我們留在本附註

63
00:03:31,000 --> 00:03:35,000
排序實現谷歌或真的只是它的前端一個星期前，

64
00:03:35,000 --> 00:03:38,000
注意到，我們有一些新的標籤。

65
00:03:38,000 --> 00:03:41,000
我們有一個大的，大膽的標題H1，

66
00:03:41,000 --> 00:03:45,000
形式，這使得我們有一個HTML表單的用戶輸入。

67
00:03:45,000 --> 00:03:48,000
行動的action屬性，究竟是什麼含義

68
00:03:48,000 --> 00:03:52,000
在HTML表單標籤？

69
00:03:52,000 --> 00:03:58,000
這一點，行動的意義是什麼？

70
00:03:58,000 --> 00:04:00,000
我就這樣做。

71
00:04:00,000 --> 00:04:03,000
行動的目標是到哪裡的形式將被提交。

72
00:04:03,000 --> 00:04:07,000
事實上，說行動=“google.com /搜索”

73
00:04:07,000 --> 00:04:10,000
意味著，當用戶單擊提交按鈕或等效

74
00:04:10,000 --> 00:04:14,000
任何形式的字段填寫的將被發送到我們的服務器

75
00:04:14,000 --> 00:04:17,000
我們的設備，但在谷歌，而該特定URL。

76
00:04:17,000 --> 00:04:19,000
要使用它的方法被稱為，

77
00:04:19,000 --> 00:04:25,000
而得到的，就目前而言，僅僅是一個技術傳遞到Web服務器的信息，以及

78
00:04:25,000 --> 00:04:29,000
通過URL的方式，讓我們來快速回顧一下這是如何工作。

79
00:04:29,000 --> 00:04:31,000
>> 請注意，有一個輸入其名稱為q

80
00:04:31,000 --> 00:04:35,000
其類型是文本，然後類型提交的第二輸入端

81
00:04:35,000 --> 00:04:39,000
它的值是CS50的搜索，而事實上，如果我們打開這個文件，在這裡，

82
00:04:39,000 --> 00:04:42,000
sea​​rch0.html，這是一個超級簡單的形式，

83
00:04:42,000 --> 00:04:45,000
如果我搜索的東西，如計算機科學

84
00:04:45,000 --> 00:04:50,000
然後按下回車鍵或點擊CS50搜索

85
00:04:50,000 --> 00:04:53,000
注意，會發生什麼情況超出去谷歌

86
00:04:53,000 --> 00:04:56,000
我特意結束了在這個URL在頂部，

87
00:04:56,000 --> 00:05:01,000
google.com /搜索Q =電腦+科學​​，

88
00:05:01,000 --> 00:05:04,000
計算機科學顯然是我所輸入的字詞。

89
00:05:04,000 --> 00:05:06,000
+只是意味著一個空格字符，

90
00:05:06,000 --> 00:05:10,000
它的瀏覽器，以確保公正，有沒有

91
00:05:10,000 --> 00:05:13,000
在實際的URL的混亂和空白。

92
00:05:13,000 --> 00:05:15,000
那麼q，當然是參數名稱。

93
00:05:15,000 --> 00:05:20,000
我們還沒有看到我們如何，程序員，實際上可以進入Q還。

94
00:05:20,000 --> 00:05:23,000
我們可以假設，谷歌知道該怎麼做在這裡，

95
00:05:23,000 --> 00:05:25,000
但我們會在適當的時候。

96
00:05:25,000 --> 00:05:30,000
>> 但是，讓我看看，而不是在search1.html，

97
00:05:30,000 --> 00:05:34,000
看起來有點不同，因為我決定，這種形式在這裡只是有點跛。

98
00:05:34,000 --> 00:05:36,000
我的意思是，這是在左上角。

99
00:05:36,000 --> 00:05:40,000
真的沒有美學，所以我想的樣式

100
00:05:40,000 --> 00:05:43,000
有點像谷歌的網頁，召回，

101
00:05:43,000 --> 00:05:47,000
即使你可能經常不能訪問，今天看起來是這樣的萬聖節。

102
00:05:47,000 --> 00:05:53,000
而如果我們打開這個文件的第1版，搜索1.HTML，我中心。

103
00:05:53,000 --> 00:05:57,000
不過很醜陋，但至少現在我已經開始控制此頁的美學，

104
00:05:57,000 --> 00:06:00,000
不只是標記物。

105
00:06:00,000 --> 00:06:04,000
讓我們來看看在搜索，而且也真的只有一個區別就在這裡，

106
00:06:04,000 --> 00:06:06,000
這可能跳出你，也許不是，

107
00:06:06,000 --> 00:06:11,000
但什麼是一條線或片段的差異呢？

108
00:06:11,000 --> 00:06:14,000
>> 這種風格的屬性，所以，在HTML

109
00:06:14,000 --> 00:06:19,000
大部分元素，大部分標籤上的樣式屬性，

110
00:06:19,000 --> 00:06:23,000
在該樣式屬性是帶引號的字符串，

111
00:06:23,000 --> 00:06:26,000
而且引號的字符串是CSS。

112
00:06:26,000 --> 00:06:29,000
在那裡，你可以把級聯樣式表

113
00:06:29,000 --> 00:06:32,000
通過指定它作為屬性名

114
00:06:32,000 --> 00:06:34,000
其次由一個冒號後面的值。

115
00:06:34,000 --> 00:06:37,000
幾年前，這是一個不幸的設計決策

116
00:06:37,000 --> 00:06:40,000
CSS是你們自己的語言，

117
00:06:40,000 --> 00:06:43,000
但是從HTML語法上是非常不同的。

118
00:06:43,000 --> 00:06:46,000
在這種情況下，我們可以看到，我的網頁上的內部，這是寫在HTML中，

119
00:06:46,000 --> 00:06:51,000
我有CSS裡面的這些報價，並約定CSS

120
00:06:51,000 --> 00:06:55,000
是，你有什麼所謂的財產，其次，再次，一個冒號，

121
00:06:55,000 --> 00:06:58,000
其次，物業的價值，所以也沒有等號。

122
00:06:58,000 --> 00:07:00,000
有沒有額外的報價。

123
00:07:00,000 --> 00:07:03,000
只是這個冒號分隔的鍵值對，

124
00:07:03,000 --> 00:07:05,000
文本行不正是它說。

125
00:07:05,000 --> 00:07:09,000
它在體內的頁對齊文本，這是真正的膽量的頁面，

126
00:07:09,000 --> 00:07:11,000
在中心。

127
00:07:11,000 --> 00:07:13,000
>> 好了，那麼，最終的結果是明確的，是這樣的。

128
00:07:13,000 --> 00:07:17,000
不是所有的性感，但至少它為中心，有點像真正的谷歌。

129
00:07:17,000 --> 00:07:21,000
但是，如果我不是打開第2版

130
00:07:21,000 --> 00:07:25,000
並指出在這裡完全一個新的標籤？

131
00:07:25,000 --> 00:07:30,000
現在，在我的網頁的頭，這在以前只有標籤

132
00:07:30,000 --> 00:07:32,000
在所有先前的例子嗎？

133
00:07:32,000 --> 00:07:34,000
它只是有這個稱號。

134
00:07:34,000 --> 00:07:38,000
剛才的head標籤是這樣的。

135
00:07:38,000 --> 00:07:40,000
現在，而不是它有它的style標籤內，

136
00:07:40,000 --> 00:07:44,000
這也太，我很抱歉，語法看起來非常不同的（HTML）

137
00:07:44,000 --> 00:07:47,000
但你習慣了它，據此，裡面的風格標籤

138
00:07:47,000 --> 00:07:50,000
我現在可以分解出是剛才

139
00:07:50,000 --> 00:07:54,000
一個屬性，樣式屬性，我可以把它在我的網頁的最頂端。

140
00:07:54,000 --> 00:07:56,000
>> 為什麼呢？

141
00:07:56,000 --> 00:08:00,000
那麼，這是一步步走向清潔的東西，就像在寫C代碼

142
00:08:00,000 --> 00:08:04,000
我們有時會寫功能分解出常見的功能。

143
00:08:04,000 --> 00:08:07,000
這只是一個小的清潔劑開始分解出的東西，如美學

144
00:08:07,000 --> 00:08:11,000
到一個中央位置，而不是它的所有點綴在你的HTML。

145
00:08:11,000 --> 00:08:14,000
這也沒有說什麼，即使有一點新的語法。

146
00:08:14,000 --> 00:08:19,000
我們在這裡可以看到，這是一個選擇，身體只是意味著選擇body元素

147
00:08:19,000 --> 00:08:21,000
適用於下列屬性。

148
00:08:21,000 --> 00:08:23,000
好了，財產是完全一樣的。

149
00:08:23,000 --> 00:08:25,000
良好的措施，我添加了一個分號結束，

150
00:08:25,000 --> 00:08:29,000
這往往是慣例，我已經包裝全部財產

151
00:08:29,000 --> 00:08:33,000
在大括號中，因為我其實可以有不同的東西在這裡。

152
00:08:33,000 --> 00:08:39,000
我其實可以說的東西喜歡的顏色：藍色;

153
00:08:39,000 --> 00:08:42,000
>> 現在，這也不會是一步步走向任何事情都漂亮，

154
00:08:42,000 --> 00:08:47,000
但如果我現在回去版本2我至少現在我的身體

155
00:08:47,000 --> 00:08:49,000
頁的文本藍色的。

156
00:08:49,000 --> 00:08:51,000
保持不變，因為這是一個輸入的按鈕。這不是純文本。

157
00:08:51,000 --> 00:08:56,000
但一切是文本，像CS50搜索往上頂，其實是藍色的。

158
00:08:56,000 --> 00:09:01,000
同樣，我們現在所做的是刪除從body標籤，通知，

159
00:09:01,000 --> 00:09:04,000
的樣式屬性，我們已經考慮在這裡。

160
00:09:04,000 --> 00:09:08,000
這是不是一個巨大的進步，但是如果我們採取這一步

161
00:09:08,000 --> 00:09:10,000
注意這裡，我們可以在這第三個版本。

162
00:09:10,000 --> 00:09:14,000
>> ，在search3.html的網頁幾乎是相同的

163
00:09:14,000 --> 00:09:17,000
除非有什麼新的標籤，現在呢？

164
00:09:17,000 --> 00:09:20,000
鏈接，所以這個人是不是很恰當地命名為

165
00:09:20,000 --> 00:09:24,000
因為你不是在這個意義上的可點擊的超鏈接連接起來。

166
00:09:24,000 --> 00:09:28,000
相反，你排序，這樣做相當於在C＃

167
00:09:28,000 --> 00:09:31,000
其中的鏈接標籤的href屬性

168
00:09:31,000 --> 00:09:34,000
rel屬性說，繼續

169
00:09:34,000 --> 00:09:39,000
和複製的內容粘貼的文件名為的search3.css在這裡，基本上。

170
00:09:39,000 --> 00:09:42,000
它不這樣做，但它的精神。

171
00:09:42,000 --> 00:09:45,000
它說，去打開這個文件，search3.css，

172
00:09:45,000 --> 00:09:49,000
和對待它，就好像用戶輸入了正確的在頁面頭部的

173
00:09:49,000 --> 00:09:51,000
就像我在前面的例子。

174
00:09:51,000 --> 00:09:54,000
同時，Search3.css，是非常簡單的。

175
00:09:54,000 --> 00:09:58,000
它實際上只是包含正是剛才

176
00:09:58,000 --> 00:10:03,000
標籤的風格，但我已經考慮它在這裡它自己的文件。

177
00:10:03,000 --> 00:10:07,000
>> 即使我們沒有花太多的時間在所有的HTML或Web編程

178
00:10:07,000 --> 00:10:11,000
只是憑直覺是什麼動機，也許，以剔除

179
00:10:11,000 --> 00:10:14,000
這個小片段，甚至CSS到自己的文件

180
00:10:14,000 --> 00:10:19,000
然後包括它這個鏈接標籤嗎？

181
00:10:19,000 --> 00:10:21,000
[聽不見的學生反應]

182
00:10:21,000 --> 00:10:25,000
好吧，這是在這個意義上，你有你的CSS CSS文件中的更容易閱讀。

183
00:10:25,000 --> 00:10:28,000
你有你的HTML在HTML文件中，所以在這個意義上，它更具可讀性。

184
00:10:28,000 --> 00:10:30,000
什麼是吸引力？是啊。

185
00:10:30,000 --> 00:10:32,000
[聽不見的學生反應]

186
00:10:32,000 --> 00:10:35,000
是啊，所以你就可以包括了很多次，所以現在我們正在做的這些

187
00:10:35,000 --> 00:10:38,000
基本與單個文件的例子，但假設你實際上

188
00:10:38,000 --> 00:10:42,000
pset的7或您的項目最終也許像你這樣的一個真正的網站，

189
00:10:42,000 --> 00:10:45,000
你想有多個網頁，肯定是常見的

190
00:10:45,000 --> 00:10:48,000
現實世界的資訊網絡，這將是一種跛腳

191
00:10:48,000 --> 00:10:52,000
複製和粘貼相同的藍色

192
00:10:52,000 --> 00:10:56,000
和相同的文本對齊的中心，每一個這些網頁。

193
00:10:56,000 --> 00:10:59,000
相反，它更有意義的因素，就像我們已經在C

194
00:10:59,000 --> 00:11:02,000
h文件，把它放在一個集中的地方，

195
00:11:02,000 --> 00:11:06,000
在這種情況下search3.css，然後允許任何文件

196
00:11:06,000 --> 00:11:11,000
在您的網站，其實這個標籤在第16行中包含該文件。

197
00:11:11,000 --> 00:11:14,000
通常情況下，我們開始與版本0，哪種類型的作品

198
00:11:14,000 --> 00:11:18,000
但不一定是最好的，和每一個步驟，

199
00:11:18,000 --> 00:11:21,000
搜索1，搜索2，搜索我們已經採取了這些嬰兒的步驟

200
00:11:21,000 --> 00:11:26,000
向設計，是一個小更清潔，更準備

201
00:11:26,000 --> 00:11:30,000
更複雜的頁面，我們可以做的道路上。

202
00:11:30,000 --> 00:11:33,000
>> 讓我打開最後一個例子，在這裡只是為了說明

203
00:11:33,000 --> 00:11:36,000
更風格化的頁面，但首​​先讓我們來看看在HTML。

204
00:11:36,000 --> 00:11:41,000
這是search4.html，並注意在結構上幾乎相同

205
00:11:41,000 --> 00:11:44,000
除了引入一個新的標籤，DIV。

206
00:11:44,000 --> 00:11:48,000
Div是一個標籤，引入了一個師的頁面。

207
00:11:48,000 --> 00:11:51,000
你可以認為這是一種無形的矩形。

208
00:11:51,000 --> 00:11:54,000
它的創建在網頁中一大片區域

209
00:11:54,000 --> 00:11:56,000
您可以設置樣式的一次。

210
00:11:56,000 --> 00:11:58,000
我在這裡做了如下。

211
00:11:58,000 --> 00:12:01,000
內我的身體標記，它一直在那裡，一直以來，

212
00:12:01,000 --> 00:12:05,000
我說在這裡創建一個分區的頁面通過線45到47，

213
00:12:05,000 --> 00:12:09,000
這意味著，基本上是沿著頁面頂部給我一種無形的矩形。

214
00:12:09,000 --> 00:12:14,000
然後給了我第二次​​的矩形，但無形的，下面，

215
00:12:14,000 --> 00:12:16,000
，並確定它的名字的內容，最後，

216
00:12:16,000 --> 00:12:19,000
給我一個第三師的頁面底部

217
00:12:19,000 --> 00:12:21,000
叫ID。

218
00:12:21,000 --> 00:12:23,000
我們將看到為什麼我在短短的時刻已經做到了這一點，

219
00:12:23,000 --> 00:12:26,000
但在概念上，我有一個頭部門。

220
00:12:26,000 --> 00:12:30,000
我有一個內容劃分，和我有一個頁腳的頁面劃分

221
00:12:30,000 --> 00:12:32,000
即使這些都只是標記。

222
00:12:32,000 --> 00:12:35,000
用戶不會看到3個矩形，

223
00:12:35,000 --> 00:12:37,000
但形式的結構有幕後

224
00:12:37,000 --> 00:12:39,000
他們是實際存在的。

225
00:12:39,000 --> 00:12:41,000
>> 現在，誰在乎呢？為什麼要真正做到這一點呢？

226
00:12:41,000 --> 00:12:43,000
一切在頁面上是一樣的，因為我們之前已經看到了。

227
00:12:43,000 --> 00:12:47,000
這裡是我的形式。下面是我的輸入，我輸入了一個換行符等等。

228
00:12:47,000 --> 00:12:50,000
不過，這裡有一個圖像，所以我們會看到這個來自一會兒就好了。

229
00:12:50,000 --> 00:12:52,000
這裡有一個頁腳，這是新的，只是因為我想介紹

230
00:12:52,000 --> 00:12:54,000
一些更多的內容。

231
00:12:54,000 --> 00:12:58,000
如果我們向上滾動注意到，這個div的ID是頭。

232
00:12:58,000 --> 00:13:02,000
這個div的ID是內容，和這一個的ID是頁腳。

233
00:13:02,000 --> 00:13:05,000
而作為顧名思義，當你有一個ID屬性

234
00:13:05,000 --> 00:13:09,000
在HTML中，根據定義，它必須唯一地標識

235
00:13:09,000 --> 00:13:12,000
的元素之一，在您的網頁的標籤之一。

236
00:13:12,000 --> 00:13:16,000
完全是你要記住，你已經有一個頭ID的負擔。

237
00:13:16,000 --> 00:13:19,000
你有一個頁腳。你已經有一個內容ID。

238
00:13:19,000 --> 00:13:22,000
電腦是不會找出一個可用的ID是你的，

239
00:13:22,000 --> 00:13:27,000
所以，你可能會意外地給2標籤的ID的頭，

240
00:13:27,000 --> 00:13:29,000
這將是錯誤的。

241
00:13:29,000 --> 00:13:31,000
>> 你必須記住，你已經創建了，

242
00:13:31,000 --> 00:13:34,000
但一旦你這樣做，我們可以在這裡做什麼通知。

243
00:13:34,000 --> 00:13:38,000
我現在可以指定我的風格標籤的頂部

244
00:13:38,000 --> 00:13:41,000
或等價的，如果我在我的CSS文件中仍然使用該版本，

245
00:13:41,000 --> 00:13:46,000
我可以說＃頭，這是什麼意思的是，任何標籤

246
00:13:46,000 --> 00:13:49,000
在這個網頁上有一個ID的頭

247
00:13:49,000 --> 00:13:53,000
＃中，只需通過人的慣例，代表ID。

248
00:13:53,000 --> 00:13:56,000
井號或井號代表ID。

249
00:13:56,000 --> 00:13:58,000
頭是我給它的名稱。

250
00:13:58,000 --> 00:14:01,000
這意味著應用此CSS屬性

251
00:14:01,000 --> 00:14:04,000
在此頁面中的任何標記承擔ID的頭。

252
00:14:04,000 --> 00:14:06,000
同樣的交易在這裡。

253
00:14:06,000 --> 00:14:09,000
應用此屬性的任何元素，而這恰好是相同的，

254
00:14:09,000 --> 00:14:11,000
其ID是內容，然後在這裡

255
00:14:11,000 --> 00:14:14,000
請注意，我有一個小票友頁腳。

256
00:14:14,000 --> 00:14:18,000
任何元素的ID是頁腳，其中可以有一個定義，

257
00:14:18,000 --> 00:14:21,000
繼續前進，其字體大小較小，

258
00:14:21,000 --> 00:14:24,000
其字體粗細大膽的，其保證金20像素。

259
00:14:24,000 --> 00:14:26,000
>> 這是什麼意思呢？

260
00:14:26,000 --> 00:14:28,000
它只是一個緣的頂部，底部，左側和右側上。

261
00:14:28,000 --> 00:14:31,000
這意味著，給我一個20像素的無形的邊緣時

262
00:14:31,000 --> 00:14:35,000
一切只是推離它一點點，像你可能在Word中，

263
00:14:35,000 --> 00:14:37,000
Microsoft Word或頁面等。

264
00:14:37,000 --> 00:14:39,000
然後文本居中對齊。

265
00:14:39,000 --> 00:14:43,000
讓我們來看看最終的結果，那麼我們就回去了，這是剩下的CSS片段。

266
00:14:43,000 --> 00:14:48,000
這是第4版，我們的搜索的例子，和它的多，更性感。

267
00:14:48,000 --> 00:14:54,000
現在，為公平起見，我只是谷歌搜索“谷歌字體標識生成器”。

268
00:14:54,000 --> 00:14:58,000
這讓我創建一個GIF圖像格式，它看起來像有。

269
00:14:58,000 --> 00:15:00,000
事實上，你可以做到這一點。

270
00:15:00,000 --> 00:15:03,000
我們有“谷歌字體標發生器”。

271
00:15:03,000 --> 00:15:05,000
>> 讓我們來看看，如果我們能做到這一點。

272
00:15:05,000 --> 00:15:07,000
好吧，我覺得這是我所使用的網站。

273
00:15:07,000 --> 00:15:11,000
例如，我們可以說，EC 10，和他們自己的。

274
00:15:11,000 --> 00:15:13,000
你可以玩這個整天長，然後用鼠標右鍵單擊它

275
00:15:13,000 --> 00:15:16,000
然後下載實際的GIF，這是我做的這一切。

276
00:15:16,000 --> 00:15:19,000
事實上，這就是為什麼在我的HTML，回想一下，在這裡

277
00:15:19,000 --> 00:15:22,000
我有一個形象的標籤，這是我們上週看到的

278
00:15:22,000 --> 00:15:24,000
其來源是logo.gif的。

279
00:15:24,000 --> 00:15:28,000
什麼又是有這個alt屬性的動機，

280
00:15:28,000 --> 00:15:31,000
這種替代屬性呢？

281
00:15:31,000 --> 00:15:33,000
是啊。

282
00:15:33,000 --> 00:15:35,000
[聽不見的學生反應]

283
00:15:35,000 --> 00:15:37,000
好，所以有2個原因真的，如果瀏覽器不能拉的形象

284
00:15:37,000 --> 00:15:40,000
因為你有一個緩慢的網絡連接或圖像已損壞

285
00:15:40,000 --> 00:15:44,000
或類似的東西，至少在人類可以看到“CS50搜索”，

286
00:15:44,000 --> 00:15:46,000
然後還訪問性的原因。

287
00:15:46,000 --> 00:15:48,000
如果你有一個誰是盲目的，並使用屏幕閱讀器的用戶

288
00:15:48,000 --> 00:15:50,000
，因此，顯然不能看到圖像，他們至少可以

289
00:15:50,000 --> 00:15:52,000
如果他們的電腦說給他們聽文本。

290
00:15:52,000 --> 00:15:56,000
>> 在一般情況下，這是最好的練習，當它涉及到網頁的可訪問性

291
00:15:56,000 --> 00:16:00,000
所以在這種情況下，即使用戶可以聽到或看到的，可以這麼說，

292
00:16:00,000 --> 00:16:03,000
它是什麼，您的網頁上。

293
00:16:03,000 --> 00:16:05,000
還有一個其他的事情，我在這裡做

294
00:16:05,000 --> 00:16:09,000
這是一個有點有趣，我們會看到更多關於這個問題，設置為7

295
00:16:09,000 --> 00:16:12,000
通過的教學研究員領導的短褲之一。

296
00:16:12,000 --> 00:16:15,000
但＃的內容是指該標記

297
00:16:15,000 --> 00:16:20,000
其ID是內容，但是有一個空格字符，然後有字的輸入。

298
00:16:20,000 --> 00:16:25,000
那麼，什麼是有趣的CSS，你可以

299
00:16:25,000 --> 00:16:29,000
標籤頁面中的類的層次結構，

300
00:16:29,000 --> 00:16:33,000
這是什麼代碼片段的CSS的手段是找到標籤

301
00:16:33,000 --> 00:16:37,000
其ID是內容，然後採用下列屬性

302
00:16:37,000 --> 00:16:42,000
的所有內容的後代的輸入標籤，

303
00:16:42,000 --> 00:16:44,000
那就是它內部的縮進。

304
00:16:44,000 --> 00:16:48,000
再次，壓痕，唯一重要的計算機，不以人的，

305
00:16:48,000 --> 00:16:51,000
但按照慣例，我們縮進的事情，因為我們去深入到一個頁面，

306
00:16:51,000 --> 00:16:54,000
因此，這意味著申請保證金的5個像素任何輸入元素

307
00:16:54,000 --> 00:16:57,000
這是某處內部或嵌套在

308
00:16:57,000 --> 00:16:59,000
 元素的ID是內容。

309
00:16:59,000 --> 00:17:01,000
>> 誰不適用？

310
00:17:01,000 --> 00:17:03,000
好了，其實只是這兩個傢伙在這裡。

311
00:17:03,000 --> 00:17:05,000
請注意，內側的形式有2個輸入，

312
00:17:05,000 --> 00:17:07,000
因為可用於所有這些實施例的。

313
00:17:07,000 --> 00:17:11,000
但是請注意，這2個輸入發生嵌套在

314
00:17:11,000 --> 00:17:13,000
雖然有點深，一對夫婦的縮進層次，

315
00:17:13,000 --> 00:17:16,000
裡面的標籤的ID是內容。

316
00:17:16,000 --> 00:17:18,000
這是什麼意思呢？

317
00:17:18,000 --> 00:17:21,000
如果我們去到瀏覽器，在這裡你可以看到非常輕微

318
00:17:21,000 --> 00:17:23,000
讓我放大在按鈕之間，有一個填充位

319
00:17:23,000 --> 00:17:25,000
之間的文本字段。

320
00:17:25,000 --> 00:17:27,000
>> 讓我暫時把它們關掉。

321
00:17:27,000 --> 00:17:30,000
讓我走我的CSS，並讓我繼續前進，只是

322
00:17:30,000 --> 00:17:34,000
改變這種保證金從5個像素為0像素。

323
00:17:34,000 --> 00:17:37,000
讓我走前面，然後保存文件，返回的搜索引擎

324
00:17:37,000 --> 00:17:40,000
並重新加載，並觀看頁面中間的。

325
00:17:40,000 --> 00:17:43,000
一切都壓縮在一起了，當我第一次鞭打這個例子

326
00:17:43,000 --> 00:17:46,000
我想，看起來愚蠢的文本字段，然後它下面的按鈕。

327
00:17:46,000 --> 00:17:50,000
我要墊那麼一點點的，所以我介紹的利潤。

328
00:17:50,000 --> 00:17:55,000
我們不會做的是通過在課堂上的幾十個

329
00:17:55,000 --> 00:17:58,000
CSS屬性存在，因為，有一些事情，如字體大小，

330
00:17:58,000 --> 00:18:02,000
字體粗細，保證金，文字對齊，和幾十個其他，

331
00:18:02,000 --> 00:18:06,000
和問題，我們將請您在7到各種在線教程

332
00:18:06,000 --> 00:18:08,000
和參考，讓您選擇這些東西。

333
00:18:08,000 --> 00:18:10,000
但什麼是真正重要的，在一天結束的時候

334
00:18:10,000 --> 00:18:12,000
>> 了解如何應用這些東西。

335
00:18:12,000 --> 00:18:15,000
同樣，如果我們有style標籤內的

336
00:18:15,000 --> 00:18:19,000
可以去選擇器的標識符指定

337
00:18:19,000 --> 00:18:21,000
向誰你想應用這些屬性，

338
00:18:21,000 --> 00:18:24,000
然後你把鍵值對的屬性

339
00:18:24,000 --> 00:18:28,000
由冒號分隔，然後用一個分號結束，

340
00:18:28,000 --> 00:18:32,000
或者您可以複製出來，並把它放在一個單獨的CSS文件

341
00:18:32,000 --> 00:18:35,000
你們自己。

342
00:18:35,000 --> 00:18:39,000
所有的權利，任何問題的概念

343
00:18:39,000 --> 00:18:41,000
或大圖片的CSS？

344
00:18:41,000 --> 00:18:43,000
你會再次看到更多的內容在pset中7，

345
00:18:43,000 --> 00:18:47,000
但我們會保持它通常是非常簡單的。

346
00:18:47,000 --> 00:18:49,000
不是嗎？好的。

347
00:18:49,000 --> 00:18:51,000
這是一個實際的編程語言，

348
00:18:51,000 --> 00:18:54,000
而我們再回過頭來一點點的CSS中的一個例子。

349
00:18:54,000 --> 00:18:58,000
PHP實際上是一個奇妙的易懂的語言

350
00:18:58,000 --> 00:19:02,000
在於它是語法上幾乎等同於下

351
00:19:02,000 --> 00:19:06,000
換句話說，如果你知道，你知道的大部分PHP，

352
00:19:06,000 --> 00:19:08,000
至少在語法上，即使有一些新的特點

353
00:19:08,000 --> 00:19:10,000
一些新的概念，我們將不得不看。

354
00:19:10,000 --> 00:19:13,000
>> 但在大多數情況下，現在我們從C過渡到PHP

355
00:19:13,000 --> 00:19:16,000
最新的東西，是真正的大畫面，

356
00:19:16,000 --> 00:19:19,000
如何程序在網絡上使用的語言，而不是

357
00:19:19,000 --> 00:19:23,000
在命令行或在閃爍提示，我們已經做了迄今為止。

358
00:19:23,000 --> 00:19:27,000
作為參考，特別是與pset的7和最終的項目開始，

359
00:19:27,000 --> 00:19:31,000
不利用這個URL，在這裡，如果你想讀的PHP手續。

360
00:19:31,000 --> 00:19:34,000
它實際上是喜歡一個免費的在線教材有效，

361
00:19:34,000 --> 00:19:37,000
你還會發現，什麼是真正好的關於PHP

362
00:19:37,000 --> 00:19:41,000
是有數百功能，用它來，

363
00:19:41,000 --> 00:19:44,000
而在C中，你並不一定有機會獲得

364
00:19:44,000 --> 00:19:47,000
更多的功能比的數學函數庫，的CS50庫。

365
00:19:47,000 --> 00:19:51,000
在PHP和大量的現代語言，Python和Ruby，其中，

366
00:19:51,000 --> 00:19:54,000
您可以訪問那麼多的功能，這意味著你寫

367
00:19:54,000 --> 00:19:57,000
少了很多的代碼，因為你可以站在別人的肩膀上

368
00:19:57,000 --> 00:19:59,000
已經寫了一些你的東西。

369
00:19:59,000 --> 00:20:03,000
>> 讓我們快速瀏覽PHP的語法，然後寫了幾個例子。

370
00:20:03,000 --> 00:20:06,000
什麼是好的關於PHP的第一個和最重要的

371
00:20:06,000 --> 00:20:08,000
有沒有沒有主函數。

372
00:20:08,000 --> 00:20:10,000
如果你想在PHP編寫一個程序，你剛開始寫代碼，

373
00:20:10,000 --> 00:20:12,000
你不必擔心主。

374
00:20:12,000 --> 00:20:14,000
有沒有詮釋。有沒有回報。

375
00:20:14,000 --> 00:20:17,000
有沒有ARGV ARGC，當你寫的程序。

376
00:20:17,000 --> 00:20:20,000
相反，您就可以開始編寫代碼，這是部分

377
00:20:20,000 --> 00:20:23,000
因為PHP是一種解釋型語言。

378
00:20:23,000 --> 00:20:26,000
C的編譯，它被編譯在這個意義上，你開始

379
00:20:26,000 --> 00:20:29,000
源代碼，運行它通過鐺，這是一個編譯器，

380
00:20:29,000 --> 00:20:33,000
並最終一些數量的步驟後，您可以在對象的代碼，0s和1s。

381
00:20:33,000 --> 00:20:36,000
PHP，Python和Ruby和珠江三角洲及其他

382
00:20:36,000 --> 00:20:39,000
不同類型的語言，你不要把它們編譯。

383
00:20:39,000 --> 00:20:42,000
你不要去從源代碼到0和1。

384
00:20:42,000 --> 00:20:45,000
您只需運行的源代碼，並且運行的源代碼

385
00:20:45,000 --> 00:20:49,000
寫在一個普通的文本文件，在這種情況下，PHP結束

386
00:20:49,000 --> 00:20:53,000
而不是C，該程序的功能在您的計算機上

387
00:20:53,000 --> 00:20:57,000
從字面上解釋是由一行行的代碼行。

388
00:20:57,000 --> 00:21:00,000
>> 換句話說，而不是寫一個程序並運行程序

389
00:21:00,000 --> 00:21:04,000
直接，你來寫一個程序，PHP結尾的文件。

390
00:21:04,000 --> 00:21:09,000
然後運行實際的程序中，名為php.exe的，如果你使用的是Windows，

391
00:21:09,000 --> 00:21:12,000
或只是PHP的，如果你在Mac OS或Linux，

392
00:21:12,000 --> 00:21:17,000
您提供的輸入到PHP程序自己的源代碼，

393
00:21:17,000 --> 00:21:20,000
在生活中，其目的是閱讀你的代碼從上到下，從左到右，

394
00:21:20,000 --> 00:21:23,000
，做任何你已經告訴它做的事。

395
00:21:23,000 --> 00:21:25,000
>> 讓我們來看看這是什麼將意味著語法。

396
00:21:25,000 --> 00:21:27,000
在PHP中，我們具備的條件。

397
00:21:27,000 --> 00:21:29,000
這張幻燈片是你所看到的，在第1週

398
00:21:29,000 --> 00:21:33,000
因為語法的條件下，如果和其他人如果和其他PHP

399
00:21:33,000 --> 00:21:35,000
看起來正是這樣。

400
00:21:35,000 --> 00:21:38,000
當布爾表達式他們要去看看正是這樣的。

401
00:21:38,000 --> 00:21:43,000
當涉及到安定為布爾值，它會完全一樣的東西放在一起。

402
00:21:43,000 --> 00:21:46,000
開關看起來是一樣的，你會得到額外的好處在PHP

403
00:21:46,000 --> 00:21:51,000
在C，交換機只能打開一個char或int。

404
00:21:51,000 --> 00:21:53,000
你可以打開一個字符串值。

405
00:21:53,000 --> 00:21:55,000
在PHP中，你其實可以有一個表達

406
00:21:55,000 --> 00:21:58,000
這是一個變量，其內容是一個字符串，

407
00:21:58,000 --> 00:22:01,000
實際上，你可以做字符串比較在現實直觀的方式，

408
00:22:01,000 --> 00:22:06,000
沒有指針的比較，以決定是否做的情況下，i或j或別的東西。

409
00:22:06,000 --> 00:22:09,000
不久，我們將看到潛在的。

410
00:22:09,000 --> 00:22:11,000
>> 循環過奇妙的是相同的。

411
00:22:11,000 --> 00:22:15,000
For循環的初始化，條件，和一定數量的更新。

412
00:22:15,000 --> 00:22:18,000
while循環，也存在於PHP。

413
00:22:18,000 --> 00:22:21,000
DO WHILE循環也存在於PHP，

414
00:22:21,000 --> 00:22:26,000
和數組存在於PHP，但這裡的語法開始有一點不同的地方，

415
00:22:26,000 --> 00:22:29,000
但其概念是相同的，和概念真的是相同的

416
00:22:29,000 --> 00:22:32,000
因為他們是在第0週與劃傷。

417
00:22:32,000 --> 00:22:34,000
首先是$符號。

418
00:22:34,000 --> 00:22:37,000
這是一個設計決定，PHP，任何變量

419
00:22:37,000 --> 00:22:41,000
在PHP的設計從$符號。

420
00:22:41,000 --> 00:22:46,000
有沒有更多的X，Y，Z $ X $ Y $ Z只是因為。

421
00:22:46,000 --> 00:22:49,000
這件事情要記住，現在的右手邊

422
00:22:49,000 --> 00:22:52,000
這看起來類似於數組，

423
00:22:52,000 --> 00:22:54,000
但我們在這裡使用方括號。

424
00:22:54,000 --> 00:22:57,000
在PHP和JavaScript，因為我們最終會看到，

425
00:22:57,000 --> 00:23:01,000
聲明一個數組，你做開括號和閉方括號，

426
00:23:01,000 --> 00:23:04,000
那麼你有一個逗號分隔的值列表，無論是int型

427
00:23:04,000 --> 00:23:09,000
或字符串或字符，你想要什麼，裡面的表達有。

428
00:23:09,000 --> 00:23:11,000
>> 現在，怎麼我們做這樣的事情在C？

429
00:23:11,000 --> 00:23:16,000
已知的數字靜態聲明一個數組的語法是什麼？

430
00:23:16,000 --> 00:23:19,000
這是大括號，這樣微小的差別，但在PHP

431
00:23:19,000 --> 00:23:22,000
並最終器的，它只是使用方括號，所以真的

432
00:23:22,000 --> 00:23:25,000
唯一有趣的細節是$符號的變量名

433
00:23:25,000 --> 00:23:28,000
方括號中，也有一個很奇怪的事情

434
00:23:28,000 --> 00:23:32,000
被省略的，以及在左邊的等號（=）。

435
00:23:32,000 --> 00:23:36,000
缺少了什麼，我們已經要求了好幾個星期呢？是啊。

436
00:23:36,000 --> 00:23:38,000
[聽不見的學生反應]

437
00:23:38,000 --> 00:23:41,000
的大小，所以這裡沒有提到的數組的大小。

438
00:23:41,000 --> 00:23:45,000
坦率地說，這裡沒有提到的方括號的左側

439
00:23:45,000 --> 00:23:47,000
等號（=），還有什麼缺少的行嗎？

440
00:23:47,000 --> 00:23:49,000
是啊。>> [聽不見的學生反應]

441
00:23:49,000 --> 00:23:52,000
的類型，有什麼有趣的，特別是關於PHP

442
00:23:52,000 --> 00:23:56,000
是，它是不是一個強類型語言，C是

443
00:23:56,000 --> 00:23:58,000
強類型的字符在這個意義上，你必須說，

444
00:23:58,000 --> 00:24:00,000
你必須說int，你必須說浮動。

445
00:24:00,000 --> 00:24:03,000
>> 任何時候你想要一個變量，其類型是什麼，你要告訴鐺。

446
00:24:03,000 --> 00:24:05,000
PHP是一個有點懶惰。

447
00:24:05,000 --> 00:24:08,000
在這個意義上它是鬆散類型的，

448
00:24:08,000 --> 00:24:11,000
你可以有花車和字符和字符串

449
00:24:11,000 --> 00:24:14,000
和整型等等，但語言本身

450
00:24:14,000 --> 00:24:17,000
並不真正關心什麼，你把裡面的變量。

451
00:24:17,000 --> 00:24:20,000
您沒有提前告知什麼樣的數據類型

452
00:24:20,000 --> 00:24:22,000
在變量中。

453
00:24:22,000 --> 00:24:24,000
這完全取決於你，所以這是很好的

454
00:24:24,000 --> 00:24:27,000
，你不必擔心，因為很多數據輸入

455
00:24:27,000 --> 00:24:29,000
和擔心你的論點是什麼，等等。

456
00:24:29,000 --> 00:24:32,000
這也意味著最終PHP中的函數能夠返回

457
00:24:32,000 --> 00:24:36,000
無論是一個int的時候，也許曾經在一段時間內

458
00:24:36,000 --> 00:24:40,000
例如，他們將返回一個布爾值，布爾值false，表示出事了。

459
00:24:40,000 --> 00:24:44,000
這給了我們一些不相上下，但它也將使我們的設計

460
00:24:44,000 --> 00:24:47,000
有點懶，當涉及到數據類型。

461
00:24:47,000 --> 00:24:50,000
>> 還有什麼在這裡要記住的？

462
00:24:50,000 --> 00:24:54,000
變量看起來很喜歡這一點，所以$ S =“你好，世界”。

463
00:24:54,000 --> 00:24:57,000
這也許能推理從前面的例子中，

464
00:24:57,000 --> 00:24:59,000
我們有另一種類型的循環。

465
00:24:59,000 --> 00:25:02,000
這一次，我們將真正看到曾經在一段時間內，因為它是非常方便的，

466
00:25:02,000 --> 00:25:04,000
foreach構造。

467
00:25:04,000 --> 00:25:11,000
在這種情況下，foreach循環需要其括號中的3個字的內側通常情況下，

468
00:25:11,000 --> 00:25:16,000
美元的東西，這是你想要什麼樣的陣列遍歷成員，

469
00:25:16,000 --> 00:25:19,000
然後字面上的關鍵字，然後最後，

470
00:25:19,000 --> 00:25:21,000
另一個變量的名稱，你可以選擇。

471
00:25:21,000 --> 00:25:23,000
它可以是富，酒吧，或元素，

472
00:25:23,000 --> 00:25:26,000
這是什麼結構並

473
00:25:26,000 --> 00:25:29,000
如果陣列包含10個元素

474
00:25:29,000 --> 00:25:34,000
在每次迭代這個數組對不起，這個循環在每次迭代

475
00:25:34,000 --> 00:25:37,000
變量稱為元素將被更新

476
00:25:37,000 --> 00:25:40,000
成為第一個數組中的元素，那麼第二個數組中的元素，

477
00:25:40,000 --> 00:25:44,000
然後第三個元素的數組，從而無需

478
00:25:44,000 --> 00:25:46,000
做的有點惱人的方括號和

479
00:25:46,000 --> 00:25:49,000
$我為了到一個數組中的索引。

480
00:25:49,000 --> 00:25:53,000
PHP做所有的工作，並在每次迭代

481
00:25:53,000 --> 00:25:55,000
只是手從數組中的下一個元素

482
00:25:55,000 --> 00:26:01,000
沒有你不必知道或關心它的數字索引位置。

483
00:26:01,000 --> 00:26:04,000
>> 最後，就目前而言，還有另外一個功能的PHP

484
00:26:04,000 --> 00:26:08,000
這將是巨大的，特別是當我們在網絡上開始編程，

485
00:26:08,000 --> 00:26:10,000
而這被稱為關聯數組。

486
00:26:10,000 --> 00:26:13,000
因此，我們知道的陣列為20秒前

487
00:26:13,000 --> 00:26:17,000
在過去8週的數字索引數組，

488
00:26:17,000 --> 00:26:20,000
傳統的陣列類型的指數是整數，

489
00:26:20,000 --> 00:26:23,000
0，1，2，所有的方式上升。

490
00:26:23,000 --> 00:26:25,000
關聯數組功能更強大。

491
00:26:25,000 --> 00:26:28,000
他們讓你有任意鍵，

492
00:26:28,000 --> 00:26:31,000
任意指數和任意值。

493
00:26:31,000 --> 00:26:34,000
而在傳統的陣列，它是0，1，2，

494
00:26:34,000 --> 00:26:37,000
在一個關聯數組，你可以有一個指數

495
00:26:37,000 --> 00:26:41,000
foo的一個關鍵，它的值是酒吧。

496
00:26:41,000 --> 00:26:46,000
然後，您可以有另外一個關鍵的名字是巴茲，其值QUX的。

497
00:26:46,000 --> 00:26:49,000
>> 同樣的，愚蠢的計算機科學通用的變量名，

498
00:26:49,000 --> 00:26:55,000
但問題是，這個數組沒有支架0或支架1。

499
00:26:55,000 --> 00:26:59,000
相反，它會，有支架foo和支架巴茲。

500
00:26:59,000 --> 00:27:03,000
這是一個很大的通用性，我們將能夠聯想到的

501
00:27:03,000 --> 00:27:07,000
與其他詞的話，完全任意鍵的值，

502
00:27:07,000 --> 00:27:12,000
我們將是能夠得到這些值在固定的時間

503
00:27:12,000 --> 00:27:14,000
因為引擎蓋下的一個關聯數組

504
00:27:14,000 --> 00:27:16,000
真的是一個哈希表。

505
00:27:16,000 --> 00:27:20,000
回想一下，一個哈希表，可以讓你把一些輸入

506
00:27:20,000 --> 00:27:25,000
喜歡把中的單詞大衛，如果你要插入到某種字典大衛，

507
00:27:25,000 --> 00:27:27,000
然後你會得到一定的價值一般。

508
00:27:27,000 --> 00:27:29,000
拼寫檢查的情況下，真或假。

509
00:27:29,000 --> 00:27:33,000
大衛的字在字典中沒有的。

510
00:27:33,000 --> 00:27:36,000
一個關聯數組，其實只是一個哈希表，

511
00:27:36,000 --> 00:27:38,000
但它是一個更加用戶友好的化身。

512
00:27:38,000 --> 00:27:41,000
正如我們將要看到的，這將允許我們做一些事情

513
00:27:41,000 --> 00:27:43,000
非常，非常容易。

514
00:27:43,000 --> 00:27:45,000
>> 讓我們來看看一些基本的PHP

515
00:27:45,000 --> 00:27:47,000
例子，看看我們能做些什麼這門語言。

516
00:27:47,000 --> 00:27:51,000
讓我去進取，不斷開拓今天在我們的源代碼目錄

517
00:27:51,000 --> 00:27:54,000
一個名為hello1.php。

518
00:27:54,000 --> 00:27:57,000
這個文件是更多的評論比它實際的代碼，

519
00:27:57,000 --> 00:28:00,000
因此，讓我真正從文件中刪除所有的評論

520
00:28:00,000 --> 00:28:05,000
和現在的你也許是最簡單的PHP程序在這裡。

521
00:28:05,000 --> 00:28:07,000
5條線，並且其中一些是白色的空間，

522
00:28:07,000 --> 00:28:09,000
所以在這裡發現一些關鍵的差別。

523
00:28:09,000 --> 00:28:12,000
該文件稱為hello1.php。

524
00:28:12,000 --> 00:28:16,000
不過，第一行，<？PHP。

525
00:28:16,000 --> 00:28:18,000
類似的精神，HTML，

526
00:28:18,000 --> 00:28:21,000
該序列的字符告訴計算機

527
00:28:21,000 --> 00:28:25,000
“嘿，計算機，來我們在PHP程序。”

528
00:28:25,000 --> 00:28:28,000
它可以確保它不會混淆，它的一些其他語言。

529
00:28:28,000 --> 00:28:30,000
2號線是一個有趣的空白。

530
00:28:30,000 --> 00:28:32,000
printf的第3行是我們的老朋友，

531
00:28:32,000 --> 00:28:34,000
這時候在PHP的背景下。

532
00:28:34,000 --> 00:28:37,000
PHP有它自己的版本的printf的行為完全一樣的，

533
00:28:37,000 --> 00:28:39,000
因此，這只是要打印“你好，世界”。

534
00:28:39,000 --> 00:28:46,000
然後此相反的標記在這裡，>，這意味著這是我的PHP代碼。

535
00:28:46,000 --> 00:28:48,000
>> 讓我們來看看如何運行。

536
00:28:48,000 --> 00:28:50,000
我要回到我的終端窗口。

537
00:28:50,000 --> 00:28:52,000
我要進入我的PHP目錄。

538
00:28:52,000 --> 00:28:56,000
請注意，我們有一大堆的文件，其中第一個是hello.php的。

539
00:28:56,000 --> 00:29:01,000
讓我繼續運行，hello1.php，進入。

540
00:29:01,000 --> 00:29:03,000
權限被拒絕。好吧。

541
00:29:03,000 --> 00:29:06,000
我們是如何固定的像這樣的事情在過去的？

542
00:29:06,000 --> 00:29:08,000
那是什麼？>> [聽不見的學生反應]

543
00:29:08,000 --> 00:29:11,000
我們需要讀取和寫入，但讓我做的ls-l。

544
00:29:11,000 --> 00:29:14,000
記住這個有點神秘的輸出，此處為Hello1

545
00:29:14,000 --> 00:29:17,000
似乎是可讀和可寫的我

546
00:29:17,000 --> 00:29:19,000
但其他人可讀的。

547
00:29:19,000 --> 00:29:22,000
事實證明，這實際上是不正確的方向前進的一個步驟。

548
00:29:22,000 --> 00:29:25,000
一種解釋型語言差異，再次與

549
00:29:25,000 --> 00:29:27,000
你不要直接運行程序。

550
00:29:27,000 --> 00:29:30,000
你，而不是一個翻譯，把它的代碼

551
00:29:30,000 --> 00:29:33,000
你寫的，所以它可以解釋一行行。

552
00:29:33,000 --> 00:29:36,000
在這種情況下，解釋器或程序，其實我是想運行

553
00:29:36,000 --> 00:29:38,000
是真正的PHP。

554
00:29:38,000 --> 00:29:41,000
>> 這個設備的硬盤驅動器上的某個地方有一個程序

555
00:29:41,000 --> 00:29:45,000
別人寫PHP，或在Windows下的php.exe。

556
00:29:45,000 --> 00:29:48,000
我要在這裡做什麼是我要實際運行PHP

557
00:29:48,000 --> 00:29:51,000
但將它作為命令行參數，我寫的代碼，

558
00:29:51,000 --> 00:29:54,000
，然後我會放大並按下回車鍵。

559
00:29:54,000 --> 00:29:58,000
對我來說，它運行我的程序，從上到下，從左到右。

560
00:29:58,000 --> 00:30:01,000
讓我去進取，不斷開拓一個略有差異。

561
00:30:01,000 --> 00:30:05,000
在hello2.php通知，這太

562
00:30:05,000 --> 00:30:08,000
主要是註釋，所以讓我擺脫這些作為一種消遣，

563
00:30:08,000 --> 00:30:13,000
什麼明顯的不同有關此文件嗎？

564
00:30:13,000 --> 00:30:15,000
這種新的生產線，在頂部略帶神秘的。

565
00:30:15,000 --> 00:30:20,000
在第1行是＃！/ bin中/ PHP。

566
00:30:20,000 --> 00:30:24,000
斌是一個約定，Linux和Mac OS二進制文件，

567
00:30:24,000 --> 00:30:27,000
/ bin中表示這是一個文件夾，其中包含了一堆二進制文件

568
00:30:27,000 --> 00:30:29,000
被編程的，其中之一是PHP。

569
00:30:29,000 --> 00:30:32,000
＃！綽號家當，

570
00:30:32,000 --> 00:30:35,000
這是說，它的快捷方式，這是什麼意思

571
00:30:35,000 --> 00:30:40,000
是，當你運行這個程序，現在有一個提示，在該文件的頂部

572
00:30:40,000 --> 00:30:44,000
告訴計算機使用什麼樣的解釋。

573
00:30:44,000 --> 00:30:47,000
>> 它變得有點討厭，如果你要告訴你的用戶和您​​的客戶

574
00:30:47,000 --> 00:30:50,000
“嘿，我們寫了這的程序稱為hello1.php。”

575
00:30:50,000 --> 00:30:54,000
所有你所要做的是永遠運行PHP，然後這個程序的名稱。

576
00:30:54,000 --> 00:30:58,000
坦率地說，它只是更好的運行hello1.php，

577
00:30:58,000 --> 00:31:00,000
而事實上，我們可以的，如果我們做以下。

578
00:31:00,000 --> 00:31:05,000
讓我繼續做ls-l的通知hello2它仍然只是讀寫

579
00:31:05,000 --> 00:31:10,000
，然後看了看了，所以我也還沒有做到這一點，hello2.php。

580
00:31:10,000 --> 00:31:15,000
但是，我們推出了這款非常簡要地最後一次，chmod命令。

581
00:31:15,000 --> 00:31:20,000
如果我不改變存取權限chmod a + x，這意味著所有的加可執行，

582
00:31:20,000 --> 00:31:26,000
然後hello2.php，然後執行ls-l的再次注意到有什麼改變。

583
00:31:26,000 --> 00:31:29,000
一，Linux是顯示我的文件名綠色傳達的理念

584
00:31:29,000 --> 00:31:32,000
，它的可執行文件，但更重要的是，在左手側

585
00:31:32,000 --> 00:31:36,000
注意到位代表x為可執行文件現在已經被設置。

586
00:31:36,000 --> 00:31:42,000
這意味著現在是我可以運行./hello2.php的像往常一樣，

587
00:31:42,000 --> 00:31:45,000
點擊進入，因為在最高層的文件的家當

588
00:31:45,000 --> 00:31:48,000
這是一個提示，再次，Linux的說

589
00:31:48,000 --> 00:31:51,000
使用這個解釋器來運行這個文件。

590
00:31:51,000 --> 00:31:54,000
不要擔心迫使用戶輸入。

591
00:31:54,000 --> 00:31:57,000
>> 什麼是好的，現在是它的一種不相關的我的客戶還是我的朋友

592
00:31:57,000 --> 00:32:01,000
什麼語言，我寫了這個程序，這樣我就可以繼續使用mv

593
00:32:01,000 --> 00:32:04,000
hello2，例如重命名這件事情。

594
00:32:04,000 --> 00:32:07,000
現在，如果我做./hello2

595
00:32:07,000 --> 00:32:10,000
放大了我的程序繼續運行。

596
00:32:10,000 --> 00:32:13,000
這些文件的擴展名是一個人的約定，這是必要的

597
00:32:13,000 --> 00:32:15,000
為類似鐺，尋找他們的。

598
00:32:15,000 --> 00:32:18,000
但對於PHP，我可以打電話給這個文件擴展名我想要的任何東西。

599
00:32:18,000 --> 00:32:22,000
我想，我真的很不錯，在紅寶石欺騙世界，

600
00:32:22,000 --> 00:32:25,000
我可以寫hello2.rb，然後運行它，

601
00:32:25,000 --> 00:32:28,000
瞧，現在我的Ruby版本，這是一個徹頭徹尾的謊言。

602
00:32:28,000 --> 00:32:30,000
但是，文件擴展名是沒有意義的

603
00:32:30,000 --> 00:32:35,000
如果該文件是可執行文件，並在該文件的頂部，有這樣的特別提示。

604
00:32:35,000 --> 00:32:38,000
>> 現在，順便說一句，讓我告訴你很快第3版，

605
00:32:38,000 --> 00:32:40,000
這是一個有用的技巧，知道排序。

606
00:32:40,000 --> 00:32:45,000
，在hello3我做了一些錯誤

607
00:32:45,000 --> 00:32:47,000
我會在線更新的源代碼。

608
00:32:47,000 --> 00:32:50,000
在第3版事實證明，在大多數的Linux電腦

609
00:32:50,000 --> 00:32:53,000
有一個程序叫環境對環境，

610
00:32:53,000 --> 00:32:56,000
你可以在這裡做的是，如果你不知道PHP

611
00:32:56,000 --> 00:33:00,000
安裝在本地硬盤驅動器，因為它的確可以在電腦上根據

612
00:33:00,000 --> 00:33:03,000
有人正在使用，ENV只是說運行環境，

613
00:33:03,000 --> 00:33:07,000
這是在大多數系統上，並找出其中PHP是。

614
00:33:07,000 --> 00:33:11,000
只是一個普通的伎倆，以便找出其中一個方案是，你不必擔心。

615
00:33:11,000 --> 00:33:14,000
但是，如果你做護理，找出程序是，你不關心迄今

616
00:33:14,000 --> 00:33:16,000
你可以使用命令。

617
00:33:16,000 --> 00:33:19,000
>> 讓我放大和類型，也就是PHP，

618
00:33:19,000 --> 00:33:23,000
並注意到它告訴我，它實際上是在usr / bin中/ PHP。

619
00:33:23,000 --> 00:33:25,000
這是一個謊言。這也是在垃圾桶。

620
00:33:25,000 --> 00:33:27,000
這只是我的第一擊。

621
00:33:27,000 --> 00:33:31,000
如果你想知道在Clang的是，這，這是在usr / bin中/鐺鐺，

622
00:33:31,000 --> 00:33:34,000
使usr / bin中/，而這一切是什麼意思

623
00:33:34,000 --> 00:33:38,000
你可能會被輸入usr / bin中/鐺鐺進入運行，

624
00:33:38,000 --> 00:33:41,000
但它是一種單調乏味的做到這一點，所以一些文件夾

625
00:33:41,000 --> 00:33:44,000
像usr / bin和垃圾桶都被假定為默認值

626
00:33:44,000 --> 00:33:50,000
這樣，計算機就知道給你看。

627
00:33:50,000 --> 00:33:53,000
寫一個超級，超級簡單的Hello World程序的任何問題

628
00:33:53,000 --> 00:33:55,000
在PHP中，然後運行它呢？

629
00:33:55,000 --> 00:33:59,000
因為現在我們將開始推出更具吸引力的語法。

630
00:33:59,000 --> 00:34:01,000
好吧，我們開始吧。

631
00:34:01,000 --> 00:34:03,000
這些計劃中，我們實際上已經看到了，所有的人前。

632
00:34:03,000 --> 00:34:07,000
>> 如果我打開了，例如，讓我們做beer1.php，

633
00:34:07,000 --> 00:34:09,000
我們不會去通過幾個版本的，但我做了什麼

634
00:34:09,000 --> 00:34:13,000
我坐了下來澆或轉換

635
00:34:13,000 --> 00:34:15,000
我的C代碼PHP代碼。

636
00:34:15,000 --> 00:34:18,000
大部分的頂部的文件是留下在這裡。

637
00:34:18,000 --> 00:34:20,000
原來，有一個新的功能，我們需要調用的ReadLine。

638
00:34:20,000 --> 00:34:23,000
GetString的，回想一下，從0週開始，一個CS50事情。

639
00:34:23,000 --> 00:34:27,000
PHP中有其自己的用戶友好的功能的ReadLine

640
00:34:27,000 --> 00:34:30,000
需要1個參數，該參數指定的提示

641
00:34:30,000 --> 00:34:33,000
要顯示給用戶，和什麼的readline

642
00:34:33,000 --> 00:34:35,000
它返回任何用戶鍵入的

643
00:34:35,000 --> 00:34:39,000
在這種情況下，我聲明了一個變量名為$ N。

644
00:34:39,000 --> 00:34:42,000
我存儲在它的返回值的ReadLine

645
00:34:42,000 --> 00:34:44,000
後提示用戶使用此字符串。

646
00:34:44,000 --> 00:34:47,000
只要備份，以實際運行這件事情，讓我繼續前進

647
00:34:47,000 --> 00:34:50,000
並運行php beer1.php。

648
00:34:50,000 --> 00:34:53,000
會有多少瓶？讓我們只是做這一次。

649
00:34:53,000 --> 00:34:55,000
輸入。這就是全部。

650
00:34:55,000 --> 00:34:59,000
>> 從數週前的C版本的程序在功能上是相同的。

651
00:34:59,000 --> 00:35:01,000
但語法讓我們來看看有什麼不同。

652
00:35:01,000 --> 00:35:05,000
之後，我得到一個int從用戶的通知，我做了一些錯誤檢查，

653
00:35:05,000 --> 00:35:08,000
如果n小於1，我退出，我打印出來

654
00:35:08,000 --> 00:35:11,000
一個遺憾的消息給用戶，並在退出時1。

655
00:35:11,000 --> 00:35:13,000
這也是有一點不同。

656
00:35:13,000 --> 00:35:16,000
 在C語言中我們做了什麼？在C語言中，我們返回1。

657
00:35:16,000 --> 00:35:20,000
在PHP中退出，1，坦率地說，我認為一個更直觀一點

658
00:35:20,000 --> 00:35:22,000
因為你從字面上退出程序。

659
00:35:22,000 --> 00:35:25,000
好吧，然後在這裡討厭的歌曲是相同的語法

660
00:35:25,000 --> 00:35:29,000
除了變量，這樣下來在這裡24日起

661
00:35:29,000 --> 00:35:31,000
注意到我的for循環幾乎是相同的，

662
00:35:31,000 --> 00:35:34,000
但我在前面的i和n，

663
00:35:34,000 --> 00:35:37,000
什麼也缺少從第26行，我們已經在過去

664
00:35:37,000 --> 00:35:39,000
聲明變量時我嗎？

665
00:35:39,000 --> 00:35:41,000
有沒有類型。

666
00:35:41,000 --> 00:35:43,000
這是不正確的PHP說詮釋。

667
00:35:43,000 --> 00:35:45,000
你根本不需要做到這一點。

668
00:35:45,000 --> 00:35:48,000
計算機，解釋PHP是明智地意識到

669
00:35:48,000 --> 00:35:51,000
如果你把一些在我會把它

670
00:35:51,000 --> 00:35:53,000
你的號。

671
00:35:53,000 --> 00:35:57,000
再往下這裡我們插在我，我，我 -  1。

672
00:35:57,000 --> 00:36:00,000
所有這一切都是一樣的，然後在這裡做了一個“哇，這是惱人的”printf

673
00:36:00,000 --> 00:36:02,000
然後退出（0）。

674
00:36:02,000 --> 00:36:05,000
>> 同樣，這裡的外賣是，即使我們要花費比較

675
00:36:05,000 --> 00:36:09,000
PHP的一點時間，肯定對我們所做的對C，

676
00:36:09,000 --> 00:36:12,000
這幾乎是一樣的，所以我們要做的今天和下週

677
00:36:12,000 --> 00:36:14,000
超越是真正關注一些新的想法。

678
00:36:14,000 --> 00:36:17,000
剛才看到另一件事情並翻譯從C，

679
00:36:17,000 --> 00:36:20,000
這是一個超級簡單的程序，我們在第1週

680
00:36:20,000 --> 00:36:22,000
或2的立方的值。

681
00:36:22,000 --> 00:36:25,000
但是，什麼是這個程序的時間大約是有趣的，它

682
00:36:25,000 --> 00:36:28,000
介紹了一個自定義的函數的概念，我們自己寫的。

683
00:36:28,000 --> 00:36:31,000
PHP中的語法幾乎是相同的。

684
00:36:31,000 --> 00:36:33,000
下面是我的程序往上頂。

685
00:36:33,000 --> 00:36:35,000
請再次缺席是主任何概念。

686
00:36:35,000 --> 00:36:39,000
我開始編寫代碼，這是要被執行的解釋。

687
00:36:39,000 --> 00:36:42,000
我打印出x為2，據推測。

688
00:36:42,000 --> 00:36:44,000
然後，我要求刺...

689
00:36:44,000 --> 00:36:47,000
然後，我所說的多維數據集函數，並通過在$ X

690
00:36:47,000 --> 00:36:50,000
的返回值分配給$ x。

691
00:36:50,000 --> 00:36:53,000
然後，我要求它的立方，然後我這樣說，它希望

692
00:36:53,000 --> 00:36:55,000
會說x是8。

693
00:36:55,000 --> 00:36:59,000
PHP中的函數的語​​法是以往任何時候都略有不同。

694
00:36:59,000 --> 00:37:01,000
再次失踪的返回類型。

695
00:37:01,000 --> 00:37:05,000
再次失踪的返回類型，還缺少什麼其他類型嗎？

696
00:37:05,000 --> 00:37:07,000
[聽不見的學生反應]

697
00:37:07,000 --> 00:37:10,000
好吧，好吧，這是很好的。讓我們回到在第二。

698
00:37:10,000 --> 00:37:12,000
>> 我們不具備的，例如int在這裡。

699
00:37:12,000 --> 00:37:15,000
例如，我們不有int，又因為在這裡，在PHP

700
00:37:15,000 --> 00:37:18,000
你根本就沒有必要，不應該這樣做，

701
00:37:18,000 --> 00:37:20,000
而是有一個新的關鍵字調用的函數。

702
00:37:20,000 --> 00:37:23,000
在PHP中，它幾乎是一個更清楚一點，因為當你想要一個函數

703
00:37:23,000 --> 00:37:26,000
你從字面上說功能時，你給它一個名字，然後以逗號分隔的列表

704
00:37:26,000 --> 00:37:28,000
如果它的任何參數。

705
00:37:28,000 --> 00:37:32,000
不用說無效或類似的東西，然後返回是一樣的，

706
00:37:32,000 --> 00:37:35,000
$ * $ * $。

707
00:37:35,000 --> 00:37:38,000
什麼也沒有？森指出這一點在這裡。

708
00:37:38,000 --> 00:37:43,000
在完全沒有在PHP文件的頂部是一個原型。

709
00:37:43,000 --> 00:37:45,000
這也是設計。

710
00:37:45,000 --> 00:37:48,000
PHP等語言和口譯更聰明比C是

711
00:37:48,000 --> 00:37:50,000
像鏗鏘的編譯器。

712
00:37:50,000 --> 00:37:53,000
>> 回想一下，鐺，如果你不告訴它的立方體存在，

713
00:37:53,000 --> 00:37:56,000
如果你不告訴它輸出的原型存在

714
00:37:56,000 --> 00:38:00,000
或使用的＃include，好了，這是要罵你的，而不是編譯你的代碼。

715
00:38:00,000 --> 00:38:03,000
PHP和更現代的語言有很多聰明的，當它涉及到這一點。

716
00:38:03,000 --> 00:38:07,000
他們將承擔起自己閱讀你的代碼

717
00:38:07,000 --> 00:38:11,000
然後罵你的，只有當它發現立方體無處。

718
00:38:11,000 --> 00:38:15,000
它並不重要，如果立方體是在底部或頂部，​​或什至在一些單獨的文件中。

719
00:38:15,000 --> 00:38:18,000
PHP和類似的語言足夠聰明，現在，放眼未來

720
00:38:18,000 --> 00:38:26,000
在之前的所有字句認為你犯了一個錯誤。

721
00:38:26,000 --> 00:38:28,000
在什麼地方離開我們嗎？

722
00:38:28,000 --> 00:38:32,000
>> 讓我們做最後一個例子，這裡的條件下，

723
00:38:32,000 --> 00:38:35,000
如果我打開了conditions2.php通知

724
00:38:35,000 --> 00:38:37,000
語法在這裡幾乎是相同的。

725
00:38:37,000 --> 00:38:40,000
我使用readline，而不是GetString的，但該行是一樣的，

726
00:38:40,000 --> 00:38:42,000
“我想請一個整數。”

727
00:38:42,000 --> 00:38:45,000
然後，我有一個if條件，否則的話，然後一個else，

728
00:38:45,000 --> 00:38:48,000
但在功能上，這個程序也是相同的，我們所做的幾個星期前，

729
00:38:48,000 --> 00:38:51,000
所以，如果我遇到這件事情，php的conditions2，

730
00:38:51,000 --> 00:38:54,000
我給它一些像23  - 

731
00:38:54,000 --> 00:38:57,000
我選了個正數。如果我給它-1我挑了負數。

732
00:38:57,000 --> 00:39:00,000
如果我給它0我確實拿起0。

733
00:39:00,000 --> 00:39:02,000
那麼，誰在乎這一切嗎？

734
00:39:02,000 --> 00:39:06,000
好了，其中一個在這裡練習的樂趣排序

735
00:39:06,000 --> 00:39:10,000
至少對我來說是回去看看的速度有多快，我可以實現的pset 5，

736
00:39:10,000 --> 00:39:12,000
拼寫錯誤pset中。

737
00:39:12,000 --> 00:39:15,000
回想一下，有這稱為speller.c的文件，

738
00:39:15,000 --> 00:39:17,000
有一個名為dictionary.c。

739
00:39:17,000 --> 00:39:20,000
我所做的是我種的花了幾分鐘，我的C代碼轉換

740
00:39:20,000 --> 00:39:23,000
PHP代碼，我們不會花太多時間在拼寫檢查

741
00:39:23,000 --> 00:39:26,000
因為就像在pset中，你也沒有真正需要

742
00:39:26,000 --> 00:39:29,000
拼寫檢查器本身上花太多的時間，因為你的注意力都集中在詞典。

743
00:39:29,000 --> 00:39:32,000
>> 我只想說，如果你讀通過的拼寫，

744
00:39:32,000 --> 00:39:35,000
這個文件在這裡，這幾乎是等價的C代碼

745
00:39:35,000 --> 00:39:37,000
我們給你的pset 5。

746
00:39:37,000 --> 00:39:39,000
我只是增加了一些的地方。

747
00:39:39,000 --> 00:39:43,000
我已經改變了某些函數名，如果他們不存在於PHP。

748
00:39:43,000 --> 00:39:45,000
這裡還有一個額外的東西，preg_match，

749
00:39:45,000 --> 00:39:48,000
這是一個小票友的做事方式，但我們會回來的，最終。

750
00:39:48,000 --> 00:39:51,000
但在短期，拼寫檢查器是幾乎相同的，如果你看的最下方

751
00:39:51,000 --> 00:39:54,000
它最終吐出的是，在這裡，

752
00:39:54,000 --> 00:39:57,000
拼寫錯誤的詞，詞語的詞典，詞彙文本。

753
00:39:57,000 --> 00:40:00,000
好了，現在有什麼有趣的是下面的。

754
00:40:00,000 --> 00:40:05,000
在我的文件頂部的，我要求dictionary.php。

755
00:40:05,000 --> 00:40:09,000
正如C＃PHP有一個特殊的函數調用需要

756
00:40:09,000 --> 00:40:14,000
這幾乎做同樣的事情，需要一個名為dictionary.php。

757
00:40:14,000 --> 00:40:18,000
我該如何去實施的pset 5？

758
00:40:18,000 --> 00:40:21,000
讓我繼續前進，在這裡打開了一個文件。

759
00:40:21,000 --> 00:40:24,000
讓我在這裡需要一點參考。

760
00:40:24,000 --> 00:40:29,000
讓我創建一個新的文件，並開始調用此dictionary.php。

761
00:40:29,000 --> 00:40:31,000
讓我把它放在另一個文件夾，所以我們可以做這個活。

762
00:40:31,000 --> 00:40:33,000
我現在就放大。

763
00:40:33,000 --> 00:40:37,000
我要開始我的PHP文件，開放式支架PHP關閉支架。

764
00:40:37,000 --> 00:40:40,000
然後在這裡有幾個功能，我需要實現的pset 5，

765
00:40:40,000 --> 00:40:42,000
所以讓我開始實施其中的一些，

766
00:40:42,000 --> 00:40:47,000
功能檢查，其中有一個字作為參數。

767
00:40:47,000 --> 00:40:49,000
我們將做到這一點，它在某一時刻回來。

768
00:40:49,000 --> 00:40:53,000
>> 函數作為參數，負載了什麼？

769
00:40:53,000 --> 00:40:56,000
字典，所以，我其實是想加載的文件。

770
00:40:56,000 --> 00:41:00,000
有功能的大小，但不帶任何參數

771
00:41:00,000 --> 00:41:04,000
有功能是什麼其他的嗎？

772
00:41:04,000 --> 00:41:06,000
卸載，不帶任何參數。

773
00:41:06,000 --> 00:41:10,000
這是4，我需要的功能，現在在PHP中實現，

774
00:41:10,000 --> 00:41:13,000
我什麼都做的是繼續這樣做。

775
00:41:13,000 --> 00:41:16,000
很多你使用一個哈希表中的pset 5，

776
00:41:16,000 --> 00:41:21,000
所以，讓我繼續前進，在PHP中創建一個哈希表。

777
00:41:21,000 --> 00:41:23,000
完成。

778
00:41:23,000 --> 00:41:25,000
這給了我一個哈希表。好了，為什麼呢？

779
00:41:25,000 --> 00:41:30,000
一，變量名為$表，只是想起了一個哈希表的想法。

780
00:41:30,000 --> 00:41:34,000
不過，方括號，記得，代表什麼？

781
00:41:34,000 --> 00:41:37,000
一個數組，但是在PHP數組不具有數字索引。

782
00:41:37,000 --> 00:41:41,000
它們也可以是關聯數組，

783
00:41:41,000 --> 00:41:44,000
這意味著你可以有任意鍵和值。

784
00:41:44,000 --> 00:41:49,000
>> 就像在pset的，那些你誰做到了哈希表的實現

785
00:41:49,000 --> 00:41:53,000
你可能插入的字，然後將其插入鍊錶鏈，

786
00:41:53,000 --> 00:41:56,000
或者你存儲的價值，真正的某個地方或東西的效果。

787
00:41:56,000 --> 00:41:59,000
你莫名其妙地想起了事實，這個詞是有。

788
00:41:59,000 --> 00:42:01,000
就目前而言，那將是我的哈希表，

789
00:42:01,000 --> 00:42:06,000
所以現在去實施檢查功能，

790
00:42:06,000 --> 00:42:09,000
我只需要看看裡面的那個哈希表

791
00:42:09,000 --> 00:42:11,000
如果有一個字是有。

792
00:42:11,000 --> 00:42:15,000
我要的是我說的話，

793
00:42:15,000 --> 00:42:20,000
讓我們使用isset，這是一個PHP函數，從字面上的意思只是說是關鍵的設置，

794
00:42:20,000 --> 00:42:24,000
所以使用isset（$ [$字]

795
00:42:24,000 --> 00:42:29,000
如果是的話返回true。

796
00:42:29,000 --> 00:42:32,000
就是這樣。這是pset的PHP 5中。

797
00:42:32,000 --> 00:42:34,000
那麼，在公平，好吧。

798
00:42:34,000 --> 00:42:37,000
否則返回false，所以它不存在。

799
00:42:37,000 --> 00:42:39,000
到底發生了什麼嗎？

800
00:42:39,000 --> 00:42:42,000
好了，如果表或哈希表一般

801
00:42:42,000 --> 00:42:46,000
是一個關聯數組，這意味著你可以索引

802
00:42:46,000 --> 00:42:50,000
用一個詞像“字，”你要回去一定的價值。

803
00:42:50,000 --> 00:42:52,000
>> 我們是種讓自己領先一步。

804
00:42:52,000 --> 00:42:56,000
這將是一種不錯的，如果我們實際加載的文件的第一個，

805
00:42:56,000 --> 00:42:58,000
所以負載是不是很簡單，但讓我繼續前進，掀起

806
00:42:58,000 --> 00:43:00,000
 一個真正快速實現負載。

807
00:43:00,000 --> 00:43:07,000
讓我繼續前進，說的話獲取文件字典。

808
00:43:07,000 --> 00:43:10,000
在PHP中打開一個文件，該文件的功能

809
00:43:10,000 --> 00:43:12,000
並返回給你一個數組在該文件中的所有的話，

810
00:43:12,000 --> 00:43:14,000
只是手給你。

811
00:43:14,000 --> 00:43:16,000
這是一個很大的痛苦，不是嗎？

812
00:43:16,000 --> 00:43:21,000
現在的foreach，這是我們的新的結構時，foreach（$美元的字的話）。

813
00:43:21,000 --> 00:43:25,000
要開始這個循環遍歷數組的話

814
00:43:25,000 --> 00:43:30,000
並分配給變量$字在文件中的每個字

815
00:43:30,000 --> 00:43:32,000
從第一到第二至第三到第四的所有方式

816
00:43:32,000 --> 00:43:35,000
所以我沒有做惱人的[]符號等。

817
00:43:35,000 --> 00:43:38,000
我簡單地做了這些字

818
00:43:38,000 --> 00:43:43,000
是我的表，它存儲在索引到表

819
00:43:43,000 --> 00:43:47,000
，然後做真實的，因為要記住

820
00:43:47,000 --> 00:43:50,000
一個字是在我的字典裡，所有我真正要做的

821
00:43:50,000 --> 00:43:55,000
種翻轉了一下，說這個詞在我的哈希表是存在的，真實的。

822
00:43:55,000 --> 00:43:58,000
如果它不存在，我沒有明確地把假，

823
00:43:58,000 --> 00:44:01,000
否則，在宇宙中所有可能的話，我不得不把假。

824
00:44:01,000 --> 00:44:05,000
>> 總之，對我來說只是設置了索引值

825
00:44:05,000 --> 00:44:09,000
如果有一個字實際上是在我的哈希表。

826
00:44:09,000 --> 00:44:12,000
現在，我切割的角落，在這裡，我要揮揮手，現在，

827
00:44:12,000 --> 00:44:15,000
但現在負載的功能就完成了。

828
00:44:15,000 --> 00:44:18,000
我到一個數組中，從文件中加載所有的話。

829
00:44:18,000 --> 00:44:21,000
我遍歷超過該陣列，陣列中的每個單詞

830
00:44:21,000 --> 00:44:24,000
我將它插入我的哈希表的一行代碼。

831
00:44:24,000 --> 00:44:26,000
這很有趣。你知道我們現在可以實現規模嗎？

832
00:44:26,000 --> 00:44:28,000
，大小總是很容易的，公平的。

833
00:44:28,000 --> 00:44:32,000
在這裡，我們就可以返回計數表。

834
00:44:32,000 --> 00:44:34,000
這是很容易的事情，數一數，在表中。

835
00:44:34,000 --> 00:44:36,000
這實際上是一種不是最有效的。

836
00:44:36,000 --> 00:44:39,000
我也許應該有一個變量的大小，因此，我們可以做到這一點

837
00:44:39,000 --> 00:44:41,000
在固定的時間，但是這是很容易的。

838
00:44:41,000 --> 00:44:45,000
哦，然後卸載，如果我們真正想要的是肛門

839
00:44:45,000 --> 00:44:47,000
我們可以說，這就是你如何卸載的東西。

840
00:44:47,000 --> 00:44:49,000
你剛才設置的變量等於一個空數組，

841
00:44:49,000 --> 00:44:51,000
和擺脫一切有。

842
00:44:51,000 --> 00:44:53,000
無需撥打免費。

843
00:44:53,000 --> 00:44:56,000
>> 同樣，我已經削減了一些角落，和我道歉分配問題集

844
00:44:56,000 --> 00:45:00,000
也許在C，但如果我們現在去繼續運行，

845
00:45:00,000 --> 00:45:02,000
我要以實際運行的版本，我寫了提前

846
00:45:02,000 --> 00:45:05,000
只是讓我沒有做任何任何語法錯誤。

847
00:45:05,000 --> 00:45:08,000
讓我繼續運行拼寫檢查器。的使用是相同的。

848
00:45:08,000 --> 00:45:12,000
這是一本字典文件，該文件只包含單詞富。

849
00:45:12,000 --> 00:45:15,000
這裡是一個文本文件，其中只包含foo的酒吧。

850
00:45:15,000 --> 00:45:19,000
讓我們這一點，所以拼寫檢查拼寫檢查，使用這本字典文件，這個文本文件。

851
00:45:19,000 --> 00:45:21,000
有拼寫錯誤的單詞，酒吧，和瞧。

852
00:45:21,000 --> 00:45:23,000
完成的pset 5。

853
00:45:23,000 --> 00:45:30,000
在這裡，讓我們有5分鐘的休息時間，我們會回來更多的PHP。

854
00:45:30,000 --> 00:45:32,000
好了，我們又回來了。

855
00:45:32,000 --> 00:45:34,000
讓我們不恨我了一會兒。

856
00:45:34,000 --> 00:45:37,000
現在讓我們來看看這是不是一個積極的

857
00:45:37,000 --> 00:45:39,000
這件事在實際執行PHP。

858
00:45:39,000 --> 00:45:43,000
當然，它花了45秒來實現。

859
00:45:43,000 --> 00:45:45,000
>> 但是，讓我們繼續和運行的東西。

860
00:45:45,000 --> 00:45:49,000
讓我繼續運行的C版本

861
00:45:49,000 --> 00:45:52,000
拼寫檢查，和我們將上運行它的一個最大的文件，

862
00:45:52,000 --> 00:45:54,000
這是國王詹姆斯聖經。

863
00:45:54,000 --> 00:45:57,000
這裡是在讓我們進入我們的C文件夾，

864
00:45:57,000 --> 00:46:01,000
國王詹姆斯第5的拼寫上。

865
00:46:01,000 --> 00:46:03,000
很多拼寫錯誤的單詞。

866
00:46:03,000 --> 00:46:06,000
好的，那麼你很可能得了即使有一點不同的輸出，

867
00:46:06,000 --> 00:46:09,000
如果你把一切都正常工作，所以總的時間進行拼寫檢查

868
00:46:09,000 --> 00:46:13,000
在國王詹姆斯聖經“是0.38秒，相當不錯的，所以使用該實現。

869
00:46:13,000 --> 00:46:16,000
現在讓我到PHP版本，這是我們剛寫。

870
00:46:16,000 --> 00:46:18,000
讓我跑的拼寫國王詹姆斯。

871
00:46:18,000 --> 00:46:21,000
哎呀，忽略這個錯誤。我在錯誤的目錄。

872
00:46:21,000 --> 00:46:24,000
國王詹姆斯第5的拼寫上。

873
00:46:46,000 --> 00:46:48,000
差不多完成了。

874
00:46:48,000 --> 00:46:51,000
>> 好了，精明的觀察者會意識到這是3秒以上，有。

875
00:46:51,000 --> 00:46:54,000
這是真實的運行時間。

876
00:46:54,000 --> 00:46:58,000
事實證明，它需要時間來吐了大量的文字

877
00:46:58,000 --> 00:47:00,000
由於緩衝的問題，但長話短說，

878
00:47:00,000 --> 00:47:04,000
的加工時間為3.15秒，CPU時間，

879
00:47:04,000 --> 00:47:07,000
與剛才又是什麼呢？

880
00:47:07,000 --> 00:47:09,000
像0.3。

881
00:47:09,000 --> 00:47:11,000
我的意思是，這是一個數量級的速度較慢，所以在哪裡

882
00:47:11,000 --> 00:47:14,000
可笑的放緩從哪裡來的呢？

883
00:47:14,000 --> 00:47:17,000
好了，因為一直的情況下，幾乎所有的設計決定，我們已經取得了

884
00:47:17,000 --> 00:47:21,000
在過去9週中的類幾乎總是權衡。

885
00:47:21,000 --> 00:47:24,000
有時候之間，有時只是空間之間的空間和時間，

886
00:47:24,000 --> 00:47:27,000
空間，時間和開發工作，並確實在這裡，即使

887
00:47:27,000 --> 00:47:31,000
我們節省了大量的時間，可能有潛在10-20-30小時

888
00:47:31,000 --> 00:47:34,000
實施拼寫檢查器的開發時間

889
00:47:34,000 --> 00:47:36,000
通過鞭打，這種語言在短短45秒

890
00:47:36,000 --> 00:47:40,000
我們付出的代價是，它是慢了一個數量級，

891
00:47:40,000 --> 00:47:43,000
這是一般的情況下與大多數任何解釋語言，

892
00:47:43,000 --> 00:47:46,000
PHP，Python和紅寶石，珍珠或其他人據此

893
00:47:46,000 --> 00:47:49,000
如果你要運行它通過翻譯和閱讀你的代碼

894
00:47:49,000 --> 00:47:52,000
一行行，從上到下，從左到右，

895
00:47:52,000 --> 00:47:55,000
，中間人會採取一些自己的時間，

896
00:47:55,000 --> 00:47:59,000
和你的感受是什麼在3秒到0.3秒，而不是

897
00:47:59,000 --> 00:48:02,000
是的事實，這是中間人，從字面上理解我們的代碼

898
00:48:02,000 --> 00:48:05,000
一行行，但願，如果你是內循環

899
00:48:05,000 --> 00:48:08,000
一個巨大的文件，其中包含數十萬字。

900
00:48:08,000 --> 00:48:11,000
>> 的開銷加起來，加起來，加起來，並添加了。

901
00:48:11,000 --> 00:48:16,000
對於這樣一個工具，它可能不是最好的語言，使用的實施

902
00:48:16,000 --> 00:48:20,000
如果直接是一個拼寫檢查您的用戶和你的興趣。

903
00:48:20,000 --> 00:48:23,000
但我們在某一時刻的奢侈品是，如果你

904
00:48:23,000 --> 00:48:27,000
使用的語言，如PHP或有很多解釋型語言

905
00:48:27,000 --> 00:48:30,000
在網絡的背景下，對於這個問題，你有益處

906
00:48:30,000 --> 00:48:34,000
互聯網是比大多數的電腦慢了很多。

907
00:48:34,000 --> 00:48:38,000
您有在您的計算機上，2 GHz時，甚至更多，這些天GHz的CPU。

908
00:48:38,000 --> 00:48:41,000
但現實情況是，在互聯網上有一個高的延遲量

909
00:48:41,000 --> 00:48:45,000
由此，對於瀏覽器到服務器，即使我們看到上週

910
00:48:45,000 --> 00:48:47,000
這是相當快的，一毫秒的一半左右，

911
00:48:47,000 --> 00:48:51,000
也增加了，而如果你下載的東西，如圖像

912
00:48:51,000 --> 00:48:54,000
或Facebook的照片或即時消息，Facebook的喋喋不休，

913
00:48:54,000 --> 00:48:57,000
的Gchat或類似，所有的往返時間

914
00:48:57,000 --> 00:49:00,000
之間的瀏覽器和服務器開始增加，

915
00:49:00,000 --> 00:49:03,000
這使得在許多情況下，您的特定選擇的語言

916
00:49:03,000 --> 00:49:07,000
不是所有的相關的，因此你使用一個稍微慢的語言

917
00:49:07,000 --> 00:49:10,000
如PHP或Python或Ruby

918
00:49:10,000 --> 00:49:13,000
但有巨大的積極給您和您的同事

919
00:49:13,000 --> 00:49:17,000
和你的朋友，因為你可以實現的事情，所以，如此之快。

920
00:49:17,000 --> 00:49:20,000
此外，你有一定的安全缺陷的風險要少得多。

921
00:49:20,000 --> 00:49:22,000
在PHP中有沒有指針。

922
00:49:22,000 --> 00:49:25,000
段有沒有故障，你可以很容易地誘發

923
00:49:25,000 --> 00:49:27,000
以同樣的方式，你可以在C.

924
00:49:27,000 --> 00:49:29,000
C，你是超級的硬件。

925
00:49:29,000 --> 00:49:33,000
使用PHP和類似的語言，你是那種水平的提高，可以這麼說，

926
00:49:33,000 --> 00:49:37,000
你和什麼之間有很多的防禦實際上是怎麼回事

927
00:49:37,000 --> 00:49:39,000
在機器內部，它只是一個折衷。

928
00:49:39,000 --> 00:49:42,000
>> 我們已經得到的地步，這些更現代化的，高層次的語言

929
00:49:42,000 --> 00:49:47,000
像PHP，因為吸取的經驗教訓的語言，如PHP C.

930
00:49:47,000 --> 00:49:50,000
但是，如果你不明白什麼已經持續引擎蓋下的所有時間

931
00:49:50,000 --> 00:49:53,000
你肯定不能做出正確的設計決策，

932
00:49:53,000 --> 00:49:56,000
當然，當它涉及到像Facebook或谷歌在一個地方工作

933
00:49:56,000 --> 00:49:59,000
這些地方是越來越大的數據集

934
00:49:59,000 --> 00:50:01,000
即使你回去做醫學預科，並正與一些MD

935
00:50:01,000 --> 00:50:04,000
在一些大的數據集，涉及患者和醫生

936
00:50:04,000 --> 00:50:08,000
如使用正確的工具是巨大的令人信服的

937
00:50:08,000 --> 00:50:11,000
，否則你分析一些數據集可能需要幾秒鐘，

938
00:50:11,000 --> 00:50:14,000
或者它可能從字面上需要幾個小時。

939
00:50:14,000 --> 00:50:17,000
這僅僅是一個例子，而不是阻撓你多少的努力，

940
00:50:17,000 --> 00:50:21,000
這是在C，但幫助您了解，當你實現的東西在C

941
00:50:21,000 --> 00:50:24,000
你真的理解，或在理論上，真正了解

942
00:50:24,000 --> 00:50:28,000
如何一切都應該工作，你幾乎完全控制

943
00:50:28,000 --> 00:50:31,000
這是怎麼回事引擎蓋下的，並與這些高層次的語言

944
00:50:31,000 --> 00:50:34,000
你必須放棄更多的控制權的人，是誰發明的

945
00:50:34,000 --> 00:50:37,000
，並受到他們的設計決策比你。

946
00:50:37,000 --> 00:50:41,000
但是，如果我們想當然地認為表現

947
00:50:41,000 --> 00:50:44,000
是不是很重要的，因為這些問題在網絡上，

948
00:50:44,000 --> 00:50:47,000
只是網絡速度比CPU的速度慢一點，無論如何，

949
00:50:47,000 --> 00:50:50,000
所以我們可以排序，用得起一個稍微慢的語言

950
00:50:50,000 --> 00:50:55,000
如果有利的一面是，我們可以開發的東西10倍的速度或什至更多。

951
00:50:55,000 --> 00:50:57,000
>> 讓我們來看看如何，我們就可以開始使用。

952
00:50:57,000 --> 00:51:00,000
讓我去到一個文件夾

953
00:51:00,000 --> 00:51:03,000
在今天的例子稱為frosh.ims，

954
00:51:03,000 --> 00:51:06,000
這實際上是親自動機的第一件事的事實，即

955
00:51:06,000 --> 00:51:10,000
我寫的Web年前後，CS50和CS51

956
00:51:10,000 --> 00:51:14,000
是一個網站的大一IMS程序，大一學生校內運動，

957
00:51:14,000 --> 00:51:16,000
這在當時，這是足以年前，當時

958
00:51:16,000 --> 00:51:19,000
有沒有網站的程序，即使是一個網絡，

959
00:51:19,000 --> 00:51:22,000
取而代之的是一個值日生威格爾斯沃據此，如果你想

960
00:51:22,000 --> 00:51:26,000
註冊排球或足球或任何你填寫一張紙。

961
00:51:26,000 --> 00:51:28,000
然後，您可以步行穿過院子。

962
00:51:28,000 --> 00:51:31,000
在他們的門或監考官的手，然後，你會敲他們的門​​和幻燈片

963
00:51:31,000 --> 00:51:34,000
在一張紙上，你的名字就可以了，你是否想成為一個球隊的隊長，

964
00:51:34,000 --> 00:51:37,000
你你想要做什麼運動，什麼宿舍英寸

965
00:51:37,000 --> 00:51:39,000
這是一個老同學的做事方式，這是一個主要

966
00:51:39,000 --> 00:51:41,000
自動化這個過程中有很多的機會。

967
00:51:41,000 --> 00:51:43,000
你剛才去的網站。您鍵入的東西英寸

968
00:51:43,000 --> 00:51:46,000
您會收到一封電子郵件，確認和繁榮，就大功告成了。

969
00:51:46,000 --> 00:51:49,000
>> 這是我做的第一件事，雖然在語言，稱為珍珠，

970
00:51:49,000 --> 00:51:52,000
但它是比較容易做的PHP，這是形式的代表

971
00:51:52,000 --> 00:51:55,000
的問題，你就可以開始解決時，你可以表達自己的

972
00:51:55,000 --> 00:51:58,000
編程和沒有依靠的東西，如谷歌網站

973
00:51:58,000 --> 00:52:01,000
或Excel或工具，就交給你了。

974
00:52:01,000 --> 00:52:03,000
你們現在有能力做這樣的事情。

975
00:52:03,000 --> 00:52:06,000
這是一個超級醜陋的版本的一種形式，

976
00:52:06,000 --> 00:52:09,000
但讓​​我們只用它的談話，這是開始

977
00:52:09,000 --> 00:52:12,000
大概什麼形式看起來就像幾年前，我們

978
00:52:12,000 --> 00:52:14,000
使人們在網站上註冊為大一IMS。

979
00:52:14,000 --> 00:52:18,000
我們要求一個名字，一個複選框，他們是否想當隊長，

980
00:52:18,000 --> 00:52:21,000
男或女的，然後他們在什麼宿舍，

981
00:52:21,000 --> 00:52:23,000
然後，他們將提交本表格。

982
00:52:23,000 --> 00:52:27,000
讓我們先來看看下面的罩在表示這個網頁的HTML。

983
00:52:27,000 --> 00:52:31,000
讓我進入froshims0，

984
00:52:31,000 --> 00:52:35,000
順便說一句，pset中7，我考慮是理所當然的

985
00:52:35,000 --> 00:52:37,000
我把事情英寸的目錄和文件夾

986
00:52:37,000 --> 00:52:40,000
我們將引導您完成的確切位置飄然而至，在家電，

987
00:52:40,000 --> 00:52:43,000
國防部的命令，你必須運行的，所以不要擔心所有的

988
00:52:43,000 --> 00:52:46,000
愚蠢的詳細信息同步，從一開始就在這裡。

989
00:52:46,000 --> 00:52:49,000
>> 好吧，這裡的froshims0.php的。

990
00:52:49,000 --> 00:52:52,000
讓我向下滾動，有什麼好奇的，

991
00:52:52,000 --> 00:52:56,000
這是一個PHP文件，但它裡面是什麼，清楚嗎？

992
00:52:56,000 --> 00:52:59,000
這是一個很多的HTML，PHP的起源

993
00:52:59,000 --> 00:53:02,000
真的是一個以網絡為中心的語言。

994
00:53:02,000 --> 00:53:04,000
剛才我們用它來實現啤酒的例子，

995
00:53:04,000 --> 00:53:07,000
的條件，例如，你好例如，這很好。

996
00:53:07,000 --> 00:53:11,000
您可以使用PHP作為一種腳本語言

997
00:53:11,000 --> 00:53:15,000
腳本是真的只是一個快速和骯髒的程序給出的術語

998
00:53:15,000 --> 00:53:19,000
什麼，你寫的腳本或更普遍的一種解釋型語言。

999
00:53:19,000 --> 00:53:22,000
PHP是超級有用的，因為你已經看到如何迅速

1000
00:53:22,000 --> 00:53:24,000
比較我們可以掀起的PHP程序。

1001
00:53:24,000 --> 00:53:27,000
但它真正目的是用於Web，

1002
00:53:27,000 --> 00:53:31,000
和設計為Web在某種意義上說，注意到在這裡的文件的頂部

1003
00:53:31,000 --> 00:53:34,000
我開始<？PHP。

1004
00:53:34,000 --> 00:53:38,000
然後，我有一堆無用的意見，授予，但後來我關閉PHP模式。

1005
00:53:38,000 --> 00:53:41,000
但後​​來我下降到HTML模式。

1006
00:53:41,000 --> 00:53:45,000
>> 關於PHP有什麼有趣的是，即使文件結束。PHP

1007
00:53:45,000 --> 00:53:48,000
它通常意味著要與HTML混在一起，

1008
00:53:48,000 --> 00:53:50,000
一些PHP代碼，一些HTML。

1009
00:53:50,000 --> 00:53:53,000
我們最終會看到，我們就可以開始挑逗那些除了

1010
00:53:53,000 --> 00:53:56,000
，使我們的HTML獨立於我們的PHP完全，

1011
00:53:56,000 --> 00:53:59,000
但PHP的起源真的是給你這樣的靈活性，

1012
00:53:59,000 --> 00:54:02,000
如果你想一些HTML只寫它，將是

1013
00:54:02,000 --> 00:54:04,000
吐出相同的瀏覽器。

1014
00:54:04,000 --> 00:54:07,000
但是，如果你需要一些編程技術，

1015
00:54:07,000 --> 00:54:12,000
一些編程的代碼，你也可以把它變成完全相同的文件，我們很快就會看到。

1016
00:54:12,000 --> 00:54:14,000
這裡是我的HTML。

1017
00:54:14,000 --> 00:54:16,000
我有一個標題為大一IMS。

1018
00:54:16,000 --> 00:54:20,000
我有一個body標籤誰得到了它一些CSS中心在中間的一切，

1019
00:54:20,000 --> 00:54:23,000
然後在這裡我有一個形式，這顯然是將要提交

1020
00:54:23,000 --> 00:54:27,000
到一個新的稱為register0.php的文件，所以我們會看到，在一個時刻。

1021
00:54:27,000 --> 00:54:31,000
它的使用方法後，我們會回來的，以及。

1022
00:54:31,000 --> 00:54:34,000
然後，我有某種形式的輸入，一個所謂的名稱，其類型是文本，

1023
00:54:34,000 --> 00:54:37,000
他的名字是隊長，其類型是“複選框，

1024
00:54:37,000 --> 00:54:40,000
這一點，我們沒有看到它之前，但它到底是什麼說的。

1025
00:54:40,000 --> 00:54:42,000
你會得到一個複選框，而不是一個文本框。

1026
00:54:42,000 --> 00:54:46,000
在這裡，你有一個單選按鈕，這是那些圓形按鈕

1027
00:54:46,000 --> 00:54:48,000
你可以選擇這一個或那一個。

1028
00:54:48,000 --> 00:54:52,000
>> 請注意，這是故意的，我給了兩個單選按鈕的名稱，性別。

1029
00:54:52,000 --> 00:54:55,000
這是你如何相互排斥，你必須按一下

1030
00:54:55,000 --> 00:54:58,000
無論是這一個或那一個，並點擊

1031
00:54:58,000 --> 00:55:01,000
取消選中，所以你必須給他們同樣的名稱

1032
00:55:01,000 --> 00:55:03,000
如果你想它們是相互排斥的那樣。

1033
00:55:03,000 --> 00:55:07,000
然後宿舍，我不認為我們已經看到了這一點，但它是一個選擇菜單，下拉菜單中。

1034
00:55:07,000 --> 00:55:09,000
因為這是選擇的標籤。

1035
00:55:09,000 --> 00:55:11,000
然後，您可以在下拉菜單的名稱，

1036
00:55:11,000 --> 00:55:13,000
然後你有一大堆的這些選項。

1037
00:55:13,000 --> 00:55:16,000
第一個，只是為了美觀，是一個空字符串。

1038
00:55:16,000 --> 00:55:20,000
我只是想下拉列表中，默認情況下是空白的，

1039
00:55:20,000 --> 00:55:22,000
，然後有Apley，卡納迪，灰色，等等。

1040
00:55:22,000 --> 00:55:24,000
注意到這裡的二分法。

1041
00:55:24,000 --> 00:55:27,000
在下拉式菜單中的選項下有一個值，

1042
00:55:27,000 --> 00:55:30,000
但然後它有一個人類友好的名稱，在該示例中

1043
00:55:30,000 --> 00:55:33,000
是相同的，但如果我們真正想要的是肛門，我們可以有

1044
00:55:33,000 --> 00:55:36,000
這一下降的價值下降只是短期的版本，

1045
00:55:36,000 --> 00:55:39,000
灰色，但我們真的可以說，人類的灰色廳實際看到的，

1046
00:55:39,000 --> 00:55:43,000
但不是所有的有趣，所以我只是保持簡單和他們相同。

1047
00:55:43,000 --> 00:55:46,000
接著下來的底部，我們有一個提交按鈕

1048
00:55:46,000 --> 00:55:49,000
這是我們見過的，但是請注意我只是給它一個不同的字。

1049
00:55:49,000 --> 00:55:53,000
而不是我給CS50搜索標籤“註冊”。

1050
00:55:53,000 --> 00:55:56,000
>> 最終的結果是這樣的網頁，並再次，

1051
00:55:56,000 --> 00:56:00,000
這得到提交？

1052
00:56:00,000 --> 00:56:04,000
它被提交一些文件，這個值的action屬性，

1053
00:56:04,000 --> 00:56:07,000
這是register0.php。

1054
00:56:07,000 --> 00:56:09,000
讓我們來看看到底發生了什麼在這裡。

1055
00:56:09,000 --> 00:56:13,000
讓我繼續前進，填寫此表，說大衛，

1056
00:56:13,000 --> 00:56:16,000
男，馬修斯，然後我會說註冊。

1057
00:56:16,000 --> 00:56:18,000
讓我放大，然後點擊註冊。

1058
00:56:18,000 --> 00:56:22,000
好了，這樣一種無用的，但讓我們來看看什麼回事。

1059
00:56:22,000 --> 00:56:26,000
請注意，URL更改為register0.php。

1060
00:56:26,000 --> 00:56:34,000
奇怪的是不存在的URL，不過，即使我們只是提出的一種形式嗎？

1061
00:56:34,000 --> 00:56:37,000
[聽不見的學生反應]

1062
00:56:37,000 --> 00:56:39,000
好吧，這只是Chrome瀏覽器是用戶友好的，這些天。

1063
00:56:39,000 --> 00:56:42,000
這是實際存在的。他們只是將其隱藏以節省空間。

1064
00:56:42,000 --> 00:56:44,000
但是，好的想法，好的想法。

1065
00:56:44,000 --> 00:56:46,000
朝另一端的URL，雖然缺少了什麼？是啊。

1066
00:56:46,000 --> 00:56:48,000
[學生]的查詢字符串。

1067
00:56:48,000 --> 00:56:51,000
查詢字符串，所以記得從簡單的谷歌搜索的例子。

1068
00:56:51,000 --> 00:56:54,000
當我點擊提交按鈕時，URL

1069
00:56:54,000 --> 00:57:00,000
帶我去谷歌，但再有就是Q =計算機科學或什麼的，我已經輸入

1070
00:57:00,000 --> 00:57:04,000
這是因為我們的搜索示例使用GET方法。

1071
00:57:04,000 --> 00:57:06,000
>> 這一次，我們使用的是什麼方法，而不是？

1072
00:57:06,000 --> 00:57:10,000
發布，並立即區別之一

1073
00:57:10,000 --> 00:57:14,000
GET和POST之間是後並沒有把用戶的輸入的URL。

1074
00:57:14,000 --> 00:57:16,000
它隱藏它。它仍然將其發送。

1075
00:57:16,000 --> 00:57:19,000
事實上，我們所看到的在這裡在瀏覽器中，我們將揭示在某一時刻

1076
00:57:19,000 --> 00:57:22,000
在寄存器，我只是看到的內容

1077
00:57:22,000 --> 00:57:25,000
的陣列，從瀏覽器向服務器提交。

1078
00:57:25,000 --> 00:57:29,000
但URL沒有？，沒有任何關鍵字

1079
00:57:29,000 --> 00:57:31,000
或在它的值，這是為什麼呢？

1080
00:57:31,000 --> 00:57:35,000
好了，後允許您從形式到服務器提交數據，

1081
00:57:35,000 --> 00:57:38,000
但它並沒有把它的URL，所以什麼樣的信息後

1082
00:57:38,000 --> 00:57:41,000
特別適合於也許當你問用戶

1083
00:57:41,000 --> 00:57:44,000
輸入到表單中輸入？

1084
00:57:44,000 --> 00:57:48,000
像密碼一樣的東西，像什麼呢？

1085
00:57:48,000 --> 00:57:50,000
信用卡號碼。

1086
00:57:50,000 --> 00:57:53,000
凡是輕度敏感的你可能不希望結束的URL

1087
00:57:53,000 --> 00:57:56,000
如果只是因為它意味著你的室友或家庭成員都可以只是嚇嚇

1088
00:57:56,000 --> 00:57:59,000
您的互聯網歷史記錄，然後從字面上看您的密碼，

1089
00:57:59,000 --> 00:58:02,000
從字面上看您的信用卡號碼，因為大多數瀏覽器

1090
00:58:02,000 --> 00:58:05,000
記得在歷史上的任何網址，你已經在

1091
00:58:05,000 --> 00:58:09,000
因此，如果僅僅是因為這將是一個糟糕的主意。

1092
00:58:09,000 --> 00:58:11,000
使用後隱藏，詳細的用戶。

1093
00:58:11,000 --> 00:58:14,000
>> 此外，如何上傳到Facebook的照片嗎？

1094
00:58:14,000 --> 00:58:17,000
好了，你真的可以使用的只有2個機制，

1095
00:58:17,000 --> 00:58:21,000
儘管有其他一些更神秘的​​，是GET和POST。

1096
00:58:21,000 --> 00:58:26,000
你怎麼可能通過一個URL上傳照片嗎？

1097
00:58:26,000 --> 00:58:28,000
實際上，你可以做到這一點。

1098
00:58:28,000 --> 00:58:30,000
你可以把一個JPEG或位圖或GIF，你可以代表它在十六進制

1099
00:58:30,000 --> 00:58:32,000
或一些所謂的基地64。

1100
00:58:32,000 --> 00:58:35,000
而不是基地16使用基本64，基本上看起來像

1101
00:58:35,000 --> 00:58:38,000
ASCII字符，實際上，你可以通過一個URL上傳照片

1102
00:58:38,000 --> 00:58:41,000
後一個問號，但也有一般大小的限制。

1103
00:58:41,000 --> 00:58:44,000
大多數瀏覽器強制不超過1000個字符的URL，

1104
00:58:44,000 --> 00:58:47,000
也許2000個字符或類似的，所以你不能上傳

1105
00:58:47,000 --> 00:58:50,000
10 MB Facebook的照片。

1106
00:58:50,000 --> 00:58:54,000
對，你使用後，現在得到了參數中的URL，

1107
00:58:54,000 --> 00:58:57,000
這是很好的，有用的，有時，但對於任何敏感或大

1108
00:58:57,000 --> 00:58:59,000
後是要走的路。

1109
00:58:59,000 --> 00:59:02,000
什麼是寄存器實際上是在這裡做什麼？

1110
00:59:02,000 --> 00:59:05,000
好吧，如果我打開寄存器的注意，這是一個超級簡單的頁面，

1111
00:59:05,000 --> 00:59:09,000
但它證明了的事實，我可以混合，或好或壞，

1112
00:59:09,000 --> 00:59:12,000
HTML與PHP。

1113
00:59:12,000 --> 00:59:15,000
這整個文件，除了在頂部的意見，HTML

1114
00:59:15,000 --> 00:59:19,000
除了這傢伙在這裡。

1115
00:59:19,000 --> 00:59:22,000
>> 請注意，在我的PHP代碼中，

1116
00:59:22,000 --> 00:59:26,000
在我的HTML中，我暫時有幾分

1117
00:59:26,000 --> 00:59:28,000
進入PHP模式。

1118
00:59:28,000 --> 00:59:31,000
我調用一個特殊的稱為印記R的函數。

1119
00:59:31,000 --> 00:59:34,000
這意味著打印遞歸的，它的作用是遞歸打印

1120
00:59:34,000 --> 00:59:38,000
任何變量，你把它分號，退出PHP模式。

1121
00:59:38,000 --> 00:59:40,000
和PRE標記為您提供了預先格式化的文本，

1122
00:59:40,000 --> 00:59:43,000
單空間的文字，使每一個空間，你真正看到它。

1123
00:59:43,000 --> 00:59:46,000
它並沒有消失。是什麼職位？

1124
00:59:46,000 --> 00:59:48,000
那麼，什麼是有趣的和引人注目的PHP

1125
00:59:48,000 --> 00:59:52,000
是當你提交一個表單使用GET或POST

1126
00:59:52,000 --> 00:59:56,000
任何提交您的瀏覽器

1127
00:59:56,000 --> 01:00:00,000
PHP本身計算出這些鍵值對，

1128
01:00:00,000 --> 01:00:02,000
數字，如果有相等的符號，數字，如果有一個問號。

1129
01:00:02,000 --> 01:00:07,000
它為你做所有的辛勤工作，然後將它交給你一個關聯數組

1130
01:00:07,000 --> 01:00:10,000
含有用戶輸入到表單中的一切。

1131
01:00:10,000 --> 01:00:12,000
那麼，哪些領域沒有這種形式有哪些？

1132
01:00:12,000 --> 01:00:14,000
>> 它有4個領域。

1133
01:00:14,000 --> 01:00:16,000
一個是文本字段名為name的。

1134
01:00:16,000 --> 01:00:18,000
一個是稱為隊長的複選框。

1135
01:00:18,000 --> 01:00:22,000
一個是被稱為性別的單選按鈕，

1136
01:00:22,000 --> 01:00:24,000
，還有一個是叫宿舍的下拉菜單中，

1137
01:00:24,000 --> 01:00:27,000
所以注意到，當我打印遞歸

1138
01:00:27,000 --> 01:00:29,000
這個特殊變量的內容。

1139
01:00:29,000 --> 01:00:34,000
這是一個特殊的全局變量從字面上$ _POST，全部大寫。

1140
01:00:34,000 --> 01:00:39,000
這是一個特殊的全局變量，PHP只是為你創造

1141
01:00:39,000 --> 01:00:42,000
和手給你，讓你可以訪問一切

1142
01:00:42,000 --> 01:00:45,000
由用戶通過表單提交。

1143
01:00:45,000 --> 01:00:48,000
，調用print r上，你就不會這樣做在一個正常的應用程序。

1144
01:00:48,000 --> 01:00:50,000
我們這樣做是為了看到這個變量的內，

1145
01:00:50,000 --> 01:00:53,000
，什麼是它的內部，以及，4個按鍵，

1146
01:00:53,000 --> 01:00:56,000
4 HTTP參數，可以這麼說，

1147
01:00:56,000 --> 01:00:59,000
名，隊長，性別，宿舍，然後用戶的值

1148
01:00:59,000 --> 01:01:01,000
中鍵入一個例外。

1149
01:01:01,000 --> 01:01:03,000
我做了D-à-V-I-D型。

1150
01:01:03,000 --> 01:01:05,000
我檢查了箱子，雖然，男性，這顯然提交了一份價值

1151
01:01:05,000 --> 01:01:07,000
只是m為簡潔。

1152
01:01:07,000 --> 01:01:10,000
>> 當我選擇了馬修斯的價值，進行了選擇，

1153
01:01:10,000 --> 01:01:12,000
這個人是有點愚蠢，但它的慣例。

1154
01:01:12,000 --> 01:01:17,000
當我檢查的框，值上，“，”得到提交的複選框。

1155
01:01:17,000 --> 01:01:21,000
如果我沒有檢查，沒有任何價值將被送往任何責任。

1156
01:01:21,000 --> 01:01:26,000
這只是讓我們深入了解這個特殊的全局變量裡面有什麼，

1157
01:01:26,000 --> 01:01:29,000
它是如此特別，它被稱為超全局變量。

1158
01:01:29,000 --> 01:01:33,000
它的存在在你的代碼中到處找你，所以，你其實可以訪問它。

1159
01:01:33,000 --> 01:01:36,000
這是不令人滿意的，讓我們實際使用超全局

1160
01:01:36,000 --> 01:01:38,000
，實際嘗試註冊的人。

1161
01:01:38,000 --> 01:01:41,000
在froshims1我要做出一個改變。

1162
01:01:41,000 --> 01:01:44,000
我改變的行動是register1.php的，

1163
01:01:44,000 --> 01:01:46,000
和我做一件事。

1164
01:01:46,000 --> 01:01:48,000
我是通過我的網頁上有質量的一種尷尬。

1165
01:01:48,000 --> 01:01:52,000
說實話，這是非常可怕的，所以它原來

1166
01:01:52,000 --> 01:01:56,000
在網絡上，你可以很容易地使用

1167
01:01:56,000 --> 01:01:59,000
其他人的JavaScript代碼，其他人的CSS

1168
01:01:59,000 --> 01:02:02,000
他們編寫並開放了源代碼，並提供圖書館，

1169
01:02:02,000 --> 01:02:06,000
可以這麼說，例如，我在這裡使用免費提供的庫，

1170
01:02:06,000 --> 01:02:08,000
一堆別人寫的代碼。

1171
01:02:08,000 --> 01:02:11,000
>> Twitter的事寫這段代碼，這就是所謂的引導程序庫，

1172
01:02:11,000 --> 01:02:15,000
它只是一個CSS樣式表，一堆一堆的。css文件

1173
01:02:15,000 --> 01:02:19,000
別人寫的，並計算出如何讓一切都很好，漂亮

1174
01:02:19,000 --> 01:02:22,000
像我們這樣的人可以少擔心一點美學，重點更

1175
01:02:22,000 --> 01:02:24,000
在邏輯和實際的編程。

1176
01:02:24,000 --> 01:02:30,000
通過將包含該標籤的，這是我用相同的標記記住的styles3.css早期，

1177
01:02:30,000 --> 01:02:34,000
我現在有一個稱為bootstrap.min.css的文件的訪問。

1178
01:02:34,000 --> 01:02:37,000
只是意味著，他們已經精縮最小，他們已經擺脫所有的白色空間等等

1179
01:02:37,000 --> 01:02:40,000
只是，以確保他們沒有向我發送的字節數比我的實際需要。

1180
01:02:40,000 --> 01:02:45,000
但在有一大堆的CSS，所以如果我現在開的大一IMS版本1

1181
01:02:45,000 --> 01:02:49,000
請注意我的文件肯定是漂亮。

1182
01:02:49,000 --> 01:02:54,000
現在，它仍然只是黑色和白色，但是請注意，只是使用的樣式表

1183
01:02:54,000 --> 01:02:58,000
使用某些功能，這是我的形式不驚人，

1184
01:02:58,000 --> 01:03:01,000
但它肯定比以前清潔，並在投影機不這樣做正義。

1185
01:03:01,000 --> 01:03:05,000
周圍的按鈕和文本字段周圍有小灰線就在這裡，

1186
01:03:05,000 --> 01:03:07,000
但它肯定比以前更乾淨。

1187
01:03:07,000 --> 01:03:09,000
>> 現在，為公平起見，我沒有改變我的標記位。

1188
01:03:09,000 --> 01:03:12,000
這是第1版，請注意，我已經使用了一些新的標籤，

1189
01:03:12,000 --> 01:03:17,000
說實話，我不知道該怎麼辦，直到我讀的文檔

1190
01:03:17,000 --> 01:03:20,000
Twitter的引導庫，他們告訴我，如果你想使用我們的圖書館

1191
01:03:20,000 --> 01:03:23,000
使用fieldset元素在你的形式，

1192
01:03:23,000 --> 01:03:27,000
把你要顯示的字旁邊一個領域內的一個標籤，標籤，

1193
01:03:27,000 --> 01:03:30,000
然後給你輸入一個名字，就像之前，

1194
01:03:30,000 --> 01:03:34,000
的複選框，不僅你把它包在一個標籤元素，

1195
01:03:34,000 --> 01:03:36,000
你使用一類的東西，所以我們還沒有看到這之前，

1196
01:03:36,000 --> 01:03:39,000
但是你會看到在一個的pset中7的短褲。

1197
01:03:39,000 --> 01:03:43,000
CSS中的類可以讓你做的東西非常相似的ID，

1198
01:03:43,000 --> 01:03:46,000
但在此之前，當我們有一個ID以＃符號

1199
01:03:46,000 --> 01:03:48,000
這是一個只有一個元素。

1200
01:03:48,000 --> 01:03:51,000
什麼是一類很好多個元素具有相同的類

1201
01:03:51,000 --> 01:03:54,000
或相同的CSS的東西應用到它。

1202
01:03:54,000 --> 01:03:57,000
>> 但同樣，對那些在短期內，剩下的這僅僅是複製和粘貼

1203
01:03:57,000 --> 01:04:00,000
從他們的文件，我添加了一個標籤，在這裡和那裡。

1204
01:04:00,000 --> 01:04:03,000
在最後，因為我已​​經包含在上面的鏈接標籤，

1205
01:04:03,000 --> 01:04:06,000
一切看起來更漂亮自動

1206
01:04:06,000 --> 01:04:10,000
通過簡單的標記的方式，在我的網頁

1207
01:04:10,000 --> 01:04:12,000
Twitter的預期，有這麼多不同的方式

1208
01:04:12,000 --> 01:04:14,000
做到這一點，這確實是非常合適的。

1209
01:04:14,000 --> 01:04:17,000
在本學期在這一點上，你會看到在pset中7的規格，

1210
01:04:17,000 --> 01:04:20,000
谷歌搜索，閱讀庫，用別人的CSS

1211
01:04:20,000 --> 01:04:23,000
和JavaScript來解決配套問題

1212
01:04:23,000 --> 01:04:26,000
組本身的問題，肯定是鼓勵和方式

1213
01:04:26,000 --> 01:04:29,000
網絡是建立這些天來，站在別人的肩膀上

1214
01:04:29,000 --> 01:04:32,000
所以，你可以真正著眼於新的和有趣的問題。

1215
01:04:32,000 --> 01:04:34,000
但是，讓我們現在的重點，再次，邏輯。

1216
01:04:34,000 --> 01:04:38,000
>> 這是一個快速迂迴美學只是為了顯示你的方向，你可以去。

1217
01:04:38,000 --> 01:04:40,000
我要恢復的醜陋，現在僅僅是因為

1218
01:04:40,000 --> 01:04:44,000
有與Twitter的東西，心無雜念，讓我去進取，不斷開拓

1219
01:04:44,000 --> 01:04:51,000
froshims2，再強調一下，只有在不同的動作，register2.php，

1220
01:04:51,000 --> 01:04:55,000
讓我們來看看什麼樣的影響是在這裡。

1221
01:04:55,000 --> 01:04:57,000
讓我繼續前進，輸入大衛。

1222
01:04:57,000 --> 01:04:59,000
我不會隊長這個時候。

1223
01:04:59,000 --> 01:05:01,000
我會說男性，馬修斯，寄存器。

1224
01:05:01,000 --> 01:05:05,000
該死的。好吧，這是一個搞砸了我的一部分。

1225
01:05:05,000 --> 01:05:07,000
待機。

1226
01:05:07,000 --> 01:05:17,000
寄存器2，第22行，如果為空或遺憾。

1227
01:05:17,000 --> 01:05:19,000
讓我們重新加載。

1228
01:05:19,000 --> 01:05:22,000
好了，在提交這種形式剛剛發生了什麼？

1229
01:05:22,000 --> 01:05:25,000
我在大衛的輸入，檢查男馬修斯，註冊，點擊。

1230
01:05:25,000 --> 01:05:27,000
您的註冊。 （當然，不是真的。）

1231
01:05:27,000 --> 01:05:32,000
這顯然是一個超越剛剛打印出來的一些變量的內容，

1232
01:05:32,000 --> 01:05:34,000
但是這是什麼文件，實際上是在做什麼？

1233
01:05:34,000 --> 01:05:37,000
在register2.php

1234
01:05:37,000 --> 01:05:40,000
請注意，我有一些新的代碼。

1235
01:05:40,000 --> 01:05:44,000
我的身體標記內，我基本上是一個if else結構，

1236
01:05:44,000 --> 01:05:47,000
但是，因為我共同交融與一些HTML

1237
01:05:47,000 --> 01:05:51,000
我來回的進入和退出PHP模式，讓我們看看我在做什麼。

1238
01:05:51,000 --> 01:05:55,000
>> 在這裡的第一線，我說如果是的情況下

1239
01:05:55,000 --> 01:06:00,000
後超全局的關鍵名稱是空的，

1240
01:06:00,000 --> 01:06:04,000
換句話說，如果用戶沒有給我一個值名稱的形式，

1241
01:06:04,000 --> 01:06:07,000
然後空返回true，因為值是空的。

1242
01:06:07,000 --> 01:06:11,000
或注意到的豎線如果性別是空的，

1243
01:06:11,000 --> 01:06:15,000
內部的這個特殊的超全局，其中，再次，表示內容的形式，

1244
01:06:15,000 --> 01:06:19,000
或在宿舍裡是空的，然後我會繼續前進，大聲嚷嚷的用戶。

1245
01:06:19,000 --> 01:06:22,000
怎麼樣？那麼，請注意，我說，你必須提供您的姓名，性別，和宿舍。

1246
01:06:22,000 --> 01:06:24,000
讓實際導致這樣的錯誤。

1247
01:06:24,000 --> 01:06:27,000
讓我回到我的形式。讓我重新加載，以清除它。

1248
01:06:27,000 --> 01:06:30,000
，我只是給他們大衛，他們並不需要知道我住的地方。

1249
01:06:30,000 --> 01:06:33,000
註冊。很顯然，我需要告訴他們我住的地方。

1250
01:06:33,000 --> 01:06:35,000
您必須提供您的姓名，性別和宿舍。回去。

1251
01:06:35,000 --> 01:06:39,000
>> 我可以點擊回到這種形式，但是這是為什麼呢？

1252
01:06:39,000 --> 01:06:43,000
那麼，在這種情況下，名稱是空的，但性別的，和宿舍，

1253
01:06:43,000 --> 01:06:47,000
所以整個表達式的計算結果為true，即使是一點點新的語法，

1254
01:06:47,000 --> 01:06:51,000
再次，我們進入PHP if語句模式，熟悉，

1255
01:06:51,000 --> 01:06:54,000
但新的部分是冒號，我搞砸了，省略了括號

1256
01:06:54,000 --> 01:06:57,000
偶然的，而是注意冒號，這意味著

1257
01:06:57,000 --> 01:07:00,000
即使我們退出PHP模式一切

1258
01:07:00,000 --> 01:07:03,000
應吐出一字不漏的瀏覽器

1259
01:07:03,000 --> 01:07:07,000
直到你看到一個else塊中，因為我們在這裡做的，

1260
01:07:07,000 --> 01:07:10,000
在這種情況下，你應該吐了這一點

1261
01:07:10,000 --> 01:07:13,000
直到你看到的ENDIF，所以微微有些新的語法

1262
01:07:13,000 --> 01:07:16,000
，讓我HTML和PHP之間的切換。

1263
01:07:16,000 --> 01:07:19,000
最終，我們可以清理它，但現在，

1264
01:07:19,000 --> 01:07:22,000
它是一種形式的錯誤檢查一個令人信服的方式。

1265
01:07:22,000 --> 01:07:25,000
>> 現在，我說你不是真的，因為很明顯，我們什麼也沒做，但數據註冊，

1266
01:07:25,000 --> 01:07:28,000
讓我們真正嘗試做一些很酷的東西。

1267
01:07:28,000 --> 01:07:33,000
在froshims3唯一的區別是，我會向寄存器3，

1268
01:07:33,000 --> 01:07:35,000
所以HTML是相同的。

1269
01:07:35,000 --> 01:07:38,000
在寄存器3注意到這一點。

1270
01:07:38,000 --> 01:07:40,000
這是一種性感。

1271
01:07:40,000 --> 01:07:44,000
我頂使用require語句中的，所以這是如＃include。

1272
01:07:44,000 --> 01:07:46,000
這一次，它不是stdio.h中或類似的東西。

1273
01:07:46,000 --> 01:07:50,000
這是一個PHP庫，以及一個被稱為PHPMailer的。

1274
01:07:50,000 --> 01:07:53,000
我怎麼知道正是這包括引號的字符串？

1275
01:07:53,000 --> 01:07:56,000
我讀了它在文件中，所以當他們告訴我把這個頂部的文件

1276
01:07:56,000 --> 01:08:00,000
如果你想使用一個特殊的庫稱為PHPMailer的，做什麼，它說。

1277
01:08:00,000 --> 01:08:03,000
它可以讓你通過發送電子郵件的PHP。

1278
01:08:03,000 --> 01:08:05,000
現在，讓我們繼續向下滾動。

1279
01:08:05,000 --> 01:08:08,000
>> 請注意，開始我在PHP模式，

1280
01:08:08,000 --> 01:08:11,000
所以，現在發現在這裡導入該庫後，

1281
01:08:11,000 --> 01:08:13,000
 可以這麼說，我做了一些合理性檢查。

1282
01:08:13,000 --> 01:08:16,000
如果它是這個名字不為空的情況下，

1283
01:08:16,000 --> 01:08:19,000
和性別是不為空，注意感嘆號

1284
01:08:19,000 --> 01:08:24,000
宿舍是不是空的，那麼用戶已在邏輯上填寫的表格，至少要有足夠。

1285
01:08:24,000 --> 01:08:28,000
我不在乎，如果他們的隊長或沒有。我只需要他們的姓名，性別，和宿舍。

1286
01:08:28,000 --> 01:08:31,000
如果他們填補這些了，沒有這些字段是空的

1287
01:08:31,000 --> 01:08:33,000
這是稍微新的語法。

1288
01:08:33,000 --> 01:08:36,000
順便說一句，PHP，是一個面向對象的編程語言

1289
01:08:36,000 --> 01:08:39,000
你們可能還記得從APCS或類似。

1290
01:08:39,000 --> 01:08:42,000
現在，如果不熟悉，只知道使用這個庫

1291
01:08:42,000 --> 01:08:45,000
你必須寫一行代碼，像這樣使用一個新的關鍵字，

1292
01:08:45,000 --> 01:08:47,000
從字面上一個新的關鍵字稱為新的。

1293
01:08:47,000 --> 01:08:50,000
但除此之外，我們有一些熟悉的語法。

1294
01:08:50,000 --> 01:08:54,000
這是一個箭頭操作符，我們使用的指針的上下文中的結構是類似的。

1295
01:08:54,000 --> 01:08:57,000
今天，PHP沒有指針，

1296
01:08:57,000 --> 01:09:01,000
但現在知道這裡面的郵件變量

1297
01:09:01,000 --> 01:09:05,000
本質上是善良的指針一個特殊的庫

1298
01:09:05,000 --> 01:09:08,000
別人說，如果我想訪問特定的功能

1299
01:09:08,000 --> 01:09:12,000
該庫裡面我做什麼，和C一樣，使用箭頭操作符，

1300
01:09:12,000 --> 01:09:14,000
即使這些實際上不是指針。

1301
01:09:14,000 --> 01:09:16,000
這是PHP自己的版本。

1302
01:09:16,000 --> 01:09:20,000
這意味著，去圖書館，和調用的IsSMTP的功能。

1303
01:09:20,000 --> 01:09:23,000
從我們的戰士的淨SMTP，召回，是指到電子郵件，

1304
01:09:23,000 --> 01:09:28,000
這只是意味著使用這個大一IMS註冊的電子郵件服務器。

1305
01:09:28,000 --> 01:09:30,000
>> 我要使用什麼主機？

1306
01:09:30,000 --> 01:09:34,000
那麼，哈佛，如果你谷歌周圍，有的郵件服務器smtp.fas.harvard.edu。

1307
01:09:34,000 --> 01:09:37,000
如果你在家裡打你住在一個Comcast網絡

1308
01:09:37,000 --> 01:09:40,000
它可能類似smtp.comcast.net。

1309
01:09:40,000 --> 01:09:43,000
這完全取決於你住在哪裡，你的ISP。

1310
01:09:43,000 --> 01:09:47,000
之後，我要我的地址任意jharvard@cs50.net。

1311
01:09:47,000 --> 01:09:52,000
然後，我打算設置解決jharvard@cs50.net的。

1312
01:09:52,000 --> 01:09:55,000
只有這樣，我知道，這些功能被稱為SetFrom和AddAddress

1313
01:09:55,000 --> 01:09:57,000
是，我再次閱讀文檔。

1314
01:09:57,000 --> 01:09:59,000
這是不樣的神奇的所有程序員。

1315
01:09:59,000 --> 01:10:02,000
然後，我定下了一個主題為“登記”。

1316
01:10:02,000 --> 01:10:07,000
現在有點難看，因為這條線是什麼點運算符的意思是在PHP？

1317
01:10:07,000 --> 01:10:09,000
任何人都知道嗎？

1318
01:10:09,000 --> 01:10:11,000
串聯。

1319
01:10:11,000 --> 01:10:14,000
在C語言中，這是一個痛苦在脖子上連接兩個字符串。

1320
01:10:14,000 --> 01:10:17,000
你必須處理malloc或realloc或所有的東西

1321
01:10:17,000 --> 01:10:20,000
只是延長其長度的字符串。

1322
01:10:20,000 --> 01:10:22,000
在PHP，JavaScript和其他語言

1323
01:10:22,000 --> 01:10:24,000
通常，你可以做一個單一的字符。

1324
01:10:24,000 --> 01:10:28,000
在這種情況下，點是指字符串

1325
01:10:28,000 --> 01:10:30,000
並追加到這個字符串。

1326
01:10:30,000 --> 01:10:32,000
>> 哦，順便說一下，追加到該字符串，

1327
01:10:32,000 --> 01:10:34,000
這恰好是，超全局變量裡面的。

1328
01:10:34,000 --> 01:10:37,000
然後附加到一個新的生產線，因此所有的這些點僅僅意味著

1329
01:10:37,000 --> 01:10:39,000
繼續作出越來越大，大字符串，

1330
01:10:39,000 --> 01:10:43,000
你不必關心在所有的malloc或類似這樣的語言，

1331
01:10:43,000 --> 01:10:46,000
有其他的方法來做到這一點，但是這是一個最快的

1332
01:10:46,000 --> 01:10:48,000
的方式展示出來。

1333
01:10:48,000 --> 01:10:50,000
這是什麼做的嗎？

1334
01:10:50,000 --> 01:10:55,000
它創建一個電子郵件正文中，要說出名字：船長：性別：宿舍：

1335
01:10:55,000 --> 01:10:58,000
在單獨的行，然後最後，

1336
01:10:58,000 --> 01:11:00,000
一行代碼，而我現在將忽略此。

1337
01:11:00,000 --> 01:11:02,000
如果== FALSE意味著，如果出事了，

1338
01:11:02,000 --> 01:11:04,000
但魔術在這裡發生的。

1339
01:11:04,000 --> 01:11:08,000
郵件發送方式發送這封電子郵件。

1340
01:11:08,000 --> 01:11:10,000
讓我們來看看最終的結果是什麼。

1341
01:11:10,000 --> 01:11:13,000
在該文件的底部，發現它會說你真的是註冊

1342
01:11:13,000 --> 01:11:15,000
如果我走到這一步。

1343
01:11:15,000 --> 01:11:18,000
不過，如果用戶螺絲，請注意，我們開始了這個

1344
01:11:18,000 --> 01:11:21,000
如果條件在這裡，如果它不是空的，而不是空

1345
01:11:21,000 --> 01:11:24,000
，而不是空的，我們發送的郵件。

1346
01:11:24,000 --> 01:11:27,000
否則，我們將發送下面這行代碼，

1347
01:11:27,000 --> 01:11:30,000
這是有效果，你會看到在pset中7，將用戶重定向

1348
01:11:30,000 --> 01:11:35,000
回到他們原來的地方，froshims3.php。

1349
01:11:35,000 --> 01:11:38,000
>> 手指交叉，否則，這將是今天最令人失望的演示。

1350
01:11:38,000 --> 01:11:40,000
在這裡，我們走了。

1351
01:11:40,000 --> 01:11:42,000
讓我打開我的郵箱在Gmail的收件箱jharvard。

1352
01:11:42,000 --> 01:11:44,000
現在沒有電子郵件。好的。

1353
01:11:44,000 --> 01:11:53,000
現在讓我開了froshims3，這是第三個也是最後一個例子，我們來看看在這裡。

1354
01:11:53,000 --> 01:11:55,000
好了，在這裡，我們走了。

1355
01:11:55,000 --> 01:12:00,000
內特，他會是隊長，男，說，Apley。

1356
01:12:00,000 --> 01:12:04,000
註冊。好吧，你真的註冊。

1357
01:12:04,000 --> 01:12:07,000
如果我現在滾動到我的郵箱，哦，我的上帝。

1358
01:12:07,000 --> 01:12:09,000
我剛才動態在網絡上發送了一封電子郵件。

1359
01:12:09,000 --> 01:12:11,000
>> 讓我們留在那筆記。

1360
01:12:11,000 --> 01:12:16,000
一個視頻是即將到來的演講中，我們錯過了。下週見。

1361
01:12:16,000 --> 01:12:18,000
[CS50.TV]