1
00:00:00,000 --> 00:00:02,270
>> [ರಿವ್ಯೂ: ರಸಪ್ರಶ್ನೆ 1]

2
00:00:02,270 --> 00:00:04,620
[ಅಲಿ Nahm, Oreoluwa Barbarinsa, ಲ್ಯೂಕಾಸ್ ಫ್ರೀಟಾಸ್, ರಾಬ್ ಬೌಡೆನ್] [ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]

3
00:00:04,620 --> 00:00:07,660
[ಈ CS50 ಹೊಂದಿದೆ.] [CS50.TV]

4
00:00:07,660 --> 00:00:11,610
[ಲ್ಯೂಕಾಸ್ ಫ್ರೀಟಾಸ್] ಎಲ್ಲರಿಗೂ ಸ್ವಾಗತ. ಈ ರಸಪ್ರಶ್ನೆ 1 ವಿಮರ್ಶೆ.

5
00:00:11,610 --> 00:00:15,040
ಕೇವಲ ಒಂದು ಹಕ್ಕುನಿರಾಕರಣೆ ಮಾಹಿತಿ, ಈ - ನಾನು ಅರ್ಥ, ನಾವು ರಕ್ಷಣೆ ಪ್ರಯತ್ನಿಸಿ ನೀನು

6
00:00:15,040 --> 00:00:17,770
ಸಾಧ್ಯ, ಆದರೆ ಅಷ್ಟು ವಸ್ತು ಎಂದು ಅರ್ಥವಲ್ಲ

7
00:00:17,770 --> 00:00:20,780
ನಾವು ರಸಪ್ರಶ್ನೆ 1 ಮಾಡಬಹುದು ವಸ್ತುಗಳ ಎಲ್ಲಾ ರಕ್ಷಣೆ ನೀನು.

8
00:00:20,780 --> 00:00:25,270
ಆದ್ದರಿಂದ ನೀವು ಸಹ ಒಂದು ಉಪನ್ಯಾಸ ನೋಟ ವಿಭಾಗಗಳು, ನೀವು ಎಲ್ಲವನ್ನೂ ತೆಗೆದುಕೊಂಡು ಮರೆಯಬೇಡಿ.

9
00:00:25,270 --> 00:00:28,240
ರಸಪ್ರಶ್ನೆ 1 ಬುಧವಾರ, ಮುಂದಿನ ಬುಧವಾರ ಏರಲಿದೆ.

10
00:00:28,240 --> 00:00:33,800
ಆದ್ದರಿಂದ ಅಧ್ಯಯನ ಮರೆಯಬೇಡಿ. ಇದು ಮೊದಲ ರಸಪ್ರಶ್ನೆ ರೀತಿಯಲ್ಲಿ, ಅತ್ಯಧಿಕವಾಗಿ, ಎಂದು ವಿಶೇಷವೇನು

11
00:00:33,800 --> 00:00:36,390
ಅದರ ಸ್ವರೂಪ ಬಗ್ಗೆ, ಆದರೆ ಬಹುಶಃ ಹೆಚ್ಚು ಕಷ್ಟ ಎಂದು ವಿಶೇಷವೇನು.

12
00:00:36,390 --> 00:00:39,600
ನಾನು 50 ಪಡೆದಾಗ ಕನಿಷ್ಠ, ಕಳೆದ ವರ್ಷ, ನಾನು ತುಂಬಾ ಕಷ್ಟವಾಯಿತು ಎಂದು ಭಾವಿಸಲಾಗಿದೆ.

13
00:00:39,600 --> 00:00:42,410
ಆದ್ದರಿಂದ ಸಾಕಷ್ಟು ಅಧ್ಯಯನ.

14
00:00:42,410 --> 00:00:45,190
>> ನಾನು ಡೇಟಾ ರಚನೆಗಳು ರಕ್ಷಣೆ ಹೋಗುವ ಬಾಗುತ್ತೇನೆ ಮತ್ತು ಹಫ್ಮನ್ ಕೋಡಿಂಗ್.

15
00:00:45,190 --> 00:00:47,910
ಈ, ಜನರು ಬಹಳಷ್ಟು ಸಂಕೀರ್ಣ ಎಂದು ವಿಷಯ

16
00:00:47,910 --> 00:00:51,930
ಆದರೆ ನಾನು ಸಾಧ್ಯವಾದಷ್ಟು ಸುಲಭ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ ಪಡೆಯಲಿದ್ದೇನೆ.

17
00:00:51,930 --> 00:00:56,330
ಎಲ್ಲಾ ಮೊದಲ, ನಾವು ನೀವು ಹುಡುಗರಿಗೆ ರಸಪ್ರಶ್ನೆ 1 ತಿಳಿಯಲು ಬಯಸುವ ಆಗಿದೆ

18
00:00:56,330 --> 00:01:00,970
ನಾನು ಪ್ರಸ್ತುತ ಪಡೆಯಲಿದ್ದೇನೆ ದತ್ತಾಂಶ ರಚನೆಗಳು ಪ್ರತಿ ಕಲ್ಪನಾತ್ಮಕ ವಿವರಣೆಗಳನ್ನು ಅರ್ಥ.

19
00:01:00,970 --> 00:01:03,960
ನೀವು ಹೊಂದಿಲ್ಲ ಎಂದರ್ಥ ವಾಸ್ತವವಾಗಿ

20
00:01:03,960 --> 00:01:07,020
ನಿಮ್ಮ ರಸಪ್ರಶ್ನೆ 1 ಒಂದು ಹ್ಯಾಶ್ ಕೋಷ್ಟಕದ ಜಾರಿಗೆ.

21
00:01:07,020 --> 00:01:10,250
ನಾವು ನೀವು ಇಡೀ ಹ್ಯಾಷ್ ಟೇಬಲ್ ಜಾರಿಗೆ ಬಯಸುವುದಿಲ್ಲ; ಬಹುಶಃ ನಾವು ಪ್ರಯತ್ನಿಸಿ ಮಾಡುತ್ತೇವೆ

22
00:01:10,250 --> 00:01:13,090
ನೀವು ಕೆಲವು ಕಾರ್ಯಗಳನ್ನು ಜಾರಿಗೆ ಮಾಡಲು,

23
00:01:13,090 --> 00:01:16,940
ಸಾಮಾನ್ಯ ಕಾರ್ಯಾಚರಣೆಗಳ, ಆದರೆ ನಾವು ನೀವು ಎಲ್ಲವೂ ಜಾರಿಗೆ ಮಾಡಲು ಹೋಗುತ್ತಿಲ್ಲ.

24
00:01:16,940 --> 00:01:21,010
ಆದ್ದರಿಂದ ನೀವು ಪ್ರತಿ ಡೇಟಾ ರಚನೆ ಹಿಂದೆ ಪರಿಕಲ್ಪನೆಯನ್ನು ಅರ್ಥ ಮುಖ್ಯವಾಗಿರುತ್ತದೆ

25
00:01:21,010 --> 00:01:23,510
ಮತ್ತು ನೀವು ಸಿ ಕೋಡ್ ಸಮರ್ಥವಾಗಿರುತ್ತವೆ,

26
00:01:23,510 --> 00:01:27,880
ಅವರು ಪ್ರತಿ ಡೇಟಾ ರಚನೆ ಹೊಂದಿವೆ ಸಾಮಾನ್ಯ ಕಾರ್ಯಾಚರಣೆಗಳ.

27
00:01:27,880 --> 00:01:30,090
ಮತ್ತು, ಪಾಯಿಂಟರ್ಸ್ ಮತ್ತು ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಪರಿಶೀಲಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ

28
00:01:30,090 --> 00:01:33,470
ಅವರು ಈ ಡೇಟಾವನ್ನು ರಚನೆಗಳು ಸಾಕಷ್ಟು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ ಏಕೆಂದರೆ.

29
00:01:33,470 --> 00:01:37,380
>> ಮೊದಲ, ಪಟ್ಟಿಯಲ್ಲಿ ಲಿಂಕ್. ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ವಾಸ್ತವವಾಗಿ ರಚನೆಗಳು ಇವೆ,

30
00:01:37,380 --> 00:01:39,930
ಆದರೆ ಲಿಂಕ್ ಪಟ್ಟಿ ಮತ್ತು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನಡುವಿನ ವ್ಯತ್ಯಾಸ,

31
00:01:39,930 --> 00:01:45,160
ಎಲ್ಲಾ ಮೊದಲ, ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಒಂದು ಹೊಂದಿಕೊಳ್ಳುವ ಗಾತ್ರದ ಹೊಂದಿದೆ

32
00:01:45,160 --> 00:01:50,060
ಸರಣಿಗಳ ನೀವು ರಚನೆಯ ಒಂದು ಅತ್ಯಂತ ದೊಡ್ಡ ಗಾತ್ರದ ಎರಡೂ ಆಯ್ಕೆ ಹೊಂದಿರುತ್ತವೆ,

33
00:01:50,060 --> 00:01:53,710
ಆದ್ದರಿಂದ ನೀವು, ನೀವು ಆ ಶ್ರೇಣಿಯಲ್ಲಿನ ಎಲ್ಲಾ ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ನೀನು ತಿಳಿದಿದೆ

34
00:01:53,710 --> 00:01:59,370
ಅಥವಾ ನೀವು ರಚನೆಯ ಒಂದು ಹೊಂದಿಕೊಳ್ಳುವ ಉದ್ದವನ್ನು, malloc ಬಳಸಲು ಹೊಂದಿರುತ್ತವೆ.

35
00:01:59,370 --> 00:02:03,680
ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ಇದು ಕೇವಲ ಹೆಚ್ಚು ಅಂಶಗಳನ್ನು ಪಡೆಯಲು ಬಹಳ ಸುಲಭ,

36
00:02:03,680 --> 00:02:07,210
ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಹೆಚ್ಚು ಅಂಶಗಳನ್ನು ಹಾಕಲು ಅಥವಾ ಅಂಶಗಳನ್ನು ತೆಗೆದು.

37
00:02:07,210 --> 00:02:09,370
ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ನೀವು ಲಿಂಕ್ ಪಟ್ಟಿ ಪ್ರತ್ಯೇಕಿಸಬಹುದು ಬಯಸದಿದ್ದರೆ,

38
00:02:09,370 --> 00:02:13,950
ನೀವು ಹುಡುಕಲು ಮತ್ತು ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಅಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕಬಹುದು,

39
00:02:13,950 --> 00:02:16,800
ಆದ್ದರಿಂದ ಓ (1) ಸಮಯ, ಆದ್ದರಿಂದ ಬಹಳ ಅನುಕೂಲಕರ.

40
00:02:16,800 --> 00:02:20,660
ನೀವು, ಗ್ರಂಥಿಗಳು ಯಾವಾಗಲೂ malloc ನೆನಪಿಡುವ ಎಚ್ಚರಿಕೆಯಿಂದ ಮತ್ತು ಉಚಿತ ಇರಬೇಕು

41
00:02:20,660 --> 00:02:25,510
ನೀವು ವೇಳೆ, ನೀವು ಮೆಮೊರಿ ಸೋರುವಿಕೆ ಹೊಂದಿರುತ್ತದೆ ಕೇವಲ.

42
00:02:25,510 --> 00:02:31,480
ಆದ್ದರಿಂದ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು - ಒಂದು ನೋಡ್ ವ್ಯಾಖ್ಯಾನವನ್ನು ಕೇವಲ ನಾವು ಅಲ್ಲಿ ಏನು ಹಾಗೆ.

43
00:02:31,480 --> 00:02:35,110
ನಾನು ಇಂಟ್ N ಪುಟ್, ಆದರೆ ನೀವು ಬಯಸುವ ಯಾವುದೇ ದತ್ತಾಂಶವನ್ನು ಶೇಖರಿಸಿಡಲು.

44
00:02:35,110 --> 00:02:37,280
ನೀವು ಸ್ಟ್ರಿಂಗ್ ಶೇಖರಿಸಿಡಲು ಬಯಸುವ ಹಾಗಿದ್ದಲ್ಲಿ, ಇದು ಉತ್ತಮ ಇಲ್ಲಿದೆ.

45
00:02:37,280 --> 00:02:41,690
ನೀವು struct ಶೇಖರಿಸಿಡಲು ಬಯಸಿದರೆ, ನೀವು ಬಯಸುವ ಯಾವುದೇ, ಎರಡು ಉತ್ತಮ ಇಲ್ಲಿದೆ.

46
00:02:41,690 --> 00:02:44,630
ನಾನು ಇಲ್ಲಿ ಉದಾಹರಣೆಗಳು ಇಂಟ್ N ಪುಟ್.

47
00:02:44,630 --> 00:02:46,800
ಮತ್ತು ನೀವು ಮುಂದಿನ ನೋಡ್ಗೆ ಒಂದು ಪಾಯಿಂಟರ್ ಹೊಂದಿರುತ್ತವೆ.

48
00:02:46,800 --> 00:02:51,940
ಮೂಲತಃ, ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಕೆಲವು ದಶಮಾಂಶ ಹೊಂದಿದೆ, ಮತ್ತು ನಂತರ ಮುಂದಿನ ನೋಡ್ ಸೂಚಿತವಾಗಿರುತ್ತದೆ.

49
00:02:51,940 --> 00:02:56,710
ಇದು ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಕೊನೆಯ ಅಂಶ ಅದನ್ನು ಶೂನ್ಯ ತೋರಿಸಲು ವಿಶೇಷವೇನು.

50
00:02:56,710 --> 00:02:59,060
ಆದ್ದರಿಂದ ಈ ಲಿಂಕ್ ಪಟ್ಟಿ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.

51
00:02:59,250 --> 00:03:05,960
>> ಸರಿ, ಈಗ ನಾನು ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಒಂದು ಅಂಶ ಸೇರಿಸಲು ಬಯಸುವ ನಾವು ಮಾಡಬೇಕು ಎಂಬುದನ್ನು ನೋಡೋಣ.

52
00:03:05,960 --> 00:03:08,810
ಮೊದಲ, ಒಂದು ಕಾರ್ಯವನ್ನು ಸೇರಿಸಿ ರೀತಿಯ ಶೂನ್ಯವನ್ನು ಇರುತ್ತದೆ

53
00:03:08,810 --> 00:03:11,350
ನಾನು ಏನು ಮರಳಲು ಬಯಸುವ ಕಾರಣ.

54
00:03:11,350 --> 00:03:14,200
ನಾನು ವಾದವನ್ನು ಒಂದು ಇಂಟ್ ತೆಗೆದುಕೊಳ್ಳಲು ಪಡೆಯಲಿದ್ದೇನೆ,

55
00:03:14,200 --> 00:03:17,090
ನಾನು ಸೇರಿಸಲು ಬಯಸುವ ಎಂಬುದನ್ನು ತಿಳಿಯಲು ಬಯಸುವ ಏಕೆಂದರೆ.

56
00:03:17,090 --> 00:03:21,840
ಹಾಗಾಗಿ ಮಾಡಬೇಕು ಮೊದಲ ವಿಷಯ ಎಂಬುದರ? ನಾನು newnode ಮೇಲೆ malloc ಮಾಡಬೇಕು,

57
00:03:21,840 --> 00:03:24,240
ಆದ್ದರಿಂದ ಮೊದಲ ಸಾಲು.

58
00:03:24,240 --> 00:03:27,580
ನಾನು ಕೇವಲ ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಹಾಕಲು ಹೊಸ ನೋಡ್ ರಚಿಸುವ ನುಡಿದರು.

59
00:03:27,580 --> 00:03:32,360
ಹಾಗಾಗಿ ಏನು ಮಾಡಬಹುದು? ಅಲ್ಲದೆ, ನಾವು ತಿಳಿದಿರುವ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ನಮ್ಮ ಅಳವಡಿಕೆಗಳು

60
00:03:32,360 --> 00:03:38,180
ವರ್ಗ, ನಾವು ಯಾವಾಗಲೂ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಎಂದು ತಲೆ ಪುಟ್.

61
00:03:38,180 --> 00:03:41,800
ಆದ್ದರಿಂದ ನಾವು ಮಾಡಬಹುದು ತಲೆ ಬದಲಾವಣೆ.

62
00:03:41,800 --> 00:03:44,300
ನಾನು ಈ ಹೊಸ ನೋಡ್ ಹೊಸ ಮುಖ್ಯಸ್ಥ ಎಂದು ಮಾಡಬಹುದು,

63
00:03:44,300 --> 00:03:46,670
ಮತ್ತು ಇದು ಹಿಂದಿನ ತಲೆಗೆ ತೋರಿಸಲು ವಿಶೇಷವೇನು.

64
00:03:46,670 --> 00:03:50,390
ನಾವು ಹೇಗೆ ಮಾಡಬಹುದು? ನಾನು ಮಾಡಬೇಕು ಮೊದಲ ವಿಷಯ

65
00:03:50,390 --> 00:03:54,770
, ಮೌಲ್ಯ ಹೊಸ ನೋಡ್ 'ಎನ್' ಬದಲಾವಣೆ

66
00:03:54,770 --> 00:03:57,530
ಕಾರ್ಯ ಅಂಗೀಕರಿಸಿತು.

67
00:03:57,530 --> 00:04:01,050
ನಂತರ newnode ಮುಂದಿನ ತಲೆ ಏರಲಿದೆ.

68
00:04:01,050 --> 00:04:05,800
ತಲೆ newnode ಏರಲಿದೆ. ಆದ್ದರಿಂದ ಇದು ಬಹಳ ಸರಳ.

69
00:04:05,800 --> 00:04:10,090
ಒಂದು ನೋಡ್ ಅಳಿಸುವುದು, ನಾವು ಹಾಗೆ ಮಾಡಬಹುದು -

70
00:04:10,090 --> 00:04:14,790
ನಾವು ಮಾಡಬಹುದಾದ ಒಂದು ರೀತಿಯಲ್ಲಿ ಹೇಳಲು ಹೊಂದಿದೆ,

71
00:04:14,790 --> 00:04:18,160
ಸರಿ, ನಾನು ಅಳಿಸಲು ಬಯಸಿದರೆ, ಉದಾಹರಣೆಗೆ, 3,

72
00:04:18,160 --> 00:04:24,850
ನಾನು ಹಾಗೆ ಕೇವಲ ಹಿಂದಿನ ನೋಡ್ ಪಾಯಿಂಟ್ ಆಗಿದೆ

73
00:04:24,850 --> 00:04:27,580
3 ಮುಂದಿನ ನೋಡ್.

74
00:04:27,580 --> 00:04:29,400
ಆದ್ದರಿಂದ ನಾನು ಆ ರೀತಿಯ ಮಾಡಲು ಎಂದು.

75
00:04:29,400 --> 00:04:33,400
ಆದರೆ ಅದನ್ನು ಮಾಡುವ ಸಮಸ್ಯೆ ಏನು?

76
00:04:33,400 --> 00:04:37,400
ನಾನು ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಹೊಂದಿರುತ್ತವೆ, ಆದ್ದರಿಂದ ನಾನು ಎಂದಿಗೂ ಸಂಖ್ಯೆ 3 ಪ್ರವೇಶವನ್ನು ಹೊಂದಿಲ್ಲ.

77
00:04:37,400 --> 00:04:42,480
ಸಮಸ್ಯೆ ನಾನು ನೋಡ್ ಮುಕ್ತಗೊಳಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ನಾನೇನು ಎಂದು.

78
00:04:42,480 --> 00:04:45,360
ನಾನು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಮತ್ತು (ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ) ನನ್ನನ್ನು ದ್ವೇಷಿಸುವೆ ಹೋಗುತ್ತದೆ ಹೊಂದಿವೆ ಪಡೆಯಲಿದ್ದೇನೆ.

79
00:04:45,360 --> 00:04:49,370
ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಮಾಡುವ, ನಾನು ಬಹುಶಃ ತಾತ್ಕಾಲಿಕ ಪಾಯಿಂಟರ್ ಇರಬೇಕು.

80
00:04:49,370 --> 00:04:53,210
ಹಾಗಾಗಿ ಟೆಂಪ್ ಪುಟ್. ಇದು ನಾನು ಅಳಿಸಲು ನೋಡ್ ತೋರಿಸಲು ಹೋಗುತ್ತದೆ.

81
00:04:53,210 --> 00:04:58,170
ತದನಂತರ ನಾನು ಮುಂದಿನ ನೋಡ್ ತೋರಿಸಲು ಹಿಂದಿನ ಗ್ರಂಥಿಗಳು ಚಲಿಸಬಹುದು

82
00:04:58,170 --> 00:05:00,390
ನಾನು ಅಳಿಸಲು ನೋಡ್.

83
00:05:00,390 --> 00:05:02,730
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾನು ಪಾಯಿಂಟರ್ ಮಾಡಬಹುದು.

84
00:05:02,730 --> 00:05:07,480
ನಾನು ನಾನು ಅಲ್ಲಿ ರಚಿಸಿದ ಪಾಯಿಂಟರ್ ಹೊಂದಿದ್ದೀರಾ?

85
00:05:07,480 --> 00:05:09,560
ನಾನು, ಕೇವಲ ಇಲ್ಲ -

86
00:05:09,560 --> 00:05:13,430
ವ್ಯತ್ಯಾಸ ಈ ನೋಡ್ malloc ಬಳಸಿಕೊಂಡು ದಾಖಲಿಸಿದವರು ಎಂದು,

87
00:05:13,430 --> 00:05:17,280
ಈ ಒಂದು ಕೇವಲ ಸ್ಟಾಕ್ ನಲ್ ಸ್ವಿಚ್ ಎಂದು ಘೋಷಿಸಲಾಯಿತು ಸಂದರ್ಭದಲ್ಲಿ ಆದ್ದರಿಂದ, ರಾಶಿ ಇಲ್ಲಿದೆ.

88
00:05:17,280 --> 00:05:20,000
ಆದ್ದರಿಂದ ನಾನು ಮುಕ್ತಗೊಳಿಸಲು ಹೊಂದಿಲ್ಲ.

89
00:05:20,000 --> 00:05:22,030
>> ಸರಿ. ಈಗ ರಾಶಿಯನ್ನು ಬಗ್ಗೆ ಮಾತನಾಡೋಣ.

90
00:05:22,030 --> 00:05:24,680
ಬಣವೆಗಳು ಬಹಳ ಸರಳವಾಗಿದ್ದು.

91
00:05:24,680 --> 00:05:29,540
ನಾವು ಸರಣಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ವರ್ಗ ಬಣವೆಗಳು ಮತ್ತು ಸಾಲುಗಳನ್ನು ಮಾಡಿದರು,

92
00:05:29,540 --> 00:05:32,820
ಆದರೆ ನೀವು ಪರಿಚಿತ ಇರಬೇಕು - ಕೇವಲ ತಿಳಿದಿರಲಿ

93
00:05:32,820 --> 00:05:40,740
ನೀವು ಸಹ ಸಂಬಂಧಿತ ಪಟ್ಟಿಗಳನ್ನು ಬಳಸಿ ಸಾಲುಗಳನ್ನು ಸ್ಟ್ಯಾಕ್ಗಳಲ್ಲಿ ಮಾಡಬಹುದು.

94
00:05:40,740 --> 00:05:44,460
ನೀವು ಒಂದು ಸರಣಿ ವೇಳೆ ಆದ್ದರಿಂದ, ಒಂದು ಸ್ಟಾಕ್ ಎಂದು?

95
00:05:44,460 --> 00:05:46,810
ಸ್ಟಾಕ್ ಮೊದಲ, ಒಂದು ಗಾತ್ರ ಹೊಂದಿವೆ ಹೊಂದಿರುತ್ತದೆ.

96
00:05:46,810 --> 00:05:49,950
ನೀವು ಇದೀಗ ಹೊಂದಿರುವ ಸ್ಟಾಕ್ ಗಾತ್ರ ಯಾವ ಶೇಖರಿಸಿಡಲು ಹೊಂದಿವೆ.

97
00:05:49,950 --> 00:05:52,980
ಮತ್ತು ನೀವು, ಸಂಖ್ಯೆಗಳ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ

98
00:05:52,980 --> 00:05:55,120
ಆದರೆ ನೀವು ಬಯಸಿದರೆ, ಒಂದು ರಚನೆಯ ಮಾಡಬಹುದು

99
00:05:55,120 --> 00:06:00,380
ತಂತಿಗಳ, struct ಒಂದು ಶ್ರೇಣಿಯನ್ನು, ನೀವು ಸಂಗ್ರಹಿಸಲು ಬಯಸುವ ಏನು.

100
00:06:00,380 --> 00:06:03,240
ಸ್ಟಾಕ್ ಬಗ್ಗೆ: ಸ್ಟಾಕ್ ಮತ್ತು ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ನಡುವಿನ ವ್ಯತ್ಯಾಸ

101
00:06:03,240 --> 00:06:08,590
ಸ್ಟಾಕ್ ನೀವು ಮಾತ್ರ ಸ್ಟಾಕ್ ಸೇರಿಸಲಾಗಿತ್ತು ಕೊನೆಯ ಅಂಶ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿಲ್ಲ ಎಂದು.

102
00:06:08,590 --> 00:06:11,770
ಇದು ಮೊದಲು, ಕಳೆದ ರಲ್ಲಿ ಕರೆಯಲಾಗುತ್ತದೆ.

103
00:06:11,770 --> 00:06:15,090
ನೀವು ಟ್ರೇನಲ್ಲಿ ಒಂದು ಸ್ಟಾಕ್ ಇರುವ ರೀತಿಯ

104
00:06:15,090 --> 00:06:17,670
ನೀವು ಸ್ಟಾಕ್ ಮೇಲೆ ಟ್ರೇ ಪುಟ್ ವೇಳೆ,

105
00:06:17,670 --> 00:06:22,670
ನೀವು ಇತರ ಟ್ರೇಗಳು ಪ್ರವೇಶವನ್ನು ಮೊದಲ ಟ್ರೇ ತೆಗೆದುಹಾಕಲು ಹೊಂದಿರುತ್ತವೆ.

106
00:06:22,670 --> 00:06:26,310
ಇದು ಸಂಗ್ರಹಗಳು ಅದೇ ವಿಷಯ.

107
00:06:26,310 --> 00:06:31,220
ನಾನು, ಉದಾಹರಣೆಗೆ, ಸ್ಟಾಕ್ ಒಂದು ಅಂಶ ಸೇರಿಸಲು ಬಯಸಿದರೆ, ನಾನು ಏನು ಮಾಡಬೇಕು?

108
00:06:31,220 --> 00:06:34,070
ತಳ್ಳಿ ಎಂದು, ಮತ್ತು ಇದು ಬಹಳ ಸರಳ ವಿಶೇಷವೇನು.

109
00:06:34,070 --> 00:06:37,130
ನೀವು ಮಾಡಬೇಕು ಮೊದಲ ವಿಷಯ ಪರಿಶೀಲಿಸಿ ವೇಳೆ, ಸಂಗ್ರಹದ ಗಾತ್ರ

110
00:06:37,130 --> 00:06:40,150
ಹೆಚ್ಚಿನ ಅಥವಾ ಸ್ಟಾಕ್ ಸಾಮರ್ಥ್ಯ ಸಮಾನವಾಗಿರುತ್ತದೆ ಅಲ್ಲ.

111
00:06:40,150 --> 00:06:45,810
ನೀವು ಈಗಾಗಲೇ ಪೂರ್ಣ ಸಾಮರ್ಥ್ಯದ ಮೇಲೆ ಇದ್ದರೆ, ನೀವು ಬೇರೇನೂ ಸೇರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

112
00:06:45,810 --> 00:06:51,140
ಅಲ್ಲ ನಂತರ, ನೀವು ಕೇವಲ ಸ್ಟಾಕ್ ಅಂಶ ಸೇರಿಸಲು ಹೊಂದಿವೆ.

113
00:06:51,140 --> 00:06:54,530
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಗಾತ್ರ ಹೆಚ್ಚಿಸಲು. ಆದ್ದರಿಂದ ಇದು ಬಹಳ ಸರಳ.

114
00:06:54,530 --> 00:06:57,140
ಆದ್ದರಿಂದ ನಾನು ಸಂಖ್ಯೆ 2 ಸೇರಿಸಿ.

115
00:06:57,140 --> 00:07:00,350
ನಾನು ಪಾಪ್ ಬಯಸಿದರೆ ಮತ್ತು, ಇದು ನಾನು ತೆಗೆದುಹಾಕಲು ಬಯಸುವ ಅರ್ಥ

116
00:07:00,350 --> 00:07:03,870
ಸೇರಿಸಲಾಗಿದೆ ಮತ್ತು ಅಂಶ ಮೌಲ್ಯವನ್ನು ಮರಳಲು ಕಳೆದ ಅಂಶ,

117
00:07:03,870 --> 00:07:09,180
ನಾನು ಪರಿಶೀಲಿಸಿ ಮೊದಲನೆಯದಾಗಿ ಸ್ಟಾಕ್ ಖಾಲಿ ಎಂದು.

118
00:07:09,180 --> 00:07:11,510
ಅದು ಖಾಲಿ ಇದ್ದರೆ, ನಾನು ಏನು ಮರಳಿ ಏಕೆಂದರೆ.

119
00:07:11,510 --> 00:07:14,820
ಆ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು -1 ಹಿಂದಿರುಗಿದ ನುಡಿದರು.

120
00:07:14,820 --> 00:07:18,960
ಇಲ್ಲವಾದರೆ, ನಾನು ವಿಶೇಷ ಗಾತ್ರ ಇಳಿಕೆ ಪಡೆಯಲಿದ್ದೇನೆ

121
00:07:18,960 --> 00:07:22,510
ಮತ್ತು ಸಂಖ್ಯೆಗಳನ್ನು (s.size,) ಮರಳಲು.

122
00:07:22,510 --> 00:07:27,230
ನಾನು ಗಾತ್ರ ಇಳಿಕೆ ಮತ್ತು ನಂತರ, s.size ಮರಳಲು ನೀಡಲಿಲ್ಲ?

123
00:07:27,230 --> 00:07:30,930
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ವಿಶೇಷ ಗಾತ್ರ 4 ಹೊಂದಿದೆ, ಕಾರಣ ಇದು,

124
00:07:30,930 --> 00:07:33,810
ಮತ್ತು ನಾನು ನಾಲ್ಕನೇ ಅಂಶ ಮರಳಿ ಬಯಸುವ, ಬಲ?

125
00:07:33,810 --> 00:07:36,030
ಆದರೆ ನಾಲ್ಕನೇ ಅಂಶ ಸೂಚ್ಯಂಕ ಎಂದರೇನು? ಮೂರು.

126
00:07:36,030 --> 00:07:44,510
ನಾನು ಗಾತ್ರ ರಿಂದ - 3 ಏರಲಿದೆ, ನಾನು (s.size,) s.numbers ಮರಳಬಹುದು

127
00:07:44,510 --> 00:07:48,410
ಇದು 3 ಏಕೆಂದರೆ. ಆದ್ದರಿಂದ ಕೇವಲ ಸೂಚ್ಯಂಕ.

128
00:07:48,410 --> 00:07:50,380
>> ಈಗ ಸಾಲುಗಳನ್ನು. ಸಾಲುಗಳನ್ನು ಅತ್ಯಧಿಕವಾಗಿ ಒಂದೇ ಆಗಿವೆ.

129
00:07:50,380 --> 00:07:54,950
ವ್ಯತ್ಯಾಸವೆಂದರೆ, ಬದಲಿಗೆ ಕಳೆದ ರಲ್ಲಿ ಹೊಂದುವ, ಮೊದಲ ಔಟ್

130
00:07:54,950 --> 00:07:57,480
ನೀವು ಮೊದಲು, ಮೊದಲ ಹೊಂದಿವೆ.

131
00:07:57,480 --> 00:07:59,460
ನೀವು ಸಂಗೀತ ಹೋಗಲು ನಿರೀಕ್ಷಿಸುತ್ತಿವೆ ಬಹುಶಃ ವೇಳೆ,

132
00:07:59,460 --> 00:08:04,260
ನೀವು ಬದಲಿಗೆ ಕ್ಯೂ ಸ್ಟಾಕ್ ವೇಳೆ ನೀವು ಸಂತೋಷವಾಗಿರುವಿರಿ ಎಂದು.

133
00:08:04,260 --> 00:08:07,730
ಬರಲು ಕಳೆದ ವ್ಯಕ್ತಿಯಾಗಿ ಸಂಗೀತ ಪ್ರವೇಶಿಸಿದ ಮೊದಲ ವ್ಯಕ್ತಿ ಎಂದು.

134
00:08:07,730 --> 00:08:09,760
ನೀವು ಬಹುಶಃ ಸಂತೋಷವಾಗಿರುವಿರಿ ಎಂದು.

135
00:08:09,760 --> 00:08:15,020
ಸರದಿಯಲ್ಲಿ, ಪಡೆಯಲು ಮೊದಲ ವ್ಯಕ್ತಿ ಸಹ ಹೊರಬರಲು ಮೊದಲ ವ್ಯಕ್ತಿ.

136
00:08:15,020 --> 00:08:18,720
ಆದ್ದರಿಂದ ಒಂದು ಕ್ಯೂ ವ್ಯಾಖ್ಯಾನ, ಶ್ರೇಣಿಯಲ್ಲಿನ ಗಾತ್ರ ಹೊಂದಿರುವ ಅಲ್ಲದೆ,

137
00:08:18,720 --> 00:08:23,360
ನೀವು ಸ್ಟಾಕ್ ಮುಖ್ಯಸ್ಥ ಇಂಡೆಕ್ಸ್ ಇದು ತಲೆ, ಹೊಂದಿರಬೇಕು.

138
00:08:23,360 --> 00:08:29,000
ಇದೀಗ ಮೊದಲ ಅಂಶ ಆದ್ದರಿಂದ.

139
00:08:29,000 --> 00:08:32,710
ಸರತಿಯಲ್ಲದ ರಾಶಿಯನ್ನು ಪ್ರೇರಣೆಯ ಅದೇ ವಿಷಯ.

140
00:08:32,710 --> 00:08:34,980
ನೀವು ಬಹಳ ನಿಷ್ಕಪಟ, ನೀವು ಕೇವಲ ಹೇಳುತ್ತಿದ್ದರು,

141
00:08:34,980 --> 00:08:39,289
ನಾನು ತಳ್ಳುವ ಮಾಡಿದರು ಹಾಗೂ, ನಾನು ನಿಖರವಾಗಿ ಒಂದೇ ಮಾಡಬಹುದು.

142
00:08:39,289 --> 00:08:44,030
ಇದು ಸಾಮರ್ಥ್ಯ ಮೀರಿ ಅಲ್ಲ ನಾನು ಪರಿಶೀಲಿಸಬಹುದು.

143
00:08:44,030 --> 00:08:48,760
ಇದು ಇದ್ದರೆ, ನಾನು ಇಲ್ಲದಿದ್ದರೆ ನಾನು ಹೊಸ ಮೌಲ್ಯದ ರಫ್ತು ಮಾಡಬಹುದು, ಸುಳ್ಳು ಹಿಂತಿರುಗಿ

144
00:08:48,760 --> 00:08:50,630
ತದನಂತರ ಗಾತ್ರ ಹೆಚ್ಚಿಸಲು.

145
00:08:50,630 --> 00:08:52,750
ಆದರೆ ಏಕೆ ಈ ತಪ್ಪು?

146
00:08:52,750 --> 00:08:55,010
ನ ಈ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ.

147
00:08:55,010 --> 00:08:57,020
ನಾನು ವಿಷಯವನ್ನು ಒಂದು ಗುಂಪೇ ಎನ್ಕ್ಯೂ ಪ್ರಯತ್ನಿಸುವಾಗ ನಾನು,

148
00:08:57,020 --> 00:08:58,390
ಮತ್ತು ನಂತರ ನಾನು dequeue ಮತ್ತು ಎನ್ಕ್ಯೂ ಪಡೆಯಲಿದ್ದೇನೆ.

149
00:08:58,390 --> 00:09:00,550
ಇಲ್ಲ ಆಜ್ಞೆಗಳನ್ನು ಸಂಗತಿಯೇ, ಆದರೆ ಇದು ಬಹಳ ಸರಳ.

150
00:09:00,550 --> 00:09:04,790
ನಾನು 5 ಎನ್ಕ್ಯೂ, ಆದ್ದರಿಂದ 5 ಸೇರಿಸಲು ನೀನು ತದನಂತರ 7, ಬಾಗುತ್ತೇನೆ

151
00:09:04,790 --> 00:09:09,310
1, 4, 6, ಮತ್ತು ನಂತರ ನಾನು ಏನನ್ನಾದರೂ dequeue ಬಯಸುವ,

152
00:09:09,310 --> 00:09:12,000
ಇದು ನಾನು ಮೊದಲ ಅಂಶ ತೆಗೆದುಹಾಕಲು ಪಡೆಯಲಿದ್ದೇನೆ ಅರ್ಥ.

153
00:09:12,000 --> 00:09:14,640
ಆದ್ದರಿಂದ ನಾನು, ಸಂಖ್ಯೆ 3 ತೆಗೆದುಹಾಕಲು ಪಡೆಯಲಿದ್ದೇನೆ?

154
00:09:14,640 --> 00:09:17,320
ಮೊದಲ ಅಂಶ. ಸರಿ.

155
00:09:17,320 --> 00:09:21,450
ನಾನು ಬೇರೆ ಏನಾದರೂ ಎನ್ಕ್ಯೂ ಪ್ರಯತ್ನಿಸಿದರೆ ಈಗ ಯಾವ ಸಂಭವಿಸಿ ಹೋಗಿ?

156
00:09:21,450 --> 00:09:24,290
ನನ್ನ ಅನುಷ್ಠಾನ ಪ್ರಕಾರ,

157
00:09:24,290 --> 00:09:31,040
ನಾನು ಸೂಚ್ಯಂಕ q.size ಮುಂದಿನ ಸಂಖ್ಯೆ ಹಾಕಲು ಹೋಗಿ.

158
00:09:31,040 --> 00:09:35,140
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಗಾತ್ರ 8,

159
00:09:35,140 --> 00:09:38,640
ಆದ್ದರಿಂದ ಸೂಚ್ಯಂಕ 8 ಕೊನೆಯ ಸ್ಥಾನ ಇಲ್ಲಿಯೇ ಇರುತ್ತದೆ.

160
00:09:38,640 --> 00:09:43,900
ನಾನು ಇಲ್ಲಿಯೇ 1 ಎನ್ಕ್ಯೂ ಪ್ರಯತ್ನಿಸಿದರೆ, ನಾನು ಕಳೆದ ಸ್ಥಾನವನ್ನು ಮೇಲೆಯೆ ಎಂದು

161
00:09:43,900 --> 00:09:45,870
ಸಂಪೂರ್ಣವಾಗಿ ತಪ್ಪು ಇದು ಸಂಖ್ಯೆ 1, ಗೆ.

162
00:09:45,870 --> 00:09:49,870
ಏನು ನಾನು ಬಯಸುವ ಸುಮಾರು ಕಟ್ಟಲು ಮತ್ತು ಮೊದಲ ಸ್ಥಾನವನ್ನು ಹೋಗಿ.

163
00:09:49,870 --> 00:09:52,870
ಬಹುಶಃ ನೀವು ಚೆನ್ನಾಗಿ, ನಾನು ಪರಿಶೀಲಿಸಿ, ಹೇಳುತ್ತಿದ್ದರು

164
00:09:52,870 --> 00:09:55,600
ನಾನು ನಿಜವಾಗಿ ಏನೋ ಹಾಕಬಹುದು.

165
00:09:55,600 --> 00:09:58,560
ಅಲ್ಲ, ನಾನು ಓಹ್, ಹೊಸ ಪೂರ್ಣ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೇಳುತ್ತಾರೆ

166
00:09:58,560 --> 00:10:02,010
ವಾಸ್ತವವಾಗಿ ಸಾಮರ್ಥ್ಯ - 1, ಮತ್ತು ನೀವು ಒಂದು ಅಂಶ ಹಾಕಲು ಸಾಧ್ಯವಿಲ್ಲ.

167
00:10:02,010 --> 00:10:06,150
ಆದರೆ ಸಮಸ್ಯೆ ಏನು? ಸಮಸ್ಯೆ ಎಂದು ನಾನು ಇಲ್ಲಿ ಎಲ್ಲವೂ dequeue ವೇಳೆ

168
00:10:06,150 --> 00:10:08,240
ಮತ್ತು ನಂತರ ನಾನು ಯಾವುದೋ ಸೇರಿಸಲು ಪ್ರಯತ್ನಿಸಿ, ಇದು ಕೇವಲ ಹೇಳುತ್ತಿದ್ದರು,

169
00:10:08,240 --> 00:10:11,210
ಅಲ್ಲದೆ, ನೀವು 0 ಇದು ಪೂರ್ಣ ಸಾಮರ್ಥ್ಯವನ್ನು ನಲ್ಲಿ ಇದ್ದರು.

170
00:10:11,210 --> 00:10:13,620
ಆದ್ದರಿಂದ ನಿಮ್ಮ ಕ್ಯೂ ಹೋದ.

171
00:10:13,620 --> 00:10:16,990
ನೀವು ಸುಮಾರು ಕಟ್ಟಲು, ಮತ್ತು ಸುತ್ತಲೂ ಸುತ್ತಿಕೊಳ್ಳುವ ಒಂದು ರೀತಿಯಲ್ಲಿ

172
00:10:16,990 --> 00:10:22,040
ನೀವು ದಾರ್ಶನಿಕ ಮತ್ತು ಇತರ psets ಕಲಿತ ವ್ಯಕ್ತಿಗಳು ಮೋಡ್ ಬಳಸಿ ಎಂದು.

173
00:10:22,040 --> 00:10:29,090
ನೀವು q.size + q.head ಏಕೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮನೆಯಲ್ಲಿ ಪ್ರಯತ್ನಿಸಬಹುದು

174
00:10:29,090 --> 00:10:31,080
ಮಾಡ್ ಸಾಮರ್ಥ್ಯ, ಆದರೆ ನೀವು ಇಲ್ಲಿಯೇ ಪರಿಶೀಲಿಸಿ ವೇಳೆ,

175
00:10:31,080 --> 00:10:34,760
ನಾವು ಕೆಲಸ ನೋಡಬಹುದು.

176
00:10:34,760 --> 00:10:37,760
ಆದ್ದರಿಂದ ಕೊನೆಯ ಉದಾಹರಣೆಯಲ್ಲಿ, 8 q.size ಆಗಿತ್ತು

177
00:10:37,760 --> 00:10:47,590
ಇಲ್ಲಿ ರಚನೆಯ ಈ ಸ್ಥಾನವನ್ನು ಏಕೆಂದರೆ ಮತ್ತು ತಲೆ, 1 ಆಗಿತ್ತು.

178
00:10:47,590 --> 00:10:51,970
ಆದ್ದರಿಂದ + 1 8, 9 ಇರುತ್ತದೆ. ಮಾಡ್ ಸಾಮರ್ಥ್ಯ 9 0 ಆಗಿರುತ್ತದೆ.

179
00:10:51,970 --> 00:10:56,640
ಇದು ಸೂಚ್ಯಂಕ 0 ಹೋಗುತ್ತಿದ್ದೆ. ನಾವು ಸರಿಯಾದ ಸ್ಥಾನದಲ್ಲಿ ಇರುವಿರಿ.

180
00:10:56,640 --> 00:10:59,750
ತದನಂತರ ಮನೆಯಲ್ಲಿ ಕ್ಯೂ ಪ್ರಯತ್ನಿಸಿ.

181
00:10:59,750 --> 00:11:04,950
ಕೆಲವು ಪ್ರಮುಖ ವಿಷಯಗಳನ್ನು: ಒಂದು ಸ್ಟಾಕ್ ಮತ್ತು ಕ್ಯೂ ನಡುವಿನ ವ್ಯತ್ಯಾಸ ತಿಳಿಯಲು ಪ್ರಯತ್ನಿಸಿ.

182
00:11:04,950 --> 00:11:11,620
ಮನೆಯಲ್ಲಿ, ಎನ್ಕ್ಯೂ, dequeue, ಪುಶ್ ಮತ್ತು ಪಾಪ್ ಅನುಷ್ಠಾನಕ್ಕೆ ಅತ್ಯಂತ ಪರಿಚಿತ ಪಡೆಯಲು ಪ್ರಯತ್ನಿಸಿ.

183
00:11:11,620 --> 00:11:16,560
ನೀವು ಅವರನ್ನು ಪ್ರತಿ ಬಳಸಬಹುದು ಆಗ ಅರ್ಥ.

184
00:11:16,560 --> 00:11:22,830
>> ಆದ್ದರಿಂದ Pokemons ಕನಸುಗಳಿವೆ 10 ಸೆಕೆಂಡುಗಳ ಕಾಲ ವಿಶ್ರಾಂತಿ ಅವಕಾಶ.

185
00:11:22,830 --> 00:11:26,080
ಮತ್ತು ಈಗ ಮತ್ತೆ ಡೇಟಾ ರಚನೆಗಳು ಹೋಗಿ ಅವಕಾಶ.

186
00:11:26,080 --> 00:11:29,770
ಕೋಷ್ಟಕಗಳು ಹ್ಯಾಶ್. ಬಹಳಷ್ಟು ಜನರು ಹ್ಯಾಶ್ ಕೋಷ್ಟಕಗಳು ಹೆದರುತ್ತಿದ್ದರು.

187
00:11:29,770 --> 00:11:33,650
ಸಮಸ್ಯೆ 6 ಸೆಟ್ ನಲ್ಲಿ, ಪದಪರೀಕ್ಷಕ.

188
00:11:33,650 --> 00:11:35,980
ಹ್ಯಾಶ್ ಕೋಷ್ಟಕಗಳು ಮತ್ತು ಪ್ರಯತ್ನಗಳ, ಜನರು ಬಹಳಷ್ಟು ಅವುಗಳನ್ನು ದಿಗಿಲುಗೊಂಡ ಪಡೆಯಿರಿ.

189
00:11:35,980 --> 00:11:38,540
ಅವರು ತಿಳಿಯಲು ಆದ್ದರಿಂದ ಹಾರ್ಡ್ ನನಗನ್ನಿಸುತ್ತದೆ. ಹೌದು?

190
00:11:38,540 --> 00:11:41,490
[ರಾಬ್ ಬೌಡೆನ್] ಪ್ರಾಬ್ಲಂ 5 ಸೆಟ್. >> ಸಮಸ್ಯೆ ಹೌದು, 5 ಸೆಟ್. ಧನ್ಯವಾದಗಳು ರಾಬ್.

191
00:11:41,490 --> 00:11:43,370
ಹೌದು. ಆರು ಹಫ್ ಎನ್ 'ಪಫ್, ಹೌದು ಆಗಿತ್ತು.

192
00:11:43,370 --> 00:11:49,340
ಪ್ರಾಬ್ಲಂ ಪದಪರೀಕ್ಷಕ ಮಾಡಲಾಯಿತು 5 ಸೆಟ್, ಮತ್ತು ನೀವು ಒಂದು ಹ್ಯಾಷ್ ಟೇಬಲ್ ಅಥವಾ ಒಂದು ಪ್ರಯತ್ನಿಸಿ ಎರಡೂ ಬಳಸಲು ಹೊಂದಿತ್ತು.

193
00:11:49,340 --> 00:11:55,360
ಬಹಳಷ್ಟು ಜನರು ಅವರು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸೂಪರ್ ಹಾರ್ಡ್ ಎಂದು ಭಾವಿಸಲಾಗಿದೆ, ಆದರೆ ವಾಸ್ತವವಾಗಿ ಬಹಳ ಸರಳ ಆರ್.

194
00:11:55,360 --> 00:12:01,290
ಒಂದು ಹ್ಯಾಷ್ ಟೇಬಲ್ ಮೂಲತಃ, ಏನು? ಹ್ಯಾಷ್ ಟೇಬಲ್ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿದೆ.

195
00:12:01,290 --> 00:12:06,730
ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮತ್ತು ಒಂದು ಹ್ಯಾಷ್ ಟೇಬಲ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸವೆಂದರೆ

196
00:12:06,730 --> 00:12:09,730
ಹ್ಯಾಷ್ ಟೇಬಲ್ ನಲ್ಲಿ ನೀವು ಒಂದು ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಎಂದು ಏನೋ ಹೊಂದಿರುತ್ತವೆ.

197
00:12:09,730 --> 00:12:12,080
ಒಂದು ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಎಂದರೇನು?

198
00:12:12,080 --> 00:12:13,970
ನೀವು ಹುಡುಗರಿಗೆ ಇಲ್ಲಿ ಓದಬಹುದು ವೇಳೆ ನನಗೆ ಗೊತ್ತಿಲ್ಲ.

199
00:12:13,970 --> 00:12:16,090
ಈ ಒಂದು ಹ್ಯಾಶ್ ಕೋಷ್ಟಕದ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.

200
00:12:16,090 --> 00:12:19,220
ಆದ್ದರಿಂದ ನೀವು 31 ಅಂಶಗಳೊಂದಿಗೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರುವ ನೋಡಬಹುದು.

201
00:12:19,220 --> 00:12:22,440
ಮತ್ತು ನಾವು ಒಂದು ಹ್ಯಾಷ್ ಟೇಬಲ್ ಮಾಡಲು ಒಂದು ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಇದೆ

202
00:12:22,440 --> 00:12:26,660
ಒಂದು ಪ್ರಮುಖ ಭಾಷಾಂತರಿಸಲು ಹೋಗುತ್ತದೆ, ಪ್ರತಿ ಸೂಚ್ಯಂಕ ಇಂಟ್.

203
00:12:26,660 --> 00:12:31,740
, ಉದಾಹರಣೆಗೆ, ನಾನು ಬಿ ಹ್ಯಾರಿಸನ್ ಆಯ್ಕೆ ಬಯಸಿದರೆ,

204
00:12:31,740 --> 00:12:34,190
ನನ್ನ ಹ್ಯಾಶ್ ಕ್ರಿಯೆಗಳನ್ನು ಬಿ ಹ್ಯಾರಿಸನ್ ಹಾಕುತ್ತಾನೆ,

205
00:12:34,190 --> 00:12:36,960
ಮತ್ತು ಹ್ಯಾಶ್ ಕ್ರಿಯೆ 24 ಹಿಂದಿರುಗುತ್ತಿದ್ದವು.

206
00:12:36,960 --> 00:12:40,930
ಆದ್ದರಿಂದ ನಾನು 24 ರಲ್ಲಿ ಬಿ ಹ್ಯಾರಿಸನ್ ಸಂಗ್ರಹಿಸಲು ಬಯಸುವ ತಿಳಿದಿದೆ.

207
00:12:40,930 --> 00:12:46,580
ಇದರಿಂದ ಕೇವಲ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರುವ ಮತ್ತು ಒಂದು ಹ್ಯಾಷ್ ಟೇಬಲ್ ಹೊಂದಿರುವ ನಡುವೆ ವ್ಯತ್ಯಾಸವನ್ನು ಇಲ್ಲಿದೆ.

208
00:12:46,580 --> 00:12:48,740
ಹ್ಯಾಷ್ ಟೇಬಲ್ ನಲ್ಲಿ ನೀವು ಹೇಳಲು ಹೋಗುತ್ತದೆ ಒಂದು ಫಂಕ್ಷನ್ ಮಾಡುತ್ತೇವೆ

209
00:12:48,740 --> 00:12:54,740
ಅಲ್ಲಿ ನೀವು ಸಂಗ್ರಹಿಸಲು ಬಯಸುವ ದತ್ತಾಂಶವನ್ನು ಶೇಖರಿಸಿಡಲು.

210
00:12:54,740 --> 00:12:57,040
ಹ್ಯಾಶ್ ಕ್ರಿಯೆ, ನೀವು ಒಂದು ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ನೋಡಲು ಬಯಸುವ

211
00:12:57,040 --> 00:13:00,600
ಎಂದು ಕಂಡುಹಿಡಿಯುವಿಕೆ ಹಾಗೂ ಚೆನ್ನಾಗಿ ವಿತರಿಸಲಾಗುತ್ತದೆ.

212
00:13:00,600 --> 00:13:07,810
ನೀವು ಇಲ್ಲಿ ನೋಡಬಹುದು ಎಂದು, ನೀವು ನಾನು ಶೇಖರಿಸಿಡಲು ಬಯಸಿದ್ದರು ಎಂದು ದಶಮಾಂಶ ಬಹಳಷ್ಟು ವಾಸ್ತವವಾಗಿ 19 ಎಂದು ನೋಡಿ

213
00:13:07,810 --> 00:13:12,470
ಬದಲಿಗೆ ಎಲ್ಲಾ ಉಚಿತ ಇದರಲ್ಲಿ 31 ಮತ್ತು 30 ಮತ್ತು 29, ಬಳಸಿ.

214
00:13:12,470 --> 00:13:16,920
ಆದ್ದರಿಂದ ನಾನು ಬಳಸಿದ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಬಹಳ ಚೆನ್ನಾಗಿ ವಿತರಣೆ ಅಲ್ಲ.

215
00:13:16,920 --> 00:13:20,710
ನಾವು ಚೆನ್ನಾಗಿ ವಿತರಣೆ ಹೇಳುವುದಾದರೆ, ಇದು, ನಾವು ಬೇಕು ಎಂದರ್ಥ

216
00:13:20,710 --> 00:13:26,520
ಸ್ಥೂಲವಾಗಿ, ಕನಿಷ್ಠ 1 ಅಥವಾ ಪ್ರತಿ 2 -

217
00:13:26,520 --> 00:13:32,190
ಹಾಗೆ, ಸರಣಿಗಳ ಸೂಚ್ಯಂಕಗಳು ಪ್ರತಿಯೊಂದು 1 ಅಥವಾ 2 ಒಂದು ವ್ಯತ್ಯಾಸ.

218
00:13:32,190 --> 00:13:43,950
ನೀವು, ಸ್ಥೂಲವಾಗಿ, ಶ್ರೇಣಿಯಲ್ಲಿನ ಪ್ರತಿ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಅಂಶಗಳನ್ನು ಒಂದೇ ಸಂಖ್ಯೆಯ ಬೇಕು.

219
00:13:43,950 --> 00:13:48,600
ಮತ್ತು ಇದು, ಹ್ಯಾಷ್ ಟೇಬಲ್ ನಲ್ಲಿ ಮಾನ್ಯವಾದ ಹ್ಯಾಶ್ ಕೋಷ್ಟಕಗಳು ವೀಕ್ಷಿಸಲು ವೇಳೆ ಪರಿಶೀಲಿಸಿ ಸುಲಭ.

220
00:13:48,600 --> 00:13:51,770
>> ನಂತರ ಮರಗಳು. ಈ ಒಂದು ಮರವಾಗಿದೆ.

221
00:13:51,770 --> 00:13:56,400
ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿ ಮರಗಳು ಕಾರಣಕ್ಕೆ ತಲೆಕೆಳಗಾಗಿ ಇವೆ.

222
00:13:56,400 --> 00:14:00,150
ಆದ್ದರಿಂದ ಇಲ್ಲಿಯೇ ನೀವು ಮರದ ಬೇರಿನ ಮತ್ತು ನಂತರ ಎಲೆಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.

223
00:14:00,150 --> 00:14:05,630
ನೀವು ಪೋಷಕರು ಮತ್ತು ಮಗುವಿಗೆ ನಾಮಕರಣ ತಿಳಿಯಬೇಕಿದೆ.

224
00:14:05,630 --> 00:14:12,880
ಪ್ರತಿ ನೋಡ್ ಮೂಲ ಕೆಳಗಿರುವ ಗ್ರಂಥಿಗಳು ಅದರ ಮಕ್ಕಳು, ಹೊಂದಿದೆ.

225
00:14:12,880 --> 00:14:19,660
ಆದ್ದರಿಂದ, ಉದಾಹರಣೆಗೆ, 2, ಬಲ ಅಲ್ಲಿ 3 ಮತ್ತು ಇತರ ಮಗುವಿಗೆ ಪೋಷಕ ಏರಲಿದೆ

226
00:14:19,660 --> 00:14:25,290
3 1 ಪೋಷಕ ಮತ್ತು ಇವೆ ಎಂದು ಇತರ ಮಕ್ಕಳು ಹೋಗುವ ಸಮಯ.

227
00:14:25,290 --> 00:14:29,990
ಮತ್ತು 1 ಹೀಗೆ 3 ಮಗು ಎಂದು ಹೋಗುತ್ತದೆ.

228
00:14:29,990 --> 00:14:34,610
ನಾವು ಹೆಚ್ಚು ಆಸಕ್ತಿದಾಯಕ ಏನೋ, ಒಂದು ಬೈನರಿ ಸರ್ಚ್ ಟ್ರೀಯನ್ನು ಎಂದು

229
00:14:34,610 --> 00:14:39,040
ಇದು ಒಂದು ನೋಡ್ ಬಲ ಮೇಲೆ ಎಲ್ಲಾ ಮೌಲ್ಯಗಳನ್ನು

230
00:14:39,040 --> 00:14:41,660
ಇಲ್ಲಿಯೇ, ಬಲ ಮೇಲೆ ಹೋಗುವ - ಬಲ,

231
00:14:41,660 --> 00:14:46,780
ಮೂಲ ಅಂಶ ಹೆಚ್ಚು ಎಂದು ಹೋಗುವ.

232
00:14:46,780 --> 00:14:49,780
ಬಲ ಮೇಲೆ ಹಾಗಾಗಿ ಇಲ್ಲಿಯೇ ಸಂಖ್ಯೆ 5 ಹೊಂದಿದ್ದರೆ, ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು

233
00:14:49,780 --> 00:14:51,940
5 ಹೆಚ್ಚು ಎಂದು ಹೋಗುವ, ಮತ್ತು ಎಡ ಮೇಲೆ

234
00:14:51,940 --> 00:14:56,770
ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು 5 ಕಡಿಮೆ ಎಂದು ಹೋಗುವ.

235
00:14:56,770 --> 00:14:58,780
ಏಕೆ ಈ ಉಪಯುಕ್ತ?

236
00:14:58,780 --> 00:15:01,660
ನಾನು ಸಂಖ್ಯೆ 7 ಇಲ್ಲಿ ನೀವು ಪರಿಶೀಲಿಸಲು ಬಯಸುವ ವೇಳೆ, ಉದಾಹರಣೆಗೆ,

237
00:15:01,660 --> 00:15:05,960
ನಾನು ಮೊದಲ 5 ಹೋಗಿ ನಾನು ನೋಡಿ ಪಡೆಯಲಿದ್ದೇನೆ, 5 7 ಹೆಚ್ಚಿನ ಅಥವಾ ಕಡಿಮೆ?

238
00:15:05,960 --> 00:15:09,540
ಇದು ಹೆಚ್ಚಿನ, ಆದ್ದರಿಂದ ನಾನು ಅದನ್ನು ಮರದ ಬಲ ಮೇಲೆ ಇರಬೇಕು ವಿಶೇಷವೇನು ತಿಳಿದಿರುವ.

239
00:15:09,540 --> 00:15:13,980
ಹಾಗಾಗಿ ನೋಡಲು ಕಡಿಮೆ ವಿಷಯವನ್ನು ಹೊಂದಿಲ್ಲ.

240
00:15:13,980 --> 00:15:19,520
ಒಂದು ಬೈನರಿ ಸರ್ಚ್ ಟ್ರೀಯನ್ನು, ನೋಡ್ ಅಳವಡಿಕೆಯಲ್ಲಿ, ನಾನು, ದಶಮಾಂಶ ಹೊಂದಿರಬೇಕು ಪಡೆಯಲಿದ್ದೇನೆ

241
00:15:19,520 --> 00:15:21,750
ಆದ್ದರಿಂದ ಇಂಟ್ N; ನೀವು ಸ್ಟ್ರಿಂಗ್ ತೋರಿಸಬಹುದಿತ್ತು

242
00:15:21,750 --> 00:15:23,630
ಅಥವಾ ನೀವು ಬಯಸಿದ ಏನೂ.

243
00:15:23,630 --> 00:15:28,100
ನೀವು ಹೆಚ್ಚಿನ ಎಂಬುದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಮೇಲೆ ಎಚ್ಚರಿಕೆಯಿಂದ ಇರಬೇಕು, ಕಡಿಮೆ ಏನು.

244
00:15:28,100 --> 00:15:30,390
ಆದ್ದರಿಂದ ನೀವು ತಂತಿ ಹೊಂದಿತ್ತು, ಉದಾಹರಣೆಗೆ, ನೀವು ವ್ಯಾಖ್ಯಾನಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ

245
00:15:30,390 --> 00:15:34,690
ಬಲ ಮೇಲೆ ಎಲ್ಲಾ ವಿಷಯಗಳನ್ನು ದೊಡ್ಡ ಉದ್ದ ಮಾಡಲಿಕ್ಕೆ ಎಂದು,

246
00:15:34,690 --> 00:15:40,940
ಎಡ ಕಡಿಮೆ ಉದ್ದವನ್ನು ಹೋಗುವ, ಆದ್ದರಿಂದ ನೀವು ನಿಜವಾಗಿಯೂ ಅಪ್.

247
00:15:40,940 --> 00:15:44,930
>> ನಾನು ಹೇಗೆ BST ಹೇಗೆ ಬಳಸಿಕೊಂಡು?

248
00:15:44,930 --> 00:15:47,840
ನಾವು ಮಾಡುತ್ತೇವೆ ಮೊದಲನೆಯದಾಗಿ ಮೂಲ ಶೂನ್ಯ ವೇಳೆ ಪರಿಶೀಲಿಸಿ ಆಗಿದೆ.

249
00:15:47,840 --> 00:15:50,920
ಇದು ಶೂನ್ಯ ಆಗಿದ್ದರೆ, ಅದು ವಿಷಯ ಇಲ್ಲ ಎಂದರ್ಥ

250
00:15:50,920 --> 00:15:53,330
ನೀವು ಸಹ ಒಂದು ಮರ, ಬಲ ಹೊಂದಿಲ್ಲ ಏಕೆಂದರೆ?

251
00:15:53,330 --> 00:15:55,790
ಹಾಗಾಗಿ ತಪ್ಪು ಹಿಂತಿರುಗಿ.

252
00:15:55,790 --> 00:15:58,740
ಇಲ್ಲವಾದರೆ, ನಾನು ಸಂಖ್ಯೆ ಹೆಚ್ಚಿನ ವೇಳೆ ಪರಿಶೀಲಿಸಿ ಪಡೆಯಲಿದ್ದೇನೆ

253
00:15:58,740 --> 00:16:01,720
ಮೂಲ ಮೌಲ್ಯವನ್ನು ಹೆಚ್ಚು.

254
00:16:01,720 --> 00:16:04,250
ನಾನು ಮೇಲೆ ಅಂಶ ಹುಡುಕಲು ಪ್ರಯತ್ನಿಸಿ ಪಡೆಯಲಿದ್ದೇನೆ

255
00:16:04,250 --> 00:16:08,590
ಮರದ.

256
00:16:08,590 --> 00:16:11,310
ನೀವು ನಾನು ಇಲ್ಲಿ ಪುನರಾವರ್ತನ ಬಳಸಿಕೊಂಡು ನಾನು ನೋಡಿ.

257
00:16:11,310 --> 00:16:14,150
ಇದು ಕಡಿಮೆ ಇದ್ದರೆ ನಂತರ, ನಾನು ಎಡ ನೋಡಲು ಪಡೆಯಲಿದ್ದೇನೆ.

258
00:16:14,150 --> 00:16:18,330
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಇಲ್ಲದಿದ್ದರೆ, ಇದು ಹೆಚ್ಚಿನ ಕಡಿಮೆ ಅಥವಾ ಅಲ್ಲ ವೇಳೆ,

259
00:16:18,330 --> 00:16:20,660
ಇದು ಮೌಲ್ಯ ಸ್ವತಃ ಎಂದರ್ಥ.

260
00:16:20,660 --> 00:16:23,010
ಆದ್ದರಿಂದ ನಾನು ನಿಜವಾದ ಹಿಂತಿರುಗಿ.

261
00:16:23,010 --> 00:16:26,360
ನೀವು ನಾನು ವೇಳೆ, ವೇಳೆ, ವೇಳೆ ಬಳಸಲಾಗುತ್ತದೆ ಇಲ್ಲಿ ನೋಡಬಹುದು.

262
00:16:26,360 --> 00:16:30,820
ಮತ್ತು ನೆನಪಿಡಿ ರಸಪ್ರಶ್ನೆ 0, ನಾವು, ವೇಳೆ, ವೇಳೆ ಎಂದು ಸಮಸ್ಯೆ

263
00:16:30,820 --> 00:16:32,780
ಮತ್ತು ನೀವು ಅದಕ್ಷ ಹೇಗೆ ಭಾವಿಸಲಾಗಿತ್ತು,

264
00:16:32,780 --> 00:16:35,180
ಮತ್ತು ಅದಕ್ಷ ನೀವು ಬಳಸಿದ ಆಗಿತ್ತು.

265
00:16:35,180 --> 00:16:39,060
ನೀವು ಬೇರೆ, ಬೇರೆ ವೇಳೆ, ವೇಳೆ ಬಳಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಬೇರೆ ಮಾಡಬೇಕು.

266
00:16:39,060 --> 00:16:44,240
ವೇಳೆ ಮತ್ತು ಬೇರೆ ವೇಳೆ ಮತ್ತು ಬೇರೆ ಇಲ್ಲಿ ಆದ್ದರಿಂದ, ನಾನು ಬೇರೆ ಬಳಸಬೇಕು?

267
00:16:44,240 --> 00:16:46,200
ಡಸ್ ಯಾರಾದರೂ - ಹೌದು?

268
00:16:46,200 --> 00:16:51,140
[ವಿದ್ಯಾರ್ಥಿ ಮಾತನಾಡುವ, ಕೇಳಿಸುವುದಿಲ್ಲ]

269
00:16:51,140 --> 00:16:53,480
ಆ ಪರಿಪೂರ್ಣ ಇಲ್ಲಿದೆ. ಆದ್ದರಿಂದ ಅವರು, ಇದು ವಿಷಯವಲ್ಲ ಎಂದು ಹೇಳುವ

270
00:16:53,480 --> 00:16:55,930
ಕೇವಲ ನಾವು ಮೊದಲು ಎಂದು ಅದಕ್ಷ

271
00:16:55,930 --> 00:16:59,550
ಎಂದು, ಕೆಲವು ಸ್ಥಿತಿಯನ್ನು ತೃಪ್ತಿ ಬಹುಶಃ ವೇಳೆ, ಏಕೆಂದರೆ

272
00:16:59,550 --> 00:17:03,570
ಆದ್ದರಿಂದ ಕ್ರಿಯಾಶೀಲ ಪ್ರದರ್ಶಿಸಿದರು ಆದರೆ ನಂತರ ನೀವು ಇತರ ಪರಿಸ್ಥಿತಿಗಳು ಎಲ್ಲಾ ಪರಿಶೀಲಿಸಿ ಹೊರಟಿದ್ದ.

273
00:17:03,570 --> 00:17:06,319
ಆದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ಈಗಿನಿಂದಲೇ ಮರಳಿದರು, ಆದ್ದರಿಂದ ಇದು ವಿಷಯವಲ್ಲ.

274
00:17:06,319 --> 00:17:09,220
ಆದ್ದರಿಂದ ನೀವು ಬೇರೆ ಬಳಸಲು ಇಲ್ಲ.

275
00:17:09,220 --> 00:17:11,740
>> ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನ ಪ್ರಯತ್ನಗಳಲ್ಲಿ ಬಗ್ಗೆ ಮಾತನಾಡೋಣ,

276
00:17:11,740 --> 00:17:13,800
ಇದು ಪ್ರತಿಯೊಬ್ಬರ ಮೆಚ್ಚಿನ ಆಗಿದೆ.

277
00:17:13,800 --> 00:17:15,980
ಪ್ರಯತ್ನಿಸಿ ಸಾಲುಗಳು ಮರವಾಗಿದೆ.

278
00:17:15,980 --> 00:17:20,369
ಇದು ಮೌಲ್ಯಗಳನ್ನು ಹುಡುಕುವ ಅತ್ಯಂತ ವೇಗವಾಗಿ, ಆದರೆ ಮೆಮೊರಿ ಬಹಳಷ್ಟು ಬಳಸುತ್ತದೆ.

279
00:17:20,369 --> 00:17:22,530
ಮತ್ತು ಪದಗಳನ್ನು ಫಿಲ್ಟರ್ ಸಾಮಾನ್ಯವಾಗಿ, ಆದ್ದರಿಂದ ನೀವು

280
00:17:22,530 --> 00:17:27,920
ನಿಮ್ಮ ಫೋನ್ ಫೋನ್ ಪುಸ್ತಕ, ಉದಾಹರಣೆಗೆ, ನನಗೆ ಗೊತ್ತಿಲ್ಲ, ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಯಸುತ್ತೀರಿ

281
00:17:27,920 --> 00:17:30,440
ಮತ್ತು ನೀವು ಬಿ ಟೈಪ್ ಮಾಡಲು ಬಯಸುವ

282
00:17:30,440 --> 00:17:32,510
ಮತ್ತು ಕೇವಲ ಬಿ ಜನರ ಹೆಸರುಗಳು

283
00:17:32,510 --> 00:17:37,960
ಇದು ಉದಾಹರಣೆಗೆ, ಒಂದು ಪ್ರಯತ್ನಿಸಿ ಬಳಸಿಕೊಂಡು ಕಾರ್ಯಗತ ಬಹಳ ಸುಲಭ.

284
00:17:37,960 --> 00:17:39,820
ನೀವು ಪ್ರಯತ್ನಿಸಿ ಒಂದು ನೋಡ್ ವ್ಯಾಖ್ಯಾನಿಸಲು ಇಲ್ಲ?

285
00:17:39,820 --> 00:17:43,910
ನೀವು is_word ಏರಲಿದೆ ಎಂದು ಒಂದು bool ಹೊಂದಿರಬೇಕು.

286
00:17:43,910 --> 00:17:48,660
ಆ, ಎಂದು ನೋಡ್ ಮೊದಲು ಎಲ್ಲಾ ಪಾತ್ರಗಳು ಬಳಸಿ ಎಂದು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ

287
00:17:48,660 --> 00:17:51,920
ನೀವು ಒಂದು ಪದ ರೂಪಿಸಲು ಸಾಧ್ಯವಾಯಿತು,

288
00:17:51,920 --> 00:17:57,230
ತದನಂತರ ನೀವು ಗ್ರಂಥಿಗಳು ರೀತಿಯು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ.

289
00:17:57,230 --> 00:18:03,120
ನೀವು ನಾವು ಪೇರೆಂಟ್ ನೋಡ್ಗಳನ್ನು ರಚನೆಯ, ಆದ್ದರಿಂದ ನೋಡ್ * ಸರಣಿ ಎಂದು ನೋಡಬಹುದು? ಹೌದು?

290
00:18:03,120 --> 00:18:06,050
ಇದರಿಂದ ಆ ಕೆಲಸ ಹೇಗೆ ನೋಡೋಣ. ಕಾಗುಣಿತ ಚೆಕ್,

291
00:18:06,050 --> 00:18:08,230
ನಾವು 27 ಅಂಶಗಳ ಒಂದು ಸರಣಿ,

292
00:18:08,230 --> 00:18:12,150
ನಾವು ಎಲ್ಲಾ ಅಕ್ಷರಗಳನ್ನು ಪ್ಲಸ್ ಅಪಾಸ್ಟ್ರಫಿ ಏಕೆಂದರೆ.

293
00:18:12,150 --> 00:18:17,800
ನಾನು ಮಂಡಳಿಯಲ್ಲಿ ಬರೆಯಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಬಯಸುವ ಏಕೆಂದರೆ ಇಲ್ಲಿ ಮೊದಲು ನಾನು 2 ಬಳಸಲು ಪಡೆಯಲಿದ್ದೇನೆ.

294
00:18:17,800 --> 00:18:20,230
ಸರಿ. ಆದ್ದರಿಂದ ಈ ಒಂದು ಪ್ರಯತ್ನಿಸಿ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.

295
00:18:20,230 --> 00:18:25,600
ನಾನು ಮೊದಲ ನೋಡ್ ವ್ಯಾಖ್ಯಾನಿಸಲು, ನಾನು 2 ಅಂಶಗಳ ಒಂದು ಸರಣಿ ಹೊಂದಿರುತ್ತದೆ

296
00:18:25,600 --> 00:18:29,290
ಶೂನ್ಯ 2 ಪಾಯಿಂಟರ್ಸ್, ಆದ್ದರಿಂದ ನಾನು 'ಎ' ಮತ್ತು 'ಬಿ' ಪುಟ್.

297
00:18:29,290 --> 00:18:32,430
ನಾನು is_word ಹೇಳುತ್ತದೆ ಒಂದು bool ಹೊಂದಿವೆ ಪಡೆಯಲಿದ್ದೇನೆ.

298
00:18:32,430 --> 00:18:34,420
ಇದು ಮೊದಲ ಒಂದು ಸುಳ್ಳು ಎಂದು ವಿಶೇಷವೇನು,

299
00:18:34,420 --> 00:18:37,370
ಕೇವಲ, ಏಕೆಂದರೆ ಮೊದಲು ನೀವು ಯಾವುದೇ ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿಲ್ಲ.

300
00:18:37,370 --> 00:18:40,900
ಆದ್ದರಿಂದ ಖಾಲಿ ಪದ ಒಂದು ಪದ ಅಲ್ಲ. ಆದ್ದರಿಂದ ತಪ್ಪು.

301
00:18:40,900 --> 00:18:46,320
ನಾನು ಈ ನಿಘಂಟು 'ಒಂದು' ಸೇರಿಸಲು ಬಯಸಿದರೆ, ನಾನು ಏನನ್ನು ಎಂದು?

302
00:18:46,320 --> 00:18:49,760
ನಾನು 'ಒಂದು' ಹೊಸ ನೋಡ್ malloc ಹೊಂದಿರುತ್ತದೆ,

303
00:18:49,760 --> 00:18:54,630
ತದನಂತರ ನಿಜವಾದ ತನ್ನ ಪದ ಸೇರಿಸಿ.

304
00:18:54,630 --> 00:19:00,180
ಆದ್ದರಿಂದ ಕೇವಲ 'ಒಂದು' ನಿಜವಾದ ಏರಲಿದೆ ನಂತರ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಅರ್ಥ?

305
00:19:00,180 --> 00:19:04,120
ನಾನು 'ಬಾ' ಸೇರಿಸಲು ಬಯಸಿದರೆ ನಂತರ, ನಾನು 'ಬಿ' ಗೆ malloc 1 ಮಾಡಬೇಕಾಗಬಹುದು,

306
00:19:04,120 --> 00:19:07,550
ತದನಂತರ ನಾನು ಸುಳ್ಳು ಬೂಲಿಯನ್ ಸ್ಥಾಪಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ

307
00:19:07,550 --> 00:19:10,160
ಸ್ವತಃ 'ಬಿ' ಒಂದು ಪದ ಅಲ್ಲ ಏಕೆಂದರೆ.

308
00:19:10,160 --> 00:19:13,010
ನಂತರ ನಾನು ಮತ್ತೊಂದು 'ಒಂದು' ಒಂದು, ಆದ್ದರಿಂದ 'ಬಾ' malloc ಪಡೆಯಲಿದ್ದೇನೆ

309
00:19:13,010 --> 00:19:16,290
ಮತ್ತು ನಂತರ ನಾನು ನಿಜವಾದ ವರ್ಡ್ ಸ್ಥಾಪಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ.

310
00:19:16,290 --> 00:19:18,950
'ಬಾ' ಒಂದು ಪದ ಕಾರಣ.

311
00:19:18,950 --> 00:19:21,910
ನಾನು ನೋಡಲು ಬಯಸಿದರೆ ತದನಂತರ 'ಬಿ', ಈ ನಿಘಂಟಿನಲ್ಲಿ ವೇಳೆ

312
00:19:21,910 --> 00:19:26,730
ನಾನು ಮೊದಲ ಒಂದು, 'ಬಿ' ಹೋಗಿ. ನಾನು ಕೆಳಗೆ ಹೋಗಿ, ಮತ್ತು ನಾನು ಪದ ನೋಡಲು ಮತ್ತು ಅದು ತಪ್ಪು ಹೇಳುತ್ತಾರೆ.

313
00:19:26,730 --> 00:19:30,110
ಆದ್ದರಿಂದ ಒಂದು ಪದ ಅಲ್ಲ. ನಾನು 'ಬಾ' ಪರಿಶೀಲಿಸಿ ಬಯಸಿದರೆ,

314
00:19:30,110 --> 00:19:38,010
ನಾನು ಮೊದಲ ಒಂದು, 'ಬಿ' ಗೆ ಹೋಗಿ, ನಂತರ 'ಒಂದು' ಹೋಗಿ, ಮತ್ತು ನಾನು ನಿಜವಾದ ನೋಡಿ, ಆದ್ದರಿಂದ ಒಂದು ಪದ. ಅರ್ಥ?

315
00:19:38,010 --> 00:19:41,950
ಬಹಳಷ್ಟು ಜನರು ಪ್ರಯತ್ನಗಳ ಮೂಲಕ ತಪ್ಪಾಗಿ. ಯಾವುದೇ?

316
00:19:41,950 --> 00:19:44,740
>> ಅಂತಿಮವಾಗಿ, ಹಫ್ಮನ್ ಕೋಡಿಂಗ್. ಹಫ್ಮನ್ ಕೋಡಿಂಗ್ ಬಹಳ ಸಹಾಯಕವಾಗಿದೆ

317
00:19:44,740 --> 00:19:47,550
ಮೆಮೊರಿ ಉಳಿಸಲು ಮತ್ತು ಪಠ್ಯ ಕಡತಗಳನ್ನು ಸಂಕುಚಿತ,

318
00:19:47,550 --> 00:19:52,270
ಕೇವಲ ನೀವು ಉದಾಹರಣೆಗೆ, 'ಎ' ಮತ್ತು 'ಇ' ಬಳಸಲು ಬಾರಿ ಸಾಕಷ್ಟು,

319
00:19:52,270 --> 00:19:57,710
ನೀವು ಹುಡುಗರಿಗೆ ಹೆಚ್ಚು 'ಕ್ಯೂ' ಅಥವಾ 'Z' ಬಳಸುತ್ತಿದ್ದರೆ ನಿಮ್ಮ ದಾಖಲೆಗಳನ್ನು, ಆದರೆ ನನಗೆ ಗೊತ್ತಿಲ್ಲ.

320
00:19:57,710 --> 00:20:02,040
ಪ್ರತಿಯೊಂದು ಪಾತ್ರದ ಕೇವಲ 1 ಬೈಟ್ ಹೊಂದಿರುವ,

321
00:20:02,040 --> 00:20:08,520
ಪ್ರತಿಯೊಂದು - ನಾವು ASCII ಕೋಷ್ಟಕದಲ್ಲಿ ಹೊಂದಿರುವ 256 ಪಾತ್ರಗಳು ಬಹಳ ಸೂಕ್ತ ಅಲ್ಲ,

322
00:20:08,520 --> 00:20:11,410
ನೀವು ಹೆಚ್ಚು ಬಳಸುವ ಕೆಲವು ಪಾತ್ರಗಳು ಇವೆ ಕಾರಣ

323
00:20:11,410 --> 00:20:15,180
ಆದ್ದರಿಂದ ನೀವು ಬಹುಶಃ ಆ ಕಡಿಮೆ ಮೆಮೊರಿ ಬಳಸಬೇಕು.

324
00:20:15,180 --> 00:20:17,560
ನಾನು ಹೇಗೆ ಹಫ್ಮನ್ ಕೋಡಿಂಗ್ ಬಳಸುವುದು?

325
00:20:17,560 --> 00:20:20,010
ನಾವು ಹಫ್ಮನ್ ಮರದ ಮಾಡಬೇಕು.

326
00:20:20,010 --> 00:20:23,370
 ಹಫ್ಮನ್ ಮರದ ಗ್ರಂಥಿಗಳು ಹೊಂದಿದೆ

327
00:20:23,370 --> 00:20:27,760
ಪತ್ರ, 'ಸಿ', 'ಬಿ', 'ಒಂದು', ಹಾಗೆ ಹೋಗುತ್ತದೆ ಸಂಕೇತವಾಗಿ ಎಂದು,

328
00:20:27,760 --> 00:20:32,990
ನೀವು ಏನೇ ಅಕ್ಷರದ, ಪದದ ಪಠ್ಯ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಆವರ್ತನ ಒಂದು ಆವರ್ತನ,

329
00:20:32,990 --> 00:20:36,280
ನೀವು, ಫಾರ್ ಹಫ್ಮನ್ ಮರದ ಸೃಷ್ಟಿಸುತ್ತಿದ್ದಾರೆ ಎಂದು

330
00:20:36,280 --> 00:20:41,800
ತದನಂತರ ಹಫ್ಮನ್ ಮರದ ಎಡ ತೋರಿಸಲು ಹೋಗುತ್ತದೆ ಒಂದು ನೋಡ್

331
00:20:41,800 --> 00:20:47,210
ಮತ್ತು ಬಲ ತೋರಿಸಲು ಏರಲಿದೆ ಮತ್ತೊಂದು ನೋಡ್. ಆದ್ದರಿಂದ ಕೇವಲ ಒಂದು ಮರ.

332
00:20:47,210 --> 00:20:49,440
ಹೇಗೆ ನೀವು ಹಫ್ಮನ್ ಮರದ ನಿರ್ಮಿಸಲು ಇಲ್ಲ?

333
00:20:49,440 --> 00:20:54,020
ನೀವು ಕಡಿಮೆ ಆವರ್ತನಗಳನ್ನು ಹೊಂದಿರುವ 2 ಗ್ರಂಥಿಗಳು ಆಯ್ಕೆ ನೀನು.

334
00:20:54,020 --> 00:20:56,490
ನೀವು ಟೈ ಇದ್ದರೆ ನೀವು 2 ಗ್ರಂಥಿಗಳು ಆಯ್ಕೆ ನೀನು

335
00:20:56,490 --> 00:20:59,870
ಹಾಗೆಯೇ ಕಡಿಮೆ ಮಾಡಿದ ASCII ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ.

336
00:20:59,870 --> 00:21:02,420
ನಂತರ ನೀವು ಆ 2 ಗ್ರಂಥಿಗಳು ಔಟ್ ಹೊಸ ಮರ ರಚಿಸಲು ನೀನು

337
00:21:02,420 --> 00:21:08,030
ಪೋಷಕ ನೋಡ್ ಸೇರಿ ಆವರ್ತನ ಮಾಡಲಿಕ್ಕೆ ಇದೆ.

338
00:21:08,030 --> 00:21:13,240
ತದನಂತರ ನೀವು ಕಾಡು 2 ಮಕ್ಕಳ ತೆಗೆದು ನೀನು

339
00:21:13,240 --> 00:21:15,570
ಮತ್ತು ಮೂಲ ಅವುಗಳನ್ನು ಬದಲಿಗೆ.

340
00:21:15,570 --> 00:21:18,930
ಮತ್ತು ನೀವು ಮಾತ್ರ ಕಾಡಿನಲ್ಲಿ 1 ಮರದ ತನಕ ಎಂದು ಪುನರಾವರ್ತಿಸಲು ನೀನು.

341
00:21:18,930 --> 00:21:23,840
ಆದ್ದರಿಂದ ನೀವು, Zamyla ಹಫ್ಮನ್ ಮರದ ಮಾಡಲು ಹೇಗೆ ನೋಡೋಣ.

342
00:21:23,840 --> 00:21:29,220
ನೀವು ಎಲ್ಲಾ ಅಕ್ಷರಗಳು 'ಎ' ಹೊರತುಪಡಿಸಿ ಆವರ್ತನ 1 ಹೊಂದಿರುವ ಇಲ್ಲಿ ನೋಡಬಹುದು; ಆವರ್ತನ 2 ಹೊಂದಿದೆ.

343
00:21:29,220 --> 00:21:34,090
ಆದ್ದರಿಂದ ನಾನು ASCII ಮೌಲ್ಯ ಮತ್ತು ಆವರ್ತನದ ಸಲುವಾಗಿ ಪುಟ್ ಎಲ್ಲಾ ಅಕ್ಷರಗಳು ಗ್ರಂಥಿಗಳು ದಾಖಲಿಸಿದವರು.

344
00:21:34,090 --> 00:21:40,090
ನಾನು ಮೊದಲ ಮರ ರಚಿಸಲು ಬಯಸುವ ಹಾಗಿದ್ದಲ್ಲಿ, ಇದು 'ಎಲ್' ಮತ್ತು 'ಎಮ್' ಇರುತ್ತದೆ.

345
00:21:40,090 --> 00:21:43,100
ಆದ್ದರಿಂದ ಇಲ್ಲಿ. ಜೋಡಿ ಆವರ್ತನ 2 ಆಗಿರುತ್ತದೆ

346
00:21:43,100 --> 00:21:49,470
+ 1 1 ಏಕೆಂದರೆ, ನಂತರ ಕಡಿಮೆ ಆವರ್ತನಗಳಲ್ಲಿ ಮುಂದಿನ 2 'ವೈ' ಮತ್ತು 'ಝಡ್' ಇವೆ.

347
00:21:49,470 --> 00:21:53,180
2 ಒಂದು ಆವರ್ತನ ಹೊಂದಿವೆ - ತದನಂತರ ನಾನು ಎಂಬ ಎಲ್ಲಾ ಹೊಂದಿವೆ.

348
00:21:53,180 --> 00:22:00,470
ಆದ್ದರಿಂದ ಮುಂದಿನ ಒಂದು ಕಡಿಮೆ ASCII ಮೌಲ್ಯ ಬಯಸುವುದನ್ನು ಇದು ಇವನ್ನು?

349
00:22:00,470 --> 00:22:04,830
'ಎ' ಮತ್ತು 'ಎಲ್'. ಹಾಗಾಗಿ ಹೊಸ ನೋಡ್ ರಚಿಸಲು,

350
00:22:04,830 --> 00:22:09,930
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಇದು 4 ಮತ್ತು 2, ಆದ್ದರಿಂದ 2 ಎಡ ಏರಲಿದೆ.

351
00:22:09,930 --> 00:22:12,430
ಮತ್ತು ಈ ಹಫ್ಮನ್ ಮರವಾಗಿದೆ.

352
00:22:12,430 --> 00:22:16,060
ನಾನು ಕೆಲವು ಪಠ್ಯ ಬರೆಯಲು ಬಯಸುವ ನಂತರ ವೇಳೆ,

353
00:22:16,060 --> 00:22:24,440
ಹಾಗೆ ಹಫ್ಮನ್ ಮರದ ಬಳಸಿ, ಪಠ್ಯ ಮತಾಂತರಗೊಳ್ಳಲು ಅವಳಿ ಬಹಳ ಸುಲಭ.

354
00:22:24,440 --> 00:22:30,220
ನಾನು ಎಡಕ್ಕೆ ಚಲಿಸುವ 0 ಮತ್ತು ಬಲಕ್ಕೆ ಚಲಿಸುವ ಎಂದು ಹೇಳಲು ಉದಾಹರಣೆಗೆ, ಒಂದು 1

355
00:22:30,220 --> 00:22:32,410
ಏನು ಪ್ರತಿನಿಧಿಸಲು ಎಂದು?

356
00:22:32,410 --> 00:22:35,530
ಆದ್ದರಿಂದ ಹಾಗೆ 1, 1, ಬಲ, ಆದ್ದರಿಂದ ಬಲ,

357
00:22:35,530 --> 00:22:40,370
ತದನಂತರ ಆದ್ದರಿಂದ ಬಿಟ್ಟು 0, ಎಲ್ ಎಂದು, ಮತ್ತು ನಂತರ 1, 0, 0.

358
00:22:40,370 --> 00:22:43,950
ಆದ್ದರಿಂದ 1, 0, ಆದ್ದರಿಂದ ಕೇವಲ 1, 0, 'ಎ'.

359
00:22:43,950 --> 00:22:47,540
ತದನಂತರ 0, 1, ಆದ್ದರಿಂದ 'ಝಡ್'.

360
00:22:47,540 --> 00:22:52,170
ತದನಂತರ 1, 0, 0 - ಯಾವುದೇ.

361
00:22:52,170 --> 00:22:56,780
0, 0 'ವೈ' ಎಂದು, ಆದ್ದರಿಂದ ಲೇಜಿ ಕಾಣಿಸುತ್ತದೆ.

362
00:22:56,780 --> 00:23:06,060
ಆದ್ದರಿಂದ ನನ್ನನ್ನು ಅಷ್ಟೆ ರಾಬ್ ಮೇಲೆ ತೆಗೆದುಕೊಳ್ಳುವುದು.

363
00:23:06,060 --> 00:23:08,400
>> [ರಾಬ್ ಬೌಡೆನ್] ಆದ್ದರಿಂದ, ವಾರ 7 ಸ್ಟಫ್.

364
00:23:08,400 --> 00:23:11,390
ನಾವು ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿ ಮೇಲೆ ಹೋಗಲು ಸಾಕಷ್ಟು ಮಾಡಲೇಬೇಕು.

365
00:23:11,390 --> 00:23:13,430
Bitwise ನಿರ್ವಾಹಕರು, ಬಫರ್,

366
00:23:13,430 --> 00:23:16,760
CS50 ಗ್ರಂಥಾಲಯದ, ನಂತರ ಎಚ್ಟಿಎಮ್ಎಲ್, HTTP ಸಿಎಸ್ಎಸ್.

367
00:23:16,760 --> 00:23:20,990
15 ರಿಂದ 20 ನಿಮಿಷಗಳ ನಂತಹ ಎಲ್ಲಾ.

368
00:23:20,990 --> 00:23:24,330
Bitwise ನಿರ್ವಾಹಕರು. ನೀವು ತಿಳಿಯಬೇಕಾದ ಅವುಗಳಲ್ಲಿ 6 ಇವೆ.

369
00:23:24,330 --> 00:23:31,200
Bitwise ಮತ್ತು, bitwise ಅಥವಾ, XOR, ಎಡ ಶಿಫ್ಟ್, ಬಲ Shift, ಮತ್ತು.

370
00:23:31,200 --> 00:23:35,420
ಬಲ Shift ಮತ್ತು ನೀವು ಕೇವಲ ಎಲ್ಲಾ ಉಪನ್ಯಾಸ ಕಂಡಿತು ಅಲ್ಲ.

371
00:23:35,420 --> 00:23:40,480
ನಾವು ಬೇಗನೆ ಇಲ್ಲಿ ಹೋಗುತ್ತೇನೆ, ಆದರೆ ಈ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ 6 ಎಂದು ತಿಳಿಯಲು ಒಳ್ಳೆಯದು.

372
00:23:40,480 --> 00:23:45,070
Bitwise ನಿರ್ವಾಹಕರು ನೀವು + 4 3 ಮಾಡಿದಾಗ ರೀತಿಯ ನೆನಪಿಡಿ.

373
00:23:45,070 --> 00:23:49,420
ನೀವು 3 ಮತ್ತು 4 ಬೈನರಿ ವ್ಯವಹರಿಸುವಾಗ ಇಲ್ಲ.

374
00:23:49,420 --> 00:23:56,550
Bitwise ನಿರ್ವಾಹಕರು ನಿಮಗೆ ನಿಜವಾಗಿ ಸಂಖ್ಯೆಗಳನ್ನು 3 ಮತ್ತು 4 ಪ್ರತ್ಯೇಕ ಬಿಟ್ಗಳು ವ್ಯವಹರಿಸುತ್ತದೆ.

375
00:23:56,550 --> 00:23:59,120
>> ನಾವು ಹೇಳುತ್ತೇನೆ ಮೊದಲ ಒಂದು bitwise, ಅಲ್ಲ

376
00:23:59,120 --> 00:24:02,340
ಮತ್ತು ಅದು ಎಲ್ಲಾ ಎಲ್ಲಾ ಬಿಟ್ಗಳು ಮಿಡಿ ಹೊಂದಿದೆ.

377
00:24:02,340 --> 00:24:05,500
ನೀವು ಸಿ ಈ ಬರೆಯುತ್ತಿದ್ದೇವೆ ವೇಳೆ ಇಲ್ಲಿ, ನೀವು ಬರೆಯಲು

378
00:24:05,500 --> 00:24:09,380
~ 11011 ಅಥವಾ ಯಾವುದೇ, ನೀವು, ಇದು ~ 4 ಇಷ್ಟ ಬರೆಯಬೇಕಿತ್ತು

379
00:24:09,380 --> 00:24:12,970
ನಂತರ ಅದನ್ನು 4 ಬೈನರಿ ಪ್ರಾತಿನಿಧ್ಯ ಮಿಡಿ ಎಂದು.

380
00:24:12,970 --> 00:24:24,800
ಇಲ್ಲಿ, 1 ನ ~ ಕೆಲವು ಬೈನರಿ ಸಂಖ್ಯೆಯ 1101101 ನಿಖರವಾಗಿ 0 ನ ಎಲ್ಲಾ 1 ಫ್ಲಿಪ್ ಹೋಗುತ್ತದೆ ಮತ್ತು ಎಲ್ಲಾ 0 ನ.

381
00:24:24,800 --> 00:24:27,600
ನಾನು ಹೇಳಿದಂತೆ, ಈ ಆಗಾಗ್ಗೆ ಬಳಕೆ,

382
00:24:27,600 --> 00:24:30,830
ನಾವು ಕೆಲವು ಸಂಖ್ಯೆಯ ಮಂದಿ ಬಯಸುವ ಮತ್ತು ನಾವು ಸ್ವಲ್ಪ ಅದನ್ನು ನೋಡುತ್ತಾರೆ, ಆಗಿದೆ

383
00:24:30,830 --> 00:24:35,460
ಬಿಟ್ಗಳು ಎಲ್ಲಾ ಅವುಗಳಲ್ಲಿ ಒಂದು ಹೊರತುಪಡಿಸಿ, 1 ಅಲ್ಲಿ.

384
00:24:35,460 --> 00:24:38,560
ಆದ್ದರಿಂದ ಸಂಖ್ಯೆ ವ್ಯಕ್ತಪಡಿಸಲು ಸಾಮಾನ್ಯವಾಗಿ ಸುಲಭ

385
00:24:38,560 --> 00:24:40,630
ಕೇವಲ ಒಂದೇ ಬಿಟ್ ಸೆಟ್ ಅಲ್ಲಿ,

386
00:24:40,630 --> 00:24:44,650
ನಂತರ ಅದನ್ನು ~, ಆದ್ದರಿಂದ ಪ್ರತಿ ಇತರ ಬಿಟ್ ಒಂದು ಹೊರತುಪಡಿಸಿ ಸೆಟ್ ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

387
00:24:44,650 --> 00:24:50,300
ಆದ್ದರಿಂದ ನಾವು ಒಂದು ಬಿಟ್ ಹೆಚ್ಚು ಬಳಸಲು ನೀನು ಇಲ್ಲಿದೆ.

388
00:24:50,300 --> 00:24:58,220
>> Bitwise ಅಥವಾ. ಇಲ್ಲಿ 2 ಬೈನರಿ ಸಂಖ್ಯೆಗಳು, ಮತ್ತು ಈ 2 ಸಂಖ್ಯೆಗಳು

389
00:24:58,220 --> 00:25:00,780
ಅವರು ಪ್ರತಿಯೊಂದು ಸಂಭವನೀಯ ಪ್ರತಿನಿಧಿಸುವಂತಹ, ಬಹಳ ಪ್ರತಿನಿಧಿಗಳು

390
00:25:00,780 --> 00:25:07,290
ಬಿಟ್ಗಳು ಸಂಯೋಜನೆಯನ್ನು ನೀವು ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಅಗತ್ಯವಿದೆ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.

391
00:25:07,290 --> 00:25:13,540
ನಾನು ಪ್ರತಿ ಬಿಟ್ or'd ಮಾಡಿದಾಗ ಇಲ್ಲಿ, ನಾವು ನೇರ ಕೆಳಗೆ ಹೋಲಿಸಲು ನೀನು.

392
00:25:13,540 --> 00:25:15,410
ಆದ್ದರಿಂದ ಎಡಭಾಗದಲ್ಲಿ ನಾವು 1 ಮತ್ತು 1 ಹೊಂದಿವೆ.

393
00:25:15,410 --> 00:25:20,510
ನಾನು bitwise ಮಾಡಿದಾಗ | ಆ, ನಾನು ಪಡೆಯಲು ನಾನು? ಒಂದು.

394
00:25:20,510 --> 00:25:25,320
0 ಮತ್ತು 1 ನನಗೆ ನೀಡಲು ಹೋಗುತ್ತದೆ | ನಂತರ bitwise? ಒಂದು.

395
00:25:25,320 --> 00:25:27,840
Bitwise 1 ಮತ್ತು 0 ಒಂದೇ, ಒಂದು ಏರಲಿದೆ.

396
00:25:27,840 --> 00:25:31,880
Bitwise 0 | 0 ನನಗೆ 0 ನೀಡಲು ಹೋಗುತ್ತದೆ.

397
00:25:31,880 --> 00:25:37,300
0 ಸಂದರ್ಭದಲ್ಲಿ | ಹಾಗಾಗಿ 0 ಪಡೆಯಲು ಅಲ್ಲಿ ಮಾತ್ರ ಸಂದರ್ಭದಲ್ಲಿ 0 ಆಗಿದೆ.

398
00:25:37,300 --> 00:25:40,020
ಮತ್ತು ನೀವು ನಿಮ್ಮ ತಾರ್ಕಿಕ ಅದರ್ಸ್ ಹಾಗೆ ಎಂದು ನಗರದ.

399
00:25:40,020 --> 00:25:44,830
ನೀವು ನಿಜವಾದ 1 ಮತ್ತು ಹುಸಿ 0 ಅನಿಸಿದರೆ, ಒಂದೇ ಇಲ್ಲಿ ಅನ್ವಯಿಸುತ್ತದೆ.

400
00:25:44,830 --> 00:25:50,040
ಆದ್ದರಿಂದ ನಿಜವಾದ ಅಥವಾ ನಿಜವಾದ ನಿಜ; ಸರಿ ಅಥವಾ ತಪ್ಪು ನಿಜ.

401
00:25:50,040 --> 00:25:57,150
ತಪ್ಪು ಅಥವಾ ನಿಜವಾದ ನಿಜ; ತಪ್ಪು ಅಥವಾ ತಪ್ಪು ವಾಸ್ತವವಾಗಿ ತಪ್ಪು ಏಕೈಕ ವಿಷಯ.

402
00:25:57,150 --> 00:26:00,100
ಇಲ್ಲಿ ನಿಮಗೆ ಎಂದು ಉದಾಹರಣೆ

403
00:26:00,100 --> 00:26:05,160
bitwise ನಿರ್ವಾಹಕರು ಬಳಸಿದಾಗ ಒಂದು ಒಳ್ಳೆಯ ಉದಾಹರಣೆಯಾಗಿ.

404
00:26:05,160 --> 00:26:08,660
ಇಲ್ಲಿ ನಾವು ಅಥವಾ Ox20 ಬಂಡವಾಳ 'ಎ',

405
00:26:08,660 --> 00:26:11,830
ಮತ್ತು ನಾವು ಏನೋ ಪಡೆಯಲು, ಎರಡನೇ ಈ ನೋಡಲು ಮಾಡುತ್ತೇವೆ.

406
00:26:11,830 --> 00:26:16,020
ನಾವು ಅಥವಾ ಸಣ್ಣ 'ಒಂದು' Ox20 ಜೊತೆ, ನಾವು ಏನೋ ಪಡೆಯಲು ವೇಳೆ.

407
00:26:16,020 --> 00:26:26,750
ಆದ್ದರಿಂದ ASCII ಟೇಬಲ್ ಎಳೆಯಲು ಅವಕಾಶ.

408
00:26:26,750 --> 00:26:34,000
ಸರಿ. ಇಲ್ಲಿ ನಾವು 'ಎ' ಎಂದು ನೋಡಿ -

409
00:26:34,000 --> 00:26:36,920
ಇಲ್ಲಿ ನಾವು 'ಎ' 65 ರೇಖಾಂಶ ಹೊಂದಿರುತ್ತವೆ.

410
00:26:36,920 --> 00:26:45,120
ಆದರೆ ನಾನು Ox41 ಇದು ಹೆಕ್ಸಾಡೆಸಿಮಲ್, ಹೋಗುತ್ತೇನೆ.

411
00:26:45,120 --> 00:26:48,280
ಬಹಳ ಖಚಿತವಾಗಿ ನಾವು ವರ್ಗ ನೋಡಿದ. ನಾನು ತರಗತಿಯಲ್ಲಿ ನಾವು ನೋಡಿದ ಭಾವಿಸುತ್ತೇನೆ

412
00:26:48,280 --> 00:26:52,730
ಇದು ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ರಿಂದ ಅವಳಿ ಪರಿವರ್ತಿಸುವುದು ಬಹಳ ಸುಲಭ ಎಂದು.

413
00:26:52,730 --> 00:26:55,280
ಇಲ್ಲಿ ನಾನು ಅವಳಿ 4 ಪುಟ್ ಬಯಸಿದರೆ,

414
00:26:55,280 --> 00:26:59,550
ಕೇವಲ 0100 ಎಂದು ವಿಶೇಷವೇನು.

415
00:26:59,550 --> 00:27:03,620
ಈ 1 ಸ್ಥಾನವನ್ನು, 2 ಸ್ಥಾನ, 4 ಸ್ಥಾನವನ್ನು, ಈ 4.

416
00:27:03,620 --> 00:27:08,550
ನಂತರ ನಾನು 0001 ಏರಲಿದೆ ಬೈನರಿ, ಒಳಗೆ 1 ವಿಭಾಗಿಸಬಹುದು.

417
00:27:08,550 --> 00:27:14,280
ಆದ್ದರಿಂದ ಈ ಅವಳಿ 'ಎ' ಪ್ರಾತಿನಿಧ್ಯ ಏರಲಿದೆ.

418
00:27:14,280 --> 00:27:22,720
ಸಣ್ಣ 'ಒಂದು', ಈಗ Ox61 ಎಂದು ವಿಶೇಷವೇನು ಟೇಕಿಂಗ್,

419
00:27:22,720 --> 00:27:27,050
ಅದರ ಬೈನರಿ ಈ ವಿಭಜಿಸುವ ಅಲ್ಲಿ,, ಒಂದು 6 -

420
00:27:27,050 --> 00:27:37,830
ವಾಸ್ತವವಾಗಿ ಇದು ಮಾಡೋಣ - ಯಾವುದೇ ಎರೇಸರ್ ಇಲ್ಲ? ಎರೇಸರ್.

421
00:27:37,830 --> 00:27:48,220
Ox61. ಆದ್ದರಿಂದ ಬೈನರಿ ಒಳಗೆ 6 ವಿಭಜಿಸುವ + 4 + 2 + 0 0 ಏರಲಿದೆ.

422
00:27:48,220 --> 00:27:54,610
ಮತ್ತು ವಿಭಜಿಸುವ 1 0001 ಏರಲಿದೆ.

423
00:27:54,610 --> 00:27:56,520
ಈ 2 ನಡುವೆ ವ್ಯತ್ಯಾಸವನ್ನು ನೋಡುತ್ತಿರುವುದು

424
00:27:56,520 --> 00:28:04,250
ನಾವು ಒಂದು ಸಣ್ಣ ಮತ್ತು ಒಂದು ರಾಜಧಾನಿ 'ಎ' ನಡುವಿನ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಈ ಬಿಟ್ ಎಂದು ನೋಡಿ.

425
00:28:04,250 --> 00:28:11,810
ಸರಿ - ಆದ್ದರಿಂದ ಮತ್ತೆ ಇಲ್ಲಿ ಬರುವ.

426
00:28:11,810 --> 00:28:15,920
ನಾವು ಸ್ವಲ್ಪ Ox20 ಏನು ನೋಡಿದರೆ, ಇಲ್ಲಿ ಮತ್ತೆ ಬರುವ

427
00:28:15,920 --> 00:28:22,210
ತನ್ನ ಅವಳಿ ಒಳಗೆ ಆದ್ದರಿಂದ ವಿಭಜಿಸುವ Ox20,

428
00:28:22,210 --> 00:28:27,310
0010, 0000 ಆಗಿದೆ.

429
00:28:27,310 --> 00:28:33,470
Ox20, ಹೊಂದಿಸಲಾಗಿದೆ ಎಂದು ಮಾತ್ರ ಬಿಟ್, ನಾವು ಸಂಬಂಧಿಸಿರುತ್ತವೆ ಎಂದು ಈ ಬಿಟ್

430
00:28:33,470 --> 00:28:38,210
ರಾಜಧಾನಿ ಮತ್ತು ಸಣ್ಣ 'ಒಂದು' ಬದಲಾಯಿಸುವಾಗ ಜೊತೆ.

431
00:28:38,210 --> 00:28:47,610
ಈ ಒಂದು, 'ಎ' ಇದು ನಾನು ಅಥವಾ 'ಎ',

432
00:28:47,610 --> 00:28:50,580
ನಾನು ಅಥವಾ Ox20 ಜೊತೆ 'ಎ',

433
00:28:50,580 --> 00:28:53,490
ನಾನು ಪಡೆಯಲು ನಾನು?

434
00:28:53,490 --> 00:28:58,960
[ವಿದ್ಯಾರ್ಥಿ, ಕೇಳಿಸುವುದಿಲ್ಲ] >> ಸಣ್ಣ 'ಒಂದು', ಇದು 1 ಈ ಬಿಟ್ ಮಿಡಿ ವಿಶೇಷವೇನು ಏಕೆಂದರೆ.

435
00:28:58,960 --> 00:29:04,170
ಮತ್ತು ನಾನು ಅಥವಾ 'ಒಂದು' Ox20 ಜೊತೆ, ನಾನು ಪಡೆಯಲು ನಾನು?

436
00:29:04,170 --> 00:29:08,780
ಒಂದು ಸಣ್ಣ, ಏಕೆಂದರೆ ಕೇವಲ oring 'ಒಂದು' Ox20 ಜೊತೆ,

437
00:29:08,780 --> 00:29:14,580
ನಾನು ಒಂದು 1 ಈ ಬಿಟ್ oring ವೃಂದದಲ್ಲಿರುತ್ತೇನೆ; ಅಪ್ರಸ್ತುತವಾಗುತ್ತದೆ ಆದ್ದರಿಂದ, ಈಗಾಗಲೇ 1 ಇಲ್ಲಿದೆ.

438
00:29:14,580 --> 00:29:17,960
ನಾವು 'ಎ' ಮತ್ತು 'ಒಂದು' ಪಡೆಯಿರಿ.

439
00:29:17,960 --> 00:29:24,820
>> Bitwise ಮತ್ತು. ಮತ್ತೆ, ನಾವು ನಮ್ಮ ತಾರ್ಕಿಕ ಮತ್ತು ಪ್ರತಿರೂಪವಾಗಿ ಈ ನಗರದ.

440
00:29:24,820 --> 00:29:28,180
ಎಡಭಾಗದಲ್ಲಿ ನಾವು ನಿಜವಾದ ಹಾಗೂ ನಿಜವಾದ ಹೊಂದಿವೆ.

441
00:29:28,180 --> 00:29:31,160
ಇದು ನಿಜ ಎಂದು ವಿಶೇಷವೇನು, ಮತ್ತು ಸಂದರ್ಭಗಳಲ್ಲಿ ಎಲ್ಲಾ ವಿಶೇಷವೇನು

442
00:29:31,160 --> 00:29:36,270
, ಸುಳ್ಳು ಹಾಗೂ ನಿಜವಾದ ಅಥವಾ ನಿಜವಾದ & ಸುಳ್ಳು, ಅಥವಾ ತಪ್ಪು ಮತ್ತು ಸುಳ್ಳು

443
00:29:36,270 --> 00:29:38,550
ಆ ವಸ್ತುಗಳ ಯಾವುದೇ ನಿಜವಾಗಿದ್ದರೆ.

444
00:29:38,550 --> 00:29:44,170
ಹಾಗಾಗಿ ನಾವು ಪಡೆಯುವಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ 1000 ಆಗಿದೆ.

445
00:29:44,170 --> 00:29:48,830
ಈಗ, ಇಲ್ಲಿ, ಇಲ್ಲಿ ನಾನು ನಂಬಲರ್ಹ bitwise ಅಲ್ಲ ಬಳಸಲಾಗುತ್ತದೆ ಮಾಡಿದ ಅಲ್ಲಿ ಇಲ್ಲಿದೆ,

446
00:29:48,830 --> 00:29:52,230
ನಾವು Ox20 ಅಲ್ಲಿ.

447
00:29:52,230 --> 00:29:54,350
ಆದ್ದರಿಂದ ಈ Ox20 ಆಗಿದೆ.

448
00:29:54,350 --> 00:29:59,570
ಈಗ ನಾನು ಯಾವ, bitwise Ox20 ಆಫ್ ~.

449
00:29:59,570 --> 00:30:03,600
ಎಲ್ಲಾ ಬಿಟ್ಗಳು ಮಿಡಿ ಹೋಗುತ್ತದೆ.

450
00:30:03,600 --> 00:30:09,330
ಹಾಗಾಗಿ 1101, 1111 ಹೊಂದಿವೆ.

451
00:30:09,330 --> 00:30:18,940
ಆದ್ದರಿಂದ 'ಎ' ~ Ox20 ನನಗೆ ಏನು ನೀಡಲು ಹೋಗುತ್ತದೆ ಜೊತೆ anded?

452
00:30:18,940 --> 00:30:22,430
ನಾವು ನಿಜವಾಗಿಯೂ ಬಗ್ಗೆ ಮಾಡಬೇಕಾಗುತ್ತದೆ ಮಾತ್ರ ಬಿಟ್, ಈ ಒಂದಾಗಿದೆ

453
00:30:22,430 --> 00:30:26,020
ರಿಂದ ಈ ಬಿಟ್ಗಳು ಎಲ್ಲಾ 1 ಸಿದ್ಧವಾಗಿವೆ ವೇಳೆ,

454
00:30:26,020 --> 00:30:29,000
ನಂತರ ನಾವು ನಿಖರವಾಗಿ 'ಎ' ಆಗಿತ್ತು ಪಡೆಯಲು ನೀನು,

455
00:30:29,000 --> 00:30:31,260
ಹೊರತುಪಡಿಸಿ, ಬಹುಶಃ, ಈ ಭಾಗ.

456
00:30:31,260 --> 00:30:34,460
ಇದು 1 ಎಂದು, ಈಗ, ಒಂದು 0 ಅನ್ನು ವಿಶೇಷವೇನು ಏಕೆಂದರೆ

457
00:30:34,460 --> 00:30:39,810
ಈ ಏನೇ ಈ 0 ಏರಲಿದೆ ಜೊತೆ anded ಏಕೆಂದರೆ.

458
00:30:39,810 --> 00:30:43,280
ಆದ್ದರಿಂದ 'ಎ' ~ Ox20 ನನಗೆ ನೀಡಲು ಹೋಗಿ & ಏನು?

459
00:30:43,280 --> 00:30:48,200
[ವಿದ್ಯಾರ್ಥಿಗಳು ಉತ್ತರಿಸಲು, ಕೇಳಿಸುವುದಿಲ್ಲ] >> ಮತ್ತು 'ಒಂದು' ಮತ್ತು ಏನು - ಇದು 'ಎ' ಇಲ್ಲಿದೆ.

460
00:30:48,200 --> 00:30:52,170
ಮತ್ತು 'ಒಂದು' ಹಾಗೂ ~ Ox20 ನನಗೆ ನೀಡಲು ಹೋಗಿ ಏನು?

461
00:30:52,170 --> 00:30:56,720
'ಎ' ಈ ಪ್ರಸ್ತುತ 1 ಕಾರಣ.

462
00:30:56,720 --> 00:30:59,570
ಈ 0 Anding, ಇದು 0 ಮಾಡಲು ಹೋಗುತ್ತದೆ

463
00:30:59,570 --> 00:31:02,530
ಮತ್ತು ಈಗ ನಾವು ಒಂದು 'ಎ' ಪಡೆಯಲು ನೀನು.

464
00:31:02,530 --> 00:31:06,600
>> ಎರಡೂ ', ಒಂದು' ಮತ್ತು ಈ ರೀತಿಯ ಕನಿಷ್ಠ ಕೊನೆಯಾಗಿ ಆದರೆ,

465
00:31:06,600 --> 00:31:10,830
ನಾವು XOR ಹೊಂದಿವೆ. ಇದು ತುಂಬಾ ಇಲ್ಲಿದೆ ಅಥವಾ,

466
00:31:10,830 --> 00:31:14,400
ಇದು ಪ್ರತ್ಯೇಕವಾಗಿ ಅರ್ಥ ಅಥವಾ ಹೊರತುಪಡಿಸಿ.

467
00:31:14,400 --> 00:31:18,420
ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಅಥವಾ ನಿಜವಾದ ವಿಶ್ವದ ನಗರದ ಯಾವ ಹಾಗೆ.

468
00:31:18,420 --> 00:31:23,190
ಆದ್ದರಿಂದ ನೀವು ಎರಡೂ 'X' ಅಥವಾ 'ವೈ', ಆದರೆ ಎರಡೂ.

469
00:31:23,190 --> 00:31:28,700
ಇಲ್ಲಿ ^ 1 1 0 ಏರಲಿದೆ.

470
00:31:28,700 --> 00:31:33,650
ನಿಜವಾದ ಕಾರಣ, ಈ - ಇದು ತಾರ್ಕಿಕ ನಿಜವಾದ ಮತ್ತು ತಪ್ಪು ಜೊತೆಗೆ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ

471
00:31:33,650 --> 00:31:37,150
, bitwise ಹಾಗೂ ಮತ್ತು ಅಥವಾ ಮಾಡುವಂತೆ

472
00:31:37,150 --> 00:31:40,100
ಆದರೆ ನಿಜವಾದ ^ ನಿಜವಾದ ತಪ್ಪಾಗಿದೆ.

473
00:31:40,100 --> 00:31:44,810
ಅವುಗಳನ್ನು ಮಾತ್ರ ನಿಜವಾದ ವೇಳೆ ನಾವು ಮಾತ್ರ ನಿಜವಾದ ಮರಳಲು ಬಯಸುವ ಕಾರಣ.

474
00:31:44,810 --> 00:31:50,950
ಆದ್ದರಿಂದ ^ 1 1 0. ಏನು ^ 1 0 ಬಗ್ಗೆ?

475
00:31:50,950 --> 00:31:56,010
1. ^ 0 ^ 1 0 0 0, 1.

476
00:31:56,010 --> 00:32:03,890
ಆದ್ದರಿಂದ ಎಲ್ಲಾ ಸಂದರ್ಭಗಳಲ್ಲಿ, 0 bitwise ಏನೋ 0 0 ಏರಲಿದೆ.

477
00:32:03,890 --> 00:32:10,270
1 bitwise ಏನೋ 0 0 ಅಥವಾ bitwise 1,

478
00:32:10,270 --> 00:32:14,660
ಇದು ಇದ್ದರೆ | ಅಥವಾ ^, ಇದು 1 ಆಗಬಹುದು, ಮತ್ತು ಇದು & ಇಲ್ಲಿದೆ ಅದು 0 ಇರುವಿರಿ.

479
00:32:14,660 --> 00:32:20,850
ಮತ್ತು 1 bitwise 1 1 ಅಲ್ಲಿ ಮಾತ್ರ ಸಂದರ್ಭದಲ್ಲಿ ಮೀಸಲು ಅಥವಾ ಆಗಿದೆ.

480
00:32:20,850 --> 00:32:24,580
ಆ 0110 ಇಲ್ಲಿದೆ.

481
00:32:24,580 --> 00:32:36,520
ಇಲ್ಲಿ ಈಗ, XOR ಬಳಸಿ - ಆದ್ದರಿಂದ ನಾವು ಹಿಂದೆ 20 ಆರ್.

482
00:32:36,520 --> 00:32:43,480
'ಎ' ^ Ox20 ನಾವು ಹೋಲಿಸುವ ನೀವು ಈ 2 ಬಿಟ್ಗಳು.

483
00:32:43,480 --> 00:32:50,020
ಆದ್ದರಿಂದ ಒಂದು 1 ^ 0 ಅಂತ ಏನು ನೀಡಲು ಹೋಗುತ್ತದೆ? ಒಂದು ಒಂದು.

484
00:32:50,020 --> 00:32:58,430
'ಎ' ^ Ox20 ನನಗೆ ನೀಡಲು ಹೋಗುತ್ತದೆ? ಒಂದು ಸಣ್ಣ.

485
00:32:58,430 --> 00:33:04,010
'ಒಂದು' ^ Ox20 ನನಗೆ ನೀಡಲು ಹೋಗುತ್ತದೆ? ರಾಜಧಾನಿ ಎ

486
00:33:04,010 --> 00:33:09,310
ಈ ಮಾಡುವುದರಿಂದ ಯಾವುದೇ, Ox20 ಈ XORing

487
00:33:09,310 --> 00:33:15,380
ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಈ ಬಿಟ್ ಏನೇ ಫ್ಲಿಪ್ಪಿಂಗ್ ಇದೆ.

488
00:33:15,380 --> 00:33:21,240
ಈ 0, ಅದನ್ನು ಈಗ 1 ಆಗಲು ವಿಶೇಷವೇನು.

489
00:33:21,240 --> 00:33:26,160
ಈ ಒಂದು 1 ಏಕೆಂದರೆ, ^ 1 1 0.

490
00:33:26,160 --> 00:33:33,280
ಆದ್ದರಿಂದ ನಮ್ಮ 'ಒಂದು' 'ಎ' ಮಾರ್ಪಟ್ಟಿದೆ, ಮತ್ತು ನಮ್ಮ 'ಎ' 'ಒಂದು' ಮಾರ್ಪಟ್ಟಿದೆ.

491
00:33:33,280 --> 00:33:36,910
ಆದ್ದರಿಂದ XOR ಕೇವಲ ಸಂದರ್ಭದಲ್ಲಿ ಫ್ಲಿಪ್ಪಿಂಗ್ ನಿಜವಾಗಿಯೂ ಅನುಕೂಲಕರ.

492
00:33:36,910 --> 00:33:39,960
ನೀವು ಕೇವಲ ಅಕ್ಷರಗಳ ಸರಣಿಯನ್ನು ಮೇಲೆ ಮರಳಿ ಬಯಸುವ

493
00:33:39,960 --> 00:33:44,330
ಮತ್ತು ಪ್ರತಿಯೊಂದು ಪಾತ್ರದ ಸಂದರ್ಭದಲ್ಲಿ ಪರ್ಯಾಯವಾಗಿ,

494
00:33:44,330 --> 00:33:50,680
Ox20 ಜೊತೆ ನೀವು XOR ಎಲ್ಲವೂ.

495
00:33:50,680 --> 00:33:55,220
>> ಈಗ ನಾವು ಶಿಫ್ಟ್ ಬಿಟ್ಟು. ಎಡ ಶಿಫ್ಟ್ ಕೇವಲ ಮೂಲತಃ, ಹೋಗುತ್ತದೆ

496
00:33:55,220 --> 00:34:01,250
ಒಳಗೆ, ಅಥವಾ ಎಡಕ್ಕೆ ಸಂಖ್ಯೆಗಳ ಎಲ್ಲಾ ತಳ್ಳಲು, ಮತ್ತು ಅವುಗಳನ್ನು ಹಿಂದೆ 0 ಸೇರಿಸಲು.

497
00:34:01,250 --> 00:34:05,550
ಇಲ್ಲಿ ನಾವು 00001101 ಹೊಂದಿವೆ.

498
00:34:05,550 --> 00:34:08,560
ನಾವು ಬಲ, 3 0 ರ ತಳ್ಳಲು ನೀನು

499
00:34:08,560 --> 00:34:13,580
ಮತ್ತು ನಾವು 01101000 ಪಡೆಯಿರಿ.

500
00:34:13,580 --> 00:34:16,380
Nonbinary ಪರಿಭಾಷೆಯಲ್ಲಿ,

501
00:34:16,380 --> 00:34:24,699
ನಾವು ನಿಜವಾಗಿಯೂ 13 ಎಡ ಸ್ಥಳಾಂತರಿಸಲಾಯಿತು 3, ನಮಗೆ 104 ನೀಡುತ್ತದೆ ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ನೋಡಿ.

502
00:34:24,699 --> 00:34:32,530
ಆದ್ದರಿಂದ ಎಡ ಶಿಫ್ಟಿಂಗ್, ನಾವು ಇಲ್ಲಿ ನೋಡಿ, ಎಕ್ಸ್ << ವೈ ಮೂಲತಃ X * 2 ^ y ಆಗಿದೆ.

503
00:34:32,530 --> 00:34:40,139
^ 3 13 * 2, ^ 3 2 ಆದ್ದರಿಂದ * 8 13 104 ಆಗಿದೆ, 8.

504
00:34:40,139 --> 00:34:45,679
ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಬೈನರಿ, ಹೇಗೆ ಪ್ರತಿ ಅಂಕಿಯ, ಬಗ್ಗೆ ಯೋಚಿಸಿದರೆ

505
00:34:45,679 --> 00:34:49,530
ನಾವು ಬಲದಿಂದ ಆರಂಭಿಸುವ ವೇಳೆ, ಇದು ನಂತರ 1 ಸ್ಥಾನವನ್ನು, ನಂತರ 2 ಸ್ಥಾನ, 4 ನ ಸ್ಥಳವಾಗಿದೆ.

506
00:34:49,530 --> 00:34:51,330
ಆದ್ದರಿಂದ ಬಲದಿಂದ 0 ರ ತಳ್ಳುತ್ತದೆ,

507
00:34:51,330 --> 00:34:55,080
ನಾವು, 8 ಸ್ಥಾನವನ್ನು 4 ಸ್ಥಳದಲ್ಲಿ ಎಂದು ವಿಷಯಗಳನ್ನು ತಳ್ಳುವುದು

508
00:34:55,080 --> 00:34:57,920
ಮತ್ತು 16 ಸ್ಥಾನವನ್ನು 8 ಸ್ಥಾನ ಎಂದು ವಸ್ತುಗಳ.

509
00:34:57,920 --> 00:35:01,280
ಪ್ರತಿ ಶಿಫ್ಟ್ ಕೇವಲ 2 ಗುಣಿಸಿದರೆ. ಹೌದು?

510
00:35:01,280 --> 00:35:05,210
ನೀವು 5 ಬದಲಾಯಿಸಿತು [ವಿದ್ಯಾರ್ಥಿ] ಏನಾಗುತ್ತದೆ?

511
00:35:05,210 --> 00:35:10,790
[ಬೌಡೆನ್] ನೀವು 5 ವರ್ಗಾಯಿಸಲಾಯಿತು ನೀವು ಕೇವಲ ಅಂಕೆಗಳನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತದೆ.

512
00:35:10,790 --> 00:35:15,410
ಅನಿವಾರ್ಯವಾಗಿ, ಅದೇ ವಿಷಯ. ಲೈಕ್, ಪೂರ್ಣಾಂಕಗಳ ಮಾತ್ರ 32 ಬಿಟ್ಗಳು ಇವೆ,

513
00:35:15,410 --> 00:35:20,750
ನೀವು 2 ನಿಜವಾಗಿಯೂ ದೊಡ್ಡ ಪೂರ್ಣಾಂಕಗಳ ಸೇರಿಸಿ ಆದ್ದರಿಂದ, ಇದು ಕೇವಲ ಒಂದು ಪೂರ್ಣಾಂಕ ಹೊಂದಿಕೊಳ್ಳದಿದ್ದರೆ.

514
00:35:20,750 --> 00:35:23,660
ಆದ್ದರಿಂದ ಇಲ್ಲಿ ಅದೇ ವಿಷಯ. ನೀವು 5 ಬದಲಾಯಿಸಿತು,

515
00:35:23,660 --> 00:35:25,650
ನಾವು ಕೇವಲ ಒಂದು ಕಳೆದುಕೊಳ್ಳುತ್ತದೆ.

516
00:35:25,650 --> 00:35:28,820
ಮತ್ತು ", ಸ್ಥೂಲವಾಗಿ" ನಾನು ಏನು ಭಾಸವಾಗುತ್ತದೆ

517
00:35:28,820 --> 00:35:37,470
ನೀವು ತುಂಬಾ ಬದಲಾಯಿಸುವಂತೆ, ನೀವು ಬಿಟ್ಗಳು ಕಳೆದುಕೊಳ್ಳಬಹುದು ಅಲ್ಲಿ.

518
00:35:37,470 --> 00:35:39,830
>> ಹಕ್ಕು ಶಿಫ್ಟ್ ವಿರುದ್ಧ ಏರಲಿದೆ,

519
00:35:39,830 --> 00:35:43,090
ನಾವು, ಕೊನೆಯಲ್ಲಿ ಆಫ್ 0 ನ ನೂಕು ನೀನು ಅಲ್ಲಿ

520
00:35:43,090 --> 00:35:48,400
ಮತ್ತು ನಮ್ಮ ಉದ್ದೇಶಗಳಿಗಾಗಿ, ಎಡದಿಂದ 0 ನ ತುಂಬಲು.

521
00:35:48,400 --> 00:35:52,910
ಆದ್ದರಿಂದ ಈ ರೀತಿ, ನಾವು ಮೂಲಭೂತವಾಗಿ ನಾವು ಈಗಾಗಲೇ ಮಾಡಿದ ತಿರುಗುವ ಮಾಡುತ್ತಿದ್ದೇವೆ.

522
00:35:52,910 --> 00:35:57,780
ನಾವು, ಬಲಭಾಗದಲ್ಲಿ ಮೂರು 0 ನ ಕೇವಲ ಆಫ್ ಬಿದ್ದ ನೋಡಿ

523
00:35:57,780 --> 00:36:02,020
ಮತ್ತು ನಾವು ಬಲಕ್ಕೆ 1101 ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಮಂಡಿಸಿದರು.

524
00:36:02,020 --> 00:36:08,380
ಈ ಪರಿಣಾಮಕಾರಿಯಾಗಿ, X / 2 ^ ವೈ, ಇದು 104 >> 3 ಮಾಡುತ್ತಿರುವ.

525
00:36:08,380 --> 00:36:11,200
ಈಗ, ಇಲ್ಲಿ, ಅದು ಒಂದು ರೀತಿಯ ಉಪಾಯ.

526
00:36:11,200 --> 00:36:18,720
ಏಕೆ ಸ್ಥೂಲವಾಗಿ X / 2 ^ ವೈ, ಮತ್ತು ವಾಸ್ತವವಾಗಿ x / 2 ^ ವೈ?

527
00:36:18,720 --> 00:36:22,240
ನಾನು 4 ಸಂಗಮದತ್ತ ವೇಳೆ, ನಾನು 1 ಕಳೆದುಕೊಂಡಿದ್ದಾರೆ ಎಂದು ಕಾರಣ.

528
00:36:22,240 --> 00:36:25,950
ಮೂಲತಃ, ಹೇಳಬೇಕಾದ ಪೂರ್ಣಾಂಕ ವಿಭಾಗ ಯಾವ ನೀವು ನಗರದ, ಭಾವಿಸುತ್ತೇನೆ.

529
00:36:25,950 --> 00:36:31,070
ಆದ್ದರಿಂದ, 5/2 ನಂತಹ 2. ಇದು 2.5 ಅಲ್ಲ.

530
00:36:31,070 --> 00:36:35,000
ಇಲ್ಲಿ ಅದೇ ಉಪಾಯ. 2 ಭಾಗಿಸಿದಾಗ, ಯಾವಾಗ

531
00:36:35,000 --> 00:36:39,910
ನಾವು ದಾರಿಯುದ್ದಕ್ಕೂ ಬೆಸ ಬಿಟ್ಗಳು ಕಳೆದುಕೊಳ್ಳಬಹುದು.

532
00:36:39,910 --> 00:36:43,870
ಈಗ - ಎಂದು bitwise ಅದು. ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಎಲ್ಲಾ ಇಲ್ಲಿದೆ.

533
00:36:43,870 --> 00:36:46,340
ನಾವು ವರ್ಗ ಕಂಡಿತು ಬಳಕೆಯ ಪ್ರಕರಣಗಳು ನೆನಪಿಡಿ,

534
00:36:46,340 --> 00:36:49,340
ಒಂದು ಬಿಟ್ ಮುಖವಾಡ bitwise ನಿರ್ವಾಹಕರು ಉಪಯುಕ್ತ

535
00:36:49,340 --> 00:36:53,220
ಅಥವಾ ನೀವು ಸ್ವಲ್ಪ ಮುಖವಾಡಗಳನ್ನು ಬಳಸಲು.

536
00:36:53,220 --> 00:36:58,620
ಅಕ್ಷರಗಳಲ್ಲಿ ಮತ್ತು ಸಣ್ಣ ಅಕ್ಷರಗಳ, ಪರಿವರ್ತನೆಗಳು ಒಂದು ಸುಂದರ ಪಕ್ಕಾ ಉದಾಹರಣೆಯಾಗಿದೆ.

537
00:36:58,620 --> 00:37:01,640
>> ಸರಿ, ಆದ್ದರಿಂದ ಉಕ್ಕಿ ದಾಳಿ ಬಫರ್.

538
00:37:01,640 --> 00:37:05,110
ಯಾರಾದರೂ ಈ ಕಾರ್ಯದ ತಪ್ಪು ಎಂಬುದನ್ನು ನೆನಪಿಡಿ?

539
00:37:05,110 --> 00:37:10,140
ನಾವು 12 ಬೈಟ್ಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು, 12 ಅಕ್ಷರಗಳು, ಡಿಕ್ಲೇರ್ಡ್ ಗಮನಿಸಿ

540
00:37:10,140 --> 00:37:18,510
ನಂತರ ನಾವು 12 ಅಕ್ಷರಗಳನ್ನು ಇಡೀ ಸ್ಟ್ರಿಂಗ್ ಬಾರ್ ನಮ್ಮ ಬಫರ್ ಒಳಗೆ ನಕಲಿಸಿ.

541
00:37:18,510 --> 00:37:25,080
ಆದ್ದರಿಂದ ಸಮಸ್ಯೆ ಇಲ್ಲಿ ಏನಿದೆ?

542
00:37:25,080 --> 00:37:32,270
ಏಕೆ 12 - ಮ್ಯಾಜಿಕ್ ಸಂಖ್ಯೆ 12 ಬಹುಮಟ್ಟಿಗೆ ತಕ್ಷಣ ಮಾಹಿತಿ ಪಾಪ್ ಔಟ್ ಮಾಡಬೇಕು?

543
00:37:32,270 --> 00:37:35,050
ಬಾರ್ ಹೆಚ್ಚು 12 ಪಾತ್ರಗಳು ಎಂದು ಏನಾಗುತ್ತದೆ ವೇಳೆ?

544
00:37:35,050 --> 00:37:41,200
ಏನು ಬಾರ್ ಅಕ್ಷರಗಳನ್ನು ಲಕ್ಷಾಂತರ ವೇಳೆ?

545
00:37:41,200 --> 00:37:46,010
ಇಲ್ಲಿ ಸಮಸ್ಯೆ memcpy ಆಗಿದೆ. ಬಾರ್ ದೀರ್ಘ ಸಾಕಷ್ಟು ವೇಳೆ

546
00:37:46,010 --> 00:37:50,330
ಅದು ಸಂಪೂರ್ಣವಾಗಿ ಕಾಣಿಸುತ್ತದೆ - 'ಸಿ', 'ಸಿ' ಕೇವಲ 12 ಪಾತ್ರಗಳು ಎಂದು ಲೆಕ್ಕಕ್ಕೆ;

547
00:37:50,330 --> 00:37:53,280
'ಸಿ' ಇದು ಅನೇಕ ಬೈಟ್ಗಳು ಹೊಂದಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ಲೆಕ್ಕಕ್ಕೆ.

548
00:37:53,280 --> 00:37:58,250
ಅದು ಸಂಪೂರ್ಣವಾಗಿ ಚಾರ್ ಬದಲಿಸಿ, ನಾವು ಮಂಜೂರು ಮಾಡಿದ 12 ಬೈಟ್ಗಳು,

549
00:37:58,250 --> 00:38:01,830
ಮತ್ತು ಮೆಮೊರಿ ಕಳೆದ ಎಲ್ಲವೂ ವಾಸ್ತವವಾಗಿ ಬಫರ್ ಸೇರುವುದಿಲ್ಲ ಎಂದು

550
00:38:01,830 --> 00:38:06,520
ಏನೇ ಸ್ಟ್ರಿಂಗ್ ಬಾರ್ ಜೊತೆ.

551
00:38:06,520 --> 00:38:09,780
ಈ ನಾವು ವರ್ಗ ಕಂಡಿತು ಚಿತ್ರವನ್ನು

552
00:38:09,780 --> 00:38:12,220
ನಮ್ಮ ಸ್ಟಾಕ್ ಬೆಳೆಯುವ ಹೊಂದಿವೆ.

553
00:38:12,220 --> 00:38:16,040
ನೀವು ಈ ಚಿತ್ರಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಅಥವಾ ಮತ್ತೆ ಅವುಗಳನ್ನು ಪರಿಚಿತವಾಗಿರುವ ಪಡೆಯಲು ಮಾಡಬೇಕು.

554
00:38:16,040 --> 00:38:21,260
ನಮ್ಮ ಸ್ಟಾಕ್ ಬೆಳೆಯಲು, ಮೆಮೊರಿ ವಿಳಾಸಗಳನ್ನು ಮೇಲ್ಭಾಗದಲ್ಲಿ 0 ಆರಂಭವಾಗುವುದು

555
00:38:21,260 --> 00:38:26,270
ಮತ್ತು ಕೆಳಭಾಗದಲ್ಲಿ 4 ಶತಕೋಟಿ ಕೆಳಗೆ ಬೆಳೆಯಲು.

556
00:38:26,270 --> 00:38:28,820
ನಾವು, ಎಲ್ಲೋ ಮೆಮೊರಿ ನಮ್ಮ ರಚನೆಯ 'ಸಿ' ಹೊಂದಿವೆ

557
00:38:28,820 --> 00:38:32,260
ನಂತರ ನಾವು ಬಲ ಕೆಳಗೆ ಬಾರ್ಗೆ ನಮ್ಮ ಪಾಯಿಂಟರ್,

558
00:38:32,260 --> 00:38:38,720
ತದನಂತರ ಈ ಉಳಿಸಿದ ಫ್ರೇಮ್ ನಮ್ಮ ರಿಟರ್ನ್ ವಿಳಾಸಕ್ಕೆ ರಲ್ಲಿ ಪಾಯಿಂಟರ್ ಮತ್ತು ನಮ್ಮ ಮೂಲ ದಿನಚರಿಯ ಸ್ಟಾಕ್ ಹೊಂದಿವೆ.

559
00:38:38,720 --> 00:38:40,800
ರಿಟರ್ನ್ ವಿಳಾಸಕ್ಕೆ ಏನು ನೆನಪಿಡಿ?

560
00:38:40,800 --> 00:38:45,360
ಮುಖ್ಯ ಕಾರ್ಯ ಕರೆಗಳನ್ನು ಬಾರ್, ಒಂದು ಕಾರ್ಯ foo ​​ಕರೆಗಳು ಅದು ಇಲ್ಲಿದೆ

561
00:38:45,360 --> 00:38:48,100
ಅನಿವಾರ್ಯವಾಗಿ, ಆದಾಯ ಅಡ್ಡಿಯುಂಟು.

562
00:38:48,100 --> 00:38:52,610
ಆದ್ದರಿಂದ ಬಾರ್ ಆದಾಯ, ಅವರು ಎಂಬ foo, ಮತ್ತೆ ವಿಶೇಷವೇನು ಎಂದು ತಿಳಿದುಕೊಳ್ಳಬೇಕು.

563
00:38:52,610 --> 00:39:01,360
ಆದ್ದರಿಂದ ರಿಟರ್ನ್ ವಿಳಾಸಕ್ಕೆ ಮಾಡಿದಾಗ ಕಾರ್ಯ ಮರಳುತ್ತದೆ ಮರಳಲು ಎಂದು ಕಾರ್ಯ ವಿಳಾಸ.

564
00:39:01,360 --> 00:39:05,830
, ಅನುಕೂಲಕರವಾಗಿ, ಏಕೆಂದರೆ ಬಫರ್ ದಾಳಿ ಪ್ರಮುಖ ಕಾರಣ

565
00:39:05,830 --> 00:39:09,580
ಹ್ಯಾಕರ್ಸ್ ರಿಟರ್ನ್ ವಿಳಾಸಕ್ಕೆ ಬದಲಾಯಿಸಲು ಬಯಸುತ್ತೀರೆ.

566
00:39:09,580 --> 00:39:14,950
ಬದಲಿಗೆ ಮತ್ತೆ foo, ಹೋಗುವ, ನಾನು ಮತ್ತೆ ಹ್ಯಾಕರ್ ನನಗೆ ಮತ್ತೆ ಹೋಗಲು ಬಯಸುತ್ತಾರೆ ಎಲ್ಲೆಲ್ಲಿ ಹೋಗಿ ಪಡೆಯಲಿದ್ದೇನೆ.

567
00:39:14,950 --> 00:39:17,760
ಮತ್ತು, ಅನುಕೂಲಕರವಾಗಿ, ಹ್ಯಾಕರ್ ಆಗಾಗ್ಗೆ ಹಿಂದಕ್ಕೆ ಹೋಗಬೇಕು ಅಲ್ಲಿ

568
00:39:17,760 --> 00:39:22,400
ನಾವು ಮೂಲತಃ ಎಂದು ಬಫರ್ ಪ್ರಾರಂಭ.

569
00:39:22,400 --> 00:39:26,170
ಆದ್ದರಿಂದ, ಮತ್ತೆ, ಲಿಟಲ್ ಭಾರತೀಯ ಗಮನಕ್ಕೆ.

570
00:39:26,170 --> 00:39:28,490
APPLIANCE ಒಂದು ಲಿಟಲ್ ಭಾರತೀಯ ವ್ಯವಸ್ಥೆಯ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ,

571
00:39:28,490 --> 00:39:34,140
ಆದ್ದರಿಂದ ಒಂದು ಪೂರ್ಣಾಂಕ ಅಥವಾ ಪಾಯಿಂಟರ್ ವ್ಯತಿರಿಕ್ತವಾಗಿದೆ ಬೈಟ್ಗಳು ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ.

572
00:39:34,140 --> 00:39:38,980
ಇಲ್ಲಿ ನಾವು ನೋಡಿ - ಈ? ಹೌದು.

573
00:39:38,980 --> 00:39:45,660
ನಾವು Ox80, OxC0, Ox35, OxO8 ನೋಡಿ.

574
00:39:45,660 --> 00:39:48,250
ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಅಂಕೆಗಳು ನೆನಪಿಡಿ?

575
00:39:48,250 --> 00:39:50,640
ನಾವು, ಲಿಟಲ್ ಭಾರತೀಯ ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಅಂಕೆಗಳು ರಿವರ್ಸ್ ಇಲ್ಲ

576
00:39:50,640 --> 00:39:56,110
2 ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಅಂಕೆಗಳು ಒಂದು ಬೈಟ್ ಮಾಡಲು, ಮತ್ತು ನಾವು ಬೈಟ್ಗಳು ರಿವರ್ಸ್ ಏಕೆಂದರೆ.

577
00:39:56,110 --> 00:40:00,300
ಏಕೆ ನಾವು, ಹಾಗೆ, 80530CO8 ಸಂಗ್ರಹಿಸಲು ಎಂದು ಇಲ್ಲಿದೆ.

578
00:40:00,300 --> 00:40:07,520
ನಾವು ಬಲ ಆರಂಭಿಸಿ, ಬದಲಿಗೆ, 2 ಅಂಕೆಗಳು ಪ್ರತಿ ಜೋಡಿ ಶೇಖರಿಸಿಡಲು.

579
00:40:07,520 --> 00:40:10,880
ಆ ವಿಳಾಸ ಪ್ರಾರಂಭ ವಿಳಾಸವನ್ನು ಸೂಚಿಸುತ್ತದೆ

580
00:40:10,880 --> 00:40:15,190
ನಾವು ವಾಸ್ತವವಾಗಿ ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ ನಕಲಿಸಿ ಮಾಡಬೇಕೆಂದು ನಮ್ಮ ಬಫರ್.

581
00:40:15,190 --> 00:40:19,230
ಉಪಯುಕ್ತ ಎಂದು ಕಾರಣ ಏನು ವೇಳೆ, ಏಕೆಂದರೆ ಆಕ್ರಮಣಕಾರರೊಂದಿಗೆ

582
00:40:19,230 --> 00:40:24,100
ಬದಲಿಗೆ ಕೇವಲ ಎಂದು ಸ್ಟ್ರಿಂಗ್ ಹೊಂದುವ, ಏನಾಯಿತು

583
00:40:24,100 --> 00:40:27,060
ಹಾಗೆ ಒಂದು ನಿರುಪದ್ರವ ಸ್ಟ್ರಿಂಗ್, ಅವರ ಹೆಸರು ಅಥವಾ ಏನೋ,

584
00:40:27,060 --> 00:40:33,900
ಹೀಗಾದರೆ, ಬದಲಿಗೆ, ಆ ವಾಕ್ಯವನ್ನು ಕೆಲವು ನಿರಂಕುಶ ಕೋಡ್ ಇದ್ದರು

585
00:40:33,900 --> 00:40:38,610
ಅವರು ಅದನ್ನು ಮಾಡಲು ನಮಗೇನು ಮಾಡಿದರು?

586
00:40:38,610 --> 00:40:45,630
ಆದ್ದರಿಂದ ಅವರು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ - ನಾನು ಯಾವುದೇ ತಂಪಾದ ಕೋಡ್ ಯೋಚಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

587
00:40:45,630 --> 00:40:47,780
ಇದು ಆದರೂ, ಏನು ಎಂದು. ಯಾವುದೇ ಹಾನಿಕಾರಕ ಕೋಡ್.

588
00:40:47,780 --> 00:40:51,440
ಅವರು ಬಯಸಿದರೆ, ಅವರು ಕೇವಲ seg ದೋಷಗಳನ್ನು ನಲ್ಲಿ ಏನಾದರೂ ಸಾಧ್ಯವಾಯಿತು, ಆದರೆ ನಿರರ್ಥಕವಾಗುತ್ತದೆ.

589
00:40:51,440 --> 00:40:54,950
ಅವರು ಸಾಮಾನ್ಯವಾಗಿ ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಯ ಹ್ಯಾಕ್ ಅದನ್ನು.

590
00:40:54,950 --> 00:40:59,930
>> ಸರಿ. CS50 ಗ್ರಂಥಾಲಯದ.

591
00:40:59,930 --> 00:41:04,800
ಈ, ಮೂಲತಃ, GetInt, GetString, ಎಲ್ಲಾ ಆ ಕಾರ್ಯಗಳನ್ನು ನಾವು ನಿಮಗಾಗಿ ಒದಗಿಸಲಾಗುತ್ತದೆ.

592
00:41:04,800 --> 00:41:10,630
ನಾವು ಚಾರ್ * ಸ್ಟ್ರಿಂಗ್ ಹೊಂದಿವೆ, ಮತ್ತು ನಾವು ದೂರ ಬೀಸಿದ ಅಮೂರ್ತತೆ ಇಲ್ಲಿದೆ

593
00:41:10,630 --> 00:41:12,450
ಸೆಮಿಸ್ಟರ್ ಸಂದರ್ಭದಲ್ಲಿ.

594
00:41:12,450 --> 00:41:18,220
ಸ್ಟ್ರಿಂಗ್ ಕೇವಲ ಪಾತ್ರಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ.

595
00:41:18,220 --> 00:41:23,240
ಇಲ್ಲಿ ನಾವು GetString ಒಂದು ಸಂಕ್ಷಿಪ್ತ ಆವೃತ್ತಿಯನ್ನು ನೋಡಿ.

596
00:41:23,240 --> 00:41:25,920
ನೀವು ನಿಜವಾಗಿ ಕಾರ್ಯರೂಪಕ್ಕೆ ಹೇಗೆ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಇದು, ಹಿಂತಿರುಗಿ ನೋಡಲು.

597
00:41:25,920 --> 00:41:30,950
ಕೀ ವಿವರಗಳನ್ನು, ನಾವು ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಪಾತ್ರ ಪಡೆಯಲು ಗಮನಕ್ಕೆ

598
00:41:30,950 --> 00:41:34,570
ಕೇವಲ ನಮಗೆ ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ ಟೈಪ್ ಹಾಗೆ, ಗುಣಮಟ್ಟದ ನಿಂದ.

599
00:41:34,570 --> 00:41:37,890
ಆದ್ದರಿಂದ ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಪಾತ್ರ ಮತ್ತು ನಾವು ಹಲವು ಪಾತ್ರಗಳು ಸಿಕ್ಕಿದರೆ,

600
00:41:37,890 --> 00:41:40,580
ಆದ್ದರಿಂದ n + 1 ಸಾಮರ್ಥ್ಯ ಹೆಚ್ಚಾಗಿದೆ ವೇಳೆ,

601
00:41:40,580 --> 00:41:44,140
ನಂತರ ನಾವು ನಮ್ಮ ಬಫರ್ ಸಾಮರ್ಥ್ಯ ಹೆಚ್ಚಿಸುವ ಅಗತ್ಯವಿದೆ.

602
00:41:44,140 --> 00:41:47,780
ಇಲ್ಲಿ ನಾವು ನಮ್ಮ ಬಫರ್ ಗಾತ್ರದ ಡಬಲ್ ಆಗಿರುವ.

603
00:41:47,780 --> 00:41:51,840
ಮತ್ತು ದುವರಿಯುತ್ತಿರುತ್ತದೆ; ನಾವು ನಮ್ಮ ಬಫರ್ ಒಳಗೆ ಚಿಹ್ನೆಯನ್ನು ಸೇರಿಸಲು

604
00:41:51,840 --> 00:41:56,220
ಒಂದು ಹೊಸ ಸಾಲನ್ನು ಅಥವಾ ಫೈಲ್ ಅಥವಾ ಯಾವುದೇ ಕೊನೆಯಲ್ಲಿ ಪಡೆಯುವ ತನಕ,

605
00:41:56,220 --> 00:41:59,380
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಸ್ಟ್ರಿಂಗ್ ತದನಂತರ ನಿಜವಾದ getString ಪೂರೈಸಿದ

606
00:41:59,380 --> 00:42:05,120
ನಾವು ತುಂಬಾ ಮೆಮೊರಿ ಹಂಚಿಕೆ ಅದು ಮತ್ತೆ ಹೋಗಿ ಸ್ವಲ್ಪ ಕುಗ್ಗಿಸಿ ಮಾಡುತ್ತೇವೆ ಹಾಗೆ, ಮೆಮೊರಿ ಕುಗ್ಗುತ್ತದೆ.

607
00:42:05,120 --> 00:42:08,830
ಆದ್ದರಿಂದ ನಾವು ತೋರಿಸುವುದಿಲ್ಲ, ಆದರೆ ಮುಖ್ಯ ಕಲ್ಪನೆ

608
00:42:08,830 --> 00:42:11,960
ಇದು ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಪಾತ್ರ ಓದಲು ಹೊಂದಿದೆ.

609
00:42:11,960 --> 00:42:17,140
ಇದು ಕೇವಲ ಒಮ್ಮೆ ಒಂದು ವಿಷಯವನ್ನು ಓದಲು ಸಾಧ್ಯವಿಲ್ಲ,

610
00:42:17,140 --> 00:42:19,550
ತಮ್ಮ ಬಫರ್ ಕೇವಲ ಒಂದು ನಿರ್ದಿಷ್ಟ ಗಾತ್ರದ ಏಕೆಂದರೆ.

611
00:42:19,550 --> 00:42:26,590
ಇದು ಬಫರ್ ಸೇರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಸ್ಟ್ರಿಂಗ್ ತುಂಬಾ ದೊಡ್ಡದಾಗಿದೆ ಆದ್ದರಿಂದ, ಅದು ಉಕ್ಕಿ ಎಂದು.

612
00:42:26,590 --> 00:42:28,940
ಇಲ್ಲಿ ನಾವು ತಪ್ಪಿಸುವ ಒಂದೇ ಅಕ್ಷರ ಓದುವ ಮೂಲಕ

613
00:42:28,940 --> 00:42:33,750
ಒಂದು ಸಮಯದಲ್ಲಿ ಮತ್ತು ನಾವು ಅಗತ್ಯವಿದೆ ಬಂದ ಬೆಳೆಯುತ್ತಿರುವ.

614
00:42:33,750 --> 00:42:40,270
ಆದ್ದರಿಂದ GetInt ಮತ್ತು ಇತರ CS50 ಗ್ರಂಥಾಲಯದ ಕಾರ್ಯಗಳನ್ನು GetString ಬಳಸಲು ಒಲವು

615
00:42:40,270 --> 00:42:42,310
ತಮ್ಮ ಅಳವಡಿಕೆಗಳು.

616
00:42:42,310 --> 00:42:45,370
ಹಾಗಾಗಿ ಇಲ್ಲಿ ಪ್ರಮುಖ ವಿಷಯಗಳನ್ನು ಹೈಲೈಟ್.

617
00:42:45,370 --> 00:42:49,460
ಇದು ಸ್ಟ್ರಿಂಗ್ ಪಡೆಯಲು GetString ಕರೆಗಳನ್ನು.

618
00:42:49,460 --> 00:42:51,710
ನೆನಪಿನಿಂದ GetString ಮರಳಲು ವಿಫಲವಾದರೆ,

619
00:42:51,710 --> 00:42:54,270
getString ಏನೋ mallocs ನೆನಪಿಡಿ, ಆದ್ದರಿಂದ ನೀವು GetString ಕರೆ ಬಂದ

620
00:42:54,270 --> 00:42:57,820
ನೀವು (ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ) ನೀವು ಕೊಂಡಿರುವ ಸ್ಟ್ರಿಂಗ್ ಮುಕ್ತಗೊಳಿಸಲು ಮಾಡಬಾರದು.

621
00:42:57,820 --> 00:43:02,870
ಇದು ಏನೋ malloc ವಿಫಲವಾಗಿದೆ ಆದ್ದರಿಂದ ಇಲ್ಲಿ, ನಾವು ಕೇವಲ ಒಂದು ಇಲ್ಲದ್ದನ್ನು INT_MAX ಮರಳಿ ಎಂದು,

622
00:43:02,870 --> 00:43:05,650
ಹೇ, ನಾವು ವಾಸ್ತವವಾಗಿ ಒಂದು ಪೂರ್ಣಾಂಕ ಪಡೆಯಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.

623
00:43:05,650 --> 00:43:10,830
ನೀವು ನಾನು ನೀವು ಮರಳಲು ಯಾವುದೇ ನಿರ್ಲಕ್ಷಿಸಿ, ಅಥವಾ ಮಾಡಬೇಕು

624
00:43:10,830 --> 00:43:15,540
ನೀವು ಮಾನ್ಯ ಇನ್ಪುಟ್ ಈ ಚಿಕಿತ್ಸೆ ಮಾಡಬಾರದು.

625
00:43:15,540 --> 00:43:21,360
ಅಂತಿಮವಾಗಿ, ಆ ಯಶಸ್ಸನ್ನು ಕಾಣಲಿಲ್ಲ ಊಹಿಸಿಕೊಂಡು, ನಾವು, ಆ ವಿಶೇಷ ಧ್ವಜವು sscanf ಬಳಸಲು

626
00:43:21,360 --> 00:43:23,820
ಅಂದರೆ, ಮೊದಲ ಒಂದು ಪೂರ್ಣಾಂಕ ಹೊಂದಿಸಲು,

627
00:43:23,820 --> 00:43:26,770
ನಂತರ ಪೂರ್ಣಾಂಕ ನಂತರ ಯಾವುದೇ ಅಕ್ಷರಗಳಿಗೆ.

628
00:43:26,770 --> 00:43:29,070
ಆದ್ದರಿಂದ ನಾವು 1 ಸಮನಾಗಿರಬೇಕು ಬಯಸುವ ಗಮನಕ್ಕೆ.

629
00:43:29,070 --> 00:43:32,940
ಆದ್ದರಿಂದ sscanf ಮರಳುತ್ತದೆ ಯಶಸ್ವಿಯಾಗಿ ಎಷ್ಟು ಪಂದ್ಯಗಳಲ್ಲಿ ಮಾಡಿದ ವೇಳೆ?

630
00:43:32,940 --> 00:43:37,010
ಇದು ಯಶಸ್ವಿಯಾಗಿ ಒಂದು ಪೂರ್ಣಾಂಕ ದಾಖಲೆಗಳುಸರಿಹೊಂದಿವೆ ವೇಳೆ 1 ಹಿಂತಿರುಗುವುದು,

631
00:43:37,010 --> 00:43:40,890
ಇದು ಒಂದು ಪೂರ್ಣಾಂಕ ಹೊಂದಿಕೆಯಾಗಲಿಲ್ಲ ವೇಳೆ 0 ಹಿಂತಿರುಗುವುದು, ಮತ್ತು ಇದು 2 ಹಿಂತಿರುಗುವುದು

632
00:43:40,890 --> 00:43:45,920
ಇದು ದಾಖಲೆಗಳುಸರಿಹೊಂದಿವೆ ವೇಳೆ ಒಂದು ಪೂರ್ಣಾಂಕ ಕೆಲವು ಪಾತ್ರದ ನಂತರ.

633
00:43:45,920 --> 00:43:49,780
ನಾವು 1 ಆದರೆ ಏನು ಹೊಂದಾಣಿಕೆ ವೇಳೆ ನಾವು ಮರುಪ್ರಯತ್ನಿಸಿ ಗಮನಕ್ಕೆ.

634
00:43:49,780 --> 00:43:55,230
ನಾವು ದಾಖಲಿಸಿದರೆ 1, 2, 3, ಸಿ, ಅಥವಾ 1, 2, 3, ಎಕ್ಸ್,

635
00:43:55,230 --> 00:43:57,400
ನಂತರ 1, 2, 3 ಪೂರ್ಣಾಂಕ ಸಂಗ್ರಹವಾಗುತ್ತದೆ ಎಂದು,

636
00:43:57,400 --> 00:43:59,620
ಎಕ್ಸ್, ಪಾತ್ರದ ನಲ್ಲಿ ಸಂಗ್ರಹವಾಗುತ್ತದೆ ಎಂದು

637
00:43:59,620 --> 00:44:06,410
ನಾವು ಮಾತ್ರ ಒಂದು ಪೂರ್ಣಾಂಕ ಬಯಸುವ ಏಕೆಂದರೆ, sscanf 2 ಹಿಂತಿರುಗಿ, ಮತ್ತು ನಾವು ಮರುಪ್ರಯತ್ನಿಸಿ ಎಂದು.

638
00:44:06,410 --> 00:44:09,810
>> ತ್ವರಿತವಾಗಿ ಎಚ್ಟಿಎಮ್ಎಲ್, HTTP ಸಿಎಸ್ಎಸ್ ಮೂಲಕ ಊದುವ.

639
00:44:09,810 --> 00:44:15,340
ಹೈಪರ್ ಟೆಕ್ಸ್ಟ್ ಮಾರ್ಕಪ್ ಲಾಂಗ್ವೇಜ್ ವೆಬ್ ರಚನೆ ಮತ್ತು ಶಬ್ದಾರ್ಥ ಆಗಿದೆ.

640
00:44:15,340 --> 00:44:19,960
ಇಲ್ಲಿ ನಾವು HTML ಟ್ಯಾಗ್ಗಳನ್ನು ಹೊಂದಿವೆ ಉಪನ್ಯಾಸ ಉದಾಹರಣೆಯಾಗಿದೆ.

641
00:44:19,960 --> 00:44:22,110
ನಾವು ತಲೆ ಟ್ಯಾಗ್ಗಳು, ದೇಹದ ಟ್ಯಾಗ್ಗಳನ್ನು ಹೊಂದಿವೆ

642
00:44:22,110 --> 00:44:27,770
ನಾವು, ನಾವು ವಾಸ್ತವವಾಗಿ ಒಂದು ಆರಂಭದ ಮತ್ತು ನಿಕಟ ಟ್ಯಾಗ್ ಇಲ್ಲ ಅಲ್ಲಿ ಖಾಲಿ ಟ್ಯಾಗ್ಗಳನ್ನು ಉದಾಹರಣೆಗಳು ಹೊಂದಿವೆ

643
00:44:27,770 --> 00:44:30,820
ನಾವು ಲಿಂಕ್ ಮತ್ತು ಇಮೇಜ್.

644
00:44:30,820 --> 00:44:38,480
ಯಾವುದೇ ಮುಚ್ಚುವ ಚಿತ್ರ ಟ್ಯಾಗ್ ಇಲ್ಲ; ಟ್ಯಾಗ್ ಅಗತ್ಯವಿದೆ ಎಲ್ಲವೂ ಒಳಗೊಂಡಿದೆ ಕೇವಲ ಒಂದು ಟ್ಯಾಗ್ ಇಲ್ಲ.

645
00:44:38,480 --> 00:44:41,950
ಲಿಂಕ್ ಉದಾಹರಣೆಯಾಗಿದೆ; ನಾವು ನೀವು ಸಿಎಸ್ಎಸ್ ಸಂಪರ್ಕ ಹೇಗೆ ನೋಡುತ್ತಾರೆ,

646
00:44:41,950 --> 00:44:45,910
ಸ್ಕ್ರಿಪ್ಟ್ ನೀವು ಬಾಹ್ಯ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಂಪರ್ಕ ಹೇಗೆ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.

647
00:44:45,910 --> 00:44:53,100
ಇದು HTML ಒಂದು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ ಅಲ್ಲ, ಬಹಳ ಸರಳ, ಮತ್ತು ನೆನಪು.

648
00:44:53,100 --> 00:44:58,250
ಇಲ್ಲಿ, ನೀವು ಈ ಏನು ಒಂದು ರೂಪ ವ್ಯಾಖ್ಯಾನಿಸಲು ಅಥವಾ ಕನಿಷ್ಠ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ?

649
00:44:58,250 --> 00:45:01,740
ಇಂತಹ ರೂಪ ಕ್ರಿಯಾಶೀಲ ಮತ್ತು ವಿಧಾನ ಹೊಂದಿದೆ.

650
00:45:01,740 --> 00:45:06,210
ನೀವು ಎಂದಾದರೂ ನೋಡುತ್ತಾರೆ ವಿಧಾನಗಳು ಮತ್ತು ಪೋಸ್ಟ್.

651
00:45:06,210 --> 00:45:09,040
ಆದ್ದರಿಂದ GET ವಿಷಯ URL ಅನ್ನು ಪುಟ್ ಅಲ್ಲಿ ಆವೃತ್ತಿಯಾಗಿದೆ.

652
00:45:09,040 --> 00:45:11,680
ಇದು URL ನಲ್ಲಿ ಹಾಕಿ ಇದೆ ಅಲ್ಲಿ ಪೋಸ್ಟ್ ಆಗಿದೆ.

653
00:45:11,680 --> 00:45:18,520
ಬದಲಿಗೆ, ರೂಪ ಯಾವುದೇ ದಶಮಾಂಶ HTTP ವಿನಂತಿ ಹೆಚ್ಚು ಗುಪ್ತ ಸೇರಿಸಲಾಗುತ್ತದೆ.

654
00:45:18,520 --> 00:45:22,390
HTTP ವಿನಂತಿ ಹೋಗುತ್ತದೆ ಅಲ್ಲಿ ಇಲ್ಲಿ, ಕ್ರಮ ವರ್ಣಿಸಬಹುದು.

655
00:45:22,390 --> 00:45:27,490
ಇದು ವಿಶೇಷವೇನು ಅಲ್ಲಿ google.com / ಶೋಧನೆ.

656
00:45:27,490 --> 00:45:32,890
ವಿಧಾನ. GET ಮತ್ತು ಪೋಸ್ಟ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳು ನೆನಪಿಡಿ,

657
00:45:32,890 --> 00:45:37,200
ನೀವು ಬುಕ್ಮಾರ್ಕ್ ಏನೋ ಬಯಸಿದರೆ, ಕೇವಲ, ಉದಾಹರಣೆಯಾಗಿ ಹೇಳಬಹುದು.

658
00:45:37,200 --> 00:45:40,660
ನೀವು ಒಂದು ಪೋಸ್ಟ್ URL ಅನ್ನು ಬುಕ್ಮಾರ್ಕ್ ಸಾಧ್ಯವಾಗುತ್ತದೆ ಎಂದಿಗೂ

659
00:45:40,660 --> 00:45:44,970
ಡೇಟಾ URL ನಲ್ಲಿ ಸೇರಿಸಲಾಗಿಲ್ಲ ಏಕೆಂದರೆ.

660
00:45:44,970 --> 00:45:49,790
>> ಎಚ್ಟಿಟಿಪಿ, ಈಗ, ಹೈಪರ್ಟೆಕ್ಸ್ಟ್ ಟ್ರಾನ್ಸ್ಫರ್ ಪ್ರೊಟೋಕಾಲ್ ಆಗಿದೆ.

661
00:45:49,790 --> 00:45:54,080
ಹೈಪರ್ಟೆಕ್ಸ್ಟ್ ಟ್ರಾನ್ಸ್ಫರ್ ಪ್ರೊಟೋಕಾಲ್, ನೀವು ವರ್ಗಾಯಿಸಲು ನಿರೀಕ್ಷಿಸಬಹುದು

662
00:45:54,080 --> 00:45:57,710
ಹೈಪರ್ ಟೆಕ್ಸ್ಟ್ ಮಾರ್ಕಪ್ ಲಾಂಗ್ವೇಜ್, ಮತ್ತು ಅದು.

663
00:45:57,710 --> 00:46:00,170
ಆದರೆ ಇದು ನೀವು ವೆಬ್ ಹುಡುಕಲು ಯಾವುದೇ ಚಿತ್ರಗಳನ್ನು ವರ್ಗಾಯಿಸುತ್ತದೆ,

664
00:46:00,170 --> 00:46:05,400
ನೀವು ಮಾಡುವ ಯಾವುದೇ ಡೌನ್ಲೋಡ್ಗಳು ಒಂದು HTTP ಕೋರಿಕೆಯನ್ನು ಆರಂಭಿಸಲು.

665
00:46:05,400 --> 00:46:10,350
ಆದ್ದರಿಂದ HTTP ಕೇವಲ ವರ್ಲ್ಡ್ ವೈಡ್ ವೆಬ್ ಭಾಷೆಯಾಗಿದೆ.

666
00:46:10,350 --> 00:46:15,610
ಇಲ್ಲಿ ನೀವು ಒಂದು HTTP ಕೋರಿಕೆಯನ್ನು ಈ ರೀತಿಯ ಗುರುತಿಸುವ ಅಗತ್ಯವಿದೆ.

667
00:46:15,610 --> 00:46:19,300
ಬದಿಯಲ್ಲಿ ಇಲ್ಲಿ HTTP/1.1 ಕೇವಲ ಆವೃತ್ತಿ ಹೇಳುತ್ತಾರೆ

668
00:46:19,300 --> 00:46:21,570
ಶಿಷ್ಟಾಚಾರದ ನಾನು ಬಳಸಿಕೊಂಡು ನಾನು.

669
00:46:21,570 --> 00:46:25,770
ನೀವು ನೋಡುತ್ತಾರೆ ಎಂದು ಬಹುಮಟ್ಟಿಗೆ ಯಾವಾಗಲೂ, HTTP/1.1 ಎಂದು ವಿಶೇಷವೇನು.

670
00:46:25,770 --> 00:46:30,110
ನಂತರ ನಾವು ಈ ನೀವು ನೋಡಿ ಎಂದು, ಪರ್ಯಾಯ ಪೋಸ್ಟ್ ಬೀಯಿಂಗ್, ಪಡೆಯಲು ಎಂದು ನೋಡಿ.

671
00:46:30,110 --> 00:46:40,790
ನಾನು ಭೇಟಿ ಹಾಕಿದ್ದೆ ಆ URL www.google.com/search?q = blah, blah blah ಆಗಿತ್ತು.

672
00:46:40,790 --> 00:46:44,240
ಆದ್ದರಿಂದ ನೆನಪಿಡಿ ಈ, ಪ್ರಶ್ನೆ ಗುರುತು Q = blah blah blah,

673
00:46:44,240 --> 00:46:49,040
ಒಂದು ರೂಪ ಸಲ್ಲಿಸಿದ ಇದೆ ವಿಷಯವನ್ನು ತೆರನಾದ.

674
00:46:49,040 --> 00:46:51,830
ನನಗೆ ಮರಳಿ ಇರಬಹುದು ಪ್ರತಿಕ್ರಿಯೆಯ ಈ ರೀತಿಯ ನೋಡುತ್ತಿದ್ದರು.

675
00:46:51,830 --> 00:46:54,050
ಮತ್ತೆ ಆ ಏರಲಿದೆ ಇದು ಪ್ರೋಟೋಕಾಲ್ ಆರಂಭಗೊಂಡು,

676
00:46:54,050 --> 00:46:59,190
ಸ್ಥಿತಿಯನ್ನು ಕೋಡ್ ನಂತರ. ಇಲ್ಲಿ 200 ಒಕೆ.

677
00:46:59,190 --> 00:47:05,060
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾನು ವಾಸ್ತವವಾಗಿ ಕೇಳಿದರು ವೆಬ್ ಪುಟ ಅನುಸರಿಸಲಾಗುವುದು.

678
00:47:05,060 --> 00:47:08,210
ಸಾಧ್ಯವಾದಷ್ಟು ಸ್ಥಿತಿಯನ್ನು ಕೋಡ್ ನೀವು ವೀಕ್ಷಿಸಬಹುದು, ಮತ್ತು ನೀವು ಅವುಗಳನ್ನು ಹಲವಾರು ತಿಳಿಯಬೇಕಿದೆ.

679
00:47:08,210 --> 00:47:12,770
200 ಸರಿ ನೀವು ಬಹುಶಃ ಮೊದಲು ಕಂಡ.

680
00:47:12,770 --> 00:47:17,830
403 ಫರ್ಬಿಡನ್, 404 ಕಂಡುಬಂದಿಲ್ಲ, 500 ಆಂತರಿಕ ಸರ್ವರ್ ದೋಷ

681
00:47:17,830 --> 00:47:22,140
ನೀವು ವೆಬ್ಸೈಟ್ಗೆ ಹೋಗಿ ಮತ್ತು ಏನೋ ಮುರಿದ ಅಥವಾ ತಮ್ಮ ಪಿಎಚ್ಪಿ ಕೋಡ್ ಕ್ರ್ಯಾಶ್, ಸಾಮಾನ್ಯವಾಗಿ

682
00:47:22,140 --> 00:47:24,930
ಉಪಕರಣಗಳಲ್ಲಿರುವ ನಾವು ಆದರೆ ದೊಡ್ಡ ಕಿತ್ತಳೆ ಬಾಕ್ಸ್

683
00:47:24,930 --> 00:47:27,830
ಎಂದು ಬರುತ್ತದೆ ಮತ್ತು ಹಾಗೆ, ಏನೋ ತಪ್ಪು, ಹೇಳುತ್ತಾರೆ, ಈ ಕೋಡ್ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ

684
00:47:27,830 --> 00:47:30,380
ಅಥವಾ ಈ ಕಾರ್ಯ ಕೆಟ್ಟ.

685
00:47:30,380 --> 00:47:33,230
ಸಾಮಾನ್ಯವಾಗಿ ವೆಬ್ಸೈಟ್, ನೀವು ಕಾರ್ಯಗಳನ್ನು ನಿಜವಾಗಿ ಕೆಟ್ಟ ತಿಳಿದುಕೊಳ್ಳುವುದರಿಂದ ಬಯಸುವುದಿಲ್ಲ

686
00:47:33,230 --> 00:47:37,880
ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಅವರು ಕೇವಲ ನೀವು 500 ಆಂತರಿಕ ಸರ್ವರ್ ದೋಷಗಳು ನೀಡುತ್ತೇನೆ.

687
00:47:37,880 --> 00:47:43,050
>> ಟಿಸಿಪಿ / ಐಪಿ ಎಚ್ಟಿಟಿಪಿ ಅಡಿಯಲ್ಲಿ 1 ಪದರ.

688
00:47:43,050 --> 00:47:47,550
ಇಂಟರ್ನೆಟ್ ವರ್ಲ್ಡ್ ವೈಡ್ ವೆಬ್ ಹೊರಗೆ ಎಂದು ನೆನಪಿಡಿ.

689
00:47:47,550 --> 00:47:52,270
ಲೈಕ್ ನೀವು HTTP ಮೂಲಕ ಹೋಗುವುದಿಲ್ಲ ಎಂದು ಆನ್ಲೈನ್ ಆಟ ವೇಳೆ,

690
00:47:52,270 --> 00:47:55,740
ಇದು ಬೇರೆ ಮೂಲಕ ವಿಶೇಷವೇನು - ಇದು ಇನ್ನೂ ಇಂಟರ್ನೆಟ್ ಬಳಸಿಕೊಂಡು,

691
00:47:55,740 --> 00:47:58,900
ಆದರೆ ಇದು HTTP ಬಳಸುವುದಿಲ್ಲ.

692
00:47:58,900 --> 00:48:02,470
ಎಚ್ಟಿಟಿಪಿ TCP / IP ನಿರ್ಮಿಸಿದ ಪ್ರೋಟೋಕಾಲ್ ಕೇವಲ ಒಂದು ಉದಾಹರಣೆ.

693
00:48:02,470 --> 00:48:07,820
ಐಪಿ ಅಕ್ಷರಶಃ ಇಂಟರ್ನೆಟ್ ಪ್ರೊಟೊಕಾಲ್ ಅರ್ಥ.

694
00:48:07,820 --> 00:48:11,500
ಪ್ರತಿ ಕಂಪ್ಯೂಟರ್ IP ವಿಳಾಸವನ್ನು ಹೊಂದಿದೆ; ಅವರು ಆ 4 ಅಂಕಿಯ ವಸ್ತುಗಳು

695
00:48:11,500 --> 00:48:16,510
192.168.2.1, ಅಥವಾ ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ; ಎಂದು ಸ್ಥಳೀಯ ಒಂದಾಗಿದೆ ಕಾಣುತ್ತಾರೆ.

696
00:48:16,510 --> 00:48:23,390
ಆದರೆ ಒಂದು IP ವಿಳಾಸ ರೀತಿಯಾಗಿದೆ.

697
00:48:23,390 --> 00:48:29,060
ಆದ್ದರಿಂದ, DNS, ಡೊಮೈನ್ ಹೆಸರು ಸೇವೆ,

698
00:48:29,060 --> 00:48:33,410
ನಿಜವಾದ IP ಗೆ google.com ವಿಷಯಗಳನ್ನು ಅನುವಾದಿಸಲಾಗುತ್ತದೆ ಇಲ್ಲಿದೆ.

699
00:48:33,410 --> 00:48:37,700
ಆದ್ದರಿಂದ ನೀವು ಒಂದು URL ಒಳಗೆ ಎಂದು IP ವಿಳಾಸವನ್ನು ನಮೂದಿಸಿ ವೇಳೆ,

700
00:48:37,700 --> 00:48:40,850
ಎಂದು Google ಗೆ ನೀವು ತರುವ, ಆದರೆ ನೀವು ಆ ನೆನಪಿಡಿ ಪ್ರವೃತ್ತಿ.

701
00:48:40,850 --> 00:48:45,470
ನೀವು ಬದಲಿಗೆ google.com ನೆನಪು ಒಲವು.

702
00:48:45,470 --> 00:48:51,560
ನಾವು ಕೊನೆಯ ವಿಷಯ ಈ ಐಪಿ ಟಿಸಿಪಿ ಭಾಗವಾಗಿದೆ ಅಲ್ಲಿ ಪೋರ್ಟುಗಳನ್ನು, ಆಗಿದೆ.

703
00:48:51,560 --> 00:48:54,880
ಟಿಸಿಪಿ ಹೆಚ್ಚು ಮಾಡುತ್ತದೆ. ನಿಮ್ಮ ವೆಬ್ ಬ್ರೌಸರ್ ರನ್ ಹೊಂದಿವೆ, ಹಾಗೆ, ಬಗ್ಗೆ ಯೋಚಿಸಿ.

704
00:48:54,880 --> 00:48:58,670
ಬಹುಶಃ ನೀವು ಕೆಲವು ಇಮೇಲ್ ಅಪ್ಲಿಕೇಶನ್ ಚಲಿಸುತ್ತಿರುವ;

705
00:48:58,670 --> 00:49:02,150
ಬಹುಶಃ ನೀವು ಇಂಟರ್ನೆಟ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಬಳಸುವ ಕೆಲವು ಇತರ ಪ್ರೋಗ್ರಾಂ.

706
00:49:02,150 --> 00:49:05,090
ಅವರು ಎಲ್ಲಾ ಇಂಟರ್ನೆಟ್ ಪ್ರವೇಶ ಅಗತ್ಯವಿದೆ,

707
00:49:05,090 --> 00:49:08,100
ಆದರೆ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಮಾತ್ರ 1 ವೈಫೈ ಕಾರ್ಡ್ ಅಥವಾ ಯಾವುದೇ ಹೊಂದಿದೆ.

708
00:49:08,100 --> 00:49:10,780
ಆದ್ದರಿಂದ ಪೋರ್ಟುಗಳನ್ನು ನಾವು ಬೇರ್ಪಡಿಸಲು ಸಾಧ್ಯವಾಯಿತು ಕೋರುತ್ತೇವೆ ಎಂದು ಮಾರ್ಗವಾಗಿದೆ

709
00:49:10,780 --> 00:49:13,550
ಈ ಅನ್ವಯಗಳ ಇಂಟರ್ನೆಟ್ ಬಳಸಲು ಹೇಗೆ.

710
00:49:13,550 --> 00:49:17,230
ಪ್ರತಿ ಅಪ್ಲಿಕೇಶನ್, ಇದು ಆಲಿಸಬಹುದು ಎಂದು 1 ನಿರ್ದಿಷ್ಟ ಪೋರ್ಟ್ ಪಡೆಯುತ್ತದೆ

711
00:49:17,230 --> 00:49:19,670
ಮತ್ತು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಎಚ್ಟಿಟಿಪಿ ಬಂದರು 80 ಬಳಸುತ್ತದೆ.

712
00:49:19,670 --> 00:49:22,410
ಕೆಲವು ಇಮೇಲ್ ಸೇವೆಗಳು 25 ಬಳಸಲು.

713
00:49:22,410 --> 00:49:24,490
ಕಡಿಮೆ ಸಂಖ್ಯೆಯ ಪದಗಳಿಗಿಂತ ಕಾಯ್ದಿರಿಸಲಾಗಿದೆ ಒಲವು.

714
00:49:24,490 --> 00:49:29,270
ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ನಿಮ್ಮನ್ನು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಪದಗಳಿಗಿಂತ ಸಮರ್ಥರಾಗುತ್ತಾರೆ.

715
00:49:29,270 --> 00:49:32,010
>> ಸಿಎಸ್ಎಸ್, ಕ್ಯಾಸ್ಕೇಡಿಂಗ್ ಸ್ಟೈಲ್ ಶೀಟ್ಸ್.

716
00:49:32,010 --> 00:49:36,030
ಸಿಎಸ್ಎಸ್ ನಾವು ಶೈಲಿ ವೆಬ್ ಪುಟಗಳು, ಅಲ್ಲ ಎಚ್ಟಿಎಮ್ಎಲ್.

717
00:49:36,030 --> 00:49:38,440
ನಿಮ್ಮ ಸಿಎಸ್ಎಸ್ ಹಾಕಬಹುದು 3 ಸ್ಥಳಗಳು ಇವೆ.

718
00:49:38,440 --> 00:49:46,300
ಇದು ಶೈಲಿ ಟ್ಯಾಗ್ಗಳನ್ನು ನಡುವೆ, ಅಥವಾ ಒಂದು ಸಂಪೂರ್ಣವಾಗಿ ಪ್ರತ್ಯೇಕ ಕಡತದಲ್ಲಿ ಮತ್ತು ನಂತರ ಸೈನ್ ಲಿಂಕ್, ಇನ್ಲೈನ್ ಮಾಡಬಹುದು

719
00:49:46,300 --> 00:49:48,470
ಇಲ್ಲಿ ಸಿಎಸ್ಎಸ್ ಕೇವಲ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.

720
00:49:48,470 --> 00:49:50,450
ಈ ಮಾದರಿಯನ್ನು ಗುರುತಿಸಲು ಮಾಡಬೇಕು,

721
00:49:50,450 --> 00:49:54,310
ಮೊದಲ ಉದಾಹರಣೆಗೆ ನಾವು ದೇಹದ ಟ್ಯಾಗ್ ಹೊಂದಾಣಿಕೆ, ನೀವು ಅಲ್ಲಿ

722
00:49:54,310 --> 00:49:56,680
ಮತ್ತು ಇಲ್ಲಿ ನಾವು ದೇಹದ ಟ್ಯಾಗ್ ಕೇಂದ್ರೀಕರಿಸಿ ಮಾಡುತ್ತಿದ್ದೇವೆ.

723
00:49:56,680 --> 00:50:00,420
ಎರಡನೇ ಉದಾಹರಣೆಗೆ, ನಾವು ವಿಷಯ ಹೊಂದಿಕೆ ಮಾಡಲಾಗುತ್ತದೆ

724
00:50:00,420 --> 00:50:04,740
ID ಯನ್ನು ಫೂಟರ್, ಮತ್ತು ನಾವು ಕೆಲವು ಶೈಲಿಗಳು ಹಾಕುತ್ತಿವೆ ಮಾಡುತ್ತಿದ್ದೇವೆ.

725
00:50:04,740 --> 00:50:07,310
ಎಡಕ್ಕೆ ID ಯನ್ನು ಅಡಿಟಿಪ್ಪಣಿ ಪಠ್ಯ ಒಟ್ಟುಗೂಡಿಸುತ್ತದೆ ಗಮನಿಸಿ,

726
00:50:07,310 --> 00:50:09,840
ದೇಹದ ಪಠ್ಯ ಒಟ್ಟುಗೂಡಿಸುತ್ತದೆ ಸೆಂಟರ್ ಆದರೆ.

727
00:50:09,840 --> 00:50:13,180
ಅಡಿಟಿಪ್ಪಣಿ ಶರೀರದ ಒಳಗೆ ಇದೆ.

728
00:50:13,180 --> 00:50:16,470
ಇದು, ಬದಲಿಗೆ, ಪಠ್ಯ align ದೇಹದ ಪಠ್ಯ align ಸೆಂಟರ್ ಹೇಳುತ್ತಾರೆ ಸಹ, ಬಿಟ್ಟು ಕಾಣಿಸುತ್ತದೆ.

729
00:50:16,470 --> 00:50:18,880
ಇದು ಇಡೀ ಕ್ಯಾಸ್ಕೇಡಿಂಗ್ ಭಾಗವಾಗಿದೆ.

730
00:50:18,880 --> 00:50:22,110
ನೀವು ಹೊಂದಬಹುದು - ನೀವು ದೇಹದ ಶೈಲಿಗಳು ಸೂಚಿಸಬಹುದು,

731
00:50:22,110 --> 00:50:25,320
ಮತ್ತು ನಂತರ ದೇಹದಲ್ಲಿ ವಿಷಯಗಳನ್ನು ನೀವು ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟ ಶೈಲಿಗಳು ಸೂಚಿಸಬಹುದು,

732
00:50:25,320 --> 00:50:28,160
ಮತ್ತು ವಿಷಯಗಳನ್ನು ನೀವು ನಿರೀಕ್ಷಿಸಬಹುದು ಕೆಲಸ.

733
00:50:28,160 --> 00:50:34,420
ಇನ್ನಷ್ಟು ನಿರ್ದಿಷ್ಟ ಸಿಎಸ್ಎಸ್ ಸ್ಪೆಸಿಫೈಯರ್ಸ್ ಆದ್ಯತೆಯಾಗಿ.

734
00:50:34,420 --> 00:50:46,140
ನಾನು ಭಾವಿಸುತ್ತೇನೆ.

735
00:50:46,140 --> 00:50:49,260
>> [ಅಲಿ Nahm] ಎಲ್ಲರೂ ಹೈ. ನಾನು ನಿಮ್ಮ ಗಮನ ಸೆಳೆಯುವುದು ಎಂದು.

736
00:50:49,260 --> 00:50:53,990
ನಾನು ಅಲಿ ನಾನು ಮತ್ತು ನಾನು ವೇಗವಾಗಿ ಪಿಎಚ್ಪಿ ಮತ್ತು SQL ಮೂಲಕ ಹೋಗಿ ಪಡೆಯಲಿದ್ದೇನೆ.

737
00:50:53,990 --> 00:51:00,310
ನಾವು ಪ್ರಾರಂಭಿಸಬಹುದು. ಪಿಎಚ್ಪಿ ಪಿಎಚ್ಪಿ ಫಾರ್ ಚಿಕ್ಕದಾಗಿದೆ: ಹೈಪರ್ಟೆಕ್ಸ್ಟ್ ಪ್ರಿಪ್ರೊಸೆಸರ್.

738
00:51:00,310 --> 00:51:03,730
ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾಗಿದೆ, ಇದು ಸರ್ವರ್ ಸೈಡ್ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಭಾಷೆಯನ್ನು ಇಲ್ಲಿದೆ,

739
00:51:03,730 --> 00:51:06,800
ಮತ್ತು ನಾವು ವೆಬ್ಸೈಟ್ಗಳ ಮತ್ತೆ ಕೊನೆಯಲ್ಲಿ ಬಳಸುತ್ತಾರೆ,

740
00:51:06,800 --> 00:51:12,540
ಮತ್ತು ಗಣನೆಗಳನ್ನು, ದೃಶ್ಯಗಳ ಹಿಂದಿನ ಭಾಗ ಬಹಳಷ್ಟು ಮಾಡುತ್ತದೆ ಹೇಗೆ.

741
00:51:12,540 --> 00:51:17,510
ಸಿಂಟ್ಯಾಕ್ಸ್. ಇದು C, ಅನಿರೀಕ್ಷಿತ, ಆಶ್ಚರ್ಯ ಅಲ್ಲ.

742
00:51:17,510 --> 00:51:22,060
ನಾನು ಮುಂದೆ ಚಲಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ - ಯಾವಾಗಲೂ ನೀವು ನೋಡಬಹುದು ವೇಳೆ, ಜೊತೆಗೆ ಆರಂಭಿಸಲು ಹೊಂದಿದೆ.

743
00:51:22,060 --> 00:51:31,340
ನೀವು ಬ್ರೇಸ್ ಹೊಸ ರೀತಿಯ ಅಗತ್ಯವಿದೆ ನೋಡಬಹುದು ಮತ್ತು ನಂತರ ನೀವು ಸಹ ಪಿಎಚ್ಪಿ ಅಗತ್ಯವಿದೆ.

744
00:51:31,340 --> 00:51:35,780
ನೀವು ನಿಮ್ಮ PHP ಪಠ್ಯ, ನಿಮ್ಮ ಪಿಎಚ್ಪಿ ಕೋಡ್ ಫ್ರೇಮ್ ಹೇಗೆ ಯಾವಾಗಲೂ ಇಲ್ಲಿದೆ.

745
00:51:35,780 --> 00:51:39,180
ಆದ್ದರಿಂದ ನೀವು ರೀತಿಯ ಮೊದಲ ಪುಟ್ ಅಲ್ಲಿ ಸಿ, ಹಾಗೆ ಸಾಧ್ಯವಿಲ್ಲ.

746
00:51:39,180 --> 00:51:42,290
ನೀವು ಯಾವಾಗಲೂ ಅದನ್ನು ಸುತ್ತುವರೆದಿರುವ ಅಗತ್ಯವಿದೆ.

747
00:51:42,290 --> 00:51:47,610
ಈಗ, ಪ್ರಮುಖ ವಾಕ್ಯ ಎಲ್ಲಾ ಅಸ್ಥಿರ $ ಪಾತ್ರ ಆರಂಭಿಸಲು ಅಗತ್ಯವಿದೆ ಎಂದು.

748
00:51:47,610 --> 00:51:49,490
ನೀವು ಅವುಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಮಾಡಿದಾಗ ಅದನ್ನು ಮಾಡಬೇಕು; ನೀವು ಮಾಡಬೇಕಾದ್ದು

749
00:51:49,490 --> 00:51:51,860
ನೀವು ನಂತರ ಅವರಿಗೆ ಉಲ್ಲೇಖಿಸಿ ಮಾಡಿದಾಗ.

750
00:51:51,860 --> 00:51:56,510
ನೀವು ಯಾವಾಗಲೂ ಎಂದು $ ಅಗತ್ಯವಿದೆ. ಇದು ಅತ್ಯಧಿಕವಾಗಿ, ನಿಮ್ಮ ಹೊಸ ಉತ್ತಮ ಸ್ನೇಹಿತ.

751
00:51:56,510 --> 00:52:01,690
ನೀವು ಇಲ್ಲ - ಸಿ ಭಿನ್ನವಾಗಿ, ನೀವು ಅದು ವೇರಿಯಬಲ್ ರೀತಿಯ ಯಾವ ರೀತಿಯ ಪುಟ್ ಅಗತ್ಯವಿಲ್ಲ.

752
00:52:01,690 --> 00:52:04,940
ನೀವು $ ಬೇಕು ಹಾಗೆಯೇ, ನೀವು,, ಪುಟ್ ಮಾಡಬೇಕಿಲ್ಲ

753
00:52:04,940 --> 00:52:09,470
ಇಂಟ್ X ಅಥವಾ ಸ್ಟ್ರಿಂಗ್ ವೈ, etcetera, etcetera.

754
00:52:09,470 --> 00:52:11,490
ಆದ್ದರಿಂದ ಸ್ವಲ್ಪ ವ್ಯತ್ಯಾಸ.

755
00:52:11,490 --> 00:52:15,590
ಈ ಪರಿಣಾಮವಾಗಿ, ಇದು ಪಿಎಚ್ಪಿ ದುರ್ಬಲವಾಗಿ ರೀತಿಯ ಎಂದರ್ಥ.

756
00:52:15,590 --> 00:52:19,310
ಪಿಎಚ್ಪಿ ದುರ್ಬಲವಾಗಿ ಮಾದರಿ ಭಾಷೆ, ಮತ್ತು ಇದು ದುರ್ಬಲವಾಗಿ ಅಸ್ಥಿರ ಟೈಪಿಸಿದ.

757
00:52:19,310 --> 00:52:24,020
ಅರ್ಥಾತ್, ನೀವು ವೇರಿಯಬಲ್ ರೀತಿಯ ಬಗೆಯ ನಡುವೆ ಬದಲಾಯಿಸಬಹುದು ಎಂದರ್ಥ.

758
00:52:24,020 --> 00:52:27,230
ನೀವು ಒಂದು ಇಂಟ್ ನಿಮ್ಮ ಸಂಖ್ಯೆ 1 ಸಂಗ್ರಹಿಸಬಹುದು,

759
00:52:27,230 --> 00:52:29,650
ನೀವು ಸ್ಟ್ರಿಂಗ್ ಎಂದು ಸಂಗ್ರಹಿಸಬಹುದು, ಮತ್ತು ನೀವು ಒಂದು ಫ್ಲೋಟ್ ಎಂದು ಸಂಗ್ರಹಿಸಬಹುದು,

760
00:52:29,650 --> 00:52:33,550
ಮತ್ತು ಎಲ್ಲಾ ಆ ಸಂಖ್ಯೆ 1 ಆಗಿರುತ್ತದೆ.

761
00:52:33,550 --> 00:52:36,080
ನೀವು ವಿವಿಧ ರೂಪಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು ನೀವು ಕೂಡ,

762
00:52:36,080 --> 00:52:39,120
ಇನ್ನೂ - ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ರೀತಿಯ ಇನ್ನೂ ಕೊನೆಯಲ್ಲಿ ಹಿಡುವಳಿ.

763
00:52:39,120 --> 00:52:41,540
ಆದ್ದರಿಂದ ನೀವು ಇಲ್ಲಿ ನೋಡಿದರೆ, ನೀವು pset 7 ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ವೇಳೆ,

764
00:52:41,540 --> 00:52:43,500
ನೀವು ಅನೇಕ ಬಹುಶಃ ಈ ಸಮಸ್ಯೆಯಿಂದ.

765
00:52:43,500 --> 00:52:47,280
ಎರಡು ಸಮಾನ ಚಿಹ್ನೆಗಳು, 3 ಸಮಾನ ಚಿಹ್ನೆಗಳು, 4 ಸಮಾನ ಚಿಹ್ನೆಗಳು.

766
00:52:47,280 --> 00:52:49,990
ಸರಿ, ಯಾವುದೇ 4 ಸಮಾನ ಚಿಹ್ನೆಗಳು ಇವೆ, ಆದರೆ 2 ಮತ್ತು 3 ಇವೆ.

767
00:52:49,990 --> 00:52:53,320
ನೀವು ಮೌಲ್ಯಗಳನ್ನು ಪರಿಶೀಲಿಸಿ 2 ಸಮಾನ ಚಿಹ್ನೆಗಳು ಬಳಸಲು.

768
00:52:53,320 --> 00:52:55,830
ಇದು ರೀತಿಯ ಪರಿಶೀಲಿಸಬಹುದು.

769
00:52:55,830 --> 00:52:58,770
ಆದ್ದರಿಂದ ನೀವು ಮೊದಲ ಉದಾಹರಣೆಯನ್ನು ನೋಡಬಹುದು ವೇಳೆ,

770
00:52:58,770 --> 00:53:02,210
ನಾನು num_int == num_string ಹೊಂದಿವೆ.

771
00:53:02,210 --> 00:53:06,710
ಆದ್ದರಿಂದ ನಿಮ್ಮ ಇಂಟ್ ನಿಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ಎರಡೂ, ತಾಂತ್ರಿಕವಾಗಿ, 1,

772
00:53:06,710 --> 00:53:10,790
ಆದರೆ ವಿವಿಧ ಆರ್. ಆದರೆ ಎರಡು ಸಮ, ಇದು ಇನ್ನೂ ಪಾಸ್ ಮಾಡುತ್ತೇವೆ.

773
00:53:10,790 --> 00:53:15,510
ಆದಾಗ್ಯೂ, ಟ್ರಿಪಲ್ ಸಮ, ಇದು ಮೌಲ್ಯ ಹಾಗೂ ವಿವಿಧ ಪರಿಶೀಲಿಸುತ್ತದೆ.

774
00:53:15,510 --> 00:53:18,760
ಅದು ಇಲ್ಲಿ ಎರಡನೇ ಸಂದರ್ಭದಲ್ಲಿ ಹಾದು ಹೋಗುವ ಅಲ್ಲ ಎಂದರ್ಥ

775
00:53:18,760 --> 00:53:22,350
ನೀವು ಬದಲಿಗೆ 3 ಸಮಾನ ಚಿಹ್ನೆಗಳು ಬಳಸುತ್ತಿದ್ದರೆ ಅಲ್ಲಿ.

776
00:53:22,350 --> 00:53:26,590
ಆದ್ದರಿಂದ ನೀವು ಎಲ್ಲಾ ಈಗ ತೋರಿಸಿವೆ ಎಂದು ಒಂದು ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಇಲ್ಲಿದೆ.

777
00:53:26,590 --> 00:53:31,570
>> ತಂತುವಿನ ಪೋಣಿಸುವಿಕೆಯ ನೀವು ಪಿಎಚ್ಪಿ ಬಳಸಬಹುದಾದ ಮತ್ತೊಂದು ಪ್ರಬಲ ವಿಷಯ.

778
00:53:31,570 --> 00:53:34,080
ಇದು, ಮೂಲತಃ ಕೇವಲ ಸೂಕ್ತ ಡಾಟ್ ಸಂಕೇತಗಳನ್ನು ಇಲ್ಲಿದೆ

779
00:53:34,080 --> 00:53:36,230
ಮತ್ತು ನೀವು ಒಟ್ಟಿಗೆ ತಂತಿಗಳನ್ನು ಬಂಧಿಸಬಹುದು ಹೇಗೆ.

780
00:53:36,230 --> 00:53:40,800
ಆದ್ದರಿಂದ ನೀವು ಕ್ಯಾಟ್ ಮತ್ತು ನೀವು ಡಾಗ್, ಮತ್ತು ನೀವು ಒಟ್ಟಿಗೆ 2 ತಂತಿಗಳು ಪುಟ್ ಬಯಸಿದರೆ,

781
00:53:40,800 --> 00:53:44,080
ನೀವು ಅವಧಿಯಲ್ಲಿ ಬಳಸಬಹುದು, ಮತ್ತು ಅದು ಹೇಗೆ ಕೆಲಸ ಭಾಸವಾಗುತ್ತದೆ.

782
00:53:44,080 --> 00:53:46,660
ನೀವು ಕೇವಲ ಪರಸ್ಪರ ಮುಂದಿನ ಇಡಿ,

783
00:53:46,660 --> 00:53:49,030
ನೀವು ಕೆಳಗೆ ಉದಾಹರಣೆಗೆ ಇಲ್ಲಿ ನೋಡಬಹುದು ಎಂದು,

784
00:53:49,030 --> 00:53:51,610
ನಾನು ಸ್ಟ್ರಿಂಗ್ 1, ಸ್ಪೇಸ್ ಸ್ಟ್ರಿಂಗ್ 2 ಪ್ರತಿಧ್ವನಿ ಅಲ್ಲಿ.

785
00:53:51,610 --> 00:53:56,930
ಪಿಎಚ್ಪಿ ಅವುಗಳನ್ನು ಬದಲಾಯಿಸಲು ತಿಳಿಯುವುದಿಲ್ಲ.

786
00:53:56,930 --> 00:53:59,780
ಅರೆಸ್. ಈಗ, ಪಿಎಚ್ಪಿ ಸರಣಿಗಳ 2 ಬಗೆಯ.

787
00:53:59,780 --> 00:54:03,180
ನೀವು ಸಾಮಾನ್ಯ ಸರಣಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ ಮತ್ತು ನೀವು ಸಹ ಸಹಾಯಕ ಸರಣಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ

788
00:54:03,180 --> 00:54:06,040
ಮತ್ತು ನಾವು ಇದೀಗ ಅವುಗಳನ್ನು ಮೂಲಕ ಹೋಗಲು ನೀನು.

789
00:54:06,040 --> 00:54:08,280
ನಿಯಮಿತ ಸಾಲುಗಳು, ಕೇವಲ ಈ ಸಿ

790
00:54:08,280 --> 00:54:11,240
ಮತ್ತು ಆದ್ದರಿಂದ ನೀವು ನೀಡಲಾಗುತ್ತದೆ ಎಂಬುದರ ಸೂಚಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.

791
00:54:11,240 --> 00:54:13,160
ಇದೀಗ ನಾವು ಕೇವಲ ಒಂದು ರಚಿಸಲು ಹೋಗುವ ಮತ್ತು ಮಾಡುತ್ತಿದ್ದೇವೆ -

792
00:54:13,160 --> 00:54:15,500
ಆದ್ದರಿಂದ ನಾವು ಖಾಲಿ ರಚನೆಯ ರಚಿಸಲು ಹೇಗೆ, ನಾವು ನೀನು

793
00:54:15,500 --> 00:54:17,310
ಸೂಚ್ಯಂಕ 0 ಜಾರಿಗೆ.

794
00:54:17,310 --> 00:54:19,200
ನಾವು ಸಂಖ್ಯೆ 6, ಮೌಲ್ಯ 6 ಹಾಕಲು ನೀನು.

795
00:54:19,200 --> 00:54:21,500
ನೀವು ಇಲ್ಲಿ ಕೆಳಗೆ ನೋಡಬಹುದು.

796
00:54:21,500 --> 00:54:24,240
Where's - ಸೂಚ್ಯಂಕ 1 ನಲ್ಲಿ ನಾವು ಮೌಲ್ಯ ಸಂಖ್ಯೆ 4 ಹಾಕಲು ನೀನು

797
00:54:24,240 --> 00:54:26,720
ಮತ್ತು ಆದ್ದರಿಂದ ನೀವು ಒಂದು 6 ನೋಡಬಹುದು, ಒಂದು 4, ಇಲ್ಲ

798
00:54:26,720 --> 00:54:29,160
ನಂತರ ನಾವು ವಿಷಯಗಳನ್ನು ಮುದ್ರಿಸುವ ಎಂದು,

799
00:54:29,160 --> 00:54:33,550
ನಾವು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಸೂಚ್ಯಂಕ 0 ಸಂಗ್ರಹಿಸಿಡಬೇಕು ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ,

800
00:54:33,550 --> 00:54:36,900
ನಂತರ ನಾವು ಮುದ್ರಿಸುವುದು 6 ಮೌಲ್ಯವನ್ನು ನೋಡುತ್ತಾರೆ. ಕೂಲ್?

801
00:54:36,900 --> 00:54:40,160
ಆದ್ದರಿಂದ ನೀವು ಸಾಮಾನ್ಯ ಸರಣಿಗಳ ಇಲ್ಲಿದೆ.

802
00:54:40,160 --> 00:54:42,750
ನೀವು ಈಗ ಸಾಮಾನ್ಯ ಸರಣಿಗಳ ವಿಷಯಗಳನ್ನು ಸೇರಿಸಬಹುದು ಮತ್ತೊಂದು ರೀತಿಯಲ್ಲಿ

803
00:54:42,750 --> 00:54:44,780
ನೀವು ಕೊನೆಯಲ್ಲಿ ಅವುಗಳನ್ನು ಸೇರಿಸಬಹುದು ಆಗಿದೆ.

804
00:54:44,780 --> 00:54:47,240
ನೀವು ನಿರ್ದಿಷ್ಟ ಸೂಚ್ಯಂಕ ಸೂಚಿಸಲು ಇಲ್ಲ ಎಂದರ್ಥ.

805
00:54:47,240 --> 00:54:51,000
ನೀವು ಸಂಖ್ಯೆ ನೋಡಬಹುದು, ಮತ್ತು ಚೌಕಾಕಾರದ ಆವರಣ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಯಾವುದೇ ಸೂಚ್ಯಂಕ ಇಲ್ಲ.

806
00:54:51,000 --> 00:54:56,270
ಮತ್ತು ಇದು ತಿಳಿಯುವುದಿಲ್ಲ - ಪಿಎಚ್ಪಿ ಕೇವಲ ಪಟ್ಟಿ, ಮುಂದಿನ ಉಚಿತ ಸ್ಪಾಟ್ ಕೊನೆಯಲ್ಲಿ ಇದನ್ನು ಸೇರಿಸಲು ತಿಳಿಯುವುದಿಲ್ಲ.

807
00:54:56,270 --> 00:54:59,190
ಆದ್ದರಿಂದ ನೀವು ಆ 0 ಸ್ಪಾಟ್ ಸರಿಯಾದ ಇಲ್ಲ 1 ನೋಡಬಹುದು

808
00:54:59,190 --> 00:55:02,690
2 ಮೊದಲ ಸ್ಥಾನ ಸರಿಯಾದ ಅಲ್ಲಿ ಹೋದರು.

809
00:55:02,690 --> 00:55:04,690
3 ಹೋಗುತ್ತದೆ - ಹಾಗೆಯೇ ಅಲ್ಲಿ ಸೇರಿಸಲಾಗುತ್ತದೆ.

810
00:55:04,690 --> 00:55:06,720
ಆದ್ದರಿಂದ ಆ ರೀತಿಯ ಅರ್ಥವಿಲ್ಲ. ನೀವು ನಿರಂತರವಾಗಿ ಅದನ್ನು ಸೇರಿಸುವ ನೀವು,

811
00:55:06,720 --> 00:55:09,360
ನಂತರ ನಾವು, ಸಂಖ್ಯೆ 1 ಸೂಚ್ಯಂಕ ಪ್ರತಿಧ್ವನಿಸುವ ಮಾಡಿದಾಗ

812
00:55:09,360 --> 00:55:13,080
ಇದು ಮೌಲ್ಯ 2 ಮುದ್ರಿಸುತ್ತದೆ.

813
00:55:13,080 --> 00:55:16,800
>> ನಂತರ ನಾವು ಸಹವರ್ತನೀಯ ಸರಣಿಗಳ ಎಂದು ಸರಣಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.

814
00:55:16,800 --> 00:55:19,370
ಬದಲಿಗೆ ಸಂಖ್ಯಾತ್ಮಕ ಸೂಚ್ಯಂಕಗಳು ಹೊಂದಿರುವ ಸಹಕಾರಿ ಸಾಲುಗಳು,,

815
00:55:19,370 --> 00:55:23,630
ಅವರು ಏನು ಅವರು ಸ್ಟ್ರಿಂಗ್ ಎಂದು ಸೂಚಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ, ಆಗಿದೆ.

816
00:55:23,630 --> 00:55:25,670
ನೀವು ಬದಲಿಗೆ, ನೋಡಬಹುದು - ನಾನು ಆ ಸಂಖ್ಯೆ ಸೂಚ್ಯಂಕಗಳು ಹೊರಬಂದಿತು,

817
00:55:25,670 --> 00:55:32,140
ಈಗ key1, key2, key3, ಮತ್ತು ಅವರು ಎಲ್ಲಾ ತಂತಿಗಳನ್ನು ಎಂಬುದನ್ನು ಸೂಚಿಸುವುದಕ್ಕಾಗಿ ಎರಡು ಉಲ್ಲೇಖಗಳು ಆರ್.

818
00:55:32,140 --> 00:55:34,470
ಆದ್ದರಿಂದ ನಾವು ಈ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ ಹೊಂದಿವೆ.

819
00:55:34,470 --> 00:55:38,790
ಈ ಉದಾಹರಣೆಗೆ ನಾವು TF ಹೊಂದಿರುತ್ತವೆ, ಮತ್ತು ಸೂಚ್ಯಂಕ ಹೆಸರು.

820
00:55:38,790 --> 00:55:42,030
ನಾವು, ಕ್ಯಾಲೊರಿ ಬೇಕಾದರೂ, ಸೂಚ್ಯಂಕ, ಹೆಸರು "ಅಲಿ" ಹಾಕಲು ನೀನು

821
00:55:42,030 --> 00:55:47,640
ನಾವು ಬದಲಿಗೆ ಸ್ಟ್ರಿಂಗ್ ಒಂದು ಇಂಟ್ ಈ ಬಾರಿ ಹಾಕಬಹುದು,

822
00:55:47,640 --> 00:55:52,240
ತದನಂತರ ಸೂಚ್ಯಂಕ ಸಾಲಿಗೆ, ನಾವು ಒಳಗೆ ಇಡೀ ರಚನೆಯ ಹಾಕಬಹುದು.

823
00:55:52,240 --> 00:55:55,490
ಆದ್ದರಿಂದ ಈ ರೀತಿಯ ಇದೆ - ಅದು ನಾವು ಹೇಗೆ ಒಂದು ರೀತಿಯ ಪರಿಕಲ್ಪನೆಯನ್ನು

824
00:55:55,490 --> 00:55:58,930
ಸಂಖ್ಯೆಯ ಸೂಚ್ಯಂಕಗಳು ಆದರೆ ಈಗ ನಾವು ಸುಮಾರು ಸೂಚ್ಯಂಕಗಳು ಬದಲಾಯಿಸಬಹುದು

825
00:55:58,930 --> 00:56:03,890
ಬದಲಿಗೆ ತಂತಿಗಳನ್ನು ಅವುಗಳನ್ನು ಹೊಂದಲು.

826
00:56:03,890 --> 00:56:06,070
ನೀವು ಕೇವಲ ಪ್ರತ್ಯೇಕವಾಗಿ ಮಾಡುತ್ತಿದ್ದೆ ಜೊತೆಗೆ, ಈ ಮಾಡಬಹುದು

827
00:56:06,070 --> 00:56:09,400
ನೀವು ಒಂದು ಚಂಕ್ ಎಲ್ಲಾ ಮಾಡಬಹುದು. ಆದ್ದರಿಂದ ನೀವು ಆ ರಚನೆಯ TF ನೋಡಬಹುದು

828
00:56:09,400 --> 00:56:13,350
ನಂತರ ನಾವು ಒಂದು ದೈತ್ಯ ಚೌಕಾಕಾರದ ಬ್ರಾಕೆಟ್ ಸೆಟ್ ಅವರನ್ನು ಎಲ್ಲಾ ಸೆಟ್.

829
00:56:13,350 --> 00:56:15,220
ಆದ್ದರಿಂದ ವಸ್ತುಗಳನ್ನು ವೇಗವನ್ನು ಮಾಡಬಹುದು.

830
00:56:15,220 --> 00:56:19,730
ಇದು ಹೆಚ್ಚು ಶೈಲಿಯ ಆಯ್ಕೆ ಹೆಚ್ಚಿನ.

831
00:56:19,730 --> 00:56:21,550
ನಾವು ಕುಣಿಕೆಗಳು ಹೊಂದಿವೆ.

832
00:56:21,550 --> 00:56:26,020
ಸಿ ನಾವು ಈ ರೀತಿಯ ಕೆಲಸ ಕುಣಿಕೆಗಳು ಹೊಂದಿವೆ.

833
00:56:26,020 --> 00:56:29,690
ನಮ್ಮ ರಚನೆಯ ಹೊಂದಿತ್ತು, ಮತ್ತು ನಾವು ಪಟ್ಟಿಯ ಕೊನೆಯಲ್ಲಿ ಸೂಚ್ಯಂಕ 0 ಹೋದರು,

834
00:56:29,690 --> 00:56:31,740
ಮತ್ತು ನಾವು ಸರಿ, ಎಲ್ಲಾ ಮುದ್ರಿಸಲು?

835
00:56:31,740 --> 00:56:33,880
, ಸಮಸ್ಯೆ ಸಹವರ್ತನೀಯ ಸರಣಿಗಳ ಫಾರ್, ಹೊರತುಪಡಿಸಿ

836
00:56:33,880 --> 00:56:36,610
ನಾವು ಅಗತ್ಯವಾಗಿ ಆ ಸಂಖ್ಯಾತ್ಮಕ ಸೂಚ್ಯಂಕಗಳು ಗೊತ್ತಿಲ್ಲ

837
00:56:36,610 --> 00:56:39,610
ಈಗ ನಾವು ಸ್ಟ್ರಿಂಗ್ ಸೂಚ್ಯಂಕಗಳು ಏಕೆಂದರೆ.

838
00:56:39,610 --> 00:56:44,800
ಈಗ ನಾವು ಮತ್ತೆ, ನೀವು ಆಶಾದಾಯಕವಾಗಿ pset 7 ಬಳಸಲಾಗುತ್ತದೆ ಇದು, foreach ಕುಣಿಕೆಗಳು, ಬಳಸಿ.

839
00:56:44,800 --> 00:56:48,930
Foreach ಕುಣಿಕೆಗಳು ಪಟ್ಟಿಯ ಪ್ರತಿಯೊಂದು ಭಾಗ ತಿಳಿಯುವುದಿಲ್ಲ.

840
00:56:48,930 --> 00:56:52,450
ಮತ್ತು ಇದು, ನೀವು ನಿಖರವಾಗಿ ಸಂಖ್ಯಾತ್ಮಕ ಸೂಚ್ಯಂಕ ತಿಳಿಯಲು ಹೊಂದಿಲ್ಲ.

841
00:56:52,450 --> 00:56:56,490
ಆದ್ದರಿಂದ ನೀವು ಸರಣಿ ಪುಟ್, ನೀವು foreach ವಾಕ್ಯ, ಆದ್ದರಿಂದ foreach ಇಲ್ಲಿದೆ.

842
00:56:56,490 --> 00:57:00,430
, ಆದ್ದರಿಂದ ನನ್ನ ರಚನೆಯ pset ಕರೆಯಲಾಗುತ್ತದೆ, ಮತ್ತು ನಂತರ ಪದ, ಮಾಹಿತಿ

843
00:57:00,430 --> 00:57:04,530
ತದನಂತರ ನೀವು ಬಳಸಲು ನೀನು ಈ ಸ್ಥಳೀಯ ತಾತ್ಕಾಲಿಕ ವೇರಿಯಬಲ್ ಪುಟ್

844
00:57:04,530 --> 00:57:10,690
ಕೇವಲ ನಿರ್ದಿಷ್ಟ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುತ್ತದೆ ವಿಶೇಷವೇನು ನಿರ್ದಿಷ್ಟ ವಿಚಾರಕ್ಕೆ -

845
00:57:10,690 --> 00:57:14,770
ಒಂದು ಉದಾಹರಣೆಗೆ ಅಥವಾ ರಚನೆಯ ಒಂದು ವಿಭಾಗ.

846
00:57:14,770 --> 00:57:18,350
, Pset NUM 1 ಅನ್ವಯಿಸುತ್ತದೆ, ಮತ್ತು ನಂತರ ಬಹುಶಃ ಇದು ಸಂಖ್ಯೆಯ 6 ಅನ್ವಯಿಸುತ್ತದೆ

847
00:57:18,350 --> 00:57:20,410
ತದನಂತರ ಅದು 2 ಅನ್ವಯಿಸುತ್ತದೆ.

848
00:57:20,410 --> 00:57:26,630
ಅದು ರಚನೆಯ ಇಲ್ಲಿದೆ ಪ್ರತಿಯೊಂದು ಮೌಲ್ಯ ಮೂಲಕ ಹೋಗಲು ಖಾತರಿ ವಿಶೇಷವೇನು.

849
00:57:26,630 --> 00:57:30,530
ನೀವು ಪಿಎಚ್ಪಿ ರಲ್ಲಿ ತಿಳಿದಿದೆ ಎಂದು ಉಪಯುಕ್ತ ಕಾರ್ಯಗಳನ್ನು ಅಗತ್ಯವಿದೆ,

850
00:57:30,530 --> 00:57:35,880
ನಿರ್ಗಮನ, ಖಾಲಿ, ಪ್ರತಿಧ್ವನಿ ಆದ್ದರಿಂದ, ನೀವು ಕೆಲವು ಕಡತಗಳನ್ನು ಸೇರಿದಂತೆ ಇಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

851
00:57:35,880 --> 00:57:40,490
ನಾನು ಹೆಚ್ಚು ನೀವು pset 7 ನೋಡಲು ಮತ್ತು ಆ ಕಾರ್ಯಗಳನ್ನು ನೋಡಲು ಶಿಫಾರಸು.

852
00:57:40,490 --> 00:57:42,810
ನೀವು ಆ ತಿಳಿಯಲು ಹೊಂದಿರಬಹುದು,

853
00:57:42,810 --> 00:57:47,060
ಆದ್ದರಿಂದ ನಾನು ಖಂಡಿತವಾಗಿ ನಿಖರವಾಗಿ, ಆ ಎಲ್ಲಾ ಏನು, ತಿಳಿಯುವುದಿಲ್ಲ.

854
00:57:47,060 --> 00:57:50,080
>> ಈಗ ನಾವು ತ್ವರಿತವಾಗಿ ವ್ಯಾಪ್ತಿ ಮೂಲಕ ಹೋಗಲು ನೀನು.

855
00:57:50,080 --> 00:57:53,490
ವ್ಯಾಪ್ತಿ, ಪಿಎಚ್ಪಿ, ಸಿ ಭಿನ್ನವಾಗಿ, ಒಂದು ಮೋಜಿನ ವಿಷಯ ರೀತಿಯ

856
00:57:53,490 --> 00:57:56,170
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ತ್ವರಿತವಾಗಿ ಮೂಲಕ ಹೋಗಲು ನೀನು.

857
00:57:56,170 --> 00:57:58,930
ಆದ್ದರಿಂದ ನಾವು ನಾವು ಹೊಂದಿರುವ ಆ ಬಾಣದ ಆರಂಭವಾಗುವುದು ಹೇಳಲು ಅವಕಾಶ.

858
00:57:58,930 --> 00:58:02,900
ನಾವು $ ನಾನು ಪ್ರಾರಂಭಿಸಿ ನೀನು. ಆದ್ದರಿಂದ ವೇರಿಯಬಲ್ 'ನಾನು', 0 ಏರಲಿದೆ

859
00:58:02,900 --> 00:58:06,730
ಮತ್ತು ನಾವು ಅಲ್ಲಿ ಮೇಲೆ ದೊಡ್ಡ ಬಿಳಿ ಬಾಕ್ಸ್ ನಲ್ಲಿ ಅದನ್ನು ಮುದ್ರಿಸುವ ಇರಿಸಿಕೊಳ್ಳಲು ನೀನು.

860
00:58:06,730 --> 00:58:09,220
ನಾವು i0 ಆರಂಭಿಸಲು ನೀನು, ಮತ್ತು ನಾವು ಅದನ್ನು ಪ್ರತಿಧ್ವನಿ ನೀನು.

861
00:58:09,220 --> 00:58:12,670
ಆದ್ದರಿಂದ 0 ಇಲ್ಲ.

862
00:58:12,670 --> 00:58:15,210
ನಂತರ ನಾವು, ಲೂಪ್ ಮೂಲಕ ಇದನ್ನು ಹೆಚ್ಚಿಸಲು ನೀನು

863
00:58:15,210 --> 00:58:17,810
ಮತ್ತು ಇದು 1 ಮೌಲ್ಯವನ್ನು ಎಂದು ವಿಶೇಷವೇನು.

864
00:58:17,810 --> 00:58:20,070
, ಒಂದು ಕಡಿಮೆ 3, ಆದ್ದರಿಂದ ಎಂದು ಲೂಪ್ ಮೂಲಕ ಹಾದು ಹೋಗುವುದಿಲ್ಲ

865
00:58:20,070 --> 00:58:23,230
ನಂತರ ನಾವು ಮತ್ತೆ ಮುದ್ರಿತ ನೋಡಲು ನೀನು.

866
00:58:23,230 --> 00:58:25,520
ನಾವು, 2 ಮತ್ತೆ ಹೆಚ್ಚಿಸಲು ನೀನು

867
00:58:25,520 --> 00:58:29,860
ಮತ್ತು 2 3 ಕಡಿಮೆ, ಆದ್ದರಿಂದ ಲೂಪ್ ಪಾಸ್ ಮಾಡುತ್ತೇವೆ, ಮತ್ತು ಇದು 2 ಮುದ್ರಿಸಲು ಮಾಡುತ್ತೇವೆ.

868
00:58:29,860 --> 00:58:35,100
ನಂತರ ನೀವು 3 3 ಕಡಿಮೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ, ಆದ್ದರಿಂದ ನಾವು ಲೂಪ್ ಭೇದಿಸಿ ಮಾಡುತ್ತೇವೆ.

869
00:58:35,100 --> 00:58:40,050
ಈಗ ನಾವು ನಿರ್ಗಮಿಸಿದೆ ಬಂದಿದೆ ನಂತರ ನಾವು aFunction ಹೋಗಿ ನೀನು.

870
00:58:40,050 --> 00:58:45,010
ಸರಿ. ಆದ್ದರಿಂದ ನೀವು, ಈ ವೇರಿಯಬಲ್ ನಾವು ರಚಿಸಿದ ಗಮನಿಸಿ ಮಾಡಬೇಕು

871
00:58:45,010 --> 00:58:48,270
'ನಾನು' ವೇರಿಯಬಲ್, ಸ್ಥಳೀಯವಾಗಿ ಕ್ಷೇತ್ರ ಇದೆ.

872
00:58:48,270 --> 00:58:50,280
ಅದು ಲೂಪ್ ಸ್ಥಳೀಯ ಅಲ್ಲ ಎಂದರ್ಥ,

873
00:58:50,280 --> 00:58:58,060
ಮತ್ತು ವೇರಿಯಬಲ್ ನಾವು ಇನ್ನೂ ಪ್ರವೇಶಿಸಲು ಮತ್ತು ನಂತರ ಬದಲಾಯಿಸಲು, ಮತ್ತು ಇದು ಇನ್ನೂ ಪರಿಣಾಮಕಾರಿ ಮಾಡಬಹುದು.

874
00:58:58,060 --> 00:59:02,160
ನೀವು ಈಗ ಕಾರ್ಯ ಹೋಗಿ ಆದ್ದರಿಂದ, ನೀವು, ನಾವು 'ನಾನು' ವೇರಿಯಬಲ್ ಬಳಸುವ ನೋಡುತ್ತಾರೆ

875
00:59:02,160 --> 00:59:05,320
ಮತ್ತು ನಾವು 'ನಾನು' + ಹೆಚ್ಚಿಸಲು ನೀನು.

876
00:59:05,320 --> 00:59:09,410
ನೀವು 'ನಾನು' ವೇರಿಯಬಲ್ ಪ್ರತಿಯನ್ನು ಎಂದು, ಸಿ ಆಧರಿಸಿ, ಮೊದಲಿಗೆ, ಯೋಚಿಸುವುದಿಲ್ಲ.

877
00:59:09,410 --> 00:59:12,830
ಇದು ಸರಿಯಾದ ಇದು, ಸಂಪೂರ್ಣವಾಗಿ ಬೇರೆ ವಿಷಯ.

878
00:59:12,830 --> 00:59:16,560
ನಾವು ಅದನ್ನು ಮುದ್ರಿಸಲು ಮಾಡಿದಾಗ, ನಾವು ಮುದ್ರಿಸುತ್ತದೆ ಹೋಗುವ ಇದು, 'ನಾನು' + ಮುದ್ರಿಸಿ ನೀನು 4,

879
00:59:16,560 --> 00:59:19,640
ಕ್ಷಮಿಸಿ - ಮತ್ತು ನಾವು ನೀನು.

880
00:59:19,640 --> 00:59:22,030
ನಂತರ ನಾವು ಆ ಕ್ರಿಯೆಯ ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು ನೀನು,

881
00:59:22,030 --> 00:59:24,820
ಮತ್ತು ನಾವು ಬಾಣದ ಇದೀಗ ಅಲ್ಲಿ ಎಂದು ನೀನು.

882
00:59:24,820 --> 00:59:29,190
ಆ ನಂತರ, ಆದಾಗ್ಯೂ, ಕಾರ್ಯ 'ನಾನು' ಮೌಲ್ಯವನ್ನು ಬದಲಾವಣೆ ಕೂಡ ಅರ್ಥ,

883
00:59:29,190 --> 00:59:32,620
ಇದು ಹೊರಗೆ ಕ್ರಿಯೆಯ ಬದಲಾಗಲಿಲ್ಲ,

884
00:59:32,620 --> 00:59:35,060
ಕಾರ್ಯ ಪ್ರತ್ಯೇಕ ವ್ಯಾಪ್ತಿಯನ್ನು ಹೊಂದಿದೆ ಏಕೆಂದರೆ.

885
00:59:35,060 --> 00:59:38,960
ಆ, ನಾವು 'ನಾನು' ಪ್ರತಿಧ್ವನಿ ಅದು ಕಾರ್ಯ ವ್ಯಾಪ್ತಿಯ ಬದಲಾಗಿಲ್ಲ ಅರ್ಥ

886
00:59:38,960 --> 00:59:43,660
ಆದ್ದರಿಂದ ನಾವು ಮತ್ತೆ 3 ಮುದ್ರಿಸಲು ನೀನು.

887
00:59:43,660 --> 00:59:47,520
ಸಿ ಹೆಚ್ಚು PHP ಯಲ್ಲಿ ವ್ಯಾಪ್ತಿ ಬಗ್ಗೆ ಬೇರೆಬೇರೆ

888
00:59:47,520 --> 00:59:51,130
>> ಈಗ PHP ಮತ್ತು HTML ನಲ್ಲಿ.

889
00:59:51,130 --> 00:59:53,510
ಪಿಎಚ್ಪಿ ವೆಬ್ ಪುಟಗಳು ಕ್ರಿಯಾತ್ಮಕ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ.

890
00:59:53,510 --> 00:59:58,660
ಇದು ರೀತಿಯ ವಸ್ತುಗಳ ವಿವಿಧ ಮಾಡುತ್ತದೆ.

891
00:59:58,660 --> 01:00:02,090
ನಾವು HTML ಇದನ್ನು ವಿವಿಧ ಹೊಂದಿವೆ.

892
01:00:02,090 --> 01:00:05,230
ಎಚ್ಟಿಎಮ್ಎಲ್, ನಾವು ಯಾವಾಗಲೂ ಕೇವಲ, ರಾಬ್ ತೋರಿಸಿದರು ಹೇಗೆ ಅದೇ ಸ್ಥಿರ ವಿಷಯವನ್ನು ಹೊಂದಿರುತ್ತವೆ

893
01:00:05,230 --> 01:00:09,370
ಪಿಎಚ್ಪಿ ಆದರೆ, ನೀವು ಬಳಕೆದಾರ ಯಾರು ಆಧರಿಸಿ ವಿಷಯಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು.

894
01:00:09,370 --> 01:00:11,830
ನಾನು ಈ ಹಾಗಾಗಿ, ನಾನು, "ನೀವು ಪ್ರವೇಶಿಸಿದಾಗ -" ಮತ್ತು ನಂತರ ಹೆಸರು,

895
01:00:11,830 --> 01:00:14,420
ಮತ್ತು ನಾನು ಹೆಸರನ್ನು ಬದಲಾಯಿಸಬಹುದು. ಆದ್ದರಿಂದ ಈಗ ಹೆಸರು, ಜೋಸೆಫ್

896
01:00:14,420 --> 01:00:18,880
ಮತ್ತು ಇದು ", ನನ್ನ ಬಗ್ಗೆ" ಹೊಂದಿದೆ ಆದರೆ ನಂತರ ನಾನು ಟಾಮಿ ಹೊಂದಲು ಹೆಸರು ಬದಲಾಯಿಸಬಹುದು.

897
01:00:18,880 --> 01:00:21,700
ಮತ್ತು ಬೇರೆ ವಿಷಯ.

898
01:00:21,700 --> 01:00:23,840
ಆದ್ದರಿಂದ ನಾವು ಅವನ ಬಗ್ಗೆ ವಿವಿಧ ವಿಷಯಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು,

899
01:00:23,840 --> 01:00:27,070
ಮತ್ತು ಹೆಸರು ಆಧರಿಸಿ ವಿವಿಧ ವಿಷಯ ತೋರಿಸುತ್ತದೆ.

900
01:00:27,070 --> 01:00:31,430
ಆದ್ದರಿಂದ ಪಿಎಚ್ಪಿ ರೀತಿಯ ನಿಮ್ಮ ವೆಬ್ಸೈಟ್ನಲ್ಲಿ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ಬದಲಾಯಿಸಬಹುದು.

901
01:00:31,430 --> 01:00:33,540
ಇಲ್ಲಿ ಅದೇ. ಸ್ಟಿಲ್, ಅವರು ಬೇರೆ ವಿಷಯವನ್ನು ಹೊಂದಿರುವ ಗಮನಿಸಿ,

902
01:00:33,540 --> 01:00:38,870
ನೀವು ತಾಂತ್ರಿಕವಾಗಿ ಇನ್ನೂ ಮೇಲ್ಮೈ ಮೇಲೆ ಅದೇ ವೆಬ್ ಪುಟ ಪ್ರವೇಶಿಸುವ ಸಹ.

903
01:00:38,870 --> 01:00:43,450
HTML ಉತ್ಪತ್ತಿ. ನೀವು ಹಾಗೆ ಮಾಡಬಹುದು 2 ವಿವಿಧ ಬಗೆಗಳು.

904
01:00:43,450 --> 01:00:48,980
ನಾವು ಇದೀಗ ಮೂಲಕ ಹೋಗುತ್ತೇನೆ. ಮೊದಲ ರೀತಿಯಲ್ಲಿ ನೀವು, - ಹೌದು, ಕ್ಷಮಿಸಿ.

905
01:00:48,980 --> 01:00:51,150
ಆದ್ದರಿಂದ ನೀವು, ಪಿಎಚ್ಪಿ ಲೂಪ್ ನಿಮ್ಮ ನಿಯಮಿತ ಹೊಂದಿವೆ

906
01:00:51,150 --> 01:00:56,270
ತದನಂತರ ನೀವು ಪಿಎಚ್ಪಿ ಪ್ರತಿಧ್ವನಿ ಮತ್ತು ನೀವು HTML ಔಟ್ ಪ್ರತಿಧ್ವನಿ.

907
01:00:56,270 --> 01:00:58,720
ರಾಬ್ ಎಚ್ಟಿಎಮ್ಎಲ್ ಲಿಪಿಯ ನೀವು ತೋರಿಸಿದ ಬಳಕೆ

908
01:00:58,720 --> 01:01:04,030
ತದನಂತರ ಕೇವಲ ವೆಬ್ ಪುಟ ಮುದ್ರಿಸುತ್ತದೆ ಪಿಎಚ್ಪಿ ಮುದ್ರಣ ಬಳಸಿ.

909
01:01:04,030 --> 01:01:09,520
ಪರ್ಯಾಯ ರೀತಿಯಲ್ಲಿ ನೀವು PHP ಮತ್ತು HTML ಬೇರ್ಪಡಿಸಲು ವೇಳೆ ಅದನ್ನು ಮಾಡುವುದು.

910
01:01:09,520 --> 01:01:11,940
ಆದ್ದರಿಂದ ನೀವು, ಲೂಪ್ ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಪಿಎಚ್ಪಿ ಒಂದು ಸಾಲಿನ ಹೊಂದಬಹುದು

911
01:01:11,940 --> 01:01:16,020
ನಂತರ ನೀವು ಒಂದು ಪ್ರತ್ಯೇಕ ವಿಷಯ HTML ನ ಲೈನ್ ಹೊಂದಬಹುದು,

912
01:01:16,020 --> 01:01:19,700
ತದನಂತರ ನೀವು PHP, ಮತ್ತೆ, ಲೂಪ್ ಮುಕ್ತಾಯಗೊಳ್ಳಲಿವೆ.

913
01:01:19,700 --> 01:01:21,800
ಆದ್ದರಿಂದ ರೀತಿಯ ಇದು ಬೇರ್ಪಡಿಸುವ ವಿಶೇಷವೇನು.

914
01:01:21,800 --> 01:01:24,020
ಎಡಭಾಗದಲ್ಲಿ, ನೀವು ಹೊಂದಬಹುದಾದ ಎಲ್ಲಾ -

915
01:01:24,020 --> 01:01:26,360
ಇದು ಪಿಎಚ್ಪಿ ಕೇವಲ 1 ಪಾಲನ್ನು ಇಲ್ಲಿದೆ.

916
01:01:26,360 --> 01:01:28,510
ಬಲ ಮೇಲೆ ನೀವು, ನೀವು ಪಿಎಚ್ಪಿ ಒಂದು ಲೈನ್ ಎಂದು ನೋಡಬಹುದು

917
01:01:28,510 --> 01:01:32,540
ನೀವು HTML ಲೈನ್, ಮತ್ತು ನೀವು ಮತ್ತೆ ಪಿಎಚ್ಪಿ ಒಂದು ಲೈನ್.

918
01:01:32,540 --> 01:01:36,870
ಆದ್ದರಿಂದ ಅವರು ಮಾಡುತ್ತಿರುವುದು ಅದನ್ನು ಬೇರ್ಪಡಿಸುವುದು.

919
01:01:36,870 --> 01:01:39,330
ಮತ್ತು ನೀವು ಇನ್ನೊಂದು ರೀತಿಯಲ್ಲಿ, ಅವುಗಳನ್ನು ಎರಡೂ, ಗಮನಿಸಿ ಮಾಡುತ್ತೇವೆ

920
01:01:39,330 --> 01:01:41,980
ಅವರು ಇನ್ನೂ ಚಿತ್ರ ಮುದ್ರಿಸುತ್ತದೆ, ಚಿತ್ರ, ಚಿತ್ರ,

921
01:01:41,980 --> 01:01:44,540
ಆದ್ದರಿಂದ HTML ಇನ್ನೂ ಅದೇ ರೀತಿಯಲ್ಲಿ ಮುದ್ರಿಸಲಾಗುತ್ತದೆ.

922
01:01:44,540 --> 01:01:49,870
ತದನಂತರ ನೀವು ಇನ್ನೂ 3 ಚಿತ್ರಗಳನ್ನು ನಿಮ್ಮ ವೆಬ್ಸೈಟ್ನಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುವುದಿಲ್ಲ ನೋಡುತ್ತಾರೆ.

923
01:01:49,870 --> 01:01:52,820
ಆದ್ದರಿಂದ ಒಂದೇ ಮಾಡುವ 2 ರೀತಿಯಲ್ಲಿ ಇಲ್ಲಿದೆ.

924
01:01:52,820 --> 01:01:55,060
>> ಈಗ ನಾವು ರೂಪಗಳು ಮತ್ತು ವಿನಂತಿಗಳನ್ನು ಹೊಂದಿವೆ. ರಾಬ್, ನೀವು ತೋರಿಸಿದೆ

925
01:01:55,060 --> 01:01:59,400
ಅಲ್ಲಿ HTML ರೂಪಗಳು, ಮತ್ತು ನಾವು ಈ ಮೂಲಕ ಗಾಳಿ ಕಾಣಿಸುತ್ತದೆ.

926
01:01:59,400 --> 01:02:02,040
ಕ್ರಿಯಾಶೀಲ ಮತ್ತು ನೀವು ಒಂದು ವಿಧಾನವನ್ನು ಹೊಂದಿವೆ, ಮತ್ತು ನಿಮ್ಮ ಕ್ರಮ

927
01:02:02,040 --> 01:02:04,350
ರೀತಿಯ ನೀವು ಕಳುಹಿಸಲು ನೀನು ಅಲ್ಲಿ ನೀವು ತೋರಿಸುತ್ತದೆ, ಮತ್ತು ವಿಧಾನ ಎಂದು

928
01:02:04,350 --> 01:02:06,960
ಇದು ಒಂದು ಪಡೆಯಲು ಅಥವಾ ಪೋಸ್ಟ್ ಎಂದು ವಿಶೇಷವೇನು.

929
01:02:06,960 --> 01:02:11,220
ಮತ್ತು ಪಡೆಯಿರಿ ವಿನಂತಿಯನ್ನು, ರಾಬ್ ಹೇಳಿದಂತೆ, ನೀವು ರೂಪದಲ್ಲಿ ಪುಟ್ ನೀನು ಅರ್ಥ

930
01:02:11,220 --> 01:02:15,760
ಒಂದು ವಸತಿ ವಿನಂತಿಯನ್ನು ನೀವು ಒಂದು URL ನೋಡಿ ಸಾಧ್ಯವಿಲ್ಲ ಆದರೆ ಮತ್ತು ನೀವು, ಒಂದು URL ಇದನ್ನು ನೋಡುತ್ತಾರೆ.

931
01:02:15,760 --> 01:02:17,840
ಆದ್ದರಿಂದ ಸ್ವಲ್ಪ ವ್ಯತ್ಯಾಸ.

932
01:02:17,840 --> 01:02:19,950
ಆದರೆ, ಇದೇ ವಿಷಯ ಒಂದು ವಿಷಯ

933
01:02:19,950 --> 01:02:22,560
ಪೋಸ್ಟ್ ಪಡೆಯಿರಿ ಸಮನಾಗಿ ಅಸುರಕ್ಷಿತ ಎಂಬುದು.

934
01:02:22,560 --> 01:02:26,430
ಆದ್ದರಿಂದ ನೀವು, ಕೇವಲ ನೀವು URL ನಲ್ಲಿ ನೋಡದಿದ್ದರೆ ಎಂದು ಭಾವಿಸಬಹುದು

935
01:02:26,430 --> 01:02:28,790
ಎಂದು, ಪೋಸ್ಟ್ಗೆ ಹೆಚ್ಚು ಸುರಕ್ಷಿತ ಅರ್ಥ

936
01:02:28,790 --> 01:02:34,420
ಆದರೆ ನೀವು ಇನ್ನೂ ನೀವು ಕಳುಹಿಸಲು ನೀವು ಮಾಹಿತಿಯನ್ನು ನಿಮ್ಮ ಕುಕೀಸ್ ಇದನ್ನು ನೋಡಬಹುದು.

937
01:02:34,420 --> 01:02:38,260
ಆದ್ದರಿಂದ ಯೋಚಿಸುವುದಿಲ್ಲ ಬಗ್ಗೆ ಒಂದು ಅಥವಾ ಇತರ.

938
01:02:38,260 --> 01:02:42,160
ಗಮನಿಸಬೇಕಾದ ಇನ್ನೊಂದು ವಿಷಯ ನೀವು ವಿಭಾಗದಲ್ಲಿ ಅಸ್ಥಿರ ಹೊಂದಿರುತ್ತವೆ.

939
01:02:42,160 --> 01:02:45,850
ನೀವು ಹುಡುಗರಿಗೆ ನಿಮ್ಮ ಬಳಕೆದಾರ ID ಮಾಹಿತಿ ಪಡೆಯಲು pset 7 ರಲ್ಲಿ ಈ ಬಳಸಲಾಗುತ್ತದೆ.

940
01:02:45,850 --> 01:02:48,550
ಏನಾಯಿತು ಈ ಸಹಾಯಕ ರಚನೆಯ ಬಳಸಬಹುದಾದ ಆಗಿತ್ತು,

941
01:02:48,550 --> 01:02:53,310
$ _SESSION, ಮತ್ತು ನಂತರ ನೀವು ವಿವಿಧ ವಿಷಯಗಳಿಗೆ ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ನೀವು

942
01:02:53,310 --> 01:02:57,720
ಮತ್ತು ಪುಟಗಳು ವಿವಿಧ ವಿಷಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು.

943
01:02:57,720 --> 01:03:00,750
>> ಕೊನೆಯ ವಿಷಯ, ನಾವು SQL, ರಚನಾತ್ಮಕ ವೈಚಾರಿಕ ಭಾಷೆ ಹೊಂದಿರುತ್ತವೆ

944
01:03:00,750 --> 01:03:04,360
ಮತ್ತು ಈ ಡೇಟಾಬೇಸ್ ನಿರ್ವಹಿಸಲು ಒಂದು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ.

945
01:03:04,360 --> 01:03:08,220
, ನಿಖರವಾಗಿ, ಡೇಟಾಬೇಸ್ ಯಾವುವು? ಅವರು ಕೋಷ್ಟಕಗಳು ಸಂಗ್ರಹಣೆಗಳು ಆರ್,

946
01:03:08,220 --> 01:03:10,630
ಮತ್ತು ಪ್ರತಿ ಟೇಬಲ್ ವಸ್ತುಗಳ ಇದೇ ರೀತಿಯ ಹೊಂದಬಹುದು.

947
01:03:10,630 --> 01:03:14,990
ನಾವು ನಿಮ್ಮ ಹಣಕಾಸು pset ರಲ್ಲಿ ಬಳಕೆದಾರರು ಒಂದು ಟೇಬಲ್ ಹೊಂದಿತ್ತು.

948
01:03:14,990 --> 01:03:20,610
ಯಾಕೆ ಅವರು ಉಪಯುಕ್ತ? ಇದು ಶಾಶ್ವತವಾಗಿ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸುವ ಒಂದು ರೀತಿಯಲ್ಲಿ ಕಾರಣ.

949
01:03:20,610 --> 01:03:22,840
ಇದು ವಿಷಯಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮತ್ತು ವಿಷಯಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ

950
01:03:22,840 --> 01:03:25,890
ಮತ್ತು ವಾಸ್ತವವಾಗಿ ವಿವಿಧ ಪುಟಗಳು ಮತ್ತು ಕೀಪಿಂಗ್ ಟ್ರ್ಯಾಕ್ ಮೇಲೆ ನೋಡಿದ.

951
01:03:25,890 --> 01:03:29,930
ಆದರೆ ನೀವು ಕೇವಲ ಒಂದು ತಕ್ಷಣದ ಕ್ಷಣದಲ್ಲಿ ಅದನ್ನು ಸಂಗ್ರಹಿಸಲು ವೇಳೆ

952
01:03:29,930 --> 01:03:33,720
ನಂತರ ಅದನ್ನು ಬಳಸಲು, ನೀವು ಉಳಿಸಿದ್ದೇವೆ ಏನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

953
01:03:33,720 --> 01:03:37,660
ನಾವು ನಾವು SQL ಆಜ್ಞೆಗಳನ್ನು ಬಳಸಲು 4 ಪ್ರಮುಖ ವಿಷಯಗಳನ್ನು.

954
01:03:37,660 --> 01:03:40,190
ನಾವು ಆಯ್ಕೆ ಸೇರಿಸು, ಅಳಿಸಿ, ಮತ್ತು ಅಪ್ಡೇಟ್ ಹೊಂದಿವೆ.

955
01:03:40,190 --> 01:03:42,880
ಆ ನೀವು ಹುಡುಗರಿಗೆ ನಿಮ್ಮ ರಸಪ್ರಶ್ನೆ ತಿಳಿಯಲು ನಿಜವಾಗಿಯೂ ಮುಖ್ಯ.

956
01:03:42,880 --> 01:03:45,990
>> ಬೇಗ ಇದೀಗ ಮೇಲೆ ಆಯ್ಕೆ ಹೋಗುತ್ತೇನೆ.

957
01:03:45,990 --> 01:03:48,540
ಮೂಲಭೂತವಾಗಿ, ನೀವು ಒಂದು ಡೇಟಾಬೇಸ್ ಸಾಲುಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತಿದ್ದೇವೆ.

958
01:03:48,540 --> 01:03:52,400
ಆದ್ದರಿಂದ ನೀವು ಇಲ್ಲಿಯೇ, ಹೊಂದಿದ್ದರೆ -

959
01:03:52,400 --> 01:03:56,740
ನಾವು ಈ 2 ಬೇರೆಬೇರೆ, ಮತ್ತು ನಾವು ತರಗತಿಗಳು ಟೇಬಲ್ ಆಯ್ಕೆ ಬಯಸುವ

960
01:03:56,740 --> 01:04:01,480
ನಿಜಕ್ಕೂ - ನಾಡಿದು ಅಂಕಣದಲ್ಲಿ ಮೌಲ್ಯ 1 ಅಲ್ಲಿ.

961
01:04:01,480 --> 01:04:04,460
ನೀವು ಇಲ್ಲಿ ನೋಡಬಹುದು ಆದ್ದರಿಂದ, ನಾವು, ವರ್ಗ ಹೆಸರಿನ ಈ 2 ವಿಷಯಗಳನ್ನು

962
01:04:04,460 --> 01:04:08,490
CS50 ಮತ್ತು Stat110, ಮತ್ತು ನಾವು ವರ್ಗ ID ಗಳು ಮತ್ತು ಘೋಷಣೆ ಹೊಂದಿವೆ.

963
01:04:08,490 --> 01:04:13,150
ನಾವು ಎಲ್ಲಾ ಮಾಹಿತಿಗಳನ್ನು ಆಯ್ಕೆ ಬಯಸುವ.

964
01:04:13,150 --> 01:04:17,480
ನಂತರ ನೀವು, ಇದು ರೀತಿಯ ನಿಜಕ್ಕೂ ಅಂಕಣ ಉಂಟಾಗದಂತೆ ಎಂದು ಇಲ್ಲಿಯೇ ನೋಡಬಹುದು

965
01:04:17,480 --> 01:04:25,170
ಎಲ್ಲಾ ವಿಷಯಗಳನ್ನು 1, ಮತ್ತು ನಂತರ ಅದನ್ನು ವರ್ಗ ID ಯನ್ನು, ವರ್ಗದ ಹೆಸರು ಮತ್ತು ತೆಗೆಯಬೇಡಿ ಎಂದು ಘೋಷಣೆ ಹೊಂದಿದೆ ಅಲ್ಲಿ.

966
01:04:25,170 --> 01:04:28,100
ನೀವು ಈ ಕೋಡ್ ಹೇಗೆ ನಿಖರವಾಗಿ ಮಾಡಬೇಕು? ನೀವು ಪಿಎಚ್ಪಿ ಬಳಸಲು ಹೊಂದಿರುತ್ತವೆ.

967
01:04:28,100 --> 01:04:33,830
ಆದ್ದರಿಂದ ಆ ರೀತಿಯ ಪಿಎಚ್ಪಿ ಮತ್ತು SQL ಪರಸ್ಪರ ಸಂಬಂಧಿಸಿದ ಹೇಗೆ ಇಲ್ಲಿದೆ.

968
01:04:33,830 --> 01:04:38,130
ಈಗ ನಾವು ನಮ್ಮ ಕೋಡ್ ಹೊಂದಿವೆ, ಮತ್ತು ನಾವು ನಮ್ಮ ಪ್ರಶ್ನೆಗೆ ಕಾರ್ಯ ಬಳಸಲು ನೀನು

969
01:04:38,130 --> 01:04:41,370
ನಾವು pset 7 ಮಾಡಿದರು, ಮತ್ತು ನಾವು SQL ಪ್ರಶ್ನೆ ಚಲಾಯಿಸಲು ನೀನು.

970
01:04:41,370 --> 01:04:43,870
ನಂತರ ನಾವು ನೀನು -

971
01:04:43,870 --> 01:04:46,280
ನಾವು ಯಾವಾಗಲೂ ಸುಳ್ಳು ವೇಳೆ ಸಾಲು ತ್ರಿವಳಿ ಸಮಾನ ವೇಳೆ ಪರೀಕ್ಷಿಸಲು ಹೊಂದಿಲ್ಲ.

972
01:04:46,280 --> 01:04:49,010
ಆದ್ದರಿಂದ ಮತ್ತೆ, ನೀವು ರೀತಿಯ ಮತ್ತು ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸಿ ಬಯಸುವ,

973
01:04:49,010 --> 01:04:53,880
ಇದು ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ ಮತ್ತು ನಂತರ ನೀವು ನಾವು pset 7 ಮಾಡಿದಂತೆ, ಎಂದಿನಂತೆ, ಕ್ಷಮೆ ಬಯಸುವ.

974
01:04:53,880 --> 01:04:55,870
ಇಲ್ಲವಾದರೆ, ನೀವು ಆ HANDY ಎಲ್ಲವೂ ಮೂಲಕ ಲೂಪ್ ಬಯಸುವ

975
01:04:55,870 --> 01:04:59,410
foreach ನಾವು ಹೋದೆ ಕುಣಿಕೆಗಳು.

976
01:04:59,410 --> 01:05:01,280
, ನಾವು ಮೂಲಕ ಲೂಪ್ ನೀವು ಮತ್ತು ನಾವು ಕಳೆದ ಅದನ್ನು ಮಾಡಿದ ಈಗ ಆ

977
01:05:01,280 --> 01:05:05,080
ನಮ್ಮ ಪ್ರಶ್ನೆಗೆ ಜಾರಿಗೆ ಎಂದು ಊಹಿಸುತ್ತವೆ ಅವಕಾಶ, ಈಗ ನಮ್ಮ foreach ಲೂಪ್ ಹೊಂದಿರುತ್ತವೆ.

978
01:05:05,080 --> 01:05:11,050
ಮತ್ತು ಮೊದಲ ಸಾಲು ಇದು, ಇಲ್ಲಿ ಸಾಲು ಇಲ್ಲಿಯೇ, ಇಲ್ಲಿದೆ; ಇದು, ಪೆಟ್ಟಿಗೆಯ.

979
01:05:11,050 --> 01:05:14,010
ಇದು ನೆತ್ತಿಗೇರಿದೆ ಎಂದು ಎಲ್ಲಾ ಮಾಹಿತಿಯನ್ನು ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು.

980
01:05:14,010 --> 01:05:18,070
ಆದ್ದರಿಂದ ಕೆಳಭಾಗದಲ್ಲಿ ಔಟ್ ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು "ವಾನ್ನಾ HTML ತಿಳಿಯಿರಿ?"

981
01:05:18,070 --> 01:05:23,370
ಇದು ಲೂಪ್ ಮೊದಲ ಸಂಪೂರ್ಣಗೊಂಡ ನಂತರ ಏಕೆಂದರೆ ಇದು, ಮುಂದಿನ ಸಾಲು ಹೋಗಲು ವಿಶೇಷವೇನು

982
01:05:23,370 --> 01:05:26,510
ಹೀಗಾಗಿ ಅದು, ಇದು ಎರಡನೇ ಸಾಲಿನಲ್ಲಿ ಔಟ್ ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು

983
01:05:26,510 --> 01:05:32,120
STAT110 ಏರಲಿದೆ ಇದು, ಎಲ್ಲಾ ಕ್ಷಣಗಳ ಕ್ಲಿಕ್.

984
01:05:32,120 --> 01:05:34,290
>> ಒಂದು ಕೊನೆಯ ವಿಷಯ SQL ಲೋಪಗಳ ಮೇಲೆ.

985
01:05:34,290 --> 01:05:37,300
ನಾನು ಡೇವಿಡ್ ಈ ಮೇಲೆ ಉಪನ್ಯಾಸ ಸ್ವಲ್ಪ ಮುಟ್ಟಲಿಲ್ಲ ಗೊತ್ತು.

986
01:05:37,300 --> 01:05:40,730
ನೀವು ನಂತರ ಈ ಓದಬಹುದು. ಇದು ನಿಜವಾಗಿಯೂ ಹಾಸ್ಯಾಸ್ಪದ.

987
01:05:40,730 --> 01:05:45,320
SQL ಇಂಜೆಕ್ಷನ್ ಟ್ರಿಕಿ ವಿಷಯ ಒಂದು ರೀತಿಯ.

988
01:05:45,320 --> 01:05:49,890
ನೀವು ಸರಿಯಾದ ನಿಮ್ಮ ಪ್ರಶ್ನೆಗೆ ಒಳಗೆ ಆ ಅಸ್ಥಿರ ಅಂಟಿಕೊಳ್ಳುವುದಿಲ್ಲ ಎಂದು ಹೇಳುತ್ತಾರೆ,

989
01:05:49,890 --> 01:05:52,290
ನೀವು ಮೊದಲ ಸಾಲಿನಲ್ಲಿ ನೋಡಬಹುದು.

990
01:05:52,290 --> 01:05:54,520
ಆದ್ದರಿಂದ ಬಲ, ಉತ್ತಮ ತೋರುತ್ತದೆ? ನೀವು ಬಳಕೆದಾರ ಹೆಸರು ಪುಟ್ಟಿಂಗ್ ಮಾಡುತ್ತಿರುವ

991
01:05:54,520 --> 01:05:58,820
ನಿಮ್ಮ SQL ಪ್ರಶ್ನೆ ಪಾಸ್ವರ್ಡ್, ಮತ್ತು ನೀವು ಅದನ್ನು ಆಫ್ ಹಡಗು ಮತ್ತು ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಕೋಷ್ಟಕದಲ್ಲಿ ಏನೇ ಸಿಗತ್ತೆ.

992
01:05:58,820 --> 01:06:01,450
ಬಹಳ ಸರಳ ತೋರುತ್ತದೆ. ಆದ್ದರಿಂದ, ಯಾರಾದರೂ ಇರಿಸುತ್ತದೆ ಹೇಳಲು ಅವಕಾಶ

993
01:06:01,450 --> 01:06:04,910
ಪಾಸ್ವರ್ಡ್, ಈ ಅಥವಾ ಪಠ್ಯ ಇಲ್ಲಿಯೇ -

994
01:06:04,910 --> 01:06:06,780
ವಾಸ್ತವವಾಗಿ ಕೆಂಪು ಬಾಕ್ಸ್ ನಲ್ಲಿ ಇರಬೇಕು.

995
01:06:06,780 --> 01:06:11,920
ಆದ್ದರಿಂದ ಅವರು ಒಳಗೆ ಪಾಸ್ವರ್ಡ್ ಪುಟ್ ಎಂದು ತಿಳಿಸಿ - ಎಂದು ಅವರು ನಮೂದಿಸಿ ಇಲ್ಲಿದೆ.

996
01:06:11,920 --> 01:06:16,520
ಆದ್ದರಿಂದ ಅವರು ಹಾಕುವ ಅಥವಾ "1" = 1 ಮಾಡುತ್ತಿದ್ದೇವೆ.

997
01:06:16,520 --> 01:06:20,880
ಹೊಂದಲು ಒಂದು ಸಿಲ್ಲಿ ಗುಪ್ತಪದವನ್ನು ರೀತಿಯ.

998
01:06:20,880 --> 01:06:25,070
ಈಗ ಅದನ್ನು ಬದಲಾಯಿಸಲು ಅವಕಾಶ, ಮತ್ತು ನೀವು ಈಗ SQL ಪ್ರಶ್ನೆ ಗಮನಿಸಿ ಮಾಡುತ್ತೇವೆ,

999
01:06:25,070 --> 01:06:29,090
ನೀವು ಗಮನಿಸಿ ನೀವು ಏಕೆಂದರೆ ಇದು, ಯಾವಾಗಲೂ ನಿಜವೆಂದು ಮಾಪನ ಎಂದು

1000
01:06:29,090 --> 01:06:32,240
ನೀವು SQL ಪ್ರಶ್ನೆ ಈ ಮಾಹಿತಿಯನ್ನು ಎಲ್ಲಾ ಆಯ್ಕೆ ಮಾಡಬಹುದು

1001
01:06:32,240 --> 01:06:35,420
ಅಥವಾ ನೀವು ಕೇವಲ = 1 1 ಹೊಂದಬಹುದು.

1002
01:06:35,420 --> 01:06:41,030
ಆದ್ದರಿಂದ ಯಾವಾಗಲೂ ನಿಜವಾದ ಗೆ ಮೌಲ್ಯಮಾಪನ ವಿಶೇಷವೇನು.

1003
01:06:41,030 --> 01:06:46,610
ಎಂದು ಹ್ಯಾಕರ್ ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಯ ಮುರಿದು ಎಂದರ್ಥ ಏಕೆಂದರೆ, ನಿಜವಾಗಿಯೂ ಕೆಲಸ ಹಿಂದಿರುಗಬಹುದೆಂದು.

1004
01:06:46,610 --> 01:06:49,300
ಈ ಪರಿಹಾರ ನೀವು, PDO ವ್ಯವಸ್ಥೆಯನ್ನು ಬಳಸಲು ಹೊಂದಿರುತ್ತವೆ,

1005
01:06:49,300 --> 01:06:51,360
ಇದು, ನೀವು ಪ್ರಶ್ನೆ ಅಂಕಗಳನ್ನು ಬಳಸಲು ಎಂದು ಅರ್ಥ

1006
01:06:51,360 --> 01:06:53,350
ಏನು ನೀವು pset 7 ಬಳಸಲಾಗುತ್ತದೆ ಹುಡುಗರಿಗೆ, ಇದು

1007
01:06:53,350 --> 01:06:57,620
ನೀವು ಏನಾದರೂ ಹಾಕಲು ಬಯಸುವ ಸ್ಥಳದಲ್ಲಿ ಒಂದು ಪ್ರಶ್ನೆ ಗುರುತು ಬಳಸಲು ನೀನು ಅಲ್ಲಿ,

1008
01:06:57,620 --> 01:07:01,430
ಮತ್ತು, ನಂತರ ನೀವು ಚಿಹ್ನೆಗಳಿಂದ ಮಾಡಲಿಕ್ಕೆ, ಮತ್ತು ನಂತರ ನೀವು ನಂತರ ಹೊಂದಿರುತ್ತದೆ

1009
01:07:01,430 --> 01:07:07,610
ನಿಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ನಂತರ, ನೀವು ಬಯಸುವ ವಿಭಿನ್ನ ಅಸ್ಥಿರ ನಿಮ್ಮ ಪ್ರಶ್ನೆ ಗುರುತು ಒಳಗೆ ಬದಲಿಗೆ.

1010
01:07:07,610 --> 01:07:10,330
ಆದ್ದರಿಂದ ನೀವು ಈಗ ನಾನು ಈ ಕೆಂಪು ಪ್ರಶ್ನೆ ಅಂಕಗಳನ್ನು ಹೊಂದಿವೆ ಇಲ್ಲಿ ಗಮನಿಸಿ ಮಾಡುತ್ತೇವೆ.

1011
01:07:10,330 --> 01:07:15,420
ನಾನು ನಂತರ ಎಂದು ಸಲುವಾಗಿ ಅವುಗಳನ್ನು ಬದಲಾಯಿಸಲು ಗೊತ್ತು ಆದ್ದರಿಂದ ನನ್ನ ತಂತಿಗಳನ್ನು ನಂತರ ಅಸ್ಥಿರ ಪುಟ್.

1012
01:07:15,420 --> 01:07:18,470
ಯಾರಾದರೂ ಈ ರೀತಿ ಇದ್ದಲ್ಲಿ, ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಕಾಣಿಸುತ್ತದೆ

1013
01:07:18,470 --> 01:07:24,050
ಮತ್ತು ಅವರು, ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಎಂದು, ಅಥವಾ 1 = 1 ಪರಿಸ್ಥಿತಿ ಹೊಂದಿವೆ

1014
01:07:24,050 --> 01:07:30,490
ಮತ್ತೆ ಕೊನೆಯಲ್ಲಿ, ಇದು ವಾಸ್ತವವಾಗಿ SQL ಪ್ರಶ್ನೆ ಮುರಿಯಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

1015
01:07:30,490 --> 01:07:33,660
ಸರಿ, ಪಿಎಚ್ಪಿ ಮತ್ತು SQL ಸುಂಟರಗಾಳಿ, ಬಹುಮಟ್ಟಿಗೆ ಅದು ಇಲ್ಲಿದೆ.

1016
01:07:33,660 --> 01:07:41,520
ನೀವು ಎಲ್ಲಾ ಅದೃಷ್ಟ ಉತ್ತಮ, ಮತ್ತು ಈಗ Ore. ಗೆ

1017
01:07:41,520 --> 01:07:44,270
>> [Oreoluwatomiwa Babarinsa] ಸರಿ ಎಲ್ಲರೂ. ಕೆಲವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮೇಲೆ ಹೋಗಲು ಟೈಮ್

1018
01:07:44,270 --> 01:07:48,840
ಮತ್ತು ಇತರ ವಿಷಯಗಳನ್ನು ಬೇಗನೆ ಆದ್ದರಿಂದ ನಾವು ನೀವು ಟುನೈಟ್ ಪಡುವುದಿಲ್ಲ.

1019
01:07:48,840 --> 01:07:56,930
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್. ಹೌದು. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ, ತಂಪಾದ ವಿಷಯ ರೀತಿಯ.

1020
01:07:56,930 --> 01:07:59,090
ನೀವು ನಿಜವಾಗಿಯೂ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ತಿಳಿದುಕೊಳ್ಳಬೇಕು ವಿಷಯಗಳನ್ನು, ಇದು ರೀತಿಯ ಹೀಗಿದೆ

1021
01:07:59,090 --> 01:08:03,810
ನಿಮ್ಮ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಮಾಡುವಾಗ ಏನಾಗುತ್ತಿದೆ ಕ್ಲೈಂಟ್ ಸೈಡ್ ಕೊನೆಯಲ್ಲಿ.

1022
01:08:03,810 --> 01:08:08,280
ನೀವು ಸರ್ವರ್ ಬದಿಯಲ್ಲಿ ಸಾರ್ವಕಾಲಿಕ ಆರೈಕೆಯನ್ನು ಬಯಸುವುದಿಲ್ಲ ಕೆಲವು ವಿಷಯಗಳಿವೆ.

1023
01:08:08,280 --> 01:08:12,880
ಎಲ್ಲಾ ಸ್ವಲ್ಪ ಪರಸ್ಪರ, ಒಂದು ವಿಷಯ ಹೈಲೈಟ್ ಏನೋ ಕಣ್ಮರೆಯಾಗಿ ಮಾಡುವ.

1024
01:08:12,880 --> 01:08:15,340
ನೀವು ನಿಜವಾಗಿಯೂ ನಿಮ್ಮ ಪರಿಚಾರಕಕ್ಕೆ ಸಾರ್ವಕಾಲಿಕ ಮಾತನಾಡಲು ಹೊಂದಿವೆ ಬಯಸುವುದಿಲ್ಲ.

1025
01:08:15,340 --> 01:08:18,069
ಮತ್ತು ಕೆಲವು ಸರ್ವರ್ ಬದಿಯಲ್ಲಿ ಮಾಡಲು ಸಹ ಸಾಧ್ಯವಿಲ್ಲ.

1026
01:08:18,069 --> 01:08:21,899
ನಾವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ರೀತಿಯ ಅಗತ್ಯವಿದೆ ಏಕೆ ಇದು.

1027
01:08:21,899 --> 01:08:24,359
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಗ್ಗೆ ಕೂಲ್ ವಿಷಯಗಳನ್ನು: ಇದು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಟೈಪಿಸಿದ ಇದೆ.

1028
01:08:24,359 --> 01:08:27,149
ಏನು ಇದರರ್ಥ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ತಿಳಿದುಕೊಳ್ಳಬೇಕು ಮಾಡುವುದಿಲ್ಲ ಎಂದು

1029
01:08:27,149 --> 01:08:30,970
ನೀವು ಇದನ್ನು ಬರೆಯಲು ಏನು, ನಿಖರವಾಗಿ, ಚರಾಂಕಗಳ ಇವೆ.

1030
01:08:30,970 --> 01:08:34,510
ಇದು ಚಾಲನೆಯಲ್ಲಿರುವ ಎಂದು ಕೇವಲ ರೀತಿಯ ಇದು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತೇವೆ.

1031
01:08:34,510 --> 01:08:37,520
ಅದರ ಬಗ್ಗೆ ತಂಪಾದ ಇತರ ವಸ್ತುಗಳ: ಇದು ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ಭಾಷೆ,

1032
01:08:37,520 --> 01:08:41,359
ಇದು ವಾಕ್ಯ ಸಿ ಮತ್ತು ಪಿಎಚ್ಪಿ ಹೋಲುತ್ತದೆ ಅರ್ಥ.

1033
01:08:41,359 --> 01:08:47,050
ನೀವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಲಿಕೆ ಮಾಡಿದಾಗ ಹೆಚ್ಚು ಮರು ಮಾಡಲು ಹೊಂದಿಲ್ಲ.

1034
01:08:47,050 --> 01:08:49,180
ಇಲ್ಲಿ ನಾವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸ್ವಲ್ಪ ಹೊಂದಿವೆ.

1035
01:08:49,180 --> 01:08:52,560
ಇಲ್ಲಿಯೇ ಕುತೂಹಲಕಾರಿ ವಿಷಯ, ನೀವು ಅದನ್ನು ನೋಡಿದರೆ, ಆಗಿದೆ

1036
01:08:52,560 --> 01:08:56,330
ನಾವು ತಲೆ ಟ್ಯಾಗ್ ಬಲ ಅಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಒಂದು ಬಿಟ್ ಹೊಂದಿವೆ.

1037
01:08:56,330 --> 01:08:59,479
ಏನು ಮೂಲತಃ ಕೇವಲ ಒಂದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಡತ ಸೇರಿವೆ ಇದೆ ಮಾಡುವುದಿಲ್ಲ.

1038
01:08:59,479 --> 01:09:02,260
ಈ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಒಳಗೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಒಳಗೊಳ್ಳಬಹುದು ಒಂದು ಮಾರ್ಗವಾಗಿದೆ.

1039
01:09:02,260 --> 01:09:06,910
ನಂತರ ಎರಡನೇ ಸ್ವಲ್ಪ, ವಾಸ್ತವವಾಗಿ ಕೆಲವು ಇನ್ಲೈನ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಗಿದೆ

1040
01:09:06,910 --> 01:09:10,790
ಅತ್ಯಂತ ಸಿಎಸ್ಎಸ್ ಒಂದು ಇನ್ಲೈನ್ ಶೈಲಿ ಹೋಲುವ,

1041
01:09:10,790 --> 01:09:16,180
ಮತ್ತು ನೀವು ಬೇಗನೆ ಕೆಲವು ಕೋಡ್ ಬರೆಯುತ್ತಿದ್ದೇವೆ.

1042
01:09:16,180 --> 01:09:18,120
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಾಲುಗಳು ಹೊಂದಿದೆ.

1043
01:09:18,120 --> 01:09:20,850
ತುಂಬಾ ಉಪಯುಕ್ತ, ಸುಮಾರು ದಶಮಾಂಶ ಇರಿಸಿಕೊಳ್ಳಲು ಮತ್ತೊಂದು ರೀತಿಯಲ್ಲಿ.

1044
01:09:20,850 --> 01:09:25,180
ಬಹಳ ಸಂತೋಷವನ್ನು ಮತ್ತು ಸುಲಭ ವಾಕ್ಯ.

1045
01:09:25,180 --> 01:09:29,870
ನೀವು ಎಲ್ಲವನ್ನೂ ಪ್ರವೇಶಿಸಲು ಮತ್ತು ಒಟ್ಟಿಗೆ ಎಲ್ಲವೂ ಇರಿಸಿಕೊಳ್ಳಲು ಚದರ ಬ್ರಾಕೆಟ್ಗಳನ್ನು ಬಳಸಿ.

1046
01:09:29,870 --> 01:09:35,020
ತುಂಬಾ ಸಂಕೀರ್ಣ ನಥಿಂಗ್.

1047
01:09:35,020 --> 01:09:38,630
ಸಾಮಾನ್ಯವಾಗಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಲಿಪಿಗಳ ಬಗ್ಗೆ ತಂಪಾದ ವಿಷಯ

1048
01:09:38,630 --> 01:09:40,920
ನೀವು ರಚನೆಯ ಗಾತ್ರಗಳು ಬಗ್ಗೆ ಚಿಂತೆ ಇಲ್ಲ ಎಂಬುದು.

1049
01:09:40,920 --> 01:09:43,880
ನೀವು array.length ಬಳಸಲು ಮತ್ತು ಇದು ಟ್ರ್ಯಾಕ್,

1050
01:09:43,880 --> 01:09:46,960
ಮತ್ತು ರಚನೆಯ ಬೆಳೆಯಲು ಅಥವಾ ನೀವು ಅಗತ್ಯವಿರುವ ಕುಗ್ಗಿಸಿ ಮಾಡಬಹುದು.

1051
01:09:46,960 --> 01:09:49,279
ಆದ್ದರಿಂದ ನೀವು ಸಹ, ಯಾವುದೇ ರೀತಿಯ ಬಗ್ಗೆ ಚಿಂತೆ ಮಾಡಬೇಕಿಲ್ಲ

1052
01:09:49,279 --> 01:09:57,050
ಓಹ್ ಇಲ್ಲ, ನಾನು ಹೆಚ್ಚು ವಿಷಯಗಳನ್ನು, ಅಥವಾ ಹಾಗೆ ಏನು ನಿಯೋಜಿಸಿ ಅಗತ್ಯವಿದೆ.

1053
01:09:57,050 --> 01:10:00,090
>> ಇಲ್ಲಿ ತಂಪಾದ ವಿಷಯ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಸ್ತುಗಳು ಕರೆಯುವುದನ್ನು ಹೊಂದಿದೆ.

1054
01:10:00,090 --> 01:10:04,800
ಇದು ವಸ್ತುನಿಷ್ಟವಾದ ಭಾಷೆ, ಆದ್ದರಿಂದ ಅದು ಯಾವ, ಮೂಲಭೂತವಾಗಿ,

1055
01:10:04,800 --> 01:10:10,100
ಗುಂಪು ಡೇಟಾ ನಿಮ್ಮನ್ನು ಒಂದು ರೀತಿಯಲ್ಲಿ ಒಟ್ಟಿಗೆ, ಒಂದು struct ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ಹೋಲುತ್ತದೆ,

1056
01:10:10,100 --> 01:10:17,280
ಆದರೆ ನೀವು struct ಹಾಗೆ ಅಥವಾ ಒಂದು ಸಹಾಯಕ ರಚನೆಯ ವಾಕ್ಯ ಇದನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.

1057
01:10:17,280 --> 01:10:22,520
ಇದು ಬಹಳ ಸರಳ ಮತ್ತು ನೀವು ಈ ಮಾಡಬಹುದು ಒಟ್ಟಿಗೆ ಗುಂಪು ದಶಮಾಂಶ ಆಗಿದೆ

1058
01:10:22,520 --> 01:10:24,810
ನೀವು ಸಂಬಂಧಿಸಿದ ಇಲ್ಲಿದೆ ದತ್ತಾಂಶದ ಒಂದು ಗುಂಪೇ ಇದ್ದರೆ.

1059
01:10:24,810 --> 01:10:26,850
ಇದು ನೀವು ಒಂದು ಕಾರು ವಿವರಿಸಲು ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ವಿಷಯಗಳನ್ನು ಏಕೆಂದರೆ,

1060
01:10:26,850 --> 01:10:29,050
ನೀವು ಬೇರೆ ಸ್ಥಳಗಳಲ್ಲಿ ಒಂದು ಗುಂಪೇ ಅದನ್ನು ಮಾಡಬೇಕಿಲ್ಲ.

1061
01:10:29,050 --> 01:10:35,300
ನೀವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ 1 ವಸ್ತು ಅದನ್ನು ಉಳಿಸಿಕೊಳ್ಳಿ.

1062
01:10:35,300 --> 01:10:39,090
ನೀವು ಬಹುಶಃ ತಿಳಿದಿರುವಂತೆ, iterating ಆ ಬೇಸರದ ಕಾರ್ಯಗಳನ್ನು ಒಂದು.

1063
01:10:39,090 --> 01:10:43,810
ನೀವು ಮತ್ತೆ ಒಂದು ಓವರ್ ಅದನ್ನು. ನೀವು, ಕಾರು ಪ್ರತಿಯೊಂದು ವಸ್ತುವಿನ ಮಾತನಾಡಲು ಅಗತ್ಯವಿದೆ

1064
01:10:43,810 --> 01:10:47,340
ಅಥವಾ ನೀವು ಪಟ್ಟಿ ಅಥವಾ ಸ್ವಲ್ಪ ಪ್ರತಿ ಐಟಂ ಅನುಸರಿಸುವ ಅಗತ್ಯವಿದೆ.

1065
01:10:47,340 --> 01:10:51,770
ಆದ್ದರಿಂದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್, ಪಿಎಚ್ಪಿ, ಒಂದು foreach ವಾಕ್ಯ ಹೋಲುತ್ತದೆ.

1066
01:10:51,770 --> 01:10:54,590
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಲೂಪ್ ಒಂದು ಇಲ್ಲಿದೆ.

1067
01:10:54,590 --> 01:10:57,300
ನೀವು ಕೇವಲ ವಸ್ತುಗಳ ಮೇಲೆ ಈ ಬಳಸಲು ಬಯಸುವ.

1068
01:10:57,300 --> 01:11:01,030
ನೀವು ಸರಣಿಗಳ ಮೇಲೆ ಈ ಬಳಸುತ್ತಿದ್ದರೆ ಸಂಭವಿಸುವ ಕೆಲವು ಸಮಸ್ಯೆಗಳಿವೆ.

1069
01:11:01,030 --> 01:11:03,750
ಇದು ಸಾಮಾನ್ಯವಾಗಿ, ಆದರೂ, ಬಹಳ ಸಹಾಯಕವಾಗಿದೆ, ಆ ವಸ್ತುಗಳ ಒಂದು

1070
01:11:03,750 --> 01:11:06,590
ನೀವು ಓವರ್ಹೆಡ್ ಬಹಳಷ್ಟು ತೊಡೆದುಹಾಕಲು ಏಕೆಂದರೆ

1071
01:11:06,590 --> 01:11:10,270
ನೀವು ಅದಕ್ಕೆ ನಿಮ್ಮ ವಸ್ತು ಎಲ್ಲವನ್ನೂ ಅಪ್ ಎಳೆಯಿರಿ ಇಲ್ಲ ಏಕೆಂದರೆ.

1072
01:11:10,270 --> 01:11:12,300
ನೀವು ಎಲ್ಲಾ ಪ್ರಮುಖ ಹೆಸರುಗಳು ನೆನಪಿಡಿ ಇಲ್ಲ.

1073
01:11:12,300 --> 01:11:18,270
ನೀವು ಕೇವಲ ರೀತಿಯ ಈ ವಾಕ್ಯ ಅವುಗಳನ್ನು ಮರಳಿ ಪಡೆಯಲು.

1074
01:11:18,270 --> 01:11:21,500
ಈ ರಲ್ಲಿ, ಫಾರ್, ನೀವು ಕೇವಲ ನೆನಪಿಡುವ ಬಯಸುವ

1075
01:11:21,500 --> 01:11:27,180
ನೀವು ಟೇಬಲ್ ಹ್ಯಾಶ್ ಒಂದು ತುಂಬಾ ಇದೇ ರೀತಿಯಲ್ಲಿ, ಎಲ್ಲಾ ಕೀಲಿಗಳನ್ನು ಮತ್ತೆ ಬರುತ್ತಿದೆ.

1076
01:11:27,180 --> 01:11:30,880
ನೀವು ಎಂದು ನೆನಪಿಡಿ ನೀವು ಒಂದು ಸಾಲಿನಲ್ಲಿ ಹಾಕುತ್ತಾನೆ, ನೀವು ಏನೋ ಪಡೆಯಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

1077
01:11:30,880 --> 01:11:33,840
ಇದು ಒಂದು ಸಂಬಂಧ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುತ್ತದೆ.

1078
01:11:33,840 --> 01:11:36,360
ನೀವು ಈ ಮಾಡಬಹುದು, ನೀವು, ಸರಿ ಹೇಳಬಹುದು

1079
01:11:36,360 --> 01:11:42,120
ನಾನು ಕಾರು ಪುಟ್, ಮತ್ತು ನಾನು ಫೆರಾರಿ ಕರೆಯಲಾಗುತ್ತದೆ.

1080
01:11:42,120 --> 01:11:45,290
ಆದ್ದರಿಂದ ನೀವು ನಂತರ ಮತ್ತೆ ಸ್ಟ್ರಿಂಗ್ ಫೆರಾರಿ ಹಾಕಬಹುದು, ಮತ್ತು ನೀವು ಎಂದು ಪಡೆಯುವುದು.

1081
01:11:45,290 --> 01:11:50,000
ಮತ್ತು ನೀವು ಚಕ್ರಕ್ಕೆ ಜೊತೆ, ಲೂಪ್ ಮಾಡಬಹುದು.

1082
01:11:50,000 --> 01:11:53,320
ಆದ್ದರಿಂದ ಕೇವಲ ವಸ್ತುಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚು. ನೀವು ನೆನಪಿಡುವ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ ಈ ಪ್ರಮುಖ ವಿಷಯ

1083
01:11:53,320 --> 01:12:00,340
, ನೀವು ಈ ಬೇಕಾದಾಗ ನೀವು ವಾಕ್ಯ ವಸ್ತು struct ಬಳಸಿ ಮಾಡಬಹುದು

1084
01:12:00,340 --> 01:12:04,590
ಏನು ನಿಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ಬಳಸಲು ಹೋಗುವ ಮಾನ್ಯ ವೇರಿಯಬಲ್ ಹೆಸರು ಒಂದು ವೇಳೆ ಹೊರತುಪಡಿಸಿ.

1085
01:12:04,590 --> 01:12:07,650
ನೀವು ಅಲ್ಲಿ ನೋಡಲು ಆದ್ದರಿಂದ, ನಾವು ಖಾಲಿ ಕೀ.

1086
01:12:07,650 --> 01:12:12,500
ಅಲ್ಲದೆ, ನೀವು object.key ಹಾಕಲು ವೇಳೆ, ಬಾಹ್ಯಾಕಾಶ, ಜೊತೆ, ಬಾಹ್ಯಾಕಾಶ, ಖಾಲಿ,

1087
01:12:12,500 --> 01:12:15,320
ಕೇವಲ syntactically ಅರ್ಥದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ.

1088
01:12:15,320 --> 01:12:22,730
ಆದ್ದರಿಂದ ನೀವು ಮಾತ್ರ ಬ್ರಾಕೆಟ್ ವಾಕ್ಯ ಈ ರೀತಿಯ ಆ ಮಾಡಬಹುದು.

1089
01:12:22,730 --> 01:12:26,520
>> ಸಹ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಹಳ ವ್ಯಾಪ್ತಿ ಬಲ್ಲ ಪಿಎಚ್ಪಿ ಹೊಂದಿದೆ.

1090
01:12:26,520 --> 01:12:29,050
ನೀವು ವ್ಯಾಪ್ತಿ ಸಂಬೋಧಿಸುವ 2 ಮಾರ್ಗಗಳಿವೆ.

1091
01:12:29,050 --> 01:12:31,960
ನೀವು ವೇರಿಯಬಲ್ ಮುಂದೆ ವರ್ ಹೊಂದುವಂತಿಲ್ಲ,

1092
01:12:31,960 --> 01:12:34,060
ಮತ್ತು ಕೇವಲ ಈ ಜಾಗತಿಕ ಅರ್ಥ.

1093
01:12:34,060 --> 01:12:37,050
ನೀವು ಎಲ್ಲಿಯಾದರೂ ಅದನ್ನು ನೋಡಬಹುದು. ನೀವು ಒಂದು ವೇಳೆ ಹೇಳಿಕೆ ಈ ಹಾಕಲು ಸಹ,

1094
01:12:37,050 --> 01:12:42,430
ಎಲ್ಲಕ್ಕಿಂತ ನಿಮ್ಮ ಕೋಡ್ ಆ ನಂತರ ನೀವು ವೇರಿಯಬಲ್ ನೋಡಬಹುದು.

1095
01:12:42,430 --> 01:12:46,730
ಇನ್ನೊಂದು ವಿಷಯ, ಆದರೂ, ನೀವು ಸೈನ್ ಆರ್ ಯಾವುದೇ ಕಾರ್ಯ ಸೀಮಿತ ವರ್ ಜೊತೆ

1096
01:12:46,730 --> 01:12:48,870
ನೀವು ಒಂದು ಕಾರ್ಯದಲ್ಲಿ ಇಲ್ಲದಿದ್ದರೆ, ಚೆನ್ನಾಗಿ, ಇದು ಜಾಗತಿಕ ಇಲ್ಲಿದೆ.

1097
01:12:48,870 --> 01:12:53,900
ನೀವು ಒಂದು ಕಾರ್ಯದಲ್ಲಿ ಆದರೆ ಇದು ಕಾರ್ಯ ಒಳಗೆ ಮಾತ್ರ ಗೋಚರ ಇಲ್ಲಿದೆ.

1098
01:12:53,900 --> 01:12:56,420
ನಾನು ಹೌದು, ಉದಾಹರಣೆಗೆ, ಆದರೆ ಇಲ್ಲ. ಇದು ಆ ವಸ್ತುಗಳ ಒಂದು ಅಲ್ಲಿ

1099
01:12:56,420 --> 01:12:59,900
ನೀವು, ನೀವು ಜಾಗತಿಕ ಯಾವ ಅಸ್ಥಿರ ನಿರ್ವಹಿಸಬಹುದು

1100
01:12:59,900 --> 01:13:03,810
ಏನು ಅಸ್ಥಿರ ನೀವು ಸ್ಥಳೀಯ ಬಯಸುತ್ತೇನೆ, ಆದರೆ ನೀವು ಈ ಬಗ್ಗೆ ಎಚ್ಚರಿಕೆ ಬೇಕು,

1101
01:13:03,810 --> 01:13:06,890
ನೀವು ಸಿ ಮಾಡಲು ಸೂಕ್ಷ್ಮ ಧಾನ್ಯ ನಿಯಂತ್ರಣ ಮಾದರಿ ಹೊಂದಿಲ್ಲ ಏಕೆಂದರೆ,

1102
01:13:06,890 --> 01:13:15,820
ಏನೋ ಲೂಪ್ ಒಂದು ಘೋಷಿಸಿದರು ಅದನ್ನು ಲೂಪ್ ಎಂದು ಉಳಿಯಲು ವಿಶೇಷವೇನು ಅಲ್ಲಿ.

1103
01:13:15,820 --> 01:13:18,790
ನಾವು ನಿಜವಾಗಿ JavaScript ಬಳಸಿ ಕಾಳಜಿ ವಿಷಯ ಬಲ, ವೆಬ್ ಪುಟಗಳು ಕುಶಲಬಳಕೆಯ ಇದೆ?

1104
01:13:18,790 --> 01:13:21,800
ನಾನು ಅರ್ಥ, ಎಂದು ಏಕೆ ನಾವು ಮಾಡುತ್ತಿರುವುದು ಇಲ್ಲಿದೆ.

1105
01:13:21,800 --> 01:13:23,840
>> ನಾವು DOM ಕರೆಯುವುದನ್ನು ಬಳಸಿ, ಹಾಗೆ.

1106
01:13:23,840 --> 01:13:25,850
ಡಾಕ್ಯುಮೆಂಟ್ ಆಬ್ಜೆಕ್ಟ್ ಮಾಡೆಲ್.

1107
01:13:25,850 --> 01:13:29,430
ಮೂಲತಃ, ಏನು ಅದು ಇದು ಎಲ್ಲಾ ನಿಮ್ಮ HTML ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

1108
01:13:29,430 --> 01:13:34,110
ಮತ್ತು ಪರಸ್ಪರ ಟಾಪನ್ನು ವಸ್ತುಗಳ ಒಂದು ಗುಂಪೇ ಮಾದರಿಗಳು ಇದನ್ನು.

1109
01:13:34,110 --> 01:13:37,080
ನೀವು ಈ ರೀತಿಯ ಔಟ್ ಆರಂಭಿಸಲು.

1110
01:13:37,080 --> 01:13:44,770
ನೀವು ಅಲ್ಲಿಗೆ ಕೋಡ್ ಒಂದು ಗುಂಪೇ ಆ ರೀತಿಯ ಇಲ್ಲಿದೆ, ನನಗೆ ಬಲಭಾಗದಲ್ಲಿ, ಹೊಂದಿವೆ -

1111
01:13:44,770 --> 01:13:46,640
ನೀವು ಕುಶಲತೆಯಿಂದ ಬಹಳ ಕಷ್ಟ ಬಯಸುವ ಯೋಚಿಸುವುದಿಲ್ಲ,

1112
01:13:46,640 --> 01:13:48,700
ನೀವು ಪಠ್ಯ ಒಂದು ಗುಂಪನ್ನು ಮೂಲಕ ಪಾರ್ಸಿಂಗ್ ಎಂದೆನಿಸಿತ್ತು ಏಕೆಂದರೆ

1113
01:13:48,700 --> 01:13:52,080
ಮತ್ತು ವಸ್ತುಗಳನ್ನು ಹೊರತುಪಡಿಸಿ ಪೀಸ್ ಹೊಂದಿರುವ. ಮತ್ತು ಅದು ಸರಿಯಾಗಿ ಏನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದರೆ?

1114
01:13:52,080 --> 01:13:54,880
ಕೆಟ್ಟ ಕೆಲಸಗಳನ್ನು ಏನಾಗಬಹುದು.

1115
01:13:54,880 --> 01:13:58,140
ಆದ್ದರಿಂದ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನೀವು ಈ ನೋಡಿಕೊಳ್ಳುತ್ತಾರೆ, ಮತ್ತು ನೀವು ಒಂದು ಸಂತೋಷವನ್ನು ಡೇಟಾ ರಚನೆ ಪಡೆಯಲು

1116
01:13:58,140 --> 01:14:01,390
ನೀವು ಕೇವಲ ಒಂದು ಡಾಕ್ಯುಮೆಂಟ್ ಅಲ್ಲಿ ನನ್ನ ಬಿಟ್ಟು ಒಂದು ರೀತಿಯ,

1117
01:14:01,390 --> 01:14:03,530
ಮತ್ತು ಒಳಗೆ, HTML ಎಂಬ ಅಂಶವಿದೆ

1118
01:14:03,530 --> 01:14:05,600
ಮತ್ತು ಒಳಗೆ ನೀವು, ಒಂದು ತಲೆ ಮತ್ತು ದೇಹದ

1119
01:14:05,600 --> 01:14:08,420
ಮತ್ತು ತಲೆ ಒಳಗೆ ನೀವು, etcetera, etcetera etcetera ಒಂದು ಶೀರ್ಷಿಕೆ.

1120
01:14:08,420 --> 01:14:11,810
ಇದು ಕೇವಲ ಇಲ್ಲಿದೆ ಆದ್ದರಿಂದ ಒಂದು ವೆಬ್ ಪುಟ ಕುಶಲಬಳಕೆಯ ಸುಲಭಗೊಳಿಸುತ್ತದೆ

1121
01:14:11,810 --> 01:14:14,190
ಓಹ್, ನಾನು ಈ ವಸ್ತು ಮಾತನಾಡಲು ಬಯಸುವ.

1122
01:14:14,190 --> 01:14:21,340
ನೀವು ನೀವೇ ಮಾಡಿದ ಇನ್ನೊಂದು ವಸ್ತುವಿನ ಮಾತನಾಡಿ ಎಂದು ತುಂಬಾ ಇದೇ ರೀತಿಯಲ್ಲಿ ವಿಂಗಡಿಸಿ.

1123
01:14:21,340 --> 01:14:25,980
ನಾನು ಹೇಳಿದ ಹಾಗೆ, ಎಲ್ಲಾ DOM ಮತ್ತು ಡಾಕ್ಯುಮೆಂಟ್ ಆಬ್ಜೆಕ್ಟ್ ಹೊಂದಿದೆ.

1124
01:14:25,980 --> 01:14:29,290
ಒಂದೋ, ಇದು ಕೇವಲ ಒಂದು ಸ್ಥಳವಾಗಿದೆ ಮತ್ತು ನಂತರ ನೀವು ವಿಷಯಗಳನ್ನು ಹುಡುಕಲು ಇದು ಒಳಗೆ ಹೋಗಿ

1125
01:14:29,290 --> 01:14:33,880
ಮತ್ತು ನೀವು ಮಾಡಬಹುದು - ಈ ಅಪ್, ಅದನ್ನು ಮಾಡುವ ಹಳೆಯ ಶೈಲಿ,

1126
01:14:33,880 --> 01:14:38,130
ನೀವು document.getElementById ಎಂದು, ಮತ್ತು ಅಲ್ಲಿ ನಂತರ ಹೆಸರು,

1127
01:14:38,130 --> 01:14:42,420
ನೀವು ಬಹುಶಃ ಹೇಳಬಹುದು ಎಂದು ಮತ್ತು, ಈ ಒಂದು ನಂತರ ಬಹಳ ಒಡ್ಡೊಡ್ಡಾದ ಪಡೆಯುತ್ತದೆ.

1128
01:14:42,420 --> 01:14:44,480
ಆದ್ದರಿಂದ ನೀವು ಬಹುಶಃ ಹಾಗೆ ಬಯಸುವುದಿಲ್ಲ. ನಾವು ಏಕೆ ಆ

1129
01:14:44,480 --> 01:14:48,760
ನಾವು ಈ ನಂತರ ಬಗ್ಗೆ ನೀನು ಮುಂದೆ.

1130
01:14:48,760 --> 01:14:52,510
ಇಲ್ಲಿ ಪ್ರಮುಖ ವಿಷಯ, ಸರಿ, ನೀವು ಬಲ, ಈ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಹೊಂದಿವೆ?

1131
01:14:52,510 --> 01:14:56,400
ಆದ್ದರಿಂದ ಬಹುಶಃ ನಾನು ಪುಟದ ಲೋಡ್ ಏನೋ ಬಣ್ಣವನ್ನು ಬದಲಾಯಿಸಬಹುದು.

1132
01:14:56,400 --> 01:14:58,380
ಹಾಗಾಗಿ? ಏನು ನನ್ನ ಬಳಕೆದಾರ ಏನೋ ಕ್ಲಿಕ್ ವೇಳೆ?

1133
01:14:58,380 --> 01:15:00,540
ನಾನು ಅವರು ಏನೋ ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ ಇದು ಕುತೂಹಲಕಾರಿ ಏನೋ ಮಾಡಲು ಬಯಸುವ.

1134
01:15:00,540 --> 01:15:02,600
ನಾವು ಘಟನೆಗಳು ಏಕೆ ಆ.

1135
01:15:02,600 --> 01:15:05,330
ನೀವು ಮೂಲತಃ, ನಿಮ್ಮ ಡಾಮ್ ಯಾವುದೇ ಅಂಶ ಕಾಣಬಹುದು,

1136
01:15:05,330 --> 01:15:08,560
ತದನಂತರ ಹೇ, ಹೇಳುತ್ತಾರೆ. , ಈ ಲೋಡ್ ಅಥವಾ ಯಾರಾದರೂ ಅದನ್ನು ಒತ್ತಿದಾಗ

1137
01:15:08,560 --> 01:15:11,410
ಅಥವಾ ಅವರು ಅದು ಮೇಲೆ ಮೌಸ್, ಅದನ್ನು ಏನಾದರೂ ಮಾಡಿದಾಗ.

1138
01:15:11,410 --> 01:15:15,330
ಮತ್ತು ನೀವು ನೀವು ಈ ನಿರ್ವಹಿಸುವ ಕಾರ್ಯಗಳನ್ನು, ಆಗಿದೆ.

1139
01:15:15,330 --> 01:15:17,980
ಈ ಕಾರ್ಯಗಳನ್ನು ಈವೆಂಟ್ ನಿರ್ವಹಣಾಕಾರರು ಇವೆ.

1140
01:15:17,980 --> 01:15:20,440
ಏನು they're - ಇದು ಹೇಳುವ ಒಂದು ಅಲಂಕಾರಿಕ ಮಾರ್ಗವಾಗಿದೆ,

1141
01:15:20,440 --> 01:15:23,500
ಈ ಘಟನೆ ಸಂಭವಿಸಿದರೂ ಈ ಕಾರ್ಯ ಕೇವಲ ಕಾರ್ಯರೂಪಕ್ಕೆ.

1142
01:15:23,500 --> 01:15:28,070
ಆದ್ದರಿಂದ ಸಂಭವಿಸುವ ಘಟನೆಯನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ.

1143
01:15:28,070 --> 01:15:30,810
ನೀವು ಕ್ರಿಯೆಯನ್ನು ಹ್ಯಾಂಡ್ಲರ್ ಮೊಟ್ಟ ಹೇಗೆ ಹೊಂದಿದೆ.

1144
01:15:30,810 --> 01:15:34,750
ನಾನು ಕೆಲವು ಬಟನ್ ಹೊಂದಿವೆ, ಮತ್ತು ನೀವು ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ, ಸ್ಫೋಟಗೊಳ್ಳುತ್ತದೆ.

1145
01:15:34,750 --> 01:15:40,560
ಆದ್ದರಿಂದ ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಬೇಡಿ.

1146
01:15:40,560 --> 01:15:42,910
ಈ ಬಲ, ಇದು ಸಮೀಪಿಸುತ್ತಿರುವ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ?

1147
01:15:42,910 --> 01:15:46,430
, ನೀವು ಬಟನ್ ಟ್ಯಾಗ್, ಮತ್ತು ಕ್ಲಿಕ್ ಮೇಲೆ ನೀವು ಹೇಳುವಂತೆ ಸ್ಟ್ರಿಂಗ್

1148
01:15:46,430 --> 01:15:50,460
ಓಹ್, ಮೂಲಕ, ನನ್ನ ಈ ಸ್ಫೋಟದಿಂದಾಗಿ ವಿಷಯವನ್ನು.

1149
01:15:50,460 --> 01:15:53,990
ಇಲ್ಲದಿದ್ದರೆ, ಇದು ಕೇವಲ ನೀವು ಮಾಡಿದ ಸಾಮಾನ್ಯ ಬಟನ್ ಅನಿಸುತ್ತದೆ.

1150
01:15:53,990 --> 01:15:56,550
ನೀವು ಈ ಮತ್ತೊಂದು ರೀತಿಯಲ್ಲಿ ಮಾಡಬಹುದು,

1151
01:15:56,550 --> 01:16:02,770
ನಾವು jQuery ಬಗ್ಗೆ ಮಾತನಾಡಲು ನಂತರ DOM ಮತ್ತು ಅಂಶ ಧರಿಸುವುದನ್ನು, ಆದರೆ ಅದಕ್ಕೆ ನಾವು ಉಳಿಸುತ್ತೇವೆ.

1152
01:16:02,770 --> 01:16:07,580
>> JQuery: ಇದು ಅಡ್ಡ ಬ್ರೌಸರ್ ಒಂದು ಗ್ರಂಥಾಲಯವಾಗಿದೆ.

1153
01:16:07,580 --> 01:16:09,580
ನೀವು ಅತ್ಯಧಿಕವಾಗಿ ಏನು ಬಳಸಬಹುದು.

1154
01:16:09,580 --> 01:16:12,090
ಮತ್ತು ಇದು ಕೇವಲ ನೀವು ಕೆಲಸ ಉಪಕರಣಗಳು ಸಾಕಷ್ಟು ನೀಡುತ್ತದೆ.

1155
01:16:12,090 --> 01:16:15,850
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್, ಪ್ರಬಲ ಆದರೆ, ನೀವು ಎಲ್ಲಾ ಉಪಕರಣಗಳು ಕಾರಣ

1156
01:16:15,850 --> 01:16:20,550
ನಿಜವಾಗಿಯೂ ಒಂದು ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ನಿಭಾಯಿಸಲು ಬಾಕ್ಸ್ ಹೊರಗೆ ನೀವು ಬಯಸಬಹುದು.

1157
01:16:20,550 --> 01:16:24,650
ಆದ್ದರಿಂದ, ವಸ್ತುಗಳ ಬಹಳಷ್ಟು ಸುಲಭಗೊಳಿಸುತ್ತದೆ ನೀವು ಕಾರ್ಯಗಳನ್ನು ಸಾಕಷ್ಟು ನೀಡುತ್ತದೆ

1158
01:16:24,650 --> 01:16:28,760
ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಮತ್ತೆ ಮತ್ತೆ ಮತ್ತು ಮೇಲೆ, ನೀವೇ ಬರೆಯಲು ಹೊಂದಿಲ್ಲ ಎಂದು ಔಟ್ ಬಾಕ್ಸ್.

1159
01:16:28,760 --> 01:16:31,600
ಮತ್ತು ಕೇವಲ ವಿಷಯಗಳನ್ನು ಸರಳ ಮಾಡುತ್ತದೆ.

1160
01:16:31,600 --> 01:16:35,780
ನೀವು ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ನೋಡೋಣ ಇದು ಆಯ್ಕೆದಾರರು ಹೊಂದಿವೆ

1161
01:16:35,780 --> 01:16:42,800
ನಿಮ್ಮ DOM ಮತ್ತು ಹೆಚ್ಚು ನಿಂದ ಸರಳವಾಗಿ, ಬದಲಿಗೆ ಈ ಬಹಳ ಕಾರ್ಯ ಕರೆಗಳನ್ನು ಅನ್ನು ಹೊಂದುವ.

1162
01:16:42,800 --> 01:16:46,630
ಈ ಆಯ್ಕೆದಾರರಿಗೆ ಇನ್ನಷ್ಟು. ನೀವು, ಹೇಳಿ ನೋಡೋಣ ಅಪ್ ಇಲ್ಲ, ಹೊಂದಿವೆ

1163
01:16:46,630 --> 01:16:49,800
ನಾನು ID ಒಂದು ಅಂಶ ಸಿಗತ್ತೆ "ರಾಕ್."

1164
01:16:49,800 --> 01:16:56,450
ಅಲ್ಲದೆ, jQuery ರಲ್ಲಿ, ಅದು ಕೇವಲ $ ಮತ್ತು ನಂತರ ಒಂದು ಪೌಂಡ್ ಎಂದು ಸ್ಟ್ರಿಂಗ್, ಮತ್ತು ನಂತರ "ರಾಕ್."

1165
01:16:56,450 --> 01:17:01,960
ಇದು ಅತ್ಯಂತ ಸರಳ ಮತ್ತು ಈ ಸಮಸ್ಯೆ ಪರಿಹರಿಸುವಲ್ಲಿ ಸಾಂಪ್ರದಾಯಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ರೀತಿಯಲ್ಲಿ ವೇಗವಾಗಿ ಬಹಳಷ್ಟು ಇಲ್ಲಿದೆ.

1166
01:17:01,960 --> 01:17:06,120
ಮತ್ತು ನೀವು ತರಗತಿಗಳು ಮತ್ತು ಅಂಶ ರೀತಿಯ ರೀತಿಯ ವಿಷಯಗಳನ್ನು.

1167
01:17:06,120 --> 01:17:08,140
jQuery ಆಗಿದೆ - ತಂಪಾದ ವೈಶಿಷ್ಟ್ಯಗಳ ಒಂದು ನೀವು ರೀತಿಯ ಕುಗ್ಗಿಸುವಾಗ ಮಾಡಬಹುದು

1168
01:17:08,140 --> 01:17:14,350
ನಿಮ್ಮ DOM ಮತ್ತು ನಿಮ್ಮ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೆಳಗೆ ತುಂಬಾ ವೇಗವಾಗಿ.

1169
01:17:14,350 --> 01:17:18,980
ಈಗ ನಾವು ಮತ್ತೆ ಕ್ರಿಯೆಯನ್ನು ನಿರ್ವಹಣೆ ಆರ್, ಮತ್ತು ಈ ನೀವು jQuery ರಲ್ಲಿ ಒಂದು ಘಟನೆ ನಿಭಾಯಿಸಲು ಹೇಗೆ ಆಗಿದೆ.

1170
01:17:18,980 --> 01:17:23,090
ಆದ್ದರಿಂದ ಇಲ್ಲಿರುವುದು ನೀನು ನಾವು ಸರಿ, ಹೇಳುವ ಆಗಿದೆ. ನಾನು ಸ್ಕ್ರಿಪ್ಟ್ ಟ್ಯಾಗ್, ಬಲ?

1171
01:17:23,090 --> 01:17:25,400
ಹಾಗಾಗಿ ಈ ಇನ್ಲೈನ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಹೊಂದಿವೆ.

1172
01:17:25,400 --> 01:17:27,750
ನಾವು ಮಾಡಲು ನೀನು ನಾವು ಸರಿ, ಹೇಳಲು ನೀನು ಆಗಿದೆ.

1173
01:17:27,750 --> 01:17:30,860
ಡಾಕ್ಯುಮೆಂಟ್, ಡಾಕ್ಯುಮೆಂಟ್ ಲೋಡ್ ಮಾಡಲಾಗಿದೆ ಅಂದರೆ, ಸಿದ್ಧವಾದಾಗ

1174
01:17:30,860 --> 01:17:34,660
, ನಾವು ಆ ಕಾರ್ಯಕ್ಕೆ ರಲ್ಲಿ ಹೋಗುತ್ತಿದ್ದೇವೆ, ಮತ್ತು ನಾವು, ಸರಿ ಹೇಳಲು ನೀನು

1175
01:17:34,660 --> 01:17:37,060
ಈ ಕಾರ್ಯ ವಾಸ್ತವವಾಗಿ ಯಾವುದೋ ಮಾಡುತ್ತಿದ್ದಾರೆ.

1176
01:17:37,060 --> 01:17:42,320
ಇದು ಮೂಲತಃ ಸರಿ, ನನಗೆ ID ಜೊತೆ ಅಂಶ ಪಡೆಯಲು, ಹೇಳುವ "myid."

1177
01:17:42,320 --> 01:17:47,960
ತದನಂತರ ಈ ನೀವು ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ ನಿರ್ವಹಿಸುವ ಒಂದು ಕಾರ್ಯ ಹ್ಯಾಂಡ್ಲರ್ ನೀಡಿ.

1178
01:17:47,960 --> 01:17:49,820
ಮೂಲತಃ ಈ ಏನು ಹೇಳುತ್ತಾರೆ, ಎಲ್ಲಾ ಸರಿ.

1179
01:17:49,820 --> 01:17:52,630
, ಪುಟ ಲೋಡ್ ಇದೆ, ಆದ್ದರಿಂದ ನಾನು, ಈ ಅಂಶ ಹುಡುಕಲು ಪಡೆಯಲಿದ್ದೇನೆ

1180
01:17:52,630 --> 01:17:56,420
ಇದು ಈ ಈವೆಂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ನೀಡಲು, ಮತ್ತು ಇದು ಮೂಲತಃ ನೀವು ನಿಮ್ಮ ಪುಟ ನಿಲ್ಲುತ್ತಾನೆ.

1181
01:17:56,420 --> 01:18:00,520
ಮತ್ತು ಈ ನೀವು ಈವೆಂಟ್ ನಿರ್ವಹಣೆ ಬಗ್ಗೆ ಯೋಚನೆ ಮಾಡಲು ಹೇಗೆ.

1182
01:18:00,520 --> 01:18:06,310
ನೀವು ಬಗ್ಗೆ ಯೋಚನೆ ಸರಿ, ಏನೋ ಸಂಭವಿಸುತ್ತದೆ, ನಾನು ಸಂಭವಿಸಿ ಏನು ಬಯಸುತ್ತೀರಿ ಬಯಸುವ?

1183
01:18:06,310 --> 01:18:10,520
ನೀವು, ಸರಿ, ನಾನು ಈ ವಿಷಯ ಖಚಿತವಾಗಿ ಈ ವಿಷಯ ಮಾತುಕತೆ ಅಗತ್ಯವಿದೆ, ಬಗ್ಗೆ ಯೋಚನೆ ಬಯಸುವುದಿಲ್ಲ

1184
01:18:10,520 --> 01:18:14,660
ಈ ವಿಷಯ blah blah blah, ನೀವು ಕೇವಲ ಘಟನೆಗಳ ಅರ್ಥದಲ್ಲಿ ವಿಷಯ ಮಾತನಾಡಲು ಬಯಸುವ ಏಕೆಂದರೆ.

1185
01:18:14,660 --> 01:18:17,650
ಇದು ಸಂಭವಿಸಿದಾಗ, ಈ ಸಂಭವಿಸುತ್ತದೆ. ಇದು ಸಂಭವಿಸಿದಾಗ, ಎಂದು ಸಂಭವಿಸುತ್ತದೆ.

1186
01:18:17,650 --> 01:18:20,240
ವಿಷಯಗಳನ್ನು ಇತರ ವಿಷಯಗಳ ಪ್ರಚೋದಿಸುತ್ತದೆ ಮತ್ತು, ಅಭಿನಂದನೆಗಳು.

1187
01:18:20,240 --> 01:18:22,150
ಆದರೆ ನೀವು ಸಂಕೀರ್ಣ ಕೋಡ್ ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಮಾಡಲು ಬಯಸುವುದಿಲ್ಲ

1188
01:18:22,150 --> 01:18:24,130
ಅಲ್ಲಿ ನೀವು, ಅದೇ ಸಮಯದಲ್ಲಿ ಅನೇಕ ವಿಷಯಗಳನ್ನು ಪ್ರಚೋದಿಸಿ ಮಾಡುತ್ತಿದ್ದೇವೆ

1189
01:18:24,130 --> 01:18:28,860
ನೀವು ನಿಮ್ಮ ಒಂದು ತಲೆನೋವು ನೀಡಲು ನೀನು ಏಕೆಂದರೆ.

1190
01:18:28,860 --> 01:18:32,340
>> ಸರಿ. ಈಗ ನಾವು ನಮ್ಮ ಪುಟ ಘಟನೆಗಳು ನಿರ್ವಹಿಸಲು ಪಡೆಯುವುದು,

1191
01:18:32,340 --> 01:18:35,640
ಆದರೆ ನನ್ನ ಬಳಕೆದಾರರಿಗೆ ಒಂದು ಗುಂಡಿಯನ್ನು ಕ್ಲಿಕ್ ಹೇಳಲು ಅವಕಾಶ.

1192
01:18:35,640 --> 01:18:38,040
ಏನು, ನಾನು ಮತ್ತೆ ಪರಿಚಾರಕಕ್ಕೆ ಮನವಿ ಕಳುಹಿಸಲು ಬಯಸಿದರೆ

1193
01:18:38,040 --> 01:18:41,100
ಹೊಸ ಪುಟ ರಿಲೋಡ್ ಹೊಂದಿರುವ ಕಾರಣ ನಾನು, ಪುಟ ರಿಲೋಡ್ ಬಯಸುವುದಿಲ್ಲ

1194
01:18:41,100 --> 01:18:44,390
ಪ್ರತಿಯೊಂದು ಬಾರಿ ಬೇಸರದ ರೀತಿಯ ಪಡೆಯುತ್ತದೆ, ಮತ್ತು ಏಕೆ ಬೇಕು

1195
01:18:44,390 --> 01:18:47,430
ಮತ್ತೆ ಹೆಡರ್ ಕೆಳಗೆ ಎಳೆಯಿರಿ, ಮತ್ತು ಮತ್ತೆ ಅಡಿಟಿಪ್ಪಣಿ,

1196
01:18:47,430 --> 01:18:49,670
ಮತ್ತು ಎಲ್ಲಾ ಪುಟ ಅಂಶಗಳನ್ನು ಮತ್ತೆ

1197
01:18:49,670 --> 01:18:53,180
ಕೇವಲ ಶುಭಾಶಯ ಅಥವಾ ಸಮಯ ರಿಫ್ರೆಶ್?

1198
01:18:53,180 --> 01:18:55,290
ನಾವು ಅಜಾಕ್ಸ್ ರೀತಿಯ ಏಕೆ ಆ ನ.

1199
01:18:55,290 --> 01:18:59,150
ನಾವು ಅಜಾಕ್ಸ್ ಇಲ್ಲಿ ಮಾಡಬಹುದು, ನಾವು, ಸರಿ ಹೇಳಬಹುದು

1200
01:18:59,150 --> 01:19:01,290
ನಾನು ಸರ್ವರ್ ಕೆಲವು ಡೇಟಾವನ್ನು ಕಳುಹಿಸಲು ಬಯಸುವ,

1201
01:19:01,290 --> 01:19:04,010
ಮತ್ತು ನಾನು ನನ್ನ ಪುಟ ನವೀಕರಿಸಬಹುದು ಮತ್ತೆ ಪ್ರತಿಕ್ರಿಯೆ ಸಿಗತ್ತೆ,

1202
01:19:04,010 --> 01:19:12,120
ಅಥವಾ ಬಹುಶಃ ಕೇವಲ ಅಗತ್ಯವಾಗಿ ಬಳಕೆದಾರರು ಏನು ತೋರಿಸುವುದಿಲ್ಲ ಕೆಲವು ಕ್ರಮಾವಳಿಯ ಲೆಕ್ಕ.

1203
01:19:12,120 --> 01:19:15,500
ನೀವು ಈ ಏನು ಬರೆಯಬೇಕು? ಸರಿ, ನೀವು ಮಾತನಾಡಲು ಅಗತ್ಯವಿದೆ ಒಂದು URL ಬೇಕಾಗುತ್ತದೆ.

1204
01:19:15,500 --> 01:19:18,650
ನಿಮ್ಮ ಪರಿಚಾರಕವು ಮಾಂತ್ರಿಕವಾಗಿ ಎಲ್ಲಿಯೂ ಕೇಳಲು ಸಾಧ್ಯವಿಲ್ಲ.

1205
01:19:18,650 --> 01:19:21,960
ನೀವು ಈ ಡೇಟಾವನ್ನು ಕಳುಹಿಸಲು ನೀವು ನಿರ್ದಿಷ್ಟ ಸ್ಥಳದಲ್ಲಿ ಮಾಡಬೇಕು.

1206
01:19:21,960 --> 01:19:26,240
ಮತ್ತು ನೀವು ಕಳುಹಿಸಲು ಕೆಲವು ಡೇಟಾವನ್ನು ಅಗತ್ಯವಿದೆ, ಅಥವಾ ಬಹುಶಃ ಇದು ಒಂದು dataless ಪ್ರಶ್ನೆಗೆ ಇಲ್ಲಿದೆ.

1207
01:19:26,240 --> 01:19:31,380
ನೀವು ಹೇ, ನಾನು ಜೀವಂತವಾಗಿ, ಅಥವಾ ಸ್ವಲ್ಪ ಮನುಷ್ಯ, ಮತ್ತೆ ಪರಿಚಾರಕಕ್ಕೆ ಪಿಂಗ್ ಮತ್ತು ಹೇಳಲಿಚ್ಚಿಸುತ್ತೇನೆ.

1208
01:19:31,380 --> 01:19:35,150
ತದನಂತರ ನೀವು ಮೂಲತಃ ಯಶಸ್ಸನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ ಕಾರ್ಯ ಬಯಸುವ.

1209
01:19:35,150 --> 01:19:38,250
ನ ನಿಮ್ಮ ಪರಿಚಾರಕದಿಂದ ಕೆಲವು ಮಾಹಿತಿ ಪಡೆಯಲು ಮತ್ತೆ ಹೇಳುತ್ತಾರೆ,

1210
01:19:38,250 --> 01:19:42,960
ಮತ್ತು ನೀವು ತಮ್ಮ ಪುಟ ಬಳಕೆದಾರರ ಶೀರ್ಷಿಕೆ ಬದಲಾಯಿಸಲು ಬಯಸುವ.

1211
01:19:42,960 --> 01:19:44,930
ಆದ್ದರಿಂದ ನೀವು ಮಾಹಿತಿ ಹಿಂದಕ್ಕೆ ಪಡೆಯಲು ಎಂದು,

1212
01:19:44,930 --> 01:19:48,860
ಮತ್ತು ನೀವು ತೆರೆಗೆ ಎಂದು ತಳ್ಳಲು.

1213
01:19:48,860 --> 01:19:51,170
ಪುಟ ಸಿದ್ಧವಾಗಿದೆ ಏನಾಗುತ್ತದೆ, ಆಗಿದೆ

1214
01:19:51,170 --> 01:19:56,500
ನೀವು greeter ಎಂಬ ಈ ಬಟನ್ ಕ್ಲಿಕ್ ಕಾರ್ಯದ ಒಂದು ರಚಿಸಲು.

1215
01:19:56,500 --> 01:19:58,810
ಎಂದು ಬಟನ್ ತಳ್ಳಲಾಗುತ್ತದೆ ಏನು ಈ ನಂತರ ಮಾಡುತ್ತದೆ, ಆಗಿದೆ,

1216
01:19:58,810 --> 01:20:03,700
ನೀವು greetings.php ಮಾತನಾಡಲು, ನೀವು, ಒಂದು ವಸತಿ ವಿನಂತಿಯನ್ನು ಮಾಡಲು

1217
01:20:03,700 --> 01:20:07,290
ಮತ್ತು ನೀವು ಹೇ, ನನಗೆ ನಿಮ್ಮ ಪುಟ ಏನನ್ನೋ ಪಡೆಯಲು, ಹೇಳುತ್ತಾರೆ.

1218
01:20:07,290 --> 01:20:09,890
ನಾವು ನಿಜವಾಗಿಯೂ, ಎಂದು ವಿವರಿಸಲು ಅಗತ್ಯವಿದೆ, ಆದರೆ greetings.php ಇಲ್ಲ

1219
01:20:09,890 --> 01:20:12,480
ಕೇವಲ ಹೇಳುತ್ತಾರೆ ನೋಡೋಣ, "ಹಲೋ ವರ್ಲ್ಡ್." ಮತ್ತೆ ನೀಡುತ್ತದೆ

1220
01:20:12,480 --> 01:20:15,650
ನಾವು, "ಹಲೋ ವರ್ಲ್ಡ್" ಈ ಹಿಂದೆ ಮತ್ತು ಈ ಯಶಸ್ಸು

1221
01:20:15,650 --> 01:20:20,730
ಏನೂ ತಪ್ಪು ಹೋಗುತ್ತದೆ ಊಹಿಸಿಕೊಂಡು, ನಂತರ ನಾವು ಈ ಗುರಿ ಸ್ಥಳಕ್ಕೆ ಹೋಗಿ

1222
01:20:20,730 --> 01:20:25,720
ನಾವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಮತ್ತು ನಾವು ಅಲ್ಲಿ ಪ್ರತಿಕ್ರಿಯೆಯ ಅಂಟಿಕೊಳ್ಳುವುದಿಲ್ಲ.

1223
01:20:25,720 --> 01:20:31,560
ಮತ್ತು ಈ ಒಂದು ಅಜಾಕ್ಸ್ ಪ್ರಶ್ನೆಗೆ ಸ್ಥಾಪನೆಗೆ ಒಂದು ಸರಳ ಮಾರ್ಗವಾಗಿದೆ.

1224
01:20:31,560 --> 01:20:34,340
>> ಬೇಗನೆ, ರಾಬ್ ರೀತಿಯ, ಈಗಾಗಲೇ ಈ ಪ್ರಸ್ತಾಪಿಸಿದ್ದಾರೆ

1225
01:20:34,340 --> 01:20:37,170
ಸಂಗತಿಗಳು ತಪ್ಪು ಹೋಗಬಹುದು, ಕೆಟ್ಟ ಕೆಲಸಗಳನ್ನು ಸಂಭವಿಸಬಹುದು,

1226
01:20:37,170 --> 01:20:42,660
ಆದ್ದರಿಂದ ನೀವು ಈ HTTP ಪ್ರತಿಕ್ರಿಯೆ ಸಂಕೇತಗಳು ನಿಮಗಾಗಿ ಪರಿಚಯ ಬಯಸುವ.

1227
01:20:42,660 --> 01:20:46,030
ಏನು ಈ ಎಲ್ಲವೂ ಸರಿ ಹೋದರು, 200, ಹಾಗೆ, ಅವು.

1228
01:20:46,030 --> 01:20:48,670
ಯಾವುದೋ, ಕೆಟ್ಟ ಸಂಗತಿಗಳು ಸಂಭವಿಸಿದ.

1229
01:20:48,670 --> 01:20:50,790
ಸಾಮಾನ್ಯವಾಗಿ ನೀವು ನೆನಪಿಡುವ ಬಯಸುವ ವಿಷಯ.

1230
01:20:50,790 --> 01:20:53,440
ಆದರೆ ಈ ಎಲ್ಲಾ ಚೆನ್ನಾಗಿ ಇಲ್ಲಿದೆ.

1231
01:20:53,440 --> 01:20:55,970
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಒಮ್ಮೆ ನಾವು ಎಲ್ಲಾ ಮೂಲಕ ಹೋಗಿದ್ದೀರಿ,

1232
01:20:55,970 --> 01:20:58,680
ನಾವು, ವಿನ್ಯಾಸ ಬಗ್ಗೆ ಬೇಗನೆ ಮಾತನಾಡಲು ಅಗತ್ಯವಿದೆ

1233
01:20:58,680 --> 01:21:00,620
ನಂತರ ನಾವು ನೀವು ಎಲ್ಲಾ ಬಿಟ್ಟು ಅವಕಾಶ ಮಾಡಬಹುದು.

1234
01:21:00,620 --> 01:21:03,410
ಡಿಸೈನ್. ನೀವು ನೆನಪಿಡುವ ಬಯಸುವ ವಿಷಯಗಳನ್ನು.

1235
01:21:03,410 --> 01:21:06,950
ಈ ಪ್ರಶ್ನೆಗಳಿಗೆ ನೀವೇ ಕೇಳಿ: ಯಾರು ಈ ಬಳಸಿಕೊಂಡು ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ?

1236
01:21:06,950 --> 01:21:09,580
ಅವರು ಅದನ್ನು ಬಳಸಿ ಮಾಡಲಾಗುತ್ತದೆ? ನನ್ನ ಬಳಕೆದಾರರು ಏನು ಬಗ್ಗೆ ಕಾಳಜಿ ಇಲ್ಲ?

1237
01:21:09,580 --> 01:21:11,750
ಅವರು ಏನು ಕಾಳಜಿ ಇಲ್ಲ?

1238
01:21:11,750 --> 01:21:14,500
ನೀವು ಕೇವಲ ಒಂದು ಅಪ್ಲಿಕೇಶನ್ ಮಾಡಲು ಮತ್ತು ಇದು ಬೆಳೆಯಲು ಅವಕಾಶ ಬಯಸುವುದಿಲ್ಲ

1239
01:21:14,500 --> 01:21:18,270
ಮತ್ತು ಈ ದೈತ್ಯ, ನೀವು ಸಹ ಮುಗಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ಎಲ್ಲಾ ತೆಗೆದುಕೊಳ್ಳುವ ವಿಷಯ ಆಗಲು.

1240
01:21:18,270 --> 01:21:23,900
ನೀವು ವಿಳಾಸ ಬಯಸುವ ಪ್ರತ್ಯೇಕವಾದ ಗುರಿಗಳನ್ನು ಮತ್ತು ಯೋಜನೆಗಳನ್ನು ಮತ್ತು ವಿಷಯಗಳನ್ನು ಬೇಕು.

1241
01:21:23,900 --> 01:21:29,000
ಇದು ಪ್ರಯತ್ನವಿಲ್ಲದ ಮಾಡಿ. ಈ ಎಲ್ಲಾ, ಮೂಲತಃ ಹೇಳುತ್ತಾರೆ

1242
01:21:29,000 --> 01:21:34,950
ಸುಲಭವಾಗಿ ಬಳಕೆದಾರ ಬಳಸಲು ಮಾಡಲು; ವಾಸ್ತವವಾಗಿ, ಇದು ಈ ಸ್ಲೈಡ್ ರೀತಿ ಪಠ್ಯದ ಒಂದು ದೈತ್ಯ ಆಕೃತಿಯಿಂದ ಆಗಿದೆ ಮಾಡುವುದಿಲ್ಲ.

1243
01:21:34,950 --> 01:21:38,020
ನೀವು ಅದನ್ನು ಯಾರಾದರೂ ಹೋಗಿ ತುಂಬಾ ಸುಲಭ ಅಲ್ಲಿ ಏನೋ ಬಯಸುತ್ತೇನೆ

1244
01:21:38,020 --> 01:21:40,800
ಮತ್ತು ಅವರು ಮಾಡಲು ಬಯಸುವ ಏನು.

1245
01:21:40,800 --> 01:21:42,920
ನೀವು ಅವುಗಳನ್ನು 5 ಪುಟಗಳು ನ್ಯಾವಿಗೇಟ್ ಮಾಡಲು ಬಯಸುವುದಿಲ್ಲ

1246
01:21:42,920 --> 01:21:45,460
ನಿಮ್ಮ ಸೈಟ್ ನಿಮ್ಮ ಅವಿಭಾಜ್ಯ ಕಾರ್ಯ ಪಡೆಯಲು.

1247
01:21:45,460 --> 01:21:49,290
ಗೂಗಲ್ ಮೊದಲು 5 ಪುಟಗಳಷ್ಟು ನೀವು ಏನೋ ಹುಡುಕಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ,

1248
01:21:49,290 --> 01:21:53,080
ಯಾರೂ ಅದನ್ನು ಬಳಸಬಹುದು.

1249
01:21:53,080 --> 01:21:55,890
ಮತ್ತು ಕೊನೆಯದಾಗಿ, ಕಾಗದದ ಮಾದರಿ, ಕೇಂದ್ರೀಕೃತ ಸಮೂಹ.

1250
01:21:55,890 --> 01:21:59,220
ಉತ್ತಮ ವಿನ್ಯಾಸ ಮತ್ತು ಪರೀಕ್ಷಾ ಪರಿಪಾಠಗಳನ್ನು ಹ್ಯಾವ್.

1251
01:21:59,220 --> 01:22:00,730
ನೀವು ನೀವು ಕೆಲಸ ಭಾವಿಸುತ್ತೇನೆ ಕಾರಣ

1252
01:22:00,730 --> 01:22:04,860
ಬೇರೆ ಯಾರಾದರೂ ಇದನ್ನು ಕೆಲಸ ಯೋಚಿಸುತ್ತಾನೆ ಅರ್ಥವಲ್ಲ.

1253
01:22:04,860 --> 01:22:14,490
ಆದರೆ ಹೌದು, ಅದು ಇಲ್ಲಿದೆ.

1254
01:22:14,490 --> 01:22:17,490
[CS50.TV]