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

2
00:00:11,120 --> 00:00:12,590
>> 喇叭：我聽不清。

3
00:00:12,590 --> 00:00:14,820
我萊弗里特樓的高級。

4
00:00:14,820 --> 00:00:18,700
我是學計算機科學，
我就是一個TF CS50。

5
00:00:18,700 --> 00:00:21,640
作為一個新生，我什至沒有
一台筆記本電腦或智能手機。

6
00:00:21,640 --> 00:00:23,550
我有沒有編程經驗。

7
00:00:23,550 --> 00:00:29,690
CS50是最難忘的課程，
我拿了，因為它是在哈佛

8
00:00:29,690 --> 00:00:32,960
一場鬥爭，但它是一個真正的
同時的樂趣鬥爭。

9
00:00:32,960 --> 00:00:37,670
我做了很多驚人的，永久的
朋友，我真的學到了很多東西

10
00:00:37,670 --> 00:00:38,830
適用技能。

11
00:00:38,830 --> 00:00:43,480
我只是很高興，我沒有讓我的
缺乏背景是我的藉口

12
00:00:43,480 --> 00:00:44,840
不CS50。

13
00:00:44,840 --> 00:00:46,220
我聽不清。

14
00:00:46,220 --> 00:00:48,910
我是一個高級萊弗里特
房子，類2014年。

15
00:00:48,910 --> 00:00:51,670
我把CS50。

16
00:00:51,670 --> 00:00:52,380
>> DAVID馬蘭：所以這是CS50。

17
00:00:52,380 --> 00:00:54,400
這是週零年底。

18
00:00:54,400 --> 00:00:58,500
記得在那裡我們開始了最後一次，
這些燈，這是

19
00:00:58,500 --> 00:01:01,420
如此受歡迎，我們去
買了一些今天。

20
00:01:01,420 --> 00:01:03,790
所以，我認為這將是
我們的事今年 - 

21
00:01:03,790 --> 00:01:07,230
檯燈，如果你來到舞台上，
至少要等到我們用完。

22
00:01:07,230 --> 00:01:11,570
>> 但是，我們使用這些召回，給大家介紹
基礎數據的代表性。

23
00:01:11,570 --> 00:01:15,640
我們需要的方式開始代表
一台計算機內的信息。

24
00:01:15,640 --> 00:01:18,650
而最簡單的辦法做到這一點是
一個成分，電力。

25
00:01:18,650 --> 00:01:21,760
最簡單的事情可以做，
電力是打開它，它關閉。

26
00:01:21,760 --> 00:01:23,520
讓電子流與否。

27
00:01:23,520 --> 00:01:27,930
使用這兩種基本狀態，關閉
和，虛假和真實的，或零和

28
00:01:27,930 --> 00:01:31,290
一，我們開始看到，我們可以建立
了，在這種情況下，與光

29
00:01:31,290 --> 00:01:33,720
燈泡，更多的數字比
只有零和一。

30
00:01:33,720 --> 00:01:36,160
我們七算作高，
例如，最後一次。

31
00:01:36,160 --> 00:01:38,840
但是，所有我們需要做的是不斷的扔
越來越亮的燈泡

32
00:01:38,840 --> 00:01:41,820
問題，說真的，我們可以代表
任何數字，我們

33
00:01:41,820 --> 00:01:42,970
可能想要的。

34
00:01:42,970 --> 00:01:47,230
>> 好吧，我們上，然後迅速過渡
週三這個字節的志願者。

35
00:01:47,230 --> 00:01:52,040
8位是什麼，我們一般稱之為一個字節，
所以在這裡，我們有8個志願者

36
00:01:52,040 --> 00:01:54,900
上週三統稱
佔8位。

37
00:01:54,900 --> 00:01:56,750
而當他們的手去
了，他們分別為一個。

38
00:01:56,750 --> 00:01:58,530
而當他們的手
下來，有一個零。

39
00:01:58,530 --> 00:02:01,970
我們這些人
拿出在舞台上，為什麼？

40
00:02:01,970 --> 00:02:06,530
我們能夠做到什麼
這個序列的比特？

41
00:02:06,530 --> 00:02:07,510
>> 要創建一個字母。

42
00:02:07,510 --> 00:02:11,550
最重要的是我們能夠建立
以前的教訓，實際上

43
00:02:11,550 --> 00:02:14,200
開始做更有趣
的信息，至少有

44
00:02:14,200 --> 00:02:15,330
我們人類所熟悉。

45
00:02:15,330 --> 00:02:18,360
這是怎麼回事是一個反复出現
50主題貫穿，但電腦

46
00:02:18,360 --> 00:02:21,470
科學更一般地，這一想法
分層，其中，在結束的

47
00:02:21,470 --> 00:02:24,820
一天，如果你真正開始
與計算機的基本知識，是的，

48
00:02:24,820 --> 00:02:25,760
這是零和的。

49
00:02:25,760 --> 00:02:27,480
下面，它是
只是電力。

50
00:02:27,480 --> 00:02:30,840
但是，我們非常迅速地開始採取這些
低級別的細節是理所當然的

51
00:02:30,840 --> 00:02:35,600
，並開始在過去工作層
這樣做，我們最終

52
00:02:35,600 --> 00:02:38,610
學期結束的時候，真的，
更普遍的計算機科學家

53
00:02:38,610 --> 00:02:42,790
和程序員，可以做一些真正
強大的東西利用工作

54
00:02:42,790 --> 00:02:46,620
我們自己也做了，也
站在別人的肩膀上。

55
00:02:46,620 --> 00:02:49,300
>> 現在，我們很快就轉換日（星期三）
只需要

56
00:02:49,300 --> 00:02:52,080
希望代表信息
用它做什麼。

57
00:02:52,080 --> 00:02:54,170
所以我們定義是什麼算法？

58
00:02:54,170 --> 00:02:57,340

59
00:02:57,340 --> 00:02:58,900
一系列指令。

60
00:02:58,900 --> 00:03:03,380
所以這是一個系列的指令，
數的步驟，您的人，或

61
00:03:03,380 --> 00:03:07,160
一台計算機，更典型地，對
為了執行一前一後

62
00:03:07,160 --> 00:03:08,100
實現某種目標。

63
00:03:08,100 --> 00:03:11,360
我們有幾個目標最後一次，
其中之一是計數

64
00:03:11,360 --> 00:03:12,250
房間裡的人。

65
00:03:12,250 --> 00:03:15,560
另一個這樣的例子是要找到
麥克·史密斯在電話簿。

66
00:03:15,560 --> 00:03:19,750
>> 所以，你可能還記得，我撕了電話
本書一半向為此

67
00:03:19,750 --> 00:03:21,280
找到邁克·斯密。

68
00:03:21,280 --> 00:03:24,000
視覺的目的，是為了
再次證明，我們

69
00:03:24,000 --> 00:03:27,770
此問題在字面上撕裂
一半一半，一半，而且很

70
00:03:27,770 --> 00:03:31,750
很快像1000頁
只是一個單頁。

71
00:03:31,750 --> 00:03:34,860
那些你們誰錯過了這個
週三，我想我們會回放

72
00:03:34,860 --> 00:03:36,820
一些鏡頭，你錯過了什麼。

73
00:03:36,820 --> 00:03:38,914
讓我們來看看。

74
00:03:38,914 --> 00:03:40,906
>> [視頻回放]

75
00:03:40,906 --> 00:03:55,360

76
00:03:55,360 --> 00:03:55,990
>> 我們有去。

77
00:03:55,990 --> 00:04:01,432
1500頁，漂亮乾淨的線，
合法撕裂。

78
00:04:01,432 --> 00:04:02,850
>> [END視頻播放]

79
00:04:02,850 --> 00:04:05,230
>> DAVID馬蘭：所以這是星期三。

80
00:04:05,230 --> 00:04:09,150
我們過渡，雖然上週三
想代表算法

81
00:04:09,150 --> 00:04:12,410
在使用一些標準的方式，不只是
他們口頭描述，但

82
00:04:12,410 --> 00:04:16,290
他們在書面或試圖表達
電腦屏幕上，以便我們能

83
00:04:16,290 --> 00:04:19,170
開始改善，並修改
它們，並且，最終，實際上

84
00:04:19,170 --> 00:04:21,160
分析是多麼正確
有多快他們。

85
00:04:21,160 --> 00:04:23,360
>> 因此，我們推出這個概念
的偽代碼，其中，在

86
00:04:23,360 --> 00:04:26,410
通俗地說，是什麼呢？

87
00:04:26,410 --> 00:04:26,930
OK，詞。

88
00:04:26,930 --> 00:04:28,730
讓我們去更深一點。

89
00:04:28,730 --> 00:04:32,540
英語，肯定，但
朝什麼目的呢？

90
00:04:32,540 --> 00:04:35,180
話來創建或
來表示的算法。

91
00:04:35,180 --> 00:04:38,380
因此，有沒有一種語言稱為
作為在世界上的偽代碼。

92
00:04:38,380 --> 00:04:41,110
這只是你的英語，或
無論你的口語，使用

93
00:04:41,110 --> 00:04:44,930
粗略的符號來傳達一種
一個想法非常簡潔的。

94
00:04:44,930 --> 00:04:47,930
但是，我們會看到，肯定與
英語的偽代碼，原來

95
00:04:47,930 --> 00:04:51,700
大多數編程語言本身
英語本身衍生，

96
00:04:51,700 --> 00:04:55,750
我們會發現，有一些標準
代表偽代碼的方式和

97
00:04:55,750 --> 00:04:57,150
編程代碼。

98
00:04:57,150 --> 00:05:00,200
因此，當你開始看到即使是最簡單的
今天的例子，實現這些

99
00:05:00,200 --> 00:05:02,160
相同的圖案會復發下週。

100
00:05:02,160 --> 00:05:04,710
>> 因此，偽代碼是某種
語言類似

101
00:05:04,710 --> 00:05:06,170
一種編程語言。

102
00:05:06,170 --> 00:05:09,260
和第一個例子中，我們看到的視覺
寫下來是這一個。

103
00:05:09,260 --> 00:05:12,870
這只是一個三步計劃，
這是目標的數量來計算

104
00:05:12,870 --> 00:05:15,650
宿舍的人
週三上的影片。

105
00:05:15,650 --> 00:05:19,040
但也有一些有趣的方面
這個簡單的程序。

106
00:05:19,040 --> 00:05:20,320
>> 這將是反复出現的主題。

107
00:05:20,320 --> 00:05:22,930
因此，對於那些不熟悉
這一點，我們，我們引入了一個變量。

108
00:05:22,930 --> 00:05:25,650
這個房間裡的每個人都可能
熟悉與產品中的一個變量

109
00:05:25,650 --> 00:05:27,250
代數的上下文。

110
00:05:27,250 --> 00:05:31,190
但在這裡，在編程中，變量
，一，可以

111
00:05:31,190 --> 00:05:32,220
叫我們想要的東西。

112
00:05:32,220 --> 00:05:33,620
我們一直在使用n作為一個計數器。

113
00:05:33,620 --> 00:05:37,490
不過，我們可以使用字計數器，或
你會看到，大多數的任何短語

114
00:05:37,490 --> 00:05:40,240
你可能會喜歡這麼長時間，因為它是
描述性的，但它真的只是一個

115
00:05:40,240 --> 00:05:41,250
貯存容器。

116
00:05:41,250 --> 00:05:44,170
這是一個內存塊，一定數量的
位，並且不同的電腦，如何

117
00:05:44,170 --> 00:05:47,020
有多少位，
撰寫該變量。

118
00:05:47,020 --> 00:05:48,450
>> 但我們可以把它的值。

119
00:05:48,450 --> 00:05:50,740
到目前為止，我們只把號碼。

120
00:05:50,740 --> 00:05:52,290
但我們可以把實際的話。

121
00:05:52,290 --> 00:05:53,420
我們可以把段落。

122
00:05:53,420 --> 00:05:54,560
我們可以把圖像 - 

123
00:05:54,560 --> 00:05:57,860
什麼，真的，我們可以代表
零和的，我們可以把在

124
00:05:57,860 --> 00:05:59,820
這個更高層次的概念
一個變量。

125
00:05:59,820 --> 00:06:01,350
>> 所以有相當平直向前。

126
00:06:01,350 --> 00:06:02,210
線之一。

127
00:06:02,210 --> 00:06:05,340
但我們從移動非常迅速
真正做到行

128
00:06:05,340 --> 00:06:06,600
與該變量的東西。

129
00:06:06,600 --> 00:06:10,330
而第三行中，我們更新N.
遞增N.，我們可以寫

130
00:06:10,330 --> 00:06:11,330
任何數量的方式。

131
00:06:11,330 --> 00:06:14,460
但也許是最明顯的是
只是說，將N等於

132
00:06:14,460 --> 00:06:16,440
N是加1。

133
00:06:16,440 --> 00:06:17,740
所以這是我們的增量。

134
00:06:17,740 --> 00:06:18,740
>> 同時，有一個循環。

135
00:06:18,740 --> 00:06:20,720
而這其中，也可能是
非常直觀。

136
00:06:20,720 --> 00:06:24,250
環路僅僅是在程序的東西
一次又一次地發生，有些

137
00:06:24,250 --> 00:06:25,190
樣的週期。

138
00:06:25,190 --> 00:06:29,300
而這在這裡，關鍵短語，
在大多數其實很普遍

139
00:06:29,300 --> 00:06:32,300
編程語言，包括
我們在使用過程中會看到。

140
00:06:32,300 --> 00:06:35,850
每當你看到這個詞的話，那
通常傳達的想法，

141
00:06:35,850 --> 00:06:38,410
循環，週期性的東西，
即將發生。

142
00:06:38,410 --> 00:06:40,980
>> 但是，這是值得注意的一個
其他句法的細節。

143
00:06:40,980 --> 00:06:44,660
的事實，第三行
實際上曾觸及的縮進

144
00:06:44,660 --> 00:06:46,920
空格幾次是經過深思熟慮的。

145
00:06:46,920 --> 00:06:49,870
因為人類的慣例是這樣的，
當你正在做的事情再次

146
00:06:49,870 --> 00:06:54,860
再次，在一個循環中，開始上線兩條，
你縮進任何屬於

147
00:06:54,860 --> 00:06:58,880
該迴路只是作出明確規定
一行三人，而不是，例如，

148
00:06:58,880 --> 00:07:01,910
行，如果有四個或五個
線或五個，是

149
00:07:01,910 --> 00:07:03,010
該循環的一部分。

150
00:07:03,010 --> 00:07:07,340
因此，這個簡單的壓痕
傳達這一基本想法。

151
00:07:07,340 --> 00:07:09,390
>> 因此，我們應用這個算法，
現在，列舉幾個例子。

152
00:07:09,390 --> 00:07:12,620
而這，也簡單的例子
在現實世界中。

153
00:07:12,620 --> 00:07:15,440
但是它要能代表
你將如何去有關測試

154
00:07:15,440 --> 00:07:17,500
擁有日益複雜的程序。

155
00:07:17,500 --> 00:07:21,050
你嘗試了一些場景，一些
代表輸入，看是否

156
00:07:21,050 --> 00:07:22,180
獲得所需的輸出。

157
00:07:22,180 --> 00:07:25,090
>> 因此，這個例子中有兩個人
坐在宿舍裡。

158
00:07:25,090 --> 00:07:27,170
在左邊是相同的偽代碼。

159
00:07:27,170 --> 00:07:30,800
而且這是一個非常的屏幕快照
在此應用程序的最後一步

160
00:07:30,800 --> 00:07:35,270
算法的輸入，那裡
兩個人在房間裡，

161
00:07:35,270 --> 00:07:39,190
還記得，我們​​通過加強線之一，
和二，三，和兩個

162
00:07:39,190 --> 00:07:41,000
三和做 - 

163
00:07:41,000 --> 00:07:44,870
年底該算法，我們有
的確算的兩個傢伙誰是

164
00:07:44,870 --> 00:07:45,360
在房間裡。

165
00:07:45,360 --> 00:07:47,190
>> 那麼我們嘗試另一個例子。

166
00:07:47,190 --> 00:07:48,990
我們說什麼，如果有
零房間裡的人？

167
00:07:48,990 --> 00:07:50,490
這是代碼仍然是正確的嗎？

168
00:07:50,490 --> 00:07:51,305
的確是。

169
00:07:51,305 --> 00:07:55,240
它只是恰巧線兩條
線，因此，三個或

170
00:07:55,240 --> 00:07:56,620
不會執行。

171
00:07:56,620 --> 00:07:59,790
他們不會發生的事情
因為他們只是如果不適用

172
00:07:59,790 --> 00:08:01,210
還有人在房間為零。

173
00:08:01,210 --> 00:08:02,300
>> 但不是什麼大不了的。

174
00:08:02,300 --> 00:08:06,620
線一個初始化的N為零，所以
即使只有一個線

175
00:08:06,620 --> 00:08:10,930
方案實際上最終是有用的，
它仍然得到了正確的答案，

176
00:08:10,930 --> 00:08:13,780
以橙色顯示
零在底部。

177
00:08:13,780 --> 00:08:16,300
但後​​來我們決定，
樣一個愚蠢的算法。

178
00:08:16,300 --> 00:08:17,060
這是相當緩慢的。

179
00:08:17,060 --> 00:08:19,720
當然，我可以做二，四，
六，八，十，當

180
00:08:19,720 --> 00:08:20,990
計數的人在一個房間裡。

181
00:08:20,990 --> 00:08:25,030
>> 因此，我們調整了算法，
偽代碼，可以說，現在在二號線，

182
00:08:25,030 --> 00:08:29,710
每對房間裡的人，
進行第三行中，增量

183
00:08:29,710 --> 00:08:32,200
在每次迭代兩個。

184
00:08:32,200 --> 00:08:35,530
因此，這將在這裡工作
這對在房間裡的人。

185
00:08:35,530 --> 00:08:38,530
>> 然而，如果你開始思考
這一點，它並不需要很長時間，

186
00:08:38,530 --> 00:08:40,710
實現好，等待一分鐘，這是
要打破，打破

187
00:08:40,710 --> 00:08:42,679
在什麼情況下，簡單嗎？

188
00:08:42,679 --> 00:08:45,500
如果有三個人在房間裡，
更普遍的是，當有一個

189
00:08:45,500 --> 00:08:47,660
人們在奇數
室，其中包括。

190
00:08:47,660 --> 00:08:50,390
我們會想念這裡，因為那個人
有沒有這樣的對。

191
00:08:50,390 --> 00:08:58,510
因此，我們迅速解決，而不是
引進什麼額外的

192
00:08:58,510 --> 00:09:02,560
編程結構
的偽代碼。

193
00:09:02,560 --> 00:09:04,955
>> 所以一個條件，我們叫
，或者是分支。

194
00:09:04,955 --> 00:09:08,420
它要傳達，視覺，
分支的想法，一個岔路口

195
00:09:08,420 --> 00:09:11,080
在那裡你可以做到這一點
或者，也許別的東西。

196
00:09:11,080 --> 00:09:15,750
事實上，我們解決這個問題，
加入線4條，說，真的，

197
00:09:15,750 --> 00:09:20,820
結束，如果一個人仍然存在，
然後繼續前進，指望他們的特殊。

198
00:09:20,820 --> 00:09:24,460
所以，你的特殊情況下，他們的排序，所以
說話，讓我們現在可以處理

199
00:09:24,460 --> 00:09:27,810
一個偶數的人
和奇數號碼的人。

200
00:09:27,810 --> 00:09:30,260
>> 現在有任何數目的方式
我們可以表達這一點。

201
00:09:30,260 --> 00:09:33,590
坦率地說，我會一直更
挑剔挑剔的，當它來到我的選擇

202
00:09:33,590 --> 00:09:35,040
英國的偽。

203
00:09:35,040 --> 00:09:36,970
但至少精神
的想法轉達了。

204
00:09:36,970 --> 00:09:40,725
如果你把這個代碼給朋友
誰不是在CS，或者從來沒有採取

205
00:09:40,725 --> 00:09:44,560
CS，賠率是他們能想出，
三個房間裡的人，如何

206
00:09:44,560 --> 00:09:46,870
指望那些人
這些說明。

207
00:09:46,870 --> 00:09:49,920
而這一切我們真的要實現
偽代碼，不知何故

208
00:09:49,920 --> 00:09:54,300
我們如何去規範
代表想法，這樣我們就可以

209
00:09:54,300 --> 00:09:56,670
開始做更複雜
東西還在。

210
00:09:56,670 --> 00:09:58,845
>> 所以導致我們的話，今天，
實際代碼。

211
00:09:58,845 --> 00:10:01,950
我們開始今天的節目，儘管
在友好的環境。

212
00:10:01,950 --> 00:10:05,940
然後，我們非常迅速地過渡
的更艱澀難懂的語法，而是一個

213
00:10:05,940 --> 00:10:10,340
你將看到的是基本相同的
的想法會看到表現

214
00:10:10,340 --> 00:10:11,990
今天這個其他語言。

215
00:10:11,990 --> 00:10:13,920
它只是去看看
有一點不同。

216
00:10:13,920 --> 00:10:16,590
>> 因此，而不是只是調用此代碼，我
更確切的一點

217
00:10:16,590 --> 00:10:20,170
和說，從今以後，當寫
程序，你寫的源代碼。

218
00:10:20,170 --> 00:10:21,990
這是一種像偽代碼。

219
00:10:21,990 --> 00:10:26,540
但是，我們會看到它是不是有點鬆動
當涉及到選擇的話，

220
00:10:26,540 --> 00:10:27,310
您使用。

221
00:10:27,310 --> 00:10:31,300
當編程的語言，你必須
使用的單詞，短語，

222
00:10:31,300 --> 00:10:36,020
的語法，這其他人
決定代表

223
00:10:36,020 --> 00:10:37,240
特定的語言。

224
00:10:37,240 --> 00:10:38,510
所以pseudocodes給你。

225
00:10:38,510 --> 00:10:42,330
一個實際的編程語言，如
C，因為我們最終會看到，

226
00:10:42,330 --> 00:10:43,590
標準化是由其他人。

227
00:10:43,590 --> 00:10:45,590
>> 那麼，我們如何去寫
一些源代碼？

228
00:10:45,590 --> 00:10:46,810
嗯，我要去
進取，做到這一點。

229
00:10:46,810 --> 00:10:49,100
我要繼續前進，
在這裡打開一個窗口。

230
00:10:49,100 --> 00:10:50,210
更多關於這個下星期。

231
00:10:50,210 --> 00:10:52,300
但是，這是一種叫做
的CS50家電。

232
00:10:52,300 --> 00:10:55,480
我在我運行一個軟件
Mac上，但你可以做同樣的事情

233
00:10:55,480 --> 00:11:00,580
在Windows計算機上，是給
我的錯覺運行不同

234
00:11:00,580 --> 00:11:03,700
操作系統完全正確
在我的Mac上的一個窗口。

235
00:11:03,700 --> 00:11:06,790
我剛剛滿篩選，讓你不
實際上，現在的Mac OS。

236
00:11:06,790 --> 00:11:08,340
>> 這是一個操作系統
稱為Linux。

237
00:11:08,340 --> 00:11:09,300
這是非常流行的。

238
00:11:09,300 --> 00:11:10,120
這是非常快的。

239
00:11:10,120 --> 00:11:12,950
這是很自由，很
引人注目的，尤其是在

240
00:11:12,950 --> 00:11:13,970
商業世界。

241
00:11:13,970 --> 00:11:17,200
和上向端的
當我們使用Linux頗有幾分學期

242
00:11:17,200 --> 00:11:21,230
網頁編程與託管
實際的網站和項目。

243
00:11:21,230 --> 00:11:24,910
所以，現在，只知道這是一個桌面
這意味著隱約看

244
00:11:24,910 --> 00:11:26,750
熟悉Windows和Mac OS。

245
00:11:26,750 --> 00:11:29,110
它只是有一些不同的名字
及的事情圖標。

246
00:11:29,110 --> 00:11:32,510
但是，這是所謂的CS50
設備的虛擬機，

247
00:11:32,510 --> 00:11:35,310
從下週開始，你們會
內部運行的一個窗口，

248
00:11:35,310 --> 00:11:36,960
你自己的Mac或PC。

249
00:11:36,960 --> 00:11:39,760
>> 今天，我要開拓
最簡單的方案。

250
00:11:39,760 --> 00:11:41,110
這就是所謂的gedit的。

251
00:11:41,110 --> 00:11:42,565
而這僅僅是一個圖形編輯器。

252
00:11:42,565 --> 00:11:44,695
這是一種像微軟
字，但更簡單。

253
00:11:44,695 --> 00:11:47,110
這是一種類似文本
編輯或記事本。

254
00:11:47,110 --> 00:11:50,280
這只是一個很簡單的程序，
寫屏幕上的字。

255
00:11:50,280 --> 00:11:54,510
它只是會發生什麼，如果我救
這個程序時創建的文件，我

256
00:11:54,510 --> 00:11:59,860
像C，而不是在一個特殊的擴展
DOC，或XLS，或任何

257
00:11:59,860 --> 00:12:04,190
你熟悉的，其實我可以
甚至使用這個簡單的創建程序

258
00:12:04,190 --> 00:12:05,130
文本編輯器。

259
00:12:05,130 --> 00:12:05,770
>> 因此，讓我做到這一點。

260
00:12:05,770 --> 00:12:09,330
讓我繼續前進，並保存此
先向作為HELLO.C。

261
00:12:09,330 --> 00:12:12,350
再次，這個用戶界面將
迅速變得熟悉你。

262
00:12:12,350 --> 00:12:14,160
但是現在，我只是打字
在一個文件名。

263
00:12:14,160 --> 00:12:17,410
我打算將它保存到我的約翰
哈佛家裡目錄。

264
00:12:17,410 --> 00:12:20,810
現在我有這個標籤，表示
我的確編輯

265
00:12:20,810 --> 00:12:23,070
一個文件名為hello.c。

266
00:12:23,070 --> 00:12:24,510
所以沒有什麼太有趣了。

267
00:12:24,510 --> 00:12:26,000
>> 現在，它要
得到相當神秘。

268
00:12:26,000 --> 00:12:28,370
我要放大，只是
所以它的更為明顯。

269
00:12:28,370 --> 00:12:35,780
我要開始打字包括
stdio.h中，詮釋主，無效的，開放的捲髮

270
00:12:35,780 --> 00:12:40,140
撐，一個，兩個，三個，四個空格
壓痕，印刷F，打印

271
00:12:40,140 --> 00:12:44,450
格式化的東西，報價引文結束，
“你好，世界”反斜線，正，靠近

272
00:12:44,450 --> 00:12:49,640
報價，封閉括號，分號，
進入退格鍵，退格鍵，退格，

273
00:12:49,640 --> 00:12:52,310
退格，閉花括號 - 

274
00:12:52,310 --> 00:12:53,350
我已編程。

275
00:12:53,350 --> 00:12:57,380
>> 所有的權利，所以這是一個超級簡單
程序，真正的程序

276
00:12:57,380 --> 00:12:59,070
有人開始編程。

277
00:12:59,070 --> 00:13:02,300
它所做的一切，其複雜性，
被打印出來

278
00:13:02,300 --> 00:13:04,160
屏幕上，你猜是什麼？

279
00:13:04,160 --> 00:13:04,910
世界，你好。

280
00:13:04,910 --> 00:13:07,500
但它不是足夠的剛
寫一個程序。

281
00:13:07,500 --> 00:13:08,155
因此，這是代碼。

282
00:13:08,155 --> 00:13:11,300
這是源代碼
一個名為c語言。

283
00:13:11,300 --> 00:13:14,380
目前保存在
一個文件名為hello.c。

284
00:13:14,380 --> 00:13:16,180
>> 現在看底部
這裡的畫面。

285
00:13:16,180 --> 00:13:17,890
此，再次，
今後幾個星期。

286
00:13:17,890 --> 00:13:19,570
但是，這就是我們會打電話
一個終端窗口。

287
00:13:19,570 --> 00:13:21,290
這是一個閃爍，黑色
和白色的提示。

288
00:13:21,290 --> 00:13:24,390
這是一個老同學的接口
一台電腦，一般不

289
00:13:24,390 --> 00:13:27,050
使用鼠標或其他
圖形元素。

290
00:13:27,050 --> 00:13:28,320
它只是使用你的鍵盤。

291
00:13:28,320 --> 00:13:30,970
我可以輸入命令
這個閃爍提示。

292
00:13:30,970 --> 00:13:33,820
>> 而對於今天的目的，我只是
鍵入以下 - 

293
00:13:33,820 --> 00:13:35,610
使打招呼。

294
00:13:35,610 --> 00:13:39,370
並且該程序，製作，僅僅是一個
程序，在現實世界中這些

295
00:13:39,370 --> 00:13:40,690
天，我們就雙擊。

296
00:13:40,690 --> 00:13:44,580
但在今天這個接口，我們
要在此提示下鍵入其名稱。

297
00:13:44,580 --> 00:13:47,980
使打招呼字面上去
讓我一個程序名為hello。

298
00:13:47,980 --> 00:13:51,360
它要尋找這樣做
文件，只需通過

299
00:13:51,360 --> 00:13:53,460
默認情況下，名為hello.c。

300
00:13:53,460 --> 00:13:57,260
這將假設我想要一個C程序
此計算機的性質

301
00:13:57,260 --> 00:13:58,230
配置。

302
00:13:58,230 --> 00:13:59,550
>> 所以，我繼續前進，按下回車鍵。

303
00:13:59,550 --> 00:14:02,050
我看到一些神秘的輸出，但
這將成為太

304
00:14:02,050 --> 00:14:03,330
熟悉用不了多久。

305
00:14:03,330 --> 00:14:06,870
這發生在運行一個編譯器，更
在某一時刻，被稱為鏘。

306
00:14:06,870 --> 00:14:09,080
但是現在，我已經有了只是另一個
閃爍提示。

307
00:14:09,080 --> 00:14:13,060
現在，我可以繼續鍵入點
斜線，無趣的原因，我們會

308
00:14:13,060 --> 00:14:14,730
下週回來 - 

309
00:14:14,730 --> 00:14:15,910
打招呼。

310
00:14:15,910 --> 00:14:19,650
>> 因此，所有這方面的努力迄今只是
編寫簡單的程序，

311
00:14:19,650 --> 00:14:22,640
只要我一敲回車，這樣做的。

312
00:14:22,640 --> 00:14:24,510
因此，我寫我的第一個程序。

313
00:14:24,510 --> 00:14:27,500
所以我故意取笑
這個非常簡單的程序

314
00:14:27,500 --> 00:14:28,540
一對夫婦的原因。

315
00:14:28,540 --> 00:14:31,990
一，它是很難興奮起來
一類，如果

316
00:14:31,990 --> 00:14:33,430
這是比賽結束。

317
00:14:33,430 --> 00:14:37,100
>> 但更重要的是，有一個
很多分心這裡。

318
00:14:37,100 --> 00:14:40,640
當您第一次學習程序，
那些你不舒服，

319
00:14:40,640 --> 00:14:43,410
就連我，早在一天，當我第一次
看到這樣的事情 - 你可以

320
00:14:43,410 --> 00:14:46,500
圖，所有的權利，這
在打印的hello world。

321
00:14:46,500 --> 00:14:47,860
但有這麼多的分心。

322
00:14:47,860 --> 00:14:52,110
在屏幕上有這麼多的語法
它得到的方式很

323
00:14:52,110 --> 00:14:54,170
簡單，否則簡單的想法。

324
00:14:54,170 --> 00:14:56,700
>> 所以我們今天要做的是，我們
拋開C和來

325
00:14:56,700 --> 00:14:57,630
回到上週一。

326
00:14:57,630 --> 00:15:00,860
我們要使用圖形
編程語言，叫划痕。

327
00:15:00,860 --> 00:15:04,470
這是一種編程語言，我
上週三提到的，這是怎麼回事

328
00:15:04,470 --> 00:15:08,870
讓我們做同一種東西
但視而不見，今天，

329
00:15:08,870 --> 00:15:12,270
大括號，括號，
分號，所有這些愚蠢的

330
00:15:12,270 --> 00:15:15,680
分心的方式獲得，
這第一天，一些基本的，漂亮的

331
00:15:15,680 --> 00:15:17,230
有趣的想法。

332
00:15:17,230 --> 00:15:21,350
>> 為此，我要去
回到我的桌面在這裡

333
00:15:21,350 --> 00:15:25,890
給你介紹替代
程序，這是怎麼回事，看起來

334
00:15:25,890 --> 00:15:30,790
光這一點東西。

335
00:15:30,790 --> 00:15:33,930
這就是我們要實現該
今天的節目 - 兩個難題

336
00:15:33,930 --> 00:15:37,710
件時，互鎖
點擊，將走向世界，說：

337
00:15:37,710 --> 00:15:39,000
你好世界。

338
00:15:39,000 --> 00:15:41,200
>> 因此，讓我們去那裡。

339
00:15:41,200 --> 00:15:44,965
所以我要繼續前進，並打開一個
網站被稱為scratch.mit.edu。

340
00:15:44,965 --> 00:15:47,980

341
00:15:47,980 --> 00:15:52,040
而這將導致我
這個網站在這裡。

342
00:15:52,040 --> 00:15:54,660
在前進，我已經登錄到這個
網站的第一個問題，

343
00:15:54,660 --> 00:15:55,910
將步行通過
一些步驟。

344
00:15:55,910 --> 00:15:58,930
我要繼續前進，然後按一下
這裡我從頭文件夾。

345
00:15:58,930 --> 00:16:00,720
>> 而這是要告訴我
一些項目，我

346
00:16:00,720 --> 00:16:02,570
實際上預先創建。

347
00:16:02,570 --> 00:16:05,860
而事實證明，此圖形
編程語言不僅是怎麼回事

348
00:16:05,860 --> 00:16:08,480
讓我們計劃通過拖放
丟棄這些拼圖，

349
00:16:08,480 --> 00:16:09,730
甚至不需要特殊的軟件。

350
00:16:09,730 --> 00:16:13,190
這一切都嵌入在瀏覽器內，所以
你可以做到這一點，在理論上，

351
00:16:13,190 --> 00:16:16,810
您的計算機現在，你們有些人
很可能，甚至無需

352
00:16:16,810 --> 00:16:19,870
軟件像CS50家電，
下週來。

353
00:16:19,870 --> 00:16:24,200
>> 所以我要上去右上角
在這裡，點擊創建。

354
00:16:24,200 --> 00:16:27,840
在某一時刻，我要得到一個空白
屏幕，通過它，我就可以開始

355
00:16:27,840 --> 00:16:30,380
此圖形編程
編程環境。

356
00:16:30,380 --> 00:16:36,140
但是這一次，它會是多少，
要簡單得多，實際上這樣做。

357
00:16:36,140 --> 00:16:41,560
因此，在短短的時刻，當無線網絡連接
合作，我們現在有這樣的畫面。

358
00:16:41,560 --> 00:16:44,870
所以簡單的口頭之旅，但我敢說，
當然，當你潛入

359
00:16:44,870 --> 00:16:46,840
第一個問題集，你會
發現這一切非常

360
00:16:46,840 --> 00:16:48,315
訪問和相當直觀。

361
00:16:48,315 --> 00:16:50,900
但是，讓我們畫一個心理圖片
只是一瞬間。

362
00:16:50,900 --> 00:16:54,620
>> 因此，下面這個提示說保存
變化，你從頭看到。

363
00:16:54,620 --> 00:16:55,570
這是一個精靈。

364
00:16:55,570 --> 00:16:56,630
這是一個字符。

365
00:16:56,630 --> 00:17:00,740
和他住在我們就這麼叫一個階段，
這個大的白色矩形

366
00:17:00,740 --> 00:17:03,120
，他可以向上，向下，向左，
正確的，做的，真的，

367
00:17:03,120 --> 00:17:04,670
其他類型的動作。

368
00:17:04,670 --> 00:17:08,780
>> 同時，在中間的該用戶的
接口，我們有一大堆

369
00:17:08,780 --> 00:17:09,750
拼圖碎片。

370
00:17:09,750 --> 00:17:14,060
你會看到，他們說這樣的話，
移動10步，轉身15度，

371
00:17:14,060 --> 00:17:15,550
在目標方向上的點。

372
00:17:15,550 --> 00:17:17,910
但有類別
塊。

373
00:17:17,910 --> 00:17:21,410
所以，如果我去的外觀，你會看到，
還有其他拼圖

374
00:17:21,410 --> 00:17:25,530
顯然會告訴這CIT
打個招呼，去思考，去展示

375
00:17:25,530 --> 00:17:26,780
自己，隱藏​​自己。

376
00:17:26,780 --> 00:17:30,830
如果我走下來的聲音，它的出現
的方式來播放聲音，如喵，

377
00:17:30,830 --> 00:17:32,670
停止所有的聲音，發揮了鼓。

378
00:17:32,670 --> 00:17:36,530
>> 所以，長話短說，有一個整體
一堆拼圖，讓您

379
00:17:36,530 --> 00:17:40,920
告訴貓，或任意數量的
其他字符，該怎麼做。

380
00:17:40,920 --> 00:17:43,850
但是，為了使這一切發生
需要開始編程。

381
00:17:43,850 --> 00:17:48,090
和這個大的白盒或灰色的框，
在右手邊，這就是

382
00:17:48,090 --> 00:17:50,170
我要拖動
丟棄這些拼圖。

383
00:17:50,170 --> 00:17:54,320
這是我的空白文本
窗口當量。

384
00:17:54,320 --> 00:17:57,070
>> 所以我要繼續前進，然後按一下
控制在中間。

385
00:17:57,070 --> 00:17:58,540
或者說，讓我先
下設活動。

386
00:17:58,540 --> 00:18:01,530
根據事件板凳，你會發現一個
是故意的幾件事情

387
00:18:01,530 --> 00:18:05,240
在這樣一種方式，在頂部彎曲
他們可能不聯鎖

388
00:18:05,240 --> 00:18:06,710
頂部的拼圖碎片。

389
00:18:06,710 --> 00:18:10,160
那是因為他們丹麥開始
的一個程序，開始一個

390
00:18:10,160 --> 00:18:11,910
腳本，可以這麼說。

391
00:18:11,910 --> 00:18:16,290
所以，如果我繼續前進，拖動，當綠色
旗點擊這裡，然後我

392
00:18:16,290 --> 00:18:18,060
希望這個貓說
在第一次的事情。

393
00:18:18,060 --> 00:18:20,510
所以我打算去下
外觀面板。

394
00:18:20,510 --> 00:18:24,060
而且我要繼續前進，並抓住
打招呼塊，然後拖放，

395
00:18:24,060 --> 00:18:27,220
放手所以，它會自動
互鎖。

396
00:18:27,220 --> 00:18:28,640
>> 然後通知我
點擊上的文字。

397
00:18:28,640 --> 00:18:31,960
我可以覆蓋更
具體喜歡，說，你好，世界。

398
00:18:31,960 --> 00:18:36,340
現在我們有我要求的程序
是等價的更

399
00:18:36,340 --> 00:18:39,670
神秘的節目，我實現
在C剛才。

400
00:18:39,670 --> 00:18:43,130
>> 如果我走了過來左側，
注意到有一個大的停止標誌

401
00:18:43,130 --> 00:18:44,520
和一個大的綠色標誌。

402
00:18:44,520 --> 00:18:46,390
讓我放大清晰。

403
00:18:46,390 --> 00:18:49,390
而當我點擊這個綠色標誌，
你可能已經猜到這是什麼第一

404
00:18:49,390 --> 00:18:51,920
程序現在要做的事情。

405
00:18:51,920 --> 00:18:55,420
過，所以，我們的編程，但
我們實際上不是陷入困境

406
00:18:55,420 --> 00:18:58,980
在一些那些句法，
微小的細節。

407
00:18:58,980 --> 00:19:01,120
>> 但是，讓我們嘗試一些
更有趣一點。

408
00:19:01,120 --> 00:19:04,840
讓我去到這裡我的臨時文件夾。

409
00:19:04,840 --> 00:19:10,210
而實際上，讓我如此讓我開了
一個單獨的程序，這裡只是一個

410
00:19:10,210 --> 00:19:17,830
時刻，最大化這個窗口，打開文件，
我要進入今天的

411
00:19:17,830 --> 00:19:18,620
源目錄。

412
00:19:18,620 --> 00:19:21,660
一如往常，你會發現，今天和
以後，所有今天的例子

413
00:19:21,660 --> 00:19:25,225
內部的訪問
本課程的網站。

414
00:19:25,225 --> 00:19:31,170
>> 而且我要繼續前進並挑選
出一點東西不同。

415
00:19:31,170 --> 00:19:33,970
在這裡，這一個
我需要一個志願者。

416
00:19:33,970 --> 00:19:36,850
誰願意今天檯燈？

417
00:19:36,850 --> 00:19:40,600
OK，怎麼樣一點的人 - 
你就結束了嗎？

418
00:19:40,600 --> 00:19:42,124
下來吧。

419
00:19:42,124 --> 00:19:47,230
現在，你想參加，或
只是說開始伏案工作的檯燈嗎？

420
00:19:47,230 --> 00:19:48,190
>> 凡妮莎：[聽不清]。

421
00:19:48,190 --> 00:19:48,465
>> DAVID馬蘭：OK。

422
00:19:48,465 --> 00:19:49,610
優秀的，什麼是你的名字嗎？

423
00:19:49,610 --> 00:19:49,990
凡妮莎？

424
00:19:49,990 --> 00:19:50,570
大衛。

425
00:19:50,570 --> 00:19:51,390
認識你很高興。

426
00:19:51,390 --> 00:19:53,840
這樣一來和Vanessa的打算，
我採取控制

427
00:19:53,840 --> 00:19:55,490
鍵盤只是一瞬間。

428
00:19:55,490 --> 00:19:57,850
和我做了什麼在這裡，只是時間的
的緣故，因為我已​​經實現了

429
00:19:57,850 --> 00:20:01,070
Wi-Fi的速度有點慢，從無到有，
編程環境，我們

430
00:20:01,070 --> 00:20:04,110
使用，也可以被下載並
您的本地計算機上運行。

431
00:20:04,110 --> 00:20:06,360
所以我做了什麼，提前講座
如果出現這種情況，是我下載

432
00:20:06,360 --> 00:20:09,120
我們一起玩的所有文件
這樣，他們可以運行一個小

433
00:20:09,120 --> 00:20:10,840
很快就在這裡我的筆記本電腦。

434
00:20:10,840 --> 00:20:13,460
所以這就是為什麼現在我看到
在Mac專用接口。

435
00:20:13,460 --> 00:20:15,510
>> 所以，我要繼續前進
打開了這一點。

436
00:20:15,510 --> 00:20:18,400
我要繼續前進，現在，
全屏窗口。

437
00:20:18,400 --> 00:20:21,740
你會看到，我們可以非常快，
這個學生之一，

438
00:20:21,740 --> 00:20:26,360
你的前輩，從“世界，你好
一個非常更引人注目

439
00:20:26,360 --> 00:20:27,020
應用程序。

440
00:20:27,020 --> 00:20:28,180
因此，這裡的指示。

441
00:20:28,180 --> 00:20:29,500
哦，我們有其他的事情之一。

442
00:20:29,500 --> 00:20:31,640
我想這將是有趣的，因為，
通常情況下，我們將拍攝

443
00:20:31,640 --> 00:20:32,440
相機這種方式。

444
00:20:32,440 --> 00:20:34,100
我想這將是有趣，凡妮莎，
我們可以看到世界

445
00:20:34,100 --> 00:20:35,120
通過你的眼睛。

446
00:20:35,120 --> 00:20:36,670
所以，在這裡，我們有一些谷歌的玻璃。

447
00:20:36,670 --> 00:20:39,290
>> [驚訝的喘氣]

448
00:20:39,290 --> 00:20:41,610
>> 國寶馬蘭：我們將只給
遠離檯燈今天。

449
00:20:41,610 --> 00:20:43,530
>> [笑]

450
00:20:43,530 --> 00:20:45,260
>> 因此，讓我暗示這件事。

451
00:20:45,260 --> 00:20:49,340
所有權利，所以觸摸。

452
00:20:49,340 --> 00:20:51,910
OK，玻璃，錄像。

453
00:20:51,910 --> 00:20:55,700

454
00:20:55,700 --> 00:20:56,950
所有權利，凡妮莎？

455
00:20:56,950 --> 00:21:00,940

456
00:21:00,940 --> 00:21:05,560
現在，順便說一句，什麼都沒有
從頭開始做，如果你看一下

457
00:21:05,560 --> 00:21:08,540
小幅上漲的右側，你會看到
字面的玻璃，你應該

458
00:21:08,540 --> 00:21:09,650
看到一個小矩形窗口。

459
00:21:09,650 --> 00:21:11,500
你會看到所有你的同學
正在拍攝的權利嗎？

460
00:21:11,500 --> 00:21:11,840
是。

461
00:21:11,840 --> 00:21:12,340
>> VANESSA：是的。

462
00:21:12,340 --> 00:21:12,920
>> DAVID馬蘭：OK。

463
00:21:12,920 --> 00:21:15,170
所以這就是罰款。

464
00:21:15,170 --> 00:21:16,660
我們將在稍後釋放了這組鏡頭。

465
00:21:16,660 --> 00:21:18,460
現在，把你的注意力
這裡的畫面。

466
00:21:18,460 --> 00:21:20,990
和你的前任所做的是
把一些屏幕上的說明

467
00:21:20,990 --> 00:21:22,670
只需使用一個畫圖程序。

468
00:21:22,670 --> 00:21:25,040
所以，你會在某一時刻，
按空格鍵開始。

469
00:21:25,040 --> 00:21:27,790
然後一些拼圖
開始向上移動屏幕。

470
00:21:27,790 --> 00:21:30,900
和你想打，只是箭頭鍵
喜歡在真正的DDR，按照

471
00:21:30,900 --> 00:21:32,740
事情排著隊
這些箭頭。

472
00:21:32,740 --> 00:21:33,020
>> VANESSA：OK。

473
00:21:33,020 --> 00:21:33,800
>> DAVID馬蘭：你玩這個。

474
00:21:33,800 --> 00:21:34,140
>> VANESSA：是啊。

475
00:21:34,140 --> 00:21:37,330
>> 國寶馬蘭：所有的權利，蛺蝶，
繼續前進，把它拿走。

476
00:21:37,330 --> 00:22:53,082
>> [MUSIC  - 西KAYNE，“做強”]

477
00:22:53,082 --> 00:22:57,080
>> [掌聲]

478
00:22:57,080 --> 00:22:59,750
>> DAVID馬蘭：現在讓我們
採取一個步驟。

479
00:22:59,750 --> 00:23:01,230
所以很明顯，這是遊戲結束。

480
00:23:01,230 --> 00:23:02,880
結局是不是“世界，你好。

481
00:23:02,880 --> 00:23:05,520
但你不必一定做
事情是這樣的互動。

482
00:23:05,520 --> 00:23:06,810
你也可以做動畫。

483
00:23:06,810 --> 00:23:10,790
因此，例如，你的另一個
接班人在這裡提出這個方案，

484
00:23:10,790 --> 00:23:14,100
它講述了一個故事多
它實現了一個遊戲。

485
00:23:14,100 --> 00:23:19,180
所以，讓我去進取，不斷開拓這裡
在我們的程序相同的源代碼目錄

486
00:23:19,180 --> 00:23:20,300
從今天開始。

487
00:23:20,300 --> 00:23:26,990
這一個電話，讓我們開始
，一個cookie愛情故事。

488
00:23:26,990 --> 00:23:30,750
>> 而不是使這個太學術，但是，
你看這一條，認為

489
00:23:30,750 --> 00:23:34,030
自己的那些簡單
我們已經討論過的編程概念

490
00:23:34,030 --> 00:23:34,630
迄今 - 

491
00:23:34,630 --> 00:23:39,250
變量，循環，條件，
你的前任是可能只使用

492
00:23:39,250 --> 00:23:41,090
以實現一些
可視化效果。

493
00:23:41,090 --> 00:23:41,760
你在這裡看到的。

494
00:23:41,760 --> 00:23:44,118
所以我給你一個cookie的愛情故事。

495
00:23:44,118 --> 00:24:06,030
>> [音樂 -  GREEN DAY，“假期”]

496
00:24:06,030 --> 00:24:08,022
>> [CRASH]

497
00:24:08,022 --> 00:24:09,272
>> [音樂 - 海龜，
“春光乍泄”]

498
00:24:09,272 --> 00:24:58,328

499
00:24:58,328 --> 00:25:00,560
>> 國寶馬蘭：所有的權利，所以，
我們有一個cookie的愛情故事。

500
00:25:00,560 --> 00:25:01,360
但即使在那裡 - 

501
00:25:01,360 --> 00:25:01,755
>> [掌聲]

502
00:25:01,755 --> 00:25:08,110
>> 國寶馬蘭：所有的權利，即使在那裡，
想想，那些心去

503
00:25:08,110 --> 00:25:10,410
屏幕頂部的底部的
實際上是有一點點

504
00:25:10,410 --> 00:25:11,440
隨機性。

505
00:25:11,440 --> 00:25:14,150
事實上，我們可以看到，即使在
最簡單的環境中，如

506
00:25:14,150 --> 00:25:18,180
從無到有，在C語言中，您可以生成
隨機數，或幻覺

507
00:25:18,180 --> 00:25:21,110
隨機數，因此，遊戲是一個
比它更有趣

508
00:25:21,110 --> 00:25:23,390
如果你有絕對
硬編碼的一切。

509
00:25:23,390 --> 00:25:26,360
>> 在運動中，你看到的，有
有某種響應。

510
00:25:26,360 --> 00:25:28,840
只要薑餅人接觸
薑餅的女人，她

511
00:25:28,840 --> 00:25:30,000
似乎搬走。

512
00:25:30,000 --> 00:25:33,580
因此，事實上，你可以實現，
大多數編程語言的概念

513
00:25:33,580 --> 00:25:38,680
的事件，即如果一個人用手觸球
另一方面，可以引發一些

514
00:25:38,680 --> 00:25:41,270
的源代碼
實際執行。

515
00:25:41,270 --> 00:25:43,740
你可以聽等
在屏幕上的東西。

516
00:25:43,740 --> 00:25:47,310
>> 因此，讓我們來快速瀏覽，然後，
我們可以使用的一些積木

517
00:25:47,310 --> 00:25:48,790
實現一些目標。

518
00:25:48,790 --> 00:25:51,630
因此，這裡就是我們今後會
調用語句。

519
00:25:51,630 --> 00:25:55,030
的聲明恰好是紫色的
從頭開始，一點點這樣的事情，

520
00:25:55,030 --> 00:25:56,120
但是，這是任意的。

521
00:25:56,120 --> 00:26:00,140
一種說法是只是一塊拼圖，
更一般地，一個指令，即

522
00:26:00,140 --> 00:26:03,370
告訴計算機做
的東西，一個聲明。

523
00:26:03,370 --> 00:26:04,680
>> 所以這裡有一個簡單的示例。

524
00:26:04,680 --> 00:26:05,930
問好世界。

525
00:26:05,930 --> 00:26:08,180
另一種可能是等待一秒。

526
00:26:08,180 --> 00:26:10,840
所以這一塊拼圖，這是支持
划痕，我們就會讓你

527
00:26:10,840 --> 00:26:13,050
一些字符暫停
秒數。

528
00:26:13,050 --> 00:26:15,330
這，也只是一句話。

529
00:26:15,330 --> 00:26:18,640
>> 這裡未來，我們有另一種更
有趣的一個，播放聲音喵，

530
00:26:18,640 --> 00:26:21,480
小箭頭表示，在從無到有，
這是一個下拉菜單。

531
00:26:21,480 --> 00:26:22,590
因此你可以導入聲音。

532
00:26:22,590 --> 00:26:25,095
您可以錄製聲音和做其他
有趣的事情划痕。

533
00:26:25,095 --> 00:26:28,450
而這，也，雖然在年底
的一天，只是一句話。

534
00:26:28,450 --> 00:26:31,250
但現在讓我們引入一個更
有趣的片，稱為

535
00:26:31,250 --> 00:26:32,630
布爾表達式。

536
00:26:32,630 --> 00:26:35,180
資本B，得名
一個傢伙命名BOOL。

537
00:26:35,180 --> 00:26:39,500
>> 僅僅是一個布爾表達式
一塊拼圖，或者更普遍的是，一個

538
00:26:39,500 --> 00:26:42,980
片信息
無論是真的還是假的 - 

539
00:26:42,980 --> 00:26:45,830
一或為零，“是”或“否”。

540
00:26:45,830 --> 00:26:48,420
因此，它只是其中的一個
兩個對立面。

541
00:26:48,420 --> 00:26:52,840
所以這樣的一個布爾表達式
世界從頭開始看起來像這個藍色

542
00:26:52,840 --> 00:26:53,560
一塊拼圖。

543
00:26:53,560 --> 00:26:56,735
它提出一個問題，鼠標
下來，並可以是，

544
00:26:56,735 --> 00:26:58,430
當然，真或假。

545
00:26:58,430 --> 00:27:01,710
因此，這一塊拼圖從無到有，
好了，你就能夠檢測，如果

546
00:27:01,710 --> 00:27:05,490
益智如果鼠標，事實上，
按住人類相互作用

547
00:27:05,490 --> 00:27:06,550
你的程序。

548
00:27:06,550 --> 00:27:08,860
>> 這其中的一個更抽象一點，
但是這兩個白色盒子

549
00:27:08,860 --> 00:27:09,740
只是數字。

550
00:27:09,740 --> 00:27:12,950
所以，你可以做的事情，就像是這
人數比對方少？

551
00:27:12,950 --> 00:27:16,180
如果是的話，划痕會表現
一種方式或其他。

552
00:27:16,180 --> 00:27:17,505
這是一個小的圖形。

553
00:27:17,505 --> 00:27:21,840
如果精靈，如果貓，
例如，實際接觸

554
00:27:21,840 --> 00:27:22,510
鼠標指針。

555
00:27:22,510 --> 00:27:25,780
因此，如果小箭頭頭徘徊
在貓，那麼這

556
00:27:25,780 --> 00:27:28,030
一塊拼圖將評估為true。

557
00:27:28,030 --> 00:27:31,870
這是真實的，在這種情況下，如果
我們會使用這個布爾表達式，

558
00:27:31,870 --> 00:27:36,340
在某一時刻，在一個分支，你可以
做到這一點，或者你可以做到這一點，

559
00:27:36,340 --> 00:27:39,940
就像我們有一個條件，
檢查，有一個以上的最後一個人

560
00:27:39,940 --> 00:27:40,460
在房間裡？

561
00:27:40,460 --> 00:27:42,070
如果是這樣，添加一個。

562
00:27:42,070 --> 00:27:44,430
否則，不要再擔心。

563
00:27:44,430 --> 00:27:48,650
>> 所以，也可以是一個布爾表達式
和一起或一起。

564
00:27:48,650 --> 00:27:53,120
所以，你可以結合布爾表達式
並說這必須是真實的

565
00:27:53,120 --> 00:27:54,710
整個事情是真實的。

566
00:27:54,710 --> 00:27:56,520
這裡是一個更現實世界的例子。

567
00:27:56,520 --> 00:28:00,060
如果你已經使用了CS50課程做當然
購物，這些複選框

568
00:28:00,060 --> 00:28:03,520
在那裡，如果你檢查框明年
課程，會說，是的，

569
00:28:03,520 --> 00:28:07,860
只顯示我的課程
Q值是4.5或更高。

570
00:28:07,860 --> 00:28:10,610
如果取消，不，不
擔心。

571
00:28:10,610 --> 00:28:13,910
或類似的權利，不
我服用的課程衝突，

572
00:28:13,910 --> 00:28:15,650
這是無論是真的還是假的。

573
00:28:15,650 --> 00:28:16,715
這只是一個布爾表達式。

574
00:28:16,715 --> 00:28:20,080
所以這一切的時候，當你使用
網站複選框，你只是

575
00:28:20,080 --> 00:28:23,570
切換相當於一個布爾
表達的開和關。

576
00:28:23,570 --> 00:28:25,270
>> 因此，在你用什麼樣的形式？

577
00:28:25,270 --> 00:28:28,820
嗯，從無到有，我們會看到在某一時刻
條件，

578
00:28:28,820 --> 00:28:29,560
這個樣子。

579
00:28:29,560 --> 00:28:33,130
這就是一種明智的，因為多
像偽代碼，我們縮進

580
00:28:33,130 --> 00:28:38,550
U形拼圖排序，平均
該U裡面，任何

581
00:28:38,550 --> 00:28:41,390
要執行與否，取決於
它在哪裡。

582
00:28:41,390 --> 00:28:45,310
因此，如果布爾表達式，然後
無論是內將得到執行。

583
00:28:45,310 --> 00:28:46,800
>> 同時，有一個的if / else塊。

584
00:28:46,800 --> 00:28:50,320
所以，如果你想有一個分支去
這樣或划痕給我們。

585
00:28:50,320 --> 00:28:54,500
通過這樣的邏輯，現在，儘管這
顯然是太小了一塊拼圖

586
00:28:54,500 --> 00:28:57,400
楔它裡面的其他東西，
從頭拼圖，他們

587
00:28:57,400 --> 00:28:58,150
只是要成長。

588
00:28:58,150 --> 00:29:01,370
當你過的東西，拖放
只是，它會成長，以適應不管它

589
00:29:01,370 --> 00:29:02,510
你要怎樣做。

590
00:29:02,510 --> 00:29:07,230
>> 因此，我們可以採取兩種這些東西，
三路的岔路口，所以

591
00:29:07,230 --> 00:29:11,300
您這樣做，否則，
這個其他的東西，只是通過嵌套

592
00:29:11,300 --> 00:29:12,070
在這種方式。

593
00:29:12,070 --> 00:29:14,370
當然，如果你這樣做太
多，它開始變得醜陋。

594
00:29:14,370 --> 00:29:17,660
但在這一點上，你實際上
可能不是編程很好。

595
00:29:17,660 --> 00:29:20,490
因此，這將是經常性的
主題，風格。

596
00:29:20,490 --> 00:29:22,790
究竟確實
格式化你的代碼嗎？

597
00:29:22,790 --> 00:29:24,580
或者，你如何設計你的代碼嗎？

598
00:29:24,580 --> 00:29:26,430
但是，在未來。

599
00:29:26,430 --> 00:29:27,470
>> 現在我們有循環。

600
00:29:27,470 --> 00:29:30,310
有一個很好的無限循環在Scratch
它的字面意思是 - 做

601
00:29:30,310 --> 00:29:32,710
凡是在這裡面，再次，
一遍，又一遍。

602
00:29:32,710 --> 00:29:35,880
你可以更具體的說，
做以下的事情10倍。

603
00:29:35,880 --> 00:29:37,620
您還可以使用變量。

604
00:29:37,620 --> 00:29:40,260
你能想出任何名稱，
小降下來，說，給我一個

605
00:29:40,260 --> 00:29:43,190
變量稱為n和
它等於某個值。

606
00:29:43,190 --> 00:29:44,910
然後你就可以具備的功能。

607
00:29:44,910 --> 00:29:46,850
但在短短的時刻。

608
00:29:46,850 --> 00:29:49,140
>> 讓我回到我的
刮開界面。

609
00:29:49,140 --> 00:29:50,970
並讓我繼續。

610
00:29:50,970 --> 00:29:56,660
讓我們去進取，不斷開拓，
比方說，一個例子 - 

611
00:29:56,660 --> 00:29:58,740
這是一個有點更有趣。

612
00:29:58,740 --> 00:30:00,750
讓我先走了，實際上，
讓我自己。

613
00:30:00,750 --> 00:30:01,960
我不需要打開這一個。

614
00:30:01,960 --> 00:30:03,390
讓我去，新文件。

615
00:30:03,390 --> 00:30:04,740
我打算去活動。

616
00:30:04,740 --> 00:30:08,460
我要去當綠旗
點擊，我要進入聲音。

617
00:30:08,460 --> 00:30:11,590
我要拖放這個
一塊拼圖，播放聲音喵。

618
00:30:11,590 --> 00:30:12,580
閂鎖在一起。

619
00:30:12,580 --> 00:30:14,327
而現在，如果我點擊綠色旗幟 - 

620
00:30:14,327 --> 00:30:16,260
>> [MEOW聲音]

621
00:30:16,260 --> 00:30:17,500
>> 國寶馬蘭：可愛。

622
00:30:17,500 --> 00:30:21,560
好了，現在讓我們做的東西一點點
更符合邏輯的，只是為了演示

623
00:30:21,560 --> 00:30:22,760
我們就可以了，現在。

624
00:30:22,760 --> 00:30:25,550
我要解鎖
從那個傢伙。

625
00:30:25,550 --> 00:30:27,000
我打算去控制。

626
00:30:27,000 --> 00:30:28,770
我要搶了條件。

627
00:30:28,770 --> 00:30:30,600
因此，如果做某事。

628
00:30:30,600 --> 00:30:32,020
所以這是它看起來如何。

629
00:30:32,020 --> 00:30:33,890
所以我需要一個布爾表達式。

630
00:30:33,890 --> 00:30:38,130
讓我繼續說，
讓我去運營。

631
00:30:38,130 --> 00:30:40,270
我要稍微做些什麼
麥菲，只是踢。

632
00:30:40,270 --> 00:30:43,600
我要在這裡說，如果
事情是不到別的東西，

633
00:30:43,600 --> 00:30:45,030
繼續前進，做一些事情。

634
00:30:45,030 --> 00:30:46,890
所以，現在，你知道嗎，一個隨機塊。

635
00:30:46,890 --> 00:30:51,620
所以請注意，如果我懸停
事情在這裡，將卡在那裡。

636
00:30:51,620 --> 00:30:54,090
>> 所以，現在，通知，我開始做
東西已經更具邏輯

637
00:30:54,090 --> 00:30:54,650
有意思的。

638
00:30:54,650 --> 00:30:59,720
如果一個隨機數介於1和
10不到，比方說6。

639
00:30:59,720 --> 00:31:03,670
如果我選擇六個，基本上
手段，50％以下

640
00:31:03,670 --> 00:31:03,980
概率。

641
00:31:03,980 --> 00:31:05,460
這就像拋硬幣。

642
00:31:05,460 --> 00:31:07,330
現在，我可以有條件地做一些事情。

643
00:31:07,330 --> 00:31:10,800
而這東西我要去
要做的就是播放聲音。

644
00:31:10,800 --> 00:31:14,280
所以，現在，當我在屏幕上點擊
標誌，它就像擲硬幣。

645
00:31:14,280 --> 00:31:14,610
>> [MEOW聲音]

646
00:31:14,610 --> 00:31:17,160
>> 國寶馬蘭：這是頭
或諸如此類的東西。

647
00:31:17,160 --> 00:31:17,920
讓我們再做一次。

648
00:31:17,920 --> 00:31:18,860
>> [MEOW聲音]

649
00:31:18,860 --> 00:31:19,790
>> 再國寶馬蘭頭。

650
00:31:19,790 --> 00:31:20,280
>> [MEOW聲音]

651
00:31:20,280 --> 00:31:21,500
>> 再國寶馬蘭頭。

652
00:31:21,500 --> 00:31:22,631
呼，“確定”。

653
00:31:22,631 --> 00:31:24,720
當時的尾巴。

654
00:31:24,720 --> 00:31:29,545
因此，50％的時間，如果我們這樣做
無限長的，我們將得到50％的貓叫聲

655
00:31:29,545 --> 00:31:32,180
和50％的沉默。

656
00:31:32,180 --> 00:31:34,850
所以，只是一個基本的建築
塊，讓我們做到這一點。

657
00:31:34,850 --> 00:31:37,710
但是，這是一種繁瑣的，我有
繼續點擊該按鈕。

658
00:31:37,710 --> 00:31:39,810
因此，我們只需拖動和投擲
所有那些離開。

659
00:31:39,810 --> 00:31:42,270
如果你拖著他們中間，
他們就刪除自己。

660
00:31:42,270 --> 00:31:43,760
>> 讓我上去控制。

661
00:31:43,760 --> 00:31:46,060
讓我去到永遠。

662
00:31:46,060 --> 00:31:49,952
而這個時候，我要做的事情
較小煩人的東西。

663
00:31:49,952 --> 00:31:51,560
>> [笑]

664
00:31:51,560 --> 00:31:53,370
>> DAVID馬蘭：讓我走。
提前做控制。

665
00:31:53,370 --> 00:31:57,260
只是等待一秒
它不是太光柵。

666
00:31:57,260 --> 00:31:59,870
>> [MEOW聲音]

667
00:31:59,870 --> 00:32:00,970
>> DAVID馬蘭：這是不自然的。

668
00:32:00,970 --> 00:32:01,861
確定。

669
00:32:01,861 --> 00:32:04,510
>> [MEOW聲音]

670
00:32:04,510 --> 00:32:06,406
>> 國寶馬蘭：通知什麼的，真好
關於划痕，對於那些你誰

671
00:32:06,406 --> 00:32:09,210
事先編程的經驗，
不需要啟動和停止。

672
00:32:09,210 --> 00:32:10,060
你不需要進行編譯。

673
00:32:10,060 --> 00:32:13,210
你只需要改變它，程序
將動態適應。

674
00:32:13,210 --> 00:32:14,620
因此，這是獲得
有趣的小。

675
00:32:14,620 --> 00:32:16,930
但是，讓我們把它一步。

676
00:32:16,930 --> 00:32:19,760
讓我繼續前進，讓
擺脫該程序。

677
00:32:19,760 --> 00:32:23,300
>> [MEOW聲音]

678
00:32:23,300 --> 00:32:25,520
>> 國寶馬蘭：這就是我們將
調用錯誤從無到有。

679
00:32:25,520 --> 00:32:26,770
他不應該保持聲音。

680
00:32:26,770 --> 00:32:28,340
所以我們會告訴他停下來。

681
00:32:28,340 --> 00:32:30,435
所有的權利，所以現在我
要進入 - 

682
00:32:30,435 --> 00:32:32,180
我會讓麻省理工知道。

683
00:32:32,180 --> 00:32:35,160
在這裡我們會去到永遠。

684
00:32:35,160 --> 00:32:37,240
而現在，我想要做的事
一遍又一遍。

685
00:32:37,240 --> 00:32:38,760
我要進入控制。

686
00:32:38,760 --> 00:32:41,570
>> ，讓我們看看，我要拖
我如果條件存在。

687
00:32:41,570 --> 00:32:42,850
所以，現在發現的邏輯。

688
00:32:42,850 --> 00:32:46,430
當點擊綠旗，做
永遠的東西，但只做到這一點

689
00:32:46,430 --> 00:32:48,890
的東西，如果這件事是真的。

690
00:32:48,890 --> 00:32:51,480
我會去，讓我們
說，傳感。

691
00:32:51,480 --> 00:32:54,430
而且我要繼續前進，並選擇
觸摸和拖放那裡。

692
00:32:54,430 --> 00:32:55,930
這是一個布爾表達式。

693
00:32:55,930 --> 00:32:57,740
>> 現在，請注意，在該下拉
下拉菜單中，有

694
00:32:57,740 --> 00:32:59,050
一些預定義的值。

695
00:32:59,050 --> 00:33:00,910
所以我可以說，你動
在屏幕的邊緣嗎？

696
00:33:00,910 --> 00:33:03,900
或者你動鼠標指針，
屏幕上的箭頭？

697
00:33:03,900 --> 00:33:04,620
所以我打算這樣做。

698
00:33:04,620 --> 00:33:08,770
如果是這樣，那麼我會去
提前打聲喵。

699
00:33:08,770 --> 00:33:11,250
所以，現在我種
一個遊戲的開端 - 

700
00:33:11,250 --> 00:33:13,110
一個可愛的遊戲。

701
00:33:13,110 --> 00:33:14,060
>> [MEOW聲音]

702
00:33:14,060 --> 00:33:17,250
>> 國寶馬蘭：OK，一個可愛的，
越野車遊戲。

703
00:33:17,250 --> 00:33:20,770
讓我等待，比方說，
1秒。

704
00:33:20,770 --> 00:33:24,910
現在玩了，通過點擊
綠色環保標誌。

705
00:33:24,910 --> 00:33:27,860
>> [MEOW聲音]

706
00:33:27,860 --> 00:33:30,460
>> 國寶馬蘭：所以現在
像撫摸一隻貓。

707
00:33:30,460 --> 00:33:31,850
>> [MEOW聲音]

708
00:33:31,850 --> 00:33:34,460
>> 國寶馬蘭：好的，現在這個
我沒有提前作出。

709
00:33:34,460 --> 00:33:39,250
很晚了，它得到種
容易做愚蠢的事情。

710
00:33:39,250 --> 00:33:40,240
因此，讓我在這裡。

711
00:33:40,240 --> 00:33:43,720
比方說，寵物貓。

712
00:33:43,720 --> 00:33:46,600
現在，讓我們打開不要寵物貓。

713
00:33:46,600 --> 00:33:48,330
現在，如果我們玩這個，
你可以猜到，如果你

714
00:33:48,330 --> 00:33:49,650
看著屏幕 - 

715
00:33:49,650 --> 00:33:51,090
>> [MEOW聲音]

716
00:33:51,090 --> 00:33:52,170
>> 國寶馬蘭：現在，如果我的寵物貓

717
00:33:52,170 --> 00:33:55,420
>> [獅子吼]

718
00:33:55,420 --> 00:33:57,260
>> 國寶MALAN：所以實際上並不
在這種情況下，寵物貓。

719
00:33:57,260 --> 00:34:01,350
所以，現在我們只是有一個例子，
分支會在兩個方向。

720
00:34:01,350 --> 00:34:03,130
現在讓我繼續前進，
打開另一個在這裡。

721
00:34:03,130 --> 00:34:07,120
這其中，我們的源代碼，其中也
代碼文件的一天。

722
00:34:07,120 --> 00:34:13,199
所以，讓我回去到我的源
目錄和進入，讓我們的選擇

723
00:34:13,199 --> 00:34:15,610
這裡，看看這個傢伙
什麼是不同的。

724
00:34:15,610 --> 00:34:17,449
>> 哇，所有的權利，所以現在越來越
更複雜一點。

725
00:34:17,449 --> 00:34:21,300
之前，我們看到這個傢伙做什麼，
讓我們試著來推斷，從程序

726
00:34:21,300 --> 00:34:22,219
在右手邊。

727
00:34:22,219 --> 00:34:25,590
現在從頭明確允許我們
有多個腳本，多

728
00:34:25,590 --> 00:34:29,730
與一個精靈程序，
具有一個字符，並且，明顯地，

729
00:34:29,730 --> 00:34:31,760
他們倆都運行在步調一致。

730
00:34:31,760 --> 00:34:35,570
因為這些節目都開始
點擊綠色標誌時，這是

731
00:34:35,570 --> 00:34:38,650
暗示了一個更先進的話題，
一些你可能很熟悉，

732
00:34:38,650 --> 00:34:40,580
被稱為線程，或
多線程。

733
00:34:40,580 --> 00:34:44,400
>> 原來，長話短說，電腦
今天基本上可以做多

734
00:34:44,400 --> 00:34:45,270
事情一次。

735
00:34:45,270 --> 00:34:48,659
或者，他們可以做一件事的時間，
快，你甚至不會注意到，

736
00:34:48,659 --> 00:34:50,150
它實際上是在做一個
在一個時間的事情。

737
00:34:50,150 --> 00:34:53,320
但現在，讓我們假設兩個
這些程序去執行

738
00:34:53,320 --> 00:34:54,310
在同一時間。

739
00:34:54,310 --> 00:34:57,350
和通知，它們都有
永遠迷惑件。

740
00:34:57,350 --> 00:35:01,270
因此，他們既要保持運行
直到我打了紅色的停車標誌。

741
00:35:01,270 --> 00:35:02,100
>> 那麼，他們怎麼辦呢？

742
00:35:02,100 --> 00:35:06,030
在左側，我顯然
聲明一個變量稱為靜音。

743
00:35:06,030 --> 00:35:09,030
所以，我沒有稱之為像
像N.無聊，我把它叫做靜音

744
00:35:09,030 --> 00:35:10,240
時間傳達的意思。

745
00:35:10,240 --> 00:35:11,780
我將它設置等於零。

746
00:35:11,780 --> 00:35:16,200
讓我們來想想，作為虛假或
讓我們想想，作為假。

747
00:35:16,200 --> 00:35:17,490
>> 現在，永遠做到以下幾點。

748
00:35:17,490 --> 00:35:23,280
如果按下鍵盤的空格鍵，
那麼靜音等於零，

749
00:35:23,280 --> 00:35:25,930
然後改變靜音等於1。

750
00:35:25,930 --> 00:35:27,580
否則，靜音設置為零。

751
00:35:27,580 --> 00:35:30,530
所以從邏輯上講，這是一個整體，即使
一堆拼圖這是

752
00:35:30,530 --> 00:35:33,160
只是說，當我打空格鍵，
我應該怎麼辦變量

753
00:35:33,160 --> 00:35:34,750
被稱為靜音？

754
00:35:34,750 --> 00:35:37,170
改變它從一到零，
或零到一。

755
00:35:37,170 --> 00:35:37,840
這就是全部。

756
00:35:37,840 --> 00:35:40,740
因此，它就像打開電燈開關
開啟或關閉和記憶，具有

757
00:35:40,740 --> 00:35:42,330
可變的，我做過。

758
00:35:42,330 --> 00:35:45,990
>> 同時，在右手側，在
通俗地說，目的是什麼

759
00:35:45,990 --> 00:35:47,547
的腳本在右側？

760
00:35:47,547 --> 00:35:48,860
>> 學生：要播放的海獅聲音。

761
00:35:48,860 --> 00:35:52,500
>> 國寶馬蘭：要發揮海獅聲，
如果他不是靜音，

762
00:35:52,500 --> 00:35:53,480
該變量的性質。

763
00:35:53,480 --> 00:35:57,360
因此，我們共享狀態，可以這麼說，
在這兩個信息共享

764
00:35:57,360 --> 00:36:00,540
腳本，因為，在這裡，我們注意到
永遠做以下。

765
00:36:00,540 --> 00:36:04,620
如果處於靜音狀態是零，因此，如果它沒有被靜音 - 
如果靜音是假的，然後播放

766
00:36:04,620 --> 00:36:05,980
這海獅聲音。

767
00:36:05,980 --> 00:36:09,930
自己認為，喜喜喜
兩秒鐘，稍等片刻，然後

768
00:36:09,930 --> 00:36:11,140
再次檢查。

769
00:36:11,140 --> 00:36:15,150
因此，如果我們現在在這裡的左側，
這傢伙是打

770
00:36:15,150 --> 00:36:16,662
綠色標誌，

771
00:36:16,662 --> 00:36:30,260
>> [海獅聲音]

772
00:36:30,260 --> 00:36:31,910
>> 國寶馬蘭：在什麼時候
這得到真的很煩人嗎？

773
00:36:31,910 --> 00:36:33,440
因為這將只是永遠持續下去。

774
00:36:33,440 --> 00:36:36,490
所以有時候，無限循環
可以這麼說，是故意的。

775
00:36:36,490 --> 00:36:41,140
但是，在這種情況下，只要我
敲擊空格鍵，他停止。

776
00:36:41,140 --> 00:36:42,800
現在的程序還沒有退出。

777
00:36:42,800 --> 00:36:44,760
它仍然運行在這些循環。

778
00:36:44,760 --> 00:36:46,540
但是，如果我再次得到空格鍵 - 

779
00:36:46,540 --> 00:36:47,851
>> [海獅聲音]

780
00:36:47,851 --> 00:36:49,650
>> 國寶馬蘭：他要挑
在那裡他離開。

781
00:36:49,650 --> 00:36:53,240
因此，有一個為我們做的方式
一次又一次的東西，但，即

782
00:36:53,240 --> 00:36:54,920
時間，僅有條件。

783
00:36:54,920 --> 00:36:58,940
那麼，當我們在做這個靜脈
一遍又一遍的東西，讓我

784
00:36:58,940 --> 00:37:01,370
到這裡另一個這樣的例子。

785
00:37:01,370 --> 00:37:04,370
這一次，我們會打電話給數羊。

786
00:37:04,370 --> 00:37:05,710
>> 注意到這傢伙做什麼。

787
00:37:05,710 --> 00:37:08,540
它實際上更像是一個位
偽代碼，我們使用了與上

788
00:37:08,540 --> 00:37:12,230
週三，據此，他設置一些計數器，
認為它是一次N，

789
00:37:12,230 --> 00:37:14,030
為零，他永遠做以下。

790
00:37:14,030 --> 00:37:17,960
他說，一個計數器的值
第二，等待一秒鐘，然後

791
00:37:17,960 --> 00:37:19,430
改變的一個櫃檯。

792
00:37:19,430 --> 00:37:21,570
並在這方面，這只是
是指它的增量。

793
00:37:21,570 --> 00:37:23,250
所以他增加1到它。

794
00:37:23,250 --> 00:37:25,830
因此，這是字面上 - 

795
00:37:25,830 --> 00:37:27,890
它並不完全是我們認為
作為計數的羊。

796
00:37:27,890 --> 00:37:33,120
這是羊做計數，
永遠從零。

797
00:37:33,120 --> 00:37:35,560
>> 因此，我們可以做類似的事情
在那裡，頭頭是道。

798
00:37:35,560 --> 00:37:37,750
但現在讓我們嘗試清理
一些這些東西。

799
00:37:37,750 --> 00:37:43,440
讓我繼續前進，現在進入一個簡單的
例如，我們的貓只是要

800
00:37:43,440 --> 00:37:44,750
開始咳嗽。

801
00:37:44,750 --> 00:37:48,830
所有的權利，所以在這裡我們有咳嗽0  - 

802
00:37:48,830 --> 00:37:50,685
計算機科學家開始
從0開始計數。

803
00:37:50,685 --> 00:37:53,480
因此，這貓只是要
咳嗽三次。

804
00:37:53,480 --> 00:37:54,890
和這裡的我是如何實現的。

805
00:37:54,890 --> 00:38:00,130
當點擊綠旗，咳嗽，
等待，咳嗽等，咳嗽，稍候。

806
00:38:00,130 --> 00:38:02,470
我這樣做只是通過拖動
拖放拼圖碎片。

807
00:38:02,470 --> 00:38:04,740
或者，如果你開始鼓搗從無到有，
你會看到你其實可以

808
00:38:04,740 --> 00:38:08,620
所以，你可以做複製件
事情變得更加快速拖動

809
00:38:08,620 --> 00:38:10,310
和刪除廣告nauseum。

810
00:38:10,310 --> 00:38:12,680
>> 但是，我們不是在這裡的最佳路徑。

811
00:38:12,680 --> 00:38:15,210
因為我怎麼做他
咳了第四次嗎？

812
00:38:15,210 --> 00:38:16,790
好吧，我可以下去這裡進行排序。

813
00:38:16,790 --> 00:38:19,420
我可以複製，然後
粘貼在那裡。

814
00:38:19,420 --> 00:38:21,740
我如何讓他咳了第五次？

815
00:38:21,740 --> 00:38:23,230
那麼，再次複製和粘貼。

816
00:38:23,230 --> 00:38:24,210
或將再次下降。

817
00:38:24,210 --> 00:38:26,920
而且速度非常快，這個程序啟動
以獲得冗餘真的，真的，

818
00:38:26,920 --> 00:38:28,880
真的很長，但真的很無趣。

819
00:38:28,880 --> 00:38:30,120
但是，有一種方法來清理它。

820
00:38:30,120 --> 00:38:33,680
什麼是顯而易見的方法
清理它？

821
00:38:33,680 --> 00:38:36,280
>> OK，所以我們實際上可以真正去
出來，當你打的空間

822
00:38:36,280 --> 00:38:37,070
酒吧，他咳嗽起來。

823
00:38:37,070 --> 00:38:40,150
但如果我只是想要做的事
重複，記得，我們​​有

824
00:38:40,150 --> 00:38:41,310
一些控制結構。

825
00:38:41,310 --> 00:38:43,800
讓我搬出來的
的方式，去控制。

826
00:38:43,800 --> 00:38:47,340
讓我只是做了再說，
例如，三次。

827
00:38:47,340 --> 00:38:49,410
現在讓我偷些
這些拼圖。

828
00:38:49,410 --> 00:38:50,980
讓我捕捉在我們這裡。

829
00:38:50,980 --> 00:38:52,400
讓我把這些東西拿走乾脆。

830
00:38:52,400 --> 00:38:55,400
>> 而現在，我有一個更好的
設計方案。

831
00:38:55,400 --> 00:38:55,920
為什麼呢？

832
00:38:55,920 --> 00:39:00,540
如果我想改變的次數
這個貓咳嗽，我要

833
00:39:00,540 --> 00:39:05,640
要做的是改變一個變量或一個值，
而從三個​​，四個或

834
00:39:05,640 --> 00:39:06,700
五或六。

835
00:39:06,700 --> 00:39:09,060
或者，我可以有條件地做一些事情，
甚至，空間

836
00:39:09,060 --> 00:39:10,320
吧，如果我想。

837
00:39:10,320 --> 00:39:11,780
>> 因此，這是一個普遍的原則。

838
00:39:11,780 --> 00:39:14,950
一旦你開始複製和粘貼代碼，
無論是在從無到有，或

839
00:39:14,950 --> 00:39:18,340
C，你正在做的事情
錯了，最有可能的。

840
00:39:18,340 --> 00:39:21,950
或者至少，一旦你超過了一些
合理的數字副本

841
00:39:21,950 --> 00:39:24,610
膏，你可能
做錯了什麼。

842
00:39:24,610 --> 00:39:26,740
>> 但是你知道嗎？

843
00:39:26,740 --> 00:39:27,590
我真的不這樣。

844
00:39:27,590 --> 00:39:28,980
這是不乾淨的設計。

845
00:39:28,980 --> 00:39:32,860
我希望有一塊拼圖稱為
因為那時我不會咳嗽

846
00:39:32,860 --> 00:39:36,100
實現這個自己，
老式的方式，通過

847
00:39:36,100 --> 00:39:38,220
說，等待 - 

848
00:39:38,220 --> 00:39:40,320
如果他們只是
咳嗽一塊拼圖。

849
00:39:40,320 --> 00:39:41,330
>> 好吧，其實我可以做到這一點。

850
00:39:41,330 --> 00:39:45,010
讓我去下更多的塊，單擊“
塊，現在我得到這個

851
00:39:45,010 --> 00:39:45,610
這裡的窗口。

852
00:39:45,610 --> 00:39:47,540
我要去來調用這個事情咳嗽。

853
00:39:47,540 --> 00:39:49,400
我要繼續前進，並單擊“確定”。

854
00:39:49,400 --> 00:39:53,150
現在通知，我得到一個新的起點
一塊彎曲的頂部。

855
00:39:53,150 --> 00:39:56,590
我會做這個，我
要偷這些塊。

856
00:39:56,590 --> 00:39:57,800
我要在這裡把它們。

857
00:39:57,800 --> 00:40:00,490
>> 而現在，這三件，我
我要調用實現

858
00:40:00,490 --> 00:40:03,530
函數或過程，或一些
你可能知道它作為一種方法。

859
00:40:03,530 --> 00:40:05,050
字間的細微差別。

860
00:40:05,050 --> 00:40:06,950
但現在，讓我們
調用這個函數。

861
00:40:06,950 --> 00:40:08,750
這僅僅是一個新的一塊拼圖。

862
00:40:08,750 --> 00:40:11,000
現在，它是這樣實現的。

863
00:40:11,000 --> 00:40:15,170
>> 但是要注意，划痕已經給了我們一個
物理表示，整體

864
00:40:15,170 --> 00:40:16,570
在這裡阻止。

865
00:40:16,570 --> 00:40:21,930
所以，現在，我就可以拖動該在這裡，
說，重複三次，

866
00:40:21,930 --> 00:40:26,420
發生了什麼事情發生的，現在，我玩的時候
這個腳本，只有一個程序

867
00:40:26,420 --> 00:40:27,500
是在同一時間運行。

868
00:40:27,500 --> 00:40:29,880
這裡只有一個時
綠旗點擊。

869
00:40:29,880 --> 00:40:34,010
但是，紫塊，稱為咳嗽
有效地告訴划痕，每

870
00:40:34,010 --> 00:40:38,160
當你看到那一塊拼圖，其實
執行這些步驟，我

871
00:40:38,160 --> 00:40:40,420
發生在手動執行。

872
00:40:40,420 --> 00:40:41,410
>> 所以這是一種整齊。

873
00:40:41,410 --> 00:40:44,650
但現在，假設我決定了，我不知道
希望這貓只是咳嗽。

874
00:40:44,650 --> 00:40:46,660
我希望他能夠
打噴嚏。

875
00:40:46,660 --> 00:40:48,905
那麼，我們怎麼可能去
實施噴嚏？

876
00:40:48,905 --> 00:40:51,310
好吧，我幾乎可以
做同樣的事情。

877
00:40:51,310 --> 00:40:52,690
我可以做另一個塊。

878
00:40:52,690 --> 00:40:55,940
我可以打電話給這個噴嚏，單擊“確定”。

879
00:40:55,940 --> 00:40:59,250
>> 然後，在這裡我居然可以
已經讓我重複這一點 - 

880
00:40:59,250 --> 00:41:02,850
還有就是你應該感到像
你可能不會做的東西

881
00:41:02,850 --> 00:41:03,780
最好的辦法。

882
00:41:03,780 --> 00:41:06,670
我可以這樣說：
，一秒鐘achoo。

883
00:41:06,670 --> 00:41:07,440
等待一秒鐘。

884
00:41:07,440 --> 00:41:08,715
現在我有一個新的塊稱為噴嚏。

885
00:41:08,715 --> 00:41:10,210
事實上，它就在那裡。

886
00:41:10,210 --> 00:41:14,010
>> 但是，這也應該開始感受到 - 
也許不是第一個星期的類，但

887
00:41:14,010 --> 00:41:15,730
由第二 - 
有點多餘。

888
00:41:15,730 --> 00:41:17,800
顯然，在這裡有一些冗餘。

889
00:41:17,800 --> 00:41:22,090
所以我建議，而不是我們
細化定義如下。

890
00:41:22,090 --> 00:41:24,820
>> 讓我上去我的文件“菜單。

891
00:41:24,820 --> 00:41:26,090
我救不了這個版本。

892
00:41:26,090 --> 00:41:29,080
我要進入一個
我這裡預製文件。

893
00:41:29,080 --> 00:41:31,190
而且我要繼續前進
並開闢咳嗽2。

894
00:41:31,190 --> 00:41:32,220
哎呀，那是咳嗽2。

895
00:41:32,220 --> 00:41:36,900
讓我去進取，不斷開拓咳嗽3，
這是源代碼目錄。

896
00:41:36,900 --> 00:41:42,450
咳嗽3和發現 - 哦，我告訴
故事以錯誤的順序。

897
00:41:42,450 --> 00:41:45,030
讓我從這個故事中恢復過來。

898
00:41:45,030 --> 00:41:48,990
>> 我的意思是告訴的故事
咳嗽4結束 - 

899
00:41:48,990 --> 00:41:50,270
它是。

900
00:41:50,270 --> 00:41:54,380
那麼如果我，而不是定義
叫一個更大的一塊拼圖

901
00:41:54,380 --> 00:41:57,250
定義，說字n倍。

902
00:41:57,250 --> 00:41:59,930
打噴嚏是正義的，顯然，
划痕ACHOO。

903
00:41:59,930 --> 00:42:01,680
所以，我們對此表示為一個單詞，
只是因為這是

904
00:42:01,680 --> 00:42:02,750
程序的約束。

905
00:42:02,750 --> 00:42:07,860
咳嗽[咳嗽，但咳嗽，
C-O-U-G-H。所以這只是兩個

906
00:42:07,860 --> 00:42:10,820
不同的單詞，本質上，做
同樣的事情。

907
00:42:10,820 --> 00:42:12,820
>> 所以其實我可以做一個
像這樣的新塊。

908
00:42:12,820 --> 00:42:14,220
我沒有使用此菜單選項。

909
00:42:14,220 --> 00:42:16,960
但是，當你點擊座
你可以選擇一些選項。

910
00:42:16,960 --> 00:42:20,900
你可以說，此塊實際上
需要一定的投入，否則

911
00:42:20,900 --> 00:42:24,710
參數或參數，所以被稱為
您可以修改的行為

912
00:42:24,710 --> 00:42:25,520
你的塊。

913
00:42:25,520 --> 00:42:28,780
>> 所以我做了什麼剛才
我稱此塊說。

914
00:42:28,780 --> 00:42:30,880
然後我說，它需要
字符串輸入。

915
00:42:30,880 --> 00:42:32,810
現在注意到，默認情況下，
它說串1。

916
00:42:32,810 --> 00:42:35,440
字符串就是一個字，或
短語，我們的目的。

917
00:42:35,440 --> 00:42:37,810
但我只是把一些
佔位符文本，就像在

918
00:42:37,810 --> 00:42:40,620
網站，當你看到的用戶名，或
密碼，然後它消失時，

919
00:42:40,620 --> 00:42:41,550
你開始打字。

920
00:42:41,550 --> 00:42:42,720
這一切是。

921
00:42:42,720 --> 00:42:44,590
>> 現在我要去
添加一個數字輸入。

922
00:42:44,590 --> 00:42:47,180
我要調用這個N  - 
但是這是相當武斷的。

923
00:42:47,180 --> 00:42:49,510
然後只是一個標籤，只是為了讓
此塊多一點自我

924
00:42:49,510 --> 00:42:50,570
解釋 - 

925
00:42:50,570 --> 00:42:53,010
倍，這是我剛剛做了什麼。

926
00:42:53,010 --> 00:42:56,540
而最終的結果是，我得到
像這樣的一個塊。

927
00:42:56,540 --> 00:42:58,880
>> 現在注意，我使用
重複塊。

928
00:42:58,880 --> 00:43:03,480
但是，而非硬編碼三，我
拖放中n，所以我

929
00:43:03,480 --> 00:43:05,530
可以參數化的功能。

930
00:43:05,530 --> 00:43:08,590
我可以讓這個功能做一些事情
基於不同數量的次

931
00:43:08,590 --> 00:43:09,410
該值。

932
00:43:09,410 --> 00:43:14,270
>> 注意到，說，這是我做了什麼
在這裡，如果我拖字，我可以說不是一個

933
00:43:14,270 --> 00:43:17,860
硬編碼字，但無論
是通過在一秒鐘。

934
00:43:17,860 --> 00:43:20,200
同時，我怎麼重新實現
咳嗽嗎？

935
00:43:20,200 --> 00:43:26,980
我不是咳嗽定義為
說咳嗽的n倍。

936
00:43:26,980 --> 00:43:30,480
>> 因此，在短期，我要通過這
很快，但其基本思路是盡快

937
00:43:30,480 --> 00:43:32,750
當你開始看到在你的程序中
，等待一分鐘，我已經做了

938
00:43:32,750 --> 00:43:36,610
挺喜歡這個東西之前，
我可以提出一些共同

939
00:43:36,610 --> 00:43:37,090
功能嗎？

940
00:43:37,090 --> 00:43:41,090
我可以分解我在做什麼
到一些基本的想法？

941
00:43:41,090 --> 00:43:42,070
這就是我們在這裡做什麼。

942
00:43:42,070 --> 00:43:44,830
而且我已經堆放這些東西，在視覺上，
頂部的一個

943
00:43:44,830 --> 00:43:47,710
因為它是證明這個想法
二進制，開始為ASCII，

944
00:43:47,710 --> 00:43:51,530
圖形程序，排序
分層日益複雜的想法

945
00:43:51,530 --> 00:43:52,570
頂部的一個。

946
00:43:52,570 --> 00:43:53,730
>> 同樣的想法在這裡。

947
00:43:53,730 --> 00:43:56,870
我從頭開始，實施
咳嗽，然後實現咳嗽

948
00:43:56,870 --> 00:43:58,540
真的只是說著什麼。

949
00:43:58,540 --> 00:44:01,630
所以讓我代替實施
說什麼概念。

950
00:44:01,630 --> 00:44:05,200
而最重要的是，我可以實現
打噴嚏或咳嗽？

951
00:44:05,200 --> 00:44:07,990
我們可以做更多這樣的
變種依舊。

952
00:44:07,990 --> 00:44:10,400
>> 因此，從這個基本原則，
我們可以開始做

953
00:44:10,400 --> 00:44:12,180
日益複雜的程序。

954
00:44:12,180 --> 00:44:14,100
讓我開了這一個。

955
00:44:14,100 --> 00:44:18,020
事實上，我們可以有多個精靈
一次在屏幕上交互。

956
00:44:18,020 --> 00:44:23,470
如果我去到我的源目錄
搶所謂的主題之一，回想一下，

957
00:44:23,470 --> 00:44:26,920
線程僅僅是真正的能力
兩個腳本運行並排

958
00:44:26,920 --> 00:44:28,350
側在同一時間。

959
00:44:28,350 --> 00:44:34,490
>> 注意，現在，有兩個鳥精靈
一個的貓子畫面，兩者都具有

960
00:44:34,490 --> 00:44:35,270
自己的腳本。

961
00:44:35,270 --> 00:44:37,690
所以通知，當我點擊
貓，我得到這些腳本。

962
00:44:37,690 --> 00:44:39,830
當我點擊鳥，
我得到這些腳本。

963
00:44:39,830 --> 00:44:42,070
所以這些傢伙有
他自己的節目。

964
00:44:42,070 --> 00:44:46,680
現在，當我點擊綠色旗幟，請注意
，這是什麼節目

965
00:44:46,680 --> 00:44:54,090
有貓，令人難以置信
慢慢地，追鳥。

966
00:44:54,090 --> 00:44:57,120
但貓的優勢有
被編程以這樣一種方式

967
00:44:57,120 --> 00:45:00,540
無論在哪裡的鳥
是，貓走向他。

968
00:45:00,540 --> 00:45:02,150
>> 我們可以玩這個遊戲要快得多。

969
00:45:02,150 --> 00:45:07,750
所以，如果我是貓，我注意到
使用，讓我們說移動一個步驟。

970
00:45:07,750 --> 00:45:11,680
讓他感動的五個步驟
一時間，所以五個點的時間。

971
00:45:11,680 --> 00:45:13,580
讓我單擊發揮。

972
00:45:13,580 --> 00:45:14,490
>> [獅子吼]

973
00:45:14,490 --> 00:45:17,170
>> 國寶馬蘭：好的，現在我們可以
真正給貓的優勢。

974
00:45:17,170 --> 00:45:18,600
10個步驟的時間。

975
00:45:18,600 --> 00:45:20,120
>> [獅子吼]

976
00:45:20,120 --> 00:45:22,770
>> 國寶馬蘭：好的，非常迅速，
它變得有點優勢

977
00:45:22,770 --> 00:45:23,280
貓。

978
00:45:23,280 --> 00:45:25,310
但我會揮揮手
的一些細節。

979
00:45:25,310 --> 00:45:28,240
但原因，該路徑是
開始一點點的不同，每次

980
00:45:28,240 --> 00:45:29,700
是，我做一點隨機性。

981
00:45:29,700 --> 00:45:33,700
實際上，我指著貓在
基於不同的方向在哪裡

982
00:45:33,700 --> 00:45:38,710
想他開始，每次
遊戲或動畫，是一個

983
00:45:38,710 --> 00:45:39,760
有點不同。

984
00:45:39,760 --> 00:45:41,950
>> 現在，讓我給你介紹一個
其他構造。

985
00:45:41,950 --> 00:45:43,860
因此，在這種情況下，我們不得不功能。

986
00:45:43,860 --> 00:45:46,950
也有將是一塊拼圖
被稱為一個數組，或者一個列表，

987
00:45:46,950 --> 00:45:50,980
允許你存儲多個
裡面一個變量的值。

988
00:45:50,980 --> 00:45:53,410
我們看到線程，現在
有活動。

989
00:45:53,410 --> 00:45:56,330
>> 因此，這裡是一個事件使用
這兩個傢伙在這裡。

990
00:45:56,330 --> 00:46:02,490
如果我打開文件名為活動
從今天的例子中，我們將

991
00:46:02,490 --> 00:46:06,940
看到一個程序，看起來
有點像這樣。

992
00:46:06,940 --> 00:46:09,630
現在發現這傢伙 - 

993
00:46:09,630 --> 00:46:11,620
因此注意到我有藍色
布偶點擊 - 

994
00:46:11,620 --> 00:46:12,990
他只執行以下操作。

995
00:46:12,990 --> 00:46:15,540
他沒有之一
綠旗拼圖。

996
00:46:15,540 --> 00:46:18,620
他有一個當我收到事件 - 

997
00:46:18,620 --> 00:46:19,970
所以一些任意的單詞。

998
00:46:19,970 --> 00:46:21,590
我只是打出來的事件 - 

999
00:46:21,590 --> 00:46:23,740
他會說，波羅，
兩秒鐘。

1000
00:46:23,740 --> 00:46:25,800
>> 因此，那些你熟悉
這個遊戲可能知道

1001
00:46:25,800 --> 00:46:26,460
這是怎麼回事。

1002
00:46:26,460 --> 00:46:29,800
如果我現在點擊橙色布偶，
他的計劃做這件事。

1003
00:46:29,800 --> 00:46:35,020
永遠，如果鍵盤空格鍵
抑制，他會說，馬可，

1004
00:46:35,020 --> 00:46:36,580
兩秒鐘，在屏幕上。

1005
00:46:36,580 --> 00:46:39,590
但他也將使用這個票友
阻止稱為廣播。

1006
00:46:39,590 --> 00:46:42,270
他打算廣播報價
引文結束，“事件”。

1007
00:46:42,270 --> 00:46:47,540
>> 同時，藍色的傢伙，召回，
聽的報價引文結束，“事件。”

1008
00:46:47,540 --> 00:46:50,760
不知何故，現在，我們可以有
兩個精靈交互。

1009
00:46:50,760 --> 00:46:53,790
當我們到達web編程，
後來在長期，同樣

1010
00:46:53,790 --> 00:46:58,320
有利於有你的網站
做一些響應，

1011
00:46:58,320 --> 00:47:00,130
例如，敲擊鍵盤的聲音。

1012
00:47:00,130 --> 00:47:02,120
>> 因此，讓我繼續前進，
按空格。

1013
00:47:02,120 --> 00:47:04,020
橙色的傢伙馬爾科說。

1014
00:47:04,020 --> 00:47:05,840
藍傢伙說馬球。

1015
00:47:05,840 --> 00:47:10,780
如果我這樣做，再次橙傢伙說
馬可，藍色的傢伙說，馬球。

1016
00:47:10,780 --> 00:47:14,130
所以，讓我們進一步採取這一步。

1017
00:47:14,130 --> 00:47:18,790
這一次，我們就去，很可能
這裡只是一個幾分鐘。

1018
00:47:18,790 --> 00:47:19,904
我們有 - 

1019
00:47:19,904 --> 00:47:22,380
檯燈，下來吧。

1020
00:47:22,380 --> 00:47:24,500
你是對的就完了。

1021
00:47:24,500 --> 00:47:25,740
OK，你都可以上來了。

1022
00:47:25,740 --> 00:47:26,990
我們為大家的檯燈。

1023
00:47:26,990 --> 00:47:28,360
來吧。

1024
00:47:28,360 --> 00:47:30,090
我不知道，如果我們能保持
這是荒謬的插科打諢起來

1025
00:47:30,090 --> 00:47:32,035
整個學期，雖然。

1026
00:47:32,035 --> 00:47:33,530
好吧，下來吧。

1027
00:47:33,530 --> 00:47:40,260
>> 而在此之前，我們有
拉起下面的例子，只是為了

1028
00:47:40,260 --> 00:47:45,370
現在加快東西，這樣我們
從另一個的體現

1029
00:47:45,370 --> 00:47:48,360
用你的前身
相同的基本構建塊。

1030
00:47:48,360 --> 00:47:48,975
你叫什麼名字？

1031
00:47:48,975 --> 00:47:49,240
>> 約翰：約翰。

1032
00:47:49,240 --> 00:47:49,770
>> 國寶馬蘭：約翰。

1033
00:47:49,770 --> 00:47:50,400
我很高興你。

1034
00:47:50,400 --> 00:47:50,650
然後呢？

1035
00:47:50,650 --> 00:47:51,250
>> SETZ：Setz的。

1036
00:47:51,250 --> 00:47:53,130
>> 國寶馬蘭：Setz的，對我很好。

1037
00:47:53,130 --> 00:47:54,820
約翰，如果你願意來
先上去，這是一個老

1038
00:47:54,820 --> 00:47:55,910
學校遊戲名為青蛙。

1039
00:47:55,910 --> 00:47:57,530
對於這一點，您可以使用鍵盤。

1040
00:47:57,530 --> 00:48:02,425
其目標是要跨越
街道和水。

1041
00:48:02,425 --> 00:48:12,700
>> [FROGGER音樂播放聲音]

1042
00:48:12,700 --> 00:48:14,970
>> 國寶馬蘭：對不起，沒有
檯燈今天為你。

1043
00:48:14,970 --> 00:48:19,110
所有權利，SETZ，你會
喜歡來？

1044
00:48:19,110 --> 00:48:20,890
好吧，讓我們再做一次。

1045
00:48:20,890 --> 00:48:21,430
>> SETZ：我使用的箭頭？

1046
00:48:21,430 --> 00:48:22,360
>> 國寶馬蘭：箭頭鍵。

1047
00:48:22,360 --> 00:48:23,624
上，下，左，右。

1048
00:48:23,624 --> 00:48:35,700
>> [FROGGER音樂播放聲音]

1049
00:48:35,700 --> 00:48:37,880
>> 國寶馬蘭：我們會打電話給他們
安慰獎今天，

1050
00:48:37,880 --> 00:48:38,950
然後，做得非常好。

1051
00:48:38,950 --> 00:48:40,690
這裡，你，約翰和SETZ，。

1052
00:48:40,690 --> 00:48:41,940
恭喜你，所有的權利。

1053
00:48:41,940 --> 00:48:46,720

1054
00:48:46,720 --> 00:48:50,620
如此反复，遊戲，這個遊戲
想想這是怎麼回事？

1055
00:48:50,620 --> 00:48:52,060
>> 其中，顯然是一個有很多運動。

1056
00:48:52,060 --> 00:48:55,220
但我們已經看到，貓和
鳥的例子，你怎麼可以使

1057
00:48:55,220 --> 00:48:58,350
只是將一些運動錯覺
數一次又一次像素。

1058
00:48:58,350 --> 00:49:00,280
如果你有一個永遠的塊，
你可以有這些

1059
00:49:00,280 --> 00:49:02,120
汽車做下去。

1060
00:49:02,120 --> 00:49:03,720
我們有能力
有一定的隨機性。

1061
00:49:03,720 --> 00:49:06,310
因此，這個遊戲並不需要成為
完全一樣的，每次。

1062
00:49:06,310 --> 00:49:09,940
這些日誌，那些汽車，可以開始
稍微不同的時間，使

1063
00:49:09,940 --> 00:49:12,690
遊戲本身更有趣
每場比賽的發揮。

1064
00:49:12,690 --> 00:49:15,320
>> 與此同時，我們看到的能力
聽空格鍵。

1065
00:49:15,320 --> 00:49:18,830
但顯然，在從無到有，你可以也
聽向上，下，左，右，

1066
00:49:18,830 --> 00:49:20,760
真的鍵盤上的任意鍵。

1067
00:49:20,760 --> 00:49:22,200
而且你還可以做一些其他的事情。

1068
00:49:22,200 --> 00:49:24,660
讓我繼續前進，回去
網絡版。

1069
00:49:24,660 --> 00:49:30,280
>> 讓我進入我們的集合
這裡的例子。

1070
00:49:30,280 --> 00:49:36,120
而根據我的工作室，視頻
從本質上講，是一個文件夾

1071
00:49:36,120 --> 00:49:37,780
scratch.mit.edu。

1072
00:49:37,780 --> 00:49:39,710
我們有網頁版本的
所有這些項目。

1073
00:49:39,710 --> 00:49:42,530
，讓我們看看，如果我能得到我
計算機合作。

1074
00:49:42,530 --> 00:49:47,180
這是我們的一個朋友寫的
在麻省理工學院，被稱為移動的蝴蝶。

1075
00:49:47,180 --> 00:49:50,250
>> 並且，一旦這打開了，這是
要使用更多的

1076
00:49:50,250 --> 00:49:51,430
我的電腦的硬件。

1077
00:49:51,430 --> 00:49:53,325
從頭恰好是實施
用Flash。

1078
00:49:53,325 --> 00:49:56,250
Flash可以談談你的攝像頭，
如果你有一個。

1079
00:49:56,250 --> 00:50:00,210
所以，如果我繼續和全屏
在這裡，點擊綠色旗幟，通知

1080
00:50:00,210 --> 00:50:02,530
Flash的安全消息
是說，你要

1081
00:50:02,530 --> 00:50:04,210
允許使用我的攝像頭？

1082
00:50:04,210 --> 00:50:05,510
>> 通常情況下，你應該
可能會說“拒絕”。

1083
00:50:05,510 --> 00:50:07,180
但是，在這種情況下，我們會說允許。

1084
00:50:07,180 --> 00:50:10,430
然後我會告訴鉻
允許這一點。

1085
00:50:10,430 --> 00:50:15,010
而現在，在短短的時刻，
你看我，是的，我的。

1086
00:50:15,010 --> 00:50:18,154
如果我的手 - 

1087
00:50:18,154 --> 00:50:20,390
我有不動我
頭在同一時間。

1088
00:50:20,390 --> 00:50:21,740
還有一個反射
在屏幕上。

1089
00:50:21,740 --> 00:50:23,480
來吧，我們去那裡 - 

1090
00:50:23,480 --> 00:50:27,616
你可以將它在屏幕上，因為
也有拼圖碎片 - 哦，你

1091
00:50:27,616 --> 00:50:31,640
知道它是什麼，那是因為你還
看到我身後的投影屏幕。

1092
00:50:31,640 --> 00:50:33,870
因此，我們有一點點的無限
對那裡發生的事情。

1093
00:50:33,870 --> 00:50:36,470
>> 所有權利，所以我會打下來。

1094
00:50:36,470 --> 00:50:37,220
我們去那裡。

1095
00:50:37,220 --> 00:50:41,310
所以也有一塊拼圖，
說，當你看到運動下方

1096
00:50:41,310 --> 00:50:45,470
精靈之一，你可以把它去
向上，下，左，右等。

1097
00:50:45,470 --> 00:50:48,950
因此，我們有位虛擬現實
在這裡，所有內

1098
00:50:48,950 --> 00:50:52,570
我的瀏覽器，只是局限
我這裡使用的網絡攝像頭。

1099
00:50:52,570 --> 00:50:53,980
那麼什麼是在地平線上。

1100
00:50:53,980 --> 00:50:58,350
第一個問題集，你會看到，
或網站將稍後去網上

1101
00:50:58,350 --> 00:51:01,100
今晚cs50.net，是相當
多少將是開放式的。

1102
00:51:01,100 --> 00:51:04,410
並實施划痕項目
你的興趣，遊戲，

1103
00:51:04,410 --> 00:51:08,350
互動，藝術的東西，
挑戰自己使用任意數量

1104
00:51:08,350 --> 00:51:09,660
這些拼圖。

1105
00:51:09,660 --> 00:51:11,580
並且它可以是交互的
以這種方式。

1106
00:51:11,580 --> 00:51:15,470
或者，它可以更多的東西故意
講一個故事。

1107
00:51:15,470 --> 00:51:19,200
>> 事實上，這就是我們最終會關閉
今天，隨著最後一個例子。

1108
00:51:19,200 --> 00:51:21,290
讓我從頭進入本地。

1109
00:51:21,290 --> 00:51:25,300
讓我繼續打開這個，玩
最後一個寫一個程序

1110
00:51:25,300 --> 00:51:29,795
你的前任，即
一個在這裡。

1111
00:51:29,795 --> 00:51:32,960

1112
00:51:32,960 --> 00:51:35,938
好，這一個提高音量。

1113
00:51:35,938 --> 00:52:53,770
>> [音樂播放]

1114
00:52:53,770 --> 00:52:57,255
>> 旁白：在未來CS50，大衛
邀請志願者在舞台上。

1115
00:52:57,255 --> 00:52:58,636
>> 國寶馬蘭：對於本演示，
我們將需要一個志願者。

1116
00:52:58,636 --> 00:53:01,050
你想下來吧？

1117
00:53:01,050 --> 00:53:02,300
你叫什麼名字？

1118
00:53:02,300 --> 00:53:05,320

1119
00:53:05,320 --> 00:53:06,570
移動。

1120
00:53:06,570 --> 00:53:08,394