1
00:00:00,000 --> 00:00:10,075
>> [音乐播放]

2
00:00:10,075 --> 00:00:11,629

3
00:00:11,629 --> 00:00:14,420
ALLISON BUCHHOLTZ-AU：好吧，
大家好，欢迎回款。

4
00:00:14,420 --> 00:00:17,420
希望大家有一个伟大的
万圣节周末，或Halloweekend，

5
00:00:17,420 --> 00:00:20,009
我想说，所有的
休息和恢复。

6
00:00:20,009 --> 00:00:21,675
幸好这不是下雪了。

7
00:00:21,675 --> 00:00:23,230
它实际上是外面阳光普照。

8
00:00:23,230 --> 00:00:25,040
我是真的高兴。

9
00:00:25,040 --> 00:00:28,420
不准备拖我的冬靴。

10
00:00:28,420 --> 00:00:31,820
希望pset6了相当不错。

11
00:00:31,820 --> 00:00:35,040
>> 如果你已经厌倦了C，我很高兴
说你是用C现在完成的。

12
00:00:35,040 --> 00:00:37,550
我们已经完全转变
进入web编程，

13
00:00:37,550 --> 00:00:42,030
所以你的HTML，PHP是工作，
也许JavaScript的一点点。

14
00:00:42,030 --> 00:00:44,650
我不知道是什么，下周
PSET的，所以我不能保证

15
00:00:44,650 --> 00:00:47,820
你的下一个PSET会
可以，但本周的PSET

16
00:00:47,820 --> 00:00:52,290
是CS50金融，这基本上是
执行网页的排序

17
00:00:52,290 --> 00:00:57,222
，让您买和卖
股票，并跟踪它们。

18
00:00:57,222 --> 00:00:59,930
它很酷，因为所有的
它是动态生成的。

19
00:00:59,930 --> 00:01:02,320
你可以有不同的用户谁
每个人都有自己的信息，

20
00:01:02,320 --> 00:01:04,580
而你将是
实现这一切。

21
00:01:04,580 --> 00:01:05,970
这需要一段时间。

22
00:01:05,970 --> 00:01:13,030
我绝对认为这是比较容易
比C pset中，但它需要较长的时间。

23
00:01:13,030 --> 00:01:17,370
你正在学习一门新的语言，
PHP中，这是非常类似于C，

24
00:01:17,370 --> 00:01:21,390
当然，但是将要求
您要查找的语法和理解

25
00:01:21,390 --> 00:01:23,360
如何在语言之间转换。

26
00:01:23,360 --> 00:01:27,960
>> 但我不认为有什么
超级概念上很难对此PSET。

27
00:01:27,960 --> 00:01:30,087
这只是学习
新的语言和获取

28
00:01:30,087 --> 00:01:31,420
通过所有这些小碎片。

29
00:01:31,420 --> 00:01:34,850
如果你们已经通过阅读
该规范，这是相当长的。

30
00:01:34,850 --> 00:01:38,200
我觉得这个人是像21
网页，如果我没记错的话。

31
00:01:38,200 --> 00:01:40,130
这是一个漫长的规格。

32
00:01:40,130 --> 00:01:42,218
所以，如果你没有看过它 -  22。

33
00:01:42,218 --> 00:01:43,520
32。

34
00:01:43,520 --> 00:01:44,410
>> 哇。

35
00:01:44,410 --> 00:01:46,280
所以我被关了50％出现。

36
00:01:46,280 --> 00:01:48,550
因此，32页。

37
00:01:48,550 --> 00:01:49,820
所以这是很长。

38
00:01:49,820 --> 00:01:54,070
有很多条，但没有
件的应该是不好的。

39
00:01:54,070 --> 00:01:55,650
这只是一个不少。

40
00:01:55,650 --> 00:02:00,310
所以绝对初上手
如果可能的话，按通常，

41
00:02:00,310 --> 00:02:05,480
但我认为它应该感觉有点
不是特别喜欢的pset更好

42
00:02:05,480 --> 00:02:10,250
恢复和调整的只是
很难周围包裹你的头。

43
00:02:10,250 --> 00:02:12,550
>> 所以这样，我们打算在潜水。

44
00:02:12,550 --> 00:02:14,840
我没有你的日程
今天滑动，但我们

45
00:02:14,840 --> 00:02:17,920
将要谈论的PHP。

46
00:02:17,920 --> 00:02:20,790
我将让你种一
对一些事情速成班

47
00:02:20,790 --> 00:02:23,040
你可能想知道关于PHP。

48
00:02:23,040 --> 00:02:26,470
不同的语法的东西，
事情看出来的。

49
00:02:26,470 --> 00:02:29,400
我们将要谈论
关于SQL一点点。

50
00:02:29,400 --> 00:02:33,020
只是很简单的事情
在那里，然后又MVC

51
00:02:33,020 --> 00:02:36,380
是模型视图控制器，它
是你的PSET是如何设置的，

52
00:02:36,380 --> 00:02:39,801
因此，了解怎么说
作品将超级有用。

53
00:02:39,801 --> 00:02:40,300
行。

54
00:02:40,300 --> 00:02:42,030
所以PHP。

55
00:02:42,030 --> 00:02:45,050
你们应该做的
一些非常，非常简单的

56
00:02:45,050 --> 00:02:48,680
使用PHP，这是
在这里底层的东西，

57
00:02:48,680 --> 00:02:53,700
在这里你就提交了某种形式的
这里是顶部有一些名字，你

58
00:02:53,700 --> 00:02:58,860
输入时，它会说像招呼，奔，
或打招呼，佳佳，一下子就弹出。

59
00:02:58,860 --> 00:03:02,570
因此，这实际上是什么
应该已经从你的pset样子，

60
00:03:02,570 --> 00:03:06,040
如果你们想知道
或者没有完全弄明白。

61
00:03:06,040 --> 00:03:14,520
>> 但是，我们有这些问号
在这里，表示这是PHP。

62
00:03:14,520 --> 00:03:18,850
他们把它包起来，然后
htmlspecialcharge，记住，只是，

63
00:03:18,850 --> 00:03:22,450
请确保你的安全
任何疯狂的注入攻击

64
00:03:22,450 --> 00:03:26,550
或者，如果有人试图把
疯狂的恶意字符

65
00:03:26,550 --> 00:03:30,780
进入你的name字段，它不
喜欢你的服务器或诸如此类的东西。

66
00:03:30,780 --> 00:03:37,590
>> 然后如果我们注意到，这个HTML
形式，它具有$ _GET的方法，

67
00:03:37,590 --> 00:03:42,050
如果我们还记得我们的超全局变量
从PHP，$ _ GET，$ _ POST，

68
00:03:42,050 --> 00:03:44,530
我们将进入
那些在一点点。

69
00:03:44,530 --> 00:03:50,390
但我们知道，我们有一些名字
这里对应于该名

70
00:03:50,390 --> 00:03:51,920
我们提交的。

71
00:03:51,920 --> 00:03:56,930
因此，这是一种就像
很简单的PHP的HTML合作

72
00:03:56,930 --> 00:04:00,080
那你们从PSET 6例。

73
00:04:00,080 --> 00:04:02,410
>> 但是，这并没有真正
回答什么是PHP。

74
00:04:02,410 --> 00:04:04,850
显然，这是一种语言，
但是我们有没有真正

75
00:04:04,850 --> 00:04:08,260
在本节中谈到这一点，
所以有一点点

76
00:04:08,260 --> 00:04:09,740
什么PHP实际上是。

77
00:04:09,740 --> 00:04:14,270
所以，PHP只是PHP
超文本预处理器。

78
00:04:14,270 --> 00:04:16,399
>> 它的实际考虑
一种编程语言

79
00:04:16,399 --> 00:04:20,500
因为它具有逻辑，而如果
我们记得在谈论HTML，

80
00:04:20,500 --> 00:04:24,980
我们叫了一个标记语言对
一种编程语言，因为HTML

81
00:04:24,980 --> 00:04:27,790
严格怎么修改
事情看起来在页面上。

82
00:04:27,790 --> 00:04:30,650
它只是修改
事情是否是大胆的，

83
00:04:30,650 --> 00:04:35,280
还是它的形式，
元素，或者类似的东西。

84
00:04:35,280 --> 00:04:36,750
它不具有任何逻辑。

85
00:04:36,750 --> 00:04:38,770
它没有循环或条件。

86
00:04:38,770 --> 00:04:40,940
你不能错误检查的事情。

87
00:04:40,940 --> 00:04:44,810
你要么显示的东西
以某种方式或求人办事

88
00:04:44,810 --> 00:04:45,490
从用户。

89
00:04:45,490 --> 00:04:47,180
就是这样。

90
00:04:47,180 --> 00:04:51,780
>> 综上所述，使用PHP，但实际上并允许我们
做所有这些更符合逻辑的事情，

91
00:04:51,780 --> 00:04:56,840
像验证输入或
以某种方式操纵它。

92
00:04:56,840 --> 00:05:02,570
我们可以用HTML结合起来，因为我们刚刚
在你最后看到的pset而现在，

93
00:05:02,570 --> 00:05:05,280
它允许我们创建
这些动态网页。

94
00:05:05,280 --> 00:05:08,900
所以，如果你们ever--我不知道
你和我一样，但在中学

95
00:05:08,900 --> 00:05:13,820
他们把我们借此IT类的地方
我们刚才创建的HTML网页，

96
00:05:13,820 --> 00:05:20,160
而他们的静态，然后单击各地
其他的事情，但他们从来没有改变过。

97
00:05:20,160 --> 00:05:25,960
>> 用动态的，我们可以
做的是，像CS50金融，

98
00:05:25,960 --> 00:05:27,870
你将拥有不同的用户。

99
00:05:27,870 --> 00:05:30,992
根据这些用户的
喜好，他们买什么

100
00:05:30,992 --> 00:05:32,700
或者他们是怎么卖
他们的股票，

101
00:05:32,700 --> 00:05:35,050
你要展示
不同的东西。

102
00:05:35,050 --> 00:05:38,110
所以，如果有一些
识别特征

103
00:05:38,110 --> 00:05:41,990
您的用户使用该
网页，我们可以动态

104
00:05:41,990 --> 00:05:44,720
决定显示他们什么。

105
00:05:44,720 --> 00:05:49,720
这是不一样的东西，每一个
人，其中，如果我们只是有HTML，

106
00:05:49,720 --> 00:05:52,400
该网页将是相同的
每个人谁访问。

107
00:05:52,400 --> 00:05:55,790
PHP允许我们个性化的页面。

108
00:05:55,790 --> 00:06:01,670
>> 然后我们可以把它们放在
相同的文件，其中，因为在该情况下

109
00:06:01,670 --> 00:06:06,670
在此之前，我们看到，
我们有HTML都在这里

110
00:06:06,670 --> 00:06:09,760
然后我们有PHP的这一点点。

111
00:06:09,760 --> 00:06:12,690
我们可以做这样的，
或CS50金融，

112
00:06:12,690 --> 00:06:16,310
如果你们已经看过了
files--，我们应该有时间

113
00:06:16,310 --> 00:06:19,541
步骤通过他们夫妇
一起在section--我们的结束

114
00:06:19,541 --> 00:06:21,540
可以看到，你可以
其实让他们分开，

115
00:06:21,540 --> 00:06:24,720
这实际上是一个更好的事情。

116
00:06:24,720 --> 00:06:26,550
>> 所以。

117
00:06:26,550 --> 00:06:27,680
速成班。

118
00:06:27,680 --> 00:06:32,860
所有的快速简单的事情
你可能需要知道PHP。

119
00:06:32,860 --> 00:06:34,470
声明变量。

120
00:06:34,470 --> 00:06:37,970
这蓝色有点讨厌，
但希望你们可以看到它。

121
00:06:37,970 --> 00:06:39,850
如果没有，我会写
在黑板上。

122
00:06:39,850 --> 00:06:41,370
在声明变量。

123
00:06:41,370 --> 00:06:46,710
有一点需要知道的是，与C，
PHP是松散或动态类型，

124
00:06:46,710 --> 00:06:50,870
这意味着你不需要
告诉一个变量是什么类型的。

125
00:06:50,870 --> 00:06:55,710
你可以简单地说一些变量
是平等的，无论你想要它，

126
00:06:55,710 --> 00:07:00,440
它将决定的类型
该变量在你的运行时间。

127
00:07:00,440 --> 00:07:05,410
>> 正如你看到的，这可以创造
一些非常有趣的事情。

128
00:07:05,410 --> 00:07:09,130
但在大多数情况下，你
不需要指定类型。

129
00:07:09,130 --> 00:07:12,580
你可以，你可以键入
投之类的东西，你通常

130
00:07:12,580 --> 00:07:15,900
会不会看到，如果你想
强制它是某种类型，

131
00:07:15,900 --> 00:07:17,090
但你不必。

132
00:07:17,090 --> 00:07:19,810
它不会骂你
如果你只是声明了一个变量

133
00:07:19,810 --> 00:07:21,910
并没有为它指定一个类型。

134
00:07:21,910 --> 00:07:25,199
>> 所以，如果你看不懂
this--我知道这是不是最好的。

135
00:07:25,199 --> 00:07:28,490
我认为它会出现在better--
初始化任何变量的方法就是

136
00:07:28,490 --> 00:07:31,270
一个美元符号，是什么
你希望它被调用，

137
00:07:31,270 --> 00:07:33,240
然后你在分配它。

138
00:07:33,240 --> 00:07:36,520
所以在这种情况下，这是一些是$ var = 3。

139
00:07:36,520 --> 00:07:40,450
所以，如果我们使用$ VAR
某个地方，它只会

140
00:07:40,450 --> 00:07:42,760
是相同的推杆3那里。

141
00:07:42,760 --> 00:07:43,650
行？

142
00:07:43,650 --> 00:07:46,480
>> 所以，任何变量，只
美元符号，无论

143
00:07:46,480 --> 00:07:50,210
你想打电话给你的变量，
和任何你想让它相等。

144
00:07:50,210 --> 00:07:51,430
有点凉。

145
00:07:51,430 --> 00:07:56,156
少写一个初始化
一个变量，对不对？

146
00:07:56,156 --> 00:07:57,530
这是否有意义大家？

147
00:07:57,530 --> 00:08:02,280
只是快速的语法差异
与C和PHP。

148
00:08:02,280 --> 00:08:06,440
>> 数组是PHP中要冷得多。

149
00:08:06,440 --> 00:08:09,620
我们可以给他们钥匙。

150
00:08:09,620 --> 00:08:13,180
所以顺便想想
那就是，如果我们

151
00:08:13,180 --> 00:08:16,610
要访问一个
一个数组中的元素，

152
00:08:16,610 --> 00:08:19,290
我们需要知道的
它的指数，对不对？

153
00:08:19,290 --> 00:08:24,290
因此，我们知道，随着C，我们
可以访问所述第一元件

154
00:08:24,290 --> 00:08:28,650
通过做阵列支架零，或者如果我们
想第一个元素，数组支架

155
00:08:28,650 --> 00:08:29,360
1。

156
00:08:29,360 --> 00:08:31,910
如果我们想要的东西
在那里，我们可能只是

157
00:08:31,910 --> 00:08:35,850
要遍历，除非
我们其实知道的索引。

158
00:08:35,850 --> 00:08:38,320
>> 有一件事是真的
凉爽PHP数组

159
00:08:38,320 --> 00:08:40,850
是他们在做什么
我们所说的关联。

160
00:08:40,850 --> 00:08:44,970
因此，我们可以联想
一些关键的一些价值，

161
00:08:44,970 --> 00:08:47,340
而我们实际上会
to--我会告诉你

162
00:08:47,340 --> 00:08:50,370
我们如何能够在第二个使用此。

163
00:08:50,370 --> 00:08:54,330
但基本上，如果你想
来初始化这样的阵列，

164
00:08:54,330 --> 00:08:56,020
你有$数组。

165
00:08:56,020 --> 00:08:59,622
>> 所以用同样的方法，只是
我们正在创建一些变量。

166
00:08:59,622 --> 00:09:01,330
这可以被称为
无论你想要的。

167
00:09:01,330 --> 00:09:03,310
这可能是$例子。

168
00:09:03,310 --> 00:09:04,930
只是另一个变量。

169
00:09:04,930 --> 00:09:09,510
是什么让一个数组是
括号的语法，我们在这里。

170
00:09:09,510 --> 00:09:14,560
就像正常的C.我们
有一些关键的一些价值。

171
00:09:14,560 --> 00:09:19,480
所以KEY1去值1，
KEY2 2去值2。

172
00:09:19,480 --> 00:09:25,080
这对被分开了
逗号，就像正常的阵列。

173
00:09:25,080 --> 00:09:25,810
>> 然而。

174
00:09:25,810 --> 00:09:26,520
大单。

175
00:09:26,520 --> 00:09:27,270
密钥是可选的。

176
00:09:27,270 --> 00:09:28,510
你没有使用它们。

177
00:09:28,510 --> 00:09:30,850
如果你不这样做，那么它只是正常的。

178
00:09:30,850 --> 00:09:32,030
问题？

179
00:09:32,030 --> 00:09:33,540
或者，哦。

180
00:09:33,540 --> 00:09:37,829
>> 听众：嗯，对对。

181
00:09:37,829 --> 00:09:39,120
哪来的记忆来自何处？

182
00:09:39,120 --> 00:09:43,425
它也可以是相同的像
[听不清]和从堆栈？

183
00:09:43,425 --> 00:09:45,277
是，也使用PHP？

184
00:09:45,277 --> 00:09:46,485
当我们将它们连接起来怎么样？

185
00:09:46,485 --> 00:09:49,070
>> ALLISON BUCHHOLTZ-AU：
用PHP，我们不倾向于

186
00:09:49,070 --> 00:09:52,670
不用担心我们在哪里
记忆的来源。

187
00:09:52,670 --> 00:09:54,670
我们不会花很多
时间谈它，

188
00:09:54,670 --> 00:09:58,450
所以它不是真的什么
你需要担心的。

189
00:09:58,450 --> 00:10:00,620
这样的键是可选的。

190
00:10:00,620 --> 00:10:04,780
以同样的方式，如果你不这样做
要使此相关，

191
00:10:04,780 --> 00:10:09,910
你只想要一个正常的数组，其中
阵列零是第一要素

192
00:10:09,910 --> 00:10:13,190
和阵列1是第二
元素，你可以精确地做到这一点

193
00:10:13,190 --> 00:10:17,886
你会在C你有一些
变量将是您的阵列，

194
00:10:17,886 --> 00:10:20,110
而在这里等于这些括号。

195
00:10:20,110 --> 00:10:20,610
是。

196
00:10:20,610 --> 00:10:22,693
>> 听众：是否有
同样的点符号。

197
00:10:22,693 --> 00:10:26,250
喜欢，我可以做一个阵列++，
和指向第二个。

198
00:10:26,250 --> 00:10:30,260
>> ALLISON BUCHHOLTZ-AU：你可以do--
好了，你可以有一些迭代器，我，

199
00:10:30,260 --> 00:10:34,300
你可以做我++和做
i的以相同的方式排列。

200
00:10:34,300 --> 00:10:35,680
但仅此而已。

201
00:10:35,680 --> 00:10:39,630
因此，像在这种情况下，
1阵列就等于20。

202
00:10:39,630 --> 00:10:42,530
同类索引记号。

203
00:10:42,530 --> 00:10:51,330
这基本上是一个隐含的东西
在这里，那里说的零，零至10，

204
00:10:51,330 --> 00:10:54,640
为1〜20个，2至30个。

205
00:10:54,640 --> 00:10:56,760
这只是隐钥匙吧。

206
00:10:56,760 --> 00:10:59,990
什么样的变化与PHP是
你现在有能力

207
00:10:59,990 --> 00:11:02,660
重新分配的关键
做任何你愿意的话。

208
00:11:02,660 --> 00:11:13,820
>> 所以，有一件事是在这里。

209
00:11:13,820 --> 00:11:18,230
所以，我有一些例子
在这里，我写了为你们

210
00:11:18,230 --> 00:11:22,010
因为我觉得自己总是例子
帮助更多的不仅仅是抽象的。

211
00:11:22,010 --> 00:11:26,590
所以，在这里这种情况下，我们
有一定的关联数组

212
00:11:26,590 --> 00:11:31,990
这是我的第一个名字，
我的姓，我

213
00:11:31,990 --> 00:11:35,390
我呼应，这仅仅是
这里所有的目的

214
00:11:35,390 --> 00:11:38,500
将要打印出在这里的输出。

215
00:11:38,500 --> 00:11:39,300
>> 它说，OK。

216
00:11:39,300 --> 00:11:46,680
打印出的值
对应于数组在关键佳佳。

217
00:11:46,680 --> 00:11:50,860
我也可以给你的家伙
下课后所有这些代码。

218
00:11:50,860 --> 00:11:53,700
所以，当我们运行这个，做什么
你认为会发生什么？

219
00:11:53,700 --> 00:11:56,239
这是怎么回事打印出来？

220
00:11:56,239 --> 00:11:57,280
听众：您的姓氏。

221
00:11:57,280 --> 00:11:58,738
ALLISON BUCHHOLTZ-AU：我的姓。

222
00:11:58,738 --> 00:12:00,000
它的作用。

223
00:12:00,000 --> 00:12:00,960
就在这里。

224
00:12:00,960 --> 00:12:02,400
打印出。

225
00:12:02,400 --> 00:12:07,000
所以，如果我们要改变这一点，我们
要增加别人对我们的分类列表---

226
00:12:07,000 --> 00:12:11,919
因此，让我们说，我们有艾玛在这里，
我们联想上次名称 - 

227
00:12:11,919 --> 00:12:13,252
让我们来看看我这个拼写正确。

228
00:12:13,252 --> 00:12:13,714
>> 听众：是的。

229
00:12:13,714 --> 00:12:14,640
>> ALLISON BUCHHOLTZ-AU：是的。

230
00:12:14,640 --> 00:12:15,010
>> 听众：干得好。

231
00:12:15,010 --> 00:12:16,218
>> ALLISON BUCHHOLTZ-AU：可爱。

232
00:12:16,218 --> 00:12:25,370
所以，现在如果我们有这个这里
我们想找到你的姓，

233
00:12:25,370 --> 00:12:26,290
你有它。

234
00:12:26,290 --> 00:12:31,270
所以，你可以把它
这里更换该键。

235
00:12:31,270 --> 00:12:33,190
你只是取代了索引。

236
00:12:33,190 --> 00:12:36,845
所以，它可以让你只要搜索
通过阵列要容易得多。

237
00:12:36,845 --> 00:12:38,220
你不需要知道索引。

238
00:12:38,220 --> 00:12:43,470
只要你正在寻找这个键
对于存在于某个地方的阵列，

239
00:12:43,470 --> 00:12:47,660
PHP会发现它，它会返回
与之相关联的值。

240
00:12:47,660 --> 00:12:49,840
所以，它给你更多
电源与您的阵列。

241
00:12:49,840 --> 00:12:50,340
是。

242
00:12:50,340 --> 00:12:53,131
>> 听众：如果你有两个键
同样的，它会给你一个错误？

243
00:12:53,131 --> 00:12:55,830
ALLISON BUCHHOLTZ-AU：它
应该给你一个错误，是的。

244
00:12:55,830 --> 00:12:58,520
那是否做一点
对你们更有意义？

245
00:12:58,520 --> 00:13:07,640
并以同样的方式，我们有一个数组
在这里，还没有任何密钥。

246
00:13:07,640 --> 00:13:10,910
另外这是一个语法
您可能希望

247
00:13:10,910 --> 00:13:13,550
需要注意的，因为你
要使用这个在你的PSET。

248
00:13:13,550 --> 00:13:17,317
>> 每当你做一个
回音，你有这些报价，

249
00:13:17,317 --> 00:13:19,400
每当你指
以阵列的一部分，

250
00:13:19,400 --> 00:13:22,180
你必须有这些
他们周围的花括号。

251
00:13:22,180 --> 00:13:25,630
这是一种恼人的，但
你只需要做到这一点。

252
00:13:25,630 --> 00:13:28,010
所以，只是要记住。

253
00:13:28,010 --> 00:13:31,490
如果你正在运行到错误，
我知道，这存在于我的数组

254
00:13:31,490 --> 00:13:34,523
但它在我抛出的错误，
尝试把它周围的括号

255
00:13:34,523 --> 00:13:37,180
它应该工作。

256
00:13:37,180 --> 00:13:40,810
>> 所以在这里这种情况下，这是一个
我们已经习惯了普通的C数组。

257
00:13:40,810 --> 00:13:45,810
有三，五，六，我们只是
要打印的第一个元素，

258
00:13:45,810 --> 00:13:47,850
所以这应该打印出3。

259
00:13:47,850 --> 00:13:51,830
我也运行所有这些，使
希望没有发生任何变化。

260
00:13:51,830 --> 00:13:54,460
我们在底部看到这里，
它只是打印出3。

261
00:13:54,460 --> 00:13:57,050

262
00:13:57,050 --> 00:13:58,040
凉爽。

263
00:13:58,040 --> 00:14:00,000
有意义给大家？

264
00:14:00,000 --> 00:14:01,280
关联数组。

265
00:14:01,280 --> 00:14:03,150
远远超过正常的阵列散热器。

266
00:14:03,150 --> 00:14:09,640
>> 这是why--大卫有没有告诉你
PHP实现pset6的

267
00:14:09,640 --> 00:14:11,751
在演讲呢？

268
00:14:11,751 --> 00:14:12,250
行。

269
00:14:12,250 --> 00:14:13,300
所以，我会告诉你。

270
00:14:13,300 --> 00:14:13,770
我不知道它从T--

271
00:14:13,770 --> 00:14:14,680
>> 听众：他上周做了。

272
00:14:14,680 --> 00:14:15,560
>> ALLISON BUCHHOLTZ-AU：上周是吗？

273
00:14:15,560 --> 00:14:15,870
>> 听众：是的。

274
00:14:15,870 --> 00:14:16,995
>> ALLISON BUCHHOLTZ-AU：是的。

275
00:14:16,995 --> 00:14:20,800
所以拼写可以像六行来完成
用PHP的电源，并且部分

276
00:14:20,800 --> 00:14:25,640
这是关联数组，其中
你可以在装载每个字，

277
00:14:25,640 --> 00:14:28,290
和你有它等于true或false。

278
00:14:28,290 --> 00:14:31,410
所以你可以说，哦。

279
00:14:31,410 --> 00:14:39,130
返回字典中的一些词，
如果它的存在，它会返回true。

280
00:14:39,130 --> 00:14:42,130
否则，它将找不到
它，它就会返回false。

281
00:14:42,130 --> 00:14:45,810
这么样一个很酷的小东西。

282
00:14:45,810 --> 00:14:46,750
>> 行。

283
00:14:46,750 --> 00:14:48,990
因此，这些都是关联数组。

284
00:14:48,990 --> 00:14:50,150
他们很酷。

285
00:14:50,150 --> 00:14:51,830
我真的很喜欢他们。

286
00:14:51,830 --> 00:14:55,340
显然this--啊。

287
00:14:55,340 --> 00:14:56,290
行。

288
00:14:56,290 --> 00:14:57,880
现在，它的工作。

289
00:14:57,880 --> 00:15:00,700
也许吧。

290
00:15:00,700 --> 00:15:01,537
行。

291
00:15:01,537 --> 00:15:02,120
另一件事。

292
00:15:02,120 --> 00:15:07,680
因此，在平等，只是一个
很酷的事情要记住。

293
00:15:07,680 --> 00:15:12,140
用PHP，因为它
是动态类型，

294
00:15:12,140 --> 00:15:16,110
类型可以根据改变的时候
你运行它，你是如何运行的。

295
00:15:16,110 --> 00:15:19,890
我其实有一些很酷
例子我会告诉你们。

296
00:15:19,890 --> 00:15:23,350
>> 但是==只检查
类型杂耍之后的平等。

297
00:15:23,350 --> 00:15:28,890
所以，如果你有什么事情，是
像的字符1和号码1，

298
00:15:28,890 --> 00:15:31,890
PHP会告诉你，
这些都是平等的，因为它

299
00:15:31,890 --> 00:15:35,990
可以兼顾的类型
他们两个人，直到它的平等，

300
00:15:35,990 --> 00:15:38,480
这也许对你的情况是好的。

301
00:15:38,480 --> 00:15:44,170
>> 如果你需要看看他们是
相同种类的值和相同的类型，

302
00:15:44,170 --> 00:15:45,305
你想要这个===。

303
00:15:45,305 --> 00:15:48,150
而且我不认为你有什么
当你需要使用

304
00:15:48,150 --> 00:15:52,570
在你的PSET，但对于很多
你谁将会继续做网页

305
00:15:52,570 --> 00:15:57,340
为你最后的项目和事情，它是
好东西要知道==和===

306
00:15:57,340 --> 00:16:01,690
是不同的，这是一个很好的
区别了解。

307
00:16:01,690 --> 00:16:02,400
>> 行。

308
00:16:02,400 --> 00:16:02,980
所以。

309
00:16:02,980 --> 00:16:04,460
foreach循环。

310
00:16:04,460 --> 00:16:07,920
它们是一种方法来
遍历数组。

311
00:16:07,920 --> 00:16:11,714
所以，就像数组成了
所以在PHP中要冷得多，

312
00:16:11,714 --> 00:16:13,630
用自己的方式遍历
通过一个数组，我想，

313
00:16:13,630 --> 00:16:16,250
也变得更凉爽
而更强大。

314
00:16:16,250 --> 00:16:22,710
这样，代替具有以创建
有的为i等于0，什么的，

315
00:16:22,710 --> 00:16:24,890
然后更新
我为你办理，

316
00:16:24,890 --> 00:16:27,730
我们有这个真棒foreach循环。

317
00:16:27,730 --> 00:16:36,340
>> 因此，这里的一般标准
这两种结构。

318
00:16:36,340 --> 00:16:41,180
所以，你要么有一定的foreach数组
作为值要迭代的。

319
00:16:41,180 --> 00:16:46,750
因此，这是该阵列的名称
要引用变量，

320
00:16:46,750 --> 00:16:50,600
这就是你想要的
在循环中调用它。

321
00:16:50,600 --> 00:16:51,420
行？

322
00:16:51,420 --> 00:16:56,810
因此，这对应于
该数组的每个元素，

323
00:16:56,810 --> 00:16:59,500
你用这个循环中此值。

324
00:16:59,500 --> 00:17:00,675
>> 我有一个例子。

325
00:17:00,675 --> 00:17:02,930
我知道的例子是好多了。

326
00:17:02,930 --> 00:17:05,119
所以这是，如果有
没有钥匙，所以这是像

327
00:17:05,119 --> 00:17:11,170
如果我们只是有一个，其中键
对于您的阵列的正常指标。

328
00:17:11,170 --> 00:17:14,770
或者，这也是情节
你有没有用的钥匙。

329
00:17:14,770 --> 00:17:16,690
如果你不关心
键，你只要

330
00:17:16,690 --> 00:17:20,260
要遍历与价值观
每个那些以任何顺序的，

331
00:17:20,260 --> 00:17:20,950
没关系。

332
00:17:20,950 --> 00:17:22,609
>> 您可以使用这种结构。

333
00:17:22,609 --> 00:17:28,640
否则，如果有按键，我们的
$值仅仅更改为$ key值。

334
00:17:28,640 --> 00:17:30,660
因此，它只是改变了一个键值对。

335
00:17:30,660 --> 00:17:34,780
然后，我们可以参考$关键
我们的循环中美元和价值。

336
00:17:34,780 --> 00:17:35,900
行？

337
00:17:35,900 --> 00:17:36,660
所以。

338
00:17:36,660 --> 00:17:37,810
例如。

339
00:17:37,810 --> 00:17:38,610
使之更好。

340
00:17:38,610 --> 00:17:48,910

341
00:17:48,910 --> 00:17:49,410
行。

342
00:17:49,410 --> 00:17:56,780
>> 因此，我们有这一个
这里，我们有一些

343
00:17:56,780 --> 00:18:01,460
are--还可以
创建这样一个数组

344
00:18:01,460 --> 00:18:05,690
通过让一些变量等于
以数组的括号，

345
00:18:05,690 --> 00:18:08,340
或者你可以做支架。

346
00:18:08,340 --> 00:18:11,890
你应该做的支架，但
这是另一种方式来做到这一点。

347
00:18:11,890 --> 00:18:16,220
所以在这里我们有三个部分阵列
一个，两个，和三个元素，

348
00:18:16,220 --> 00:18:18,300
我们有我们的foreach。

349
00:18:18,300 --> 00:18:23,510
>> 注意到这一个对应于
数组，我们遍历，

350
00:18:23,510 --> 00:18:28,330
这就是我们调用
每个事物​​在我们的数组。

351
00:18:28,330 --> 00:18:32,670
而这一切正在做的是它的
将要打印出的每个值。

352
00:18:32,670 --> 00:18:45,590
因此，如果我们运行它，我们注意到，我们
有值1，值2，值3。

353
00:18:45,590 --> 00:18:54,080
>> 并以同样的方式，通常
阵列需要的一种类型，

354
00:18:54,080 --> 00:18:57,570
阵列不必全部
是同一类型在这里。

355
00:18:57,570 --> 00:18:58,690
所以，现在我们有一些int类型。

356
00:18:58,690 --> 00:19:00,910
我们有两个字符串。

357
00:19:00,910 --> 00:19:05,332
所以，你的阵列可
获得更强大

358
00:19:05,332 --> 00:19:07,040
也许有点
有点混乱，这取决于

359
00:19:07,040 --> 00:19:08,500
在你想要的方式来看待它。

360
00:19:08,500 --> 00:19:10,970
因此，我们可以改变这个
到任何我们想要的。

361
00:19:10,970 --> 00:19:12,860
我们使用的价值。

362
00:19:12,860 --> 00:19:14,630
这仅仅是我们使用标准的东西。

363
00:19:14,630 --> 00:19:19,650
但是，只是重要的是要知道，我们可以
调用此计数器一样，如果我们想要的。

364
00:19:19,650 --> 00:19:25,070
而且，只要它们相匹配，
显然每个人的快乐。

365
00:19:25,070 --> 00:19:30,600
如果你想运行一个PHP
运行这样的命令

366
00:19:30,600 --> 00:19:33,800
行，你知道这
在这里，你只是做PHP的，

367
00:19:33,800 --> 00:19:36,090
然后什么文件要运行。

368
00:19:36,090 --> 00:19:39,130
>> 所以，如果你想浪费时间
用PHP和更多的逻辑

369
00:19:39,130 --> 00:19:42,710
你并不真的需要
见像在Web浏览器，

370
00:19:42,710 --> 00:19:44,830
你可以运行它
这样的命令行

371
00:19:44,830 --> 00:19:48,290
和回声将打印
出任何你喜欢的。

372
00:19:48,290 --> 00:19:50,880
行。

373
00:19:50,880 --> 00:20:00,640
我们有另一种方法是这样的。

374
00:20:00,640 --> 00:20:06,974
因此，这是也许你想要一个案例
同时使用的键和值，

375
00:20:06,974 --> 00:20:08,890
我知道这些都是像
超级做作的例子

376
00:20:08,890 --> 00:20:11,950
但我希望他们做
它一点点清晰。

377
00:20:11,950 --> 00:20:14,940
所以在这里我们有一些阵
再次，但这一次，

378
00:20:14,940 --> 00:20:19,450
而不是仅仅有
你知道有没有钥匙。

379
00:20:19,450 --> 00:20:20,870
我们为每个这些键。

380
00:20:20,870 --> 00:20:24,670
所以是会是1，B将对应
到2，和c将对应于三个。

381
00:20:24,670 --> 00:20:27,030
并且在这种情况下，如果
我们把它写这样一来，

382
00:20:27,030 --> 00:20:31,580
我们可以使用这两个按键
和值对于每个这些。

383
00:20:31,580 --> 00:20:36,570
>> 所以当我们运行这个，
我们得到的每一个的。

384
00:20:36,570 --> 00:20:41,530
因此，它打印出我们的钥匙
和对应的值。

385
00:20:41,530 --> 00:20:46,940
另一个很酷的事情是，我知道
说，像这样的没有钥匙，

386
00:20:46,940 --> 00:20:51,540
但它总是隐含有
关键的，因为如果你不委托

387
00:20:51,540 --> 00:20:54,050
一个关键的，当然，你的
关键只是你的索引

388
00:20:54,050 --> 00:20:59,230
或指数，所以我们可以
一直也在做这一块。

389
00:20:59,230 --> 00:20:59,730
像这样。

390
00:20:59,730 --> 00:21:02,500

391
00:21:02,500 --> 00:21:03,400
我会打印出来。

392
00:21:03,400 --> 00:21:09,240

393
00:21:09,240 --> 00:21:13,420
所以在这种情况下，如果发现，
我们有我们的隐式按键

394
00:21:13,420 --> 00:21:15,930
零个，一个，两个此处。

395
00:21:15,930 --> 00:21:20,020

396
00:21:20,020 --> 00:21:25,600
>> 并以同样的方式与这一个，
你永远可以说为r的值，

397
00:21:25,600 --> 00:21:27,910
而你只需要访问值。

398
00:21:27,910 --> 00:21:30,685
你不关心你
键，即使你有钥匙，

399
00:21:30,685 --> 00:21:32,810
如果你不关心
他们，你不一定

400
00:21:32,810 --> 00:21:35,970
需要把它们放在你的foreach循环。

401
00:21:35,970 --> 00:21:37,953
这是否有道理给大家？

402
00:21:37,953 --> 00:21:39,764
>> 听众：你可以直接
调用键，也？

403
00:21:39,764 --> 00:21:42,180
ALLISON BUCHHOLTZ-AU：你呀
能完全做到这一点。

404
00:21:42,180 --> 00:21:44,945

405
00:21:44,945 --> 00:21:45,570
其实，等待。

406
00:21:45,570 --> 00:21:45,840
坚持，稍等。

407
00:21:45,840 --> 00:21:46,630
将它 - 号

408
00:21:46,630 --> 00:21:49,663
如果你想要的键，然后
你需要做的关键价值。

409
00:21:49,663 --> 00:21:50,496
听众：添加值。

410
00:21:50,496 --> 00:21:50,870
ALLISON BUCHHOLTZ-AU：是的。

411
00:21:50,870 --> 00:21:52,530
而你只是从来没有使用价值是一切。

412
00:21:52,530 --> 00:21:53,236
>> 听众：OK。

413
00:21:53,236 --> 00:21:55,610
ALLISON BUCHHOLTZ-AU：如果您
只是把一件事那里，

414
00:21:55,610 --> 00:22:00,010
它会假设你
谈到价值，而不是关键。

415
00:22:00,010 --> 00:22:02,070
大的问题。

416
00:22:02,070 --> 00:22:02,600
行。

417
00:22:02,600 --> 00:22:06,390

418
00:22:06,390 --> 00:22:08,170
凉爽。

419
00:22:08,170 --> 00:22:09,032
其实，坚持住。

420
00:22:09,032 --> 00:22:09,990
让我看看我有什么。

421
00:22:09,990 --> 00:22:13,600

422
00:22:13,600 --> 00:22:18,260
所以，在我们进入后而得到的，我
只是想告诉你男人一点点

423
00:22:18,260 --> 00:22:23,680
关于它是如何动态
类型化，这是种很酷。

424
00:22:23,680 --> 00:22:24,450
我有这些。

425
00:22:24,450 --> 00:22:28,160
我有这样四个例子在这里，
我会送你这些代码

426
00:22:28,160 --> 00:22:30,580
下课后。

427
00:22:30,580 --> 00:22:34,440
>> 所以在这里我们有一些变量。

428
00:22:34,440 --> 00:22:36,500
这只是1加1，对不对？

429
00:22:36,500 --> 00:22:40,930
而且我们要打印出什么是
等于，然后我们有一些类型。

430
00:22:40,930 --> 00:22:46,066
和任何人有任何的猜测
什么类型它的将是什么？

431
00:22:46,066 --> 00:22:46,890
>> 听众：一个int值。

432
00:22:46,890 --> 00:22:48,560
>> ALLISON BUCHHOLTZ-AU：是的，这是一个int。

433
00:22:48,560 --> 00:22:49,890
所以它只是把它们加在一起。

434
00:22:49,890 --> 00:22:51,671
这是一个int。

435
00:22:51,671 --> 00:22:52,170
都不错。

436
00:22:52,170 --> 00:22:56,440

437
00:22:56,440 --> 00:23:05,590
所以这下一个，我们有
什么样子的字符串。

438
00:23:05,590 --> 00:23:11,000
当我们运行这个，它认为，哦。

439
00:23:11,000 --> 00:23:13,720
你实际上是试图
只需添加的东西。

440
00:23:13,720 --> 00:23:15,140
你只要弄糊涂了。

441
00:23:15,140 --> 00:23:17,410
所以，我只是去修复它给你。

442
00:23:17,410 --> 00:23:18,090
你的意思是int型。

443
00:23:18,090 --> 00:23:19,160
我知道你的意思是int型。

444
00:23:19,160 --> 00:23:25,190
>> 因此，这是方法可以一
看，PHP有它自己的想法。

445
00:23:25,190 --> 00:23:28,800
即使我们明确表示，
看起来，这些的都是字符串。

446
00:23:28,800 --> 00:23:30,120
我的意思是字符串之一。

447
00:23:30,120 --> 00:23:32,160
但它说，哦，但
你想加入他们，

448
00:23:32,160 --> 00:23:34,460
所以你必须意味着它是一个整数。

449
00:23:34,460 --> 00:23:35,950
只是相信我这一点。

450
00:23:35,950 --> 00:23:38,920
所以说这是一个整数，
并增加了他们像正常的。

451
00:23:38,920 --> 00:23:42,460
种所以，如果你要冷静
偷懒用你的东西，

452
00:23:42,460 --> 00:23:45,470
或者你想添加的东西。

453
00:23:45,470 --> 00:23:48,690
>> 一个伟大的事情是，如果
你回想起pset2，

454
00:23:48,690 --> 00:23:51,840
这在过去是用户
输入，右，我们认为

455
00:23:51,840 --> 00:23:54,010
是char或字符串在第一。

456
00:23:54,010 --> 00:23:57,950
现在我们不必明确地
说，哦，让这个一个int。

457
00:23:57,950 --> 00:23:59,790
PHP也只是喜欢，哦耶。

458
00:23:59,790 --> 00:24:01,215
我知道你的意思是一个int。

459
00:24:01,215 --> 00:24:01,830
傻傻的你。

460
00:24:01,830 --> 00:24:04,640
你不是故意的字符串。

461
00:24:04,640 --> 00:24:12,596
>> 所以在这种情况下，现
我们有这个，有什么

462
00:24:12,596 --> 00:24:14,330
你们认为它会在这里做？

463
00:24:14,330 --> 00:24:17,220

464
00:24:17,220 --> 00:24:20,495
我们有一个字符串，现在一个int。

465
00:24:20,495 --> 00:24:21,980
>> 听众：它仍然是一个int。

466
00:24:21,980 --> 00:24:24,040
>> ALLISON BUCHHOLTZ-AU：它仍然是一个int。

467
00:24:24,040 --> 00:24:26,790
其原因is--我会把
更多的例子，但是这一次的乐趣。

468
00:24:26,790 --> 00:24:30,110
它之所以这样做是因为
这就像你想添加的东西。

469
00:24:30,110 --> 00:24:33,310
所以，如果你想添加
的东西，我要去承担，

470
00:24:33,310 --> 00:24:36,030
合理的，你有什么
合理的，你可以添加。

471
00:24:36,030 --> 00:24:40,032
我只是要让它一个int，
我们只是要添加它，就像往常一样。

472
00:24:40,032 --> 00:24:42,240
然后以同样的方式，我
觉得你们的想法。

473
00:24:42,240 --> 00:24:47,400
我们也有这样的人在这里，这是
只是碳化的，而且做同样的事情。

474
00:24:47,400 --> 00:24:49,210
这就像，你傻的用户。

475
00:24:49,210 --> 00:24:51,400
你知道你想要一个int。

476
00:24:51,400 --> 00:24:54,491
>> 听众：如果我们把一个字母，将
它做的[听不清]值不？

477
00:24:54,491 --> 00:24:56,532
ALLISON BUCHHOLTZ-AU：哦，
这是一个很好的问题。

478
00:24:56,532 --> 00:24:57,518
让我们来看看。

479
00:24:57,518 --> 00:25:00,480

480
00:25:00,480 --> 00:25:03,430
不，仍然是一个int。

481
00:25:03,430 --> 00:25:06,700
所以这是一个有点疯狂。

482
00:25:06,700 --> 00:25:12,170
这是那种只是为了显示你的PHP
有时可表现在irrational--不

483
00:25:12,170 --> 00:25:16,670
完全不合理的，但它可能表现
在你真的不希望的方式。

484
00:25:16,670 --> 00:25:18,970
所以，在有疑问时，请检查
事物的类型。

485
00:25:18,970 --> 00:25:22,570
此功能的GetType
可超有用。

486
00:25:22,570 --> 00:25:26,930
>> 通常情况下，如果你做任何事情
加分或数学运算符，

487
00:25:26,930 --> 00:25:32,010
它要承担什么
合理的仅仅是一个int。

488
00:25:32,010 --> 00:25:36,530
所以，你必须CHAR 1，或
串1，或者实际的INT 1，

489
00:25:36,530 --> 00:25:38,200
它会假设。

490
00:25:38,200 --> 00:25:41,410
如果你想强制转换
什么，你完全可以。

491
00:25:41,410 --> 00:25:46,540
你可以这样做
这里的两倍，我相信。

492
00:25:46,540 --> 00:25:50,370

493
00:25:50,370 --> 00:25:53,420
而在这种情况下，它会说，哦。

494
00:25:53,420 --> 00:25:56,550
我会让这双重原因
你明确地说，这是一个双。

495
00:25:56,550 --> 00:26:00,370
你总是可以明确
使PHP做一些事情，但是。

496
00:26:00,370 --> 00:26:02,174
>> 听众：等一下，为什么是A加1呢？

497
00:26:02,174 --> 00:26:03,215
>> ALLISON BUCHHOLTZ-AU：哦。

498
00:26:03,215 --> 00:26:06,512

499
00:26:06,512 --> 00:26:07,490
那里。

500
00:26:07,490 --> 00:26:08,400
这只是一个回声。

501
00:26:08,400 --> 00:26:10,820
这是我的错。

502
00:26:10,820 --> 00:26:14,240
所以，你可以明确地告诉它
使一些特定类型的，

503
00:26:14,240 --> 00:26:17,980
但大多数时候，它要
动态地决定在运行时。

504
00:26:17,980 --> 00:26:20,730
因此，这将继续经历
而且它会像，OK。

505
00:26:20,730 --> 00:26:23,229
什么最让
感觉这个是？

506
00:26:23,229 --> 00:26:24,520
如果它实际上是一个字符串？

507
00:26:24,520 --> 00:26:25,090
它应该是一个int？

508
00:26:25,090 --> 00:26:25,770
它应该是一个浮动？

509
00:26:25,770 --> 00:26:26,810
它应该是一个双？

510
00:26:26,810 --> 00:26:29,456
它会决定你。

511
00:26:29,456 --> 00:26:31,980
>> 你可以强制它做
你想要什么，但 - 

512
00:26:31,980 --> 00:26:35,032
>> 听众：这是否让它慢？

513
00:26:35,032 --> 00:26:37,365
ALLISON BUCHHOLTZ-AU：嗯，
我的意思是，C是非常有效的。

514
00:26:37,365 --> 00:26:41,760
我认为这是绝对慢的原因
它的过程，因为它是怎么回事。

515
00:26:41,760 --> 00:26:45,200
C，我几乎可以肯定的是更快的。

516
00:26:45,200 --> 00:26:47,620
但显然有一个
很多很酷的东西在这里

517
00:26:47,620 --> 00:26:49,190
我们不必担心。

518
00:26:49,190 --> 00:26:50,981
所以，如果我们要搜索
通过一个数组，我们

519
00:26:50,981 --> 00:26:54,290
不必实际创建
通过阵列某些搜索。

520
00:26:54,290 --> 00:26:56,920
我们只需要求的关键
和PHP会照顾它。

521
00:26:56,920 --> 00:26:59,510

522
00:26:59,510 --> 00:27:00,630
>> 凉爽。

523
00:27:00,630 --> 00:27:01,130
真棒。

524
00:27:01,130 --> 00:27:03,937
看起来像我的例子结束。

525
00:27:03,937 --> 00:27:05,770
你们永远不会
现在忘了。

526
00:27:05,770 --> 00:27:08,450
你要像，哦，PHP只是
这样的妈妈是谁的像，不，不，不。

527
00:27:08,450 --> 00:27:09,325
我知道你的意思。

528
00:27:09,325 --> 00:27:11,000
我知道你想要什么。

529
00:27:11,000 --> 00:27:11,580
行。

530
00:27:11,580 --> 00:27:15,040
因此，这是，希望对您有用
pset中，至少在一开始，

531
00:27:15,040 --> 00:27:20,290
因为你是所有关于交易
来自用户的形式和事物。

532
00:27:20,290 --> 00:27:24,460
>> 因此，有两种方法，我们
绕过PHP和HTML信息

533
00:27:24,460 --> 00:27:26,700
当我们路过
这两件事情之间。

534
00:27:26,700 --> 00:27:32,330
因此，我们有$ _ GET，这是通过
通过URL，我们有$ _ POST，

535
00:27:32,330 --> 00:27:36,600
这是通过在该消息中
体，所以我们认为这是隐藏的。

536
00:27:36,600 --> 00:27:41,660
但有一点要明白的是，
这些都不被认为是安全的。

537
00:27:41,660 --> 00:27:45,580
>> 如果你有别人谁是
去拦截消息

538
00:27:45,580 --> 00:27:49,180
来回你和之间
服务器，他们仍然可以得到这个数据。

539
00:27:49,180 --> 00:27:50,810
他们只要看有点困难。

540
00:27:50,810 --> 00:27:54,690
这不是真的that--它的
从URL只是被隐藏。

541
00:27:54,690 --> 00:27:58,820
它仍然在邮件正文中，
不过，如果他们有机会获得如此，

542
00:27:58,820 --> 00:27:59,920
它实际上只是like--

543
00:27:59,920 --> 00:28:01,710
>> 这就像区别
东西之间

544
00:28:01,710 --> 00:28:05,010
被写上的外
信封和幸福的东西

545
00:28:05,010 --> 00:28:06,980
写在一张纸上的内部。

546
00:28:06,980 --> 00:28:10,270
这不是那么难打开信封
并获得了一张纸内。

547
00:28:10,270 --> 00:28:12,414
当然，它会更容易
刚读了外面。

548
00:28:12,414 --> 00:28:14,330
但是，这怎么可以
种想到这些。

549
00:28:14,330 --> 00:28:16,940
这些都不是
真正考虑过安全。

550
00:28:16,940 --> 00:28:17,790
行？

551
00:28:17,790 --> 00:28:19,750
>> 当然，并没有真正
不管您PSET

552
00:28:19,750 --> 00:28:22,050
因为你不处理
与商业秘密，

553
00:28:22,050 --> 00:28:25,850
但它通常是一个
的事情，我们真的

554
00:28:25,850 --> 00:28:29,260
要强调的，因为人们
想想，哦，这是隐藏的。

555
00:28:29,260 --> 00:28:30,610
它必须是超级安全的。

556
00:28:30,610 --> 00:28:31,140
号

557
00:28:31,140 --> 00:28:32,570
它并不安全。

558
00:28:32,570 --> 00:28:35,808
这只是略有
少安全感，我猜。

559
00:28:35,808 --> 00:28:38,500
或不安全。

560
00:28:38,500 --> 00:28:41,625
>> 所以，我们实际上有一个例子。

561
00:28:41,625 --> 00:28:43,500
如你所知，我爱
教多用的例子。

562
00:28:43,500 --> 00:28:45,070
我觉得这有助于更好。

563
00:28:45,070 --> 00:28:49,590
因此，我们有一些简单的形式在这里
实际上，如果你们是永远

564
00:28:49,590 --> 00:28:51,940
糊涂关于PHP，
这是非常小的，

565
00:28:51,940 --> 00:28:55,630
但php.net实际上是
真正好的文档。

566
00:28:55,630 --> 00:28:56,500
我真的很喜欢它。

567
00:28:56,500 --> 00:29:02,900
我是用它来为这个做准备
部分，这样我就可以兽医给你。

568
00:29:02,900 --> 00:29:07,760
>> 这是由它们的实例
如何$ _ POST和$ _GET工作。

569
00:29:07,760 --> 00:29:09,970
唯一的区别
在其中的两个之间，

570
00:29:09,970 --> 00:29:13,285
除了其中的信息是
显示，无论是在URL中

571
00:29:13,285 --> 00:29:16,430
或在体内，也
该方法是什么。

572
00:29:16,430 --> 00:29:21,350
所以，在你的表格HTML--这
是一个非常简单的HTML表格。

573
00:29:21,350 --> 00:29:22,760
谁能告诉我这是什么呢？

574
00:29:22,760 --> 00:29:29,471

575
00:29:29,471 --> 00:29:30,970
听众：问你的姓名和年龄。

576
00:29:30,970 --> 00:29:31,230
ALLISON BUCHHOLTZ-AU：没错。

577
00:29:31,230 --> 00:29:33,330
因此，我们有某种形式的行动。

578
00:29:33,330 --> 00:29:36,260
这让我们知道它的一些行为形式。

579
00:29:36,260 --> 00:29:39,330
什么事情发生
是，当我们点击提交，

580
00:29:39,330 --> 00:29:44,280
它会调用action.php的，
这是这是什么，

581
00:29:44,280 --> 00:29:47,180
并且它会调用它
用$ _ POST方法。

582
00:29:47,180 --> 00:29:51,340
所以在这种情况下，你的
信息是隐藏的。

583
00:29:51,340 --> 00:29:57,020
它只是你的名字，有些
叫名字输入类型，一些年龄，

584
00:29:57,020 --> 00:30:01,270
INPUT TYPE =“文本”，我们也呼吁岁。

585
00:30:01,270 --> 00:30:05,110
然后，如果我们点击提交，
提交将调用action.php的。

586
00:30:05,110 --> 00:30:09,800
>> 所以，当我们真正点击提交，我们
知道它已经发布本身，

587
00:30:09,800 --> 00:30:15,290
我们将真正看到这你
问题设置希望我们能

588
00:30:15,290 --> 00:30:16,760
让走过一点点。

589
00:30:16,760 --> 00:30:21,690
和所有它做这里是POST
一些超全局变量

590
00:30:21,690 --> 00:30:23,300
我们的讲座中谈到。

591
00:30:23,300 --> 00:30:30,170
以及如何你可以想想$ _ POST是
这只是一个关联数组。

592
00:30:30,170 --> 00:30:30,960
行？

593
00:30:30,960 --> 00:30:35,930
因此，这是一些关键的，这
一些关键的，不管

594
00:30:35,930 --> 00:30:39,270
用户输入变为
值对每个那些。

595
00:30:39,270 --> 00:30:39,960
行？

596
00:30:39,960 --> 00:30:47,240
>> 所以，如果我们写的这是什么阵
本来的样子权后，我们

597
00:30:47,240 --> 00:30:56,000
提交表单，我们会
有，这是我们的$ _ POST，

598
00:30:56,000 --> 00:31:04,380
有的数组，其中我们有一些名字。

599
00:31:04,380 --> 00:31:17,670
远的不说，我们会尽我的名字，
然后我们有一些年龄21。

600
00:31:17,670 --> 00:31:19,420
呜。

601
00:31:19,420 --> 00:31:23,550
因此，这是所有$ _ POST是。 $ _ POST
仅仅是一个关联数组，好不好？

602
00:31:23,550 --> 00:31:24,807
>> 它只是说，OK。

603
00:31:24,807 --> 00:31:26,890
什么是我们所的事情
要求从用户？

604
00:31:26,890 --> 00:31:28,889
什么是变量
我们正在通过各地

605
00:31:28,889 --> 00:31:30,730
我们已经以这种形式要求？

606
00:31:30,730 --> 00:31:33,830
然后是什么
与该关联的值？

607
00:31:33,830 --> 00:31:38,750
所以在这种情况下，如果我提交它
与盟友的名字和一个21岁，

608
00:31:38,750 --> 00:31:40,890
这就是$ _ POST样子。

609
00:31:40,890 --> 00:31:41,570
行？

610
00:31:41,570 --> 00:31:45,150
而这也正是这
PHP文件访问。

611
00:31:45,150 --> 00:31:46,680
行？

612
00:31:46,680 --> 00:31:51,730
>> 所以在这种情况下，这是一样
让我们从数组中的任何其他东西。

613
00:31:51,730 --> 00:31:55,370
相反，在索引中的我们
数组，我们有一些关键的。

614
00:31:55,370 --> 00:32:00,790
因此，这将会给
我在键名的值。

615
00:32:00,790 --> 00:32:05,400
因此，这将是盟友，
这一权利在这里是要给我

616
00:32:05,400 --> 00:32:08,840
在$ _ POST其中的价值
关键是年龄，这将是21。

617
00:32:08,840 --> 00:32:12,541

618
00:32:12,541 --> 00:32:14,290
你会成为
这样做相当多的。

619
00:32:14,290 --> 00:32:18,920

620
00:32:18,920 --> 00:32:21,590
是啊，从哪个部分？

621
00:32:21,590 --> 00:32:24,235
>> 听众：如果你是
指向下方的部分。

622
00:32:24,235 --> 00:32:25,860
ALLISON BUCHHOLTZ-AU：此底部？

623
00:32:25,860 --> 00:32:26,359
行。

624
00:32:26,359 --> 00:32:31,897
所以，你知道这是我们的HTML
形成的，我们有一些方法，$ _ POST，

625
00:32:31,897 --> 00:32:32,480
这很重要。

626
00:32:32,480 --> 00:32:35,410
这也可能是$ _GET，
但为此目的，

627
00:32:35,410 --> 00:32:36,910
我们只是说这是$ _ POST。

628
00:32:36,910 --> 00:32:42,700
当我们提交这种形式，这是
这就是所谓的一个PHP文件的一部分。

629
00:32:42,700 --> 00:32:48,530
所以这个PHP文件现在要执行
给我们的HTML信息

630
00:32:48,530 --> 00:32:49,840
形式。

631
00:32:49,840 --> 00:32:52,670
>> 所以它在做什么，当我们
点击提交我们的HTML表单，

632
00:32:52,670 --> 00:32:59,220
它通过你这个超级全局，
这仅仅是一个关联数组。

633
00:32:59,220 --> 00:33:00,306
这是这一点。

634
00:33:00,306 --> 00:33:02,840
这就像递过来的文件。

635
00:33:02,840 --> 00:33:04,540
和它说的是，OK，这里的$ _ POST。

636
00:33:04,540 --> 00:33:05,706
这是你的关联数组。

637
00:33:05,706 --> 00:33:07,000
用它做你想做的。

638
00:33:07,000 --> 00:33:08,980
和我们说，确定。

639
00:33:08,980 --> 00:33:13,620
给我在name的值，
给我的年龄值。

640
00:33:13,620 --> 00:33:18,150
>> 所以这些都只是钥匙，
这就是我们的数组。

641
00:33:18,150 --> 00:33:19,190
这是否有道理？

642
00:33:19,190 --> 00:33:19,815
>> 听众：Mhmm。

643
00:33:19,815 --> 00:33:21,266
ALLISON BUCHHOLTZ-AU：真棒。

644
00:33:21,266 --> 00:33:24,432
听众：如果你要重新提交
形式它只是写过来的数据？

645
00:33:24,432 --> 00:33:25,557
ALLISON BUCHHOLTZ-AU：是的。

646
00:33:25,557 --> 00:33:26,160
Mhmm？

647
00:33:26,160 --> 00:33:30,300
>> 听众：你为什么有
可以指定它的一个int？

648
00:33:30,300 --> 00:33:34,950
>> ALLISON BUCHHOLTZ-AU：在这种情况下，该
用户只需迫使它是一个int。

649
00:33:34,950 --> 00:33:35,749
>> 听众：OK。

650
00:33:35,749 --> 00:33:38,540
ALLISON BUCHHOLTZ-AU：我不知道
如果你确实需要的，

651
00:33:38,540 --> 00:33:43,850
但他们的目的，他们决定
他们希望它是一个int。

652
00:33:43,850 --> 00:33:45,590
他们只是类型转换它。

653
00:33:45,590 --> 00:33:47,760
也许他们正在使用它作为
别的东西以后。

654
00:33:47,760 --> 00:33:49,872
这仅仅是一个片段。

655
00:33:49,872 --> 00:33:50,372
是吗？

656
00:33:50,372 --> 00:33:57,246
>> 听众：如果他们输入
12，T-W-E-L-V-E，年龄？

657
00:33:57,246 --> 00:33:59,704
ALLISON BUCHHOLTZ-AU：如果他们
试着键入为int？

658
00:33:59,704 --> 00:34:00,160
听众：是的。

659
00:34:00,160 --> 00:34:02,076
ALLISON BUCHHOLTZ-AU：我
忘记是什么呢。

660
00:34:02,076 --> 00:34:05,540
我想可能尝试转换
第一个字符为int，

661
00:34:05,540 --> 00:34:11,360
或采取价值和转换
它，但我忘了到底是什么。

662
00:34:11,360 --> 00:34:14,570
是一个有趣的事情来写
程序和尝试。

663
00:34:14,570 --> 00:34:16,389
做了几行。

664
00:34:16,389 --> 00:34:21,310
好了，这是主要原因之一
东西，你会做的事情。

665
00:34:21,310 --> 00:34:23,969
我会希望走
通过一对中的文件

666
00:34:23,969 --> 00:34:25,260
从与你们的PSET。

667
00:34:25,260 --> 00:34:28,850
看起来我们要
有时间，所以我们可以做到这一点。

668
00:34:28,850 --> 00:34:31,190
>> 但是，你要成为
做了很多事情

669
00:34:31,190 --> 00:34:36,130
这样，在你传递
从一个HTML表单的事情

670
00:34:36,130 --> 00:34:42,130
这个PHP形式，然后将
执行一些指令集

671
00:34:42,130 --> 00:34:44,460
上被提供的数据。

672
00:34:44,460 --> 00:34:46,864
这是字面上的PSET的要点。

673
00:34:46,864 --> 00:34:48,130
是啊。

674
00:34:48,130 --> 00:34:52,040
>> 听众：类型=“提交”，即
使得HTML表单上的一个按钮。

675
00:34:52,040 --> 00:34:54,280
有没有办法来调用
该按钮的东西吗？

676
00:34:54,280 --> 00:34:56,040
所以，你会像NAME =“提交”？

677
00:34:56,040 --> 00:34:59,170
或者是，按钮只是要
空现在，因为你只

678
00:34:59,170 --> 00:35:00,970
给它一个类型，而不是一个名字。

679
00:35:00,970 --> 00:35:03,803
>> ALLISON BUCHHOLTZ-AU：我认为这是
刚准备，现在是空的。

680
00:35:03,803 --> 00:35:07,320
我们完全可以期待的
PSET，因为我们一定会

681
00:35:07,320 --> 00:35:10,265
可以看
注册之类的话。

682
00:35:10,265 --> 00:35:14,610
但是，是的，你绝对可以指定
您想在您的按钮上的文本。

683
00:35:14,610 --> 00:35:17,560
OK，所以SQL。

684
00:35:17,560 --> 00:35:21,880
>> 当你买卖股票，
你需要跟踪这些的。

685
00:35:21,880 --> 00:35:25,760
所以，我们要做到这一点的方法是
与SQL，这只是一个数据库。

686
00:35:25,760 --> 00:35:29,200
把它看成是一个表，其中
你保持所有这些信息

687
00:35:29,200 --> 00:35:30,649
关于你的不同的用户。

688
00:35:30,649 --> 00:35:32,940
而你们是真正
将要创建的其中之一。

689
00:35:32,940 --> 00:35:34,290
这实在是太酷了。

690
00:35:34,290 --> 00:35:38,470
>> 而目前只有四个主要的事情
你需要知道这个PSET，

691
00:35:38,470 --> 00:35:43,120
他们是更新，所以你
基本上更新数据。

692
00:35:43,120 --> 00:35:45,190
这假定它已经存在。

693
00:35:45,190 --> 00:35:48,320
如果它不存在，这是怎么回事
打你一个错误，

694
00:35:48,320 --> 00:35:51,300
所以也许你要检查。

695
00:35:51,300 --> 00:35:55,882
你会更新on--我
应该actually-我有时间，

696
00:35:55,882 --> 00:35:57,090
我会写一对夫妇的这些。

697
00:35:57,090 --> 00:36:03,370
我居然给你们一个
几个样品，完整的SQL命令，

698
00:36:03,370 --> 00:36:06,530
因为这些只是主
的人，但你可以将它们连接在一起。

699
00:36:06,530 --> 00:36:09,780
所以，我会的，我会送
说出来给你这些笔记。

700
00:36:09,780 --> 00:36:14,580
>> 所以，如果你要更新的东西，
需要告诉它你要更新什么

701
00:36:14,580 --> 00:36:16,390
而您在何处进行更新。

702
00:36:16,390 --> 00:36:27,770
因此，一个典型的SQL命令将更新
ID其中，等于什么东西。

703
00:36:27,770 --> 00:36:31,490
或者像更新地址
其中，ID等于3，

704
00:36:31,490 --> 00:36:37,040
而这将更新地址字段
您的用户谁拥有3的ID的。

705
00:36:37,040 --> 00:36:37,630
行？

706
00:36:37,630 --> 00:36:44,300
>> 所以，如果你去到SQL和W3Schools的，
他们真棒例子。

707
00:36:44,300 --> 00:36:46,880
事实上，我可能会拉
一些在一点点。

708
00:36:46,880 --> 00:36:49,810
然后再插入，你只是
插入有一定的价值。

709
00:36:49,810 --> 00:36:56,810
所以，如果你想创造一些新的
条目，所以你要创建一个新的用户，

710
00:36:56,810 --> 00:37:00,970
你可以做INSERT INTO
无论你的数据库调用，

711
00:37:00,970 --> 00:37:03,540
你将拥有所有这些值。

712
00:37:03,540 --> 00:37:06,250
>> 那么你有选择，
选择值来查看。

713
00:37:06,250 --> 00:37:09,640
所以，如果你想检查
看看用户是否存在，或者你

714
00:37:09,640 --> 00:37:12,030
试图抓住特定的
有关用户的信息

715
00:37:12,030 --> 00:37:13,790
你将要使用选择。

716
00:37:13,790 --> 00:37:17,564
然后删除，我认为，
很简单那里。

717
00:37:17,564 --> 00:37:19,480
你只是删除
一些从该表。

718
00:37:19,480 --> 00:37:25,960
而事实上，我确实拉
一些例子你们。

719
00:37:25,960 --> 00:37:29,350
哦，看，这是我的第61页。

720
00:37:29,350 --> 00:37:32,940
>> 所以，如果我们去W3Schools的，
希望它再次出现。

721
00:37:32,940 --> 00:37:35,640
是的，爱它。

722
00:37:35,640 --> 00:37:37,680
我们去的SQL。

723
00:37:37,680 --> 00:37:39,160
所以，这个东西在这里。

724
00:37:39,160 --> 00:37:42,548
所以，这是一个非常简单的SELECT。

725
00:37:42,548 --> 00:37:45,620
男人，我喜欢这个功能。

726
00:37:45,620 --> 00:37:50,030
所以，你可以有选择
来自客户的一些领域。

727
00:37:50,030 --> 00:37:55,340
在这种情况下，客户是指
您使用的在线数据库，

728
00:37:55,340 --> 00:38:00,480
所以不管你的表被调用，
明星只是意味着选择了一切。

729
00:38:00,480 --> 00:38:01,710
给我的每一个。

730
00:38:01,710 --> 00:38:05,810

731
00:38:05,810 --> 00:38:10,720
>> 所以，我只是想给你们一个
情侣在哪里，这是例子。

732
00:38:10,720 --> 00:38:15,570

733
00:38:15,570 --> 00:38:17,960
因此，我们有SELECT，UPDATE。

734
00:38:17,960 --> 00:38:21,460

735
00:38:21,460 --> 00:38:25,420
因此，这里是一种一般的语法。

736
00:38:25,420 --> 00:38:31,080
所以，UPDATE，无论你
表名是，然后设置

737
00:38:31,080 --> 00:38:35,060
在这里，你实际上会
是你改变了什么数据。

738
00:38:35,060 --> 00:38:38,340
所以这可能让be--
我做一个例子来说明。

739
00:38:38,340 --> 00:38:44,146

740
00:38:44,146 --> 00:38:45,145
因此，这是要be--

741
00:38:45,145 --> 00:39:10,250

742
00:39:10,250 --> 00:39:10,750
>> 行。

743
00:39:10,750 --> 00:39:13,585
所以，我创建了一个小数据库，为我们。

744
00:39:13,585 --> 00:39:16,260
我们将有一些ID，
一些年，一些命名。

745
00:39:16,260 --> 00:39:23,022
所以ID只能有一个将成为今年'15，
而我们只是要让它我。

746
00:39:23,022 --> 00:39:24,980
谁愿意成为第二个
人在我们的餐桌？

747
00:39:24,980 --> 00:39:25,480
任何人。

748
00:39:25,480 --> 00:39:28,192

749
00:39:28,192 --> 00:39:30,525
我只是要选择艾玛
因为你的名字的快。

750
00:39:30,525 --> 00:39:32,220
艾玛，哪一年是吗？

751
00:39:32,220 --> 00:39:33,180
>> 听众：哪一年？

752
00:39:33,180 --> 00:39:33,600
>> ALLISON BUCHHOLTZ-AU：是的。

753
00:39:33,600 --> 00:39:34,183
>> 听众：'16。

754
00:39:34,183 --> 00:39:35,780
ALLISON BUCHHOLTZ-AU：'16。

755
00:39:35,780 --> 00:39:37,920
你只是要
我的豚鼠今天。

756
00:39:37,920 --> 00:39:40,490
好了，我们有两个人。

757
00:39:40,490 --> 00:39:42,194
其实，让我做到这一点。

758
00:39:42,194 --> 00:39:45,110
比方说，我听到她错了，我
居然说她小一岁。

759
00:39:45,110 --> 00:39:46,980
她是'17。

760
00:39:46,980 --> 00:39:50,790
我们要在这里做的，如果我们什么
想更新艾玛的一年

761
00:39:50,790 --> 00:39:57,480
要正确使用，我们会
做的是，我们会在这里说的更新数据。

762
00:39:57,480 --> 00:40:05,140

763
00:40:05,140 --> 00:40:09,130
>> 而这些都可以在同一行，但
因为我在这里的压缩空间，

764
00:40:09,130 --> 00:40:11,450
我会写在这里。

765
00:40:11,450 --> 00:40:12,740
我们要设置。

766
00:40:12,740 --> 00:40:16,770
因此，这是我们正在更新表。

767
00:40:16,770 --> 00:40:21,600
SET将是什么样的列或
什么样的数据，我们实际上是不断变化的。

768
00:40:21,600 --> 00:40:30,670
我们现在是改变的一年，所以
我们将设置年= 16的说，

769
00:40:30,670 --> 00:40:39,470
然后WHERE告诉我们哪些用户或
什么都行，我们确实更新了。

770
00:40:39,470 --> 00:40:40,980
>> 所以，在哪里？

771
00:40:40,980 --> 00:40:42,600
我们有两个选择这里。

772
00:40:42,600 --> 00:40:43,450
有哪两种？

773
00:40:43,450 --> 00:40:44,580
这些都是独一无二的，对不对？

774
00:40:44,580 --> 00:40:47,150
因此，我们的名称是唯一的
而我们的ID是唯一的，

775
00:40:47,150 --> 00:40:50,880
那么什么是两种选择
为在那里我们可以做到这一点？

776
00:40:50,880 --> 00:40:51,970
我给你一个。

777
00:40:51,970 --> 00:40:57,450
我们可以做WHERE ID =
2，或者我们可以做什么

778
00:40:57,450 --> 00:41:00,920
如果我们要关闭此模式在这里。

779
00:41:00,920 --> 00:41:02,180
>> 听众：[听不清]。

780
00:41:02,180 --> 00:41:03,430
ALLISON BUCHHOLTZ-AU：没错。

781
00:41:03,430 --> 00:41:07,300
因此，我们也可以做名字=艾玛。

782
00:41:07,300 --> 00:41:10,189

783
00:41:10,189 --> 00:41:11,480
和任一这些会工作。

784
00:41:11,480 --> 00:41:14,040
我们跑了这一点，它会想，OK。

785
00:41:14,040 --> 00:41:15,300
我们将改变它。

786
00:41:15,300 --> 00:41:17,680
你居然16，所以
现在，你是对的了。

787
00:41:17,680 --> 00:41:21,410
好了，这将是
在PSET超好用

788
00:41:21,410 --> 00:41:25,157
在那里，也许有人决定
买进100股苹果，

789
00:41:25,157 --> 00:41:26,740
然后，他们像，只是在开玩笑。

790
00:41:26,740 --> 00:41:28,320
我只想要90的股份。

791
00:41:28,320 --> 00:41:33,630
因此，他们卖10人，所以你
需要更新库存量信息

792
00:41:33,630 --> 00:41:34,330
他们有。

793
00:41:34,330 --> 00:41:39,050
因此，更新库存，更新的表。

794
00:41:39,050 --> 00:41:39,950
>> 行。

795
00:41:39,950 --> 00:41:42,710
所以这是一个例子出现。

796
00:41:42,710 --> 00:41:45,131
这是更新的语法。

797
00:41:45,131 --> 00:41:45,630
DELETE。

798
00:41:45,630 --> 00:41:50,391

799
00:41:50,391 --> 00:41:50,890
呵呵。

800
00:41:50,890 --> 00:41:53,580
插入是我们的另外一个。

801
00:41:53,580 --> 00:41:57,950
所以，这一个在这里是非常相似的。

802
00:41:57,950 --> 00:42:00,430
我们只能说，在这
情况下，让我们添加一个人。

803
00:42:00,430 --> 00:42:02,310
我们可以添加奔这个时候。

804
00:42:02,310 --> 00:42:13,300
我们INSERT INTO，而我们
希望我们的表的名称。

805
00:42:13,300 --> 00:42:16,580
在这种情况下，它的数据。

806
00:42:16,580 --> 00:42:25,790
>> 然后，我们只是想，你要
说值，你会怎么做

807
00:42:25,790 --> 00:42:29,147
是，你实际上需要确保
你有东西给每一行

808
00:42:29,147 --> 00:42:29,730
你想要的。

809
00:42:29,730 --> 00:42:31,090
你只要把它们的顺序。

810
00:42:31,090 --> 00:42:33,920
因此，在这种情况下，我们会说3。

811
00:42:33,920 --> 00:42:35,280
你是18，右奔？

812
00:42:35,280 --> 00:42:36,439
>> 听众：19。

813
00:42:36,439 --> 00:42:37,480
ALLISON BUCHHOLTZ-AU：19？

814
00:42:37,480 --> 00:42:38,360
听众：19。

815
00:42:38,360 --> 00:42:39,943
ALLISON BUCHHOLTZ-AU：你今年的'19？

816
00:42:39,943 --> 00:42:41,459
你毕业的'18，对不对？

817
00:42:41,459 --> 00:42:42,000
听众：哦。

818
00:42:42,000 --> 00:42:42,870
ALLISON BUCHHOLTZ-AU：毕业一年。

819
00:42:42,870 --> 00:42:43,842
听众：OK。

820
00:42:43,842 --> 00:42:46,070
ALLISON BUCHHOLTZ-AU：
我当时想，你

821
00:42:46,070 --> 00:42:48,550
已计划
休息一年吗？

822
00:42:48,550 --> 00:42:52,590
因此，'18，我们奔。

823
00:42:52,590 --> 00:43:01,950
所以在这种情况下，它会通过，
它会在这里创建一个新条目。

824
00:43:01,950 --> 00:43:04,520

825
00:43:04,520 --> 00:43:05,750
凉爽。

826
00:43:05,750 --> 00:43:07,570
差不太多，对不对？

827
00:43:07,570 --> 00:43:09,850
很多这会
是语法你们。

828
00:43:09,850 --> 00:43:13,280
概念要来，
希望，相对容易。

829
00:43:13,280 --> 00:43:17,270
语法是唯一
这可以是一个有点棘手。

830
00:43:17,270 --> 00:43:20,590
>> 然后我们的最后一个
DELETE，正如你注意到的，

831
00:43:20,590 --> 00:43:22,260
我强烈推荐这个网站。

832
00:43:22,260 --> 00:43:24,110
这很棒。

833
00:43:24,110 --> 00:43:25,620
有一吨的东西。

834
00:43:25,620 --> 00:43:30,550
如此，以同样的方式，我们不得不
一些UPDATE，DELETE非常相似。

835
00:43:30,550 --> 00:43:33,800
相反，我们已经删除的数据。

836
00:43:33,800 --> 00:43:37,506
因此，在这种情况下，我们最后一次
1，我会写下来。

837
00:43:37,506 --> 00:43:38,880
比方说，我们要删除我。

838
00:43:38,880 --> 00:43:44,670

839
00:43:44,670 --> 00:43:48,750
我今天不写。

840
00:43:48,750 --> 00:43:51,720
从DELETE什么
表中我们在，数据。

841
00:43:51,720 --> 00:43:56,160

842
00:43:56,160 --> 00:44:02,128
而实际上有三种方式
我们可以选择删除我。

843
00:44:02,128 --> 00:44:06,040

844
00:44:06,040 --> 00:44:09,780
>> 你们能告诉我是什么3
方法是，你怎么可以删除吗？

845
00:44:09,780 --> 00:44:12,880

846
00:44:12,880 --> 00:44:15,400
ID等于1，其中ID等于1。

847
00:44:15,400 --> 00:44:19,470
我们可以在那里做一年等于
15，或者名称等于佳佳。

848
00:44:19,470 --> 00:44:21,540
当然，只有
三种不同的方法，

849
00:44:21,540 --> 00:44:24,570
因为这些都是唯一的。

850
00:44:24,570 --> 00:44:28,000
通常，在你的餐桌，
特别是在你的pset中，

851
00:44:28,000 --> 00:44:32,105
你要设定的一个
这些列是唯一的。

852
00:44:32,105 --> 00:44:36,252
>> 它可能会是一些独特的ID
数，因为如果你have--实际上，

853
00:44:36,252 --> 00:44:37,710
它实际上可能会让你有两个。

854
00:44:37,710 --> 00:44:40,520
我不记得是否会让
你有两个同样的事情。

855
00:44:40,520 --> 00:44:42,000
>> 听众：那就
改变自己的行为。

856
00:44:42,000 --> 00:44:43,291
>> ALLISON BUCHHOLTZ-AU：会。

857
00:44:43,291 --> 00:44:46,280
这将导致行为是意外，
你不能真正预测。

858
00:44:46,280 --> 00:44:53,040
所以，你一定会有一列
在数据库中，这将是唯一的，

859
00:44:53,040 --> 00:44:55,760
并且它通常可以设置
它，使它像一个唯一的ID，

860
00:44:55,760 --> 00:44:59,884
它只是每次更新
一次插入到表中。

861
00:44:59,884 --> 00:45:02,050
创建一个新的任何时间
行，它会自动

862
00:45:02,050 --> 00:45:04,190
增加并给它一些独特的ID。

863
00:45:04,190 --> 00:45:05,960
因此，提示您PSET。

864
00:45:05,960 --> 00:45:08,560

865
00:45:08,560 --> 00:45:09,160
行。

866
00:45:09,160 --> 00:45:11,575
所以这是SQL。

867
00:45:11,575 --> 00:45:18,170

868
00:45:18,170 --> 00:45:22,140
>> 所以，现在我们要谈
在最后的事情，这关系在

869
00:45:22,140 --> 00:45:24,770
实际上相当不错的
PSET，是否会勇往直前。

870
00:45:24,770 --> 00:45:28,210
所以MVC，模型视图控制器。

871
00:45:28,210 --> 00:45:32,480
这其实只是一种方式
以保持组织的事情。

872
00:45:32,480 --> 00:45:36,910
以同样的方式使用C，我们问你们
创建函数和不同的东西

873
00:45:36,910 --> 00:45:42,350
出，这仅仅是一种方法，分离出
代码时，你在做web开发。

874
00:45:42,350 --> 00:45:46,850
>> 因此，它使事情变得
更优雅和简化，

875
00:45:46,850 --> 00:45:49,310
这实际上是方式
您PSET实际上是

876
00:45:49,310 --> 00:45:52,460
成立，所以无论你喜欢
还是不行，你要了解它，

877
00:45:52,460 --> 00:45:54,251
即使你不觉得
你在学习它。

878
00:45:54,251 --> 00:45:56,580

879
00:45:56,580 --> 00:46:01,950
还有一件事是，它也可以让你
做更像是一个用户协作。

880
00:46:01,950 --> 00:46:05,770
>> 所以，当我把CS50，我做了
网站为我最后的项目，

881
00:46:05,770 --> 00:46:09,190
我当时想，我会
处理数据库的东西。

882
00:46:09,190 --> 00:46:12,450
我会做后台的东西，和我
室友我是谁带走了

883
00:46:12,450 --> 00:46:14,270
很艺术气息。

884
00:46:14,270 --> 00:46:17,370
她做舞台设计，和她
想让这一切漂亮。

885
00:46:17,370 --> 00:46:18,435
所以我想，OK。

886
00:46:18,435 --> 00:46:20,310
你可以照顾
所有前端的东西。

887
00:46:20,310 --> 00:46:22,660
>> 而事实是，作为
我们将看到很快，

888
00:46:22,660 --> 00:46:26,130
该模型视图控制器可以让你
完全独立的代码，​​以便

889
00:46:26,130 --> 00:46:29,260
我可以工作
实现我们的网页，

890
00:46:29,260 --> 00:46:31,266
和操作信息
在我们的数据库中，

891
00:46:31,266 --> 00:46:34,140
她可能只是把事情
漂亮，我们都非常高兴，

892
00:46:34,140 --> 00:46:36,750
因为我们必须做什么
我们都希望我们

893
00:46:36,750 --> 00:46:38,400
没有要处理的另一个。

894
00:46:38,400 --> 00:46:40,377
>> 因此，我们挂出了一起。

895
00:46:40,377 --> 00:46:41,210
我们喜欢挂出。

896
00:46:41,210 --> 00:46:45,649
我只是不想对付
所有的CSS和HTML的东西。

897
00:46:45,649 --> 00:46:46,940
我当时想，你把它漂亮。

898
00:46:46,940 --> 00:46:49,420
我会处理数据库。

899
00:46:49,420 --> 00:46:52,620
因此，我们有这个真
酷，伟大的小桌子。

900
00:46:52,620 --> 00:46:55,440
我爱表。

901
00:46:55,440 --> 00:46:59,680
基本上，该模型可以
想想就是你的数据库。

902
00:46:59,680 --> 00:47:03,630
>> 我是该模型的人对我的项目。

903
00:47:03,630 --> 00:47:06,800
这是所有关于的存储
信息和组织数据。

904
00:47:06,800 --> 00:47:09,790
所以，这是我们喜欢称之为后端。

905
00:47:09,790 --> 00:47:13,260
所以，你们将处理
SQL数据库和数据文件。

906
00:47:13,260 --> 00:47:14,650
这是你的模型。

907
00:47:14,650 --> 00:47:17,800
>> 你看，你可能会
想种是有道理的，

908
00:47:17,800 --> 00:47:20,610
是你的用户实际看到的。

909
00:47:20,610 --> 00:47:22,110
它的用户界面。

910
00:47:22,110 --> 00:47:24,359
那就是前置的组成部分。

911
00:47:24,359 --> 00:47:26,650
所以，这就是我的室友
还得上班，所有的时间。

912
00:47:26,650 --> 00:47:27,660
她是超级开心。

913
00:47:27,660 --> 00:47:31,580
所以这是所有的HTML，
而且有很少的PHP。

914
00:47:31,580 --> 00:47:34,420
>> 如果你只是在谈论
什么东西被显示给用户，

915
00:47:34,420 --> 00:47:36,576
我们谈论的超文本。

916
00:47:36,576 --> 00:47:37,950
我们谈论的是它的外观。

917
00:47:37,950 --> 00:47:41,400
我们现在谈论的不是逻辑，
或条件，或者诸如此类的东西。

918
00:47:41,400 --> 00:47:45,620
所有这一切都被处理
由控制器，OK？

919
00:47:45,620 --> 00:47:49,470
以便处理用户的请求
和获取的信息。

920
00:47:49,470 --> 00:47:54,750
>> 所以，有一件事你应该知道的
您PSET的是，在你的意见，

921
00:47:54,750 --> 00:47:57,650
任何事情，实际上是
显示信息

922
00:47:57,650 --> 00:48:00,530
绝不应使
调用模型。

923
00:48:00,530 --> 00:48:02,570
所有这一切都被处理
在您的控制器。

924
00:48:02,570 --> 00:48:06,950
控制器是一个
这两者之间调解。

925
00:48:06,950 --> 00:48:10,280
它会问模型
对于某些信息。

926
00:48:10,280 --> 00:48:12,610
它可以遍历了
信息，计算出

927
00:48:12,610 --> 00:48:15,110
你真正需要的
它，做它，

928
00:48:15,110 --> 00:48:17,860
然后它会传递
只是你的信息

929
00:48:17,860 --> 00:48:24,670
需要的视图为您打印
出来或者显示给用户，好不好？

930
00:48:24,670 --> 00:48:28,690
>> 因为我们看到的视图
无论是面向用户的，

931
00:48:28,690 --> 00:48:31,340
所以这将是更容易
他们想不通，

932
00:48:31,340 --> 00:48:34,980
哦，如果你正在做
一些呼叫模型

933
00:48:34,980 --> 00:48:39,152
而你要求所有用户
谁用字母A开始，

934
00:48:39,152 --> 00:48:41,985
和你做，在你看来，
任何人谁可以看到你的网页

935
00:48:41,985 --> 00:48:43,350
可能访问。

936
00:48:43,350 --> 00:48:44,740
>> 你不一定想要的。

937
00:48:44,740 --> 00:48:48,560
你不希望别人看到
更多到数据库比

938
00:48:48,560 --> 00:48:49,800
他们应该看到的。

939
00:48:49,800 --> 00:48:51,560
只是他们的具体优惠。

940
00:48:51,560 --> 00:48:53,840
因此，控制器处理所有这一切。

941
00:48:53,840 --> 00:48:59,800
所以，所有的.php文件的，我们可以看到
你可以考虑你的控制器文件。

942
00:48:59,800 --> 00:49:02,710
而这也正是你
真的是

943
00:49:02,710 --> 00:49:06,500
要求从数据库的东西，
和迭代或操作

944
00:49:06,500 --> 00:49:10,670
它需要前
传递上进行观看。

945
00:49:10,670 --> 00:49:12,830
>> 这是一个非常酷的pset，在我看来。

946
00:49:12,830 --> 00:49:15,580
我认为这是一个多一点
喜欢即时的满足感，

947
00:49:15,580 --> 00:49:17,990
因为你实现
很多小的小东西，

948
00:49:17,990 --> 00:49:20,250
和每一件事情应该在自己的。

949
00:49:20,250 --> 00:49:24,180
不喜欢，做的一切
再看看它的工作原理。

950
00:49:24,180 --> 00:49:26,570
类似的软件
在那里你喜欢，我

951
00:49:26,570 --> 00:49:28,910
真希望这是
正确的，因为如果它不，

952
00:49:28,910 --> 00:49:30,743
有很多的
地方，它可能是错误的。

953
00:49:30,743 --> 00:49:34,220

954
00:49:34,220 --> 00:49:35,110
>> 行。

955
00:49:35,110 --> 00:49:39,744
只是要确保我说
一切我需要说一下MVC。

956
00:49:39,744 --> 00:49:40,680
是啊。

957
00:49:40,680 --> 00:49:41,347
凉爽。

958
00:49:41,347 --> 00:49:47,340
>> 因此，在CS50金融，我们有
我们的模型，因为我只是在这里说。

959
00:49:47,340 --> 00:49:51,810
这将是MySQL和phpMyAdmin的。

960
00:49:51,810 --> 00:49:55,130
我可以肯定的拉了这么
你们有机会来看待它。

961
00:49:55,130 --> 00:49:59,250
就像我之前说的，它的SQL
数据库作为模型，

962
00:49:59,250 --> 00:50:03,600
您可以发送我们所说的查询，
这只是这类事情。

963
00:50:03,600 --> 00:50:04,914
这些被称为查询。

964
00:50:04,914 --> 00:50:07,830
这是一个查询，在这里你只是
询问你的数据库的东西，

965
00:50:07,830 --> 00:50:09,810
或者你改变你
数据库中的一些方式。

966
00:50:09,810 --> 00:50:11,470
这就是它。

967
00:50:11,470 --> 00:50:16,040
而你这样做的
的功能，我们在这里给你。

968
00:50:16,040 --> 00:50:20,500
>> 您也可以操纵
他们用手通过phpMyAdmin的，

969
00:50:20,500 --> 00:50:22,170
这是我们绝对可以一起来看看。

970
00:50:22,170 --> 00:50:25,160
我将创建一个示例
数据库与你们。

971
00:50:25,160 --> 00:50:25,660
行。

972
00:50:25,660 --> 00:50:26,680
因此，控制器。

973
00:50:26,680 --> 00:50:30,730
所以在这种情况下，如果
通知，这是所有PHP。

974
00:50:30,730 --> 00:50:33,430
请注意这是一种你
控制器的主要的东西

975
00:50:33,430 --> 00:50:35,410
是，它应该是大部分的PHP。

976
00:50:35,410 --> 00:50:39,590
如果你在你的控制器有HTML，
真的不知道发生了什么事情在那里。

977
00:50:39,590 --> 00:50:42,495
以同样的方式正如我所说，如果你
设法[听不清]使用HTML，

978
00:50:42,495 --> 00:50:43,810
我真正的兴趣。

979
00:50:43,810 --> 00:50:49,150
>> 所以，我们在这里
是你有一些查询。

980
00:50:49,150 --> 00:50:53,700
查询是一个函数，该函数
我们为你打造的家伙。

981
00:50:53,700 --> 00:50:56,935
这就像一个包装进行查询
为你的数据库更容易一些。

982
00:50:56,935 --> 00:51:01,441
如果你没有这个，语法
其实说你的SQL数据库

983
00:51:01,441 --> 00:51:03,690
会是不同的，所以我们
只是提供给你的家伙。

984
00:51:03,690 --> 00:51:05,490
我们喜欢让生活轻松。

985
00:51:05,490 --> 00:51:09,050
>> 所以在这种情况下，可以你们
告诉我这条线是干什么的？

986
00:51:09,050 --> 00:51:11,860

987
00:51:11,860 --> 00:51:13,487
SELECT * FROM一些表。

988
00:51:13,487 --> 00:51:15,320
听众：选择
一切从该表中。

989
00:51:15,320 --> 00:51:16,570
ALLISON BUCHHOLTZ-AU：没错。

990
00:51:16,570 --> 00:51:18,750
因此，它说，给我
一切从该表中。

991
00:51:18,750 --> 00:51:22,430
和它的将其存储在
一些变量的结果。

992
00:51:22,430 --> 00:51:27,720
这表示，如果结果不等于
为false，那么我们做的每本。

993
00:51:27,720 --> 00:51:32,390
因此，如果没有什么在这里，如果你的
表的空或者根本就不存在，

994
00:51:32,390 --> 00:51:33,640
它会返回false。

995
00:51:33,640 --> 00:51:36,431
因此，在这种情况下，我们要做的仅仅是
肯定的东西竟是

996
00:51:36,431 --> 00:51:37,520
还给我们。

997
00:51:37,520 --> 00:51:40,070
>> 然后在这里，我们有
我们伟大的foreach循环

998
00:51:40,070 --> 00:51:44,380
我们正在遍历我们
因此，我们管这叫行，

999
00:51:44,380 --> 00:51:51,080
和我们说使这个模板
在您的数据是这样的结果。

1000
00:51:51,080 --> 00:51:52,170
行？

1001
00:51:52,170 --> 00:51:54,440
所以它只是处理
结果的行。

1002
00:51:54,440 --> 00:51:56,790
否则，就破口大骂。

1003
00:51:56,790 --> 00:51:59,770
所以，这是一个例子
控制器。

1004
00:51:59,770 --> 00:52:02,842
正如你看到的，这是
只有place--呀，不好意思？

1005
00:52:02,842 --> 00:52:04,960
>> 听众：为什么会出现
前行的符号？

1006
00:52:04,960 --> 00:52:07,000
>> ALLISON BUCHHOLTZ-AU：
前行的符号。

1007
00:52:07,000 --> 00:52:11,000
我们只是遍历。

1008
00:52:11,000 --> 00:52:13,490
这也是一个地址of--

1009
00:52:13,490 --> 00:52:16,400
>> 听众：所以这是像C引用。

1010
00:52:16,400 --> 00:52:22,080
>> ALLISON BUCHHOLTZ-AU：这是
确保你真正

1011
00:52:22,080 --> 00:52:24,730
修改原始而不是复印件。

1012
00:52:24,730 --> 00:52:28,580
它们也以同样的方式与C，其中
我们通过引用传递在这里，只

1013
00:52:28,580 --> 00:52:30,449
确保。

1014
00:52:30,449 --> 00:52:33,530
>> 听众：这难道不是==
而不是不等于在PHP？

1015
00:52:33,530 --> 00:52:35,400
>> ALLISON BUCHHOLTZ-AU：这不是==。

1016
00:52:35,400 --> 00:52:37,240
>> 听众：因为等于在C是just--

1017
00:52:37,240 --> 00:52:37,970
>> ALLISON BUCHHOLTZ-AU：这只是不是=。

1018
00:52:37,970 --> 00:52:38,470
是啊，没有。

1019
00:52:38,470 --> 00:52:39,656
这不是==。

1020
00:52:39,656 --> 00:52:45,610
==因为在PHP中检查
平等的来回切换，理所当然的，

1021
00:52:45,610 --> 00:52:47,650
但额外的质量。

1022
00:52:47,650 --> 00:52:51,050
因此，它不是== PHP中。

1023
00:52:51,050 --> 00:52:53,025
这是一个小的一个
语法差异。

1024
00:52:53,025 --> 00:52:55,330

1025
00:52:55,330 --> 00:52:55,830
是啊。

1026
00:52:55,830 --> 00:52:57,538
所以，我们只是遍历
通过每一行，

1027
00:52:57,538 --> 00:53:00,850
和渲染，如果你们
通读你的天赋，

1028
00:53:00,850 --> 00:53:05,360
仅仅是一些其他功能即
究竟要处理所有的HTML

1029
00:53:05,360 --> 00:53:09,760
并显示在您的
Web浏览器为您服务。

1030
00:53:09,760 --> 00:53:10,610
>> 行。

1031
00:53:10,610 --> 00:53:15,360
所以，我们喜欢把你的控制器
正如处理业务逻辑。

1032
00:53:15,360 --> 00:53:18,550
正如你在这里看到，这就是我们
从表中我们取数据，

1033
00:53:18,550 --> 00:53:23,530
我们正在处理它以某种方式
然后我们通过它关闭。

1034
00:53:23,530 --> 00:53:27,930
当我们做一些渲染模板，
有些模板是我们的看法，

1035
00:53:27,930 --> 00:53:31,810
而我们只是传递
它应该获取数据。

1036
00:53:31,810 --> 00:53:33,340
不是所有的数据。

1037
00:53:33,340 --> 00:53:35,340
只是我们希望它来获取数据。

1038
00:53:35,340 --> 00:53:37,520
行？

1039
00:53:37,520 --> 00:53:40,270
基本处理后的数据。

1040
00:53:40,270 --> 00:53:44,780
>> 因此，这是认为，这是
总和的模板，我们有，

1041
00:53:44,780 --> 00:53:49,810
而这一切正在做的是，你可以
有一点PHP中的视图。

1042
00:53:49,810 --> 00:53:52,620
它不象在视图中没有PHP。

1043
00:53:52,620 --> 00:53:55,650
你应该有
很鉴于最小的PHP，

1044
00:53:55,650 --> 00:53:58,860
你永远不应该
查询您的观点。

1045
00:53:58,860 --> 00:54:01,580
你不应该说的
您在您的视图的数据库。

1046
00:54:01,580 --> 00:54:02,760
这就是很大的区别。

1047
00:54:02,760 --> 00:54:07,886
>> 那么，什么是怎么回事是，我们有
PHP中的通过连续迭代。

1048
00:54:07,886 --> 00:54:10,260
所以在这种情况下，因为我们
通过每一行进行迭代

1049
00:54:10,260 --> 00:54:14,370
和呈现的东西，这是
大概像的二维阵列

1050
00:54:14,370 --> 00:54:18,240
在这里我们有一些列的
是，在本身，数组

1051
00:54:18,240 --> 00:54:20,520
因为我们遍历
通过它一次。

1052
00:54:20,520 --> 00:54:26,730
而我们只是打印出
该行的名称，然后结束。

1053
00:54:26,730 --> 00:54:28,470
>> 你不应该在foreach需要这个。

1054
00:54:28,470 --> 00:54:30,560
我从来没有看到过实际。

1055
00:54:30,560 --> 00:54:33,160
我只是做的foreach。

1056
00:54:33,160 --> 00:54:35,140
好了，这就是视图。

1057
00:54:35,140 --> 00:54:40,170
让我们看看我们是否能够穿行
您PSET一点点。

1058
00:54:40,170 --> 00:54:45,380
我们有15分钟，所以我敢肯定你
男人想的不仅仅是更多

1059
00:54:45,380 --> 00:54:45,935
提前结束。

1060
00:54:45,935 --> 00:54:48,980

1061
00:54:48,980 --> 00:54:52,680
让我看看，如果我能提这件事。

1062
00:54:52,680 --> 00:54:57,130
>> 所以我不知道有多少你们的
已经下载了它和诸如此类的东西呢，

1063
00:54:57,130 --> 00:55:00,660
但我们这里的用户名，
而且我们有一些密码。

1064
00:55:00,660 --> 00:55:05,310
不幸的是，右
现在的数据库是空的，

1065
00:55:05,310 --> 00:55:10,390
所以我们实际上需要
创建一个数据库。

1066
00:55:10,390 --> 00:55:13,470
嗯，这是奇怪的。

1067
00:55:13,470 --> 00:55:14,450
没想到的是。

1068
00:55:14,450 --> 00:55:15,375
技术错误。

1069
00:55:15,375 --> 00:55:17,139
技术上的困难。

1070
00:55:17,139 --> 00:55:17,930
我们有一些pset7。

1071
00:55:17,930 --> 00:55:22,470

1072
00:55:22,470 --> 00:55:23,180
凉爽。

1073
00:55:23,180 --> 00:55:29,660
>> 所以，有一件事你可以做的是，用
一个query--我将创建一个表。

1074
00:55:29,660 --> 00:55:38,570
因此，这将是users--什么
您可以在这里做的是，如果我们有some--

1075
00:55:38,570 --> 00:55:39,830
真的吗？

1076
00:55:39,830 --> 00:55:40,330
行。

1077
00:55:40,330 --> 00:55:44,510
很显然，我没有做这么热。

1078
00:55:44,510 --> 00:55:45,010
呵呵。

1079
00:55:45,010 --> 00:55:45,740
我知道为什么。

1080
00:55:45,740 --> 00:55:49,070
因为我从来没有创建
我的实际表。

1081
00:55:49,070 --> 00:55:52,400
所以，当你第一次开始
一个数据库，你明明

1082
00:55:52,400 --> 00:55:56,550
必须决定哪些
事情我需要在这里？

1083
00:55:56,550 --> 00:56:00,850
>> 因此，如果我们只是去关闭
我们的数据表在这里，

1084
00:56:00,850 --> 00:56:06,410
我们有一些ID，这
可以只留一个int。

1085
00:56:06,410 --> 00:56:12,460
如果我们看过来，有
一件很酷的事情that--所以指数。

1086
00:56:12,460 --> 00:56:18,060
如果你这样做的主，这将使其成为
你的表是由组织的事情，

1087
00:56:18,060 --> 00:56:19,410
它也将使其具有唯一性。

1088
00:56:19,410 --> 00:56:25,790
因此，在这种情况下，我们将使它小学，
我要去，使这个名字，

1089
00:56:25,790 --> 00:56:34,500
那么我们就让它一个varchar
就像26个字母，因为为什么不呢？

1090
00:56:34,500 --> 00:56:39,060
>> 然后你可以去保存，然后
如果你看到，我们有一些用户在这里。

1091
00:56:39,060 --> 00:56:42,950
因此，如果我们想要做的
插入，我们可以做到这一点

1092
00:56:42,950 --> 00:56:51,807
这样一来，如果你想练习
您queries--哦男孩。

1093
00:56:51,807 --> 00:56:53,140
我没有用过这个天长地久。

1094
00:56:53,140 --> 00:56:53,980
我想借此回来。

1095
00:56:53,980 --> 00:56:57,620

1096
00:56:57,620 --> 00:57:04,030
>> 您可以编辑这个在自己任
仅仅通过手动插入的信息

1097
00:57:04,030 --> 00:57:08,270
有像你
可以更改这些

1098
00:57:08,270 --> 00:57:13,730
如果你想make--如果你想
突然改掉名字，你可以删除，

1099
00:57:13,730 --> 00:57:15,220
你可以做所有这些事情。

1100
00:57:15,220 --> 00:57:17,560
如果你需要不断
手动更改表，

1101
00:57:17,560 --> 00:57:20,200
我建议这样做的
phpMyAdmin的尝试与

1102
00:57:20,200 --> 00:57:24,475
找出SQL
查询一般。

1103
00:57:24,475 --> 00:57:27,350
当你第一次启动PSET，
你将要在这里工作，

1104
00:57:27,350 --> 00:57:29,650
所以就习惯了。

1105
00:57:29,650 --> 00:57:35,650
然后，当你真正想要
插入的东西进入你的table--

1106
00:57:35,650 --> 00:57:38,310
我真的不知道在哪里也就是说，
因为there's--在这里。

1107
00:57:38,310 --> 00:57:39,310
这就是我想要的。

1108
00:57:39,310 --> 00:57:44,320
所以，如果你去到SQL，你可以
实际看到，我们在这里看到，

1109
00:57:44,320 --> 00:57:45,870
我们的SQL查询。

1110
00:57:45,870 --> 00:57:54,100
>> 因此，如果我们想要选择的东西
或者，如果我们想插入的东西，

1111
00:57:54,100 --> 00:58:00,320
我们可以做插入到用户的，对不对？

1112
00:58:00,320 --> 00:58:04,460

1113
00:58:04,460 --> 00:58:07,230
我认为你需要的反斜杠。

1114
00:58:07,230 --> 00:58:10,210
有一点需要知道的是，如果
你曾经用这个，

1115
00:58:10,210 --> 00:58:14,800
你必须使用这些背
撇号，这是典型的，

1116
00:58:14,800 --> 00:58:16,790
如果你是一个Mac上，正上方标签。

1117
00:58:16,790 --> 00:58:17,840
所以，好东西就知道了。

1118
00:58:17,840 --> 00:58:23,330
>> 你可以插入到用户，
我们有我们的价值观，对不对？

1119
00:58:23,330 --> 00:58:29,700
因此，我们有价值观，我们的价值观
在这种情况下，也只是，

1120
00:58:29,700 --> 00:58:33,910
我们只有一个ID，所以我们
可以做一个，如果我们想要的。

1121
00:58:33,910 --> 00:58:35,320
这是奇怪的。

1122
00:58:35,320 --> 00:58:36,730
行。

1123
00:58:36,730 --> 00:58:41,800
所以，这就像一个简短的
小东西用SQL，

1124
00:58:41,800 --> 00:58:48,300
但也可能是更有益的实际
看一些文件在这里。

1125
00:58:48,300 --> 00:58:50,985
>> 所以去下载。

1126
00:58:50,985 --> 00:58:51,950
哦，不是下载。

1127
00:58:51,950 --> 00:58:55,260

1128
00:58:55,260 --> 00:58:58,690
如此，只是走马观花
什么是在这些文件夹中。

1129
00:58:58,690 --> 00:59:03,090
它包括，我们只是有事情
该配置浏览器，

1130
00:59:03,090 --> 00:59:05,370
我们有这些常量，
我们有这些功能。

1131
00:59:05,370 --> 00:59:10,470
如果你感兴趣的任何人，
我建议在看功能。

1132
00:59:10,470 --> 00:59:17,400
其中一人说是超级有用，
其实这是一个在这里，转储。

1133
00:59:17,400 --> 00:59:20,020
>> 如果你使用这个的话，
它实际上只是

1134
00:59:20,020 --> 00:59:23,120
打印出的任何变量
你喜欢它。

1135
00:59:23,120 --> 00:59:29,000
所以，如果你有麻烦搞清楚
什么这个数组的样子，

1136
00:59:29,000 --> 00:59:31,920
或者究竟这个数据，
它是如何格式化的，

1137
00:59:31,920 --> 00:59:33,280
这是一个伟大的事情来使用。

1138
00:59:33,280 --> 00:59:39,889
尤其是当你有一个
用户拥有多个股票，

1139
00:59:39,889 --> 00:59:41,680
这将是
一些伟大的事情来使用。

1140
00:59:41,680 --> 00:59:42,890
因为它可能是formatted--

1141
00:59:42,890 --> 00:59:45,806
>> 我知道，至少对我来说，当我做了
这PSET，它是格式化的方式

1142
00:59:45,806 --> 00:59:47,210
我没太想到。

1143
00:59:47,210 --> 00:59:49,960
所以我想遍历
它并试图操纵它，

1144
00:59:49,960 --> 00:59:52,350
但我真的不
知道我在做什么。

1145
00:59:52,350 --> 00:59:56,830
所以，如果你只是放弃它，它会
打印出来的浏览器，

1146
00:59:56,830 --> 00:59:59,220
你可以清楚地看到
它是如何格式化的。

1147
00:59:59,220 --> 01:00:03,530
它通常会打印出来作为
数组的键和值。

1148
01:00:03,530 --> 01:00:04,637
所以，它可以帮助那里。

1149
01:00:04,637 --> 01:00:06,720
它也有助于使
确保你真正

1150
01:00:06,720 --> 01:00:09,070
抓住数据
你以为你是。

1151
01:00:09,070 --> 01:00:12,950
所以，如果你是喜欢我的表肯定
说，有这个ID的用户，

1152
01:00:12,950 --> 01:00:15,260
但是当你去到转储
可变的，它不存在，

1153
01:00:15,260 --> 01:00:17,551
你明明知道这是
其中，一个错误将是。

1154
01:00:17,551 --> 01:00:22,180
这是最好的工具之一
进行调试，在我看来。

1155
01:00:22,180 --> 01:00:24,480
然后还有一个
情侣在这里其他的事情，

1156
01:00:24,480 --> 01:00:27,660
但在大多数情况下，这就是
一个我想请你注意，

1157
01:00:27,660 --> 01:00:31,060
因为它是非常有帮助的。

1158
01:00:31,060 --> 01:00:35,800
>> 公众，我们在这里是，
这是我们所有的CSS的东西。

1159
01:00:35,800 --> 01:00:40,520
所以，CSS，字体，我们的图像，诸如此类的东西。

1160
01:00:40,520 --> 01:00:43,255
这是所有的东西，
你不必修改。

1161
01:00:43,255 --> 01:00:46,070

1162
01:00:46,070 --> 01:00:50,080
你们可以想一想，如果这
有东西像CSS中的字体，

1163
01:00:50,080 --> 01:00:54,039
这将是一个模型，或
的图，或一个控制器？

1164
01:00:54,039 --> 01:00:54,914
听众：[听不清]

1165
01:00:54,914 --> 01:00:57,080
ALLISON BUCHHOLTZ-AU：它会
多出一个观点，对不对？

1166
01:00:57,080 --> 01:01:00,510
这是处理所有
的事情，事情怎么看。

1167
01:01:00,510 --> 01:01:03,500
因此，如果我们打开这个在这里，我们看到
这一切的发生在这里

1168
01:01:03,500 --> 01:01:05,060
为我们呈现的东西。

1169
01:01:05,060 --> 01:01:05,820
行？

1170
01:01:05,820 --> 01:01:09,710
因此，这将非常
有资格作为此一观点。

1171
01:01:09,710 --> 01:01:14,810
所以这只是服用了一些，
它是调用一些portfolio.php

1172
01:01:14,810 --> 01:01:19,430
我们有，它的传递
在标题和投资组合。

1173
01:01:19,430 --> 01:01:20,696
它只是渲染。

1174
01:01:20,696 --> 01:01:21,820
其实，我收回那句话。

1175
01:01:21,820 --> 01:01:27,890
这是一个控制器，因为
渲染，记住，呈现视图。

1176
01:01:27,890 --> 01:01:30,832
所以在这个portfolio.php
情况是你的看法。

1177
01:01:30,832 --> 01:01:32,480
对不起，伙计们。

1178
01:01:32,480 --> 01:01:36,160
Portfolio.php将是
你的看法，而这也只是

1179
01:01:36,160 --> 01:01:38,730
是你的控制器的。

1180
01:01:38,730 --> 01:01:43,120
如果我们看看这个
这里最后一个，模板，

1181
01:01:43,120 --> 01:01:47,330
模板是您所有的意见在这里。

1182
01:01:47,330 --> 01:01:52,420
因此，如果我们看一下，很明显
我们看到很多的HTML这里。

1183
01:01:52,420 --> 01:01:58,920
>> 所以，这一次只是向你展示什么
登录页面应该是什么样子。

1184
01:01:58,920 --> 01:02:04,810
你注意到我们有一些
表单组，具有提交。

1185
01:02:04,810 --> 01:02:08,510
这里是你如何决定什么
被显示在那里。

1186
01:02:08,510 --> 01:02:14,320
你有一些按钮类型=“提交”，
然后你有你想要的

1187
01:02:14,320 --> 01:02:16,670
在按钮来显示。

1188
01:02:16,670 --> 01:02:19,860
这就是你如何让
显示为任何你想。

1189
01:02:19,860 --> 01:02:24,520
>> 我们在这里看到我们有一些
用户名，密码的部分，

1190
01:02:24,520 --> 01:02:30,590
而当我们真正点击提交，
这将是一些后，

1191
01:02:30,590 --> 01:02:33,346
并且它会发布些什么？

1192
01:02:33,346 --> 01:02:35,430
什么是控制器的这种观点？

1193
01:02:35,430 --> 01:02:38,040

1194
01:02:38,040 --> 01:02:40,940
当我们点击提交，
这是怎么回事要叫什么名字？

1195
01:02:40,940 --> 01:02:42,990
我们知道吗？

1196
01:02:42,990 --> 01:02:45,560
就是这里，所以login.php中。

1197
01:02:45,560 --> 01:02:47,600
东西你们是
要实现。

1198
01:02:47,600 --> 01:02:50,580
>> 所以，你总是可以告诉
这是怎么回事是

1199
01:02:50,580 --> 01:02:53,740
叫你打后提交
通过在这里的第一线。

1200
01:02:53,740 --> 01:02:55,440
什么形式的行动。

1201
01:02:55,440 --> 01:02:58,350
当这个表单被提交，
什么样的行动，我们走？

1202
01:02:58,350 --> 01:03:01,440
我们呼吁的login.php，我们
用这种方法称之为

1203
01:03:01,440 --> 01:03:05,500
后，其中有
隐藏的信息。

1204
01:03:05,500 --> 01:03:06,210
行？

1205
01:03:06,210 --> 01:03:14,485
因此，这是你的看法，然后很明显
如果我们去login.php--我们有它

1206
01:03:14,485 --> 01:03:16,025
没有？

1207
01:03:16,025 --> 01:03:17,970
是啊。

1208
01:03:17,970 --> 01:03:21,950
>> 所以，我们在这里看到，这
有很多更多的逻辑。

1209
01:03:21,950 --> 01:03:23,570
这是我们所有的PHP在这里。

1210
01:03:23,570 --> 01:03:28,870
我们正在努力，看看它是否是$ _GET，
如果是$ _ POST，验证的东西，

1211
01:03:28,870 --> 01:03:31,370
查询，所有这些东西。

1212
01:03:31,370 --> 01:03:34,950

1213
01:03:34,950 --> 01:03:40,200
因此，那些都只是三
在这里不同的事情。

1214
01:03:40,200 --> 01:03:43,750
你不必改变的事情。

1215
01:03:43,750 --> 01:03:46,540
你会创造一些东西
在模板中，可能的话，

1216
01:03:46,540 --> 01:03:51,350
但据的HTML或
任何本云的造型，

1217
01:03:51,350 --> 01:03:54,550
你可以把它当作普通的或
作为复杂的，只要你愿意。

1218
01:03:54,550 --> 01:03:59,800
>> 有些人会真正进入它，
做一些漂亮的真棒网站。

1219
01:03:59,800 --> 01:04:00,940
你不必这样做。

1220
01:04:00,940 --> 01:04:03,750
如果你有时间，这是
一个非常酷的事情。

1221
01:04:03,750 --> 01:04:08,260
您可以更动CSS和HTML
并获得一个更好的感觉了，

1222
01:04:08,260 --> 01:04:10,810
但不要感到有压力，。

1223
01:04:10,810 --> 01:04:14,760
还有很多为你做的
后端与实施登陆，

1224
01:04:14,760 --> 01:04:17,170
并注册，以及所有这些事情。

1225
01:04:17,170 --> 01:04:20,490
>> 所以希望帮助一点点。

1226
01:04:20,490 --> 01:04:23,430
做你们有任何问题，
任何事情，我们已经走了过来，

1227
01:04:23,430 --> 01:04:25,690
任何其他资源呢？

1228
01:04:25,690 --> 01:04:31,160
我一定把所有的
我的例子PHP代码你们，

1229
01:04:31,160 --> 01:04:35,020
然后随意拿
图片或本诸如此类的东西。

1230
01:04:35,020 --> 01:04:36,180
另外它的在线。

1231
01:04:36,180 --> 01:04:39,010
你永远可以观看了。

1232
01:04:39,010 --> 01:04:42,190
所以，如果是这样的话，每个人都好？

1233
01:04:42,190 --> 01:04:42,690
是。

1234
01:04:42,690 --> 01:04:44,523
>> 观众：我只是想
确认，当我们

1235
01:04:44,523 --> 01:04:47,447
在做选择在SQL中，
星意味着一切，对吧？

1236
01:04:47,447 --> 01:04:48,530
ALLISON BUCHHOLTZ-AU：是的。

1237
01:04:48,530 --> 01:04:50,446
听众：然后，如果
你不必明星，

1238
01:04:50,446 --> 01:04:53,732
如果你想让它把从一个特定的
行，那么你只要把名字of--

1239
01:04:53,732 --> 01:04:55,440
ALLISON BUCHHOLTZ-AU：
行的名称

1240
01:04:55,440 --> 01:04:56,240
你想你想的价值是什么。

1241
01:04:56,240 --> 01:04:57,577
>> 听众：然后日期。

1242
01:04:57,577 --> 01:04:59,910
ALLISON BUCHHOLTZ-AU：无论
你要找的，是的。

1243
01:04:59,910 --> 01:05:05,100
以同样的方式，如果你做DELETE * FROM
一些表，它会删除一切。

1244
01:05:05,100 --> 01:05:08,896
因此，*只是一个野性
卡的一切。

1245
01:05:08,896 --> 01:05:09,788
>> 听众：OK。

1246
01:05:09,788 --> 01:05:10,930
>> ALLISON BUCHHOLTZ-AU：酷。

1247
01:05:10,930 --> 01:05:11,430
真棒。

1248
01:05:11,430 --> 01:05:12,800
嗯，有一个伟大的周一，伙计们。

1249
01:05:12,800 --> 01:05:13,760
我会看到你下周。

1250
01:05:13,760 --> 01:05:15,530
祝你PSET。

1251
01:05:15,530 --> 01:05:16,992