1
00:00:00,000 --> 00:00:03,840
>> [ಸಂಗೀತ]

2
00:00:03,840 --> 00:00:05,770

3
00:00:05,770 --> 00:00:08,690
>> ಡೌಗ್ LLOYD: ಈಗ ನಾವು ಹಳೆಯ ಆರ್
ವೆಬ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಸಾಧಕ, ಬಲ?

4
00:00:08,690 --> 00:00:12,140
ನಾವು ಹಲವಾರು ಒಳಗೊಂಡಿದೆ ಬಂದಿದೆ
ವೈಯಕ್ತಿಕ ವೀಡಿಯೊಗಳನ್ನು ಭಾಷೆಗಳು.

5
00:00:12,140 --> 00:00:14,690
ಮತ್ತು ಈಗ ಒಂದು, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡಿ.

6
00:00:14,690 --> 00:00:17,370
>> ಮೊದಲ ಒಳ್ಳೆಯ ಸುದ್ದಿ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್
ಆಧುನಿಕ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು

7
00:00:17,370 --> 00:00:21,410
ಅವರ ಪಿಎಚ್ಪಿ ಹಾಗೆ ಭಾಷೆ
ವಾಕ್ಯ, ಸಿ ಪಡೆಯಲಾಗಿದೆ

8
00:00:21,410 --> 00:00:22,830
ಆದ್ದರಿಂದ ಆರಂಭಿಸಲು ಉತ್ತಮ ಸ್ಥಳವಾಗಿದೆ.

9
00:00:22,830 --> 00:00:25,880
ಇದು, ಹಾಗೂ, ಪಿಎಚ್ಪಿ ಎಂದು ಹಳೆಯ ಬಗ್ಗೆ
ಸುಮಾರು 20 ವರ್ಷಗಳ ಪಡೆದುಕೊಳ್ಳಲಾಗಿದೆ.

10
00:00:25,880 --> 00:00:28,600
ಇದು ಆವಿಷ್ಕರಿಸಲಾಯಿತು
ಪಿಎಚ್ಪಿ ಅದೇ ಸಮಯದಲ್ಲಿ.

11
00:00:28,600 --> 00:00:32,240
ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಹಳ ವಾಸ್ತವವಾಗಿ
ಬಳಕೆದಾರ ಅನುಭವವನ್ನು ಮೂಲಭೂತ

12
00:00:32,240 --> 00:00:32,740
ವೆಬ್.

13
00:00:32,740 --> 00:00:34,448
ವಾಸ್ತವವಾಗಿ, ಇವೆ
ಮೂರು ಭಾಷೆಗಳಲ್ಲಿ ನಾನು

14
00:00:34,448 --> 00:00:38,480
ರೂಪಿಸುವ ರೀತಿಯ ಹೇಳುತ್ತಿದ್ದರು
ಸಂವಾದಿಸುವ ಬಳಕೆದಾರ ಅನುಭವವನ್ನು

15
00:00:38,480 --> 00:00:42,650
ವೆಬ್ಸೈಟ್, HTML,
CSS, ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್.

16
00:00:42,650 --> 00:00:46,030
ಆದ್ದರಿಂದ ಈಗ ಒಂದು ಮಾತನಾಡೋಣ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಗ್ಗೆ ಸ್ವಲ್ಪ.

17
00:00:46,030 --> 00:00:50,301
>> ಕೆಟ್ಟ ಸುದ್ದಿ, ಆದರೂ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಗಿದೆ
ಇದು ತಾನೇ ನಿಯಮಗಳು ಸಾಕಷ್ಟು ಹೊಂದಿಸುತ್ತದೆ,

18
00:00:50,301 --> 00:00:51,300
ಮತ್ತು ನಂತರ ಅವುಗಳನ್ನು ಒಡೆಯುತ್ತದೆ.

19
00:00:51,300 --> 00:00:54,010
ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಾಸ್ತವವಾಗಿ ಮಾಡಬಹುದು
ರೀತಿಯ ತಿಳಿಯಲು ಸವಾಲು,

20
00:00:54,010 --> 00:00:57,000
ಇದು ಸಿ ಭಿನ್ನವಾಗಿ ಏಕೆಂದರೆ
ಬಹಳ ರಚಿಸಿದ ಪಿಎಚ್ಪಿ,

21
00:00:57,000 --> 00:01:00,270
ಮತ್ತು ಬಹಳ ಕಟ್ಟುನಿಟ್ಟಿನ ಹೊಂದಿವೆ
ವಿಷಯಗಳನ್ನು ಕೆಲಸ ಹೇಗೆ ಫಾರ್.

22
00:01:00,270 --> 00:01:03,690
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ರೀತಿಯ ಹೊಂದಿದೆ
ಆದ್ದರಿಂದ ಹೊಂದಿಕೊಳ್ಳುವ ಪಡೆದ

23
00:01:03,690 --> 00:01:06,650
ಬಹುಶಃ ವಿಷಯಗಳನ್ನು ಇಲ್ಲ
, ನಾವು ನಿರೀಕ್ಷೆ ರೀತಿಯಲ್ಲಿ ಕೆಲಸ

24
00:01:06,650 --> 00:01:09,830
ಮತ್ತು ಬಹುಶಃ ನಾವು ನಿಜವಾಗಿಯೂ ತಿಳಿಯಲು ಸಾಧ್ಯವಿಲ್ಲ
ನಮ್ಮ ಮೊದಲ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ

25
00:01:09,830 --> 00:01:10,769
ಒಂದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್.

26
00:01:10,769 --> 00:01:12,810
ಆದ್ದರಿಂದ ಬಹುಶಃ ಇದು ಏಕೆಂದರೆ
ಸ್ವತಃ ಯಾವುದೇ ನಿಯಮಗಳನ್ನು ಹೊಂದಿಸಲು,

27
00:01:12,810 --> 00:01:15,754
ಮತ್ತು ಇದು ನಿಜವಾಗಿ
ಉತ್ತಮ ಕೋಡಿಂಗ್ ಪದ್ಧತಿ ಜಾರಿಗೆ.

28
00:01:15,754 --> 00:01:18,170
ಆದರೆ ಈಗ ನಾವು ಆಶಾದಾಯಕವಾಗಿ ಅಭಿವೃದ್ಧಿ ಬಂದಿದೆ
ಕೆಲವು ಉತ್ತಮ ಕೋಡಿಂಗ್ ಪದ್ಧತಿ,

29
00:01:18,170 --> 00:01:21,470
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಆಕ್ರಮಣವು ಆರಂಭಿಸಬಹುದು
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಒಳಗೆ ಸ್ವಲ್ಪ.

30
00:01:21,470 --> 00:01:25,750
>> ಪ್ರಾರಂಭದ ಕಥೆಗೆ ಸಮಾನವಾದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್, ಬರೆಯಲು
ಒಂದು ಡಾಟ್ ಸಿ ವಿಸ್ತರಣೆಯೊಂದಿಗೆ ಸಿ ಫೈಲ್ ಅನ್ನು

31
00:01:25,750 --> 00:01:29,770
ಅಥವಾ ಒಂದು ಬಿಂದುವನ್ನು ಪಿಎಚ್ಪಿ ವಿಸ್ತರಣೆಯೊಂದಿಗೆ ಪಿಎಚ್ಪಿ ಫೈಲ್,
ನಾವು ಮಾಡಬೇಕಾದ್ದು ಎಲ್ಲಾ ಒಂದು ಕಡತವನ್ನು ತೆರೆಯುತ್ತದೆ ಆಗಿದೆ

32
00:01:29,770 --> 00:01:31,764
ಡಾಟ್ JS ಕಡತ ವಿಸ್ತರಣೆಯೊಂದಿಗೆ.

33
00:01:31,764 --> 00:01:34,430
ನಾವು ಯಾವುದೇ ವಿಶೇಷ ಹೊಂದಿವೆ ಮಾಡಬೇಕಿಲ್ಲ
ನಾವು ಹಾಗೆ ಎಲ್ಲೆಗಳನ್ನು ಪಿಎಚ್ಪಿ ಮಾಡಿದರು.

34
00:01:34,430 --> 00:01:36,750
ಕೋನ ಆ ರೀತಿಯ
ಬ್ರಾಕೆಟ್ ಪ್ರಶ್ನೆ ಗುರುತು ಪಿಎಚ್ಪಿ

35
00:01:36,750 --> 00:01:40,300
ನಾವು ಅದರಿಂದ ರೀತಿಯಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು
ನಾವು ಏನು ಎಂದು ನಾವು ನಮ್ಮ ಬ್ರೌಸರ್ ಹೇಳಲು

36
00:01:40,300 --> 00:01:43,502
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸೇರಿದಂತೆ ಮೂಲಕ
ಒಂದು HTML ಟ್ಯಾಗ್ ಅದನ್ನು,

37
00:01:43,502 --> 00:01:46,210
ಮತ್ತು ನಾವು ಬಗ್ಗೆ ಸ್ವಲ್ಪ ನೋಡುತ್ತಾರೆ
ಹೇಗೆ ಕೇವಲ ಒಂದು ಕ್ಷಣದಲ್ಲಿ ಹಾಗೆ.

38
00:01:46,210 --> 00:01:48,210
>> ಮಾಡುವ ಇತರ ವಿಷಯ
ವಿವಿಧ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್,

39
00:01:48,210 --> 00:01:50,580
ಆದರೂ, ಇದು ಕ್ಲೈಂಟ್ ಬದಿಯಲ್ಲಿ ಹರಿಯುತ್ತದೆ.

40
00:01:50,580 --> 00:01:53,430
ಆದ್ದರಿಂದ ಪಿಎಚ್ಪಿ ನೆನಪಿಗೆ
ನಾವು ನೋಡಿ ಸಾಧ್ಯವಿಲ್ಲ

41
00:01:53,430 --> 00:01:57,041
ಒಂದು ವೆಬ್ಸೈಟ್ ಎತ್ತಿ ಎಂದು ಪಿಎಚ್ಪಿ.

42
00:01:57,041 --> 00:01:59,040
ನಾವು ನೋಡಿದಾಗ ಕಾಣಿಸುವಂತೆ
ಪುಟ ಮೂಲ, ನಾವು ಮಾತ್ರ ಎಂದು

43
00:01:59,040 --> 00:02:02,830
ಎಂದು ಎಚ್ಟಿಎಮ್ಎಲ್ ನೋಡಿ
ಎಂದು ಪಿಎಚ್ಪಿ ರಚಿತವಾದ.

44
00:02:02,830 --> 00:02:04,900
ಆದರೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕ್ಲೈಂಟ್ ಸೈಡ್ ಸಾಗುತ್ತದೆ.

45
00:02:04,900 --> 00:02:06,710
ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ ರನ್.

46
00:02:06,710 --> 00:02:09,050
ನೀವು ಮಾಡಬಹುದು ಏಕೆ ಎಂದು ಇಲ್ಲಿದೆ
ವಿಷಯಗಳನ್ನು ಬ್ಲಾಕರ್ ಸೇರಿಸಲು ಇಷ್ಟ.

47
00:02:09,050 --> 00:02:09,550
ರೈಟ್?

48
00:02:09,550 --> 00:02:12,704
ಜಾಹೀರಾತು ತಡೆಯುವ ಸಾಮಾನ್ಯವಾಗಿ ಮಾಡಲಾಗುತ್ತದೆ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಎಲ್ಲಾ ಕೊಲ್ಲುವ

49
00:02:12,704 --> 00:02:14,370
ಒಂದು ನಿರ್ದಿಷ್ಟ ವೆಬ್ಸೈಟ್ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿದೆ.

50
00:02:14,370 --> 00:02:19,000
ಮತ್ತು ಇದು ಹೊಂದಿವೆ ಏಕೆಂದರೆ
ನಿಮ್ಮ ಗಣಕದಲ್ಲಿ ಕ್ಲೈಂಟ್ ಬದಿಯಲ್ಲಿ ಔಟ್,

51
00:02:19,000 --> 00:02:21,910
ನೀವು ನಿಲ್ಲಿಸಬಹುದು
ಸಂಪೂರ್ಣವಾಗಿ ಚಲಾಯಿಸಲು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್.

52
00:02:21,910 --> 00:02:27,030
ಆ ಸಹ ನೀವು ಬಳಸಿದಾಗ ಅಂದರೆ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಒಳಗೊಂಡಿರುವ ಒಂದು ವೆಬ್ಸೈಟ್,

53
00:02:27,030 --> 00:02:32,450
ನೀವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮೂಲ ಕಳುಹಿಸಲು ಹೊಂದಿರುತ್ತವೆ
ನಿಮ್ಮ HTTP ಪ್ರತಿಕ್ರಿಯೆ ಭಾಗವಾಗಿ ಕೋಡ್

54
00:02:32,450 --> 00:02:34,159
ಗ್ರಾಹಕನಿಗೆ ಅವರು ಮನವಿ ಮಾಡಿದಾಗ.

55
00:02:34,159 --> 00:02:35,950
ಆದ್ದರಿಂದ ನೀವು ಸಾಕಾಗುವುದಿಲ್ಲ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸಲು ಬಯಸುವ

56
00:02:35,950 --> 00:02:38,395
ನಿಜವಾಗಿಯೂ ಸೂಕ್ಷ್ಮ ಕೆಲಸಗಳನ್ನು
ಹಾದುಹೋಗುವ ಮಾಹಿತಿಯಂತಹ

57
00:02:38,395 --> 00:02:41,020
ಬಳಕೆದಾರರ ಪಾಸ್ವರ್ಡ್ಗಳನ್ನು ಬ್ಯಾಕ್ ಬಗ್ಗೆ ಮತ್ತು
ಮುಂದಕ್ಕೆ, ಏಕೆಂದರೆ ನಿಜವಾಗಿ ಆರ್

58
00:02:41,020 --> 00:02:45,610
ಮೂಲ ಕೋಡ್ ಎಲ್ಲಾ ಪಡೆಯಲು ಹೋಗುತ್ತದೆ,
ಉತ್ಪತ್ತಿಯಾಗುವ ಕೇವಲ HTML,

59
00:02:45,610 --> 00:02:49,030
ಇಂತಹ ಸೇ ಪಿಎಚ್ಪಿ ಸಂದರ್ಭ ಎಂದು ಮಾಹಿತಿ.

60
00:02:49,030 --> 00:02:51,620
>> ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸೇರಿವೆ
ನಮ್ಮ HTML ನಲ್ಲಿ ಆರಂಭವಾಗಬೇಕು?

61
00:02:51,620 --> 00:02:54,520
ಸಿಎಸ್ಎಸ್ ಹೋಲುವ, ಅಲ್ಲದೆ, ವಾಸ್ತವವಾಗಿ,
ನಾವು ಇಲ್ಲಿ ಅದನ್ನು ಹೇಗೆ ತೆರನಾದ.

62
00:02:54,520 --> 00:02:56,190
ಸಿಎಸ್ಎಸ್ ನಾವು ಶೈಲಿ ಟ್ಯಾಗ್ಗಳನ್ನು ಹೊಂದಿವೆ.

63
00:02:56,190 --> 00:03:00,760
ಮತ್ತು ಆ ಶೈಲಿ ಟ್ಯಾಗ್ಗಳನ್ನು ಒಳಗೆ,
ನಾವು ಒಂದು ಸಿಎಸ್ಎಸ್ ಸ್ಟೈಲ್ ಹಾಳೆಯನ್ನು ರೂಪಿಸಬಹುದು.

64
00:03:00,760 --> 00:03:03,450
ಹಾಗೆಯೇ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್
ನಾವು ಸ್ಕ್ರಿಪ್ಟ್ ಟ್ಯಾಗ್ಗಳನ್ನು ತೆರೆದುಕೊಳ್ಳಬಹುದು,

65
00:03:03,450 --> 00:03:06,660
ಮತ್ತೊಂದು HTML ಟ್ಯಾಗ್ ನಾವು ಮಾಡಲಿಲ್ಲ
ನಮ್ಮ HTML ವೀಡಿಯೊ ಬಗ್ಗೆ ಮಾತನಾಡಲು,

66
00:03:06,660 --> 00:03:09,720
ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬರೆಯಲು
ಆ ಸ್ಕ್ರಿಪ್ಟ್ ಟ್ಯಾಗ್ಗಳನ್ನು ನಡುವೆ.

67
00:03:09,720 --> 00:03:13,960
ಆದರೂ, ಸಿಎಸ್ಎಸ್, ನಾವು
ಸಿಎಸ್ಎಸ್ ಕಡತಗಳನ್ನು ಹೊರಗೆ ಸಂಪರ್ಕ ಕಲ್ಪಿಸುವ

68
00:03:13,960 --> 00:03:15,900
ಮತ್ತು ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಆ ರೀತಿಯಲ್ಲಿ ಅವುಗಳನ್ನು ಎಳೆಯಿರಿ.

69
00:03:15,900 --> 00:03:18,280
ಸಿಎಸ್ಎಸ್ ಜೊತೆ ನಾವು ಮಾಡಬಹುದು
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನನ್ನನ್ನು ಕ್ಷಮಿಸಬೇಕು

70
00:03:18,280 --> 00:03:23,240
ನಾವು ಮೂಲ ಸೂಚಿಸಬಹುದು
ಸ್ಕ್ರಿಪ್ಟ್ ಟ್ಯಾಗ್ ಗುಣಲಕ್ಷಣ

71
00:03:23,240 --> 00:03:25,720
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಲಿಂಕ್
ಪ್ರತ್ಯೇಕವಾಗಿ, ಆದ್ದರಿಂದ ನೀವು

72
00:03:25,720 --> 00:03:27,680
ಇದನ್ನು ಬರೆಯಬೇಕು
ಸ್ಕ್ರಿಪ್ಟ್ ಟ್ಯಾಗ್ಗಳನ್ನು ನಡುವೆ, ನಾವು

73
00:03:27,680 --> 00:03:29,600
ಬಳಸಿಕೊಂಡು ಲಿಂಕ್ ಮಾಡಬಹುದು
ಆ ಸ್ಕ್ರಿಪ್ಟ್ ಟ್ಯಾಗ್ ಹಾಗೂ.

74
00:03:29,600 --> 00:03:33,230
ಮತ್ತು ಕೇವಲ ಸಿಎಸ್ಎಸ್ ಅಲ್ಲಿ ಸಂದರ್ಭ ಜೊತೆ
ನಾವು ಬಹುಶಃ ಸೂಚಿಸಲಾಗುತ್ತದೆ

75
00:03:33,230 --> 00:03:36,090
ನಿಮ್ಮ ಹಿತಾಸಕ್ತಿಯನ್ನು ಬರೆಯಲು
ಸಂದರ್ಭದಲ್ಲಿ ಒಂದು ಪ್ರತ್ಯೇಕ ಕಡತದಲ್ಲಿ ನಿಮ್ಮ ಸಿಎಸ್ಎಸ್

76
00:03:36,090 --> 00:03:38,500
ನೀವು ಅದನ್ನು ಬದಲಾಯಿಸಲು ಅಗತ್ಯ,
ಅದೇ ನಾವು ಶಿಫಾರಸು ಇಲ್ಲ

77
00:03:38,500 --> 00:03:40,720
ನಿಮ್ಮ ಬರೆಯುವ
ಪ್ರತ್ಯೇಕ ಕಡತಗಳಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್

78
00:03:40,720 --> 00:03:45,460
ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್ ಟ್ಯಾಗ್ಗಳನ್ನು ಮೂಲ ಬಳಸಲು
ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಷರತ್ತು ಕಾರಣವಾಗಿದ್ದು

79
00:03:45,460 --> 00:03:49,520
ನಿಮ್ಮ HTML, ನಿಮ್ಮ ವೆಬ್ ಪುಟದಲ್ಲಿ.

80
00:03:49,520 --> 00:03:52,610
>> ಆದ್ದರಿಂದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಚರಾಂಕಗಳ ನಾವು ಮಾಡುತ್ತೇವೆ
ವಾಕ್ಯ ಬಗ್ಗೆ ಆರಂಭಿಸಲು.

81
00:03:52,610 --> 00:03:53,600
ನಾವು ಮೂಲಕ ಹೋಗುತ್ತೇನೆ
ತ್ವರಿತವಾಗಿ ಈ ರೀತಿಯ,

82
00:03:53,600 --> 00:03:56,640
ನಾವು, ಪಿಎಚ್ಪಿ ಈ ಮಾಡಿದ ಕಾರಣ
ಈ ಎಲ್ಲಾ ಬಹಳ ಪರಿಚಿತ ಇರಬೇಕು.

83
00:03:56,640 --> 00:03:59,490
ಆದ್ದರಿಂದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಸ್ಥಿರ
ಅಸ್ಥಿರ ಪಿಎಚ್ಪಿ ಹೋಲುತ್ತದೆ.

84
00:03:59,490 --> 00:04:03,270
ಯಾವುದೇ ರೀತಿಯ ನಿಷ್ಕೃಷ್ಟ, ಮತ್ತು
ನೀವು ವೇರಿಯಬಲ್ ಪರಿಚಯಿಸುವ ಸಂದರ್ಭದಲ್ಲಿ,

85
00:04:03,270 --> 00:04:05,070
ನೀವು ವರ್ ಕೀವರ್ಡ್ ಜೊತೆ ಎದುರು.

86
00:04:05,070 --> 00:04:07,750
ಪಿಎಚ್ಪಿ ನಾವು ಏನನ್ನಾದರೂ
ಈ ರೀತಿಯ, ಡಾಲರ್ ಚಿಹ್ನೆ ಎಕ್ಸ್.

87
00:04:07,750 --> 00:04:09,950
ನಾವು ಸೂಚಿಸಿದ ಹೇಗೆ ಇಲ್ಲಿದೆ
ವೇರಿಯಬಲ್, ಆದರೆ ಯಾವುದೇ, ನಾವು

88
00:04:09,950 --> 00:04:12,060
ಮಾದರಿ ಉಲ್ಲೇಖವಿಲ್ಲ
ವೇರಿಯಬಲ್ ಎಲ್ಲಾ.

89
00:04:12,060 --> 00:04:15,124
ನಾವು ರೀತಿಯ ಹೇಳುತ್ತಿದ್ದರು
ಡಾಲರ್ ಚಿಹ್ನೆ ಎಕ್ಸ್ ಪಿಎಚ್ಪಿ 44 ಸಮನಾಗಿರುತ್ತದೆ.

90
00:04:15,124 --> 00:04:17,040
ನಾವು ಮಾಡುವ ವೇಳೆ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಒಂದೇ,

91
00:04:17,040 --> 00:04:19,589
ನಾವು ವರ್ X 44 ಸಮನಾಗಿರುತ್ತದೆ ಹೇಳುತ್ತಿದ್ದರು.

92
00:04:19,589 --> 00:04:22,780
ಆದ್ದರಿಂದ ವರ್ ನಮ್ಮ ರೀತಿಯಲ್ಲಿ ತೆರನಾದ
ವೇರಿಯಬಲ್ ಪರಿಚಯಿಸುವ.

93
00:04:22,780 --> 00:04:26,850
ಬಹುಶಃ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಅರ್ಥಗರ್ಭಿತ
ಕೇವಲ ಡಾಲರ್ ಚಿಹ್ನೆ ವೇರಿಯಬಲ್ ಹೆಚ್ಚು.

94
00:04:26,850 --> 00:04:29,080
>> ಮತ್ತೆ, ಇಲ್ಲ ಏಕೆಂದರೆ ಯಾವುದೇ
ಡೇಟಾ ಪ್ರಕಾರಗಳು, ನಾವು ಇದನ್ನು

95
00:04:29,080 --> 00:04:34,490
ಯಾವುದೇ ಡೇಟಾವನ್ನು ರೀತಿಯ, ತಂತಿಗಳು
ಬೇರೆ ಏನು ಎಲ್ಲಾ ವರ್ ಎಂದು.

96
00:04:34,490 --> 00:04:37,260
ಆಫ್ ಸಂಭಾವನಾ, ಎಲ್ಲಾ ನಮ್ಮ
C ಮತ್ತು PHP ಹಳೆಯ ಸ್ನೇಹಿತರು

97
00:04:37,260 --> 00:04:41,640
ಇನ್ನೂ ಲಭ್ಯವಿದೆ, ಆದ್ದರಿಂದ ನಾವು ವೇಳೆ ಹೊಂದಿವೆ,
ಬೇರೆ ವೇಳೆ, ಬೇರೆ, ಸ್ವಿಚ್ ಮತ್ತು ಪ್ರಶ್ನೆ

98
00:04:41,640 --> 00:04:42,240
ಮಾರ್ಕ್ ಕೊಲೊನ್.

99
00:04:42,240 --> 00:04:45,890
ಇದು ಸುಲಭವಾಗಿ ಉಳಿದ ಸ್ವಿಚ್
ಪಿಎಚ್ಪಿ ರಲ್ಲಿ, ಆದರೆ ನೀವು ಈ ಎಲ್ಲಾ

100
00:04:45,890 --> 00:04:46,930
ಈಗ ತಿಳಿದಿದೆ.

101
00:04:46,930 --> 00:04:49,900
ಮತ್ತು ಲೂಪ್ ಗಳು ಇದೇ ಜೊತೆ
ಹಾಗೆಯೇ ಹಳೆಯ ಮೆಚ್ಚಿನವುಗಳು

102
00:04:49,900 --> 00:04:52,700
ಹಾಗೆಯೇ, ಮತ್ತು ನಮಗೆ ಇನ್ನೂ ಲಭ್ಯವಿದೆ.

103
00:04:52,700 --> 00:04:55,880
ಆದ್ದರಿಂದ ಈಗಾಗಲೇ ನಾವು ಗೊತ್ತಿರಬೇಕು
ಮೂಲಭೂತ ಮೂಲಭೂತ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ರೀತಿಯ

104
00:04:55,880 --> 00:05:01,800
ಕೇವಲ ಸ್ವಲ್ಪ ಹೊಂದಿರುವ ಕಾರಣದಿಂದ
ಈಗ C ಮತ್ತು PHP ಬಗ್ಗೆ ಜ್ಞಾನದ.

105
00:05:01,800 --> 00:05:03,670
>> ಏನು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಾರ್ಯಗಳನ್ನು ಬಗ್ಗೆ?

106
00:05:03,670 --> 00:05:08,199
ಸರಿ, ಇದೇ ಪ್ರತಿ ಕಾರ್ಯ ಪಿಎಚ್ಪಿ
ಕಾರ್ಯ ಕೀವರ್ಡ್ ಪರಿಚಯಿಸಿ.

107
00:05:08,199 --> 00:05:10,740
ನೀವು ಕಾರ್ಯ ಹೇಳುತ್ತಾರೆ, ಮತ್ತು ನಂತರ ನೀವು
ನಿಮ್ಮ ಕಾರ್ಯ ಆರಂಭಿಸುತ್ತದೆ.

108
00:05:10,740 --> 00:05:12,531
ಸ್ವಲ್ಪ ಬೇರೆ ಏನು
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಗ್ಗೆ,

109
00:05:12,531 --> 00:05:15,700
ಆದರೂ ಹೊಂದಿವೆ ಸಾಮರ್ಥ್ಯ
ಅನಾಮಧೇಯ ಕ್ರಿಯೆ ಎಂದು.

110
00:05:15,700 --> 00:05:18,880
ಆದ್ದರಿಂದ ನೀವು ಕಾರ್ಯಗಳನ್ನು ರೂಪಿಸಬಹುದು
ಒಂದು ಹೆಸರನ್ನು ಹೊಂದಿಲ್ಲ.

111
00:05:18,880 --> 00:05:21,222
ಈ ವಿಷಯ ನಾವು ಆಗಿದೆ
ನಿಜವಾಗಿಯೂ ಮೊದಲು ನೋಡಿಲ್ಲ.

112
00:05:21,222 --> 00:05:23,430
ನಾವು ನಿಜವಾಗಿಯೂ ಪರಿಕಲ್ಪನೆ ಬಳಸಿ
ಅನಾಮಿಕ ಕ್ರಿಯೆಯ

113
00:05:23,430 --> 00:05:27,880
ಸ್ವಲ್ಪ ನಂತರ ಈ
ವೀಡಿಯೊ, ಇದು ಏಕೆಂದರೆ

114
00:05:27,880 --> 00:05:31,530
ಸಂದರ್ಭದಲ್ಲಿ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಅರ್ಥ
ನಾವು ಒಂದು ನಿರ್ದಿಷ್ಟ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ ಅದನ್ನು ನೋಡಿ

115
00:05:31,530 --> 00:05:33,120
ನಾನು ಇಲ್ಲಿ ರಚಿಸಲಾದ ಬಂದಿದೆ.

116
00:05:33,120 --> 00:05:35,710
ಆದರೆ ಕೇವಲ ಅವಲೋಕಿಸೋಣ
ಏನು ಸರಳ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನಲ್ಲಿ

117
00:05:35,710 --> 00:05:37,850
ಕಾರ್ಯ ರೀತಿ ಇರಬಹುದು.

118
00:05:37,850 --> 00:05:40,610
>> ಹಾಗಾಗಿ ಮುಂದೆ ಹೋಗಿದ್ದೀರಿ ಮತ್ತು
ನನ್ನ CS50 ಐಡಿಇ ತೆರೆದಿವೆ

119
00:05:40,610 --> 00:05:43,690
ಮತ್ತು ನಾನು ಈಗಾಗಲೇ ಅಪಾಚೆ ಹೊಸದೊಂದು
ನನ್ನ ಸರ್ವರ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಆರಂಭಿಸಲು.

120
00:05:43,690 --> 00:05:46,800
ನಾನು ಈ ಫೈಲ್
Home.html ಎಂಬ ತೆರೆಯಲು.

121
00:05:46,800 --> 00:05:48,330
ಮತ್ತು ನಾನು ಇಲ್ಲಿ ಸ್ವಲ್ಪ ಜೂಮ್ ಮಾಡುತ್ತೇವೆ.

122
00:05:48,330 --> 00:05:52,090
ಮತ್ತು ಮೂಲಭೂತವಾಗಿ, ನೀವು ನೋಡಬಹುದು
Home.html ಗುಂಡಿಗಳು ಕೇವಲ ಒಂದು ಗುಂಪನ್ನು ಹೊಂದಿದೆ.

123
00:05:52,090 --> 00:05:55,291
ಮತ್ತು ನಾನು ಇಲ್ಲಿ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಆರೋಪಿಸಿ ಬಾಗುತ್ತೇನೆ
ಈ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಿಭಾಗ ಎಂದು

124
00:05:55,291 --> 00:05:55,790
ವಸ್ತುಗಳನ್ನು.

125
00:05:55,790 --> 00:05:59,490
ಆದ್ದರಿಂದ ಗುಂಡಿಗಳು ಒಂದು ಗುಂಪನ್ನು ಇಲ್ಲಿ ಇಲ್ಲ,
ಆದರೆ ಈ ಗುಂಡಿಗಳು ವಾಸ್ತವವಾಗಿ ಮಾಡುವಿರಿ?

126
00:05:59,490 --> 00:06:03,662
>> ಸರಿ, ನಾವು ನನ್ನ ತಳುಕುಹಾಕಿಕೊಂಡಿರುವ ಮೇಲೆ ತಲೆಯಿಂದ ಮಾಡುತ್ತೇವೆ,
ಮತ್ತು ನಾನು ಇಲ್ಲಿ ತೆರೆಯಲು Home.html ಮಾಡಿದ್ದಾರೆ.

127
00:06:03,662 --> 00:06:05,620
ಅತ್ಯಂತ ಆರಂಭದಲ್ಲಿ,
ನಾನು ಲಿಂಕ್ ನಾನು ಅಲ್ಲಿ ಇಲ್ಲಿ

128
00:06:05,620 --> 00:06:07,500
ನನ್ನ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮೂಲ ಕಡತಗಳನ್ನು ಎಲ್ಲಾ.

129
00:06:07,500 --> 00:06:08,000
ರೈಟ್?

130
00:06:08,000 --> 00:06:12,440
ಹಾಗಾಗಿ, anonymous.js, clock.js ಹೊಂದಿವೆ
ನಾನು ಮೂಲ ಲಕ್ಷಣವನ್ನು ಬಳಸಿಕೊಂಡು ಬಾಗುತ್ತೇನೆ

131
00:06:12,440 --> 00:06:14,440
ಸ್ಕ್ರಿಪ್ಟ್ ಟ್ಯಾಗ್ ಫೈಲ್ ಲಿಂಕ್.

132
00:06:14,440 --> 00:06:18,660
ಹಾಗಾಗಿ ಬರೆದಿಲ್ಲ ಯಾವುದೇ
ನೇರವಾಗಿ ಈ ಫೈಲ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್,

133
00:06:18,660 --> 00:06:21,790
ಆದರೆ ನಾನು ನಿಲ್ಲಿಸಲು ಬಂದಿದೆ ಎಲ್ಲಾ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನಾನು ಪ್ರತ್ಯೇಕವಾಗಿ ಬರೆದ.

134
00:06:21,790 --> 00:06:24,540
ನಾವು ಇಲ್ಲಿ, ಈ ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ವೇಳೆ
ಮಾಡಬೇಕಾದುದು ಎಲ್ಲಾ ಸ್ವಲ್ಪ ಪರಿಚಿತ ನೋಡಲು

135
00:06:24,540 --> 00:06:27,090
ಹೊಸ ವಾಕ್ಯ ಸ್ವಲ್ಪ.

136
00:06:27,090 --> 00:06:32,655
ನಾವು ಹೆಡರ್ ಟ್ಯಾಗ್ ಇಲ್ಲಿ ಹೊಂದಿವೆ
ಕಾರ್ಯಗಳನ್ನು ಮತ್ತು ನಂತರ ಒಂದು ಬಟನ್.

137
00:06:32,655 --> 00:06:35,530
ನಾನು, ಒಂದು ರೀತಿಯ ಬಟನ್ ಎಂದು ಒಂದು ಇನ್ಪುಟ್
ಮತ್ತು ಸ್ಪಷ್ಟವಾಗಿ ನಾನು ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ,

138
00:06:35,530 --> 00:06:38,130
ನಾನು ಕೆಲವು ಕರೆ ಪಡೆಯಲಿದ್ದೇನೆ
ಎಚ್ಚರಿಕೆಯನ್ನು ದಿನಾಂಕ ಕಾರ್ಯ.

139
00:06:38,130 --> 00:06:41,792
ಈ ನಾವು ರೀತಿಯ ಮಿಶ್ರಣ ಹೇಗೆ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಎಚ್ಟಿಎಮ್ಎಲ್ ಸ್ವಲ್ಪ.

140
00:06:41,792 --> 00:06:44,500
ವಾಸ್ತವಿಕವಾಗಿ ಬಹಳ ಚೆನ್ನಾಗಿ ಆಡಲು
ಒಟ್ಟಿಗೆ, ಮತ್ತು ಆದ್ದರಿಂದ ಸ್ಪಷ್ಟವಾಗಿ

141
00:06:44,500 --> 00:06:48,730
ಈ ಬಟನ್ ಮೇಲೆ, ನಾನು ಪಡೆಯಲಿದ್ದೇನೆ ಕ್ಲಿಕ್
ಕೆಲವು ಕಾರ್ಯ ಎಚ್ಚರಿಕೆಯನ್ನು ದಿನಾಂಕ ಕರೆ.

142
00:06:48,730 --> 00:06:53,660
ಮತ್ತು ಹಾಗೆಯೇ ನಾನು ನಡವಳಿಕೆಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ್ದಾರೆ
ಇತರ ಗುಂಡಿಗಳು ಎಲ್ಲಾ ಆ

143
00:06:53,660 --> 00:06:56,440
ಎಂದು home.html ಪುಟದಲ್ಲಿ,
ನಾವು ಮರಳಿ ಇರಿಸಿಕೊಳ್ಳಲು ಮಾಡುತ್ತೇವೆ ಇದು

144
00:06:56,440 --> 00:06:59,172
ಈ ವೀಡಿಯೊ ಅವಧಿಯಲ್ಲಿ ಗೆ.

145
00:06:59,172 --> 00:07:00,880
ಆದರೆ ಅಪ್ ಹಿಂತಿರುಗಿ ಅವಕಾಶ
ಇಲ್ಲಿ ಮತ್ತು ನೋಡೋಣ

146
00:07:00,880 --> 00:07:03,850
clock.js ನಲ್ಲಿ, ಇದು
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಡತ ನಾನು

147
00:07:03,850 --> 00:07:07,370
ಈ ಮೊದಲ ಕ್ರಿಯೆ ಹೊಂದಿರುವ ಬರೆದ
ನಾವು ನೋಡೋಣ ನೀನು.

148
00:07:07,370 --> 00:07:11,630
ನೀವು ನೋಡಬಹುದು ಎಂದು, ನಾನು ನನ್ನ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆರಂಭಿಸಲು
ಕೀವರ್ಡ್ ಕಾರ್ಯದಲ್ಲಿ ಕೆಲಸ,

149
00:07:11,630 --> 00:07:14,560
ಮತ್ತು ನಾನು ಈ ಒಂದು ನೀಡಿದ್ದೇನೆ
ಹೆಸರು, ಇದು ಎಚ್ಚರಿಕೆಯನ್ನು ದಿನಾಂಕ ಕರೆಯಲಾಗುತ್ತದೆ.

150
00:07:14,560 --> 00:07:18,710
ಅಲ್ಲಿ ಒಳಗೆ, ನಾನು ಸ್ಪಷ್ಟವಾಗಿ ರಚಿಸಲು
ಪ್ರಸ್ತುತ ದಿನಾಂಕ ಎಂಬ ಹೊಸ ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್.

151
00:07:18,710 --> 00:07:21,500
ನಾನು ನಿಯೋಜಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ
ಹೊಸ ದಿನಾಂಕ ಸಮಾನ.

152
00:07:21,500 --> 00:07:24,430
ಮತ್ತು ನಾವು ಸಾಕಷ್ಟು ಪಡೆಯಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ
ದಿನಾಂಕ ಏನು ಎಂದು ವಿವರ,

153
00:07:24,430 --> 00:07:27,060
ಮತ್ತು ನಿಜವಾಗಿಯೂ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆದ್ದರಿಂದ
ದೊಡ್ಡ ಎಂದು ನಾವು ಬಹುಶಃ ಸಾಧ್ಯವಿಲ್ಲ

154
00:07:27,060 --> 00:07:28,330
ಒಂದು ವೀಡಿಯೊ ಎಲ್ಲವನ್ನೂ ಒಳಗೊಂಡಿರುತ್ತದೆ.

155
00:07:28,330 --> 00:07:32,220
ಆದರೆ, ಈ ಹೋಗಿ ಹೇಳಲು ಇದು ಸಾಕಾಗುತ್ತದೆ
ಒಂದು ಡೇಟಾ ವಸ್ತುವಿಗಾಗಿ ನನಗೆ ಮರಳಲು

156
00:07:32,220 --> 00:07:35,470
ಪ್ರಸ್ತುತ ದಿನಾಂಕ ಮತ್ತು ಸಮಯವನ್ನು encapsulates.

157
00:07:35,470 --> 00:07:39,100
ನಾನು ಮನುಷ್ಯ ಎಂದು ವೇರಿಯಬಲ್ ಎಂದು ಸಂಗ್ರಹಿಸಲು ನಾನು
ಸ್ಪಷ್ಟವಾಗಿ ಪ್ರಸ್ತುತ ದಿನಾಂಕ ಎಚ್ಚರಿಕೆ ಹೋಗುವ.

158
00:07:39,100 --> 00:07:41,300
>> ಸರಿ, ಯಾವ ಎಚ್ಚರಿಕೆಯನ್ನು ಮಾಡುತ್ತದೆ
ಹಾಗೆ ಪ್ರಸ್ತುತ ದಿನಾಂಕ ನೋಟ?

159
00:07:41,300 --> 00:07:46,460
ಫೈಲ್ ಸ್ವತಃ ಅವಲೋಕಿಸೋಣ
ಬ್ರೌಸರ್ ವಿಂಡೋನಲ್ಲಿ ಮೇಲೆ ಮತ್ತೆ.

160
00:07:46,460 --> 00:07:49,551
ಆದ್ದರಿಂದ ಮತ್ತೆ, ಈ ಬಟನ್ ಎಂದು ನಾನು
ಈ ಹೆಸರಿನ ಕಾರ್ಯ ಕಟ್ಟಲಾಗುತ್ತದೆ ಹೊಂದಿವೆ.

161
00:07:49,551 --> 00:07:51,800
ಮತ್ತು ನಾನು ಅದನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು
ನೋಡಲು ಇದು ಏನು, ಇದು ಎಚ್ಚರಿಸಿದ್ದಾರೆ.

162
00:07:51,800 --> 00:07:56,140
ಇದು ಹೇಳುವ ಬಾಕ್ಸ್ ಈ ರೀತಿಯ ಬೇರ್ಪಡಿಸಿದ
ನನಗೆ ಪ್ರಸ್ತುತ ಸಮಯ ಸ್ಪಷ್ಟವಾಗಿ, ಎಂದು

163
00:07:56,140 --> 00:07:59,370
ಇದು ನವೆಂಬರ್ 4 ಇಲ್ಲಿದೆ
ಬೆಳಿಗ್ಗೆ 10:43:43.

164
00:07:59,370 --> 00:08:02,345
ಈಗ ನಾನು, ಮತ್ತೆ ಕ್ಲಿಕ್ ಮಾಡಿದರೆ
ಇದು ಬಲ, ನಂತರ ಕೆಲವು ಸೆಕೆಂಡುಗಳ ಇಲ್ಲಿದೆ?

165
00:08:02,345 --> 00:08:03,720
ಆದ್ದರಿಂದ ಈ ಕಾರ್ಯವನ್ನು ಮಾಡುತ್ತದೆ ಇಲ್ಲಿದೆ.

166
00:08:03,720 --> 00:08:07,670
ನಾನು ಈ ಗುಂಡಿಯನ್ನು ಒತ್ತಿದಾಗ, ಇದು
ನನಗೆ ಒಂದು ಎಚ್ಚರಿಕೆ ಸಂದೇಶ ಪುಟಿಯುತ್ತದೆ.

167
00:08:07,670 --> 00:08:13,806

168
00:08:13,806 --> 00:08:15,690
ಆದ್ದರಿಂದ ನಿಜವಾಗಿಯೂ ಅಲ್ಲ
ಕಾರ್ಯಗಳನ್ನು ತುಂಬಾ

169
00:08:15,690 --> 00:08:19,110
ಎಂದು, ಪಿಎಚ್ಪಿ ಭಿನ್ನವಾಗಿದೆ
ಹೊಸ ವಾಕ್ಯ ಸ್ವಲ್ಪ

170
00:08:19,110 --> 00:08:22,500
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೆಲಸ ಬರುತ್ತದೆ.

171
00:08:22,500 --> 00:08:24,650
>> ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸರಣಿಗಳಿವೆ
ಬಹಳ ಸರಳ.

172
00:08:24,650 --> 00:08:27,200
ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಿದ, ನೀವು ಬಳಸಲು
ಚದರ ಬ್ರಾಕೆಟ್ಗಳನ್ನು ವಾಕ್ಯ

173
00:08:27,200 --> 00:08:30,090
ನಾವು ಪಿಎಚ್ಪಿ ಪರಿಚಿತವಾಗಿರುವ.

174
00:08:30,090 --> 00:08:33,432
ಮತ್ತು ಪಿಎಚ್ಪಿ ರೀತಿಯಲ್ಲಿ, ನಾವು
ದತ್ತಾಂಶ ಬಗೆಯ ಮಿಶ್ರಣ ಮಾಡಬಹುದು.

175
00:08:33,432 --> 00:08:35,140
ಆದ್ದರಿಂದ ಈ ವ್ಯೂಹ, ಎರಡೂ
ಈ ಆಯ್ರೆಗಳ ಎಂದು

176
00:08:35,140 --> 00:08:36,960
ಸಂಪೂರ್ಣವಾಗಿ ಕಾನೂನುಬದ್ಧ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಎಂದು.

177
00:08:36,960 --> 00:08:42,500
ಎಲ್ಲಾ ಪೂರ್ಣಾಂಕಗಳ ಎಂದು ಒಂದು, ಮತ್ತು ಆ
ವಿವಿಧ ಅಕ್ಷಾಂಶ ರೀತಿಯ ಮಿಶ್ರ ಇದೆ.

178
00:08:42,500 --> 00:08:45,020
>> ಬೇರೆ ಏನಾದರೂ ಯಾವುದು
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್, ಆದರೂ?

179
00:08:45,020 --> 00:08:47,020
ಒಂದು ವಸ್ತುವಿನ ಕಲ್ಪನೆ ಇಲ್ಲಿದೆ.

180
00:08:47,020 --> 00:08:50,240
ಆದ್ದರಿಂದ ಬಹುಶಃ ನೀವು ಕೇಳಿರುವ
ಆಧಾರಿತ ಪ್ರೊಗ್ರಾಮಿಂಗ್ ವಸ್ತು.

181
00:08:50,240 --> 00:08:53,370
ನಾವು, CS50 ರಲ್ಲಿ ಇದು ಬಹಳಷ್ಟು ಮಾಡಬೇಡಿ
ಆದರೆ ನಾವು ಸ್ವಲ್ಪ ಮಾಡುತ್ತಾರೆ

182
00:08:53,370 --> 00:08:55,670
ಇಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸನ್ನಿವೇಶದಲ್ಲಿ.

183
00:08:55,670 --> 00:08:59,100
ಈಗ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿದೆ
ಒಂದು ವಸ್ತು ಆಧಾರಿತ ಪ್ರೊಗ್ರಾಮಿಂಗ್ ವರ್ತಿಸುವಂತೆ

184
00:08:59,100 --> 00:09:02,615
ಭಾಷೆ, ಆದರೆ ಸ್ವತಃ ಅಲ್ಲ
ಪ್ರತ್ಯೇಕವಾಗಿ ವಸ್ತು ಆಧಾರಿತ

185
00:09:02,615 --> 00:09:03,490
ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ.

186
00:09:03,490 --> 00:09:05,281
ಈ ಮತ್ತೆ ಬರುತ್ತದೆ
ಮತ್ತೆ ನಾನು ಹೇಳಿದೆ ಏಕೆ

187
00:09:05,281 --> 00:09:10,610
ತಿಳಿಯಲು ಬಹಳ ಕಷ್ಟಕರವಾಗಿರುತ್ತದೆ
ನಿಮ್ಮ ಮೊದಲ ಕ್ರಮವಿಧಿಕರಣ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್

188
00:09:10,610 --> 00:09:13,890
ಭಾಷೆ, ಇದು ಏಕೆಂದರೆ
ನಿಜವಾಗಿಯೂ ಒಂದು ನಿರ್ದಿಷ್ಟ ಮಾದರಿ ಹೊಂದಿಕೊಳ್ಳಲು.

189
00:09:13,890 --> 00:09:16,430
>> ಮತ್ತೊಂದೆಡೆ ಸಿ ಒಂದು
ಕಾರ್ಯಕಾರಿ ಕ್ರಮವಿಧಿ ಭಾಷೆಯಾಗಿದೆ.

190
00:09:16,430 --> 00:09:22,270
ನಾವು ಬಯಸಿದರೆ, ಕ್ರಿಯೆಗಳು
ಬಿಗ್ ಬಾಸ್ ಮಾನವ ರೀತಿಯ, ಬಲ?

191
00:09:22,270 --> 00:09:24,410
ಅವರು ವಿಚಾರದಲ್ಲಿ ಏನು
ಉಳಿದಂತೆ ನಡೆಯುತ್ತದೆ.

192
00:09:24,410 --> 00:09:26,600
ನಾವು ಅಸ್ಥಿರ ಬದಲಾಯಿಸಲು ಬಯಸುವ,
ನಾವು ಕಾರ್ಯಗಳನ್ನು ಕರೆ.

193
00:09:26,600 --> 00:09:28,220
ನಾವು ಕಾರ್ಯಗಳನ್ನು ಕೆಲಸಗಳನ್ನು.

194
00:09:28,220 --> 00:09:31,250
ಒಂದು, ಬದಲಿಗೆ ಆಬ್ಜೆಕ್ಟ್ಸ್
ಉದ್ದೇಶಿತ ಭಾಷೆಯನ್ನು ವಸ್ತು,

195
00:09:31,250 --> 00:09:35,937
ರೀತಿಯ ತಾರೆಯಾಗಲು ವಸ್ತುಗಳು ಮತ್ತು
ಕಾರ್ಯಗಳನ್ನು ದ್ವಿತೀಯ ರೀತಿಯ ಮಾರ್ಪಟ್ಟಿದೆ.

196
00:09:35,937 --> 00:09:38,270
ಆದರೆ ಒಂದು ವಸ್ತು, ಏನು
ವಸ್ತುವಿನ ಈ ಕಲ್ಪನೆಯು?

197
00:09:38,270 --> 00:09:40,880
ಸರಿ, ಇದು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಭಾವಿಸುತ್ತೇನೆ
ಮೊದಲ ರೀತಿಯ ಅದರ ಬಗ್ಗೆ

198
00:09:40,880 --> 00:09:44,540
ಒಂದು ಸಿ ರಚನೆ ಅಥವಾ ಒಂದು struct ರೀತಿಯ
ನಾವು ಮೊದಲು ಕಲಿತ.

199
00:09:44,540 --> 00:09:47,430
ಸಿ, ಒಂದು ರಚನೆಯನ್ನು ಹೊಂದಿರುತ್ತದೆ
ಕ್ಷೇತ್ರಗಳಲ್ಲಿ,

200
00:09:47,430 --> 00:09:51,174
ಮತ್ತು ಬಹುಶಃ ನಾವು ಈಗ ಆರಂಭವಾಗಬಹುದು
ಈ ಜಾಗ ಗುಣಗಳನ್ನು ಕರೆ.

201
00:09:51,174 --> 00:09:53,590
ಆದರೆ ಗುಣಗಳನ್ನು ನಿಜವಾಗಿಯೂ
ಬಲ, ತಮ್ಮ ಮೇಲೆ ನಿಂತು?

202
00:09:53,590 --> 00:09:56,410
ನಾನು ಒಂದು ಕಾರು ಒಂದು ರಚನೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ ವೇಳೆ
ಎರಡು ಕೆಳಗಿನ ಈ ರೀತಿಯ

203
00:09:56,410 --> 00:10:00,750
ಜಾಗ ಅಥವಾ ಗುಣಗಳನ್ನು, ಒಂದು
ಕಾರಿನ ವರ್ಷ ಪೂರ್ಣಾಂಕ

204
00:10:00,750 --> 00:10:04,290
ಮತ್ತು ಇನ್ನೊಂದು 10 ರ
ಕಾರಿನ ಮಾದರಿ ಸ್ಟ್ರಿಂಗ್

205
00:10:04,290 --> 00:10:07,150
ನಾನು ಈ ರೀತಿಯ ಹೇಳಬಹುದು
ನಾನು ಒಂದು ಹೊಸ ವೇರಿಯಬಲ್ ಘೋಷಿಸಿದ ಮಾಡಬಹುದು

206
00:10:07,150 --> 00:10:10,080
ರೀತಿಯ struct ಕಾರು ಹರ್ಬೀ ಆಫ್.

207
00:10:10,080 --> 00:10:13,730
ಮತ್ತು ನಂತರ ನಾನು ಹೇಳಬಹುದು
ಹಾಗೆ herbie.year, 1,963 ಸಮನಾಗಿರುತ್ತದೆ

208
00:10:13,730 --> 00:10:15,850
ಮತ್ತು herbie.model ಬೀಟಲ್ ಸಮನಾಗಿರುತ್ತದೆ.

209
00:10:15,850 --> 00:10:17,000
ಒಕೆ.

210
00:10:17,000 --> 00:10:19,680
ನಾನು ಜಾಗ ಬಳಸಿಕೊಂಡು ಬಾಗುತ್ತೇನೆ
ರಚನೆ ಸಂದರ್ಭದಲ್ಲಿ,

211
00:10:19,680 --> 00:10:22,290
ಆದರೆ ನಾನು ಸಾಧ್ಯವೋ ಎಂದಿಗೂ
ಈ ರೀತಿಯ ಹೇಳಲು.

212
00:10:22,290 --> 00:10:22,790
ರೈಟ್?

213
00:10:22,790 --> 00:10:26,836
ನಾನು ಕ್ಷೇತ್ರದಲ್ಲಿ ಹೆಸರು ಬಳಸುವಂತಿಲ್ಲ
ರಚನೆಯ ಸ್ವತಂತ್ರ.

214
00:10:26,836 --> 00:10:28,210
ಇದು ಮೂಲಭೂತ ವಿಷಯ ರೀತಿಯ ಇಲ್ಲಿದೆ.

215
00:10:28,210 --> 00:10:32,990
>> ಜಾಗ ಎಂದು ಆದ್ದರಿಂದ
ಸಿ ರಚನೆಗಳು ಮೂಲಭೂತ

216
00:10:32,990 --> 00:10:39,050
ಗುಣಗಳನ್ನು ಎಂಬ ಇವೆ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಸ್ತುಗಳು ಮೂಲಭೂತ.

217
00:10:39,050 --> 00:10:42,080
ಆದರೆ ಅವುಗಳನ್ನು ಮಾಡುತ್ತದೆ
ನಿರ್ದಿಷ್ಟವಾಗಿ ಆಸಕ್ತಿದಾಯಕವಾಗಿ

218
00:10:42,080 --> 00:10:46,230
ವಸ್ತುಗಳು ಸಹ ಏನು ಹೊಂದಬಹುದಾದ ಆಗಿದೆ
ನಿಜವಾಗಿಯೂ ಇದು ಕರೆಯಲಾಗುತ್ತದೆ ವಿಧಾನಗಳು

219
00:10:46,230 --> 00:10:50,730
ಚಟುವಟಿಕೆಗಳಿಗೆ ಒಂದು ಅಲಂಕಾರಿಕ ಪದ ಎಂದು
ವಸ್ತು ಅಂತರ್ಗತ ಹಾಗೆಯೇ ಇವೆ.

220
00:10:50,730 --> 00:10:55,340
ಇದು ಒಂದು ಕಾರ್ಯ ಆದ್ದರಿಂದ ಮಾತ್ರ ಎಂದು
ವಸ್ತುವಿನ ಸಂದರ್ಭದಲ್ಲಿ ಕರೆ.

221
00:10:55,340 --> 00:10:59,200
ವ್ಯಾಖ್ಯಾನಿಸಿದೆ ಒಂದು ವಸ್ತು
ಅದರ ಒಳಗೆ ಈ ಕಾರ್ಯ,

222
00:10:59,200 --> 00:11:02,020
ನೀವು ಭಾವಿಸಿದರೆ
struct, ಕಾರ್ಯ

223
00:11:02,020 --> 00:11:05,720
ವಿವರಿಸುವ ಆ ಒಳಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ
ರಚನೆಯ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್.

224
00:11:05,720 --> 00:11:07,980
ಆದ್ದರಿಂದ ಕೇವಲ ಅರ್ಥವನ್ನು
ರಚನೆ.

225
00:11:07,980 --> 00:11:10,960
ಮತ್ತು ನಾವು ಮಾಡುತ್ತಿರುವುದು ರೀತಿಯ ಇಲ್ಲಿದೆ
ಇಲ್ಲಿ ವಸ್ತುಗಳು ಮತ್ತು ವಿಧಾನಗಳು.

226
00:11:10,960 --> 00:11:13,580
ನಾವು ಮಾಡುತ್ತಿರುವಂತೆ ಇದು ಮೂಲತಃ
ಒಂದು ಕಾರ್ಯ ವಿವರಿಸುವ ಎಂದು

227
00:11:13,580 --> 00:11:16,670
ಕೇವಲ ಮೇಲೆ ಅರ್ಥವಿಲ್ಲ
ನಿರ್ದಿಷ್ಟ ವಸ್ತುವಿನ, ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು

228
00:11:16,670 --> 00:11:19,440
ವಸ್ತುವಿನ ಒಂದು ವಿಧಾನ ಎಂದು ಕರೆ.

229
00:11:19,440 --> 00:11:23,180
ಮತ್ತು ನಾವು ಕರೆ ಎಂದಿಗೂ
ವಸ್ತುವಿನ ಸ್ವತಂತ್ರ ಕಾರ್ಯ,

230
00:11:23,180 --> 00:11:29,260
ನಾವು ವರ್ಷದ ಮಾದರಿಯಲ್ಲಿ ಹೇಳಲು ಸಾಧ್ಯವಿಲ್ಲ ಕೇವಲ ಹಾಗೆ
ಸಿ struct ಆಫ್ ಸ್ವತಂತ್ರ

231
00:11:29,260 --> 00:11:32,300
>> ಆದ್ದರಿಂದ ಕಾರ್ಯಾಚರಣೆಯ ಪ್ರೊಗ್ರಾಮಿಂಗ್
ವಿಶ್ಲೇಷಣೆಗಳು ಈ ರೀತಿಯ ನೋಡಲು.

232
00:11:32,300 --> 00:11:35,450
ಫಂಕ್ಷನ್ ಮತ್ತು ನಂತರ ನೀವು ಹಾದುಹೋದಾಗ
ಪ್ಯಾರಾಮೀಟರ್ನಂತೆ ವಸ್ತು.

233
00:11:35,450 --> 00:11:38,650
ಒಂದು ವಸ್ತು ಆಧಾರಿತ ಪ್ರೊಗ್ರಾಮಿಂಗ್ ರಲ್ಲಿ
ಭಾಷೆಗಳು, ಈ ರೀತಿಯ ಗೆಟ್ಸ್

234
00:11:38,650 --> 00:11:43,464
ಹಿಮ್ಮೊಗ, ಮತ್ತು ನಾವು ಬಗ್ಗೆ ಯೋಚಿಸುವುದಿಲ್ಲ
ಇದು, object.function ಈ ಇಷ್ಟ.

235
00:11:43,464 --> 00:11:45,380
ಆದ್ದರಿಂದ ಡಾಟ್ ರೀತಿಯ
ಆಯೋಜಕರು ಮತ್ತೆ ಸೂಚಿಸುವ

236
00:11:45,380 --> 00:11:49,540
ಇದು ಆಸ್ತಿ ಕೆಲವು ರೀತಿಯ ಎಂದು
ಅಥವಾ ವಸ್ತುವಿನ ಸ್ವತಃ ಗುಣಲಕ್ಷಣ.

237
00:11:49,540 --> 00:11:53,240
ಆದರೆ ಈ ಯಾವ ವಸ್ತು
ಆಧಾರಿತ ಪ್ರೊಗ್ರಾಮಿಂಗ್ ಭಾಷೆ

238
00:11:53,240 --> 00:11:57,150
ಕಾರ್ಯ ಮಾಡಲು ಏನು ಮಾಡಬಹುದು
, ಮತ್ತೆ, ಒಂದು ವಿಧಾನವನ್ನು ಕುರಿತು ಕರೆ

239
00:11:57,150 --> 00:12:00,260
ಕೇವಲ ವಿಶೇಷ ಪದ ಕಾರ್ಯ ಆಗಿದೆ
ಒಂದು ವಸ್ತುವಿಗೆ ಅಂತರ್ಗತವಾಗಿದೆ.

240
00:12:00,260 --> 00:12:03,440
ಈ ಯಾವ ಎಂಬುದು
ವಾಕ್ಯ ರೀತಿ ಇರಬಹುದು.

241
00:12:03,440 --> 00:12:09,360
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಕೆಲವು ನೋಡಲು ಪ್ರಾರಂಭಿಸಿ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸನ್ನಿವೇಶದಲ್ಲಿ ಈ.

242
00:12:09,360 --> 00:12:12,470
>> ನೀವು ವಸ್ತುವಿನ ಬಗ್ಗೆ
ರೀತಿಯ ಒಂದು ಸಹಾಯಕ ರಚನೆಯ ಹಾಗೆ,

243
00:12:12,470 --> 00:12:14,160
ನಾವು ಪಿಎಚ್ಪಿ ಪರಿಚಿತವಾಗಿರುವ ಇದು.

244
00:12:14,160 --> 00:12:17,720
ಒಂದು ಸಹಾಯಕ ರಚನೆಯ ಅನುಮತಿಸುತ್ತದೆ ನೆನಪಿಡಿ
ನಮಗೆ ಬದಲಿಗೆ, ಪ್ರಮುಖ ಮೌಲ್ಯ ಜೋಡಿ ಹೊಂದಲು

245
00:12:17,720 --> 00:12:23,040
ಸೂಚಿಕೆಗಳನ್ನು 0, ಒಂದು, ಎರಡು, ಮೂರು ಹೊಂದಿರುವ,
ಮತ್ತು ನಾವು ಸಿ ರಿಂದ ಬಳಸಲಾಗುತ್ತದೆ ನೀವು ಹೀಗೆ ರೀತಿಯ

246
00:12:23,040 --> 00:12:23,940
ರಚನೆಗಳು.

247
00:12:23,940 --> 00:12:27,472
ಸಹಾಯಕ ರಚನೆಗಳು ನಕ್ಷೆ
ಉದಾಹರಣೆಗೆ PHP ವಿಡಿಯೋದಲ್ಲಿ ಪದಗಳನ್ನು,

248
00:12:27,472 --> 00:12:29,180
ನಾವು ಬಗ್ಗೆ
ಪಿಜ್ಜಾಗಳು ಮೇಲೋಗರಗಳಿಗೆ.

249
00:12:29,180 --> 00:12:31,180
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿದ್ದರೆ
ಎಂಬ ಪಿಜ್ಜಾಗಳು, ಮತ್ತು ನಾವು

250
00:12:31,180 --> 00:12:36,670
ಹೊಂದಿತ್ತು ಚೀಸ್ ಮುಖ್ಯವಾಗಿದೆ ಮತ್ತು $ 8,99 ಆಗಿತ್ತು
ಮೌಲ್ಯ, ಮತ್ತು ನಂತರ ಪೆಪ್ಪೆರೋನಿ ಮುಖ್ಯವಾಗಿದೆ,

251
00:12:36,670 --> 00:12:39,190
$ 9.99 ಹೀಗೆ ಈ ಕೆಳಗಿನ, ಮತ್ತು.

252
00:12:39,190 --> 00:12:43,300
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಒಂದು ಬಗ್ಗೆ
ಒಂದು ಸಹಾಯಕ ಗೆ ಇದೇ ರೀತಿಯ ವಸ್ತು

253
00:12:43,300 --> 00:12:43,840
ಸರಣಿ.

254
00:12:43,840 --> 00:12:47,020
ಇಲ್ಲಿ ಮತ್ತು ಈ ವಾಕ್ಯ
ಹೊಸ ವಸ್ತು ರಚಿಸಲು ಎಂದು

255
00:12:47,020 --> 00:12:50,950
ಎರಡು ಎಂಬ ಹರ್ಬೀ
ಅದರ ಒಳಗೆ ಗುಣಲಕ್ಷಣಗಳನ್ನು.

256
00:12:50,950 --> 00:12:57,310
ಮೌಲ್ಯದ 1963 ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಇದು ವರ್ಷದ,
ಸ್ಟ್ರಿಂಗ್ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಇದು ಮತ್ತು ಮಾದರಿ,

257
00:12:57,310 --> 00:12:58,140
ಬೀಟಲ್.

258
00:12:58,140 --> 00:13:01,770
>> ನಾನು ಬಳಸಿ ನಾನು ಇಲ್ಲಿ ಗಮನಿಸಿ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ತಂತುವನ್ನು.

259
00:13:01,770 --> 00:13:05,570
ನೀವು ಏಕೈಕ ಅಥವಾ ಎರಡು ಉದ್ದರಣ ಬಳಸಬಹುದು
ತಂತಿಗಳನ್ನು ಬಗ್ಗೆ ನೀವು.

260
00:13:05,570 --> 00:13:07,772
ಇದು ಕೇವಲ ಸಾಂಪ್ರದಾಯಿಕವಾಗಿ ಇಲ್ಲಿದೆ
ಸಂದರ್ಭದಲ್ಲಿ ಹೆಚ್ಚಿನ ಬಾರಿ

261
00:13:07,772 --> 00:13:10,230
ನೀವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬರೆಯಲು ನೀವು,
ನೀವು ಏಕ ಉದ್ಧರಣ.

262
00:13:10,230 --> 00:13:15,050
ಆದರೆ ನಾನು ಇಲ್ಲಿ ಎರಡು ಉಲ್ಲೇಖಗಳು ಬಳಸಬಹುದಾಗಿತ್ತು ಮತ್ತು
ಜೊತೆಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಚೆನ್ನಾಗಿರುತ್ತದೆ.

263
00:13:15,050 --> 00:13:17,470
>> ಆದ್ದರಿಂದ ಹೇಗೆ ಮರೆಯದಿರಿ
ಪಿಎಚ್ಪಿ ನಾವು ಈ ಕಲ್ಪನೆಯನ್ನು ಹೊಂದಿತ್ತು

264
00:13:17,470 --> 00:13:22,730
ನಮಗೆ ಅವಕಾಶ ಎಂದು ಪ್ರತಿ ಲೂಪ್ ಒಂದು
ಪ್ರಮುಖ ಮೌಲ್ಯದ ಎಲ್ಲಾ ಮೇಲೆ ತಿರುಗಿ

265
00:13:22,730 --> 00:13:25,270
ಒಂದು ಸಹಾಯಕ ಜೋಡಿ
ಅರೇ, ನಾವು ಏಕೆಂದರೆ

266
00:13:25,270 --> 00:13:29,050
ತಿರುಗಿ ಈ ಸಾಮರ್ಥ್ಯವನ್ನೇ
0 ಮೂಲಕ, ಒಂದು, ಎರಡು, ಮೂರು, ನಾಲ್ಕು,

267
00:13:29,050 --> 00:13:30,710
ಮತ್ತು ಇತ್ಯಾದಿ?

268
00:13:30,710 --> 00:13:35,010
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್, ಹೋಲುತ್ತದೆ ಏನೋ ಹೊಂದಿದೆ
ಆದರೆ, ಪ್ರತಿ ಲೂಪ್ ಒಂದು ಎಂದು ಅಲ್ಲ

269
00:13:35,010 --> 00:13:38,960
ಇದು ಕುಣಿಕೆಗಳು ಒಂದು ಎಂದು.

270
00:13:38,960 --> 00:13:42,890
ಹಾಗಾಗಿ ಹಾಗೆ ನನಗೆ ಹೇಳಿದರು ವೇಳೆ
ಈ, ವಸ್ತು ವರ್ ಕೀಲಿ,

271
00:13:42,890 --> 00:13:48,670
ಎಂದು ಗೆ ಇದೇ ರೀತಿಯ ಇಲ್ಲಿದೆ
ಏನೋ ಪ್ರತಿ ಏನೋ.

272
00:13:48,670 --> 00:13:53,850
ಆದರೆ ನಾನು ಇಲ್ಲಿ ಮಾಡುತ್ತಿರುವೆ ಎಲ್ಲಾ iterating ಇದೆ
ನನ್ನ ವಸ್ತುವಿನ ಕೀಲಿಗಳನ್ನು ಎಲ್ಲಾ ಮೂಲಕ.

273
00:13:53,850 --> 00:13:56,070
ಮತ್ತು ಸುರುಳಿಯಾದ ಒಳಗೆ
ಅಲ್ಲಿ ಕಟ್ಟುಪಟ್ಟಿಗಳು, ನಾನು

274
00:13:56,070 --> 00:14:03,410
ಉಲ್ಲೇಖಿಸಲು ವಸ್ತು ಚದರ ಬ್ರಾಕೆಟ್ಗಳನ್ನು ಕೀಲಿಯನ್ನು ಬಳಸಿ
ಪ್ರಮುಖ ಸ್ಥಳದಲ್ಲಿ ಮೌಲ್ಯಕ್ಕೆ.

275
00:14:03,410 --> 00:14:05,400
>> ಪರ್ಯಾಯವಾಗಿ, ಇಲ್ಲ
ಮತ್ತೊಂದು ವಿಧಾನ.

276
00:14:05,400 --> 00:14:10,880
ನಾನು ಮಾತ್ರ ಕಾಳಜಿ
ಮೌಲ್ಯಗಳು, ನಾನು, ವಸ್ತುವಿನ ಪ್ರಮುಖ ಹೇಳಬಹುದು

277
00:14:10,880 --> 00:14:12,360
ಮತ್ತು ಕೇವಲ ಒಳಗೆ ಕೀಲಿಯನ್ನು ಬಳಸಿ.

278
00:14:12,360 --> 00:14:17,240
ಆದ್ದರಿಂದ ವಸ್ತು ವರ್ ಪ್ರಮುಖ, ನಾನು ಹೊಂದಿವೆ
ವಸ್ತು ಚದರ ಬ್ರಾಕೆಟ್ಗಳನ್ನು ಬಳಸಲು

279
00:14:17,240 --> 00:14:19,340
ಲೂಪ್ ಒಳಗೆ ಪ್ರಮುಖ.

280
00:14:19,340 --> 00:14:24,580
ವಸ್ತುವಿನ ವರ್ ಪ್ರಮುಖ, ನಾನು ಮಾಡಬಹುದು
ಕೇವಲ ಲೂಪ್ ಒಳಗೆ ಕೀಲಿಯನ್ನು ಬಳಸಿ,

281
00:14:24,580 --> 00:14:29,040
ನಾನು ನಿರ್ದಿಷ್ಟವಾಗಿ ಮನುಷ್ಯ ಏಕೆಂದರೆ
ಅಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ಬಗ್ಗೆ.

282
00:14:29,040 --> 00:14:32,630
>> ಆದ್ದರಿಂದ ಬಹುಶಃ ನೋಡೋಣ
ವ್ಯತ್ಯಾಸವನ್ನು ನೋಡಿ

283
00:14:32,630 --> 00:14:35,670
ತ್ವರಿತವಾಗಿ ನೀವು ತೋರಿಸಲು
ನಾಲ್ಕು ನಡುವಿನ ವ್ಯತ್ಯಾಸ

284
00:14:35,670 --> 00:14:40,730
ಒಂದು ನಿರ್ದಿಷ್ಟ ಜೊತೆ ಮತ್ತು
ಇಲ್ಲಿರುವುದು ಸರಣಿ, ವಾರ ಶ್ರೇಣಿಯನ್ನು.

285
00:14:40,730 --> 00:14:43,616
ಆದ್ದರಿಂದ ನಾನು ಒಂದು ಹೊಸ ಶ್ರೇಣಿಯನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕಿದೆ
ನಾನು ಏಳು ತಂತಿಗಳ ತುಂಬಿದ,

286
00:14:43,616 --> 00:14:46,240
ಸೋಮವಾರ, ಮಂಗಳವಾರ, ಬುಧವಾರ,
ಗುರುವಾರ, ಶುಕ್ರವಾರ, ಶನಿವಾರ, ಭಾನುವಾರ.

287
00:14:46,240 --> 00:14:50,530
ಈಗ ನಾನು ಮರಳಿ ಬಯಸುವ
ಈ ರಚನೆಯ ಮೂಲಕ,

288
00:14:50,530 --> 00:14:53,090
ಕೆಲವು ಮಾಹಿತಿಯನ್ನು ಮುದ್ರಿಸುವ.

289
00:14:53,090 --> 00:14:58,780
ನಾನು ಚಕ್ರಕ್ಕೆ ಒಂದು ಬಳಸಿದರೆ
ಮಾಹಿತಿ ಮುದ್ರಿಸುತ್ತದೆ,

290
00:14:58,780 --> 00:15:00,710
ನೀವು ನಾನು ಪಡೆಯಲು ಪಡೆಯಲಿದ್ದೇನೆ ಏನು ಆಲೋಚಿಸುತ್ತೀರಿ ಏನು?

291
00:15:00,710 --> 00:15:01,710
ಅಲ್ಲದೆ, ಅವಲೋಕಿಸೋಣ.

292
00:15:01,710 --> 00:15:05,300
ನಾವು ಜಿಗಿತವನ್ನು ಮೊದಲು
ನನ್ನ ಬ್ರೌಸರ್ನಲ್ಲಿ,

293
00:15:05,300 --> 00:15:08,090
ಕೇವಲ ತಿಳಿದಿದೆ
console.log ಒಂದು ತೆರನಾದ

294
00:15:08,090 --> 00:15:10,630
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಒಂದು ಮುದ್ರಣ F ಮಾಡುವ ರೀತಿಯಲ್ಲಿ.

295
00:15:10,630 --> 00:15:12,040
ಆದರೆ ಕನ್ಸೋಲ್ ಏನು?

296
00:15:12,040 --> 00:15:14,940
ಸರಿ, ನಾವು ನೀನು ಇಲ್ಲಿದೆ
ಇದೀಗ ನೋಡೋಣ ಹೋಗಲು.

297
00:15:14,940 --> 00:15:16,850
>> ಸರಿ, ಆದ್ದರಿಂದ ನಾವು ಇಲ್ಲಿ ಮರಳಿದ್ದೀರಿ
ನನ್ನ ಬ್ರೌಸರ್ನಲ್ಲಿ,

298
00:15:16,850 --> 00:15:19,410
ಮತ್ತು ನಾನು ತೆರೆಯಲು ಪಡೆಯಲಿದ್ದೇನೆ
ನನ್ನ ಡೆವಲಪರ್ ಸಾಧನಗಳು.

299
00:15:19,410 --> 00:15:22,290
ಮತ್ತೆ, ನಾನು ಎಫ್ 12 ಹೊಡೆಯುವ ಬಾಗುತ್ತೇನೆ
ಡೆವಲಪರ್ ಸಾಧನಗಳು ತೆರೆಯಲು.

300
00:15:22,290 --> 00:15:25,670
ಮತ್ತು ಇಲ್ಲಿ ಗಮನಿಸಿ
ಉನ್ನತ ನಾನು ಕನ್ಸೋಲ್ ಆಯ್ಕೆ ಮಾಡಿದ.

301
00:15:25,670 --> 00:15:28,480
ಆದ್ದರಿಂದ ಈ ಕಲ್ಪನೆಯು
ಡೆವಲಪರ್ ಕನ್ಸೋಲ್,

302
00:15:28,480 --> 00:15:30,500
ಮತ್ತು ಇದು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ
ಮಾಹಿತಿ ಮುದ್ರಿಸುತ್ತದೆ

303
00:15:30,500 --> 00:15:33,000
ರೀತಿಯ ಟರ್ಮಿನಲ್, ಆದರೆ
ನೀವು ಸ್ವಲ್ಪ ನಂತರ ನೋಡುತ್ತಾರೆ ಎಂದು,

304
00:15:33,000 --> 00:15:37,720
ನಾವು ಮಾಹಿತಿ ಟೈಪಿಸಿದರೆ
ನಮ್ಮ ವೆಬ್ ಪುಟ ವ್ಯವಹರಿಸಲು.

305
00:15:37,720 --> 00:15:42,320
ನಾನು ಇಲ್ಲಿ ಸ್ವಲ್ಪ ಜೂಮ್ ಪಡೆಯಲಿದ್ದೇನೆ
ಮತ್ತು ನಾನು ಹೇಳಲು ಈಗ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಫಾರ್ ಕ್ಲಿಕ್ ಮನುಷ್ಯ.

306
00:15:42,320 --> 00:15:45,230
ಮತ್ತು ನಾಲ್ಕು test-- ನಾನು ಗೊನ್ನಾ ಅಲ್ಲ
ಇದೀಗ ನೀವು ಕೋಡ್ ತೋರಿಸಲು,

307
00:15:45,230 --> 00:15:47,479
ಆದರೆ ನೀವು ಅದನ್ನು ವೇಳೆ ಪಡೆಯುತ್ತೀರಿ
ಮೂಲ ಕೋಡ್ ಡೌನ್ಲೋಡ್ ಎಂದು

308
00:15:47,479 --> 00:15:50,380
ಈ video-- ಸಂಬಂಧಿಸಿದೆ
ಕೇವಲ ಚಕ್ರಕ್ಕೆ ಆಗಿದೆ

309
00:15:50,380 --> 00:15:52,610
ನಾವು ನೋಡಿದ ಕೇವಲ
ಎರಡನೇ ಹಿಂದೆ ಸ್ಲೈಡ್.

310
00:15:52,610 --> 00:15:54,810
>> ಹಾಗಾಗಿ ಹೇಳಲು ಕ್ಲಿಕ್ ಮನುಷ್ಯ
ಬಟನ್, ಮತ್ತು ಇಲ್ಲಿ,

311
00:15:54,810 --> 00:15:58,440
ಇಲ್ಲಿ ಮುದ್ರಿಸಲಾಗುತ್ತದೆ ಇಲ್ಲಿದೆ
ಕನ್ಸೋಲ್, 0, ಒಂದು, ಎರಡು, ಮೂರು, ನಾಲ್ಕು, ಐದು,

312
00:15:58,440 --> 00:15:58,940
ಆರು.

313
00:15:58,940 --> 00:16:02,490
ನಾನು ಮಾಹಿತಿ ಮುದ್ರಿಸುತ್ತದೆ ಮಾಡಲಿಲ್ಲ
ಆ ರಚನೆಯ ಸ್ಥಳಗಳನ್ನು,

314
00:16:02,490 --> 00:16:05,180
ನಾನು ಚಕ್ರಕ್ಕೆ ಒಂದು ಬಳಸಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ.

315
00:16:05,180 --> 00:16:10,670
ಮತ್ತು ಲೂಪ್ ದೇಹದ ಒಳಗೆ, ನಾನು
ಕೇವಲ ಪ್ರಮುಖ ಆಕ್ಷೇಪಣೆಯಿರುವುದು ಕೀ ಮುದ್ರಿತ.

316
00:16:10,670 --> 00:16:18,600
ಆದರೆ ನಾನು ಈಗ ನನ್ನ ಕನ್ಸೋಲ್ ತೆರವುಗೊಳಿಸಿ, ಮತ್ತು ನಾನು ವೇಳೆ
ಪರೀಕ್ಷೆಯ ಫಾರ್ ಬದಲಾಯಿಸಲು, ಮತ್ತು ಪರೀಕ್ಷೆಯ ನಾಲ್ಕು

317
00:16:18,600 --> 00:16:22,500
ನಾನು ಲೂಪ್ ಬಳಸಲು ಹೇಳುತ್ತಾರೆ
ಬದಲಿಗೆ ಮತ್ತು ಪ್ರಮುಖ ಮುದ್ರಿಸುತ್ತದೆ,

318
00:16:22,500 --> 00:16:28,079
ನಾನು ಕ್ಲಿಕ್ ಮಾಡಿದರೆ, ಈಗ ನಾನು ಮಾಡುವ ಬಾಗುತ್ತೇನೆ
ನನ್ನ ವಸ್ತುವಿನ ಒಳಗೆ ನೈಜ ಅಂಶಗಳನ್ನು

319
00:16:28,079 --> 00:16:29,120
ಅಥವಾ ಈ ಸಂದರ್ಭದಲ್ಲಿ ನನ್ನ ರಚನೆಯ.

320
00:16:29,120 --> 00:16:31,760
ವಾರ ದಿನಗಳ ನನ್ನ ರಚನೆಯ.

321
00:16:31,760 --> 00:16:33,480
ನಾನು ಸೋಮವಾರ ಮುದ್ರಣ
ಮಂಗಳವಾರ, ಬುಧವಾರ.

322
00:16:33,480 --> 00:16:36,930
ಆದ್ದರಿಂದ ವ್ಯತ್ಯಾಸವಾಗಿದೆ ನಡುವೆ ಇಲ್ಲಿದೆ
ಒಂದು ಫಾರ್ ಲೂಪ್ ರಲ್ಲಿ, ಇದು ಔಟ್ ಮುದ್ರಿಸುತ್ತದೆ

323
00:16:36,930 --> 00:16:43,410
ನೀವು ಪ್ರಮುಖ ಬಳಸುತ್ತಿದ್ದರೆ ಕೇವಲ ಕೀಲಿಗಳನ್ನು
ಲೂಪ್ ದೇಹದ ಒಳಗೆ,

324
00:16:43,410 --> 00:16:46,850
ಮತ್ತು ಲೂಪ್, ಇದು ಅಚ್ಚುಗಳ ಒಂದು
ಔಟ್ ಮೌಲ್ಯಗಳು ನೀವು ಬಳಸುತ್ತಿದ್ದರೆ

325
00:16:46,850 --> 00:16:48,870
ಲೂಪ್ ದೇಹದ ಒಳಗೆ ಪ್ರಮುಖ.

326
00:16:48,870 --> 00:16:52,380
>> ಸರಿ, ನಾವು ಈಗ ಆರಂಭಿಸಲು ಇಲ್ಲ
ತಂತಿಗಳನ್ನು concatenate ಮತ್ತು ಬಹುಶಃ ಮಿಶ್ರಣ

327
00:16:52,380 --> 00:16:57,220
ಪ್ರಕ್ಷೇಪಣ ಕೆಲವು ಅಸ್ಥಿರ
ಹಾಗೆ ನಾವು PHP ಮಾಡಲು ಸಾಧ್ಯವಾಯಿತು?

328
00:16:57,220 --> 00:16:59,410
ಸರಿ, ನಾವು ಬಹಳ ಚೆನ್ನಾಗಿ ಬಂದಿದೆ
ಪಿಎಚ್ಪಿ ಈ.

329
00:16:59,410 --> 00:17:04,109
ಈ ನಾವು ಬಳಸಿಕೊಂಡು ಅದನ್ನು ಹೇಗೆ ಆಗಿದೆ
ಡಾಟ್ ಆಯೋಜಕರು ತಂತಿಗಳನ್ನು concatenate ಗೆ.

330
00:17:04,109 --> 00:17:06,260
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್, ಆದರೂ,
ನಾವು ನಿಜವಾಗಿ ಏನಾದರೂ ಬಳಸಲು

331
00:17:06,260 --> 00:17:09,290
ಜೊತೆಗೆ ಆಯೋಜಕರು, ಎಂದು
ಬೇಕೆನ್ನಿಸಿದರೆ ಸ್ವಲ್ಪ ಹೆಚ್ಚು

332
00:17:09,290 --> 00:17:10,470
ಅರ್ಥಗರ್ಭಿತ, ಬಲ?

333
00:17:10,470 --> 00:17:12,609
ನಾವು ಒಂದು ಗುಂಪನ್ನು ಸೇರಿಸುವ ನೀವು
ತಂತಿಗಳ ಒಟ್ಟಿಗೆ.

334
00:17:12,609 --> 00:17:14,520
ಆದ್ದರಿಂದ ಮತ್ತೆ ಹೋಗಿ ಅವಕಾಶ
ಮೇಲೆ ಮತ್ತು ಈ ನೋಡಿ

335
00:17:14,520 --> 00:17:18,693
ನಾವು ಮುದ್ರಿಸುತ್ತದೆ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೆ ಮುದ್ರಿಸಿ
ವಾರ ಶ್ರೇಣಿಯಲ್ಲಿನ ಮಾಹಿತಿಯನ್ನು ಎಲ್ಲಾ.

336
00:17:18,693 --> 00:17:20,859
ಇಲ್ಲಿ ಅಡಿಯಲ್ಲಿ ಸರಿ, ಆದ್ದರಿಂದ
ತಂತುವಿನ ಪೋಣಿಸುವಿಕೆಯ ಅಡಿಯಲ್ಲಿ,

337
00:17:20,859 --> 00:17:24,822
ನಾನು ಎರಡು ಆಯ್ಕೆಗಳಿವೆ, ಸ್ಟ್ರಿಂಗ್ ಕಟ್ಟಡ
V1 ಹಾಗು ನಂತರ ಸ್ಟ್ರಿಂಗ್ ಕಟ್ಟಡ ವಿ 2.

338
00:17:24,822 --> 00:17:26,530
ಮತ್ತು ನಾವು ಏಕೆ ನೋಡುತ್ತೀರಿ
ಎರಡನೇ ವಿ 2 ಅಗತ್ಯವಿದೆ.

339
00:17:26,530 --> 00:17:28,610
ಆದರೆ ನಾನು ಹೇಳಲು ಮನುಷ್ಯ ಕ್ಲಿಕ್
ಸ್ಟ್ರಿಂಗ್ ಕಟ್ಟಡ, V1, ಇದು

340
00:17:28,610 --> 00:17:30,360
ನಾವು ಸಂಕೇತ
ಕೇವಲ ಒಂದು ನೋಟ ತೆಗೆದುಕೊಂಡು,

341
00:17:30,360 --> 00:17:32,980
ಪ್ಲಸಸ್ ಎಲ್ಲಾ console.log.

342
00:17:32,980 --> 00:17:35,910
ಈ ಮುದ್ರಿತ ವೇಳೆ ನೋಡೋಣ
ನಾವು ನಿರೀಕ್ಷಿಸಬಹುದು ಏನೆಂದು.

343
00:17:35,910 --> 00:17:39,939
>> ಸೋಮವಾರ, ವಾರದ ದಿನ ಸಂಖ್ಯೆ 01 ಆಗಿದೆ
ಮಂಗಳವಾರ ವಾರದ ದಿನದ ಸಂಖ್ಯೆಯು 11.

344
00:17:39,939 --> 00:17:41,730
ನಾನು ಏನು ಹಾಕಿದ್ದೆ
ಪಡೆಯಲು ಇತ್ತು ಮಾಡಲು

345
00:17:41,730 --> 00:17:46,280
ಇದು ಸೋಮವಾರ ದಿನ ಸಂಖ್ಯೆ ಮುದ್ರಿಸುತ್ತದೆ
ಒಂದು ಮಂಗಳವಾರ ದಿನ ಸಂಖ್ಯೆ ಎರಡು.

346
00:17:46,280 --> 00:17:50,140
ಆದರೆ ನಾನು ಹಾಗೆ ತೋರುತ್ತದೆ
ಯಾವಾಗಲೂ ಒಂದು ಮುದ್ರಿಸುವ.

347
00:17:50,140 --> 00:17:51,260
ಸರಿ, ಏಕೆ ಎಂದು?

348
00:17:51,260 --> 00:17:55,600
ಸರಿ, ಇದು ತಿರುಗಿದರೆ, ಇನ್ನೊಂದು ನೋಡೋಣ
ಇಲ್ಲಿ ಕೋಡ್ ಈ ಸಣ್ಣ ತುಣುಕನ್ನು.

349
00:17:55,600 --> 00:18:00,160
ನಾವು ಜೊತೆಗೆ ಬಳಸುತ್ತಿರುವ ಗಮನಿಸಿ
ಎರಡು ವಿವಿಧ ಸಂದರ್ಭಗಳಲ್ಲಿ ಆಯೋಜಕರು.

350
00:18:00,160 --> 00:18:03,221
>> ಮತ್ತು ಇಲ್ಲಿ ಅಲ್ಲಿ ಬಹುಶಃ ವಸ್ತುಗಳನ್ನು ಇಲ್ಲಿದೆ
ನಾವು ರೀತಿಯ ಹೇಳುವ ನಾವು ಆ,

351
00:18:03,221 --> 00:18:03,970
ಓಹ್, ಇದು ಬಹಳವೇ.

352
00:18:03,970 --> 00:18:05,910
ನಾವು ಎಂದಿಗೂ ಡೇಟಾ ಪ್ರಕಾರಗಳು ವ್ಯವಹರಿಸುವುದಿಲ್ಲ.

353
00:18:05,910 --> 00:18:08,220
ಆದರೆ ಇಲ್ಲಿ ಅಲ್ಲಿ ಸತ್ಯ
ನಾವು ಡೇಟಾ ಪ್ರಕಾರಗಳು ಕಳೆದುಕೊಳ್ಳುವ

354
00:18:08,220 --> 00:18:10,960
ವಾಸ್ತವವಾಗಿ ಸ್ವಲ್ಪ ಮಾಡಬಹುದು
ನಮಗೆ ಒಂದು ಸಮಸ್ಯೆಯ.

355
00:18:10,960 --> 00:18:16,260
ಈಗ ಜೊತೆಗೆ ಆಯೋಜಕರು ಬಳಸಲಾಗುತ್ತದೆ
ತಂತಿಗಳನ್ನು concatenate ಮತ್ತು ಸಂಖ್ಯೆಗಳನ್ನು ಸೇರಿಸಿ

356
00:18:16,260 --> 00:18:19,550
ಒಟ್ಟಿಗೆ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಹೊಂದಿರುವ
ತನ್ನ ಊಹೆ ಮಾಡಲು

357
00:18:19,550 --> 00:18:22,030
ಎಂದು ನಾನು ನನಗೆ ಮಾಡಲು ಯಾವ.

358
00:18:22,030 --> 00:18:23,900
ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ತಪ್ಪು ಊಹಿಸಿದ.

359
00:18:23,900 --> 00:18:29,340
ಇದು ಕೇವಲ ಪೋಣಿಸಿದ ದಿನ, ಅದು
0, ಒಂದು, ಎರಡು, ಮೂರು, ನಾಲ್ಕು, ಐದು, ಆರು,

360
00:18:29,340 --> 00:18:32,060
ಮತ್ತು ಅದು ಕೇವಲ ಪೋಣಿಸಿದ
ಆ ನಂತರ ಒಂದು ಪೋಣಿಸಿದ.

361
00:18:32,060 --> 00:18:35,020
ಇದು ವಾಸ್ತವವಾಗಿ ಅವುಗಳನ್ನು ಒಟ್ಟಿಗೆ ಸೇರಿಸಲು ಮಾಡಲಿಲ್ಲ.

362
00:18:35,020 --> 00:18:37,320
ಆದ್ದರಿಂದ ಈ ಭಾಷೆಗಳಲ್ಲಿ,
PHP ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್,

363
00:18:37,320 --> 00:18:39,196
ದೂರ ಅಮೂರ್ತವಾಗಿರುತ್ತವೆ
ರೀತಿಯ ಈ ಕಲ್ಪನೆಯನ್ನು

364
00:18:39,196 --> 00:18:40,820
ನೀವು ಇನ್ನು ಮುಂದೆ ಇದು ಎದುರಿಸಲು ಹೊಂದಿಲ್ಲ.

365
00:18:40,820 --> 00:18:43,600
ಅವರು ಇನ್ನೂ HOOD ಅಡಿಯಲ್ಲಿ ರೀತಿಯ ಹೊಂದಿರುತ್ತವೆ.

366
00:18:43,600 --> 00:18:46,780
ಮತ್ತು ನಾವು, ಮಾಡಬಹುದು ಸಂದರ್ಭಗಳಲ್ಲಿ
ಈ ರೀತಿಯ, ವಾಸ್ತವವಾಗಿ ಹತೋಟಿ

367
00:18:46,780 --> 00:18:49,240
ಏನೋ ಹೇಳುವ ಮೂಲಕ
ಬಹುಶಃ ಈ ರೀತಿಯ ಇದು

368
00:18:49,240 --> 00:18:53,210
ಮೂಲಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಹೇಳುತ್ತಿದೆ
ರೀತಿಯಲ್ಲಿ, ಒಂದು ಪೂರ್ಣಾಂಕ ಎಂದು ಪರಿಗಣಿಸುತ್ತದೆ,

369
00:18:53,210 --> 00:18:57,100
ಸಹ, ಸ್ಟ್ರಿಂಗ್ ಎಂದು ಚಿಕಿತ್ಸೆ ಇಲ್ಲ
ಆದರೂ ನಾವು ಒಟ್ಟಿಗೆ ತಂತಿಗಳನ್ನು ಮಿಶ್ರಣ ಇರುವ

370
00:18:57,100 --> 00:18:58,940
ಇಲ್ಲಿ ಮತ್ತು ಪೂರ್ಣಾಂಕಗಳ.

371
00:18:58,940 --> 00:19:02,204
>> ಇದು ಆ ವಸ್ತುಗಳ ಒಂದು
ಇದು ಸಂದರ್ಭಕ್ಕೆ ಬಹಳವೇ ತೋರುತ್ತದೆ

372
00:19:02,204 --> 00:19:04,120
ನಾವು ಹೊಂದಿಲ್ಲ ಎಂದು
ಇನ್ನು ಮುಂದೆ ರೀತಿಯ ಎದುರಿಸಲು,

373
00:19:04,120 --> 00:19:05,828
ಆದರೆ ಕೆಲವೊಮ್ಮೆ ನೀವು ಮಾಡುತ್ತೇವೆ
ಪರಿಸ್ಥಿತಿ ಎದುರಾದವು

374
00:19:05,828 --> 00:19:09,110
ಈ ರೀತಿ ನಿಖರವಾಗಿ ಅಲ್ಲಿ ವಾಸ್ತವವಾಗಿ
ನೀವು ರೀತಿಯ ನಿಯಂತ್ರಣ ಹೊಂದಿಲ್ಲ

375
00:19:09,110 --> 00:19:11,220
ನೀವು ಉಂಟುಮಾಡಬಹುದು
ನೀವು ಎಚ್ಚರಿಕೆಯಿಂದ ಇಲ್ಲದಿದ್ದರೆ.

376
00:19:11,220 --> 00:19:18,285
ನಾವು ಐಡಿಇ ಮೇಲೆ ಪಾಪ್ ಮತ್ತು ಆದ್ದರಿಂದ, ನಾನು
ಮತ್ತೆ ನನ್ನ ಕನ್ಸೋಲ್ ತೆರವುಗೊಳಿಸಿ ಹೋಗುವ,

377
00:19:18,285 --> 00:19:20,660
ಮತ್ತು ನಾನು ಸ್ಟ್ರಿಂಗ್ ಕ್ಲಿಕ್ ಪಡೆಯಲಿದ್ದೇನೆ
ಕಟ್ಟಡ ಆವೃತ್ತಿ ಎರಡು, ಇದು

378
00:19:20,660 --> 00:19:23,052
ನಾನು ಪಾರ್ಸ್ ಇಂಟ್ ಕಾರ್ಯವನ್ನು ಉಪಯೋಗಿಸಬಹುದು ಅಲ್ಲಿ ಆಗಿದೆ.

379
00:19:23,052 --> 00:19:25,260
ಈಗ ಅದನ್ನು ಮುದ್ರಿಸುವ ವಿಶೇಷವೇನು
ನಾನು ನಿರೀಕ್ಷಿಸುವುದಾಗಿ ನಾನು ಮಾಹಿತಿ.

380
00:19:25,260 --> 00:19:29,330
ಸೋಮವಾರ ದಿನ ಒಂದನೇ ಮಂಗಳವಾರ
ಹೀಗೆ ದಿನ ಸಂಖ್ಯೆ ಎರಡು, ಮತ್ತು ಇದೆ.

381
00:19:29,330 --> 00:19:31,170
>> ಇದರಿಂದ ಮತ್ತೆ ಕಾರ್ಯಗಳನ್ನು ಬಗ್ಗೆ ಮಾತನಾಡೋಣ.

382
00:19:31,170 --> 00:19:34,790
ನಾವು ಅನಾಮಧೇಯ ಬಗ್ಗೆ ಮಾತನಾಡಲು ಭರವಸೆ
ಕಾರ್ಯಗಳನ್ನು, ಮತ್ತು ಈಗ ಸಂದರ್ಭವನ್ನು

383
00:19:34,790 --> 00:19:36,360
ಅಂತಿಮವಾಗಿ ಬಂದ.

384
00:19:36,360 --> 00:19:39,980
ನಾವು ಹಾಗೆ ಮೊದಲು ಆದ್ದರಿಂದ, ಮತ್ತೆ ಮಾತನಾಡೋಣ
ಎರಡನೇ ಸಾಲುಗಳು ಬಗ್ಗೆ.

385
00:19:39,980 --> 00:19:42,120
ಆದ್ದರಿಂದ ಸರಣಿಗಳ ಒಂದು ವಿಶೇಷವಾಗಿದೆ
ಒಂದು ವಸ್ತುವಿನ ಸಂದರ್ಭದಲ್ಲಿ.

386
00:19:42,120 --> 00:19:45,180
ವಾಸ್ತವವಾಗಿ, ಎಲ್ಲವೂ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಾಸ್ತವವಾಗಿ ವಸ್ತು.

387
00:19:45,180 --> 00:19:47,190
ಆದ್ದರಿಂದ ಕ್ರಿಯೆಗಳು ಒಂದು
ಒಂದು ವಸ್ತುವಿನ ವಿಶೇಷ ಸಂದರ್ಭದಲ್ಲಿ,

388
00:19:47,190 --> 00:19:49,770
ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ವಿಶೇಷವಾಗಿದೆ
ಒಂದು ವಸ್ತುವಿನ ಸಂದರ್ಭದಲ್ಲಿ,

389
00:19:49,770 --> 00:19:52,152
ಆದರೆ ಸರಣಿಗಳ ನಿರ್ದಿಷ್ಟವಾಗಿ
ವಿಧಾನಗಳು ಹೊಂದಿದ್ದೇವೆ.

390
00:19:52,152 --> 00:19:55,110
ಅವರು ವಸ್ತುಗಳನ್ನು ಏಕೆಂದರೆ ನೆನಪಿಡಿ,
ಅವರು ಗುಣಗಳನ್ನು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಹೊಂದಿರಬಹುದು.

391
00:19:55,110 --> 00:19:58,600
ಅವರು ಅನೇಕ ವಿಧಾನಗಳಿಂದ ಹೊಂದಿರುವ
ಆ ವಸ್ತುಗಳನ್ನು ಅನ್ವಯಿಸಬಹುದು.

392
00:19:58,600 --> 00:20:01,197
ಎಂಬ ಕ್ರಮವಿದೆ
ಗಾತ್ರ, array.size,

393
00:20:01,197 --> 00:20:03,030
ಇದು ಹಿಂದಿರುಗುವ
ನೀವು ಅಪೇಕ್ಷಿಸಬಹುದು ಮಾಹಿತಿ

394
00:20:03,030 --> 00:20:05,120
ನಿಮ್ಮ ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ.

395
00:20:05,120 --> 00:20:08,480
array.pop, ರೀತಿಯಾಗಿ
ಆಫ್ ಉಂಟಾಗುತ್ತದೆ ನಮ್ಮ ಕಲ್ಪನೆ

396
00:20:08,480 --> 00:20:11,110
ಒಂದು ಸ್ಟಾಕ್, ನೀವು ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ ವೇಳೆ
ನಮ್ಮ ರಾಶಿಯನ್ನು ವೀಡಿಯೊ,

397
00:20:11,110 --> 00:20:13,810
ಸರಣಿ ಕೊನೆಯ ಅಂಶ ತೆಗೆದುಹಾಕುತ್ತದೆ.

398
00:20:13,810 --> 00:20:17,110
array.push ಒಂದು ಹೊಸ ಅಂಶವನ್ನು
ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಕೊನೆಯಲ್ಲಿ.

399
00:20:17,110 --> 00:20:20,910
array.shift ರೀತಿಯ ಆಗಿದೆ
DQ ಇದೂ ಔಟ್ ಜೋಡಣೆಗಳನ್ನು

400
00:20:20,910 --> 00:20:23,610
ವ್ಯೂಹದ ಮೊಟ್ಟಮೊದಲ ಅಂಶ.

401
00:20:23,610 --> 00:20:27,549
>> ಆದರೆ ಮತ್ತೊಂದು ವಿಶೇಷ ಇಲ್ಲ
ವ್ಯೂಹದ ವಿಧಾನ ನಕ್ಷೆ ಎಂದು.

402
00:20:27,549 --> 00:20:29,340
ಮತ್ತು ಈ ತೆರನಾದ
ಕುತೂಹಲಕಾರಿ ಪರಿಕಲ್ಪನೆ.

403
00:20:29,340 --> 00:20:30,930
ಆದ್ದರಿಂದ ಒಂದು ನಕ್ಷೆ ಕಲ್ಪನೆಯನ್ನು ಏನು?

404
00:20:30,930 --> 00:20:33,880
ನೀವು ನಿಜವಾಗಿಯೂ ಈ ನೋಡುತ್ತಾರೆ
ಅನೇಕ ವಿವಿಧ ಭಾಷೆಗಳಲ್ಲಿ,

405
00:20:33,880 --> 00:20:38,550
ಮತ್ತು ನಾವು ಒಂದು ಬಗ್ಗೆ ಇಲ್ಲ
cartographers ರೀತಿಯ, ಇಲ್ಲಿ ನಕ್ಷೆ

406
00:20:38,550 --> 00:20:41,480
ನಾವು ಒಂದು ಮ್ಯಾಪಿಂಗ್ ಕಾರ್ಯ ಬಗ್ಗೆ ನೀವು.

407
00:20:41,480 --> 00:20:44,110
ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಆರ್
ಇಲ್ಲಿ ಬಗ್ಗೆ, ಒಂದು ನಕ್ಷೆ

408
00:20:44,110 --> 00:20:47,950
ವಿಶೇಷ ಕಾರ್ಯಾಚರಣೆ ನಾವು ಆಗಿದೆ
ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮಾಡಬಹುದು

409
00:20:47,950 --> 00:20:51,630
ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಕ್ಕಾಗಿ ಅರ್ಜಿ
ರಚನೆಯ ಪ್ರತಿ ಅಂಶ.

410
00:20:51,630 --> 00:20:55,190
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಹೇಳುತ್ತಿದ್ದರು
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಬಹುಶಃ, array.map

411
00:20:55,190 --> 00:21:00,330
ಮತ್ತು ಇದು ಒಳಗೆ, ನಾವು ಹಾದುಹೋಗುವ ನೀವು
ನಕ್ಷೆಯಲ್ಲಿ ನಾವು ಬಯಸುವ ಕ್ರಿಯೆಯಾಗಿದೆ

412
00:21:00,330 --> 00:21:02,430
ಪ್ರತಿಯೊಂದು ಅಂಶ ಅನ್ವಯಿಸಬಹುದು.

413
00:21:02,430 --> 00:21:07,299
ಆದ್ದರಿಂದ ಅದನ್ನು ಬಳಸಿ ರೀತಿಯ ಹೋಲುತ್ತದೆ ಇಲ್ಲಿದೆ
ಲೂಪ್ ಪ್ರತಿ ಅಂಶ ಮೇಲೆ ಮರಳಿ

414
00:21:07,299 --> 00:21:09,340
ಮತ್ತು ಒಂದು ನಿರ್ದಿಷ್ಟ ಅರ್ಜಿ
ಪ್ರತಿ ಅಂಶ ಕಾರ್ಯ,

415
00:21:09,340 --> 00:21:14,830
ಕೇವಲ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಈ ನಿರ್ಮಿಸಿದೆ
ಅನ್ವಯಿಸಬಹುದು ಎಂದು ಮ್ಯಾಪಿಂಗ್ ಕಲ್ಪನೆ.

416
00:21:14,830 --> 00:21:19,700
ಮತ್ತು ಈ ಒಂದು ದೊಡ್ಡ ಸನ್ನಿವೇಶವೂ
ಅನಾಮಿಕ ಕಾರ್ಯ ಬಗ್ಗೆ ಮಾತನಾಡಲು.

417
00:21:19,700 --> 00:21:22,370
>> ಆದ್ದರಿಂದ ನಾವು ಹೇಳುತ್ತಾರೆ
ಪೂರ್ಣಾಂಕಗಳ ಈ ಶ್ರೇಣಿಯಲ್ಲಿನ.

418
00:21:22,370 --> 00:21:25,370
ಇದು nums ಕರೆಯಲಾಗುತ್ತದೆ, ಮತ್ತು ಇದು ಐದು ಅವರಲ್ಲಿದೆ
ಇದು ವಿಷಯಗಳನ್ನು, ಒಂದು, ಎರಡು, ಮೂರು, ನಾಲ್ಕು,

419
00:21:25,370 --> 00:21:26,410
ಐದು.

420
00:21:26,410 --> 00:21:30,620
ಈಗ ನಾನು ಕೆಲವು ನಕ್ಷೆ ಬಯಸುವ
ಈ ರಚನೆಯ ಮೇಲೆ ಕಾರ್ಯ.

421
00:21:30,620 --> 00:21:34,337
ನಾನು ಕಾರ್ಯ ಅರ್ಜಿ ಬೇಕು
ರಚನೆಯ ಪ್ರತಿ ಅಂಶ.

422
00:21:34,337 --> 00:21:37,420
ಅಲ್ಲದೆ, ನಾನು ಯಾವ ಎಂದು ತಿಳಿಸಿ
ಕೇವಲ ಅಂಶಗಳನ್ನು ಎಲ್ಲಾ ಡಬಲ್ ಆಗಿದೆ.

423
00:21:37,420 --> 00:21:42,520
ನಾನು ಕೇವಲ ಒಂದು ಲೂಪ್ ಅನ್ನು ಹೊಂದಿದೆ ಏನು
ವರ್ ನಾನು 0 ಸಮನಾಗಿರುತ್ತದೆ, ನಾನು ಕಡಿಮೆ

424
00:21:42,520 --> 00:21:47,390
ಅಥವಾ ಸಮಾನ 4, ನಾನು ಜೊತೆಗೆ, ಜೊತೆಗೆ, ಮತ್ತು
ನಂತರ ಪ್ರತಿಯೊಂದು ಸಂಖ್ಯೆ ದ್ವಿಗುಣವಾಗುತ್ತಿತ್ತು.

425
00:21:47,390 --> 00:21:49,580
ಆದರೆ ನಾನು ಈ ರೀತಿಯ ಮಾಡಬಹುದು.

426
00:21:49,580 --> 00:21:53,420
ನಾನು nums ಹಿಂದೆ ಹೇಳಬಹುದು
ಒಂದು ಎರಡು ಮೂರು ನಾಲ್ಕು ಐದು,

427
00:21:53,420 --> 00:21:58,310
ಈಗ, ಆದರೂ, ನಾನು ನೀವು ಬಯಸುತ್ತೀರಿ
ಈ ಸರಣಿಗಳ ಮೇಲೆ ಮ್ಯಾಪಿಂಗ್ ಅರ್ಜಿ

428
00:21:58,310 --> 00:22:00,400
ನಾನು ಬಯಸುತ್ತೇನೆ ಅಲ್ಲಿ
ಪ್ರತಿ ಸಂಖ್ಯೆ ದ್ವಿಗುಣವಾಗುತ್ತಿತ್ತು.

429
00:22:00,400 --> 00:22:02,540
ಮತ್ತು ನಿಖರವಾಗಿ
ಇಲ್ಲಿ ನಡೆಯುತ್ತಿದೆ.

430
00:22:02,540 --> 00:22:06,870
ಆದರೆ ನಾನು ಹಾದುಹೋಗುವ ನಾನು ಏನು ಗಮನಿಸುವುದಿಲ್ಲ
ವಾದ ನಕ್ಷೆ ಪ್ರಮಾಣವಚನ.

431
00:22:06,870 --> 00:22:09,080
ಈ ಅನಾಮಿಕ ಕ್ರಿಯೆಯಾಗಿದೆ.

432
00:22:09,080 --> 00:22:11,140
ನಾನು ನೀಡಿದ ಮಾಡಿಲ್ಲ ಗಮನಕ್ಕೆ
ಈ ಕಾರ್ಯವನ್ನು ಹೆಸರನ್ನು,

433
00:22:11,140 --> 00:22:13,290
ನಾನು ಮಾತ್ರ ಒಂದು ನಿಯತಾಂಕ ಪಟ್ಟಿ ನೀಡಿದ್ದೇನೆ.

434
00:22:13,290 --> 00:22:16,370
ಆದ್ದರಿಂದ ಈ ಒಂದು ಉದಾಹರಣೆ
ಅನಾಮಿಕ ಕ್ರಿಯೆಯ.

435
00:22:16,370 --> 00:22:21,270
>> ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಈ ಕರೆ ಎಂದಿಗೂ
ಮ್ಯಾಪ್ ವಿಷಯದ ಹೊರಗಡೆ ಕಾರ್ಯ.

436
00:22:21,270 --> 00:22:24,110
ನಾವು ಒಂದು ನಿಯತಾಂಕ ಎಂದು ವಿವರಿಸುವ ನೀವು
ನಕ್ಷೆ, ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ನಿಜವಾಗಿಯೂ ಮಾಡಲು

437
00:22:24,110 --> 00:22:27,910
ವೇಳೆ ಇದು ಒಂದು ಹೆಸರನ್ನು ಮಾಡಬೇಕು
ಕಾಳಜಿ ಮಾತ್ರ ವಿಷಯ ನಕ್ಷೆ

438
00:22:27,910 --> 00:22:30,339
ಅದು ಸರಿಯಾದ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ
ಅಲ್ಲಿ ನಕ್ಷೆ ಒಳಗೆ.

439
00:22:30,339 --> 00:22:31,880
ಆದ್ದರಿಂದ ಈ ಅನಾಮಿಕ ಕ್ರಿಯೆಯಾಗಿದೆ.

440
00:22:31,880 --> 00:22:34,680
ನಾವು ಸಾಧ್ಯವಾಗಿಲ್ಲ
ಹಿಂದೆ ಇದನ್ನು.

441
00:22:34,680 --> 00:22:38,400
ಕೆಲವು ಕಾರ್ಯ ಮ್ಯಾಪ್
, ಸಂ, ಒಂದು ನಿಯತಾಂಕ ಸ್ವೀಕರಿಸುತ್ತದೆ

442
00:22:38,400 --> 00:22:41,890
ಮತ್ತು ಕಾರ್ಯ ಮಾಡುತ್ತಾರೆ
ಆದಾಯ ಬಾರಿ 2 NUM ಇದೆ.

443
00:22:41,890 --> 00:22:45,330
ಆದ್ದರಿಂದ ಈ ನಂತರ
ಮ್ಯಾಪಿಂಗ್ ಅನ್ವಯಿಸಲಾಯಿತು,

444
00:22:45,330 --> 00:22:50,090
ಈ ಈಗ nums ನೋಟ
ಹಾಗೆ, ಎರಡು, ನಾಲ್ಕು, ಆರು, ಎಂಟು, 10.

445
00:22:50,090 --> 00:22:52,090
ಮತ್ತು ನಾವು ಮೇಲೆ ಪಾಪ್ ವಿಲ್ ನನ್ನ
ಬ್ರೌಸರ್ ವಿಂಡೋವನ್ನು ಮತ್ತು ಕೇವಲ

446
00:22:52,090 --> 00:22:55,240
ಈ ನೋಡೋಣ
ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿ ಹಾಗೂ.

447
00:22:55,240 --> 00:22:58,000
>> ಹಾಗಾಗಿ ಇಲ್ಲಿ ಮತ್ತೊಂದು ಬಟನ್
ನನ್ನ ಮುಖಪುಟದಲ್ಲಿ ಎರಡು ಕರೆಯಲಾಗುತ್ತದೆ.

448
00:22:58,000 --> 00:23:03,570
ನಾನು ಡಬಲ್ ಕ್ಲಿಕ್ ಮಾಡಿ, ಮತ್ತು ಇದು ಹೇಳುತ್ತದೆ
ನನಗೆ ಇದು ಒಂದು ಮೊದಲು, ಎರಡು, ಮೂರು, ನಾಲ್ಕು,

449
00:23:03,570 --> 00:23:07,250
ಐದು ಎರಡು, ನಾಲ್ಕು, ಆರು, ಎಂಟು, 10 ನಂತರ.

450
00:23:07,250 --> 00:23:11,930
ಮತ್ತು ನಾನು ಮತ್ತೆ ಹೋಗಿ ವೇಳೆ ಡಬಲ್ ಕ್ಲಿಕ್
ಮತ್ತೆ, ಎರಡು, ನಾಲ್ಕು, ಆರು, ಎಂಟು, 10.

451
00:23:11,930 --> 00:23:17,400
ತದನಂತರ ನಂತರ, ನಾಲ್ಕು,
ಎಂಟು, 12, 16, ಮತ್ತು ನಂತರ 20.

452
00:23:17,400 --> 00:23:20,440
ಮತ್ತು ನಾನು ಈ ಕಾರ್ಯದಲ್ಲಿ ಏನು ನಾನು?

453
00:23:20,440 --> 00:23:25,210
ವೆಲ್, ನಾವು ಐಡಿಇ ಗೆ ಪಾಪ್, ಮತ್ತು ವೇಳೆ
ನಾನು ಇಲ್ಲಿ, ನನ್ನ ಅನಾಮಿಕ ಕಾರ್ಯ ಮೇಲೆಳೆದುಕೊಳ್ಳಲು

454
00:23:25,210 --> 00:23:28,780
13 ಮೂಲಕ ಲೈನ್ ಏಳು, ನಾನು
ಇಲ್ಲಿ ಸ್ವಲ್ಪ ಅಲಂಕಾರಿಕ ಕೆಲಸ,

455
00:23:28,780 --> 00:23:32,240
ಆದರೆ ನಾನು ಔಟ್ ಮುದ್ರಿಸುವ ನಾನು
ಏನು ಶ್ರೇಣಿಯಲ್ಲಿನ ಪ್ರಸ್ತುತ.

456
00:23:32,240 --> 00:23:36,580
ನಂತರ ಸಾಲಿನ 16, 17 ರಂದು,
ಮತ್ತು 18, ನನ್ನ ನಕ್ಷೆ ಇಲ್ಲ.

457
00:23:36,580 --> 00:23:40,930
ನಾನು ಈ ದ್ವಿಗುಣಗೊಳಿಸುವ ಅನ್ವಯಿಸುವ ಬಾಗುತ್ತೇನೆ ಅಲ್ಲಿ ಇದು
ಪ್ರತಿಯೊಂದು ಅಂಶ ಕಾರ್ಯ.

458
00:23:40,930 --> 00:23:43,530
ತದನಂತರ ಮತ್ತಷ್ಟು ಕೆಳಗೆ ಸ್ವಲ್ಪ,
ನಾನು ಒಂದೇ ಮಾಡುತ್ತಿರುವೆ

459
00:23:43,530 --> 00:23:46,640
ನಾನು ಈಗ ನಾನು ಹೊರತುಪಡಿಸಿ, ಮೊದಲು ಮಾಡುತ್ತಿದ್ದ
ರಚನೆಯ ವಿಷಯಗಳನ್ನು ಔಟ್ ಮುದ್ರಣ

460
00:23:46,640 --> 00:23:48,167
ನಂತರ.

461
00:23:48,167 --> 00:23:50,500
ಆದರೆ ನಾನು ಇಲ್ಲಿ ಮಾಡಿದ ಎಲ್ಲಾ
ಕೇವಲ ಅನಾಮಿಕ ಕಾರ್ಯ ಬಳಸಲು

462
00:23:50,500 --> 00:23:53,640
ಇಡೀ ರಚನೆಯ ಸುತ್ತಲೂ ನಕ್ಷೆ.

463
00:23:53,640 --> 00:23:58,466
>> ಆದ್ದರಿಂದ ಒಂದು ದೊಡ್ಡ ವಿಷಯ ಬಗ್ಗೆ ಮಾತನಾಡಲು
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕ್ರಿಯೆಯನ್ನು ವಿಚಾರವಾಗಿದೆ.

464
00:23:58,466 --> 00:24:01,590
ಕ್ರಿಯೆಯನ್ನು ಕೇವಲ ನಡೆಯುತ್ತದೆ
ಒಂದು ಬಳಕೆದಾರ ನಿಮ್ಮ ವೆಬ್ ಪರಸ್ಪರ ವರ್ತಿಸಿದಾಗ

465
00:24:01,590 --> 00:24:04,715
ಪುಟ, ಆದ್ದರಿಂದ ಬಹುಶಃ ಅವರು ಏನೋ ಕ್ಲಿಕ್
ಅಥವಾ ಬಹುಶಃ ಪುಟ ಲೋಡ್ ಮುಗಿದ

466
00:24:04,715 --> 00:24:07,200
ಅಥವಾ ಬಹುಶಃ ಅವರು ಹೋದರು ಬಂದಿದೆ
ಏನೋ ಅವರ ಮೌಸ್,

467
00:24:07,200 --> 00:24:09,290
ಅಥವಾ ಅವರು ಏನೋ ಟೈಪ್ ಮಾಡಿದ
ಇನ್ಪುಟ್ ಕ್ಷೇತ್ರದಲ್ಲಿ.

468
00:24:09,290 --> 00:24:14,260
ಈ ಎಲ್ಲ ವಿಷಯಗಳ ಘಟನೆಗಳು
ನಮ್ಮ ವೆಬ್ ಪುಟದಲ್ಲಿ ನಡೆಯುತ್ತಿವೆ.

469
00:24:14,260 --> 00:24:17,460
ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಹೊಂದಿರುವ
ಸಾಮರ್ಥ್ಯವನ್ನು ಏನೋ ಬೆಂಬಲಿಸಲು

470
00:24:17,460 --> 00:24:21,760
ಕ್ರಿಯೆಯನ್ನು ಹ್ಯಾಂಡ್ಲರ್, ಎಂದು
ಒಂದು ಕಾಲ್ಬ್ಯಾಕ್ ಕಾರ್ಯ ಎಂದು

471
00:24:21,760 --> 00:24:23,329
ಒಂದು HTML ಘಟನೆಗೆ ಪ್ರತಿಕ್ರಿಯೆ.

472
00:24:23,329 --> 00:24:24,620
ಮತ್ತು ಕಾಲ್ಬ್ಯಾಕ್ ಇಲ್ಲಿದೆ?

473
00:24:24,620 --> 00:24:27,328
ಅಲ್ಲದೆ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಮತ್ತೊಂದು ಇಲ್ಲಿದೆ
ಅನಾಮಿಕ ಕಾರ್ಯ ಹೆಸರು.

474
00:24:27,328 --> 00:24:30,170
ಇದು ಒಂದು ಕಾರ್ಯ ಎಂದು
ಒಂದು ಘಟನೆಗೆ ಪ್ರತಿಕ್ರಿಯೆ.

475
00:24:30,170 --> 00:24:34,130
ನಾವು ಬಂದು ಅಲ್ಲಿ ಮತ್ತು ಇದು
ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಗಳನ್ನು ಬಂಧಿಸುವ ಕಲ್ಪನೆಯನ್ನು

476
00:24:34,130 --> 00:24:38,060
ನಿರ್ದಿಷ್ಟ HTML ಲಕ್ಷಣದ ಗೆ.

477
00:24:38,060 --> 00:24:41,420
ಅತ್ಯಂತ HTML ಅಂಶಗಳನ್ನು ಹೊಂದಿವೆ
ಒಂದು ಗುಣಲಕ್ಷಣ ಬೆಂಬಲ

478
00:24:41,420 --> 00:24:45,170
ನಾವು HTML ನಲ್ಲಿ ಬಗ್ಗೆ ಮಾತನಾಡಲಿಲ್ಲ ಎಂದು
ಕ್ಲಿಕ್ ರೀತಿಯ ವಿಡಿಯೋ

479
00:24:45,170 --> 00:24:50,540
ಅಥವಾ ಹೂವರ್ ಅಥವಾ ಲೋಡ್,
ಈ ಘಟನೆಗಳ ಎಲ್ಲಾ

480
00:24:50,540 --> 00:24:53,120
ನೀವು ಕಾರ್ಯಗಳನ್ನು ಬರೆಯಬಹುದು
ಆ ಘಟನೆಗಳು ಒಪ್ಪಂದ

481
00:24:53,120 --> 00:24:56,090
ಆ ಘಟನೆಗಳು
ನಿಮ್ಮ ವೆಬ್ ಪುಟದಲ್ಲಿ ಸಂಭವಿಸುತ್ತವೆ.

482
00:24:56,090 --> 00:24:59,170
>> ಆದ್ದರಿಂದ ಬಹುಶಃ ನಿಮ್ಮ HTML
ಈ ರೀತಿಯಲ್ಲಿ ಕಾಣುತ್ತದೆ.

483
00:24:59,170 --> 00:25:02,240
ಮತ್ತು ನಾನು ಇಲ್ಲಿ ಎರಡು ಗುಂಡಿಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ,
ಬಟನ್ ಮತ್ತು ಬಟನ್ ಎರಡು,

484
00:25:02,240 --> 00:25:04,620
ಮತ್ತು ಇಲ್ಲಿ ನಾನು ಪ್ರಸ್ತುತ
ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಏನೂ,

485
00:25:04,620 --> 00:25:11,170
ಆದರೆ ಈ ಅಲ್ಲಿ ಆಟ್ರಿಬ್ಯೂಟ್ನಲ್ಲಿ
ಕ್ಲಿಕ್ ಸ್ಪಷ್ಟವಾಗಿ ನನ್ನ HTML ಟ್ಯಾಗ್ ಭಾಗವಾಗಿದೆ.

486
00:25:11,170 --> 00:25:15,220
ಆದ್ದರಿಂದ ಸ್ಪಷ್ಟವಾಗಿ ನಾನು ಎಂಬುದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಮಾಡಿದಾಗ
ಗುಣಲಕ್ಷಣ ಒಳಗೆ ಇಂದಿನ,

487
00:25:15,220 --> 00:25:18,590
ಇದು ಕೆಲವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಎಂದು ವಿಶೇಷವೇನು
ಘಟನೆಗೆ ಪ್ರತಿಕ್ರಿಯೆ ಕಾರ್ಯ

488
00:25:18,590 --> 00:25:24,360
ಬಹುಶಃ ಕ್ಲಿಕ್ಕಿಸಿ ಆಫ್
ಬಟನ್ ಒಂದು ಅಥವಾ ಬಟನ್ ಎರಡು.

489
00:25:24,360 --> 00:25:28,580
>> ಯಾವ ರೀತಿಯ ತಂಪಾದ ಈ ನಾವು ಆಗಿದೆ ಬಗ್ಗೆ
ಒಂದು ವಿಶಿಷ್ಟ ಕ್ರಿಯೆಯನ್ನು ಹ್ಯಾಂಡ್ಲರ್ ಬರೆಯಬಹುದು.

490
00:25:28,580 --> 00:25:32,370
ಮತ್ತು ಈ ಕ್ರಿಯೆಯನ್ನು ಹ್ಯಾಂಡ್ಲರ್ ತಿನ್ನುವೆ
ಕ್ರಿಯೆಯನ್ನು ವಸ್ತು ರಚಿಸಲು.

491
00:25:32,370 --> 00:25:37,000
ಮತ್ತು ಈವೆಂಟ್ ವಸ್ತು ನಮಗೆ ಕಾಣಿಸುತ್ತದೆ
ಎರಡು ಗುಂಡಿಗಳನ್ನು ಯಾವ ಕ್ಲಿಕ್.

492
00:25:37,000 --> 00:25:38,064
ಈಗ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ?

493
00:25:38,064 --> 00:25:39,730
ಅಲ್ಲದೆ, ಇದು ಈ ರೀತಿಯ ನೋಡಲು ಇರಬಹುದು.

494
00:25:39,730 --> 00:25:44,860
ನಾವು ಮೊದಲ ನಮ್ಮ ಗುಂಡಿಗಳು ನಿರೂಪಿಸುತ್ತದೆ
ಕಾಲ್ಬ್ಯಾಕ್ ಒಂದು ಪ್ರತಿಕ್ರಿಯೆ

495
00:25:44,860 --> 00:25:47,470
ಎಂದು ಎಂದು ಕಾರ್ಯ
ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ,

496
00:25:47,470 --> 00:25:49,520
ನಾವು ಕ್ರಿಯೆಯನ್ನು ಎಚ್ಚರಿಕೆಯನ್ನು ಹೆಸರು ಕರೆ ಮಾಡುತ್ತೇವೆ.

497
00:25:49,520 --> 00:25:53,320
ನಾವು ಆರ್ ಎರಡೂ ಸಂದರ್ಭಗಳಲ್ಲಿ ಗಮನಕ್ಕೆ
ಈ ಈವೆಂಟ್ ನಿಯತಾಂಕ ಹಾದುಹೋಗುವ.

498
00:25:53,320 --> 00:25:55,460
ಆದ್ದರಿಂದ ನಾವು ಈ ಕಾರ್ಯ ಕರೆ
ಅಥವಾ ಈ ಕಾರ್ಯ

499
00:25:55,460 --> 00:26:00,330
ನಡೆಯುತ್ತಿದೆ ಕ್ರಿಯೆಯನ್ನು ಪ್ರಚೋದಿಸಲ್ಪಡುತ್ತದೆ,
ಇದು ಈ ಈವೆಂಟ್ ವಸ್ತು ರಚಿಸಲು ವಿಶೇಷವೇನು

500
00:26:00,330 --> 00:26:03,300
ಮತ್ತು ಸರಿಸುತ್ತದೆ
ನಿಯತಾಂಕ ಹೆಸರು ಎಚ್ಚರಿಸಲು.

501
00:26:03,300 --> 00:26:07,270
ಮತ್ತು ಆ ಸಂದರ್ಭದಲ್ಲಿ ವಸ್ತು
ಮಾಹಿತಿಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ ಹೋಗುವ

502
00:26:07,270 --> 00:26:09,800
ಇದು ಸುಮಾರು ಬಟನ್ ಕ್ಲಿಕ್.

503
00:26:09,800 --> 00:26:11,580
ಮತ್ತು ಹೇಗೆ ಮಾಡುತ್ತದೆ?

504
00:26:11,580 --> 00:26:13,654
ಅಲ್ಲದೆ, ಇದು ಈ ರೀತಿಯ ನೋಡಲು ಇರಬಹುದು.

505
00:26:13,654 --> 00:26:15,570
ಈಗ ನನ್ನ ಪ್ರತ್ಯೇಕ ರಲ್ಲಿ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಡತ, ನಾನು ಬಹುಶಃ

506
00:26:15,570 --> 00:26:17,420
ಈ ಕಂಡುಹಿಡಿಯಬೇಕಿದೆ
ಕಾರ್ಯ ಎಚ್ಚರಿಕೆಯನ್ನು ಹೆಸರು, ಇದು

507
00:26:17,420 --> 00:26:19,500
ಮತ್ತೆ ಆ ಸಂದರ್ಭದಲ್ಲಿ ನಿಯತಾಂಕ ಸ್ವೀಕರಿಸುತ್ತದೆ.

508
00:26:19,500 --> 00:26:24,640
ನಾನು ಪತ್ತೆ ಬಾಗುತ್ತೇನೆ ಅಲ್ಲಿ ತದನಂತರ ಇಲ್ಲಿ
ಇದು ಬಟನ್ ಹತ್ತಿಕೊಂಡಿತು,

509
00:26:24,640 --> 00:26:28,100
ವರ್ ಪ್ರಚೋದಕ ಕ್ರಿಯೆಯನ್ನು ಸಮನಾಗಿರುತ್ತದೆ
ಡಾಟ್ ಮೂಲ ಅಂಶ.

510
00:26:28,100 --> 00:26:33,150
ರಚಿಸಿದ ಮೂಲ ಏನು
ಸೈನ್ ರವಾನಿಸಲಾಗಿದೆ ಎಂದು ಈ ಈವೆಂಟ್ ವಸ್ತು?

511
00:26:33,150 --> 00:26:36,390
ಇದು ಬಟನ್ ಒಂದು ಅಥವಾ ಬಟನ್ ಎರಡು?

512
00:26:36,390 --> 00:26:40,710
>> ತದನಂತರ ಇಲ್ಲಿ ನಾನು ಮಾಡುತ್ತಿರುವೆ ಎಲ್ಲಾ
trigger.innerhtml ಮುದ್ರಿಸುವ.

513
00:26:40,710 --> 00:26:43,860
ಅಲ್ಲದೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ
ಸಂದರ್ಭವನ್ನು, trigger.innerhtml

514
00:26:43,860 --> 00:26:45,940
ಬಟನ್ ಮೇಲೆ ಬರೆಯಲಾಗಿದೆ ಕೇವಲ ಏನು.

515
00:26:45,940 --> 00:26:48,830
ನಾವು ಜಿಗಿತವನ್ನು ವೇಳೆ ಅದು ನಡೆಯುತ್ತದೆ
ಮತ್ತೆ ಎರಡನೇ, ಎಂದು

516
00:26:48,830 --> 00:26:51,670
ಆ ಬಟನ್ ಟ್ಯಾಗ್ಗಳನ್ನು ನಡುವೆ ಏನು ಎಂದು.

517
00:26:51,670 --> 00:26:54,150
ಇದು ಬಟನ್ ಒಂದು ಅಥವಾ ಬಟನ್ ಎರಡು ಇರುತ್ತದೆ.

518
00:26:54,150 --> 00:26:57,320
ಮತ್ತು ನಲ್ಲಿ ಅವಲೋಕಿಸೋಣ
ಹೇಗೆ ಈ ಈವೆಂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಎಂದು

519
00:26:57,320 --> 00:27:01,080
ನಾವು ಆಚರಣೆಯಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸಿದ ವೇಳೆ ನೋಡಲು.

520
00:27:01,080 --> 00:27:03,850
>> ಆದ್ದರಿಂದ ಎಲ್ಲಾ ಮೊದಲ, ನೀವು ಮಾಡಿದ
ತೆರೆದಿವೆ events.js,

521
00:27:03,850 --> 00:27:06,517
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಡತ ಅಲ್ಲಿ ಇದು
ನಾನು ಈ ಕಾರ್ಯವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ್ದಾರೆ.

522
00:27:06,517 --> 00:27:08,558
ನೀವು ನೋಡಬಹುದು ಎಂದು, ಇದು
ಬಹುಮಟ್ಟಿಗೆ ನಿಖರವಾಗಿ

523
00:27:08,558 --> 00:27:10,230
ನಾವು ಕೇವಲ ಒಂದು ಸೆಕೆಂಡ್ ಹಿಂದೆ ಸ್ಲೈಡ್ ನೋಡಿದ.

524
00:27:10,230 --> 00:27:14,890
ನಾನು ಮೇಲೆ ಹೋಗುತ್ತದೆ
ನಾವು ಅನ್ನು ಬಳಸುತ್ತಿದ್ದೇನೆ ಮುಖಪುಟದಲ್ಲಿ.

525
00:27:14,890 --> 00:27:17,660
ನಾನು ಬಟನ್ ಇಲ್ಲಿರುವುದು
ಒಂದು ಮತ್ತು ಬಟನ್ ಎರಡು.

526
00:27:17,660 --> 00:27:19,820
ನಾನು ಬಟನ್ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡುತ್ತೇವೆ.

527
00:27:19,820 --> 00:27:23,930
ನೀವು ನೀವು, ಬಟನ್ ಒಂದು ಕ್ಲಿಕ್
ಇಲ್ಲಿಯೇ ಎಚ್ಚರಿಕೆಯನ್ನು ನೋಡಬಹುದು.

528
00:27:23,930 --> 00:27:25,810
ಸರಿ.

529
00:27:25,810 --> 00:27:28,980
, ಬಟನ್ ಎರಡು ನೀವು ಕ್ಲಿಕ್
ಒಂದು ಬಟನ್ ಎರಡು ಕ್ಲಿಕ್.

530
00:27:28,980 --> 00:27:32,150
>> ಆದ್ದರಿಂದ ಎರಡೂ ಗುಂಡಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ
ಅದೇ ಕಾರ್ಯ ಕರೆ, ಬಲ?

531
00:27:32,150 --> 00:27:35,840
ಇಬ್ಬರೂ ಎಚ್ಚರಿಕೆಯನ್ನು ಹೆಸರು ಎಂದು
ಈವೆಂಟ್, ಆದರೆ ಈ ಕ್ರಿಯೆಯನ್ನು ವಸ್ತು

532
00:27:35,840 --> 00:27:41,900
ನಾವು ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ ದಾಖಲಿಸಿದವರು ಸಿಗುತ್ತದೆ
ಇದು ಕ್ಲಿಕ್ ಇದು ಬಟನ್ ತಿಳಿಸುತ್ತದೆ.

533
00:27:41,900 --> 00:27:44,650
ನಾವು ಪ್ರತ್ಯೇಕ ಎರಡು ಬರೆಯಲು ಹೊಂದಿರಲಿಲ್ಲ
ಹೊಂದಿರುವ ಕಾರ್ಯಗಳನ್ನು ಅಥವಾ ಒಪ್ಪಂದ

534
00:27:44,650 --> 00:27:46,470
ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಮಾಹಿತಿ ರವಾನಿಸಲು.

535
00:27:46,470 --> 00:27:48,220
ನಾವು ಭರವಸೆ ಮಾಡುತ್ತಿದ್ದೇವೆ
ಏನು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ತಿನ್ನುವೆ

536
00:27:48,220 --> 00:27:53,772
ಎಂದು ರಚಿಸಲು ಇದು ನಮಗೆ ಮಾಡಲು
ನಮ್ಮ ಪರವಾಗಿ ಕ್ರಿಯೆಯನ್ನು ವಸ್ತು ರೀತಿಯ.

537
00:27:53,772 --> 00:27:56,730
ಹೆಚ್ಚು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಹಳ ಇಲ್ಲ
ನಾವು ಈ ವೀಡಿಯೊ ಒಳಗೊಂಡಿದೆ ಬಂದಿದೆ ಏನು,

538
00:27:56,730 --> 00:27:58,521
ಆದರೆ ಹೊಂದಿರುವ ಈ
ನೀವು ಪಡೆಯಬೇಕು ಮೂಲಭೂತ

539
00:27:58,521 --> 00:28:00,690
ಸ್ವಲ್ಪ ದೀರ್ಘ ರೀತಿಯಲ್ಲಿ
ನೀವು ಎಲ್ಲವನ್ನೂ ಮಾಡುತ್ತೇವೆ ಕಲಿಕೆ

540
00:28:00,690 --> 00:28:04,030
ಈ ತಿಳಿದುಕೊಳ್ಳಬೇಕು
ಆಸಕ್ತಿದಾಯಕ ಭಾಷೆ.

541
00:28:04,030 --> 00:28:05,000
ನಾನು ಡೌಗ್ ಲಾಯ್ಡ್ ಮನುಷ್ಯ.

542
00:28:05,000 --> 00:28:07,010
ಈ CS50 ಹೊಂದಿದೆ.

543
00:28:07,010 --> 00:28:09,181