1
00:00:00,000 --> 00:00:02,150
>> [講座] [Kohana的：一個輕量級PHP框架]

2
00:00:02,150 --> 00:00:04,000
[劉布蘭登] [哈佛大學]

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

4
00:00:07,270 --> 00:00:09,130
>>大家好。我的名字是布蘭登。

5
00:00:09,130 --> 00:00:11,000
我是一個大三在這裡的大學做計算機科學，今天我們要談

6
00:00:11,000 --> 00:00:14,460
Kohana的，這是一個PHP的Web開發框架。

7
00:00:14,460 --> 00:00:17,260
今天將是一個活的編碼研討會上，

8
00:00:17,260 --> 00:00:21,000
所以我基本上要花費5-10分鐘解釋什麼是Kohana的是，

9
00:00:21,000 --> 00:00:25,000
然後我簡直要建立一個超級簡單的博客

10
00:00:25,000 --> 00:00:28,570
你從頭開始就在這裡字面上。

11
00:00:28,570 --> 00:00:32,229
我們打算從Kohana的網站上下載代碼，

12
00:00:32,229 --> 00:00:35,000
而且我們要開始建立一個博客，並希望這將是非常有益的，

13
00:00:35,000 --> 00:00:37,000
因為你會看到也許也許我會犯一些錯誤，

14
00:00:37,000 --> 00:00:39,000
你會看到我從中恢復，

15
00:00:39,000 --> 00:00:42,040
或者你會看到我的思考過程，因為我建立通過這個博客，

16
00:00:42,040 --> 00:00:44,000
而同時，你也將獲得熟悉框架本身。

17
00:00:44,000 --> 00:00:48,000
希望這將是一個非常有啟發性的運動。

18
00:00:48,000 --> 00:00:51,370
>>首先，究竟什麼是框架？

19
00:00:51,370 --> 00:00:54,000
如果你一直在服用CS50到目前為止，你還沒有真正曾與任何

20
00:00:54,000 --> 00:00:56,000
框架著呢，事情是這樣的。

21
00:00:56,000 --> 00:01:00,000
你可能已經做了1 web開發PSET已經，

22
00:01:00,000 --> 00:01:03,000
讓我們說你繼續建立網站，並保持網站建設。

23
00:01:03,000 --> 00:01:05,000
你會開始注意到一些事情。

24
00:01:05,000 --> 00:01:07,000
你會注意到的第一件事情是，你可能做同樣的事情

25
00:01:07,000 --> 00:01:09,150
一遍又一遍的時候，

26
00:01:09,150 --> 00:01:13,000
之類的東西清理用戶輸入的數據，

27
00:01:13,000 --> 00:01:17,250
事情，比如組織以某種方式文件。

28
00:01:17,250 --> 00:01:19,000
你也可能注意到的另一件事是，你的代碼

29
00:01:19,000 --> 00:01:21,000
可能開始變得非常，非常凌亂，

30
00:01:21,000 --> 00:01:24,000
你可以把它凌亂，只是有一個非常困難時期維護它，

31
00:01:24,000 --> 00:01:26,000
或者您可以開始構建你的代碼，並使其模塊化

32
00:01:26,000 --> 00:01:28,510
在某些方面，使之更易於維護。

33
00:01:28,510 --> 00:01:31,020
>>這是Web框架基本上走了進來。

34
00:01:31,020 --> 00:01:33,680
這些人誰已經建立了很多網站，他們說，

35
00:01:33,680 --> 00:01:35,820
“我們並不需要重做這每一次我們建立了一個網站。”

36
00:01:35,820 --> 00:01:39,050
“為什麼我們不只是做一個包，做所有這些事情對你

37
00:01:39,050 --> 00:01:41,250
每一次你想建立一個網站？“

38
00:01:41,250 --> 00:01:43,030
所以，當你做一個新網站，

39
00:01:43,030 --> 00:01:45,880
你只關注究竟這個特殊的網站是關於。

40
00:01:45,880 --> 00:01:48,630
你不必重複所有的各種配置

41
00:01:48,630 --> 00:01:53,070
和代碼的分離和重寫代碼

42
00:01:53,070 --> 00:01:56,180
你經常有，當你正在做的網站做。

43
00:01:56,180 --> 00:01:59,410
這個想法是，一​​個框架，允許你寫一個更高級別的代碼

44
00:01:59,410 --> 00:02:01,030
而不必擔心低級別的細節。

45
00:02:01,030 --> 00:02:03,670
較低層次的細節可能是這樣的

46
00:02:03,670 --> 00:02:07,250
處理清洗用戶輸入數據。

47
00:02:07,250 --> 00:02:09,320
在這個時候，你應該不是真的需要擔心。

48
00:02:09,320 --> 00:02:12,370
你應著眼於你的web配置內容到底如何。

49
00:02:12,370 --> 00:02:14,790
它消除了大量的樣板代碼。

50
00:02:14,790 --> 00:02:16,640
這是為您的項目的架構。

51
00:02:16,640 --> 00:02:18,680
>>最流行的一種是模型 - 視圖 - 控制器，

52
00:02:18,680 --> 00:02:20,380
而我要談的第二個。

53
00:02:20,380 --> 00:02:22,790
並且很多時候這些框架體現了一套程序，

54
00:02:22,790 --> 00:02:25,750
供您使用的規則和最佳實踐

55
00:02:25,750 --> 00:02:28,190
這樣，當你採用Web框架

56
00:02:28,190 --> 00:02:30,050
你必須編寫代碼以某種方式，

57
00:02:30,050 --> 00:02:32,430
而且它一般是一套原則商定

58
00:02:32,430 --> 00:02:34,290
由被普遍接受的是社會

59
00:02:34,290 --> 00:02:36,230
編寫代碼的好方法。

60
00:02:36,230 --> 00:02:38,260
它使你的代碼更容易維護，更實用，

61
00:02:38,260 --> 00:02:40,030
依此類推等等。

62
00:02:40,030 --> 00:02:42,740
最後，我想要的東西，強調有關框架

63
00:02:42,740 --> 00:02:45,980
與庫是這種想法對控制反轉，而事情是這樣的。

64
00:02:45,980 --> 00:02:48,430
之間的庫和框架的不同之處在於用一個圖書館

65
00:02:48,430 --> 00:02:51,990
你還在編寫主程序，

66
00:02:51,990 --> 00:02:54,460
而你那種調用庫

67
00:02:54,460 --> 00:02:56,810
並呼籲圖書館要為你做些什麼。

68
00:02:56,810 --> 00:02:58,180
之間的一個圖書館和一個框架的區別

69
00:02:58,180 --> 00:03:01,620
是，框架開始時與對照，

70
00:03:01,620 --> 00:03:03,260
它調用你的代碼，

71
00:03:03,260 --> 00:03:06,190
所以你可以把它看作是 - 這就是為什麼它被稱為一個框架 - 

72
00:03:06,190 --> 00:03:09,700
該框架提供了這個框架和結構，為您的代碼，

73
00:03:09,700 --> 00:03:11,320
而您在孔填充，

74
00:03:11,320 --> 00:03:13,990
這將在第二變得更加明顯

75
00:03:13,990 --> 00:03:16,670
當你看到我開始的框架範圍內編寫代碼。

76
00:03:16,670 --> 00:03:19,130
你會看到，我填補國內空白，

77
00:03:19,130 --> 00:03:22,450
該框架是一種控制所有移動件，

78
00:03:22,450 --> 00:03:27,420
我必須把碎片在正確的地方。

79
00:03:27,420 --> 00:03:29,360
>>今天我們要談的Kohana，

80
00:03:29,360 --> 00:03:31,610
這是許多PHP框架之一。

81
00:03:31,610 --> 00:03:34,550
還有Web框架，並且有那些在幾乎每一個單一的語言，

82
00:03:34,550 --> 00:03:38,330
而且我撿Kohana的，因為Kohana的可以說是

83
00:03:38,330 --> 00:03:43,250
一般公認的最簡單的PHP框架回升。

84
00:03:43,250 --> 00:03:45,940
這是最輕巧的。

85
00:03:45,940 --> 00:03:48,470
還有其他的人在那裡，拿出很多很多的功能，

86
00:03:48,470 --> 00:03:51,590
但他們往往更難以回暖。

87
00:03:51,590 --> 00:03:54,920
最後，Kohana中使用MVC架構。

88
00:03:54,920 --> 00:03:57,780
它的重量足夠輕，我們可以從字面上建設項目

89
00:03:57,780 --> 00:03:59,620
在這裡就在你眼前，你幾乎可以

90
00:03:59,620 --> 00:04:02,780
跟著很容易。

91
00:04:02,780 --> 00:04:04,420
>> MVC架構是什麼？

92
00:04:04,420 --> 00:04:06,540
它代表了模型 - 視圖 - 控制器，

93
00:04:06,540 --> 00:04:09,560
也許，如果你想想你的代碼已經寫了這麼遠

94
00:04:09,560 --> 00:04:11,280
對於你的一些web開發的pset

95
00:04:11,280 --> 00:04:14,710
你也許能看到一些這方面，但通常當你開始寫作

96
00:04:14,710 --> 00:04:16,500
一個更複雜的網絡應用程序，

97
00:04:16,500 --> 00:04:21,209
這3段之間的分工變得越來越明顯。

98
00:04:21,209 --> 00:04:26,740
我制定了對MVC這裡有點作為一個堆棧，

99
00:04:26,740 --> 00:04:29,920
而且往往你會聽到人們談論棧在網絡的發展，

100
00:04:29,920 --> 00:04:33,760
這是為了說明的想法

101
00:04:33,760 --> 00:04:37,510
每一層，每個組件真的只試圖溝通

102
00:04:37,510 --> 00:04:40,750
之間2等組成。

103
00:04:40,750 --> 00:04:44,550
有人訪問你的網站作為客戶端或瀏覽器。

104
00:04:44,550 --> 00:04:48,870
他們通過查看代碼與你的程序進行交互。

105
00:04:48,870 --> 00:04:50,500
與控制器的視圖代碼進行交互。

106
00:04:50,500 --> 00:04:52,400
該控制器與模型進行交互，

107
00:04:52,400 --> 00:04:55,090
與模型進行交互的SQL數據庫。

108
00:04:55,090 --> 00:04:59,670
如果你正確地寫你的代碼中有中間沒有跳躍。

109
00:04:59,670 --> 00:05:01,670
>>什麼做這些事情呢？

110
00:05:01,670 --> 00:05:06,020
該模型基本上是一段代碼，與您的數據處理。

111
00:05:06,020 --> 00:05:09,100
凡是與數據庫處理，與你存儲的對象，

112
00:05:09,100 --> 00:05:11,280
或檢索數據庫中的那些對象，

113
00:05:11,280 --> 00:05:13,450
這是所有的模型來處理。

114
00:05:13,450 --> 00:05:15,290
也許你有你的數據庫對象。

115
00:05:15,290 --> 00:05:17,700
我們要創建不得不與崗位的典範，

116
00:05:17,700 --> 00:05:19,760
這樣一個職位可能有一些屬性給它。

117
00:05:19,760 --> 00:05:23,900
您可能必須圍繞存儲的職位或崗位檢索功能

118
00:05:23,900 --> 00:05:26,270
或過濾的職位等等等等，

119
00:05:26,270 --> 00:05:28,880
而這一切是由模型處理的代碼。

120
00:05:28,880 --> 00:05:31,780
該控制器是排序的應用程序邏輯，

121
00:05:31,780 --> 00:05:37,910
和很多不同的東西可以去在應用程序邏輯。

122
00:05:37,910 --> 00:05:39,790
如果你在談論一個不同的API，

123
00:05:39,790 --> 00:05:42,310
這也許就是你正在處理的應用程序邏輯。

124
00:05:42,310 --> 00:05:47,990
如果你想有帶來來自多個不同的數據模型

125
00:05:47,990 --> 00:05:51,540
並具有將它們結合起來，在某種程度上，這經常可以由控制器來處理。

126
00:05:51,540 --> 00:05:53,820
例如，在Facebook，如果你的朋友的人，

127
00:05:53,820 --> 00:05:58,500
建立這種關係的話，或許這種行為

128
00:05:58,500 --> 00:06:00,490
可以由控制器來完成。

129
00:06:00,490 --> 00:06:04,350
>>最後，認為是這是生成您實際看到的代碼。

130
00:06:04,350 --> 00:06:07,410
很多時候，我覺得在CS50的pset

131
00:06:07,410 --> 00:06:10,050
他們真的不鼓勵你們分開這三件事。

132
00:06:10,050 --> 00:06:12,430
你會在頂部可能有這樣大的，長的文件，其中

133
00:06:12,430 --> 00:06:15,130
你做一些SQL查詢，也許做一些處理

134
00:06:15,130 --> 00:06:17,020
在你的數據從數據庫中檢索，

135
00:06:17,020 --> 00:06:19,370
然後你把所有的HTML的底部。

136
00:06:19,370 --> 00:06:22,840
你可能會發現，當你創造更多的頁面

137
00:06:22,840 --> 00:06:25,790
你要去有一些代碼的重複，而且，

138
00:06:25,790 --> 00:06:29,600
事情是你的文件變得非常大又長

139
00:06:29,600 --> 00:06:32,370
並且變得難於管理。

140
00:06:32,370 --> 00:06:34,500
之所以MVC是這麼好視

141
00:06:34,500 --> 00:06:36,120
為幾個原因。

142
00:06:36,120 --> 00:06:38,110
的第一件事就是一些所謂的關注點分離

143
00:06:38,110 --> 00:06:40,370
這是想法，當你有 - 

144
00:06:40,370 --> 00:06:43,520
1理想一段代碼應該做的1件事，做到這一點真的很好，

145
00:06:43,520 --> 00:06:47,210
你不應該合併的代碼片段，做不同的事情。

146
00:06:47,210 --> 00:06:49,230
例如，查看代碼和模型代碼，

147
00:06:49,230 --> 00:06:51,040
他們並不真正需要有關。

148
00:06:51,040 --> 00:06:53,290
他們不必在同一個文件中，所以當你可以，將它們分開了

149
00:06:53,290 --> 00:06:55,300
所以很容易維護。

150
00:06:55,300 --> 00:06:57,130
>>另一件事是代碼重用。

151
00:06:57,130 --> 00:06:59,770
您可能會發現自己寫相同的SQL查詢或做

152
00:06:59,770 --> 00:07:03,060
類似的查詢，可以被抽象成1的功能，

153
00:07:03,060 --> 00:07:05,440
而這背後的思想模型和控制器，

154
00:07:05,440 --> 00:07:09,690
有它在一個單獨的函數，你可以在不同的地方重複使用您的項目。

155
00:07:09,690 --> 00:07:12,420
最後，這是綁在曬你的代碼，

156
00:07:12,420 --> 00:07:14,700
或不重複自己，不重複自己。

157
00:07:14,700 --> 00:07:18,090
這是非常可以理解的發展。

158
00:07:18,090 --> 00:07:20,110
只要你能，你不想重複自己，因為如果你重複自己，

159
00:07:20,760 --> 00:07:23,400
 它更昂貴的維護。

160
00:07:23,400 --> 00:07:26,040
如果你想改變1件事，你要到處改變它，

161
00:07:26,040 --> 00:07:30,230
並導致錯誤，而這是可怕的。

162
00:07:30,230 --> 00:07:32,010
>>所有權利。

163
00:07:32,010 --> 00:07:37,270
任何迄今為止關於Kohana的問題呢？

164
00:07:37,270 --> 00:07:39,200
大。

165
00:07:39,200 --> 00:07:42,300
現在，我們要深入現場編碼會話，

166
00:07:42,300 --> 00:07:48,050
並希望一切順利。

167
00:07:57,200 --> 00:08:00,050
我要基本建成本網站

168
00:08:00,050 --> 00:08:03,910
在我的一個遠程服務器，並且這樣你們也可以

169
00:08:03,910 --> 00:08:06,310
看網站和訪問該網站，

170
00:08:06,310 --> 00:08:10,990
也是環境比我的遠程機器更好的配置

171
00:08:10,990 --> 00:08:14,580
因為它的運行，而不是OS X上的Linux

172
00:08:14,580 --> 00:08:16,260
我們確實要開始。

173
00:08:16,260 --> 00:08:18,110
KohanaFramework.org。

174
00:08:18,110 --> 00:08:21,350
我會從網站上下載的代碼。

175
00:08:21,350 --> 00:08:24,610
我要去複製鏈接地址，

176
00:08:24,610 --> 00:08:29,770
去我的服務器，下載它，

177
00:08:29,770 --> 00:08:33,000
和我要提取它。

178
00:08:38,330 --> 00:08:45,710
>> [學生]什麼是你可以使文本最大？

179
00:08:45,710 --> 00:08:47,330
[布蘭登劉]那是更好嗎？

180
00:08:47,330 --> 00:08:50,070
[學生]那是可行的？>> [布蘭登劉]是啊，這很好。

181
00:08:50,070 --> 00:08:54,500
我下載一個ZIP文件，解壓縮該到一個名為Kohana的目錄，

182
00:08:54,500 --> 00:08:58,820
而且我們要重新命名CS50-Kohana的，

183
00:08:58,820 --> 00:09:01,140
並讓我們進去。

184
00:09:01,140 --> 00:09:03,610
真棒。

185
00:09:03,610 --> 00:09:06,870
在這裡，你看到一堆不同的文件。

186
00:09:06,870 --> 00:09:10,140
大多數時候，你可以忽略 - 方向走，不會去通過每一個文件，該文件在這裡

187
00:09:10,140 --> 00:09:13,130
因為我們的時間有限，

188
00:09:13,130 --> 00:09:16,310
但通常，當您安裝Kohana的，你要做的第一件事

189
00:09:16,310 --> 00:09:23,210
是你去的目錄，

190
00:09:23,210 --> 00:09:26,050
你會基本上做一些環境測試和諸如此類的東西

191
00:09:26,050 --> 00:09:28,640
以確保您的環境已正確設置運行Kohana的

192
00:09:28,640 --> 00:09:31,450
並確保一切都正確無誤。

193
00:09:31,450 --> 00:09:35,510
你可以看到大部分事情過去了，但通常你總是遇到這樣的問題1

194
00:09:35,510 --> 00:09:38,180
它抱怨說，有些目錄不可寫，

195
00:09:38,180 --> 00:09:40,410
那是因為一些權限。

196
00:09:40,410 --> 00:09:43,080
我不知道有多少你們已經了解了CS50文件權限，

197
00:09:43,080 --> 00:09:47,920
但如果你做網站開發，你會遇到這樣的問題很多。

198
00:09:47,920 --> 00:09:58,340
我要使其可寫

199
00:09:58,340 --> 00:10:03,390
我想我也有 - 我們走吧。

200
00:10:03,390 --> 00:10:07,040
>>好了，現在你可以看到一切過去了，

201
00:10:07,040 --> 00:10:10,000
而現在它會告訴你重命名install.php了。

202
00:10:10,000 --> 00:10:15,630
我要去移動的install.php文件installed.php，

203
00:10:15,630 --> 00:10:19,610
而現在，如果我刷新，

204
00:10:19,610 --> 00:10:22,810
它給了我一些錯誤，而這正是調試用武之地。

205
00:10:22,810 --> 00:10:25,610
在這裡，你可以看到什麼實際事情發生。

206
00:10:25,610 --> 00:10:28,460
問題是，在默認情況下，Kohana的假設

207
00:10:28,460 --> 00:10:31,480
你的項目是在您的域的根目錄下，

208
00:10:31,480 --> 00:10:35,920
因此它希望你能在demo.brandonkliu.com。

209
00:10:35,920 --> 00:10:37,540
我們要告訴它，它實際上是在一個子文件夾。

210
00:10:37,540 --> 00:10:39,820
這是在一個名為CS50 Kohana的子文件夾。

211
00:10:39,820 --> 00:10:42,640
關鍵是，它的曲解CS50-Kohana的

212
00:10:42,640 --> 00:10:45,680
作為別的東西，我會解釋給你在第二。

213
00:10:45,680 --> 00:10:49,910
但我要告訴你的東西，是可以預料的。

214
00:10:49,910 --> 00:10:53,700
我們現在要做的是，我們要進入這個文件夾，名為bootstrap.php，

215
00:10:53,700 --> 00:10:59,260
這是很多不同的東西都設置的配置文件夾。

216
00:10:59,260 --> 00:11:01,570
我打開了。

217
00:11:01,570 --> 00:11:09,790
那麼也許的第一件事情我會做一個是更改時區。

218
00:11:09,790 --> 00:11:13,910
>>然後讓我們來看看。

219
00:11:13,910 --> 00:11:15,180
啊哈！就在這兒。

220
00:11:15,180 --> 00:11:18,690
有一堆不同的配置說法在這裡，

221
00:11:18,690 --> 00:11:21,700
但一來我要找的就是這個東西叫做基本URL，

222
00:11:21,700 --> 00:11:24,570
並且在默認情況下我得到它設置為Kohana的，

223
00:11:24,570 --> 00:11:29,020
但我要改變，要CS50-Kohana的，

224
00:11:29,020 --> 00:11:32,880
我認為應該修復它。

225
00:11:32,880 --> 00:11:34,150
是的，偉大的。

226
00:11:34,150 --> 00:11:39,530
默認情況下，一看就知道它的工作，它說，“你好世界”。

227
00:11:39,530 --> 00:11:42,930
哪裡來的？我們是如何來的Hello World？

228
00:11:42,930 --> 00:11:47,640
究竟出在哪裡，實際上寫的代碼？

229
00:11:47,640 --> 00:11:50,240
要理解這一點，我將介紹這個概念叫做路由。

230
00:11:50,240 --> 00:11:52,590
幾乎所有的web框架有一個叫做路由的概念，

231
00:11:52,590 --> 00:11:57,230
這是一塊軟件，將映射特定的URL

232
00:11:57,230 --> 00:12:01,550
到一定的一段代碼的框架內。

233
00:12:01,550 --> 00:12:07,510
例如，如果你有一些網址，你去一些URL如foo.com /博客/全部

234
00:12:07,510 --> 00:12:11,170
那麼什麼樣的框架是要幹什麼 - 或者至少是Kohana的是要幹什麼 - 

235
00:12:11,170 --> 00:12:15,540
是它要找到一個類調用控制器的博客，

236
00:12:15,540 --> 00:12:18,720
並且它會運行一個名為功能操作的所有。

237
00:12:18,720 --> 00:12:20,160
我知道我說的類和函數，

238
00:12:20,160 --> 00:12:23,860
我知道你們還沒有涉及到的類和函數

239
00:12:23,860 --> 00:12:26,470
在CS50還，但就目前而言，

240
00:12:26,470 --> 00:12:29,800
你能想到的類作為只是一組函數，

241
00:12:29,800 --> 00:12:32,900
一種方式分組功能結合在一起的。

242
00:12:32,900 --> 00:12:37,690
這的確是所有你需要知道的。

243
00:12:37,690 --> 00:12:43,120
>>現在，如果我們看我們的文件夾結構，

244
00:12:43,120 --> 00:12:47,110
應用程序文件夾裡面有一個叫班另一個文件夾，

245
00:12:47,110 --> 00:12:49,200
和其他文件夾被稱為控制器和模型。

246
00:12:49,200 --> 00:12:52,530
如果你看看控制器的文件夾裡面，

247
00:12:52,530 --> 00:12:56,330
我們看到，有一個叫歡迎文件，

248
00:12:56,330 --> 00:13:00,370
你可以在這裡看到的是一類叫做控制器歡迎，

249
00:13:00,370 --> 00:13:02,340
並有一個稱為動作指數函數

250
00:13:02,340 --> 00:13:06,360
和它做什麼是它設置你的回應的Hello World的身體。

251
00:13:06,360 --> 00:13:08,730
這其中的代碼被寫入。

252
00:13:08,730 --> 00:13:11,610
另一個問題是，好了，我沒有去

253
00:13:11,610 --> 00:13:13,680
胡說，胡說，胡說，/歡迎/索引。

254
00:13:13,680 --> 00:13:16,250
我怎麼會在這裡結束？

255
00:13:16,250 --> 00:13:20,410
嗯，這僅僅是因為

256
00:13:20,410 --> 00:13:22,410
在這裡我們的啟動文件的底部

257
00:13:22,410 --> 00:13:24,550
在這裡我們設置我們的路線

258
00:13:24,550 --> 00:13:26,570
你可以看到，他們設置一些默認值給你。

259
00:13:26,570 --> 00:13:28,990
默認控制器是歡迎。默認操作是指數。

260
00:13:28,990 --> 00:13:31,600
這就是為什麼當我們把什麼在那裡它會自動跑到歡迎控制器

261
00:13:31,600 --> 00:13:33,940
和索引操作。

262
00:13:33,940 --> 00:13:37,460
>>更多有意義這麼遠嗎？

263
00:13:37,460 --> 00:13:40,850
現在，你可以做的不僅僅是去控制器

264
00:13:40,850 --> 00:13:43,670
和具體的行動。

265
00:13:43,670 --> 00:13:48,480
您也可以傳遞參數給控制器。

266
00:13:48,480 --> 00:13:56,390
只是作為一個例子，

267
00:13:56,390 --> 00:14:04,070
我要添加另一個行動，該控制器向您展示。

268
00:14:04,070 --> 00:14:09,130
讓我們把這個動作回音，因為它會告訴你，無論你給它，

269
00:14:09,130 --> 00:14:17,510
所以我基本上要搶

270
00:14:17,510 --> 00:14:20,960
一個參數，那將通過我被送到路由程序，

271
00:14:20,960 --> 00:14:24,440
正如你可以在這裡看到，

272
00:14:24,440 --> 00:14:28,440
這條線就在這裡，你可以看到，

273
00:14:28,440 --> 00:14:31,270
這基本上意味著你有控制器，和你有一個/，

274
00:14:31,270 --> 00:14:33,480
你必須採取行動，和你有另一/，

275
00:14:33,480 --> 00:14:39,140
那將是參數，因為我們有這個名字的ID

276
00:14:39,140 --> 00:14:42,450
尖括號內，這意味著我們命名這個參數標識。

277
00:14:42,450 --> 00:14:45,490
在我的控制器代碼後，如果我想要抓住保持該參數，

278
00:14:45,490 --> 00:14:51,790
我可以用我寫的代碼，找到名為ID的參數。

279
00:14:51,790 --> 00:14:59,290
這就是我在這裡，和我要回來，說，

280
00:14:59,290 --> 00:15:07,090
“你說的”這一點。

281
00:15:07,090 --> 00:15:10,760
所以現在如果我去我們的網站，

282
00:15:10,760 --> 00:15:19,550
我去cs50-kohana/welcome/echo/Helloooo--

283
00:15:19,550 --> 00:15:21,420
哦，這是正確的。

284
00:15:21,420 --> 00:15:23,930
有1步我離開了。

285
00:15:23,930 --> 00:15:27,020
這是實時編碼構思的一部分。

286
00:15:27,020 --> 00:15:36,100
>>這裡是1的事情。讓我們來看看。

287
00:15:36,100 --> 00:15:38,870
所以，通常在默認情況下有很多的這些Web應用程序

288
00:15:38,870 --> 00:15:42,820
你必須包含這個index.php的事情在您的網址，

289
00:15:42,820 --> 00:15:46,410
因為想法的index.php是排序的入口點

290
00:15:46,410 --> 00:15:48,250
您的應用程序，但是，當然

291
00:15:48,250 --> 00:15:50,110
這就是有點兒煩也。

292
00:15:50,110 --> 00:15:53,790
你不希望有index.php文件出現在您的網址，

293
00:15:53,790 --> 00:15:56,080
而幾乎每一個Web框架的開箱

294
00:15:56,080 --> 00:15:58,440
有這個index.php的問題，

295
00:15:58,440 --> 00:16:03,370
所以你必須採取一些措施，可以刪除。

296
00:16:03,370 --> 00:16:07,540
所以在這種情況下，

297
00:16:07,540 --> 00:16:11,450
我們要做的是什麼，我們要使用一個名為。htaccess文件，

298
00:16:11,450 --> 00:16:13,900
這是東西是特定於Apache Web服務器，

299
00:16:13,900 --> 00:16:16,290
它可以做這樣的事情的URL重寫

300
00:16:16,290 --> 00:16:19,350
和重定向的URL等等等等，

301
00:16:19,350 --> 00:16:24,280
和Kohana的是不夠好，提供我們可以使用模板。htaccess文件。

302
00:16:24,280 --> 00:16:28,300
>>正如你可以看到，有一個文件叫做有ex​​ample.htaccess，

303
00:16:28,300 --> 00:16:33,410
而且我們要複製到的。htaccess。

304
00:16:33,410 --> 00:16:36,950
我要打開這個編輯它，

305
00:16:36,950 --> 00:16:40,840
基本上它做了一堆不同的東西。

306
00:16:40,840 --> 00:16:45,320
你可能想看看重點線就在這裡。

307
00:16:45,320 --> 00:16:49,840
我們的想法是，這設置了一個規則說，

308
00:16:49,840 --> 00:16:56,400
“好吧，不管你輸入，前面加上index.php來了。”

309
00:16:56,400 --> 00:16:58,710
你可以看到這一點。

310
00:16:58,710 --> 00:17:00,370
的*代表什麼，搭配什麼，

311
00:17:00,370 --> 00:17:03,300
然後第二部分是index.php文件/ 0元，

312
00:17:03,300 --> 00:17:07,410
及$ 0指的是任何先前匹配。

313
00:17:07,410 --> 00:17:09,500
這是否有道理？

314
00:17:09,500 --> 00:17:12,190
但我想改變真正關鍵的是改變這種重寫基地，

315
00:17:12,190 --> 00:17:14,300
這是該URL基礎。

316
00:17:14,300 --> 00:17:17,780
它有點兒假設​​你來自哪裡工作。

317
00:17:17,780 --> 00:17:22,560
我要CS50 Kohana的補充，

318
00:17:22,560 --> 00:17:26,530
而這種方式現在如果我去掉index.php文件，

319
00:17:26,530 --> 00:17:32,110
它應該工作，和我將要添加一些數字

320
00:17:32,110 --> 00:17:36,380
告訴你，它確實沒有工作。

321
00:17:36,380 --> 00:17:38,130
聽起來不錯。

322
00:17:38,130 --> 00:17:40,260
>>到目前為止，有問題嗎？

323
00:17:40,260 --> 00:17:42,300
[學生]這是如何知道要123？

324
00:17:42,300 --> 00:17:44,120
是的說法呢？

325
00:17:44,120 --> 00:17:46,560
沒錯。你可以認為它就像一個說法。

326
00:17:46,560 --> 00:17:52,410
但奇怪的事情，不過，是Kohana的做它的方式

327
00:17:52,410 --> 00:17:54,910
是他們不這樣做完全一樣的參數。

328
00:17:54,910 --> 00:17:56,930
你必須抓住它，像這樣。

329
00:17:56,930 --> 00:18:01,030
你必須抓住的請求對象，並要求該公司名為ID的參數，

330
00:18:01,030 --> 00:18:03,240
那名ID來自於引導文件

331
00:18:03,240 --> 00:18:06,990
我表現出早了，該名ID是在那些尖括號，

332
00:18:06,990 --> 00:18:11,580
這就是你如何抓住這些參數。

333
00:18:11,580 --> 00:18:14,010
真棒。

334
00:18:14,010 --> 00:18:17,550
還有沒有其他問題？

335
00:18:17,550 --> 00:18:20,500
就像我說的，控制器，他們處理應用邏輯，

336
00:18:20,500 --> 00:18:22,980
所以這1個實例，你可以看到佼佼者 - 

337
00:18:22,980 --> 00:18:24,830
這是非常基本的，但它仍然是應用程序邏輯，

338
00:18:24,830 --> 00:18:27,980
抓住了參數並創建一個新的字符串的想法

339
00:18:27,980 --> 00:18:31,920
上面寫著，“你說廢話”，然後吐了還給你。

340
00:18:31,920 --> 00:18:34,030
一般你要做的就是創建不同的控制器。

341
00:18:34,030 --> 00:18:36,450
您為您的網站的不同部分單獨的控制器。

342
00:18:36,450 --> 00:18:38,160
>>今天，我們將提出一個非常簡單的網站，

343
00:18:38,160 --> 00:18:40,420
而這將是一個非常基本的博客。

344
00:18:40,420 --> 00:18:43,780
我們將創建一個新的控制器只是在博客中的帖子。

345
00:18:43,780 --> 00:18:47,060
但是如果我還添加註釋到博客文章，

346
00:18:47,060 --> 00:18:50,140
然後我可能會想為這些意見一個新的控制器。

347
00:18:50,140 --> 00:18:53,380
如果我想添加的用戶，我可能會添加這些用戶一個新的控制器，

348
00:18:53,380 --> 00:18:57,000
而在一般情況下，這個想法是，只要你有一個新的模式，

349
00:18:57,000 --> 00:18:59,630
你正在處理一個新的數據對象，

350
00:18:59,630 --> 00:19:02,970
你有這些數據對象的單個控制器。

351
00:19:02,970 --> 00:19:04,370
今天，我們只打算用1個數據對象的工作，

352
00:19:04,370 --> 00:19:06,250
那將是帖子，

353
00:19:06,250 --> 00:19:08,710
，你也可以把數據對象對應於表。

354
00:19:08,710 --> 00:19:12,160
通常每個表對應於1類型的數據對象，

355
00:19:12,160 --> 00:19:15,160
因此該職位表將有1篇文章模型，

356
00:19:15,160 --> 00:19:18,230
這將具有對應於1交控制器

357
00:19:18,230 --> 00:19:22,190
和相同的意見中，相同的用戶，依此類推等等。

358
00:19:22,190 --> 00:19:24,070
這就是一般的經驗法則。

359
00:19:24,070 --> 00:19:27,460
這裡將是特殊情況下，您可能不同於，

360
00:19:27,460 --> 00:19:29,300
但90％的時候，就是你要什麼做的，

361
00:19:29,300 --> 00:19:32,810
我會告訴你，就是我們今天將要幹什麼。

362
00:19:32,810 --> 00:19:35,490
1之前，我們深入放回代碼更概念，

363
00:19:35,490 --> 00:19:37,710
這個想法對象關係映射。

364
00:19:37,710 --> 00:19:41,200
>>你們已經做了Web開發的pset，

365
00:19:41,200 --> 00:19:43,820
和你見過，你做一個SQL查詢，

366
00:19:43,820 --> 00:19:46,510
也不論它返回到你的行。

367
00:19:46,510 --> 00:19:50,040
你得到這些行，你為它們編制索引的一些名稱，

368
00:19:50,040 --> 00:19:55,480
列和表的名稱，

369
00:19:55,480 --> 00:19:57,630
這就是你的工作吧，

370
00:19:57,630 --> 00:19:59,290
它可以是一個有點麻煩。

371
00:19:59,290 --> 00:20:01,810
但此外，如果你有你的數據庫中的關係，

372
00:20:01,810 --> 00:20:05,280
例如像如果我有評論和帖子，

373
00:20:05,280 --> 00:20:11,240
那麼也許我要搶註釋的父職。

374
00:20:11,240 --> 00:20:14,350
如果我在SQL中使用剛剛行，那我只能得到的是ID

375
00:20:14,350 --> 00:20:19,310
父職位，而不是實際的職位本身。

376
00:20:19,310 --> 00:20:21,680
但是，當我們編碼，其實我們要的是真正搶

377
00:20:21,680 --> 00:20:23,550
 父後本身有時。

378
00:20:23,550 --> 00:20:25,730
什麼對象關係映射確實是

379
00:20:25,730 --> 00:20:29,480
它需要對數據庫查詢的結果

380
00:20:29,480 --> 00:20:32,420
並把它轉化為你的對象，這是好得多一起工作

381
00:20:32,420 --> 00:20:34,770
比普通數組和行。

382
00:20:34,770 --> 00:20:37,550
>>例如，現在當我有意見也許，

383
00:20:37,550 --> 00:20:40,900
我想抓住它的父職，

384
00:20:40,900 --> 00:20:43,440
我也說不定評論箭頭後，

385
00:20:43,440 --> 00:20:45,230
那麼它實際上給我的職位對象

386
00:20:45,230 --> 00:20:47,940
對應於實際的父職，不僅僅是一些ID，

387
00:20:47,940 --> 00:20:52,210
我會以其他方式使用，使另一個SQL查詢來抓住後，

388
00:20:52,210 --> 00:20:57,430
這是麻煩的和不必要的。

389
00:20:57,430 --> 00:21:01,840
進而，通過映射所有這些數據行插入對象，

390
00:21:01,840 --> 00:21:03,760
您還可以附加更多的功能對象，

391
00:21:03,760 --> 00:21:09,700
因此，例如，我談到了類如何本質上屬於功能組別。

392
00:21:09,700 --> 00:21:11,620
你可以認為它這樣。

393
00:21:11,620 --> 00:21:15,290
例如，也許我這個職位的對象，

394
00:21:15,290 --> 00:21:17,830
也許我想有連接到它的某種功能

395
00:21:17,830 --> 00:21:20,300
它主要是告訴我它是最近貼？

396
00:21:20,300 --> 00:21:23,570
它被張貼在最近一周內，真的還是假的？

397
00:21:23,570 --> 00:21:27,320
那是一個函數，我可以附加到該對象，

398
00:21:27,320 --> 00:21:31,300
而且它真的很方便有它在同一個地方，

399
00:21:31,300 --> 00:21:33,820
而且有很多不同的功能，你可以創建

400
00:21:33,820 --> 00:21:37,990
對於這些對象，而且它真的很高興能夠將它附加到一個類，

401
00:21:37,990 --> 00:21:41,700
一個對象，而如果你只是不得不從您的數據庫來行，

402
00:21:41,700 --> 00:21:43,790
那麼你真的不能附加任何功能的。

403
00:21:43,790 --> 00:21:47,850
這只是字面上的數據。

404
00:21:47,850 --> 00:21:50,550
有關，在所有有問題嗎？

405
00:21:50,550 --> 00:21:52,710
奧姆斯是很常見的Web開發，

406
00:21:52,710 --> 00:21:56,330
這裡面有很多不同類型的運籌學和管理學的，

407
00:21:56,330 --> 00:21:58,450
和Kohana的有自己的ORM。

408
00:21:58,450 --> 00:22:05,050
這是非常基本的，但你會得到什麼，它看起來像一個味道。

409
00:22:05,050 --> 00:22:08,780
>>讓我們創建一個模型，我們的博客文章，

410
00:22:08,780 --> 00:22:12,350
我們顯然需要做的第一件事是創建一個實際的表

411
00:22:12,350 --> 00:22:16,680
我們的數據庫中實際存儲我們的數據為這些職位。

412
00:22:16,680 --> 00:22:19,260
我要做的第一件事就是去phpMyAdmin的。

413
00:22:19,260 --> 00:22:21,410
有你們使用phpMyAdmin的呢？

414
00:22:21,410 --> 00:22:23,400
好了，真棒，所以你們已經知道那是什麼，

415
00:22:23,400 --> 00:22:32,200
我要去創建一個新的表稱為Kohana的帖子，

416
00:22:32,200 --> 00:22:37,820
而這將是非常簡單的。

417
00:22:37,820 --> 00:22:40,190
我將不得不重新登錄。

418
00:23:02,620 --> 00:23:04,640
所有我們今天要做的是有一個作者和一個身體，

419
00:23:04,640 --> 00:23:11,930
只是保持簡單。

420
00:23:11,930 --> 00:23:15,620
我要創建一個表，

421
00:23:15,620 --> 00:23:19,620
現在我們只是有了代表職位表

422
00:23:19,620 --> 00:23:23,370
有2個字段為我們的作者和我們的身體。

423
00:23:23,370 --> 00:23:26,290
其他的事情，我現在要做的是

424
00:23:26,290 --> 00:23:29,820
配置我的web應用程序，以便它知道如何連接到數據庫，

425
00:23:29,820 --> 00:23:31,950
而這，又是東西，你就必須做所有的Web應用程序。

426
00:23:31,950 --> 00:23:34,790
你必須告訴它的用戶名和密碼

427
00:23:34,790 --> 00:23:36,990
和數據庫的名稱等等等等

428
00:23:36,990 --> 00:23:40,000
弄清楚如何實際連接到數據庫。

429
00:23:40,000 --> 00:23:58,710
>>在Kohana中，我們有一些所謂的數據庫模塊，

430
00:23:58,710 --> 00:24:02,690
而在配置文件夾，我們有這個文件夾叫做數據庫，

431
00:24:02,690 --> 00:24:07,330
正如你可以看到，有一堆的設置，你必須在這裡設置

432
00:24:07,330 --> 00:24:09,860
告訴它什麼是用戶名和密碼

433
00:24:09,860 --> 00:24:13,110
數據庫，所以我實際上可以連接到它。

434
00:24:13,110 --> 00:24:15,010
因為我不想讓你們真正知道

435
00:24:15,010 --> 00:24:17,190
用戶名和我的數據庫的密碼，

436
00:24:17,190 --> 00:24:23,840
我有，我已經設置了這一切文件，並且我將其複製並粘貼過來。

437
00:24:33,080 --> 00:24:36,870
真棒。

438
00:24:36,870 --> 00:24:39,880
好吧。我認為這是所有我需要做的配置，

439
00:24:39,880 --> 00:24:41,070
但讓​​我們來看看。

440
00:24:41,070 --> 00:24:43,720
我們會繼續在它的工作，如果事情死機，

441
00:24:43,720 --> 00:24:47,490
那麼我們會解決它。

442
00:24:47,490 --> 00:24:51,830
現在，我什麼都做的是我將創建一個新的控制器。

443
00:24:51,830 --> 00:24:53,190
或者實際上，對不起。

444
00:24:53,190 --> 00:24:55,080
首先，我要創建一個新的模式。

445
00:24:55,080 --> 00:25:01,620
我將創建一個名為Post.php新模式，

446
00:25:01,620 --> 00:25:12,440
而我們要做的是什麼，我們要調用它的類Model_Post。

447
00:25:12,440 --> 00:25:15,390
得到一些語法高亮顯示，

448
00:25:15,390 --> 00:25:19,750
所以當我說，“延伸的ORM，”這基本上

449
00:25:19,750 --> 00:25:21,210
一些面向對象編程，

450
00:25:21,210 --> 00:25:23,340
不幸的是你們在CS50還沒有學到的是，

451
00:25:23,340 --> 00:25:25,290
但它很容易上手。

452
00:25:25,290 --> 00:25:27,950
它給我進來這個ORM包所有這些額外的功能，

453
00:25:27,950 --> 00:25:31,120
所以我得到了一堆額外的功能和諸如此類的東西是免費的，

454
00:25:31,120 --> 00:25:34,810
你會看到在第二位的。

455
00:25:34,810 --> 00:25:37,670
>>現在實際上所有我需要做的就是創建這個類。

456
00:25:37,670 --> 00:25:39,160
我什至都不需要進行任何功能或任何東西，

457
00:25:39,160 --> 00:25:41,770
但我已經創建了一個表示表的類，

458
00:25:41,770 --> 00:25:44,140
因為我已經把這項ORM類，

459
00:25:44,140 --> 00:25:51,080
我得到了一堆東西是免費的，所以現在你不必設置任何事情多了起來。

460
00:25:51,080 --> 00:25:53,530
現在我什麼都做的是我要創建一個新的控制器，

461
00:25:53,530 --> 00:25:58,480
而我要去的名字blog.php的，

462
00:25:58,480 --> 00:26:04,350
我要去複製在歡迎控制器

463
00:26:04,350 --> 00:26:11,950
所以我不必重新輸入一些東西，

464
00:26:11,950 --> 00:26:20,720
現在我要重新命名此。

465
00:26:20,720 --> 00:26:24,710
現在，我什麼都做測試，以確保一切正常了，

466
00:26:24,710 --> 00:26:27,820
我要抓住從我的數據庫中的第一篇文章

467
00:26:27,820 --> 00:26:32,680
並打印在屏幕上後的身體。

468
00:26:32,680 --> 00:26:37,920
要做到這一點我什麼都做第一是我要保存的職位

469
00:26:37,920 --> 00:26:48,770
給一個變量，所以我們要做的是 - 

470
00:26:48,770 --> 00:26:52,090
在Kohana中你要做的就是抓住物體後

471
00:26:52,090 --> 00:26:55,380
這是種累贅，但你必須做這個東西叫ORM ::工廠，

472
00:26:55,380 --> 00:26:57,750
然後你通過在你想要的模型的名稱，

473
00:26:57,750 --> 00:27:00,490
它返回ORM的對象，表示模型。

474
00:27:00,490 --> 00:27:04,860
然後，就像我說的，當我們擴展了ORM的對象，

475
00:27:04,860 --> 00:27:07,320
我們得到的所有這些方法的自由，因此，例如，

476
00:27:07,320 --> 00:27:09,200
我們得到這個所謂的新功能“找到”

477
00:27:09,200 --> 00:27:12,160
它會自動返回數據庫中每一個職位，

478
00:27:12,160 --> 00:27:14,850
這是非常方便的。

479
00:27:14,850 --> 00:27:17,480
>>現在的身體我將返回

480
00:27:17,480 --> 00:27:24,860
在第一篇文章，並返回它的身體。

481
00:27:24,860 --> 00:27:27,930
當然，我需要創建一個職位，

482
00:27:27,930 --> 00:27:31,880
所以讓我們插入一個新的職位。

483
00:27:31,880 --> 00:27:37,870
我會說，“布蘭登，我的第一個帖子。”

484
00:27:37,870 --> 00:27:40,010
真棒。

485
00:27:40,010 --> 00:27:45,910
現在我們要進入博客

486
00:27:45,910 --> 00:27:50,960
如果一切運作良好 - 哦，這是其他一些愚蠢的文件權限的事情了。

487
00:27:50,960 --> 00:27:56,090
按住1秒。這有點荒謬。

488
00:28:06,700 --> 00:28:08,490
我們走吧。好吧。

489
00:28:08,490 --> 00:28:10,040
我固定的權限問題。

490
00:28:10,040 --> 00:28:12,040
它試圖創建一些文件和一些日誌，

491
00:28:12,040 --> 00:28:15,400
和權限，再設定不正確，所以我做了它

492
00:28:15,400 --> 00:28:18,320
所以這些文件是可寫和可執行

493
00:28:18,320 --> 00:28:21,090
所以它實際上可以登錄到的東西。

494
00:28:21,090 --> 00:28:24,220
現在，它給我另一個異常的說法，“一流的ORM沒有找到，”

495
00:28:24,220 --> 00:28:26,960
那是因為我忘了一大步。

496
00:28:26,960 --> 00:28:37,010
這太糟糕了。

497
00:28:37,010 --> 00:28:40,270
在程序的引導文件夾中的文件，也有這些模塊在這裡，

498
00:28:40,270 --> 00:28:42,480
您可以選擇啟用或禁用。

499
00:28:42,480 --> 00:28:44,340
這是一群不同的功能，你可以選擇使用

500
00:28:44,340 --> 00:28:46,180
Kohana的範圍內，這是有點漂亮。

501
00:28:46,180 --> 00:28:49,090
>>例如，他們有一個認證模塊

502
00:28:49,090 --> 00:28:51,170
它可用於驗證用戶身份。

503
00:28:51,170 --> 00:28:53,390
他們有一個緩存模塊，如果你想實現

504
00:28:53,390 --> 00:28:57,870
某種緩存後端，使應用程序工作得更快和諸如此類的東西。

505
00:28:57,870 --> 00:29:02,140
我們需要啟用數據庫和ORM模塊，

506
00:29:02,140 --> 00:29:04,280
因為就像我說的，我們使用的數據庫，很明顯，

507
00:29:04,280 --> 00:29:08,200
而且我們還需要啟用的ORM模塊，

508
00:29:08,200 --> 00:29:12,220
因為我們希望有額外的功能，這是不錯的。

509
00:29:12,220 --> 00:29:14,240
所有我需要做的就是取消註釋這些2線，

510
00:29:14,240 --> 00:29:18,760
而現在，如果我刷新，它給了我另一個錯誤。

511
00:29:18,760 --> 00:29:22,100
它說，“類Model_Post沒有找到。”

512
00:29:22,100 --> 00:29:30,210
現在，這是一個很好的問題有。

513
00:29:30,210 --> 00:29:37,660
讓我們來看看。

514
00:29:37,660 --> 00:29:42,200
把它公開。

515
00:29:42,200 --> 00:29:46,450
第等一等。

516
00:30:11,610 --> 00:30:13,160
哦，親愛的。

517
00:30:13,160 --> 00:30:18,590
我不知道為什麼它不能夠找到。

518
00:30:18,590 --> 00:30:21,030
這真的很奇怪。

519
00:30:21,030 --> 00:30:23,820
我有這個類就在這裡。

520
00:30:23,820 --> 00:30:28,650
我想我可能要 - 哦。

521
00:30:28,650 --> 00:30:32,010
我很愚蠢的。我忘了補充一個PHP標籤。

522
00:30:32,010 --> 00:30:34,670
這就是為什麼。

523
00:30:34,670 --> 00:30:41,260
現在，我必須撤消1的變化我只是做了。

524
00:30:41,260 --> 00:30:44,270
>>好吧。我們走吧。

525
00:30:44,270 --> 00:30:47,500
這是非常愚蠢的。我沒有開口的PHP標籤。

526
00:30:47,500 --> 00:30:49,900
但正如你所看到的，現在它的正常工作，對不對？

527
00:30:49,900 --> 00:30:51,240
我們有1篇文​​章。

528
00:30:51,240 --> 00:30:54,730
我們搶到了第一篇文章，現在我們打印出它的身體。

529
00:30:54,730 --> 00:30:58,010
大。太棒了。

530
00:30:58,010 --> 00:31:01,470
有任何疑問，這麼遠嗎？

531
00:31:01,470 --> 00:31:04,100
沒了？有問題嗎？

532
00:31:04,100 --> 00:31:08,340
好了，所以我們剛剛創建的模型後，很基本的，

533
00:31:08,340 --> 00:31:10,930
而我們要在以後添加一些功能。

534
00:31:10,930 --> 00:31:13,600
我們可以添加驗證和過濾。

535
00:31:13,600 --> 00:31:15,650
驗證是的事情之一

536
00:31:15,650 --> 00:31:18,150
該框架解決你真的，真的很好，

537
00:31:18,150 --> 00:31:21,310
而且我不認為你們不得不這樣做對你的CS50 PSET，

538
00:31:21,310 --> 00:31:24,000
但如果你做web開發為您的最終項目，

539
00:31:24,000 --> 00:31:26,280
你可能會想要做一些驗證，

540
00:31:26,280 --> 00:31:28,290
就像沒有空白用戶名，

541
00:31:28,290 --> 00:31:31,950
也許有一個密碼，且至少有長度，這樣的事情。

542
00:31:31,950 --> 00:31:34,750
它真的很麻煩由我們自己來實現這些東西，

543
00:31:34,750 --> 00:31:37,390
和幾乎每一個Web框架會為你

544
00:31:37,390 --> 00:31:41,140
並允許你做一個非常乾淨的方式。

545
00:31:41,140 --> 00:31:44,340
該模型是你通常表達這些驗證規則，

546
00:31:44,340 --> 00:31:48,790
因為它在驗證模型是否是有效還是無效。

547
00:31:48,790 --> 00:31:51,350
>>但現在，我們將稍後把那之前，

548
00:31:51,350 --> 00:31:53,520
而現在我們要工作的另一部分，

549
00:31:53,520 --> 00:31:55,400
而且我們要嘗試做一個新視圖

550
00:31:55,400 --> 00:31:59,580
列出所有的職位。

551
00:31:59,580 --> 00:32:02,490
參與制定新的行動列出所有職位的步驟

552
00:32:02,490 --> 00:32:04,810
是抓住所有的職位列表

553
00:32:04,810 --> 00:32:11,990
然後通過視圖渲染所有的帖子列表。

554
00:32:11,990 --> 00:32:16,420
在這裡，幸運的是，我們已經抓住了所有職位

555
00:32:16,420 --> 00:32:20,310
使用這種第一線，發現所有的功能，

556
00:32:20,310 --> 00:32:22,520
現在我們要做的是什麼，是迄今為​​止

557
00:32:22,520 --> 00:32:25,350
我一直在直接設置響應體

558
00:32:25,350 --> 00:32:29,090
通過傳遞字符串，但現在我想使用一個視圖，

559
00:32:29,090 --> 00:32:31,870
和一個視圖，只是這樣的區別

560
00:32:31,870 --> 00:32:35,330
與一個視圖，我可以有一個很好的，大的HTML模板，

561
00:32:35,330 --> 00:32:37,710
什麼我可以做的是通過它的某些變量

562
00:32:37,710 --> 00:32:42,200
然後有鑑於自動填充模板

563
00:32:42,200 --> 00:32:44,690
使用這些變量。

564
00:32:44,690 --> 00:32:50,780
我要做的是，我將創建一個新的視圖，

565
00:32:50,780 --> 00:32:55,940
我會命名視圖類似“博客/指數”

566
00:32:55,940 --> 00:33:08,480
我要去基本上綁定這個 - 哦，那我在寫什麼？

567
00:33:08,480 --> 00:33:12,910
我的大腦在其他地方。

568
00:33:12,910 --> 00:33:16,600
我要綁定變量到視圖的職位，

569
00:33:16,600 --> 00:33:19,950
所以這樣的觀點可以訪問到這個職位的變量。

570
00:33:19,950 --> 00:33:26,140
>>所以現在我需要創建這個視圖，

571
00:33:26,140 --> 00:33:28,500
所以在這裡我們有這個文件夾，名為“查看”

572
00:33:28,500 --> 00:33:32,150
和第一，我要去下調用來創建一個新的文件夾“博客”。

573
00:33:32,150 --> 00:33:35,810
這是很好的。這樣，我們就可以有一個很好的層次結構為我們的意見。

574
00:33:35,810 --> 00:33:43,910
然後，我將在那裡創建另一個文件名為“index.php的。”

575
00:33:43,910 --> 00:33:45,780
真棒。

576
00:33:45,780 --> 00:33:52,930
其實，讓我們有他們都在這裡。

577
00:33:52,930 --> 00:33:56,760
製作一個視圖文件可能是這一切的最簡單的部分，

578
00:33:56,760 --> 00:33:59,090
這些都是可能的事情你已經很熟悉了。

579
00:33:59,090 --> 00:34:01,240
我們要做的很簡單的東西，

580
00:34:01,240 --> 00:34:05,360
開始說，“我的博客文章列表”。

581
00:34:05,360 --> 00:34:14,860
然後，我們可以通過，

582
00:34:14,860 --> 00:34:17,920
我們可以通過職位遍歷數組，

583
00:34:17,920 --> 00:34:21,760
抓住每一個職位，並這樣說 - 

584
00:34:21,760 --> 00:34:25,290
也許添加一行

585
00:34:25,290 --> 00:34:42,460
然後打印出作者和身體。

586
00:34:42,460 --> 00:34:44,480
有意義的這麼遠嗎？

587
00:34:44,480 --> 00:34:50,870
讓我們看看它的工作原理。

588
00:34:50,870 --> 00:34:53,489
什麼都沒有發生。

589
00:34:53,489 --> 00:34:55,090
我不知道為什麼。

590
00:34:55,090 --> 00:34:58,760
哦，我錯過了1步。很無聊的我。

591
00:34:58,760 --> 00:35:01,640
我創建了一個觀點，但我沒有設置視圖作為響應，

592
00:35:01,640 --> 00:35:03,190
所以你必須做更多的事情。

593
00:35:03,190 --> 00:35:12,610
你需要做的“這樣的反應體”，並將其設置為視圖。

594
00:35:12,610 --> 00:35:14,760
我們走吧。

595
00:35:14,760 --> 00:35:17,200
我們有我們的標題，然後我們有一個帖子，

596
00:35:17,200 --> 00:35:20,500
而只是踢，讓我們插入另一篇文章

597
00:35:20,500 --> 00:35:23,390
所以我們可以看到一個列表。

598
00:35:31,800 --> 00:35:36,650
並插入這2個職位，

599
00:35:36,650 --> 00:35:39,500
現在如果我刷新頁面，

600
00:35:39,500 --> 00:35:42,060
我們看到所有這些職位在這裡。

601
00:35:42,060 --> 00:35:44,250
>>這是否有意義這麼遠嗎？

602
00:35:44,250 --> 00:35:46,400
是啊，一個問題嗎？哦，好吧。

603
00:35:46,400 --> 00:35:51,440
正如你所看到的，我們已經能夠分離所有這些代碼了

604
00:35:51,440 --> 00:35:53,920
成不同的部分，然後你就可以看到它的最清晰的視圖代碼。

605
00:35:53,920 --> 00:35:57,810
這裡該文件表示視圖，

606
00:35:57,810 --> 00:36:01,220
它只關心表示數據，顯示數據。

607
00:36:01,220 --> 00:36:04,310
它被傳遞某種形式的數據，它所做的只是把它給你。

608
00:36:04,310 --> 00:36:07,660
在你的代碼的所有其他部分，你將不必擔心任何的是，

609
00:36:07,660 --> 00:36:10,480
同樣，你的視圖代碼不必擔心任何事情

610
00:36:10,480 --> 00:36:13,390
如何訪問數據庫等等，等等，

611
00:36:13,390 --> 00:36:19,950
這是非常好，使你的代碼很多更易於維護。

612
00:36:19,950 --> 00:36:23,390
就像我說的，看法，他們是動態的，

613
00:36:23,390 --> 00:36:27,080
這是1個文件，但它會產生不同的看法

614
00:36:27,080 --> 00:36:29,940
根據您實際傳遞的變量，

615
00:36:29,940 --> 00:36:32,370
，此外，還有很多不同的輔助函數的

616
00:36:32,370 --> 00:36:34,230
您可以用它來幫你寫你的代碼速度更快，

617
00:36:34,230 --> 00:36:36,320
我會告訴你，在短短一秒鐘。

618
00:36:36,320 --> 00:36:38,050
是啊。

619
00:36:38,050 --> 00:36:42,490
>> [學生]所以$ 0是一個控制器，對不對？

620
00:36:42,490 --> 00:36:44,000
這第二件事。

621
00:36:44,000 --> 00:36:46,090
現在的問題是為0元控制器？

622
00:36:46,090 --> 00:36:48,610
$ 0 =我創建了這裡的變量。

623
00:36:48,610 --> 00:36:51,320
我創建了一個視圖第一。我賦予它的一些變量。

624
00:36:51,320 --> 00:36:54,960
然後，我通過它進入此功能，將其作為響應體。

625
00:36:54,960 --> 00:36:57,260
這是否有道理？

626
00:36:57,260 --> 00:37:02,200
[學生]所以是視圖::廠，是認為像一班

627
00:37:02,200 --> 00:37:06,610
或庫[聽不清]工廠函數？

628
00:37:06,610 --> 00:37:10,640
現在的問題是關於視圖::工廠函數，

629
00:37:10,640 --> 00:37:14,020
基本上這基本上是一些面向對象編程。

630
00:37:14,020 --> 00:37:18,000
視圖是視圖類，它有一個方法叫做“工廠”

631
00:37:18,000 --> 00:37:24,170
而這一種方式來獲取該文件的命名對象“博客/指數。”

632
00:37:24,170 --> 00:37:27,140
這就是一些面向對象編程的東西

633
00:37:27,140 --> 00:37:33,010
說我不打算在這裡贅述了太多。

634
00:37:33,010 --> 00:37:36,400
現在很明顯，我們要創造新職位，

635
00:37:36,400 --> 00:37:38,790
但我們不希望有通過數據庫來做到這一點，

636
00:37:38,790 --> 00:37:41,280
所以我們要創建一個新動作，用於創建一個新的職位，

637
00:37:41,280 --> 00:37:43,050
而且有很多的東西，我們必須做的。

638
00:37:43,050 --> 00:37:45,910
>>我們要做的第一件事情 - 讓我們處理這些事情一個接一個。

639
00:37:45,910 --> 00:37:48,320
我們要做的第一件事是我們必須創建一個窗體

640
00:37:48,320 --> 00:37:54,460
插入一個新的職位，

641
00:37:54,460 --> 00:37:57,360
但我也要去先添加一個新的動作，

642
00:37:57,360 --> 00:38:01,050
所以加入一個新的動作是一樣一樣容易

643
00:38:01,050 --> 00:38:03,490
添加一個新的功能與您的控制器，

644
00:38:03,490 --> 00:38:13,710
而現在我會做一些很基本的，

645
00:38:13,710 --> 00:38:20,850
只要抓住這一觀點，並張貼，只是顯示它。

646
00:38:20,850 --> 00:38:26,220
然後現在我要創建一個新的視圖文件，

647
00:38:26,220 --> 00:38:33,690
和我要開始寫一些東西。

648
00:38:33,690 --> 00:38:36,540
什麼是好的關於Kohana的是，他們提供了很多不同的輔助函數的

649
00:38:36,540 --> 00:38:38,790
讓您更輕鬆地編寫視圖代碼，

650
00:38:38,790 --> 00:38:41,970
1這些輔助功能或輔助模塊

651
00:38:41,970 --> 00:38:45,860
圍繞寫作形式。

652
00:38:45,860 --> 00:38:49,460
對於寫作形式，我真的沒有直接寫任何HTML自己。

653
00:38:49,460 --> 00:38:51,100
你們已經寫HTML表單。

654
00:38:51,100 --> 00:38:54,850
你知道它是如何可真是，真是痛苦和繁瑣的書寫形式。

655
00:38:54,850 --> 00:38:59,970
這不好玩，所以幸運的是，

656
00:38:59,970 --> 00:39:04,860
我們可以使用Kohana中的基本上寫一個形式

657
00:39:04,860 --> 00:39:11,190
形成輔助函數來為我們做了。

658
00:39:11,190 --> 00:39:17,340
我們將主要有領域的每一件事情，我們有，

659
00:39:17,340 --> 00:39:23,160
所以一個作者和一個用於屍體。

660
00:39:23,160 --> 00:39:27,090
我們將有一個標籤，我們將有一個輸入。

661
00:39:37,450 --> 00:39:41,360
>>然後最後，我們將有一個提交。

662
00:39:49,350 --> 00:39:52,230
正如你所看到的，這是乾淨多了寫

663
00:39:52,230 --> 00:39:58,150
比這些雜亂的HTML，這是種不錯的。

664
00:39:58,150 --> 00:40:00,930
當然，還有一些有它甚至比這更清潔其他的web框架，

665
00:40:00,930 --> 00:40:04,440
但至少這比自己寫的HTML更好。

666
00:40:09,400 --> 00:40:11,130
真棒，所以這就是你看到的。

667
00:40:11,130 --> 00:40:13,530
這還算比較凌亂，

668
00:40:13,530 --> 00:40:19,720
所以我打算添加一個換行符有

669
00:40:19,720 --> 00:40:21,180
作出這樣看起來更好一點。

670
00:40:21,180 --> 00:40:23,330
嗯，當然，它仍然看起來真的，真的很糟糕，但我們只是專注

671
00:40:23,330 --> 00:40:26,050
上的美學為現在而不是功能。

672
00:40:26,050 --> 00:40:28,010
沒有時間做的一切。

673
00:40:28,010 --> 00:40:30,600
正如你可以看到，現在我們有一個超級基本形式，

674
00:40:30,600 --> 00:40:32,080
這是種不錯的。

675
00:40:32,080 --> 00:40:36,730
這段代碼我想說的是比試圖寫一個HTML表單自己清潔，

676
00:40:36,730 --> 00:40:40,290
所以這是很好的。

677
00:40:40,290 --> 00:40:42,030
下一步是什麼？

678
00:40:42,030 --> 00:40:49,260
現在我們需要做的事情與行動。

679
00:40:49,260 --> 00:40:51,240
通常，當你寫HTML表單，

680
00:40:51,240 --> 00:40:54,070
你必須告訴它到哪裡去的形式提交給。

681
00:40:54,070 --> 00:40:56,050
默認情況下，在大多數web框架，

682
00:40:56,050 --> 00:40:58,200
它提交的確切相同的URL，所以事情是，

683
00:40:58,200 --> 00:41:01,310
如果你發送一個GET請求到/博客/新的，

684
00:41:01,310 --> 00:41:03,240
它應該顯示你的形式，

685
00:41:03,240 --> 00:41:06,810
但如果你發送一個POST請求/博客/新的數據，

686
00:41:06,810 --> 00:41:10,000
它實際上應該嘗試保存該職位

687
00:41:10,000 --> 00:41:13,300
並用它做什麼。

688
00:41:20,630 --> 00:41:22,180
>>我們現在要做的是

689
00:41:22,180 --> 00:41:25,320
基本上所有我們必須做的，檢查它是否是一個post請求或GET請求

690
00:41:25,320 --> 00:41:29,350
是檢查哪些變量後，您可以設置。

691
00:41:29,350 --> 00:41:34,560
如果該職位變量被設置，那麼我們將嘗試創建一個新的職位。

692
00:41:34,560 --> 00:41:38,440
同樣，我們只是做到這一點，

693
00:41:38,440 --> 00:41:41,090
並創建一個新的職位，並且我們從字面上去

694
00:41:41,090 --> 00:41:51,150
設置其字段這樣，

695
00:41:51,150 --> 00:41:55,640
然後我們要保存它。

696
00:41:55,640 --> 00:41:59,200
然後我會重定向

697
00:41:59,200 --> 00:42:07,660
到索引頁面，使他們能夠再次看到我們的帖子列表。

698
00:42:07,660 --> 00:42:09,620
我們來試一下。

699
00:42:09,620 --> 00:42:15,160
我會說，“布蘭登”

700
00:42:15,160 --> 00:42:18,140
然後提交後，如果一切順利的話，

701
00:42:18,140 --> 00:42:21,390
你可以看到，它重定向我的索引頁，

702
00:42:21,390 --> 00:42:24,140
如果我滾動到底部，我們有一個新插入的崗位。

703
00:42:24,140 --> 00:42:26,430
耶！

704
00:42:26,430 --> 00:42:28,430
是啊，問題。

705
00:42:28,430 --> 00:42:31,760
>> [學生]如果你已經進入了完全一樣的東西

706
00:42:31,760 --> 00:42:33,380
你之前輸入？

707
00:42:33,380 --> 00:42:36,950
不會檢查，以確保你沒有複製

708
00:42:36,950 --> 00:42:38,810
同樣提交？

709
00:42:38,810 --> 00:42:41,660
缺省情況下，沒有，因為默認情況下 - 

710
00:42:41,660 --> 00:42:46,470
不好意思，問題是，如果你在表單中完全相同的數據輸入

711
00:42:46,470 --> 00:42:50,180
並提交，將它允許你插入一個重複的對象，

712
00:42:50,180 --> 00:42:52,550
重複的項目，基本上是？

713
00:42:52,550 --> 00:42:54,070
現在，是的，它可以讓你做到這一點，

714
00:42:54,070 --> 00:42:58,860
因為在數據庫中是完全有效的完全重複的行，

715
00:42:58,860 --> 00:43:02,260
但如果這是一個問題，那麼你可以添加驗證，例如，

716
00:43:02,260 --> 00:43:06,430
以確保如果這是完全一樣的東西已經存在，

717
00:43:06,430 --> 00:43:08,720
然後說，這是一個無效的對象，

718
00:43:08,720 --> 00:43:11,200
然後，你甚至可以指定你的錯誤信息

719
00:43:11,200 --> 00:43:14,390
並說，“無效的，因為這個已經存在”或類似的東西。

720
00:43:14,390 --> 00:43:22,420
但在這種情況下，我可以創造一些重複的。

721
00:43:22,420 --> 00:43:26,010
現在，讓我們嘗試添加一些驗證。

722
00:43:26,010 --> 00:43:30,400
這樣做的問題，現在是，

723
00:43:30,400 --> 00:43:34,220
我可以從字面上提交一個完全空白的職位。

724
00:43:34,220 --> 00:43:37,500
我可以按一下這個按鈕，現在，我們走吧。

725
00:43:37,500 --> 00:43:40,290
你不能真正看到它，但在這裡這些額外的行

726
00:43:40,290 --> 00:43:43,830
表明我從字面上有一個新的職位。

727
00:43:43,830 --> 00:43:46,050
它只是一個空白的作者和坯體，

728
00:43:46,050 --> 00:43:48,630
我們不想讓人們做到這一點。

729
00:43:48,630 --> 00:43:52,550
這是驗證的用武之地。

730
00:43:52,550 --> 00:43:57,540
>>我可以去我的模型對象，

731
00:43:57,540 --> 00:43:59,530
現在我可以添加一個新的函數，它指定

732
00:43:59,530 --> 00:44:02,000
我要補充到這個模型是什麼驗證規則

733
00:44:02,000 --> 00:44:06,840
以確保它是有效的或指定是什麼意思是一個有效的崗位？

734
00:44:06,840 --> 00:44:10,210
我想說，這只是一個有效的崗位，如果作者和身體

735
00:44:10,210 --> 00:44:15,150
不為空，這是你如何做到這一點的Kohana的。

736
00:44:15,150 --> 00:44:18,750
您可以創建一個名為“規則，”新功能

737
00:44:18,750 --> 00:44:20,210
然後你基本上返回一個關聯數組

738
00:44:20,210 --> 00:44:24,230
定義此對象的驗證規則。

739
00:44:24,230 --> 00:44:27,530
我們要返回的數組，然後我們要做的是什麼

740
00:44:27,530 --> 00:44:32,820
說“作者，”它關係到一個數組，

741
00:44:32,820 --> 00:44:37,720
這正好叫另一個數組“不是空的。”

742
00:44:37,720 --> 00:44:41,480
然後我會說“身體”。

743
00:44:50,980 --> 00:44:54,120
好吧，和語法，這和結構這

744
00:44:54,120 --> 00:44:56,530
可能看起來有點麻煩，有點複雜。

745
00:44:56,530 --> 00:44:59,330
如果您閱讀文檔，這是很簡單的找出，

746
00:44:59,330 --> 00:45:02,500
但本質上這就是你需要做的指定

747
00:45:02,500 --> 00:45:04,130
一些驗證規則，而且有很多不同的規則

748
00:45:04,130 --> 00:45:06,810
這Kohana的會給你免費的，比如您可以添加規則說

749
00:45:06,810 --> 00:45:08,410
它必須至少有這個長度。

750
00:45:08,410 --> 00:45:11,800
也許它必須是數字。也許它必須是字母數字。

751
00:45:11,800 --> 00:45:14,410
也許它必須是在最這個長度，等等，等等。

752
00:45:14,410 --> 00:45:17,730
有很多不同的規則，Kohana的為您提供，

753
00:45:17,730 --> 00:45:19,610
你可以去他們的網站上，看文檔，

754
00:45:19,610 --> 00:45:23,150
你可以看到所有不同的東西，你可以做。

755
00:45:23,150 --> 00:45:25,650
>>但這是我必須做的，

756
00:45:25,650 --> 00:45:30,490
現在讓我們看看會發生什麼

757
00:45:30,490 --> 00:45:34,060
如果我提交一份空白後。

758
00:45:34,060 --> 00:45:36,960
有什麼事情發生？哦，不，我得到一個錯誤。

759
00:45:36,960 --> 00:45:39,440
我得到了驗證異常。

760
00:45:39,440 --> 00:45:41,070
嗯，這是很好的。

761
00:45:41,070 --> 00:45:43,200
它告訴我，我的模型是無效的，

762
00:45:43,200 --> 00:45:45,780
但我不希望顯示異常

763
00:45:45,780 --> 00:45:48,720
我的用戶，當他們嘗試提交一些無效的，對不對？

764
00:45:48,720 --> 00:45:51,560
我想給他們一些友好的錯誤消息

765
00:45:51,560 --> 00:45:53,610
當不順心的事。

766
00:45:53,610 --> 00:46:01,830
我們現在要做的是我們要

767
00:46:01,830 --> 00:46:04,490
在嘗試捕捉環包裹的一切。

768
00:46:04,490 --> 00:46:06,750
其實，我覺得這也是東西你還沒有學會還

769
00:46:06,750 --> 00:46:10,820
在CS50，因為C，編程語言C，

770
00:46:10,820 --> 00:46:14,000
沒有例外，但幾乎每一個其他語言

771
00:46:14,000 --> 00:46:16,700
有例外，所以真的，真的很短暫，

772
00:46:16,700 --> 00:46:19,430
一個異常的東西，一段代碼可以

773
00:46:19,430 --> 00:46:21,430
拋出異常時，不順心的事，

774
00:46:21,430 --> 00:46:23,410
但隨後也許一些其他的代碼段越往上

775
00:46:23,410 --> 00:46:25,810
可以捕獲該異常，並用它做什麼。

776
00:46:25,810 --> 00:46:27,710
>>例如，在這種情況下，

777
00:46:27,710 --> 00:46:29,940
的一段代碼，它盡可能保存模型，

778
00:46:29,940 --> 00:46:33,170
它驗證了模型，如果它說，“好吧，這種模式是無效的。”

779
00:46:33,170 --> 00:46:36,150
它會拋出一個異常，這是一種相當於

780
00:46:36,150 --> 00:46:39,870
在C裡，你可能會返回一個-1或類似的東西。

781
00:46:39,870 --> 00:46:42,320
然後對我來說，這個功能，我的代碼

782
00:46:42,320 --> 00:46:46,310
在更高的層次，我可以嘗試捕獲該異常

783
00:46:46,310 --> 00:46:49,330
基本上說，“好吧，如果我捕獲該異常，我該怎麼辦？”

784
00:46:49,330 --> 00:46:51,570
或者我可以選擇不捕獲該異常，並讓別人高了

785
00:46:51,570 --> 00:46:54,400
捕獲異常，或者如果沒有人抓住它，

786
00:46:54,400 --> 00:46:56,820
那麼整個程序崩潰，並說，

787
00:46:56,820 --> 00:46:59,170
“出事了，我不能處理它。”

788
00:46:59,170 --> 00:47:04,490
>>但是我們做的是你包裝在一個try塊中的一段代碼，

789
00:47:04,490 --> 00:47:09,030
然後你還可以添加一些所謂的catch塊，

790
00:47:09,030 --> 00:47:17,300
這是代碼排序，將嘗試捕獲可能發生的異常。

791
00:47:17,300 --> 00:47:20,430
所以如果我抓住這個特殊的例外

792
00:47:20,430 --> 00:47:23,110
或無效的異常，然後我什麼都做的是

793
00:47:23,110 --> 00:47:31,210
我要設置的錯誤 - 我想這就是我要做的事 - 

794
00:47:31,210 --> 00:47:35,370
我要去設置錯誤的一些對象。

795
00:47:35,370 --> 00:47:40,920
然後，如果它擊中這個例外就是我要做的是，

796
00:47:40,920 --> 00:47:43,090
它不會重定向，如果它不重定向，

797
00:47:43,090 --> 00:47:46,160
它走出來的，如果博客的

798
00:47:46,160 --> 00:47:49,920
而打這個博客/新的，這是要我想做的事情。

799
00:47:49,920 --> 00:47:53,190
如果有錯誤的話，我想回去形式

800
00:47:53,190 --> 00:47:55,100
並顯示這些錯誤。

801
00:47:55,100 --> 00:48:00,780
現在，我想要做的就是我想通過在這些錯誤

802
00:48:00,780 --> 00:48:07,010
到視圖。

803
00:48:07,010 --> 00:48:10,360
好吧，我想我有看法就在這裡，

804
00:48:10,360 --> 00:48:14,660
基本上我想，如果他們的存在是為了顯示這些錯誤。

805
00:48:14,660 --> 00:48:19,740
之前我寫的HTML是什麼，我要真的很快

806
00:48:19,740 --> 00:48:21,720
告訴你什麼是這個錯誤的結構變量的樣子，

807
00:48:21,720 --> 00:48:23,080
這是一般的一個很好的做法。

808
00:48:23,080 --> 00:48:25,070
很多時候，你得到的東西從某種方法回來，

809
00:48:25,070 --> 00:48:27,250
在Web框架的一些功能，

810
00:48:27,250 --> 00:48:29,410
你不知道什麼是變量的樣子，

811
00:48:29,410 --> 00:48:31,210
所以你不知道如何使用它的工作。

812
00:48:31,210 --> 00:48:37,790
我將使用一個印記R的方法基本上是把它打印出來。

813
00:48:37,790 --> 00:48:41,100
>>正如你所看到的，它告訴我它是一個關聯數組，

814
00:48:41,100 --> 00:48:44,880
和你有一個關鍵，作者，指向這個字符串，

815
00:48:44,880 --> 00:48:47,050
筆者不能為空，而另一個關鍵，身體，

816
00:48:47,050 --> 00:48:49,680
點到另一個字符串，身體不能為空。

817
00:48:49,680 --> 00:48:52,130
我想，好吧，冷靜。

818
00:48:52,130 --> 00:48:56,230
然後，我可以通過遍歷數組，並打印出每一個消息。

819
00:48:56,230 --> 00:49:02,150
這基本上就像一個關聯數組有一堆的消息。

820
00:49:02,150 --> 00:49:13,500
我什麼都做的是“如果錯誤，”

821
00:49:13,500 --> 00:49:17,140
我要去創建一個無序列表，

822
00:49:17,140 --> 00:49:20,860
而且我要遍歷所有的錯誤。

823
00:49:33,730 --> 00:49:38,710
而這一點，現在我要去嘗試再次提交此，

824
00:49:38,710 --> 00:49:41,200
，讓我們看看會發生什麼。

825
00:49:41,200 --> 00:49:45,370
現在，我們得到錯誤的這個漂亮的名單，

826
00:49:45,370 --> 00:49:48,630
這仍然是很醜陋，但是這顯然可以被格式化為看起來不錯，

827
00:49:48,630 --> 00:49:51,620
但其基本思想就是在幾行代碼，

828
00:49:51,620 --> 00:49:53,720
我們能夠驗證我們的模型中，

829
00:49:53,720 --> 00:49:56,510
確保某些字段不為空，

830
00:49:56,510 --> 00:49:59,740
如果發生了錯誤，則返回某種錯誤消息

831
00:49:59,740 --> 00:50:01,760
然後，我可以介紹給用戶。

832
00:50:01,760 --> 00:50:03,910
您還可以自定義您的驗證

833
00:50:03,910 --> 00:50:07,590
所以，你其實可以有一個錯誤信息

834
00:50:07,590 --> 00:50:09,620
那就是更多的特定於應用程序或類似的東西。

835
00:50:09,620 --> 00:50:14,600
所有這一切都是一般定制。

836
00:50:14,600 --> 00:50:17,150
>>不幸的是，我們的時間不多了，

837
00:50:17,150 --> 00:50:20,040
所以我將要在這裡切斷直播編碼會話。

838
00:50:20,040 --> 00:50:22,980
還有一堆其他的功能，我要證明給你

839
00:50:22,980 --> 00:50:25,650
在這個例子。

840
00:50:25,650 --> 00:50:27,620
例如，您可以添加模板到您的網站，

841
00:50:27,620 --> 00:50:31,110
所以也許有HTML代碼，您要應用某種

842
00:50:31,110 --> 00:50:35,190
在你的網站的每一個頁面，，而不是粘貼的

843
00:50:35,190 --> 00:50:40,630
在每一個視圖文件，你有，這顯然將是一個不好的做法，

844
00:50:40,630 --> 00:50:43,020
你基本上可以定義這些模板，

845
00:50:43,020 --> 00:50:46,660
然後在你的控制器說，“好吧，我使用這個模板。”

846
00:50:46,660 --> 00:50:50,130
“有我所有的意見，使用此模板。”

847
00:50:50,130 --> 00:50:52,470
我要證明給你聽的最後一件事

848
00:50:52,470 --> 00:50:57,800
我們沒有時間的，是跨站點腳本，

849
00:50:57,800 --> 00:51:01,430
基本上我想你們可能已經看到在CS50  - 

850
00:51:01,430 --> 00:51:03,770
我覺得大衛·馬蘭大概談到你怎麼能通常注入

851
00:51:03,770 --> 00:51:08,040
JavaScript代碼到 - 你談過嗎？

852
00:51:08,040 --> 00:51:10,220
也許？也許不是？

853
00:51:10,220 --> 00:51:12,670
>>但很多時候，你可以注入惡意JavaScript代碼

854
00:51:12,670 --> 00:51:15,630
到別人的數據庫，如果他們不逃避，妥善，

855
00:51:15,630 --> 00:51:18,280
那麼當他們提出這些數據返回給用戶，

856
00:51:18,280 --> 00:51:21,310
那麼它可能會運行的任意JavaScript代碼一些你不希望發生的事情，

857
00:51:21,310 --> 00:51:23,050
而我將演示你如何做到這一點在Kohana的。

858
00:51:23,050 --> 00:51:25,380
它實際上是真的，真的很方便。

859
00:51:25,380 --> 00:51:31,920
我能做到這一點，現在在2秒內從字面上。

860
00:51:31,920 --> 00:51:34,560
所有您需要做的基本上是包裝這些東西

861
00:51:34,560 --> 00:51:46,920
在這個東西叫做HTML實體。

862
00:51:46,920 --> 00:51:51,180
並且，將自動轉義的所有字符正確

863
00:51:51,180 --> 00:51:54,730
並確保你沒有得到這個問題。

864
00:51:54,730 --> 00:51:57,220
[學生]你拼了第一次測試不正確。

865
00:51:57,220 --> 00:52:01,030
[布蘭登劉]哦，哎呀。

866
00:52:01,030 --> 00:52:06,420
>>好吧，這就是我不得不跟你今天分享。

867
00:52:06,420 --> 00:52:09,930
這些幻燈片將要發布，不過一般都是

868
00:52:09,930 --> 00:52:13,900
你應該真正需要的唯一資源開始使用Kohana的。

869
00:52:13,900 --> 00:52:16,770
你可以去網站。他們有一個用戶指南，他們也有一個API的探險家。

870
00:52:16,770 --> 00:52:20,630
我們可以探討各種不同的功能和輔助功能，它們對你。

871
00:52:20,630 --> 00:52:22,070
他們一般都在網站上足夠的信息

872
00:52:22,070 --> 00:52:25,310
您可以使用上手並獲得與Kohana中去。

873
00:52:25,310 --> 00:52:30,840
有沒有那麼多的教程，我認為，對於Kohana中，外

874
00:52:30,840 --> 00:52:33,880
他們有什麼網站就到這裡，所以這可能是你最好的選擇。

875
00:52:33,880 --> 00:52:35,600
但是，如果你想要去的web框架

876
00:52:35,600 --> 00:52:37,120
你不希望有拿起一個新的語言，

877
00:52:37,120 --> 00:52:39,780
你想要的東西，也比較輕巧，有一個簡單的學習曲線，

878
00:52:39,780 --> 00:52:41,570
我肯定會建議Kohana的。

879
00:52:41,570 --> 00:52:44,040
這可能是為最好的產品。

880
00:52:44,040 --> 00:52:46,830
有趣的事情，雖然是如果我們是在Rails的使用Ruby，

881
00:52:46,830 --> 00:52:48,550
我們可以複製我們剛剛做

882
00:52:48,550 --> 00:52:51,430
而且可能更在3分鐘內。

883
00:52:51,430 --> 00:52:54,710
可不是鬧著玩的，但學習Ruby on Rails需要花費很多時間

884
00:52:54,710 --> 00:52:56,780
比，將採取學習Kohana的。

885
00:52:56,780 --> 00:52:58,840
它基本上是你的選擇，你要選擇學什麼，

886
00:52:58,840 --> 00:53:01,260
但如果你想獲得快速建立和運行，

887
00:53:01,260 --> 00:53:03,870
Kohana的絕對是一個非常不錯的選擇。

888
00:53:03,870 --> 00:53:06,730
>>任何最後幾個問題，才結束？是。

889
00:53:06,730 --> 00:53:08,020
[學生]如何將我們整合了

890
00:53:08,020 --> 00:53:13,120
在一個CSS框架，比如你使用時，你被指示？

891
00:53:13,120 --> 00:53:16,700
現在的問題是如何將我們整合了一個CSS框架？

892
00:53:16,700 --> 00:53:18,740
我們可能會做的是，我們可能會包括

893
00:53:18,740 --> 00:53:21,090
一個新的文件夾，我們將放棄我們所有的CSS文件，

894
00:53:21,090 --> 00:53:23,010
然後我們也想補充一個新的模板。

895
00:53:23,010 --> 00:53:26,090
在模板中，我們希望包括CSS文件

896
00:53:26,090 --> 00:53:28,410
以確保他們在每一個頁面上引用，

897
00:53:28,410 --> 00:53:32,220
然後當你真正在寫HTML，

898
00:53:32,220 --> 00:53:34,010
你只需要添加相應的類和諸如此類的東西，

899
00:53:34,010 --> 00:53:36,100
和例如，當你使用類似的形式

900
00:53:36,100 --> 00:53:40,710
輔助函數，你可以以後添加更多的參數

901
00:53:40,710 --> 00:53:42,830
以指定要連接到各種各樣的東西哪些類

902
00:53:42,830 --> 00:53:47,820
這樣他們就可以正確設置其樣式，而且基本上你將如何去。

903
00:53:47,820 --> 00:53:50,100
>>其他問題嗎？

904
00:53:50,100 --> 00:53:52,090
真棒。

905
00:53:52,090 --> 00:53:58,540
謝謝您的時間，並感謝您的光臨。

906
00:53:58,540 --> 00:54:05,170
我是不是要添加很多東西，

907
00:54:05,170 --> 00:54:08,560
但1非常快的事情是我們沒有一個鏈接

908
00:54:08,560 --> 00:54:12,590
到窗體。

909
00:54:12,590 --> 00:54:14,310
非常愚蠢的。

910
00:54:14,310 --> 00:54:20,110
讓我們添加一個 - 居然在看，博客，指數，

911
00:54:20,110 --> 00:54:23,890
讓我們真的很快補充說，進入新的頁面的鏈接，

912
00:54:23,890 --> 00:54:26,770
的頁面，我們可以插入一個新的職位。

913
00:54:26,770 --> 00:54:29,950
我們將做到這一點。

914
00:54:29,950 --> 00:54:34,020
什麼是好的是存在的HTML輔助函數這整個組

915
00:54:34,020 --> 00:54:37,090
它為你做不同的事情，所以你已經看到了實體

916
00:54:37,090 --> 00:54:41,980
在這裡發揮作用，但他們也有一個功能叫做“錨”

917
00:54:41,980 --> 00:54:45,400
您可以輸入博客/新

918
00:54:45,400 --> 00:54:49,550
並說，“郵政一個新的博客。”

919
00:54:49,550 --> 00:54:51,850
而且，它還將創建一個鏈接給你，

920
00:54:51,850 --> 00:54:54,120
這似乎真的容易做到，但是這是很好的，

921
00:54:54,120 --> 00:54:58,720
因為假設你正在你的網站從1個域到另一個。

922
00:54:58,720 --> 00:55:01,390
如果你只是自己寫出來的URL，

923
00:55:01,390 --> 00:55:04,350
那麼你將不得不改變所有的URL。

924
00:55:04,350 --> 00:55:06,850
或者，也許你從1子文件夾移動到另一個子文件夾。

925
00:55:06,850 --> 00:55:08,790
你必須自己改變所有這些網址，

926
00:55:08,790 --> 00:55:12,180
而這不好玩。

927
00:55:12,180 --> 00:55:14,510
你可以使用這個錨在這裡，

928
00:55:14,510 --> 00:55:18,950
您可以更改域名或子文件夾的前綴

929
00:55:18,950 --> 00:55:20,640
在配置文件中一次，

930
00:55:20,640 --> 00:55:22,980
然後它將應用的無處不在，這就是，同樣，

931
00:55:22,980 --> 00:55:26,930
一個很好的例子，不要重複自己，曬你的代碼了。

932
00:55:26,930 --> 00:55:30,370
無論你正在重複自己，嘗試和提取某種配置文件

933
00:55:30,370 --> 00:55:34,160
或到不同的函數，並將它處理為你。

934
00:55:34,160 --> 00:55:42,930
>>而且，我想告訴你的最後一件事是

935
00:55:42,930 --> 00:55:50,250
假設我們回到這個帖子，和我組成了一些很長的文章，

936
00:55:50,250 --> 00:55:52,670
但我忘了，包括我的作者。

937
00:55:52,670 --> 00:55:55,210
現在，當我點擊“提交郵報”

938
00:55:55,210 --> 00:55:57,270
我只是失去了一切。

939
00:55:57,270 --> 00:56:00,000
不！真的很傷心。

940
00:56:00,000 --> 00:56:03,870
那麼，你如何處理呢？

941
00:56:03,870 --> 00:56:06,070
這是我們做的。

942
00:56:06,070 --> 00:56:09,340
我們要做的就是在這裡為這些輸入和文本區域的功能，

943
00:56:09,340 --> 00:56:12,700
如果我們有第二個參數，即第二個參數則該值

944
00:56:12,700 --> 00:56:16,620
將是什麼樣的字段是要首先填充來。

945
00:56:16,620 --> 00:56:23,570
我們可以做的是在我們的博客控制器，

946
00:56:23,570 --> 00:56:25,360
我們可以綁定另一個變量。

947
00:56:25,360 --> 00:56:27,050
稱之為“價值觀”也許吧。

948
00:56:27,050 --> 00:56:30,620
並通過後數組中，從字面上。

949
00:56:30,620 --> 00:56:32,620
這意味著，如果驗證失敗，

950
00:56:32,620 --> 00:56:36,570
傳遞給我，我從最後一個請求提交後陣，

951
00:56:36,570 --> 00:56:38,420
而且這樣我可以從我的上次提交使用的值

952
00:56:38,420 --> 00:56:44,540
重新填充該字段。

953
00:56:44,540 --> 00:56:49,600
現在，我可以做一些像筆者的值

954
00:56:49,600 --> 00:56:55,180
和值身體，這種方式現在如果我做了一些隨機的東西

955
00:56:55,180 --> 00:57:01,490
並點擊“提交後”，那麼它在那裡停留。

956
00:57:01,490 --> 00:57:03,830
但我們要碰到的另一個問題。

957
00:57:03,830 --> 00:57:07,670
這樣的作品，但如果我去到頁面的第一次，

958
00:57:07,670 --> 00:57:09,720
它會崩潰，那是因為這是第一次

959
00:57:09,720 --> 00:57:13,730
我們去的網頁，這個帖子變量沒有被定義。

960
00:57:13,730 --> 00:57:18,170
它為空。它不存在。

961
00:57:18,170 --> 00:57:21,630
>>而我們想說的是，如果該鍵存在，

962
00:57:21,630 --> 00:57:27,750
然後返回這個數組的值，

963
00:57:27,750 --> 00:57:30,450
但是，如果該鍵不存在，則返回一個空字符串。

964
00:57:30,450 --> 00:57:32,150
這就是我們想在這裡的功能。

965
00:57:32,150 --> 00:57:34,690
我們要檢查鑰匙是否存在試圖訪問該陣列之前，

966
00:57:34,690 --> 00:57:36,580
而幸運的是，

967
00:57:36,580 --> 00:57:38,570
Kohana的也給了我們一個輔助函數，該函數。

968
00:57:38,570 --> 00:57:41,040
他們有這樣的整體功能套件

969
00:57:41,040 --> 00:57:43,660
的名義下房租，簡稱陣列，

970
00:57:43,660 --> 00:57:45,800
他們有1個功能叫做“得”

971
00:57:45,800 --> 00:57:48,690
您可以通過在陣列中，

972
00:57:48,690 --> 00:57:50,740
你可以通過在鍵的名稱。

973
00:57:50,740 --> 00:57:54,330
那麼基本上它會做什麼是它會嘗試獲取該鍵，

974
00:57:54,330 --> 00:57:56,470
但是，如果該鍵沒有在數組中存在，

975
00:57:56,470 --> 00:58:00,900
然後將返回空，或者我們也可以指定一個默認的，我相信，

976
00:58:00,900 --> 00:58:03,500
這是很好的。

977
00:58:09,740 --> 00:58:13,150
現在，如果我們再次做同樣的事情，

978
00:58:13,150 --> 00:58:15,970
那麼你現在看到它的工作原理周圍的第一次，

979
00:58:15,970 --> 00:58:18,080
並再次，如果我們輸入一些隨機的東西

980
00:58:18,080 --> 00:58:23,210
並嘗試並提交，那麼它在那裡停留。

981
00:58:23,210 --> 00:58:31,640
>>我想我也可以告訴你如何真正快速添加的模板。

982
00:58:31,640 --> 00:58:36,140
我們可以首先做的是，我們可以添加一個名為“的template.php”的新觀點

983
00:58:36,140 --> 00:58:38,890
在Views文件夾，

984
00:58:38,890 --> 00:58:44,730
而我什麼都做的是我要打印出一些所謂的“內容”，

985
00:58:44,730 --> 00:58:49,130
這將是我的主要內容。

986
00:58:49,130 --> 00:58:51,380
也許在最底層我要補充，比方說，

987
00:58:51,380 --> 00:58:53,340
版權所有。

988
00:58:53,340 --> 00:58:56,150
[聽不見學生提問]

989
00:58:56,150 --> 00:58:58,050
[布蘭登劉]也許這是一個超級的基本模板，我想用。

990
00:58:58,050 --> 00:59:02,840
我想和我的版權，每一個單頁的文件夾中，

991
00:59:02,840 --> 00:59:05,560
現在我什麼都在我的控制做的

992
00:59:05,560 --> 00:59:07,740
是不是說現在，“擴展控制器”

993
00:59:07,740 --> 00:59:11,870
我會說，“延伸Controller_Template，”

994
00:59:11,870 --> 00:59:15,890
而不是說，現在，“響應體等於這個觀點，”

995
00:59:15,890 --> 00:59:24,110
我會說，“這個模板的內容是 - ”

996
00:59:24,110 --> 00:59:27,690
我認為 - 我把等號？

997
00:59:27,690 --> 00:59:32,710
我忘記了。是啊，我是這麼認為的。

998
00:59:32,710 --> 00:59:37,710
現在我設定的內容變量等於視圖。

999
00:59:37,710 --> 00:59:40,960
我可以在這裡做同樣的。

1000
00:59:49,620 --> 00:59:57,170
現在如果我刷新，你可以看到現在這個版權被添加在那裡，

1001
00:59:57,170 --> 01:00:00,350
而只是進行一些隨機的帖子，

1002
01:00:00,350 --> 01:00:06,760
然後，再次，你應該看到，版權是在頁面的最底部。

1003
01:00:06,760 --> 01:00:10,730
>>大。這就是我想給大家看看。

1004
01:00:10,730 --> 01:00:14,970
[鼓掌]

1005
01:00:14,970 --> 01:00:18,950
有問題嗎？

1006
01:00:18,950 --> 01:00:21,000
[CS50.TV]