1
00:00:00,000 --> 00:00:08,560

2
00:00:08,560 --> 00:00:10,410
>> GABRIEL GUIMARAES：這是CS50。

3
00:00:10,410 --> 00:00:14,740
歡迎驚人的Web應用程序
用Ruby on Rails的。

4
00:00:14,740 --> 00:00:19,700
因此，對於任何人誰是感興趣的網頁
開發和製作網站，網頁

5
00:00:19,700 --> 00:00:26,510
應用程序，Ruby on Rails是這個
驚人的工具，Twitter的，GitHub上，

6
00:00:26,510 --> 00:00:31,470
Groupon的，以及各種非常好的的，
和大，web應用程序使用的

7
00:00:31,470 --> 00:00:33,080
最近幾年。

8
00:00:33,080 --> 00:00:37,190
這是一個非常，非常酷
功能，一個很酷的工具，

9
00:00:37,190 --> 00:00:39,290
因為它是新的。

10
00:00:39,290 --> 00:00:43,830
所以，它擁有所有的新的強大
技術整合在一個

11
00:00:43,830 --> 00:00:49,050
框架可以幫助你處理
各種令人驚奇的事情。

12
00:00:49,050 --> 00:00:50,970
>> 但究竟什麼是框架？

13
00:00:50,970 --> 00:00:55,700
這樣一個框架基本上是
一些創建 - 

14
00:00:55,700 --> 00:00:59,680
當你啟動一個網站，如果你開始
從頭開始，就像你打開

15
00:00:59,680 --> 00:01:04,530
gedit的存在，並且要所有代碼
你的HTML和代碼所有的

16
00:01:04,530 --> 00:01:08,130
PHP中，所有的CSS，一切
從頭開始 - 

17
00:01:08,130 --> 00:01:09,690
這只是將是一個大量的工作。

18
00:01:09,690 --> 00:01:13,940
和一個框架，從字面上給你
一半的網站已經完成。

19
00:01:13,940 --> 00:01:18,070
所以，你有一半的網站開始
有一切為您服務。

20
00:01:18,070 --> 00:01:22,690
如數據庫連接，並且所有
各種各樣的事情，你不用擔心

21
00:01:22,690 --> 00:01:25,040
樣，如果你​​從頭開始做，
你不必擔心那些

22
00:01:25,040 --> 00:01:26,480
低級別的細節。

23
00:01:26,480 --> 00:01:32,360
>> 但今天我們要導出的一個
本網站的大一

24
00:01:32,360 --> 00:01:34,740
類2017可能是熟悉的。

25
00:01:34,740 --> 00:01:40,170
所以這個網站是網站，我
沒有為我們班在今年夏天。

26
00:01:40,170 --> 00:01:46,500
這是一個網站，那裡的學生
類2017可以登錄和

27
00:01:46,500 --> 00:01:47,480
彼此相互作用。

28
00:01:47,480 --> 00:01:49,610
然後這是一個地圖 - 

29
00:01:49,610 --> 00:01:51,210
每個人，那裡的人們。

30
00:01:51,210 --> 00:01:56,970
和我們有一本書遊戲，遊戲歌曲
在這裡我們看到了人們的歌曲，

31
00:01:56,970 --> 00:01:57,970
人的書籍。

32
00:01:57,970 --> 00:02:00,480
他們喜歡讀什麼書，什麼
他們喜歡聽。

33
00:02:00,480 --> 00:02:06,830
而它的最有趣的部分是
它字面上花了三個小時

34
00:02:06,830 --> 00:02:07,840
編寫這一切。

35
00:02:07,840 --> 00:02:13,050
因為如果我不得不從做的一切
從頭開始，像開了gedit的，它

36
00:02:13,050 --> 00:02:16,400
可能會採取
我20，30小時。

37
00:02:16,400 --> 00:02:20,210
但隨著Ruby on Rails的，因為
一切都已經設置好適合我，

38
00:02:20,210 --> 00:02:25,550
我只花了三四個小時，
或者類似的東西。

39
00:02:25,550 --> 00:02:27,580
>> 那麼，什麼是Ruby on Rails的。

40
00:02:27,580 --> 00:02:32,720
Ruby on Rails的，又因為我們已經
說，是一個框架。

41
00:02:32,720 --> 00:02:34,800
這是一個框架的圖片。

42
00:02:34,800 --> 00:02:37,460
所以，你要開始建立一個
房子，你已經有一半的

43
00:02:37,460 --> 00:02:38,320
內部完成。

44
00:02:38,320 --> 00:02:38,970
這就是框架。

45
00:02:38,970 --> 00:02:40,560
和Ruby on Rails是
完全一樣的。

46
00:02:40,560 --> 00:02:44,440
你應該把它看作是，你開始
一個網站，你​​開始你的網頁

47
00:02:44,440 --> 00:02:48,830
應用程序，我們已經有了
一半是在那裡進行。

48
00:02:48,830 --> 00:02:50,400
但首先，什麼是紅寶石？

49
00:02:50,400 --> 00:02:53,510

50
00:02:53,510 --> 00:02:58,310
Ruby on Rails的使用模型視圖
控制器，這是範例，其中

51
00:02:58,310 --> 00:02:59,930
是一個非常有趣 - 

52
00:02:59,930 --> 00:03:04,250
與時下所有的應用程序
使用類似的東西。

53
00:03:04,250 --> 00:03:08,630
分離到的東西的這種想法
三個部分，模型，視圖和

54
00:03:08,630 --> 00:03:09,630
控制器。

55
00:03:09,630 --> 00:03:11,950
我們要談一點
稍後詳細說明。

56
00:03:11,950 --> 00:03:13,400
>> 一，什麼是紅寶石？

57
00:03:13,400 --> 00:03:14,500
因此，這是紅寶石。

58
00:03:14,500 --> 00:03:17,850
這就是的符號
語言稱為紅寶石。

59
00:03:17,850 --> 00:03:24,170
Ruby是解釋的新望一
語言，因此腳本。

60
00:03:24,170 --> 00:03:29,530
它是不是編譯的語言
像C.它是編譯後運行。

61
00:03:29,530 --> 00:03:33,220
所以這是一件好事，因為，就像PHP的，
例如也解釋，是

62
00:03:33,220 --> 00:03:33,960
不編譯。

63
00:03:33,960 --> 00:03:35,710
這是一件好事，因為它的便攜。

64
00:03:35,710 --> 00:03:39,740
所以你只要把你的代碼
一台機器到另一台。

65
00:03:39,740 --> 00:03:44,440
從一台Linux機器，到Windows
機，Mac或蘋果機，或

66
00:03:44,440 --> 00:03:45,240
類似的東西。

67
00:03:45,240 --> 00:03:49,160
而且你也不需要擔心
對於每個具體的細節

68
00:03:49,160 --> 00:03:49,890
操作系統。

69
00:03:49,890 --> 00:03:51,330
這是去上班無處不在。

70
00:03:51,330 --> 00:03:54,700
>> 和Ruby是一種語言，它 - 

71
00:03:54,700 --> 00:03:56,920
你們可能還記得這一點。

72
00:03:56,920 --> 00:04:01,440
人們用實現的哈希函數
C語言的哈希表

73
00:04:01,440 --> 00:04:04,860
上週有各種各樣
段錯誤的。

74
00:04:04,860 --> 00:04:12,360
然後事情擔心是否
該字符串我在那裡，我的字符串

75
00:04:12,360 --> 00:04:20,380
在這裡，實際上是小寫或
大寫，或這些令人擔憂

76
00:04:20,380 --> 00:04:21,410
低級別的細節。

77
00:04:21,410 --> 00:04:26,180
那麼在Ruby中，如果你想實現
一個哈希表，這正是你如何

78
00:04:26,180 --> 00:04:27,100
創建哈希表。

79
00:04:27,100 --> 00:04:30,280
你說，字典，這就是名
我的變量，=“Hash.new”。

80
00:04:30,280 --> 00:04:34,680
然後辭典[“富”]，而當我
加富到我的哈希表，我

81
00:04:34,680 --> 00:04:35,960
只是說foo是那裡。

82
00:04:35,960 --> 00:04:38,070
>> 然後，如果我想檢查是否
富在那裡，我只是說，如果

83
00:04:38,070 --> 00:04:40,270
字典[“富”] == true返回真。

84
00:04:40,270 --> 00:04:41,560
哇，這是你的哈希表。

85
00:04:41,560 --> 00:04:44,280
這就是執行
在Ruby的哈希表。

86
00:04:44,280 --> 00:04:50,200
所以每個人都希望他們能有
使用類似紅寶石的最後

87
00:04:50,200 --> 00:04:51,450
本週的PSET，對不對？

88
00:04:51,450 --> 00:04:54,410

89
00:04:54,410 --> 00:04:59,050
我們有各種各樣的原因想要
使用像Ruby的語言。

90
00:04:59,050 --> 00:05:01,380
Ruby有寶石。

91
00:05:01,380 --> 00:05:04,000
寶石是一種名稱
在Ruby庫。

92
00:05:04,000 --> 00:05:07,490
>> 所以各種有趣的功能
你可以有，例如，如果我

93
00:05:07,490 --> 00:05:09,280
要整合我的應用程序。

94
00:05:09,280 --> 00:05:12,470
哈佛2017的應用程序
被整合到Facebook。

95
00:05:12,470 --> 00:05:15,810
所以，你可以登錄，通過
臉譜，到應用程序。

96
00:05:15,810 --> 00:05:19,760
因此，如果你打算這樣做，你不這樣做
無需擔心發送一些

97
00:05:19,760 --> 00:05:23,760
HTTP請求到Facebook，並等待
為響應，並迫使

98
00:05:23,760 --> 00:05:25,150
反應，胡說，胡說，胡說。

99
00:05:25,150 --> 00:05:29,120
你剛才下載的寶石，
做一切為您。

100
00:05:29,120 --> 00:05:30,750
然後你就不需要
擔心這一切。

101
00:05:30,750 --> 00:05:33,670
>> 然後大量的幫助
在線的，當然。

102
00:05:33,670 --> 00:05:37,040
還有很多，很多，很多網站
要幫你倆用

103
00:05:37,040 --> 00:05:38,880
Ruby和Rails的。

104
00:05:38,880 --> 00:05:40,530
它是樂呵呵地代碼。

105
00:05:40,530 --> 00:05:46,770
正是因為你可以停止擔心
那些不是那麼好玩的問題。

106
00:05:46,770 --> 00:05:50,690
如果一樣東西是小寫或
大寫字母，然後這是為什麼

107
00:05:50,690 --> 00:05:54,500
給你一個分段錯誤，並
你真的可以潛入非常

108
00:05:54,500 --> 00:05:55,460
有趣的東西。

109
00:05:55,460 --> 00:05:59,650
潛入真的很酷問題。

110
00:05:59,650 --> 00:06:02,420
>> 所以紅寶石就像到C在一定意義上。

111
00:06:02,420 --> 00:06:05,950
所以它不會是那
大的跳躍實際上。

112
00:06:05,950 --> 00:06:09,470
這樣把，這是在我們的Ruby應用程序的打印。

113
00:06:09,470 --> 00:06:12,790
我想你可以使用打印過，
但看跌期權是每個人都使用。

114
00:06:12,790 --> 00:06:14,490
所以才提出的“Hello World”。

115
00:06:14,490 --> 00:06:21,400
你能，或者你不能，有
括號包圍

116
00:06:21,400 --> 00:06:23,280
“Hello World”的存在。

117
00:06:23,280 --> 00:06:25,350
你可以選擇是否
或不使用。

118
00:06:25,350 --> 00:06:26,780
然後X =“1”。

119
00:06:26,780 --> 00:06:29,030
while循環看起來很漂亮
大致相同。

120
00:06:29,030 --> 00:06:30,630
它只是有少的語法。

121
00:06:30,630 --> 00:06:32,590
這是種清潔劑一點點。

122
00:06:32,590 --> 00:06:37,380
然後當x> 25看跌期權“大！”
和別人把“小...”。

123
00:06:37,380 --> 00:06:39,070
而且它是一種C在這個意義上。

124
00:06:39,070 --> 00:06:41,630
>> 所以，如果你看一下，你可以
方法大概明白

125
00:06:41,630 --> 00:06:42,890
一切是怎麼回事。

126
00:06:42,890 --> 00:06:47,750
但它的功能更強大。

127
00:06:47,750 --> 00:06:54,520
更強大，因為，更重要的是，
它可以做的事情都不是 - 

128
00:06:54,520 --> 00:06:55,750
某種hackage一點點。

129
00:06:55,750 --> 00:06:57,430
在C語言中，你可以不這樣做
只是做一行。

130
00:06:57,430 --> 00:06:58,680
例如，把“我是＃{X}”。

131
00:06:58,680 --> 00:07:04,330

132
00:07:04,330 --> 00:07:11,100
這僅僅是語法把值
的X這裡，並且不打印

133
00:07:11,100 --> 00:07:12,160
字符x。

134
00:07:12,160 --> 00:07:17,850
在C語言中你所要做的百分比d和
然後豎起變量x的後

135
00:07:17,850 --> 00:07:19,730
這裡的逗號，或者類似的東西。

136
00:07:19,730 --> 00:07:22,220
>> 而在Ruby中有一個速記
只是這樣做。

137
00:07:22,220 --> 00:07:27,830
並提出這一點，如果x> 3，所以你可以
把如果所有在同一行。

138
00:07:27,830 --> 00:07:29,010
然後列表。

139
00:07:29,010 --> 00:07:33,320
在C列出，就像一個數組，你必須
跟踪你的數組有多大或

140
00:07:33,320 --> 00:07:34,720
否則，你得到一個分割
故障。

141
00:07:34,720 --> 00:07:36,210
您的陣列只有一種類型。

142
00:07:36,210 --> 00:07:38,790
所以，它要么收費的數組
或整數數組。

143
00:07:38,790 --> 00:07:43,620
在這種情況下，我創建了一個列表在這裡，
這是一個陣列，具有第一

144
00:07:43,620 --> 00:07:48,450
元素是一個字符串，約翰，然後
4，2  - 這些都是整數。

145
00:07:48,450 --> 00:07:53,590
然後我想補充，列表中，
左尖括號，左

146
00:07:53,590 --> 00:07:54,820
角度支架，三。

147
00:07:54,820 --> 00:07:58,170
這意味著剛剛追加
東西到我的清單。

148
00:07:58,170 --> 00:08:01,630
>> 因此，它是由於一種更為有趣
如果你想使用它作為

149
00:08:01,630 --> 00:08:03,920
整數的只是一個簡單的列表，
你可以，完全。

150
00:08:03,920 --> 00:08:05,530
這是完全罰款。

151
00:08:05,530 --> 00:08:06,750
只要把整數那裡。

152
00:08:06,750 --> 00:08:10,240
但是，如果你想要做的東西是
更引人注目的，是有其他的

153
00:08:10,240 --> 00:08:11,690
的東西，有 - 

154
00:08:11,690 --> 00:08:15,480
我不知道，各種列表中
那裡，或者是多個其它對象

155
00:08:15,480 --> 00:08:16,970
有趣的，你完全可以做到這一點。

156
00:08:16,970 --> 00:08:17,880
這是完全正常。

157
00:08:17,880 --> 00:08:21,210
然後，如果你想遍歷
在列表中，您可以使用

158
00:08:21,210 --> 00:08:24,850
更多C-ISH樣的方式。

159
00:08:24,850 --> 00:08:29,970
這是for循環，你開始
一個變量，I =“1”，或I =“0”。

160
00:08:29,970 --> 00:08:32,980
然後你走了，和迭代，
並獲得所有的元素。

161
00:08:32,980 --> 00:08:37,559
>> 但你也可以用這個
更多的紅寶石般的做法。

162
00:08:37,559 --> 00:08:40,289
這就像一個list.each。

163
00:08:40,289 --> 00:08:45,230
這只是說，我返回
列表中的所有元素。

164
00:08:45,230 --> 00:08:49,120
並與每一個元素做，
叫他們ELEM。

165
00:08:49,120 --> 00:08:51,880
所以這只是一個名字，我很
給予每個元素。

166
00:08:51,880 --> 00:08:56,630
現在這個是要重複所有
的元素，和元素，這將

167
00:08:56,630 --> 00:09:00,790
是，我們訪問的方式
該單一元件。

168
00:09:00,790 --> 00:09:04,310
所以，你完全可以堅持到
Ç的方法，但這個工程了。

169
00:09:04,310 --> 00:09:07,970
它是完全一樣的東西，確定。

170
00:09:07,970 --> 00:09:13,830
>> 而除此之外，它真的是，
很容易集成的Ruby和HTML

171
00:09:13,830 --> 00:09:17,010
因為你們有興趣
在Web應用程序。

172
00:09:17,010 --> 00:09:20,070
HTML是絕對的東西，
你會使用很多。

173
00:09:20,070 --> 00:09:25,820
在這裡，如果你想要把紅寶石
在HTML中，只是從這裡開始，<％。

174
00:09:25,820 --> 00:09:28,500
這意味著，這裡的Ruby開始。

175
00:09:28,500 --> 00:09:32,130
樣的，然後％>，像
PHP在這個意義上。

176
00:09:32,130 --> 00:09:35,520
紅寶石在這裡結束，那麼你就可以
只是把你如果在這裡。

177
00:09:35,520 --> 00:09:39,400
然後我有一些變量
user.logged_in。

178
00:09:39,400 --> 00:09:45,120
在Ruby中，我們通常會添加這些，無論是
問號或感嘆號

179
00:09:45,120 --> 00:09:48,210
標誌，像銀行的性格，
只是那種

180
00:09:48,210 --> 00:09:49,480
我們的職責區分。

181
00:09:49,480 --> 00:09:52,780
但你只要把那個
為了你自己。

182
00:09:52,780 --> 00:09:56,910
這不是改變
任何在功能性。

183
00:09:56,910 --> 00:10:01,160
>> 因此，只是為了提醒我，這是一個
功能 - 並在Ruby的功能，

184
00:10:01,160 --> 00:10:06,650
而不是C，正如我已經說過，
他們不需要括號。

185
00:10:06,650 --> 00:10:09,740
讓登錄的事情，這就是
一個函數，這是一個方法。

186
00:10:09,740 --> 00:10:12,990
但你沒有明確需要
把括號在那裡。

187
00:10:12,990 --> 00:10:16,030
所以只是問如果用戶的登錄狀態，
和如果用戶的登錄，現在

188
00:10:16,030 --> 00:10:17,100
HTML再次啟動。

189
00:10:17,100 --> 00:10:21,670
所以歡迎，並在這裡
我打印的user.name。

190
00:10:21,670 --> 00:10:22,920
就是這樣。

191
00:10:22,920 --> 00:10:24,970

192
00:10:24,970 --> 00:10:30,420
所以這是非常簡單的，如何
你與你的HTML集成的Ruby。

193
00:10:30,420 --> 00:10:34,560
和資源，正如我所說，有
各種各樣的Ruby資源。

194
00:10:34,560 --> 00:10:39,560
你們都可以事後看這個了
因為無論是視頻，並

195
00:10:39,560 --> 00:10:40,875
幻燈片，要
在線可用。

196
00:10:40,875 --> 00:10:44,620

197
00:10:44,620 --> 00:10:47,180
>> 現在讓我們進入軌道。

198
00:10:47,180 --> 00:10:48,330
Rails是愛。

199
00:10:48,330 --> 00:10:49,230
導軌 - 

200
00:10:49,230 --> 00:10:51,030
所以Ruby是他的語言。

201
00:10:51,030 --> 00:10:54,340
好了，就像PHP的，就像Python的。

202
00:10:54,340 --> 00:10:59,980
這是一個高層次的語言，而不是像C。
C'S中間，在低層次的語言

203
00:10:59,980 --> 00:11:05,240
這個意義上，紅寶石你不必
擔心內存重新分配，並

204
00:11:05,240 --> 00:11:07,300
指針和這些類型的東西。

205
00:11:07,300 --> 00:11:11,120
但Rails是這個程序，
是用Ruby編寫的。

206
00:11:11,120 --> 00:11:15,610
並且它採用紅寶石，為了這個
框架，為你能

207
00:11:15,610 --> 00:11:18,990
構建真棒Web應用程序。

208
00:11:18,990 --> 00:11:21,940
>> 所以，你必須先在安裝Ruby
你的機器，但是大多數機器

209
00:11:21,940 --> 00:11:22,630
已經有了。

210
00:11:22,630 --> 00:11:24,800
然後在它上面安裝導軌。

211
00:11:24,800 --> 00:11:26,540
我們將稍後談論那。

212
00:11:26,540 --> 00:11:28,100
以及為什麼Rails的？

213
00:11:28,100 --> 00:11:31,470
這樣的MVC，這是模型視圖控制器
我們談到了一點

214
00:11:31,470 --> 00:11:36,050
位，讓一切更簡單，因為
它分為東西都是

215
00:11:36,050 --> 00:11:42,420
在概念上不同分成不同的
部分應用程序。

216
00:11:42,420 --> 00:11:45,930
更少的時間花費在低層次的問題，
再次，和非常，非常

217
00:11:45,930 --> 00:11:46,820
流行的現在。

218
00:11:46,820 --> 00:11:52,130
因此，對於所有那些誰感興趣的
在啟動現場，或在一些

219
00:11:52,130 --> 00:11:58,435
喜歡創業，和人民
在技​​術市場誰是

220
00:11:58,435 --> 00:12:02,440
自己創業，現在
真的，林心如對真正的球迷

221
00:12:02,440 --> 00:12:04,120
Rails的，因為它是如此之快。

222
00:12:04,120 --> 00:12:07,510
>> 所以，你可以得到的東西運行起來
在不到一天的時間，而這

223
00:12:07,510 --> 00:12:10,410
真是一個非常引人注目的
參數使用Ruby。

224
00:12:10,410 --> 00:12:13,460
和Rails 4.0  - 

225
00:12:13,460 --> 00:12:15,920
它是從烤箱很新鮮了。

226
00:12:15,920 --> 00:12:16,930
所以Rails的4.0  - 

227
00:12:16,930 --> 00:12:20,180
我覺得第一個版本
在今年三月。

228
00:12:20,180 --> 00:12:23,460
而且它真的很好，它擁有所有
各種新的，很酷的功能。

229
00:12:23,460 --> 00:12:30,290
所以Ruby on Rails是一個框架，它是
不斷更新，讓所有

230
00:12:30,290 --> 00:12:31,540
的新技術。

231
00:12:31,540 --> 00:12:33,710

232
00:12:33,710 --> 00:12:39,800
>> 我第一次嘗試使用的Ruby on
Rails的，我有這個麻煩，因為我

233
00:12:39,800 --> 00:12:44,540
創建我的第一個Web應用程序，
它看起來完全一樣的。

234
00:12:44,540 --> 00:12:49,020
因此，它對於創建所有這些文件
你，我不知道是什麼 - 

235
00:12:49,020 --> 00:12:50,780
這是什麼？

236
00:12:50,780 --> 00:12:54,850
它創造了所有這些文件，我只
要創建一個簡單的程序，

237
00:12:54,850 --> 00:12:57,140
簡單的HTML網頁。

238
00:12:57,140 --> 00:12:59,680
而我什至不能做任何事情。

239
00:12:59,680 --> 00:13:02,430
所以我有點不知所措。

240
00:13:02,430 --> 00:13:08,350
但是，這的事情之一，一旦你
了解它，一切都變得那麼

241
00:13:08,350 --> 00:13:09,190
更加清晰。

242
00:13:09,190 --> 00:13:15,750
所以，不要被第一不堪重負
視線在你第一次創建什麼。

243
00:13:15,750 --> 00:13:18,430
>> 所以會發生什麼是Rails的創建
所有這些文件。

244
00:13:18,430 --> 00:13:20,470
所以，一個是文檔，文檔。

245
00:13:20,470 --> 00:13:23,080
DB，這是涉及到數據庫。

246
00:13:23,080 --> 00:13:25,060
lib中，這是庫記錄。

247
00:13:25,060 --> 00:13:28,200
公開，腳本和一些東西。

248
00:13:28,200 --> 00:13:32,110
幾乎所有你要擔心
大約是app文件夾，在那裡。

249
00:13:32,110 --> 00:13:34,430
這是一個包含文件夾
您的應用程序。

250
00:13:34,430 --> 00:13:35,540
所有其他文件 - 

251
00:13:35,540 --> 00:13:37,770
其中有些是重要的，你
要了解稍後。

252
00:13:37,770 --> 00:13:42,040
但他們只是在這裡
包含的框架。

253
00:13:42,040 --> 00:13:46,420
房子所以第一基石
你們正在建設，好不好？

254
00:13:46,420 --> 00:13:47,730
>> 但應用程序文件夾 - 

255
00:13:47,730 --> 00:13:49,630
這是真正重要的。

256
00:13:49,630 --> 00:13:53,050
和應用程序文件夾中有資產。

257
00:13:53,050 --> 00:13:57,690
資產是幾乎一切
這是未來。

258
00:13:57,690 --> 00:14:01,890
例如圖片，一切的
靜態那將會被下載

259
00:14:01,890 --> 00:14:03,450
您的網站。

260
00:14:03,450 --> 00:14:06,850
所以，圖像，JavaScript，CSS  - 

261
00:14:06,850 --> 00:14:08,520
這些類型的東西都是資產。

262
00:14:08,520 --> 00:14:11,310

263
00:14:11,310 --> 00:14:12,260
控制器 - 

264
00:14:12,260 --> 00:14:15,190
我們要多談談
什麼是控制器，模型，

265
00:14:15,190 --> 00:14:16,800
並且在第二字段。

266
00:14:16,800 --> 00:14:20,760
和傭工的功能，你
可以用在你的代碼

267
00:14:20,760 --> 00:14:22,800
幫你做一些事情。

268
00:14:22,800 --> 00:14:25,800
像功能登陸，
例如 -  user.loggedin。

269
00:14:25,800 --> 00:14:29,500
這是一個，大概你的功能
必須使用在您的所有部分

270
00:14:29,500 --> 00:14:30,030
應用程序。

271
00:14:30,030 --> 00:14:33,590
所以，你可以把喜歡的東西
在你的幫手。

272
00:14:33,590 --> 00:14:34,370
>> 郵寄 - 

273
00:14:34,370 --> 00:14:41,480
如果你要發送的
一封電子郵件給你的用戶，你

274
00:14:41,480 --> 00:14:43,420
要使用郵件程序。

275
00:14:43,420 --> 00:14:46,420
與模型和視圖，我們將
談論那現在。

276
00:14:46,420 --> 00:14:52,450
因此，模型視圖控制器，這是
紅寶石的基本基石

277
00:14:52,450 --> 00:14:55,730
Rails和大多數框架
現在，說實話。

278
00:14:55,730 --> 00:15:01,180
所以，再一次，我們分開我們所有的代碼
成三個不同部分。

279
00:15:01,180 --> 00:15:02,590
該模型 - 

280
00:15:02,590 --> 00:15:04,620
該模型基本數據庫。

281
00:15:04,620 --> 00:15:06,090
它可以處理數據庫中的事情。

282
00:15:06,090 --> 00:15:10,790
>> 所以在數據庫中的每個表都有一個
模型內的相應文件。

283
00:15:10,790 --> 00:15:13,330
所以這是怎樣的一個表
為您的用戶。

284
00:15:13,330 --> 00:15:18,250
所以你存儲信息，如
用戶名，他們的電子郵件，他們

285
00:15:18,250 --> 00:15:20,970
地址，他們的密碼，
之類的東西。

286
00:15:20,970 --> 00:15:24,535
你將有一個文件
被叫用戶RB模型 - 

287
00:15:24,535 --> 00:15:26,240
RB為Ruby。

288
00:15:26,240 --> 00:15:30,180
而且你將擁有一切
的方法和變量。

289
00:15:30,180 --> 00:15:34,130
變量要對應
到的用戶名，電子郵件，和

290
00:15:34,130 --> 00:15:35,370
一切。

291
00:15:35,370 --> 00:15:37,760
>> 而你將不得不方法。

292
00:15:37,760 --> 00:15:42,690
這將是有關的東西 - 

293
00:15:42,690 --> 00:15:46,400
你要處理這種信息
在數據庫中。

294
00:15:46,400 --> 00:15:50,220
要創建Rails的一個模型，
你只需要使用Rails的生成。

295
00:15:50,220 --> 00:15:54,990
並在Rails中創造的東西，你
實際需要的終端。

296
00:15:54,990 --> 00:15:58,770
所以這是一個非常終端
基礎架構。

297
00:15:58,770 --> 00:16:02,530
您只需登錄到終端，
和你的Rails，生成模型。

298
00:16:02,530 --> 00:16:04,670
和模型的名稱是用戶。

299
00:16:04,670 --> 00:16:10,270
我只是想有兩個變量，
兩列，在我的表。

300
00:16:10,270 --> 00:16:11,450
所以這是電子郵件。

301
00:16:11,450 --> 00:16:13,080
電子郵件是一種類型的字符串。

302
00:16:13,080 --> 00:16:15,450
密碼，密碼為
還有一種類型的字符串。

303
00:16:15,450 --> 00:16:16,520
這些是僅有的兩件事情。

304
00:16:16,520 --> 00:16:19,160
這是一種簡單化的用戶表。

305
00:16:19,160 --> 00:16:22,490
但你完全可以放一百個
事情的存在，如果你想。

306
00:16:22,490 --> 00:16:27,620
>> 和Rails也使得它非常，
讓一切都非常簡單

307
00:16:27,620 --> 00:16:30,040
各種數據庫的關係。

308
00:16:30,040 --> 00:16:36,100
所以通常情況下，當你在你的表
數據庫，他們不是很

309
00:16:36,100 --> 00:16:37,570
相互獨立的。

310
00:16:37,570 --> 00:16:39,392
讓我們來想想。

311
00:16:39,392 --> 00:16:42,960
你想購買和出售
產品線上。

312
00:16:42,960 --> 00:16:46,620
好了，讓你擁有一個網站，你
想購買和銷售產品。

313
00:16:46,620 --> 00:16:55,060
因此，每個用戶有很多的產品，
這個用戶是願意出售。

314
00:16:55,060 --> 00:17:00,970
並且每個用戶也有許多交易
這是正在進行的，或

315
00:17:00,970 --> 00:17:01,920
類似的東西。

316
00:17:01,920 --> 00:17:05,430
與交易
與另一個用戶。

317
00:17:05,430 --> 00:17:08,310
每個事務屬於
到兩個不同的用戶。

318
00:17:08,310 --> 00:17:10,560
這是購買和用戶
這是銷售給用戶。

319
00:17:10,560 --> 00:17:13,920
>> 因此，這些是所謂的
數據庫裡的關係。

320
00:17:13,920 --> 00:17:17,890
在這裡，我們有完全相同的關鍵字，
有許多屬於。

321
00:17:17,890 --> 00:17:19,500
這些是最重要的。

322
00:17:19,500 --> 00:17:22,410
而你只是想說，對於
例如，這是一個示例

323
00:17:22,410 --> 00:17:25,740
模型在哈佛20​​17網站。

324
00:17:25,740 --> 00:17:28,820
同樣，學生在這裡 - 

325
00:17:28,820 --> 00:17:32,870
每個學生在網站上，學生
是一個模型，是一個數據庫表。

326
00:17:32,870 --> 00:17:37,560
每個學生有很多書，因為你
可以說，什麼是你最喜歡的

327
00:17:37,560 --> 00:17:38,630
書，對吧。

328
00:17:38,630 --> 00:17:44,450
所以，每本書屬於
一個學生到這裡。

329
00:17:44,450 --> 00:17:46,910
和屬性訪問 - 

330
00:17:46,910 --> 00:17:49,580
這只是說，那些
是變量。

331
00:17:49,580 --> 00:17:53,050
這些都是變量訪問
從這個模型。

332
00:17:53,050 --> 00:17:58,570
和變量的作者
書中，描述，類型，和

333
00:17:58,570 --> 00:17:59,870
這本書的標題。

334
00:17:59,870 --> 00:18:02,700
因此，只要信息
關於這本書。

335
00:18:02,700 --> 00:18:06,410
>> 在這裡，我有一個方法，
簡單排序的一切。

336
00:18:06,410 --> 00:18:10,710
所以，定義和在這裡結束，這只是
說，這才是我的方法。

337
00:18:10,710 --> 00:18:13,220
Self.sorted_all。

338
00:18:13,220 --> 00:18:16,390
這只是，給我的一切來分類，
這就是你如何實現

339
00:18:16,390 --> 00:18:22,360
排序算法，
這是相當容易。

340
00:18:22,360 --> 00:18:27,430
但基本上，這是怎麼
一個模型的樣子，確定。

341
00:18:27,430 --> 00:18:32,990
有沒有人有關於問題
這個數據庫的事情嗎？

342
00:18:32,990 --> 00:18:33,736
關係？

343
00:18:33,736 --> 00:18:36,430
清楚了嗎？

344
00:18:36,430 --> 00:18:37,125
是。

345
00:18:37,125 --> 00:18:38,490
>> 觀眾：你能做到
排序算法？

346
00:18:38,490 --> 00:18:41,960
>> GABRIEL GUIMARAES：該
排序算法，確定。

347
00:18:41,960 --> 00:18:45,340
當你習慣了Ruby的語法，
這將是明確的。

348
00:18:45,340 --> 00:18:48,800
但基本上，elems後是Book.all。

349
00:18:48,800 --> 00:18:50,820
因此，本書是我的模型的名稱。

350
00:18:50,820 --> 00:18:55,670
當你創建一個模型，它帶有
各種漂亮的方法給你。

351
00:18:55,670 --> 00:18:58,810
所以dot.all是一種方法，
將返回所有圖書。

352
00:18:58,810 --> 00:19:02,560
但發現，例如，將搜索
一本書，並返回那本書，或

353
00:19:02,560 --> 00:19:03,840
類似的東西。

354
00:19:03,840 --> 00:19:05,990
所以elems後就是一切。

355
00:19:05,990 --> 00:19:08,870
而我只是說elems.sort。

356
00:19:08,870 --> 00:19:11,300
排序是一個內置的Ruby功能。

357
00:19:11,300 --> 00:19:13,526
>> 而且，做AB。

358
00:19:13,526 --> 00:19:15,940
因此，這不又是 - 

359
00:19:15,940 --> 00:19:17,400
你要排序。

360
00:19:17,400 --> 00:19:19,850
但你會得到
這種說法對我來說。

361
00:19:19,850 --> 00:19:25,160
和參數使用 - 這是一個
在Ruby中更難的事情實際上，

362
00:19:25,160 --> 00:19:26,920
該做的事情。

363
00:19:26,920 --> 00:19:31,470
但是，一旦你了解它的一切
來非常，非常直觀。

364
00:19:31,470 --> 00:19:37,140
所以，AB，這是說的地方
持有人，我要去使用 - 像

365
00:19:37,140 --> 00:19:41,760
變量我要去使用，是
將被稱為A和B。

366
00:19:41,760 --> 00:19:43,380
而這些都是書。

367
00:19:43,380 --> 00:19:47,120
>> 所以，因為排序需要比較
元素，還記得嗎？

368
00:19:47,120 --> 00:19:49,760
所以，當你理清頭緒，你
比較的兩個元素。

369
00:19:49,760 --> 00:19:51,900
我會說，每一次
你要去比較 - 

370
00:19:51,900 --> 00:19:54,350
所以這就是我傳遞
將參數排序。

371
00:19:54,350 --> 00:19:59,370
，爭論的焦點就是一切
從DO到這裡，好不好？

372
00:19:59,370 --> 00:20:02,980
而這樣的說法，只是告訴
排序如何比較。

373
00:20:02,980 --> 00:20:07,460
排序將在這裡工作，但它
將與他們的比較

374
00:20:07,460 --> 00:20:09,530
默認的比較算法。

375
00:20:09,530 --> 00:20:13,810
我希望它在一個非常具體的比較
方式，即，當書

376
00:20:13,810 --> 00:20:16,900
被創造，當每個
本書已創建。

377
00:20:16,900 --> 00:20:21,090
>> 所以我說，說的名頭
書是一個和名稱

378
00:20:21,090 --> 00:20:27,620
第二本書為b，我想排序排序
基於b.created_at這個東西

379
00:20:27,620 --> 00:20:30,000
奇怪的符號，a.created_at。

380
00:20:30,000 --> 00:20:34,350
而且奇怪的符號是速記
為如果一個大於

381
00:20:34,350 --> 00:20:35,380
其他的，則返回1。

382
00:20:35,380 --> 00:20:37,450
如果一個等於
另外，返回零。

383
00:20:37,450 --> 00:20:41,180
如果一個比小
另外，回報減去1。

384
00:20:41,180 --> 00:20:43,435
所以這是奇怪的符號是什麼。

385
00:20:43,435 --> 00:20:46,680

386
00:20:46,680 --> 00:20:47,500
>> 但是，這並不重要。

387
00:20:47,500 --> 00:20:52,780
我的意思是，我希望你們得到
現在的想法，數據庫 - 

388
00:20:52,780 --> 00:20:54,150
你可以有模式存在。

389
00:20:54,150 --> 00:20:59,850
所以你不必擔心
連接和使用SQL語句，

390
00:20:59,850 --> 00:21:00,500
之類的東西。

391
00:21:00,500 --> 00:21:04,920
它也可以創建門
SQL注入和所有

392
00:21:04,920 --> 00:21:06,460
各種各樣的安全問題。

393
00:21:06,460 --> 00:21:07,930
在這種情況下，你不
擔心。

394
00:21:07,930 --> 00:21:11,880
你只需要使用像book.all方法。

395
00:21:11,880 --> 00:21:15,210
而且，在課程的背景下，
是要你的數據庫，它的

396
00:21:15,210 --> 00:21:17,570
要使用一個SQL語句
讓所有的書籍。

397
00:21:17,570 --> 00:21:19,650
但你不必
擔心。

398
00:21:19,650 --> 00:21:24,090
這就是外賣，好不好？

399
00:21:24,090 --> 00:21:26,790
>> 而當你有一個belongs_to的聲明
這樣，這意味著

400
00:21:26,790 --> 00:21:31,780
一旦你有一本書的對象，你
可以看到的是它的學生。

401
00:21:31,780 --> 00:21:34,130
所以，哪個學生有這本書嗎？

402
00:21:34,130 --> 00:21:38,760
所以我們可以只使用book.student，並
，讓你的學生是什麼。

403
00:21:38,760 --> 00:21:42,440
，這是一個真正的功能有。

404
00:21:42,440 --> 00:21:43,950
>> 好了，現在的觀點。

405
00:21:43,950 --> 00:21:48,380
因此，該模型是交互
與數據庫，對不對？

406
00:21:48,380 --> 00:21:52,240
該視圖是基本的HTML，和
CSS和一些JavaScript。

407
00:21:52,240 --> 00:21:55,080
而這正是用戶
其實看到。

408
00:21:55,080 --> 00:21:56,540
用戶不會
看到你的數據庫。

409
00:21:56,540 --> 00:22:00,290
他會從看到的一些數據
數據庫嵌入到瀏覽器。

410
00:22:00,290 --> 00:22:04,940

411
00:22:04,940 --> 00:22:08,410
Ruby on Rails的，好不
簡單的製作領域。

412
00:22:08,410 --> 00:22:12,780
首先，因為它已經創建了
對你來說，開箱，一個佈局。

413
00:22:12,780 --> 00:22:16,200
>> 佈局是基本的東西 - 

414
00:22:16,200 --> 00:22:24,230
如果你所有的網頁都具有一個標誌在上面
而且，我不知道，某些菜單或

415
00:22:24,230 --> 00:22:29,000
類似的情況，您的所有網頁
分享共同的，那你就不要

416
00:22:29,000 --> 00:22:34,830
需要創建很多，很多，很多的HTML
文件，其中的所有文件有

417
00:22:34,830 --> 00:22:36,830
相同的HTML代碼。

418
00:22:36,830 --> 00:22:40,700
我的意思是這是愚蠢的，因為你只是
重複代碼不同的文件中。

419
00:22:40,700 --> 00:22:42,480
這絕對不是一個好辦法。

420
00:22:42,480 --> 00:22:45,660
>> 所以Ruby on Rails的創建
這種佈局適合你。

421
00:22:45,660 --> 00:22:49,770
而這僅僅是說，我的所有網頁
將有此HTML，這頭

422
00:22:49,770 --> 00:22:54,805
標題在這裡，這些都是
樣式表鏈接標記。

423
00:22:54,805 --> 00:22:56,800
插在這裡我所有的CSS。

424
00:22:56,800 --> 00:23:01,194
插在這裡我所有的JavaScript
和一些meta標籤。

425
00:23:01,194 --> 00:23:04,440
這只是東西，他們
自動為你做。

426
00:23:04,440 --> 00:23:07,490
然後，結束了頭，現在
此處開始體內。

427
00:23:07,490 --> 00:23:09,780
現在這是我的實際內容。

428
00:23:09,780 --> 00:23:16,620
所以，如果我想要把這樣的東西，一
菜單在這裡，我會把它的權利了

429
00:23:16,620 --> 00:23:19,600
這個地方，或者類似的東西，
讓我所有的頁面共享它。

430
00:23:19,600 --> 00:23:21,730
這樣的佈局被共享
所有的頁面。

431
00:23:21,730 --> 00:23:26,500
>> 現在，收益率在這裡只是說，沒有
不管是什麼頁面這是在，只是

432
00:23:26,500 --> 00:23:30,560
插入的所述內容
頁面在這裡了，好不好？

433
00:23:30,560 --> 00:23:33,770
現在這是，例如，
一個頁面，那將是內容

434
00:23:33,770 --> 00:23:38,950
插入此yield語句
自動軌道。

435
00:23:38,950 --> 00:23:40,700
但是，這是共享一個佈局
所有頁面。

436
00:23:40,700 --> 00:23:42,500
這是一個頁面的示例。

437
00:23:42,500 --> 00:23:46,410
而這正是本頁面
列出所有的書。

438
00:23:46,410 --> 00:23:49,390
所以這是一個基本的HTML表往上頂。

439
00:23:49,390 --> 00:23:53,730
所以上市書籍，書名，作者，
說明，流派。

440
00:23:53,730 --> 00:24:00,810
>> 這裡我們使用，再次，一些
Ruby語法，@ books.each- - 

441
00:24:00,810 --> 00:24:07,720
樣的@說，你變
是全球性的意義。

442
00:24:07,720 --> 00:24:10,940
因為這個變量實際上是
在控制器中聲明的

443
00:24:10,940 --> 00:24:12,840
你會看到現在。

444
00:24:12,840 --> 00:24:18,570
但只是想當然地認為這
@書是一個變量，它是一個列表

445
00:24:18,570 --> 00:24:20,000
所有的書籍。

446
00:24:20,000 --> 00:24:24,580
所以books.each，做，並再次，這是
只是說你怎麼想的名字

447
00:24:24,580 --> 00:24:29,580
每個迭代器，這樣我們不
擔心四，INT I

448
00:24:29,580 --> 00:24:30,630
等等，等等，等等。

449
00:24:30,630 --> 00:24:33,760
我們只取每個
元素，並使用它們。

450
00:24:33,760 --> 00:24:38,890
>> 所以，這是這本書，然後就打印
在這裡。 book.title，book.author，

451
00:24:38,890 --> 00:24:41,020
book.description，並
等等，等等，等等。

452
00:24:41,020 --> 00:24:42,940
這裡有一個的link_to。

453
00:24:42,940 --> 00:24:46,840
這樣的link_to只是一個鏈接標籤
用戶可以點擊和

454
00:24:46,840 --> 00:24:49,040
去到另一個網站。

455
00:24:49,040 --> 00:24:51,160
LINK_TO，表明本特別的書。

456
00:24:51,160 --> 00:24:56,480
因此，如果用戶是在很感興趣
這本書，那麼他就可以單擊顯示。

457
00:24:56,480 --> 00:24:59,350
或點擊編輯，如果他想
編輯的書。

458
00:24:59,350 --> 00:25:03,560
或銷毀，如果他想刪除
本書從數據庫中。

459
00:25:03,560 --> 00:25:06,260
好了，這是否有道理？

460
00:25:06,260 --> 00:25:08,610
好。

461
00:25:08,610 --> 00:25:10,600
>> 最後，控制器。

462
00:25:10,600 --> 00:25:17,150
所以基本上控制器
之間的界面

463
00:25:17,150 --> 00:25:20,040
模型和視圖。

464
00:25:20,040 --> 00:25:25,120
因此，該模型是部分的
代碼有數據庫 - 

465
00:25:25,120 --> 00:25:27,620
數據庫中的每個表有
在一個相應的文件

466
00:25:27,620 --> 00:25:30,120
模型，等等。

467
00:25:30,120 --> 00:25:34,890
以及如何做的模型，並
該視圖進行交互？

468
00:25:34,890 --> 00:25:36,990
這樣，通過控制器。

469
00:25:36,990 --> 00:25:43,620
什麼是控制器的作用是它的
模型類似，例如

470
00:25:43,620 --> 00:25:46,510
把所有的書裡面的
一個變量。

471
00:25:46,510 --> 00:25:47,760
贊一個，@書籍。

472
00:25:47,760 --> 00:25:50,200

473
00:25:50,200 --> 00:25:54,800
>> 並且它必須是全局與此
在的事，因為這將是

474
00:25:54,800 --> 00:25:56,180
通過視圖訪問。

475
00:25:56,180 --> 00:26:00,000
它不會被用於內
控制器本身。

476
00:26:00,000 --> 00:26:03,160
它只是減緩信息
該視圖將使用。

477
00:26:03,160 --> 00:26:08,030
例如，控制器檢查
如果用戶處於聯機狀態。

478
00:26:08,030 --> 00:26:09,620
它是如何做到這一點？

479
00:26:09,620 --> 00:26:11,760
實際上，它要求模型
因為該模型具有

480
00:26:11,760 --> 00:26:12,890
有關用戶的信息。

481
00:26:12,890 --> 00:26:15,840
它有一個用戶表，本本
表，其他表。

482
00:26:15,840 --> 00:26:18,560
因此控制器詢問
用戶在線。

483
00:26:18,560 --> 00:26:23,760
如果用戶是在線的，則控制器
處理事情，比如把一個cookie，

484
00:26:23,760 --> 00:26:28,120
或類似的東西，把郵票
可以說，用戶在線。

485
00:26:28,120 --> 00:26:29,930
無需再次登錄。

486
00:26:29,930 --> 00:26:34,080
>> 並且它會加載一個名為變量
用戶，例如，該

487
00:26:34,080 --> 00:26:35,130
視圖可以使用。

488
00:26:35,130 --> 00:26:42,375
並認為可以把這裡的東西，
例如，歡迎user.name。

489
00:26:42,375 --> 00:26:46,040
因此，它會說：歡迎
約翰，歡迎詹姆斯 - 

490
00:26:46,040 --> 00:26:47,390
這樣的事情，對不對？

491
00:26:47,390 --> 00:26:50,380
因此，所有這些變量中的使用
視圖將會在加載

492
00:26:50,380 --> 00:26:54,190
控制器和將要
從模型上拉。

493
00:26:54,190 --> 00:26:58,310

494
00:26:58,310 --> 00:27:00,555
>> 這是一個控制器的例子。

495
00:27:00,555 --> 00:27:03,140

496
00:27:03,140 --> 00:27:08,640
因此，我們有，基本上，每 - 

497
00:27:08,640 --> 00:27:10,010
我們所說的那些東西的動作。

498
00:27:10,010 --> 00:27:11,570
因此，指數是一個動作。

499
00:27:11,570 --> 00:27:13,820
這是一個Ruby的功能。

500
00:27:13,820 --> 00:27:16,160
它在那裡一個Ruby方法。

501
00:27:16,160 --> 00:27:19,350
但對於控制器調用
這些東西的動作。

502
00:27:19,350 --> 00:27:24,830
和每個動作都涉及到的路由。

503
00:27:24,830 --> 00:27:29,350
所以在這裡這條路線，例如，
是一個GET語句/書籍。

504
00:27:29,350 --> 00:27:37,500
所以，如果你去harvard2017.com/books，
什麼事情發生是這樣的代碼是

505
00:27:37,500 --> 00:27:40,630
將要被調用。

506
00:27:40,630 --> 00:27:44,290
>> 並有一個文件 - 

507
00:27:44,290 --> 00:27:46,010
讓我打開這個真正的快。

508
00:27:46,010 --> 00:27:51,310

509
00:27:51,310 --> 00:27:55,386
有一種稱為原始文件的文件。

510
00:27:55,386 --> 00:27:57,920
它不開放。

511
00:27:57,920 --> 00:28:02,330
因此，有一個叫做原始文件的文件
基本上匹配 - 

512
00:28:02,330 --> 00:28:03,580
哦，現在它打開。

513
00:28:03,580 --> 00:28:15,900

514
00:28:15,900 --> 00:28:17,550
在這裡，路線。

515
00:28:17,550 --> 00:28:24,440
所以基本上匹配的應變，
激活/新為例，

516
00:28:24,440 --> 00:28:27,810
東西在控制器中。

517
00:28:27,810 --> 00:28:31,580
因此，有此控制器稱為
激活控制器，但在這裡，

518
00:28:31,580 --> 00:28:32,790
我們有書籍，例如。

519
00:28:32,790 --> 00:28:33,740
所以比賽 - 

520
00:28:33,740 --> 00:28:39,040
書籍/新控制器
書籍，新的動作。

521
00:28:39,040 --> 00:28:41,290
所以基本上，非常簡單
的東西。

522
00:28:41,290 --> 00:28:43,970

523
00:28:43,970 --> 00:28:48,770
>> 在這裡，如果你必須得到/書籍，
斜線的書籍ID，斜線新，

524
00:28:48,770 --> 00:28:53,250
你打算去那
Ruby方法出現了下滑。

525
00:28:53,250 --> 00:28:58,210
所以在這裡，這是什麼指數做
只是加載本書記錄。

526
00:28:58,210 --> 00:28:59,570
在這個時候， - 

527
00:28:59,570 --> 00:29:02,160
我記錄所有的日誌的書籍。

528
00:29:02,160 --> 00:29:03,050
和排序了這一切。

529
00:29:03,050 --> 00:29:05,870
因此，這將返回
所有分類書籍。

530
00:29:05,870 --> 00:29:07,940
這是，再次，在數據庫中。

531
00:29:07,940 --> 00:29:09,570
因此，這是該模型的一種方法。

532
00:29:09,570 --> 00:29:12,440
您看到這個方法是
在模型中創建的。

533
00:29:12,440 --> 00:29:16,170
現在，這只是加載所有的書
並把在一個變量，

534
00:29:16,170 --> 00:29:17,490
可以通過該視圖可以看出。

535
00:29:17,490 --> 00:29:20,680
>> 因為，你不能在中間
您的HTML代碼，您不能調用

536
00:29:20,680 --> 00:29:23,940
一些直接從模型
因為有兩個原因。

537
00:29:23,940 --> 00:29:28,260
首先，出於安全原因，因為
它不是真正有趣的是

538
00:29:28,260 --> 00:29:32,920
裡面直接加載信息
每個HTML這是在數據庫中。

539
00:29:32,920 --> 00:29:36,030
第二，保持你的
代碼真的舉辦。

540
00:29:36,030 --> 00:29:38,800
因此，分離完全
不同的部分。

541
00:29:38,800 --> 00:29:42,830
所以BookLog.sorted_all，這在
數據庫，這是將要投入

542
00:29:42,830 --> 00:29:44,290
一個變量@書。

543
00:29:44,290 --> 00:29:47,695
現在這個變量的訪問
在你的HTML代碼。

544
00:29:47,695 --> 00:29:54,610
所以，你可以把所有的書
有像我們一樣，就在這裡。

545
00:29:54,610 --> 00:29:57,760
這是可變的。

546
00:29:57,760 --> 00:30:04,730
>> 來訪的respond_to做|格式|，
這只是一種Ruby語法的

547
00:30:04,730 --> 00:30:08,140
如果用戶問我
HTML代碼，我要去

548
00:30:08,140 --> 00:30:09,340
響應的HTML代碼。

549
00:30:09,340 --> 00:30:15,500
如果用戶問我使用JSON代碼，
這恐怕是網絡應用程序使用

550
00:30:15,500 --> 00:30:20,780
彼此之間進行通信，它們
通常使用JSON或其他

551
00:30:20,780 --> 00:30:23,120
之類的話。

552
00:30:23,120 --> 00:30:25,850
因此，它只是回應那些使用
兩種不同的格式。

553
00:30:25,850 --> 00:30:31,720
但對於普通用戶，這
不需要到這裡來。

554
00:30:31,720 --> 00:30:34,060
你會剛剛與回應
HTML，這很好。

555
00:30:34,060 --> 00:30:36,220
所以，真的不擔心
很多關於這個。

556
00:30:36,220 --> 00:30:39,510
這是代碼的唯一行我們
控制，因為它是從HTML載入

557
00:30:39,510 --> 00:30:42,630
數據庫，投入的東西的
通過視圖訪問。

558
00:30:42,630 --> 00:30:49,870
>> 然後新的，所以在這裡
我創建的書籍。

559
00:30:49,870 --> 00:30:55,490
而是創造的書籍，我需要一個學生
因為我需要知道學生

560
00:30:55,490 --> 00:30:58,490
其著作這屬於，右。

561
00:30:58,490 --> 00:31:00,780
所以@學生=學生。

562
00:31:00,780 --> 00:31:06,500
學生，再一次，我們已經開始與
大S是模範學生。

563
00:31:06,500 --> 00:31:09,380
好了，這就是模範生，
這是模型本書記錄。

564
00:31:09,380 --> 00:31:15,150
Student.find，所以我打算找一個
學生使用的參數標識。

565
00:31:15,150 --> 00:31:19,160
params.id，這只是讓我的價值
 - 這個ID來傳遞

566
00:31:19,160 --> 00:31:23,410
與該URL。

567
00:31:23,410 --> 00:31:25,440
>> 只是要尋找的學生。

568
00:31:25,440 --> 00:31:28,420
和第一，我們要檢查
如果學生有一些歌曲

569
00:31:28,420 --> 00:31:29,910
和胡說，胡說，胡說。

570
00:31:29,910 --> 00:31:35,570
而這已處理
情況下，當學生

571
00:31:35,570 --> 00:31:38,340
不存在，例如。

572
00:31:38,340 --> 00:31:44,450
然後，否則，我們只是回應
使用HTML同樣的事情。

573
00:31:44,450 --> 00:31:47,570
然後我們就可以讓用戶
創建自己的歌曲。

574
00:31:47,570 --> 00:31:49,320
因此，這是新的。

575
00:31:49,320 --> 00:31:52,580
新通常用於讓
用戶創造的東西。

576
00:31:52,580 --> 00:31:56,440
再有就是創​​建操作
這通常用於 - 

577
00:31:56,440 --> 00:31:59,040
居然把歌曲中的數據庫
或者類似的東西。

578
00:31:59,040 --> 00:32:01,770
但是，一旦你開始使用Rails，
這些東西都將是

579
00:32:01,770 --> 00:32:05,110
很多很多更加清晰。

580
00:32:05,110 --> 00:32:07,910
OK，冷卻。

581
00:32:07,910 --> 00:32:09,715
有任何疑問，這麼遠嗎？

582
00:32:09,715 --> 00:32:15,240
確實很有道理帶控制器，
模型，領域 - 

583
00:32:15,240 --> 00:32:17,860
是嗎？

584
00:32:17,860 --> 00:32:20,980
>> 再次在你的Rails應用程序 - 

585
00:32:20,980 --> 00:32:24,700
因此，所有的，可以在這裡找到。

586
00:32:24,700 --> 00:32:30,430
所以，你有應用程序，控制器，這些
是我所有的控制器。

587
00:32:30,430 --> 00:32:32,880
因此，例如，書籍控制。

588
00:32:32,880 --> 00:32:35,490
這就是我們剛才看到的那個。

589
00:32:35,490 --> 00:32:36,400
然後景色。

590
00:32:36,400 --> 00:32:39,750
並且每個控制器都有一個
關聯視圖，對不對？

591
00:32:39,750 --> 00:32:43,750
所以，當你調用這個自動
指數在這裡，例如，或當您

592
00:32:43,750 --> 00:32:49,930
把這種新的書籍，那麼該視圖，
書籍，新的將被調用。

593
00:32:49,930 --> 00:32:53,300
>> 所以Rails的做一切
自動為您。

594
00:32:53,300 --> 00:32:59,420
因此，每個控制器都有一個關聯的
查看所有的車型 - 

595
00:32:59,420 --> 00:33:01,970
這裡我有一個，兩個，三個，
四，五款。

596
00:33:01,970 --> 00:33:05,800
但是，這是一個學生的模式，所以這些
是變量，所有的

597
00:33:05,800 --> 00:33:08,620
學生 - 本地化，
出生日期。

598
00:33:08,620 --> 00:33:11,270
學生是多一點點
複雜，因為每個學生都​​有

599
00:33:11,270 --> 00:33:15,400
以上不同的方法
與其關聯。

600
00:33:15,400 --> 00:33:18,770
但是，這只是處理
表中把所有的

601
00:33:18,770 --> 00:33:21,980
學生在數據庫中。

602
00:33:21,980 --> 00:33:24,300
>> 而且，OK，安裝Rails的。

603
00:33:24,300 --> 00:33:27,710
安裝Rails的，說實話，
不是簡單的事情。

604
00:33:27,710 --> 00:33:32,980
但是，一旦你過去的一切，
這是非常，非常容易。

605
00:33:32,980 --> 00:33:38,810
所以在安裝Rails的，你只要到
網站rubyandrails.org /下載

606
00:33:38,810 --> 00:33:41,510
並按照他們的指示在那裡。

607
00:33:41,510 --> 00:33:42,700
下載一切。

608
00:33:42,700 --> 00:33:46,600
而你能做到這一點無論是在家電，
在CS50電器，上

609
00:33:46,600 --> 00:33:51,120
Windows上，Mac或任何操作
您所選擇的系統。

610
00:33:51,120 --> 00:33:52,460
Ruby on Rails的運行一切。

611
00:33:52,460 --> 00:33:56,680
>> 賠率是你已經安裝了Ruby
如果你有一台Mac或 - 

612
00:33:56,680 --> 00:33:58,130
在家電，我認為Ruby是 - 

613
00:33:58,130 --> 00:34:00,940
我不太肯定。

614
00:34:00,940 --> 00:34:02,440
然後你只需要安裝該軟件。

615
00:34:02,440 --> 00:34:07,190
如果你想創建一個新的
Web應用程序，你只需

616
00:34:07,190 --> 00:34:10,270
做Rails的，新的，博客。

617
00:34:10,270 --> 00:34:12,429
Rails的，新的 - 

618
00:34:12,429 --> 00:34:13,310
我不知道 - 

619
00:34:13,310 --> 00:34:15,050
您的網站的名稱。

620
00:34:15,050 --> 00:34:16,380
它就是這麼簡單。

621
00:34:16,380 --> 00:34:19,060
>> 這將創建所有這些
文件，我剛才給你看。

622
00:34:19,060 --> 00:34:22,730
但該模型，視圖和
控制器都不會是

623
00:34:22,730 --> 00:34:24,330
人口呢。

624
00:34:24,330 --> 00:34:28,710
你只是將不得不去那裡
並填充這三個文件夾。

625
00:34:28,710 --> 00:34:32,840
所以賠率是，你要創建一個模型，
例如，實現一個

626
00:34:32,840 --> 00:34:33,780
第一個模型。

627
00:34:33,780 --> 00:34:40,440
如此反复，總是要咬小
有問題的位的時間。

628
00:34:40,440 --> 00:34:42,659
>> 然後讓我們說，創建
一款型號為你的用戶。

629
00:34:42,659 --> 00:34:44,370
這是第一件事
如果你的用戶。

630
00:34:44,370 --> 00:34:48,440
然後，我想創建一個模型
就像我們發現在這裡。

631
00:34:48,440 --> 00:34:58,470
導軌，生成，模型，用戶，然後
電子郵件字符串 - 我們在這裡。

632
00:34:58,470 --> 00:35:01,200
而剛剛建立的模型，是的。

633
00:35:01,200 --> 00:35:05,030
Rails的模型生成用戶的電子郵件：字符串
密碼：字符串。

634
00:35:05,030 --> 00:35:09,650
>> 然後創建一個控制器
該處理的用戶。

635
00:35:09,650 --> 00:35:12,790
您可以創建新的用戶和
做這些類型的東西。

636
00:35:12,790 --> 00:35:18,280
然後你就可以繼續創建
您的網站的其餘部分。

637
00:35:18,280 --> 00:35:22,470
酷，問題嗎？

638
00:35:22,470 --> 00:35:23,230
是。

639
00:35:23,230 --> 00:35:24,480
>> 觀眾：[聽不清]

640
00:35:24,480 --> 00:35:27,430

641
00:35:27,430 --> 00:35:29,910
>> GABRIEL GUIMARAES：是的，是的，你
肯定是要進入該視圖。

642
00:35:29,910 --> 00:35:31,290
這是一個非常好的問題。

643
00:35:31,290 --> 00:35:36,410
這樣的觀點實際上是什麼
包含你的HTML。

644
00:35:36,410 --> 00:35:39,240
因此，它是什麼樣的用戶
將要看到的。

645
00:35:39,240 --> 00:35:46,690
再次，在這裡，這是一個
例如一個觀點。

646
00:35:46,690 --> 00:35:52,040
它具有HTML代碼和紅寶石
在同一時間碼。

647
00:35:52,040 --> 00:35:56,010
所以Ruby代碼有沒有放東西
從數據庫，例如

648
00:35:56,010 --> 00:35:59,150
這是在控制器加載。

649
00:35:59,150 --> 00:36:04,240
使變量@書籍，例如
擁有所有的書籍和表

650
00:36:04,240 --> 00:36:05,340
書在數據庫中。

651
00:36:05,340 --> 00:36:08,680
我們確信，它有
在控制器中。

652
00:36:08,680 --> 00:36:10,250
>> 和視圖 - 

653
00:36:10,250 --> 00:36:15,900
每過你的網站的網頁是
將會有一個相關聯的視圖。

654
00:36:15,900 --> 00:36:21,762
所以，如果你去到首頁，
第一個頁面，harvard2017.com。

655
00:36:21,762 --> 00:36:23,490
這顯示一個頁面。

656
00:36:23,490 --> 00:36:26,760
然後你去削減輪廓。

657
00:36:26,760 --> 00:36:30,150
那將進入一個控制器
這是一個配置文件控制。

658
00:36:30,150 --> 00:36:34,620
以及更新控制器會
給你縱斷面圖。

659
00:36:34,620 --> 00:36:37,590
和縱斷面圖是怎樣看
有點像這樣，但是它要

660
00:36:37,590 --> 00:36:41,910
有關於用戶的信息，
而不是書本。

661
00:36:41,910 --> 00:36:46,840
>> 所以它的HTML代碼，CSS和那些
即用戶看到的東西

662
00:36:46,840 --> 00:36:49,680
用Ruby代碼 - 

663
00:36:49,680 --> 00:36:52,505
實際打印的東西
從數據庫中。

664
00:36:52,505 --> 00:36:54,520
是更清楚了嗎？

665
00:36:54,520 --> 00:36:55,080
我希望。

666
00:36:55,080 --> 00:36:58,066
>> 觀眾：的HTML代碼是用來
其實做網站的

667
00:36:58,066 --> 00:37:02,470
用戶看到，但Ruby代碼是
是什麼讓網站的工作？

668
00:37:02,470 --> 00:37:06,500
>> GABRIEL GUIMARAES：Ruby代碼
被轉換為HTML。

669
00:37:06,500 --> 00:37:09,420
因此，用戶得到什麼
僅僅是HTML，好不好？

670
00:37:09,420 --> 00:37:10,900
這是唯一的HTML。

671
00:37:10,900 --> 00:37:18,740
這book.title是要轉換為
book.title的HTML中的值，確定。

672
00:37:18,740 --> 00:37:23,080
因此，這是在所有的服務器上，所以
這個要看什麼書都沒有

673
00:37:23,080 --> 00:37:24,410
在服務器現在。

674
00:37:24,410 --> 00:37:32,930
但是，服務器馬上會
意義僅僅是HTML代碼，確定。

675
00:37:32,930 --> 00:37:36,720
>> 但認為只是給佈局
什麼是HTML將會是什麼樣

676
00:37:36,720 --> 00:37:39,530
和什麼樣的變數
將要。

677
00:37:39,530 --> 00:37:42,170
這種打印出來，確定。

678
00:37:42,170 --> 00:37:44,360
那些東西有
基本打印輸出。

679
00:37:44,360 --> 00:37:47,430
他們將打印變量，確定。

680
00:37:47,430 --> 00:37:49,850
那麼，什麼是唯一的HTML，那些 - 

681
00:37:49,850 --> 00:37:51,390
作者，標題，描述。

682
00:37:51,390 --> 00:37:53,540
這是靜態內容。

683
00:37:53,540 --> 00:37:54,520
這是不會改變的。

684
00:37:54,520 --> 00:37:56,700
這只是普通的HTML代碼。

685
00:37:56,700 --> 00:37:59,080
這些都是打印輸出
變量 - 

686
00:37:59,080 --> 00:38:00,330
依賴的東西。

687
00:38:00,330 --> 00:38:02,350

688
00:38:02,350 --> 00:38:03,600
酷，更多的問題？

689
00:38:03,600 --> 00:38:12,120

690
00:38:12,120 --> 00:38:12,600
好？

691
00:38:12,600 --> 00:38:13,080
是。

692
00:38:13,080 --> 00:38:15,720
>> 觀眾：我覺得你在做所有
在不同的文本編輯

693
00:38:15,720 --> 00:38:16,920
編輯程序。

694
00:38:16,920 --> 00:38:19,520
難道我們還下載了？

695
00:38:19,520 --> 00:38:24,250
>> GABRIEL GUIMARAES：是的，我喜歡這個
調用文本編輯TextMate的。

696
00:38:24,250 --> 00:38:24,990
而且它真的很不錯。

697
00:38:24,990 --> 00:38:26,980
它非常適合紅寶石。

698
00:38:26,980 --> 00:38:29,270
它的色彩的東西很整齊。

699
00:38:29,270 --> 00:38:34,770
這樣的TextMate，T-E-X-T。我要去
放了，堅持住 - 

700
00:38:34,770 --> 00:38:42,880

701
00:38:42,880 --> 00:38:45,720
>> 我的意思是你可以用gedit
或者你想要的任何東西。

702
00:38:45,720 --> 00:38:49,970
但是，這是特定的Mac，而這
真的是整齊的，因為它把所有的

703
00:38:49,970 --> 00:38:51,000
您的文件在那裡。

704
00:38:51,000 --> 00:38:53,620
而在Ruby on Rails的，你需要
切換文件很多。

705
00:38:53,620 --> 00:38:55,890
所以它的很多很多的文件只是
從一個文件中去，跳轉到

706
00:38:55,890 --> 00:38:57,120
一個文件或另一個。

707
00:38:57,120 --> 00:39:02,000
這樣的TextMate是一個非常好的，但
有很多在那裡。

708
00:39:02,000 --> 00:39:03,250
更多問題？

709
00:39:03,250 --> 00:39:08,680

710
00:39:08,680 --> 00:39:09,870
好了，是嗎？

711
00:39:09,870 --> 00:39:12,825
>> 觀眾：是否有一個移動開發
通過Ruby on Rails的？

712
00:39:12,825 --> 00:39:15,640

713
00:39:15,640 --> 00:39:17,050
>> GABRIEL GUIMARAES：我已經
聽說過的東西。

714
00:39:17,050 --> 00:39:19,550
我沒有使用過他們。

715
00:39:19,550 --> 00:39:21,570
你可以研究更上了。

716
00:39:21,570 --> 00:39:24,740
我不知道是否有任何
好東西在那裡。

717
00:39:24,740 --> 00:39:29,980

718
00:39:29,980 --> 00:39:31,030
好了，是嗎？

719
00:39:31,030 --> 00:39:32,280
>> 觀眾：[聽不清]

720
00:39:32,280 --> 00:39:38,340

721
00:39:38,340 --> 00:39:40,550
>> GABRIEL GUIMARAES：不Rails的，
大概紅寶石陣列。

722
00:39:40,550 --> 00:39:44,270

723
00:39:44,270 --> 00:39:49,080
打開一個終端窗口
和類型，“紅寶石”。

724
00:39:49,080 --> 00:39:52,030
是啊，大概，然後你
只需要安裝Rails。

725
00:39:52,030 --> 00:39:57,050
但是，如果你要安裝新的
Rails的4.0，我強烈建議，

726
00:39:57,050 --> 00:40:02,870
你應該下載的Ruby 2.0。

727
00:40:02,870 --> 00:40:04,530
這就是新的了。

728
00:40:04,530 --> 00:40:09,530
而新的Rails 4.0的東西
很酷的說

729
00:40:09,530 --> 00:40:11,260
它的資產。

730
00:40:11,260 --> 00:40:12,810
它可以處理的資產。

731
00:40:12,810 --> 00:40:18,860
資產再有圖像，CSS文件，
和JavaScript文件。

732
00:40:18,860 --> 00:40:24,060
因此，一個非常靈巧的東西的Ruby on
Rails的為你做的是所有這些的CSS

733
00:40:24,060 --> 00:40:26,980
你有文件和一切 - 

734
00:40:26,980 --> 00:40:32,420
它只是一切都捆綁起來成一個
巨大的文件，不帶空格或任何東西，

735
00:40:32,420 --> 00:40:40,120
以減少用戶需要的時間
從你的服務器上下載代碼。

736
00:40:40,120 --> 00:40:47,780
>> 因此，當您在計算機中看到的，它
將不得不像15 CSS文件。

737
00:40:47,780 --> 00:40:49,520
或者很多很多不同的CSS文件。

738
00:40:49,520 --> 00:40:54,890
但在一天結束時，什麼的Rails
它會自動為你是它把

739
00:40:54,890 --> 00:41:00,760
一切都匯集成一個大文件
這樣它最大限度地減少了請求時間。

740
00:41:00,760 --> 00:41:02,630
這真的很酷。

741
00:41:02,630 --> 00:41:02,940
是嗎？

742
00:41:02,940 --> 00:41:04,190
>> 觀眾：[聽不清]

743
00:41:04,190 --> 00:41:13,910

744
00:41:13,910 --> 00:41:14,440
>> GABRIEL GUIMARAES：沒錯。

745
00:41:14,440 --> 00:41:16,230
因此，谷歌地圖集成。

746
00:41:16,230 --> 00:41:20,200
這是從一個谷歌的JavaScript API。

747
00:41:20,200 --> 00:41:23,750
所以，我只是去了谷歌網站。

748
00:41:23,750 --> 00:41:29,950
他們有這樣的谷歌地圖API和我
下載的代碼，並將其集成

749
00:41:29,950 --> 00:41:31,610
進入我的看法。

750
00:41:31,610 --> 00:41:35,490
因此，我需要做的有
是我需要得到的

751
00:41:35,490 --> 00:41:37,310
從數據庫的位置。

752
00:41:37,310 --> 00:41:38,990
這是在控制器中完成的。

753
00:41:38,990 --> 00:41:40,950
於是我去到控制器 - 

754
00:41:40,950 --> 00:41:42,350
哪來的控制器。

755
00:41:42,350 --> 00:41:44,330
該控制器是這樣的。

756
00:41:44,330 --> 00:41:48,660
得到了所有的位置的
學生，把所有這一切變成了大

757
00:41:48,660 --> 00:41:52,060
變量，一個大名單，這
擁有所有的位置。

758
00:41:52,060 --> 00:41:55,340
>> 並在視圖中，因為JavaScript的
API是什麼東西在

759
00:41:55,340 --> 00:41:55,800
看到了吧？

760
00:41:55,800 --> 00:42:00,440
因為JavaScript的HTML中運行
代碼，它要被發送到

761
00:42:00,440 --> 00:42:01,710
用戶的機器。

762
00:42:01,710 --> 00:42:09,310
並在視圖中，我裝了這一切
信息到谷歌的API。

763
00:42:09,310 --> 00:42:12,080
它做了所有的對於
我，這是真的很酷。

764
00:42:12,080 --> 00:42:16,240
但是，如果你想使用的東西，在
後端，它就像一個圖書館，為

765
00:42:16,240 --> 00:42:18,720
例如，再次 - 

766
00:42:18,720 --> 00:42:20,140
與Facebook的整合。

767
00:42:20,140 --> 00:42:24,060
這件事情，很多很多，
許多應用程序使用的是現在。

768
00:42:24,060 --> 00:42:27,300
>> 因此，有你的Facebook整合
因為它是很容易做的只是

769
00:42:27,300 --> 00:42:30,450
與Facebook的登錄，而不是創建
一個帳戶，胡說，胡說，胡說。

770
00:42:30,450 --> 00:42:35,120
然後你只需用寶石和它一樣
簡單的將你的寶石文件。

771
00:42:35,120 --> 00:42:39,350
寶石文件是一個名為寶石中文件的文件
你的Ruby上的源目錄

772
00:42:39,350 --> 00:42:40,370
Rails項目。

773
00:42:40,370 --> 00:42:43,700
只是去那裡，並添加新的寶石。

774
00:42:43,700 --> 00:42:45,300
而且你看它在谷歌。

775
00:42:45,300 --> 00:42:46,520
還有很多，很多，很多的寶石。

776
00:42:46,520 --> 00:42:51,070
還有一個專門做
這對Facebook的整合。

777
00:42:51,070 --> 00:42:54,660
我不知道它是什麼名字。

778
00:42:54,660 --> 00:42:56,680
它只是谷歌和你
要找到它。

779
00:42:56,680 --> 00:42:57,930
好了，更多的問題？

780
00:42:57,930 --> 00:43:01,110

781
00:43:01,110 --> 00:43:03,280
真棒，謝謝你的光臨。

782
00:43:03,280 --> 00:43:09,227