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 ಆಬ್ಜೆಕ್ಟ್ ಸಂಕೇತ ಇದು.

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
ಇತರ ಪದಗಳಲ್ಲಿ ನಿಜವಾದ ಒಂದು ಮೂಲರೂಪದ ಮೌಲ್ಯಕ್ಕೆ ನಕ್ಷೆಗಳು, ಒಂದು ಬೂಲಿಯನ್.

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 ಅರ್ರೆಯ್, ಪರಿಮಿತಿ ರೀತಿಯ

69
00:03:43,420 --> 00:03:46,400
ಹಾಗಾಗಿ, HI ಇದು, ಇಲ್ಲಿ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ತೋರಿಸಬಹುದಿತ್ತು

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
ನೀವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನ ಸ್ವಲ್ಪ ಕಲಿತ ಮಾಡಿದ, ಇದು ಉತ್ತಮ ಮಾರ್ಗ

102
00:05:49,290 --> 00:05:53,710
ಒಂದು ವೆಬ್ಸೈಟ್ ಒಳಗೆ ಎಚ್ಟಿಎಮ್ಎಲ್ ಮತ್ತು ಸಿಎಸ್ಎಸ್ ಕುಶಲತೆಯಿಂದ.

103
00:05:53,710 --> 00:05:57,190
ಆದರೆ, ರೀತಿಯ ಸರಳ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಂಕೇತವನ್ನು ಒಂದು ನೋವು ಆಗಿರಬಹುದು

104
00:05:57,190 --> 00:05:59,810
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನಿಜವಾಗಿಯೂ ಅತಿಮಾತಿನ ಭಾಷೆ ಬಹುಮಟ್ಟಿಗೆ ಕಾರಣ.

105
00:05:59,810 --> 00:06:03,020
ನೀವು ವಾಕ್ಯ ಸಾಕಷ್ಟು ಕಲಿಯಬೇಕಾಗುತ್ತದೆ, ಮತ್ತು ಕೇವಲ ಸರಳ ಕೆಲಸಗಳನ್ನು

106
00:06:03,020 --> 00:06:07,590
ಇದು ಕೋಡ್ ಬಹಳಷ್ಟು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಆದ್ದರಿಂದ jQuery ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಒಂದು ಗ್ರಂಥಾಲಯವಾಗಿದೆ.

107
00:06:07,590 --> 00:06:09,800
ಅಂದರೆ, ನೀವು ಲೋಡ್ ಒಂದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಡತದ

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
ಇದು 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
ಸರಳ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ರಲ್ಲಿ ರೇಖೆಗಳ ಕ್ರೇಜಿ ಸಂಖ್ಯೆಗಳನ್ನು ಮಾಡುವುದಾಗಿ ಆದರೆ

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
ನಾವು, ಹೆಸರು ಜೆನ್ನಿಫರ್ ಉದಾಹರಣೆಗೆ,, ಹುಡುಕಬಹುದು

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
ವೈ ಅಕ್ಷ ಮತ್ತು 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
ಯುದ್ಧ, ಯುದ್ಧ, ಮತ್ತು ಗ್ಯೂರ್ರೆ ಇದು ಯುದ್ಧ, ಫ್ರೆಂಚ್ ಪದ.

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
ಕೇವಲ ಯುಕೆ ಎರಡನೆಯ ಒಂದು, ಮತ್ತು ಕೇವಲ ಫ್ರಾನ್ಸ್ನಲ್ಲಿ ಪ್ರಕಟವಾದ ಕೃತಿಗಳು ಮೂರನೇ ರಲ್ಲಿ.

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
ನಾನು ಕ್ರೋಮ್ನ ಅಭಿವರ್ಧಕ ಉಪಕರಣಗಳು ಬಳಸಿಕೊಂಡು ವೃಂದದಲ್ಲಿರುತ್ತೇನೆ, ಮತ್ತು ಆ ಪಡೆಯಲು

180
00:10:30,200 --> 00:10:35,160
ನೀವು ನಿಯಂತ್ರಣ, ಶಿಫ್ಟ್, ಜೆ, ಮತ್ತು 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
ಮತ್ತೆ ವೈ ಅಕ್ಷದ ಮೌಲ್ಯಗಳಿಗೆ 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
ವಿವಿಧ ವೈ ಮತ್ತು ಆಯ್ಕೆ ಮತ್ತು ವಿಷಯ ಆ ರೀತಿಯ ಎಲ್ಲಾ ನೀವು 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
ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಈ, ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ 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
ಇದು ನಾವು ಮೇಲೆ ವೈ ಅಕ್ಷದ ರಲ್ಲಿ ಆಯ್ಕೆಮಾಡಿದ ನಿಖರವಾಗಿ ಏನು.

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 ಅಕ್ಷದ ಮೌಲ್ಯಗಳ ಎಂದು ಮ್ಯಾಪಿಂಗ್ ಬಯಸುವ.

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
ಮತ್ತು ನಾವು ವೈ ಅಕ್ಷ ಮತ್ತು 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
ನಾವು ಫೇಸ್ಬುಕ್ ಮಾಡಲು ನೀನು.

265
00:15:56,510 --> 00:15:59,440
ಫೇಸ್ಬುಕ್ನ API, ಫೇಸ್ಬುಕ್ ಗ್ರಾಫ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ

266
00:15:59,440 --> 00:16:04,390
ಮತ್ತು ಮೂಲತಃ ಎಂದರೆ ಏನು ಫೇಸ್ಬುಕ್ ಈ ಬೃಹತ್ ಡೇಟಾಬೇಸ್ ಎಂದು ಸ್ವತಃ ಕಾಣಬಹುದು

267
00:16:04,390 --> 00:16:08,000
ಎಲ್ಲಾ ಪರಸ್ಪರ ಕೆಲವು ಸಂಬಂಧಗಳನ್ನು ಹೊಂದಿರುವ ವಿವಿಧ ಭಾಗಗಳಲ್ಲಿ ಸಾಕಷ್ಟು ಆಫ್.

268
00:16:08,000 --> 00:16:11,070
ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ನಾನು ಫೇಸ್ಬುಕ್ ಒಂದು ಬಳಕೆದಾರ ಆಮ್, ಆದ್ದರಿಂದ ನಾನು ಒಂದು ಪ್ರೊಫೈಲ್

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
>> ಫೇಸ್ಬುಕ್ ವಿವಿಧ ಭಾಗಗಳಲ್ಲಿ ಬಹಳಷ್ಟು ಇಲ್ಲ.

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 ಯನ್ನು ಫೇಸ್ಬುಕ್ ಇಲ್ಲ.

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
>> ನಾವು ಉದಾಹರಣೆಗೆ, ಡೇವಿಡ್ Malan ಅದೇ ವಿಷಯ ಮಾಡಬಹುದು.

286
00:17:10,849 --> 00:17:13,599
ನಾನು ಅವರ ಹೆಸರನ್ನು dmalan ಎಂದು.

287
00:17:13,599 --> 00:17:16,369
ನಾವು ಡೇವಿಡ್ Malan ಒಂದು ಅನನ್ಯ 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
ಲೆಟ್ಸ್ ನಾನು ಡೇವಿಡ್ Malan ಫೇಸ್ಬುಕ್ ಮೇಲೆ ಇಷ್ಟಪಟ್ಟಿದ್ದಾರೆ ಯಾವ ಆಸಕ್ತಿ ಆಮ್ ಹೇಳುತ್ತಾರೆ.

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
ನೀವು ಫೇಸ್ಬುಕ್ನ ದತ್ತಸಂಚಯದ ಪ್ರತಿಯೊಂದು ಭಾಗವನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಾದರೆ

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 ಗಳು,

303
00:18:06,940 --> 00:18:09,840
ಕೆಲವು ಅನುಮತಿಗಳನ್ನು ಕೆಲವು ಕೆಲಸಗಳನ್ನು ಅಗತ್ಯವಿರುತ್ತದೆ.

304
00:18:09,840 --> 00:18:12,650
ನಾನು ಡೇವಿಡ್ Malan ಬಗ್ಗೆ ಈ ಮೂಲಭೂತ ಮಾಹಿತಿಯನ್ನು ನೋಡಬಹುದು.

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
ಈಗ ಈ ತಿರುಗಾಡಲು, ಫೇಸ್ಬುಕ್ ಈ ಸಂತೋಷವನ್ನು ಉಪಕರಣವನ್ನು ಹೊಂದಿದೆ

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
ಓಹ್, ನಾನು ಇಲ್ಲಿ ನನ್ನ ಟೋಕನ್ 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
ಈ ನನ್ನ ನಿಜವಾದ ಫೇಸ್ಬುಕ್ ಇಷ್ಟಗಳು ಇವೆ.

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 ಅಂತಿಮ ಯೋಜನೆಗೆ ಫೇಸ್ಬುಕ್ API ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಆಸಕ್ತಿ

327
00:19:37,980 --> 00:19:40,720
ಅಥವಾ ಏನು ಅದು ನಿಜವಾಗಿಯೂ ಸ್ವಲ್ಪ doable ಎಂದು ಹಾಗೆ.

328
00:19:40,720 --> 00:19:44,260
ಮೂಲತಃ ನೀವು ದೃಢೀಕರಣ ವಿಷಯ ತಿರುಗಾಡಲು ಹೇಗೆ ಫೇಸ್ಬುಕ್ ಆಗಿದೆ

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
>> ನೀವು ಗೂಗಲ್ ಫೇಸ್ಬುಕ್ API ವೇಳೆ ಬಹಳ ಓದಬಲ್ಲ ಇಲ್ಲಿದೆ.

335
00:20:04,050 --> 00:20:06,670
ಇಡೀ ವಿಶೇಷ ಇಲ್ಲ.

336
00:20:06,670 --> 00:20:10,210
ಉದಾಹರಣೆಗೆ, ಈ, ಫೇಸ್ಬುಕ್ 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
>> ನೀವು ಮಾಡಿದ ಒಂದು ಫೇಸ್ಬುಕ್ ಅಪ್ಲಿಕೇಶನ್ ಮತ್ತು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್, ಕೆಲವು ಬಳಕೆದಾರರನ್ನು ಹೊಂದಿದೆ

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
ನೀವು ಫೇಸ್ಬುಕ್ ಬಳಸಲು ಬಯಸುವ ವೇಳೆ ನಾನು ಹೆಚ್ಚು ಶಿಫಾರಸು ಎಂದು ನೀವು

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
ಕಲ್ಪನೆ ಒಟ್ಟಾರೆ, ಫೇಸ್ಬುಕ್ 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
ಇದು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಎ, ವಿಶೇಷವಾಗಿ ಯಾವ 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
ಮತ್ತು ಬಿ, ಅದು ನನಗೆ ಮರಳಿ ನೀಡಲು ವಿಶೇಷವೇನು ನಿಖರವಾಗಿ ಟೆಲ್ ಮಿ ವಾಟ್ ಕಾಣಿಸುತ್ತದೆ.

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
ನಾವು ಈ ಕೆಲವು ಆಹಾರ ಪದಾರ್ಥಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ ಬ್ರಂಚ್ ಗಾಗಿ ನೋಡಬಹುದು.

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
ನೀವು ಕೇವಲ ನವೆಂಬರ್ 16, 2012 ಕ್ರಿ.ಶ. ಹೇಳಲು ಸಾಧ್ಯವಿಲ್ಲ.

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
ನಾವು, ನಾವು ಹೋಗಿ ಬಯಸುವ 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
ಎಚ್ಟಿಎಮ್ಎಲ್ ಅಪ್ಡೇಟ್ ಮತ್ತು ಈ ಹೊಸ ಅಕ್ಷಾಂಶ ಸೇರಿಸಲು.

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
>> ಇದು ದೂರದ API ಎಂದು ಸ್ವಲ್ಪ ಕಷ್ಟ ಆದರೂ ಫ್ರೀಬೇಸ್, ಇದೇ ರೀತಿಯ ಹೊಂದಿದೆ.

466
00:28:21,350 --> 00:28:24,390
ಫ್ರೀಬೇಸ್ ಇದು ಆನ್ಲೈನ್ ವಿಶ್ವಕೋಶ ಎಂದು ವಿಕಿಪೀಡಿಯ ಹಾಗೆ

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
ನಾನು 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
ನೀವು ಹಾಗೆ ಅದರಲ್ಲಿ ಸೇರಿಕೊಳ್ಳುವುದು ಕೆಲವು ನಿಯಮಗಳನ್ನು ಹೊಂದಿದೆ ಮಾತ್ರ ದಿನಕ್ಕೆ ಎಕ್ಸ್ ಪ್ರಶ್ನೆಗಳನ್ನು ಮಾಡಬಹುದು

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, 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 ಕ್ಯಾಲೆಂಡರ್, ಆ ಒಂದು 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 ಗಳು fantastically ಉಪಯುಕ್ತ, ಮತ್ತು ಅವರು ಎಲ್ಲೆಡೆ ಆರ್.

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]