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]