1
00:00:00,000 --> 00:00:00,500

2
00:00:00,500 --> 00:00:10,960
[音乐播放]

3
00:00:10,960 --> 00:00:12,960
ROGER ZURAWICKI：嗨，我
名字是罗杰Zurawicki，

4
00:00:12,960 --> 00:00:16,410
我将涵盖
在CS50流星研讨会。

5
00:00:16,410 --> 00:00:21,520
流星是一个新的框架
致力于新种类的网络的，

6
00:00:21,520 --> 00:00:25,220
不是PHP发出请求
来回种类

7
00:00:25,220 --> 00:00:29,070
网络，我们在PHPP集看到，
但更多的动态JavaScript

8
00:00:29,070 --> 00:00:31,370
份纤维网的。

9
00:00:31,370 --> 00:00:36,260
流星的事情可以做
包括现场更新

10
00:00:36,260 --> 00:00:42,380
并立即沟通
同一个网站的用户之间。

11
00:00:42,380 --> 00:00:46,420
>> 对于本次研讨会，我们有
代码托管在GitHub上我。

12
00:00:46,420 --> 00:00:49,690
你可以去这个网址并下载。

13
00:00:49,690 --> 00:00:53,085
如果你知道如何使用Git的，
您可以克隆存储库。

14
00:00:53,085 --> 00:00:55,460
如果你不知道如何使用
Git的或没有使用GitHub上，

15
00:00:55,460 --> 00:00:57,030
这是完全没问题。

16
00:00:57,030 --> 00:01:00,480
我真的会迅速告诉你
我们如何可以去GitHub上，

17
00:01:00,480 --> 00:01:03,604
并有一个选项
下载一个ZIP就在那里。

18
00:01:03,604 --> 00:01:06,770
一旦你下载这个目录，你
可以开始使用我们的代码打。

19
00:01:06,770 --> 00:01:10,200

20
00:01:10,200 --> 00:01:13,190
>> 有关流星的更多信息
可以在meteor.com找到。

21
00:01:13,190 --> 00:01:16,580
在研讨会的文件夹，其实我
有一些流星的项目，我们可以使用。

22
00:01:16,580 --> 00:01:20,380

23
00:01:20,380 --> 00:01:26,400
一个我们在文件夹我们
研讨会项目是待办事项应用程序。

24
00:01:26,400 --> 00:01:28,780
所以，如果我走了进去我，
已安装流星。

25
00:01:28,780 --> 00:01:35,690
因此，要运行它，我只需要键入
流星，流星和将安装。

26
00:01:35,690 --> 00:01:38,310
正如你所看到的，我们必须要
确保我们安装流星。

27
00:01:38,310 --> 00:01:40,562
所以我只是要
运行一次

28
00:01:40,562 --> 00:01:42,520
确保流星
正确安装。

29
00:01:42,520 --> 00:01:46,370

30
00:01:46,370 --> 00:01:48,450
>> 虽然我有流星
安装，我可以告诉你

31
00:01:48,450 --> 00:01:53,760
流星网站的一些现场演示
去住，现在在互联网上。

32
00:01:53,760 --> 00:01:57,990
我有我们的应用程序的演示。

33
00:01:57,990 --> 00:02:00,740
您可以在以下网址访问它。

34
00:02:00,740 --> 00:02:06,350
这是做应用程序，我们
在我们的讲座目录。

35
00:02:06,350 --> 00:02:09,940
该网址是
rozu-rabbit.meteor.com。

36
00:02:09,940 --> 00:02:14,782
你会看到流星居然会
承载您的流星项目是免费的。

37
00:02:14,782 --> 00:02:17,490
并在研讨会结束时，
你就可以做到这一点。

38
00:02:17,490 --> 00:02:20,550

39
00:02:20,550 --> 00:02:22,160
>> 这是一个待办事项应用程序。

40
00:02:22,160 --> 00:02:27,740
你可以登录，创建
帐户，并添加任务。

41
00:02:27,740 --> 00:02:30,020
您可以创建一个帐户，像这样。

42
00:02:30,020 --> 00:02:33,050

43
00:02:33,050 --> 00:02:35,850
而现在，一旦你有一个
帐户，您可以添加任务。

44
00:02:35,850 --> 00:02:42,780
例如，其中一项任务我
可能需要去拿起我的衣服。

45
00:02:42,780 --> 00:02:45,160
如果你对这个
网站在线，你会

46
00:02:45,160 --> 00:02:49,790
其实看到这个任务
您的计算机实时的。

47
00:02:49,790 --> 00:02:53,760
>> 我可以告诉你一个快速演示
这种通过打开rozu兔

48
00:02:53,760 --> 00:02:56,700
在相同的URL另一个选项卡。

49
00:02:56,700 --> 00:03:00,360
而且我们看到，同样的数据出现。

50
00:03:00,360 --> 00:03:02,240
我们也可以在运行它
不同的浏览器。

51
00:03:02,240 --> 00:03:03,420
说我在Safari浏览器中运行它。

52
00:03:03,420 --> 00:03:04,720
这样，我们没有登录。

53
00:03:04,720 --> 00:03:07,750

54
00:03:07,750 --> 00:03:11,060
因此，我们有相同的流星
应用程序，一旦它加载，

55
00:03:11,060 --> 00:03:13,910
我们将看到同样的数据
我们做的第一个。

56
00:03:13,910 --> 00:03:16,710
正如你所看到的，我不记录在这里了。

57
00:03:16,710 --> 00:03:20,000
并且当观众的检查数据，
它更新的所有浏览器

58
00:03:20,000 --> 00:03:20,910
同时。

59
00:03:20,910 --> 00:03:23,740
这是真的1
很酷的功能有关流星。

60
00:03:23,740 --> 00:03:27,700
几乎没有工作，你
有一个实时更新的应用程序

61
00:03:27,700 --> 00:03:31,240
这对所有的变化
您的设备一次。

62
00:03:31,240 --> 00:03:36,690
>> 如果我在这里选中的复选框
在我做的名单，我们都会有，

63
00:03:36,690 --> 00:03:41,230
我的其他的Chrome浏览器，
该项目勾掉。

64
00:03:41,230 --> 00:03:42,605
而这种情况在瞬间。

65
00:03:42,605 --> 00:03:46,340

66
00:03:46,340 --> 00:03:47,280
行。

67
00:03:47,280 --> 00:03:52,730
所以它看起来像流星
安装已准备就绪。

68
00:03:52,730 --> 00:03:57,000
所以，现在让我们回到
待办事项应用程序在本地运行此。

69
00:03:57,000 --> 00:04:01,599
>> 如果你有一个流星的项目，你可以
只是用命令流星运行它。

70
00:04:01,599 --> 00:04:03,640
一旦你这样做，流星
会做一些准备工作

71
00:04:03,640 --> 00:04:06,120
以确保所有的
你的代码是在检查。

72
00:04:06,120 --> 00:04:12,440
然后它会告诉你，
项目准备送达。

73
00:04:12,440 --> 00:04:17,750
您可能需要让你的
防火墙，如果你的电脑，你的块。

74
00:04:17,750 --> 00:04:22,440
>> 那么，什么流星告诉我
现在的问题是，在这个网站

75
00:04:22,440 --> 00:04:26,100
本地到我的电脑，我可以看到
这是什么流星项目。

76
00:04:26,100 --> 00:04:29,290
需要注意的是，现在，我的应用程序是
不能访问到互联网。

77
00:04:29,290 --> 00:04:35,170
我们将讨论如何把你的流星
应用到直播现场有点以后。

78
00:04:35,170 --> 00:04:40,510
所以我只是要复制此
URL现在进入谷歌Chrome浏览器。

79
00:04:40,510 --> 00:04:42,600
>> 这就是做
从这个例子列出。

80
00:04:42,600 --> 00:04:46,080
你可以看到他们实施
一些更多的功能在这里。

81
00:04:46,080 --> 00:04:49,210
我们有不同的选项卡中，我们
具有相同的帐户功能，

82
00:04:49,210 --> 00:04:52,141
我们可以添加新的列表。

83
00:04:52,141 --> 00:04:54,140
现在，一个真正的
关于流星很酷的功能

84
00:04:54,140 --> 00:04:57,450
是，这不仅可以
在您的网页浏览器中，

85
00:04:57,450 --> 00:05:00,030
但你也可以创建
原生iPhone和Android

86
00:05:00,030 --> 00:05:02,990
通过一个名为PhoneGap的应用程序的工具。

87
00:05:02,990 --> 00:05:06,740
>> 因此，一些项目会
预先配置为运行

88
00:05:06,740 --> 00:05:08,700
在iOS上，这样的待办事项应用程序。

89
00:05:08,700 --> 00:05:14,780
因此，所有我需要做的iOS中运行
类型是流星，运行，然后的iOS。

90
00:05:14,780 --> 00:05:17,540
当我这样做，流星
将再次准备包。

91
00:05:17,540 --> 00:05:21,670
然后，一旦它准备好，它会
加载在我的命令的iOS模拟器。

92
00:05:21,670 --> 00:05:24,745
注意你只能运行iOS应用
如果你有一台Mac电脑。

93
00:05:24,745 --> 00:05:27,650

94
00:05:27,650 --> 00:05:30,730
你可以运行你的应用程序
Android的所有平台上。

95
00:05:30,730 --> 00:05:34,070

96
00:05:34,070 --> 00:05:38,290
>> 所以，现在你可以看到我的iPhone
模拟器来到了我的屏幕上。

97
00:05:38,290 --> 00:05:40,370
并在短短的一瞬间，
它会加载的应用程序。

98
00:05:40,370 --> 00:05:46,070

99
00:05:46,070 --> 00:05:48,490
如果我们只是有点
小以适应屏幕上，

100
00:05:48,490 --> 00:05:50,780
我们可以看到，我们有我们的iPhone应用程序。

101
00:05:50,780 --> 00:05:53,220
而只是让我们不这样做
感到困惑，让我们

102
00:05:53,220 --> 00:05:59,790
相信大家都在同一个
网站，本地主机3000。

103
00:05:59,790 --> 00:06:03,490
>> 所以这里有一个例子
流星的应用程序我有，

104
00:06:03,490 --> 00:06:08,770
在待办事项应用程序，无论是运行
电话和网络浏览器。

105
00:06:08,770 --> 00:06:10,770
当我改变的东西
在网络浏览器，

106
00:06:10,770 --> 00:06:12,675
立刻去了电话。

107
00:06:12,675 --> 00:06:16,500
我可以删除手机上的东西，
和它的变化，在网络浏览器。

108
00:06:16,500 --> 00:06:21,050
>> 现在，常以创建本地
手机应用程序适用于iOS或Android，

109
00:06:21,050 --> 00:06:26,090
你需要知道Java或
客观C.技术流星用途

110
00:06:26,090 --> 00:06:29,240
要允许JavaScript作为运行
您的应用程序被称为PhoneGap的。

111
00:06:29,240 --> 00:06:31,320
你有什么本质上的应用程序
是一个网页浏览器。

112
00:06:31,320 --> 00:06:34,500
和流星处理所有
所涉及的棘手的部分

113
00:06:34,500 --> 00:06:39,820
用于使该Web浏览器来
你的iPhone或Android设备。

114
00:06:39,820 --> 00:06:42,210
你可以看到，
用户界面是光滑的，

115
00:06:42,210 --> 00:06:45,290
和它的外观和感觉很
很像一个本机应用程序。

116
00:06:45,290 --> 00:06:48,620
请注意，如果我去家里
屏幕现在，我也得到一个图标。

117
00:06:48,620 --> 00:06:50,880
这并不像一个网站
你会发现在Safari浏览器。

118
00:06:50,880 --> 00:06:51,860
这是它自己的应用程序。

119
00:06:51,860 --> 00:06:54,130
您可以安装和
删除它，如果你愿意的话。

120
00:06:54,130 --> 00:06:59,500

121
00:06:59,500 --> 00:07:04,436
>> 我们可以简单地告诉你什么码
对于这种待办事项应用程序看起来像。

122
00:07:04,436 --> 00:07:08,260
如果你看一下在待办事项文件夹中，
你会看到有很多的文件夹。

123
00:07:08,260 --> 00:07:11,440
但过度的过程中
在研讨会中，我们将

124
00:07:11,440 --> 00:07:14,780
了解每个文件夹的用途。

125
00:07:14,780 --> 00:07:17,830
让我们去到终端，所以我们
可以看到文件的好一点。

126
00:07:17,830 --> 00:07:20,410
>> 我要按下Control
C停止服务器，

127
00:07:20,410 --> 00:07:22,770
现在我回到了待办事项应用程序。

128
00:07:22,770 --> 00:07:26,660
我有不同的文件夹位置，如
客户端文件夹，服务器文件夹。

129
00:07:26,660 --> 00:07:30,500
这些文件夹只是意味着
一切都在客户端文件夹

130
00:07:30,500 --> 00:07:32,630
在Web浏览器中被执行。

131
00:07:32,630 --> 00:07:35,530
在服务器文件夹中的一切
在服务器上被执行。

132
00:07:35,530 --> 00:07:38,100
>> 我想点
的是，我们有什么

133
00:07:38,100 --> 00:07:42,140
当我们有我们的电话和运行
我们的网络浏览器，这些都是客户。

134
00:07:42,140 --> 00:07:45,730
但是，什么是在运行中
终端，这就是服务器。

135
00:07:45,730 --> 00:07:48,710
我们还有其他的文件夹，如
lib中，这是库代码，

136
00:07:48,710 --> 00:07:51,050
喜欢你的帮手
功能，您可以

137
00:07:51,050 --> 00:07:53,710
使用客户端和服务器上。

138
00:07:53,710 --> 00:07:55,820
然后你有一个公共
文件夹和资源

139
00:07:55,820 --> 00:07:59,310
需要获取文件夹
您的图像和其他CSS加载。

140
00:07:59,310 --> 00:08:02,630

141
00:08:02,630 --> 00:08:09,360
>> 如果您已经安装了流星，我们将
继续教程流星。

142
00:08:09,360 --> 00:08:12,790
你可以去这个网址，
meteor.com/install，

143
00:08:12,790 --> 00:08:17,990
获取命令行，我
表明您安装流星。

144
00:08:17,990 --> 00:08:20,240
我们将通过第一
几个步骤，以获得更好

145
00:08:20,240 --> 00:08:22,760
感觉如何安装流星。

146
00:08:22,760 --> 00:08:28,000
>> 但首先，我认为这是非常重要的
我们回顾了JavaScript的一点点。

147
00:08:28,000 --> 00:08:32,360
向您展示如何一些例子
我们的C知识，可以翻译

148
00:08:32,360 --> 00:08:34,950
JavaScript的，我已经
创建了几个例子。

149
00:08:34,950 --> 00:08:36,940
它们是在js目录。

150
00:08:36,940 --> 00:08:41,750
因此，如果在研讨会文件夹，你
你看，有一个名为JS的文件夹。

151
00:08:41,750 --> 00:08:44,540
并且在这里，我们有几个例子。

152
00:08:44,540 --> 00:08:50,120
>> 让我们打开了第一
例如，看到非常快。

153
00:08:50,120 --> 00:08:53,980
我们看到的是你的标准
世界您好命令。

154
00:08:53,980 --> 00:08:56,520
您会注意到在C中，你
有不少行。

155
00:08:56,520 --> 00:09:00,490
而作为CS50的学生都知道，
我们需要一个主要功能，

156
00:09:00,490 --> 00:09:05,730
我们必须包括标准
I / O，以调用printf库。

157
00:09:05,730 --> 00:09:09,320
>> 让我们来看看如何JavaScript的比较。

158
00:09:09,320 --> 00:09:11,560
我要开ex1.js.

159
00:09:11,560 --> 00:09:14,650
注释掉是什么
C代码会是什么样子，

160
00:09:14,650 --> 00:09:17,550
和下方的线是所有
需要在节点中运行。

161
00:09:17,550 --> 00:09:20,452
你并不需要一个main函数，你
不需要包括任何文件，

162
00:09:20,452 --> 00:09:21,660
你不需要返回。

163
00:09:21,660 --> 00:09:23,810
您只要致电的console.log。

164
00:09:23,810 --> 00:09:26,370
这是你的printf的等价物。

165
00:09:26,370 --> 00:09:29,310
>> 它采用相同的
争论的printf会。

166
00:09:29,310 --> 00:09:33,870
而为了运行它，
而不是运行使EX1，

167
00:09:33,870 --> 00:09:38,930
你只需要调用节点ex1.js.

168
00:09:38,930 --> 00:09:41,830
你写的节点，然后
该文件，它就会被运行。

169
00:09:41,830 --> 00:09:43,580
它不会编译。

170
00:09:43,580 --> 00:09:45,970
JavaScript是一种解释型语言。

171
00:09:45,970 --> 00:09:49,150
所以它并不需要是
它的运行之前编译。

172
00:09:49,150 --> 00:09:53,450
如果我想跑ex1.c中，
我要让它首先，

173
00:09:53,450 --> 00:09:59,160
然后我可以运行可执行文件
以得到相同的输出。

174
00:09:59,160 --> 00:10:02,460
>> 让我们迅速覆盖了一些
其他JavaScript概念。

175
00:10:02,460 --> 00:10:04,490
让我们来看看例子2。

176
00:10:04,490 --> 00:10:14,690
在ex2.js，在ex2.c，我们可以
看到我们有一些代码。

177
00:10:14,690 --> 00:10:16,550
让我赶快去
一个更好的文本编辑器

178
00:10:16,550 --> 00:10:18,400
这将显示这些
新的生产线会好一点。

179
00:10:18,400 --> 00:10:21,760

180
00:10:21,760 --> 00:10:22,380
行。

181
00:10:22,380 --> 00:10:24,190
在这里，我们有例如2.C.

182
00:10:24,190 --> 00:10:27,360
在这里，我们有不同类型的
我们要打印出来。

183
00:10:27,360 --> 00:10:30,880
正如我们所知，printf的需要
不同的参数百分比

184
00:10:30,880 --> 00:10:34,050
访问不同的数据片段。

185
00:10:34,050 --> 00:10:36,840
如果我们想打印
一个字符串，我们称之为％S。

186
00:10:36,840 --> 00:10:40,390
如果我们要调用一个浮动
点编号，我们叫做％F。

187
00:10:40,390 --> 00:10:45,810
有没有简单的方法来调用
其真或假值布尔值。

188
00:10:45,810 --> 00:10:50,760
但是如果你使用％D，就可以得到
0或1的虚假和真实的。

189
00:10:50,760 --> 00:10:53,270
>> JavaScript是我们的一个位更好。

190
00:10:53,270 --> 00:10:57,740
在JavaScript中，让我们来看看几个
差异，我们在这个文件中。

191
00:10:57,740 --> 00:11:05,790
首先，您会注意到，在C，我们必须
初始化一个类型的每个变量。

192
00:11:05,790 --> 00:11:06,940
S是一个char明星。

193
00:11:06,940 --> 00:11:08,930
这是一个字符串，它
不能是任何其它类型。

194
00:11:08,930 --> 00:11:10,450
N是一个浮动。

195
00:11:10,450 --> 00:11:11,780
B是一个布尔值。

196
00:11:11,780 --> 00:11:14,220
>> 但在JavaScript中，
也有动态的类型。

197
00:11:14,220 --> 00:11:16,400
这意味着，你不这样做
需要告诉的JavaScript

198
00:11:16,400 --> 00:11:17,860
什么类型的变量会。

199
00:11:17,860 --> 00:11:22,730
你刚才说VAR的变量名
的变量，然后将其值的。

200
00:11:22,730 --> 00:11:24,690
所以无功真的可以什么。

201
00:11:24,690 --> 00:11:25,640
它可以是一个字符串。

202
00:11:25,640 --> 00:11:27,300
它可以是一个浮点数。

203
00:11:27,300 --> 00:11:28,560
它可以是一个字符。

204
00:11:28,560 --> 00:11:31,250
它可以是一个布尔值。

205
00:11:31,250 --> 00:11:34,380
和控制台日志作品有点不同。

206
00:11:34,380 --> 00:11:37,340
如果你要打印
一个数字，你叫％D。

207
00:11:37,340 --> 00:11:41,740
但大多数值可以
打印字符串就好了。

208
00:11:41,740 --> 00:11:46,220
>> 让我们在节点运行此
看看会发生什么。

209
00:11:46,220 --> 00:11:51,880
我可以打电话节点ex2.js，
我们得到的printf

210
00:11:51,880 --> 00:11:56,870
与价值观CS50，N为
浮点数，

211
00:11:56,870 --> 00:12:00,620
然后B作为布尔
转换为字符串真。

212
00:12:00,620 --> 00:12:03,830
怎么样，如果我们做了榜样2.C？

213
00:12:03,830 --> 00:12:09,630
好了，我们还是有一定的
更多的烦恼与printf的。

214
00:12:09,630 --> 00:12:13,110
注意，浮点
一些必须正确格式化，

215
00:12:13,110 --> 00:12:18,120
和布尔不能简单
显示为真或假。

216
00:12:18,120 --> 00:12:18,620
行。

217
00:12:18,620 --> 00:12:22,680
现在，让我们来看看例子3。

218
00:12:22,680 --> 00:12:26,470
在例3中，我们展示
你将如何使用for循环。

219
00:12:26,470 --> 00:12:27,630
事实上，这是非常简单的。

220
00:12:27,630 --> 00:12:31,430
一对好东西
JavaScript是它是基于C的。

221
00:12:31,430 --> 00:12:33,920
这意味着，你的很多
代码看起来非常相似

222
00:12:33,920 --> 00:12:36,490
感觉大同小异。

223
00:12:36,490 --> 00:12:39,220
在fo​​r循环中，唯一
已真的在这里改变

224
00:12:39,220 --> 00:12:41,840
是不是int我，我们有变种我。

225
00:12:41,840 --> 00:12:45,470
我们仍然可以将它的价值
零，检查它的不足五，

226
00:12:45,470 --> 00:12:49,390
并加一
与++运算符。

227
00:12:49,390 --> 00:12:56,286
我们呼吁我的console.log，而且
将打印我们许多与每一行。

228
00:12:56,286 --> 00:12:58,410
让我们快速运行它真的
看看它输出。

229
00:12:58,410 --> 00:13:02,320

230
00:13:02,320 --> 00:13:03,880
我们得到每行一个新的号码。

231
00:13:03,880 --> 00:13:06,920
另一件事，我想你
用的console.log注意

232
00:13:06,920 --> 00:13:09,960
是你没有写
反斜杠n表示新的生产线。

233
00:13:09,960 --> 00:13:12,480
CONSOLE.LOG将打印
一切都在自己的路线。

234
00:13:12,480 --> 00:13:14,585
这是一个不错的功能
的JavaScript给了我们。

235
00:13:14,585 --> 00:13:18,440

236
00:13:18,440 --> 00:13:22,600
>> 现在，让我们打开了榜样4。

237
00:13:22,600 --> 00:13:28,710
在例4，先在C，
我们要求的一些功能。

238
00:13:28,710 --> 00:13:33,290
请注意，我们要声明
功能之前，我们使用他们在主。

239
00:13:33,290 --> 00:13:37,250
如果我们有主要的第一和
再加入再高，制作，

240
00:13:37,250 --> 00:13:39,540
铿锵，或将​​GCC
给我们一个错误说

241
00:13:39,540 --> 00:13:41,060
它不知道什么是高。

242
00:13:41,060 --> 00:13:42,780
它不知道什么补充的是。

243
00:13:42,780 --> 00:13:46,480
因此，在C，你必须要挑剔
为了在你打电话的功能。

244
00:13:46,480 --> 00:13:49,220

245
00:13:49,220 --> 00:13:51,310
>> 让我们来看看你怎么能
在JavaScript中做到这一点。

246
00:13:51,310 --> 00:13:56,060
我们有不同的文件，因为有
有几种不同的方式来做到这一点。

247
00:13:56,060 --> 00:13:58,950
一种方法是非常
直接翻译。

248
00:13:58,950 --> 00:14:02,180
因为在C函数
返回类型和JavaScript

249
00:14:02,180 --> 00:14:05,210
并不知道也不关心
关于什么类型的返回，

250
00:14:05,210 --> 00:14:06,300
你不写一个类型。

251
00:14:06,300 --> 00:14:08,100
相反，你只需要
写功能，

252
00:14:08,100 --> 00:14:11,180
一切是相当
很多以前一样。

253
00:14:11,180 --> 00:14:14,630
>> 当你有一个变量，像
加上，我们只需要编写x和y。

254
00:14:14,630 --> 00:14:16,060
我们不需要说x是一个int。

255
00:14:16,060 --> 00:14:18,940
我们不需要说y是一个int。

256
00:14:18,940 --> 00:14:21,030
我们返回与相同的语法。

257
00:14:21,030 --> 00:14:24,230
对于高，我们与它声明
函数而不是无效。

258
00:14:24,230 --> 00:14:26,110
请注意，无论是
它是无效或不空，

259
00:14:26,110 --> 00:14:28,380
它仍然是所有相同的功能。

260
00:14:28,380 --> 00:14:32,440
我们根本不把
在括号什么，

261
00:14:32,440 --> 00:14:34,690
它看起来非常像C代码。

262
00:14:34,690 --> 00:14:37,460
以下，我们可以在下面调用它。

263
00:14:37,460 --> 00:14:42,730
>> 如果我们看一下例子4b中，我们注意到
我已经改变了一些东西。

264
00:14:42,730 --> 00:14:45,340
我唯一​​改变的
真的，虽然是订单。

265
00:14:45,340 --> 00:14:47,340
我们有相同的
的功能，但现在他们

266
00:14:47,340 --> 00:14:52,200
他们在使用后宣布
的console.log和高上线18，19。

267
00:14:52,200 --> 00:14:54,740
如果您在C中这样做，
使会抛出一个错误。

268
00:14:54,740 --> 00:14:56,070
在这里，这工作得很好。

269
00:14:56,070 --> 00:15:01,935
我可以展示给你
调用节点上的4B的例子。

270
00:15:01,935 --> 00:15:05,350

271
00:15:05,350 --> 00:15:10,130
>> 我们可以调用函数的另一种方式
是通过保存作为变量。

272
00:15:10,130 --> 00:15:13,790
就像我说的，一个变量
可以具有任何类型。

273
00:15:13,790 --> 00:15:16,720
一种类型的可变
可以有一个函数。

274
00:15:16,720 --> 00:15:19,800
所以，如果你看一下例子
4C，我已经改变了

275
00:15:19,800 --> 00:15:24,320
这里是VAR增加而不是函数添加。

276
00:15:24,320 --> 00:15:26,807
现在等于增加功能。

277
00:15:26,807 --> 00:15:28,140
此功能在这里是匿名的。

278
00:15:28,140 --> 00:15:33,346
它没有名字，所以它只是
功能，然后在括号中。

279
00:15:33,346 --> 00:15:35,220
之后，该语法
不改变，但你

280
00:15:35,220 --> 00:15:38,300
确实要记住，
你有你的变量

281
00:15:38,300 --> 00:15:42,940
存储所述函数到添加，和一个
那你存储成高变量。

282
00:15:42,940 --> 00:15:47,620
>> 由于添加高现在变量
而不是功能，就有点变味了。

283
00:15:47,620 --> 00:15:50,190
这是我看到了一个共同的错误
很多人的JavaScript的，

284
00:15:50,190 --> 00:15:52,410
有什么东西要牢记。

285
00:15:52,410 --> 00:15:54,365
当我运行这一点，让我们看看会发生什么。

286
00:15:54,365 --> 00:15:57,410

287
00:15:57,410 --> 00:15:58,230
我得到一个错误。

288
00:15:58,230 --> 00:16:01,000
它说未定义在这一点上。

289
00:16:01,000 --> 00:16:03,520
所以它说它
不知道什么补充的是。

290
00:16:03,520 --> 00:16:06,010
>> 因为现在加的是不是一个
功能中，添加是一个变量。

291
00:16:06,010 --> 00:16:10,100
而你还没有真正给
添加一个值然而，当你使用它。

292
00:16:10,100 --> 00:16:14,460
这给我们带来了例如4D，如果在那里
要使用变量的函数，

293
00:16:14,460 --> 00:16:17,210
你只需要确保他们
获得的价值，他们正在使用之前。

294
00:16:17,210 --> 00:16:20,200

295
00:16:20,200 --> 00:16:23,420
>> 让我们继续以例五则。

296
00:16:23,420 --> 00:16:27,390
在这里，我们谈论
在结构C.在C，结构

297
00:16:27,390 --> 00:16:30,320
有这样的固定结构，它们
因为你必须声明它们

298
00:16:30,320 --> 00:16:33,050
你使用它之前，和
你说我有一个学生，

299
00:16:33,050 --> 00:16:36,645
和每一个学生都有完全相同
一个名字，一年一种性别。

300
00:16:36,645 --> 00:16:37,770
它有让所有的人。

301
00:16:37,770 --> 00:16:42,280
它不能有任何其他的价值，
并且他们必须是特定类型。

302
00:16:42,280 --> 00:16:47,540
>> 然后，我们可以初始化
结构在这个漂亮的语法

303
00:16:47,540 --> 00:16:49,470
因为它知道的顺序。

304
00:16:49,470 --> 00:16:51,460
所以它知道罗杰是一个名字。

305
00:16:51,460 --> 00:16:54,060
它知道，2016年是一个
年和M是性别

306
00:16:54,060 --> 00:16:58,200
因为我们告诉它这
列表是一个结构的学生。

307
00:16:58,200 --> 00:17:01,607
然后你就可以打印
它，访问s.name。

308
00:17:01,607 --> 00:17:03,690
让我们来看看我们将如何
将其转换为JavaScript。

309
00:17:03,690 --> 00:17:06,400

310
00:17:06,400 --> 00:17:09,790
请注意，s是现在
可变的，而且也没有类型。

311
00:17:09,790 --> 00:17:10,920
这只是一个变种了。

312
00:17:10,920 --> 00:17:14,480
因为它并不重要，如果这件事
这个变量的类型是一个指针，

313
00:17:14,480 --> 00:17:17,440
它是一个结构，或其他任何东西。

314
00:17:17,440 --> 00:17:19,650
我们有一个稍微不同的语法。

315
00:17:19,650 --> 00:17:21,890
这个语法是对象语法。

316
00:17:21,890 --> 00:17:24,400
>> 你可能已经看到它在JSON。

317
00:17:24,400 --> 00:17:27,780
JSON实际上代表的
JavaScript对象符号。

318
00:17:27,780 --> 00:17:31,240
这是你如何定义
在JavaScript对象。

319
00:17:31,240 --> 00:17:34,500
我们有一个密钥，它是
值，如姓名。

320
00:17:34,500 --> 00:17:37,680
我们给它的值
结肠的另一侧。

321
00:17:37,680 --> 00:17:41,850
还有一件事要记住的就是你
不需要有一个名字和一个年

322
00:17:41,850 --> 00:17:42,980
和性别的对象。

323
00:17:42,980 --> 00:17:44,570
一个对象可以没有价值。

324
00:17:44,570 --> 00:17:46,920
它可以有很多，只要你愿意。

325
00:17:46,920 --> 00:17:50,375
>> 我们可以在刚刚使用这些对象
同样的方法，我们会用一个结构，s.name。

326
00:17:50,375 --> 00:17:53,810

327
00:17:53,810 --> 00:17:57,080
我们可以快速运行真的
这样做节点例如5.c.

328
00:17:57,080 --> 00:18:00,320

329
00:18:00,320 --> 00:18:02,520
我们不能真正运行节点C文件。

330
00:18:02,520 --> 00:18:03,654
它不知道什么C是。

331
00:18:03,654 --> 00:18:04,695
它只知道的JavaScript。

332
00:18:04,695 --> 00:18:09,865
当我们运行ex5.js，我们得到
的价值，这是我们的预期。

333
00:18:09,865 --> 00:18:13,490

334
00:18:13,490 --> 00:18:15,980
>> 让我们转移到例如6。

335
00:18:15,980 --> 00:18:18,930
在这里，我只想谈一点
更多一点关于JavaScript数组

336
00:18:18,930 --> 00:18:20,930
因为他们是有点
比你有什么不同

337
00:18:20,930 --> 00:18:26,940
用于在C数组的记谱，
不与支架像C，

338
00:18:26,940 --> 00:18:28,640
用大括号，括号内却。

339
00:18:28,640 --> 00:18:32,150
你可以有一个空数组，
喜欢改编四线。

340
00:18:32,150 --> 00:18:34,680
你可以有数组
有多个值。

341
00:18:34,680 --> 00:18:39,790
你访问它们
只是在C以同样的方式

342
00:18:39,790 --> 00:18:42,990
>> 截至七号线，一切
似乎很简单。

343
00:18:42,990 --> 00:18:45,390
一个微小的差别就在这里，在第10行。

344
00:18:45,390 --> 00:18:48,620
途中你得到的长度
阵列仅仅是通过调用.length。

345
00:18:48,620 --> 00:18:50,620
一个数组其实是可以
就像一个对象处理，

346
00:18:50,620 --> 00:18:54,960
而这个对象有一个length属性
你打电话来获得它的长度。

347
00:18:54,960 --> 00:18:57,350
注意，这是不同的
在C，因为在C中你

348
00:18:57,350 --> 00:19:01,600
必须知道的长度
提前你的对象。

349
00:19:01,600 --> 00:19:04,700
>> 有关阵列使另一个好处
是，你可以有不同的类型。

350
00:19:04,700 --> 00:19:07,470
如果您在C数组，有
是一个特定的值的阵列，

351
00:19:07,470 --> 00:19:11,900
无论是结构指针
或浮或[听不清]。

352
00:19:11,900 --> 00:19:13,700
在这里，你可以有不同的价值观。

353
00:19:13,700 --> 00:19:17,560
我第一次有一个浮点数，
再一个布尔值，然后又整数。

354
00:19:17,560 --> 00:19:19,670
而实际上，他们可以改变的类型了。

355
00:19:19,670 --> 00:19:21,220
看16行。

356
00:19:21,220 --> 00:19:26,760
阵列二是被改变
数，为整数，为字符串。

357
00:19:26,760 --> 00:19:30,920
>> 有关阵列的另一个好处是这里
在第19行，它们具有无限的大小。

358
00:19:30,920 --> 00:19:35,900
你可以说我想要的百
元件为字符串合法的。

359
00:19:35,900 --> 00:19:38,510
而这似乎并没有使
有道理的，因为该数组只

360
00:19:38,510 --> 00:19:41,080
有空间三个要素，
所以到底应该是两个。

361
00:19:41,080 --> 00:19:44,800
但是，当你做到这一点，让我们
看到三个变成什么阵。

362
00:19:44,800 --> 00:19:47,460
我们将很快运行这个
与节点例如six.js.

363
00:19:47,460 --> 00:19:49,990

364
00:19:49,990 --> 00:19:52,180
我们得到这个很长
数组，会发生什么

365
00:19:52,180 --> 00:19:55,100
在我们最初的几个要素
然后一堆空白

366
00:19:55,100 --> 00:19:56,580
直到我们得到我们的字符串。

367
00:19:56,580 --> 00:19:58,580
JavaScript的填写
数组作为它的需要。

368
00:19:58,580 --> 00:20:01,790

369
00:20:01,790 --> 00:20:05,420
>> 让我们终于进入我们的最后一个例子。

370
00:20:05,420 --> 00:20:08,180
在这里，我们有一个列表
不同的学生。

371
00:20:08,180 --> 00:20:11,350
我想谈一点
一些好的方面位

372
00:20:11,350 --> 00:20:14,240
对在JavaScript中循环。

373
00:20:14,240 --> 00:20:17,500
在C语言中，for循环是一种限制。

374
00:20:17,500 --> 00:20:21,490
他们有一个固定的结构，在那里你
有一个变量，你有一个条件，

375
00:20:21,490 --> 00:20:23,850
然后你做什么
在循环的结束。

376
00:20:23,850 --> 00:20:27,560
当然还有这部作品在JavaScript中，
正如我们在前面的例子中看到的。

377
00:20:27,560 --> 00:20:31,030
但我们也有更好的方法
对这样做在JavaScript中。

378
00:20:31,030 --> 00:20:33,870
这就是所谓的foreach循环。

379
00:20:33,870 --> 00:20:36,580
>> 对不起，让我们回到
例7这里。

380
00:20:36,580 --> 00:20:39,320
我们也可以说部分是一个列表。

381
00:20:39,320 --> 00:20:43,250
所以给我的每i或
各项指标在该列表中。

382
00:20:43,250 --> 00:20:46,255
然后，我们可以得到学生
通过只调用了我部分。

383
00:20:46,255 --> 00:20:50,690
因此，所有的设置我的代码
等于零，并确保我

384
00:20:50,690 --> 00:20:54,420
小于长度和
每次添加一个到我，这是

385
00:20:54,420 --> 00:21:00,220
照顾你，而
很好地与这个foreach循环。

386
00:21:00,220 --> 00:21:02,830
>> 不仅foreach循环
在列表或阵列工作，

387
00:21:02,830 --> 00:21:06,130
他们还工作的对象，
这也是很好的。

388
00:21:06,130 --> 00:21:10,240
你可以得到的名称
每个属性，只需服用

389
00:21:10,240 --> 00:21:15,030
字典或一个对象，像学生，
然后只是说给我的每一个关键。

390
00:21:15,030 --> 00:21:18,920
一个关键是这些
性质，名称或房子。

391
00:21:18,920 --> 00:21:22,870
那么什么会发生在这里的是，
我们打​​印出第一名称，然后

392
00:21:22,870 --> 00:21:24,920
每个学生的家。

393
00:21:24,920 --> 00:21:29,170
>> 我可以在节点运行此
真的很快给你看。

394
00:21:29,170 --> 00:21:35,510
我们得到的第一个C风格的for循环，其中
我们得到的每一个对象被打印出来。

395
00:21:35,510 --> 00:21:38,910
然后，我们有JavaScript的
风格，在那里你可以

396
00:21:38,910 --> 00:21:41,510
打印出的每个关键
和独立的价值。

397
00:21:41,510 --> 00:21:45,560

398
00:21:45,560 --> 00:21:47,050
>> 行。

399
00:21:47,050 --> 00:21:52,850
现在，我们已经介绍了Node.js的，我觉得
我们已经准备好开始使用流星。

400
00:21:52,850 --> 00:21:56,070
就像我说的，流星的表现非常出色
中写一些现成的例子

401
00:21:56,070 --> 00:22:00,600
对你，你可以探索通过
本教程或研讨会文件夹。

402
00:22:00,600 --> 00:22:03,750
但在这里，我想
开始从头越。

403
00:22:03,750 --> 00:22:06,810
>> 让我们创建一个简单的做​​应用。

404
00:22:06,810 --> 00:22:14,140
这是什么样的的作为碱的
做应用程序，我刚才向您展示的。

405
00:22:14,140 --> 00:22:16,990
在本教程中，
会看到有

406
00:22:16,990 --> 00:22:20,180
命令流星创建到
创建一个新的流星的项目。

407
00:22:20,180 --> 00:22:24,510
你需要调用这个以
运行流星的项目，因为它

408
00:22:24,510 --> 00:22:27,470
将运行命令
创建流星

409
00:22:27,470 --> 00:22:31,100
为您的项目文件的必要。

410
00:22:31,100 --> 00:22:35,920
>> 如果你去到终端，我们可以
进入所谓的第一步的文件夹。

411
00:22:35,920 --> 00:22:41,240
并加强人会对应
在本教程的第一步。

412
00:22:41,240 --> 00:22:44,020
注意事项有文件夹，一步
1，步骤2，一路5。

413
00:22:44,020 --> 00:22:47,835
而且每一个对应
在本教程中的一个步骤。

414
00:22:47,835 --> 00:22:50,960

415
00:22:50,960 --> 00:22:52,780
我要打开它
在这里我的文本编辑器

416
00:22:52,780 --> 00:22:56,280
所以我们可以看到一点点被创造的。

417
00:22:56,280 --> 00:22:58,530
我们注意到，有
有四个主要部分。

418
00:22:58,530 --> 00:23:01,170
有一个流星目录，.meteor。

419
00:23:01,170 --> 00:23:03,180
那你平时
不需要触摸。

420
00:23:03,180 --> 00:23:05,070
流星需要照顾
该文件夹，它只是

421
00:23:05,070 --> 00:23:08,640
确保你的
项目将正常工作。

422
00:23:08,640 --> 00:23:14,580
>> 我们也有三个文件，HTML文件，
JavaScript文件和CSS文件。

423
00:23:14,580 --> 00:23:18,670
让我们先开始与HTML文件。

424
00:23:18,670 --> 00:23:21,310
乍一看，这看起来
象正常的HTML文档。

425
00:23:21,310 --> 00:23:23,490
但是请注意，有
有一些不同之处。

426
00:23:23,490 --> 00:23:26,520
之一，这是不实际
一个完整的HTML文档。

427
00:23:26,520 --> 00:23:28,640
我们缺少的HTML标签。

428
00:23:28,640 --> 00:23:29,700
这是正常的。

429
00:23:29,700 --> 00:23:33,560
在流星，你不期望
创造这些HTML标签。

430
00:23:33,560 --> 00:23:35,260
这样做了你。

431
00:23:35,260 --> 00:23:38,380
你想，如果你begin--
要创建一个网站，

432
00:23:38,380 --> 00:23:40,430
你只需要启动
用头标签，

433
00:23:40,430 --> 00:23:43,510
定义，然后
定义body标签。

434
00:23:43,510 --> 00:23:48,940
>> 但是，如果你在这个通知
HTML文件中，我们有一个新的标签。

435
00:23:48,940 --> 00:23:50,350
我们有模板标签。

436
00:23:50,350 --> 00:23:52,050
这是不正常的HTML。

437
00:23:52,050 --> 00:23:55,300
这是HTML的一个特殊版本
该流星向您提供。

438
00:23:55,300 --> 00:23:57,660
这就是所谓的空间吧。

439
00:23:57,660 --> 00:24:00,980
您可以定义模板少
模块，有点像辅助功能，

440
00:24:00,980 --> 00:24:03,660
在C或JavaScript代码。

441
00:24:03,660 --> 00:24:06,020
这个模板会
有一个叫任务的名称。

442
00:24:06,020 --> 00:24:10,520
你可以看到这里就行
13，你可以调用这些模板。

443
00:24:10,520 --> 00:24:14,380
什么流星会做的就是
填写这些任务给你。

444
00:24:14,380 --> 00:24:17,540

445
00:24:17,540 --> 00:24:22,580
>> 你可能会注意到的另一件事是一个
有点不同的是这每一个功能。

446
00:24:22,580 --> 00:24:26,130
每次将变量
种任务，并通过它去

447
00:24:26,130 --> 00:24:28,810
在fo​​reach循环我们
例如7中看到的。

448
00:24:28,810 --> 00:24:34,200
这个每个人都可以拿一本字典
或列表，对象或列表，

449
00:24:34,200 --> 00:24:38,820
它会只是去通过所有的
就像一个foreach循环值会。

450
00:24:38,820 --> 00:24:44,110
因此，如果我们有一大堆的任务，这
将调用每个任务的模板。

451
00:24:44,110 --> 00:24:49,590
>> 让我们运行的流星项目
刚看到这种情况的发生。

452
00:24:49,590 --> 00:24:53,260
我运行流星项目
只是流星或流星运行。

453
00:24:53,260 --> 00:24:56,690
现在流星只是需要
迅速准备项目，

454
00:24:56,690 --> 00:25:03,320
启动数据库如必要，
然后在本地发布的应用程序。

455
00:25:03,320 --> 00:25:07,200
我们可以到我们的网页浏览器了。

456
00:25:07,200 --> 00:25:10,215
我们会看到，我们
有一个很简单的应用程序。

457
00:25:10,215 --> 00:25:22,190

458
00:25:22,190 --> 00:25:29,130
所以，我们看到出现了竟是
在步骤1，步骤1的文件。

459
00:25:29,130 --> 00:25:33,260
>> 让我们继续前进到第二步，只是因为
我认为它会达到同样的目的。

460
00:25:33,260 --> 00:25:36,500
我只是要改变
到步骤2的目录

461
00:25:36,500 --> 00:25:39,550
并再次运行流星，所以我们可以看到
模板，我们只是工作与。

462
00:25:39,550 --> 00:25:43,560

463
00:25:43,560 --> 00:25:45,730
是的，一个问题吗？

464
00:25:45,730 --> 00:25:49,724
>> 观众：如果我们要得到许可
否认是that--什么是它

465
00:25:49,724 --> 00:25:50,390
要求是什么？

466
00:25:50,390 --> 00:25:52,154

467
00:25:52,154 --> 00:25:54,070
ROGER ZURAWICKI：如果
你正在运行的流星跑，

468
00:25:54,070 --> 00:25:57,280
你有权限
否认，某些文件

469
00:25:57,280 --> 00:25:59,070
可能没有合适的权限集。

470
00:25:59,070 --> 00:26:03,970
所以，你必须要检查的地方
权限关闭。

471
00:26:03,970 --> 00:26:06,030
他们可以被关闭
您流星的项目，

472
00:26:06,030 --> 00:26:08,550
或者也可以在离开
流星文件本身。

473
00:26:08,550 --> 00:26:13,742
>> 听众：如果我下载刚才
从GitHub上，那么我该怎么办

474
00:26:13,742 --> 00:26:16,110
[听不清]？

475
00:26:16,110 --> 00:26:20,110
>> ROGER ZURAWICKI：如果你想
以确保您可以访问它，

476
00:26:20,110 --> 00:26:21,450
还有，你可以运行一个命令。

477
00:26:21,450 --> 00:26:26,590
让我赶紧写出来
所以其他人可以看到它。

478
00:26:26,590 --> 00:26:30,670
我要在这里打开一个新标签
并进入我的研讨会文件夹。

479
00:26:30,670 --> 00:26:33,500

480
00:26:33,500 --> 00:26:36,490
CHMOD就是命令
更改权限，

481
00:26:36,490 --> 00:26:40,060
你可以说r表示做
递归地为每个文件。

482
00:26:40,060 --> 00:26:46,040
和权限，你可以尝试0755
为确保您有充分的机会，

483
00:26:46,040 --> 00:26:47,820
和其他人可以阅读。

484
00:26:47,820 --> 00:26:50,100
如果你只是运行
这个命令，它会令

485
00:26:50,100 --> 00:26:55,800
确保权限是在
检查整个目录。

486
00:26:55,800 --> 00:26:59,160
运行LS-L可以告诉你的
更详细的权限。

487
00:26:59,160 --> 00:27:01,290
这看起来OK。

488
00:27:01,290 --> 00:27:03,900
>> 什么是最重要的
你有三个

489
00:27:03,900 --> 00:27:06,610
RWX中的所有文件
研讨会目录。

490
00:27:06,610 --> 00:27:09,415

491
00:27:09,415 --> 00:27:11,330
这是否解决了问题吗？

492
00:27:11,330 --> 00:27:13,735
>> 观众：它说失踪
操作性[听不清]。

493
00:27:13,735 --> 00:27:17,980

494
00:27:17,980 --> 00:27:18,740
[听不清]

495
00:27:18,740 --> 00:27:20,490
ROGER ZURAWICKI：您
要确保你

496
00:27:20,490 --> 00:27:23,022
有一个点在你的命令的末尾。

497
00:27:23,022 --> 00:27:23,938
观众：[听不清]。

498
00:27:23,938 --> 00:27:36,395

499
00:27:36,395 --> 00:27:37,520
ROGER ZURAWICKI：好的。

500
00:27:37,520 --> 00:27:42,220
让我们赶紧回去
本地主机，应用程序，我们有。

501
00:27:42,220 --> 00:27:46,640
你会看到，我们有一个
这里几个任务，符合市场预期。

502
00:27:46,640 --> 00:27:49,330

503
00:27:49,330 --> 00:27:51,990
我们有一大堆的CSS，这
你不必担心。

504
00:27:51,990 --> 00:27:53,740
流星教程
只是给这个给你

505
00:27:53,740 --> 00:27:58,010
让你的待办事项清单一看
位比普通的HTML更好。

506
00:27:58,010 --> 00:28:02,290
我们有JavaScript文件，其中
我会更详细一点后，

507
00:28:02,290 --> 00:28:04,272
但它只是提供了这些任务。

508
00:28:04,272 --> 00:28:04,980
这是任务之一。

509
00:28:04,980 --> 00:28:05,740
这是任务二。

510
00:28:05,740 --> 00:28:06,590
这是任务三种。

511
00:28:06,590 --> 00:28:09,720
因此，这是该数据流星的获得。

512
00:28:09,720 --> 00:28:15,590
>> 凉爽的事情之一是流星
该变化可以自动发生。

513
00:28:15,590 --> 00:28:18,990
如果我想改变
第一个任务的名称，

514
00:28:18,990 --> 00:28:22,490
所以它会说这是不是
任务之一，我保存它，

515
00:28:22,490 --> 00:28:26,370
然后当我去到Web
浏览器，你可以刷新它，

516
00:28:26,370 --> 00:28:30,861
它会自动说
这不是任务之一。

517
00:28:30,861 --> 00:28:32,860
你可以做同样的事情
在这些文件中。

518
00:28:32,860 --> 00:28:37,940
做出改变，而不是做
列表中，我将是我做的名单。

519
00:28:37,940 --> 00:28:40,980
>> 还有一件事你刚才注意到，
我甚至没有刷新。

520
00:28:40,980 --> 00:28:43,960
令人耳目一新的想法是怎么样
的帮你解决了与流星。

521
00:28:43,960 --> 00:28:48,970
当它检测到文件的变化，
它会加载改变你。

522
00:28:48,970 --> 00:28:53,110
这适用于所有的文件，无论是
它的HTML，CSS或JavaScript。

523
00:28:53,110 --> 00:28:57,990
给大家展示一下这个程序会是什么样
就像没有CSS，我可以将其删除所有。

524
00:28:57,990 --> 00:29:04,720
而当它重新加载，你现在有
一个没有好看的待办事项清单。

525
00:29:04,720 --> 00:29:06,370
让我们把这些内容背。

526
00:29:06,370 --> 00:29:11,343
，肯定不够，
刷新，我们的CSS又回来了。

527
00:29:11,343 --> 00:29:11,843
大。

528
00:29:11,843 --> 00:29:15,700

529
00:29:15,700 --> 00:29:20,010
>> 现在，我们可以用教程继续前进。

530
00:29:20,010 --> 00:29:23,360
让我们来谈谈第二步，模板。

531
00:29:23,360 --> 00:29:27,140
这就是我们刚才看到
与不同的任务。

532
00:29:27,140 --> 00:29:31,550
流星会向你解释什么
模板和如何逻辑的工作。

533
00:29:31,550 --> 00:29:34,760
但是，让我们只是看代码
看看我们是否能有意义出来。

534
00:29:34,760 --> 00:29:38,030

535
00:29:38,030 --> 00:29:41,460
>> 在非常简单的应用程序，
像我们在简单

536
00:29:41,460 --> 00:29:44,550
这样做，第一步，第二步，一步
3，第四步，第五步，

537
00:29:44,550 --> 00:29:45,700
我们没有任何文件夹。

538
00:29:45,700 --> 00:29:47,533
我们没有足够的服务器
文件夹中我提到。

539
00:29:47,533 --> 00:29:50,510
我们没有客户端
提到该文件夹​​。

540
00:29:50,510 --> 00:29:52,290
所以流星将运行中的所有文件。

541
00:29:52,290 --> 00:29:55,210
它会在运行它既
客户端，服务器上。

542
00:29:55,210 --> 00:29:58,840
>> 如果你想你的JavaScript的部分
代码只在客户端上运行，

543
00:29:58,840 --> 00:30:02,350
他们需要确保你有
if语句，有点像什么

544
00:30:02,350 --> 00:30:04,890
我们有我们的JavaScript文件在这里。

545
00:30:04,890 --> 00:30:08,010
所以流星，只有当
它的客户端，那么我

546
00:30:08,010 --> 00:30:12,355
要定义一个模板
所谓辅助性任务。

547
00:30:12,355 --> 00:30:15,050

548
00:30:15,050 --> 00:30:19,260
这是什么代码真的
所做的就是它说有

549
00:30:19,260 --> 00:30:21,800
一个叫做对象模板
该流星提供。

550
00:30:21,800 --> 00:30:23,270
我们要添加一个帮手。

551
00:30:23,270 --> 00:30:27,680
佣工这些任务，
这些东西就像任务。

552
00:30:27,680 --> 00:30:33,890
>> 你会看到，如果我们回到
HTML文件，我们叫上各自的任务。

553
00:30:33,890 --> 00:30:35,750
任务未在HTML中定义。

554
00:30:35,750 --> 00:30:37,770
它是在JavaScript中定义的。

555
00:30:37,770 --> 00:30:42,610
和流星需要知道哪些任务是
当我们进入此处的JavaScript。

556
00:30:42,610 --> 00:30:45,550
任务是这样的帮手。

557
00:30:45,550 --> 00:30:49,830
帮手，你能想到的
它作为模板变量。

558
00:30:49,830 --> 00:30:51,000
又是什么任务呢？

559
00:30:51,000 --> 00:30:53,580
嗯，它返回值的列表。

560
00:30:53,580 --> 00:30:56,750
因为它是一个列表，
我们可以在它调用每个。

561
00:30:56,750 --> 00:30:58,590
所以这就是为什么我们呼吁每一个任务上。

562
00:30:58,590 --> 00:30:59,730
现在我们有任务。

563
00:30:59,730 --> 00:31:02,850

564
00:31:02,850 --> 00:31:03,990
>> 是什么任务呢？

565
00:31:03,990 --> 00:31:07,740
那么，它有这个箭头
在此之后的花括号。

566
00:31:07,740 --> 00:31:09,130
该装置的任务是一个模板。

567
00:31:09,130 --> 00:31:11,100
这不是一个帮手，
像我们刚才看到的。

568
00:31:11,100 --> 00:31:12,872
这是我们定义的模板。

569
00:31:12,872 --> 00:31:14,080
哪里有我们定义它？

570
00:31:14,080 --> 00:31:16,950
我们定义它下面的就在这里。

571
00:31:16,950 --> 00:31:21,160
>> 所有这些模板所做的是使
列表项，并且调用文本。

572
00:31:21,160 --> 00:31:24,160
现在，文本似乎是一个
帮手，但我会告诉你

573
00:31:24,160 --> 00:31:26,610
这其实还是
任务的数据成员。

574
00:31:26,610 --> 00:31:29,230

575
00:31:29,230 --> 00:31:33,670
当你调用每一个，它进入
数据结构一点点。

576
00:31:33,670 --> 00:31:39,130
像foreach循环，现在只是看起来
在我们的对象的第一个元素。

577
00:31:39,130 --> 00:31:41,850
我们看到，文字
这里定义我们的对象。

578
00:31:41,850 --> 00:31:45,350
因此，流星是聪明，知道
我们谈论这段文字，

579
00:31:45,350 --> 00:31:47,630
不叫文字的帮手。

580
00:31:47,630 --> 00:31:52,120
它只是让这种价值
文字在这里，它显示为HTML，

581
00:31:52,120 --> 00:31:55,475
这就是如何将数据变
从JavaScript来的HTML。

582
00:31:55,475 --> 00:32:03,320

583
00:32:03,320 --> 00:32:07,030
>> 上移动，虽然，在本实施例
我们硬编码这些值。

584
00:32:07,030 --> 00:32:10,440
流星做两真
好东西给我们。

585
00:32:10,440 --> 00:32:15,050
除了现场的刷新，我们
结果显示，它也负责管理我们的数据库。

586
00:32:15,050 --> 00:32:18,750
如果你有使用PHP工作，
你不得不配置的phpMyAdmin。

587
00:32:18,750 --> 00:32:21,320
你必须确保你的
表都在检查。

588
00:32:21,320 --> 00:32:24,760
你不得不做大量的工作，使
确保您的数据格式正确，

589
00:32:24,760 --> 00:32:27,880
和PHP可以与它进行通信。

590
00:32:27,880 --> 00:32:30,170
>> 现在，流星采用了新的范例。

591
00:32:30,170 --> 00:32:32,310
这是一个更现代的方式
处理的数据库。

592
00:32:32,310 --> 00:32:34,580
这是一个名为MongoDB的技术。

593
00:32:34,580 --> 00:32:38,740
就像在JavaScript中，我们看到了它
没有关系是什么类型的数据了。

594
00:32:38,740 --> 00:32:39,640
一切都是一个变种。

595
00:32:39,640 --> 00:32:40,570
这不是一个charstar。

596
00:32:40,570 --> 00:32:40,930
这不是一个int。

597
00:32:40,930 --> 00:32:41,970
这不是一个结构。

598
00:32:41,970 --> 00:32:44,210
这只是这个变种，该变种。

599
00:32:44,210 --> 00:32:46,320
>> MongoDB的作品种方式相同。

600
00:32:46,320 --> 00:32:48,160
你不必定义你的表。

601
00:32:48,160 --> 00:32:50,860
你不必多说表
有一个名字，它有一个int。

602
00:32:50,860 --> 00:32:54,710
它有，我不知道，一
元，这是一个小数。

603
00:32:54,710 --> 00:32:58,360
这只是这些JavaScript对象，
所有这些增值经销商，从根本上。

604
00:32:58,360 --> 00:33:02,780
这是一个真正强大
办法原型您的应用程序。

605
00:33:02,780 --> 00:33:06,190
这就是为什么流星
利用了这一优势。

606
00:33:06,190 --> 00:33:11,080
>> 如果我们去到第三步，
让我们来看看发生了什么变化。

607
00:33:11,080 --> 00:33:15,480
如果我们看一下待办事项HTML，没有太大的。

608
00:33:15,480 --> 00:33:17,170
CSS并没有任何变化。

609
00:33:17,170 --> 00:33:22,420
但小的变化，我们在看到HTML
是我们改变了任务的定义。

610
00:33:22,420 --> 00:33:23,800
任务现在是一个函数。

611
00:33:23,800 --> 00:33:25,800
这意味着，每
一次，我们想要得到的任务，

612
00:33:25,800 --> 00:33:27,480
我们要运行这个功能。

613
00:33:27,480 --> 00:33:29,230
它不返回
函数为一个值。

614
00:33:29,230 --> 00:33:33,710
>> 流星是明智的实际运行
函数来看看我们出去。

615
00:33:33,710 --> 00:33:36,650
并返回这个东西叫做任务。

616
00:33:36,650 --> 00:33:40,650
我们已经在行一个定义的任务，
这是一个蒙戈集合。

617
00:33:40,650 --> 00:33:43,170
蒙戈是指
数据库流星使用，

618
00:33:43,170 --> 00:33:48,420
而这个新的意思只是让我们做
一个新的集合，称之为任务。

619
00:33:48,420 --> 00:33:53,540
在MySQL中，这将相当于
找表称为任务。

620
00:33:53,540 --> 00:33:56,350
蒙戈具有收藏，不表。

621
00:33:56,350 --> 00:34:00,100
因此，这只是看起来的任务。

622
00:34:00,100 --> 00:34:04,820
>> 现在，模板中我们
助手在模板中，所有的

623
00:34:04,820 --> 00:34:08,380
我们要做的，让所有的
任务是此功能，找到

624
00:34:08,380 --> 00:34:11,710
而这个空括号。

625
00:34:11,710 --> 00:34:14,150
这是更特别蒙戈语法。

626
00:34:14,150 --> 00:34:16,159
有大量的
在线文档如何

627
00:34:16,159 --> 00:34:19,360
你可以高效，
真正有用的蒙戈查询。

628
00:34:19,360 --> 00:34:25,560
但是，这样的事情是好的
足以让刚刚找到的所有数据。

629
00:34:25,560 --> 00:34:30,100
>> 现在，其中一个问题，你可能会看到
是，我们从来没有真正添加数据。

630
00:34:30,100 --> 00:34:35,020
所以会发生什么，当我们
实际运行第三步？

631
00:34:35,020 --> 00:34:37,550
让我们快速进入
步骤3和运行流星。

632
00:34:37,550 --> 00:34:42,870

633
00:34:42,870 --> 00:34:45,650
请注意，我有另外的流星
项目运行别的地方，

634
00:34:45,650 --> 00:34:49,110
所以流星不喜欢这一点。

635
00:34:49,110 --> 00:34:52,810
我只是要迅速接近
其他流星与控制C，

636
00:34:52,810 --> 00:34:55,780
进入第三步，
并再次运行流星。

637
00:34:55,780 --> 00:35:01,070

638
00:35:01,070 --> 00:35:03,180
请注意它的开始
MongoDB的，因为MongoDB的

639
00:35:03,180 --> 00:35:06,370
是每一个流星的项目的一部分。

640
00:35:06,370 --> 00:35:09,190
>> 所以说，我的申请有错误。

641
00:35:09,190 --> 00:35:10,590
这是一个不错的功能流星了。

642
00:35:10,590 --> 00:35:13,700
它确保您的
HTML是很好的验证。

643
00:35:13,700 --> 00:35:17,710
让我们赶紧来看看这可能是为什么。

644
00:35:17,710 --> 00:35:26,110
看来我得小心
抄错HTML代码。

645
00:35:26,110 --> 00:35:30,610
如果我保存它，现在，流星
自动重启服务器，

646
00:35:30,610 --> 00:35:34,650
现在的应用程序正在运行预期。

647
00:35:34,650 --> 00:35:39,220
请注意，以解决这个问题，你可以运行
步骤2相同的HTML文件，

648
00:35:39,220 --> 00:35:40,380
它复制到第三步。

649
00:35:40,380 --> 00:35:43,290

650
00:35:43,290 --> 00:35:45,917
>> 我们可以回到我们的本地主机。

651
00:35:45,917 --> 00:35:47,500
现在我们看到，我们有我们做的名单。

652
00:35:47,500 --> 00:35:50,070
伟大的，但它是空的。

653
00:35:50,070 --> 00:35:54,210
我们实际上没有任何
在我们的数据库中蒙哥任务。

654
00:35:54,210 --> 00:35:57,930
因此，让我们来谈谈一个
几个方面，我们可以做到这一点。

655
00:35:57,930 --> 00:36:03,240
如果我们回到码头，我们
可以将其关闭并运行流星蒙戈。

656
00:36:03,240 --> 00:36:05,320
>> 如果你熟悉
与流星是如何工作的，

657
00:36:05,320 --> 00:36:14,100
这实际上给你访问
充分的MongoDB的流星。

658
00:36:14,100 --> 00:36:17,570
请注意，您必须运行
第一次流星这个工作。

659
00:36:17,570 --> 00:36:23,840
所以，如果我跑这一个新的标签，我
可以回到同一目录中。

660
00:36:23,840 --> 00:36:29,040

661
00:36:29,040 --> 00:36:32,570
现在流星工作得很好。

662
00:36:32,570 --> 00:36:33,600
这是一个提示。

663
00:36:33,600 --> 00:36:36,350

664
00:36:36,350 --> 00:36:38,790
让我有点
更大，所以我们可以看到。

665
00:36:38,790 --> 00:36:41,550
这看起来比有点不同
你可能会用于向您

666
00:36:41,550 --> 00:36:42,869
并不真正需要使用蒙戈。

667
00:36:42,869 --> 00:36:45,410
我的整点这里
这样您就可以使用JavaScript。

668
00:36:45,410 --> 00:36:48,250
但是，如果你很好奇，
蒙戈API不

669
00:36:48,250 --> 00:36:50,730
使用SQL，结构化查询语言。

670
00:36:50,730 --> 00:36:55,570
它使用自己的语言
看起来很像的JavaScript。

671
00:36:55,570 --> 00:37:00,520
很快，我们就可以找到
经由db.tasks表。

672
00:37:00,520 --> 00:37:08,940
它在告诉我
事实证明，如果我们运行发现，

673
00:37:08,940 --> 00:37:13,450
一种类似于我们曾与
流星，我们可以加载所有的元素。

674
00:37:13,450 --> 00:37:17,330
问题是，我们不
实际上有定义的任何任务。

675
00:37:17,330 --> 00:37:20,600
所以不能让他们。

676
00:37:20,600 --> 00:37:22,130
>> 我们可以插入，但。

677
00:37:22,130 --> 00:37:25,170
因此，我们可以运行插入
使用命令插入。

678
00:37:25,170 --> 00:37:29,140
我们只是给它
一个对象，我们只是

679
00:37:29,140 --> 00:37:31,840
确保格式是我们所期望的。

680
00:37:31,840 --> 00:37:35,030
如果我们看第二步，
我们看到，每一个任务

681
00:37:35,030 --> 00:37:39,590
为一个对象与文本
作为密钥和任何

682
00:37:39,590 --> 00:37:41,640
你做的项目是作为一个变量。

683
00:37:41,640 --> 00:37:44,680
所以，我们可以做的东西在这里。

684
00:37:44,680 --> 00:37:50,160
>> 我们可以把它插入任务
叫我来自蒙戈。

685
00:37:50,160 --> 00:37:52,570
我们按Enter键，它运行。

686
00:37:52,570 --> 00:37:56,900
我们可以再次运行发现，我们
看到，有一个对象在这里。

687
00:37:56,900 --> 00:38:01,810
蒙戈它分配一个ID，你
并不需要担心。

688
00:38:01,810 --> 00:38:06,690
数据什么是重要的是你是
你把，是你出的数据。

689
00:38:06,690 --> 00:38:10,500
>> 让我们回到我们的网站，
哎，我们的任务加载。

690
00:38:10,500 --> 00:38:13,987
你可以看到，
由于流星是非常聪明的

691
00:38:13,987 --> 00:38:16,570
始终刷新你，我
没有触及页面。

692
00:38:16,570 --> 00:38:19,160
它会自动加载。

693
00:38:19,160 --> 00:38:23,520
>> 让我们来运行一些代码
虽然JavaScript的做到这一点。

694
00:38:23,520 --> 00:38:26,120
像我们有节点在后面
最终执行了JavaScript的，

695
00:38:26,120 --> 00:38:29,280
我们也可以运行JavaScript
直接在我们的浏览器。

696
00:38:29,280 --> 00:38:31,970
您可以通过一个功能做到这一点
所谓的检查元素。

697
00:38:31,970 --> 00:38:34,210
如果我右键点击一个
页面的部分中，

698
00:38:34,210 --> 00:38:36,730
还有一个选项
所谓的检查元素。

699
00:38:36,730 --> 00:38:38,840
如果你正在运行的
浏览器Safari浏览器一样，你

700
00:38:38,840 --> 00:38:45,430
可能需要启用您的开发
之前，你的工具得到这个功能。

701
00:38:45,430 --> 00:38:46,930
>> 我们关心的是控制台。

702
00:38:46,930 --> 00:38:48,930
所以，我们只是去了
控制台在底部。

703
00:38:48,930 --> 00:38:52,110

704
00:38:52,110 --> 00:38:55,970
现在，我们可以运行任何JavaScript
这里，如JavaScript的

705
00:38:55,970 --> 00:38:58,860
文件显示，我在js的例子。

706
00:38:58,860 --> 00:39:02,040
但是，现在让我们来看看任务。

707
00:39:02,040 --> 00:39:04,955
我们可以运行我们的命令。

708
00:39:04,955 --> 00:39:07,830
并希望我能做出
它有点大，所以我们都可以看到。

709
00:39:07,830 --> 00:39:14,390

710
00:39:14,390 --> 00:39:18,450
>> 如果我们运行tasks.find，你会
看，这是完全一样的代码

711
00:39:18,450 --> 00:39:24,840
该JavaScript文件的用途
在第三步，这task.find。

712
00:39:24,840 --> 00:39:29,100
我们可以运行同样的事情，
现在我们得到了一些奇怪的东西。

713
00:39:29,100 --> 00:39:31,050
我们如何真正得到的数据？

714
00:39:31,050 --> 00:39:34,860
好了，我们要运行这个
命令称取。

715
00:39:34,860 --> 00:39:37,150
>> 这对于调试是非常有用的。

716
00:39:37,150 --> 00:39:41,000
你这里是什么
一个光标，而这是

717
00:39:41,000 --> 00:39:44,890
一个很好的方式，有流星
优化取数据。

718
00:39:44,890 --> 00:39:48,270
此光标拥有所有的功能
现场更新和刷新页面

719
00:39:48,270 --> 00:39:49,650
当事情发生了变化。

720
00:39:49,650 --> 00:39:51,280
但它不会让我们的数据。

721
00:39:51,280 --> 00:39:52,720
我们可以通过获取数据。

722
00:39:52,720 --> 00:39:56,880
你看，我们有一个对象，
这就像我们曾在蒙戈，

723
00:39:56,880 --> 00:40:00,040
有ID和文字，我们把英寸

724
00:40:00,040 --> 00:40:04,200
>> 那么，如何才能插入流星的项目？

725
00:40:04,200 --> 00:40:07,250
好了，我们只是有任务。

726
00:40:07,250 --> 00:40:09,990
然后我们就可以运行
同样的插入命令，

727
00:40:09,990 --> 00:40:17,520
给一个字典或对象
具有相同的格式，文本

728
00:40:17,520 --> 00:40:22,340
然后我来自控制台。

729
00:40:22,340 --> 00:40:27,240
拿上面看看，因为当我
做到这一点，它显示了在网站上

730
00:40:27,240 --> 00:40:29,660
自动。

731
00:40:29,660 --> 00:40:33,291
>> 注意，你可以把任何东西
你想在这些项目。

732
00:40:33,291 --> 00:40:35,040
它不必
有一个固定的结构。

733
00:40:35,040 --> 00:40:39,790
我可以有一个等于所述
排名第三和b等于假。

734
00:40:39,790 --> 00:40:41,600
而这一切的作品。

735
00:40:41,600 --> 00:40:46,000
我甚至可以选择不
包括所有的文本。

736
00:40:46,000 --> 00:40:48,320
这仅仅是不推荐
但因为那时流星

737
00:40:48,320 --> 00:40:50,920
不知道要显示的内容。

738
00:40:50,920 --> 00:40:53,110
但是在每一种情况下，我们
获得一个ID，这是

739
00:40:53,110 --> 00:40:54,785
可以使用对象的ID。

740
00:40:54,785 --> 00:41:01,120

741
00:41:01,120 --> 00:41:03,280
>> 随着我们继续
第四步和第五步，

742
00:41:03,280 --> 00:41:06,870
本教程将告诉你如何说
您可以通过创建UI元素

743
00:41:06,870 --> 00:41:13,130
你知道的HTML
创建不同的任务。

744
00:41:13,130 --> 00:41:15,440
让我们来看看第四步真的很快。

745
00:41:15,440 --> 00:41:18,290
我们会看到，我们增加
一节有关的事件。

746
00:41:18,290 --> 00:41:20,874
模板可以具有
帮手，这让我们的数据。

747
00:41:20,874 --> 00:41:22,040
但它也可以称之为事件。

748
00:41:22,040 --> 00:41:25,300
而这正是东西
变得很有用，因为事件

749
00:41:25,300 --> 00:41:28,590
当您点击会发生什么
在您的网站不同的事情。

750
00:41:28,590 --> 00:41:33,790
>> 在这里，我们的代码是告诉
我们添加这个事件。

751
00:41:33,790 --> 00:41:38,860
添加它，当你已经提交
一些与一流的新任务。

752
00:41:38,860 --> 00:41:41,910
你在这里是一个CSS选择器。

753
00:41:41,910 --> 00:41:45,870
因此，这只是寻找一个HTML
元素具有一流的新任务。

754
00:41:45,870 --> 00:41:47,940
它看起来的事件，如提交。

755
00:41:47,940 --> 00:41:51,050
其他活动包括：
点击，悬停，双击，

756
00:41:51,050 --> 00:41:54,450
类似于您在普通HTML搞定。

757
00:41:54,450 --> 00:41:56,770
>> 现在你给它在这里是一个函数。

758
00:41:56,770 --> 00:42:01,210
你可以有你
在该功能的代码。

759
00:42:01,210 --> 00:42:06,360
这个功能是什么最终得到
所谓当您提交这项新任务。

760
00:42:06,360 --> 00:42:12,170
让我们来看看HTML只是让我们
明白这是什么新的任务。

761
00:42:12,170 --> 00:42:15,570
我们在这里增加了一个表格
与一流的新任务。

762
00:42:15,570 --> 00:42:19,880
并且它有一个输入端，取文本。

763
00:42:19,880 --> 00:42:22,605
而这正是我们
将增加我们的新任务。

764
00:42:22,605 --> 00:42:25,520

765
00:42:25,520 --> 00:42:29,780
>> 让我们在运行第四步
网站上看到是什么样子。

766
00:42:29,780 --> 00:42:32,710
我们可以退出先出
在MongoDB中，我们有

767
00:42:32,710 --> 00:42:35,300
从我们以往的
例如与控制C.

768
00:42:35,300 --> 00:42:37,690
让我们把它变成
步骤4目录。

769
00:42:37,690 --> 00:42:41,000

770
00:42:41,000 --> 00:42:42,920
我们将再次运行流星
启动服务器。

771
00:42:42,920 --> 00:42:46,850

772
00:42:46,850 --> 00:42:50,510
不幸的是，我有流星
在另一个终端上运行。

773
00:42:50,510 --> 00:42:53,080
所以我只是要
确保这一关。

774
00:42:53,080 --> 00:43:01,805
让我们离开这一点，并改变
第四部分，第四步。

775
00:43:01,805 --> 00:43:02,305
好不好。

776
00:43:02,305 --> 00:43:11,220

777
00:43:11,220 --> 00:43:13,250
>> 现在我们的流星代码运行。

778
00:43:13,250 --> 00:43:19,480
你可以看到，它更新，而不
我们甚至无需刷新页面。

779
00:43:19,480 --> 00:43:24,410
现在这里有什么改变的是
我们没有任何任务，

780
00:43:24,410 --> 00:43:29,530
但我们有一个表格在这里，这
文本框，增加我们的新任务。

781
00:43:29,530 --> 00:43:31,550
我们可以在这里键入我们的任务。

782
00:43:31,550 --> 00:43:34,564
我来自HTML页面。

783
00:43:34,564 --> 00:43:36,105
当我按下Enter键，它得到了提交。

784
00:43:36,105 --> 00:43:39,180

785
00:43:39,180 --> 00:43:44,540
>> 我们可以看到发生了什么的
由JavaScript代码中定义。

786
00:43:44,540 --> 00:43:49,930
这是什么功能做的是
从形式上采取文字，

787
00:43:49,930 --> 00:43:53,680
然后就被称为tasks.insert，
像我们一样在控制台中。

788
00:43:53,680 --> 00:43:56,410
他们也选择了加createdAt日期。

789
00:43:56,410 --> 00:43:59,840
这是你会如何
指定当前时刻。

790
00:43:59,840 --> 00:44:03,220
之后，它通过使清除的形式
确保值是空字符串。

791
00:44:03,220 --> 00:44:06,550
>> 然后调用返回false来
确保没有什么事情发生。

792
00:44:06,550 --> 00:44:10,350
当您从返回false
活动的形式，即停止执行。

793
00:44:10,350 --> 00:44:14,520
说形式有一个动作，
就像提交到PHP页面。

794
00:44:14,520 --> 00:44:16,980
如果你还没有回来
假的，你会返回true。

795
00:44:16,980 --> 00:44:18,500
这将最终使这一请求。

796
00:44:18,500 --> 00:44:20,590
假拦截它，
它停在那里。

797
00:44:20,590 --> 00:44:23,510

798
00:44:23,510 --> 00:44:28,610
>> 所以这是关于一个小演示
流星是如何工作的，我们已经

799
00:44:28,610 --> 00:44:30,980
一直跟随本教程一段时间。

800
00:44:30,980 --> 00:44:33,560
你可以请随时
自由地继续这样做。

801
00:44:33,560 --> 00:44:37,760
有丰富的资源，
和教程实际上只是

802
00:44:37,760 --> 00:44:40,400
很不错的关于解释
这是怎么回事。

803
00:44:40,400 --> 00:44:44,362
我现在要告诉你，在
我们已经离开了几分钟，

804
00:44:44,362 --> 00:44:46,320
什么是一些
流星冷却器的特点，

805
00:44:46,320 --> 00:44:48,772
什么是一些
更有用的包。

806
00:44:48,772 --> 00:44:51,730
一个关于流星的伟大的事情
是，你有一个包系统。

807
00:44:51,730 --> 00:44:55,620
您可以轻松地将代码
许多成千上万的开发者

808
00:44:55,620 --> 00:44:58,840
采写全球
到流星的项目。

809
00:44:58,840 --> 00:45:02,410
这方面的一个例子是，你可能
做的教程，其中第九步

810
00:45:02,410 --> 00:45:07,435
您要添加帐户
您流星的项目。

811
00:45:07,435 --> 00:45:10,010

812
00:45:10,010 --> 00:45:13,690
如果我们有一个CS50 PHP
项目中，我们将有

813
00:45:13,690 --> 00:45:17,810
依靠框架
或者我们自己的代码，以使

814
00:45:17,810 --> 00:45:20,820
确保我们安全地处理
密码和用户名

815
00:45:20,820 --> 00:45:23,120
并存储在数据库
和所有的这一点。

816
00:45:23,120 --> 00:45:25,670
>> 原来，流星有一些
包为你做的，

817
00:45:25,670 --> 00:45:29,160
而做到这一点很容易。

818
00:45:29,160 --> 00:45:31,950
我们所能做的就是添加了几包。

819
00:45:31,950 --> 00:45:37,450
因此，让我们做正确的
现在在我们的控制台。

820
00:45:37,450 --> 00:45:42,460
我要退出该项目，
现在进入简单待办事项。

821
00:45:42,460 --> 00:45:47,450

822
00:45:47,450 --> 00:45:50,050
现在，简单待办事项是
该项目你

823
00:45:50,050 --> 00:45:53,500
将正在做后
与步骤11或步骤12中，

824
00:45:53,500 --> 00:45:55,250
在本教程结束。

825
00:45:55,250 --> 00:45:58,642
让我们再看一下，看看
有哪些不同的特点，我们有。

826
00:45:58,642 --> 00:46:01,610
我们只是要确保它的运行。

827
00:46:01,610 --> 00:46:04,400
有时，它需要一段时间
刷新，但在这里它是。

828
00:46:04,400 --> 00:46:09,710
>> 我们有选择隐藏
完成任务，我们可以登录。

829
00:46:09,710 --> 00:46:11,770
这是与完成
流星包。

830
00:46:11,770 --> 00:46:12,270
这很棒。

831
00:46:12,270 --> 00:46:14,910
现在，我们已经用户名
和密码请登录。

832
00:46:14,910 --> 00:46:19,170
但是，如果我们想添加
另一种登录机制？

833
00:46:19,170 --> 00:46:22,560
比方说，我想记录
在我的流星账户。

834
00:46:22,560 --> 00:46:27,270
我要运行流星加，而这
是语法加包。

835
00:46:27,270 --> 00:46:32,160
我可以说的帐户，并accounts.meteor。

836
00:46:32,160 --> 00:46:35,720
这将现在发现
包并加载它。

837
00:46:35,720 --> 00:46:40,480
你可以看到，我没有
找到了合适的包名。

838
00:46:40,480 --> 00:46:42,820
>> 那么，你如何了解包？

839
00:46:42,820 --> 00:46:46,380
那么有一个伟大的网站，做
可用的流星人，

840
00:46:46,380 --> 00:46:47,780
所谓atmospherejs.com。

841
00:46:47,780 --> 00:46:52,520
Atmospherejs，一个字，点
COM，是一个伟大的库

842
00:46:52,520 --> 00:46:57,660
寻找所有的流星
包存储库中。

843
00:46:57,660 --> 00:47:05,140
我可以搜索帐户，然后
它会告诉我所有的东西有关，

844
00:47:05,140 --> 00:47:07,320
所有包与该帐户的名称。

845
00:47:07,320 --> 00:47:10,180

846
00:47:10,180 --> 00:47:13,270
>> 而加载，我们可以尝试
加入一些其他的包。

847
00:47:13,270 --> 00:47:19,380
也许流星包不工作
现在，我可以添加Facebook的。

848
00:47:19,380 --> 00:47:22,860

849
00:47:22,860 --> 00:47:27,190
我可以添加的帐户，然后
再次运行流星项目。

850
00:47:27,190 --> 00:47:33,260

851
00:47:33,260 --> 00:47:36,900
一旦开始，让我们来看看
什么网站上发生变化。

852
00:47:36,900 --> 00:47:40,010

853
00:47:40,010 --> 00:47:44,580
您可以see--我可能
要在这里刷新。

854
00:47:44,580 --> 00:47:47,320
>> 我有一个按钮，
配置Facebook登录。

855
00:47:47,320 --> 00:47:49,765
在这里，我把所有
说明流星

856
00:47:49,765 --> 00:47:52,960
已经为你准备的
建立一个Facebook应用程序。

857
00:47:52,960 --> 00:47:58,990
你可以使用
信息的添加您的ID。

858
00:47:58,990 --> 00:48:04,130
一旦这样做了，你就会有
Facebook登录在你的应用程序工作。

859
00:48:04,130 --> 00:48:08,559
>> 我只是要得到
一个应用程序ID和秘密，

860
00:48:08,559 --> 00:48:10,100
只是为了显示你如何可能会奏效。

861
00:48:10,100 --> 00:48:16,000

862
00:48:16,000 --> 00:48:20,360
您将需要一个Facebook帐户
使用Facebook开发者选项。

863
00:48:20,360 --> 00:48:31,160

864
00:48:31,160 --> 00:48:35,290
让我很快找到
流星密钥所必需。

865
00:48:35,290 --> 00:48:46,994

866
00:48:46,994 --> 00:48:49,160
我还有一个流星的项目
我要去使用，

867
00:48:49,160 --> 00:48:55,590
而我只是要带
钥匙从该文件。

868
00:48:55,590 --> 00:49:14,410

869
00:49:14,410 --> 00:49:20,930
>> 一旦我找到它，我就可以
这些键复制到我的Facebook。

870
00:49:20,930 --> 00:49:23,489
因此，这里是一个关键。

871
00:49:23,489 --> 00:49:24,280
这是秘密。

872
00:49:24,280 --> 00:49:26,071
你不应该
与人分享这些。

873
00:49:26,071 --> 00:49:28,870

874
00:49:28,870 --> 00:49:30,910
然后你给它您的应用程序的秘密。

875
00:49:30,910 --> 00:49:33,560
这是如此的Facebook
知道你是你。

876
00:49:33,560 --> 00:49:37,630

877
00:49:37,630 --> 00:49:39,080
你保存配置。

878
00:49:39,080 --> 00:49:45,160

879
00:49:45,160 --> 00:49:48,640
>> 我觉得在这个过程中我
已经停止我的流星应用程序。

880
00:49:48,640 --> 00:49:52,290
所以，我只是想
确保它仍然存在。

881
00:49:52,290 --> 00:49:54,962

882
00:49:54,962 --> 00:49:58,610
OK，让我们确保我们的流星服务器
运行，以便该网页正在运行。

883
00:49:58,610 --> 00:50:02,440
请注意，如果我们停止流星
服务器，页面仍然存在。

884
00:50:02,440 --> 00:50:04,700
它只是不会再更新。

885
00:50:04,700 --> 00:50:10,290
流星服务器是必要的
为确保该页面是活的。

886
00:50:10,290 --> 00:50:14,050
>> OK，我已经提交了，现在
我可以签署旅游。

887
00:50:14,050 --> 00:50:17,400
现在它只是一个问题
有一个Facebook的弹出

888
00:50:17,400 --> 00:50:21,710
并把您的帐户
在信息和记录。

889
00:50:21,710 --> 00:50:24,520

890
00:50:24,520 --> 00:50:27,930
一旦你做到这一点，Facebook的可能
老马你一些更安全。

891
00:50:27,930 --> 00:50:29,810
所以，我们就就此打住。

892
00:50:29,810 --> 00:50:34,110
问题是，当你完成
就这样，你就会有Facebook登录。

893
00:50:34,110 --> 00:50:37,850
>> 流星有一堆
其他包为好。

894
00:50:37,850 --> 00:50:39,200
您可以通过Google+登录。

895
00:50:39,200 --> 00:50:40,500
您可以GitHub上登录。

896
00:50:40,500 --> 00:50:42,170
您可以与Twitter登录。

897
00:50:42,170 --> 00:50:44,870
或者，如果你搜索，你会
发现很多其他的事情

898
00:50:44,870 --> 00:50:49,170
像Meetup网站，LinkedIn，
和流星开发。

899
00:50:49,170 --> 00:50:53,100
所以流星开发是
包我一直在寻找。

900
00:50:53,100 --> 00:50:56,170
流星添加帐户，流星开发商。

901
00:50:56,170 --> 00:51:06,192

902
00:51:06,192 --> 00:51:07,900
在此期间，我
也想推荐

903
00:51:07,900 --> 00:51:11,340
一些其他的包为您的项目。

904
00:51:11,340 --> 00:51:14,670
它可能证明是有益的
包括jQuery的包。

905
00:51:14,670 --> 00:51:17,909
这使您可以使用
jQuery的在你的客户。

906
00:51:17,909 --> 00:51:21,200
你可能只是做一个路线，
流星会确保你最新的

907
00:51:21,200 --> 00:51:21,825
jQuery的。

908
00:51:21,825 --> 00:51:24,330

909
00:51:24,330 --> 00:51:27,450
我还建议休斯顿：管理员。

910
00:51:27,450 --> 00:51:31,550
>> 这有点像一个phpMyAdmin的
这种工具为您的MongoDB。

911
00:51:31,550 --> 00:51:33,890
这使您可以编辑
您的数据很容易

912
00:51:33,890 --> 00:51:37,950
而不必去到蒙戈外壳，
就像我早先在研讨会上做了。

913
00:51:37,950 --> 00:51:43,160

914
00:51:43,160 --> 00:51:47,101
所以，现在说的运行，让我们运行
再次流星，看看我们能做些什么。

915
00:51:47,101 --> 00:51:56,240

916
00:51:56,240 --> 00:52:00,720
>> 您会注意到添加一些包
可能有他们提出了一些警告。

917
00:52:00,720 --> 00:52:02,720
您将不必担心
关于与休斯敦。

918
00:52:02,720 --> 00:52:06,040

919
00:52:06,040 --> 00:52:10,810
所以，我们现在可以有选择
配置流星管理。

920
00:52:10,810 --> 00:52:15,080
他们给你方向
如果你想设置了起来。

921
00:52:15,080 --> 00:52:17,750

922
00:52:17,750 --> 00:52:20,440
>> 我们也可以现在去/管理。

923
00:52:20,440 --> 00:52:23,280
这是赞助商
由休斯顿包。

924
00:52:23,280 --> 00:52:27,470
这是流星管理界面。

925
00:52:27,470 --> 00:52:30,660
你只需创建一个
管理员帐户，像这样。

926
00:52:30,660 --> 00:52:38,150
如果你刷新页面，则可能
有一些收藏品显示出来。

927
00:52:38,150 --> 00:52:40,980

928
00:52:40,980 --> 00:52:43,460
>> 这是一个非常有用的工具，
我强烈推荐它。

929
00:52:43,460 --> 00:52:46,717

930
00:52:46,717 --> 00:52:49,050
你可以看到，因为
休斯顿是给一些错误，

931
00:52:49,050 --> 00:52:52,330
我们没有任何收藏
显示了现在。

932
00:52:52,330 --> 00:52:56,800
你会用火箭的方式是
确保这一功能得到

933
00:52:56,800 --> 00:52:58,860
叫你简单待办事项。

934
00:52:58,860 --> 00:53:01,370
所以火箭不
知道我的任务。

935
00:53:01,370 --> 00:53:04,490
>> 我们建立了一个蒙戈
收集所谓的任务。

936
00:53:04,490 --> 00:53:11,390
让我们进入简单待办事项和公正
确保在JavaScript中，

937
00:53:11,390 --> 00:53:16,295
我们增加了任务，我们的产品系列。

938
00:53:16,295 --> 00:53:19,340

939
00:53:19,340 --> 00:53:25,670
现在，我们已经保存，它的建设
该应用程序，令人耳目一新。

940
00:53:25,670 --> 00:53:26,750
让我们来看看。

941
00:53:26,750 --> 00:53:29,090
现在我们有一些任务。

942
00:53:29,090 --> 00:53:32,630
我们可以添加一些新的任务。

943
00:53:32,630 --> 00:53:35,840
但是，如果我们想要添加的任务，
让我们做它的应用程序本身。

944
00:53:35,840 --> 00:53:39,660

945
00:53:39,660 --> 00:53:41,050
>> 现在，我们可以添加一些数据。

946
00:53:41,050 --> 00:53:53,410
嗨，这是一个任务。

947
00:53:53,410 --> 00:53:57,080
这似乎有点怪
我们没有看到任何任务。

948
00:53:57,080 --> 00:54:00,290

949
00:54:00,290 --> 00:54:05,260
我们可能要检查，如果我们有任何
这里的错误，或者其他地方。

950
00:54:05,260 --> 00:54:08,810

951
00:54:08,810 --> 00:54:20,260
如果我们去管理，这似乎有些奇怪。

952
00:54:20,260 --> 00:54:24,080
如果你拉库
本次研讨会后，

953
00:54:24,080 --> 00:54:27,580
我会确保
简单待办事项工程与休斯敦。

954
00:54:27,580 --> 00:54:30,370
不幸的是，它似乎并没有
是在这个非常时刻的工作。

955
00:54:30,370 --> 00:54:34,810

956
00:54:34,810 --> 00:54:37,640
>> 是否有任何其他的问题吗？

957
00:54:37,640 --> 00:54:41,800
休斯顿通常是
工具，工作得非常好。

958
00:54:41,800 --> 00:54:44,510
休斯顿特别是有点
比其他的buggier，

959
00:54:44,510 --> 00:54:49,470
但我推荐它时，它的工作原理。

960
00:54:49,470 --> 00:54:50,080
是啊。

961
00:54:50,080 --> 00:54:52,395
>> 听众：你能做些什么
与Facebook包

962
00:54:52,395 --> 00:54:54,270
一旦用户已登录
在他们的Facebook？

963
00:54:54,270 --> 00:54:55,978
>> ROGER ZURAWICKI：一旦
用户的登录，

964
00:54:55,978 --> 00:54:59,540
您可以拨打电话到Facebook的API。

965
00:54:59,540 --> 00:55:02,890
很多摆在更加
如何Facebook的开放他们的API。

966
00:55:02,890 --> 00:55:05,120
流星，请确保您
有连接。

967
00:55:05,120 --> 00:55:09,300
但在那之后一切问题
学习如何使用Facebook的API。

968
00:55:09,300 --> 00:55:10,216
观众：[听不清]。

969
00:55:10,216 --> 00:55:17,756

970
00:55:17,756 --> 00:55:18,880
ROGER ZURAWICKI：好的。

971
00:55:18,880 --> 00:55:21,670
非常感谢您的
这CS50研讨会流星。

972
00:55:21,670 --> 00:55:24,060
如果你有任何问题，
你可以给我发电子邮件

973
00:55:24,060 --> 00:55:28,319
我的电子邮件地址
下面列出了研讨会。

974
00:55:28,319 --> 00:55:30,110
我会很高兴的
回答你的问题。

975
00:55:30,110 --> 00:55:33,020
我也可以在
CS50黑客马拉松应

976
00:55:33,020 --> 00:55:35,550
你需要与你的流星的项目提供帮助。

977
00:55:35,550 --> 00:55:37,650
感谢您的收看。

978
00:55:37,650 --> 00:55:38,816