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 పట్టికలు మరియు stuff యొక్క విధమైన అన్ని ఉపయోగించి చేస్తాడు

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, లేదా జావాస్క్రిప్ట్ ఆబ్జెక్ట్ నొటేషన్ ఇది.

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
నేను, జావాస్క్రిప్ట్ ఆబ్జెక్ట్ నొటేషన్ అన్నాడు.

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
మీరు శ్రేణులను hashmaps, మరియు ధాతువులు ఉన్నాయి.

43
00:02:13,540 --> 00:02:16,580
మీరు CS50 లో కొద్దిగా చూశారు చేసిన వ్యూహాలను మరియు hashmaps,

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
మేము ఈ కీ isAwesome ఇది hashmap యొక్క మరొక మూలకం, చూడండి

58
00:03:04,120 --> 00:03:07,370
ఇతర మాటలలో నిజమైన యొక్క పురాతన విలువ Maps, బూలియన్.

59
00:03:07,370 --> 00:03:09,420
ధాతువులు తీగలను ఉంటుంది. వారు పూర్ణ ఉంటుంది.

60
00:03:09,420 --> 00:03:11,960
వారు ఆ వంటి ఏదైనా bools ఉంటుంది.

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
ఆ JSON యొక్క 2 లక్షణాలు, మరియు మేము 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 లో శ్రేణుల, BOUND రకం

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
ఇది మీరు బాగా చూడగలిగిన ఒక nice, అందంగా వెర్షన్ ఇస్తుంది.

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
ఇది, ఇది చాలా శ్రద్ధ డేటా వంటి reading అందంగా ఫాస్ట్ అని అర్థం

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 లు పని సాధారణంగా నిజంగా ఉపయోగకరంగా ఉంటుంది మరొక భాగం క్వెరీ ఉంది.

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
అది కోడ్ చాలా పడుతుంది, కాబట్టి క్వెరీ JavaScript ఒక గ్రంధాలయం.

107
00:06:07,590 --> 00:06:09,800
ఇతర మాటలలో, మీరు లోడ్ ఒక JavaScript ఫైల్

108
00:06:09,800 --> 00:06:12,730
మరియు తర్వాత కొన్ని పనులు క్వెరీ విధులు ఉపయోగించండి.

109
00:06:12,730 --> 00:06:15,670
మరియు j క్వెరీ ప్రధానంగా జీవితంలోని మొత్తం చాలా సులభతరం చేస్తుంది.

110
00:06:15,670 --> 00:06:20,390
ఇది j క్వెరీ కొన్ని పంక్తులు మీరు జావాస్క్రిప్ట్ను లో పంక్తులు వందల రాసుకోదగిన ఏ సులభతరం.

111
00:06:20,390 --> 00:06:24,430
>> మీరు ఎందుకంటే సాధారణంగా API లను ఉపయోగించి మీరు ప్రత్యేకించి ఉపయోగం

112
00:06:24,430 --> 00:06:27,600
మీరు API లు యాక్సెస్ వస్తుంది ఎలా, అజాక్స్ అభ్యర్ధనలు ద్వారా ఉంది

113
00:06:27,600 --> 00:06:30,130
మరియు నేను డేవిడ్ ఉపన్యాసంలో చెప్పాడు అని అజాక్స్ అభ్యర్ధనలు

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
క్వెరీ, 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 Viewer ఉంది

127
00:07:18,310 --> 00:07:23,270
మరియు ప్రధానంగా ఒక Ngram Viewer ఆలోచన మీరు పదం యొక్క రకమైన శోధించవచ్చు ఉంది

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
మేము, పేరు జెన్నిఫర్ కోసం, ఉదాహరణకు, శోధించవచ్చు

132
00:07:40,090 --> 00:07:44,400
మరియు మేము అది నిజంగా అన్ని ఎక్కువ చేసేవారు కాదు ముందు 1960 ఆ చూడండి

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
మరియు మేము ఒక నిర్దిష్ట అక్షం మరియు stuff యొక్క విధమైన అన్ని శ్రద్ధ.

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
ఇతర మాటలలో, ఈ మొదటి ప్రశ్న మనం మాత్రమే, USA లో శోధిస్తున్న

167
00:09:45,080 --> 00:09:51,150
మాత్రమే UK లో రెండవ, మరియు మాత్రమే ఫ్రాన్స్ లో ప్రచురితమైన రచనల నుండి మూడవ లో.

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
మీరు మేము ఒక మ్యాపింగ్ కలిగి ఆ hashmaps ప్రతి లోపల చూడగలరు

204
00:12:07,340 --> 00:12:12,700
ఈ ఇండెక్స్ 0 విలువను మరియు మరొక hashmap ఈ విలువ యొక్క విలువ,

205
00:12:12,700 --> 00:12:18,360
మళ్ళీ Y అక్షం విలువలకు X అక్షం విలువలు మ్యాపింగ్ ఇది.

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
ఈ వెబ్ అప్లికేషన్ యొక్క పరస్పర అన్ని నిర్వహణ చేసే పెద్ద జావాస్క్రిప్ట్ ఫైలు

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
కానీ I-లో లేదు నిజానికి, నేను ఇప్పటికే ఈ చేస్తున్నదాన్ని వెళుతున్న ఏ, ఇది గొప్ప-ఉంది

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
ఇతర మాటలలో, ఈ, వెబ్ అప్లికేషన్ 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
కానీ ఈ సందర్భంలో, మనం Y అక్షం విలువలకు X అక్షం విలువలు ఆ మ్యాపింగ్ కావలసిన.

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
మేము USA ఇది ఈ దేశం కలిగి.

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
నేను కలిగి ఉండే ఏకైక ID Facebook ఉన్నాయి.

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
లెట్ యొక్క నేను డేవిడ్ మలన్ ఫేస్బుక్లో ఇష్టపడ్డారు విధంగా ఆసక్తి ఉన్నాను చెప్పారు.

293
00:17:33,060 --> 00:17:36,860
I / ఇష్టాలు చేయవచ్చు. ఇప్పుడు మాకు ఒక సమస్య ఆకస్మికంగా చేసిన.

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
Facebook విధంగా మరియు మరింత ఆధునిక API లు,

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 ఈ nice సాధనం ఉంది

308
00:18:23,050 --> 00:18:27,690
ఇది గ్రాఫ్ API Explorer, మరియు ఆ ఆలోచన మీ క్రమం అనేది

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
అయ్యో, నేను ఇక్కడ నా టోకెన్ revalidate ఉంటుంది అంచనా.

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
మరియు మీరు ఒక CS50 చివరి ప్రాజెక్ట్ Facebook API ఉపయోగించి మీకు ఆసక్తి ఉంటే

327
00:19:37,980 --> 00:19:40,720
లేదా ఏదైనా కోసం ఇది నిజానికి చాలా doable అని ఇష్టపడుతున్నారు.

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
>> మీరు Google 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
మరియు ఆ వినియోగదారులు App వారి ప్రొఫైల్ యొక్క కొన్ని భాగాలు ఆక్సెస్ చెయ్యడానికి ఆ అనుమతించింది

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
ఇది రోజు HUDS మెను తిరిగి CS50 ఆహార API ఉపయోగిస్తుంది.

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
మేము కొన్ని విభిన్న రకాలు ఉన్నాయి. మేము బీన్ మరియు ధాన్యపు స్టేషన్.

397
00:23:58,130 --> 00:24:00,340
మేము బ్రౌన్ రైస్ స్టేషన్.

398
00:24:00,340 --> 00:24:03,360
మేము ఈ కొన్ని ఆహార కలిగి brunch కోసం చూడగలరు.

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
అది pseudocode ఉన్నప్పటికీ కానీ అది చాలా రీడబుల్, కనుక నేను ద్వారా ఉంటాము.

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
మీరు నవంబర్ 16, 2012 AD చెప్పలేను.

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
క్వెరీ చెయ్యాల్సిన అన్ని తెలియచేస్తాయి ఈ సూపర్ ఉపయోగకరమైన AJAX చర్యను కలిగి

424
00:25:41,680 --> 00:25:45,780
కొన్ని ఇక్కడ డౌన్ పారామితులు మరియు అది తిరిగి సరిగ్గా మీరు ఏమి మీరు ఇస్తుంది.

425
00:25:45,780 --> 00:25:50,490
మేము, మేము అది కు వెళ్లాలని మీరు అనుకుంటున్నారా URL ఈ CS50 ఆహార API అని అది చెప్పుకుంటున్నారు

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, సరే, అని, 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
లేదా ఆ వంటి ఏదైనా, Freebase మరియు వికీపీడియా ఉంటాయి.

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
జస్ట్ hey say, వికీపీడియా 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
>> ఇది చాలా API వంటి కొద్దిగా కష్టం అయితే Freebase, ఇలాంటి విధమైన ఉంది.

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
octopuses గురించి, గొప్ప పని కాబట్టి.

473
00:28:43,830 --> 00:28:46,870
Freebase ఆ కొద్దిగా చాలా క్లిష్టమైన పద్ధతిలో పనిచేస్తుంది

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
నేను Freebase 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
మళ్ళీ, Last.fm వెనుక ఒక పెద్ద API ఉన్నది

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
మరియు మీరు Last.fm API ఒక అందమైన సాధారణ AJAX కాల్ చేయడం ద్వారా ఆ చేయవచ్చు.

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
మీరు మాత్రమే IP చిరునామా లేదా అలాంటిదే రోజుకు 1,000 అభ్యర్థనలను చెప్పేవారు.

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
మీ మొత్తం takeaway API లు, నిజంగా నిజంగా ఉపయోగపడతాయి ఉంది.

539
00:32:42,030 --> 00:32:45,610
>> ఒక API అక్కడ దాదాపు ఏ పెద్ద వెబ్ సేవ కోసం ఉన్నాయి.

540
00:32:45,610 --> 00:32:50,700
Google Tools సూట్, Google Maps, Google Earth యొక్క ప్రెట్టీ చాలా భాగాన్ని

541
00:32:50,700 --> 00:32:54,390
Gmail, Google క్యాలెండర్, ఆ విషయాలను అన్ని 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
ఒకరి Google Calendar, ఆ కోసం ఒక API ఉంది.

545
00:33:04,190 --> 00:33:07,810
మీరు ఎక్కడ చెప్పడం జరగబోతోంది ఏదో చేయాలనుకుంటే

546
00:33:07,810 --> 00:33:12,530
ఒక నిర్దిష్ట చిరునామా నగర మీరు ఆ కోసం Google Maps 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]