1
00:00:00,000 --> 00:00:12,510

2
00:00:12,510 --> 00:00:13,870
>> 羅伯：好吧。

3
00:00:13,870 --> 00:00:16,770
歡迎到首節。

4
00:00:16,770 --> 00:00:17,480
我搶。

5
00:00:17,480 --> 00:00:18,806
>> 約瑟夫：我是約瑟夫。

6
00:00:18,806 --> 00:00:21,540
>> 羅伯：所以我們將深入權利英寸

7
00:00:21,540 --> 00:00:23,420
首先要說說
是電器。

8
00:00:23,420 --> 00:00:27,150
所以希望你們中的大多數都
已經下載了它。

9
00:00:27,150 --> 00:00:37,180
但是你可以看到指示
在cs50.net/appliance。

10
00:00:37,180 --> 00:00:38,430
哦，上帝，現在我的自我意識。

11
00:00:38,430 --> 00:00:44,590

12
00:00:44,590 --> 00:00:45,430
我還聽到它。

13
00:00:45,430 --> 00:00:47,232
>> 約瑟夫：哇，這聽起來像
它的暈頭轉向。

14
00:00:47,232 --> 00:00:52,460
>> 羅伯：所以有些人一直有
與它的問題，所以不要等到

15
00:00:52,460 --> 00:00:54,940
問題的最後一分鐘設置為
試圖解決的電器和

16
00:00:54,940 --> 00:00:56,320
找出它不工作。

17
00:00:56,320 --> 00:00:59,010
>> 約瑟夫：如果有什麼不工作
而你需要幫助，你可以去

18
00:00:59,010 --> 00:01:03,390
cs50.net/discussion我們
有一個論壇，在這裡你

19
00:01:03,390 --> 00:01:04,110
可以發布您的問題。

20
00:01:04,110 --> 00:01:06,655
我們會得到他們最終。

21
00:01:06,655 --> 00:01:07,490
>> 羅伯：好吧。

22
00:01:07,490 --> 00:01:12,180
因此，這是什麼樣的電器
模樣。

23
00:01:12,180 --> 00:01:15,480
再次，它只是一個完全獨立的
操作系統內運行的

24
00:01:15,480 --> 00:01:19,440
無論操作系統你
在筆記本電腦上運行。

25
00:01:19,440 --> 00:01:24,450
和主就是你
使用是gedit的。

26
00:01:24,450 --> 00:01:28,050
所以希望這已經
成為一個熟悉的網站。

27
00:01:28,050 --> 00:01:29,470
該終端。

28
00:01:29,470 --> 00:01:31,890
>> 你也可以運行Chrome瀏覽器
內的電器。

29
00:01:31,890 --> 00:01:33,860
曾有一對夫婦的人
誰曾報導互聯網

30
00:01:33,860 --> 00:01:35,390
在設備無法正常工作。

31
00:01:35,390 --> 00:01:38,090
其中一些剛剛假設
有是不應該

32
00:01:38,090 --> 00:01:39,190
網絡中的設備。

33
00:01:39,190 --> 00:01:40,750
但是，是的，還有被認為
是互聯網。

34
00:01:40,750 --> 00:01:44,000

35
00:01:44,000 --> 00:01:46,410
>> 我會說出來的權利，但它不
真正意味著什麼。

36
00:01:46,410 --> 00:01:50,680
如果網絡不能正常工作，
這就是你往往需要

37
00:01:50,680 --> 00:01:52,180
運行修復它。

38
00:01:52,180 --> 00:01:55,602
如果您有互聯網的問題，不
記住它，只是它張貼在

39
00:01:55,602 --> 00:01:57,560
討論，我們會說，運行。

40
00:01:57,560 --> 00:02:00,420
但互聯網應該是工作。

41
00:02:00,420 --> 00:02:06,650
>> 所以，唯一的其他東西 - 是啊，沒有什麼
別的是真正相關。

42
00:02:06,650 --> 00:02:08,979
但我只是想指出 - 

43
00:02:08,979 --> 00:02:13,290
請參閱本右下角。

44
00:02:13,290 --> 00:02:16,530
所以，你的每一個設備的應
有一個IP地址。

45
00:02:16,530 --> 00:02:22,350
後來在這個學期，該IP
地址將變得更加重要時

46
00:02:22,350 --> 00:02:27,230
你的工作在網絡上對集，因為
你就可以訪問

47
00:02:27,230 --> 00:02:32,310
網站，你正在努力從你的
當地的Chrome使用此IP地址。

48
00:02:32,310 --> 00:02:35,400
>> 但我喜歡用的IP地址
為 - 和你沒有做到這一點，我

49
00:02:35,400 --> 00:02:37,460
只是想指出來 - 

50
00:02:37,460 --> 00:02:39,540
就在這裡。

51
00:02:39,540 --> 00:02:42,910
所以這是一個終端窗口
我的Mac，這不是在

52
00:02:42,910 --> 00:02:44,580
電器都沒有。

53
00:02:44,580 --> 00:02:47,190
並且你可以看看是什麼
這個命令的作用。

54
00:02:47,190 --> 00:02:51,855
但我直接去的SSH
我的電器。

55
00:02:51,855 --> 00:02:53,410
我不知道IP是什麼。

56
00:02:53,410 --> 00:02:54,300
>> 約瑟夫：168  - 

57
00:02:54,300 --> 00:02:56,080
>> 168.224.1.0。

58
00:02:56,080 --> 00:02:59,950
>> 羅伯：所以一旦我受夠了
與此，請登錄。

59
00:02:59,950 --> 00:03:05,450
現在，基本上，這是相同的
我的電器內的終端窗口。

60
00:03:05,450 --> 00:03:10,280
所以，我幾乎從來沒有真正的工作
從設備本身。

61
00:03:10,280 --> 00:03:12,550
我只是一直有它運行
在最小化的背景

62
00:03:12,550 --> 00:03:15,890
並SSHed進去。

63
00:03:15,890 --> 00:03:24,270
>> 這個問題是你不打算
能夠容易地用gedit

64
00:03:24,270 --> 00:03:25,600
直接從本。

65
00:03:25,600 --> 00:03:31,500
但是，如果你想成為一個真正的酷
黑客，那麼你應該習慣了一個

66
00:03:31,500 --> 00:03:34,220
命令行的文本編輯器呢。

67
00:03:34,220 --> 00:03:39,620
所以Vim和Emacs和納米，所有這些
有不同的選擇。

68
00:03:39,620 --> 00:03:41,560
納米往往是最容易的。

69
00:03:41,560 --> 00:03:45,006
而且我認為它沒有
語法高亮。

70
00:03:45,006 --> 00:03:47,620
哦，不，完全不會。

71
00:03:47,620 --> 00:03:49,870
所以你可以使用納米，因為
那一個是很容易的。

72
00:03:49,870 --> 00:03:52,000
>> 你看到所有這些命令
在底部。

73
00:03:52,000 --> 00:03:54,750
這個小胡蘿蔔象徵。

74
00:03:54,750 --> 00:03:57,620
如果你以前沒有見過它，你會
可能看到了很多了。

75
00:03:57,620 --> 00:04:02,350
這通常意味著控制胡蘿蔔，
喜歡你的鍵盤的左下角

76
00:04:02,350 --> 00:04:04,130
控制字符。

77
00:04:04,130 --> 00:04:07,260
所以在這裡它告訴我到這裡 - 

78
00:04:07,260 --> 00:04:08,710
哦，這不是斷我是否放大。

79
00:04:08,710 --> 00:04:11,040
所以，控制，X是如何
我要退出。

80
00:04:11,040 --> 00:04:14,710
和它說我打的Y
是的，對於節能，N代表號

81
00:04:14,710 --> 00:04:17,190
所以這是納米。

82
00:04:17,190 --> 00:04:22,860
>> Vim和Emacs往往是稍
複雜的和壓倒一切的。

83
00:04:22,860 --> 00:04:28,840
但是你可以習慣它，
然後你會愛上它。

84
00:04:28,840 --> 00:04:30,590
所以，就是這樣。

85
00:04:30,590 --> 00:04:31,720
>> 約瑟夫：沒必要那樣做。

86
00:04:31,720 --> 00:04:31,840
>> 羅伯：是啊。

87
00:04:31,840 --> 00:04:37,510
你可以自由地用gedit的
其餘的學期。

88
00:04:37,510 --> 00:04:40,630
所以任何設備相關的問題？

89
00:04:40,630 --> 00:04:42,820
還是你有什麼別的什麼想法
必須談及有關

90
00:04:42,820 --> 00:04:43,610
家電？

91
00:04:43,610 --> 00:04:43,996
是。

92
00:04:43,996 --> 00:04:47,720
>> 揚聲器1：當你SSHed到您的
的事情，是密碼深紅？

93
00:04:47,720 --> 00:04:48,390
>> 羅伯：是啊。

94
00:04:48,390 --> 00:04:50,170
對於幾乎所有的密碼
在電器是怎麼回事

95
00:04:50,170 --> 00:04:52,473
是深紅。

96
00:04:52,473 --> 00:04:56,517
>> 揚聲器2：安裝像一個真正的IDE
在設備上，將它的工作？

97
00:04:56,517 --> 00:04:59,200

98
00:04:59,200 --> 00:05:07,290
>> 羅伯：我想像的Eclipse確實有
Fedora的版本，在這種情況下，是的，

99
00:05:07,290 --> 00:05:08,420
你可以做到這一點。

100
00:05:08,420 --> 00:05:10,875
它可能不是真的值得。

101
00:05:10,875 --> 00:05:11,742
>> 揚聲器2：確定。

102
00:05:11,742 --> 00:05:15,924
所以它可能如果我想更輕鬆
使用Eclipse，只需使用原生和

103
00:05:15,924 --> 00:05:17,646
然後上傳到 - 

104
00:05:17,646 --> 00:05:21,090
>> 羅伯：哦，那也是可能更容易。

105
00:05:21,090 --> 00:05:24,046
但你可以得到它的工作
內的電器。

106
00:05:24,046 --> 00:05:27,740
>> 約瑟夫：而對於攝像頭的問題
是，你可以安裝另一個

107
00:05:27,740 --> 00:05:29,490
IDE中的電器內？

108
00:05:29,490 --> 00:05:31,520
>> 羅伯：Eclipse中作為一個
例如一個IDE的。

109
00:05:31,520 --> 00:05:34,800

110
00:05:34,800 --> 00:05:36,050
任何其它電器問題嗎？

111
00:05:36,050 --> 00:05:38,250

112
00:05:38,250 --> 00:05:38,680
好的。

113
00:05:38,680 --> 00:05:44,920
>> 所以我們現在進入到命令行
接口相關的東西，所以CLI。

114
00:05:44,920 --> 00:05:47,990
又一次，我只是去上班的
在這裡，因為這是相同的

115
00:05:47,990 --> 00:05:52,780
在一個終端窗口工作
內的電器。

116
00:05:52,780 --> 00:05:54,160
是如何形成的字體看？

117
00:05:54,160 --> 00:05:55,970
是否足夠大？

118
00:05:55,970 --> 00:05:57,000
好的。

119
00:05:57,000 --> 00:06:02,480
>> 所以有很多的命令是
你應該得到很習慣

120
00:06:02,480 --> 00:06:04,490
整個學期。

121
00:06:04,490 --> 00:06:09,480
大二用於導航的LS，列表
此目錄中的文件;和

122
00:06:09,480 --> 00:06:11,380
CD，所以更改目錄。

123
00:06:11,380 --> 00:06:18,390
這樣我就可以改變桌面，然後
一個很常見的模式是cd到一個

124
00:06:18,390 --> 00:06:22,550
目錄並立即LS
什麼的在目錄中。

125
00:06:22,550 --> 00:06:25,540
>> 人們有時也沒有意識到
該選項卡完成的一件事。

126
00:06:25,540 --> 00:06:28,370
因此，像CD，VH，然後我打標籤。

127
00:06:28,370 --> 00:06:30,790
我幾乎從來不打出來
整個事情。

128
00:06:30,790 --> 00:06:32,920
然後，如果我繼續打標籤
再次，它會自動

129
00:06:32,920 --> 00:06:33,670
開始我列出。

130
00:06:33,670 --> 00:06:37,000
所以我可以cd虛擬主機，本地主機。

131
00:06:37,000 --> 00:06:39,880
而這只是要 - 

132
00:06:39,880 --> 00:06:43,380
如果你還沒有聽說過這個詞
之前，目錄是另一個字

133
00:06:43,380 --> 00:06:45,170
為文件夾。

134
00:06:45,170 --> 00:06:49,930
所以，現在如果你看 - 

135
00:06:49,930 --> 00:06:51,810
讓我們把那個頂端。

136
00:06:51,810 --> 00:06:55,380
>> 所以，現在，如果你在括號中看到的，你
看到小波浪線，斜線，虛擬主機，

137
00:06:55,380 --> 00:06:56,810
斜線，本地主機。

138
00:06:56,810 --> 00:07:00,040
所以，波浪，是指
我的主目錄。

139
00:07:00,040 --> 00:07:03,090
這是你的目錄
當你通過SSH連接。在

140
00:07:03,090 --> 00:07:05,660
這是你在當目錄
你打開一個終端。

141
00:07:05,660 --> 00:07:08,650
這是你從哪裡開始。

142
00:07:08,650 --> 00:07:13,110
所以我為我的主目錄裡面，
而我的虛擬主機裡面

143
00:07:13,110 --> 00:07:14,475
我的主目錄的目錄中。

144
00:07:14,475 --> 00:07:19,670
然後我在本地內
主辦這裡面的目錄。

145
00:07:19,670 --> 00:07:23,740
>> 因此，一些其他的與CD有用的事情 - 

146
00:07:23,740 --> 00:07:29,220
或好，一般，所以總是點
指的是當前目錄。

147
00:07:29,220 --> 00:07:31,130
鎘，點是一個非常值錢的命令。

148
00:07:31,130 --> 00:07:35,150
但是，這改變的
當前目錄。

149
00:07:35,150 --> 00:07:38,230
一個更有效的方法之一在以下方面
CD是點，點，這是

150
00:07:38,230 --> 00:07:40,220
只是去了一個目錄。

151
00:07:40,220 --> 00:07:43,360
>> 並注意，這些 - 

152
00:07:43,360 --> 00:07:48,610
我想說的別名，但這些
符號，點和點，點，這些工作

153
00:07:48,610 --> 00:07:51,740
對於幾乎你的任何命令
將運行在想。

154
00:07:51,740 --> 00:07:55,370
因此，像CD可能是在那裡你會
使用最多的，但這些都不是

155
00:07:55,370 --> 00:07:56,780
事情剛剛CD理解。

156
00:07:56,780 --> 00:07:59,980
這是相當多的東西你的整個
命令行了解。

157
00:07:59,980 --> 00:08:01,932
很多程序可以理解
點與點，點。

158
00:08:01,932 --> 00:08:04,830

159
00:08:04,830 --> 00:08:09,090
>> 所以其他有用的 -  CD，破折號。

160
00:08:09,090 --> 00:08:13,460
所以這是要帶我去了
我是去年英寸目錄

161
00:08:13,460 --> 00:08:15,980
所以有時候我會做這樣的事情，
哦，我的工作在這裡。

162
00:08:15,980 --> 00:08:21,110
而我看​​到的東西一定誤差，
我會去通過去調查它

163
00:08:21,110 --> 00:08:24,020
一些隨機的目錄裡。

164
00:08:24,020 --> 00:08:25,260
我不知道這是否會
讓我在那裡。

165
00:08:25,260 --> 00:08:25,720
它的意志。

166
00:08:25,720 --> 00:08:27,615
於是我做我想做的事情
在此目錄中。

167
00:08:27,615 --> 00:08:28,950
胡說，胡說，胡說，胡說，胡說。

168
00:08:28,950 --> 00:08:31,770
我當時想，沒事，我想
回到我在哪裡。

169
00:08:31,770 --> 00:08:34,490
CD，破折號，它帶給我的右後衛。

170
00:08:34,490 --> 00:08:39,970
>> 所以，我要扔了很多
今天的這些你。

171
00:08:39,970 --> 00:08:43,730
我不希望你記住
所有的人。

172
00:08:43,730 --> 00:08:46,170
樣的，它只是知道
它們的存在。

173
00:08:46,170 --> 00:08:48,690
再後來就當你喜歡，
嗯，我想回去

174
00:08:48,690 --> 00:08:51,870
目錄我只是在，哦，等等，
類似的東西存在。

175
00:08:51,870 --> 00:08:53,980
你不必只需鍵入
再整個目錄。

176
00:08:53,980 --> 00:08:56,090
>> 約瑟夫：最終你會剛
一遍又一遍的使用它們，並且

177
00:08:56,090 --> 00:08:57,830
它會變成肌肉記憶。

178
00:08:57,830 --> 00:09:00,090
>> 羅伯：是啊。

179
00:09:00,090 --> 00:09:02,930
我以前那麼如何說，那波浪
是你的home目錄。

180
00:09:02,930 --> 00:09:04,820
所以我可以cd，波浪線。

181
00:09:04,820 --> 00:09:07,280
但我什至不有
這樣做，如果我只是 - 

182
00:09:07,280 --> 00:09:09,760
我會回去的目錄，以便
這不是一個毫無意義的例子。

183
00:09:09,760 --> 00:09:14,560
但是，如果我只是做CD，這也是該
一樣，去我的主目錄。

184
00:09:14,560 --> 00:09:18,380

185
00:09:18,380 --> 00:09:19,880
我做的命令，K.

186
00:09:19,880 --> 00:09:24,015
>> 約瑟夫：您也可以鍵入清晰，
總之，它應該清除它。

187
00:09:24,015 --> 00:09:28,650
>> 羅伯：我也想控制，
L同時，這樣做了。

188
00:09:28,650 --> 00:09:29,690
所以，很多不同的方式。

189
00:09:29,690 --> 00:09:34,070
我覺得有一定的差異，其中
明確和控制，L將只

190
00:09:34,070 --> 00:09:37,280
真的把它推到頂部，
我仍然可以向後滾動。

191
00:09:37,280 --> 00:09:40,580
命令，K字面上破壞
一切，你

192
00:09:40,580 --> 00:09:42,960
不能滾動備份。

193
00:09:42,960 --> 00:09:45,530
最起碼，這是
它是如何工作的iTerm2。

194
00:09:45,530 --> 00:09:48,690
我不知道其他的事情 - 

195
00:09:48,690 --> 00:09:49,360
哦。

196
00:09:49,360 --> 00:09:55,450
>> 用ssh方式連接，所以如果你是在Windows上，
你將要下載的PuTTY

197
00:09:55,450 --> 00:10:02,360
為了SSH，因為Windows不
有這樣一個內置的SSH工具。

198
00:10:02,360 --> 00:10:06,150
從Mac電腦，你可以只是直接的SSH
從終端窗口。

199
00:10:06,150 --> 00:10:08,755

200
00:10:08,755 --> 00:10:09,690
確定。

201
00:10:09,690 --> 00:10:11,840
有問題嗎？

202
00:10:11,840 --> 00:10:19,260
>> 通過ls，所以一些習慣
大多數這些命令是 - 

203
00:10:19,260 --> 00:10:20,060
好了，我就做一個。

204
00:10:20,060 --> 00:10:21,310
LS，破折號，L。

205
00:10:21,310 --> 00:10:26,330
所以破折號，l是什麼，我們要去
調用一個標誌，LS。

206
00:10:26,330 --> 00:10:30,770
和很多這些命令有標誌
您可以傳遞給他們。

207
00:10:30,770 --> 00:10:35,020
所以在這種情況下，儀表板，l是一個標誌
告訴它給我一個完整的

208
00:10:35,020 --> 00:10:37,850
所有的信息清單
這些文件。

209
00:10:37,850 --> 00:10:44,790
>> 所以，我們在這裡看到，桌面是
在12:54更新於7月30日。

210
00:10:44,790 --> 00:10:47,160
下載於9月6日修改。

211
00:10:47,160 --> 00:10:52,350
這些都是當前大小和
這些目錄中的字節數。

212
00:10:52,350 --> 00:10:54,412
您不必了解
所有這一切。

213
00:10:54,412 --> 00:11:00,380
>> 這東西在左邊，這些drwx的，
這將成為更相關

214
00:11:00,380 --> 00:11:02,290
以後當你不得不處理 - 

215
00:11:02,290 --> 00:11:05,900
有做誰擁有權限
來看看這些文件。

216
00:11:05,900 --> 00:11:09,880
所以，如果你沒有上唯一的用戶
這台電腦，你就可以到

217
00:11:09,880 --> 00:11:13,345
說好，我應該是唯一一個
可以看看這個文件，或者我

218
00:11:13,345 --> 00:11:14,870
要允許每個人
看看這個文件。

219
00:11:14,870 --> 00:11:17,710
所以，別人在我的電腦上
可以看看這個文件。

220
00:11:17,710 --> 00:11:22,190

221
00:11:22,190 --> 00:11:25,600
我什至不知道這是什麼 - 
這是什麼呢？

222
00:11:25,600 --> 00:11:26,840
>> 約瑟夫：我不太清楚，其實。

223
00:11:26,840 --> 00:11:27,705
>> 羅伯：不知道。

224
00:11:27,705 --> 00:11:30,530
>> 約瑟夫：但是，如果你不知道，有
您可以使用一個有用的命令

225
00:11:30,530 --> 00:11:31,680
告訴你什麼裝置的輸出。

226
00:11:31,680 --> 00:11:33,780
如果你的男人類型
該命令前 - 

227
00:11:33,780 --> 00:11:35,000
所以M-A-N。羅伯：男人。

228
00:11:35,000 --> 00:11:37,690
這樣的人是另外一個
這是非常有用的。

229
00:11:37,690 --> 00:11:39,540
和男人，LS。

230
00:11:39,540 --> 00:11:47,320
因此，手冊頁，他們有兩個
命令，你將要使用

231
00:11:47,320 --> 00:11:50,330
在命令行中，他們也有
功能，將有關

232
00:11:50,330 --> 00:11:52,530
與C所以，你可以man  - 

233
00:11:52,530 --> 00:11:53,720
我忽略3。

234
00:11:53,720 --> 00:11:57,410
但3人的printf會帶來
了C版的printf。

235
00:11:57,410 --> 00:12:01,030
但是，如果我只是做男人的printf，這是
要調出命令的printf

236
00:12:01,030 --> 00:12:03,540
這種情況發生在命令行。

237
00:12:03,540 --> 00:12:05,730
>> 這樣的男人，LS。

238
00:12:05,730 --> 00:12:09,030
手冊頁可以很
鋪天蓋地。

239
00:12:09,030 --> 00:12:12,770
在這裡，雖然，你會看到此房源
所有這些標誌的是LS

240
00:12:12,770 --> 00:12:14,300
理解。

241
00:12:14,300 --> 00:12:17,876
因此，如果我們去衝，l和 - 

242
00:12:17,876 --> 00:12:19,300
我只是要在你扔了。

243
00:12:19,300 --> 00:12:23,050
但為了搜索，你要
先打問題

244
00:12:23,050 --> 00:12:24,780
標記或斜線按鈕。

245
00:12:24,780 --> 00:12:26,040
所以，兇多吉少。

246
00:12:26,040 --> 00:12:29,000
>> 然後我就可以搜索
對於我想做的事情。

247
00:12:29,000 --> 00:12:33,780
所以我打算削減為破折號，L。

248
00:12:33,780 --> 00:12:35,110
而且它那裡。

249
00:12:35,110 --> 00:12:37,450
因此，使用一個長列表格式。

250
00:12:37,450 --> 00:12:40,060
這並不能幫助我弄清楚什麼
該特定列的意思，但我

251
00:12:40,060 --> 00:12:44,480
假設在這裡的某個地方
它會解釋。

252
00:12:44,480 --> 00:12:48,740
因此，使用手冊頁的任何命令
你不立刻明白了。

253
00:12:48,740 --> 00:12:51,080
>> 我敢肯定，你甚至可以男人，男人。

254
00:12:51,080 --> 00:12:53,070
在線給接口
參考手冊。

255
00:12:53,070 --> 00:12:57,700

256
00:12:57,700 --> 00:13:03,570
呵呵，最後一個是也許稍微
相關的是LS，破折號，。

257
00:13:03,570 --> 00:13:08,490
所以請注意，如果我只是做LS，
我得到這五個文件。

258
00:13:08,490 --> 00:13:11,480
如果我做LS，破折號，我
得到更多的文件。

259
00:13:11,480 --> 00:13:15,350
所以，所有這些之間的共同點
新文件是事先點。

260
00:13:15,350 --> 00:13:21,220
>> 因此，該公約是一個文件，
以圓點開頭的隱藏。

261
00:13:21,220 --> 00:13:25,300
所以，你不希望看到這個文件，你
不想擁有它惹

262
00:13:25,300 --> 00:13:26,750
您的目錄清單。

263
00:13:26,750 --> 00:13:30,020
只有當你明確要求，
沒事，LS，破折號，，告訴我。

264
00:13:30,020 --> 00:13:32,830
的一個代表所有文件，
包括隱藏的。

265
00:13:32,830 --> 00:13:37,260

266
00:13:37,260 --> 00:13:39,270
因此，一些其他命令。

267
00:13:39,270 --> 00:13:41,323
哦，在這一點上的問題？

268
00:13:41,323 --> 00:13:41,746
是。

269
00:13:41,746 --> 00:13:45,914
>> 揚聲器3：當你做LS，
一，什麼是點，點？

270
00:13:45,914 --> 00:13:46,870
>> 羅伯：哦。

271
00:13:46,870 --> 00:13:48,780
所以，這就是我在說什麼。

272
00:13:48,780 --> 00:13:50,890
這是同樣的事情在那裡
我喜歡的CD，點，點。

273
00:13:50,890 --> 00:13:56,790
所以在技術上，點和點，點是
存在於每一個文件

274
00:13:56,790 --> 00:14:03,620
所在的目錄dot文件指
到當前目錄。

275
00:14:03,620 --> 00:14:06,930
所以，如果我的CD，點，我只是去
留在目錄中。

276
00:14:06,930 --> 00:14:10,870
和圓點，圓點總是指
以前的一級目錄。

277
00:14:10,870 --> 00:14:18,200
所以，如果我進入日誌和ls，破折號，人​​，
我會看到圓點，圓點。 cd到網點，網點

278
00:14:18,200 --> 00:14:20,390
使我先前的目錄。

279
00:14:20,390 --> 00:14:24,530

280
00:14:24,530 --> 00:14:25,780
是啊。

281
00:14:25,780 --> 00:14:27,160

282
00:14:27,160 --> 00:14:28,110
確定。

283
00:14:28,110 --> 00:14:33,070
>> 因此，另一個非常重要的
命令為rm。

284
00:14:33,070 --> 00:14:35,650
所以，這就是我們要去
使用去除。

285
00:14:35,650 --> 00:14:38,100
讓我實際上做一套
命令第一。

286
00:14:38,100 --> 00:14:39,610
所以MKDIR。

287
00:14:39,610 --> 00:14:42,770
MKDIR是你可以
創建目錄。

288
00:14:42,770 --> 00:14:47,530
我會創建一個臨時目錄
並進入該臨時目錄。

289
00:14:47,530 --> 00:14:49,590
和預期的一樣，它是空的。

290
00:14:49,590 --> 00:14:53,680
但是，如果我LS，破折號，一個，我還有點
與點，點，因為點是指

291
00:14:53,680 --> 00:14:54,480
當前目錄。

292
00:14:54,480 --> 00:14:56,170
與點，點指
上一個目錄。

293
00:14:56,170 --> 00:14:58,700
而那些將永遠存在，無論
您所在的目錄

294
00:14:58,700 --> 00:15:01,910

295
00:15:01,910 --> 00:15:09,010
>> 這是一個完全沒有必要的
命令，但觸摸。

296
00:15:09,010 --> 00:15:11,880
我只是用它，因為它是
一個簡單的方法來創建文件。

297
00:15:11,880 --> 00:15:16,180
所以觸摸，觸摸B，觸摸c是剛
要創建一個名為三個文件，

298
00:15:16,180 --> 00:15:17,845
b和c是完全空的。

299
00:15:17,845 --> 00:15:20,450

300
00:15:20,450 --> 00:15:24,980
於是我點創建那些在
首先就是這麼說是RM

301
00:15:24,980 --> 00:15:26,250
我們如何才能將其刪除。

302
00:15:26,250 --> 00:15:27,850
所以，RM，一。

303
00:15:27,850 --> 00:15:30,960
它會問我，取出
常規的空文件？

304
00:15:30,960 --> 00:15:33,170
然後我會說是的。

305
00:15:33,170 --> 00:15:39,090
>> 所以，如果我確實知道我要
刪除該文件，而不必是

306
00:15:39,090 --> 00:15:44,500
提示，定期刪除空文件？，
然後RM，破折號，f為將成為

307
00:15:44,500 --> 00:15:48,230
標誌，上面寫著，強制刪除而不
甚至促使我哦，是你

308
00:15:48,230 --> 00:15:49,710
確定要刪除的文件？

309
00:15:49,710 --> 00:15:50,810
是的，我敢肯定。

310
00:15:50,810 --> 00:15:56,050
所以，RM，破折號，FB將只
做到這一點不求回報。

311
00:15:56,050 --> 00:15:57,950
>> 因此，讓我們做一些更多的目錄。

312
00:15:57,950 --> 00:16:03,670
MKDIR，TMP2，CD，TMP2，
觸，觸按B。

313
00:16:03,670 --> 00:16:04,300
確定。

314
00:16:04,300 --> 00:16:08,180
所以現在我想刪除
TMP2作為目錄。

315
00:16:08,180 --> 00:16:10,316
所以，RM TMP2。

316
00:16:10,316 --> 00:16:12,920
你不能刪除TMP2，
它是一個目錄。

317
00:16:12,920 --> 00:16:21,370
因此，這裡的問題是，RM不
馬上工作在目錄上。

318
00:16:21,370 --> 00:16:26,530
它只是意味著像文件
非目錄的文件。

319
00:16:26,530 --> 00:16:30,800
>> 所以我們能做些什麼
這裡為rm，破折號，河

320
00:16:30,800 --> 00:16:35,160
這表示遞歸，這可能
不是對你意味著什麼呢。

321
00:16:35,160 --> 00:16:38,280
但是，當你到了遞歸，
這將意味著更多。

322
00:16:38,280 --> 00:16:43,540
所以，RM，破折號，R，TMP2是要
遞歸進入該目錄。

323
00:16:43,540 --> 00:16:45,540
於是陷入目錄TMP2？

324
00:16:45,540 --> 00:16:47,330
是的，讓我們考慮這樣做。

325
00:16:47,330 --> 00:16:49,360
難道我們要刪除TMP2 /一？

326
00:16:49,360 --> 00:16:49,745
是。

327
00:16:49,745 --> 00:16:51,830
難道我們要刪除TMP2 / B？

328
00:16:51,830 --> 00:16:52,840
是。

329
00:16:52,840 --> 00:16:55,170
現在，我們要刪除
目錄TMP2？

330
00:16:55,170 --> 00:16:56,040
是。

331
00:16:56,040 --> 00:16:58,410
所以現在的目錄
和裡面的一切

332
00:16:58,410 --> 00:16:59,660
它已被刪除。

333
00:16:59,660 --> 00:17:02,850

334
00:17:02,850 --> 00:17:07,250
>> 有技術上的命令RMDIR
您可以用它來去除

335
00:17:07,250 --> 00:17:11,670
目錄，但它僅適用
在空目錄反正。

336
00:17:11,670 --> 00:17:14,109
並且一看就知道，我們只
再做MKDIR，TMP2。

337
00:17:14,109 --> 00:17:15,940
TMP2，觸摸。

338
00:17:15,940 --> 00:17:16,800
確定。

339
00:17:16,800 --> 00:17:22,770
所以，如果我嘗試刪除dirtmp2，它​​會
說，目錄不是空的。

340
00:17:22,770 --> 00:17:29,540
所以，我幾乎從來沒有使用remove
dir命令無論如何，因為RM，破折號，

341
00:17:29,540 --> 00:17:35,140
r會為其工作的空目錄
和非空目錄。

342
00:17:35,140 --> 00:17:37,760
>> 還有，如果我不希望有
經歷了整個過程

343
00:17:37,760 --> 00:17:40,720
降入目錄，並
刪除每個單獨的文件，RM，

344
00:17:40,720 --> 00:17:44,190
破折號，RF，TMP2。

345
00:17:44,190 --> 00:17:45,670
而現在它不見了。

346
00:17:45,670 --> 00:17:51,220
>> 東西要小心
關於為rm，破折號，RF。

347
00:17:51,220 --> 00:17:53,660
它讓我害怕，甚至鍵入它，
因為如果我不小心

348
00:17:53,660 --> 00:17:55,090
按Enter鍵或東西。

349
00:17:55,090 --> 00:18:02,735
所以，RM，破折號，RF，波浪會，不
提示我，F不提示

350
00:18:02,735 --> 00:18:05,670
我，它會自動刪除
我的整個主目錄和

351
00:18:05,670 --> 00:18:06,780
一切都在它。

352
00:18:06,780 --> 00:18:11,460
所以，你可能認為這是
一個愚蠢的事情。

353
00:18:11,460 --> 00:18:12,830
很好，它是。

354
00:18:12,830 --> 00:18:18,600
>> 但它可以通過很容易出現
意外，如果說，我想刪除

355
00:18:18,600 --> 00:18:21,640
我的斜線，虛擬主機目錄。

356
00:18:21,640 --> 00:18:26,610
而就在快速打字，
我不小心這樣做。

357
00:18:26,610 --> 00:18:31,880
這將遞歸刪除我的兩個
主目錄和虛擬主機目錄

358
00:18:31,880 --> 00:18:35,450
這個特定的目錄中，僅僅
恰好不存在現在。

359
00:18:35,450 --> 00:18:39,520
但是，這仍然會刪除
我的整個主目錄。

360
00:18:39,520 --> 00:18:43,090
至少是沒有一個f，
它會先提示我。

361
00:18:43,090 --> 00:18:45,670
我會想，哦，不，我
不想做。

362
00:18:45,670 --> 00:18:50,570
但是，人們，斜線，包括
我往往會得到進

363
00:18:50,570 --> 00:18:53,090
習慣總是RF-ING。

364
00:18:53,090 --> 00:18:58,713
即使是常規文件，我可以只RM，
C，我傾向於只RM，破折號，RF，C。

365
00:18:58,713 --> 00:19:01,330
只是要小心，當你RF-ING。

366
00:19:01,330 --> 00:19:03,160
>> 揚聲器4：什麼是c執行？

367
00:19:03,160 --> 00:19:11,570
>> 羅伯：C被我說的是C文件
在此目錄中，即RM，C。

368
00:19:11,570 --> 00:19:15,730
>> 約瑟夫：而更危險的是，如果你使用
一個明星，它是指在一切

369
00:19:15,730 --> 00:19:16,450
的目錄。

370
00:19:16,450 --> 00:19:20,040
所以我通常傾向於做是我會的
進入一個目錄，我想

371
00:19:20,040 --> 00:19:21,510
除去在那裡的所有文件。

372
00:19:21,510 --> 00:19:23,640
所以，RM，破折號，RF，明星。

373
00:19:23,640 --> 00:19:25,700
>> 羅伯：是啊。

374
00:19:25,700 --> 00:19:26,780
室，破折號，RF，明星。

375
00:19:26,780 --> 00:19:29,530
>> 約瑟夫：如果你不小心
你在哪個目錄 - 

376
00:19:29,530 --> 00:19:33,340
我是不是臨時的，但我還是不小心
在我的主目錄，

377
00:19:33,340 --> 00:19:35,450
然後我會刪除一切
在我的主目錄。

378
00:19:35,450 --> 00:19:39,095
而我實際上做到這一點之前，和
我覺得你還是以前做過這

379
00:19:39,095 --> 00:19:40,640
周杰倫之前做到這一點。

380
00:19:40,640 --> 00:19:42,480
>> 羅伯：我不小心刪除 - 

381
00:19:42,480 --> 00:19:44,480
所以忽略該命令為位。

382
00:19:44,480 --> 00:19:45,800
>> 喬瑟夫：不好玩。

383
00:19:45,800 --> 00:19:52,650
>> 羅伯：所以在斜線bin目錄是一個
一串二進制文件，其中有會

384
00:19:52,650 --> 00:19:54,840
熟悉的像鐺。

385
00:19:54,840 --> 00:20:00,740
好了，鐺，基本上所有這些
我在命令正在運行的東西

386
00:20:00,740 --> 00:20:02,060
線是在這個斜線bin目錄下。

387
00:20:02,060 --> 00:20:03,090
>> 約瑟夫：像LS是在這裡。

388
00:20:03,090 --> 00:20:06,285
>> 羅伯：那麼點，斜線，LS會
列出該目錄。

389
00:20:06,285 --> 00:20:08,120
>> 約瑟夫：室也是在這個目錄中。

390
00:20:08,120 --> 00:20:12,770
>> 羅伯：我不小心RM，RF，海關斌，
其中刪除任何命令我可以

391
00:20:12,770 --> 00:20:14,380
可能是有史以來想要的。

392
00:20:14,380 --> 00:20:18,085
然後我剛剛重新安裝
新的電器在該點。

393
00:20:18,085 --> 00:20:20,170
>> 喬瑟夫：所以要非常小心，當
使用此命令。

394
00:20:20,170 --> 00:20:21,120
>> 觀眾：[聽不清]？

395
00:20:21,120 --> 00:20:22,640
>> 羅伯：是的。

396
00:20:22,640 --> 00:20:24,135
這也是一個不好的習慣進入。

397
00:20:24,135 --> 00:20:27,920

398
00:20:27,920 --> 00:20:30,170
如果你注意到，我現在 - 

399
00:20:30,170 --> 00:20:33,580
好了，你不能看到，但
我使用zoom-in，也許可以。

400
00:20:33,580 --> 00:20:35,360
所以，我現在根@設備。

401
00:20:35,360 --> 00:20:39,790
所以jharvard是我們想要的用戶
你總是可以使用。

402
00:20:39,790 --> 00:20:43,820
根是具有權限的用戶
做任何事情絕。

403
00:20:43,820 --> 00:20:50,260
>> 所以請注意，當我jharvard，
如果我嘗試到CD  - 

404
00:20:50,260 --> 00:20:52,461
什麼是目錄？

405
00:20:52,461 --> 00:20:53,980
哦，根是一個很好的例子。

406
00:20:53,980 --> 00:20:54,950
所以CD，根。

407
00:20:54,950 --> 00:20:56,030
權限被拒絕。

408
00:20:56,030 --> 00:21:00,060
因為如果我們看一下此房源 - 

409
00:21:00,060 --> 00:21:02,410
又一次，你不必
完全理解這一點。

410
00:21:02,410 --> 00:21:09,210
但是這三個破折號都這麼說
沒有讓任何其他

411
00:21:09,210 --> 00:21:11,120
用戶進入這個目錄。

412
00:21:11,120 --> 00:21:14,540
並且該目錄恰好
由root用戶所擁有。

413
00:21:14,540 --> 00:21:20,310
>> 所以，我其實jharvard無
一個誰不是root允許進入

414
00:21:20,310 --> 00:21:23,490
這個目錄，這意味著我
會得到權限被拒絕時，我

415
00:21:23,490 --> 00:21:25,160
試試cd到它。

416
00:21:25,160 --> 00:21:31,370
所以，當我的根，我有權限
絕對做任何事情，包括

417
00:21:31,370 --> 00:21:34,660
刪除重要文件
在電器和

418
00:21:34,660 --> 00:21:36,640
毀掉整個事情。

419
00:21:36,640 --> 00:21:41,240
>> 所以這是一個不好的習慣進入
只是四處遊蕩的

420
00:21:41,240 --> 00:21:43,650
操作系統的根。

421
00:21:43,650 --> 00:21:46,520
我反正做。

422
00:21:46,520 --> 00:21:48,710
有問題嗎？

423
00:21:48,710 --> 00:21:52,230
我會退出的根，留為jharvard。

424
00:21:52,230 --> 00:21:54,510
確定。

425
00:21:54,510 --> 00:21:55,820
>> 更多相關的命令。

426
00:21:55,820 --> 00:22:03,975
所以，要回我們的溫度時，
mv命令代表的舉動。

427
00:22:03,975 --> 00:22:05,450
您可以移動。

428
00:22:05,450 --> 00:22:07,610
現在，我們要叫它B，
所以現在它稱為B。

429
00:22:07,610 --> 00:22:10,650
或者，也許我們要移動
B上漲一個目錄。

430
00:22:10,650 --> 00:22:12,730
所以，現在這個目錄是空的。

431
00:22:12,730 --> 00:22:15,410
我將回到我的主目錄，
我們看到，b為在這裡，因為

432
00:22:15,410 --> 00:22:19,230
主目錄是從一個目錄了
是B曾經所在的目錄。

433
00:22:19,230 --> 00:22:24,710

434
00:22:24,710 --> 00:22:26,580
>> 還有CP。

435
00:22:26,580 --> 00:22:33,210
因此，CP是複製的超級節，
點，文字。

436
00:22:33,210 --> 00:22:35,750
我可以調用它s，點，文字。

437
00:22:35,750 --> 00:22:39,780
現在我們有兩個超級節，
點，文字，和s，點，文字。

438
00:22:39,780 --> 00:22:41,340
這也適用於目錄。

439
00:22:41,340 --> 00:22:44,040

440
00:22:44,040 --> 00:22:46,560
我RF，海關單個文件。

441
00:22:46,560 --> 00:22:48,200
因此，CP  - 

442
00:22:48,200 --> 00:22:51,710
好了，首先讓我們來試試CP，TMP，TMP2。

443
00:22:51,710 --> 00:22:53,220
所以省略tmp目錄。

444
00:22:53,220 --> 00:22:57,440
如此相似RM，默認行為
是對目錄不起作用。

445
00:22:57,440 --> 00:23:01,570
>> 再次，類似RM，默認
行為 - 好，得到它的工作

446
00:23:01,570 --> 00:23:04,230
使用目錄是一個，破折號-R的路程。

447
00:23:04,230 --> 00:23:09,240
所以遞歸複製該溫度
目錄複製到TMP2。

448
00:23:09,240 --> 00:23:13,700
所以現在我們有兩個tmp目錄和tmp2
那是不是有益的，因為TMP

449
00:23:13,700 --> 00:23:16,814
是空擺在首位。

450
00:23:16,814 --> 00:23:18,660
TMP2。

451
00:23:18,660 --> 00:23:22,680
>> 現在，讓我們tmp目錄複製到TMP2。

452
00:23:22,680 --> 00:23:27,900
而且我們看到，TMP2還具有文件
一，因為目錄和

453
00:23:27,900 --> 00:23:32,220
一切的那裡面
目錄被複製。

454
00:23:32,220 --> 00:23:36,000
而這可能有點幫助
如果說你的工作

455
00:23:36,000 --> 00:23:38,860
在問題設置1  - 

456
00:23:38,860 --> 00:23:41,320
或者實際上，後來問題集
更為重要的，因為有

457
00:23:41,320 --> 00:23:43,660
將一大堆
文件和事情。

458
00:23:43,660 --> 00:23:47,010
>> 但你只是想，對於一個分裂
第二，你喜歡，沒事，我

459
00:23:47,010 --> 00:23:50,210
要嘗試不同的東西。

460
00:23:50,210 --> 00:23:57,860
讓我複製我的整個PSET1
目錄複製到PSET1備份，這樣如果

461
00:23:57,860 --> 00:24:01,490
我最終搞砸的事情了，我可以
返回到我的備份目錄。

462
00:24:01,490 --> 00:24:07,340
還有更合適的方法
版本備份你的代碼，但

463
00:24:07,340 --> 00:24:10,610
這始終是一個快速的方法來只是讓
確保你有東西副本

464
00:24:10,610 --> 00:24:11,860
那你要修改。

465
00:24:11,860 --> 00:24:16,974

466
00:24:16,974 --> 00:24:27,090
>> 所以迴聲也是一次性的命令
一種sillily將只打印到

467
00:24:27,090 --> 00:24:31,540
命令行到底是什麼
你想呼應。

468
00:24:31,540 --> 00:24:32,680
所以迴聲喜。

469
00:24:32,680 --> 00:24:35,420
我們將只打印喜。

470
00:24:35,420 --> 00:24:38,030
迴聲的hello world。

471
00:24:38,030 --> 00:24:39,800
我們將打印的hello world。

472
00:24:39,800 --> 00:24:44,350
這涉及到使用的時候你
啟動合併命令。

473
00:24:44,350 --> 00:24:48,300
>> 再次，不要指望你完全
理解這一步，但它的

474
00:24:48,300 --> 00:24:49,910
看到的東西。

475
00:24:49,910 --> 00:24:52,470
然後，如果你對谷歌搜索的例子
或者你知道你想要做的

476
00:24:52,470 --> 00:24:55,030
的東西，它可以是有益的。

477
00:24:55,030 --> 00:24:59,020
因此，讓我們作為一個例子，
所以LS，破折號，L。

478
00:24:59,020 --> 00:25:01,160
所以我在這裡看到的輸出
LS的，破折號，L。

479
00:25:01,160 --> 00:25:06,560
我說好，我想
存儲到文件中。

480
00:25:06,560 --> 00:25:11,620
所有在這裡的輸出，我想
投入到一個單獨的文件。

481
00:25:11,620 --> 00:25:16,080
>> 比符號更大所以這一點
就是我們要去打電話。

482
00:25:16,080 --> 00:25:18,570
我們的重定向
輸出到文件中。

483
00:25:18,570 --> 00:25:21,680
讓我們把文件等等，因為這是
我往往會在調用它。

484
00:25:21,680 --> 00:25:26,430
所以現在我們看到我們有一個
文件胡說就在這裡。

485
00:25:26,430 --> 00:25:30,270
如果我打開它，我會看到它的
正是從這個命令的輸出

486
00:25:30,270 --> 00:25:31,990
我只是跑。

487
00:25:31,990 --> 00:25:36,020
同樣，你可以 - 

488
00:25:36,020 --> 00:25:41,260
如果這是輸出到一個文件中，這
從文件中獲得輸入。

489
00:25:41,260 --> 00:25:45,790

490
00:25:45,790 --> 00:25:47,050
什麼是命令，我 - 

491
00:25:47,050 --> 00:25:49,620
>> 約瑟夫：我想你可以用
少跌多，大概。

492
00:25:49,620 --> 00:25:53,031
>> 羅伯：但如何只少廢話？

493
00:25:53,031 --> 00:25:53,930
我不知道。

494
00:25:53,930 --> 00:25:57,870
如果你進入這個場景，像
有pset時，它是很有用的。

495
00:25:57,870 --> 00:25:59,950
>> 約瑟夫：你可以管成迴聲。

496
00:25:59,950 --> 00:26:02,920
管道文件到回波看到它。

497
00:26:02,920 --> 00:26:04,060
>> 羅伯：這是管道。

498
00:26:04,060 --> 00:26:04,860
>> 約瑟夫：對不起。

499
00:26:04,860 --> 00:26:06,190
>> 羅伯：好吧。

500
00:26:06,190 --> 00:26:12,720
因此，這是輸出到文件。

501
00:26:12,720 --> 00:26:18,700
這是從文件中獲取文本
並把它交給該程序。

502
00:26:18,700 --> 00:26:20,560
而且你還可以看到這個傢伙。

503
00:26:20,560 --> 00:26:24,410
因此，這是一次那種做兩個。

504
00:26:24,410 --> 00:26:28,310
而實際上，我將介紹兩個新
命令只是為了它的使用。

505
00:26:28,310 --> 00:26:33,060
>> 歷史是一個方便的命令，這只是
將打印出的清單

506
00:26:33,060 --> 00:26:34,940
任何我曾經運行的命令行。

507
00:26:34,940 --> 00:26:38,290
所以，我們在這裡看到的一切，我有
已經運行這整個時間。

508
00:26:38,290 --> 00:26:39,540
大量的LS的。

509
00:26:39,540 --> 00:26:41,570

510
00:26:41,570 --> 00:26:48,470
>> 而另一個有用的命令是grep的那
其目的是為了在搜索

511
00:26:48,470 --> 00:26:52,060
文字尋找模式，好了，
尋找任何你

512
00:26:52,060 --> 00:26:53,310
希望它去尋找。

513
00:26:53,310 --> 00:26:59,770
所以這裡一個方便的用途是，比方說
我們要抓住歷史。

514
00:26:59,770 --> 00:27:03,860
我要尋找的命令
在那裡我 - 什麼是

515
00:27:03,860 --> 00:27:05,000
有用的寶貝？

516
00:27:05,000 --> 00:27:06,898
>> 約瑟夫：[聽不清]？

517
00:27:06,898 --> 00:27:09,710
>> 羅伯：還是讓我們只是看所有
倒是，不管是什麼原因。

518
00:27:09,710 --> 00:27:13,850
所以這是它的樣子。

519
00:27:13,850 --> 00:27:15,560
而你也不必完全
理解這一點。

520
00:27:15,560 --> 00:27:20,570
但這個想法是在這裡，歷史是給
相同的輸出它確實在這裡

521
00:27:20,570 --> 00:27:25,030
在那裡它打印出整個
一切我曾經運行的歷史。

522
00:27:25,030 --> 00:27:27,030
然後我們又路過那個 - 

523
00:27:27,030 --> 00:27:30,230
而不是將它打印到屏幕，這樣，
我們要傳遞給

524
00:27:30,230 --> 00:27:34,640
命令grep的是尋找
字觸摸的所有實例。

525
00:27:34,640 --> 00:27:40,280
>> 所以使用的這個組合
歷史的工具和grep，我可以看到，OK，

526
00:27:40,280 --> 00:27:44,820
這裡的所有的命令，我曾經
運行，這裡是一個有點常見的一種。

527
00:27:44,820 --> 00:27:45,510
我們是在底部。

528
00:27:45,510 --> 00:27:47,930
並且它也給了我命令
我剛跑了有

529
00:27:47,930 --> 00:27:51,240
在它的詞聯繫。

530
00:27:51,240 --> 00:27:58,500
但管道是一個非常有用的東西
用於組合多個程序。

531
00:27:58,500 --> 00:28:04,670
而實際上，這是為讓快捷方式
我歷史輸出到文件等等，並

532
00:28:04,670 --> 00:28:10,190
讓我用grep使用文件等等
因為我想看看了。

533
00:28:10,190 --> 00:28:13,460
所以管只是一個快捷方式
對於這兩個命令。

534
00:28:13,460 --> 00:28:13,950
是。

535
00:28:13,950 --> 00:28:15,306
>> 揚聲器4：[聽不清]？

536
00:28:15,306 --> 00:28:16,556
>> 羅伯：是的。

537
00:28:16,556 --> 00:28:20,142

538
00:28:20,142 --> 00:28:21,110
什麼是 - 

539
00:28:21,110 --> 00:28:21,858
呵呵。

540
00:28:21,858 --> 00:28:24,820
讓我們來測試一下。

541
00:28:24,820 --> 00:28:29,170
所以，貓，狗，魚。

542
00:28:29,170 --> 00:28:33,770
所以我想給grep。

543
00:28:33,770 --> 00:28:37,680
短跑河，再次，將是
遞歸的，所以我想降下來

544
00:28:37,680 --> 00:28:38,870
所有目錄。

545
00:28:38,870 --> 00:28:43,210
我想遞歸的grep對所有 - 
讓我暫時得到

546
00:28:43,210 --> 00:28:44,460
這一點的方式。

547
00:28:44,460 --> 00:28:48,650

548
00:28:48,650 --> 00:28:50,740
不理我。

549
00:28:50,740 --> 00:28:51,360
確定。

550
00:28:51,360 --> 00:28:56,740
>> 所以我想暫時用grep的
這個詞的魚的所有實例。

551
00:28:56,740 --> 00:29:00,510
所以在這裡我在做什麼是用grep搜索
遞歸的字魚。

552
00:29:00,510 --> 00:29:05,410
和星意味著在所有的這些
此目錄中的文件。

553
00:29:05,410 --> 00:29:08,930
因此，這給了我拒絕的權限，
因為這是不允許讀

554
00:29:08,930 --> 00:29:10,060
特定的文件。

555
00:29:10,060 --> 00:29:14,040
但它在文件中，測試中發現的魚。

556
00:29:14,040 --> 00:29:18,450
>> 我也可以說，具體而言，我只
想看看在文件等等，在

557
00:29:18,450 --> 00:29:19,580
這種情況下它不會找到任何東西。

558
00:29:19,580 --> 00:29:20,990
我只是想看看在文件，測試。

559
00:29:20,990 --> 00:29:22,240
它會找到魚。

560
00:29:22,240 --> 00:29:25,980

561
00:29:25,980 --> 00:29:29,260
這是一個非常有用的命令
要知道一般。

562
00:29:29,260 --> 00:29:31,640
有一些替代品到grep
這被認為是更加

563
00:29:31,640 --> 00:29:36,780
程序員友好的，但我傾向於
仍然依傍的grep。

564
00:29:36,780 --> 00:29:38,030
有問題嗎？

565
00:29:38,030 --> 00:29:39,965

566
00:29:39,965 --> 00:29:40,919
確定。

567
00:29:40,919 --> 00:29:42,520
>> 還有沒有其他的命令？

568
00:29:42,520 --> 00:29:45,270
呵呵。

569
00:29:45,270 --> 00:29:48,370
只是一次性的一個，我始終
發現很有趣的卡爾。

570
00:29:48,370 --> 00:29:55,610
所以，當我在這個可愛的通知
全屏模式下，我沒有最喜歡

571
00:29:55,610 --> 00:29:56,720
工具欄或任何東西。

572
00:29:56,720 --> 00:29:59,530
所以，卡爾只是給了我一個可愛的小
日曆這是正確的

573
00:29:59,530 --> 00:30:02,380
現在斷了，我假設。

574
00:30:02,380 --> 00:30:04,770
但可愛的小命令。

575
00:30:04,770 --> 00:30:06,540
>> 約瑟夫：這是[聽不清]。

576
00:30:06,540 --> 00:30:09,170
你可能有其他的命令
看到包括鏗鏘而作。

577
00:30:09,170 --> 00:30:11,180
我們就去了他們
後面更詳細。

578
00:30:11,180 --> 00:30:13,400
但是，如果你已經工作
在PSET，你應該

579
00:30:13,400 --> 00:30:15,160
熟悉這些。

580
00:30:15,160 --> 00:30:16,640
>> 羅伯：好吧。

581
00:30:16,640 --> 00:30:18,520
在命令行的東西有問題？

582
00:30:18,520 --> 00:30:22,450

583
00:30:22,450 --> 00:30:23,260
好的。

584
00:30:23,260 --> 00:30:27,416
因此，讓我們進入到一些
C-相關的東西。

585
00:30:27,416 --> 00:30:28,666
變量的數學。

586
00:30:28,666 --> 00:30:39,078

587
00:30:39,078 --> 00:30:40,060
確定。

588
00:30:40,060 --> 00:30:45,230
所以就像我們有數學的划痕，
您還可以使用數學三中

589
00:30:45,230 --> 00:30:49,270
>> 在我們到達那個完全，
這樣的變量。

590
00:30:49,270 --> 00:30:53,920
請記住，當你聲明一個
如int X或浮動y，則變量

591
00:30:53,920 --> 00:30:56,710
必須給它之前鍵入
變量名。

592
00:30:56,710 --> 00:31:03,020
因此，我們已經看到了類型到目前為止是int，
浮點型，雙，很長很長，我

593
00:31:03,020 --> 00:31:06,150
實際上不知道我們是否已經
看到這麼遠。

594
00:31:06,150 --> 00:31:07,700
>> 還有一些其他的。

595
00:31:07,700 --> 00:31:09,990
我們已經看到字符。

596
00:31:09,990 --> 00:31:13,920
有短，這是喜歡它的
相反的很長很長的地方是

597
00:31:13,920 --> 00:31:16,650
比小的整數。

598
00:31:16,650 --> 00:31:18,580
我們也看到字符串。

599
00:31:18,580 --> 00:31:23,070
那麼，什麼是特別的字符串？

600
00:31:23,070 --> 00:31:25,350
為什麼我會說這是
不是很喜歡整型？

601
00:31:25,350 --> 00:31:27,030
>> 揚聲器4：它並不真的​​存在。

602
00:31:27,030 --> 00:31:27,990
>> 羅伯：是啊。

603
00:31:27,990 --> 00:31:31,820
因此，我們有字符串的唯一理由
是因為當你這樣做

604
00:31:31,820 --> 00:31:33,215
哈希，包括cs50.h.

605
00:31:33,215 --> 00:31:36,530

606
00:31:36,530 --> 00:31:42,670
我們會看到這樣的例子以後 - 
哦，那不處理好 - 

607
00:31:42,670 --> 00:31:46,160
其中cs50.h正在做的事情
沿型的線

608
00:31:46,160 --> 00:31:49,230
閃避，焦炭星，字符串。

609
00:31:49,230 --> 00:31:53,280
>> 所以這是說，我們甚至不
知道一個char明星是什麼呢。

610
00:31:53,280 --> 00:31:56,770
但是，這是說我們要的字符串。

611
00:31:56,770 --> 00:32:00,250
任何你已經使用字符串，你的地方
可以用字符明星已，

612
00:32:00,250 --> 00:32:04,670
這實際上是一個類型，
存在於C語言。

613
00:32:04,670 --> 00:32:06,680
但我們會到達那個。

614
00:32:06,680 --> 00:32:07,860
哦，它會馬上回來。

615
00:32:07,860 --> 00:32:10,170
整齊。

616
00:32:10,170 --> 00:32:15,370
>> 所以，同樣的事情與布爾
其中真假。

617
00:32:15,370 --> 00:32:22,510
這是不是真的在C的內置型
相反，它只是，這是否有

618
00:32:22,510 --> 00:32:23,740
零值？

619
00:32:23,740 --> 00:32:26,200
然後，我們將只考慮
它是假的。

620
00:32:26,200 --> 00:32:27,350
這是否有值 - 

621
00:32:27,350 --> 00:32:30,530
好了，這是否有任何
值不為零？

622
00:32:30,530 --> 00:32:32,200
然後，我們將認為這是正確的。

623
00:32:32,200 --> 00:32:35,940
所以，有一個為真，二是真實的，
任何非零為真。

624
00:32:35,940 --> 00:32:38,710

625
00:32:38,710 --> 00:32:42,790
因此，這些都是那些。

626
00:32:42,790 --> 00:32:47,624
在聲明變量的問題和
變量類型和所有？

627
00:32:47,624 --> 00:32:48,100
是啊。

628
00:32:48,100 --> 00:32:52,384
>> 揚聲器4：對於長很長，在書中，
它說，它必須是long long int的。

629
00:32:52,384 --> 00:32:54,288
但也只是很長很長的工作？

630
00:32:54,288 --> 00:32:58,210

631
00:32:58,210 --> 00:33:01,470
>> 羅伯：所以這些類型修飾符。

632
00:33:01,470 --> 00:33:04,170
所以詮釋x。

633
00:33:04,170 --> 00:33:07,710
所以我們也可以說無符號詮釋x。

634
00:33:07,710 --> 00:33:09,640
我們可以說短詮釋x。

635
00:33:09,640 --> 00:33:12,570
我們可以說，很長很長詮釋x。

636
00:33:12,570 --> 00:33:17,250
但這些東西幾乎任何我
剛才說了，無符號整型，短整型，

637
00:33:17,250 --> 00:33:21,480
long long int的，你可以擺脫
int和它只是假設

638
00:33:21,480 --> 00:33:22,510
那你的意思是int類型。

639
00:33:22,510 --> 00:33:26,045
所以無符號x，它只是意味著 - 

640
00:33:26,045 --> 00:33:29,400
你知道如何正常使用int，
你可以說x等於負3？

641
00:33:29,400 --> 00:33:31,636
用一個無符號整數，你不能。

642
00:33:31,636 --> 00:33:34,480
>> 約瑟夫：再次，對於攝像頭，
問題是，有什麼區別

643
00:33:34,480 --> 00:33:37,796
長的長整型之間
和公正的很長很長？

644
00:33:37,796 --> 00:33:38,410
>> 羅伯：是啊。

645
00:33:38,410 --> 00:33:42,850
所以，我幾乎從來不會
寫的很長很長整型。

646
00:33:42,850 --> 00:33:44,100
我會寫很長很長。

647
00:33:44,100 --> 00:33:47,770

648
00:33:47,770 --> 00:33:50,636
>> 約瑟夫：有問題嗎？

649
00:33:50,636 --> 00:33:51,886
>> 羅伯：確定。

650
00:33:51,886 --> 00:33:56,180

651
00:33:56,180 --> 00:34:02,390
那真是太傻了一點提醒是如何
我們聲明一個變量並初始化

652
00:34:02,390 --> 00:34:04,450
變量和聲明其他
變量和初始化

653
00:34:04,450 --> 00:34:05,870
這一切在一個步驟。

654
00:34:05,870 --> 00:34:09,370
變量如此的聲明和
初始化變量沒有

655
00:34:09,370 --> 00:34:11,120
到，但可以在同一條線上。

656
00:34:11,120 --> 00:34:15,409

657
00:34:15,409 --> 00:34:20,060
>> 因此，我們有標準的數學運算符
你已經習慣了 - 

658
00:34:20,060 --> 00:34:22,199
加，減，除，次。

659
00:34:22,199 --> 00:34:24,389
還有模，我們拭目以待。

660
00:34:24,389 --> 00:34:29,060
沒有的話，至少在
C，一個內置電源

661
00:34:29,060 --> 00:34:31,765
冪^操作符。

662
00:34:31,765 --> 00:34:33,770
嗯，有一個插入符號運算符，
但它不是權力。

663
00:34:33,770 --> 00:34:34,239
>> 約瑟夫：但它不是冪，
是。

664
00:34:34,239 --> 00:34:36,210
>> 羅伯：不要使用插入符號
假定它是指

665
00:34:36,210 --> 00:34:39,980
像方或什麼的。

666
00:34:39,980 --> 00:34:42,289
所以有些事情保持
介意師。

667
00:34:42,289 --> 00:34:46,282

668
00:34:46,282 --> 00:34:48,880
我會受不了。

669
00:34:48,880 --> 00:34:51,315
如此宣布初始化的答案。

670
00:34:51,315 --> 00:34:54,670
所以，我們說浮動答案
等於1除以10。

671
00:34:54,670 --> 00:34:57,500
打印答案到小數點後兩位。

672
00:34:57,500 --> 00:35:02,180
>> 這就是這種東西，我
將男人的printf弄清楚，

673
00:35:02,180 --> 00:35:05,110
這到底是什麼％，網點，2F是什麼意思？

674
00:35:05,110 --> 00:35:07,930
而這只是意味著，好吧，
無視0.2。

675
00:35:07,930 --> 00:35:10,420
和％f是用什麼
打印浮動。

676
00:35:10,420 --> 00:35:15,370
0.2是說，複印件
浮到小數點後兩位。

677
00:35:15,370 --> 00:35:19,600
所以這個程序有一個bug，你可能會
已經在一些見過這個

678
00:35:19,600 --> 00:35:20,870
前政務司司長課程。

679
00:35:20,870 --> 00:35:22,170
但是，什麼是錯誤？

680
00:35:22,170 --> 00:35:23,050
>> 揚聲器5：零。

681
00:35:23,050 --> 00:35:24,130
>> 羅伯：是啊。

682
00:35:24,130 --> 00:35:29,630
所以，當我們說，答案等於
1除以10，我們想要的

683
00:35:29,630 --> 00:35:31,610
回答是0.1。

684
00:35:31,610 --> 00:35:37,450
但1除以10，圖1是
整數，10是一個整數。

685
00:35:37,450 --> 00:35:41,060
所以當我們做一個整數除以
一個整數，我們要拿回

686
00:35:41,060 --> 00:35:42,190
的整數。

687
00:35:42,190 --> 00:35:43,660
因此，1除以10是0.1。

688
00:35:43,660 --> 00:35:46,760
>> 因為它需要給我們一個整數，
它只是要扔掉

689
00:35:46,760 --> 00:35:49,410
小數位，說
答案是0。

690
00:35:49,410 --> 00:35:55,314
所以當我們打印的答案，
這將打印0.00。

691
00:35:55,314 --> 00:35:58,430
>> 約瑟夫：而且，正如一個音符，它實際上
扔掉什麼後

692
00:35:58,430 --> 00:35:59,390
小數點。

693
00:35:59,390 --> 00:36:03,180
所以，如果你不是有6除以10，
你可能會認為它會給你

694
00:36:03,180 --> 00:36:05,200
0.6，然後你會四捨五入到1。

695
00:36:05,200 --> 00:36:10,520
但實際上，當輸入發生了什麼
任務，那就是它滴是什麼

696
00:36:10,520 --> 00:36:11,470
小數點後。

697
00:36:11,470 --> 00:36:13,020
所以0.6也變為0。

698
00:36:13,020 --> 00:36:13,370
>> 羅伯：是啊。

699
00:36:13,370 --> 00:36:15,160
我們會說截斷了點。

700
00:36:15,160 --> 00:36:21,760
所以每當你強制轉換為int，
小數將被截斷。

701
00:36:21,760 --> 00:36:23,980
因此，對於該修復 - 有
其實是兩個。

702
00:36:23,980 --> 00:36:27,890
而我要做的那一秒，因為
這個是一個很容易修復。

703
00:36:27,890 --> 00:36:32,670
>> 因此，一個解決辦法是使用浮點數
在分裂。

704
00:36:32,670 --> 00:36:34,720
真的，你只需要
讓其中一人的持股量。

705
00:36:34,720 --> 00:36:37,400
但它的有些只是更清晰
讓他們都浮在水上。

706
00:36:37,400 --> 00:36:41,170
因此，1.0除以10.0是
劃分兩個浮點數。

707
00:36:41,170 --> 00:36:43,970
因此，答案最終會被
一個浮點數，所以你會

708
00:36:43,970 --> 00:36:48,050
正確打印0.10這裡。

709
00:36:48,050 --> 00:36:52,220
>> 一些不工作這麼好
大約也就是，嗯，當然，這是很容易

710
00:36:52,220 --> 00:36:56,240
夠轉換1至
通過使1.0浮動。

711
00:36:56,240 --> 00:37:02,180
但是，如果不是我們有兩個整數
如int x等於1和詮釋y

712
00:37:02,180 --> 00:37:05,660
等於10，然後我們想
以做X除以Y'

713
00:37:05,660 --> 00:37:10,420
因此它是不容易的剛
做X.0什麼的。

714
00:37:10,420 --> 00:37:12,790
>> 所以要修復被鑄造。

715
00:37:12,790 --> 00:37:19,780
所以鑄件是用C來轉換方式
從1變到另一種。

716
00:37:19,780 --> 00:37:22,320
因此，這裡，圖1是一個整數。

717
00:37:22,320 --> 00:37:27,050
並把這個浮在眼前
它，我們是鑄造1為float。

718
00:37:27,050 --> 00:37:30,350
所以這將轉換
在1至1.0。

719
00:37:30,350 --> 00:37:33,380
這將轉換
在10至10.0。

720
00:37:33,380 --> 00:37:36,790
>> 然後事情的行為類似於
我們只是表明以前的版本

721
00:37:36,790 --> 00:37:42,190
其中，符合市場預期，我們得到0.10
它會打印。

722
00:37:42,190 --> 00:37:44,120
我們可以做到這一點
變量，也。

723
00:37:44,120 --> 00:37:47,376
所以我們可以說，浮x
通過浮動Ÿ分。

724
00:37:47,376 --> 00:37:48,626
>> 約瑟夫：有問題嗎？

725
00:37:48,626 --> 00:37:54,182

726
00:37:54,182 --> 00:38:00,090
>> 羅伯：所以，就像在常規的數學，
我們有運算符優先級。

727
00:38:00,090 --> 00:38:06,960
因此，在數學課上，你就更有可能
調用它的操作順序。

728
00:38:06,960 --> 00:38:09,890
在這裡，官方用語是
運算符優先級。

729
00:38:09,890 --> 00:38:15,230
但是，運算符優先級，或最
運營商，是你所期望的。

730
00:38:15,230 --> 00:38:22,660
>> 所以，就像在數學，2次10
將要超過密切分組

731
00:38:22,660 --> 00:38:25,410
這10除以2，然後2。

732
00:38:25,410 --> 00:38:29,745
操作的順序，它會做2
次10，10除以2，然後

733
00:38:29,745 --> 00:38:32,720
它會做20加5加2。

734
00:38:32,720 --> 00:38:37,020
所以它的預期效果，您可以使用
括號把表達式分組。

735
00:38:37,020 --> 00:38:41,063
你不能使用方括號
分組表達式。

736
00:38:41,063 --> 00:38:41,544
是嗎？

737
00:38:41,544 --> 00:38:43,468
>> 你居然能：喇叭5
只是回去一下嗎？

738
00:38:43,468 --> 00:38:47,316
你可以投一個int為字符串？

739
00:38:47,316 --> 00:38:53,330
>> 羅伯：那麼在C中，你可以投什麼
你要你想要的任何東西。

740
00:38:53,330 --> 00:38:55,600
這並不意味著它是
一個好的事情。

741
00:38:55,600 --> 00:38:59,760
所以，當你施放一個int到
一個字符串，即表示 - 

742
00:38:59,760 --> 00:39:03,240
我們將進入這個
更徹底 - 

743
00:39:03,240 --> 00:39:03,720
>> 約瑟夫：晚得多。

744
00:39:03,720 --> 00:39:06,840
>> 羅伯：我不想很久以後說，
所以我試圖改變我的句子。

745
00:39:06,840 --> 00:39:13,370
我們將進入它更徹底
以後如果真的是當你有一個

746
00:39:13,370 --> 00:39:14,810
字符串變量 - 

747
00:39:14,810 --> 00:39:17,160
所以一個字符串可以是任意
長，對不對？

748
00:39:17,160 --> 00:39:21,850
我們一直在說，一個int
四個字節和long long是八

749
00:39:21,850 --> 00:39:23,620
字節和浮子是4個字節。

750
00:39:23,620 --> 00:39:29,520
所以一個字符串，就像一個int，只有
一定數目的字節到它的。

751
00:39:29,520 --> 00:39:31,800
而這將是四個字節。

752
00:39:31,800 --> 00:39:34,750
>> 但一個字符串可以很
任意長，對不對？

753
00:39:34,750 --> 00:39:40,190
等你好了世界上已經，如果這是10
字符或什麼的，這已經

754
00:39:40,190 --> 00:39:42,670
將要在4個字節
我可以放入一個字符串。

755
00:39:42,670 --> 00:39:51,140
所以如何將字符串真正的工作是，
他們是在內存中的字符串

756
00:39:51,140 --> 00:39:52,380
被保留。

757
00:39:52,380 --> 00:39:57,290
>> 所以在這裡，當我說串X
等於的hello world，X裡面是

758
00:39:57,290 --> 00:40:01,840
只是說，哦，你好，世界存儲
在內存中這個特殊的地方。

759
00:40:01,840 --> 00:40:07,060
因此，如果我們嘗試將整數轉換為
字符串，然後我們試圖解讀

760
00:40:07,060 --> 00:40:10,500
內存部分隨機部分
作為一個字符串。

761
00:40:10,500 --> 00:40:14,465
而且幾乎總是打破的東西。

762
00:40:14,465 --> 00:40:17,040
>> 約瑟夫：但是，如果，混淆
您，我們將覆蓋它

763
00:40:17,040 --> 00:40:17,550
更深入的後面。

764
00:40:17,550 --> 00:40:17,850
>> 羅伯：是啊。

765
00:40:17,850 --> 00:40:20,540
這就是你要去的地方
進入指針。

766
00:40:20,540 --> 00:40:25,485
那就是顯著塊
二週課程的。

767
00:40:25,485 --> 00:40:28,275
>> 揚聲器6：它的工作狀物體
在其他語言或不是真的？

768
00:40:28,275 --> 00:40:34,050
>> 羅伯：那麼在其他語言中，對象
會使用指針來表示。

769
00:40:34,050 --> 00:40:37,070

770
00:40:37,070 --> 00:40:38,793
這是不一樣的東西，雖然。

771
00:40:38,793 --> 00:40:42,110

772
00:40:42,110 --> 00:40:42,910
有什麼想法？

773
00:40:42,910 --> 00:40:43,760
>> 約瑟夫：號

774
00:40:43,760 --> 00:40:44,185
沒有思想。

775
00:40:44,185 --> 00:40:44,980
>> 羅伯：確定。

776
00:40:44,980 --> 00:40:46,994
>> 約瑟夫：下一步。

777
00:40:46,994 --> 00:40:48,255
>> 羅伯：剛去這一點。

778
00:40:48,255 --> 00:40:48,670
好的。

779
00:40:48,670 --> 00:40:51,120
所以模。

780
00:40:51,120 --> 00:40:53,900
就像我們有加，減，
分裂和繁殖。

781
00:40:53,900 --> 00:40:56,720
所以模是一個你可以
以前沒看過。

782
00:40:56,720 --> 00:40:59,540
它只是說，給
的我的其餘部分。

783
00:40:59,540 --> 00:41:02,850
所以55％10。

784
00:41:02,850 --> 00:41:06,840
在做55的餘數
由10將是5。

785
00:41:06,840 --> 00:41:09,630
所以55％10 5。

786
00:41:09,630 --> 00:41:12,260
和3％5是3。

787
00:41:12,260 --> 00:41:14,180
8％8將0。

788
00:41:14,180 --> 00:41:15,903
16％15將是1。

789
00:41:15,903 --> 00:41:20,670
>> 約瑟夫：有一點要注意這一點，
也就是它如預期可能無法正常工作

790
00:41:20,670 --> 00:41:22,700
如果你使用一個負數。

791
00:41:22,700 --> 00:41:26,215
因此，負5％​​4，有些人
可能會認為那就是 - 

792
00:41:26,215 --> 00:41:28,890

793
00:41:28,890 --> 00:41:33,808
你會怎麼想負
5％4會是什麼？

794
00:41:33,808 --> 00:41:34,792
>> 揚聲器5：一。

795
00:41:34,792 --> 00:41:37,920
>> 喬瑟夫：所以有些人說的，
有人說消極的。

796
00:41:37,920 --> 00:41:38,450
但是 - 

797
00:41:38,450 --> 00:41:40,820
>> 羅伯：我什至不會有
說其中的一個。

798
00:41:40,820 --> 00:41:42,370
>> 約瑟夫：二，對不起。

799
00:41:42,370 --> 00:41:43,240
有人說 - 

800
00:41:43,240 --> 00:41:43,450
>> 羅伯：三。

801
00:41:43,450 --> 00:41:43,800
>> 約瑟夫：三？

802
00:41:43,800 --> 00:41:44,890
>> 羅伯：負 - 

803
00:41:44,890 --> 00:41:45,950
究竟是什麼 - 負5  - 

804
00:41:45,950 --> 00:41:47,100
>> 約瑟夫：三，三，三。

805
00:41:47,100 --> 00:41:48,450
抱歉。

806
00:41:48,450 --> 00:41:51,910
因為模，通常，當你已經
看到它在其他地方，這通常意味著

807
00:41:51,910 --> 00:41:54,000
返回一個正數，對不對？

808
00:41:54,000 --> 00:42:01,160
>> 羅伯：所以當我們說數學，10％的，
他們往往想給你 - 

809
00:42:01,160 --> 00:42:05,980
如果我們國防部10，那麼我們預期
得到0到9之間的數字。

810
00:42:05,980 --> 00:42:09,860
在這裡，這不是這種情況，你
將得到負數返回。

811
00:42:09,860 --> 00:42:15,898
>> 喬瑟夫：所以負5％
4將是負1。

812
00:42:15,898 --> 00:42:19,325
>> 羅伯：但它是罕見的，你是MOD-ING
負數開始。

813
00:42:19,325 --> 00:42:25,490

814
00:42:25,490 --> 00:42:25,970
跳過此。

815
00:42:25,970 --> 00:42:27,314
>> 約瑟夫：是啊。

816
00:42:27,314 --> 00:42:29,420
>> 羅伯：MEH。

817
00:42:29,420 --> 00:42:29,990
確定。

818
00:42:29,990 --> 00:42:36,400
所以最後一件事要指出有關
彩車是它是一個危險的行為，

819
00:42:36,400 --> 00:42:39,850
但花車是不是一個確切的
表示。

820
00:42:39,850 --> 00:42:46,190
所以回到字節一遍，記住
那一個int總是有四個字節，一個

821
00:42:46,190 --> 00:42:47,830
浮總是四個字節。

822
00:42:47,830 --> 00:42:51,340
所以盧卡斯的例子是相當不錯的。

823
00:42:51,340 --> 00:42:55,730
>> 因此，認為1除以3。

824
00:42:55,730 --> 00:42:57,800
所以0.3333333。

825
00:42:57,800 --> 00:43:03,540
如果我只有32位，怎麼能
我保存0.33333到底是什麼？

826
00:43:03,540 --> 00:43:07,250
也許，不管什麼原因，你說，
好吧，好吧，讓我們只說

827
00:43:07,250 --> 00:43:13,210
這個特殊的1011001，讓我們
只是說，應該是0.333333。

828
00:43:13,210 --> 00:43:16,960
那麼，你只有有限數量的
這些位，所以這是不可能的

829
00:43:16,960 --> 00:43:22,550
代表每一個浮點
鑑於只有32位值。

830
00:43:22,550 --> 00:43:25,580
>> 嗯，這是不可能代表任何
浮點值給出無限 - 

831
00:43:25,580 --> 00:43:28,480
還有，由於位中的任何數量有限。

832
00:43:28,480 --> 00:43:38,265
因此，這裡的問題是，好了，當我們用
打印到小數點後兩位，

833
00:43:38,265 --> 00:43:42,000
我們沒有得到正確的答案0.10。

834
00:43:42,000 --> 00:43:47,510
但引擎蓋下，它是真正
被存儲盡可能接近到

835
00:43:47,510 --> 00:43:51,790
0.10那些位可以代表。

836
00:43:51,790 --> 00:43:53,200
這是對下一張幻燈片？

837
00:43:53,200 --> 00:43:53,830
或者，是不是？

838
00:43:53,830 --> 00:43:54,660
>> 約瑟夫：是啊，就是這樣。

839
00:43:54,660 --> 00:43:55,750
>> 羅伯：Blegh，blegh。

840
00:43:55,750 --> 00:43:57,760
>> 約瑟夫：是啊，你可以只
拉筆記了一下。

841
00:43:57,760 --> 00:43:59,700
>> 羅伯：我只是要放大
中的最後一個上。

842
00:43:59,700 --> 00:44:00,950
哦，我的天哪，這是[聽不清]。

843
00:44:00,950 --> 00:44:06,089

844
00:44:06,089 --> 00:44:08,300
使數。

845
00:44:08,300 --> 00:44:12,300
這就是將要打印
如果我們運行該程序。

846
00:44:12,300 --> 00:44:20,340
並請注意，這不是一個真正的大問題
如果我們只關心像

847
00:44:20,340 --> 00:44:21,920
兩到三個小數位。

848
00:44:21,920 --> 00:44:26,700
像我們最初只印刷0.10，
這就是為什麼我們看到什麼不對。

849
00:44:26,700 --> 00:44:31,380
但是，一旦我們開始漸入
確切的說，確切的數字，它是

850
00:44:31,380 --> 00:44:35,660
代表，我們看到，它不能
完全代表0.1。

851
00:44:35,660 --> 00:44:40,900
>> 在這裡，問題的一部分是喜歡，
沒事，這很好，但是，好吧，

852
00:44:40,900 --> 00:44:46,120
首先，如果我們試圖做的，
答案等於等於0.1？

853
00:44:46,120 --> 00:44:49,200
是要返回true或false？

854
00:44:49,200 --> 00:44:51,850
因此，這很難說。

855
00:44:51,850 --> 00:44:53,330
我認為它實際上可能返回true。

856
00:44:53,330 --> 00:44:55,265
它會先 - 

857
00:44:55,265 --> 00:44:56,180
我不知道。

858
00:44:56,180 --> 00:45:00,090
答案是，一旦你開始處理
與浮點值，你漂亮

859
00:45:00,090 --> 00:45:05,150
很多不應該使用相等
因為這種不精確性。

860
00:45:05,150 --> 00:45:09,470
>> 而對於所有你知道，它的百
小數位的

861
00:45:09,470 --> 00:45:13,670
浮點無法
正確處理。

862
00:45:13,670 --> 00:45:18,180
所以平等只會失敗，甚至
雖然數 - 如果你已經

863
00:45:18,180 --> 00:45:24,450
用確切的數字，該數字應
已經完全一樣。

864
00:45:24,450 --> 00:45:27,790
一切都結束了的像50的過程
使用這些浮動的計算

865
00:45:27,790 --> 00:45:30,270
點值，誤差可以建立
起來，起來，起來，

866
00:45:30,270 --> 00:45:31,125
事情就出錯。

867
00:45:31,125 --> 00:45:33,870
>> 約瑟夫：還有一直很
這種情況發生的著名的例子。

868
00:45:33,870 --> 00:45:37,190
像美國航空航天局的工程師們獲得這樣的
錯了，造成火箭爆炸的

869
00:45:37,190 --> 00:45:38,665
他們已經發動後的空氣。

870
00:45:38,665 --> 00:45:41,490
和很多類似的問題。

871
00:45:41,490 --> 00:45:41,956
所以，是的。

872
00:45:41,956 --> 00:45:45,218
>> 揚聲器6：當你說0.3樓
它截斷的休息嗎？

873
00:45:45,218 --> 00:45:46,468
抑或是一輪上漲或下跌？

874
00:45:46,468 --> 00:45:48,800

875
00:45:48,800 --> 00:45:50,200
>> 羅伯：請問printf的圓嗎？

876
00:45:50,200 --> 00:45:52,180
>> 約瑟夫：我認為printf的截斷。

877
00:45:52,180 --> 00:45:52,640
>> 羅伯：確定。

878
00:45:52,640 --> 00:45:59,890
所以，我們同樣可以走向反面
這其中的方向，在這種情況下，

879
00:45:59,890 --> 00:46:03,320
它可以代表最接近
0.1是用這個號碼。

880
00:46:03,320 --> 00:46:06,820
它或許能在最接近
表示0.2是在相反的

881
00:46:06,820 --> 00:46:11,420
方向，0.199999996356
什麼的。

882
00:46:11,420 --> 00:46:17,480
所以，如果我們去的那個方向
的東西，然後printf的0.3 F.將返回

883
00:46:17,480 --> 00:46:20,866
1.99，而不是2.00。

884
00:46:20,866 --> 00:46:22,960
>> 約瑟夫：我也完全不
確定這一點。

885
00:46:22,960 --> 00:46:25,430
你可能想要寫一個小的，小
程序只是檢查。

886
00:46:25,430 --> 00:46:29,370
>> 羅伯：雖然，我們所肯定的是，
如果你試圖強制轉換成一個

887
00:46:29,370 --> 00:46:33,660
int和鑄造為int是要
導致它截斷小數，如果

888
00:46:33,660 --> 00:46:38,140
您嘗試轉換1.9999999
為int，您將獲得1。

889
00:46:38,140 --> 00:46:41,440
所以你通常應該使用
輪函數的數學函數庫。

890
00:46:41,440 --> 00:46:44,190

891
00:46:44,190 --> 00:46:45,440
有問題嗎？

892
00:46:45,440 --> 00:46:47,660

893
00:46:47,660 --> 00:46:48,982
確定。

894
00:46:48,982 --> 00:46:54,000
>> 喬瑟夫：所以，移動到條件
和布爾表達式。

895
00:46:54,000 --> 00:46:58,120
所以，你以前見過這些。

896
00:46:58,120 --> 00:47:07,420
而實際上，讓我確保我
電腦是正確的格式在這裡。

897
00:47:07,420 --> 00:47:08,670
空間。

898
00:47:08,670 --> 00:47:10,630

899
00:47:10,630 --> 00:47:13,870
對不起，我們將不得不面對一個
與截止點點的邊緣。

900
00:47:13,870 --> 00:47:15,830
>> 但是，是的，你們已經看到
這之前，在划痕。

901
00:47:15,830 --> 00:47:19,930
所以這裡這個權利是一個表達式
這是用來在

902
00:47:19,930 --> 00:47:21,250
一個條件語句。

903
00:47:21,250 --> 00:47:23,930
所以回答大於零的意志
告訴你，真或假。

904
00:47:23,930 --> 00:47:26,530
這些都是非常重要的，因為
他們允許我們介紹

905
00:47:26,530 --> 00:47:28,670
邏輯到我們的代碼。

906
00:47:28,670 --> 00:47:32,820
>> 因此，例如，這是一個程序
寫在刮，要求用戶

907
00:47:32,820 --> 00:47:36,980
為一個整數，並告訴他們是否
整數，他們給你是一個

908
00:47:36,980 --> 00:47:38,690
正數或負數。

909
00:47:38,690 --> 00:47:42,980
和轉換在這裡看到的是
你先打印出報表，

910
00:47:42,980 --> 00:47:43,870
給我一個整數。

911
00:47:43,870 --> 00:47:45,980
然後你問他們一個整數。

912
00:47:45,980 --> 00:47:49,870
>> 然後使用條件邏輯在
在這裡，檢查該號碼是否

913
00:47:49,870 --> 00:47:52,030
實際上比為零或不大於。

914
00:47:52,030 --> 00:47:58,960
所以在這裡，我們有一個布爾表達式
裡面的條件If語句。

915
00:47:58,960 --> 00:48:00,660
有什麼問題嗎？

916
00:48:00,660 --> 00:48:03,030
是否有關於什麼問題嗎？

917
00:48:03,030 --> 00:48:03,950
確定。

918
00:48:03,950 --> 00:48:06,140
>> 因此，有不止
比，當然，更大。

919
00:48:06,140 --> 00:48:10,385
你可以構造布爾表達式
使用大多數的各種各樣的事情你

920
00:48:10,385 --> 00:48:11,150
會想到數學。

921
00:48:11,150 --> 00:48:12,370
因此大於。

922
00:48:12,370 --> 00:48:13,740
這應該是一個小於。

923
00:48:13,740 --> 00:48:14,990
抱歉。

924
00:48:14,990 --> 00:48:18,520

925
00:48:18,520 --> 00:48:19,760
和間距。

926
00:48:19,760 --> 00:48:22,971
>> 羅伯：上帝保佑你離開它。

927
00:48:22,971 --> 00:48:23,620
>> 約瑟夫：好吧。

928
00:48:23,620 --> 00:48:25,950
這樣比，小於，大於更大
大於或等於，小於

929
00:48:25,950 --> 00:48:27,070
大於或等於。

930
00:48:27,070 --> 00:48:31,980
我們使用雙等號檢查
平等，因為單等於手段

931
00:48:31,980 --> 00:48:32,810
分配，對不對？

932
00:48:32,810 --> 00:48:33,140
是。

933
00:48:33,140 --> 00:48:37,130
然後我們也可以不等於由
使用感嘆號，等於。

934
00:48:37,130 --> 00:48:41,530
>> 而這個感嘆號符號可以
也可以擴展，這樣，如果你​​想

935
00:48:41,530 --> 00:48:44,050
顛倒任何形式的布爾
表達式，你可以做到這一點。

936
00:48:44,050 --> 00:48:48,530
因此，這將評估為true
只有當回答為少

937
00:48:48,530 --> 00:48:51,240
大於或等於零。

938
00:48:51,240 --> 00:48:53,950
上有問題嗎？

939
00:48:53,950 --> 00:48:55,180
確定。

940
00:48:55,180 --> 00:48:58,840
>> 所以，你也可以將這些
使用邏輯與和表達式

941
00:48:58,840 --> 00:48:59,790
邏輯或。

942
00:48:59,790 --> 00:49:03,530
所以，這只是和符號，
這應該是平移，7。

943
00:49:03,530 --> 00:49:07,720
這是管道符號，這是
不是小寫L.這是一個

944
00:49:07,720 --> 00:49:09,440
這是正確的上方的Enter鍵。

945
00:49:09,440 --> 00:49:12,870
所以你使用其中的兩個象徵
邏輯的邏輯或。

946
00:49:12,870 --> 00:49:18,180
>> 因此，這將只返回true，如果答案
是一個，兩個，三個或四個。

947
00:49:18,180 --> 00:49:23,030
這將只返回true，如果答案
超出該兩側。

948
00:49:23,030 --> 00:49:26,190
所以它不是一個，兩個，三個或四個。

949
00:49:26,190 --> 00:49:28,385
並且你會使用的方式
在一個表達式 - 

950
00:49:28,385 --> 00:49:29,990
>> 羅伯：或零或五。

951
00:49:29,990 --> 00:49:32,200
>> 約瑟夫：零或五。

952
00:49:32,200 --> 00:49:32,380
抱歉。

953
00:49:32,380 --> 00:49:33,320
是的，是的，是的。

954
00:49:33,320 --> 00:49:34,180
確定。

955
00:49:34,180 --> 00:49:38,980
而在這裡現在，同樣的方式，你
將使用該表達式，一個較小的

956
00:49:38,980 --> 00:49:42,000
的如果條件表達式側
聲明中，你也會使用它

957
00:49:42,000 --> 00:49:47,800
同樣的方式通過只把它的內部
If語句的括號中。

958
00:49:47,800 --> 00:49:54,020
因此，這將printf的只有火，如果答案
是一個，兩個，三個或四個。

959
00:49:54,020 --> 00:49:56,002
結合上有任何問題
表達式？

960
00:49:56,002 --> 00:50:00,450

961
00:50:00,450 --> 00:50:04,240
>> 因此，有另一個條件
構建體，我們稱之為一個if / else語句。

962
00:50:04,240 --> 00:50:08,120
所以基本上，這意味著現在好不好，如果
我想要的東西，檢查是不是

963
00:50:08,120 --> 00:50:11,600
真的，然後去Else和
執行其他動作。

964
00:50:11,600 --> 00:50:15,570
因此，在這種特殊情況下，我問
用戶的一個整數。

965
00:50:15,570 --> 00:50:17,790
是大於零的整數？

966
00:50:17,790 --> 00:50:18,310
是嗎？

967
00:50:18,310 --> 00:50:20,100
好吧，那麼他們選
一個正數。

968
00:50:20,100 --> 00:50:22,320
如果沒有，那麼它必須有
是負或零。

969
00:50:22,320 --> 00:50:27,530
所以，你選擇了一個負數
或者在此情況下為零。

970
00:50:27,530 --> 00:50:29,235
是。

971
00:50:29,235 --> 00:50:30,485
或零。

972
00:50:30,485 --> 00:50:36,320

973
00:50:36,320 --> 00:50:39,300
>> 然後我們也有if / else語句，
如果和其他人。

974
00:50:39,300 --> 00:50:45,640
因此，這可以讓我們執行的順序
事情只有首當其衝失敗。

975
00:50:45,640 --> 00:50:49,540
因此，在這種情況下，我們現在正在做的
最後一個你挑為零。

976
00:50:49,540 --> 00:50:53,080
所以，如果他們既不挑了積極的，也不
一個負數，那麼他們必須

977
00:50:53,080 --> 00:50:53,640
紛紛拿起為零。

978
00:50:53,640 --> 00:50:56,720
因此，它只是下降的
鏈條是這樣的。

979
00:50:56,720 --> 00:50:59,960
>> 如何在這樣一個例子
如果是從不同的 - 

980
00:50:59,960 --> 00:51:02,590
一個if / else語句是不同的
只是一個序列IFS的。

981
00:51:02,590 --> 00:51:07,680
這是一個常見的問題，
人們問的是，好吧，如果你得到一個像

982
00:51:07,680 --> 00:51:11,265
95 CS50，又會此
程序告訴你嗎？

983
00:51:11,265 --> 00:51:12,600
>> 揚聲器5：你有一個A。

984
00:51:12,600 --> 00:51:13,490
>> 約瑟夫：是的。

985
00:51:13,490 --> 00:51:14,960
你得到的每一個
其中的一個權利。

986
00:51:14,960 --> 00:51:17,130
你有一個A，你有一個B，你
得到了一個C和D，對不對？

987
00:51:17,130 --> 00:51:19,770
因此，所有這些得到評估
為了。

988
00:51:19,770 --> 00:51:23,570
因此，雖然95大於90，它的
比80也更大，這也是

989
00:51:23,570 --> 00:51:25,790
大於70，它的
也大於60。

990
00:51:25,790 --> 00:51:27,620
所以，你得到了所有這些成績的。

991
00:51:27,620 --> 00:51:31,630
我相信，你會
只希望A。

992
00:51:31,630 --> 00:51:34,060
>> 要解決這一問題的方法是更換
那些否則/如果的。

993
00:51:34,060 --> 00:51:37,540
所以在這種情況下，它看到的是95
大於90，然後它

994
00:51:37,540 --> 00:51:38,885
不評價其他地區
的語句。

995
00:51:38,885 --> 00:51:41,900

996
00:51:41,900 --> 00:51:43,150
關於什麼問題嗎？

997
00:51:43,150 --> 00:51:48,580

998
00:51:48,580 --> 00:51:52,470
>> 因此，有另一個條件排序
結構，我們在這裡，我們

999
00:51:52,470 --> 00:51:53,390
調用一個switch語句。

1000
00:51:53,390 --> 00:51:57,390
因此，這可以讓你基本檢查
怎樣的一個數字，你把價值

1001
00:51:57,390 --> 00:51:59,000
進入switch語句。

1002
00:51:59,000 --> 00:52:03,200
所以在這種情況下，我們切換
於n，和我們說，哦，如果n為

1003
00:52:03,200 --> 00:52:04,710
一個，然後打印該報表。

1004
00:52:04,710 --> 00:52:07,910
再突破，這意味著退出
出了switch語句。

1005
00:52:07,910 --> 00:52:12,670
>> 如果它不是一個，那麼，很好，只是
最後檢查所有的這些情況。

1006
00:52:12,670 --> 00:52:16,280
所以它會檢查是否它的一個或兩個或
三，它打印相應。

1007
00:52:16,280 --> 00:52:19,780
什麼這個默認的關鍵字到這裡
方法是，如果他們沒有進入任何

1008
00:52:19,780 --> 00:52:21,690
那些，然後說無效。

1009
00:52:21,690 --> 00:52:25,910
因此，讓我們說，我問n和
用戶給我四。

1010
00:52:25,910 --> 00:52:29,470
那麼，它沒有匹配的那些情況下，
所以它會打印出什麼在

1011
00:52:29,470 --> 00:52:30,540
默認段。

1012
00:52:30,540 --> 00:52:31,180
是的，質疑？

1013
00:52:31,180 --> 00:52:32,614
>> 揚聲器5：你可以使用布爾
表達式代替

1014
00:52:32,614 --> 00:52:33,570
一個，兩個，或三個？

1015
00:52:33,570 --> 00:52:36,940
>> 喬瑟夫：所以，問題是你能使用
布爾表達式，而不是一個，

1016
00:52:36,940 --> 00:52:37,940
二，三？

1017
00:52:37,940 --> 00:52:40,520
而在C中，我相信你
不能做到這一點。

1018
00:52:40,520 --> 00:52:44,320
但在其他語言中，你可能會
在遇到的結束

1019
00:52:44,320 --> 00:52:46,460
學期如JavaScript，你可以。

1020
00:52:46,460 --> 00:52:50,050
那麼，你就必須先計算
該值，然後使用它在

1021
00:52:50,050 --> 00:52:50,650
switch語句。

1022
00:52:50,650 --> 00:52:50,930
是嗎？

1023
00:52:50,930 --> 00:52:54,760
>> 羅伯：開關部分的利益所以
報表是想，如果你這樣做

1024
00:52:54,760 --> 00:52:58,680
作為一個if / else語句，所以如果n等於像
等於一個或什麼的。

1025
00:52:58,680 --> 00:53:00,300
其他/如果n等於等於二，什麼的。

1026
00:53:00,300 --> 00:53:01,960
其他/如果n等於等於三。

1027
00:53:01,960 --> 00:53:05,930
這樣的方式，程序將運行的是它
會按順序往下走的列表

1028
00:53:05,930 --> 00:53:07,500
並檢查是N嗎？

1029
00:53:07,500 --> 00:53:08,040
不。

1030
00:53:08,040 --> 00:53:09,070
為n 2？

1031
00:53:09,070 --> 00:53:09,490
不。

1032
00:53:09,490 --> 00:53:10,940
為n 3？

1033
00:53:10,940 --> 00:53:11,710
是啊。

1034
00:53:11,710 --> 00:53:12,610
做到這一點。

1035
00:53:12,610 --> 00:53:15,270
>> 而用switch語句，它的
居然能夠編譯它是

1036
00:53:15,270 --> 00:53:16,360
真快。

1037
00:53:16,360 --> 00:53:19,550
而一旦它說開關，它
說，沒事，n為2時，我

1038
00:53:19,550 --> 00:53:23,060
馬上要跳的地方
我應該開始執行。

1039
00:53:23,060 --> 00:53:26,080
我不會先檢查，
為n之一，N雙？

1040
00:53:26,080 --> 00:53:28,860
它可以立即開始做
什麼是應該做的。

1041
00:53:28,860 --> 00:53:33,830
>> 正因為如此，它不能
採取布爾條件。

1042
00:53:33,830 --> 00:53:36,480
否則將不得不這樣做的
順序一樣，所有的權利，為n

1043
00:53:36,480 --> 00:53:37,820
大於零？

1044
00:53:37,820 --> 00:53:41,140
否則為n大於10或任何更高。

1045
00:53:41,140 --> 00:53:44,780
>> 約瑟夫：在這種情況下，如果你使用
if / else語句，如果的，則開關會

1046
00:53:44,780 --> 00:53:47,792
運行約3倍
比的if / else，如果速度更快。

1047
00:53:47,792 --> 00:53:53,060

1048
00:53:53,060 --> 00:53:56,040
我們可以組織開關在這樣的
我們不分手的方式

1049
00:53:56,040 --> 00:53:57,520
之後每個案件。

1050
00:53:57,520 --> 00:54:00,960
因此，在這種情況下，我分隔
我們選擇到一個和數字

1051
00:54:00,960 --> 00:54:04,250
兩個是不高的數字和
三位的是大量的。

1052
00:54:04,250 --> 00:54:08,290
>> 因此，在這種情況下，如果n是1或2，它
會打的情況下，然後它會

1053
00:54:08,290 --> 00:54:10,640
告吹，因為
沒有休息。

1054
00:54:10,640 --> 00:54:11,610
它會在這裡結束。

1055
00:54:11,610 --> 00:54:15,360
因此，如果我們挑一個，它會做的printf
然後突破，這樣的無

1056
00:54:15,360 --> 00:54:17,610
這被執行。

1057
00:54:17,610 --> 00:54:21,870
當然，如果他們在三個進入
還是其他什麼東西，然後它會跳過

1058
00:54:21,870 --> 00:54:25,320
這些，而不是去那裡，它
將執行的，而不是

1059
00:54:25,320 --> 00:54:27,490
相應的行。

1060
00:54:27,490 --> 00:54:29,390
是否有關於什麼問題嗎？

1061
00:54:29,390 --> 00:54:29,780
是嗎？

1062
00:54:29,780 --> 00:54:32,642
>> 揚聲器4：你會得到一個錯誤，如果你
有情況下，一前一後休息，但它

1063
00:54:32,642 --> 00:54:34,550
沒有東西給它做？

1064
00:54:34,550 --> 00:54:37,820
>> 喬瑟夫：所以，問題是，你會得到
一個錯誤，如果你有後休息

1065
00:54:37,820 --> 00:54:39,730
案例一但有什麼可以做？

1066
00:54:39,730 --> 00:54:41,520
答案是否定的。

1067
00:54:41,520 --> 00:54:43,172
你不會真正得到一個錯誤。

1068
00:54:43,172 --> 00:54:44,590
是啊，毫米嗯。

1069
00:54:44,590 --> 00:54:54,540
>> 作為排序的那麼一點點這裡的變化，
我打算把一個printf這裡。

1070
00:54:54,540 --> 00:54:55,790
哎呦。

1071
00:54:55,790 --> 00:55:00,994

1072
00:55:00,994 --> 00:55:04,880
那麼，什麼會這樣，如果打印
我把一個在輸入？

1073
00:55:04,880 --> 00:55:07,530

1074
00:55:07,530 --> 00:55:07,770
是啊。

1075
00:55:07,770 --> 00:55:10,360
它會告訴你，它沒有考慮
高數的兩倍，對嗎？

1076
00:55:10,360 --> 00:55:13,500
因為它會打的第一種情況下，
它不會打破，一下子就摔倒

1077
00:55:13,500 --> 00:55:15,730
通過向所述第二殼體。

1078
00:55:15,730 --> 00:55:16,950
關於什麼問題嗎？

1079
00:55:16,950 --> 00:55:18,280
>> 羅伯：你有別的問題？

1080
00:55:18,280 --> 00:55:20,840
>> 約瑟夫：好，冷卻。

1081
00:55:20,840 --> 00:55:22,400
好的。

1082
00:55:22,400 --> 00:55:25,780
因此，有我們所說的別的東西
三元運算符這基本上是一個

1083
00:55:25,780 --> 00:55:29,010
替代語法幹嘛
如果再別的。

1084
00:55:29,010 --> 00:55:30,470
它可以讓你做這一切在同一行。

1085
00:55:30,470 --> 00:55:34,110
所以這個特定的程序中，
我問n的用戶。

1086
00:55:34,110 --> 00:55:37,190
如果n大於100時，我告訴
他們，他們選擇了一個高的數字。

1087
00:55:37,190 --> 00:55:39,560
別的我告訴他們，他們
挑一個低的數字。

1088
00:55:39,560 --> 00:55:43,030
>> 因此，我們可以用這個很長的語法，
字符串，S，然後檢查是否n是

1089
00:55:43,030 --> 00:55:45,260
大於100，並分配
它相應。

1090
00:55:45,260 --> 00:55:49,450
但是，我們可以讓這個更簡潔
通過使用這個三元運算符語法

1091
00:55:49,450 --> 00:55:52,090
其中涉及的問題
標記和一個冒號。

1092
00:55:52,090 --> 00:55:55,070
所以問號本質上是
問一個問題，對不對？

1093
00:55:55,070 --> 00:55:56,625
>> 羅伯：或許放大了。

1094
00:55:56,625 --> 00:55:57,372
>> 約瑟夫：是的。

1095
00:55:57,372 --> 00:56:00,210
好點。

1096
00:56:00,210 --> 00:56:02,550
因此，這是三元運算符。

1097
00:56:02,550 --> 00:56:06,100
我首先要問的問題，
為n大於100？

1098
00:56:06,100 --> 00:56:09,770
如果是，那麼我執行第一
冒號前的部分。

1099
00:56:09,770 --> 00:56:13,360
如果不是，那麼我執行
在冒號後面第二部分。

1100
00:56:13,360 --> 00:56:16,640
因此，如果n大於100，
然後挑選高，看跌期權

1101
00:56:16,640 --> 00:56:18,360
那到字符串s。

1102
00:56:18,360 --> 00:56:22,170
如果n小於100，它選擇低
進而提出了到字符串s。

1103
00:56:22,170 --> 00:56:30,186
因此，將這種凝結大塊
成只是一條線。

1104
00:56:30,186 --> 00:56:32,010
>> 揚聲器5：這是流行？

1105
00:56:32,010 --> 00:56:36,070
>> 約瑟夫：是的，這是很流行的
那裡基本上你要的東西

1106
00:56:36,070 --> 00:56:38,700
做基於任務
某種條件。

1107
00:56:38,700 --> 00:56:43,110
在這種情況下，我們試圖
到一個值賦給字符串s。

1108
00:56:43,110 --> 00:56:44,840
這不是那麼 - 

1109
00:56:44,840 --> 00:56:47,670
我想我真的不喜歡
但在其他情況下。

1110
00:56:47,670 --> 00:56:49,390
但它是特別有用
對於這項任務。

1111
00:56:49,390 --> 00:56:54,490
>> 羅伯：這是一個很常見的模式
在那裡你有一些變量，

1112
00:56:54,490 --> 00:56:58,200
你會說，如果事情，設置
該變量為一個值，否則，設置

1113
00:56:58,200 --> 00:56:59,810
此變量為另一個值。

1114
00:56:59,810 --> 00:57:03,360
那就是場景
其中使用三元。

1115
00:57:03,360 --> 00:57:05,220
>> 約瑟夫：你是在救
很多行，對不對？

1116
00:57:05,220 --> 00:57:08,090
它只是使你的代碼可以說是
更可讀的一點點。

1117
00:57:08,090 --> 00:57:08,635
是的，質疑？

1118
00:57:08,635 --> 00:57:12,384
>> 揚聲器6：對於三元，你能不能去，
字符串s等於S，問號？

1119
00:57:12,384 --> 00:57:15,280
然後你可以有，比方說，
五個不同的選項。

1120
00:57:15,280 --> 00:57:18,310
以及根據什麼n的數目
是，你會選擇其​​中的一個？

1121
00:57:18,310 --> 00:57:22,210
>> 喬瑟夫：所以，問題是，有沒有
排序語法，你可以做字符串

1122
00:57:22,210 --> 00:57:25,910
s等於n，並且隨後有兩個以上的
那個問號的選項？

1123
00:57:25,910 --> 00:57:29,740
而一個簡單的答案是否定的，有沒有
真是一個好辦法做到這一點，除非

1124
00:57:29,740 --> 00:57:33,850
要嵌套多個三元
彼此的內部運算符。

1125
00:57:33,850 --> 00:57:38,050
>> 你可以做如：n大於100，
問號，然後再

1126
00:57:38,050 --> 00:57:41,850
三元運算符中，n大於50，
問號，巢這種方式。

1127
00:57:41,850 --> 00:57:45,240
但在這種情況下，你的代碼是
得到一種不可讀和凌亂，

1128
00:57:45,240 --> 00:57:47,920
它可能是更好的只是去
一個if / else語句在這一點上。

1129
00:57:47,920 --> 00:57:54,530
>> 羅伯：還有，作為一​​個側面說明，PHP
不正確地實現了三元

1130
00:57:54,530 --> 00:57:58,053
運營商這樣嵌套的三元系
甚至不工作，因為他們應該。

1131
00:57:58,053 --> 00:57:58,840
>> 約瑟夫：是啊。

1132
00:57:58,840 --> 00:58:01,170
因此，它變得有點混亂，
尤其是當你去

1133
00:58:01,170 --> 00:58:02,145
以不同的語言。

1134
00:58:02,145 --> 00:58:04,810
>> 羅伯：這是迷惑，以至於
語言是錯的。

1135
00:58:04,810 --> 00:58:08,030

1136
00:58:08,030 --> 00:58:11,510
>> 喬瑟夫：所以其實只是為了澄清，
每個人都知道那是什麼

1137
00:58:11,510 --> 00:58:13,900
％s的確實在這裡？

1138
00:58:13,900 --> 00:58:15,650
關於什麼問題嗎？

1139
00:58:15,650 --> 00:58:19,760
我猜只是相機，％s的
基本上讓我們放一個佔位符

1140
00:58:19,760 --> 00:58:20,790
為一個字符串。

1141
00:58:20,790 --> 00:58:23,920
然後到了最後，我們指定的
變量，我們希望把這個

1142
00:58:23,920 --> 00:58:25,500
佔位符為s。

1143
00:58:25,500 --> 00:58:27,730
所以，基本上需要s
它把它在這裡。

1144
00:58:27,730 --> 00:58:32,130
然後它會打印出來，你挑
高或你選擇了一個低的數字。

1145
00:58:32,130 --> 00:58:33,770
確定。

1146
00:58:33,770 --> 00:58:36,970
>> 所以循環允許你執行的事情
在打圈，對不對？

1147
00:58:36,970 --> 00:58:40,300
你可能會在遇到此
在從無到有的永遠的形式循環

1148
00:58:40,300 --> 00:58:45,650
或重複，直到或重複特定的
的次數。

1149
00:58:45,650 --> 00:58:47,540
那麼，為什麼這是對我們有好處？

1150
00:58:47,540 --> 00:58:51,500
那麼，在C中，假設我們有這樣的
在刮歌實施了

1151
00:58:51,500 --> 00:58:53,450
唱歌，這是歌曲
永遠不會結束。

1152
00:58:53,450 --> 00:58:55,710
它只是和和
永遠，永遠。

1153
00:58:55,710 --> 00:58:59,395
好了，你真的不能讓一個程序
具有printf的無限數量的

1154
00:58:59,395 --> 00:59:00,850
在它的報表，對不對？

1155
00:59:00,850 --> 00:59:04,900
>> 因此，在這種特定的情況下，單程
您可以進行這項工作，

1156
00:59:04,900 --> 00:59:09,330
讓它永遠印是
而不是使用一個while循環。

1157
00:59:09,330 --> 00:59:13,640
因此，一個While循環將執行什麼
在兩個支撐體是

1158
00:59:13,640 --> 00:59:17,250
屬於它的依據是什麼
條件是。

1159
00:59:17,250 --> 00:59:21,170
因此，在這個特定的例子之前，如果
我們要永遠的打印本，有什麼

1160
00:59:21,170 --> 00:59:23,590
也許我們做什麼？

1161
00:59:23,590 --> 00:59:25,190
嗯，當然，對不對？

1162
00:59:25,190 --> 00:59:32,290
>> 所以，這樣的結合的想法
一些布爾表達式

1163
00:59:32,290 --> 00:59:33,610
隨著循環。

1164
00:59:33,610 --> 00:59:35,780
我們了解了布爾
表達式前面。

1165
00:59:35,780 --> 00:59:39,650
所以每當裡面的條件
這雖然仍是如此，這個循環

1166
00:59:39,650 --> 00:59:41,480
將執行上和和。

1167
00:59:41,480 --> 00:59:44,640
在這種情況下，如果我們只是提供了
與真實的，這將導致無限

1168
00:59:44,640 --> 00:59:49,310
循環打印出的歌曲，並在
和我們之前沒有期望

1169
00:59:49,310 --> 00:59:52,410
具有一個程序，有無限
的printf語句數目，這是

1170
00:59:52,410 --> 00:59:55,220
不可能的。

1171
00:59:55,220 --> 00:59:57,810
>> 所以更令人信服，不過，
你可以使用這個用

1172
00:59:57,810 --> 00:59:59,710
變量和條件。

1173
00:59:59,710 --> 01:00:04,420
因此，讓我們說，我們要重複的
詞組，完全充滿循環，10倍。

1174
01:00:04,420 --> 01:00:08,380
所以，你可以用一個While循環做的是
你可以先初始化一個計數器

1175
01:00:08,380 --> 01:00:10,860
變量以外的
While循環到10。

1176
01:00:10,860 --> 01:00:14,360
然後基本上，每次你走
通過While循環，打印出

1177
01:00:14,360 --> 01:00:19,090
您降低語句，然後將
計數器變量，直到在最後，

1178
01:00:19,090 --> 01:00:23,020
在某些時候，當我們減去我不夠
次，1次從我足夠的時間 - 

1179
01:00:23,020 --> 01:00:27,290
而只是為了澄清，我減減
意味著我等於I減1。

1180
01:00:27,290 --> 01:00:31,280
>> 這將基本上把我下到
點，一旦我打零，這

1181
01:00:31,280 --> 01:00:35,260
條件不再真實，
所以它退出圈外。

1182
01:00:35,260 --> 01:00:37,045
所以完全充滿循環只打印10倍。

1183
01:00:37,045 --> 01:00:39,550

1184
01:00:39,550 --> 01:00:41,080
關於While循環有問題嗎？

1185
01:00:41,080 --> 01:00:44,580

1186
01:00:44,580 --> 01:00:46,790
確定。

1187
01:00:46,790 --> 01:00:50,550
>> 因此，有一個辦法，我們可以做什麼，我們只是
在一個更簡潔的方式與做

1188
01:00:50,550 --> 01:00:51,715
我們所說的For循環。

1189
01:00:51,715 --> 01:00:55,750
因此，一個For循環由一個
初始化的狀態下，和一個

1190
01:00:55,750 --> 01:00:58,950
更新，就像我們以前有
在這個While循環。

1191
01:00:58,950 --> 01:00:59,890
因此，讓我們一起來看看。

1192
01:00:59,890 --> 01:01:02,900
在這個while循環，我們有
初始化，然後我們有一個

1193
01:01:02,900 --> 01:01:04,260
調理，我們檢查。

1194
01:01:04,260 --> 01:01:06,450
然後我們有一個更新
步驟在頂部。

1195
01:01:06,450 --> 01:01:10,060
>> 在fo​​r循環中，這主要取
這三樣東西和它凝結

1196
01:01:10,060 --> 01:01:11,370
成一行。

1197
01:01:11,370 --> 01:01:15,130
因此，它確實在的第一件事
for循環的初始化。

1198
01:01:15,130 --> 01:01:19,090
然後，你做一個分號，然後
你做的條件，這是我

1199
01:01:19,090 --> 01:01:22,200
大於零去那邊，
然後在更新步驟。

1200
01:01:22,200 --> 01:01:26,470
因此，這被在執行
循環體的最後一刻。

1201
01:01:26,470 --> 01:01:28,790
所以，這兩個程序是
基本上是等價的。

1202
01:01:28,790 --> 01:01:31,960

1203
01:01:31,960 --> 01:01:33,870
>> 有問題嗎？

1204
01:01:33,870 --> 01:01:37,000
那麼，什麼是一個區別
這兩者之間？

1205
01:01:37,000 --> 01:01:38,000
任何人都可以指出來？

1206
01:01:38,000 --> 01:01:40,480
它可能是一個有點微妙。

1207
01:01:40,480 --> 01:01:41,930
這只是一個非常小的差異。

1208
01:01:41,930 --> 01:01:42,330
是嗎？

1209
01:01:42,330 --> 01:01:49,008
>> 揚聲器5：您將無法使用
For循環外的我變

1210
01:01:49,008 --> 01:01:49,962
[聽不清]？

1211
01:01:49,962 --> 01:01:50,900
>> 約瑟夫：沒錯。

1212
01:01:50,900 --> 01:01:53,550
所以，這是我們會得到
後來被稱為變量的作用域。

1213
01:01:53,550 --> 01:01:56,610
但本質上，這種詮釋我的生活
這個while循環之外。

1214
01:01:56,610 --> 01:01:59,800
所以一旦這個while循環完成
執行時，我就可以在以後使用我

1215
01:01:59,800 --> 01:02:00,880
在該程序。

1216
01:02:00,880 --> 01:02:05,430
>> 而用這種For循環，這個INT I
作用域是這裡面的for循環。

1217
01:02:05,430 --> 01:02:10,240
並且，因為它是該部分的內
For循環，即啟動

1218
01:02:10,240 --> 01:02:13,200
在括號和結束
大括號那邊。

1219
01:02:13,200 --> 01:02:16,120
這就是內聲明的任何事情
這裡不能被外部使用。

1220
01:02:16,120 --> 01:02:20,420
所以，如果我嘗試使用外我，它會
告訴我，未申報的象徵。

1221
01:02:20,420 --> 01:02:22,420
而且基本上，我不會
能夠使用它。

1222
01:02:22,420 --> 01:02:28,460
>> 羅伯：和好了，10年前，在
從字面上所有的情況下，大括號

1223
01:02:28,460 --> 01:02:31,140
你用什麼來確定
一個變量的範圍。

1224
01:02:31,140 --> 01:02:37,240
所以在那裡，INT I等於10
這裡面聲明

1225
01:02:37,240 --> 01:02:38,520
設置大括號。

1226
01:02:38,520 --> 01:02:42,530
所以這時只要您嘗試使用我
這個大括號之前，它的罰款。

1227
01:02:42,530 --> 01:02:47,090

1228
01:02:47,090 --> 01:02:51,460
當你鍵入make您可能會看到，你
看破折號，破折號，標準，等於和C99。

1229
01:02:51,460 --> 01:02:57,100
>> 所以這是C以後的版本，
海灣合作委員會已實施也給

1230
01:02:57,100 --> 01:02:58,740
此快捷方式。

1231
01:02:58,740 --> 01:03:03,505
因此，這用於不能在C.允許和
你可以看到為什麼，因為這個整數

1232
01:03:03,505 --> 01:03:07,600
我是這個大括號之外，但
它仍然被認為是在

1233
01:03:07,600 --> 01:03:09,750
這些大括號的範圍。

1234
01:03:09,750 --> 01:03:14,120
但是，這是一個非常方便的事情，
所以它是一個很好的延伸。

1235
01:03:14,120 --> 01:03:15,370
>> 約瑟夫：有問題嗎？

1236
01:03:15,370 --> 01:03:17,550

1237
01:03:17,550 --> 01:03:19,260
確定。

1238
01:03:19,260 --> 01:03:22,820
那麼什麼是更有益的是，有時
你想在那種活力

1239
01:03:22,820 --> 01:03:23,410
你的循環，對不對？

1240
01:03:23,410 --> 01:03:26,350
你不想只是必然打印
完全糊塗的所有的時間，你

1241
01:03:26,350 --> 01:03:28,650
要從倒計時
10什麼的。

1242
01:03:28,650 --> 01:03:32,010
所以你可以使用計數器變量
那裡面循環的為好。

1243
01:03:32,010 --> 01:03:35,530
在這種情況下，本程序只是
倒計時從10一路下跌下來。

1244
01:03:35,530 --> 01:03:39,260
它有什麼不能打印？

1245
01:03:39,260 --> 01:03:42,790
它不打印零，
沒錯，因為當 - 

1246
01:03:42,790 --> 01:03:45,460
是的，它也不會打印11。

1247
01:03:45,460 --> 01:03:49,200
>> 因此，它不打印零，因為當
我是零，請記住，它會評估

1248
01:03:49,200 --> 01:03:52,170
之前那張條件
執行循環體。

1249
01:03:52,170 --> 01:03:56,820
當我是零，這是假的，所以
它不會打印出倒計時

1250
01:03:56,820 --> 01:04:00,200
零，它只是打印出票
跌10一路下滑至1。

1251
01:04:00,200 --> 01:04:03,420
如果我們真的想要它打印為零，
然後我們會把等號

1252
01:04:03,420 --> 01:04:04,750
比後簽訂本更大。

1253
01:04:04,750 --> 01:04:09,400

1254
01:04:09,400 --> 01:04:10,130
確定。

1255
01:04:10,130 --> 01:04:16,410
>> 因此，一個辦法做到的輸入驗證，這
是當你問用戶做

1256
01:04:16,410 --> 01:04:18,620
什麼，你要確保他們
按照您的指示，是使用

1257
01:04:18,620 --> 01:04:19,400
While循環，對不對？

1258
01:04:19,400 --> 01:04:22,990
因此，在這種特殊情況下，我在問
為正數，那麼我

1259
01:04:22,990 --> 01:04:23,810
等待輸入。

1260
01:04:23,810 --> 01:04:28,210
>> 然後我檢查而輸入
小於零，不斷地問他們。

1261
01:04:28,210 --> 01:04:32,100
所以只要他們給我一個號碼
這不是積極的，不斷地問，

1262
01:04:32,100 --> 01:04:33,600
不停的問，不停的問。

1263
01:04:33,600 --> 01:04:35,860
但是，什麼是有點兒奇怪這件事？

1264
01:04:35,860 --> 01:04:38,570
或似乎有什麼不理想有關
這種結構在這裡？

1265
01:04:38,570 --> 01:04:44,282

1266
01:04:44,282 --> 01:04:44,758
任何人嗎？

1267
01:04:44,758 --> 01:04:45,234
是嗎？

1268
01:04:45,234 --> 01:04:47,614
>> 揚聲器6：你重複
該指令的兩倍。

1269
01:04:47,614 --> 01:04:48,100
>> 喬瑟夫：對。

1270
01:04:48,100 --> 01:04:50,090
因此，我們有兩個printf語句
在這裡，對不對？

1271
01:04:50,090 --> 01:04:53,440
因此，有一個辦法，我們可以得到這個剛
下降到一個會令我們的

1272
01:04:53,440 --> 01:04:57,170
代碼更易於閱讀和
更乾淨一點。

1273
01:04:57,170 --> 01:05:00,180
然後我們就不必
已取得在兩次為好。

1274
01:05:00,180 --> 01:05:03,740
你也可以做到這一點的方法之一是
通過使用一個do-whil​​e循環。

1275
01:05:03,740 --> 01:05:07,670
>> 和do-whil​​e循環基本上是一個
不同形式的While循環在哪裡

1276
01:05:07,670 --> 01:05:11,460
無論是在大括號內
被至少執行一次。

1277
01:05:11,460 --> 01:05:14,840
所以在這裡，我宣布，整型
輸入外第一。

1278
01:05:14,840 --> 01:05:18,100
然後，我只是說，這樣做
指令同時輸入

1279
01:05:18,100 --> 01:05:19,140
小於零。

1280
01:05:19,140 --> 01:05:20,530
所以，它擊中先做。

1281
01:05:20,530 --> 01:05:24,190
它總是至少執行此
一次，所以它總是會詢問用戶

1282
01:05:24,190 --> 01:05:25,960
對於至少一次輸入。

1283
01:05:25,960 --> 01:05:29,390
然後它計算的輸入，
並且它繼續了一圈。

1284
01:05:29,390 --> 01:05:30,135
是的，質疑？

1285
01:05:30,135 --> 01:05:32,602
>> 揚聲器6：有沒有辦法做到這一點
[聽不清]的類型，如果你說喜歡，

1286
01:05:32,602 --> 01:05:34,268
GetString的，有人[聽不清]

1287
01:05:34,268 --> 01:05:35,220
是有辦法[聽不清]

1288
01:05:35,220 --> 01:05:40,060
>> 喬瑟夫：所以，問題是，有沒有
這樣做的輸入驗證，如果用戶

1289
01:05:40,060 --> 01:05:41,850
不把正確的
變量的類型？

1290
01:05:41,850 --> 01:05:44,460
因此，如果我們要求一個int和他們
給我們一個字符串來代替。

1291
01:05:44,460 --> 01:05:49,110
而在我們實現的功能
對你來說，調用getInt是，GetString在所有的

1292
01:05:49,110 --> 01:05:52,680
這些功能，他們實際上已經
做那種基本類型的輸入

1293
01:05:52,680 --> 01:05:54,120
引擎蓋下驗證。

1294
01:05:54,120 --> 01:05:57,390
所以，如果你正在使用的功能，我們
給了你，你真的沒有來。

1295
01:05:57,390 --> 01:06:01,380
>> 但是，如果你想看起來更探討如何
你其實可以做到這一點，你可以看看

1296
01:06:01,380 --> 01:06:03,360
罩在文件下I/O--

1297
01:06:03,360 --> 01:06:07,990
不是一個文件，標準I / O函數
像一個從標準輸入讀取和

1298
01:06:07,990 --> 01:06:08,580
標準輸出。

1299
01:06:08,580 --> 01:06:10,630
你可以得到一個更好的感覺
您可能如何做到這一點。

1300
01:06:10,630 --> 01:06:13,670
>> 羅伯：有一個問題，雖然是專門
用你的例子

1301
01:06:13,670 --> 01:06:17,070
說，你期望一個字符串
而我進入一個int。

1302
01:06:17,070 --> 01:06:20,110
你將如何分辨
故意想要的

1303
01:06:20,110 --> 01:06:23,130
串123對想要整型123？

1304
01:06:23,130 --> 01:06:29,230
這樣的字符串，它幾乎沒有
驗證，它只是不管他們

1305
01:06:29,230 --> 01:06:31,600
進入你將圓夢
作為一個字符串。

1306
01:06:31,600 --> 01:06:35,790
>> int是比較容易的，因為不管
輸入你從用戶，你是

1307
01:06:35,790 --> 01:06:37,470
始終以一個字符串。

1308
01:06:37,470 --> 01:06:40,650
所以該字符串就可以再
檢查一下，是所有這些

1309
01:06:40,650 --> 01:06:44,218
實際上位數字？

1310
01:06:44,218 --> 01:06:45,170
>> 約瑟夫：確定。

1311
01:06:45,170 --> 01:06:46,420
大約一個do-whil​​e循環有問題嗎？

1312
01:06:46,420 --> 01:06:49,170
>> 羅伯：哦，這也是 - 

1313
01:06:49,170 --> 01:06:55,130
回去範圍，一個比較常見的
錯誤是試圖用一些當地的

1314
01:06:55,130 --> 01:06:59,540
從這個的do-whil​​e中變量
循環的這種情況下的內部。

1315
01:06:59,540 --> 01:07:02,850
而實際上，如果我們只是擺脫了
這一點，並說，INT輸入等於

1316
01:07:02,850 --> 01:07:06,990
調用getInt，那麼編譯器會罵
我們，因為輸入不存在

1317
01:07:06,990 --> 01:07:08,900
的範圍之外的
這些大括號。

1318
01:07:08,900 --> 01:07:10,792
>> 約瑟夫：這就是為什麼我們
需要這樣的陣容在這裡。

1319
01:07:10,792 --> 01:07:13,620

1320
01:07:13,620 --> 01:07:14,630
確定。

1321
01:07:14,630 --> 01:07:17,530
所以你也可以打出來的
循環初期，如果你想。

1322
01:07:17,530 --> 01:07:21,240
所以這是一個不同的方式
實施我們剛剛實施。

1323
01:07:21,240 --> 01:07:24,340
和，而不是使用條件
在括號內，我們使用了

1324
01:07:24,340 --> 01:07:26,920
如果身體的內部表
在do-whil​​e循環的。

1325
01:07:26,920 --> 01:07:30,000
>> 基本上，當輸入最後
大於零，我們將

1326
01:07:30,000 --> 01:07:31,000
跳出循環。

1327
01:07:31,000 --> 01:07:33,420
因此，我們將全力以赴
一路下來這裡。

1328
01:07:33,420 --> 01:07:37,920
而且你可以看到這會
可能是優選的這

1329
01:07:37,920 --> 01:07:39,870
情況下，因為它是一個小
有點清潔和一點點

1330
01:07:39,870 --> 01:07:41,380
位更容易閱讀。

1331
01:07:41,380 --> 01:07:45,210
而這一類的，你
有多餘的線條在裡面。

1332
01:07:45,210 --> 01:07:47,890
這只是一點點醜陋，
我猜想，在某種意義上。

1333
01:07:47,890 --> 01:07:48,530
是的，質疑？

1334
01:07:48,530 --> 01:07:52,178
>> 揚聲器4：將僅獲得突破
你出一組大括號？

1335
01:07:52,178 --> 01:07:53,080
>> 喬瑟夫：對。

1336
01:07:53,080 --> 01:07:58,100
所以，問題是只破
讓你出一個循環的？

1337
01:07:58,100 --> 01:07:59,280
答案是肯定的。

1338
01:07:59,280 --> 01:08:04,290
所以，如果你有嵌套的For循環，對於
舉例來說，如果我有整型I等於0

1339
01:08:04,290 --> 01:08:09,040
直到10然後對於int j為0
直到10，如果我打出來的內在的

1340
01:08:09,040 --> 01:08:12,310
環，我還是會去
到外循環。

1341
01:08:12,310 --> 01:08:15,760
所以它會繼續執行
操作在外面。

1342
01:08:15,760 --> 01:08:17,640
關於什麼問題嗎？

1343
01:08:17,640 --> 01:08:18,000
是嗎？

1344
01:08:18,000 --> 01:08:21,760
>> 揚聲器5：但只有突破功能
對大括號，而不是其他

1345
01:08:21,760 --> 01:08:22,230
報表？

1346
01:08:22,230 --> 01:08:22,700
[聽不清]

1347
01:08:22,700 --> 01:08:27,620
>> 喬瑟夫：所以，問題是將打破
唯一的功能for循環，而不是

1348
01:08:27,620 --> 01:08:29,014
其他語句一樣，如果？

1349
01:08:29,014 --> 01:08:32,950
是的，是這樣的話，因為
你打破一個循環出來了吧，

1350
01:08:32,950 --> 01:08:33,630
在感。

1351
01:08:33,630 --> 01:08:37,215
>> 羅伯：在案件的絕大多數，這是
這是如果某樣東西的那種，

1352
01:08:37,215 --> 01:08:37,660
然後打破。

1353
01:08:37,660 --> 01:08:41,580
所以，你不必打破申請
的如果是環繞著它。

1354
01:08:41,580 --> 01:08:45,250
而且，這並不是太大的環，
但請記住，開關也

1355
01:08:45,250 --> 01:08:46,340
通過斷裂破碎出來的。

1356
01:08:46,340 --> 01:08:48,390
我們看到正在使用的中斷
與切換前。

1357
01:08:48,390 --> 01:08:52,189
>> 約瑟夫：你也可以使用它們
在While循環和for循環。

1358
01:08:52,189 --> 01:08:54,560
有問題嗎？

1359
01:08:54,560 --> 01:08:55,830
確定。

1360
01:08:55,830 --> 01:08:57,779
所以，接下來是功能。

1361
01:08:57,779 --> 01:09:01,500
所以，你可能已經使用了這些BYOB之一
塊，將刮項目。

1362
01:09:01,500 --> 01:09:04,569
這基本上可以讓
您可以定義一組

1363
01:09:04,569 --> 01:09:05,680
指令被執行。

1364
01:09:05,680 --> 01:09:09,569
>> 而我的意思是讓我們覺得
回到數學，右，代數。

1365
01:09:09,569 --> 01:09:13,370
你有什麼我們稱之為x的函數，
一些變量，並假設本

1366
01:09:13,370 --> 01:09:16,080
函數是f的x等於x加5。

1367
01:09:16,080 --> 01:09:20,410
所以，你能想到前後x的，因為這黑色
框取15，然後

1368
01:09:20,410 --> 01:09:22,590
生產20。

1369
01:09:22,590 --> 01:09:26,630
>> 所以更一般地，一個功能是
的東西，需要一些投入和

1370
01:09:26,630 --> 01:09:27,880
然後產生一些輸出。

1371
01:09:27,880 --> 01:09:31,920

1372
01:09:31,920 --> 01:09:32,960
以及為什麼是功能好？

1373
01:09:32,960 --> 01:09:35,189
他們是很好的為一定數量的原因。

1374
01:09:35,189 --> 01:09:40,470
因此，沒有人想採取刺
在組織什麼意思？

1375
01:09:40,470 --> 01:09:42,630
在為什麼功能方面都是有幫助嗎？

1376
01:09:42,630 --> 01:09:43,090
是嗎？

1377
01:09:43,090 --> 01:09:44,735
>> 揚聲器4：它使你的
代碼更具可讀性。

1378
01:09:44,735 --> 01:09:45,399
>> 喬瑟夫：對。

1379
01:09:45,399 --> 01:09:47,670
這樣的事情之一是它使
你的代碼更易讀，對不對？

1380
01:09:47,670 --> 01:09:53,710
而不必像詮釋x等於x時
次x次X，我可以得x的立方，

1381
01:09:53,710 --> 01:09:57,190
這是更具可讀性，更
可以理解的讀者。

1382
01:09:57,190 --> 01:10:01,150
>> 組織也是來講
把您的代碼轉換成可管理的

1383
01:10:01,150 --> 01:10:05,610
部分，因此，與其試圖
實現這一切在一個長款

1384
01:10:05,610 --> 01:10:09,070
在主，你可以有點分裂它
成想，好，讓我們寫一個函數

1385
01:10:09,070 --> 01:10:11,910
多維數據集的東西，讓我們寫一個
功能為方形的東西。

1386
01:10:11,910 --> 01:10:15,950
這樣，你可以把它分解成微小的，
小部分，你可以解決

1387
01:10:15,950 --> 01:10:18,944
而不是試圖解決
一個很大的問題一下子。

1388
01:10:18,944 --> 01:10:21,806
>> 羅伯：甚至微小的，小零件
你和你的伴侶可以解決。

1389
01:10:21,806 --> 01:10:22,283
>> 約瑟夫：是啊。

1390
01:10:22,283 --> 01:10:23,855
>> 羅伯：所以不是兩個
你想植入1

1391
01:10:23,855 --> 01:10:27,170
功能的同時。

1392
01:10:27,170 --> 01:10:28,800
>> 約瑟夫：簡化。

1393
01:10:28,800 --> 01:10:30,050
有人想以此來猜測？

1394
01:10:30,050 --> 01:10:33,080

1395
01:10:33,080 --> 01:10:33,410
是嗎？

1396
01:10:33,410 --> 01:10:34,675
>> 揚聲器5：更多的重複。

1397
01:10:34,675 --> 01:10:35,260
>> 喬瑟夫：對。

1398
01:10:35,260 --> 01:10:39,210
這樣一件事，你可以做
簡化是它的排序上

1399
01:10:39,210 --> 01:10:42,520
相同的線作為可重用性是
有一次我寫一個立方體函數，我可以

1400
01:10:42,520 --> 01:10:45,410
剛剛使用過，並一遍又一遍
又在我的程序，而不是打字

1401
01:10:45,410 --> 01:10:49,610
x次x次x在和
一遍又一遍。

1402
01:10:49,610 --> 01:10:52,980
和簡化在這裡也只是
意味著它使你的代碼排序

1403
01:10:52,980 --> 01:10:55,900
一旦你分割更容易調試
這成函數。

1404
01:10:55,900 --> 01:10:58,250
因為這樣你可以在那裡本地化
排序您的問題。

1405
01:10:58,250 --> 01:11:00,910

1406
01:11:00,910 --> 01:11:02,160
有問題嗎？

1407
01:11:02,160 --> 01:11:04,200

1408
01:11:04,200 --> 01:11:06,540
>> 所以另一個想法是抽象的，對不對？

1409
01:11:06,540 --> 01:11:07,390
這個黑匣子。

1410
01:11:07,390 --> 01:11:11,360
就像你知道什麼調用getInt呢
以接收來自用戶的輸入？

1411
01:11:11,360 --> 01:11:12,510
我們還沒有真正告訴你，對不對？

1412
01:11:12,510 --> 01:11:15,670
所有我們告訴你的是調用getInt呢
正是它說，它的作用。

1413
01:11:15,670 --> 01:11:18,440
所以，即使我們不告訴你如何
它的工作原理，你還是知道的。

1414
01:11:18,440 --> 01:11:21,670
>> 因此，在這種特殊情況下，這是
四重功能，不

1415
01:11:21,670 --> 01:11:24,520
不同的東西來輸入
以產生一個輸出。

1416
01:11:24,520 --> 01:11:28,050
而且你可以翻兩番一個數字
通過將其乘以4。

1417
01:11:28,050 --> 01:11:30,790
或者您也可以就是我們所說的
位由兩個移動它。

1418
01:11:30,790 --> 01:11:32,960
我們將討論這
一點點後。

1419
01:11:32,960 --> 01:11:36,570
而且也沒有必要知道如何
函數實際上只要工程，它

1420
01:11:36,570 --> 01:11:37,640
誠如作品。

1421
01:11:37,640 --> 01:11:40,740
>> 於是在引擎蓋下，我可能是
像，返回輸入倍

1422
01:11:40,740 --> 01:11:41,690
8除以二。

1423
01:11:41,690 --> 01:11:42,510
而你不知道吧？

1424
01:11:42,510 --> 01:11:44,970
所有你需要知道的是，
它做什麼它說。

1425
01:11:44,970 --> 01:11:48,070
所以這是有用的東西
關於抽象。

1426
01:11:48,070 --> 01:11:52,910
>> 而另一件事是有點這樣的想法
定位你的代碼之一

1427
01:11:52,910 --> 01:11:54,280
特定部分。

1428
01:11:54,280 --> 01:11:57,450
所以，如果你有一個問題，你不
要走遍你的代碼試圖

1429
01:11:57,450 --> 01:11:58,730
解決那裡的問題。

1430
01:11:58,730 --> 01:12:00,990
因此，在這種情況下，我實現
立方體錯誤的。

1431
01:12:00,990 --> 01:12:02,820
我想多維數據集乘以
三。

1432
01:12:02,820 --> 01:12:05,760
>> 所以在這種情況下，這是一個程序
只是已經由三個相乘

1433
01:12:05,760 --> 01:12:06,750
無處不在。

1434
01:12:06,750 --> 01:12:10,910
而且，還有另一個計劃，有
保理立方體出成一個函數。

1435
01:12:10,910 --> 01:12:14,040
所以現在如果我想解決我的錯
在這裡，我必須要修好每一行

1436
01:12:14,040 --> 01:12:15,620
這個程序的代碼。

1437
01:12:15,620 --> 01:12:19,190
而在另一方面，如果我用
功能，我只需要改變

1438
01:12:19,190 --> 01:12:20,650
在一個地方發生了什麼事。

1439
01:12:20,650 --> 01:12:25,330

1440
01:12:25,330 --> 01:12:28,730
>> 因此，在計算機科學中，我們
調用的輸入和輸出。

1441
01:12:28,730 --> 01:12:31,640
輸入被稱為參數或
參數，並輸出被稱為

1442
01:12:31,640 --> 01:12:32,950
返回值。

1443
01:12:32,950 --> 01:12:39,000
我們將看到如何這可以幫助我們理清
在第二個定義一個函數。

1444
01:12:39,000 --> 01:12:41,430
所以這是一個函數定義
對於體積測量。

1445
01:12:41,430 --> 01:12:45,110
因此它需要一個輸入，然後
它返回一個數字時代

1446
01:12:45,110 --> 01:12:47,020
本身三次。

1447
01:12:47,020 --> 01:12:48,020
因此，讓我們打破這種分解。

1448
01:12:48,020 --> 01:12:53,090
>> 所以我們有一個函數頭，其中
基本上由三件事情。

1449
01:12:53,090 --> 01:12:56,050
所以，我們有參數，
是，正如我前面所說的，

1450
01:12:56,050 --> 01:12:57,680
投入到這個功能。

1451
01:12:57,680 --> 01:12:59,300
然後我們給函數的名稱。

1452
01:12:59,300 --> 01:13:00,740
在這種情況下，它被稱為多維數據集。

1453
01:13:00,740 --> 01:13:03,860
然後，我們指定哪些類型
的返回值是。

1454
01:13:03,860 --> 01:13:06,760
>> 所以在這種情況下，我的立方體函數
取入的整數，並且它也

1455
01:13:06,760 --> 01:13:07,890
返回一個整數。

1456
01:13:07,890 --> 01:13:11,510
所以，如果我通過在二，二是整數，
它返回八到我，這

1457
01:13:11,510 --> 01:13:13,250
是一個整數。

1458
01:13:13,250 --> 01:13:15,420
因此，返回類型名稱參數。

1459
01:13:15,420 --> 01:13:16,670
有關該問題？

1460
01:13:16,670 --> 01:13:19,440

1461
01:13:19,440 --> 01:13:24,230
>> 然後返回值實際上是
在最後說指定的回報

1462
01:13:24,230 --> 01:13:27,540
然後回到什麼
包含返回值。

1463
01:13:27,540 --> 01:13:30,940
因此，在這種情況下，如果我們把它全部
同時，一個函數接受

1464
01:13:30,940 --> 01:13:35,100
參數，這就是所謂的東西，
它返回的東西是類型

1465
01:13:35,100 --> 01:13:36,350
我們說這將是。

1466
01:13:36,350 --> 01:13:39,830

1467
01:13:39,830 --> 01:13:41,080
有問題嗎？

1468
01:13:41,080 --> 01:13:43,710

1469
01:13:43,710 --> 01:13:45,080
>> 那麼，我們如何使用函數？

1470
01:13:45,080 --> 01:13:49,230
好了，我們寫一個函數，然後
我們用它在我們的計劃，對不對？

1471
01:13:49,230 --> 01:13:51,565
所以我把它稱為多維數據集，
然後我可以使用多維數據集。

1472
01:13:51,565 --> 01:13:54,200
>> 但重要的是要注意
就是為了事宜。

1473
01:13:54,200 --> 01:13:58,100
如果我有以下主要的立方體，它的
要碰上立方體。

1474
01:13:58,100 --> 01:14:00,360
在這一點上，沒有什麼
所謂的魔方程序中，它的

1475
01:14:00,360 --> 01:14:02,550
只是要像，我有
不知道什麼是立方體。

1476
01:14:02,550 --> 01:14:05,060
>> 因此，它會告訴你，隱
聲明的函數。

1477
01:14:05,060 --> 01:14:06,690
這顯示了錯誤。

1478
01:14:06,690 --> 01:14:10,230
所以在這種情況下，立方體低於
主要的，所以它不會

1479
01:14:10,230 --> 01:14:12,006
來了解一下吧。

1480
01:14:12,006 --> 01:14:14,724
>> 揚聲器5：所以主要是通常
最後一個函數定義？

1481
01:14:14,724 --> 01:14:17,290
>> 喬瑟夫：所以，問題是，
是主要的通常是最後

1482
01:14:17,290 --> 01:14:18,170
你想定義的事情嗎？

1483
01:14:18,170 --> 01:14:19,730
並沒有。

1484
01:14:19,730 --> 01:14:22,280
這是因為我們通常喜歡主
要在頂部，對不對？

1485
01:14:22,280 --> 01:14:24,640
因為這是第一件事情你
希望程序員打開

1486
01:14:24,640 --> 01:14:25,640
程序，看看。

1487
01:14:25,640 --> 01:14:29,950
所以，我們如何解決這個問題，我們
想主要是在頂部，但

1488
01:14:29,950 --> 01:14:33,750
我們想要的功能，我們希望他們
將低於主還能夠使用

1489
01:14:33,750 --> 01:14:34,930
他們的主要內？

1490
01:14:34,930 --> 01:14:36,870
>> 好了，我們用我們稱之為
函數原型。

1491
01:14:36,870 --> 01:14:40,830
那麼，什麼函數原型本質
是被它首先需要什麼

1492
01:14:40,830 --> 01:14:45,060
簽名或函數頭
什麼我們要實現下降

1493
01:14:45,060 --> 01:14:47,420
在這裡，我們把它放在
一個程序的頂部。

1494
01:14:47,420 --> 01:14:51,400
>> 因此，在這種情況下，我們說，好了，
後來在我們的節目中，我們將

1495
01:14:51,400 --> 01:14:55,010
作出承諾來實現這個
函數調用整型立方體，這需要

1496
01:14:55,010 --> 01:14:56,260
一個整數輸入。

1497
01:14:56,260 --> 01:15:00,870
所以，現在，因為那是上面的主，
主要的，它會說，哦，好吧，

1498
01:15:00,870 --> 01:15:03,910
在節目後，也將是
有這樣我就可以參考它，所以我會

1499
01:15:03,910 --> 01:15:05,230
就讓它通過去現在。

1500
01:15:05,230 --> 01:15:07,660
>> 然後在底部，
我們實現的立方體。

1501
01:15:07,660 --> 01:15:11,180
然後主只想說，
好了，它會進行排序的鏈接

1502
01:15:11,180 --> 01:15:12,250
這兩個符號在一起。

1503
01:15:12,250 --> 01:15:14,320
我們將討論是什麼
意味著以後。

1504
01:15:14,320 --> 01:15:17,090
所以它會知道，這是
立方體函數，它應該使用。

1505
01:15:17,090 --> 01:15:19,630

1506
01:15:19,630 --> 01:15:23,383
>> 羅伯：在[聽不清]關於希望
主要在底部或

1507
01:15:23,383 --> 01:15:24,880
頂，我見過兩個。

1508
01:15:24,880 --> 01:15:28,630
有些事情，就像
把主要的底部。

1509
01:15:28,630 --> 01:15:32,520
但是，一旦一個項目獲得特別
大，平時主要是在

1510
01:15:32,520 --> 01:15:34,290
提交自己的所有。

1511
01:15:34,290 --> 01:15:38,170
在這一點上，如
整型立方體線會 - 

1512
01:15:38,170 --> 01:15:42,460
stdio.h中裡面是一堆
就這樣整型行

1513
01:15:42,460 --> 01:15:44,010
立方體整型輸入線。

1514
01:15:44,010 --> 01:15:50,170
>> 等等這些原型都是你
往往投入的頭文件，在

1515
01:15:50,170 --> 01:15:52,140
這一點，也沒有關係。

1516
01:15:52,140 --> 01:15:54,700
好吧，沒關係。

1517
01:15:54,700 --> 01:15:56,070
那些總是在頂部。

1518
01:15:56,070 --> 01:15:59,490
如果主要不是一個文件自身所有，
你不必擔心這會讓

1519
01:15:59,490 --> 01:16:02,360
個別函數原型
在文件中。

1520
01:16:02,360 --> 01:16:05,370
>> 約瑟夫：我們會得到一個小
位後，當羅布開始談論

1521
01:16:05,370 --> 01:16:06,380
有關編譯。

1522
01:16:06,380 --> 01:16:09,480
所以還有一個區別
之間的參數和參數。

1523
01:16:09,480 --> 01:16:12,500
和參數正是
我們稱這些投入時

1524
01:16:12,500 --> 01:16:13,820
我們定義函數。

1525
01:16:13,820 --> 01:16:16,950
我們把它叫做一個參數，當我們
實際上它傳遞到函數。

1526
01:16:16,950 --> 01:16:19,600
>> 所以在這種情況下，這是一個參數，
正如我們之前所說的。

1527
01:16:19,600 --> 01:16:24,130
而當我們真正使用它在那邊，
的x立方體，那麼X本身是

1528
01:16:24,130 --> 01:16:25,910
我們所說的論點
該函數的立方體。

1529
01:16:25,910 --> 01:16:28,150
>> 羅伯：所以參數的論點是 - 

1530
01:16:28,150 --> 01:16:33,270
有這種區別，很
交替混淆。

1531
01:16:33,270 --> 01:16:37,090
在這一點上，對我來說，它就像一個
那些話，當我看到它在

1532
01:16:37,090 --> 01:16:41,190
野外，我不禁馬上
質疑他們是否在使用它

1533
01:16:41,190 --> 01:16:44,120
正確的上下文，因為
差足夠細微，僅僅

1534
01:16:44,120 --> 01:16:45,500
每個人都傾向於 - 

1535
01:16:45,500 --> 01:16:48,530
我幾乎總是說參數
不管我是什麼意思。

1536
01:16:48,530 --> 01:16:51,230

1537
01:16:51,230 --> 01:16:54,630
>> 約瑟夫：和功能也很有用
對於我們所說的副作用。

1538
01:16:54,630 --> 01:16:59,230
因此，一個函數可以不取輸入，並
它也可以不產生輸出。

1539
01:16:59,230 --> 01:17:03,280
因此，在這種特殊情況下，我
定義一個子程序，有沒有

1540
01:17:03,280 --> 01:17:03,970
返回值。

1541
01:17:03,970 --> 01:17:07,730
並且為了指定這一點，我們使用
我們稱之為無效在這裡。

1542
01:17:07,730 --> 01:17:10,890
因此該函數的副作用
是，它只是打印的東西

1543
01:17:10,890 --> 01:17:11,920
出到頁面中。

1544
01:17:11,920 --> 01:17:13,840
它實際上並沒有採取任何
輸入，並且它不

1545
01:17:13,840 --> 01:17:15,360
實際上產生任何輸出。

1546
01:17:15,360 --> 01:17:18,230
>> 但是這可能在這個意義上是有用
如果你想，例如，調試

1547
01:17:18,230 --> 01:17:21,530
東西在你的程序中，如果你想要
寫一點子程序

1548
01:17:21,530 --> 01:17:25,160
打印出來，讓我們說，內容
內存什麼的。

1549
01:17:25,160 --> 01:17:29,800
等等這些副作用是有時
上下文之外有用

1550
01:17:29,800 --> 01:17:33,010
只是想輸入和輸出。

1551
01:17:33,010 --> 01:17:34,260
有問題嗎？

1552
01:17:34,260 --> 01:17:37,270

1553
01:17:37,270 --> 01:17:44,240
>> 並結束這個特殊的領域，
這是什麼節目呢？

1554
01:17:44,240 --> 01:17:47,420
我給你們一對夫婦
秒讀通過它。

1555
01:17:47,420 --> 01:17:52,720

1556
01:17:52,720 --> 01:17:56,880
在一個非常基本的水平，我們要
說的是，它交換x和y，對不對？

1557
01:17:56,880 --> 01:18:00,090
>> 所以，你們有多少人真的認為
這將交換x和y？

1558
01:18:00,090 --> 01:18:02,160
舉起你的手。

1559
01:18:02,160 --> 01:18:02,760
沒有之一。

1560
01:18:02,760 --> 01:18:03,070
確定。

1561
01:18:03,070 --> 01:18:06,720
誰認為它會
不會掉x和y？

1562
01:18:06,720 --> 01:18:09,120
和該總和是
不是整個房間。

1563
01:18:09,120 --> 01:18:10,440
所以有些人不知道。

1564
01:18:10,440 --> 01:18:10,920
確定。

1565
01:18:10,920 --> 01:18:11,630
這是合理的。

1566
01:18:11,630 --> 01:18:16,450
>> 所以，讓我們通過會發生什麼時，
你實際上調用函數首先在

1567
01:18:16,450 --> 01:18:18,320
為了回答這個問題。

1568
01:18:18,320 --> 01:18:21,430
因此，這是什麼內存
那種樣子。

1569
01:18:21,430 --> 01:18:23,860
這有點像一個簡化模型
的記憶是什麼樣子時，

1570
01:18:23,860 --> 01:18:24,800
你運行一個程序。

1571
01:18:24,800 --> 01:18:27,270
因此，有一種叫
堆棧下來這裡

1572
01:18:27,270 --> 01:18:28,330
一種叫做堆。

1573
01:18:28,330 --> 01:18:30,950
而這些對成長
的存儲器的中間。

1574
01:18:30,950 --> 01:18:33,860
>> 因此，在這種特殊情況下，當
你調用一個函數，它

1575
01:18:33,860 --> 01:18:35,680
被放在堆棧上。

1576
01:18:35,680 --> 01:18:38,900
然後無論是包含在
功能停留在我們所說的

1577
01:18:38,900 --> 01:18:40,550
函數的堆棧幀。

1578
01:18:40,550 --> 01:18:44,500
等拿到一個不錯的可視化
對此，let's  - 例如，我們有

1579
01:18:44,500 --> 01:18:45,960
程序主要更早。

1580
01:18:45,960 --> 01:18:47,820
和主裡面，我們稱之為立方體。

1581
01:18:47,820 --> 01:18:50,650
所以主要會先進入堆疊
框架，因為它是第一個函數

1582
01:18:50,650 --> 01:18:51,640
這就是所謂的。

1583
01:18:51,640 --> 01:18:55,740
>> 然後當立方體被稱為內側
主要的，它被放在主頂部

1584
01:18:55,740 --> 01:18:57,790
內的存儲器中。

1585
01:18:57,790 --> 01:19:02,090
所以，你會發現這裡是立方體
有它自己的參數和其

1586
01:19:02,090 --> 01:19:02,950
自己的本地人。

1587
01:19:02,950 --> 01:19:06,720
所以，當你真正傳遞的東西
一個函數，參數，它

1588
01:19:06,720 --> 01:19:09,910
得到是什麼副本
從主要的傳遞。

1589
01:19:09,910 --> 01:19:14,140
>> 和排序來解釋這一點，讓我們
走過一個程序。

1590
01:19:14,140 --> 01:19:16,960
因此，我們有棧，這是
只是部分堆垛。

1591
01:19:16,960 --> 01:19:21,240
而我們要做的是，我們首先初始化
x和y為一個和兩個。

1592
01:19:21,240 --> 01:19:22,400
因此，我們有這些小盒子。

1593
01:19:22,400 --> 01:19:25,310
他們坐在主的堆棧
框架堆棧上。

1594
01:19:25,310 --> 01:19:26,580
它們含有一個和兩個。

1595
01:19:26,580 --> 01:19:28,820
>> 現在，我們稱之為交換。

1596
01:19:28,820 --> 01:19:33,940
什麼情況是我們通過x和y成
掉期，掉期和創建自己的副本

1597
01:19:33,940 --> 01:19:36,520
這些變量裡面使用
它的堆棧幀。

1598
01:19:36,520 --> 01:19:39,920
所以，現在在那邊，我們有一個，這
包含x具有的值，以及b，

1599
01:19:39,920 --> 01:19:41,620
其中包含使y的值是。

1600
01:19:41,620 --> 01:19:42,670
這樣的一，二。

1601
01:19:42,670 --> 01:19:47,130
>> 而且你會發現，這是獨立的
從x和y的主內。

1602
01:19:47,130 --> 01:19:51,390
所以我們現在創建一個臨時的
變量包含。

1603
01:19:51,390 --> 01:19:56,100
我們設置一個等於b，那麼它
變化從一到兩個。

1604
01:19:56,100 --> 01:19:59,340
然後我們將b等於
到溫度，這是其中之一。

1605
01:19:59,340 --> 01:20:01,640
>> 然後現在我們退出了
這個功能。

1606
01:20:01,640 --> 01:20:04,310

1607
01:20:04,310 --> 01:20:07,410
當您退出功能的出去，
堆棧幀被彈出堆棧。

1608
01:20:07,410 --> 01:20:08,270
我們稱它推。

1609
01:20:08,270 --> 01:20:12,750
你推一個棧幀壓入堆棧
而你若彈出從堆棧中。

1610
01:20:12,750 --> 01:20:16,080
所以會發生什麼事是一切
是剛才那個堆棧幀排序

1611
01:20:16,080 --> 01:20:17,280
上升在火焰中。

1612
01:20:17,280 --> 01:20:19,180
所以不再存在。

1613
01:20:19,180 --> 01:20:20,470
>> 但是，我們注意到了嗎？

1614
01:20:20,470 --> 01:20:23,690
我們從來沒有真正改變
x和y的值，對不對？

1615
01:20:23,690 --> 01:20:26,530
所以那些地方呆主。

1616
01:20:26,530 --> 01:20:29,900
並通過傳遞東西掉期，我們
其實從來沒有改變這些值。

1617
01:20:29,900 --> 01:20:31,260
而我們稱這是什麼？

1618
01:20:31,260 --> 01:20:33,040
我們按值調用這個傳球。

1619
01:20:33,040 --> 01:20:36,860
>> 所以在C中，當你通過東西進入
功能，它通過它們按價值計算，

1620
01:20:36,860 --> 01:20:40,160
使他們的副本
該函數使用。

1621
01:20:40,160 --> 01:20:43,980
我們將了解一些所謂的
通過引用傳遞後，但是這

1622
01:20:43,980 --> 01:20:45,390
一種方法可以解決這個問題。

1623
01:20:45,390 --> 01:20:47,080
但我們不會擔心
那直到後來。

1624
01:20:47,080 --> 01:20:52,200
>> 羅伯：而實際上，這個詞，傳遞
通過引用，所以C甚至沒有

1625
01:20:52,200 --> 01:20:54,270
路過的參考。

1626
01:20:54,270 --> 01:20:56,760
Ç已經完全經過值。

1627
01:20:56,760 --> 01:20:59,630
不管你做什麼，你總是
路過的一些副本。

1628
01:20:59,630 --> 01:21:03,395
它只是說，像我樣的提
之前的指針

1629
01:21:03,395 --> 01:21:07,690
和一個字符串確實是只有四
字節指著某處在內存中。

1630
01:21:07,690 --> 01:21:11,890
>> 好吧，如果我有這樣的字符串，它的
告訴我，是其中的字符串 - 

1631
01:21:11,890 --> 01:21:15,470
好吧，如果我有這個指針指向這個
放置在內存中，然後我可以通過一個

1632
01:21:15,470 --> 01:21:19,160
該指針指向一個函數的副本，
該功能仍然知道在哪裡

1633
01:21:19,160 --> 01:21:19,780
內存是。

1634
01:21:19,780 --> 01:21:22,950
所以，這兩個指針都指向
內存中的同一個地方，和

1635
01:21:22,950 --> 01:21:26,460
這就是我們要如何才能夠
修改以後的事情

1636
01:21:26,460 --> 01:21:29,852
當前堆棧幀。

1637
01:21:29,852 --> 01:21:31,040
>> 約瑟夫：你們想幹什麼編譯？

1638
01:21:31,040 --> 01:21:31,820
>> 羅伯：不，這是5:30。

1639
01:21:31,820 --> 01:21:32,910
>> 約瑟夫：確定。

1640
01:21:32,910 --> 01:21:35,040
它是5:30。

1641
01:21:35,040 --> 01:21:35,360
確定。

1642
01:21:35,360 --> 01:21:39,280
因此，我們將覆蓋編譯我猜
下一節，或者你的節

1643
01:21:39,280 --> 01:21:42,795
領導者會在這一點上。

1644
01:21:42,795 --> 01:21:43,272
和 - 

1645
01:21:43,272 --> 01:21:44,630
>> 羅伯：有問題嗎？

1646
01:21:44,630 --> 01:21:46,760
>> 約瑟夫：有問題嗎？

1647
01:21:46,760 --> 01:21:47,150
是嗎？

1648
01:21:47,150 --> 01:21:52,469
>> 喇叭5：使用從CS50，任何字符串
我們要使用的功能

1649
01:21:52,469 --> 01:21:53,880
這些，那將是像C函數。

1650
01:21:53,880 --> 01:21:59,050
CS50並沒有消失在和
做任何額外的。

1651
01:21:59,050 --> 01:22:01,850
>> 羅伯：正確。

1652
01:22:01,850 --> 01:22:08,155
任何的C狀[聽不清]，您
會使用那些在我們的字符串。

1653
01:22:08,155 --> 01:22:12,400
>> 約瑟夫：最後一件事我想
一提的是，我們有一個風格指南

1654
01:22:12,400 --> 01:22:13,130
這個類。

1655
01:22:13,130 --> 01:22:13,360
>> 羅伯：哦，是的。

1656
01:22:13,360 --> 01:22:15,270
>> 喬瑟夫：所以，如果你來自一個
前編程背景，你

1657
01:22:15,270 --> 01:22:17,750
可能有一定的約定，當
你寫的代碼就像把

1658
01:22:17,750 --> 01:22:20,950
在同一行或特定括號
縮進方式

1659
01:22:20,950 --> 01:22:22,240
或命名變量。

1660
01:22:22,240 --> 01:22:26,870
在這個類中，我們要遵循
具體風格指南只是因為，

1661
01:22:26,870 --> 01:22:31,100
好吧，如果你出去工作的
行業，你會在意料之中

1662
01:22:31,100 --> 01:22:34,780
遵循的風格指南
公司在這你去。

1663
01:22:34,780 --> 01:22:38,040
>> 像例如，Facebook的我覺得
已命名的特定排序

1664
01:22:38,040 --> 01:22:38,760
約定。

1665
01:22:38,760 --> 01:22:42,570
還有的駱駝之間的差異
外殼變量和像

1666
01:22:42,570 --> 01:22:44,610
他們用下劃線分隔。

1667
01:22:44,610 --> 01:22:52,170
而且，我認為最重要的是，像
例如，壓痕，對不對？

1668
01:22:52,170 --> 01:22:56,440
>> 我們花括號開始的地方
的條件是，它們

1669
01:22:56,440 --> 01:22:57,730
是從下一行的。

1670
01:22:57,730 --> 01:23:01,230
而我們也把花括號中
即使是只有一條線。

1671
01:23:01,230 --> 01:23:06,100
而很多時候，有很多方法可以做
它在那裡你可以將這些括號

1672
01:23:06,100 --> 01:23:08,380
如果是只有一條線斷
下的If語句。

1673
01:23:08,380 --> 01:23:12,070
但在這個類中，我們要遵循
具體風格指南只是讓你得到

1674
01:23:12,070 --> 01:23:13,550
用之類的事情。

1675
01:23:13,550 --> 01:23:16,410
>> 羅伯：是啊，50款將要
執行本風格指南，我們很

1676
01:23:16,410 --> 01:23:18,080
要使用樣式50
分級代碼。

1677
01:23:18,080 --> 01:23:25,150
因此，它使事情變得更容易為我們和
希望不要把事情說

1678
01:23:25,150 --> 01:23:30,120
為你提供了很多糟糕的
標準化的風格不應該是

1679
01:23:30,120 --> 01:23:31,460
不現實的。

1680
01:23:31,460 --> 01:23:36,000
>> 約瑟夫：最後，找到風格
引導，去manual.cs50.net/style。

1681
01:23:36,000 --> 01:23:37,725
，是的。

1682
01:23:37,725 --> 01:23:40,575
>> 揚聲器4：你要強制執行
每行的所有字符？

1683
01:23:40,575 --> 01:23:42,480
>> 羅伯：是的。

1684
01:23:42,480 --> 01:23:45,405
>> 約瑟夫：對不起，伙計們。

1685
01:23:45,405 --> 01:23:47,680
>> 羅伯：這就像唯一的一個。

1686
01:23:47,680 --> 01:23:50,420
在這一點上，我與120確定。

1687
01:23:50,420 --> 01:23:52,460
我跟說120行
每行的字符。

1688
01:23:52,460 --> 01:23:53,830
據我所知，被一些限制。

1689
01:23:53,830 --> 01:23:57,130
我覺得80是如此之小，但
我們正在執行它。

1690
01:23:57,130 --> 01:24:00,260
>> 約瑟夫：我個人認為，用
C，80個字符是比較確定。

1691
01:24:00,260 --> 01:24:04,160
一旦你開始給其他
語言如JavaScript和PHP，不

1692
01:24:04,160 --> 01:24:08,860
所以合理的，只是限制
它為80個字符。

1693
01:24:08,860 --> 01:24:09,260
確定。

1694
01:24:09,260 --> 01:24:12,780
嗯，這是超級節。

1695
01:24:12,780 --> 01:24:14,750
有誰要糖果？

1696
01:24:14,750 --> 01:24:16,000
>> 揚聲器4：是的。

1697
01:24:16,000 --> 01:24:18,667