1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [ಸೆಮಿನಾರ್] [ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಚೌಕಟ್ಟುಗಳು:? ಏಕೆ ಮತ್ತು ಹೇಗೆ]

2
00:00:02,000 --> 00:00:04,000
[ಕೆವಿನ್ ಸ್ಕಿಮಿಡ್] [ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]

3
00:00:04,000 --> 00:00:06,960
[ಈ CS50 ಹೊಂದಿದೆ.] [CS50.TV]

4
00:00:06,960 --> 00:00:10,630
>> ಹೈ, ಎಲ್ಲರೂ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಚೌಕಟ್ಟುಗಳು ಸೆಮಿನಾರ್ ಸುಸ್ವಾಗತ.

5
00:00:10,630 --> 00:00:14,910
, ನನ್ನ ಹೆಸರು ಕೆವಿನ್ ಮತ್ತು ಇಂದು ನಾನು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಚೌಕಟ್ಟುಗಳ ಬಗ್ಗೆ ವೃಂದದಲ್ಲಿರುತ್ತೇನೆ

6
00:00:14,910 --> 00:00:20,400
ಮತ್ತು ಈ ಸೆಮಿನಾರ್ ಗುರಿ, ನೀವು ಪಡೆಯಲು ಹೇಳುತ್ತಾರೆ, ವಸ್ತುತಃ ಒಂದು ನಿರ್ದಿಷ್ಟ ಚೌಕಟ್ಟಿನೊಳಗೆ ಸದುಪಯೋಗಪಡಿಸಿಕೊಳ್ಳಲು ಅಲ್ಲ

7
00:00:20,400 --> 00:00:23,810
ಆದರೆ ಚೌಕಟ್ಟುಗಳ ಒಂದೆರಡು ನಿಮ್ಮನ್ನು ಒಂದು ವಿಶಾಲವಾದ ಪರಿಚಯ ನೀಡಲು

8
00:00:23,810 --> 00:00:27,150
ಮತ್ತು ನಾವು ಇದುವರೆಗೆ ಚೌಕಟ್ಟನ್ನು ಬಳಸಲು ಬಯಸುತ್ತೇನೆ ಏಕೆ ತೋರಿಸುತ್ತದೆ.

9
00:00:27,150 --> 00:00:31,060
>> ನಾನು ಹಾಗೆ ಮೊದಲು, ನಾನು, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ರಲ್ಲಿ ಸ್ವಲ್ಪ ಹಿನ್ನೆಲೆ ನೀಡುತ್ತೇವೆ

10
00:00:31,060 --> 00:00:33,750
ತದನಂತರ ನಾವು ಅಲ್ಲಿಂದ ತೆಗೆದುಕೊಂಡು ಮಾಡುತ್ತೇವೆ.

11
00:00:33,750 --> 00:00:36,270
ನಾವು ಒಂದು ಗದ್ದಲ ಪಟ್ಟಿ ಅನುಷ್ಠಾನಗೊಳಿಸುವ ಮೂಲಕ ಆರಂಭಿಸಲು ಹೊರಟಿರುವೆ.

12
00:00:36,270 --> 00:00:39,330
ಇಲ್ಲಿ ಇಂದು ನಮ್ಮ ಕಾರ್ಯಪಟ್ಟಿಯನ್ನು ಇಲ್ಲಿದೆ.

13
00:00:39,330 --> 00:00:41,990
ಇದು ತಮಾಷೆಯ ರೀತಿಯ ಇಲ್ಲಿದೆ. ನಾವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಒಂದು ಗದ್ದಲ ಪಟ್ಟಿಯಲ್ಲಿ ಅಳವಡಿಸಲು ಹೊಂದಿರುತ್ತವೆ.

14
00:00:41,990 --> 00:00:45,110
ಇದು ನಮ್ಮ ಮೊದಲ ಗುರಿ, ಅದು ಕಾಣುವಂತೆ ಇಂದಿನ ವಿಶೇಷವೇನು ಏನು.

15
00:00:45,110 --> 00:00:47,160
ನಾವು ಮಾಡಲು ಚೌಕಟ್ಟನ್ನು ಬಳಸಲು ಹೋಗುತ್ತಿಲ್ಲ.

16
00:00:47,160 --> 00:00:51,930
ನಾವು ಕೋಡ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಹೋಗಿ ಮತ್ತು ಗದ್ದಲ ಪಟ್ಟಿಯನ್ನು ಕೆಲಸ ಪಡೆಯಲು ನೀವು.

17
00:00:51,930 --> 00:00:54,370
ನಂತರ ನಾವು ಚೌಕಟ್ಟನ್ನು ಬಳಸದೆ ವಿನ್ಯಾಸ ಸುಧಾರಿಸಲು ಹೊರಟಿರುವೆ.

18
00:00:54,370 --> 00:00:57,190
ನಾವು ಕೇವಲ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾತ್ರ ಮಾಡಲು ಸಾಧ್ಯ ವಿವಿಧ ವಿಷಯಗಳನ್ನು ಚರ್ಚಿಸಲು ಹೊರಟಿರುವೆ

19
00:00:57,190 --> 00:01:00,650
ನಮ್ಮ ಮಾಡಲು ಗದ್ದಲ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ವಿನ್ಯಾಸ ಪಟ್ಟಿ.

20
00:01:00,650 --> 00:01:02,490
ನಂತರ ನಾವು, ಕೆಲವು jQuery ರಲ್ಲಿ ಎಸೆಯಲು ಹೊರಟಿರುವೆ

21
00:01:02,490 --> 00:01:05,030
ತದನಂತರ ನಾವು ಲಿಸ್ಟ್ ಮಾಡಲು ಅದೇ ನೋಡಲು ಹೊರಟಿರುವೆ

22
00:01:05,030 --> 00:01:07,170
ಕೇವಲ ವಿವಿಧ ಚೌಕಟ್ಟುಗಳು ಅಳವಡಿಸಲಾಗಿದೆ, ಮತ್ತು ನಾವು ಚರ್ಚೆ ಮಾಡುತ್ತೇವೆ

23
00:01:07,170 --> 00:01:09,280
 ದಾರಿಯುದ್ದಕ್ಕೂ ಬಾಧಕಗಳನ್ನು.

24
00:01:09,280 --> 00:01:12,040
>> ಪಟ್ಟಿಯಲ್ಲಿ ಮಾಡಬೇಕಾದವೆಂದು ಎಂದು ಅನುಷ್ಠಾನಕ್ಕೆ ಆರಂಭಿಸೋಣ.

25
00:01:12,040 --> 00:01:14,270
ನಮಗೆ ಈ HTML ನೀಡಿದ ನೀವು ಹೇಳಬಹುದು.

26
00:01:14,270 --> 00:01:16,620
ನಾನು ಈ ಸ್ವಲ್ಪ ಸಣ್ಣ ಮಾಡಲು ಹೋಗುವ ಬಾಗುತ್ತೇನೆ.

27
00:01:16,620 --> 00:01:19,300
ನೀವು ನೋಡಬಹುದು ಎಂದು, ನಾನು ಟೊಡೊ ಹೇಳುತ್ತದೆ ಸ್ವಲ್ಪ ಹೆಡರ್ ಹೊಂದಿವೆ

28
00:01:19,300 --> 00:01:21,740
ನಾನು ಟೊಡೊ ಒಂದು ವಿವರಣೆ ನಮೂದಿಸಬಹುದು ಅಲ್ಲಿ ಮತ್ತು ಸ್ವಲ್ಪ ಬಾಕ್ಸ್

29
00:01:21,740 --> 00:01:26,990
ತದನಂತರ, ಈ ಪಟ್ಟಿಗೆ ಹೊಸ ಟೊಡೊ ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸಿ ನ ಹೊಸ ಐಟಂ ಬಟನ್ ಅವಕಾಶ.

30
00:01:26,990 --> 00:01:31,000
, ಒಂದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಚೌಕಟ್ಟುಗಳ ಸೆಮಿನಾರ್ ನೀಡಿ

31
00:01:31,000 --> 00:01:33,090
ಮತ್ತು ನಾನು ಹೊಸ ಐಟಂ ಹೊಡೆಯಲು ಮನುಷ್ಯ.

32
00:01:33,090 --> 00:01:35,730
ನನ್ನ ಜಾರಿಗೆ ಹೇಳುತ್ತದೆ ಈ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಎಚ್ಚರಿಕೆಯನ್ನು ಪಡೆಯಿರಿ.

33
00:01:35,730 --> 00:01:37,560
ನಾವು ಕಾರ್ಯಗತ ಮಾಡಲೇಬೇಕು.

34
00:01:37,560 --> 00:01:41,490
HTML ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಎರಡೂ, ಅವರ ಈ ಕೋಡ್ ಔಟ್ ಪರೀಕ್ಷಿಸೋಣ.

35
00:01:41,490 --> 00:01:43,260
ಇಲ್ಲಿ ನಮ್ಮ ಎಚ್ಟಿಎಮ್ಎಲ್ ಇಲ್ಲಿದೆ.

36
00:01:43,260 --> 00:01:45,500
ನೀವು ಇಲ್ಲಿ ನೋಡಬಹುದು ಎಂದು, ಇಲ್ಲಿ ನಮ್ಮ ಸ್ವಲ್ಪ Todos ಹೆಡರ್ ಇಲ್ಲಿದೆ.

37
00:01:45,500 --> 00:01:47,620
ಎಂದು, ಮೇಲ್ಭಾಗದಲ್ಲಿ ದಿಟ್ಟ ವಿಷಯ

38
00:01:47,620 --> 00:01:50,690
ತದನಂತರ ನಾವು, ಪ್ಲೇಸ್ಹೋಲ್ಡರ್ ಹೊಂದಿರುವ ಇನ್ಪುಟ್ ಬಾಕ್ಸ್ ಹೊಂದಿವೆ

39
00:01:50,690 --> 00:01:59,460
ತದನಂತರ ಈ ಕಾರ್ಯ addTodo ಅಪೇಕ್ಷಿಸುವ ಈ ಬಟನ್ ಒಂದು ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣ ಅಲ್ಲಿ ಇಲ್ಲಿದೆ.

40
00:01:59,460 --> 00:02:05,460
ಯಾರಾದರೂ ಸೂಚಿಸುತ್ತದೆ ಇದೆ ಕ್ಲಿಕ್ ಏನು ಎಂದು ಊಹಿಸಲು ಬಯಸುವಿರಾ?

41
00:02:05,460 --> 00:02:07,390
[ವಿದ್ಯಾರ್ಥಿ ಕೇಳಿಬರುವುದಿಲ್ಲ ಪ್ರತಿಕ್ರಿಯೆ]

42
00:02:07,390 --> 00:02:09,289
ಗುಡ್, ಮೇಲೆ ಕ್ಲಿಕ್, ಕ್ರಿಯೆಯನ್ನು ರೀತಿಯ ರೀತಿಯ ಆಗಿದೆ

43
00:02:09,289 --> 00:02:12,120
ಮೌಸ್ ಕ್ಲಿಕ್ ಕೇವಲ ಕ್ರಿಯೆಯನ್ನು, ಮತ್ತು ನಾವು ಮಾಡುತ್ತಿರುವುದು ಹೇಗಿದೆಯೋ

44
00:02:12,120 --> 00:02:16,890
ನಾವು ಕಾರ್ಯ ನಿರ್ವಹಿಸಲು ಈ ಗುಂಡಿಯನ್ನು ಕ್ಲಿಕ್ಕಿಸುವುದರ ಸಂದರ್ಭದಲ್ಲಿ ಕಟ್ಟಿ ನೀವು ಇದೆ.

45
00:02:16,890 --> 00:02:21,700
AddTodo ಗುಂಡಿಯನ್ನು ಕ್ಲಿಕ್ ಈ ಈವೆಂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಆಗಿದೆ.

46
00:02:21,700 --> 00:02:25,010
>> ನೀವು ನೋಡಬಹುದು ಎಂದು, ನಾನು ಹೊಸ ಐಟಂ ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ

47
00:02:25,010 --> 00:02:29,940
ಮೇಲೆ ಕ್ಲಿಕ್ ಕ್ರಿಯೆಯನ್ನು ಕೆಲಸದಿಂದ ಸಿಗುತ್ತದೆ, ಮತ್ತು ಈ ಕಾರ್ಯ ಎಂದು ಸಿಗುತ್ತದೆ.

48
00:02:29,940 --> 00:02:33,170
ಅವರ ಕಾರ್ಯವನ್ನು ನೋಡೋಣ.

49
00:02:33,170 --> 00:02:36,260
ನೀವು ನೋಡಬಹುದು ಎಂದು, ಇಲ್ಲಿ ಇದುವರೆಗೆ ನನ್ನ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಇಲ್ಲಿದೆ.

50
00:02:36,260 --> 00:02:41,280
ನಾನು ಮೇಲಿರುವ ನನ್ನ ಗದ್ದಲ ಪಟ್ಟಿಗಾಗಿ ಜಾಗತಿಕ ದಶಮಾಂಶ ರಚನೆಯಾಗಿದೆ.

51
00:02:41,280 --> 00:02:44,060
ಇದು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ತೋರುತ್ತಿದೆ. ಅದು ಖಾಲಿ ರಚನೆಯ ಇಲ್ಲಿದೆ.

52
00:02:44,060 --> 00:02:47,100
ಮತ್ತು ನಂತರ ನಾನು, ನಾವು ಹಿಂದಿನ ಕಂಡಿದ್ದು addTodo ಕಾರ್ಯವಾಗುತ್ತದೆ

53
00:02:47,100 --> 00:02:50,740
ಮತ್ತು ಅಲ್ಲಿ ಸಂಕೇತವನ್ನು ಕೇವಲ ಲೈನ್ ಈ ಎಚ್ಚರಿಕೆಯನ್ನು ಹೊಂದಿದೆ.

54
00:02:50,740 --> 00:02:55,730
ಇದು ನನಗೆ ಜಾರಿಗೆ ಎಚ್ಚರಿಸುತ್ತದೆ, ಮತ್ತು ನಂತರ ನಾನು ಕೈಯಲ್ಲಿ 2 ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿವೆ.

55
00:02:55,730 --> 00:02:58,790
ನಾನು, ಜಾಗತಿಕ ದಶಮಾಂಶ ರಚನೆಗೆ ಟೊಡೊ ಸೇರಿಸಬೇಕಾಗಿಲ್ಲ

56
00:02:58,790 --> 00:03:01,860
ಮತ್ತು ನಂತರ ನಾನು ಗದ್ದಲ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯಲು ಬಯಸುವ.

57
00:03:01,860 --> 00:03:06,360
ನಥಿಂಗ್ ತುಂಬಾ ಇನ್ನೂ ಅಲಂಕಾರಿಕ, ಆದರೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನೀವು, ಜೊತೆಗೆ ಪರಿಚಯವಿಲ್ಲದ ಇರಬಹುದು

58
00:03:06,360 --> 00:03:12,370
ಆದ್ದರಿಂದ ನಾನು ನಿಧಾನವಾಗಿ ಹೋಗಿ ರೀತಿಯಲ್ಲಿ JavaScript ನ ಮೂಲಭೂತ ಪರಿಶೀಲಿಸಿ ಹೋಗುವ ಬಾಗುತ್ತೇನೆ.

59
00:03:12,370 --> 00:03:15,490
>> ತಂದೆಯ ಈ ಶಾಟ್ ನೀಡುವ ಅವಕಾಶ.

60
00:03:15,490 --> 00:03:21,130
ಲೆಟ್ಸ್ ಬಳಕೆದಾರ ಈ ಪೆಟ್ಟಿಗೆಯಲ್ಲಿ ಏನಾದರೂ ಪ್ರವೇಶಿಸಿತು ಹೇಳುತ್ತಾರೆ.

61
00:03:21,130 --> 00:03:23,360
ನಾನು ಇಲ್ಲಿ, ಪಠ್ಯ ಏನೋ ಟೈಪ್.

62
00:03:23,360 --> 00:03:27,620
ನಾನು ಹೇಗೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮೂಲಕ ಪ್ರವೇಶ ಎಂದು ಪಠ್ಯದ ವಿಂಗಡಿಸಲು ಇಲ್ಲ?

63
00:03:27,620 --> 00:03:32,500
ಆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನೆನಪಿಡಿ, ಅದರ ಮೂಲಭೂತ ಲಕ್ಷಣಗಳನ್ನು ಒಂದು ನಮಗೆ ನೀಡುತ್ತದೆ ಎಂಬುದು

64
00:03:32,500 --> 00:03:34,670
DOM ಈ ಪ್ರೋಗ್ರಾಮೆಟಿಕ್ ಪ್ರವೇಶ.

65
00:03:34,670 --> 00:03:40,670
ಇದು ನಮಗೆ ಈ ನಿಜವಾದ HTML ನ ಅಂಶಗಳನ್ನು ಮತ್ತು ಅವರ ಆಸ್ತಿಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.

66
00:03:40,670 --> 00:03:43,430
ನಾವು ಎಲುಬಿನಂತೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆ ಹಾಗೆ

67
00:03:43,430 --> 00:03:51,360
ನಾವು ವಾಸ್ತವವಾಗಿ getElementByID ಎಂದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಒಂದು ಕಾರ್ಯವನ್ನು ಉಪಯೋಗಿಸಬಹುದು ಆಗಿದೆ.

68
00:03:51,360 --> 00:03:55,140
ನಾನು, ಕೆಲವು ವೇರಿಯಬಲ್ ಅಲ್ಲಿ ಟೈಪ್ ವಿಶೇಷವೇನು ಪಠ್ಯ ಸಂಗ್ರಹಿಸಲು ಬಯಸುವ

69
00:03:55,140 --> 00:03:58,350
ಆದ್ದರಿಂದ ನಾನು, new_todo ಎಂಬ ಹೊಸ ವೇರಿಯಬಲ್ ಹೇಳಲು ಹೋಗುವ ಬಾಗುತ್ತೇನೆ

70
00:03:58,350 --> 00:04:01,980
ಮತ್ತು ನಾನು ಆ ಅಂಶ ಪಡೆಯಲು ಹೋಗುವ ಬಾಗುತ್ತೇನೆ.

71
00:04:01,980 --> 00:04:06,330
ಈ, ಒಂದು ಕ್ರಿಯೆಯಾಗಿದೆ. GetElementByID.

72
00:04:06,330 --> 00:04:11,580
ಮತ್ತು ಈಗ ನಾನು ID ಒಂದು ಅಂಶ ಪಡೆಯುವಲ್ಲಿ ಬಾಗುತ್ತೇನೆ, ಆದ್ದರಿಂದ ನಾನು ಪಠ್ಯ ಬಾಕ್ಸ್ನಲ್ಲಿನ ID ಅಗತ್ಯವಿದೆ

73
00:04:11,580 --> 00:04:15,860
ಆದ್ದರಿಂದ ನಾನು ID new_todo_description ನೀಡಿದ್ದೇನೆ.

74
00:04:15,860 --> 00:04:18,399
ನಾನು ಒಂದು ಅಂಶ ಪಡೆಯಲು ಹೋಗುವ ಬಾಗುತ್ತೇನೆ ಹೇಗೆ.

75
00:04:18,399 --> 00:04:23,880
ಆ ಪಡೆಯಲು ಇದು ID ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು, ಈ ಕಾರ್ಯಕ್ಕೆ ನನ್ನ ವಾದದ.

76
00:04:23,880 --> 00:04:28,110
ಮತ್ತು ಆದ್ದರಿಂದ HTML ನಲ್ಲಿ ಒಂದು ಅಂಶ, ಮತ್ತು ಇದು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿದೆ.

77
00:04:28,110 --> 00:04:30,650
ಈ ನೋಡಿದ್ದೇವೆ. ಅವರು ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಆರ್.

78
00:04:30,650 --> 00:04:37,090
ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ಸಂಗ್ರಹಿಸುತ್ತದೆ ಎಂದು ಪಠ್ಯ ಅಂಶದ ಗುಣಲಕ್ಷಣ ಮೌಲ್ಯದ ಕರೆಯಲಾಗುತ್ತದೆ.

79
00:04:37,090 --> 00:04:40,860
ನಾನು new_todo ಎಂದು ಈ ವೇರಿಯಬಲ್ ಈಗ ಆ ಪಠ್ಯ ಬಾಕ್ಸ್ನಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ಉಳಿಸಲಾಗಿದೆ.

80
00:04:40,860 --> 00:04:45,040
ಈಗ ನಾನು ಈ ವೇರಿಯಬಲ್ ಪ್ರೋಗ್ರಾಮ್ಯಾಟಿಕ್ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಇದು ರೀತಿಯ ತಂಪಾದ ಹೊಂದಿದೆ

81
00:04:45,040 --> 00:04:49,200
ಈಗ ನಾನು ಏನು ಮಾಡಬಹುದು ಏಕೆಂದರೆ ನನ್ನ ಗದ್ದಲ ಪಟ್ಟಿಗೆ ಸೇರಿಸಬಹುದು ಆಗಿದೆ.

82
00:04:49,200 --> 00:04:52,870
>> ನಾವು ಈ ಮಾಡುತ್ತಿರಲಿಲ್ಲ ರೀತಿಯಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಈ ಬಗ್ಗೆ ಪರಿಚಯವಿರದ ಚಿಂತೆ ಇಲ್ಲ,

83
00:04:52,870 --> 00:04:57,010
ಆದರೆ ಅದನ್ನು ಹಾದುಹೋಗುವ todos.push ಆಗಿದೆ

84
00:04:57,010 --> 00:05:00,130
ಅಪ್ ಇಲ್ಲಿ ನನ್ನ ಜಾಗತಿಕ ದಶಮಾಂಶ ರಚನೆಯ ಹೆಸರು ಎಂದು ಕಾರಣ,

85
00:05:00,130 --> 00:05:04,450
ಮತ್ತು ನಾನು new_todo ತಳ್ಳುವ ಹೋಗುವ ಬಾಗುತ್ತೇನೆ.

86
00:05:04,450 --> 00:05:09,120
ಈಗ ನಾನು ನನ್ನ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅದನ್ನು ಸೇರಿಸಿದ ಈ ಅದ್ಭುತವಾಗಿದೆ

87
00:05:09,120 --> 00:05:11,280
ಆ ಗದ್ದಲ ಪಟ್ಟಿಯ ಪ್ರಾತಿನಿಧ್ಯ.

88
00:05:11,280 --> 00:05:15,170
ಆದರೆ ಈಗ ಹೇಗೆ ನಾನು ಎಚ್ಟಿಎಮ್ಎಲ್ ಅದನ್ನು ಮರಳಿ ಪಡೆಯಲು ಇಲ್ಲ?

89
00:05:15,170 --> 00:05:18,560
ನಾನು ಹಿಂದಕ್ಕೆ ತಳ್ಳುವ ಆಫ್ ವಿಂಗಡಿಸಲು ಒಂದು ರೀತಿಯಲ್ಲಿ ಕಂಡುಹಿಡಿಯಬೇಕಿದೆ.

90
00:05:18,560 --> 00:05:21,830
ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ನಾನು ರೀತಿಯ ಈ ಸೆಳೆಯಲು ಹೊಂದಿವೆ.

91
00:05:21,830 --> 00:05:26,060
ನಾವು ಮಾಡಲು ಹೊರಟಿರುವೆ ನಾವು ಗದ್ದಲ ಪಟ್ಟಿ ಸೆಳೆಯಲು ಹೊರಟಿರುವೆ ಆಗಿದೆ.

92
00:05:26,060 --> 00:05:29,270
ನಾನು, ಆ ಪುಟದ ಇತರ ಎಚ್ಟಿಎಮ್ಎಲ್ ಆರಿಸ ಬೇಕಾಗುತ್ತದೆ

93
00:05:29,270 --> 00:05:32,040
ನೀವು ನೋಡಬಹುದು ಎಂದು ಮತ್ತು, ನಾನು, ಈ ಕಡಿಮೆ ಧಾರಕ ಬಿಟ್ಟು ಬಂದಿದೆ

94
00:05:32,040 --> 00:05:36,840
ಇದರ ID todos ಆಗಿದೆ ಪುಟದ ಈ ವಿಭಾಜಕ,

95
00:05:36,840 --> 00:05:40,870
ಮತ್ತು ನಾನು ಅಲ್ಲಿ ಗದ್ದಲ ಪಟ್ಟಿಯಲ್ಲಿ ಹಾಕಲು ಹೋಗುವ ಬಾಗುತ್ತೇನೆ.

96
00:05:40,870 --> 00:05:47,240
ಮೊದಲ ನಾನು ಗದ್ದಲ ಪಟ್ಟಿ ಹಳೆಯ ಇಲ್ಲ, ಹೇಳುತ್ತಾರೆ, ಏಕೆಂದರೆ ಅದನ್ನು ತೆರವುಗೊಳಿಸಿ ಹೋಗುವ ಬಾಗುತ್ತೇನೆ.

97
00:05:47,240 --> 00:05:49,560
ನಾನು, ಮತ್ತೆ ID ಆ ಅಂಶ ಪಡೆಯುವಲ್ಲಿ ಬಾಗುತ್ತೇನೆ

98
00:05:49,560 --> 00:05:54,530
ಮತ್ತು ನಾನು ಆ ಅಂಶ ಒಳ ಎಚ್ಟಿಎಮ್ಎಲ್ ಪ್ರವೇಶಿಸುವ ಬಾಗುತ್ತೇನೆ

99
00:05:54,530 --> 00:05:58,010
ಮತ್ತು ನಾನು ಆ ತೆರವುಗೊಳಿಸಲು ಹೋಗುವ ಬಾಗುತ್ತೇನೆ.

100
00:05:58,010 --> 00:06:05,510
ಎಂದು ನಾವು ಈ ಕೋಡ್ ಬಿಟ್ಟರೆ, ನಾವು, ಅಲ್ಲಿ ಒಂದು ಖಾಲಿ ಇಲ್ಲ ನೋಡಿ 'd

101
00:06:05,510 --> 00:06:10,410
ಮತ್ತು ಈಗ ನಾನು ನನ್ನ ಹೊಸ ಗದ್ದಲ ಪಟ್ಟಿ ಸಲ್ಲಿಕೆ ಆರಂಭಿಸಲು ಬಯಸುವ.

102
00:06:10,410 --> 00:06:12,870
ನಾನು ಮೂಲತಃ ನನ್ನ ಗದ್ದಲ ಪಟ್ಟಿ ಅಳಿಸಿಹಾಕುತ್ತದೆ ಹೋಗುವ ಬಾಗುತ್ತೇನೆ.

103
00:06:12,870 --> 00:06:18,180
>> ಈಗ ಆ todos DIV ಒಳ ಎಚ್ಟಿಎಮ್ಎಲ್ ಒಳಗೆ, ಸಂಪೂರ್ಣವಾಗಿ ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ

104
00:06:18,180 --> 00:06:20,060
ಮತ್ತು ಈಗ ನಾನು ನನ್ನ ಪಟ್ಟಿಯಲ್ಲಿ ಸೇರಿಸುವ ಆರಂಭಿಸುವ ಅಗತ್ಯವಿರುತ್ತದೆ.

105
00:06:20,060 --> 00:06:23,890
ನಾನು ಮತ್ತೆ ಸೇರಿಸಲು ಬಯಸುವ ಮೊದಲ ವಿಷಯ, unordered ಪಟ್ಟಿ ಟ್ಯಾಗ್ ಹೊಂದಿದೆ

106
00:06:23,890 --> 00:06:33,890
ಇದು ಮೂಲಭೂತವಾಗಿ ಇದು unordered ಪಟ್ಟಿಯ ಆರಂಭ ಎಂದು ಸೂಚಿಸುತ್ತದೆ.

107
00:06:33,890 --> 00:06:39,770
ಈಗ ನನ್ನ todos ಶ್ರೇಣಿಯಲ್ಲಿನ ಪ್ರತಿ ಅಂಶ ನಾನು HTML ನ ಒಳಗೆ ಇದು ಮುದ್ರಿಸುತ್ತದೆ ಬಯಸುವ.

108
00:06:39,770 --> 00:06:43,710
ನಾನು ಈ ಪಟ್ಟಿಯಲ್ಲಿ ಕೆಳಕ್ಕೆ ಅದನ್ನು ಸೇರಿಸಲು ಬಯಸುವ.

109
00:06:43,710 --> 00:06:49,040
ಕೇವಲ ಸಿ ಹಾಗೆ, ನಾನು ಲೂಪ್ ಒಂದು ಬಳಸಬಹುದು, ಮತ್ತು ನನ್ನ ಪಟ್ಟಿ ಆರಂಭದಲ್ಲಿ ಆರಂಭಿಸಲು ಹೋಗುವ ಬಾಗುತ್ತೇನೆ

110
00:06:49,040 --> 00:06:54,140
ಅಂಶ 0 ನಲ್ಲಿ, ಮತ್ತು ನಾನು ಪಟ್ಟಿಯ ಉದ್ದಕ್ಕೆ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಹೋಗಿ ಹೋಗುವ ಬಾಗುತ್ತೇನೆ.

111
00:06:54,140 --> 00:07:01,100
ನಾವು ವಾಸ್ತವವಾಗಿ ಉದ್ದ ಆಸ್ತಿ ಬಳಸಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಒಂದು ರಚನೆಯ ಉದ್ದ ಪಡೆಯಬಹುದು.

112
00:07:01,100 --> 00:07:03,420
ಮೂಲತಃ ನಾನು ಇಲ್ಲಿ ಒಳಗೆ ಹೋಲುತ್ತದೆ ಏನಾದರೂ ಹೋಗುವ ಬಾಗುತ್ತೇನೆ

113
00:07:03,420 --> 00:07:05,600
ಆ ಅಂಶ ಔಟ್ ಮುದ್ರಿಸಲು.

114
00:07:05,600 --> 00:07:12,970
ನಾನು ಮತ್ತೆ todos DIV, ಆ ಒಳಗಿನ ಎಚ್ಟಿಎಮ್ಎಲ್ ಆಸ್ತಿ, ಪ್ರವೇಶಿಸಬಹುದು

115
00:07:12,970 --> 00:07:17,560
ಮತ್ತು ನಾನು ಈ ಹೊಸ ಪಟ್ಟಿ ಐಟಂನ ಸೇರಿಸಲು ಹೋಗುವ ಬಾಗುತ್ತೇನೆ, ಮತ್ತು ಸುತ್ತಲೂ ಎಂದು ಇಂದಿನ ವಿಶೇಷವೇನು

116
00:07:17,560 --> 00:07:25,390
ಈ ಲಿ ಟ್ಯಾಗ್, ಮತ್ತು ನಾನು, + ಆಯೋಜಕರು ಜೊತೆ concatenate ಹೋಗುವ ಬಾಗುತ್ತೇನೆ

117
00:07:25,390 --> 00:07:28,040
ಮತ್ತು, ನನ್ನ todos ರಚನೆಯ ಇತ್ ಅಂಶ ಇಲ್ಲಿದೆ

118
00:07:28,040 --> 00:07:32,380
ಮತ್ತು ನಂತರ ನಾನು ಟ್ಯಾಗ್ ಮುಚ್ಚಿ ಹೋಗುವ ಬಾಗುತ್ತೇನೆ.

119
00:07:32,380 --> 00:07:36,240
ಈಗ ಪ್ರತಿ ಅಂಶ ನಾವು ಹೊಸ ಪಟ್ಟಿಯಲ್ಲಿ ನಮೂದನ್ನು ಸೇರಿಸಿ ಮಾಡುತ್ತೇವೆ.

120
00:07:36,240 --> 00:07:48,700
ತದನಂತರ ನಾವು ಮಾಡಬೇಕಾದ್ದು ಎಲ್ಲಾ ಟ್ಯಾಗ್ ಮುಚ್ಚಿ ಆಗಿದೆ.

121
00:07:48,700 --> 00:07:52,820
ನಾನು ಪಟ್ಟಿಯಲ್ಲಿ ಟ್ಯಾಗ್ unordered ಎಂದು ಮುಚ್ಚಿ ಅಗತ್ಯವಿದೆ.

122
00:07:52,820 --> 00:07:55,490
>> ನೀವು ಆ ಕೆಲಸ ಹೇಗೆ ಒಂದು ಭಾವನೆ ಪಡೆಯಲು ಮಾಡಬೇಡಿ?

123
00:07:55,490 --> 00:07:57,700
ಈ ಸಂಪೂರ್ಣ ಪಟ್ಟಿ ತೆರೆಯುತ್ತದೆ.

124
00:07:57,700 --> 00:08:01,080
ಈ, todos ಪಟ್ಟಿಯಿಂದ ಪಟ್ಟಿಗೆ ಪ್ರತ್ಯೇಕ ಅಂಶಗಳು ಸೇರಿಸುತ್ತದೆ

125
00:08:01,080 --> 00:08:05,470
ತದನಂತರ ಸಂಪೂರ್ಣ ಪಟ್ಟಿ ಮುಚ್ಚಲ್ಪಡುತ್ತದೆ, ಮತ್ತು ಈ ನನ್ನ addTodo ಕ್ರಿಯೆಯಾಗಿದೆ ಎಂದು.

126
00:08:05,470 --> 00:08:09,590
ನಾನು ಮೂಲತಃ ಪಠ್ಯ ಪೆಟ್ಟಿಗೆಯಿಂದ ಟೊಡೊ ಪಡೆಯುವಲ್ಲಿ ಮೂಲಕ ಆರಂಭವಾಗುತ್ತದೆ.

127
00:08:09,590 --> 00:08:18,950
ನಾನು todos ರಚನೆಯ ಎಂದು ಸೇರಿಸಿ, ತದನಂತರ ನಾನು ಗದ್ದಲ ಪಟ್ಟಿಯಲ್ಲಿ ಮತ್ತೆ ನಿರೂಪಿಸಲು.

128
00:08:18,950 --> 00:08:21,520
ಈಗ ನಾನು ನನ್ನ ಪಟ್ಟಿಗೆ ಐಟಂಗಳನ್ನು ಸೇರಿಸಬಹುದು.

129
00:08:21,520 --> 00:08:24,620
ಈ ರೀತಿಯ ರೋಮಾಂಚಕಾರಿ ಏಕೆಂದರೆ ಕೋಡ್ ಕೆಲವೇ ಸಾಲುಗಳಲ್ಲಿ

130
00:08:24,620 --> 00:08:28,240
ನಾವು ಮೂಲತಃ ನಾವು ಐಟಂಗಳನ್ನು ಸೇರಿಸಬಹುದು ಅಲ್ಲಿ ಒಂದು ಗದ್ದಲ ಪಟ್ಟಿ ಮಾಡಿದ.

131
00:08:28,240 --> 00:08:30,050
ಗ್ರೇಟ್.

132
00:08:30,050 --> 00:08:34,480
ಆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಗೆ ಒಂದು ಮೂಲ ಪರಿಚಯದ ರೀತಿಯ.

133
00:08:34,480 --> 00:08:36,179
, ಈಗ ವಾಕ್ಯ ಬಗ್ಗೆ ತುಂಬಾ ಚಿಂತಿಸಬೇಡಿ

134
00:08:36,179 --> 00:08:38,130
ಆದರೆ ಈ ಪರಿಕಲ್ಪನೆಗಳ ಬಗ್ಗೆ.

135
00:08:38,130 --> 00:08:40,539
ನಾವು ಕೆಲವು ಎಚ್ಟಿಎಮ್ಎಲ್ ಹೊಂದಿತ್ತು.

136
00:08:40,539 --> 00:08:45,310
ನಾವು ಇನ್ಪುಟ್ ಒಂದು ಗದ್ದಲ ಐಟಂಗೆ ಮೂಲತಃ ಅವಕಾಶ ಬಳಕೆದಾರರನ್ನು ಸೇರಿಸಲು ಆ ಪುಟದಲ್ಲಿ ಒಂದು ಪಠ್ಯ ಬಾಕ್ಸ್ನಲ್ಲಿ ಹೊಂದಿತ್ತು.

137
00:08:45,310 --> 00:08:49,210
ತದನಂತರ ನಾವು ಪಠ್ಯ ಬಾಕ್ಸ್ನಲ್ಲಿ ಆ ಟೊಡೊ ತರಲು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸಲಾಗುತ್ತದೆ.

138
00:08:49,210 --> 00:08:52,830
ನಾವು ಒಂದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ರಚನೆಯ ಒಳಗೆ, ಇದು ರೀತಿಯ ಮೂಲತಃ ಎಂದು ಸಂಗ್ರಹವಾಗಿರುವ

139
00:08:52,830 --> 00:08:56,010
ಎಂದು ನಮ್ಮ ಪ್ರೋಗ್ರಾಮೆಟಿಕ್ ಪ್ರಾತಿನಿಧ್ಯ ಲಿಸ್ಟ್ ಮಾಡಲು,

140
00:08:56,010 --> 00:08:59,060
ತದನಂತರ ನಾವು ಅದನ್ನು ಮುದ್ರಿತ.

141
00:08:59,060 --> 00:09:02,690
ಈ todos.js ಆಗಿದೆ.

142
00:09:02,690 --> 00:09:07,620
>> ಈ ತಂಪಾದ ರೀತಿಯ, ಆದರೆ ಹೇಗೆ ನಾವು ಈ ಮುಂದಿನ ತೆಗೆದುಕೊಳ್ಳಬಹುದು?

143
00:09:07,620 --> 00:09:11,350
ನೀವು ನೋಡಬಹುದು ಜೊತೆಗೆ, ಈ ಗದ್ದಲ ಪಟ್ಟಿಯು ಸಂಪೂರ್ಣ ರೀತಿಯಲ್ಲಿ ಅಲ್ಲ.

144
00:09:11,350 --> 00:09:15,100
ಉದಾಹರಣೆಗೆ, ನಾನು, ಅಪೂರ್ಣವಾಗಿ ಈ ಐಟಂಗಳ ಯಾವುದೇ ಗುರುತಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ

145
00:09:15,100 --> 00:09:19,920
ನಾನು ಐಟಂಗಳನ್ನು reprioritize ಅಥವಾ ಐಟಂಗಳನ್ನು ಅಳಿಸಲು ಬಯಸಿದರೆ ಇಷ್ಟ.

146
00:09:19,920 --> 00:09:23,150
ಈ ತಪ್ಪಿಲ್ಲ, ಆದರೆ ನಾವು ಈ ಮುಂದಿನ ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

147
00:09:23,150 --> 00:09:29,280
ನಾನು, ಹೆಚ್ಚುವರಿ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಸೇರಿಸುವ ಬಗ್ಗೆ ತುಂಬಾ ಮಾತನಾಡಲು ನಾನೇನು

148
00:09:29,280 --> 00:09:32,800
ಆದರೆ ನಾವು ಮತ್ತಷ್ಟು ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

149
00:09:32,800 --> 00:09:35,970
ಲಿಸ್ಟ್ ಮಾಡಲು ಇದಕ್ಕೆ ಇನ್ನೊಂದು ವೈಶಿಷ್ಟ್ಯವನ್ನು ಸೇರಿಸುವುದರ ಬಗ್ಗೆ ಮಾತನಾಡೋಣ,

150
00:09:35,970 --> 00:09:40,370
ಒಂದು ಮಾಲಿಕ ಗದ್ದಲ ಐಟಂ ಪರಿಶೀಲಿಸಲು ಸಾಮರ್ಥ್ಯವನ್ನು ಏರಲಿದೆ ಇದು

151
00:09:40,370 --> 00:09:44,780
ಮತ್ತು ಅದು ಮೂಲತಃ ನಾನಿದನ್ನು ಮಾಡಿದ್ದೇನೆ ಹೇಳುವ ಔಟ್ ದಾಟಬಹುದಾಗಿತ್ತು ಎಂದು.

152
00:09:44,780 --> 00:09:50,240
ತಂದೆಯ ಎಂದು ಸಾಧಿಸಲು ಎಂದು ಕೆಲವು ಕೋಡ್ ನೋಡೋಣ.

153
00:09:50,240 --> 00:09:52,740
ನಾನು ಮೇಲಿರುವ ಮಾಡಿದ ನಾನು ಸೇರಿಸಿದ ಆಗಿದೆ ಗಮನಿಸಿ

154
00:09:52,740 --> 00:09:57,620
ಹೊಸ ಜಾಗತಿಕ ರಚನೆಯ ಸಂಪೂರ್ಣ ಎಂದು.

155
00:09:57,620 --> 00:10:02,890
ನಾನು ಮೂಲತಃ ಸಂಗ್ರಹಿಸಲು ಈ ಬಳಸಿಕೊಂಡು ಬಾಗುತ್ತೇನೆ ಎಂದು ಗದ್ದಲ ಪಟ್ಟಿಯಲ್ಲಿ ಐಟಂಗಳನ್ನು

156
00:10:02,890 --> 00:10:06,560
ಸಂಪೂರ್ಣ ಅಥವಾ ಇಲ್ಲ.

157
00:10:06,560 --> 00:10:08,470
ಈ ಮಾಡಲು ಒಂದು ಮಾರ್ಗವಾಗಿದೆ.

158
00:10:08,470 --> 00:10:13,750
ನಾನು ಈ ಅನುಷ್ಠಾನದಲ್ಲಿ, ಪ್ರದರ್ಶನ, ನೋಡಿದರೆ

159
00:10:13,750 --> 00:10:21,120
ನಾನು ಟೊಡೊ ನಮೂದಿಸಿ ಮತ್ತು ವೇಳೆ ಮೂಲತಃ ನಾನು ಈ ಟಾಗಲ್ ಗುಂಡಿಯನ್ನು ಒತ್ತಿ

160
00:10:21,120 --> 00:10:25,040
ಇದನ್ನು ದಾಟಿ, ಈ ಪಟ್ಟಿಯಲ್ಲಿ ಪ್ರತಿ ಐಟಂ ಒಂದೋ ಸಂಪೂರ್ಣ ಹೊಂದಿದೆ

161
00:10:25,040 --> 00:10:31,050
ಅಥವಾ ಅಪೂರ್ಣ ರಾಜ್ಯದ, ಮತ್ತು ನಾನು ಆ ಪ್ರತಿನಿಧಿಸಲು ಮತ್ತೊಂದು ವ್ಯೂಹವನ್ನು ಬಳಸಿಕೊಂಡು ಬಾಗುತ್ತೇನೆ.

162
00:10:31,050 --> 00:10:33,730
>> ಮೂಲತಃ ಎಂದು todos ಶ್ರೇಣಿಯಲ್ಲಿನ ಪ್ರತಿ ಟೊಡೊ ಫಾರ್

163
00:10:33,730 --> 00:10:37,110
ಐಟಂ ಮೂಲತಃ ಸೂಚಿಸುತ್ತದೆ ಎಂದು ಸಂಪೂರ್ಣ ಶ್ರೇಣಿಯಲ್ಲಿನ ಇಲ್ಲ

164
00:10:37,110 --> 00:10:39,060
ಆ ಸಂಪೂರ್ಣ ಅಥವಾ ಎಂದು.

165
00:10:39,060 --> 00:10:41,640
ನಾನು, ಈ ಸಂಕೇತಕ್ಕೆ ಸಾಕಷ್ಟು ಕಡಿಮೆ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಲು ಹೊಂದಿತ್ತು ಬಂದಿದೆ

166
00:10:41,640 --> 00:10:44,470
ಇಲ್ಲಿ ನಮ್ಮ addTodo ಕಾರ್ಯ ಇಲ್ಲಿದೆ.

167
00:10:44,470 --> 00:10:48,530
ಇಲ್ಲಿ ನಾನು ರಚನೆಯ ಮೇಲೆ ತಳ್ಳುವುದು ಬಾಗುತ್ತೇನೆ ಎಂದು ಗಮನಿಸಿ,

168
00:10:48,530 --> 00:10:51,300
ಮತ್ತು ನಂತರ ನಾನು, ಎಂದು ಸಂಪೂರ್ಣ ರಚನೆಯ ಒಂದು 0 ತಳ್ಳುವುದು ಬಾಗುತ್ತೇನೆ

169
00:10:51,300 --> 00:10:57,090
ಮೂಲತಃ ಹೇಳಲು ಹೊಸ ಟೊಡೊ ಪುಶ್ ಸಮಾನಾಂತರವಾಗಿ

170
00:10:57,090 --> 00:11:00,430
ನಾನು, ಈ ಐಟಂ ಸೇರಿಸುವ ಬಾಗುತ್ತೇನೆ, ಮತ್ತು ಇದು ಈ ಮೌಲ್ಯವನ್ನು ಸೇರಿಕೊಂಡು ವಿಶೇಷವೇನು

171
00:11:00,430 --> 00:11:02,810
ಇದು ಅಪೂರ್ಣ ಎಂದು ಅರ್ಥ.

172
00:11:02,810 --> 00:11:04,970
ಮತ್ತು ನಂತರ ನಾನು ಗದ್ದಲ ಪಟ್ಟಿ ಮರುರಚನೆ ಬಾಗುತ್ತೇನೆ.

173
00:11:04,970 --> 00:11:09,220
ಈಗ, ನಾನು ಈ drawTodoList ಕಾರ್ಯ ಸೇರಿಸಿದ ಗಮನಿಸಿ.

174
00:11:09,220 --> 00:11:11,760
ಈ, ನಾವು ಮೊದಲು ಹೊಂದಿತ್ತು ಕೋಡ್ ಬಹಳಷ್ಟು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

175
00:11:11,760 --> 00:11:15,320
ಮೂಲತಃ ಬಾಕ್ಸ್ ಔಟ್ ದಾಟಿದರೆ ತದನಂತರ ಹೊಸ ಗದ್ದಲ ಪಟ್ಟಿ ಸೆಳೆಯುತ್ತದೆ.

176
00:11:15,320 --> 00:11:19,620
ಆದರೆ ಇದರ ಒಳಗೆ ಲೂಪ್ ನಾವು ಹೆಚ್ಚು ಈಗ ಸ್ವಲ್ಪ ಮಾಡುತ್ತಿರುವುದು ಎಂದು ಗಮನಿಸಿ.

177
00:11:19,620 --> 00:11:25,000
ನಾವು ಮೂಲತಃ ಇತ್ ಟೊಡೊ ಗೆ ಐಟಂ ಅನುಗುಣವಾದ ಎಂಬುದನ್ನು ಇಲ್ಲಿ ತಪಾಸಣೆ ನೀವು

178
00:11:25,000 --> 00:11:30,220
ಪೂರ್ಣಗೊಂಡ, ಮತ್ತು ನಾವು ಈ 2 ಸಂದರ್ಭಗಳಲ್ಲಿ ವಿಭಿನ್ನವಾಗಿ ವರ್ತಿಸುವ ನೀವು.

179
00:11:30,220 --> 00:11:32,790
ಇದು ಸಂಪೂರ್ಣ ಇಲ್ಲಿದೆ, ನಾವು, ಈ ಡೆಲ್ ಟ್ಯಾಗ್ ಸೇರಿಸಿ ನೀವು

180
00:11:32,790 --> 00:11:35,360
ಇದು ಮೂಲತಃ ನೀವು ಪರಿಣಾಮವನ್ನು ಮೂಲಕ ಎಂದು ಮುಷ್ಕರ ಪಡೆಯುವುದು ದಾರಿ

181
00:11:35,360 --> 00:11:38,190
ಇದು ಸಂಪೂರ್ಣ ಇಲ್ಲಿದೆ ವೇಳೆ ಗದ್ದಲ ಪಟ್ಟಿ ಔಟ್ ದಾಟಿ

182
00:11:38,190 --> 00:11:42,200
ಇದು ಅಲ್ಲ ವೇಳೆ ಮತ್ತು, ನಾವು ಸೇರಿದಂತೆ ಇಲ್ಲ.

183
00:11:42,200 --> 00:11:45,030
ಮತ್ತು ಆದ್ದರಿಂದ ಆ ರೀತಿಯ, ಎಂದು ಆರೈಕೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

184
00:11:45,030 --> 00:11:49,140
>> ಮತ್ತು ಈ ಸಾಧಿಸಲು ಒಂದು ಮಾರ್ಗವಾಗಿದೆ.

185
00:11:49,140 --> 00:11:53,420
ಬಳಕೆದಾರ ಇವುಗಳಲ್ಲಿ ಒಂದನ್ನು ಒತ್ತಿದಾಗ ತದನಂತರ ಗಮನಕ್ಕೆ

186
00:11:53,420 --> 00:11:56,780
ನಾವು ಪೂರ್ಣಗೊಂಡ ಸ್ಥಿತಿ ಟಾಗಲ್.

187
00:11:56,780 --> 00:12:02,170
ಬಳಕೆದಾರರ ಕ್ಲಿಕ್, ನಾವು ಅದನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ಅಥವಾ ಮಾಡಲಾಗಿದೆ ಎಂಬುದನ್ನು ರಿವರ್ಸ್ ಮಾಡಿದಾಗ,

188
00:12:02,170 --> 00:12:04,540
ತದನಂತರ ನಾವು ಪುನರ್ಚಿತ್ರಿಸಿದ ಮಾಡುತ್ತೇವೆ.

189
00:12:04,540 --> 00:12:06,190
ಕೃತಿಗಳ ಈ ರೀತಿಯ.

190
00:12:06,190 --> 00:12:09,860
ನಾವು, ತಮ್ಮ ಕಾರ್ಯಗಳನ್ನು ಕೈಗೊಳ್ಳಲು ಈ ಕಾರ್ಯಗಳನ್ನು

191
00:12:09,860 --> 00:12:11,730
ಮತ್ತು ಈ ತಪ್ಪಿಲ್ಲ.

192
00:12:11,730 --> 00:12:14,110
ನಾವು ಆದರೂ, ಈ ಬಗ್ಗೆ ಉತ್ತಮ ಮಾಡಬಲ್ಲರು ಇದೆಯೇ?

193
00:12:14,110 --> 00:12:18,700
ಈ 2 ಜಾಗತಿಕ ರಚನೆಗಳು ಹೊಂದಿರುತ್ತವೆ ಗಮನಿಸಿ.

194
00:12:18,700 --> 00:12:23,550
ಈ ಸಿ ಮತ್ತು ನಾವು ರೀತಿಯ ನಿರೂಪಿಸಲಾಗಿದೆ 2 ರಚನೆಗಳು ಹೊಂದಿದ್ದರೆ

195
00:12:23,550 --> 00:12:25,800
ರೀತಿಯ ಕೆಲವು ರೀತಿಯಲ್ಲಿ ಸಂಬಂಧಿಸಿದ ಎಂದು ದಶಮಾಂಶ

196
00:12:25,800 --> 00:12:30,140
ಈ 2 ಜಾಗ ಸಂಯೋಜನ ಸಿ ಏನು ಬಳಸಬಹುದು

197
00:12:30,140 --> 00:12:35,420
ಮಾಹಿತಿ ಎರಡೂ ತುಂಡುಗಳನ್ನು encapsulates ಏನೋ ಆಗಿ?

198
00:12:35,420 --> 00:12:37,600
ಯಾರಾದರೂ ಒಂದು ಸಲಹೆ ಮಾಡಲು ಬಯಸುವಿರಾ?

199
00:12:37,600 --> 00:12:39,450
[ವಿದ್ಯಾರ್ಥಿ ಕೇಳಿಬರುವುದಿಲ್ಲ ಪ್ರತಿಕ್ರಿಯೆ]

200
00:12:39,450 --> 00:12:42,340
>> ನಿಖರವಾಗಿ, ಆದ್ದರಿಂದ ನಾವು, struct ಕೆಲವು ರೀತಿಯ ಬಳಸಬಹುದಾಗಿತ್ತು

201
00:12:42,340 --> 00:12:44,960
ಮತ್ತು ನೀವು pset 3, ಹೇಳುತ್ತಾರೆ, ಮತ್ತೆ ಆಲೋಚಿಸುತ್ತೀರಿ, ವೇಳೆ

202
00:12:44,960 --> 00:12:47,350
ನಾವು ನಿಘಂಟು ಹೊಂದಿತ್ತು, ಮತ್ತು ನಂತರ ನಾವು ಮರೆಯದಿರಿ ಎಂದು ಪದ

203
00:12:47,350 --> 00:12:50,230
ನಿಘಂಟು ರಲ್ಲಿ, ಮತ್ತು ಎಲ್ಲಾ ಮಾಹಿತಿಯನ್ನು ಒಂದುಗೂಡಿತು

204
00:12:50,230 --> 00:12:52,420
ಕೆಲವು ದಶಮಾಂಶ ರಚನೆಯ ಒಳಗೆ.

205
00:12:52,420 --> 00:12:56,390
ಈ ಕೋಡ್ ಮಾಡಲು ಸಾಧ್ಯ ಒಂದು ವಿಷಯ ಈ 2 ವಿವಿಧ ರಚನೆಗಳು ಹೊಂದಿರುವ ತಪ್ಪಿಸಲು

206
00:12:56,390 --> 00:13:01,760
ಮಾಹಿತಿಯನ್ನು ರೀತಿಯ ಕಾಯಿಗಳಿಗಾಗಿ ನಾನು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಸ್ತು ಅವುಗಳನ್ನು ಒಂದುಗೂಡಿಸಬಹುದು ಆಗಿದೆ.

207
00:13:01,760 --> 00:13:07,150
ಅವರ ಆ ಒಂದು ಗಮನಿಸೋಣ.

208
00:13:07,150 --> 00:13:11,740
ನಾನು ಈಗ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿವೆ ಗಮನಿಸಿ

209
00:13:11,740 --> 00:13:17,650
ಮತ್ತು ನಾನು ಮಾಡಿದ ಆಗಿದೆ ಮತ್ತು ಈ ಕೇವಲ ರೀತಿಯ ಫಾರ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಾಕ್ಯ ಆಗಿದೆ

210
00:13:17,650 --> 00:13:21,350
ವಸ್ತುವಿನ ಒಂದು ಅಕ್ಷರಶಃ ಆವೃತ್ತಿ ಸೃಷ್ಟಿಸುತ್ತದೆ

211
00:13:21,350 --> 00:13:24,670
ಮತ್ತು, ಆದ್ದರಿಂದ ನಾವು ಟೊಡೊ ಹೊಂದಿವೆ, 2 ಗುಣಲಕ್ಷಣಗಳು ಇವೆ ಗಮನಕ್ಕೆ

212
00:13:24,670 --> 00:13:29,660
ಮತ್ತು ಅದು ಸಂಪೂರ್ಣ ಅಥವಾ ಅಪೂರ್ಣ ಇಲ್ಲಿದೆ ಎಂದು ಜೊತೆ ಇದ್ದರು ವಿಶೇಷವೇನು.

213
00:13:29,660 --> 00:13:31,000
ಈ ಹೋಲುತ್ತದೆ ಸಂಕೇತಗಳನ್ನು.

214
00:13:31,000 --> 00:13:35,310
ನಾವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಸ್ತುಗಳು ಬಳಸುತ್ತಿದ್ದರೆ.

215
00:13:35,310 --> 00:13:38,600
ಸುಧಾರಿಸುತ್ತದೆ ವಸ್ತುಗಳ ಈ ರೀತಿಯ.

216
00:13:38,600 --> 00:13:43,850
ಈಗ ಹಾಗೆ, ಸಂಬಂಧಿತ ಮಾಹಿತಿ ಎಲ್ಲಾ ಈ ಜಾಗ ಒಟ್ಟಿಗೆ ಇರಿಸಲಾಗುತ್ತದೆ.

217
00:13:43,850 --> 00:13:46,410
ನಾವು ಮುದ್ರಿಸುತ್ತದೆ ಹೋದಾಗ, ನಾವು ಜಾಗ ಪ್ರವೇಶಿಸಬಹುದು.

218
00:13:46,410 --> 00:13:49,060
>> ನಾವು todos [ನಾನು] ಮಾಡುತ್ತಿರುವುದು ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಸಂಪೂರ್ಣ

219
00:13:49,060 --> 00:13:52,880
ಬದಲಿಗೆ ಪ್ರತ್ಯೇಕವಾಗಿ ಸಂಪೂರ್ಣ ರಚನೆಯ ಪರಿಶೀಲಿಸುವ,

220
00:13:52,880 --> 00:13:56,560
ಮತ್ತು ನಾವು ಗದ್ದಲ ಆಸ್ತಿ ಪಡೆಯುತ್ತಿದ್ದೀರಿ ಗದ್ದಲ ಸ್ಟ್ರಿಂಗ್ ಪಡೆಯಲು ಬಯಸಿದಾಗ ಗಮನಕ್ಕೆ

221
00:13:56,560 --> 00:13:58,750
ಆ ಟೊಡೊ ಆಫ್, ಆದ್ದರಿಂದ ಈ ರೀತಿಯ ಸಮಂಜಸವೇ ಏಕೆಂದರೆ

222
00:13:58,750 --> 00:14:01,660
ಪ್ರತಿ ಐಟಂ ಅದರ ಬಗ್ಗೆ ಈ ಸ್ವಾಭಾವಿಕ ಗುಣಗಳನ್ನು ಹೊಂದಿದೆ.

223
00:14:01,660 --> 00:14:05,650
ಇದು ಟೊಡೊ ಹೊಂದಿದೆ, ಮತ್ತು ಇದು ಸಂಪೂರ್ಣ ಅಥವಾ ಅಲ್ಲ ಎಂದು ಹೊಂದಿದೆ.

224
00:14:05,650 --> 00:14:11,540
ಮಾಡಿರುವುದಿಲ್ಲ ಹಲವಾರು ಬದಲಾವಣೆಗಳು ಕಾರ್ಯತತ್ಪರವಾಗಿಲ್ಲದಿರಬಹುದು, ಕೇವಲ ಕೋಡ್ ಕೆಲವು ಹೆಚ್ಚು ಸೇರಿಸಲಾಗಿದೆ.

225
00:14:11,540 --> 00:14:13,430
ಈ ಬಲ, ಕೆಲವು ರಂಗಗಳಲ್ಲಿ ಒಂದು ಸುಧಾರಣೆ?

226
00:14:13,430 --> 00:14:16,030
ನಾನು ಬಿಟ್ ವಿನ್ಯಾಸ ಔಟ್ ನಾವು factored, ಅರ್ಥ.

227
00:14:16,030 --> 00:14:20,350
ಈಗ ನಾವು ಮೂಲತಃ ಈ ಡೇಟಾವನ್ನು ಕೋಶೀಕರಿಸುತ್ತದೆ ಗೆ ವಸ್ತುಗಳನ್ನು ಹೊಂದಿಲ್ಲ.

228
00:14:20,350 --> 00:14:27,130
ನಾವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದೃಷ್ಟಿಯಿಂದ ಇಲ್ಲಿಂದ ಮಾಡಬಲ್ಲರು ಹೆಚ್ಚು ಇದೆಯೇ?

229
00:14:27,130 --> 00:14:31,810
ಲೈಕ್ ಸೂಚನೆ ಎಂದು ಇಲ್ಲಿಯೇ ಈ ಕೋಡ್

230
00:14:31,810 --> 00:14:34,760
ಒಂದು DIV ಒಳ ಎಚ್ಟಿಎಮ್ಎಲ್ ಫಾರ್ ಗೆಟ್ಟಿಂಗ್

231
00:14:34,760 --> 00:14:40,520
ಸ್ವಲ್ಪ, ನಾನು ಭಾವಿಸುತ್ತೇನೆ, ಉದ್ದವಾಗಿದೆ.

232
00:14:40,520 --> 00:14:45,100
Document.getElementByID ("todos") ಇಲ್ಲ. InnerHTML.

233
00:14:45,100 --> 00:14:48,400
ಈ ಕೋಡ್ ಒಂದು ಸ್ವಲ್ಪ ಸ್ನೇಹಮಯಿಯನ್ನಾಗಿ ಕಾಣುವಂತೆ ಮಾಡಲು ಒಂದು ವಿಷಯ

234
00:14:48,400 --> 00:14:51,450
ಆದ್ದರಿಂದ ನಾನು, ಹಿಂದಕ್ಕೆ ಮತ್ತು ಮುಂದಕ್ಕೆ, ಸ್ಕ್ರೋಲಿಂಗ್ ಎಡ ಮತ್ತು ಬಲ ಇರಿಸಿಕೊಳ್ಳಲು ಇರುತ್ತಿರಲಿಲ್ಲ

235
00:14:51,450 --> 00:14:58,480
ನಾನು jQuery ಒಂದು ಗ್ರಂಥಾಲಯದ ಬಳಸಬಹುದಾಗಿತ್ತು ಆಗಿದೆ.

236
00:14:58,480 --> 00:15:02,710
>> ತಂದೆಯ ಸೆಮಿನಾರ್ 2 ಔಟ್ ಪರೀಕ್ಷಿಸೋಣ

237
00:15:02,710 --> 00:15:05,880
ಮತ್ತು ಇದೇ ಸಂಕೇತ, ಆದರೆ ಇದು jQuery ನಿಲ್ಲಿಸುವುದಾಗಿ ಅವನು.

238
00:15:05,880 --> 00:15:08,790
ನೀವು, jQuery ಅತಿ ಪರಿಚಿತ ಇರಬಹುದು

239
00:15:08,790 --> 00:15:11,510
ಆದರೆ ಕೇವಲ jQuery ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಒಂದು ಗ್ರಂಥಾಲಯದ ರೀತಿಯ ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ

240
00:15:11,510 --> 00:15:15,910
ಎಂದು ಸುಲಭವಾಗಿ ಡಾಮ್ ಪ್ರವೇಶ ಪ್ರತ್ಯೇಕ ಅಂಶಗಳು ರೀತಿಯ ಕೆಲಸಗಳನ್ನು ಮಾಡುತ್ತದೆ.

241
00:15:15,910 --> 00:15:21,280
ಇಲ್ಲಿ ಬದಲಿಗೆ document.getElementByID ಹೇಳುವುದರ ("todos"). InnerHTML

242
00:15:21,280 --> 00:15:25,210
ನಾನು, jQuery ಹೆಚ್ಚು ಕ್ಲೀನರ್ ರೀತಿಯಲ್ಲಿ ಬಳಸಬಹುದು

243
00:15:25,210 --> 00:15:28,490
ಇದು ಕೇವಲ ಆಯ್ಕೆ ಬಳಸುವುದು.

244
00:15:28,490 --> 00:15:31,300
ನೀವು ನೋಡಬಹುದು ಎಂದು, ಈ ಕೋಡ್, ಸ್ವಲ್ಪ ಕ್ಲೀನರ್ ಬಂದೆವು

245
00:15:31,300 --> 00:15:35,770
ತುಂಬಾ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಹೋಲುತ್ತದೆ, ಆದರೆ ಆ ಉಪಾಯ.

246
00:15:35,770 --> 00:15:37,980
ನಾವು ಇದುವರೆಗೆ ವಸ್ತುಗಳ ಒಂದೆರಡು ನೋಡಿದ

247
00:15:37,980 --> 00:15:42,010
ಆದ್ದರಿಂದ ನಾವು ಕಚ್ಚಾ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅನುಷ್ಠಾನ ಪ್ರಾರಂಭವಾಯಿತು.

248
00:15:42,010 --> 00:15:45,370
ನಾವು ಹೊಸ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಸೇರಿಸಲಾಗಿದೆ ಮತ್ತು ನಾವು ಅದನ್ನು ಸುಧಾರಿಸಲು ಹೇಗೆ ತೋರಿಸಿದರು

249
00:15:45,370 --> 00:15:49,090
ಕೇವಲ ನಾವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ರಲ್ಲಿ ಹೊಂದಿರುತ್ತವೆ.

250
00:15:49,090 --> 00:15:53,300
>> ಯಾರಾದರೂ ಈ ವಿನ್ಯಾಸದ ಯಾವುದೇ ತೊಂದರೆಗಳನ್ನು ನೋಡಿ ಡಸ್?

251
00:15:53,300 --> 00:16:01,090
ಅವುಗಳೆಂದರೆ, ನನ್ನ ಊಹೆಯ ಅಥವಾ ತೊಂದರೆಗಳನ್ನು ಎಂದೇನೂ ಆದರೆ ಹೇಳಲು ನಾವು

252
00:16:01,090 --> 00:16:04,830
ನಾವು ಒಂದು ಗದ್ದಲ ಪಟ್ಟಿ ಯೋಜನೆಯ ಮಾಡುತ್ತಿರಲಿಲ್ಲ ಮತ್ತು ನಾಳೆ ನಾವು ನಿರ್ಧರಿಸಿದ್ದಾರೆ

253
00:16:04,830 --> 00:16:10,320
ನಾವು ಒಂದು ದಿನಸಿ ಪಟ್ಟಿ ಅಥವಾ ಒಂದು ಶಾಪಿಂಗ್ ಪಟ್ಟಿಯನ್ನು ಯೋಜನೆಯನ್ನು ಮಾಡಲು ಬಯಸಿದ್ದರು.

254
00:16:10,320 --> 00:16:14,150
ಈ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಹಳಷ್ಟು ಇವೆ.

255
00:16:14,150 --> 00:16:19,080
ನಾವು JavaScript ನ ಔಟ್ ಪಡೆಯಲು ಬಯಸುವ ವಸ್ತುಗಳ ಬಹಳಷ್ಟು ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾಗಿವೆ

256
00:16:19,080 --> 00:16:23,820
ಮತ್ತು ಈ ರೀತಿಯಲ್ಲಿ ಕೆಲವು ರೀತಿಯ ಅಗತ್ಯತೆಯನ್ನು ಒತ್ತಿಹೇಳುತ್ತದೆ

257
00:16:23,820 --> 00:16:25,670
ಮಾಡಲು ಈ ಸುಲಭಗೊಳಿಸುತ್ತದೆ.

258
00:16:25,670 --> 00:16:30,400
ನಾನು, ಈ HTML ಪ್ರವೇಶವನ್ನು ಎಲ್ಲಾ ನಿರ್ಮಿಸಲು ಎಲ್ಲಾ ಈ DOM ಕಲ್ಪಿಸಲಾಯಿತು

259
00:16:30,400 --> 00:16:35,530
ನಾನು ಈ ಮಾದರಿಯ ಗದ್ದಲ ಪಟ್ಟಿ ಪ್ರತಿನಿಧಿಸಲು ಹೋಗುವ ಬಾಗುತ್ತೇನೆ ಹಾಗೆ.

260
00:16:35,530 --> 00:16:39,130
ಮತ್ತು ನಾನು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪರ್ ಮಾಹಿತಿ ಜವಾಬ್ದಾರಿ ಮನುಷ್ಯ ಗಮನಕ್ಕೆ

261
00:16:39,130 --> 00:16:42,890
ನಾನು ಸಿಂಕ್ ರಲ್ಲಿ ಹೊಂದಿರುವ HTML ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇರಿಸಿಕೊಳ್ಳಬೇಕಾದ.

262
00:16:42,890 --> 00:16:48,040
ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಇಲ್ಲ ಎಂದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾತಿನಿಧ್ಯ

263
00:16:48,040 --> 00:16:51,590
ಅಥವಾ ಗದ್ದಲ ಪಟ್ಟಿಯಲ್ಲಿ HTML ಗೆ ಹೊರಹಾಕಲ್ಪಟ್ಟ ಪಡೆಯುತ್ತೀರಿ.

264
00:16:51,590 --> 00:16:54,000
ಏನೂ ನನಗೆ ಹೊರತುಪಡಿಸಿ ಜಾರಿಗೊಳಿಸಲಾಗಿದೆ.

265
00:16:54,000 --> 00:16:56,880
ನಾನು ಪಟ್ಟಿ ಕಾರ್ಯ ಮಾಡಬೇಕಾದವೆಂದು ಡ್ರಾ ಬರೆಯಬೇಕಾಗಿತ್ತು.

266
00:16:56,880 --> 00:17:01,650
ಮತ್ತು ಅರ್ಥ ನಾನು ಇರಬೇಕು, ಅದು, ಹಾಗೆ ಸಮಂಜಸ ಇಲ್ಲಿದೆ ಇರಬಹುದು ಎಂದು

267
00:17:01,650 --> 00:17:03,670
ಆದರೆ ಇದು ಕೆಲವೊಮ್ಮೆ ಬೇಸರದ ಇರಬಹುದು.

268
00:17:03,670 --> 00:17:08,190
ನೀವು ಒಂದು ದೊಡ್ಡ ಯೋಜನೆ ಇದ್ದರೆ, ಆ ಕಷ್ಟವಾಗುತ್ತದೆ.

269
00:17:08,190 --> 00:17:10,720
>> ಚೌಕಟ್ಟುಗಳು, ಚೌಕಟ್ಟುಗಳ ಉದ್ದೇಶಗಳಲ್ಲಿ ಒಂದು

270
00:17:10,720 --> 00:17:14,060
ಫ್ಯಾಕ್ಟರ್ನ ಪ್ರಕ್ರಿಯೆಯ ಮತ್ತು ರೀತಿಯ ಔಟ್ ಸರಳಗೊಳಿಸುವ ಆಗಿದೆ

271
00:17:14,060 --> 00:17:16,950
ಈ ಸಾಮಾನ್ಯ ನಾನು ನೀವು ಸಾಧ್ಯವೋ ಹೇಳುತ್ತಾರೆ ವಿನ್ಯಾಸ ಮಾದರಿಗಳನ್ನು ಊಹೆ

272
00:17:16,950 --> 00:17:20,700
ಜನರು ಸಾಮಾನ್ಯವಾಗಿ, ದಶಮಾಂಶ ಪ್ರತಿನಿಧಿಸುವ ರೀತಿಯಲ್ಲಿ ಕೆಲವು ರೀತಿಯ ಹೊಂದಿವೆ

273
00:17:20,700 --> 00:17:25,599
ಆ ನಕ್ಷೆ ಮಾಹಿತಿ ಇಲ್ಲಿದೆ ಎಂದು, ಒಂದು ಸ್ನೇಹಿತರ ಪಟ್ಟಿಯಿಂದ ಇಲ್ಲಿದೆ ಎಂದು

274
00:17:25,599 --> 00:17:27,280
ಅಥವಾ ಏನೋ ಅಥವಾ ಒಂದು ಗದ್ದಲ ಪಟ್ಟಿ.

275
00:17:27,280 --> 00:17:30,660
ಕೆಲವರು, ಸಾಮಾನ್ಯವಾಗಿ ಮಾಹಿತಿ ಪ್ರತಿನಿಧಿಸುವ ಒಂದು ರೀತಿಯಲ್ಲಿ ಹೊಂದಿವೆ

276
00:17:30,660 --> 00:17:33,650
ಮತ್ತು ಅವರು ಸಾಮಾನ್ಯವಾಗಿ ಸಿಂಕ್ ಆ ಮಾಹಿತಿ ರೀತಿಯ ಇರಿಸಿಕೊಳ್ಳಲು ಅಗತ್ಯವಿದೆ

277
00:17:33,650 --> 00:17:36,520
ಬಳಕೆದಾರ ನೋಟದ ಕೆಲವು ರೀತಿಯ ನೋಡುತ್ತಾನೆ ಏನು ನಡುವೆ,

278
00:17:36,520 --> 00:17:39,850
ನೀವು ಉಪನ್ಯಾಸದಲ್ಲಿ ಕಂಡಿದ್ದು ಮಾದರಿ ವೀಕ್ಷಿಸಿ ನಿಯಂತ್ರಕ ರೀತಿಯ ಪರಿಭಾಷೆಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ,

279
00:17:39,850 --> 00:17:45,400
ತದನಂತರ ಈ ಸಂದರ್ಭದಲ್ಲಿ ಈ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಶ್ರೇಣಿಯನ್ನು ಇದು ಮಾದರಿ.

280
00:17:45,400 --> 00:17:49,020
ಚೌಕಟ್ಟುಗಳು ಆ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಒಂದು ದಾರಿ.

281
00:17:49,020 --> 00:17:53,080
ಈಗ ಪಟ್ಟಿಯಲ್ಲಿ ಮಾಡಬೇಕಾದವೆಂದು ಈ ಅನುಷ್ಠಾನಕ್ಕೆ ನಲ್ಲಿ ಅವಲೋಕಿಸೋಣ

282
00:17:53,080 --> 00:18:02,360
angularjs ಎಂಬ ಚೌಕಟ್ಟಿನಲ್ಲಿ.

283
00:18:02,360 --> 00:18:04,650
ಇದು ಹೊಂದಿದೆ. ಇದು ಒಂದು ಸ್ಲೈಡ್ ಮೇಲೆ ಸೂಕ್ತವಾದ ಗಮನಿಸಿ.

284
00:18:04,650 --> 00:18:07,330
ನಾನು ಎಡ ಮತ್ತು ಬಲಕ್ಕೆ ಸ್ಕ್ರೋಲ್ ಇಲ್ಲ.

285
00:18:07,330 --> 00:18:10,460
ಅದು ಬಹುಶಃ, ಚೌಕಟ್ಟನ್ನು ಬಳಸಿಕೊಂಡು ಶಿಫಾರಸು ಮಾಡಲು ಒಂದು ದೊಡ್ಡ ಕಾರಣ ಅಲ್ಲ

286
00:18:10,460 --> 00:18:20,120
ಆದರೆ ಸೂಚನೆ ನಾನು ಇಲ್ಲಿ ಮಾಲಿಕ ಎಚ್ಟಿಎಮ್ಎಲ್ ಘಟಕಗಳು ಪ್ರವೇಶಿಸುವ ನಾನು?

287
00:18:20,120 --> 00:18:22,400
ನಾನು DOM ಹೋಗುವಾಗ ಆಮ್?

288
00:18:22,400 --> 00:18:26,120
ಆ ರೀತಿಯ ಯಾವುದೇ document.getElementByID ಅಥವಾ ಏನೋ ನೋಡಿ ಡು?

289
00:18:26,120 --> 00:18:29,870
ಇಲ್ಲ, ಆ ಗಾನ್.

290
00:18:29,870 --> 00:18:35,590
>> ಕೋನೀಯ ನಮಗೆ DOM ಮತ್ತು ಏನೋ ನಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾತಿನಿಧ್ಯ ಇರಿಸಿಕೊಳ್ಳಲು ಸಹಾಯ

291
00:18:35,590 --> 00:18:40,430
ಸಿಂಕ್ ರಲ್ಲಿ ರೀತಿಯ, ಇದು, JS ಕಡತದಲ್ಲಿ ಅಲ್ಲ ಹಾಗಿದ್ದಲ್ಲಿ

292
00:18:40,430 --> 00:18:46,790
ಸರಣಿಬದ್ಧವಾಗಿ ಎಲ್ಲಾ ಎಚ್ಟಿಎಮ್ಎಲ್ ವಿಷಯಕ್ಕೆ ಮಾಡುವ ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ಅಲ್ಲಿ ಇಲ್ಲಿದೆ ವೇಳೆ

293
00:18:46,790 --> 00:18:51,800
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನಿಂದ ಹೇಗೆ ನಾವು ಸಿಂಕ್ ಈ ಕೀಪಿಂಗ್ ಮಾಡಲಾಗುತ್ತದೆ?

294
00:18:51,800 --> 00:18:58,160
ಇದು. JS ಕಡತದಲ್ಲಿ ಅಲ್ಲ ವೇಳೆ, ಇದು ಬಲ, HTML ನಲ್ಲಿ ಎಂದು ಸಿಕ್ಕಿತು ವಿಶೇಷವೇನು?

295
00:18:58,160 --> 00:19:01,910
ಇದು HTML ಫೈಲ್ ಹೊಸ ಆವೃತ್ತಿಯಾಗಿದೆ

296
00:19:01,910 --> 00:19:04,660
ಮತ್ತು ನಾವು ಇಲ್ಲಿ ಬಹಳಷ್ಟು ಸೇರಿಸಿದ ಗಮನಿಸಿ.

297
00:19:04,660 --> 00:19:11,110
Ng ಕ್ಲಿಕ್ ಹಾಗೂ ng-ಮತ್ತೆ ಹೇಳುತ್ತಾರೆ ಈ ಹೊಸ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಇಲ್ಲ ಗಮನಿಸಿ.

298
00:19:11,110 --> 00:19:15,650
ವಿನ್ಯಾಸದಲ್ಲಿ ಕಷ್ಟಗಳನ್ನು ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಬಹುದು ಕೋನೀಯ ತಂದೆಯ ವಿಧಾನ

299
00:19:15,650 --> 00:19:19,130
ಮೂಲತಃ HTML ಹೆಚ್ಚು ಪ್ರಬಲ ಮಾಡುವುದು.

300
00:19:19,130 --> 00:19:24,420
ಕೋನೀಯ ನೀವು HTML ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಅಭಿವ್ಯಕ್ತಿಗೆ ಮಾಡಲು ಅವಕಾಶ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ.

301
00:19:24,420 --> 00:19:30,520
ಉದಾಹರಣೆಗೆ, ನಾನು ಈ ಪಠ್ಯ ಬಾಕ್ಸ್ನಲ್ಲಿ ಷರತ್ತು ಅಥವಾ ಬೈಂಡ್ ಹೋಗುವ ಬಾಗುತ್ತೇನೆ ಎಂದು ಹೇಳಬಹುದು

302
00:19:30,520 --> 00:19:35,080
ನನ್ನ ಕೋನೀಯ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಒಂದು ವೇರಿಯೇಬಲ್ ಗೆ.

303
00:19:35,080 --> 00:19:37,030
ಈ ng-ಮಾದರಿ ಕೇವಲ ಮಾಡುತ್ತದೆ.

304
00:19:37,030 --> 00:19:41,550
ಮೂಲಭೂತವಾಗಿ ಹೇಳುತ್ತದೆ ಐಟಂ ಈ ಪಠ್ಯ ಪೆಟ್ಟಿಗೆಯ ಒಳಗೆ, ಆ

305
00:19:41,550 --> 00:19:45,000
ಕೇವಲ ವೇರಿಯಬಲ್ new_todo_description ಆ ಸಂಯೋಜಿಸಲು

306
00:19:45,000 --> 00:19:47,870
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಒಳಗೆ.

307
00:19:47,870 --> 00:19:51,600
ನಾನು ಸ್ಪಷ್ಟವಾಗಿ ಹೋಗಲು ಹೊಂದಿಲ್ಲ ಏಕೆಂದರೆ ಅದು ಅತ್ಯಂತ ಶಕ್ತಿಯುತ ಇಲ್ಲಿದೆ

308
00:19:51,600 --> 00:19:53,310
DOM ಎಂದು ಮಾಹಿತಿ ಪಡೆಯಲು.

309
00:19:53,310 --> 00:19:56,250
ನಾನು document.getElementByID ಹೇಳಲು ಇಲ್ಲ.

310
00:19:56,250 --> 00:19:58,750
ನಾನು DOM ಪ್ರವೇಶಾನುಮತಿಗಳ jQueries ಬಳಸಲು ಹೊಂದಿಲ್ಲ.

311
00:19:58,750 --> 00:20:03,280
ನಾನು ವೇರಿಯಬಲ್ ಬದಲಾದಾಗ ನಾನು ಒಂದು ವೇರಿಯಬಲ್ ಇದನ್ನು ಸಂಯೋಜಿಸಲು, ಮತ್ತು ಮಾಡಬಹುದು

312
00:20:03,280 --> 00:20:07,400
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಒಳಗೆ, ಎಚ್ಟಿಎಮ್ಎಲ್ ಸಿಂಕ್ ಇರಿಸಲಾಗಿತ್ತು ವಿಶೇಷವೇನು

313
00:20:07,400 --> 00:20:11,640
ಆದ್ದರಿಂದ ಎರಡು ನಡುವೆ ಹಿಂದಕ್ಕೆ ಮತ್ತು ಮುಂದಕ್ಕೆ ಹೋಗಲು ಹೊಂದುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.

314
00:20:11,640 --> 00:20:18,260
ಆ ಅರ್ಥದಲ್ಲಿ ಮಾಡಲು ಡಸ್?

315
00:20:18,260 --> 00:20:22,060
>> ಮತ್ತು ಯಾವುದೇ HTML ಪ್ರವೇಶ ಕೋಡ್ ಇತ್ತು ಗಮನಿಸಿ.

316
00:20:22,060 --> 00:20:27,760
ನಾವು ಕೇವಲ HTML ಹೆಚ್ಚಿನ ಶಕ್ತಿಶಾಲಿ ಮಾಡಿದ

317
00:20:27,760 --> 00:20:32,070
ಮತ್ತು ಈಗ, ಉದಾಹರಣೆಗೆ, ನಾವು, ಈ ರೀತಿಯ ಕೆಲಸಗಳನ್ನು ಮಾಡಬಹುದು

318
00:20:32,070 --> 00:20:38,610
ಈ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ, todos.js ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಈ ಕಾರ್ಯವನ್ನು ಕರೆ ಇಷ್ಟ,

319
00:20:38,610 --> 00:20:43,410
ಮತ್ತು, ಈ ng-ಮಾದರಿಯ ಹಾಗೆ, ನಾವು ಮೊದಲು ಹಾಗೆ, ಆದರೆ ಇತರ ವಿಷಯಗಳನ್ನು

320
00:20:43,410 --> 00:20:47,020
ಮತ್ತು ಈ ng-ಮತ್ತೆ ಗಮನಿಸಬಹುದು.

321
00:20:47,020 --> 00:20:51,520
ನೀವು ಈ ಏನು ಆಲೋಚಿಸುತ್ತೀರಿ ಏನು?

322
00:20:51,520 --> 00:20:54,390
ಇಲ್ಲಿ ಮೊದಲು ನಮ್ಮ unordered ಪಟ್ಟಿ ಇಲ್ಲಿದೆ.

323
00:20:54,390 --> 00:20:56,470
ನಾವು, ಉಲ್ ಟ್ಯಾಗ್ಗಳನ್ನು ಹೊಂದಿವೆ

324
00:20:56,470 --> 00:21:03,710
ಆದರೆ ನಾನು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಒಳಗೆ ಎಂದು ಪಟ್ಟಿ ಸಲ್ಲಿಕೆ ನಾನು?

325
00:21:03,710 --> 00:21:09,280
ನಾನು ಸ್ಪಷ್ಟವಾಗಿ ಎಂದು ಪಟ್ಟಿ ಸಲ್ಲಿಕೆ ನನಗಿಲ್ಲ.

326
00:21:09,280 --> 00:21:11,580
ಈ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ?

327
00:21:11,580 --> 00:21:16,410
ಸರಿ, ದಾರಿ ಕೋನೀಯ ಈ ಒಂದು ಪುನರಾವರ್ತಕ ಕರೆಯಲಾಗುತ್ತದೆ ಯನ್ನು ಒಳಗೊಂಡಿದೆ.

328
00:21:16,410 --> 00:21:22,760
ಮೂಲತಃ ನಾನು ಈ HTML ಮುದ್ರಿಸಲು ಬಯಸುವ ಹೇಳುತ್ತಾರೆ

329
00:21:22,760 --> 00:21:26,240
ನನ್ನ todos ರಚನೆಯ ಪ್ರತಿ ಟೊಡೊ ಒಳಗಿನ.

330
00:21:26,240 --> 00:21:31,850
Todos.jr ಒಳಗಿನ todos ಸರಣಿ, ಇಲ್ಲಿಯೇ ಇರುತ್ತದೆ

331
00:21:31,850 --> 00:21:37,910
ಮತ್ತು ಈ ಆ ರಚನೆಯ ಮೂಲಕ ಕೋನೀಯ GO ಹೇಳುತ್ತವೆ, ಮತ್ತು ಪ್ರತಿ ಅಂಶ ಅನ್ನು ನೋಡಿ

332
00:21:37,910 --> 00:21:41,390
ನಾನು ನೀವು ಈ HTML ಮುದ್ರಿಸಲು ಬಯಸುವ.

333
00:21:41,390 --> 00:21:44,620
ನಾನು ಇದನ್ನು ಕೇವಲ ಏಕೆಂದರೆ ಈ ನಾಡಿದು ರೀತಿಯ

334
00:21:44,620 --> 00:21:47,760
ಲೂಪ್ ಒಂದು ಬರೆಯುವ ಅಗತ್ಯವೇ ಇಲ್ಲದೇ,

335
00:21:47,760 --> 00:21:52,250
ಇದು ಕೋಡ್ ಕೇವಲ 30 ಸಾಲುಗಳನ್ನು ಎಂದು ಒಂದು ಗದ್ದಲ ಪಟ್ಟಿಗಾಗಿ

336
00:21:52,250 --> 00:21:54,700
ಅತ್ಯಂತ ಅನುಕೂಲಕರ ವಿಷಯ ಇರಬಹುದು,

337
00:21:54,700 --> 00:22:01,240
ನೀವು ಒಂದು ದೊಡ್ಡ ಯೋಜನೆಯನ್ನು ಹೊಂದಿದ್ದರೆ ಆದರೆ, ಈ ಬಹಳ ಅನುಕೂಲಕರ ಸಾಧ್ಯವಾಯಿತು.

338
00:22:01,240 --> 00:22:06,100
>> ಈ HTML ಹೆಚ್ಚು ಶಕ್ತಿಯುತ ಮಾಡುವ, ಈ ಸಮಸ್ಯೆಗೆ ಒಂದು ಪರಿಹಾರ,

339
00:22:06,100 --> 00:22:10,820
ಮತ್ತು ನಮಗೆ ಸಿಂಕ್ ರಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಎಚ್ಟಿಎಮ್ಎಲ್ ಇರಿಸಿಕೊಳ್ಳಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

340
00:22:10,820 --> 00:22:13,220
ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಇತರ ಸಂಭಾವ್ಯ ರೀತಿಯಲ್ಲಿ, ಇವೆ

341
00:22:13,220 --> 00:22:15,320
ಮತ್ತು ಪ್ರತಿ ಚೌಕಟ್ಟನ್ನು ಈ ಮಾಡುವುದಿಲ್ಲ.

342
00:22:15,320 --> 00:22:17,720
ಪ್ರತಿ ಚೌಕಟ್ಟನ್ನು ಈ ಹಳಿಗಳ ಕೆಲಸ ಮಾಡಿರುವುದಿಲ್ಲ.

343
00:22:17,720 --> 00:22:19,490
ಕೆಲವು ಚೌಕಟ್ಟುಗಳು, ವಿವಿಧ ವಿಧಾನಗಳನ್ನು ಹೊಂದಿದ್ದವು

344
00:22:19,490 --> 00:22:23,310
ಮತ್ತು ನೀವು ಇತರ ಪ್ರತಿ ಒಂದು ಚೌಕಟ್ಟಿನಲ್ಲಿ ಕೋಡಿಂಗ್ ಅನುಭವಿಸುವ ಕಾಣಬಹುದು.

345
00:22:23,310 --> 00:22:26,160
ಅವರ ಇನ್ನೊಂದು ನೋಡೋಣ.

346
00:22:26,160 --> 00:22:30,060
ಈ ಬ್ಯಾಕ್ಬೋನ್ ಎಂಬ ಚೌಕಟ್ಟಿನಲ್ಲಿ ಅಪ್ ಮಾಡಲಾದ ಗದ್ದಲ ಪಟ್ಟಿ.

347
00:22:30,060 --> 00:22:33,250
ನಾನು ಬೇಗ ಈ ಮೂಲಕ ಹೋಗಿ ಹೋಗುವ ಬಾಗುತ್ತೇನೆ.

348
00:22:33,250 --> 00:22:38,300
ನಾವು ಅಲ್ಲಿ ಹೋಗಿ ಮೊದಲು ನಾನು ಎಚ್ಟಿಎಮ್ಎಲ್ ಆರಂಭಿಸಲು ಮಾಡುತ್ತೇವೆ.

349
00:22:38,300 --> 00:22:40,290
ಒಂದು ಎರಡನೇ.

350
00:22:40,290 --> 00:22:43,950
ನೀವು ಗಮನಿಸಿ ಮಾಹಿತಿ, ಎಚ್ಟಿಎಮ್ಎಲ್ ಆರಂಭಗೊಂಡು, ನಮ್ಮ ಎಚ್ಟಿಎಮ್ಎಲ್ ಹೋಲುತ್ತದೆ

351
00:22:43,950 --> 00:22:50,000
ಆ ಮುಂಭಾಗದಲ್ಲಿ ಮೊದಲು, ಆದ್ದರಿಂದ ಅಲ್ಲ ತುಂಬಾ ಹೊಸ ಇದ್ದ.

352
00:22:50,000 --> 00:22:55,410
ಆದರೆ ನಮ್ಮ JS ಫೈಲ್ ಸ್ವಲ್ಪ ವಿಭಿನ್ನವಾಗಿದೆ.

353
00:22:55,410 --> 00:23:00,360
ಬೆನ್ನೆಲುಬಾಗಿ ರೀತಿಯ ಈ ಕಲ್ಪನೆಯನ್ನು ಹೊಂದಿದೆ, ಅಥವಾ ಕಲ್ಪನೆಯನ್ನು ನಿರ್ಮಾಣವಾಗುತ್ತದೆ

354
00:23:00,360 --> 00:23:04,750
ನಾವು ಏನು ಬಹಳಷ್ಟು, ಹೇಳುತ್ತಾರೆ, ನಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಯೋಜನೆಗಳು

355
00:23:04,750 --> 00:23:09,110
ಮಾದರಿಗಳು ಮತ್ತು ಈ ಮಾದರಿಗಳ ಸಂಗ್ರಹಣೆಯ ಬಗ್ಗೆ ಇದೆ.

356
00:23:09,110 --> 00:23:12,510
ಇದು, ಉದಾಹರಣೆಗೆ, ಫೋಟೋಗಳನ್ನು ಫೋಟೋ ಮತ್ತು ಸಂಗ್ರಹಣೆಯ ಆಗಿರಬಹುದು

357
00:23:12,510 --> 00:23:16,230
ಅಥವಾ ಸ್ನೇಹಿತರ ಸ್ನೇಹಿತರಿಗೆ ಮತ್ತು ಸಂಗ್ರಹಣೆಯ ಕಲ್ಪನೆ.

358
00:23:16,230 --> 00:23:20,700
ಮತ್ತು ಅನೇಕ ವೇಳೆ ನಾವು JavaScript ಅಪ್ಲಿಕೇಶನ್ಗಳು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾಡಿದಾಗ

359
00:23:20,700 --> 00:23:25,340
ಸ್ನೇಹಿತರ ಸಂಗ್ರಹವನ್ನು ಹೊಂದಿರುವ ಕಲ್ಪನೆಯನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಆಫ್ ನಾವು ವಿಂಗಡಿಸಲು ಮಾಡುತ್ತೇವೆ

360
00:23:25,340 --> 00:23:29,500
ಹೇಗೋ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಬ್ಯಾಕ್ಬೋನ್ ನಮಗೆ ಈ ಪದರವನ್ನು ನೀಡುತ್ತದೆ

361
00:23:29,500 --> 00:23:33,040
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ರಚನೆಗಳು ಮತ್ತು ವಸ್ತುಗಳ ಮೇಲೆ

362
00:23:33,040 --> 00:23:38,300
ಸುಲಭವಾಗಿ ಎಂದು ಹೆಚ್ಚು ಪ್ರಬಲ ಕೆಲಸಗಳನ್ನು.

363
00:23:38,300 --> 00:23:41,870
>> ಇಲ್ಲಿ ನಾನು, ಒಂದು ಗದ್ದಲ ಮಾದರಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಬಂದಿದೆ

364
00:23:41,870 --> 00:23:44,630
ಮತ್ತು ನೀವು, ವಾಕ್ಯ ಬಗ್ಗೆ ತುಂಬಾ ಚಿಂತೆ ಇಲ್ಲ

365
00:23:44,630 --> 00:23:48,730
ಆದರೆ ಇದರ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಒಂದು ಎಂದು ಗಮನಿಸಬಹುದು?

366
00:23:48,730 --> 00:23:53,190
ಇದು ಡೀಫಾಲ್ಟ್ ಕ್ಷೇತ್ರ ಹೊಂದಿದೆ.

367
00:23:53,190 --> 00:23:56,640
ಬ್ಯಾಕ್ಬೋನ್ ನನಗೆ ಬ್ಯಾಟ್ ಆಫ್ ಈಗಾಗಲೇ ಸೂಚಿಸಲು ಅವಕಾಶ

368
00:23:56,640 --> 00:24:00,190
ನಾನು ರಚಿಸಿದ ಗದ್ದಲ ಯಾವುದೇ ಹೊಸ ಈ ಡಿಫಾಲ್ಟ್ ಮಾಡಲಿಕ್ಕೆ ಇದೆ.

369
00:24:00,190 --> 00:24:04,100
ಈಗ ನಾನು ಈ ಕಸ್ಟಮೈಸ್, ಆದರೆ ಡಿಫಾಲ್ಟ್ ಸೂಚಿಸಲು ಎಂದು ಸಾಧ್ಯವಾಯಿತು ಮಾಡಬಹುದು

370
00:24:04,100 --> 00:24:07,220
ಸಂತೋಷವನ್ನು ಆಗಿದೆ, ಮತ್ತು ಈ ರೀತಿಯಲ್ಲಿ ಅದು ಏಕೆಂದರೆ ಇದು ಅನುಕೂಲಕರ ರೀತಿಯ

371
00:24:07,220 --> 00:24:10,430
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಂತರ್ಗತವಾಗಿರುವ, ಮತ್ತು ಈಗ ನಾನು ಸ್ಪಷ್ಟವಾಗಿ ಇಲ್ಲ

372
00:24:10,430 --> 00:24:12,430
todos ಅಪೂರ್ಣ ಎಂದು ಹೇಳುತ್ತಾರೆ.

373
00:24:12,430 --> 00:24:19,190
ನಾನು todos ಅಪೂರ್ಣ ಮಾಹಿತಿ ಗುರುತಿಸಲಾಗುತ್ತದೆ ಹೋಗುವ ಎಂದು ಬಲ ಬ್ಯಾಟ್ ಆಫ್ ಹೇಳಬಹುದು.

374
00:24:19,190 --> 00:24:21,300
ನಂತರ ಗಮನಿಸಿ ಈ ಏನು?

375
00:24:21,300 --> 00:24:25,520
ಈಗ ನಾನು ಗದ್ದಲ ಪಟ್ಟಿಯಲ್ಲಿದ್ದಾರೆ, ಮತ್ತು ಒಂದು ಸಂಗ್ರಹ ಇಲ್ಲಿದೆ.

376
00:24:25,520 --> 00:24:30,960
ಮಾದರಿ ಟೊಡೊ ಹೇಳುತ್ತದೆ ಸಂಬಂಧಿಸಿದ ಕ್ಷೇತ್ರದಲ್ಲಿ ಗಮನಿಸಿ.

377
00:24:30,960 --> 00:24:33,390
ಇದು ಬ್ಯಾಕ್ಬೋನ್ ಹೇಳುವ ನನ್ನ ದಾರಿ

378
00:24:33,390 --> 00:24:37,350
ಈ ಮಾಲಿಕ todos ಸಂಗ್ರಹವನ್ನು ಕುರಿತು ವೃಂದದಲ್ಲಿರುತ್ತೇನೆ.

379
00:24:37,350 --> 00:24:42,140
ಈ ಮೂಲತಃ ನನ್ನ ಕಾರ್ಯಕ್ರಮಕ್ಕಾಗಿ ಮಾದರಿ ರಚನೆಯಾಗಿದೆ.

380
00:24:42,140 --> 00:24:44,980
ಇಲ್ಲಿ ನಾನು, ಸಂಗ್ರಹವೊಂದನ್ನು ಈ ಕಲ್ಪನೆಯನ್ನು ಹೊಂದಿವೆ

381
00:24:44,980 --> 00:24:48,960
ಮತ್ತು ಮೂಲತಃ ಆ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಒಳಗೊಂಡಿರುವ ಐಟಂಗಳನ್ನು ಎಲ್ಲಾ, ಈ todos ಎಂದು ಹೋಗುವ

382
00:24:48,960 --> 00:24:51,910
ಮತ್ತು ಈ ಅರ್ಥದಲ್ಲಿ ಬಹಳ ಸಹಜ

383
00:24:51,910 --> 00:24:59,890
ನಾನು ಏಕೆಂದರೆ todos ಹೊಂದಿವೆ, ಮತ್ತು ನಾನು ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಅವುಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.

384
00:24:59,890 --> 00:25:02,940
>> ತಂದೆಯ ಈ ಒಂದು ಸ್ವಲ್ಪ ನೋಡೋಣ.

385
00:25:02,940 --> 00:25:05,900
ಇಲ್ಲಿ ಒಂದು ಬ್ಯಾಕ್ಬೋನ್ ಚಿತ್ರಣವಾಗಿದೆ.

386
00:25:05,900 --> 00:25:08,890
ಬ್ಯಾಕ್ಬೋನ್ ಹೇಳುತ್ತದೆ ಇತರ ವಿಷಯ ಎಂದು

387
00:25:08,890 --> 00:25:14,660
ನಿಮ್ಮ ಬಗ್ಗೆ ಅಥವಾ ಸಂಗ್ರಹಗಳು ಆಲೋಚನೆ ನೀವು ಮಾದರಿಗಳ ಬಹಳಷ್ಟು

388
00:25:14,660 --> 00:25:19,150
ಪ್ರಕಟಗೊಳ್ಳುತ್ತಿಲ್ಲ ಕೆಲವು ರೀತಿಯಲ್ಲಿ ಮಾಡಬೇಕು ಹೋಗುವ.

389
00:25:19,150 --> 00:25:21,900
ನಾವು, ಲಿಸ್ಟ್ ಮಾಡಲು ಎಂದು ನಿರೂಪಿಸಲು ಅಗತ್ಯ

390
00:25:21,900 --> 00:25:25,460
ನಾವು ಪ್ರತಿ ಮಾದರಿಗೆ ಒದಗಿಸಬಹುದು ವೇಳೆ ಮತ್ತು ಇದು ಸಂತೋಷವನ್ನು ಎಂದು

391
00:25:25,460 --> 00:25:28,390
ಅಥವಾ ಪ್ರತಿ ಮಾದರಿಯು ಈ ವೀಕ್ಷಿಸಿ ಸಂಯೋಜಿಸಲು

392
00:25:28,390 --> 00:25:34,020
ನಮಗೆ ಅನುಮತಿಸುವ ನಾನು ಎರಡು ಒಟ್ಟಿಗೆ ಸಂಪರ್ಕ ಊಹೆ?

393
00:25:34,020 --> 00:25:38,320
ಮೊದಲು ಆದರೆ ನಾವು ಮೂಲಕ ಔಟ್ ಎಂದು ಲೂಪ್ ಒಂದು ಬಳಸಬೇಕಿತ್ತು

394
00:25:38,320 --> 00:25:41,130
ಪ್ರತಿ ನಮ್ಮ ಪಟ್ಟಿಯಲ್ಲಿ ಟೊಡೊ ತದನಂತರ ಇಲ್ಲಿ ಮುದ್ರಿಸುತ್ತದೆ

395
00:25:41,130 --> 00:25:44,650
ನಾವು ಮೂಲತಃ ಈ ಮಾದರಿಯಿಂದ ಇದು ಸಂಪರ್ಕಿಸಬಹುದು.

396
00:25:44,650 --> 00:25:47,550
ಇದು ಗದ್ದಲ ಚಿತ್ರಣವಾಗಿದೆ.

397
00:25:47,550 --> 00:25:50,550
ಈ ನಾವು ಮೊದಲು ಕಂಡು ಟೊಡೊ ಸಂಬಂಧಿಸಿದೆ.

398
00:25:50,550 --> 00:25:54,940
ಈಗ ಪ್ರತಿ ಟೊಡೊ displayable ಅಥವಾ renderable ಇದೆ

399
00:25:54,940 --> 00:25:56,960
ಈ ಮೂಲಕ ವೀಕ್ಷಣೆ ಮಾಡಲು.

400
00:25:56,960 --> 00:25:59,440
ಜಾಗ ಕೆಲವು ಗಮನಿಸಿ.

401
00:25:59,440 --> 00:26:05,880
ನೀವು ಈ ಟ್ಯಾಗ್ ಹೆಸರನ್ನು ಹೊಂದಿದೆ ಟ್ಯಾಗ್ ಹೆಸರನ್ನು ಯೋಚಿಸುವುದೇನು: ಲಿ?

402
00:26:05,880 --> 00:26:09,790
ಒಂದು ಟೊಡೊ ನಿರೂಪಿಸಲು ನಾವು ಬೇಕಾಗಿದ್ದಾರೆ ಮಾಡಿದಾಗ ಮೊದಲು ನೆನಪಿಡಿ

403
00:26:09,790 --> 00:26:16,700
ನಾವು ಸ್ಪಷ್ಟವಾಗಿ ಈ ಲಿ ಟ್ಯಾಗ್ ನಮ್ಮ todos ಜೋಡಿಯಾಗಬಹುದಾಗಿರುತ್ತದೆ ಹೊಂದಿರುತ್ತದೆ.

404
00:26:16,700 --> 00:26:21,080
ಈಗ ನಾವು ಈ ಟೊಡೊ ವಾಸಿಸಲು ಹೋಗಿ ಅಲ್ಲಿ ಎಂದು ನೀವು

405
00:26:21,080 --> 00:26:25,250
ಒಂದು ಲಿ ಟ್ಯಾಗ್ನ ಒಳಗಡೆ ಹೋಗುವ ಇದೆ.

406
00:26:25,250 --> 00:26:31,440
ಮತ್ತು ಈಗ ನಾವು ನಮ್ಮ todos ಘಟನೆಗಳನ್ನು ಸಂಬಂಧ ನೀವು.

407
00:26:31,440 --> 00:26:34,320
>> ಪ್ರತಿ ಟೊಡೊ ಈ ಒಂದು ಈವೆಂಟ್ ಹೊಂದಿದೆ.

408
00:26:34,320 --> 00:26:38,480
ನೀವು ಬಹುಮಟ್ಟಿಗೆ ಟಾಗಲ್ ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಿದರೆ, ಆ, ನಾನು ಹೇಳಿದರು ಬಾಗುತ್ತೇನೆ ಇಲ್ಲಿದೆ

409
00:26:38,480 --> 00:26:43,080
ನಂತರ ಮೂಲಭೂತವಾಗಿ ಇದು ಮುಂಚೆ ಇದ್ದ ವಿರುದ್ಧ ಮಾಹಿತಿ ಟೊಡೊ ಗುರುತು

410
00:26:43,080 --> 00:26:45,890
ತದನಂತರ ಅಪ್ಲಿಕೇಶನ್ ಮತ್ತೆ ನಿರೂಪಿಸಲು.

411
00:26:45,890 --> 00:26:47,810
ಈ ಮೊದಲು ಕೋಡ್ ಹೋಲುವ ರೀತಿಯ ಆಗಿದೆ.

412
00:26:47,810 --> 00:26:50,730
ನಾವು ಎರಡೂ ವಿರುದ್ಧ ಅಥವಾ ಎಂದು ಗುರುತಿಸಲಾಗಿದೆ ನೆನಪಿಡಿ

413
00:26:50,730 --> 00:26:52,410
ತದನಂತರ ನಾವು ಮರು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.

414
00:26:52,410 --> 00:26:57,750
ಆದರೆ ಈಗ HTML ನಲ್ಲಿ ಎಂದು ಏನೋ ಎಂದು ಬಳಸಲಾಗುತ್ತದೆ ಈ ಈವೆಂಟ್ ಗಮನಿಸಿ.

415
00:26:57,750 --> 00:26:59,640
ಇದು ಅಲ್ಲಿ ಕುಳಿತಿದ್ದ.

416
00:26:59,640 --> 00:27:01,410
ಬಟನ್ ಮೇಲೆ ಕ್ಲಿಕ್ ಹೊಂದಿತ್ತು.

417
00:27:01,410 --> 00:27:05,310
ನೀವು ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಿ, ಇದು ರೀತಿಯ ವಿಷಯವನ್ನು ಮಾಡುತ್ತದೆ

418
00:27:05,310 --> 00:27:07,210
ಟೊಡೊ ಅಪೂರ್ಣ ಎಂದು ಸ್ಥಾಪಿಸಲಾಯಿತು.

419
00:27:07,210 --> 00:27:11,180
ಇಲ್ಲಿ ನಾವು ಟಾಗಲ್ ಬಟನ್ ಕ್ಲಿಕ್ ಆ ಘಟನೆಯ ಸಂಬಂಧ ಬಂದಿದೆ

420
00:27:11,180 --> 00:27:15,830
ಮತ್ತು ಇದು ಈ ದೃಷ್ಟಿಯಿಂದ ಆನ್ ಅಥವಾ ಆಫ್ ಇಲ್ಲಿದೆ ಎಂಬುದನ್ನು ವಿರುದ್ಧ.

421
00:27:15,830 --> 00:27:20,480
>> ಇದು ಅತ್ಯಂತ ಭದ್ರವಾದ ಎಂದು ಆದ್ದರಿಂದ ಈ ಈವೆಂಟ್ ಸ್ಥಾಪನೆಗೆ ಒಂದು ಸಂತೋಷವನ್ನು ದಾರಿ

422
00:27:20,480 --> 00:27:26,980
ಈ ದೃಷ್ಟಿಕೋನದ, ಮತ್ತು ಆದ್ದರಿಂದ ಹೆಚ್ಚು ಈ ಒಂದು ಗಮನಿಸಿ.

423
00:27:26,980 --> 00:27:31,050
ನಾನು ಈ ರೆಂಡರ್ ವಿಧಾನವನ್ನು ಹೊಂದಿವೆ, ಮತ್ತು ನಾವು ವಿವರಗಳು ಮೂಲಕ ಹೋಗಲು ಹೊಂದಿಲ್ಲ.

424
00:27:31,050 --> 00:27:33,650
ಇದು, ನಾವು ಮೊದಲು ಯಾವುದೆಂದು ಹೋಲುವ ರೀತಿಯ ಇಲ್ಲಿದೆ

425
00:27:33,650 --> 00:27:36,070
ಆದರೆ ನಾನು ಏನು ಮೂಲಕ ಲೂಪಿಂಗ್ ನನಗಿಲ್ಲ ಗಮನಿಸಿ.

426
00:27:36,070 --> 00:27:40,700
ನಾನು ಅಂಶಗಳನ್ನು ಎಲ್ಲಾ ಮುದ್ರಿಸಲು ಹೋಗುವ ಬಾಗುತ್ತೇನೆ ಹೇಳುವ ರೀತಿಯ ಇಲ್ಲಿದೆ ಆ ಉಲ್ ಟ್ಯಾಗ್ ಮುದ್ರಣ ನನಗಿಲ್ಲ.

427
00:27:40,700 --> 00:27:46,610
ನಾನು ಈ ಒಂದು ಗದ್ದಲ ಐಟಂ ಸಲ್ಲಿಸುವುದಕ್ಕಾಗಿ ಕ್ರಿಯಾತ್ಮಕತೆಯನ್ನು ನೀಡುವ ಬಾಗುತ್ತೇನೆ.

428
00:27:46,610 --> 00:27:49,400
ಈ ಮೂಲತಃ ಒಂದು ಅತ್ಯಂತ ಶಕ್ತಿಯುತ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ

429
00:27:49,400 --> 00:27:53,600
ನಮ್ಮ ಗದ್ದಲ ಪಟ್ಟಿಯಲ್ಲಿ ಎಲ್ಲಾ ಈ todos ಒಳಗೊಂಡಿದೆ, ಮತ್ತು ನಾವು ಮೂಲತಃ ಸೂಚಿಸಬಹುದು ವೇಳೆ

430
00:27:53,600 --> 00:27:56,890
ಆ todos ಒಂದು ನಿರೂಪಿಸಲು ರೀತಿಯಲ್ಲಿ

431
00:27:56,890 --> 00:28:04,230
ನಂತರ ನಾವು ವಸ್ತುತಃ ನಮ್ಮ ಪ್ರಬಲ ಬೆನ್ನೆಲುಬಾಗಿ ಹೊಂದಬಹುದು todos ಎಲ್ಲಾ ನಿರೂಪಿಸಲು

432
00:28:04,230 --> 00:28:07,760
ಮಾಲಿಕ todos ಮೇಲೆ ರೆಂಡರ್ ವಿಧಾನ ಕರೆದು.

433
00:28:07,760 --> 00:28:14,180
ಈ ಇಲ್ಲಿ ಉಪಯುಕ್ತ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ.

434
00:28:14,180 --> 00:28:18,160
ಈಗ ಕೇಳಲು ಉತ್ತಮ ಪ್ರಶ್ನೆ ಈ ಅಪ್ಲಿಕೇಶನ್ ಹೇಗೆ ಒಟ್ಟಾಗಿ ಮಾಡಲಾಗುತ್ತಿದೆ ಆಗಿದೆ?

435
00:28:18,160 --> 00:28:21,200
ನಾವು ಒಂದು ಟೊಡೊ ನಿರೂಪಿಸಲು ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿರುತ್ತವೆ, ಏಕೆಂದರೆ

436
00:28:21,200 --> 00:28:23,860
ಆದರೆ ಹೇಗೆ ನಾವು ಅನೇಕ todos ಕಲ್ಪನೆಯನ್ನು ಪಡೆಯಲು ಇಲ್ಲ?

437
00:28:23,860 --> 00:28:25,100
>> ಅವರ ಆ ಒಂದು ಗಮನಿಸೋಣ.

438
00:28:25,100 --> 00:28:27,100
ಈ ಕೊನೆಯ ಭಾಗ.

439
00:28:27,100 --> 00:28:29,740
ನಾವು ಇಲ್ಲಿ ಗದ್ದಲ ಪಟ್ಟಿಯನ್ನು ವೀಕ್ಷಿಸಿ ಹೊಂದಿರುತ್ತವೆ ಗಮನಿಸಿ,

440
00:28:29,740 --> 00:28:34,440
ಮತ್ತು ಇದು ಒಂದು ನೋಟ ಇಲ್ಲಿದೆ ಗಮನಿಸಿ.

441
00:28:34,440 --> 00:28:36,970
ಮತ್ತು ವಸ್ತುಗಳ ಒಂದೆರಡು ಮೇಲೆ ಹೋಗಲು,

442
00:28:36,970 --> 00:28:45,280
ನಾವು ಮೊದಲ ಈ ಗದ್ದಲ ಪಟ್ಟಿ ರಚಿಸುವಾಗ ಈ ಆರಂಭಿಸಲು ವಿಧಾನ ಎಂಬ ನಡೆಯಲಿದೆ.

443
00:28:45,280 --> 00:28:52,630
ನೀವು ನೋಡಬಹುದು ಎಂದು, ಇದು ಗದ್ದಲ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಲು ಮತ್ತು ಈ ದೃಷ್ಟಿಯಿಂದ ಇದು ಸಂಬಂಧ ಹೀಗಿದೆ.

444
00:28:52,630 --> 00:28:57,860
ನೀವು ಕೂಡಿದಾಗ ತದನಂತರ ನಾನು ಮೂಲತಃ ಇಲ್ಲಿ ಕಾರ್ಯಗಳನ್ನು ಸೇರಿಸಲಾಗಿದೆ ವಸ್ತುವಾಗಿ

445
00:28:57,860 --> 00:29:01,440
ಈ addItem ವಿಧಾನ ಹೋಲುತ್ತದೆ ನಾವು ಮೊದಲು ಗರಗಸ

446
00:29:01,440 --> 00:29:07,430
ನಾನು ಒಂದು ಹೊಸ ಟೊಡೊ ವಸ್ತು ರಚಿಸಲು, ಮತ್ತು ನಾನು ವಾಸ್ತವವಾಗಿ ಎಂದು ಬಾಗುತ್ತೇನೆ ಗಮನಕ್ಕೆ ಹೋಗುವ ಬಾಗುತ್ತೇನೆ

447
00:29:07,430 --> 00:29:13,080
ಈ ಹೊಸ ಟೊಡೊ ವಿಧಾನ, ಈ ಬ್ಯಾಕ್ಬೋನ್ ನೀಡುತ್ತಿದೆ,

448
00:29:13,080 --> 00:29:16,010
ಮತ್ತು ನಾನು ಇಲ್ಲಿ ನನ್ನ ಆಸ್ತಿಗಳನ್ನು ಹಸ್ತಾಂತರಿಸುತ್ತಾನೆ.

449
00:29:16,010 --> 00:29:23,710
ಮತ್ತು ಈಗ ನಾನು ಈ ಬಳಸಿಕೊಂಡು ರಚಿಸಿದರೆ ಪ್ರತಿ ಟೊಡೊ ನಾವು ಮೊದಲು ಕಂಡ ಆ ಕಾರ್ಯವನ್ನು ಪಡೆಯುತ್ತಾನೆ.

450
00:29:23,710 --> 00:29:28,140
ನಾನು ಪಠ್ಯ ಬಾಕ್ಸ್ ಔಟ್ ತೆರವುಗೊಳಿಸಲು ಬಾಗುತ್ತೇನೆ ಮೊದಲು ಒಂದು ಸಣ್ಣ ಸಣ್ಣ ವಿವರ-ಗಮನಿಸಿ

451
00:29:28,140 --> 00:29:32,900
ಮತ್ತು ನಂತರ ನಾನು ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಸೇರಿಸಿ ಬಾಗುತ್ತೇನೆ.

452
00:29:32,900 --> 00:29:37,630
>> ಈ ಬಹುತೇಕ ವಿಚಿತ್ರವಾಗಿ ತೋರುತ್ತದೆ ನಾವು ಎಂದು todos.push ಮಾಡಲು ಮೊದಲು ಏಕೆಂದರೆ,

453
00:29:37,630 --> 00:29:43,310
ತದನಂತರ ನಾವು, ಮಾಡಲಾಯಿತು, ಮತ್ತು ಈ ನಿರ್ದಿಷ್ಟ ಯೋಜನೆಗೆ ಸಂಕೀರ್ಣವಾದ ಕಾಣಿಸಬಹುದು

454
00:29:43,310 --> 00:29:46,980
ಮತ್ತು ಆ ಬ್ಯಾಕ್ಬೋನ್ ಅಥವಾ ಕೋನೀಯ ಅಥವಾ ಯಾವುದೇ ಇತರ ಚೌಕಟ್ಟನ್ನು ಕಾಣಬಹುದು

455
00:29:46,980 --> 00:29:50,790
ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಯೋಜನೆ ಸರಿಹೊಂದುವಂತೆ, ಆದರೆ ನಾನು ಅದರ ಬಗ್ಗೆ ಯೋಚಿಸಲು ಪ್ರಮುಖ ಭಾವಿಸುತ್ತೇನೆ ಇಲ್ಲ

456
00:29:50,790 --> 00:29:54,100
ಏನು ಈ ದೊಡ್ಡ ಯೋಜನೆಗಳಿಗೆ ಒಂದು ದೊಡ್ಡ ಪ್ರಮಾಣದಲ್ಲಿ ಅಂದರೆ,

457
00:29:54,100 --> 00:29:56,610
ಏಕೆಂದರೆ ನಾವು ಪ್ರತಿನಿಧಿಸುವ ಅಲ್ಲಿ ಒಂದು ದೊಡ್ಡ ಯೋಜನೆಯ ಹಂತ ವೇಳೆ

458
00:29:56,610 --> 00:30:00,860
ಕೆಲವು ನಿಜವಾಗಿಯೂ ಸಂಕೀರ್ಣ ಸಂಗ್ರಹ, ಕೇವಲ ಒಂದು ಗದ್ದಲ ಪಟ್ಟಿಯಲ್ಲಿ ಹೆಚ್ಚು ಆಳವಾದ ಏನೋ,

459
00:30:00,860 --> 00:30:04,490
ನ ಒಂದು ಸ್ನೇಹಿತರ ಪಟ್ಟಿಯಿಂದ ಅಥವಾ ಹಾಗೆ ಏನೋ ಹೇಳಲು ಅವಕಾಶ, ಈ HANDY ಬರುತ್ತವೆ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

460
00:30:04,490 --> 00:30:09,620
ಏಕೆಂದರೆ ನಾವು, ಒಂದು ನಿಜವಾಗಿಯೂ ಅನುಕೂಲಕರ ರೀತಿಯಲ್ಲಿ ನಮ್ಮ ಕೋಡ್ ಸಂಘಟಿಸಲು ಸಾಧ್ಯವಾಯಿತು

461
00:30:09,620 --> 00:30:12,550
ಬೇರೊಬ್ಬರು ಸುಲಭವಾಗುತ್ತದೆ ಎಂದು ಒಂದು ರೀತಿಯಲ್ಲಿ

462
00:30:12,550 --> 00:30:16,820
ಯಾರು ಮೇಲೆ ನಿರ್ಮಿಸುವ ಯೋಜನೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಬಯಸಿದರು.

463
00:30:16,820 --> 00:30:21,450
ಈ ರಚನೆ ಬಹಳಷ್ಟು ಒದಗಿಸುತ್ತದೆ ಎಂದು ನೋಡಬಹುದು.

464
00:30:21,450 --> 00:30:26,580
ಮತ್ತು ನಂತರ ನಾನು ಈ addItem ಮೇಲೆ ನಿರೂಪಿಸಲು ಕರೆ ಬಾಗುತ್ತೇನೆ.

465
00:30:26,580 --> 00:30:31,050
ನೀವು ನೋಡಬಹುದು ಎಂದು, ಮಾಡಲು ಮತ್ತು ಈ ಸಂಪೂರ್ಣ ವಾಕ್ಯ ಆತುರದಿಂದ ಇಲ್ಲ,

466
00:30:31,050 --> 00:30:37,790
ಆದರೆ ಮೂಲತಃ ಪ್ರತಿ ಮಾದರಿಗೆ ಇದು ಮಾಲಿಕ ರೆಂಡರ್ ವಿಧಾನ ಕರೆಯಲು ಇಂದಿನ ವಿಶೇಷವೇನು.

467
00:30:37,790 --> 00:30:41,500
ಈ ಬರುತ್ತದೆ ಅಲ್ಲಿ ಆ ರೀತಿಯ ಇಲ್ಲಿದೆ.

468
00:30:41,500 --> 00:30:44,140
ಕೇವಲ ವೈಯಕ್ತಿಕ todos ನಿರೂಪಿಸಲು ಹೇಗೆ ಸೂಚಿಸಲು ಲೆಟ್ಸ್,

469
00:30:44,140 --> 00:30:47,310
ತದನಂತರ ಒಟ್ಟಾರೆಯಾಗಿ ಒಟ್ಟಿಗೆ ಅಂಟು ಅವರನ್ನು ತಂದೆಯ ಅವಕಾಶ.

470
00:30:47,310 --> 00:30:49,810
ಆದರೆ ಈ, ಅಮೂರ್ತತೆಯ ಒಂದು ರೀತಿಯಲ್ಲಿ ಒದಗಿಸುತ್ತದೆ

471
00:30:49,810 --> 00:30:55,470
ನಾನು ವೈಯಕ್ತಿಕ todos ನಿರೂಪಿಸಲು ನಿರ್ಧರಿಸಲು ಮಾರ್ಗವನ್ನು ಬದಲಿಸಲು ಕಾರಣ,

472
00:30:55,470 --> 00:30:57,940
ಮತ್ತು ನಾನು ಈ ಕೋಡ್ ಯಾವುದೇ ಬದಲಾಯಿಸಲು ಇರುತ್ತಿರಲಿಲ್ಲ.

473
00:30:57,940 --> 00:31:00,700
ಆ ರೀತಿಯ ತಂಪಾದ ಇಲ್ಲಿದೆ.

474
00:31:00,700 --> 00:31:08,540
>> ಯಾರಾದರೂ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಚೌಕಟ್ಟುಗಳ ಬಗ್ಗೆ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ಡಸ್?

475
00:31:08,540 --> 00:31:14,310
[ವಿದ್ಯಾರ್ಥಿ ಕೇಳಿಬರುವುದಿಲ್ಲ ಪ್ರಶ್ನೆ]

476
00:31:14,310 --> 00:31:16,050
ಓಹ್, ಖಚಿತವಾಗಿ, ಒಂದು ದೊಡ್ಡ ಪ್ರಶ್ನೆ ಇಲ್ಲಿದೆ.

477
00:31:16,050 --> 00:31:19,080
ಪ್ರಶ್ನೆ ಹೇಗೆ ನಾನು ಚೌಕಟ್ಟುಗಳು ಸೇರಿವೆ ಮಾಡಿದರು?

478
00:31:19,080 --> 00:31:22,970
ಹೆಚ್ಚಿನ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಚೌಕಟ್ಟುಗಳ ಮೂಲತಃ ಕೇವಲ JS ಕಡತಗಳಾಗಿದ್ದು

479
00:31:22,970 --> 00:31:25,740
ನಿಮ್ಮ ಕೋಡ್ ಮೇಲಿರುವ ಸೇರಿವೆ ಎಂದು.

480
00:31:25,740 --> 00:31:29,830
ನಾನು ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಟ್ಯಾಗ್ಗಳನ್ನು ಹೊಂದಿವೆ ನನ್ನ HTML ನ ತಲೆ ಭಾಗವನ್ನು ಗಮನಿಸಿ,

481
00:31:29,830 --> 00:31:34,250
ಮತ್ತು ಅಂತಿಮ ಸ್ಕ್ರಿಪ್ಟ್ ಟ್ಯಾಗ್ ನಾವು ಬರೆದ ಬಂದಿದೆ ಎಂದು ಸಂಕೇತ.

482
00:31:34,250 --> 00:31:38,820
ತದನಂತರ 3 ಚೌಕಟ್ಟನ್ನು ಸಂಕೇತಗಳು ಕೇವಲ ಕೂಡ ಸ್ಕ್ರಿಪ್ಟ್ ಟ್ಯಾಗ್ಗಳು ಇವೆ.

483
00:31:38,820 --> 00:31:42,110
ನಾನು, ಒಂದು CDN ಎಂದು ಏನನ್ನು ಅವರನ್ನು ಒಳಗೊಂಡಂತೆ ಬಾಗುತ್ತೇನೆ

484
00:31:42,110 --> 00:31:46,200
ಇದು ನನಗೆ ಈ ಹಂತದಲ್ಲಿ ಬೇರೊಬ್ಬರು ಇದನ್ನು ಪಡೆಯಲು ಅನುಮತಿಸುತ್ತದೆ

485
00:31:46,200 --> 00:31:57,930
ಆದರೆ ಪ್ರತಿ ಚೌಕಟ್ಟನ್ನು ಈ ನೀವು ಬಹುಮಟ್ಟಿಗೆ ವಿಷಯ ಕಾಣಬಹುದು ಹೊಂದಿದೆ

486
00:31:57,930 --> 00:32:03,540
ಹಾಗೆ ಕೆಲವು CDN ಅಥವಾ ಏನೋ ಲಭ್ಯವಿರುವ ನಿರ್ದಿಷ್ಟ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಗ್ರಂಥಾಲಯಕ್ಕೆ,

487
00:32:03,540 --> 00:32:05,570
ತದನಂತರ ನೀವು ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಟ್ಯಾಗ್ಗಳು ಒಳಗೊಳ್ಳಬಹುದು.

488
00:32:05,570 --> 00:32:07,600
ಆ ಅರ್ಥದಲ್ಲಿ ಮಾಡಲು ಡಸ್?

489
00:32:07,600 --> 00:32:09,500
ಕೂಲ್.

490
00:32:09,500 --> 00:32:11,730
>> ಆ 2 ಬೇರೆ ಮಾರ್ಗಗಳೆಂದರೆ.

491
00:32:11,730 --> 00:32:14,640
ಆ ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವ ಮಾತ್ರ ವಿಧಾನಗಳು ಇಲ್ಲ.

492
00:32:14,640 --> 00:32:17,080
ವಿವಿಧ ವಸ್ತುಗಳ ಇವೆ ಎಂದು

493
00:32:17,080 --> 00:32:19,490
ಯಾರಾದರೂ ಮಾಡಬಲ್ಲರು, ಮತ್ತು ಅನೇಕ ಚೌಕಟ್ಟುಗಳು ಔಟ್ ಅಲ್ಲಿ ಇವೆ.

494
00:32:19,490 --> 00:32:23,300
ಕೋನೀಯ ಮತ್ತು ಬ್ಯಾಕ್ಬೋನ್ ಇಡೀ ಕಥೆಯನ್ನು ಹೇಳಲು ಇಲ್ಲ.

495
00:32:23,300 --> 00:32:26,370
ನಿಮ್ಮ ಅಂತಿಮ ಯೋಜನೆಗಳೊಂದಿಗೆ ಅದೃಷ್ಟ ಗುಡ್, ಮತ್ತು ತುಂಬಾ ಧನ್ಯವಾದ.

496
00:32:31,960 --> 00:32:35,000
[CS50.TV]