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]