1
00:00:00,000 --> 00:00:02,150
[Powered by Google Translate] [講座] [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
你可能已經做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
你應著眼於你的網絡分配實際上是。

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
一個更複雜的Web應用程序，

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
你會經常聽到人們談論棧在web開發中，

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
他們真的不鼓勵你們分開這3樣東西。

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個理想的代碼應該做的事情，這樣做真的很好，

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
如果你想改變的事情，你必須改變它無處不在，

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
因為它是運行Linux，而不是OS X。

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
你可以看到大多數事情過去了，但一般你總是碰上這個問題

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
但如果你做web開發，你會碰到這個問題很多。

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
但我要找的是這個東西叫做基地網址，

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
默認情況下，要看到它的工作，它說的“Hello World”。

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
例如，如果你有一些網址，你去foo.com /博客/所有像某些URL

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
尖括號內，這意味著，我們命名這個參數ID。

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的事情在你的URL，

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
>> 正如你可以看到，有一個文件叫example.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
一般每個表對應於不同的數據對象，

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
更多的概念之前，我們潛回代碼，

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
現在，我必須撤消變化，我只是做了。

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
我們有我們的標題，然後我們有個post，

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
包裹在一個try一切趕上循環。

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
，不過，有趣的是，如果我們使用Ruby on Rails，

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
但真快的事情是我們沒有鏈接

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
那麼你將不得不改變所有的網址。

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
ARR的名字下，短陣列，

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]