1
00:00:00,000 --> 00:00:11,050

2
00:00:11,050 --> 00:00:13,351
>> ROB BOWDEN：这是
更舒适的节，

3
00:00:13,351 --> 00:00:16,309
但是，这并不意味着，如果你
觉得你是不是更舒服

4
00:00:16,309 --> 00:00:18,420
你不会学到的东西在这里。

5
00:00:18,420 --> 00:00:20,600
因此，让我们开始吧。

6
00:00:20,600 --> 00:00:22,819
你有滑梯
直入事情。

7
00:00:22,819 --> 00:00:24,360
难道我只是把它的权利吗？

8
00:00:24,360 --> 00:00:25,680

9
00:00:25,680 --> 00:00:26,450
开关笔记本电脑。

10
00:00:26,450 --> 00:00:30,470

11
00:00:30,470 --> 00:00:32,950
>> 艾里逊：你不想要
自我介绍一下，罗布？

12
00:00:32,950 --> 00:00:34,090
>> 罗布·鲍登：哦，我抢。

13
00:00:34,090 --> 00:00:35,182

14
00:00:35,182 --> 00:00:37,470
这是我的第五个年头TF-ING CS50。

15
00:00:37,470 --> 00:00:38,760

16
00:00:38,760 --> 00:00:39,650
>> GABRIEL：我是加布里埃尔。

17
00:00:39,650 --> 00:00:41,610
我是CS50的头TF。

18
00:00:41,610 --> 00:00:44,009
我是TF在去年和今年。

19
00:00:44,009 --> 00:00:46,675
艾里逊：我是艾莉森，这
是我的第二个年头TF-ING CS50。

20
00:00:46,675 --> 00:00:48,510

21
00:00:48,510 --> 00:00:50,825
>> 罗布·鲍登：好吧，那么
这个东西在左边，

22
00:00:50,825 --> 00:00:52,250
希望你以前见过它。

23
00:00:52,250 --> 00:00:54,112
如果不是因为你
下载为自己，

24
00:00:54,112 --> 00:00:55,570
你应该已经看到了在课堂上。

25
00:00:55,570 --> 00:00:56,590

26
00:00:56,590 --> 00:01:01,320
所以这是CS50家电，和他
做了一定程度的相关描述

27
00:01:01,320 --> 00:01:01,880
在演讲。

28
00:01:01,880 --> 00:01:06,890
但基本上它只是你
正在运行的操作

29
00:01:06,890 --> 00:01:10,550
您的操作系统中的系统
系统，使我们可以给你

30
00:01:10,550 --> 00:01:12,540
无需计划
不用担心哦是这样的

31
00:01:12,540 --> 00:01:15,989
上班在Windows上
和Mac，或者如果你们中的一些

32
00:01:15,989 --> 00:01:17,280
已经使用Linux，Linux操作系统。

33
00:01:17,280 --> 00:01:18,532

34
00:01:18,532 --> 00:01:20,240
这只是应该
是一种常见的演奏

35
00:01:20,240 --> 00:01:23,010
字段，以便每个人都有
完全相同的环境。

36
00:01:23,010 --> 00:01:25,344
>> 所以，如果你还没有
下载了这个已经，

37
00:01:25,344 --> 00:01:28,510
你应该下载它，因为你
会需要它的习题集。

38
00:01:28,510 --> 00:01:32,335
并且它是一个2千兆字节
下载，所以它可能需要一段时间。

39
00:01:32,335 --> 00:01:33,780
在哈佛，它会走的快。

40
00:01:33,780 --> 00:01:35,870

41
00:01:35,870 --> 00:01:37,440
所以CS50设备。

42
00:01:37,440 --> 00:01:41,980
>> 现在，在开始的时候，我们要
说说只是一堆命令行

43
00:01:41,980 --> 00:01:46,880
的东西，所以通过这一点，我的意思是工作
在这边这个小环境。

44
00:01:46,880 --> 00:01:53,230
并注意所有的东西
我说就在这里，现在

45
00:01:53,230 --> 00:01:56,900
会，如果你的内部工作
组件内的端子，

46
00:01:56,900 --> 00:02:00,790
或者，如果你是内
在gedit中终端窗口

47
00:02:00,790 --> 00:02:02,090
内的器具的。

48
00:02:02,090 --> 00:02:03,770
所以这些环境是相同的。

49
00:02:03,770 --> 00:02:04,940

50
00:02:04,940 --> 00:02:07,270
>> 但我会去三分之一的路线。

51
00:02:07,270 --> 00:02:12,200
并注意倒在这里
这里有点IP地址。

52
00:02:12,200 --> 00:02:15,940
所以，你不必
做到这一点，但这个IP

53
00:02:15,940 --> 00:02:19,700
address--现在如果我 - 除非
它阻止这件事情。

54
00:02:19,700 --> 00:02:22,790

55
00:02:22,790 --> 00:02:27,000
OK，这样IP地址
过在终端

56
00:02:27,000 --> 00:02:31,090
这里 - 所以这个终端上
这里是我的Mac终端。

57
00:02:31,090 --> 00:02:34,540
因此，这是目前没有办法
与设备在所有相关联。

58
00:02:34,540 --> 00:02:39,360
如果你使用的是Windows，那么你
将需要下载的东西

59
00:02:39,360 --> 00:02:44,430
专门为此，特别
人们往往用腻子，P-U-T-T-Y。

60
00:02:44,430 --> 00:02:50,700
>> 所以，我什么都做的是类型
SSH和然后该IP地址。

61
00:02:50,700 --> 00:02:54,030
好吧，jharvard在该IP地址。

62
00:02:54,030 --> 00:03:00,150
所以192.168.24.220。

63
00:03:00,150 --> 00:03:02,127
这个可怕的消息，忽略它。

64
00:03:02,127 --> 00:03:02,710
只需输入yes。

65
00:03:02,710 --> 00:03:04,550

66
00:03:04,550 --> 00:03:06,030
这是CS50在一个盒子里。

67
00:03:06,030 --> 00:03:07,460
它会询问你的密码。

68
00:03:07,460 --> 00:03:11,910
>> 所以在很多这些上下文中的
它要求输入密码，[听不清]。

69
00:03:11,910 --> 00:03:15,670
我们已经得到了很多的问题在哪里
它说，它实际上不是打字。

70
00:03:15,670 --> 00:03:20,011
它不会告诉你的人物
密码在您键入，如果有的话，

71
00:03:20,011 --> 00:03:23,010
对于一个安全功能，因为如果
有人找你的肩膀上

72
00:03:23,010 --> 00:03:25,870
他们看到明星明星
明星星，那么他们

73
00:03:25,870 --> 00:03:28,640
知道你的密码
是四个大字。

74
00:03:28,640 --> 00:03:32,660
这样的想法是它会询问
您的密码，请键入。

75
00:03:32,660 --> 00:03:34,490
它不会显示
你的字符，

76
00:03:34,490 --> 00:03:36,090
但它实际上是接受他们。

77
00:03:36,090 --> 00:03:39,210
在这种情况下，任何时候你
曾经看到一个密码提示

78
00:03:39,210 --> 00:03:42,280
处理设备，所述
密码将是深红色的。

79
00:03:42,280 --> 00:03:43,270
所以绯红。

80
00:03:43,270 --> 00:03:44,730

81
00:03:44,730 --> 00:03:50,550
>> 现在这里的这里面
窗口是在我的Mac上，

82
00:03:50,550 --> 00:03:54,120
我基本上有
完全相同的看法

83
00:03:54,120 --> 00:03:57,040
作为终端的内部
在产品中。

84
00:03:57,040 --> 00:03:58,470
所以，你不必这样做。

85
00:03:58,470 --> 00:04:01,300
你可以做一切你
希望该设备的内部。

86
00:04:01,300 --> 00:04:05,140
我几乎从来没有真正做
任何在产品中。

87
00:04:05,140 --> 00:04:09,440
我几乎总是最小化，现在
我正在通过SSH进入组件。

88
00:04:09,440 --> 00:04:11,480

89
00:04:11,480 --> 00:04:14,180
>> 如果有什么事情，如果你
具有较慢的计算机，

90
00:04:14,180 --> 00:04:15,820
你可能会注意到一个区别。

91
00:04:15,820 --> 00:04:18,839
我这样做是因为我喜欢
这个终端窗口。

92
00:04:18,839 --> 00:04:20,881
它有像某些功能
我可以分割窗口，

93
00:04:20,881 --> 00:04:22,672
现在我可以SSH方式
通过设备。

94
00:04:22,672 --> 00:04:24,105
我有两个SSH的一次事情。

95
00:04:24,105 --> 00:04:28,030

96
00:04:28,030 --> 00:04:32,250
如果你的电脑是特别慢
和你的工作在家电，

97
00:04:32,250 --> 00:04:35,200
你知道这是
真的laggy，等等。

98
00:04:35,200 --> 00:04:38,220
往往要快很多
如果你是SSH-ED英寸

99
00:04:38,220 --> 00:04:40,960
但除此之外，你可以工作两种方式。

100
00:04:40,960 --> 00:04:42,388
>> 听众：什么是SSH是什么意思？

101
00:04:42,388 --> 00:04:43,820

102
00:04:43,820 --> 00:04:47,479
>> 罗布·鲍登：安全壳，
类似的东西？

103
00:04:47,479 --> 00:04:48,270
什么是SSH是什么意思？

104
00:04:48,270 --> 00:04:54,214

105
00:04:54,214 --> 00:04:55,130
GABRIEL：安全壳。

106
00:04:55,130 --> 00:04:56,463
艾里逊：这只是安全壳。

107
00:04:56,463 --> 00:04:57,720
罗布·鲍登：安全壳。

108
00:04:57,720 --> 00:05:03,700
这是一个协议，你 - 这是
安全协议，从而进行加密。

109
00:05:03,700 --> 00:05:06,850
让人无法窥探的网络
看到你说要什么有什么

110
00:05:06,850 --> 00:05:08,120
你是SSH-ED来。

111
00:05:08,120 --> 00:05:12,900
而事实上，在古代
CS50的日子，因此在2009年

112
00:05:12,900 --> 00:05:19,300
当我还是个大一的方式，
你曾CS50习题集，

113
00:05:19,300 --> 00:05:22,490
是你的SSH-ED一些服务器
我们给您访问，

114
00:05:22,490 --> 00:05:23,497
而你的工作在那里。

115
00:05:23,497 --> 00:05:25,330
所以，你没有这个
图形设备。

116
00:05:25,330 --> 00:05:26,160
你没有gedit中。

117
00:05:26,160 --> 00:05:28,930
你没有这些东西，
你可以视觉化的指向和点击。

118
00:05:28,930 --> 00:05:30,346
你有这个接口才能正常工作。

119
00:05:30,346 --> 00:05:31,580

120
00:05:31,580 --> 00:05:33,716
我更喜欢在此界面中工作。

121
00:05:33,716 --> 00:05:36,090
那么，我们要的一部分
将要在现在

122
00:05:36,090 --> 00:05:39,560
一堆的
命令，你应该

123
00:05:39,560 --> 00:05:42,095
开始熟悉的
你在使用过程中走。

124
00:05:42,095 --> 00:05:43,190

125
00:05:43,190 --> 00:05:45,790
而且说实话，当你
习惯了，它

126
00:05:45,790 --> 00:05:48,220
这么多快
在这种环境中工作

127
00:05:48,220 --> 00:05:53,690
比它与取景工作，
拖动和点击的东西。

128
00:05:53,690 --> 00:05:55,340

129
00:05:55,340 --> 00:05:57,210
>> 所以，我们在这里。

130
00:05:57,210 --> 00:06:01,779
现在我只是SSH-ED在等
默认location--你

131
00:06:01,779 --> 00:06:04,820
看到了一些在课堂上这些命令，
但我们去了所有的人了。

132
00:06:04,820 --> 00:06:08,060
默认位置我们
在是主目录。

133
00:06:08,060 --> 00:06:11,520
和目录，只是
另一个字的文件夹。

134
00:06:11,520 --> 00:06:13,310
所以我们在主目录中。

135
00:06:13,310 --> 00:06:15,889
输入ls，列出文件
在这个目录中。

136
00:06:15,889 --> 00:06:17,430
显然，我创建了一个blah.c更早。

137
00:06:17,430 --> 00:06:19,120

138
00:06:19,120 --> 00:06:20,472
因此，我们有一个桌面目录。

139
00:06:20,472 --> 00:06:21,930
你注意到了语法高亮？

140
00:06:21,930 --> 00:06:27,400

141
00:06:27,400 --> 00:06:32,900
淡蓝色的高亮显示
目录和直白

142
00:06:32,900 --> 00:06:34,380
表示只是一个纯文本文件。

143
00:06:34,380 --> 00:06:35,410

144
00:06:35,410 --> 00:06:37,690
所以有将要
你看到一些其他颜色。

145
00:06:37,690 --> 00:06:41,240
一个可执行文件，很可能会
是绿色的或类似的东西。

146
00:06:41,240 --> 00:06:44,820
好了，我们是在主目录中。

147
00:06:44,820 --> 00:06:48,970
>> 现在，如果我想进入一个不同的
目录中，CD是我想要的命令。

148
00:06:48,970 --> 00:06:52,720
所以，改变目录，然后你
通过该目录的名称

149
00:06:52,720 --> 00:06:54,020
你想进入。

150
00:06:54,020 --> 00:06:55,780
所以在这里我们有四个选项。

151
00:06:55,780 --> 00:07:03,397
我可以进入下载了，现在我们看到的
这里已经更新了这个括号

152
00:07:03,397 --> 00:07:04,480
说我在〜/下载。

153
00:07:04,480 --> 00:07:05,620

154
00:07:05,620 --> 00:07:06,800
>> 那么，什么是波浪？

155
00:07:06,800 --> 00:07:10,640
这是一个简写
你的home目录。

156
00:07:10,640 --> 00:07:15,260
所以，你做的几乎一切都会好起来
是相对于你的home目录，

157
00:07:15,260 --> 00:07:20,620
和PWD只是一个命令
我在一年使用一次即

158
00:07:20,620 --> 00:07:22,420
只是打印当前目录。

159
00:07:22,420 --> 00:07:25,730
所以你看这里
〜/下载真正解决

160
00:07:25,730 --> 00:07:26,896
到/ home / jharvard /下载。

161
00:07:26,896 --> 00:07:29,320

162
00:07:29,320 --> 00:07:32,230
因此，/家用/ jharvard是我的主目录。

163
00:07:32,230 --> 00:07:33,700

164
00:07:33,700 --> 00:07:39,400
>> 因此，我们可以CD点点。

165
00:07:39,400 --> 00:07:47,800
现在，点点是一个特殊的目录
总是指一个目录了。

166
00:07:47,800 --> 00:07:51,730
所以，如果我在〜/下载，那么CD点
点是要带我去波浪线。

167
00:07:51,730 --> 00:07:52,950

168
00:07:52,950 --> 00:07:55,490
什么是我们认为CD点点
是要带我去吗？

169
00:07:55,490 --> 00:07:58,740

170
00:07:58,740 --> 00:08:00,570
它会带我到/ home。

171
00:08:00,570 --> 00:08:04,450
因此，通过打印工作目录波浪线，
我在现在的/ home / jharvard。

172
00:08:04,450 --> 00:08:06,060

173
00:08:06,060 --> 00:08:08,820
从一个目录时，
现在，这里说的/ home。

174
00:08:08,820 --> 00:08:12,330

175
00:08:12,330 --> 00:08:17,180
>> 现在CD点点。

176
00:08:17,180 --> 00:08:20,910
现在我在根目录下，
你不能再这样做。

177
00:08:20,910 --> 00:08:23,340
你会仅仅停留在
根目录下去。

178
00:08:23,340 --> 00:08:26,700
根目录下有一大堆
，如果你想看看的东西，

179
00:08:26,700 --> 00:08:27,410
您可以。

180
00:08:27,410 --> 00:08:29,700
例如，如果我去
成箱，包含

181
00:08:29,700 --> 00:08:35,789
所有这些二进制文件，如ls，
和CD，以及所有这些事情。

182
00:08:35,789 --> 00:08:38,630
因此，这些命令需要
存在于系统中的某个地方，

183
00:08:38,630 --> 00:08:40,820
它是在/ bin目录下。

184
00:08:40,820 --> 00:08:44,530
但是你做的几乎一切
将是从你的主目录。

185
00:08:44,530 --> 00:08:49,490
和CD对此不承担任何参数，
你可以说CD〜，不需要。

186
00:08:49,490 --> 00:08:51,810
CD将会给你带来
回到你的home目录。

187
00:08:51,810 --> 00:08:53,170

188
00:08:53,170 --> 00:08:54,230
>> 其中最后一个。

189
00:08:54,230 --> 00:09:00,200
CD  - 将会给你带来回
你是在最后一个目录。

190
00:09:00,200 --> 00:09:04,080
所以，我只是cd'd连续两次，所以我
最后的目录是主目录。

191
00:09:04,080 --> 00:09:11,520
如果我去削减斌，现在
让我们上去，进入用户。

192
00:09:11,520 --> 00:09:12,550

193
00:09:12,550 --> 00:09:13,280
用户份额。

194
00:09:13,280 --> 00:09:14,840

195
00:09:14,840 --> 00:09:15,940
让我们去的用户份额。

196
00:09:15,940 --> 00:09:17,140
现在，我现在在用户份额。

197
00:09:17,140 --> 00:09:19,320
CD  - 早在箱中。

198
00:09:19,320 --> 00:09:22,980
所以这变得特别有用
当你have--，它会切换。

199
00:09:22,980 --> 00:09:25,660
所以用户份额，回仓，仓份额。

200
00:09:25,660 --> 00:09:27,250
>> 所以这变得非常有用。

201
00:09:27,250 --> 00:09:33,150
你会发现自己有很多，
很多很多嵌套的目录。

202
00:09:33,150 --> 00:09:37,370
而你想要做的事
真正的快速的上一级目录。

203
00:09:37,370 --> 00:09:40,330
你去到该目录，使
变化之类的东西，

204
00:09:40,330 --> 00:09:42,400
现在你想要去
回到你在哪里。

205
00:09:42,400 --> 00:09:43,660
CD  - 。

206
00:09:43,660 --> 00:09:47,320
我总是很沮丧
当我正好去

207
00:09:47,320 --> 00:09:49,630
该目录我
想干的工作英寸

208
00:09:49,630 --> 00:09:52,670
我总是感到沮丧时，我做了
这两个步骤，而不是一个步骤，

209
00:09:52,670 --> 00:09:55,715
因为这意味着CD  - 是怎么回事
带入的中间位置

210
00:09:55,715 --> 00:09:57,010
而不是在这里我想去的地方。

211
00:09:57,010 --> 00:09:59,350

212
00:09:59,350 --> 00:10:01,450
>> 所以我们看到所有的列表文件。

213
00:10:01,450 --> 00:10:03,300
我们知道如何解决为止。

214
00:10:03,300 --> 00:10:09,900
所以，现在让我们来谈谈编辑文件。

215
00:10:09,900 --> 00:10:18,790
所以在这个过程中，你几乎
总是希望用gedit。

216
00:10:18,790 --> 00:10:24,410
如果你愿意，你可以采取的下一个步骤
并开始学习命令行的文本

217
00:10:24,410 --> 00:10:25,240
编辑器。

218
00:10:25,240 --> 00:10:27,560
因此，不同的选项存在。

219
00:10:27,560 --> 00:10:31,760
>> 和那些可能
将与您，

220
00:10:31,760 --> 00:10:35,340
我们有纳米时，Vim，和Emacs。

221
00:10:35,340 --> 00:10:40,196
因此，Nano是初学者
命令行的文本编辑器。

222
00:10:40,196 --> 00:10:42,985
因此，纳米，让我们去
blah.c我刚才创建的。

223
00:10:42,985 --> 00:10:44,030

224
00:10:44,030 --> 00:10:46,480
这只是这个标准的C文件。

225
00:10:46,480 --> 00:10:51,540
你看到一大堆的东西
在屏幕底部的继续，

226
00:10:51,540 --> 00:10:54,100
显然blah.c
这包含C代码。

227
00:10:54,100 --> 00:10:55,420

228
00:10:55,420 --> 00:11:00,330
>> 所以在这个特定的编辑器，
它是说在bottom--

229
00:11:00,330 --> 00:11:06,290
现在这个插入符号的象征，
我们看到的这款^ G，^ X，^ o。

230
00:11:06,290 --> 00:11:10,310
因此，在几乎所有
的背景下，你看，

231
00:11:10,310 --> 00:11:13,530
你可能会看到插入符号符号
其他地方上网，对堆栈溢出，

232
00:11:13,530 --> 00:11:14,450
类似的东西。

233
00:11:14,450 --> 00:11:16,970
它几乎总是指控制。

234
00:11:16,970 --> 00:11:21,590
因此，要退出我想做的事情
十，控制控制X，退出。

235
00:11:21,590 --> 00:11:22,750

236
00:11:22,750 --> 00:11:26,855
我可以用我的箭
键移动。

237
00:11:26,855 --> 00:11:28,010

238
00:11:28,010 --> 00:11:31,015
请注意，我不能指向和点击爽快。

239
00:11:31,015 --> 00:11:33,000

240
00:11:33,000 --> 00:11:35,010
你需要用你的箭头
键移动。

241
00:11:35,010 --> 00:11:36,950
有可能是一个设置
指向和点击。

242
00:11:36,950 --> 00:11:40,000
>> 但是让我们做出一些改变。

243
00:11:40,000 --> 00:11:42,100
现在控制X去退出。

244
00:11:42,100 --> 00:11:44,120
它会说保存修改过的缓冲区。

245
00:11:44,120 --> 00:11:47,900
现在的提示，Y（是），N（否）。

246
00:11:47,900 --> 00:11:49,900
控制下取消。

247
00:11:49,900 --> 00:11:50,780
我只想说是的。

248
00:11:50,780 --> 00:11:51,709
文件名来写。

249
00:11:51,709 --> 00:11:53,500
默认的是文件
它已经是了。

250
00:11:53,500 --> 00:11:54,230
按Enter键。

251
00:11:54,230 --> 00:11:54,740
行。

252
00:11:54,740 --> 00:11:58,580
现在，我刚刚编辑的文件，
保存它，并且它被改变。

253
00:11:58,580 --> 00:11:59,770

254
00:11:59,770 --> 00:12:03,000
>> 所以纳米是最简单的
文本编辑器就习惯了。

255
00:12:03,000 --> 00:12:05,520
在替代品的Vim和​​Emacs。

256
00:12:05,520 --> 00:12:11,250
这些都是更高层次的文本编辑器
有一个非常陡峭的学习曲线。

257
00:12:11,250 --> 00:12:13,740
所以我个人的偏好是Vim的。

258
00:12:13,740 --> 00:12:17,175
并且它有各种各样的选择。

259
00:12:17,175 --> 00:12:18,210

260
00:12:18,210 --> 00:12:24,070
一旦你习惯
它，你将永远不会

261
00:12:24,070 --> 00:12:26,900
想要去的任何其他
文本编辑器，因为你只是

262
00:12:26,900 --> 00:12:29,590
有这么多的事情
在这些提供给你，

263
00:12:29,590 --> 00:12:31,690
但它需要一个真正的
很长一段时间来学习。

264
00:12:31,690 --> 00:12:36,000
因此，也许你只是想逼
自己现在要习惯它，

265
00:12:36,000 --> 00:12:38,130
但我要说这是值得的。

266
00:12:38,130 --> 00:12:39,660
但做起来很难。

267
00:12:39,660 --> 00:12:41,220
>> 然后Emacs的。

268
00:12:41,220 --> 00:12:44,940
我一直在Emacs中挣扎，因为
我知道该怎么做绝对没有。

269
00:12:44,940 --> 00:12:47,755
显然Emacs是默认情况下不
安装在设备上。

270
00:12:47,755 --> 00:12:49,210

271
00:12:49,210 --> 00:12:51,720
我们可能会补充说，
作为默认安装的。

272
00:12:51,720 --> 00:12:59,620

273
00:12:59,620 --> 00:13:02,390
一旦你学会了一
VIM或Emacs，有

274
00:13:02,390 --> 00:13:04,810
没有令人信服的理由
不断学习，另外，

275
00:13:04,810 --> 00:13:07,570
但它是一个完全不同的风格。

276
00:13:07,570 --> 00:13:10,460
OK，这样的编辑文本文件。

277
00:13:10,460 --> 00:13:13,374
>> 听众：如果你被卡
在Vim的现在，怎么办we--

278
00:13:13,374 --> 00:13:18,840

279
00:13:18,840 --> 00:13:20,800
>> 罗布·鲍登：有
多种模式的Vim中，

280
00:13:20,800 --> 00:13:23,770
并且有全
教程学习Vim的。

281
00:13:23,770 --> 00:13:27,390
如果你恰巧是这样
在以插入模式

282
00:13:27,390 --> 00:13:29,930
输入文本，你可以
输入以各种方式

283
00:13:29,930 --> 00:13:31,610
但我是你如何进入插入模式。

284
00:13:31,610 --> 00:13:34,780
或摆脱任何特殊的
模式你在，只是逃命。

285
00:13:34,780 --> 00:13:37,640
而你只是来砸逃生得到
出任何嵌套模式的研究。

286
00:13:37,640 --> 00:13:40,360
刚刚好，现在我又回到正常模式。

287
00:13:40,360 --> 00:13:43,790
>> 因此在正常模式中，一个冒号。

288
00:13:43,790 --> 00:13:45,160
你看它出现在底部。

289
00:13:45,160 --> 00:13:46,240
然后Q。

290
00:13:46,240 --> 00:13:52,600
所以Q将退出，如果你已经进行了更改，
而我 - 因为我已改变？

291
00:13:52,600 --> 00:13:54,180
我显然所做的更改。

292
00:13:54,180 --> 00:13:57,264
所以，如果你已经进行了更改，它会
说你可以把一个感叹号。

293
00:13:57,264 --> 00:13:58,430
我要叫它一声。

294
00:13:58,430 --> 00:14:02,040
所以，你可以把一个班只
退出而不做任何事情，

295
00:14:02,040 --> 00:14:04,520
或结肠WQ将保存并退出。

296
00:14:04,520 --> 00:14:06,580
因此，瓦特一般是写。

297
00:14:06,580 --> 00:14:08,300
所以写的文件。

298
00:14:08,300 --> 00:14:09,810
我可以写，然后退出。

299
00:14:09,810 --> 00:14:13,606
或者你可能只是
QX满贯，Q爆炸刚

300
00:14:13,606 --> 00:14:16,230
要离开那里，无论
那你所做的任何更改。

301
00:14:16,230 --> 00:14:21,310

302
00:14:21,310 --> 00:14:28,940
>> 好吧，那么现在让我们来
go--我们可以创建文件。

303
00:14:28,940 --> 00:14:30,890
让我们开始删除文件。

304
00:14:30,890 --> 00:14:35,450
我就随便扔在一个
很快新的命令，触摸。

305
00:14:35,450 --> 00:14:38,200
因此，触摸FOO。

306
00:14:38,200 --> 00:14:39,340
触摸吧。

307
00:14:39,340 --> 00:14:40,220
触摸巴兹。

308
00:14:40,220 --> 00:14:42,810
如果我LS，现在我们看到的
这些文件的存在。

309
00:14:42,810 --> 00:14:44,315
他们完全是空的。

310
00:14:44,315 --> 00:14:47,178
因此，触摸仅仅是一个简单的
1的方​​法，[听不清]。

311
00:14:47,178 --> 00:14:50,850

312
00:14:50,850 --> 00:14:54,640
二，技术上只是状态
它，它更新的时间戳。

313
00:14:54,640 --> 00:14:58,470
所以，你所创建的任何文件都有
与之相关联的时间戳。

314
00:14:58,470 --> 00:15:01,330
所以巴兹上创建
9月14日的16:21。

315
00:15:01,330 --> 00:15:02,570

316
00:15:02,570 --> 00:15:06,670
它现在是16点22分，所以，如果
我再碰巴兹我们

317
00:15:06,670 --> 00:15:11,420
看到巴兹最
最近修改的16:22。

318
00:15:11,420 --> 00:15:17,680
但除此之外，我几乎从来没有
看着文件上的时间戳。

319
00:15:17,680 --> 00:15:20,490
所以触摸，在这里我只是用
它创建一些快速的文件。

320
00:15:20,490 --> 00:15:21,620

321
00:15:21,620 --> 00:15:27,400
>> 好了，所以现在RM是
命令，我们关心这里。

322
00:15:27,400 --> 00:15:28,665
我们可以RM嘘声。

323
00:15:28,665 --> 00:15:31,000
说定期删除空文件嘘。

324
00:15:31,000 --> 00:15:34,070
我们可以键入y，而现在它的排除。

325
00:15:34,070 --> 00:15:34,850
RM巴兹。

326
00:15:34,850 --> 00:15:35,910

327
00:15:35,910 --> 00:15:38,620
定期删除空文件
巴兹和类型N（否）。

328
00:15:38,620 --> 00:15:40,060
现在它不会被删除。

329
00:15:40,060 --> 00:15:41,240
所以，酒吧和巴兹依然存在。

330
00:15:41,240 --> 00:15:42,232
富走了。

331
00:15:42,232 --> 00:15:43,148
GABRIEL继续说。

332
00:15:43,148 --> 00:15:43,970

333
00:15:43,970 --> 00:15:44,720
罗布·鲍登：太好了。

334
00:15:44,720 --> 00:15:45,800

335
00:15:45,800 --> 00:15:50,370
因此，恼人的消息
在这里，除去常规empty--

336
00:15:50,370 --> 00:15:52,390
你在做什么在哪儿？

337
00:15:52,390 --> 00:15:54,030
定期删除空文件。

338
00:15:54,030 --> 00:15:58,840

339
00:15:58,840 --> 00:16:01,610
因此，如果我们不想成为
受该消息困扰，

340
00:16:01,610 --> 00:16:05,340
我们可以在这个-f扔
标志，并所以这是力。

341
00:16:05,340 --> 00:16:11,330
而现在，如果我RM -f，它不会
说你想删除此文件。

342
00:16:11,330 --> 00:16:12,040
它会就去做。

343
00:16:12,040 --> 00:16:13,720
和LS，我看不到了吧那里。

344
00:16:13,720 --> 00:16:14,810

345
00:16:14,810 --> 00:16:18,021
>> 现在这是一个潜在的
危险的命令。

346
00:16:18,021 --> 00:16:19,020
它往往不会太糟糕。

347
00:16:19,020 --> 00:16:22,240
我们会回来的第二个怎么样
它可以变得非常危险。

348
00:16:22,240 --> 00:16:28,740
让我们创建一些临时目录。

349
00:16:28,740 --> 00:16:30,880
MKDIR，其它命令。

350
00:16:30,880 --> 00:16:34,880
所以MKDIR是一个命令
这使得一个目录。

351
00:16:34,880 --> 00:16:40,650
而现在通过LS，我们看到这个漂亮的光
蓝色突出显示临时目录。

352
00:16:40,650 --> 00:16:42,295
我可以用cd命令进入温度。

353
00:16:42,295 --> 00:16:44,590
我可以命令mkdir foo中。

354
00:16:44,590 --> 00:16:46,330
cd到foo中。 MKDIR吧。

355
00:16:46,330 --> 00:16:46,860
cd进入酒吧。

356
00:16:46,860 --> 00:16:49,400

357
00:16:49,400 --> 00:16:54,300
>> 所以我们看到，我们可以很容易地得到
进了一些漂亮的深层嵌套。

358
00:16:54,300 --> 00:16:56,385
现在我怎么删除一个目录？

359
00:16:56,385 --> 00:16:57,020

360
00:16:57,020 --> 00:16:57,520
命令rmdir。

361
00:16:57,520 --> 00:16:59,030

362
00:16:59,030 --> 00:17:03,540
所以，如果我只是直接尝试RM，
像我们做一个常规文件，

363
00:17:03,540 --> 00:17:06,420
RM杆将要
说不能删除吧。

364
00:17:06,420 --> 00:17:07,569
它是一个目录。

365
00:17:07,569 --> 00:17:10,619
有一个特殊的命令
除去种目录。

366
00:17:10,619 --> 00:17:12,900
于是命令rmdir吧。

367
00:17:12,900 --> 00:17:13,710
现在酒吧已经一去不复返了。

368
00:17:13,710 --> 00:17:14,980

369
00:17:14,980 --> 00:17:22,680
>> 好了，命令rmdir我几乎从来不使用。

370
00:17:22,680 --> 00:17:32,220
究其原因，现在being--我们
做一个常规文件的酒吧在这里了。

371
00:17:32,220 --> 00:17:34,780
于是命令rmdir嘘。

372
00:17:34,780 --> 00:17:35,760
命令rmdir。

373
00:17:35,760 --> 00:17:36,900
无法删除foo中。

374
00:17:36,900 --> 00:17:38,420
目录不是空的。

375
00:17:38,420 --> 00:17:43,420
所以，你不能使用在目录中删除
目录下有东西在里面。

376
00:17:43,420 --> 00:17:44,830
>> 所以，你有一些选择。

377
00:17:44,830 --> 00:17:49,780
你可以进入该目录，删除
一切手动，然后走出来

378
00:17:49,780 --> 00:17:51,759
和rmdir目录。

379
00:17:51,759 --> 00:17:53,050
这显然​​听起来很烦人。

380
00:17:53,050 --> 00:17:55,000
如果有成千上万
在里面的文件？

381
00:17:55,000 --> 00:17:58,119
嗯，你可以RM *。

382
00:17:58,119 --> 00:17:59,410
我们将在第二讲*。

383
00:17:59,410 --> 00:18:00,870
这基本上意味着所有的事情。

384
00:18:00,870 --> 00:18:02,030

385
00:18:02,030 --> 00:18:05,470
但更重要的是，这样RM -r。

386
00:18:05,470 --> 00:18:10,220
所以，RM -r--了很多
背景，-r表示递归，

387
00:18:10,220 --> 00:18:13,810
我们将谈论什么
递归装置在几个星期。

388
00:18:13,810 --> 00:18:18,630
但它基本上意味着导线
这个目录的全部

389
00:18:18,630 --> 00:18:20,190
并取出了一切。

390
00:18:20,190 --> 00:18:24,420
>> 所以，RM -r富会说
陷入目录富？

391
00:18:24,420 --> 00:18:25,210
是的。

392
00:18:25,210 --> 00:18:26,800
定期删除空文件foo /酒吧？

393
00:18:26,800 --> 00:18:27,880

394
00:18:27,880 --> 00:18:28,540
是的。

395
00:18:28,540 --> 00:18:29,760
删除目录FOO？

396
00:18:29,760 --> 00:18:30,260
是的。

397
00:18:30,260 --> 00:18:31,470

398
00:18:31,470 --> 00:18:35,020
所以，现在foo和一切
在它已被删除。

399
00:18:35,020 --> 00:18:42,370
>> 现在，可以得到特别烦
when--让我们碰1，2摸，摸3。

400
00:18:42,370 --> 00:18:44,400
可能有一大堆的文件。

401
00:18:44,400 --> 00:18:49,060
如果我想，我可以创建
成千上万的文件在这里了。

402
00:18:49,060 --> 00:18:53,340
和RM -r FOO是怎么回事
是相当恼人的。

403
00:18:53,340 --> 00:18:55,374
是的，是的，是的，是的，是的，是的。

404
00:18:55,374 --> 00:18:57,540
有很多文件，你
赶紧看看有多少次

405
00:18:57,540 --> 00:18:58,581
我会是类型。

406
00:18:58,581 --> 00:19:02,265
好了，我们只是看到了之前我们怎样才能
摆脱无需输入yes，-f的。

407
00:19:02,265 --> 00:19:03,330

408
00:19:03,330 --> 00:19:07,020
所以MKDIR富CD富触摸1 2 3。

409
00:19:07,020 --> 00:19:08,380

410
00:19:08,380 --> 00:19:17,190
好了，命令rm -rf foo的是要
盲目地完全删除foo中。

411
00:19:17,190 --> 00:19:17,960
没有任何提示。

412
00:19:17,960 --> 00:19:18,650
什么都没有。

413
00:19:18,650 --> 00:19:20,040
富走了。

414
00:19:20,040 --> 00:19:23,830
>> 所以我倾向于使用这种
命令所有的时间。

415
00:19:23,830 --> 00:19:25,120

416
00:19:25,120 --> 00:19:27,830
这就是说，它是一个
很危险的命令，

417
00:19:27,830 --> 00:19:33,240
因为如果我做这样的事
这一点，就不会提示你。

418
00:19:33,240 --> 00:19:34,730
它将会消失。

419
00:19:34,730 --> 00:19:40,140
和它发生相当频繁，
甚至在更高级别的CS课程。

420
00:19:40,140 --> 00:19:42,070
有时我们会看到
一些地方的人

421
00:19:42,070 --> 00:19:48,360
说我不小心我们的RM RF-ED我的家
目录和我所有的P组已经一去不复返了。

422
00:19:48,360 --> 00:19:52,422
而且它是毁灭性的，
但没有垃圾桶。

423
00:19:52,422 --> 00:19:54,380
有没有有什么
供您检索。

424
00:19:54,380 --> 00:19:55,330
这只是走了。

425
00:19:55,330 --> 00:19:56,529

426
00:19:56,529 --> 00:19:58,320
更糟糕的是
像RM -rf /。

427
00:19:58,320 --> 00:19:59,432

428
00:19:59,432 --> 00:20:01,140
所以我们刚才讨论
该根目录中。

429
00:20:01,140 --> 00:20:03,095
它拥有所有的
您的系统上的文件。

430
00:20:03,095 --> 00:20:04,120

431
00:20:04,120 --> 00:20:07,380
事情往往会变得相当凌乱
当您删除之类的东西LS，

432
00:20:07,380 --> 00:20:10,280
和CD，以及所有那些。

433
00:20:10,280 --> 00:20:15,467
>> 听众：有什么区别
RM，RF和rm *之间

434
00:20:15,467 --> 00:20:16,300
罗布·鲍登：所以RM *  - 

435
00:20:16,300 --> 00:20:17,700

436
00:20:17,700 --> 00:20:22,300
>> 艾里逊：问题是有什么
RM，RF和rm *之间的差异。

437
00:20:22,300 --> 00:20:23,750

438
00:20:23,750 --> 00:20:25,950
>> 罗布·鲍登：所以RM *。

439
00:20:25,950 --> 00:20:31,910
明星一般是所有的
此目录的内容。

440
00:20:31,910 --> 00:20:33,540

441
00:20:33,540 --> 00:20:35,540
冥思苦想其他的
方式呈现明星。

442
00:20:35,540 --> 00:20:38,280

443
00:20:38,280 --> 00:20:44,780
好吧，其实明星一般
指符合任何图案。

444
00:20:44,780 --> 00:20:54,930
所以，如果我有一个名为DOG1的文件，
触摸DOG2，触摸CAT1，CAT2触摸。

445
00:20:54,930 --> 00:20:56,050

446
00:20:56,050 --> 00:21:02,110
所以LS * 1将打印和CAT1
DOG1，因为明星可以填充

447
00:21:02,110 --> 00:21:06,270
在with--一个需要存在，
但明星可以是猫或狗。

448
00:21:06,270 --> 00:21:07,247
这是一个外卡。

449
00:21:07,247 --> 00:21:08,580
这就是我正在寻找的话。

450
00:21:08,580 --> 00:21:09,120
外卡。

451
00:21:09,120 --> 00:21:10,180

452
00:21:10,180 --> 00:21:13,960
或者我可以ls的狗*和
我还见到DOG1，DOG2。

453
00:21:13,960 --> 00:21:16,870
所以，那些上市文件
匹配特定的模式。

454
00:21:16,870 --> 00:21:18,150
您可以以这种方式使用ls命令。

455
00:21:18,150 --> 00:21:19,350

456
00:21:19,350 --> 00:21:22,020
>> LS * STAR匹配任何内容。

457
00:21:22,020 --> 00:21:25,710
因此，它会打印所有的
此目录的内容

458
00:21:25,710 --> 00:21:27,290
因为所有的人都一致。

459
00:21:27,290 --> 00:21:30,130
它不会打印出任何东西
在上一级目录。

460
00:21:30,130 --> 00:21:38,680
如果我有一个子目录，foo和
摸1 2 3--所以现在如果RM *星，

461
00:21:38,680 --> 00:21:41,450
删除CAT1，CAT2，DOG1，DOG2。

462
00:21:41,450 --> 00:21:42,340
无法删除foo中。

463
00:21:42,340 --> 00:21:43,090
它是一个目录。

464
00:21:43,090 --> 00:21:43,920

465
00:21:43,920 --> 00:21:50,340
>> 所以明星扩展到所有的
目录中的文件。

466
00:21:50,340 --> 00:21:55,210
所以在技术上RM *好像是说
RM CAT1，CAT2，DOG1，DOG2，FOO。

467
00:21:55,210 --> 00:22:03,630
而RM -rf，技术上明星会
实现我们想要的东西，但RM -rf--

468
00:22:03,630 --> 00:22:06,090
如果我走出这个
目录，RM -rf温度，

469
00:22:06,090 --> 00:22:08,890
那将进入温度和
递归删除一切。

470
00:22:08,890 --> 00:22:11,260

471
00:22:11,260 --> 00:22:21,060
>> 所以，明星是分开在那
了解by--所以这件事

472
00:22:21,060 --> 00:22:25,090
我正在运行，这个东西
这是促使我要命令

473
00:22:25,090 --> 00:22:28,770
然后执行和操作的
他们，我称之为我的壳。

474
00:22:28,770 --> 00:22:31,930
所以这个shell本身就是一个程序。

475
00:22:31,930 --> 00:22:35,010
如果我想，我
可以运行位于/ bin / bash的。

476
00:22:35,010 --> 00:22:36,930
壳被称为庆典。

477
00:22:36,930 --> 00:22:39,340
现在我们看到的东西
已经略有改变，

478
00:22:39,340 --> 00:22:42,200
那是因为我的设置
外壳有所不同。

479
00:22:42,200 --> 00:22:45,415
>> 但现在我在技术上运行
在我原来的壳壳，

480
00:22:45,415 --> 00:22:49,570
我可以退出该shell，现在
我回到我的顶级壳。

481
00:22:49,570 --> 00:22:55,240
说法的目的
这is--的明星。

482
00:22:55,240 --> 00:22:59,020
所以，明星是什么
理解的是bash。

483
00:22:59,020 --> 00:23:04,260
于是命令rm -rf，-rf标志
理解只是RM。

484
00:23:04,260 --> 00:23:06,380
它知道，当你
通过一个-rf你

485
00:23:06,380 --> 00:23:09,520
希望它递归删除
所有的文件而不提示。

486
00:23:09,520 --> 00:23:13,960
明星被理解的东西
通过bash中，当你说RM *，

487
00:23:13,960 --> 00:23:16,890
bash中是不会说
哎RM *，取出明星。

488
00:23:16,890 --> 00:23:21,010
击会说RM *
删除CAT1，CAT2，DOG1，DOG2。

489
00:23:21,010 --> 00:23:24,305
它会自动将扩大
所有在该目录中的文件。

490
00:23:24,305 --> 00:23:29,100

491
00:23:29,100 --> 00:23:33,140
>> 同样波浪线是另一个
符号bash的理解。

492
00:23:33,140 --> 00:23:37,130
当你说CD〜，bash的扩展
那到你的home目录。

493
00:23:37,130 --> 00:23:38,910

494
00:23:38,910 --> 00:23:40,210
其他问题这么远吗？

495
00:23:40,210 --> 00:23:42,760

496
00:23:42,760 --> 00:23:46,060
OK，所以我们要开始去快。

497
00:23:46,060 --> 00:23:47,700

498
00:23:47,700 --> 00:23:48,545
>> 选项​​卡中完成。

499
00:23:48,545 --> 00:23:49,670
只是把它扔到那里。

500
00:23:49,670 --> 00:23:51,530
很多人不
意识到这一点的存在。

501
00:23:51,530 --> 00:23:55,060
所以，如果我输入的CD陶氏，我
要进入下载。

502
00:23:55,060 --> 00:23:56,700
我并不需要键入nloads。

503
00:23:56,700 --> 00:23:57,960

504
00:23:57,960 --> 00:24:00,770
我可以打标签。

505
00:24:00,770 --> 00:24:03,794
所以它识别出
陶氏是一家前缀

506
00:24:03,794 --> 00:24:05,710
不符合任何东西
否则在此目录中，

507
00:24:05,710 --> 00:24:07,520
所以它会完成你们。

508
00:24:07,520 --> 00:24:08,610
现在我可以进入。

509
00:24:08,610 --> 00:24:10,110
>> 我也做了递归。

510
00:24:10,110 --> 00:24:11,205
于是命令mkdir foo中。

511
00:24:11,205 --> 00:24:12,480

512
00:24:12,480 --> 00:24:13,300
让我们去到foo中。

513
00:24:13,300 --> 00:24:14,830
MKDIR吧。

514
00:24:14,830 --> 00:24:17,345
所以，要回我的家
目录中，我可以看到下载。

515
00:24:17,345 --> 00:24:19,040

516
00:24:19,040 --> 00:24:21,860
现在再次打标签，
自动将填foo中。

517
00:24:21,860 --> 00:24:22,880
这是唯一的目录。

518
00:24:22,880 --> 00:24:25,340
再次击中标签，自动
去填写吧。

519
00:24:25,340 --> 00:24:26,798
所以，现在我在（〜下载/富/条）。

520
00:24:26,798 --> 00:24:27,310

521
00:24:27,310 --> 00:24:31,692
>> 所以这个选项卡中完成，
每当我到办公时间，

522
00:24:31,692 --> 00:24:33,400
而我站在
一个人的肩膀，

523
00:24:33,400 --> 00:24:40,470
他们要去RM
D-O型W-N-L-O-A-D-S，我要死了。

524
00:24:40,470 --> 00:24:41,990
只是标签，标签，标签，标签。

525
00:24:41,990 --> 00:24:44,550

526
00:24:44,550 --> 00:24:45,630
所以肯定使用的标签。

527
00:24:45,630 --> 00:24:47,890

528
00:24:47,890 --> 00:24:49,840
同样和
下来，很多人

529
00:24:49,840 --> 00:24:51,930
只是碰巧
从来没有触及上下。

530
00:24:51,930 --> 00:24:54,870
它会经过以前
命令，所以如果你只是跑的东西，

531
00:24:54,870 --> 00:24:58,300
并且要再次运行它，
牵住了，直到你得到它。

532
00:24:58,300 --> 00:24:59,870

533
00:24:59,870 --> 00:25:00,370
行。

534
00:25:00,370 --> 00:25:01,460

535
00:25:01,460 --> 00:25:03,585
>> 这么快，一些其他的事情。

536
00:25:03,585 --> 00:25:04,800

537
00:25:04,800 --> 00:25:05,930
让我们重新回到温。

538
00:25:05,930 --> 00:25:06,976

539
00:25:06,976 --> 00:25:08,125
让我们创建一些文件。

540
00:25:08,125 --> 00:25:10,480

541
00:25:10,480 --> 00:25:15,215
所以在这里，我只是
要列出一些单词。

542
00:25:15,215 --> 00:25:18,460

543
00:25:18,460 --> 00:25:21,035
狗，猫，喵喵。

544
00:25:21,035 --> 00:25:23,940

545
00:25:23,940 --> 00:25:26,040
让我们做狗，鱼。

546
00:25:26,040 --> 00:25:27,500

547
00:25:27,500 --> 00:25:32,320
所以，现在代表是一个非常
有用的命令，你

548
00:25:32,320 --> 00:25:37,820
使用全搜索
对于一个特定的文本文件，

549
00:25:37,820 --> 00:25:40,910
而在技术上，你可以做真正的
复杂的表达式为它匹配。

550
00:25:40,910 --> 00:25:44,830
>> 所以在这里，如果我用grep，什么
我要搜索？

551
00:25:44,830 --> 00:25:49,130
比方说，我在寻找猫和
我要搜索所有这些文件。

552
00:25:49,130 --> 00:25:50,650
所以，我该怎么做所有这些文件？

553
00:25:50,650 --> 00:25:51,900
星。

554
00:25:51,900 --> 00:25:54,939
因此，在文件中的一个，我有一只猫。

555
00:25:54,939 --> 00:25:56,980
我大概可以有
称它更好的东西，

556
00:25:56,980 --> 00:25:59,063
因为看起来像
行号什么的。

557
00:25:59,063 --> 00:26:01,590
但在文件中的一个我与猫的线。

558
00:26:01,590 --> 00:26:04,160
在文件中的两个我有猫行。

559
00:26:04,160 --> 00:26:07,280
所以，现在我可以看看里面的文件之一，
看噢，该文件确实有猫。

560
00:26:07,280 --> 00:26:10,210
通知文件中的三个不匹配
因为猫是不是在那里。

561
00:26:10,210 --> 00:26:13,882
我可以grep的喵。

562
00:26:13,882 --> 00:26:14,840
只有文件中的两个有喵。

563
00:26:14,840 --> 00:26:16,120

564
00:26:16,120 --> 00:26:20,640
>> 因此，这可以结合，
再次，与-r，这

565
00:26:20,640 --> 00:26:23,580
正如我以前说过
通常意味着递归。

566
00:26:23,580 --> 00:26:29,800
所以，我可以在这里拿出中，grep -r
任何情况下of--让我们编辑

567
00:26:29,800 --> 00:26:32,010
这一次只是扔一只猫在那里。

568
00:26:32,010 --> 00:26:38,800
所以，用grep -r任何情况下
猫的整个目录。

569
00:26:38,800 --> 00:26:41,600
它会递归
搜索所有子目录。

570
00:26:41,600 --> 00:26:43,940
因此，在巴兹，还有猫。

571
00:26:43,940 --> 00:26:45,570
在温度/ 2，还有猫。

572
00:26:45,570 --> 00:26:47,960
而在温度/ 1有猫。

573
00:26:47,960 --> 00:26:50,045
所以这是文件中进行搜索。

574
00:26:50,045 --> 00:26:51,250

575
00:26:51,250 --> 00:26:55,090
>> 现在，你也可以使用一个发现。

576
00:26:55,090 --> 00:26:59,640
等发现是专门约
寻找具有给定名称的文件。

577
00:26:59,640 --> 00:27:02,490
因此，让我们做更多一些。

578
00:27:02,490 --> 00:27:03,660
让我们进入下载。

579
00:27:03,660 --> 00:27:04,680

580
00:27:04,680 --> 00:27:05,380
触摸DOG1。

581
00:27:05,380 --> 00:27:06,840

582
00:27:06,840 --> 00:27:07,770
触摸CAT2。

583
00:27:07,770 --> 00:27:09,290

584
00:27:09,290 --> 00:27:10,760
触摸cat_dog。

585
00:27:10,760 --> 00:27:14,550

586
00:27:14,550 --> 00:27:15,975
触摸catcat。

587
00:27:15,975 --> 00:27:18,270

588
00:27:18,270 --> 00:27:23,810
>> 所以我想找到的所有
文件与狗的名称。

589
00:27:23,810 --> 00:27:28,060
因此发现，与最长
一次，我从来不记得

590
00:27:28,060 --> 00:27:33,760
如何找到工作，直到我终于
读的东西，说得那么清楚。

591
00:27:33,760 --> 00:27:35,784
所以发现，自动递归。

592
00:27:35,784 --> 00:27:36,950
你并不需要通过一个-r。

593
00:27:36,950 --> 00:27:38,090

594
00:27:38,090 --> 00:27:39,110
所以找点。

595
00:27:39,110 --> 00:27:40,750
我们还没有谈到点呢。

596
00:27:40,750 --> 00:27:44,800
而点点总是
是指一个目录了。

597
00:27:44,800 --> 00:27:46,960
点总是表示当前目录。

598
00:27:46,960 --> 00:27:51,390
所以我可以RM在-r点
同样的方式，我可以命令rm -rf *。

599
00:27:51,390 --> 00:27:53,140
最终他们
完成同样的事情。

600
00:27:53,140 --> 00:27:56,040
RM -rf点是要去除
整个当前目录。

601
00:27:56,040 --> 00:27:57,440

602
00:27:57,440 --> 00:27:59,680
>> 好了，我不想在那里做。

603
00:27:59,680 --> 00:28:01,490

604
00:28:01,490 --> 00:28:04,320
但找到点。

605
00:28:04,320 --> 00:28:07,920
所以递归搜索当前
目录，现在一切

606
00:28:07,920 --> 00:28:14,125
在此之后的一堆标志，你
使用从返回排除的东西。

607
00:28:14,125 --> 00:28:17,250
所以找点返回的一切，它
可以找到从当前目录。

608
00:28:17,250 --> 00:28:19,700
这些都是所有文件
递归搜索。

609
00:28:19,700 --> 00:28:21,250
我们将看到一些有第二个的。

610
00:28:21,250 --> 00:28:23,150

611
00:28:23,150 --> 00:28:27,140
>> 但如果你想知道我该怎么办
即，这样的命令K，最起码

612
00:28:27,140 --> 00:28:29,660
我在Mac终端将其清除。

613
00:28:29,660 --> 00:28:34,660
控制l通常清除
这对于任何类型的终端。

614
00:28:34,660 --> 00:28:36,480
您也可以键入清楚。

615
00:28:36,480 --> 00:28:38,410
如果你有机会
成一个奇怪的scenario--

616
00:28:38,410 --> 00:28:42,790
它发生在我身上了几个时间 - 
在您提示的颜色

617
00:28:42,790 --> 00:28:46,590
都搞砸了，或者你
不能够看到什么

618
00:28:46,590 --> 00:28:51,232
当你正在打字输入，因为
有时像背景颜色设置

619
00:28:51,232 --> 00:28:53,940
相同的前景色
现在你看不到的字体。

620
00:28:53,940 --> 00:28:55,110

621
00:28:55,110 --> 00:28:59,830
重置是什么，只是重置
你到默认黑色背景，

622
00:28:59,830 --> 00:29:01,840
白前，或任何
你将它们设置为。

623
00:29:01,840 --> 00:29:03,390

624
00:29:03,390 --> 00:29:04,790
>> 所以，我们说到哪儿了？

625
00:29:04,790 --> 00:29:05,930
找点。

626
00:29:05,930 --> 00:29:09,360
所以，现在一切都过去，这
点限制的结果

627
00:29:09,360 --> 00:29:11,450
东西相匹配
给定的模式。

628
00:29:11,450 --> 00:29:16,110
所以在这里我要搜索
一切与名猫。

629
00:29:16,110 --> 00:29:17,300
我什么也没得到。

630
00:29:17,300 --> 00:29:18,390
为什么会这样？

631
00:29:18,390 --> 00:29:21,230
好吧，我只是在寻找
东西正是名猫。

632
00:29:21,230 --> 00:29:25,150
如果我想搜索的东西
有一些图案，并cat--

633
00:29:25,150 --> 00:29:28,890
引号技术上是没有必要的，
但我扔在那里。

634
00:29:28,890 --> 00:29:32,720
所以，现在它找到catcat因为
这是唯一的事情，

635
00:29:32,720 --> 00:29:36,040
有一些武断
其次是猫的图案。

636
00:29:36,040 --> 00:29:41,950
我可以把猫*，现在
找到catcat，cat_dog，CAT2，

637
00:29:41,950 --> 00:29:45,245
因为那些都是事情的猫
在开始之后任何东西。

638
00:29:45,245 --> 00:29:46,120
你可以结合这一点。

639
00:29:46,120 --> 00:29:50,480
如果你想搜索所有的C文件
你有，你可能会做的* .c。

640
00:29:50,480 --> 00:29:51,960
我们在这里blah.c。

641
00:29:51,960 --> 00:29:53,000

642
00:29:53,000 --> 00:29:55,020
所以这是一个发现的作品。

643
00:29:55,020 --> 00:29:55,770
您可以搜索。

644
00:29:55,770 --> 00:29:58,270
它有一大堆的标志
为进一步的限制。

645
00:29:58,270 --> 00:30:00,960
和一个对他们来说，假设-d。

646
00:30:00,960 --> 00:30:02,110

647
00:30:02,110 --> 00:30:04,435
所以不推荐使用。

648
00:30:04,435 --> 00:30:05,425

649
00:30:05,425 --> 00:30:06,550
哦，那不是我想要的。

650
00:30:06,550 --> 00:30:07,730
不-d。

651
00:30:07,730 --> 00:30:08,860
D型。

652
00:30:08,860 --> 00:30:13,820
因此，发现点 -  D型。

653
00:30:13,820 --> 00:30:17,760
还等什么，仅仅是做了我搜索
在当前目录下的所有文件

654
00:30:17,760 --> 00:30:21,680
与A-- d代表
directory--目录类型。

655
00:30:21,680 --> 00:30:24,430
这将返回所有目录
在当前目录中。

656
00:30:24,430 --> 00:30:27,670
和F型的所有常规
文件，所有的非目录。

657
00:30:27,670 --> 00:30:29,809
所以，这只是一个
例如其他的方法你

658
00:30:29,809 --> 00:30:32,350
可以限制搜索其它
比文件的只是名称。

659
00:30:32,350 --> 00:30:34,126

660
00:30:34,126 --> 00:30:35,570
>> 它已经30分钟。

661
00:30:35,570 --> 00:30:36,848
仍在继续。

662
00:30:36,848 --> 00:30:38,132
>> 艾里逊：我会微风过。

663
00:30:38,132 --> 00:30:39,670
它会没事的。

664
00:30:39,670 --> 00:30:41,460
>> 罗布·鲍登：所以一些其他的事情。

665
00:30:41,460 --> 00:30:45,700
现在的一声，感叹号。

666
00:30:45,700 --> 00:30:50,530
这样一般是指：
好了，让我们看一个例子。

667
00:30:50,530 --> 00:30:52,230
所以！楼什么的怎么办？

668
00:30:52,230 --> 00:30:53,520

669
00:30:53,520 --> 00:30:57,810
那么它似乎有
反复找点型F。

670
00:30:57,810 --> 00:30:59,240
怎么样！克？

671
00:30:59,240 --> 00:31:00,760
这只是用grep -r猫*。

672
00:31:00,760 --> 00:31:02,010

673
00:31:02,010 --> 00:31:05,720
所以，一鼓作气，您可以使用重复
最近完成的命令。

674
00:31:05,720 --> 00:31:13,280
所以，如果我输入！GRE，它会重新运行
始于GRE大多数命令

675
00:31:13,280 --> 00:31:14,060
最近。

676
00:31:14,060 --> 00:31:17,090
>> 你可以看到这一切
历史命令。

677
00:31:17,090 --> 00:31:17,880
所以历史。

678
00:31:17,880 --> 00:31:19,630
这些都是
命令我今天跑。

679
00:31:19,630 --> 00:31:21,089

680
00:31:21,089 --> 00:31:23,130
和好了，这是不是真的
限于今天，

681
00:31:23,130 --> 00:31:25,180
但我只用这
家电今天的。

682
00:31:25,180 --> 00:31:28,730
这是你的全部
你的bash shell的历史，

683
00:31:28,730 --> 00:31:30,433
除了它在某点切断。

684
00:31:30,433 --> 00:31:33,474
听众：如果你这样做，会发生什么
历史[听不清]命令和错误

685
00:31:33,474 --> 00:31:35,430
在结果仍然打印the--

686
00:31:35,430 --> 00:31:44,110
>> 罗布·鲍登：是的，如果有
在这些commands--的一个错误

687
00:31:44,110 --> 00:31:48,090
所以我们说，这是一个
未找到错误的命令。

688
00:31:48,090 --> 00:31:49,312

689
00:31:49,312 --> 00:31:50,520
仍然出现在历史记录。

690
00:31:50,520 --> 00:31:52,620

691
00:31:52,620 --> 00:31:53,170
行。

692
00:31:53,170 --> 00:31:54,750

693
00:31:54,750 --> 00:31:56,040
在什么其他问题？

694
00:31:56,040 --> 00:31:58,760

695
00:31:58,760 --> 00:32:00,300
所以这就是一声巨响。

696
00:32:00,300 --> 00:32:04,230
>> 现在，真正有用的命令，伙计。

697
00:32:04,230 --> 00:32:07,750
所以，让你的
手动对给定命令。

698
00:32:07,750 --> 00:32:11,640
所以我们说男人的ls，所以
这是我展示LS。

699
00:32:11,640 --> 00:32:13,400
它列出目录内容。

700
00:32:13,400 --> 00:32:17,150
这是我看到有
都存在这些不同的标志。

701
00:32:17,150 --> 00:32:21,340
所以我们看到ls -l命令的存在
如果我们阅读。 ls -l命令

702
00:32:21,340 --> 00:32:26,150
给我的这个完整列表
与谁拥有的文件目录，

703
00:32:26,150 --> 00:32:29,750
该文件的大小，在
的修改的时戳。

704
00:32:29,750 --> 00:32:31,130

705
00:32:31,130 --> 00:32:34,980
所以LS -a是另一个你可能会
实际使用多少有些频繁。

706
00:32:34,980 --> 00:32:38,130
-al是我最常见的标志，在过去的LS。

707
00:32:38,130 --> 00:32:42,520
>> 所以-a，看到有很多
不仅仅是LS多个文件。

708
00:32:42,520 --> 00:32:44,170
LS -a。

709
00:32:44,170 --> 00:32:46,170
什么是在与所有这些文件？

710
00:32:46,170 --> 00:32:47,790
他们先从一个点。

711
00:32:47,790 --> 00:32:54,710
所以这是一个约定在Linux中的
即以点开始的文件是隐藏的。

712
00:32:54,710 --> 00:32:58,330
所以它只是意味着，
当我们刚刚直LS，

713
00:32:58,330 --> 00:33:04,170
或者，我们正在寻找使用这个目录
取景器相当，或Windows

714
00:33:04,170 --> 00:33:07,250
资源管理器等同，我们
不希望看到这些点文件。

715
00:33:07,250 --> 00:33:09,680
他们只是污染对事物的看法。

716
00:33:09,680 --> 00:33:11,790
因此，他们被隐藏
除非您特别

717
00:33:11,790 --> 00:33:14,250
要求他们像-a。

718
00:33:14,250 --> 00:33:18,920
这样我就可以用cd命令进入。本地，我看
这本身就是一个目录

719
00:33:18,920 --> 00:33:22,220
一个共享目录，
应用程序，等等等等。

720
00:33:22,220 --> 00:33:24,520
于是点，他们只是隐藏文件。

721
00:33:24,520 --> 00:33:26,250

722
00:33:26,250 --> 00:33:29,355
>> 好了，其他重要的。

723
00:33:29,355 --> 00:33:30,490

724
00:33:30,490 --> 00:33:32,000
我有一对夫妇，我可以跳过。

725
00:33:32,000 --> 00:33:38,160
让我们只对真正的快速通话
文件重定向的东西。

726
00:33:38,160 --> 00:33:43,020
所以这是一个复杂的全系列
的东西，你可以用这些做什么，

727
00:33:43,020 --> 00:33:47,204
只是看到他们，让我们说，回声。

728
00:33:47,204 --> 00:33:47,870
另一个命令。

729
00:33:47,870 --> 00:33:48,920
非常愚蠢的命令。

730
00:33:48,920 --> 00:33:50,710
它所做的就是打印我告诉它。

731
00:33:50,710 --> 00:33:52,070
所以回声招呼。

732
00:33:52,070 --> 00:33:53,850
它只是回应打招呼的画面。

733
00:33:53,850 --> 00:33:55,170

734
00:33:55,170 --> 00:33:56,390
你好世界。

735
00:33:56,390 --> 00:33:57,890
相呼应的hello world。

736
00:33:57,890 --> 00:34:02,650
>> 因此，一个命令或者一个
符号bash的理解

737
00:34:02,650 --> 00:34:07,620
比符号这更大，并
即，输出到文件符号。

738
00:34:07,620 --> 00:34:10,940
所以，如果我输出这
FOO，现在有一个文件

739
00:34:10,940 --> 00:34:15,100
名为foo，里面
这是世界您好。

740
00:34:15,100 --> 00:34:18,489
所以请注意，当我回音
你好世界管到foo中，

741
00:34:18,489 --> 00:34:19,980
它没有回音的hello world。

742
00:34:19,980 --> 00:34:22,630
相反，它被放入文件foo。

743
00:34:22,630 --> 00:34:25,340
而另一个命令只是
把它扔在你的猫。

744
00:34:25,340 --> 00:34:29,191
这是一个简单的方法来一场彻底
列出的文件中的内容

745
00:34:29,191 --> 00:34:31,440
这样我就不必开
文本编辑器来查看。

746
00:34:31,440 --> 00:34:34,159
的所以内容
foo的文件是的hello world。

747
00:34:34,159 --> 00:34:38,460
我可以猫blah.c，
内容是这样。

748
00:34:38,460 --> 00:34:42,123
>> 同样，这些命令是，不
希望你把它们都记住。

749
00:34:42,123 --> 00:34:43,860
这个想法是，你见过他们。

750
00:34:43,860 --> 00:34:45,735
也许你正在努力
什么，你

751
00:34:45,735 --> 00:34:47,230
就像我讨厌打开此文件。

752
00:34:47,230 --> 00:34:50,120
我希望我能看
在内容真正的快。

753
00:34:50,120 --> 00:34:52,320
你可以这样做，那么
回过头来说，哦，我

754
00:34:52,320 --> 00:34:55,250
记得是这样
存在，它的猫。

755
00:34:55,250 --> 00:35:00,630
>> 所以，是要的文件。

756
00:35:00,630 --> 00:35:06,639
现在有没有什么好的
例如从一个文件中读取呢。

757
00:35:06,639 --> 00:35:08,930
是什么东西把
从标准的东西？

758
00:35:08,930 --> 00:35:10,010

759
00:35:10,010 --> 00:35:11,544
任何简单的Linux命令？

760
00:35:11,544 --> 00:35:13,480

761
00:35:13,480 --> 00:35:16,970
当我们得到它，在一对夫妇
周所有piece--好，

762
00:35:16,970 --> 00:35:20,470
这周你有一块，你
开始从用户接受输入。

763
00:35:20,470 --> 00:35:23,696
所以通常你键入
该输入的键盘。

764
00:35:23,696 --> 00:35:25,570
而不是打字说的
输入的键盘，

765
00:35:25,570 --> 00:35:30,950
您可以改为管道从文件
所以，当你这样做的马里奥，./mario，

766
00:35:30,950 --> 00:35:35,200
管中，从任何给定的文件中，并
那将运行马里奥程序。

767
00:35:35,200 --> 00:35:37,300
在没有预料的输入
键盘上，而不是它的

768
00:35:37,300 --> 00:35:39,650
只是要阅读
线路从FOO文件。

769
00:35:39,650 --> 00:35:45,230
>> 所以，大于富将其放入
foo的文件，且小于富

770
00:35:45,230 --> 00:35:50,170
需要的东西，从foo的文件，
使用该输入到这个程序。

771
00:35:50,170 --> 00:35:51,520

772
00:35:51,520 --> 00:36:00,630
而刚刚看到它，我们也可以呼应
FOO酒吧巴兹，然后而不是一个

773
00:36:00,630 --> 00:36:03,850
大于，让我们做两到foo中。

774
00:36:03,850 --> 00:36:05,610
这是什么做的？

775
00:36:05,610 --> 00:36:07,180
它只是追加到文件中。

776
00:36:07,180 --> 00:36:15,360
因此，而不是发现，如果我不回应胡说成
富然后猫FOO，它只是胡说。

777
00:36:15,360 --> 00:36:18,285
所以，当你输出到一个文件，它
完全覆盖该文件。

778
00:36:18,285 --> 00:36:19,330

779
00:36:19,330 --> 00:36:22,740
如果你只是想追加，
双[？平地机。 ？]

780
00:36:22,740 --> 00:36:24,080
>> 而在去年的管道。

781
00:36:24,080 --> 00:36:29,590
管获取更加复杂，其中
它需要一个命令的输出

782
00:36:29,590 --> 00:36:32,320
并将其馈送到下一个命令。

783
00:36:32,320 --> 00:36:36,140
因此，一些平常的事情，历史。

784
00:36:36,140 --> 00:36:37,920
所以，唉，我不想看这个。

785
00:36:37,920 --> 00:36:40,680

786
00:36:40,680 --> 00:36:44,485
告诉我在我的历史中的所有命令
在这里我用grep-ED的东西。

787
00:36:44,485 --> 00:36:45,360
不，这是令人困惑的。

788
00:36:45,360 --> 00:36:50,360
告诉我在哪里，我觉得所有的命令。

789
00:36:50,360 --> 00:36:52,360
所有的查找命令我曾经跑了。

790
00:36:52,360 --> 00:36:55,050
>> 所以历史。

791
00:36:55,050 --> 00:36:59,017
现在，历史输出到
筛选此命令列表，

792
00:36:59,017 --> 00:37:00,850
但我不希望
将其输出到屏幕。

793
00:37:00,850 --> 00:37:03,445
相反，我要管成grep的。

794
00:37:03,445 --> 00:37:04,790

795
00:37:04,790 --> 00:37:07,830
因此，让我们用grep进行查找的所有实例。

796
00:37:07,830 --> 00:37:09,550

797
00:37:09,550 --> 00:37:17,000
所以现在，而不是采取的grep
的输入，而不是of--

798
00:37:17,000 --> 00:37:24,360
grep的是能够处理的input--我们
使用grep在这里稍微不同。

799
00:37:24,360 --> 00:37:29,550
因此，而不是打字名单
事情我们想搜索

800
00:37:29,550 --> 00:37:31,070
和所述的grep正在作为输入。

801
00:37:31,070 --> 00:37:34,810
所以，如果我只是grep的发现，它
等待我输入的东西。

802
00:37:34,810 --> 00:37:37,661
所以猫你好找到。

803
00:37:37,661 --> 00:37:38,160
您好。

804
00:37:38,160 --> 00:37:40,430

805
00:37:40,430 --> 00:37:40,930
查找。

806
00:37:40,930 --> 00:37:43,670
请注意，我每次键入找
它认识到，我输入的查找。

807
00:37:43,670 --> 00:37:44,880

808
00:37:44,880 --> 00:37:49,540
因此，而不是此，
搜索文件的查找。

809
00:37:49,540 --> 00:37:53,930
>> 所以，历史是现在要
输出所有的命令的列表。

810
00:37:53,930 --> 00:37:55,200

811
00:37:55,200 --> 00:37:58,100
我们把该输出，
我们正在喂养它到grep，

812
00:37:58,100 --> 00:38:00,180
所以它吐出
发现的所有实例。

813
00:38:00,180 --> 00:38:02,170

814
00:38:02,170 --> 00:38:05,570
我之所以说这会很混乱
是，如果我 - 它仍然扑朔迷离。

815
00:38:05,570 --> 00:38:07,030
如果我用grep grep的。

816
00:38:07,030 --> 00:38:08,755

817
00:38:08,755 --> 00:38:11,130
请注意，这是几乎总是
显示命令我

818
00:38:11,130 --> 00:38:15,280
跑，因为该命令
本身具有的grep它里面。

819
00:38:15,280 --> 00:38:16,580

820
00:38:16,580 --> 00:38:20,674
>> 好了，就什么问题吗？

821
00:38:20,674 --> 00:38:22,340
我会在这一点上转移过来。

822
00:38:22,340 --> 00:38:24,690
希望这是一个很好的
所有命令的概观

823
00:38:24,690 --> 00:38:30,100
你不需要有
记住，但是这些补

824
00:38:30,100 --> 00:38:32,950
坚实的95％是我
这样做在命令行中。

825
00:38:32,950 --> 00:38:34,310

826
00:38:34,310 --> 00:38:39,140
也请记住，在命令行
本身的bash是一种编程语言，

827
00:38:39,140 --> 00:38:43,070
所以，当你坐下来，你
可能需要做非常复杂的事情。

828
00:38:43,070 --> 00:38:47,522
因此它具有类似的东西
循环，并且如果，并且所有这些

829
00:38:47,522 --> 00:38:50,230
那你要习惯
与你的编程语言。

830
00:38:50,230 --> 00:38:53,660
但是，这是超越
本节的范围。

831
00:38:53,660 --> 00:38:55,520

832
00:38:55,520 --> 00:38:56,985
好了，没有什么问题？

833
00:38:56,985 --> 00:38:57,940

834
00:38:57,940 --> 00:38:58,523
艾里逊：没有？

835
00:38:58,523 --> 00:38:59,450
GABRIEL：你会to--

836
00:38:59,450 --> 00:39:01,158
艾里逊：我能行
对矿井，如果你想要的。

837
00:39:01,158 --> 00:39:02,626
我们可以看看会发生什么。

838
00:39:02,626 --> 00:39:03,750
罗布·鲍登：关艾里逊。

839
00:39:03,750 --> 00:39:05,090
艾里逊：呜。

840
00:39:05,090 --> 00:39:07,504
你是一个望尘莫及，罗布。

841
00:39:07,504 --> 00:39:08,920
难道你要我跟你转？

842
00:39:08,920 --> 00:39:10,246
或者你有，OK。

843
00:39:10,246 --> 00:39:13,590

844
00:39:13,590 --> 00:39:16,990
我要去尝试，并没有
很是冗长那里。

845
00:39:16,990 --> 00:39:20,619

846
00:39:20,619 --> 00:39:22,660
如果让这种意志来看看
工作，我想它的方式。

847
00:39:22,660 --> 00:39:26,170

848
00:39:26,170 --> 00:39:26,670
也许？

849
00:39:26,670 --> 00:39:27,760

850
00:39:27,760 --> 00:39:28,296
哈哈！

851
00:39:28,296 --> 00:39:28,796
是的。

852
00:39:28,796 --> 00:39:30,460

853
00:39:30,460 --> 00:39:34,066
>> 所以，我只是要很快去
通过变量，循环，条件，

854
00:39:34,066 --> 00:39:35,440
和编译器一点点。

855
00:39:35,440 --> 00:39:38,570
如果你有问题
任何时候，请阻止我。

856
00:39:38,570 --> 00:39:42,750
这些家伙会提醒我重复
你的问题的情况下，我忘了，

857
00:39:42,750 --> 00:39:44,210
但应该不会太差。

858
00:39:44,210 --> 00:39:45,850
>> 所以变量，是的。

859
00:39:45,850 --> 00:39:48,060
我们有没有一个你
片划伤这里。

860
00:39:48,060 --> 00:39:50,440
我敢肯定，你们中的大多数，如果
你有某种游戏

861
00:39:50,440 --> 00:39:53,810
那你从头开始创建，你有
保留的东西轨道一样得分，

862
00:39:53,810 --> 00:39:55,870
或时间，或类似的东西。

863
00:39:55,870 --> 00:39:58,080
因此，那些明亮的橙色
我们看到有件

864
00:39:58,080 --> 00:40:02,630
都只是暂存形式
变量，你一定会

865
00:40:02,630 --> 00:40:04,640
可以使用变量
整个程序。

866
00:40:04,640 --> 00:40:07,350
如果你不是，我不是真的
知道自己在做什么。

867
00:40:07,350 --> 00:40:09,000

868
00:40:09,000 --> 00:40:12,215
>> 但无论如何，大的事情，
定义变量。

869
00:40:12,215 --> 00:40:13,630

870
00:40:13,630 --> 00:40:16,970
用C每一个变量都有
有一个类型中声明，

871
00:40:16,970 --> 00:40:22,090
所以我给你一个非常
一般一个在顶部。

872
00:40:22,090 --> 00:40:24,045
所以，你有你
类型，然后什么

873
00:40:24,045 --> 00:40:25,420
你决定打电话给你的变量。

874
00:40:25,420 --> 00:40:27,500

875
00:40:27,500 --> 00:40:29,680
所以在这种情况下，类型
在变量列表。

876
00:40:29,680 --> 00:40:31,400
>> 我们有三个例子。

877
00:40:31,400 --> 00:40:34,439
夏亚有些档次的，
一个A，这是什么

878
00:40:34,439 --> 00:40:36,230
我敢肯定，你都想要
取得这一类。

879
00:40:36,230 --> 00:40:37,380

880
00:40:37,380 --> 00:40:40,670
您可以定义多个
在一行中的变量

881
00:40:40,670 --> 00:40:43,880
只要它们具有相同的类型，
这是我们的第二个例子中有

882
00:40:43,880 --> 00:40:46,409
在这里你有三个
变量中，x，y和z。

883
00:40:46,409 --> 00:40:47,200
他们都是浮动。

884
00:40:47,200 --> 00:40:49,160

885
00:40:49,160 --> 00:40:53,250
然后你也可以，在这最后
例如与诠释得分和数量

886
00:40:53,250 --> 00:40:56,510
队，你可以
初始化它们就在那里。

887
00:40:56,510 --> 00:41:01,270
>> 所以在中间例子，其中我们
只是有X，Y和Z的浮动，

888
00:41:01,270 --> 00:41:02,730
那些尚未初始化。

889
00:41:02,730 --> 00:41:04,140
他们没有任何价值。

890
00:41:04,140 --> 00:41:05,600
或者他们有垃圾值。

891
00:41:05,600 --> 00:41:07,370

892
00:41:07,370 --> 00:41:10,790
如果您尝试使用它们，
编译器会骂你。

893
00:41:10,790 --> 00:41:14,727
你有两种申报和
初始化变量。

894
00:41:14,727 --> 00:41:16,310
因此，在这个最后一个，我们正在做两个。

895
00:41:16,310 --> 00:41:19,320
我们声明变量
比分和球队的数量，

896
00:41:19,320 --> 00:41:24,134
我们正在初始化他们，给
7和4它们的初始值

897
00:41:24,134 --> 00:41:24,675
分别。

898
00:41:24,675 --> 00:41:26,310

899
00:41:26,310 --> 00:41:27,190
凉爽。

900
00:41:27,190 --> 00:41:28,550
大家好？

901
00:41:28,550 --> 00:41:29,470
真棒。

902
00:41:29,470 --> 00:41:31,690
>> OK，所以一些约定。

903
00:41:31,690 --> 00:41:35,965
如果你们看过
通过样式50，这些

904
00:41:35,965 --> 00:41:39,510
只是事情，我们想为
你要实现你的风格。

905
00:41:39,510 --> 00:41:41,230
因此，有意义的名称。

906
00:41:41,230 --> 00:41:45,700
如果你开始打电话的事
刚的x，y和z，尤其

907
00:41:45,700 --> 00:41:47,902
当你进入更长
程序，你

908
00:41:47,902 --> 00:41:49,610
可能会
迷惑自己，是

909
00:41:49,610 --> 00:41:52,930
喜欢什么是这个变量指。

910
00:41:52,930 --> 00:41:55,880
我不知道这意味着什么。

911
00:41:55,880 --> 00:41:59,280
>> 所以，如果它意味着持有
分的高分，称其为得分。

912
00:41:59,280 --> 00:42:05,720
如果它的目的是保存一些答案
或导致，给它一个这样的名字。

913
00:42:05,720 --> 00:42:09,920
for循环，我们将
进入的下一个幻灯片，

914
00:42:09,920 --> 00:42:12,985
单个字母的变量都是精品。

915
00:42:12,985 --> 00:42:16,033

916
00:42:16,033 --> 00:42:18,449
ROB BOWDEN：我，j和k分别
只是约定for循环

917
00:42:18,449 --> 00:42:22,050
每个人都希望他们
被称为I，j和k。

918
00:42:22,050 --> 00:42:26,890
您可以拨打them--我看行
列或行的电话，有时

919
00:42:26,890 --> 00:42:29,450
对于两个嵌套循环，并
这也是一种标准。

920
00:42:29,450 --> 00:42:31,450
但是，i和j被完全理解。

921
00:42:31,450 --> 00:42:33,670
>> ALLISON：是啊，我和
j您是完全的罚款。

922
00:42:33,670 --> 00:42:36,250
为了清楚起见，像
在你的一些P组，

923
00:42:36,250 --> 00:42:39,745
它可能是有意义有更多的
在那里只是描述性事

924
00:42:39,745 --> 00:42:40,920
跟踪它。

925
00:42:40,920 --> 00:42:45,100
但我认为，I，J和K，我认为
绝大多数的我们全部使用。

926
00:42:45,100 --> 00:42:46,890

927
00:42:46,890 --> 00:42:50,340
>> 罗布·鲍登：有了这些
约定，所以风格是很重要的。

928
00:42:50,340 --> 00:42:53,520
这是四个轴中的一个
在这你分级，

929
00:42:53,520 --> 00:42:58,110
它是那么容易只是去了
你P设定在年底确保

930
00:42:58,110 --> 00:42:59,770
有没有文体的错误。

931
00:42:59,770 --> 00:43:01,742
所以一定要确保你是正确的tab键切换。

932
00:43:01,742 --> 00:43:03,200
确保你的变量命名。

933
00:43:03,200 --> 00:43:04,450
留下一些评论。

934
00:43:04,450 --> 00:43:06,677
这是很容易得到这些点。

935
00:43:06,677 --> 00:43:09,510
你不必去想
为了任何事情来得到这些点。

936
00:43:09,510 --> 00:43:11,093
你不必弄清楚什么了。

937
00:43:11,093 --> 00:43:12,640
它只是使它看起来很漂亮。

938
00:43:12,640 --> 00:43:14,850
>> 艾里逊：其实我们
有风格的50，这

939
00:43:14,850 --> 00:43:17,920
会告诉你，你搞乱
了，如果你搞乱款式

940
00:43:17,920 --> 00:43:21,180
并会告诉你，正是你
需要修复，你需要如何解决它。

941
00:43:21,180 --> 00:43:23,900
这也是刚刚好提
这是当然的政策

942
00:43:23,900 --> 00:43:27,200
如果你在办公室
小时，你的代码是一个烂摊子，

943
00:43:27,200 --> 00:43:30,200
我们可以拒绝帮助
你，直到它看起来更好。

944
00:43:30,200 --> 00:43:34,310
于是开始了吧，
保持一贯的风格，

945
00:43:34,310 --> 00:43:37,100
你也只会让
你的生活轻松许多，当

946
00:43:37,100 --> 00:43:38,730
你试图去通过调试。

947
00:43:38,730 --> 00:43:41,510
如果你想弄清楚
在那里你错过了一个大括号

948
00:43:41,510 --> 00:43:44,890
他们是所有的地方，你
只是让自己的生活更加艰难。

949
00:43:44,890 --> 00:43:47,217
所以，要与风格相一致。

950
00:43:47,217 --> 00:43:48,800
我保证它会让你的生活更轻松。

951
00:43:48,800 --> 00:43:50,330
它会让我们的生活更轻松。

952
00:43:50,330 --> 00:43:51,869
每个人都会更幸福。

953
00:43:51,869 --> 00:43:52,910
这就是你想要的。

954
00:43:52,910 --> 00:43:54,192

955
00:43:54,192 --> 00:43:55,650
GABRIEL：你的分数会更高。

956
00:43:55,650 --> 00:43:56,858
ALLISON：是的，你的成绩。

957
00:43:56,858 --> 00:43:58,410

958
00:43:58,410 --> 00:44:01,930
如果你的TF就是喜欢你，
往往是有利的。

959
00:44:01,930 --> 00:44:02,940

960
00:44:02,940 --> 00:44:05,010
好吧，然后就
这里的第二点。

961
00:44:05,010 --> 00:44:06,300
一致的初始化。

962
00:44:06,300 --> 00:44:09,605
所以，正如我们所看到，你可以声明
和初始化的东西。

963
00:44:09,605 --> 00:44:10,750

964
00:44:10,750 --> 00:44:13,180
在同一行上的多个变量。

965
00:44:13,180 --> 00:44:17,930
我们希望您不是一回事
做的是声明一些变量

966
00:44:17,930 --> 00:44:21,360
而不是初始化它们在同
您正在初始化其他线路。

967
00:44:21,360 --> 00:44:23,960
>> 所以，如果说做
没有任何意义，

968
00:44:23,960 --> 00:44:29,050
我们这里的例子
我们正在申报整数

969
00:44:29,050 --> 00:44:31,180
在宿舍的变量
助攻和便士，

970
00:44:31,180 --> 00:44:34,214
但宿舍和便士
有没有初始值。

971
00:44:34,214 --> 00:44:36,630
我们没有初始化他们，
但就在中间有

972
00:44:36,630 --> 00:44:38,600
我们已经初始化助攻为0。

973
00:44:38,600 --> 00:44:41,650
所以，无论是做宿舍，硬币，硬币。

974
00:44:41,650 --> 00:44:43,170
或者做宿舍等于0。

975
00:44:43,170 --> 00:44:43,930
一角硬币等于0。

976
00:44:43,930 --> 00:44:46,810
便士等于0，或任何
这些初始值。

977
00:44:46,810 --> 00:44:49,800
>> 大的事情有型有款，是一致的。

978
00:44:49,800 --> 00:44:51,050
如果有疑问，是一致的。

979
00:44:51,050 --> 00:44:52,129

980
00:44:52,129 --> 00:44:53,420
但是，按照我们的风格指南了。

981
00:44:53,420 --> 00:44:54,710

982
00:44:54,710 --> 00:44:55,317
凉爽。

983
00:44:55,317 --> 00:44:56,150
每个人都很好吗？

984
00:44:56,150 --> 00:44:57,566
>> 听众：哪里的风格指南？

985
00:44:57,566 --> 00:45:00,800
艾里逊：本风格指南
是on--有什么网站？

986
00:45:00,800 --> 00:45:03,950
>> GABRIEL：我认为这是manual.cs50.net/--

987
00:45:03,950 --> 00:45:04,575
艾里逊：风格？

988
00:45:04,575 --> 00:45:05,610

989
00:45:05,610 --> 00:45:06,390
>> GABRIEL：风格。

990
00:45:06,390 --> 00:45:06,920
是的。

991
00:45:06,920 --> 00:45:07,520
>> 艾里逊：是的。

992
00:45:07,520 --> 00:45:10,150
那么问题究竟在哪里风格50。

993
00:45:10,150 --> 00:45:12,250
manual.cs50.net/style。

994
00:45:12,250 --> 00:45:13,639
是吗？

995
00:45:13,639 --> 00:45:16,880
>> 听众：如果我们定义
变量，它是OK

996
00:45:16,880 --> 00:45:28,145
如果我们把像[听不清]像
INT得分，然后INT目标。

997
00:45:28,145 --> 00:45:29,873

998
00:45:29,873 --> 00:45:35,100
所以，你会说，现在我们已经
一定要确定他们在一起吗？

999
00:45:35,100 --> 00:45:37,640
>> 艾里逊：那么质疑，应
你有多余的代码

1000
00:45:37,640 --> 00:45:40,940
当你定义
变量如int得分和

1001
00:45:40,940 --> 00:45:43,239
在下一行INT游戏？

1002
00:45:43,239 --> 00:45:46,030
罗布·鲍登：有一定
情况下，冗余的代码是坏的。

1003
00:45:46,030 --> 00:45:47,738
我不会考虑
该冗余代码。

1004
00:45:47,738 --> 00:45:50,970
我几乎从来没有申报多
变量在同一行过。

1005
00:45:50,970 --> 00:45:53,736
如果有什么，那是因为
平时我留下一些评论

1006
00:45:53,736 --> 00:45:55,235
解释变量是什么。

1007
00:45:55,235 --> 00:45:57,582
所以我会说INT得分斜线斜线。

1008
00:45:57,582 --> 00:45:59,350
跟踪什么的。

1009
00:45:59,350 --> 00:46:00,710
在总斜线斜线。

1010
00:46:00,710 --> 00:46:01,790

1011
00:46:01,790 --> 00:46:06,455
因此，它是那样的多格罗瑟
把它们都在同一行上。

1012
00:46:06,455 --> 00:46:08,080
我从来没有把它们放在同一行。

1013
00:46:08,080 --> 00:46:10,580
>> 艾里逊：我觉得这是
个人偏好在这一点上。

1014
00:46:10,580 --> 00:46:14,900
>> 听众：这是否去
for循环之类的东西吗？

1015
00:46:14,900 --> 00:46:15,900
罗布·鲍登：像里面？

1016
00:46:15,900 --> 00:46:18,282
如int i等于0逗号
长度等于什么？

1017
00:46:18,282 --> 00:46:19,490
那你没有选择。

1018
00:46:19,490 --> 00:46:21,850

1019
00:46:21,850 --> 00:46:25,910
用for循环的初始化
part--所以你可能只看到

1020
00:46:25,910 --> 00:46:31,520
INT i等于0分号我少
比任何分号我加再加。

1021
00:46:31,520 --> 00:46:33,820
这个int i等于0，
技术上你也可以

1022
00:46:33,820 --> 00:46:35,770
做我们之前看到的
用逗号语法。

1023
00:46:35,770 --> 00:46:39,790
INT i等于0逗号Ĵ
等于3逗号k等于5。

1024
00:46:39,790 --> 00:46:41,610

1025
00:46:41,610 --> 00:46:44,320
你没有选择拆分
这为多行，

1026
00:46:44,320 --> 00:46:46,530
这就是标准。

1027
00:46:46,530 --> 00:46:47,780
看到它有罚款。

1028
00:46:47,780 --> 00:46:49,182

1029
00:46:49,182 --> 00:46:49,890
艾里逊：真棒。

1030
00:46:49,890 --> 00:46:52,120
好吧，方便SEGUE成环。

1031
00:46:52,120 --> 00:46:54,860

1032
00:46:54,860 --> 00:46:58,980
所以呀，我们这里有一些例子
回路，你们在看到划痕。

1033
00:46:58,980 --> 00:47:01,550
当然，所有的这些
只需在C.重建

1034
00:47:01,550 --> 00:47:04,610
他们基本上是让你
重复代码的某些部分

1035
00:47:04,610 --> 00:47:06,740
直到一定的条件
得到满足，我们将

1036
00:47:06,740 --> 00:47:09,198
进入正确的说话后，
关于循环使用条件语句。

1037
00:47:09,198 --> 00:47:11,150

1038
00:47:11,150 --> 00:47:12,570
>> 因此，我们有三种主要类型。

1039
00:47:12,570 --> 00:47:17,500
因为，虽然，做一段时间，这
我们将所有的经历现在。

1040
00:47:17,500 --> 00:47:18,860
所以，第一个是for循环。

1041
00:47:18,860 --> 00:47:20,490

1042
00:47:20,490 --> 00:47:25,034
所以对于一些条件，
执行这个代码块。

1043
00:47:25,034 --> 00:47:27,200
我们有这个很酷的小
关系图在此间举行的底部。

1044
00:47:27,200 --> 00:47:28,230

1045
00:47:28,230 --> 00:47:32,310
但基本上，你在
你的，那行头，

1046
00:47:32,310 --> 00:47:34,240
你要
初始化变量。

1047
00:47:34,240 --> 00:47:38,260
>> 因此，当我们谈到，我是
等于0或i等于10。

1048
00:47:38,260 --> 00:47:40,010
无论你需要的
变量是它的

1049
00:47:40,010 --> 00:47:43,970
要被初始化的存在，
声明和初始化为某个值。

1050
00:47:43,970 --> 00:47:46,760
所以后来我们有一些
条件是怎么回事

1051
00:47:46,760 --> 00:47:48,900
要检查我们的
可变反对的东西。

1052
00:47:48,900 --> 00:47:55,220
这样的情况下的典型的情况下
也许你想这部分代码

1053
00:47:55,220 --> 00:47:56,620
执行五次。

1054
00:47:56,620 --> 00:48:02,380
因此，我们不得不INT i等于0，而且我们
希望它是，当i小于5。

1055
00:48:02,380 --> 00:48:04,940
使条件是刚刚
要检查每一次。

1056
00:48:04,940 --> 00:48:07,120
如果条件
计算结果为true，它的

1057
00:48:07,120 --> 00:48:11,162
要运行的代码，而这正是
这是什么小图是显示。

1058
00:48:11,162 --> 00:48:12,370

1059
00:48:12,370 --> 00:48:13,639
>> 所以它执行它。

1060
00:48:13,639 --> 00:48:15,430
它更新一个变量，
这就是我们看到的

1061
00:48:15,430 --> 00:48:21,020
在我们对的最后部分
环路初始化那里。

1062
00:48:21,020 --> 00:48:22,370

1063
00:48:22,370 --> 00:48:26,030
因此，只要继续这样做
直到该条件没有被满足，

1064
00:48:26,030 --> 00:48:28,010
然后将退出
循环并继续

1065
00:48:28,010 --> 00:48:29,960
移动与程序的其余部分。

1066
00:48:29,960 --> 00:48:31,320

1067
00:48:31,320 --> 00:48:33,620
每个人都很好吗？

1068
00:48:33,620 --> 00:48:34,440
凉爽。

1069
00:48:34,440 --> 00:48:37,780
>> 因此，这里是一个例子，非常相似
到东西，我刚才讲的。

1070
00:48:37,780 --> 00:48:42,030
所以，我们只想打印
这是CS50 10倍。

1071
00:48:42,030 --> 00:48:44,540
所以，你在这里看到我们有
我们的，然后我们

1072
00:48:44,540 --> 00:48:47,450
初始化变量
i到等于0。

1073
00:48:47,450 --> 00:48:50,610
我们的条件检查
它的不到10％。

1074
00:48:50,610 --> 00:48:55,210
因此，计算结果为true时首先我们
开始，然后更新我们的变量

1075
00:48:55,210 --> 00:48:58,985
每次它实际上执行的时间
并打印出来，这是CS50。

1076
00:48:58,985 --> 00:49:00,510

1077
00:49:00,510 --> 00:49:02,180
经过10次将终止。

1078
00:49:02,180 --> 00:49:03,190

1079
00:49:03,190 --> 00:49:04,070
凉爽。

1080
00:49:04,070 --> 00:49:07,130
>> 所以，当环路旁边。

1081
00:49:07,130 --> 00:49:12,400
正如你看到这里，我们只是有
有的虽然这condition--问题？

1082
00:49:12,400 --> 00:49:15,238
>> 观众：我怎么能跳
其实不只是一个数字，

1083
00:49:15,238 --> 00:49:19,030
但两个号码[听不清]
我加再加加？

1084
00:49:19,030 --> 00:49:23,390
>> 艾里逊：所以，问题是你怎么能
由一个以上的更新变量

1085
00:49:23,390 --> 00:49:24,070
的时间。

1086
00:49:24,070 --> 00:49:26,860
所以我加Plus会
更新一个各一次。

1087
00:49:26,860 --> 00:49:32,310
如果您希望通过更新它
2，你可以做我加等于2。

1088
00:49:32,310 --> 00:49:34,526
>> 罗布·鲍登：你见过
加上演讲等于没？

1089
00:49:34,526 --> 00:49:35,442
>> 听众：[听不清]。

1090
00:49:35,442 --> 00:49:37,440

1091
00:49:37,440 --> 00:49:42,110
>> 艾里逊：这是有效的
同样的事情，我等于我加2。

1092
00:49:42,110 --> 00:49:46,130
因此，它打算把它和
通过每次2更新它。

1093
00:49:46,130 --> 00:49:49,432
加等于只是一些
我们所说的语法糖。

1094
00:49:49,432 --> 00:49:52,390
罗布·鲍登：是啊，那些存在
几乎所有的算术运算符。

1095
00:49:52,390 --> 00:49:55,830
所以，我多次等于
将增加一倍的数量。

1096
00:49:55,830 --> 00:50:02,590
Ĵ除法等于3是相同的
作为j为j通过3分。

1097
00:50:02,590 --> 00:50:07,399
>> 艾里逊：或减等于2将
通过每次2递减岛

1098
00:50:07,399 --> 00:50:08,565
罗布·鲍登：即使MOD平等。

1099
00:50:08,565 --> 00:50:09,690

1100
00:50:09,690 --> 00:50:13,270
你没见过位运算符，
但插入符等于和等于符号，

1101
00:50:13,270 --> 00:50:14,560
所有这些的存在。

1102
00:50:14,560 --> 00:50:19,480
>> 艾里逊：所以很多时候，尤其是
你的第一对夫妇的P组，

1103
00:50:19,480 --> 00:50:22,527
你将很可能由递增
一个，所以我加再加，J加再加

1104
00:50:22,527 --> 00:50:24,610
是你要的所有东西
以典型地使用。

1105
00:50:24,610 --> 00:50:28,240
但该更新条件是
完全的控制范围之内。

1106
00:50:28,240 --> 00:50:32,310
您可以通过任何增量更新
或以任何方式你决定。

1107
00:50:32,310 --> 00:50:33,389

1108
00:50:33,389 --> 00:50:35,680
也许你甚至希望它是
随机数的时候。

1109
00:50:35,680 --> 00:50:37,180

1110
00:50:37,180 --> 00:50:39,580
但是，是的，有很多
事情可以做的。

1111
00:50:39,580 --> 00:50:41,280
你不会受限于我加再加。

1112
00:50:41,280 --> 00:50:44,400
>> 罗布·鲍登：只要你
知道它的存在，它也

1113
00:50:44,400 --> 00:50:46,960
存在的另一种形式，再加上加上我。

1114
00:50:46,960 --> 00:50:51,410
因此，如果你曾经在网上搜索
而碰巧看到再加上加我，

1115
00:50:51,410 --> 00:50:52,870
几乎是同一个意思。

1116
00:50:52,870 --> 00:50:54,377

1117
00:50:54,377 --> 00:50:54,960
艾里逊：酷。

1118
00:50:54,960 --> 00:50:56,070

1119
00:50:56,070 --> 00:50:56,740
好不好？

1120
00:50:56,740 --> 00:50:57,240
真棒。

1121
00:50:57,240 --> 00:50:59,190

1122
00:50:59,190 --> 00:50:59,990
因此，尽管循环。

1123
00:50:59,990 --> 00:51:01,160

1124
00:51:01,160 --> 00:51:02,570
非常相似。

1125
00:51:02,570 --> 00:51:03,737
你有一些条件。

1126
00:51:03,737 --> 00:51:05,820
最主要的是要注意
这里，代替具有

1127
00:51:05,820 --> 00:51:08,540
三个不同的部分
成立，我们有一个。

1128
00:51:08,540 --> 00:51:11,090
我们只是有一些条件
这就是被选中。

1129
00:51:11,090 --> 00:51:14,920
并以同样的方式，只要
该条件的计算结果为true，

1130
00:51:14,920 --> 00:51:16,840
你的代码将运行。

1131
00:51:16,840 --> 00:51:18,870
如果它是假的，它
将终止，招

1132
00:51:18,870 --> 00:51:21,930
到你的程序的下一个部分。

1133
00:51:21,930 --> 00:51:25,780
因此，这是种like--什么
检查的一个很好的例子

1134
00:51:25,780 --> 00:51:27,215
对于一些正常状态？

1135
00:51:27,215 --> 00:51:29,402

1136
00:51:29,402 --> 00:51:30,235
GABRIEL：尽管这是事实。

1137
00:51:30,235 --> 00:51:32,110
艾里逊：你可以这样做，而真实的。

1138
00:51:32,110 --> 00:51:33,510
井，1等于1。

1139
00:51:33,510 --> 00:51:34,970

1140
00:51:34,970 --> 00:51:37,642
>> 罗布·鲍登：你可以做while--
使用for循环刚相反，

1141
00:51:37,642 --> 00:51:39,600
你总是可以编写一个
for循环在while循环，

1142
00:51:39,600 --> 00:51:42,600
所以我大于0或
虽然我不到10。

1143
00:51:42,600 --> 00:51:45,200

1144
00:51:45,200 --> 00:51:46,010
>> 艾里逊：真棒。

1145
00:51:46,010 --> 00:51:50,640
然后我们做的while循环，这
非常适合用户的验证，其中

1146
00:51:50,640 --> 00:51:55,370
你想获得的东西
你的用户，看它是否有效，

1147
00:51:55,370 --> 00:51:57,060
然后从那里继续。

1148
00:51:57,060 --> 00:52:04,000
所以的事情知道的一个是用
这样做，而在于它要执行，

1149
00:52:04,000 --> 00:52:08,000
然后它会重新执行
如果满足这一条件。

1150
00:52:08,000 --> 00:52:11,240
>> 所以，可能是最好的方式做到这一点
只是看到一个例子来说明。

1151
00:52:11,240 --> 00:52:14,620
因此，正如我刚才提到的，用户
验证是真的useful--

1152
00:52:14,620 --> 00:52:17,520
或者做消遣是真的
实用与用户的验证。

1153
00:52:17,520 --> 00:52:19,730
因此，这只是走
重新提示一些用户

1154
00:52:19,730 --> 00:52:23,640
直到他们进入一个正数，
这可能是你的P组有用

1155
00:52:23,640 --> 00:52:24,190
本星期。

1156
00:52:24,190 --> 00:52:25,850

1157
00:52:25,850 --> 00:52:29,480
因此在这种情况下，当我们
首先运行该程序，

1158
00:52:29,480 --> 00:52:32,260
它要打印
输入一个正数。

1159
00:52:32,260 --> 00:52:34,810
它会得到一些
来自用户的输入，

1160
00:52:34,810 --> 00:52:38,320
然后它会检查
即对输入的条件

1161
00:52:38,320 --> 00:52:39,500
你已经为它设置的。

1162
00:52:39,500 --> 00:52:41,030
>> 所以在这种情况下，它会检查。

1163
00:52:41,030 --> 00:52:44,190
它会说，OK，
是我们的输入负数，

1164
00:52:44,190 --> 00:52:47,175
或者是0或负，
这将是无效的。

1165
00:52:47,175 --> 00:52:48,300
这样的话它会重新提示。

1166
00:52:48,300 --> 00:52:50,280

1167
00:52:50,280 --> 00:52:50,780
问题？

1168
00:52:50,780 --> 00:52:54,720
>> 听众：这是相同的，那么作为一个
while循环，如果你只是复制代码

1169
00:52:54,720 --> 00:52:56,680
并把它[听不清] while循环？

1170
00:52:56,680 --> 00:52:59,620

1171
00:52:59,620 --> 00:53:05,160
>> 艾里逊：那么问题是会
这是相同的只是一会儿

1172
00:53:05,160 --> 00:53:08,570
循环，如果我们只
复制while循环以上。

1173
00:53:08,570 --> 00:53:12,440
所以在这种情况下，你的while循环
要首先检查条件。

1174
00:53:12,440 --> 00:53:15,300
所以在这种情况下，如果我们试图
写的只是一个while循环，

1175
00:53:15,300 --> 00:53:18,010
它会说而
输入小于1。

1176
00:53:18,010 --> 00:53:20,801
但是，我们并没有一个输入它。

1177
00:53:20,801 --> 00:53:24,238
>> 听众：如果[听不清]
while循环包括这段代码，

1178
00:53:24,238 --> 00:53:28,166
但你应付代码
上面的while循环也。

1179
00:53:28,166 --> 00:53:31,052
你只要有这个代码
[听不清] while循环。

1180
00:53:31,052 --> 00:53:32,760
ALLISON：这将是
同样的事情，是的。

1181
00:53:32,760 --> 00:53:37,110
所以，你可以只写 - 
而不是有一个do--肯定的。

1182
00:53:37,110 --> 00:53:37,976

1183
00:53:37,976 --> 00:53:39,350
GABRIEL：但是，这更优雅。

1184
00:53:39,350 --> 00:53:41,020
ALLISON：是啊，那是更优雅。

1185
00:53:41,020 --> 00:53:44,560
你可以进入设计和诸如此类的东西，
但是，是的，你完全可以做到这一点。

1186
00:53:44,560 --> 00:53:45,850

1187
00:53:45,850 --> 00:53:47,072
还有没有其他问题？

1188
00:53:47,072 --> 00:53:49,240

1189
00:53:49,240 --> 00:53:50,250
OK，爽。

1190
00:53:50,250 --> 00:53:55,540
>> 因此，我们谈了很多关于条件
所有这些循环，我们有，

1191
00:53:55,540 --> 00:53:58,615
所以我们实际上进入
条件布尔表达式。

1192
00:53:58,615 --> 00:53:59,990

1193
00:53:59,990 --> 00:54:03,440
同样，你在C中使用这些，
所以只是一种过渡

1194
00:54:03,440 --> 00:54:06,050
从以上图形界面
实际的编码。

1195
00:54:06,050 --> 00:54:07,480

1196
00:54:07,480 --> 00:54:09,100
>> 酷，这么大一个，如果。

1197
00:54:09,100 --> 00:54:11,130

1198
00:54:11,130 --> 00:54:17,070
基本上只允许我们引入
一些逻辑到我们的程序和检查

1199
00:54:17,070 --> 00:54:17,790
SYS条件。

1200
00:54:17,790 --> 00:54:22,150
所以在这种情况下，确定，
为n大于0？

1201
00:54:22,150 --> 00:54:24,070
的确是这样，这样你就可以执行了。

1202
00:54:24,070 --> 00:54:28,060
这只是一些检查
你已经条件

1203
00:54:28,060 --> 00:54:33,565
设置，我认为我们都
舒适的检查环境。

1204
00:54:33,565 --> 00:54:35,975

1205
00:54:35,975 --> 00:54:36,475
凉爽。

1206
00:54:36,475 --> 00:54:38,760

1207
00:54:38,760 --> 00:54:44,530
所以，如果别人是你的另外一个，
你可以说好，如果这是真的，

1208
00:54:44,530 --> 00:54:46,150
这样做的第一件事。

1209
00:54:46,150 --> 00:54:48,720
否则我要你
默认情况下，做别的事情。

1210
00:54:48,720 --> 00:54:51,977

1211
00:54:51,977 --> 00:54:55,060
像这种情况，你要么选择一个
正数或负数。

1212
00:54:55,060 --> 00:54:56,500
你只有两个选择。

1213
00:54:56,500 --> 00:54:59,550
你需要它来执行，无论
了解你的用户输入。

1214
00:54:59,550 --> 00:55:02,920
所以，你可以说好，
是它大于0？

1215
00:55:02,920 --> 00:55:03,480
凉爽。

1216
00:55:03,480 --> 00:55:04,480
打印的正数。

1217
00:55:04,480 --> 00:55:06,153
如果不是的话，打印负。

1218
00:55:06,153 --> 00:55:06,960
大家好？

1219
00:55:06,960 --> 00:55:14,920
>> 再有一点认识是
如果满足该条件的话，

1220
00:55:14,920 --> 00:55:16,650
的人会永远也执行。

1221
00:55:16,650 --> 00:55:19,210
只有将其中的一个
同时执行。

1222
00:55:19,210 --> 00:55:20,410
所以这是一个权衡。

1223
00:55:20,410 --> 00:55:21,720
你没有得到兼得。

1224
00:55:21,720 --> 00:55:23,566
你要么具备的首要条件。

1225
00:55:23,566 --> 00:55:25,440
你要么有，如果
还是一样，不能同时使用。

1226
00:55:25,440 --> 00:55:26,849

1227
00:55:26,849 --> 00:55:28,890
然后可以把事情
更加复杂，

1228
00:55:28,890 --> 00:55:31,060
因为如果你能做到，
否则，然后其他人。

1229
00:55:31,060 --> 00:55:32,810
所以在这种情况下，我们
有三个条件。

1230
00:55:32,810 --> 00:55:34,830

1231
00:55:34,830 --> 00:55:38,370
再次，只有其中的一个是
最终将会被执行。

1232
00:55:38,370 --> 00:55:41,030
所以，你可能想知道
好吧，如果你有什么

1233
00:55:41,030 --> 00:55:45,510
有什么事情，
能满足这两个。

1234
00:55:45,510 --> 00:55:49,520
也许无论你输入
符合这两个条件

1235
00:55:49,520 --> 00:55:51,811
因为如果和其他人的话。

1236
00:55:51,811 --> 00:55:53,060
唯一的事情，那将运行

1237
00:55:53,060 --> 00:55:56,240
>> 艾里逊：一旦它发现的东西
它满足该条件

1238
00:55:56,240 --> 00:55:59,790
计算结果为true，这就是
它会跑，没有别的。

1239
00:55:59,790 --> 00:56:04,440
所以，如果你有这号
关于第1 0和5之间，

1240
00:56:04,440 --> 00:56:10,530
或者是介于3这个数
和5的其他部分如，

1241
00:56:10,530 --> 00:56:15,550
您输入的number--
我说0和5还有 -  4。

1242
00:56:15,550 --> 00:56:18,110
这将创下第一个。

1243
00:56:18,110 --> 00:56:20,960
它会说OK，这
数为0和5之间。

1244
00:56:20,960 --> 00:56:22,480
执行和离开。

1245
00:56:22,480 --> 00:56:25,340
它永远不会打了第二个选项。

1246
00:56:25,340 --> 00:56:26,394
酷？

1247
00:56:26,394 --> 00:56:27,250
真棒。

1248
00:56:27,250 --> 00:56:31,300
>> OK，我们也有switch语句，如果
你想获得更为缓慢 - 还是遗憾，

1249
00:56:31,300 --> 00:56:31,965
开关旁边。

1250
00:56:31,965 --> 00:56:33,540

1251
00:56:33,540 --> 00:56:34,990
我自己走在前面这里。

1252
00:56:34,990 --> 00:56:36,370

1253
00:56:36,370 --> 00:56:39,210
同样，如果多块
正如我刚才所说的地方

1254
00:56:39,210 --> 00:56:45,600
只要你找到一个条件是
这是遇到了和其他人的话，如果其他人，

1255
00:56:45,600 --> 00:56:46,630
它的叶子。

1256
00:56:46,630 --> 00:56:49,560
如果您需要检查
多的东西，你

1257
00:56:49,560 --> 00:56:53,000
会想用这个，因为
它会检查这里的每一次。

1258
00:56:53,000 --> 00:56:58,060
因此，这将通过，如果运行
它是大于或等于90，

1259
00:56:58,060 --> 00:56:59,160
它会打印。

1260
00:56:59,160 --> 00:57:00,530

1261
00:57:00,530 --> 00:57:03,600
它将贯穿和
检查这些每一个人。

1262
00:57:03,600 --> 00:57:06,444
>> 听众：所以这将是
比[听不清]更多的越野车。

1263
00:57:06,444 --> 00:57:07,735
这会不会像[听不清]？

1264
00:57:07,735 --> 00:57:10,990

1265
00:57:10,990 --> 00:57:15,740
>> 艾里逊：问题是这是否
越野车还是该做你想做的。

1266
00:57:15,740 --> 00:57:19,830
这真的取决于什么
你想从你的程序。

1267
00:57:19,830 --> 00:57:22,291
>> 听众：我的意思是，如果你把90等。

1268
00:57:22,291 --> 00:57:23,290
艾里逊：如果你把90--

1269
00:57:23,290 --> 00:57:24,206
听众：[听不清]。

1270
00:57:24,206 --> 00:57:25,584

1271
00:57:25,584 --> 00:57:27,250
GABRIEL：你会得到两件事情。

1272
00:57:27,250 --> 00:57:28,916
艾里逊：你会得到两件事情。

1273
00:57:28,916 --> 00:57:29,420
是的，2。

1274
00:57:29,420 --> 00:57:32,420

1275
00:57:32,420 --> 00:57:33,920
>> 罗布·鲍登：两个？

1276
00:57:33,920 --> 00:57:34,580
>> 艾里逊：第

1277
00:57:34,580 --> 00:57:35,288
>> 罗布·鲍登：四。

1278
00:57:35,288 --> 00:57:37,070

1279
00:57:37,070 --> 00:57:40,070
如果你把90，它会说你
得了A，你有一个B，你有一个C，

1280
00:57:40,070 --> 00:57:40,545
你有D.

1281
00:57:40,545 --> 00:57:41,461
>> 听众：[听不清]。

1282
00:57:41,461 --> 00:57:42,196

1283
00:57:42,196 --> 00:57:42,820
艾里逊：对。

1284
00:57:42,820 --> 00:57:44,778
所以，我要看你
想从你的程序。

1285
00:57:44,778 --> 00:57:47,050
有时你需要
检查多东西。

1286
00:57:47,050 --> 00:57:49,970

1287
00:57:49,970 --> 00:57:55,270
你会得到更深入到什么
良好的设计是为你往前走。

1288
00:57:55,270 --> 00:57:57,090
重要的是要
知道的是，这

1289
00:57:57,090 --> 00:58:01,090
这里将检查所有四个条件。

1290
00:58:01,090 --> 00:58:05,860
然而，如果这是一个的if else的if else
否则的话，它会打的第一种情况下，

1291
00:58:05,860 --> 00:58:07,950
它会打印你有一个A和完成。

1292
00:58:07,950 --> 00:58:10,250
>> 罗布·鲍登：即使我们
决定改变这是否

1293
00:58:10,250 --> 00:58:13,880
和大于或等于90，
如果和大于或等于80，

1294
00:58:13,880 --> 00:58:19,710
如果和小于或等于89，
如果n大于或等于70，则

1295
00:58:19,710 --> 00:58:23,830
并且n小于或等于
79，所以，这将是正确的。

1296
00:58:23,830 --> 00:58:27,190
这将做我们想要的，但
它仍然会检查每一个它。

1297
00:58:27,190 --> 00:58:34,050
>> 因此，而在第一种情况，如果我们
进入90只，如果还有其他​​的话，如果，

1298
00:58:34,050 --> 00:58:37,300
我们输入90，然后
它要纠正。

1299
00:58:37,300 --> 00:58:39,615
它会检查第一
1，打印你得到一个A，

1300
00:58:39,615 --> 00:58:42,590
跳过一切，因为它
已经找到一个工作。

1301
00:58:42,590 --> 00:58:46,360
所有病例均是互斥的
否则的话，如果别人的话的基础上。

1302
00:58:46,360 --> 00:58:48,630
所以它会执行
首先，如果，那么它的完成。

1303
00:58:48,630 --> 00:58:49,790
它会走到最后。

1304
00:58:49,790 --> 00:58:52,400
>> 而如果我们改变
这是什么我

1305
00:58:52,400 --> 00:58:54,204
说小于或等于89。

1306
00:58:54,204 --> 00:58:55,620
这将检查的第一个。

1307
00:58:55,620 --> 00:58:56,560
它会打印。

1308
00:58:56,560 --> 00:58:58,010
它会检查第二个。

1309
00:58:58,010 --> 00:58:59,010
它不会打印。

1310
00:58:59,010 --> 00:58:59,910
检查第三个。

1311
00:58:59,910 --> 00:59:00,620
无法进行打印。

1312
00:59:00,620 --> 00:59:01,495
检查第四个。

1313
00:59:01,495 --> 00:59:02,420
现在去打印。

1314
00:59:02,420 --> 00:59:05,380
所以在这种情况下，否则，如果
版本，因为这些情况

1315
00:59:05,380 --> 00:59:09,120
是相互排斥的，这是
更好地利用别人的话，如果还有的话，

1316
00:59:09,120 --> 00:59:12,970
因为那将不得不
少的条件检查

1317
00:59:12,970 --> 00:59:14,750
比这个版本。

1318
00:59:14,750 --> 00:59:17,692

1319
00:59:17,692 --> 00:59:18,400
艾里逊：真棒。

1320
00:59:18,400 --> 00:59:20,580
所以另一件事，我们可以
做的是switch语句。

1321
00:59:20,580 --> 00:59:23,104

1322
00:59:23,104 --> 00:59:25,270
基本上是一个switch语句
需要一些变量，

1323
00:59:25,270 --> 00:59:28,780
在这种情况下，它是n，并且
决定执行哪一个情况。

1324
00:59:28,780 --> 00:59:33,106
所以，这也是1在您的案件
应该是种相互排斥的。

1325
00:59:33,106 --> 00:59:35,210

1326
00:59:35,210 --> 00:59:37,940
所以在这种情况下，如果
我们得到一个，它的

1327
00:59:37,940 --> 00:59:42,270
要匹配什么的
n个变量 - 无论价值

1328
00:59:42,270 --> 00:59:48,700
是其中的一个箱子，所以1，2，或
3，并打印出相应的行。

1329
00:59:48,700 --> 00:59:51,870
>> 然后，如果你在这里看到，
我们也有一个默认的，

1330
00:59:51,870 --> 00:59:54,670
你可以对所认为的你的人。

1331
00:59:54,670 --> 00:59:58,510
如果你选择的任何其他号码，以便
除1，2，和3在这种情况下

1332
00:59:58,510 --> 00:59:59,885
它只是要打印无效。

1333
00:59:59,885 --> 01:00:03,690

1334
01:00:03,690 --> 01:00:08,390
决定何时使用IFS与
如果偷别人对交换机是怎么回事

1335
01:00:08,390 --> 01:00:12,590
要的东西，你们会
看到你开始编写设计智慧

1336
01:00:12,590 --> 01:00:15,270
更复杂的方案，并且
有没有硬性的规定

1337
01:00:15,270 --> 01:00:16,330
的时候使用它们。

1338
01:00:16,330 --> 01:00:17,890
这真的取决于你的环境。

1339
01:00:17,890 --> 01:00:18,590
>> 罗布·鲍登：而就
把它扔在那里

1340
01:00:18,590 --> 01:00:20,131
因为它是更舒适的部分。

1341
01:00:20,131 --> 01:00:20,920

1342
01:00:20,920 --> 01:00:25,053
开关时，往往会
be--所以你限制

1343
01:00:25,053 --> 01:00:27,430
在方式的数量，你
可以使用它们，因为如果，

1344
01:00:27,430 --> 01:00:30,100
条件可以很
你想要任何东西。

1345
01:00:30,100 --> 01:00:33,410
带开关的情况下，
必须是数字，

1346
01:00:33,410 --> 01:00:37,770
或技术上也可以是字符，但
字符，正如我们将看到的，都只是数字。

1347
01:00:37,770 --> 01:00:44,250
因此，他们必须是数字，但开关
真的，如果不是更有效

1348
01:00:44,250 --> 01:00:50,060
否则的话，如果还有，因为即使
以这个例子before--好，

1349
01:00:50,060 --> 01:00:51,486
档次例子似乎不错。

1350
01:00:51,486 --> 01:00:52,550

1351
01:00:52,550 --> 01:00:57,080
>> 好吧，让我们在这里说，我们不是做
这是一个用if else的if else，如果场景。

1352
01:00:57,080 --> 01:01:00,930
因此，如果n等于等于1，则
打印你选择了一个低的数字。

1353
01:01:00,930 --> 01:01:04,490
如果别人当n等于等于2，
你选择了一个中等数目。

1354
01:01:04,490 --> 01:01:06,550
否则，如果等于等于3，高。

1355
01:01:06,550 --> 01:01:08,060
否则无效。

1356
01:01:08,060 --> 01:01:09,820
>> 所以我们可以说，这是我们的场景。

1357
01:01:09,820 --> 01:01:14,060
所以我们可以说，我们进入
4，因此我们预计无效。

1358
01:01:14,060 --> 01:01:17,410
顺便说，如果其他的if else
如果方法是行不通的

1359
01:01:17,410 --> 01:01:18,740
检查第一个条件。

1360
01:01:18,740 --> 01:01:19,776
这不是满意。

1361
01:01:19,776 --> 01:01:21,150
所以，我们检查了第二个条件。

1362
01:01:21,150 --> 01:01:21,940
这不是满意。

1363
01:01:21,940 --> 01:01:23,023
检查第三个条件。

1364
01:01:23,023 --> 01:01:23,640
不满意。

1365
01:01:23,640 --> 01:01:26,650
所以，我们去别的并打印无效。

1366
01:01:26,650 --> 01:01:30,169
>> 路开关厂
是它编译成

1367
01:01:30,169 --> 01:01:31,960
到了我们要去
调用跳转表。

1368
01:01:31,960 --> 01:01:33,180

1369
01:01:33,180 --> 01:01:37,120
主要的想法是
当你进入4的，

1370
01:01:37,120 --> 01:01:39,090
它可以立即去默认。

1371
01:01:39,090 --> 01:01:41,460
它并不需要检查时的情况下我吗？

1372
01:01:41,460 --> 01:01:42,350
没了，这不是它。

1373
01:01:42,350 --> 01:01:42,850
案例2？

1374
01:01:42,850 --> 01:01:43,240
没了。

1375
01:01:43,240 --> 01:01:43,770
案例3？

1376
01:01:43,770 --> 01:01:44,270
没了。

1377
01:01:44,270 --> 01:01:45,090
默认值。

1378
01:01:45,090 --> 01:01:47,610
OK，这一定是哪里
想要的，然后执行这一点。

1379
01:01:47,610 --> 01:01:49,590
不，它会立即跳转到默认值。

1380
01:01:49,590 --> 01:01:51,900
或者我输入2，它是
马上要去到2

1381
01:01:51,900 --> 01:01:54,060
而不需要去通过案例1。

1382
01:01:54,060 --> 01:01:57,820
>> 因此，在这种方式
切实如今这

1383
01:01:57,820 --> 01:02:00,250
没有那么多的效率增益。

1384
01:02:00,250 --> 01:02:02,880
一般的电脑都还
快，这不是很大。

1385
01:02:02,880 --> 01:02:07,270
但它是这种情况即
开关速度更快。

1386
01:02:07,270 --> 01:02:10,380
如果你真的想
优化，使用一个开关。

1387
01:02:10,380 --> 01:02:11,980

1388
01:02:11,980 --> 01:02:12,710
>> 艾里逊：酷。

1389
01:02:12,710 --> 01:02:15,270
然后我们有三元运算符。

1390
01:02:15,270 --> 01:02:19,470
所以我知道我前面提到的
单词语法糖。

1391
01:02:19,470 --> 01:02:24,160
所以，它只是事情让
你的代码更简洁。

1392
01:02:24,160 --> 01:02:25,590
因此，这是其中的案例之一。

1393
01:02:25,590 --> 01:02:31,430
>> 因此，三元运算符是问号
结肠我们行字符串中看到

1394
01:02:31,430 --> 01:02:35,810
上的equalsñ大于100
问号高冒号低。

1395
01:02:35,810 --> 01:02:41,800
所以基本上这是如何工作是很
在n大于100是一个条件。

1396
01:02:41,800 --> 01:02:43,674
所以我认为这是有意义的。

1397
01:02:43,674 --> 01:02:44,840
这就像问一个问题。

1398
01:02:44,840 --> 01:02:47,320
它说的哦，是正大于100。

1399
01:02:47,320 --> 01:02:48,340
谁知道？

1400
01:02:48,340 --> 01:02:50,750
而如果计算结果为
如此，这将让你

1401
01:02:50,750 --> 01:02:54,270
第一件事是
那里列出，这是很高的。

1402
01:02:54,270 --> 01:02:55,840
否则，它会为您提供低。

1403
01:02:55,840 --> 01:03:01,210
所以，这只是一个非常简单的和
有效的方式做到像的if else。

1404
01:03:01,210 --> 01:03:02,780
这就是这一切。

1405
01:03:02,780 --> 01:03:07,450
>> 如果我们写这
作为一个if else条件，

1406
01:03:07,450 --> 01:03:12,480
那将是如果n是大于
100余名，高回报。

1407
01:03:12,480 --> 01:03:14,220
否则，回报低。

1408
01:03:14,220 --> 01:03:17,570
这仅仅是一个更
写它的简洁方式。

1409
01:03:17,570 --> 01:03:27,090
>> 罗布·鲍登：所以这个特定的例子
是当你正在做的事情

1410
01:03:27,090 --> 01:03:30,190
就是这样，这是一种模式
在这里我使用三元非常频繁。

1411
01:03:30,190 --> 01:03:31,540

1412
01:03:31,540 --> 01:03:35,460
所以，我们还没有谈到的范围呢，
但我讨厌看到字符串s分号。

1413
01:03:35,460 --> 01:03:39,150
如果n大于100，S等于高。

1414
01:03:39,150 --> 01:03:40,660
否则，S​​等于低。

1415
01:03:40,660 --> 01:03:45,070
这样的模式，这五个线
代码100字面上的时间％

1416
01:03:45,070 --> 01:03:49,800
可以被转移到什么
就是在那里与三元。

1417
01:03:49,800 --> 01:03:52,340
因此，三元，一行代码。

1418
01:03:52,340 --> 01:03:54,640
在别人的话，五。

1419
01:03:54,640 --> 01:03:56,910
这是一个例子，我点
每一次。

1420
01:03:56,910 --> 01:03:59,250
这将极大的地方
对于三元运算符。

1421
01:03:59,250 --> 01:04:00,647
它是那么干净。

1422
01:04:00,647 --> 01:04:01,980
但是，人们往往不会使用它。

1423
01:04:01,980 --> 01:04:06,140

1424
01:04:06,140 --> 01:04:08,030
>> 艾里逊：把它拿走加布。

1425
01:04:08,030 --> 01:04:11,110
>> GABRIEL：所以现在你们所有的
在本周的演讲学会

1426
01:04:11,110 --> 01:04:13,420
这一切都在一个
计算机是二进制的，对不对？

1427
01:04:13,420 --> 01:04:14,570
就像这里的灯。

1428
01:04:14,570 --> 01:04:16,492
你可以是接通和关断。

1429
01:04:16,492 --> 01:04:18,450
和一切，我的意思是
从字面上一切。

1430
01:04:18,450 --> 01:04:24,272
一些数字和字符和字符串，
甚至代码，你写的时候

1431
01:04:24,272 --> 01:04:26,480
它被编译为机器
代码之类的东西，

1432
01:04:26,480 --> 01:04:29,230
所以这一切归结为0和1“。

1433
01:04:29,230 --> 01:04:34,540
>> 所以，当我们正在处理
与整数，这

1434
01:04:34,540 --> 01:04:38,000
是什么，在技术上是非常
简单，我们应该能够做的东西

1435
01:04:38,000 --> 01:04:40,630
如添加它们，这是
最简单的事情大概1

1436
01:04:40,630 --> 01:04:42,300
你可以做两个整数，对吧？

1437
01:04:42,300 --> 01:04:47,410
因此，加法和减法工作得
就像它在十进制记数法，

1438
01:04:47,410 --> 01:04:50,780
在这里，除了它是二进制的，对不对？

1439
01:04:50,780 --> 01:04:52,090
因此，它在基地2。

1440
01:04:52,090 --> 01:04:54,070
所以加1加1。

1441
01:04:54,070 --> 01:04:57,020
这给了0和1进行了过来。

1442
01:04:57,020 --> 01:05:01,335
而只是一味地这样做，所以现在
自带的更有趣的问题。

1443
01:05:01,335 --> 01:05:03,730

1444
01:05:03,730 --> 01:05:07,710
>> 我们知道如何代表所有
在计算机中的正整数，

1445
01:05:07,710 --> 01:05:09,870
但让我们做这个练习。

1446
01:05:09,870 --> 01:05:15,240
假装你们都在1960年或
一些试图建立一个电脑，

1447
01:05:15,240 --> 01:05:19,950
你必须拿出的
存储减去1的方法，

1448
01:05:19,950 --> 01:05:22,554
例如，或减去任何
整为此事。

1449
01:05:22,554 --> 01:05:23,470
你会怎么做呢？

1450
01:05:23,470 --> 01:05:27,820

1451
01:05:27,820 --> 01:05:29,220
任何想法？

1452
01:05:29,220 --> 01:05:31,302
就在我扔东西。

1453
01:05:31,302 --> 01:05:32,264
是吗？

1454
01:05:32,264 --> 01:05:39,480
>> 听众：[听不清]指定
一个特殊的，如果你的[听不清]。

1455
01:05:39,480 --> 01:05:42,590
>> GABRIEL：您可以指定一个
特位，这将是0或1。

1456
01:05:42,590 --> 01:05:45,590
比方说一个，如果它是积极的
和0，如果是负面的。

1457
01:05:45,590 --> 01:05:48,171
该位，然后休息
只是存储号码。

1458
01:05:48,171 --> 01:05:48,670
凉爽。

1459
01:05:48,670 --> 01:05:49,990
所以这是一个非常好的主意。

1460
01:05:49,990 --> 01:05:51,550
我们有，我不知道，200。

1461
01:05:51,550 --> 01:05:54,720
如果第一位是
导通时，那么它的加200。

1462
01:05:54,720 --> 01:05:57,270
如果它关闭，这是零下200。

1463
01:05:57,270 --> 01:05:58,380
凉爽。

1464
01:05:58,380 --> 01:06:01,350
>> 只有一个小
问题这一点，

1465
01:06:01,350 --> 01:06:05,370
这就是，如果我们试图总结的东西了。

1466
01:06:05,370 --> 01:06:18,910
所以，想象我们有11111在这里，
我们正在总结这与00100什么的。

1467
01:06:18,910 --> 01:06:21,630
如果这两个是积极的，这很好。

1468
01:06:21,630 --> 01:06:24,470
但是，如果一个
它们是负的，像

1469
01:06:24,470 --> 01:06:27,410
让我们说，这一点在这里
是一个负责任的

1470
01:06:27,410 --> 01:06:31,390
for--我打算做一个separate--
所以这一个装置，该数字在这里

1471
01:06:31,390 --> 01:06:31,970
是正的。

1472
01:06:31,970 --> 01:06:34,450
这个意味着该
此数字为负数，对不对？

1473
01:06:34,450 --> 01:06:37,010
>> 但是，当你
要总结他们，你

1474
01:06:37,010 --> 01:06:40,180
需要一个if语句
他说哦，如果这是0，

1475
01:06:40,180 --> 01:06:43,479
那么我的总和将是
不同的东西，对吧？

1476
01:06:43,479 --> 01:06:45,270
所以这是一个稍微
更聪明的方式做

1477
01:06:45,270 --> 01:06:48,520
即，这是所谓的二的补码。

1478
01:06:48,520 --> 01:06:52,350
所以基本上我们
做的是我们定义零下1

1479
01:06:52,350 --> 01:06:57,250
要的东西，如果
我们加起来1给了我们0。

1480
01:06:57,250 --> 01:06:59,470

1481
01:06:59,470 --> 01:07:00,860
让我再说一遍。

1482
01:07:00,860 --> 01:07:03,280
所以我们可以说，这是这里1。

1483
01:07:03,280 --> 01:07:08,110

1484
01:07:08,110 --> 01:07:13,570
是什么东西
当然在正整数

1485
01:07:13,570 --> 01:07:15,570
加入给我们0？

1486
01:07:15,570 --> 01:07:19,150

1487
01:07:19,150 --> 01:07:21,030
如果我们尝试将它添加到这个数字？

1488
01:07:21,030 --> 01:07:22,830

1489
01:07:22,830 --> 01:07:28,032
我们要have--好了，让我们添加。

1490
01:07:28,032 --> 01:07:32,820

1491
01:07:32,820 --> 01:07:38,065
我们将有1加1
为0，然后将其携带以上。

1492
01:07:38,065 --> 01:07:40,160

1493
01:07:40,160 --> 01:07:45,490
然后我们将再次得到0。

1494
01:07:45,490 --> 01:07:47,730

1495
01:07:47,730 --> 01:07:48,820
我越来越糊涂了。

1496
01:07:48,820 --> 01:07:51,670
而你会得到0和
0 0 0 0 0。

1497
01:07:51,670 --> 01:07:52,450
大量的0。

1498
01:07:52,450 --> 01:07:56,240
>> 在最后的，我们不
要能够进行一遍，

1499
01:07:56,240 --> 01:07:59,614
因为假设我们只处理
用一个字节，所以只有8位。

1500
01:07:59,614 --> 01:08:02,780
所以电脑的默认操作是什么
只是忘记有关[听不清]

1501
01:08:02,780 --> 01:08:03,279
行？

1502
01:08:03,279 --> 01:08:04,530

1503
01:08:04,530 --> 01:08:06,880
因此，这就是所谓的
的二的补码。

1504
01:08:06,880 --> 01:08:15,180
我们简单地定义减去1是
这里的事情，如果你添加了1

1505
01:08:15,180 --> 01:08:15,995
会给你0。

1506
01:08:15,995 --> 01:08:17,609

1507
01:08:17,609 --> 01:08:20,180
这就是很酷
因为我们真的不

1508
01:08:20,180 --> 01:08:24,090
需要后期实施
不同类型的总和的

1509
01:08:24,090 --> 01:08:26,590
这取决于这是否是一个
负或正数。

1510
01:08:26,590 --> 01:08:27,465
这是否有道理？

1511
01:08:27,465 --> 01:08:28,740

1512
01:08:28,740 --> 01:08:32,370
>> 这么一件事，我们做
这里为了将

1513
01:08:32,370 --> 01:08:38,550
积极和消极之间
整数，然后我们会抛一切，

1514
01:08:38,550 --> 01:08:40,930
然后我们加1的号码。

1515
01:08:40,930 --> 01:08:43,140
如果您尝试自己做
上一张纸，

1516
01:08:43,140 --> 01:08:44,681
你会看到这是有道理的。

1517
01:08:44,681 --> 01:08:51,000
但是，如果我把这个号码
这里，这是5。

1518
01:08:51,000 --> 01:08:54,859
所以，如果我翻转一切
这里，使1，1，1，1，1。

1519
01:08:54,859 --> 01:08:55,880

1520
01:08:55,880 --> 01:08:57,830
翻转，翻转，翻转。

1521
01:08:57,830 --> 01:09:00,130
然后我把它加1。

1522
01:09:00,130 --> 01:09:02,750
我要恰好有零下5。

1523
01:09:02,750 --> 01:09:03,250
行？

1524
01:09:03,250 --> 01:09:06,220
>> 种这是有道理的，因为如果
你试图用数字总结本

1525
01:09:06,220 --> 01:09:10,229
我们面前，这
was--让我们再次拨动了。

1526
01:09:10,229 --> 01:09:12,999
这是101和大量的0。

1527
01:09:12,999 --> 01:09:13,795

1528
01:09:13,795 --> 01:09:15,670
如果您尝试添加这些
两个数字一起，

1529
01:09:15,670 --> 01:09:16,961
你将有完全相同0。

1530
01:09:16,961 --> 01:09:18,920

1531
01:09:18,920 --> 01:09:19,460
行。

1532
01:09:19,460 --> 01:09:19,884
有问题吗？

1533
01:09:19,884 --> 01:09:20,759
>> 听众：[听不清]

1534
01:09:20,759 --> 01:09:25,790

1535
01:09:25,790 --> 01:09:27,280
>> GABRIEL：你是什么意思？

1536
01:09:27,280 --> 01:09:29,240
>> 听众：负向
正[听不清]。

1537
01:09:29,240 --> 01:09:33,215
>> GABRIEL：不，你翻车
你加1永远。

1538
01:09:33,215 --> 01:09:34,081

1539
01:09:34,081 --> 01:09:34,580
是啊。

1540
01:09:34,580 --> 01:09:36,910

1541
01:09:36,910 --> 01:09:39,680
好了，人物也被编码的二进制文件。

1542
01:09:39,680 --> 01:09:42,649
我们有ASCII表，你
也看到了讲座，对不对？

1543
01:09:42,649 --> 01:09:45,040
因此，它基本上是一个事物的映射。

1544
01:09:45,040 --> 01:09:50,960
在这里，我不能强调不够
对于一台计算机，一和65

1545
01:09:50,960 --> 01:09:52,770
从字面上同样的事情。

1546
01:09:52,770 --> 01:10:03,430
所以，如果我写的东西像炭ç
等于一，我可以在同一时间

1547
01:10:03,430 --> 01:10:06,890
只写65在这里，它
将是完全一样的，好不好？

1548
01:10:06,890 --> 01:10:08,470
有没有任何区别。

1549
01:10:08,470 --> 01:10:12,420
>> 我们通常倾向于把
字符类型的变量。

1550
01:10:12,420 --> 01:10:16,770
CHAR，不是因为他们基本上是
对于制成的，但因为

1551
01:10:16,770 --> 01:10:18,050
人类的约定。

1552
01:10:18,050 --> 01:10:22,410
但是，你可以处理整数
而不是char类型的变量，

1553
01:10:22,410 --> 01:10:23,490
你会没事的。

1554
01:10:23,490 --> 01:10:28,410
唯一的实际差别
一个char c和一个int我之间

1555
01:10:28,410 --> 01:10:31,960
是一个int在大多数四个字节
系统，而一个字符具有一个字节。

1556
01:10:31,960 --> 01:10:33,070

1557
01:10:33,070 --> 01:10:35,460
他们本质上是
同样的事情在数据方面。

1558
01:10:35,460 --> 01:10:36,990

1559
01:10:36,990 --> 01:10:37,990
那么，什么将打印吗？

1560
01:10:37,990 --> 01:10:43,780
在这里，我们印刷用printf数字
用加1，只是喜欢整数，

1561
01:10:43,780 --> 01:10:46,240
字符可以总结，因此
的字符也可以被求和。

1562
01:10:46,240 --> 01:10:47,890
因此，这也正是65岁。

1563
01:10:47,890 --> 01:10:49,950
因此，有将是
66，在这里，我们有

1564
01:10:49,950 --> 01:10:56,860
65加小负大A，
这将是的，我真的不知道。

1565
01:10:56,860 --> 01:11:00,900
但是这将是完全相同的间隙
大写字母之间

1566
01:11:00,900 --> 01:11:07,800
和所用更小的文字，所以
我们将得到一个小，对吧？

1567
01:11:07,800 --> 01:11:08,300
是啊。

1568
01:11:08,300 --> 01:11:11,740
所以，这是怎么回事打印
性格这正是这一个。

1569
01:11:11,740 --> 01:11:12,260
好不好？

1570
01:11:12,260 --> 01:11:12,860
有问题吗？

1571
01:11:12,860 --> 01:11:16,320

1572
01:11:16,320 --> 01:11:19,430
>> 在这里，我们有一堆不同
类型为数值型变量。

1573
01:11:19,430 --> 01:11:20,620
我们已经谈整型。

1574
01:11:20,620 --> 01:11:21,740

1575
01:11:21,740 --> 01:11:27,760
浮动，不过是to--这是真的
有趣，因为当我第一次听说

1576
01:11:27,760 --> 01:11:32,320
编程早在一天
Python中，第一个节目我这辈子

1577
01:11:32,320 --> 01:11:37,480
试着写，我看到有一个
在所谓的类型和类型称为浮动。

1578
01:11:37,480 --> 01:11:39,800
和浮子是对于所有实数。

1579
01:11:39,800 --> 01:11:43,290
于是我问为什么
我曾经用一个int呢？

1580
01:11:43,290 --> 01:11:45,590
因为如果我可以使用所有
实数有浮动，

1581
01:11:45,590 --> 01:11:47,120
我只想停止使用整数，对吧？

1582
01:11:47,120 --> 01:11:49,550
因为实数是
很像更通用。

1583
01:11:49,550 --> 01:11:51,820

1584
01:11:51,820 --> 01:11:54,060
>> 事实证明，这是
没有电脑的情况下

1585
01:11:54,060 --> 01:11:58,480
因为他们根本
不同的东西。

1586
01:11:58,480 --> 01:12:01,470
所以，整数和浮点数时，
操作，你做给他们

1587
01:12:01,470 --> 01:12:04,739
是因为本质的不同
对它们的存储方式，好不好？

1588
01:12:04,739 --> 01:12:07,280
我们要谈一点
更多的关于在第二。

1589
01:12:07,280 --> 01:12:09,110
>> 所以双只是一个更大的浮动。

1590
01:12:09,110 --> 01:12:12,830
通常在大多数系统中，一个float
是四个字节，就像一个int。

1591
01:12:12,830 --> 01:12:15,440
和双是八个字节。

1592
01:12:15,440 --> 01:12:21,450
很长很长，其实只是一个符号
你追加到如int类型。

1593
01:12:21,450 --> 01:12:24,040
你说的很长很长诠释这个样子。

1594
01:12:24,040 --> 01:12:28,550
龙长整型X使它更长的时间。

1595
01:12:28,550 --> 01:12:32,310
所以在大多数系统中，这将使
八个字节，而不是通常的4。

1596
01:12:32,310 --> 01:12:35,620
而实际上你可以删除
的，所以它只能说很长很长，

1597
01:12:35,620 --> 01:12:37,240
并且工作过，好不好？

1598
01:12:37,240 --> 01:12:42,850
你也可以做其他事情一样
unsigned int类型，或只是再次签名

1599
01:12:42,850 --> 01:12:43,680
也将正常工作。

1600
01:12:43,680 --> 01:12:49,370
而且，它们将使得X是一个变量
就像一切都是积极的，

1601
01:12:49,370 --> 01:12:53,231
所以你不能真正拥有负
在我们看到了这里的路上号码。

1602
01:12:53,231 --> 01:12:56,484

1603
01:12:56,484 --> 01:12:58,650
所以，下面的精彩
浮点和精度。

1604
01:12:58,650 --> 01:13:01,890
这是其中一个原因，为什么你
想用整数来代替花车，

1605
01:13:01,890 --> 01:13:04,370
因为整数是100％准确的，对不对？

1606
01:13:04,370 --> 01:13:06,170
这正是这个数字。

1607
01:13:06,170 --> 01:13:11,910
对于浮动点，如果你
说的答案等于1比10--

1608
01:13:11,910 --> 01:13:14,690
我碰巧确切有这个
计划在这里，float.c。

1609
01:13:14,690 --> 01:13:16,390

1610
01:13:16,390 --> 01:13:19,420
打印到20位小数。

1611
01:13:19,420 --> 01:13:23,270
1除以10，并
通常为0.1，对不对？

1612
01:13:23,270 --> 01:13:27,910
但在这里，如果我们做
浮然后我们运行它，

1613
01:13:27,910 --> 01:13:30,320
我们看到，它不是完全0.1。

1614
01:13:30,320 --> 01:13:33,570
这是0.149的东西。

1615
01:13:33,570 --> 01:13:35,570
>> 为什么会这样？

1616
01:13:35,570 --> 01:13:40,390
因为你不能真正代表每
在内存中一个可能的实数

1617
01:13:40,390 --> 01:13:42,730
因为有
不可数很多。

1618
01:13:42,730 --> 01:13:48,360
所以，我们在技术上只能
表示它们的一个有限数量

1619
01:13:48,360 --> 01:13:50,470
与数据的有限量。

1620
01:13:50,470 --> 01:13:52,050
但是，这真的很有趣。

1621
01:13:52,050 --> 01:13:54,920
现在，这引出了一个
的问题，你会怎么

1622
01:13:54,920 --> 01:13:59,299
去代表
与此位，对不对？

1623
01:13:59,299 --> 01:14:00,340
那么如何彩车存储？

1624
01:14:00,340 --> 01:14:01,970

1625
01:14:01,970 --> 01:14:03,730
与整数很容易。

1626
01:14:03,730 --> 01:14:06,690
但随着花车想要
最大限度的范围内，

1627
01:14:06,690 --> 01:14:10,530
并希望能够代表
巨大的数字和非常小的数字一样

1628
01:14:10,530 --> 01:14:14,210
0.000001同时。

1629
01:14:14,210 --> 01:14:15,180
如此反复，相同的游戏。

1630
01:14:15,180 --> 01:14:20,470
没有任何人有任何想法如何，我们可以
去代表内存浮动？

1631
01:14:20,470 --> 01:14:26,820

1632
01:14:26,820 --> 01:14:27,970
只是扔东西。

1633
01:14:27,970 --> 01:14:29,930

1634
01:14:29,930 --> 01:14:30,856
是的，请。

1635
01:14:30,856 --> 01:14:33,552
>> 听众：[听不清]为
如果是两个整数和一个

1636
01:14:33,552 --> 01:14:36,890
作为[听不清]和一个幸福
小数点后的一切。

1637
01:14:36,890 --> 01:14:37,640
GABRIEL：好，冬暖夏凉。

1638
01:14:37,640 --> 01:14:40,300
所以两个不同的整数。

1639
01:14:40,300 --> 01:14:45,260
你可以有12.45，所以这是12和45。

1640
01:14:45,260 --> 01:14:45,890
不错。

1641
01:14:45,890 --> 01:14:46,973
什么前，先要考验你要说的话？

1642
01:14:46,973 --> 01:14:48,420

1643
01:14:48,420 --> 01:14:49,430
同样的事情？

1644
01:14:49,430 --> 01:14:49,930
是吗？

1645
01:14:49,930 --> 01:14:55,630
>> 听众：[听不清]符号
你分开的基础在哪里。

1646
01:14:55,630 --> 01:14:58,910
>> GABRIEL：科学记数法，
是啊，这通常会发生什么。

1647
01:14:58,910 --> 01:15:01,350
因此，这就是所谓的尾数。

1648
01:15:01,350 --> 01:15:06,490
这就是什么是真正的
号，然后将指数

1649
01:15:06,490 --> 01:15:08,780
只是那里的逗号，不是吗？

1650
01:15:08,780 --> 01:15:13,720
因此，这将是东西
形式1，2，3，4，5次10

1651
01:15:13,720 --> 01:15:15,000
到零下4。

1652
01:15:15,000 --> 01:15:17,800
我只是意识到that--是啊，没错。

1653
01:15:17,800 --> 01:15:23,372
然后这个10的负4是
要定义所在的逗号，好不好？

1654
01:15:23,372 --> 01:15:24,330
在巴西，我们使用逗号。

1655
01:15:24,330 --> 01:15:26,795
在这里，你们用一个点。

1656
01:15:26,795 --> 01:15:27,640
这样一个点。

1657
01:15:27,640 --> 01:15:28,860

1658
01:15:28,860 --> 01:15:34,840
>> 这是很酷的，因为这样你可以
集中大量的位上的这个家伙

1659
01:15:34,840 --> 01:15:40,863
这里，在尾数，然后这
将是您的实际精度。

1660
01:15:40,863 --> 01:15:41,920

1661
01:15:41,920 --> 01:15:47,175
你也可以做到这一点无论是在十进制
或在二进制基础的系统。

1662
01:15:47,175 --> 01:15:49,781
有不同
的方式来实现这一点。

1663
01:15:49,781 --> 01:15:50,280
有问题吗？

1664
01:15:50,280 --> 01:15:55,918

1665
01:15:55,918 --> 01:15:56,418
是吗？

1666
01:15:56,418 --> 01:15:57,508

1667
01:15:57,508 --> 01:15:59,841
听众：有多少地方
小数[听不清]呢？

1668
01:15:59,841 --> 01:16:05,240

1669
01:16:05,240 --> 01:16:12,610
>> GABRIEL：这是一个复杂的问题，
因为它从来没有真正100％准确，

1670
01:16:12,610 --> 01:16:15,680
因为当你看到这里，为
一些数字是100％精确的。

1671
01:16:15,680 --> 01:16:20,350
我相信，如果我们把0.5在这里，
这将是100％准确的。

1672
01:16:20,350 --> 01:16:22,220
这将是0.500000。

1673
01:16:22,220 --> 01:16:24,170
所以在这种情况下，它是完美的。

1674
01:16:24,170 --> 01:16:27,330
但在其他情况下，
这是少得多完美。

1675
01:16:27,330 --> 01:16:35,010
根据我的经验，像多达四个，
小数点后五位是相当精确的。

1676
01:16:35,010 --> 01:16:38,300
如果您使用的是双，这将
有办法比这更精确，好不好？

1677
01:16:38,300 --> 01:16:42,750
>> 罗布·鲍登：所以刚才扔
在彩车一些情况下，

1678
01:16:42,750 --> 01:16:46,320
我从来不记得100％如何
彩车的规格实际工作，

1679
01:16:46,320 --> 01:16:52,660
但我做你永远记得
漂浮开始变得凌乱。

1680
01:16:52,660 --> 01:16:55,460

1681
01:16:55,460 --> 01:17:00,930
这样的想法是，当你真的，
真正的大数字还是真的，真的

1682
01:17:00,930 --> 01:17:03,470
小的数字，我们开始
每况愈下

1683
01:17:03,470 --> 01:17:05,860
在差异化
之间的两个亲密的浮动。

1684
01:17:05,860 --> 01:17:09,180
>> 所以，我怎么样想的是
浮点不精确，

1685
01:17:09,180 --> 01:17:11,890
有两个浮筒的
如果我尝试将它们指定

1686
01:17:11,890 --> 01:17:15,150
在C中，尽管事实是
他们是不同的数字，

1687
01:17:15,150 --> 01:17:17,340
他们将成为
解释为相同的号码，

1688
01:17:17,340 --> 01:17:19,006
因为我们不能将它们存储不同。

1689
01:17:19,006 --> 01:17:20,540
我们需要使用相同的比特。

1690
01:17:20,540 --> 01:17:23,220
所以，当我们到达
真的，真的大量涌现，

1691
01:17:23,220 --> 01:17:28,460
像10交谈的300
的东西，它是在该点

1692
01:17:28,460 --> 01:17:33,240
该10到300或
5次为10〜300个

1693
01:17:33,240 --> 01:17:37,020
无法区分
7次10到300。

1694
01:17:37,020 --> 01:17:39,660
所以这是一个相当大的差异
两个数字之间。

1695
01:17:39,660 --> 01:17:43,830
>> 但是，当你趴下
到正常范围外，

1696
01:17:43,830 --> 01:17:45,770
你往往是相当
在区分好。

1697
01:17:45,770 --> 01:17:49,020
然后当你趴下真的很小，
你也变得非常糟糕了。

1698
01:17:49,020 --> 01:17:52,529
因此，像一大堆
0.0000，它变得非常糟糕。

1699
01:17:52,529 --> 01:17:53,820
GABRIEL：是啊，这么快注释。

1700
01:17:53,820 --> 01:17:54,670
从来没有做到这一点。

1701
01:17:54,670 --> 01:17:57,590
永远不要尝试比较
彩车使用equals等于，

1702
01:17:57,590 --> 01:18:02,800
因为即使他们几乎
同样，几乎相同的是不一样的。

1703
01:18:02,800 --> 01:18:06,360
那么，你通常做的是你减去
其中，采取的是绝对值，

1704
01:18:06,360 --> 01:18:12,380
看看这是不是小
0.0001或类似的东西，好不好？

1705
01:18:12,380 --> 01:18:12,880
和冷静。

1706
01:18:12,880 --> 01:18:16,630
我知道很多人都有
一些背景在Java中，

1707
01:18:16,630 --> 01:18:19,700
特别是那些谁做
AP计算机科学，对吧？

1708
01:18:19,700 --> 01:18:23,630
而Java是一种语言
这主要是基于C，

1709
01:18:23,630 --> 01:18:26,570
它有几个非常大的差异。

1710
01:18:26,570 --> 01:18:31,430
但对于循环，如果，之类的东西
，他们都是一样的语法。

1711
01:18:31,430 --> 01:18:35,240
我有几个项目在这里展示这一点。

1712
01:18:35,240 --> 01:18:37,050
>> 因此，举例来说，一个简单的Hello World。

1713
01:18:37,050 --> 01:18:43,140

1714
01:18:43,140 --> 01:18:46,600
这是世界您好在C中，你
家伙肯定是熟悉的，

1715
01:18:46,600 --> 01:18:49,100
而这一点，这个人是在Java中。

1716
01:18:49,100 --> 01:18:53,100
所以，在Java中，我们有这样的
公共类，你好世界，

1717
01:18:53,100 --> 01:18:57,050
公共静态无效
主，和字符串的args。

1718
01:18:57,050 --> 01:18:59,665
该字符串的args会
出现在C中很快。

1719
01:18:59,665 --> 01:19:00,740

1720
01:19:00,740 --> 01:19:01,990
但是，我们不要去那里呢。

1721
01:19:01,990 --> 01:19:06,060
现在，我们有空隙这里，这意味着
这主要是不带任何参数。

1722
01:19:06,060 --> 01:19:09,220
然后我们有
的System.out.println的，这就是

1723
01:19:09,220 --> 01:19:11,140
一种等价类printf的。

1724
01:19:11,140 --> 01:19:17,150
在这里，我们并不真正需要的反斜杠
N，因为打印LN这是否适合你。

1725
01:19:17,150 --> 01:19:19,680
其附加的反斜杠
处的N行的末端。

1726
01:19:19,680 --> 01:19:22,540

1727
01:19:22,540 --> 01:19:30,415
>> 但是，如果你进入
有点像的，你

1728
01:19:30,415 --> 01:19:32,590
可以看到，他们是
几乎同样的事情。

1729
01:19:32,590 --> 01:19:37,390
这样的初始化，并且
条件，并且在更新

1730
01:19:37,390 --> 01:19:42,050
is--我错过了一个空间，这里 - 他们
几乎除了Java的同样的事情，

1731
01:19:42,050 --> 01:19:44,430
作为拥有几个高层次的东西。

1732
01:19:44,430 --> 01:19:46,010

1733
01:19:46,010 --> 01:19:49,610
在这里，我们可以做的，再加上我和
Java将自动

1734
01:19:49,610 --> 01:19:52,730
使这个我在这里，这是
一个整数，转换为字符串，

1735
01:19:52,730 --> 01:19:55,200
再追加
两个串在一起。

1736
01:19:55,200 --> 01:19:57,570
在这里，在C中，我们需要做的与％D。

1737
01:19:57,570 --> 01:20:15,310

1738
01:20:15,310 --> 01:20:18,170
这里的线，对于
长得一模一样。

1739
01:20:18,170 --> 01:20:37,760
>> 如果我们看一下，如果，在IFS
还长得一模一样，对吧？

1740
01:20:37,760 --> 01:20:39,290

1741
01:20:39,290 --> 01:20:44,650
所以，真正的大差异
在你在这里看到的那些东西。

1742
01:20:44,650 --> 01:20:47,530
公共静态的，无效的，并
那么公共类的话。

1743
01:20:47,530 --> 01:20:48,990

1744
01:20:48,990 --> 01:20:52,360
因此，Java有什么
称为虚拟机。

1745
01:20:52,360 --> 01:20:53,560

1746
01:20:53,560 --> 01:21:00,150
这是非常严重依据是什么
被称为面向对象的程序设计，

1747
01:21:00,150 --> 01:21:04,120
这是一个非常，非常普遍
范式编程时下。

1748
01:21:04,120 --> 01:21:10,870
这个类的事情是你所看到的，
从面向对象的东西，

1749
01:21:10,870 --> 01:21:14,214
在你创建一个类，然后你
可以从派生类的对象。

1750
01:21:14,214 --> 01:21:16,380
我们不会说太多
不多，在CS50，

1751
01:21:16,380 --> 01:21:18,213
但是这绝对
东西真的很酷，

1752
01:21:18,213 --> 01:21:21,440
特别是如果你想进入
更复杂的Web开发

1753
01:21:21,440 --> 01:21:24,050
在该过程结束时，
像提交您的最终项目

1754
01:21:24,050 --> 01:21:26,430
和一些漂亮的框架和内容。

1755
01:21:26,430 --> 01:21:31,250
>> 所以基本上的想法是，你
不想重新实现的东西，

1756
01:21:31,250 --> 01:21:36,330
所以你创造的东西，是
非常通用的，如形状，

1757
01:21:36,330 --> 01:21:38,310
然后创建
它从不同的形状，

1758
01:21:38,310 --> 01:21:40,240
然后从每个
这些形状，为您打造

1759
01:21:40,240 --> 01:21:45,110
在三个一些更具体的形状
尺寸或类似的东西。

1760
01:21:45,110 --> 01:21:48,799
他们有这样的层次，他们
从其他的继承，所以

1761
01:21:48,799 --> 01:21:51,840
所有功能和所有变量
大形在这里了，所有这些

1762
01:21:51,840 --> 01:21:54,110
将有，所有的这些都
将有，等等，等等。

1763
01:21:54,110 --> 01:21:55,640
所以这是基本的想法。

1764
01:21:55,640 --> 01:21:59,170
>> C没有说，但是C ++
确实有这种功能。

1765
01:21:59,170 --> 01:22:02,710
和Java是严重影响
通过面向对象，

1766
01:22:02,710 --> 01:22:05,310
所以这就是为什么你看到
类在这里所有的时间。

1767
01:22:05,310 --> 01:22:10,790
而另一件事是
该Java虚拟机。

1768
01:22:10,790 --> 01:22:13,790
所以，我觉得，是一个非常聪明的想法。

1769
01:22:13,790 --> 01:22:17,020
那么是什么人谁
发明了Java的确实是

1770
01:22:17,020 --> 01:22:19,630
他们不想要
两次编译自己的代码

1771
01:22:19,630 --> 01:22:23,990
如果他们不得不在Windows中运行它，
或者Mac或Linux，所以他们做了什么

1772
01:22:23,990 --> 01:22:26,740
他们是从字面上运行
像家电，

1773
01:22:26,740 --> 01:22:29,630
但你真的不看到它发生。

1774
01:22:29,630 --> 01:22:32,430
因此，他们运行一个虚拟机
你的电脑，里面的这

1775
01:22:32,430 --> 01:22:34,940
基本上像一个
微型操作系统。

1776
01:22:34,940 --> 01:22:37,920
而且操作
系统的生命的目的

1777
01:22:37,920 --> 01:22:41,430
只是跑什么叫做字节码。

1778
01:22:41,430 --> 01:22:47,411
>> 因此，而不是在C中，这样，我们将
编译这让若，然后运行

1779
01:22:47,411 --> 01:22:47,910
./if。

1780
01:22:47,910 --> 01:22:53,510

1781
01:22:53,510 --> 01:22:55,290
我忘了反斜线。

1782
01:22:55,290 --> 01:23:00,240
在Java中，你会先做
Java的C到编译它，if.c.

1783
01:23:00,240 --> 01:23:06,440

1784
01:23:06,440 --> 01:23:08,252
这不是C.它的点的java。

1785
01:23:08,252 --> 01:23:09,460

1786
01:23:09,460 --> 01:23:12,140
然后，你必须运行不./。

1787
01:23:12,140 --> 01:23:15,440
你得到这个新的文件
if.class，但你不能真的

1788
01:23:15,440 --> 01:23:17,980
运行if.class现在只是
像我们以前那样。

1789
01:23:17,980 --> 01:23:19,440
这不是一个可执行文件。

1790
01:23:19,440 --> 01:23:20,630
您必须运行。

1791
01:23:20,630 --> 01:23:23,410
你必须把它送入
一个叫做Java程序，

1792
01:23:23,410 --> 01:23:28,260
并且该程序是虚拟机，
然后你做if.class，或者如果。

1793
01:23:28,260 --> 01:23:28,760
是的。

1794
01:23:28,760 --> 01:23:30,890
然后它的工作原理。

1795
01:23:30,890 --> 01:23:33,740
OK，所以这是同类产品中
虚拟机发生。

1796
01:23:33,740 --> 01:23:37,700
C没有了，所以如果我是
把这个程序在Windows机器上，

1797
01:23:37,700 --> 01:23:40,516
在Java中C.这是行不通的它。

1798
01:23:40,516 --> 01:23:41,015
有问题吗？

1799
01:23:41,015 --> 01:23:43,430

1800
01:23:43,430 --> 01:23:44,030
凉爽。

1801
01:23:44,030 --> 01:23:47,160
这是否超节今天。

1802
01:23:47,160 --> 01:23:49,462