1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [的演练习题集7]

2
00:00:03,000 --> 00:00:04,400
[Zamyla陈] [哈佛大学]

3
00:00:04,400 --> 00:00:07,640
[这是CS50] [CS50.TV]

4
00:00:07,640 --> 00:00:12,090
>> 大家好，欢迎演练，CS50金融。

5
00:00:12,090 --> 00:00:15,090
现在，我们正式完成所有pset时，CS50

6
00:00:15,090 --> 00:00:19,380
我们剩下的就只有一个这将是一个有趣的实施

7
00:00:19,380 --> 00:00:23,770
一个网站，用户可以登录到CS50金融

8
00:00:23,770 --> 00:00:25,830
买入和卖出股票。

9
00:00:25,830 --> 00:00:32,280
>> 今天，我们将在我们的处置有几个工具。

10
00:00:32,280 --> 00:00:34,320
我们要去谈论的权限。

11
00:00:34,320 --> 00:00:36,380
只要你有一个Web文件夹，

12
00:00:36,380 --> 00:00:40,800
你会想允许用户执行某些文件

13
00:00:40,800 --> 00:00:42,500
但也只是阅读其他的，

14
00:00:42,500 --> 00:00:45,150
让我们来看看权限和如何设置这些。

15
00:00:45,150 --> 00:00:49,630
然后我们要看看到PHP，HTML，SQL代码。

16
00:00:49,630 --> 00:00:51,990
>> 首先，权限。

17
00:00:51,990 --> 00:00:56,060
当你在一个特定的目录中的终端，

18
00:00:56,060 --> 00:01:00,430
然后你想要做的是你要运行的chmod命令。

19
00:01:00,430 --> 00:01:03,750
这是其次是字母或数字

20
00:01:03,750 --> 00:01:08,100
相应的，你基本上希望世界看到，

21
00:01:08,100 --> 00:01:09,830
你看，等等。

22
00:01:09,830 --> 00:01:13,350
例如，当你有一个文件夹，

23
00:01:13,350 --> 00:01:15,560
那么，您希望该文件夹中的每个人都认为它是可执行的，

24
00:01:15,560 --> 00:01:19,500
所以你会做什么，你可以运行命令chmod A + X

25
00:01:19,500 --> 00:01:21,050
然后你的文件夹的名称。

26
00:01:21,050 --> 00:01:28,110
当你有一个文件，如CSS文件或图像文件 - 

27
00:01:28,110 --> 00:01:33,060
像JPEG和位图之类的东西，或任何JavaScript代码 - 

28
00:01:33,060 --> 00:01:36,440
你想成为人人可读的，

29
00:01:36,440 --> 00:01:39,880
这样的话，你要做的就是，你可以使用通配符 - 

30
00:01:39,880 --> 00:01:41,650
这是一个星号 - 

31
00:01:41,650 --> 00:01:46,190
基本上表明在CSS文件夹 - 在该文件夹中的一切 - 

32
00:01:46,190 --> 00:01:48,740
 我会说，这将是人人可读的。

33
00:01:48,740 --> 00:01:54,220
使用权限，当我们使用字母，

34
00:01:54,220 --> 00:01:57,610
我们也可以用数字来代替。

35
00:01:57,610 --> 00:02:00,900
所以，你看，最终当你想要的东西必须是可执行的 - 

36
00:02:00,900 --> 00:02:02,810
所表示的数字1  - 

37
00:02:02,810 --> 00:02:08,340
是可读的东西是多少，然后 - 

38
00:02:08,340 --> 00:02:10,590
写的是2号 - 

39
00:02:10,590 --> 00:02:13,670
，所以基本上这些当你想要一个组合，那么你将它们添加。

40
00:02:13,670 --> 00:02:15,860
如果你想要的东西可读，可写，可执行文件，

41
00:02:15,860 --> 00:02:21,970
那么你会增加4，2，1，能够让你7，

42
00:02:21,970 --> 00:02:26,230
然后，只要你有一个文件夹，你想，每个人都必须是可执行的 - 

43
00:02:26,230 --> 00:02:31,380
以及为可读和可写的 - 那么你做，7，1，1。

44
00:02:31,380 --> 00:02:38,140
这将是7你，那么其他人。

45
00:02:38,140 --> 00:02:42,870
当你有规范，实际上，它会指定哪些文件夹和文件

46
00:02:42,870 --> 00:02:45,040
需要搭配chmod  - 特别。

47
00:02:45,040 --> 00:02:47,920
例如，当你有文件夹 - 这些是7-1-1  - 

48
00:02:47,920 --> 00:02:52,690
当你有图像，HTML，CSS，JavaScript的，

49
00:02:52,690 --> 00:02:55,870
那么这些都将是6，0，4  - 或6个，4个，4  - 

50
00:02:55,870 --> 00:03:00,030
PHP文件，然后将要6，0，0。

51
00:03:00,030 --> 00:03:04,940
背后的想法是，用户不应该真正看到你的PHP代码，

52
00:03:04,940 --> 00:03:08,370
但仅仅是能够看到的输出。

53
00:03:08,370 --> 00:03:11,030
>> 太好了！移动到PHP。

54
00:03:11,030 --> 00:03:18,850
简单地说，只要你想有一个PHP文件时，文件的后缀是。PHP。

55
00:03:18,850 --> 00:03:22,000
您也可以混合使用HTML与PHP代码。

56
00:03:22,000 --> 00:03:24,880
如果你有一个HTML文件，例如，

57
00:03:24,880 --> 00:03:32,520
那么你就可以将其括在左边的角，问号，PHP  - 

58
00:03:32,520 --> 00:03:39,320
把你的PHP代码 - 然后关闭，另一个问号和一个直角。

59
00:03:39,320 --> 00:03:45,020
PHP中的变量是一个更容易比C中的​​变量处理

60
00:03:45,020 --> 00:03:50,310
任何变量都在它的前面有一个美元符号，刚开始他们是弱类型的。

61
00:03:50,310 --> 00:03:53,470
这意味着，你不必担心设置的东西

62
00:03:53,470 --> 00:03:55,020
等于一个字符串或一个整数。

63
00:03:55,020 --> 00:03:57,710
您可以只是简单的说，这是我的变量名

64
00:03:57,710 --> 00:04:00,390
然后，这是它的值，

65
00:04:00,390 --> 00:04:03,280
所以它会更容易处理有。

66
00:04:03,280 --> 00:04:08,220
>> 另一件事是，PHP也允许你使用关联数组。

67
00:04:08,220 --> 00:04:11,330
您可以简单地定义一个数组，就像你会在C

68
00:04:11,330 --> 00:04:14,900
说，美元符号的名称，您的阵列等于，

69
00:04:14,900 --> 00:04:22,600
然后在方括号中基本上只是在数组中的所有元素的值列表。

70
00:04:22,600 --> 00:04:27,160
但是，在PHP中，你也可以做的是指定基本上是 - 

71
00:04:27,160 --> 00:04:31,050
它有点像一个哈希函数。

72
00:04:31,050 --> 00:04:34,410
您可以指定索引 - 你打算把它称为 - 

73
00:04:34,410 --> 00:04:37,030
然后，对应于值。

74
00:04:37,030 --> 00:04:42,880
如果你确实通过在A = 1，B = 2，C = 3，

75
00:04:42,880 --> 00:04:50,820
那么你的索引数组的一个给你。

76
00:04:50,820 --> 00:04:56,600
这pset的会让你暖和了一些PHP中的部分问题，

77
00:04:56,600 --> 00:04:59,240
然后我们潜水到CS50融资。

78
00:04:59,240 --> 00:05:02,650
>> 我们有一对夫妇 - 我们有一些功能，基本上，

79
00:05:02,650 --> 00:05:05,130
在这个网站实现。

80
00:05:05,130 --> 00:05:10,440
我们希望允许用户在我们的网站上注册的用户名和密码。

81
00:05:10,440 --> 00:05:13,670
我们希望，让他们看报价，

82
00:05:13,670 --> 00:05:19,330
，那我们就打印出了名的，报价以及目前的价格，它是在。

83
00:05:19,330 --> 00:05:26,830
我们希望让他们看到一个组合，他们已经买了迄今为止的所有股份。

84
00:05:26,830 --> 00:05:34,240
我们也希望让他们买股票卖给他们。

85
00:05:34,240 --> 00:05:37,540
最后，我们想要让他们看到了历史

86
00:05:37,540 --> 00:05:39,490
所有的交易，他们已经取得了。

87
00:05:39,490 --> 00:05:41,540
然后，终于，你已经实现了这一切，

88
00:05:41,540 --> 00:05:45,110
那么，你是自由的实现一个额外的功能。

89
00:05:45,110 --> 00:05:46,610
我们将进入这些。

90
00:05:46,610 --> 00:05:51,330
这些可以是让用户获得额外的现金存入额外的现金，

91
00:05:51,330 --> 00:05:54,550
或者你可以让他们改变自己的密码，或类似的东西，

92
00:05:54,550 --> 00:06:00,590
给他们发邮件的收据时，他们买进或卖出股票。

93
00:06:00,590 --> 00:06:05,370
有一个有限的列表，你可以实现自己的功能，

94
00:06:05,370 --> 00:06:08,340
所以这是最后一个。

95
00:06:08,340 --> 00:06:13,430
>> 由于这是一个网站，你们也有很大的自由度来定制它。

96
00:06:13,430 --> 00:06:20,960
我们提供一些CSS代码，但你绝对自由调整，

97
00:06:20,960 --> 00:06:26,680
使它看起来更好，但背后是一个基本的功能

98
00:06:26,680 --> 00:06:30,310
所以你的实际需要，包括有参考的规范。

99
00:06:30,310 --> 00:06:39,940
规范，我们将要使用的设备也是一个服务器。

100
00:06:39,940 --> 00:06:43,910
这将承载我们的网站对我们来说，它的本地服务器上。

101
00:06:43,910 --> 00:06:49,750
如果您按照这些说明并解压缩在pset分配代码

102
00:06:49,750 --> 00:06:53,500
到您的虚拟主机/本地主机文件夹，

103
00:06:53,500 --> 00:07:02,470
 那么你就可以访问http://localhost/在谷歌浏览器在家电，

104
00:07:02,470 --> 00:07:09,120
然后你会达到你写的代码中，pset中7。

105
00:07:09,120 --> 00:07:14,490
>> PSET 7自带的分布一堆代码，

106
00:07:14,490 --> 00:07:18,330
并希望我们已经 - 在此之前的所有pset时 - 

107
00:07:18,330 --> 00:07:21,700
习惯我们读通过分配代码，

108
00:07:21,700 --> 00:07:25,650
了解已经提供了哪些功能，以及我们如何能够使用

109
00:07:25,650 --> 00:07:29,470
那些和我们将要实施的其他功能。

110
00:07:29,470 --> 00:07:31,570
在这种情况下，我们有3个文件夹。

111
00:07:31,570 --> 00:07:36,350
我们有一个HTML的文件夹，包括文件夹，文件夹和模板“文件夹。

112
00:07:36,350 --> 00:07:40,630
我们将做这个pset的是一种分离的思想 - 

113
00:07:40,630 --> 00:07:45,580
编程思想 - 与实际视觉方面的PHP代码。

114
00:07:45,580 --> 00:07:52,690
我们将有一个PHP文件，它所有的思想，读入数据库，

115
00:07:52,690 --> 00:07:55,620
打印出来的东西，有，如果的报表 - 这样的事情 - 

116
00:07:55,620 --> 00:08:02,140
，然后将数据传递到我们的模板文件 - 或template.php文件。

117
00:08:02,140 --> 00:08:05,710
什么，会做的就是读取数据，然后将其打印出来。

118
00:08:05,710 --> 00:08:09,550
>> 我们可以把为“哑”，因为我们真的不希望他们的模板

119
00:08:09,550 --> 00:08:12,370
被计算的东西，做了很多的工作。

120
00:08:12,370 --> 00:08:16,330
我们希望我们的控制器来做到这一点。

121
00:08:16,330 --> 00:08:21,610
 - 一点点，让我们来看看一些分配代码。

122
00:08:21,610 --> 00:08:28,250
在这里，我们有我们的index.html文件，这是很空的。

123
00:08:28,250 --> 00:08:34,429
从本质上讲它做什么 - 它说，好，我会要求configuration.php文件。

124
00:08:34,429 --> 00:08:40,120
我们没有看到，就在那里，但它基本上是调用configuration.php文件，

125
00:08:40,120 --> 00:08:42,240
和执行。

126
00:08:42,240 --> 00:08:45,130
后，这将导致投资组合。

127
00:08:45,130 --> 00:08:49,310
渲染是一个函数，所以每当我们在一个控制器，

128
00:08:49,310 --> 00:08:56,490
我们将调用render，我们会给它的文件，然后我们传递的数据中，

129
00:08:56,490 --> 00:09:04,570
因此，它会调用在portfolio.php种传中的数据，这样的组合可以处理这个问题。

130
00:09:04,570 --> 00:09:10,540
>> 而现在，在这里，我们有我们的login.php形式。

131
00:09:10,540 --> 00:09:17,540
 这是控制器，基本上需要照顾的日志记录中。

132
00:09:17,540 --> 00:09:29,090
在这里，它会检查是否提交表单这个文件，交易确认提交。

133
00:09:29,090 --> 00:09:31,990
我们来看看这表示歉意功能。

134
00:09:31,990 --> 00:09:35,100
当我们要打印出一条错误消息，

135
00:09:35,100 --> 00:09:39,550
我们使用的道歉，这将用户重定向到一个特定的页面

136
00:09:39,550 --> 00:09:42,530
，将打印出具体的错误信息，我们表示。

137
00:09:42,530 --> 00:09:47,860
持续，它会查询数据库 - 我们就会得到更多的后来。

138
00:09:47,860 --> 00:09:54,180
然后你就看到，在这里，如果一个表单没有提交，那么它呈现的一种形式。

139
00:09:54,180 --> 00:10:01,360
这意味着它去login_form.php的，所以让我们来看看这个。

140
00:10:01,360 --> 00:10:09,400
>> login.php的是，其实我们看到的HTML交易的实际视觉方面。

141
00:10:09,400 --> 00:10:15,130
在这里，我们有一个输入标签的用户名，输入的密码，

142
00:10:15,130 --> 00:10:16,630
以及一个提交按钮。

143
00:10:16,630 --> 00:10:22,660
这实际上是将要举行的视觉效果和HTML形式。

144
00:10:22,660 --> 00:10:27,550
在这里，它说，它要提交通过一定的方法，称为后。

145
00:10:27,550 --> 00:10:30,190
我们将进入方法之间的差异 - 

146
00:10:30,190 --> 00:10:33,240
发布与获取，也称为放的东西 - 

147
00:10:33,240 --> 00:10:36,160
稍后我们将进入这些方法，但本的pset的利益，

148
00:10:36,160 --> 00:10:37,810
我会强烈建议您使用后。

149
00:10:37,810 --> 00:10:42,210
>> 我们知道，基本上，一旦该表单被提交 - 

150
00:10:42,210 --> 00:10:44,650
从login_form.php  - 

151
00:10:44,650 --> 00:10:50,850
然后，它会去行动 -  login.php的 - 

152
00:10:50,850 --> 00:10:56,070
基本上通过这些形式在所有这些参数到login.php的。

153
00:10:56,070 --> 00:11:04,900
这种形式的结果都包含在这个职位的关联数组。

154
00:11:04,900 --> 00:11:11,710
后数组中的不同元素的索引

155
00:11:11,710 --> 00:11:15,290
正是您在此处指定。

156
00:11:15,290 --> 00:11:19,240
你说，该输入的是用户名的名称。这个名称是密码。

157
00:11:19,240 --> 00:11:26,840
同样的，你的用户名作为关联数组的索引。

158
00:11:26,840 --> 00:11:35,110
如果我们去的包括文件夹，我们有这个功能的文件，该文件将是非常有用的。

159
00:11:35,110 --> 00:11:37,570
>> 所有这些功能都实现了你。

160
00:11:37,570 --> 00:11:41,870
你并不需要具体落实这些自己，

161
00:11:41,870 --> 00:11:43,140
但他们会非常有用。

162
00:11:43,140 --> 00:11:49,450
我们已经道歉，正如我之前说的，基本上会打印出一个错误信息

163
00:11:49,450 --> 00:11:52,920
你在一个特定的页面 -  apology.php。

164
00:11:52,920 --> 00:11:59,890
然后，我们有转储，因此，如果你只需要调用转储，然后通过在变量，

165
00:11:59,890 --> 00:12:04,930
然后，它会带给你一个页面，显示该变量。

166
00:12:04,930 --> 00:12:09,950
然后，我们已经注销，这将基本结束一个特定用户的会话。

167
00:12:09,950 --> 00:12:12,240
查找将是有益的。

168
00:12:12,240 --> 00:12:15,870
由于我们的报价和股票，我们将能够 - 

169
00:12:15,870 --> 00:12:17,650
它本质上是实时的。

170
00:12:17,650 --> 00:12:21,380
我们需要知道这些股票价值是什么，

171
00:12:21,380 --> 00:12:28,210
所以我们有查找功能，雅虎股票的文档处理。

172
00:12:28,210 --> 00:12:37,700
一旦你看到了一定的符号的股票，它会返回到您的股票代码

173
00:12:37,700 --> 00:12:41,480
以及该股票的名称和目前的价格。

174
00:12:41,480 --> 00:12:44,330
这就是查找功能。

175
00:12:44,330 --> 00:12:48,350
>> 然后，我们使用MySQL，

176
00:12:48,350 --> 00:12:53,970
所以我们想在我们的SQL数据库执行某些查询。

177
00:12:53,970 --> 00:12:58,890
我们有查询处理 - 一些抽象出来的​​一种。

178
00:12:58,890 --> 00:13:03,200
我们要通过我们的SQL查询整个字符串 - 

179
00:13:03,200 --> 00:13:05,360
和所有的变量去 - 

180
00:13:05,360 --> 00:13:09,480
这是什么做的是，我们实际执行。

181
00:13:09,480 --> 00:13:15,070
而不是写每次要查询出来的这一切 - 

182
00:13:15,070 --> 00:13:21,740
从该查询得到的结果 - 

183
00:13:21,740 --> 00:13:24,740
那么你可以致电查询功能，它会返回给你 - 

184
00:13:24,740 --> 00:13:28,750
这取决于你正在使用您的查询 - 

185
00:13:28,750 --> 00:13:33,000
可能是一个行与查询匹配的或类似的所有的结果。

186
00:13:33,000 --> 00:13:34,690
更多关于了。

187
00:13:34,690 --> 00:13:41,200
>> 最后，我们有，重定向，正如其名称所暗示的，将您重定向到一个不同的页面。

188
00:13:41,200 --> 00:13:46,280
然后我们有渲染，我们将要调用几次。

189
00:13:46,280 --> 00:13:51,010
当你在一个控制器，可以调用渲染到模板页

190
00:13:51,010 --> 00:13:55,390
然后通过该模板​​将处理的值。

191
00:13:55,390 --> 00:13:59,540
这些值可能是将要处理的输出，你要的类型

192
00:13:59,540 --> 00:14:01,050
显示在模板页。

193
00:14:01,050 --> 00:14:09,370
好吧。这些功能，并有更多的特定此分发代码。

194
00:14:09,370 --> 00:14:12,930
我鼓励你去探索自己。

195
00:14:12,930 --> 00:14:17,050
此外，该规范可能会引导你通过一些其他元素的分布代码。

196
00:14:17,050 --> 00:14:27,360
下面是总结的functions.php中发现的功能。

197
00:14:27,360 --> 00:14:31,710
>> 好吧。第一项任务就是让用户在网站上注册。

198
00:14:31,710 --> 00:14:34,860
现在，在网站上有一个登录表单，

199
00:14:34,860 --> 00:14:40,080
为您提供了几个用户的密码。

200
00:14:40,080 --> 00:14:42,130
您可以使用这些用户名和登录，

201
00:14:42,130 --> 00:14:45,140
但你想要让人们作出自己的用户名

202
00:14:45,140 --> 00:14:47,390
并添加自己的网站。

203
00:14:47,390 --> 00:14:53,070
登记的布局是非常相似的登录表单，

204
00:14:53,070 --> 00:14:56,340
除了用户名是不存在的，

205
00:14:56,340 --> 00:14:59,430
用户还需要提供一个新的密码，

206
00:14:59,430 --> 00:15:02,440
然后通常我们有一个密码确认。

207
00:15:02,440 --> 00:15:06,580
一旦用户输入的所有信息，

208
00:15:06,580 --> 00:15:10,620
我们想将它们添加到我们的数据库中的用户。

209
00:15:10,620 --> 00:15:12,970
我们将有一个数据库 -  SQL数据库 - 

210
00:15:12,970 --> 00:15:14,470
我们将引用。

211
00:15:14,470 --> 00:15:18,140
在该数据库中，我们将有一个表的所有用户

212
00:15:18,140 --> 00:15:23,850
包含自己的用户名，密码，也多少现金。

213
00:15:23,850 --> 00:15:28,480
>> 在寄存器中，我们要允许他们进入该信息。

214
00:15:28,480 --> 00:15:29,740
我们希望显示形式。

215
00:15:29,740 --> 00:15:32,210
我们要确保他们的密码 - 

216
00:15:32,210 --> 00:15:37,490
，他们进入了一个，然后也该密码匹配时，输入两次。

217
00:15:37,490 --> 00:15:42,240
所有这一切都完成 - 假设这些错误检查 - 

218
00:15:42,240 --> 00:15:45,120
那么，我们希望这些用户添加到我们的数据库。

219
00:15:45,120 --> 00:15:49,630
最后，一​​旦你已经注册了，这是很方便的，如果你不需要重新登录

220
00:15:49,630 --> 00:15:51,000
一旦你注册，

221
00:15:51,000 --> 00:15:54,000
所以，我们要登录他们的网站，如果他们已经注册成功。

222
00:15:54,000 --> 00:16:00,360
>> 第一个任务是显示的形式，这实际上是将是 - 

223
00:16:00,360 --> 00:16:04,920
整个注册过程进行建模非常密切登录后

224
00:16:04,920 --> 00:16:10,510
除了没有login.php的，你可能有注册页面register.php。

225
00:16:10,510 --> 00:16:14,300
而是login_form.php- - 这是模板 - 

226
00:16:14,300 --> 00:16:16,030
你就已经登记表。

227
00:16:16,030 --> 00:16:19,680
您需要添加更多的领域 - 密码确认字段 - 

228
00:16:19,680 --> 00:16:23,450
而不是只是一个用户名和一个密码。

229
00:16:23,450 --> 00:16:28,120
接下来，我们要检查的密码是否匹配，或者是空白的。

230
00:16:28,120 --> 00:16:38,560
我们的控制器 - 注册页面register.php  - 这是要照顾做这些检查。

231
00:16:38,560 --> 00:16:41,690
通过POST方法提交表单时，

232
00:16:41,690 --> 00:16:47,050
那么所有这些变量都包含在后阵列。

233
00:16:47,050 --> 00:16:52,280
你想，以确保指数的密码后数组的值

234
00:16:52,280 --> 00:16:58,080
确认元素相匹配。

235
00:16:58,080 --> 00:16:59,410
你想，以确保他们不为空，

236
00:16:59,410 --> 00:17:01,650
你想，以确保它们是相同的。

237
00:17:01,650 --> 00:17:05,960
>> 关于PHP的一个方便的事情是，我们并不需要使用字符串比较了。

238
00:17:05,960 --> 00:17:08,410
我们可以使用等于等于运算符

239
00:17:08,410 --> 00:17:11,470
 检查字符串是否是彼此相等的。

240
00:17:11,470 --> 00:17:14,960
对于错误处理，你要道歉。

241
00:17:14,960 --> 00:17:17,150
要道歉，你只需调用该函数

242
00:17:17,150 --> 00:17:21,910
 然后指定一个要输出的消息类型。

243
00:17:21,910 --> 00:17:24,630
然后，您要添加到数据库中的用户。

244
00:17:24,630 --> 00:17:30,880
到现在为止，我们一直在做的只是当地交易形式的结果。

245
00:17:30,880 --> 00:17:33,940
现在，我们确实希望将它们添加到我们的数据库。

246
00:17:33,940 --> 00:17:38,890
对于这一点，我们首先要确保不为空的用户名。

247
00:17:38,890 --> 00:17:44,550
了解，在网站上，你可以有多个用户相同的用户名，

248
00:17:44,550 --> 00:17:50,010
所以你要确保当你插入到你的数据库中的东西 - 

249
00:17:50,010 --> 00:17:56,650
添加一个新用户 - 然后你没有得到一个预先存在的用户名之间的冲突

250
00:17:56,650 --> 00:17:59,150
和用户名，用户试图提交。

251
00:17:59,150 --> 00:18:02,250
对于这一点，一旦你执行一个查询 - 

252
00:18:02,250 --> 00:18:08,760
插入一个特定的用户与他们的密码和一个初始量的现金 - 

253
00:18:08,760 --> 00:18:15,140
一旦你调用查询，那么MySQL将实际返回false，如果它失败。

254
00:18:15,140 --> 00:18:21,050
>> 结构的用户的用户名是一个独特的价值，

255
00:18:21,050 --> 00:18:22,540
所以你不能有一个以上的。

256
00:18:22,540 --> 00:18:30,080
当您尝试插入新行的用户名已经存在，

257
00:18:30,080 --> 00:18:34,470
将返回错误的 - 就像一个布尔值false。

258
00:18:34,470 --> 00:18:45,320
这里是一个棘手的事情，你要检查的结果是，如果您的查询结果。

259
00:18:45,320 --> 00:18:52,320
如果失败的话，那么你将要检查的三等于运算符。

260
00:18:52,320 --> 00:18:55,420
这实际上是要检查是否有故障或不，

261
00:18:55,420 --> 00:19:02,760
而在只是一个简单的等于，等于，这将是真实的，如果该行是空的。

262
00:19:02,760 --> 00:19:06,000
失败的结果，如果有一个用户名之间的碰撞

263
00:19:06,000 --> 00:19:10,350
是实际的错误值。

264
00:19:10,350 --> 00:19:15,230
>> 这里是你如何将插入到数据库中。

265
00:19:15,230 --> 00:19:19,220
这里是，你会严格执行SQL查询。

266
00:19:19,220 --> 00:19:25,750
有一件事是，你可以真正去管理您的SQL数据库的网站，

267
00:19:25,750 --> 00:19:31,070
和玩耍通过手动或者输入值或行。

268
00:19:31,070 --> 00:19:34,540
它将输出的SQL输出是什么。

269
00:19:34,540 --> 00:19:38,870
您也可以在数据库中执行SQL命令

270
00:19:38,870 --> 00:19:42,200
 然后看语法可能是什么，

271
00:19:42,200 --> 00:19:46,790
然后转换到查询功能，我们在pset中7，

272
00:19:46,790 --> 00:19:51,120
这将是非常相似的查询，在实际运行。

273
00:19:51,120 --> 00:19:54,570
>> 如果我希望我的用户表中插入新行，

274
00:19:54,570 --> 00:20:01,240
然后，我会指定插入到用户，这是我的表的名称。

275
00:20:01,240 --> 00:20:06,870
然后，我将指定列名。

276
00:20:06,870 --> 00:20:13,230
然后，我会随着我的密码提供的值。

277
00:20:13,230 --> 00:20:17,080
在我们的用户表中的密码不只是存储为字符串。

278
00:20:17,080 --> 00:20:19,440
它们被存储为加密的版本，

279
00:20:19,440 --> 00:20:24,560
所以你要运行的函数crypt实际的密码，

280
00:20:24,560 --> 00:20:29,680
，而且会给你正确的用户数组的存储类型。

281
00:20:29,680 --> 00:20:34,960
运行此将插入一个新行插入到用户表。

282
00:20:34,960 --> 00:20:39,020
>> 要处理的查询功能，

283
00:20:39,020 --> 00:20:43,100
我们以前在C百分号作为占位符。

284
00:20:43,100 --> 00:20:47,670
同样的一个占位符，同样的概念适用于这里。

285
00:20:47,670 --> 00:20:50,720
通过查询，您可以指定整个查询，

286
00:20:50,720 --> 00:20:55,510
但只要你正在处理的变量作为输入到查询，

287
00:20:55,510 --> 00:21:00,490
然后，而不是把他们里面 - 就像在C中的printf语句，当我们有

288
00:21:00,490 --> 00:21:03,740
我们将字符串，然后在那里有一个占位符，然后在每个

289
00:21:03,740 --> 00:21:06,990
逗号，指定的变量，我们有。

290
00:21:06,990 --> 00:21:14,480
在这里，我们要使用我们的占位符问号标志

291
00:21:14,480 --> 00:21:21,670
，然后通过每个变量中，分别按顺序的占位符 - 

292
00:21:21,670 --> 00:21:24,420
这些变量应该去的地方。

293
00:21:24,420 --> 00:21:29,470
所以在这里，第一个问号将被替换为实际的用户名

294
00:21:29,470 --> 00:21:33,610
然后第二个问号的账号和密码。

295
00:21:33,610 --> 00:21:37,000
>> 最后，一​​旦你注册了它们，并将它们添加到数据库中，

296
00:21:37,000 --> 00:21:40,510
然后，你要登录到网站。

297
00:21:40,510 --> 00:21:45,320
我们有一个超全局变量称为会话种。

298
00:21:45,320 --> 00:21:48,160
会话需要一定的id，

299
00:21:48,160 --> 00:21:51,750
该标识对应于当前登录的用户

300
00:21:51,750 --> 00:21:56,380
你会想要做的就是找​​到自己的用户名是什么

301
00:21:56,380 --> 00:22:03,710
然后设置特定的用户ID，会话ID。

302
00:22:03,710 --> 00:22:07,560
你要在这里使用的函数是一个SQL命令

303
00:22:07,560 --> 00:22:15,150
从表中，将检索最后插入的ID号。

304
00:22:15,150 --> 00:22:24,560
行会调用 -  it'll调用的ID  -  it'll指定一个名称，它返回的数量。

305
00:22:24,560 --> 00:22:27,900
它会调用该ID。

306
00:22:27,900 --> 00:22:33,370
现在，我们已经完成了注册，我们可以将引用。

307
00:22:33,370 --> 00:22:36,610
>> 报价允许用户输入的名称，一定的库存，

308
00:22:36,610 --> 00:22:41,940
然后它会返回该股票的素质。

309
00:22:41,940 --> 00:22:48,410
你会想在这里做的是有一个控制器和一些模板。

310
00:22:48,410 --> 00:22:53,380
在这种情况下，我们将有一个控制器，这是要为我们做所有的思想。

311
00:22:53,380 --> 00:23:01,210
要查找符号，然后传递值，将打印出的模板。

312
00:23:01,210 --> 00:23:03,060
我们要在这里有2个模板。

313
00:23:03,060 --> 00:23:07,260
我们将有1个模板，提供的表格中，用户要

314
00:23:07,260 --> 00:23:09,920
输入股票名称 - 这个名字的份额。

315
00:23:09,920 --> 00:23:16,030
然后我们也将要显示这些值的另一个模板。

316
00:23:16,030 --> 00:23:27,450
你可以看的一个例子，如何你想有一个接受输入的形式，登录，

317
00:23:27,450 --> 00:23:30,060
除了在这里，我们只需要1场。

318
00:23:30,060 --> 00:23:31,630
我们不希望一个用户名和密码字段。

319
00:23:31,630 --> 00:23:37,110
我们只是想让文本字段，允许用户输入某只股票的名称。

320
00:23:37,110 --> 00:23:40,110
然后，你要发送的数据 - 一旦你抬起头来，股票 - 

321
00:23:40,110 --> 00:23:45,550
到quote_form.php。

322
00:23:45,550 --> 00:23:50,780
查询将返回符号A股股票的名称，以及价格。

323
00:23:50,780 --> 00:23:53,910
这些都包含在一个关联数组。

324
00:23:53,910 --> 00:24:01,390
查一查的functions.php内查找功能的更多信息

325
00:24:01,390 --> 00:24:04,010
者的返回类型。

326
00:24:04,010 --> 00:24:08,520
>> 太好了！那么最后，你将要显示的股票信息。

327
00:24:08,520 --> 00:24:14,110
您可能会想显示 - 你要访问这些变量。

328
00:24:14,110 --> 00:24:17,610
一旦你的价格在一个变量 - 

329
00:24:17,610 --> 00:24:20,860
的名称和符号，以及 - 

330
00:24:20,860 --> 00:24:25,550
然后，你将要显示在模板页。

331
00:24:25,550 --> 00:24:31,540
该模板的页面可以被称为，show_quote.php或东西。

332
00:24:31,540 --> 00:24:39,660
你的quote.php页会导致显示的报价，然后通过在所有这些值。

333
00:24:39,660 --> 00:24:47,170
然后，在你的PHP页面，你居然打印出这些值在页面的HTML方面。

334
00:24:47,170 --> 00:24:53,800
你只需要使用打印功能和价格传递。

335
00:24:53,800 --> 00:24:57,990
有2种方式 - 你可以将它连接点操作符，

336
00:24:57,990 --> 00:25:02,230
或者使用一个占位符。

337
00:25:07,580 --> 00:25:12,750
>> 最终用户将要购买和出售股票。

338
00:25:12,750 --> 00:25:18,450
我们希望，让他们看到所有的股票，他们目前有一些方式。

339
00:25:18,450 --> 00:25:21,350
我们会打电话给他们的投资组合。

340
00:25:21,350 --> 00:25:26,180
组合，大概为每一位用户，包含了一堆行

341
00:25:26,180 --> 00:25:31,760
列出了他们，然后他们有多少份额的类型。

342
00:25:31,760 --> 00:25:36,500
我们现有的表 - 现在我们有一个在我们的数据库中的用户表。

343
00:25:36,500 --> 00:25:41,780
它包含一个用户的用户名以及密码多少现金。

344
00:25:41,780 --> 00:25:50,390
有没有真正的方式存储所有的内，他们的股票。

345
00:25:50,390 --> 00:25:58,010
它不象所有的股票，我们可以插入新列。

346
00:25:58,010 --> 00:26:03,650
因为我们有一个无限的数量，这将是一个很长很长的行

347
00:26:03,650 --> 00:26:06,200
类型的股票，他们可以有。

348
00:26:06,200 --> 00:26:09,150
所以，我们要做的是在同一个数据库，

349
00:26:09,150 --> 00:26:15,000
我们将有一个用户表，但我们也将有一个投资组合表。

350
00:26:15,000 --> 00:26:18,430
肯定会有联系的投资组合表的用户表，

351
00:26:18,430 --> 00:26:24,600
而是投资组合表结构将有股票信息，

352
00:26:24,600 --> 00:26:27,780
有多少用户拥有该股票的股份，

353
00:26:27,780 --> 00:26:31,620
以及用户的特定的ID号。

354
00:26:31,620 --> 00:26:34,620
您的用户表，其中有一个ID和用户名，哈希 - 

355
00:26:34,620 --> 00:26:40,130
这是密码，加密后的密码 - 

356
00:26:40,130 --> 00:26:42,130
然后的现金数额。

357
00:26:42,130 --> 00:26:47,900
的ID号，将投资组合的ID号。

358
00:26:47,900 --> 00:26:52,490
投资组合将有符号的股票，以及股份 - 

359
00:26:52,490 --> 00:26:55,410
的用户拥有该股票的股份数。

360
00:26:55,410 --> 00:26:58,520
在这个组合表，基本上你将有

361
00:26:58,520 --> 00:27:03,760
所有股份所拥有的所有的用户在您的网站上。

362
00:27:03,760 --> 00:27:10,550
后来，只指定一个特定的用户股份 - 只有他们的投资组合 - 

363
00:27:10,550 --> 00:27:15,360
你会从投资组合的表检索值

364
00:27:15,360 --> 00:27:19,930
是特定于该用户的ID号。

365
00:27:26,520 --> 00:27:34,890
>> 当显示的组合，你要报告每个用户的投资组合中的股票。

366
00:27:34,890 --> 00:27:41,670
你会想报告的股份，这些股份的价值。

367
00:27:41,670 --> 00:27:45,950
，目前这些股份的价值不存储在投资组合表

368
00:27:45,950 --> 00:27:51,640
因为那是要更新 - 最低 - 每一天的雅虎。

369
00:27:51,640 --> 00:27:58,550
要获得这些信息，你可以不引用，从您的SQL查询。

370
00:27:58,550 --> 00:28:02,400
什么样的功能，提供给我们吗？什么样的功能将得到价格是多少？

371
00:28:02,400 --> 00:28:09,110
这是查找，因此使用查找一个特定的符号会给你很多信息。

372
00:28:09,110 --> 00:28:13,710
它会给你3个信息 - 名称，符号，以及价格。

373
00:28:13,710 --> 00:28:17,490
一旦你查找一个特定的符号，那么你可以得到的价格，

374
00:28:17,490 --> 00:28:20,460
然后你就可以使用的价格，将显示在你的投资组合。

375
00:28:20,460 --> 00:28:26,190
>> 投资组合也应该显示用户的当前现金余额。

376
00:28:26,190 --> 00:28:30,310
那场被存储在用户表。

377
00:28:30,310 --> 00:28:33,400
那么记住我们基本上有 - 

378
00:28:33,400 --> 00:28:36,850
我们有不同类型的PHP文件。

379
00:28:36,850 --> 00:28:40,160
我们将有一个控制器，它基本上是你所有的思想。

380
00:28:40,160 --> 00:28:45,940
然后我们有一个模板，该模板输出数据的处理。

381
00:28:45,940 --> 00:28:50,790
你必须考虑哪些变量控制器将需要采取英寸

382
00:28:50,790 --> 00:29:01,630
如果我们正在处理的组合输出的每一个名字，符号和股数，

383
00:29:01,630 --> 00:29:03,730
以及当前的股票价格，

384
00:29:03,730 --> 00:29:06,950
然后，你要找到某种方式，基本上通过 - 

385
00:29:06,950 --> 00:29:12,070
你可以通过在一个数组中的值匹配。

386
00:29:15,250 --> 00:29:24,360
>> 让我们进入一个例子，你可以检索所有的股票

387
00:29:24,360 --> 00:29:26,210
所拥有的一个特定的用户。

388
00:29:26,210 --> 00:29:31,400
这不是买卖 - 还 - 股票的价格。

389
00:29:31,400 --> 00:29:33,520
这将是运行一个查询。

390
00:29:33,520 --> 00:29:37,070
将获得的符号，以及股份 - 

391
00:29:37,070 --> 00:29:42,770
我打电话来，此表，但在这种情况下，你会做什么？

392
00:29:42,770 --> 00:29:49,400
叫什么名字的表，我们正在处理的有符号和股份

393
00:29:49,400 --> 00:29:52,280
对于一个特定的用户？

394
00:29:52,280 --> 00:29:56,410
这是用户或组合。

395
00:29:56,410 --> 00:29:57,820
投资组合。

396
00:29:57,820 --> 00:30:03,220
这将是查询的符号和股份的组合

397
00:30:03,220 --> 00:30:04,920
对于一个特定的用户。

398
00:30:04,920 --> 00:30:09,260
在这里，我要说，“（SELECT符号，股份TBL  - 

399
00:30:09,260 --> 00:30:12,280
但表，而不是要取代与组合。

400
00:30:12,280 --> 00:30:15,220
“去哪儿”基本上是我的条件。

401
00:30:15,220 --> 00:30:21,050
我说我只想要得到的关联数组对应

402
00:30:21,050 --> 00:30:23,850
 这以下条件 -  id等于。

403
00:30:23,850 --> 00:30:27,600
 然后，我把一个占位符，然后会话ID。

404
00:30:27,600 --> 00:30:36,720
这是说行中的每一行。

405
00:30:36,720 --> 00:30:40,940
这是一个不错的方式，而不是设置一个for循环，

406
00:30:40,940 --> 00:30:47,450
遍历所有索引，然后在PHP中，你可以有一个for-each循环。

407
00:30:47,450 --> 00:30:53,520
>> 如果你有一个给定的数组，那么你可以说，我现在就打电话给每一个连续的元素 - 

408
00:30:53,520 --> 00:30:57,930
我现在就打电话给每一个元素这个名字。

409
00:30:57,930 --> 00:31:02,780
因此，对于每一个这些元素，我会打电话给他们这个，

410
00:31:02,780 --> 00:31:04,500
然后我就可以做到这一点。

411
00:31:04,500 --> 00:31:10,370
在对每个有实际的数组，你要叫行，每一行的行。

412
00:31:10,370 --> 00:31:12,420
每次执行主体，

413
00:31:12,420 --> 00:31:16,960
它会，它会更新一行行的下一个元素。

414
00:31:18,900 --> 00:31:25,260
>> 现在，在买股票，

415
00:31:25,260 --> 00:31:29,500
我们想要做的就是让用户希望购买的股票

416
00:31:29,500 --> 00:31:35,300
和股份数额的，用户想购买，然后 - 如果他们想 - 

417
00:31:35,300 --> 00:31:38,120
补充说，股票的投资组合。

418
00:31:38,120 --> 00:31:40,310
很显然，如果他们买了一些东西，那是怎么回事减少

419
00:31:40,310 --> 00:31:43,520
他们的钱的数量，所以这会减少他们的现金。

420
00:31:43,520 --> 00:31:48,380
我们将要处理，更新的产品组合以及用户表，

421
00:31:48,380 --> 00:31:50,300
其中包含了现金。

422
00:31:50,300 --> 00:31:54,920
但首先，你需要获得股份的实际库存量，用户希望。

423
00:31:54,920 --> 00:32:00,010
对于这一点，你需要一个HTML的形式，将要求符号的股票

424
00:32:00,010 --> 00:32:03,360
您要购买的股份数目。

425
00:32:03,360 --> 00:32:08,300
然后你需要添加。

426
00:32:08,300 --> 00:32:13,750
您需要选择特定的值。

427
00:32:13,750 --> 00:32:19,670
我们已经经历这有点了，但是当你试图获取某些行 - 

428
00:32:19,670 --> 00:32:22,020
从SQL表中检索某些行，

429
00:32:22,020 --> 00:32:24,290
这是下面的语法。

430
00:32:24,290 --> 00:32:28,400
您已经选择，然后如果你指定一个明星，

431
00:32:28,400 --> 00:32:31,830
，整体而言，整个行会基本上恢复。

432
00:32:31,830 --> 00:32:36,890
再说，你具备条件的地方，然后指定 - 

433
00:32:36,890 --> 00:32:39,990
我只想要的用户名是平等的邮件，

434
00:32:39,990 --> 00:32:46,660
因此它只会在用户中检索该行相对应的邮件。

435
00:32:46,660 --> 00:32:52,860
>> 当一个用户要添加共享一个投资组合，

436
00:32:52,860 --> 00:32:54,400
你需要检查的几个错误。

437
00:32:54,400 --> 00:32:57,680
你想，以确保用户实际上可以负担得起的股票，

438
00:32:57,680 --> 00:33:00,810
所以你要检查他们的现金。

439
00:33:00,810 --> 00:33:05,810
在此之前，我们用星从一个SQL表中检索一整行。

440
00:33:05,810 --> 00:33:08,930
但在这里，我们可以只指定，我只想要一值 - 

441
00:33:08,930 --> 00:33:10,080
我只想要现金。

442
00:33:10,080 --> 00:33:17,970
所以在这里，它会返回现金的用户ID号为1。

443
00:33:17,970 --> 00:33:25,940
如果用户已经买了某只股票，然后购买更多的该股票，

444
00:33:25,940 --> 00:33:30,440
然后在你的投资组合 - 你不想要一个单独的行，

445
00:33:30,440 --> 00:33:34,770
另一行包含新的交易。

446
00:33:34,770 --> 00:33:37,950
您要更新量。

447
00:33:37,950 --> 00:33:42,530
所有这一切的改变确实是该用户所拥有的股份数额。

448
00:33:42,530 --> 00:33:47,730
如果您使用插入查询 - 只需要插入到你的投资组合中，所有的这些值 - 

449
00:33:47,730 --> 00:33:51,710
用户的ID号以及他们所购买的股票的象征

450
00:33:51,710 --> 00:33:57,750
的股份，那么你也将要指定，好了，如果我遇到重复的键 - 

451
00:33:57,750 --> 00:34:00,750
在这种情况下，重复的键不仅是用户的ID，但也股票符号 - 

452
00:34:00,750 --> 00:34:08,340
因为你只能有 - 我们的前提是，你只能有1个行

453
00:34:08,340 --> 00:34:10,699
 对应到1特定符号。

454
00:34:10,699 --> 00:34:13,659
因此，在重复键 - 如果你遇到了一个碰撞 - 

455
00:34:13,659 --> 00:34:18,520
你只是要更新其新的价值的股份。

456
00:34:18,520 --> 00:34:23,290
股份相等于我们以前加，用户购买的股份数。

457
00:34:27,790 --> 00:34:31,090
>> 现在，我们已经更新了投资组合表，

458
00:34:31,090 --> 00:34:34,730
我们将要更新用户的现金。

459
00:34:34,730 --> 00:34:40,300
这是在用户表，所以我们将要减去一定数额的现金。

460
00:34:40,300 --> 00:34:46,270
据推测，这将是现金等于减去现金 - 然后一定量。

461
00:34:46,270 --> 00:34:50,560
要更新的现金，你会 - 

462
00:34:50,560 --> 00:34:55,699
如果我想从邮件中拿走钱，然后我将运行此查询 - 

463
00:34:55,699 --> 00:35:00,220
“更新用户”，然后设置列的现金的现金 - 

464
00:35:00,220 --> 00:35:07,300
>> 如果用户名是平等的邮件，我会删除9,999美元。

465
00:35:07,300 --> 00:35:12,020
但是，在这种情况下，我们不希望具体减去9999。

466
00:35:12,020 --> 00:35:17,610
我们要指定，那么，我们要减去当前的股票价格

467
00:35:17,610 --> 00:35:22,400
，他们所购买的股份数乘以。

468
00:35:25,260 --> 00:35:29,910
>> 现在，我们已经让他们看到所有的股票，他们有，

469
00:35:29,910 --> 00:35:33,080
以及买入更多的股票。

470
00:35:33,080 --> 00:35:37,430
我们以前也使他们能够查看当前的股票价格。

471
00:35:37,430 --> 00:35:40,030
在这里，我们要允许他们卖给他们。

472
00:35:40,030 --> 00:35:42,160
首先，我们要基本显示 - 

473
00:35:42,160 --> 00:35:45,270
我们希望让他们看到他们有所有的股票，

474
00:35:45,270 --> 00:35:53,170
所以在这里我们要显示的所有行的投资组合。

475
00:35:53,170 --> 00:35:56,650
如果他们选择卖出某只股票，

476
00:35:56,650 --> 00:35:59,140
然后，我们要假设他们想出售它的所有。

477
00:35:59,140 --> 00:36:04,350
他们不只是要出售50％的股份，他们将出售100％。

478
00:36:04,350 --> 00:36:08,630
我们可以从投资组合中删除整行。

479
00:36:08,630 --> 00:36:17,520
我们可以删除给定用户的某个符号的股份。

480
00:36:17,520 --> 00:36:21,410
是的语法。

481
00:36:21,410 --> 00:36:22,710
>> 然后，我们要更新的现金。

482
00:36:22,710 --> 00:36:30,930
我们要在他们所销售的股份数额的现金增加

483
00:36:30,930 --> 00:36:34,640
乘以当前的股票价格 - 

484
00:36:34,640 --> 00:36:38,610
不是这个价了，他们买了它，而是他们的价格 - 

485
00:36:38,610 --> 00:36:40,500
目前的价格时，他们所销售的时候。

486
00:36:40,500 --> 00:36:43,660
来引用当前的股票价格，

487
00:36:43,660 --> 00:36:49,120
你将要使用的查询，这会给你一个股票的价格

488
00:36:50,030 --> 00:36:52,650
在当前时间。

489
00:36:52,650 --> 00:36:55,930
>> 现在留给我们的历史，

490
00:36:55,930 --> 00:37:00,170
你想允许用户跟踪他们的交易 - 

491
00:37:00,170 --> 00:37:03,040
要看到，每当他们卖的东西，只要他们买了股票。

492
00:37:03,040 --> 00:37:08,870
我们要指定的时间，他们在这样做，以及他们买了多少

493
00:37:08,870 --> 00:37:11,650
什么股票了。

494
00:37:11,650 --> 00:37:17,800
我们是否有任何指定的电流，现有的结构？

495
00:37:17,800 --> 00:37:25,230
好了，我们的组合，其中显示用户的数量的股票，

496
00:37:25,230 --> 00:37:26,470
为一个给定的共享。

497
00:37:26,470 --> 00:37:34,060
但是，我们构建投资组合的方式，它更新时，我们买多，

498
00:37:34,060 --> 00:37:40,190
而历史应该 - 如果你买了苹果，股吧，然后后来就卖出5，

499
00:37:40,190 --> 00:37:44,040
那么你想看到那些分别作为单独的行动，单独的行。

500
00:37:44,040 --> 00:37:48,520
鉴于该操作可视化，在我们的投资组合表

501
00:37:48,520 --> 00:37:52,540
也只是特定行的更新，

502
00:37:52,540 --> 00:37:55,740
 所以我们可能会想另一个表。

503
00:37:55,740 --> 00:38:00,460
在我们的数据库中，我们有我们的用户表，我们有我们的投资组合表，

504
00:38:00,460 --> 00:38:04,090
现在我们可能要一个历史表中。

505
00:38:04,090 --> 00:38:08,070
这历史表可以跟踪当前的日期，

506
00:38:08,070 --> 00:38:12,800
以及特定股票的符号，以及多少股份，

507
00:38:12,800 --> 00:38:15,410
然后它是什么样的行动 - 

508
00:38:15,410 --> 00:38:18,800
你是否在购买这些股票，或者是否进行销售。

509
00:38:20,660 --> 00:38:25,720
>> 要处理的日期，有一对夫妇的方式，你可以做到这一点。

510
00:38:25,720 --> 00:38:28,820
PHP有办法跟踪的日期，你可以看一下你自己。

511
00:38:28,820 --> 00:38:33,990
在SQL中，你也可以使用，不论是现在或当前时间戳。这是给你的。

512
00:38:33,990 --> 00:38:40,720
只要确保在用户每次购买或出售，你会被更新他们的现金

513
00:38:40,720 --> 00:38:46,750
在用户表，你就可以更新的投资组合表中的行，

514
00:38:46,750 --> 00:38:50,900
然后你也可更新的历史，

515
00:38:50,900 --> 00:38:56,260
所以有打算是，你将调用有3个独立的SQL查询。

516
00:38:58,640 --> 00:39:01,530
我们现在有一堆的功能。

517
00:39:01,530 --> 00:39:10,600
>> 只是一对夫妇的提醒，在您的索引文件，你要链接到至少你的 - 

518
00:39:10,600 --> 00:39:15,550
但你会希望允许用户连接的buy.php页面。

519
00:39:15,550 --> 00:39:23,560
这会允许一个用户 -  buy.php的控制器，所以，要既

520
00:39:23,560 --> 00:39:29,170
送你去 - 这就是要送你去的形式，让你看的东西。

521
00:39:29,170 --> 00:39:34,420
我们有历史。我们已经记录，得到一个报价，然后销售。

522
00:39:34,420 --> 00:39:37,350
这些都是你想要在最低。

523
00:39:37,350 --> 00:39:43,640
在投资组合方面，投资组合的实际显示在索引页。

524
00:39:43,640 --> 00:39:52,050
如果我们去索引，在这里我们看到它呈现portfolio.php的

525
00:39:52,050 --> 00:40:00,050
并通过关联数组中的标题 - 基本上等于投资组合。

526
00:40:00,050 --> 00:40:02,610
所以，这是控制器。

527
00:40:02,610 --> 00:40:08,000
如果我们去模板portfolio.php，

528
00:40:08,000 --> 00:40:18,060
那么它是 - 基本上是一个显示的画面，说，哦，这个网站正在建设中。

529
00:40:18,060 --> 00:40:23,810
后来，当你传递 - 你基本上更具体的信息传递。

530
00:40:23,810 --> 00:40:27,400
，而不仅仅是标题，你可能会被传递更多的东西。

531
00:40:27,400 --> 00:40:32,010
一旦你有了这些值，，然后portfolio.php可以处理这些值

532
00:40:32,010 --> 00:40:34,490
打印出来任何形式的秩序。

533
00:40:34,490 --> 00:40:41,660
>> 一旦你实现了所有这些，你还需要实现更多的功能。

534
00:40:41,660 --> 00:40:44,890
这可以允许用户更改其密码，

535
00:40:44,890 --> 00:40:50,110
重设密码，如果他们已经忘记了 - 这样的密码重置，然后

536
00:40:50,110 --> 00:40:54,560
，你可能还需要编辑注册，以便让他们到指定的电子邮件，

537
00:40:54,560 --> 00:40:57,910
所以，如果他们忘记了自己的密码，然后他们可以得到的。

538
00:40:57,910 --> 00:41:02,870
他们或许可以输入他们的用户名，然后一封电子邮件将被发送到他们的

539
00:41:02,870 --> 00:41:06,180
可以重设密码的链接。

540
00:41:06,180 --> 00:41:10,980
你可以拥有的东西，可以让用户获得收入

541
00:41:10,980 --> 00:41:12,380
每次他们买或卖的东西，

542
00:41:12,380 --> 00:41:19,910
然后终于，让他们增加现金到他们的网站。

543
00:41:19,910 --> 00:41:24,970
只是为了重新回到控制器和模板的概念一点点。

544
00:41:24,970 --> 00:41:31,170
你必须像一个 - 所以您在这里有一个控制器。

545
00:41:31,170 --> 00:41:35,080
现在，我们正在寻找在login.php的例子。

546
00:41:35,080 --> 00:41:38,220
当我们有一个控制器，基本上这将需要2例。

547
00:41:38,220 --> 00:41:42,090
当我们有控制器，我们在这一块，我们也种处理

548
00:41:42,090 --> 00:41:43,880
当我们有形式为好。

549
00:41:43,880 --> 00:41:47,500
控制器将基本上都有独立的行动 - 

550
00:41:47,500 --> 00:41:53,880
如果一个表单已经提交，然后两个，如果用户到该页面

551
00:41:53,880 --> 00:41:56,870
在第一次和仍需要输入该表单。

552
00:41:56,870 --> 00:42:02,820
>> 我要跳这种情况下，前第一案的形式中。

553
00:42:02,820 --> 00:42:12,640
在这里，我们说的方法后，如果表单已提交 - 

554
00:42:12,640 --> 00:42:13,580
不用担心，有点。

555
00:42:13,580 --> 00:42:19,780
不要担心太多，但明白，基本上是这样的函数处理

556
00:42:19,780 --> 00:42:22,430
表单是否已被提交或没有。

557
00:42:22,430 --> 00:42:25,640
这种情况是真实的，如果用户提交了表单。

558
00:42:25,640 --> 00:42:45,940
如果没有的话，我们会到要调用render login_form.php，然后通过在标题中。

559
00:42:45,940 --> 00:42:48,010
这个称号是基本上要出现在标题中。

560
00:42:48,010 --> 00:42:54,990
这基本上是说，好了 - 好了，如果用户进入的login.php

561
00:42:54,990 --> 00:43:00,310
并没有实际登录的话，我想送他们到该表单的页面，有

562
00:43:00,310 --> 00:43:03,160
这使得他们能够输入用户名和密码。

563
00:43:03,160 --> 00:43:07,590
然后我去login_form，然后有实际的形式。

564
00:43:07,590 --> 00:43:13,750
然后，一旦用户提交该表单时，他们将提交到login.php的

565
00:43:13,750 --> 00:43:15,840
与POST方法。

566
00:43:15,840 --> 00:43:21,560
实际上，我进入这个部分，我的if-else循环。

567
00:43:21,560 --> 00:43:29,560
然后，它在这里，我们处理输入到表单中的值。

568
00:43:29,560 --> 00:43:32,800
在这里，我们处理这些。

569
00:43:32,800 --> 00:43:40,860
>> 然后，一旦你处理这些值 - 如果你正在处理的 - 

570
00:43:40,860 --> 00:43:46,640
说我们正在处理的quote.php页面，可以输入一个股票

571
00:43:46,640 --> 00:43:49,950
他们想看看，然后看到显示 - 

572
00:43:49,950 --> 00:43:52,850
这是一种类似在这里。

573
00:43:52,850 --> 00:43:56,070
在这里，我们有一个登录表单 - ，you'd可能有一个报价表 - 

574
00:43:56,070 --> 00:44:00,290
但然后一旦用户已实际提交该信息，

575
00:44:00,290 --> 00:44:04,810
那么你会希望控制传递到另一个模板

576
00:44:04,810 --> 00:44:07,430
，将显示他们的实际信息。

577
00:44:07,430 --> 00:44:11,250
在这里，那么正确，那么你就可能 - 

578
00:44:11,250 --> 00:44:18,830
您的病情年底左右 - 如果该方法等于后 - 

579
00:44:18,830 --> 00:44:22,520
然后你可能会想要呈现的另一页 - 展会报价 - 

580
00:44:22,520 --> 00:44:28,040
发送到该页面 -  show_quote.php  - 

581
00:44:28,040 --> 00:44:34,120
然后在该文件中引用这些值。

582
00:44:34,120 --> 00:44:36,480
这是否有意义吗？

583
00:44:36,480 --> 00:44:40,390
>> 我们有一个控制器，基本上与2例 - 

584
00:44:40,390 --> 00:44:42,710
您是否已经进入或没有的一种形式。

585
00:44:42,710 --> 00:44:43,950
如果你还没有进入的一种形式，

586
00:44:43,950 --> 00:44:47,300
然后将您重定向到该窗体，然后把你返回到该页面。

587
00:44:47,300 --> 00:44:54,020
然后，一旦你有在控制器的信息，该机构将处理

588
00:44:54,020 --> 00:44:59,750
必要的信息 - 无论是值的股票，

589
00:44:59,750 --> 00:45:04,150
，那么，当它抬头一看这些价值观，并有一个很好的格式化阵列，

590
00:45:04,150 --> 00:45:08,180
那么可以通过该数组的模板页面

591
00:45:08,180 --> 00:45:10,330
 该输出该信息。

592
00:45:10,330 --> 00:45:14,680
>> 同样，因为它的网络，它将会很有趣。

593
00:45:14,680 --> 00:45:20,310
我们的C之外，所以我们不仅限于ASCII字符，而终端输出，

594
00:45:20,310 --> 00:45:21,800
因此，有乐趣与此有关。

595
00:45:21,800 --> 00:45:24,920
你可以把它作为视觉的，只要你想。

596
00:45:24,920 --> 00:45:31,860
您可以允许用户输入数百万美元的时间，

597
00:45:31,860 --> 00:45:34,730
或限制他们真正的意思，并让他们只一次进入1分钱

598
00:45:34,730 --> 00:45:36,330
或类似的东西。

599
00:45:36,330 --> 00:45:38,550
一定会确保有乐趣。

600
00:45:38,550 --> 00:45:47,030
>> PHP代码是简单一点的，因为它更容易一些伪代码

601
00:45:47,030 --> 00:45:50,070
到实际的实现。

602
00:45:50,070 --> 00:45:56,320
因此，绝对有乐趣，因为它实际上是我们的最后一块CS50。

603
00:45:56,320 --> 00:46:01,150
考虑到这，这是演练7。

604
00:46:01,150 --> 00:46:04,640
一旦你看完演练，完成你的pset中，

605
00:46:04,640 --> 00:46:09,590
那么这些也pset的，和我们现在是在最终产品 - 

606
00:46:09,590 --> 00:46:12,330
后我们通过测验1。

607
00:46:12,330 --> 00:46:16,200
希望你能使用的工具，你所学到的pset时 - 

608
00:46:16,200 --> 00:46:21,980
不仅是语法，但更多的是抽象的概念，如何采取一定的 - 

609
00:46:21,980 --> 00:46:24,950
喜欢，我要做到这一点，那么实际执行。

610
00:46:24,950 --> 00:46:28,740
学习如何奋斗通过语法和分布代码。

611
00:46:28,740 --> 00:46:33,020
阅读其他人的代码，然后解释，使用预先存在的功能。

612
00:46:33,020 --> 00:46:37,360
>> 所以，运气好的话，最后的pset。

613
00:46:37,360 --> 00:46:39,930
这是一个很高兴导致的演练。

614
00:46:39,930 --> 00:46:40,940
我希望他们已经对你有所帮助。

615
00:46:40,940 --> 00:46:46,560
这些演练，非常感谢。

616
00:46:52,580 --> 00:46:56,200
[CS50.TV]