1
00:00:00,000 --> 00:00:02,480
[Powered by Google Translate] [講座] [程序員的API]

2
00:00:02,480 --> 00:00:04,059
[比利Janitsch] [哈佛大學] [湯米MacWilliam]

3
00:00:04,059 --> 00:00:08,220
這是CS50。[CS50.TV]

4
00:00:08,220 --> 00:00:12,100
>> 嗨，大家好，我是比利，今天我要談論的API，

5
00:00:12,100 --> 00:00:15,220
或應用程序編程接口，

6
00:00:15,220 --> 00:00:20,040
特別是在的背景下，的CS50最終項目之類的事情。

7
00:00:20,040 --> 00:00:22,490
一般來說，什麼是API？

8
00:00:22,490 --> 00:00:25,530
概括而言，這是一種中間人，允許2個

9
00:00:25,530 --> 00:00:28,610
的軟件，以相互通信。

10
00:00:28,610 --> 00:00:32,530
這是一個非常寬泛的定義，而不是我們正在尋找相關的。

11
00:00:32,530 --> 00:00:35,450
我們真正需要的是某種有用的中間地帶

12
00:00:35,450 --> 00:00:40,570
溝通的某種類型的數據庫的地方。

13
00:00:40,570 --> 00:00:43,310
>> 這裡有一個圖表，基本的想法是，

14
00:00:43,310 --> 00:00:46,790
我們是一個應用程序，我們希望從數據庫中獲取數據，

15
00:00:46,790 --> 00:00:49,570
但我們不想直接查詢數據庫。

16
00:00:49,570 --> 00:00:52,710
相反，我們希望通過這種中間人，API去。

17
00:00:52,710 --> 00:00:55,440
背後的想法，在圖表上的數字2和3

18
00:00:55,440 --> 00:00:57,750
都將是非常複雜而混亂的。

19
00:00:57,750 --> 00:00:59,960
換句話說，當API查詢數據庫，

20
00:00:59,960 --> 00:01:03,300
它可能會使用SQL表和所有的那種東西，

21
00:01:03,300 --> 00:01:05,489
我們已經了解了一些關於它的CS50，但總體而言，

22
00:01:05,489 --> 00:01:07,590
你已經注意到了，這是一個有點痛苦。

23
00:01:07,590 --> 00:01:10,590
它變得非常，非常複雜而混亂，尤其是當你正在做

24
00:01:10,590 --> 00:01:12,530
複雜的查詢，諸如此類的事情。

25
00:01:12,530 --> 00:01:15,960
>> 我們真正需要的是某種有用而簡單的方式

26
00:01:15,960 --> 00:01:19,780
得到的數據，而這背後的想法在圖表上的數字1和4。

27
00:01:19,780 --> 00:01:23,600
換句話說，我們希望有一個非常簡單的方法來告訴API為我們

28
00:01:23,600 --> 00:01:27,760
一個非常簡單的方式來獲得的數據。

29
00:01:27,760 --> 00:01:33,020
有一個主要的方式，該數據通常是發送和接收的，

30
00:01:33,020 --> 00:01:36,490
這是JSON，或JavaScript Object Notation。

31
00:01:36,490 --> 00:01:40,370
這可以改變一點點，只要您發送請求的API。

32
00:01:40,370 --> 00:01:43,210
換句話說，如果你想要一些一定量的數據，

33
00:01:43,210 --> 00:01:46,670
你如何告訴API來獲取這些數據可以改變一點點。

34
00:01:46,670 --> 00:01:49,210
通常涉及某種形式的網絡請求。

35
00:01:49,210 --> 00:01:53,130
換句話說，訪問的URL某種要告訴API

36
00:01:53,130 --> 00:01:56,190
正是你想要的，但數據幾乎總是發回，

37
00:01:56,190 --> 00:01:59,530
換句話說，JSON中的4號。

38
00:01:59,530 --> 00:02:01,030
>> 什麼是JSON是什麼呢？

39
00:02:01,030 --> 00:02:03,030
正如我所說，JavaScript對象表示法。

40
00:02:03,030 --> 00:02:07,090
它基本上是發送和接收數據的通用標準。

41
00:02:07,090 --> 00:02:11,410
我們的想法是，你有這3類的東西。

42
00:02:11,410 --> 00:02:13,540
你有數組，HashMap的，和原語。

43
00:02:13,540 --> 00:02:16,580
數組和HashMap的看著你一點點CS50，

44
00:02:16,580 --> 00:02:19,870
但是，你得到了非常嚴格的意義上它們是什麼。

45
00:02:19,870 --> 00:02:22,780
換句話說，用數組，你知道他們的類型綁定，

46
00:02:22,780 --> 00:02:26,560
所以，你只能有一個排序的類型，在整個陣列。

47
00:02:26,560 --> 00:02:29,310
JSON是一個較為寬鬆的，諸如此類的事情。

48
00:02:29,310 --> 00:02:33,590
基本的想法是你建設這個對象，

49
00:02:33,590 --> 00:02:36,270
它可以由任何這些3東西

50
00:02:36,270 --> 00:02:39,470
並且可以由其中的多個，並且它們可以嵌套。

51
00:02:39,470 --> 00:02:42,110
>> 這裡的排序JSON的例子，

52
00:02:42,110 --> 00:02:47,910
這是這些大括號在這裡代表你的hashmap，

53
00:02:47,910 --> 00:02:51,400
和hashmap是基本的映射某種關鍵的

54
00:02:51,400 --> 00:02:53,340
某種價值。

55
00:02:53,340 --> 00:02:56,440
在這裡，你會看到我們有關鍵，

56
00:02:56,440 --> 00:02:59,600
的映射到一個數組中，這是這件事了。

57
00:02:59,600 --> 00:03:04,120
我們看到了另一種元素的HashMap，這是關鍵isAwesome的，

58
00:03:04,120 --> 00:03:07,370
映射到真正的原始值，換句話說，一個布爾值。

59
00:03:07,370 --> 00:03:09,420
基元可以是字符串。他們可以是整數。

60
00:03:09,420 --> 00:03:11,960
它們可以是bool值，類似的事情。

61
00:03:11,960 --> 00:03:18,410
而你看到這個數組的內容的屬性點有2個字符串，

62
00:03:18,410 --> 00:03:20,050
自相似性和精彩。

63
00:03:20,050 --> 00:03:27,410
這2個屬性的JSON，我們可以看到，JSON是真棒。

64
00:03:27,410 --> 00:03:30,060
要看看在這一點更加緊密，我要構建

65
00:03:30,060 --> 00:03:32,870
一個更複雜的例子JSON在這裡。

66
00:03:32,870 --> 00:03:37,000
>> 讓我們從一個數組，例如，只是一個空數組。

67
00:03:37,000 --> 00:03:39,180
但是，這是無聊的，所以我們要補上的一點，

68
00:03:39,180 --> 00:03:43,420
正如我剛才所說，在JSON數組類型綁定，

69
00:03:43,420 --> 00:03:46,400
因此，我們也可以有一個字符串，在這裡，是喜，

70
00:03:46,400 --> 00:03:49,330
這是該數組的另一個因素。

71
00:03:49,330 --> 00:03:53,450
同樣地，我們可以添加一個hashmapping在這裡，有幾個映射。

72
00:03:53,450 --> 00:04:00,470
這將有一個映射名的字符串比利。

73
00:04:00,470 --> 00:04:04,590
我們有一個從名稱到比利的映射，我們的映射

74
00:04:04,590 --> 00:04:10,860
最喜歡的顏色為藍色。

75
00:04:10,860 --> 00:04:12,700
這基本上是JSON的一個很好的例子。

76
00:04:12,700 --> 00:04:18,160
種獲得進入哎呦，有所有的不同部分需要一個逗號。

77
00:04:18,160 --> 00:04:21,140
同樣，它不是在所有類型綁定，這樣你就可以有什麼樣的類型

78
00:04:21,140 --> 00:04:24,710
內任何你想要的，這種想法是它的自相似。

79
00:04:24,710 --> 00:04:28,830
換句話說，在這裡是一個JSON對象，這是整個事情，

80
00:04:28,830 --> 00:04:33,200
只是這一點，所以你可以有一個原始的對象，

81
00:04:33,200 --> 00:04:35,680
數組是一個對象或一個HashMap的對象。

82
00:04:35,680 --> 00:04:40,270
>> JSON，你可以種看，是真的，真的有用的，它是如此多才多藝。

83
00:04:40,270 --> 00:04:45,860
你可以有，你可以設想任何可能的數據存儲在JSON。

84
00:04:45,860 --> 00:04:47,900
這使得它一個非常好的語言使用的API

85
00:04:47,900 --> 00:04:50,770
因為它幾乎意味著，無論什麼樣的數據要

86
00:04:50,770 --> 00:04:54,270
要以某種方式把它找回來的JSON。

87
00:04:54,270 --> 00:04:58,600
有幾個特性使JSON特別適合這樣的事情。

88
00:04:58,600 --> 00:05:02,270
正如你可以看到的，到了很多東西，你一直在CS50

89
00:05:02,270 --> 00:05:06,040
這是相對非常容易閱讀，也很容易寫。

90
00:05:06,040 --> 00:05:09,700
您可以縮進，如果你想，像我在做這個例子中，

91
00:05:09,700 --> 00:05:12,990
它為您提供了一個不錯的，漂亮的，你可以看到真正的版本。

92
00:05:12,990 --> 00:05:17,150
此外，它也易於閱讀和編寫的計算機。

93
00:05:17,150 --> 00:05:19,870
換句話說，它容易解析和編碼，

94
00:05:19,870 --> 00:05:23,820
這意味著它是相當快的讀取數據，

95
00:05:23,820 --> 00:05:26,460
和JSON可以產生非常迅速。

96
00:05:26,460 --> 00:05:30,300
>> 這也很容易訪問不同地區的JSON之類的事情。

97
00:05:30,300 --> 00:05:33,320
這是很好的，而且，事實上，它是自相似的，

98
00:05:33,320 --> 00:05:36,090
換句話說，其實，你可以有內JSON JSON JSON內

99
00:05:36,090 --> 00:05:40,040
用於存儲數據是非常好的。

100
00:05:40,040 --> 00:05:45,490
另一部分是真正有用的API是jQuery。

101
00:05:45,490 --> 00:05:49,290
你已經學會了一點點的JavaScript代碼，這是一個很好的方式，

102
00:05:49,290 --> 00:05:53,710
操縱HTML和CSS的網站。

103
00:05:53,710 --> 00:05:57,190
但它可以是一個痛苦，在普通的JavaScript代碼的一種，

104
00:05:57,190 --> 00:05:59,810
這主要是因為JavaScript是一個非常冗長的語言。

105
00:05:59,810 --> 00:06:03,020
你必須去學習了很多語法，只是為了做很簡單的事情

106
00:06:03,020 --> 00:06:07,590
它需要大量的代碼，所以jQuery是一個JavaScript的庫。

107
00:06:07,590 --> 00:06:09,800
換句話說，它是一個JavaScript文件，你可以加載

108
00:06:09,800 --> 00:06:12,730
然後使用jQuery的功能做一些事情。

109
00:06:12,730 --> 00:06:15,670
和jQuery基本上是讓您的生活變得更加簡單了。

110
00:06:15,670 --> 00:06:20,390
它簡化了在JavaScript中需要數百行中的幾行jQuery的。

111
00:06:20,390 --> 00:06:24,430
>> 這是特別有用的，如果你正在使用API​​，因為一般

112
00:06:24,430 --> 00:06:27,600
您將如何被訪問的API是由AJAX請求，

113
00:06:27,600 --> 00:06:30,130
我相信大衛講座中提到的，AJAX請求

114
00:06:30,130 --> 00:06:33,120
一般都是當你正在做一個網絡請求某種服務器

115
00:06:33,120 --> 00:06:37,760
並獲得某種形式的數據，並即時更新的頁面。

116
00:06:37,760 --> 00:06:41,840
而在普通的JavaScript，將採取瘋狂的行數

117
00:06:41,840 --> 00:06:44,620
驗證所有的頭和做所有的東西之類的，

118
00:06:44,620 --> 00:06:46,810
jQuery有一個非常簡單的函數調用AJAX，

119
00:06:46,810 --> 00:06:51,760
和所有你必須做的AJAX是給你想給的API的參數，

120
00:06:51,760 --> 00:06:56,830
API的位置要配置的選項，讓您任何額外的排序。

121
00:06:56,830 --> 00:07:02,480
這是真的，真的很好，這種事情非常有用的。

122
00:07:02,480 --> 00:07:06,970
這是我們需要開始的所有的API，讓我們的手臟。

123
00:07:06,970 --> 00:07:10,220
>> 我要帶了幾個例子，並探討其不同的特性

124
00:07:10,220 --> 00:07:13,150
為什麼他們不同的東西是有用的。

125
00:07:13,150 --> 00:07:15,570
實際上，我會告訴你的第一件事是什麼，我的工作

126
00:07:15,570 --> 00:07:18,310
在我的研究實驗室，這是一個NGRAM瀏覽器，

127
00:07:18,310 --> 00:07:23,270
基本的想法的一個NGRAM的瀏覽器，您可以搜索一些這類詞

128
00:07:23,270 --> 00:07:28,840
或短語，經常出現在一組特定的文字隨著時間的推移。

129
00:07:28,840 --> 00:07:33,160
這裡的例子是這樣的數據集的嬰兒

130
00:07:33,160 --> 00:07:36,480
出生在紐約，1920年和2000年之間。

131
00:07:36,480 --> 00:07:40,090
例如，我們可以搜索的名字Jennifer，

132
00:07:40,090 --> 00:07:44,400
我們看到，20世紀60年代，它真的是不使用所有的東西，

133
00:07:44,400 --> 00:07:48,900
然後，隨著我們進入晚年，這已經成為越來越多的使用。

134
00:07:48,900 --> 00:07:53,680
我們還可以做比較，所以，如果我們比較珍妮弗，例如，托馬斯，

135
00:07:53,680 --> 00:07:56,520
我們可以看到整個歷史上，托馬斯已經相當普遍，

136
00:07:56,520 --> 00:07:58,780
而珍妮弗是一個較新的名字。

137
00:07:58,780 --> 00:08:00,590
我們可以做這樣的事情。

138
00:08:00,590 --> 00:08:02,460
>> 這個應用程序是如何工作的？

139
00:08:02,460 --> 00:08:06,030
基本上，它可以通過一個API。

140
00:08:06,030 --> 00:08:08,660
換句話說，我們在這裡有某些參數。

141
00:08:08,660 --> 00:08:11,360
我們的參數，我們實際上是在尋找，

142
00:08:11,360 --> 00:08:13,720
這些名字，然後我們有一些其它的屬性，

143
00:08:13,720 --> 00:08:16,570
類似的Y軸和X軸。

144
00:08:16,570 --> 00:08:18,440
你可以看到我們有一些不同的選擇，盡可能的

145
00:08:18,440 --> 00:08:20,860
使用的時間分辨率和諸如此類的事情。

146
00:08:20,860 --> 00:08:26,700
我們有這些選項，只要我們真正想要什麼樣的數據從數據庫中，

147
00:08:26,700 --> 00:08:29,400
我們想要得到的數據，在一些有用的方法。

148
00:08:29,400 --> 00:08:34,020
通常情況下，如果我們查詢數據庫直接將排序是一個痛苦的做

149
00:08:34,020 --> 00:08:38,970
因為這大概給孩子起什麼名字，住在一些數據庫數據的地方，

150
00:08:38,970 --> 00:08:42,789
這將是非常複雜的手動查詢

151
00:08:42,789 --> 00:08:45,830
決定什麼樣的數據返回。

152
00:08:45,830 --> 00:08:49,300
換句話說，我們只關心珍妮弗和托馬斯在這種情況下，

153
00:08:49,300 --> 00:08:53,410
我們只關心某個軸和所有的那種東西。

154
00:08:53,410 --> 00:08:55,720
>> 我們如何解決這個問題呢？

155
00:08:55,720 --> 00:09:01,200
要深入到這個API多一點我會告訴你這個平台的另一個例子

156
00:09:01,200 --> 00:09:04,490
它使用一個稍微不同的數據集。

157
00:09:04,490 --> 00:09:09,950
該數據集，而不是嬰兒的名字，其實只是整個

158
00:09:09,950 --> 00:09:12,460
印刷出版物的圖書數據庫，

159
00:09:12,460 --> 00:09:18,410
這是一個巨大的整個過去的100年左右出版的文本來源。

160
00:09:18,410 --> 00:09:23,540
我們的想法是我們有這compository的數以百萬計的文字，

161
00:09:23,540 --> 00:09:27,420
我們現在可以搜索不同的詞和短語英寸

162
00:09:27,420 --> 00:09:30,840
下面是一個例子，變化有點不同，從前面的例子

163
00:09:30,840 --> 00:09:33,350
我給你，這是我們這3個搜索查詢，

164
00:09:33,350 --> 00:09:36,290
戰爭，戰爭，戰爭的法語單詞，這是GUERRE。

165
00:09:36,290 --> 00:09:40,380
我們正在尋找的總數據庫內3個不同的部分。

166
00:09:40,380 --> 00:09:45,080
換句話說，在這第一個查詢中，我們只在美國，

167
00:09:45,080 --> 00:09:51,150
僅在英國，在第二個，第三個在法國出版的作品。

168
00:09:51,150 --> 00:09:53,120
我們看到一些有趣的模式出現。

169
00:09:53,120 --> 00:09:58,180
例如，我們看到的在這裡 - 

170
00:09:58,180 --> 00:10:02,410
哎呀，我搞砸了軸一點點，但你可以看到在此範圍內

171
00:10:02,410 --> 00:10:05,730
在美國版的內戰周圍有一個大的峰值

172
00:10:05,730 --> 00:10:08,340
但沒有這麼大的在其他兩個高峰，而這顯然是因為

173
00:10:08,340 --> 00:10:10,880
在這一點上美國南北戰爭發生了。

174
00:10:10,880 --> 00:10:13,890
>> 我們可以看到，有一些很酷的東西，

175
00:10:13,890 --> 00:10:17,070
但我們真正關心的是我們如何得到這個數據。

176
00:10:17,070 --> 00:10:21,320
我會帶你在這個程序中一點點幕後。

177
00:10:21,320 --> 00:10:24,540
一個絕招，如果你正在使用的站點和種想知道

178
00:10:24,540 --> 00:10:27,430
這是怎麼回事幕後，你可以打開開發工具。

179
00:10:27,430 --> 00:10:30,200
我將使用Chrome的開發者工具，並得到那些

180
00:10:30,200 --> 00:10:35,160
你可以做控制，移位，J，，您可以到JavaScript控制台。

181
00:10:35,160 --> 00:10:37,420
有幾個標籤。

182
00:10:37,420 --> 00:10:39,680
他們都可以在不同的情況下是非常有用的，但我關心的網絡

183
00:10:39,680 --> 00:10:44,150
選項卡，現在，我其實有刷新，工作。

184
00:10:44,150 --> 00:10:50,180
哦，對不起。

185
00:10:50,180 --> 00:10:52,320
它喜歡給一個隨機的例子。

186
00:10:52,320 --> 00:10:54,700
好了，然後我們將使用這個例子，而不是。

187
00:10:54,700 --> 00:11:01,330
>> 我們的想法是在這裡有這個API，

188
00:11:01,330 --> 00:11:05,330
你可以看到什麼API返回。

189
00:11:05,330 --> 00:11:10,220
這是什麼應用程序正在發送該請求的API。

190
00:11:10,220 --> 00:11:13,680
讓我在一點點放大，

191
00:11:13,680 --> 00:11:18,340
基本上，我們可以看到，它只是一個系列的關鍵值對的JSON。

192
00:11:18,340 --> 00:11:23,220
換句話說，我們有這個HashMap中的映射值。

193
00:11:23,220 --> 00:11:26,440
換句話說，它的值映射年。

194
00:11:26,440 --> 00:11:32,600
1765年什麼字，我們初步搜索使用90次

195
00:11:32,600 --> 00:11:35,810
出了1萬元，所以我們又回到了這個結果。

196
00:11:35,810 --> 00:11:40,280
這不完全JSON，因為我們有這個收效甚微頭，

197
00:11:40,280 --> 00:11:45,630
但是請注意，這裡整個的對象僅僅是一個偉大的大JSON一滴。

198
00:11:45,630 --> 00:11:51,070
我們這裡有一個數組，其中包含整個元素，

199
00:11:51,070 --> 00:11:55,590
你可以看到，整個元素在這裡結束，然後我們有再大的元素

200
00:11:55,590 --> 00:11:59,430
“一路下跌到了最後，而且在這裡結束。

201
00:11:59,430 --> 00:12:02,200
我們有一個非常大的數組2中的對象，

202
00:12:02,200 --> 00:12:04,630
每個對象是一個HashMap。

203
00:12:04,630 --> 00:12:07,340
你可以看到在這些HashMap的，我們有一個映射

204
00:12:07,340 --> 00:12:12,700
該指數值設置為0，該值的價值的另一個HashMap，

205
00:12:12,700 --> 00:12:18,360
這又是X軸的值映射到Y軸的值。

206
00:12:18,360 --> 00:12:20,970
>> 你可以看到JSON變得有點複雜，但總體而言，

207
00:12:20,970 --> 00:12:24,190
它實際上是非常有用的，它是很容易的訪問相比，

208
00:12:24,190 --> 00:12:27,390
其他不同形式的符號。

209
00:12:27,390 --> 00:12:30,550
據我們實際發送數據的API得到，

210
00:12:30,550 --> 00:12:34,690
我要到後端去一點點在這裡。

211
00:12:34,690 --> 00:12:39,850
這是大的JavaScript文件，該文件處理所有的Web應用程序之間的相互作用，

212
00:12:39,850 --> 00:12:44,810
，所以我們不關心這個最，但我們是關心一些。

213
00:12:44,810 --> 00:12:47,410
例如，我們關心這BuildQuery對於功能，

214
00:12:47,410 --> 00:12:50,670
這個功能是基本的想法，它看起來在頁面上，

215
00:12:50,670 --> 00:12:53,750
找出用戶想要什麼查詢，換句話說，

216
00:12:53,750 --> 00:12:57,090
檢查那些箱子，他們已經輸入的搜索字詞，

217
00:12:57,090 --> 00:13:01,380
檢查不同的Y軸和X軸的值，他們選擇了和所有諸如此類的事情，

218
00:13:01,380 --> 00:13:06,650
它會吐出來此查詢的值，然後我就可以發送的API。

219
00:13:06,650 --> 00:13:09,180
>> 這看起來比較複雜，它是相當複雜的

220
00:13:09,180 --> 00:13:18,090
但我要做的事情，事實上，我已經這樣做，這是偉大的 - 

221
00:13:18,090 --> 00:13:21,640
是，我要在控制台打印出準確的查詢值

222
00:13:21,640 --> 00:13:28,110
它發送的API。

223
00:13:28,110 --> 00:13:30,870
這實際上就​​在這裡。對不起，我輸了很多東西。

224
00:13:30,870 --> 00:13:33,690
但是，這就是我們所關心的，這個對象就在這裡。

225
00:13:33,690 --> 00:13:35,300
這是查詢的對象。

226
00:13:35,300 --> 00:13:40,670
換句話說，這正是在Web應用程序發送到API，

227
00:13:40,670 --> 00:13:45,730
讓我們往裡一點點，我們看到我們這裡有幾個值。

228
00:13:45,730 --> 00:13:48,710
我們看到，我們有這個計數類型，這是每萬字的出現，

229
00:13:48,710 --> 00:13:51,460
而這正是我們選擇了在Y軸在這裡。

230
00:13:51,460 --> 00:13:53,740
這就是我們在未來從。

231
00:13:53,740 --> 00:13:58,010
我們有一個數據庫中的值，這意味著，有一些某些數據庫

232
00:13:58,010 --> 00:14:01,610
這個數據是生活在我們要訪問的數據，特別是

233
00:14:01,610 --> 00:14:04,950
相對於嬰兒名字的數據，例如。

234
00:14:04,950 --> 00:14:08,320
然後，我們這組值，

235
00:14:08,320 --> 00:14:12,090
這是說，我們要搜索的一年，而不是

236
00:14:12,090 --> 00:14:16,030
任何其他X軸的值。

237
00:14:16,030 --> 00:14:19,040
然後我們有一個方法，其中一些API將做多件事情。

238
00:14:19,040 --> 00:14:22,360
換句話說，這個API還可以返回其他類型的數據，

239
00:14:22,360 --> 00:14:27,740
但在這種情況下，我們要映射的X軸值，Y軸的值。

240
00:14:27,740 --> 00:14:30,730
這是什麼，告訴它在那裡做，

241
00:14:30,730 --> 00:14:35,020
我們有這樣的搜索限制的陣列，其中包含2個值。

242
00:14:35,020 --> 00:14:40,720
第一個是我們在這裡看到，這是所有的值

243
00:14:40,720 --> 00:14:43,020
包含內，第一個小盒子的頂部。

244
00:14:43,020 --> 00:14:47,570
>> 換句話說，我們要看的單詞戰鬥，我們要對其進行過濾

245
00:14:47,570 --> 00:14:51,920
在美國文學中的英文文本。

246
00:14:51,920 --> 00:14:54,590
我們有這樣的國家，這是美國。

247
00:14:54,590 --> 00:14:59,130
我們有一個語言，即英語，所以我們有所有這些不同的部分

248
00:14:59,130 --> 00:15:02,690
都告訴API正是我們想要的。

249
00:15:02,690 --> 00:15:04,940
我們不知道什麼樣的數據，我們回去又是，

250
00:15:04,940 --> 00:15:10,970
但我們知道數據是要採取一定的形式。

251
00:15:10,970 --> 00:15:13,650
這個例子是有點複雜的，

252
00:15:13,650 --> 00:15:16,180
你不一定要使用的API這個複雜的，

253
00:15:16,180 --> 00:15:20,600
但是，這是告訴你的範圍和能力的API可以做什麼。

254
00:15:20,600 --> 00:15:24,980
換句話說，使用一個相對簡單的查詢系統，我們基本上有一個輸入框

255
00:15:24,980 --> 00:15:29,490
在不同的地方有幾個其他選擇。

256
00:15:29,490 --> 00:15:32,010
>> 讓我放大了這裡。

257
00:15:32,010 --> 00:15:37,720
我們有一個輸入框，幾個不同的元數據選擇，

258
00:15:37,720 --> 00:15:40,610
我們有Y軸和X軸的選擇。

259
00:15:40,610 --> 00:15:42,830
我們實際上並不擁有的許多領域，

260
00:15:42,830 --> 00:15:46,210
我們可以很容易地看到，我們能夠查詢某種API

261
00:15:46,210 --> 00:15:48,510
並獲取數據，然後把它放到這個圖表，

262
00:15:48,510 --> 00:15:52,080
這是要顯示它的一個有用的方法。

263
00:15:52,080 --> 00:15:54,970
看一個例子，它可能是一個有點熟悉的你們

264
00:15:54,970 --> 00:15:56,510
我們要去到Facebook。

265
00:15:56,510 --> 00:15:59,440
Facebook的API被稱為Facebook的走勢圖，

266
00:15:59,440 --> 00:16:04,390
基本上，這意味著什麼是Facebook把自己定位為這個龐大的數據庫

267
00:16:04,390 --> 00:16:08,000
大量的不同部位，都有一定的相互之間的關係。

268
00:16:08,000 --> 00:16:11,070
換句話說，我在Facebook上的用戶，所以我有一個配置文件，

269
00:16:11,070 --> 00:16:14,310
我也有一定的朋友，和他們每個人都有一個配置文件，

270
00:16:14,310 --> 00:16:17,580
我的每一個朋友有一面牆，有不同的意見就可以了，

271
00:16:17,580 --> 00:16:20,800
這些意見有多麼喜歡和所有諸如此類的事情。

272
00:16:20,800 --> 00:16:23,100
>> 有很多的不同部位到Facebook。

273
00:16:23,100 --> 00:16:26,670
這是一個非常複雜的API，而且也噸，你可以用它做，

274
00:16:26,670 --> 00:16:28,450
但它實際上是非常簡單易用。

275
00:16:28,450 --> 00:16:33,680
我要開始由要graph.facebook.com / billyjanitsch的，

276
00:16:33,680 --> 00:16:38,430
這是我唯一的帳戶名稱，您的帳戶的名稱將會是

277
00:16:38,430 --> 00:16:43,710
某種字，如果你選擇了它，或者它可能只是一串數字。

278
00:16:43,710 --> 00:16:46,360
我們回來的是非常基本的信息。

279
00:16:46,360 --> 00:16:50,460
我們可以看到，我有一個名字，這是比利，姓氏，這是Janitsch。

280
00:16:50,460 --> 00:16:53,370
還有，我有一個獨特的Facebook ID。

281
00:16:53,370 --> 00:16:57,920
您可以看到，我是男的，我有我的語言設置

282
00:16:57,920 --> 00:17:01,290
英式英語。

283
00:17:01,290 --> 00:17:03,490
換句話說，我們在這裡看到非常基本的信息。

284
00:17:03,490 --> 00:17:08,670
這是不是太多了，而是它讓我們知道那裡的東西。

285
00:17:08,670 --> 00:17:10,849
>> 大衛·馬蘭我們可以做同樣的事情，例如。

286
00:17:10,849 --> 00:17:13,599
我覺得他的名字dmalan。

287
00:17:13,599 --> 00:17:16,369
我們看到大衛·馬蘭有一個唯一的ID。

288
00:17:16,369 --> 00:17:19,300
他有一個名稱，名字，中間名，姓。

289
00:17:19,300 --> 00:17:24,210
我們也看到，他的男性，他的語言設置為英語（美國）。

290
00:17:24,210 --> 00:17:26,869
換句話說，我們在這裡看到非常基本的信息。

291
00:17:26,869 --> 00:17:28,860
現在，會發生什麼，如果我們嘗試別的東西嗎？

292
00:17:28,860 --> 00:17:33,060
比方說，我很感興趣大衛·馬蘭就喜歡在Facebook上。

293
00:17:33,060 --> 00:17:36,860
我可以做的/喜歡。現在，我們遇到了一個問題。

294
00:17:36,860 --> 00:17:39,280
我們已經得到了某種錯誤，說一個訪問令牌

295
00:17:39,280 --> 00:17:41,660
需要要求本資源。

296
00:17:41,660 --> 00:17:44,730
但是，如果你仔細想想，其實是有道理的，因為這將是不可思議的

297
00:17:44,730 --> 00:17:47,830
如果您可以訪問Facebook的數據庫中的每一個部分，

298
00:17:47,830 --> 00:17:50,170
從某種簡單的API，對不對？

299
00:17:50,170 --> 00:17:56,040
換句話說，想必您的信息不能被訪問的人誰想要它。

300
00:17:56,040 --> 00:17:58,330
>> 這個錯誤是什麼意思。

301
00:17:58,330 --> 00:18:03,630
一些API需要一定的權限，才能訪問他們的數據。

302
00:18:03,630 --> 00:18:06,940
甚至更高級的API，如Facebook的一個，

303
00:18:06,940 --> 00:18:09,840
將需要一定的權限做一些事情。

304
00:18:09,840 --> 00:18:12,650
我可以看到這個大衛馬蘭的基本信息。

305
00:18:12,650 --> 00:18:15,950
我可以看到他的男性，他住在美國，

306
00:18:15,950 --> 00:18:19,270
但我不能真的看不到過去的。

307
00:18:19,270 --> 00:18:23,050
為了解決這個問題，現在，Facebook有這很好的工具

308
00:18:23,050 --> 00:18:27,690
這是圖形API的探險家，和的想法，是可以排序的

309
00:18:27,690 --> 00:18:31,880
根據您自己的帳戶彌補自己的權限

310
00:18:31,880 --> 00:18:35,680
然後查看的東西，具體可以查看您的帳戶。

311
00:18:35,680 --> 00:18:45,120
例如，如果我這樣做graph.facebook.com/billyjanitsch/likes-

312
00:18:45,120 --> 00:18:53,510
哎呦，我想我必須在這裡重新驗證我的令牌。

313
00:18:53,510 --> 00:18:55,950
好吧。

314
00:18:55,950 --> 00:19:01,740
如果我這樣做了，偉大的，現在我看到，我得到這個對象

315
00:19:01,740 --> 00:19:06,300
這說，我想，這是在遊戲和玩具類的池面。

316
00:19:06,300 --> 00:19:08,620
我想，這是在類動物的海象。

317
00:19:08,620 --> 00:19:10,180
這些都是我實際的Facebook喜歡。

318
00:19:10,180 --> 00:19:13,280
他們那種尷尬。

319
00:19:13,280 --> 00:19:16,090
>> 但是我們可以看到，所有返回的JSON數據。

320
00:19:16,090 --> 00:19:18,160
這是非常可讀的。

321
00:19:18,160 --> 00:19:20,970
換句話說，我們有這樣的數據映射到一個數組某種

322
00:19:20,970 --> 00:19:25,220
這個數組的每個元素是一個HashMap的映射

323
00:19:25,220 --> 00:19:28,530
了相同的名稱和一個像的類別。

324
00:19:28,530 --> 00:19:31,240
每一樣都有一個唯一的ID。

325
00:19:31,240 --> 00:19:34,510
有各種不同的東西，我們可以得到的數據，

326
00:19:34,510 --> 00:19:37,980
，如果你有興趣使用Facebook的API的CS50最後項目

327
00:19:37,980 --> 00:19:40,720
或類似的東西，它實際上相當可行的。

328
00:19:40,720 --> 00:19:44,260
基本上你如何繞過身份驗證的事情是Facebook

329
00:19:44,260 --> 00:19:48,030
使用的系統稱為OAuth，開放式認證，

330
00:19:48,030 --> 00:19:52,870
我不想進入，因為現在的OAuth的或不同類型的

331
00:19:52,870 --> 00:19:56,060
認證往往不同的API之間有很大的差異，

332
00:19:56,060 --> 00:19:58,320
所以我可以花很長的時間去每一個，

333
00:19:58,320 --> 00:20:01,170
但它們實際上是相當不言自明。

334
00:20:01,170 --> 00:20:04,050
>> 如果谷歌Facebook的API，這是非常具有可讀性。

335
00:20:04,050 --> 00:20:06,670
有一個整體的規範。

336
00:20:06,670 --> 00:20:10,210
例如，這是Facebook的API的文檔，

337
00:20:10,210 --> 00:20:14,170
你可以看到我的用戶頁面上，這樣我就可以了解所有不同的東西

338
00:20:14,170 --> 00:20:17,170
得到的數據

339
00:20:17,170 --> 00:20:21,550
和也，我需要不同的權限才能訪問它們。

340
00:20:21,550 --> 00:20:25,470
正如我們所看到的，我們並不需要權限來訪問的名稱或性別，

341
00:20:25,470 --> 00:20:29,380
但除此之外，我們確實需要對大多數事情的權限。

342
00:20:29,380 --> 00:20:33,040
此頁面，或者更確切地說，本網站也將告訴你到那裡怎麼走嗎？

343
00:20:33,040 --> 00:20:35,640
一個令牌可以驗證自己的身份。

344
00:20:35,640 --> 00:20:39,290
大多數認證系統使用某種類型的令牌

345
00:20:39,290 --> 00:20:42,880
你在哪裡得到這個獨特的價值，這是一個很長的隨機字符串，

346
00:20:42,880 --> 00:20:46,240
這種方式，他們可以將你與你的要求。

347
00:20:46,240 --> 00:20:50,560
換句話說，他們知道，你什麼都沒有做他們的數據持懷疑態度。

348
00:20:50,560 --> 00:20:53,340
他們知道你要什麼。

349
00:20:53,340 --> 00:20:56,180
他們也知道，你有權限查看該信息。

350
00:20:56,180 --> 00:20:59,110
>> 如果你已經有了一個Facebook應用程序和您的應用程序有一定的用戶，

351
00:20:59,110 --> 00:21:03,380
那些用戶允許應用程序訪問他們的個人資料的某些部分，

352
00:21:03,380 --> 00:21:07,790
那麼無論API密鑰或應用程序正在使用的令牌，

353
00:21:07,790 --> 00:21:11,090
將能夠為這些用戶訪問的數據。

354
00:21:11,090 --> 00:21:13,780
這可能聽起來很複雜，但它也不是太糟糕，

355
00:21:13,780 --> 00:21:16,810
如果你想使用Facebook，我會強烈建議你

356
00:21:16,810 --> 00:21:18,990
考慮在玩弄他們的API。

357
00:21:18,990 --> 00:21:21,610
這是非常冷靜，用它你可以做很多不同的事情。

358
00:21:21,610 --> 00:21:24,880
如果用戶授予這些權限，你甚至可以回去的API

359
00:21:24,880 --> 00:21:28,820
並說，我要發布到用戶的牆，我想他們發布的照片​​，

360
00:21:28,820 --> 00:21:32,390
這就是為什麼你的新聞源，你有時會得到那些煩人的事

361
00:21:32,390 --> 00:21:37,840
說你的朋友觀看此視頻在某種奇怪的網站或類似的東西。

362
00:21:37,840 --> 00:21:43,120
這是因為該應用程序已被授予訪問那個人的牆壁上發布。

363
00:21:43,120 --> 00:21:48,350
整體的想法，Facebook的API是非常複雜的，但也是非常有用的。

364
00:21:48,350 --> 00:21:53,220
絕對值得一試，如果你還在尋找一個最終的項目。

365
00:21:53,220 --> 00:21:57,930
>> 另一套API，我會去為CS50的API。

366
00:21:57,930 --> 00:22:00,070
讓我在這裡放大。

367
00:22:00,070 --> 00:22:03,390
CS50實際上已經把整個系列的API

368
00:22:03,390 --> 00:22:07,080
您可以使用一個最後的項目，或者只是為你正在做什麼。

369
00:22:07,080 --> 00:22:12,830
，他們大多是哈佛相關，和他們不同從HUDS菜單，

370
00:22:12,830 --> 00:22:17,780
例如，這個哈佛大學的事件API，這將讓你訪問列表

371
00:22:17,780 --> 00:22:21,290
不同的事件，在哈佛之類的事情。

372
00:22:21,290 --> 00:22:24,510
因此，我們可以點擊其中的任何一個，並得到一個規範的，

373
00:22:24,510 --> 00:22:28,090
你是能夠找到的任何API的想法是

374
00:22:28,090 --> 00:22:33,920
它可以讓你知道，A，具體的API請求，要求它。

375
00:22:33,920 --> 00:22:37,370
換句話說，如果我想明天發生的所有事件

376
00:22:37,370 --> 00:22:42,550
那麼我就明顯給它的日期，我想在一個特定的格式，

377
00:22:42,550 --> 00:22:46,030
B，它會告訴我到底是什麼回事退給我。

378
00:22:46,030 --> 00:22:48,590
它會說，我要回到你這個JSON對象，

379
00:22:48,590 --> 00:22:50,960
或者像你所看到的，有不同的格式。

380
00:22:50,960 --> 00:22:54,050
>> 您也可以返回一個CSV數據，例如。

381
00:22:54,050 --> 00:22:57,620
但是，你知道這些數據究竟是如何去看看，當你把它找回來

382
00:22:57,620 --> 00:23:00,610
所以你可以期望用它做一些事情。

383
00:23:00,610 --> 00:23:07,240
我們可以向下滾動看到的，例如，如果我們要查詢的API

384
00:23:07,240 --> 00:23:11,500
日曆，那麼我們就可以用這種特殊的URL

385
00:23:11,500 --> 00:23:16,480
並給它一定的參數，都將是我們想要的確切的數據。

386
00:23:16,480 --> 00:23:19,540
同樣地，如果我們想在一定格式的數據，

387
00:23:19,540 --> 00:23:23,790
那麼我們就可以問它輸出一個CSV中的數據，

388
00:23:23,790 --> 00:23:27,700
這只是另一個參數，我們傳遞的API。

389
00:23:27,700 --> 00:23:29,210
很多很酷的東西在那裡做。

390
00:23:29,210 --> 00:23:32,550
我肯定會建議你檢查出的CS50的API。

391
00:23:32,550 --> 00:23:36,000
>> 我要看看在這個哈佛食品API，特別是一點點。

392
00:23:36,000 --> 00:23:39,870
其實我設計的一件事是這個哈佛大學NOMS網站，

393
00:23:39,870 --> 00:23:44,930
使用CS50的食物的API來檢索的HUDS的菜單的天。

394
00:23:44,930 --> 00:23:50,400
擴展學校的人，HUDS是哈佛大學的餐飲服務。

395
00:23:50,400 --> 00:23:55,130
你得到的是這個頁面，它包含了所有的日子，讓我們看到了午餐的飯菜。

396
00:23:55,130 --> 00:23:58,130
我們有幾個不同的類別。我們bean和全穀物站。

397
00:23:58,130 --> 00:24:00,340
我們有的糙米站。

398
00:24:00,340 --> 00:24:03,360
我們可以看到，早午餐，我們這幾年的食品項目。

399
00:24:03,360 --> 00:24:07,030
如果我們點擊他們，那麼我們得到的營養信息。

400
00:24:07,030 --> 00:24:12,240
你看這是為柚子的營養信息，如果你想知道。

401
00:24:12,240 --> 00:24:14,870
因此，我們要在這裡一點點地窺探到後端

402
00:24:14,870 --> 00:24:18,530
看看究竟是如何得到這個數據。

403
00:24:18,530 --> 00:24:21,710
它實際上是非常複雜的。

404
00:24:21,710 --> 00:24:28,720
這個文件看起來有點亂，但請記住，這是處理整個網站，

405
00:24:28,720 --> 00:24:34,130
如果我向下滾動，我們看到這種變化數據的功能。

406
00:24:34,130 --> 00:24:36,630
>> 現在，僅僅是明確的，這是寫在CoffeeScript的，

407
00:24:36,630 --> 00:24:39,570
這是一門語言，你可能還沒有見過。

408
00:24:39,570 --> 00:24:44,810
但它是相當可讀的，所以我會穿過它，就好像是偽代碼。

409
00:24:44,810 --> 00:24:49,080
更改日期是一個函數，要在此日期值，

410
00:24:49,080 --> 00:24:51,740
它也將採取在第一，這是我們不關心盡可能多的。

411
00:24:51,740 --> 00:24:54,110
但最重要的是，它有這個日期，

412
00:24:54,110 --> 00:25:00,080
而這個日期是希望的日子裡，我們要求所有的食品項目。

413
00:25:00,080 --> 00:25:04,030
然後你看我們有一點點的語法，

414
00:25:04,030 --> 00:25:09,000
這基本上是解析該日為可讀的格式。

415
00:25:09,000 --> 00:25:11,920
換言之，該API需要一定的格式中的日期。

416
00:25:11,920 --> 00:25:17,390
你不能只是說，公元2012年11月16日。

417
00:25:17,390 --> 00:25:20,320
不知道做什麼用。它希望在一個特定的格式的日期。

418
00:25:20,320 --> 00:25:23,230
我們在這裡做的是給它正是格式，

419
00:25:23,230 --> 00:25:26,520
這是一年的值，然後連字號，月值，

420
00:25:26,520 --> 00:25:29,420
一個連字符和日期值。

421
00:25:29,420 --> 00:25:34,910
同時，我們也說，我們希望將數據輸出JSON。

422
00:25:34,910 --> 00:25:37,560
>> 現在，我們正在做這AJAX請求，正如我前面提到的，

423
00:25:37,560 --> 00:25:41,680
jQuery有這樣的超級有用的AJAX功能，所有你需要做的就是指定

424
00:25:41,680 --> 00:25:45,780
到這裡的一些參數，它會回給你，正是你想要的。

425
00:25:45,780 --> 00:25:50,490
我們告訴它，我們希望它去的，這是CS50食品API的URL，

426
00:25:50,490 --> 00:25:52,270
我們得到了從規範。

427
00:25:52,270 --> 00:25:56,730
我們說，我們想要的數據的JSON和

428
00:25:56,730 --> 00:25:59,490
我們要去給它這個數據，我們已經定義了這裡。

429
00:25:59,490 --> 00:26:02,670
在這個日子裡，我們需要的食品項目。

430
00:26:02,670 --> 00:26:07,790
然後我們要做的是定義了一些成功的功能，

431
00:26:07,790 --> 00:26:11,980
這基本上是API返回的數據時，會發生什麼情況。

432
00:26:11,980 --> 00:26:15,490
換句話說，我們已經打包了所有的參數，我們希望，

433
00:26:15,490 --> 00:26:20,530
在這種情況下，我們希望它是天的事實，我們希望它在JSON，

434
00:26:20,530 --> 00:26:23,840
我們把它關閉的API，所以現在的空氣污染指數是說，好吧，

435
00:26:23,840 --> 00:26:26,350
這裡是您的數據，我回去給你。

436
00:26:26,350 --> 00:26:29,930
我們有成功的函數，這意味著給定的API

437
00:26:29,930 --> 00:26:32,230
成功返回一些數據，我們該怎麼辦呢？

438
00:26:32,230 --> 00:26:35,980
>> 事實證明，我們要做的就是調用這個更新菜單功能

439
00:26:35,980 --> 00:26:42,680
任何的API返回，這樣我們就可以搜索

440
00:26:42,680 --> 00:26:47,970
看到我們所做的就是在這裡使用了一堆新的語法

441
00:26:47,970 --> 00:26:52,220
更新的HTML和插入這個新的數據。

442
00:26:52,220 --> 00:26:56,580
這讓我們這些箭頭的兩邊，我們可以單擊，

443
00:26:56,580 --> 00:27:01,060
現在我們正在尋找的數據，第二天再次第二天，

444
00:27:01,060 --> 00:27:04,820
每次更新該日期值和查詢API，

445
00:27:04,820 --> 00:27:07,510
獲得一些數據，並把它進入該網站。

446
00:27:07,510 --> 00:27:10,590
同樣，你可以看到，超級，超級有用。

447
00:27:10,590 --> 00:27:14,410
這個程序我花了幾個小時，一起砍，

448
00:27:14,410 --> 00:27:20,140
我有了更多的經驗，很明顯，但你的CS50最終項目

449
00:27:20,140 --> 00:27:22,870
可以看看非常喜歡這東西。

450
00:27:22,870 --> 00:27:29,540
>> API是超級強大的，他們採取的工作量。

451
00:27:29,540 --> 00:27:32,800
最後一件事，我會去一些更多的API廣泛。

452
00:27:32,800 --> 00:27:35,480
我不會得到盡可能遠，因為他們做了什麼特別的，

453
00:27:35,480 --> 00:27:38,740
但我會給你那裡有什麼想法。

454
00:27:38,740 --> 00:27:42,700
2真正有用的，如果你有興趣在數據分析和可視化

455
00:27:42,700 --> 00:27:45,960
或類似的東西，是游離鹽基和維基百科。

456
00:27:45,960 --> 00:27:49,800
維基百科想必大家都知道是一個免費的在線百科全書，

457
00:27:49,800 --> 00:27:53,230
它實際上有一個API，所以如果你想，例如，

458
00:27:53,230 --> 00:27:56,250
讓所有的文本和八達通的文章

459
00:27:56,250 --> 00:27:58,030
你可以很容易地做到這一點。

460
00:27:58,030 --> 00:28:02,300
維基百科的API，只是說，嘿，我想，這返回的數據，

461
00:28:02,300 --> 00:28:07,010
，我想這種格式，在文章中，我想是章魚，

462
00:28:07,010 --> 00:28:09,820
，並很快給你回的信息。

463
00:28:09,820 --> 00:28:12,230
這可以是非常有用的，如果你想某種網站

464
00:28:12,230 --> 00:28:16,200
維基百科或類似的東西，這是一個更好的瀏覽器。

465
00:28:16,200 --> 00:28:21,350
>> Freebase是幾分相似，但它是一個有點困難盡可能API。

466
00:28:21,350 --> 00:28:24,390
Freebase是像維基百科，它是一個在線的百科全書

467
00:28:24,390 --> 00:28:29,050
其中包含了很多很多各種不同的主題不同的數據，

468
00:28:29,050 --> 00:28:33,150
但它存儲在一個關係數據庫，它是從維基百科略有不同。

469
00:28:33,150 --> 00:28:36,410
維基百科的文章和文章鏈接到其他物品，

470
00:28:36,410 --> 00:28:38,860
但在大多數情況下，如果你想章魚的數據，

471
00:28:38,860 --> 00:28:41,990
你去的章魚文章，獲得這些數據，你有一堆文字

472
00:28:41,990 --> 00:28:43,830
關於章魚，所以這是偉大的。

473
00:28:43,830 --> 00:28:46,870
游離鹼的工作在一個稍微複雜的方式

474
00:28:46,870 --> 00:28:48,930
一切都是彼此相關的。

475
00:28:48,930 --> 00:28:52,620
換句話說，如果我們需要尋找的章魚

476
00:28:52,620 --> 00:28:54,940
它還包含了許多與它關聯的類別。

477
00:28:54,940 --> 00:28:57,920
>> 例如，它是一種動物，它生活在水下，

478
00:28:57,920 --> 00:28:59,710
它具有一定的體溫。

479
00:28:59,710 --> 00:29:01,210
我不知道。

480
00:29:01,210 --> 00:29:04,230
所有這些類別的鏈接到其他地方，你可以去

481
00:29:04,230 --> 00:29:06,640
與同一類的東西。

482
00:29:06,640 --> 00:29:13,450
換句話說，章魚數據集將包含一個鏈接的數據集所有的動物，

483
00:29:13,450 --> 00:29:16,790
這將讓我走動，在數據庫中真的很快。

484
00:29:16,790 --> 00:29:21,740
喜歡攀比，如果你正在做的事情，這是非常有用的。

485
00:29:21,740 --> 00:29:24,490
換句話說，給定某一件事，你想看到的

486
00:29:24,490 --> 00:29:27,890
它還有什麼相關的和看到什麼是不相關的。

487
00:29:27,890 --> 00:29:30,700
諸如此類的事情。它可以是有用的，在多種方式。

488
00:29:30,700 --> 00:29:34,250
如果你正在尋找一個更大的挑戰，能夠做一些更複雜的事情

489
00:29:34,250 --> 00:29:38,740
我會考慮看看的游離鹽基API的。

490
00:29:38,740 --> 00:29:44,670
但在很大程度上，維基百科是一個非常簡單的地方去盡可能獲取信息。

491
00:29:44,670 --> 00:29:48,340
另一個地方，我會看的是Last.fm，實際上，我要到現場去

492
00:29:48,340 --> 00:29:53,800
的情況下，有些人不熟悉，但Last.fm基本上是一個音樂

493
00:29:53,800 --> 00:29:57,220
口味和建議的網站。

494
00:29:57,220 --> 00:29:59,000
你可以讓一個帳戶。

495
00:29:59,000 --> 00:30:04,250
您可以從你的音樂播放器上傳音樂

496
00:30:04,250 --> 00:30:08,020
的網站，基本上它會開始給你音樂的建議

497
00:30:08,020 --> 00:30:10,030
根據你聽。

498
00:30:10,030 --> 00:30:14,270
>> 例如，如果你去到您的個人資料頁，這是我的

499
00:30:14,270 --> 00:30:18,180
你可以看到你有一個列表，最近聽的曲目。

500
00:30:18,180 --> 00:30:22,550
你可以看到整體的喜愛的藝術家，所有的諸如此類的事情，

501
00:30:22,550 --> 00:30:25,280
再次，有一個大的API背後Last.fm，

502
00:30:25,280 --> 00:30:29,360
 你可以用它做很多很多非常酷的事情。

503
00:30:29,360 --> 00:30:38,870
例如，我會去一個朋友的頁面，這個的Last.fm工具網站有。

504
00:30:38,870 --> 00:30:42,380
這實際上是一個平台，是建立在Last.fm API，

505
00:30:42,380 --> 00:30:45,420
做了一些非常有趣的事情。

506
00:30:45,420 --> 00:30:50,260
如果我在我的用戶名登錄，例如，

507
00:30:50,260 --> 00:30:53,110
我可以問它來生成一個標籤雲，例如，

508
00:30:53,110 --> 00:30:56,480
什麼，會做的，是給我回的圖像

509
00:30:56,480 --> 00:30:59,850
所有不同的風格之類的東西，我喜歡聽。

510
00:30:59,850 --> 00:31:01,410
它是如何做的呢？

511
00:31:01,410 --> 00:31:05,670
基本上說Last.fm API，該用戶。

512
00:31:05,670 --> 00:31:10,710
我想知道，他們已經聽到過的每首歌曲的風格，

513
00:31:10,710 --> 00:31:15,130
你可以做到這一點通過一個非常簡單的AJAX調用Last.fm API。

514
00:31:15,130 --> 00:31:18,990
你會得到一個大名單，然後明顯一些其他的東西正在做

515
00:31:18,990 --> 00:31:22,280
把它變成一個詞雲，但你可以看到整體

516
00:31:22,280 --> 00:31:25,850
這是很容易的訪問，很容易使用。

517
00:31:25,850 --> 00:31:30,750
真的很好了一些東西。

518
00:31:30,750 --> 00:31:35,940
>> 我想這就是所有我要說的整體。

519
00:31:35,940 --> 00:31:39,040
最後一件事，我會提到一般的API是

520
00:31:39,040 --> 00:31:41,840
有時你會碰到一種叫速率限制，

521
00:31:41,840 --> 00:31:44,940
和速率限制的想法是，你不想濫用的API。

522
00:31:44,940 --> 00:31:48,130
換句話說，這是非常好的，很多這些網站的API

523
00:31:48,130 --> 00:31:51,070
你可以去免費使用。

524
00:31:51,070 --> 00:31:54,460
但是，如果你賺了幾百萬或數十億每天的請求，

525
00:31:54,460 --> 00:31:57,610
例如，如果你停留在一個無限循環，無限查詢

526
00:31:57,610 --> 00:32:00,680
某種形式的API和，取回一個巨大的數據量，

527
00:32:00,680 --> 00:32:04,570
顯然，這不是很好，所以有很多的API做的是有速率限制功能

528
00:32:04,570 --> 00:32:09,970
說，你只能每天每1,000個請求IP地址或類似的東西。

529
00:32:09,970 --> 00:32:12,540
如果你做了很多的測試和諸如此類的事情，

530
00:32:12,540 --> 00:32:14,890
有時你會遇到，突然，它會關閉你

531
00:32:14,890 --> 00:32:18,280
並說沒有，我不會給你任何更多的數據。

532
00:32:18,280 --> 00:32:20,000
>> 你想要做的是遊戲規則。

533
00:32:20,000 --> 00:32:22,950
你要確保你讀了API規範，仔細。

534
00:32:22,950 --> 00:32:26,330
如果它有一定的規則連接到它，就像你每天只能使X查詢

535
00:32:26,330 --> 00:32:30,000
或者可以只訪問一個數據庫的一部分，一定數目的次數

536
00:32:30,000 --> 00:32:32,900
或類似的東西，你要確保你堅持。

537
00:32:32,900 --> 00:32:38,360
只要你在這些規則，你可能有一個非常好的時間，使用API​​。

538
00:32:38,360 --> 00:32:42,030
您的整體外賣API是真的，真的有用。

539
00:32:42,030 --> 00:32:45,610
>> 有幾乎所有大的網絡服務的API。

540
00:32:45,610 --> 00:32:50,700
幾乎所有的谷歌地球，谷歌地圖，谷歌工具套件的一部分，

541
00:32:50,700 --> 00:32:54,390
Gmail，谷歌日曆，所有這些東西的API。

542
00:32:54,390 --> 00:32:58,280
你可以用它們來都得到來自服務器的數據和發送數據到服務器。

543
00:32:58,280 --> 00:33:00,870
換句話說，如果你想使一個日曆應用程序可以更新

544
00:33:00,870 --> 00:33:04,190
一個人的谷歌日曆，有一個API，。

545
00:33:04,190 --> 00:33:07,810
如果你想的東西，會告訴你在哪裡

546
00:33:07,810 --> 00:33:12,530
某個地址的位置，你可以使用谷歌地圖API是。

547
00:33:12,530 --> 00:33:15,860
API是極其有用的，它們到處都是。

548
00:33:15,860 --> 00:33:18,700
如果你有興趣在某種觀念，

549
00:33:18,700 --> 00:33:22,170
有可能是一個相關的API，你可以用它來獲得大量的數據

550
00:33:22,170 --> 00:33:25,060
很快很簡單。

551
00:33:25,060 --> 00:33:28,140
>> 如果你還在尋找一個項目，或者如果你只是想玩弄

552
00:33:28,140 --> 00:33:31,820
在一般的東西，API是絕對值得做的事情。

553
00:33:31,820 --> 00:33:37,200
謝謝，我很樂意回答任何問題，你們可能。

554
00:33:37,200 --> 00:33:44,900
好了，非常感謝。

555
00:33:44,900 --> 00:33:48,000
[CS50.TV]