1
00:00:00,000 --> 00:00:02,610
[Powered by Google Translate] [ವಿಭಾಗ 8 - ಹೆಚ್ಚು ಆರಾಮದಾಯಕ]

2
00:00:02,610 --> 00:00:04,910
[ರಾಬ್ ಬೌಡೆನ್ - ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]

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

4
00:00:11,520 --> 00:00:14,160
>> ಈ ವಾರ ವಿಭಾಗ ಟಿಪ್ಪಣಿಗಳು, ಬಹಳ ಕಡಿಮೆ ಎಂದು ಹೋಗುವ

5
00:00:14,160 --> 00:00:19,070
ನಾನು ಮಾತನಾಡಲು ಪಡೆಯಲಿದ್ದೇನೆ ಆದ್ದರಿಂದ, ನೀವು ಹುಡುಗರಿಗೆ, ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳುವ ಇರಿಸಿಕೊಳ್ಳಲು ಹೋಗುವ

6
00:00:19,070 --> 00:00:22,720
ಮತ್ತು ನಾವು ಎಷ್ಟು ಸಾಧ್ಯವೋ ಅಷ್ಟು ಬಾರಿ ಅಪ್ ತುಂಬಲು ಪ್ರಯತ್ನಿಸಿ ಮಾಡುತ್ತೇವೆ.

7
00:00:22,720 --> 00:00:31,950
ಬಹಳಷ್ಟು ಜನರು ಈ pset ಅಗತ್ಯವಾಗಿ ಕಷ್ಟ ಎಂದು ಭಾವಿಸುತ್ತೇನೆ, ಆದರೆ ಇದು ತುಂಬಾ ಉದ್ದವಾಗಿದೆ.

8
00:00:31,950 --> 00:00:37,070
pset ನಿರ್ದಿಷ್ಟಪಡಿಸುವಿಕೆಯನ್ನು ಸ್ವತಃ ಒಂದು ಗಂಟೆ ಓದಲು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

9
00:00:40,530 --> 00:00:45,730
ನೀವು ಬಹುಶಃ ಬಳಸಬೇಕಾಗುತ್ತದೆ ಎಂದು SQL ಸಾಕಷ್ಟು ನೀಡಿ.

10
00:00:45,730 --> 00:00:50,520
ನಾವು ಬಹಳಷ್ಟು ಮೂಲಕ ನೀವು ವಾಕ್ ತುಂಬಾ ಕೆಟ್ಟ ಇರುವಂತಿಲ್ಲ.

11
00:00:50,520 --> 00:00:54,560
ಯಾರಾದರೂ ಆರಂಭಿಸಿದರು ಅಥವಾ ಮುಗಿದಿದೆ?

12
00:00:55,380 --> 00:00:59,710
ಕಳೆದ pset ಇಲ್ಲಿದೆ. ಓಹ್, ನನ್ನ ದೇವರು.

13
00:00:59,710 --> 00:01:05,400
ಸಾಮಾನ್ಯವಾಗಿ ಕ್ಯಾಲೆಂಡರ್ ಬದಲಾವಣೆ ವಿಷಯಗಳನ್ನು ಈ ನಂತರ ಒಂದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಒಂದಾಗಿದೆ, ಆದರೆ

14
00:01:05,400 --> 00:01:09,560
1 ವಾರ ಕಡಿಮೆ ಎಲ್ಲವನ್ನೂ ಮಾಡುತ್ತದೆ, ಮತ್ತು ನಾವು ಮುಂದೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ pset ಹೊಂದಿರುತ್ತವೆ.

15
00:01:09,560 --> 00:01:12,310
ನಾನು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ ಹೋಗುವ ಎಂಬುದನ್ನು ಪರಿಣಾಮ ಹೇಗೆ ಗೊತ್ತಿಲ್ಲ

16
00:01:12,310 --> 00:01:15,510
ಅಥವಾ 1 ಕ್ವಿಜ್.

17
00:01:15,510 --> 00:01:22,260
ನಾನು ನೀವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಗ್ಗೆ ಉನ್ನತ ಮಟ್ಟದ ವಿಷಯಗಳನ್ನು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ರೀತಿಯಲ್ಲಿ ಇದು, ಏನೋ ಎಂದು ಕಲ್ಪನೆ

18
00:01:22,260 --> 00:01:26,460
ಆದರೆ ನಾವು ನೀವು ನೇರ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ನೀಡಲು ಬಯಸುವ ಅನುಮಾನ

19
00:01:26,460 --> 00:01:28,720
ನೀವು ಒಂದು pset ಪಡೆದಿರಲಿಲ್ಲ ರಿಂದ.

20
00:01:28,720 --> 00:01:33,000
ಆದರೆ ಮುಂದಿನ ವಾರದ ರಸಪ್ರಶ್ನೆ ವಿಮರ್ಶೆ ವಿಷಯ ಎಂದು ಕಾಣಿಸುತ್ತದೆ.

21
00:01:33,000 --> 00:01:36,320
>> ಪ್ರಶ್ನೆಗಳನ್ನು ವಿಭಾಗ.

22
00:01:36,320 --> 00:01:43,870
ಈ ವಿಷಯದ ಬಹಳಷ್ಟು ಸ್ವಲ್ಪ ಕಳಪೆ worded, ಆದರೆ ನಾವು ಯಾಕೆ ಚರ್ಚೆ ಮಾಡುತ್ತೇವೆ.

23
00:01:43,870 --> 00:01:50,220
ಸಿ ಭಿನ್ನವಾಗಿ, PHP ಒಂದು "ಕ್ರಿಯಾಶೀಲವಾಗಿ-ಟೈಪ್" ಭಾಷೆ. ಈ ಅರ್ಥ ಏನು, ನೀವು ಕೇಳಲು?

24
00:01:50,220 --> 00:01:53,830
ಅಲ್ಲದೆ, ಆ ಚಾರ್, ಫ್ಲೋಟ್, ಇಂಟ್, ಮತ್ತು ಇತರ ಕೀವರ್ಡ್ಗಳನ್ನು ಎಲ್ಲಾ ಸೆ ಗುಡ್ಬೈ ಟು ನೀವು ಬಳಸಬೇಕಾಗುತ್ತದೆ

25
00:01:53,830 --> 00:01:56,190
ಅಸ್ಥಿರ ಮತ್ತು ಸಿ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಘೋಷಿಸುವ ಸಂದರ್ಭದಲ್ಲಿ

26
00:01:56,190 --> 00:02:00,420
PHP, ಒಂದು ವೇರಿಯೇಬಲ್ ನ ಪ್ರಕಾರ ಇದು ಪ್ರಸ್ತುತ ಹಿಡುವಳಿ ಎಂದು ಮೌಲ್ಯವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ.

27
00:02:00,420 --> 00:02:04,990
ನಾವು dynamic.php ಎಂಬ ಕಡತವನ್ನು ಈ ಕೋಡ್ ನಮೂದಿಸಿ, ಆದ್ದರಿಂದ ಮೊದಲು

28
00:02:04,990 --> 00:02:12,670
PHP ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಟೈಪಿಸಿದ ಇದೆ. ಎಂಬುದು ಸತ್ಯ.

29
00:02:12,670 --> 00:02:17,590
ನಾನು, ನಾವು ಇಂಟ್, ಚಾರ್, ಫ್ಲೋಟ್ ವಿದಾಯ ಹೇಳುವ ನೀವು ಅರ್ಥ ವಾಸ್ತವವಾಗಿ ಅಸಮ್ಮತಿ

30
00:02:17,590 --> 00:02:20,620
ಮತ್ತು ಇತರ ಕೀವರ್ಡ್ಗಳನ್ನು.

31
00:02:20,620 --> 00:02:25,510
ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಟೈಪ್ ಮತ್ತು ಪರ್ಯಾಯ ನಡುವಿನ ನಿಖರವಾದ ವ್ಯತ್ಯಾಸವನ್ನು,

32
00:02:25,510 --> 00:02:32,010
ಸ್ಥಾಯಿಸ್ಥಿತಿಯಲ್ಲಿ ಟೈಪಿಸಿದ ಇದು, ಎಂದು ಸಕ್ರಿಯವಾಗಿ ಟೈಪಿಸಿದ, ನಿಮ್ಮ ಮಾದರಿ ಪರಿಶೀಲನೆ ಮತ್ತು ವಿಷಯವನ್ನು ಎಲ್ಲಾ

33
00:02:32,010 --> 00:02:37,350
, ರನ್ ಸಮಯದಲ್ಲಿ ನಡೆಯುತ್ತದೆ ಸ್ಥಾಯಿಸ್ಥಿತಿಯಲ್ಲಿ ಟೈಪಿಸಿದ ಆದರೆ ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ನಡೆಯುತ್ತದೆ.

34
00:02:37,350 --> 00:02:43,030
ಸಾಮಾನ್ಯವಾಗಿ ಸ್ಥಿರ ಪದ ಕಂಪೈಲ್ ಟೈಮ್ ಅರ್ಥದ ತೋರುತ್ತದೆ.

35
00:02:43,030 --> 00:02:48,170
ನಾನು ಇತರ ಬಳಕೆಗಳು ಇವೆ ಊಹಿಸುತ್ತಾರೆ, ಆದರೆ ನೀವು ಒಂದು ಸ್ಥಿರ ವೇರಿಯಬಲ್ ಘೋಷಿಸಿದ ಸಂದರ್ಭದಲ್ಲಿ ಸಿ, ಇನ್

36
00:02:48,170 --> 00:02:52,650
ಅದರ ಸಂಗ್ರಹ ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ನಿಯೋಜಿತವಾದ ಇದೆ.

37
00:02:52,650 --> 00:02:59,260
ಇಲ್ಲಿ, ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಟೈಪಿಸಿದ ಕೇವಲ ಅರ್ಥ -

38
00:02:59,260 --> 00:03:04,350
ಸಿ ನೀವು ಇದು ಕಂಪೈಲ್ ಮಾಡುವಾಗ, ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ಒಂದು ಪೂರ್ಣಾಂಕ ಸೇರಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ,

39
00:03:04,350 --> 00:03:11,000
ಇದು ನೀವು ಒಂದು ಇಂಟ್ ಮತ್ತು ಪಾಯಿಂಟರ್ ಸೇರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ಹೇಳಲು ವಿಶೇಷವೇನು ಏಕೆಂದರೆ ದೂರು ಹೋಗುವುದಿಲ್ಲ.

40
00:03:11,000 --> 00:03:14,710
ಇದು ಕೇವಲ ಒಂದು ಮಾನ್ಯ ಕಾರ್ಯಾಚರಣೆ ಅಲ್ಲ.

41
00:03:14,710 --> 00:03:21,170
ನಾವು ಎರಡನೇ ರಲ್ಲಿ ಪಡೆಯುತ್ತೀರಿ ಮತ್ತೊಂದು ವಿಷಯ.

42
00:03:21,170 --> 00:03:24,860
ಆದರೆ ಪರಿಶೀಲನೆ ಆ ರೀತಿಯ, ಇದು ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ದೂರು ವಾಸ್ತವವಾಗಿ,

43
00:03:24,860 --> 00:03:29,220
ಸ್ಥಿರ ಮಾದರಿ ಪರಿಶೀಲನೆ ಆಗಿದೆ.

44
00:03:29,220 --> 00:03:35,220
ನೀವು ಚಾರ್, ಫ್ಲೋಟ್, ಇಂಟ್ ಹೇಳುವ ಅಗತ್ಯವಿಲ್ಲ ಅಲ್ಲಿ ಭಾಷೆ, ಮತ್ತು ಆ ವಸ್ತುಗಳ ಎಲ್ಲಾ ಇವೆ

45
00:03:35,220 --> 00:03:40,940
ಆದರೆ ಭಾಷೆ, ಅದು ಆಗಿರಬೇಕು ಏನನ್ನು ರೀತಿಯ ವಿಷಯ ಸಂದರ್ಭದಿಂದ ಹೇಳಬಹುದು

46
00:03:40,940 --> 00:03:43,980
ಆದರೆ ಇನ್ನೂ ಸ್ಥಾಯಿಸ್ಥಿತಿಯಲ್ಲಿ ಟೈಪ್ ಮಾಡಿದ.

47
00:03:43,980 --> 00:03:49,000
ನೀವು 51, OCaml ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಆದ್ದರಿಂದ, ನೀವು, ಈ ರೀತಿಯ ಯಾವುದೇ ಬಳಸಲು ಅವಶ್ಯಕತೆಯಿಲ್ಲ

48
00:03:49,000 --> 00:03:58,700
ಆದರೆ ಇನ್ನೂ ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ನೀವು ಇಂಟ್ ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಮಿಶ್ರಣ ಇರುವ ಕಾರಣ ನೀವು ಇದನ್ನು ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ ಹೇಳುವುದಿಲ್ಲ.

49
00:03:58,700 --> 00:04:05,650
ಕ್ರಿಯಾಶೀಲವಾಗಿ ಟೈಪಿಸಿದ ಕೇವಲ ಕೆಲವು ರನ್ ಸಮಯದಲ್ಲಿ ನೀವು ದೂರು ಪಡೆಯಲು ನೀನು ಎಂದರ್ಥ.

50
00:04:05,650 --> 00:04:13,430
ನೀವು ಸಾಮಾನ್ಯವಾಗಿ, ಮೊದಲು ಜಾವಾ ಬಳಸಿದ್ದರೆ, ಯಾವುದೇ ಸಿ ಮಾದರಿಯ ಭಾಷೆ

51
00:04:13,430 --> 00:04:20,070
ಸ್ಥಾಯಿಸ್ಥಿತಿಯಲ್ಲಿ ಆದ್ದರಿಂದ C, C + +, ಜಾವಾ, ಆ ಎಲ್ಲಾ ಸಾಮಾನ್ಯವಾಗಿ ಸ್ಥಾಯಿಸ್ಥಿತಿಯಲ್ಲಿ ಟೈಪಿಸಿದ ಮಾಡಲಾಗುತ್ತದೆ, ಟೈಪಿಸಿದ ಏರಲಿದೆ.

52
00:04:20,070 --> 00:04:22,910
ಜಾವಾದಲ್ಲಿ ನೀವು ಏನಾದರೂ ಸಂಕಲಿಸಲು ಮತ್ತು ನೀವು ಹೇಳುವ ಮಾಡಿದಾಗ

53
00:04:22,910 --> 00:04:26,670
ಸ್ಟ್ರಿಂಗ್ ರು, ಸ್ಟ್ರಿಂಗ್ ಎಂದು ಹೊಸತನ್ನು ಸಮನಾಗಿರುತ್ತದೆ

54
00:04:26,670 --> 00:04:28,950
ಆ ರೀತಿಯ ಕೇವಲ ಸರಿಸಮವಾದ ಕಾರಣ ದೂರು ಹೋಗುವುದಿಲ್ಲ.

55
00:04:28,950 --> 00:04:31,180
ಆ ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ದೂರು ಹೋಗುವುದಿಲ್ಲ.

56
00:04:31,180 --> 00:04:36,750
ನೀವು ಏನಾದರೂ ಎರಕ ಪ್ರಯತ್ನಿಸಿ ಆದರೆ ಇದು ವಸ್ತುಗಳ ಕೆಲವು ಕ್ರಿಯಾತ್ಮಕ ಸಮಯ

57
00:04:36,750 --> 00:04:40,500
ಈಗಿನ ರೀತಿಯ ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟ ಎಂದು ಒಂದು ಬಗೆಯ,

58
00:04:40,500 --> 00:04:45,610
ಅದು ಎರಕಹೊಯ್ದ ಯಶಸ್ಸು ಕಾಣಲಿದೆ ಎಂದು ಪರಿಶೀಲಿಸಲು ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ಮಾಡಬಹುದು ಇಲ್ಲ.

59
00:04:45,610 --> 00:04:51,130
ಜಾವಾವು ಎಂದು ಪರಿಶೀಲಿಸುತ್ತಿರುವುದರಿಂದ ಕೆಲವು ಸಕ್ರಿಯ ಮಾದರಿ ಹೊಂದಿದೆ ಅದನ್ನು ಕೋಡ್ ಆ ಸಾಲಿಗೆ ಗೆಟ್ಸ್ ಬೇಗ

60
00:04:51,130 --> 00:04:54,130
ಇದು ವಾಸ್ತವವಾಗಿ ಕಾರ್ಯರೂಪಕ್ಕೆ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ಕಾಸ್ಟ್ ಮಾಡಲು ವಿಶೇಷವೇನು

61
00:04:54,130 --> 00:04:56,260
ಆ ಪಾತ್ರವರ್ಗಕ್ಕೆ ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ ಮಾನ್ಯ ಎಂದು, ಪರಿಶೀಲಿಸಿ

62
00:04:56,260 --> 00:04:59,890
ಮತ್ತು ಇದು ಒಂದು ವೇಳೆ, ನಂತರ ನೀವು ಅಮಾನ್ಯ ರೀತಿಯ ದೂರುತ್ತಾರೆ ಹೋಗುವುದಿಲ್ಲ.

63
00:04:59,890 --> 00:05:03,200
ಸಕ್ರಿಯ ಮಾದರಿ ಪರಿಶೀಲನೆ.

64
00:05:03,200 --> 00:05:07,010
Dynamic.php ಎಂಬ ಕಡತವನ್ನು ಈ ಟೈಪ್.

65
00:05:10,130 --> 00:05:12,380
Dynamic.php.

66
00:05:14,580 --> 00:05:17,190
ನಾನು ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅನ್ಜಿಪ್ ಮಾಡುತ್ತೇವೆ.

67
00:05:18,750 --> 00:05:21,880
ನಾವು ಪೂರ್ಣಾಂಕ 7 ಹೊಂದಿಸಿ, ಒಂದು ವೇರಿಯೇಬಲ್ ಹೊಂದಿವೆ

68
00:05:21,880 --> 00:05:27,930
ನಂತರ ನಾವು ಮತ್ತು% ರು ಮುದ್ರಿಸಲು ನೀನು -

69
00:05:27,930 --> 00:05:32,830
ಓಹ್, ನಾವು ವಿಧದ ಮುದ್ರಣ ನೀವು, ಆದ್ದರಿಂದ gettype ಚರಮೌಲ್ಯದಬಗೆ ಮರಳಲು ಹೋಗುತ್ತದೆ.

70
00:05:32,830 --> 00:05:35,720
ನಾವು ಕೇವಲ ಮತ್ತು ಮತ್ತೊಮ್ಮೆ ಟೈಪ್ ಮುದ್ರಿಸುವ ಮಾಡುತ್ತಿದ್ದೇವೆ.

71
00:05:35,720 --> 00:05:39,440
ನಾವು php.dynamic.php.

72
00:05:39,440 --> 00:05:45,920
ನಾವು ನೋಡುತ್ತಾರೆ ಎಂದು ಪೂರ್ಣಾಂಕದಿಂದ ಬೂಲಿಯನ್ ಸರಣಿಯನ್ನು ಅದನ್ನು ಬದಲಾವಣೆಗಳನ್ನು ನಾವು ಮೂಲಕ ಹೋಗಿ ಎಂದು.

73
00:05:45,920 --> 00:05:54,590
ಸಿ ಯಾವುದೇ ಬೂಲಿಯನ್ ಅಕ್ಷಾಂಶ ರೀತಿಯ, ಯಾವುದೇ ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷಾಂಶ ಬಗೆ ಇಲ್ಲ.

74
00:05:54,590 --> 00:06:00,500
ಇಲ್ಲ ಚಾರ್ * ಮತ್ತು ಬೂಲಿಯನ್ ಕೇವಲ ಇಂಟ್ ಅಥವಾ ಅಕ್ಷರ ಅಥವಾ ಏನೋ ಒಲವು.

75
00:06:00,500 --> 00:06:05,690
PHP ಈ ರೀತಿಯ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ, ಮತ್ತು ಸಿ ಮೇಲೆ PHP ಯ ದೊಡ್ಡ ಅನುಕೂಲಗಳು ವ್ಯಕ್ತಿ -

76
00:06:05,690 --> 00:06:13,290
ಸ್ಟ್ರಿಂಗ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಅವರು ಕೇವಲ ಕೆಲಸ ಸಿ ಹೆಚ್ಚು PHP ಯಲ್ಲಿ ಕೊನೆಯಿಲ್ಲದ ಸುಲಭ ಎಂದು.

77
00:06:13,290 --> 00:06:18,290
>> ನಾವು ಇಲ್ಲಿ ಹಿಂತಿರುಗಿ.

78
00:06:18,290 --> 00:06:21,260
ನಾವು dynamic.php ನಡೆಯಿತು.

79
00:06:21,260 --> 00:06:26,710
ಈ dynamic.php ರಲ್ಲಿ ಪಿಎಚ್ಪಿ ಕೋಡ್ ಚಲಾಯಿಸಲು PHP ಎಂಬ PHP ವ್ಯಾಖ್ಯಾನಕಾರರು, ಹೇಳುತ್ತದೆ.

80
00:06:26,710 --> 00:06:30,250
ನೀವು ಫೈಲ್ ಯಾವುದೇ ದೋಷಗಳು ಹೊಂದಿದ್ದರೆ, ವಿವರಣೆಯನ್ನು ನಿಮಗೆ ತಿಳಿಸುವರು!

81
00:06:30,250 --> 00:06:39,110
ನಿರೂಪಕ, ಈ PHP ಮತ್ತು ಸಿ ನಡುವೆ ಮತ್ತೊಂದು ದೊಡ್ಡ ವ್ಯತ್ಯಾಸ

82
00:06:39,110 --> 00:06:48,200
ಸಿ ನೀವು ಏನಾದರೂ ಕಂಪೈಲ್ ತದನಂತರ ಆ ಕಂಪೈಲ್ ಕಡತವನ್ನು ಚಲಾಯಿಸಲು ಹೊಂದಿರುತ್ತವೆ.

83
00:06:48,200 --> 00:06:50,490
PHP ನೀವು ಏನು ಕಂಪೈಲ್ ಎಂದಿಗೂ.

84
00:06:50,490 --> 00:06:57,200
ಆದ್ದರಿಂದ PHP ಇಂಟರ್ಪ್ರಿಟರ್ ಮೂಲತಃ ಕೇವಲ ಲೈನ್ ಮೂಲಕ ಈ ಸಾಲನ್ನು ಓದುವ ಇದೆ.

85
00:06:57,200 --> 00:07:02,900
ಇದು var = 7 ನಂತರ ಅದನ್ನು printf ಹೀಗೆ ಹೊಡೆದ ನಂತರ ವರ್ ಹಿಟ್ಸ್ printf ನಂತರ ಹಿಟ್ಸ್ ಹಿಟ್ಸ್.

86
00:07:02,900 --> 00:07:10,910
ಅಲ್ಲಿ ಅದು ಕಂಪೈಲ್ ಒಂದು ಭಾಗ, ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಗ್ರಹಗಳು

87
00:07:10,910 --> 00:07:15,510
ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ನೀವು ಆದ್ದರಿಂದ ನಂತರ ನೀವು, ಕೆಲವು ಮಾಡಬಹುದು

88
00:07:15,510 --> 00:07:19,280
ಆದರೆ ಮೂಲಭೂತವಾಗಿ ಇದು ವಿಷಯ ಲೈನ್ ವಿಂಗಡಿಸಿ ಒಂದು ಲೈನ್.

89
00:07:19,280 --> 00:07:25,280
ಎಂದು ನಾವು C ನಲ್ಲಿ ಪಡೆಯಲು ಎಂದು ಆಪ್ಟಿಮೈಜೇಶನ್ಗಳನ್ನು ಬಹಳಷ್ಟು, ಅಂದರೆ

90
00:07:25,280 --> 00:07:31,920
ಕಂಪೈಲ್ ಇದೂ ಕಂಪೈಲರ್ ನೀವು ತಂತ್ರಗಳನ್ನು ಬಹಳಷ್ಟು ಮಾಡಬಹುದು ಕೇವಲ ಸಾಮಾನ್ಯವಾಗಿ ಇಲ್ಲಿದೆ.

91
00:07:31,920 --> 00:07:36,110
ಇದು ಬಳಕೆಯಾಗದ ಅಸ್ಥಿರ ಔಟ್ ತೆಗೆದುಕೊಳ್ಳಬಹುದು, ಇದು ವಿಷಯಗಳನ್ನು ಈ ರೀತಿಯ ಎಲ್ಲಾ ಮಾಡಬಹುದು

92
00:07:36,110 --> 00:07:38,660
ಅದು ಬಾಲ ರಿಕರ್ಶನ್ ಮಾಡಬಹುದು.

93
00:07:38,660 --> 00:07:42,550
PHP ನೀವು ಪ್ರಯೋಜನ ಪಡೆಯಲು ಹೋಗುತ್ತಿಲ್ಲ

94
00:07:42,550 --> 00:07:45,690
ಇದು ಕೇವಲ ಲೈನ್ ಲೈನ್ ಲೈನ್ ಪಾಲಿಸಲು ಆರಂಭಿಸಲು ವಿಶೇಷವೇನು ಏಕೆಂದರೆ,

95
00:07:45,690 --> 00:07:49,950
ಮತ್ತು ಅದು ನಿಜವಾಗಿಯೂ ಸುಲಭವಾಗಿ ಈ ವಿಷಯಗಳನ್ನು ಗುರುತಿಸುವುದಿಲ್ಲ

96
00:07:49,950 --> 00:07:54,440
ಇದು 1 ದೊಡ್ಡ ಸಂಕಲನ ವಿಷಯ ಮೇಲೆ ಪಾಸ್ ಮತ್ತು ನಂತರ ಮರಣದಂಡನೆ ಅಲ್ಲ ರಿಂದ;

97
00:07:54,440 --> 00:07:56,860
ಇದು ರೇಖೆಯಿಂದ ಕೇವಲ ಲೈನ್.

98
00:08:00,730 --> 00:08:02,750
ಆದ್ದರಿಂದ ಇಂಟರ್ಪ್ರಿಟರ್ ಇಲ್ಲಿದೆ.

99
00:08:02,750 --> 00:08:06,840
>> ನಮ್ಮ ಡೈನಮಿಕ್ ಟೈಪಿಂಗ್ ಹಿಂದಕ್ಕೆ: ಸುಂದರವಾಗಿದೆ, EH?

100
00:08:06,840 --> 00:08:08,640
ನೀವು ಖಂಡಿತವಾಗಿಯೂ ಸಿ ಹಾಗೆ ಆಗಲಿಲ್ಲ!

101
00:08:08,640 --> 00:08:11,860
ನೀವು ಕೆಳಗಿನ ಮೌಲ್ಯಗಳ ಪ್ರತಿ ಪ್ರಕಾರ ವ್ಯಕ್ತಿಯು ಒಂದು ವೇಳೆ ಈಗ ನೋಡಿ.

102
00:08:11,860 --> 00:08:14,760
ಉಲ್ಲೇಖ ಈ ನೋಡಿ.

103
00:08:14,760 --> 00:08:19,420
3.50 ಆದ್ದರಿಂದ. ನೀವು ಎಂದು ವಿಶೇಷವೇನು ಎಂದು ಬಗೆ ತಿಳಿದಿರುವಿರಿ?

104
00:08:24,480 --> 00:08:26,370
ಇಲ್ಲಿ ನಾವು ವಿಧಗಳು.

105
00:08:26,370 --> 00:08:30,430
ನಾವು bools, ಪೂರ್ಣಾಂಕಗಳು, ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್, ತಂತಿಗಳು, ಸಾಲುಗಳು, ವಸ್ತುಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ

106
00:08:30,430 --> 00:08:38,370
ತದನಂತರ ಅಸ್ಪಷ್ಟ ರೀತಿಯ ಸಂಪನ್ಮೂಲಗಳನ್ನು, ಇದು.

107
00:08:38,370 --> 00:08:41,010
ನಾನು ಉದಾಹರಣೆಗೆ ಇಲ್ಲಿ ವಾಸ್ತವವಾಗಿ ಇಲ್ಲ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.

108
00:08:41,010 --> 00:08:43,740
ನಂತರ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಇಲ್ಲ. ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ವಿಶೇಷ ವಿಧ.

109
00:08:43,740 --> 00:08:47,140
ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಕೇವಲ ವಿಳಾಸಕ್ಕೆ 0 ಒಂದು ಪಾಯಿಂಟರ್ ಅಲ್ಲಿ ಸಿ ಭಿನ್ನವಾಗಿ,

110
00:08:47,140 --> 00:08:54,930
PHP ಯಲ್ಲಿ, ಶೂನ್ಯ ಆ ರೀತಿಯ ಮಾತ್ರ ಮಾನ್ಯ ವಿಷಯ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಅಲ್ಲಿ ತನ್ನದೇ ವಿಧ.

111
00:08:57,560 --> 00:09:00,670
ಈ ಹೆಚ್ಚು ಉಪಯುಕ್ತ ದೋಷ ಪರಿಶೀಲನೆಗಾಗಿ ಹೊಂದಿದೆ.

112
00:09:00,670 --> 00:09:04,310
ನೀವು ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮರಳಿ ವೇಳೆ ಅಲ್ಲಿ ಈ ಸಮಸ್ಯೆಯನ್ನು ಹೊಂದಿತ್ತು ಅಲ್ಲಿ ಸಿ,

113
00:09:04,310 --> 00:09:08,660
ನೀವು ಒಂದು ನಲ್ ಪಾಯಿಂಟರ್ ಹಿಂದಿರುಗಿದ ಅಥವಾ ದೋಷ ಸೂಚಿಸುವುದಕ್ಕಾಗಿ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಬಳಸುತ್ತಿರುವ ಅರ್ಥವೇನು

114
00:09:08,660 --> 00:09:12,380
ಅಥವಾ ನಾವು ಒಂದು ಹಂತದಲ್ಲಿ ಎಂದು ಗೊಂದಲ ಎಲ್ಲಾ.

115
00:09:12,380 --> 00:09:18,440
ಇಲ್ಲಿ, ಶೂನ್ಯ ಹಿಂದಿರುಗಿದ ಸಾಮಾನ್ಯವಾಗಿ ದೋಷ ಅರ್ಥ.

116
00:09:20,860 --> 00:09:27,300
ಬಹಳಷ್ಟು ಸಂಗತಿಗಳನ್ನು ಕೂಡ ದೋಷ ತಪ್ಪಾಗಿತ್ತೆಂದು ಹಿಂತಿರುಗಿ.

117
00:09:27,300 --> 00:09:33,140
ಆದರೆ ಪಾಯಿಂಟ್ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ವಿಧ, ಶೂನ್ಯ ರೀತಿಯ ಕೇವಲ ವಿಷಯ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಹೊಂದಿದೆ.

118
00:09:33,140 --> 00:09:40,090
ನೀವು ಕೆಲವು ಅನಾಮಧೇಯ ಕಾರ್ಯಗಳನ್ನು ರೂಪಿಸಬಹುದು ನಂತಹ ನಂತರ ಕಾಲ್ಬ್ಯಾಕ್ ಹೊಂದಿದೆ.

119
00:09:40,090 --> 00:09:46,420
ನೀವು ಕಾರ್ಯವನ್ನು ಒಂದು ಹೆಸರನ್ನು ಹೊಂದಿಲ್ಲ, ಆದರೆ ನೀವು ಇಲ್ಲಿ ಎಂದು ವ್ಯವಹರಿಸಲು ಬೀರುವುದಿಲ್ಲ.

120
00:09:46,420 --> 00:09:53,940
ಅವರು ನಮಗೆ ನಿರೀಕ್ಷೆ ಇರುವ ರೀತಿಯ ನಲ್ಲಿ ನೋಡುತ್ತಿರುವುದು,

121
00:09:53,940 --> 00:09:59,000
ನೀವು 3.50 ಮಾದರಿ ಏನು ಆಲೋಚಿಸುತ್ತೀರಿ ಏನು? >> [ವಿದ್ಯಾರ್ಥಿ] ಫ್ಲೋಟ್.

122
00:09:59,000 --> 00:10:00,370
ಹೌದು.

123
00:10:00,370 --> 00:10:06,290
ಆದ್ದರಿಂದ ಇಲ್ಲಿ, ಈ ರೀತಿಯ ಯಾವ ತಿಳಿದಿರುವಿರಿ? >> [ವಿದ್ಯಾರ್ಥಿ] ಅರೇ.

124
00:10:06,290 --> 00:10:09,890
ಹೌದು. ಮೊದಲ ಒಂದು ಫ್ಲೋಟ್ ಆಗಿತ್ತು, ಎರಡನೇ ಒಂದು ರಚನೆ.

125
00:10:09,890 --> 00:10:14,500
ಈ ಸರಣಿ ಒಂದು ಸಿ ರಚನೆಯ ರೀತಿಯಲ್ಲಿ ಗಮನಿಸಿ

126
00:10:14,500 --> 00:10:19,610
ನೀವು ಸೂಚಕ ಅಲ್ಲಿ 0 ಕೆಲವು ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ, ಸೂಚ್ಯಂಕ 1 ಕೆಲವು ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ.

127
00:10:19,610 --> 00:10:26,320
ಇಲ್ಲಿ ಸೂಚ್ಯಂಕಗಳು ಒಂದು, ಬಿ, ಮತ್ತು ಸಿ ಮತ್ತು ಮೌಲ್ಯಗಳು 1, 2, ಮತ್ತು 3.

128
00:10:26,320 --> 00:10:33,980
PHP ಒಂದು ಅಸ್ಸೋಸಿಯೇಟಿವ್ ಅರ್ರೆಯ್ ಮತ್ತು ಕೇವಲ ಒಂದು ಸಾಮಾನ್ಯ ರಚನೆಯ ನಡುವೆ ವ್ಯತ್ಯಾಸವಿದೆ

129
00:10:33,980 --> 00:10:36,740
ನೀವು ಸಿ ಅದನ್ನು ಯೋಚಿಸುವುದಿಲ್ಲ ಮಾಹಿತಿ

130
00:10:36,740 --> 00:10:43,040
ಅಲ್ಲಿ ಕೇವಲ ಇದು, ಮತ್ತು HOOD ಕೆಳಗೆ ಸಾಮಾನ್ಯ ರಚನೆಯ ಕೇವಲ ಸಹವರ್ತನೀಯ ರಚನೆ

131
00:10:43,040 --> 00:10:50,000
ಅಲ್ಲಿ ಕೆಲವು ಮೌಲ್ಯವನ್ನು ಕೆಲವು ಮೌಲ್ಯವನ್ನು 0 ನಕ್ಷೆಗಳು ಅದೇ ರೀತಿಯಲ್ಲಿ ಒಂದು ನಕ್ಷೆಗಳು.

132
00:10:50,000 --> 00:11:00,410
ಈ ಕಾರಣಕ್ಕಾಗಿ, PHP ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿ ಕೋಡ್ / ಬೆಂಚ್ಮಾರ್ಕಿಂಗ್ ವಸ್ತುಗಳನ್ನು ಬಹಳ ಕೆಟ್ಟ ಮಾಡಬಹುದು

133
00:11:00,410 --> 00:11:07,930
ಸಿ ನೀವು ಒಂದು ವ್ಯೂಹವನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ನಂತರ ನೀವು ಒಂದು ಸದಸ್ಯ ಪ್ರವೇಶಿಸುವ ಸ್ಥಿರ ಸಮಯ ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ.

134
00:11:07,930 --> 00:11:11,860
PHP ಸದಸ್ಯ ಪ್ರವೇಶಿಸುವ ಎಷ್ಟು ಸಮಯ ತಿಳಿದಿರುವ ಹೊಂದಿದೆ?

135
00:11:11,860 --> 00:11:18,970
ಸರಿಯಾಗಿ ಹ್ಯಾಷೆಸ್ ಅದು ಬಹುಶಃ ನಿರಂತರ ಇಲ್ಲಿದೆ.

136
00:11:18,970 --> 00:11:21,620
ಯಾರು ನಿಜವಾಗಿ HOOD ಕೆಳಗೆ ಏನು ತಿಳಿದಿದೆ?

137
00:11:21,620 --> 00:11:25,600
ನೀವು ನಿಜವಾಗಿಯೂ ಆ ವ್ಯವಹರಿಸಲು ವಿಶೇಷವೇನು ಹೇಗೆ ನೋಡಲು ಅನುಷ್ಠಾನ ನೋಡಬೇಕು.

138
00:11:25,600 --> 00:11:28,550
ಆದ್ದರಿಂದ fopen.

139
00:11:28,550 --> 00:11:36,420
ನಾನು PHP ಹಸ್ತಚಾಲಿತ fopen ರಿಟರ್ನ್ ಪ್ರಕಾರ ನೋಡಲು ನಾವು ಇಲ್ಲಿ ಭಾವಿಸುತ್ತೇನೆ.

140
00:11:36,420 --> 00:11:41,260
ನೀವು PHP ಕೈಪಿಡಿಯಲ್ಲಿ ಅತ್ಯಧಿಕವಾಗಿ ಯಾವುದೇ ಫಂಕ್ಷನ್ ಅನ್ನು ನೋಡಬಹುದು ಇಲ್ಲಿ ನೋಡಿ

141
00:11:41,260 --> 00:11:47,540
ಮತ್ತು ಈ PHP ಯ ಮ್ಯಾನ್ ಪುಟವನ್ನು ರೀತಿಯ ಹೊಂದಿದೆ.

142
00:11:47,540 --> 00:11:51,060
ರಿಟರ್ನ್ ರೀತಿಯ ಸಂಪನ್ಮೂಲ ಎಂದು ಹೋಗುತ್ತದೆ.

143
00:11:51,060 --> 00:11:56,050
ನಾನು ಹುಡುಕುತ್ತಿದ್ದವು ಏಕೆ ನಾವು ಸಂಪನ್ಮೂಲ ವ್ಯಾಖ್ಯಾನಿಸಲಿಲ್ಲ ಏಕೆಂದರೆ, ನ.

144
00:11:56,050 --> 00:12:04,110
ಸಂಪನ್ಮೂಲ ಕಲ್ಪನೆಯನ್ನು, ಸಿ ನಿಮ್ಮ ರೀತಿಯ ಫೈಲ್ * ಅಥವಾ ಯಾವುದೇ ಪಡೆದರು;

145
00:12:04,110 --> 00:12:07,200
PHP ಯಲ್ಲಿ ಸಂಪನ್ಮೂಲ ನಿಮ್ಮ ಫೈಲ್ * ಹೊಂದಿದೆ.

146
00:12:07,200 --> 00:12:10,360
ಇದನ್ನು ನೀವು ಓದಲು ಎಂದು ನೀನು ಏನು, ಅದು ನಿಮಗೆ ಬರೆಯಲು ನೀನು ಇಲ್ಲಿದೆ.

147
00:12:10,360 --> 00:12:20,710
ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಬಾಹ್ಯ, ಆದ್ದರಿಂದ ನೀವು ವಸ್ತುಗಳ ಪುಲ್ ಮತ್ತು ವಿಷಯಗಳನ್ನು ಎಸೆಯಲು ಮಾಡಬಹುದು ಉಪಯುಕ್ತವಾದುದು.

148
00:12:20,710 --> 00:12:26,520
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಶೂನ್ಯ ಪ್ರಕಾರ ಏನು? >> [ವಿದ್ಯಾರ್ಥಿ] ಸಾಂಕೇತಿಕಕೊಂಡಿಯು.

149
00:12:26,520 --> 00:12:30,650
ಹೌದು. ಆದ್ದರಿಂದ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಏಕೈಕ ವಿಷಯ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಹೊಂದಿದೆ.

150
00:12:30,650 --> 00:12:33,480
ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಹೊಂದಿದೆ.

151
00:12:35,490 --> 00:12:41,170
>> PHP ಯ ವಿಧದ ವ್ಯವಸ್ಥೆ (ಉತ್ತಮ ಅಥವಾ ಕೆಟ್ಟದ್ದಕ್ಕಾಗಿ) ಒಂದು ವಿಶೇಷತೆಯೆಂದರೆ ರೀತಿಯ ಯಕ್ಷಿಣಿ ತನ್ನ ಸಾಮರ್ಥ್ಯ.

152
00:12:41,170 --> 00:12:44,390
ನೀವು ವಿವಿಧ ರೀತಿಯ ಮೌಲ್ಯಗಳನ್ನು ರಚಿಸಿರುವ PHP ಕೋಡ್ ಒಂದು ಸಾಲು ಬರೆಯುವುದು ಯಾವಾಗ,

153
00:12:44,390 --> 00:12:46,670
PHP ಸಂವೇದನಾಶೀಲ ವಿಷಯ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ.

154
00:12:46,670 --> 00:12:48,920
PHP ಕೋಡ್ ಕೆಳಗಿನ ಸಾಲುಗಳನ್ನು ಪ್ರತಿ ಪ್ರಯತ್ನಿಸಿ. ಏನೆಂದು ಮುದ್ರಿತ ವಿಶೇಷವೇನು?

155
00:12:48,920 --> 00:12:51,000
ನೀವು ನಿರೀಕ್ಷಿಸಿದ ಏನು ಅದು? ವೈ ಅಥವಾ ಏಕೆ ಇಲ್ಲ?

156
00:12:51,000 --> 00:12:58,600
PHP ಬಗ್ಗೆ ಈ ವಾಸ್ತವವಾಗಿ ನಾವು ದುರ್ಬಲವಾಗಿ ಟೈಪ್ ಕರೆಯುವ ಇದು ಏನು.

157
00:12:58,600 --> 00:13:04,610
ದುರ್ಬಲವಾಗಿ ಟೈಪಿಸಿದ ಮತ್ತು ಬಲವಾಗಿ ಟೈಪಿಸಿದ,

158
00:13:04,610 --> 00:13:06,840
ಆ ಅವಧಿಗೆ ವಿವಿಧ ಬಳಕೆಗಳು ಇವೆ

159
00:13:06,840 --> 00:13:12,020
ಆದರೆ ಹೆಚ್ಚಿನ ಜನರು ವಿಷಯ ಈ ರೀತಿಯ ಅರ್ಥ ದುರ್ಬಲವಾಗಿ ಟೈಪಿಸಿದ ಮತ್ತು ಬಲವಾಗಿ ಟೈಪಿಸಿದ ಬಳಸಿ

160
00:13:12,020 --> 00:13:15,920
ಅಲ್ಲಿ ("1" + 2); ಆ ಕೆಲಸ.

161
00:13:15,920 --> 00:13:18,290
ಸಿ ಆ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ.

162
00:13:18,290 --> 00:13:22,490
ಈ ಕೆಲಸ ಕಲ್ಪಿಸಬಹುದಾದ.

163
00:13:22,490 --> 00:13:29,200
ಬಹಳಷ್ಟು ಜನರು ಡೈನಮಿಕ್ ಟೈಪಿಂಗ್ ಮತ್ತು ದುರ್ಬಲ ಟೈಪಿಂಗ್ ಮತ್ತು ಸ್ಥಿರ ಟೈಪಿಂಗ್ ಮತ್ತು ಬಲವಾದ ಟೈಪಿಂಗ್ ಅಪ್ ಮಿಶ್ರಣ.

164
00:13:29,200 --> 00:13:34,050
ಪೈಥಾನ್ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಟೈಪಿಸಿದ ಎಂದು ಒಂದು ಭಾಷೆ ಇನ್ನೊಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.

165
00:13:34,050 --> 00:13:41,770
ನೀವು ಛಲಪರಿಮಾಣಗಳಲ್ಲಿ ರೀತಿಯ ಸುಮಾರು ಥ್ರೋ ಮತ್ತು ಚಾಲನೆ ಸಮಯದಲ್ಲಿ ನಿರ್ಧರಿಸಲು ವಿಶೇಷವೇನು

166
00:13:41,770 --> 00:13:44,680
ಯಾವುದೇ ದೋಷ checkings.

167
00:13:44,680 --> 00:13:50,740
Python ನಲ್ಲಿ ಈ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮತ್ತು ("1" + 2) ನೋಡುತ್ತಾರೆ ವಿಶೇಷವೇನು;

168
00:13:50,740 --> 00:13:55,920
ನೀವು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ಒಂದು ಪೂರ್ಣಾಂಕ ಸೇರಿಸಲಾಗುವುದಿಲ್ಲ ಹೇಳುತ್ತಾರೆ ಏಕೆಂದರೆ ಈ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ.

169
00:13:55,920 --> 00:14:00,860
ಕೇವಲ ಮಾಹಿತಿ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಟೈಪಿಸಿದ ಇದು PHP, ರಲ್ಲಿ, ಈ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ ಮಾಡುವುದಿಲ್ಲ.

170
00:14:00,860 --> 00:14:04,220
ದುರ್ಬಲ ಟೈಪಿಂಗ್ ಇದು ರೀತಿಯ ಕೆಲಸಗಳನ್ನು ಮಾಡುತ್ತಾನೆ ಎಂದು ವಾಸ್ತವವಾಗಿ ಮಾಡಬೇಕಾಗುತ್ತದೆ

171
00:14:04,220 --> 00:14:07,800
ನಿಜವಾಗಿಯೂ ಅಗತ್ಯವಾಗಿ ಅರ್ಥ ಇರುವುದಿಲ್ಲ.

172
00:14:07,800 --> 00:14:17,420
ಆದ್ದರಿಂದ ("1" + 2); ನಾನು ಸ್ಟ್ರಿಂಗ್ 12 ಎಂದು, ನಾನು ಸ್ಟ್ರಿಂಗ್ 3 ಎಂಬ ಕಲ್ಪನೆಯ ಆ ಕಲ್ಪನೆಯ,

173
00:14:17,420 --> 00:14:20,710
ನಾನು ಪೂರ್ಣಾಂಕ 3 ಎಂಬ ಕಲ್ಪನೆಯ.

174
00:14:20,710 --> 00:14:24,530
ಇದು ಅಗತ್ಯವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಅಲ್ಲ, ಮತ್ತು ನಾವು ಬಹುಶಃ ಇಲ್ಲಿ ನೋಡಲು ನೀನು

175
00:14:24,530 --> 00:14:29,140
ನಾವು ಮುದ್ರಿಸಲು ಮಾಡಿದಾಗ ("1" + 2) ಇದು ಬಹುಶಃ ಬೇರೆ ಎಂದು ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು ವಿಶೇಷವೇನು

176
00:14:29,140 --> 00:14:32,320
ಮುದ್ರಣ ಹೆಚ್ಚು (1 + "2").

177
00:14:32,320 --> 00:14:39,700
ಮತ್ತು ಈ ಕೆಡುತ್ತದೆ, ನನ್ನ ಅಭಿಪ್ರಾಯದಲ್ಲಿ, ಕಾಣುತ್ತಾರೆ.

178
00:14:39,700 --> 00:14:44,240
ಇಲ್ಲಿ ನಾವು ಈ ಪ್ರಯತ್ನಿಸಬಹುದು.

179
00:14:44,240 --> 00:14:48,740
PHP ಬಗ್ಗೆ ಇನ್ನೊಂದು ಸ್ವಲ್ಪ ಟ್ರಿಕ್ ನಿಜವಾಗಿಯೂ ಕಡತವನ್ನು ಬರೆಯಲು ಅಗತ್ಯವಿರುವುದಿಲ್ಲ ಆಗಿದೆ.

180
00:14:48,740 --> 00:14:52,790
ಈ ಆಜ್ಞೆಯನ್ನು ಮೋಡ್ ರನ್ ಹೊಂದಿದೆ.

181
00:14:52,790 --> 00:14:57,710
PHP-R, ಆದ್ದರಿಂದ ನಾವು ಇಲ್ಲಿ ಆಜ್ಞೆಯನ್ನು ಎಸೆಯಿರಿ ಮಾಡಬಹುದು:

182
00:14:57,710 --> 00:15:06,610
"ಮುದ್ರಣ ('1 '+ 2);" ಮತ್ತು ನಾನು ಹೊಸ ಲೈನ್ ಎಸೆಯಲು ಮಾಡುತ್ತೇವೆ.

183
00:15:19,550 --> 00:15:23,970
ಈ 3 ಮುದ್ರಿತ.

184
00:15:31,100 --> 00:15:35,330
ಇದು 3 ಮುದ್ರಿಸುತ್ತದೆ ಮತ್ತು ಪೂರ್ಣಾಂಕ 3 ಕಾಣುತ್ತಿಲ್ಲ.

185
00:15:35,330 --> 00:15:38,420
ಈಗ ಅವರ ಇತರ ಪ್ರಯತ್ನಿಸೋಣ:

186
00:15:38,420 --> 00:15:42,970
"ಮುದ್ರಣ (1 + '2 ');

187
00:15:45,560 --> 00:15:50,490
ನಾವು 3 ಪಡೆಯಲು, ಮತ್ತು ಇದು ಪೂರ್ಣಾಂಕ 3 ಎಂದು ಹೋಗುತ್ತದೆ? ನಾನು ಪ್ರಾಮಾಣಿಕವಾಗಿ ಕಲ್ಪನೆಯೂ ಇಲ್ಲ.

188
00:15:50,490 --> 00:15:54,030
ಅದು ಸ್ಥಿರವಾಗಿರುತ್ತದೆ ಎಂದು ತೋರುತ್ತಿದೆ.

189
00:15:54,030 --> 00:15:59,550
ಇದು ಸ್ಟ್ರಿಂಗ್ 12 ಅಥವಾ ಹಾಗೆ ಏನು ಎಂಬ ಯಾವುದೇ ಅವಕಾಶ ಎಂಬುದನ್ನು ಎಂದಿಗೂ

190
00:15:59,550 --> 00:16:08,080
ಏಕೆಂದರೆ ತುಂಬಾ PHP, ಭಿನ್ನವಾಗಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಜಾವಾ,

191
00:16:08,080 --> 00:16:11,670
ಪೋಣಿಸುವಿಕೆಯ ಪ್ರತ್ಯೇಕ ಆಯೋಜಕರು ಹೊಂದಿದೆ.

192
00:16:11,670 --> 00:16:14,930
PHP ಯಲ್ಲಿ ಪೋಣಿಸುವಿಕೆಯ ಬಿಂದುವನ್ನು ಹೊಂದಿದೆ.

193
00:16:14,930 --> 00:16:22,950
ಮುದ್ರಣ ಆದ್ದರಿಂದ (1 '2 '.); ನಮಗೆ 12 ನೀಡಲು ಹೋಗುತ್ತದೆ.

194
00:16:25,790 --> 00:16:32,420
ಈ ಜನರು Str + = ರೀತಿಯ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ ಅಲ್ಲಿ ಗೊಂದಲಕ್ಕೆ ದಾರಿ ಒಲವು

195
00:16:32,420 --> 00:16:37,840
ತಮ್ಮ ಸರಣಿಯ ಅಂತ್ಯಕ್ಕೆ ಮೇಲೆ ಸೇರಿಸಲು ಬಯಸುವ, ಮತ್ತು ವಿಫಲವಾದ ವಿಶೇಷವೇನು ಕೆಲವು ವಿಷಯ.

196
00:16:37,840 --> 00:16:40,770
ನೀವು Str ಮಾಡಬೇಕಾದ್ದು. =

197
00:16:42,000 --> 00:16:46,240
ಆದ್ದರಿಂದ PHP ಯಲ್ಲಿ ಪೋಣಿಸುವಿಕೆಯ ಒಂದು ಬಿಂದುವನ್ನು ಹೊಂದಿದೆ ಎಂಬುದನ್ನು ಮರೆಯಬೇಡಿ.

198
00:16:46,240 --> 00:16:52,100
ಪ್ರಯತ್ನಿಸಿ ಇತರ ವಸ್ತುಗಳು: ("CS" + 50) ಮುದ್ರಿಸಲು;

199
00:16:55,750 --> 00:17:03,610
ನಾನು CS50 ಪರಿಣಾಮವಾಗಿ ಈ ಯಾವುದೇ ಭರವಸೆ ಇಲ್ಲ ಎಂದು ಹೇಳಿದರು ನಾವು

200
00:17:03,610 --> 00:17:06,119
ಪೋಣಿಸುವಿಕೆಯ + ಕಾರಣ.

201
00:17:06,119 --> 00:17:08,440
ನೀವು ಇದಕ್ಕೆ ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು ಹೋಗುತ್ತದೆ ಏನು ಆಲೋಚಿಸುತ್ತೀರಿ ಏನು?

202
00:17:10,359 --> 00:17:13,460
ನಾನು ಪ್ರಾಮಾಣಿಕವಾಗಿ ಸಂಪೂರ್ಣವಾಗಿ ಕಲ್ಪನೆಯೂ ಇಲ್ಲ.

203
00:17:14,250 --> 00:17:16,460
ಅದು ಕೇವಲ 50 ಕಾಣುತ್ತಿಲ್ಲ.

204
00:17:16,460 --> 00:17:21,490
ಇದು ಸ್ಟ್ರಿಂಗ್ ಕಾಣುತ್ತಾನೆ, ಮತ್ತು ನಾವು 123CS ಮಾಡಿದರೆ ನಾನು ಜೂಜು -

205
00:17:21,490 --> 00:17:29,640
ಮೊದಲ ಸಾಲನ್ನು ನೋಡುತ್ತಾನೆ, ಅದು ಒಂದು ಪೂರ್ಣಾಂಕ ಅಥವಾ ಒಂದು ಸಂಖ್ಯೆ ಓದಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ.

206
00:17:29,640 --> 00:17:31,710
ಈ ಪ್ರಕರಣದಲ್ಲಿ 123CS ನೋಡುತ್ತಾನೆ.

207
00:17:31,710 --> 00:17:35,190
"ಒಂದು ಪೂರ್ಣಾಂಕವಾಗಿ ಅರ್ಥದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ ಎಂದು, ಆದ್ದರಿಂದ ನಾನು 123 ನಗರದ ಪಡೆಯಲಿದ್ದೇನೆ."

208
00:17:35,190 --> 00:17:38,580
123 ಆದ್ದರಿಂದ + 50 173 ಏರಲಿದೆ.

209
00:17:38,580 --> 00:17:40,740
ಮತ್ತು ಇಲ್ಲಿ ಒಂದು ಪೂರ್ಣಾಂಕವಾಗಿ ಈ ಓದುವ ಆರಂಭವಾಗುತ್ತದೆ.

210
00:17:40,740 --> 00:17:45,690
ಇದು ಏನು ನೋಡಿ ಇಲ್ಲ, ಇದು ಅದನ್ನು 0 ಎಂದು ಪರಿಗಣಿಸುತ್ತದೆ ಆದ್ದರಿಂದ. 0 ಆದ್ದರಿಂದ + 50 50 ಎಂದು ಹೋಗುತ್ತದೆ.

211
00:17:45,690 --> 00:17:51,600
ನಾನು ಊಹಿಸಿಕೊಂಡು ನಾನು ಈ ರೀತಿಯ ಏನಾದರೂ ಮಾಡಲು ಹೋಗುತ್ತದೆ.

212
00:17:51,600 --> 00:17:54,310
ನಾನು 99 ನಾನು ಯೋಚಿಸುತ್ತೇನೆ.

213
00:17:54,310 --> 00:17:57,580
ಹೌದು, ಇದು ಮೊದಲ ತೆಗೆದುಕೊಳ್ಳುವುದು ಏಕೆಂದರೆ -

214
00:18:12,880 --> 00:18:15,730
99 ಆದ್ದರಿಂದ.

215
00:18:15,730 --> 00:18:21,970
ಈ ಸಿ ವೇಳೆ ಇಲ್ಲಿ (10/7), ಎಂದು ಯಾವ ಹಿಂದಿರುಗುತ್ತಿದ್ದವು?

216
00:18:23,700 --> 00:18:29,630
[ವಿದ್ಯಾರ್ಥಿ] 1. 10/7 2 ಪೂರ್ಣಾಂಕಗಳ ಭಾಗಿಸುವ ಏಕೆಂದರೆ >> ಹೌದು, ಇದು 1 ಎಂದು.

217
00:18:29,630 --> 00:18:32,910
ಒಂದು ಪೂರ್ಣಾಂಕ ಭಾಗಿಸಿ ಒಂದು ಪೂರ್ಣಾಂಕ ಒಂದು ಪೂರ್ಣಾಂಕ ಮರಳಲು ಹೋಗುತ್ತದೆ.

218
00:18:32,910 --> 00:18:37,750
ಇದು ಎಂದು 1 ಬಿಂದು ಏನೇ ಹಿಂತಿರುಗಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದ್ದರಿಂದ ಕೇವಲ 1 ಮರಳಲು ವಿಶೇಷವೇನು.

219
00:18:37,750 --> 00:18:46,120
ಇಲ್ಲಿ (10/7) ಮುದ್ರಿಸುವ; ಇದು ವಾಸ್ತವವಾಗಿ ಎಂದು ಅರ್ಥೈಸಲು ವಿಶೇಷವೇನು.

220
00:18:46,120 --> 00:18:53,760
ಈ ಅರ್ಥ, ನೀವು ವಾಸ್ತವವಾಗಿ ಆ ರೀತಿಯ ಪೂರ್ಣಾಂಕ ಪೂರ್ಣಾಂಕವನ್ನು ಮತ್ತು ಸ್ಟಫ್ ಮಾಡಲು ಬಯಸಿದರೆ

221
00:18:53,760 --> 00:18:59,950
ನೀವು ಮುದ್ರಣ (ಮಹಡಿ (10/7)) ಮಾಡಲು ಅಗತ್ಯವಿದೆ;

222
00:18:59,950 --> 00:19:08,460
ಸಿ ಇದನ್ನು, ನೀವು ನಿಯಮಿತವಾಗಿ ಪೂರ್ಣಾಂಕ ಮೊಟಕುಗೊಳಿಸುವ ಅವಲಂಬಿಸಿವೆ ಎಂದು ಬಹುಶಃ ವಿಲಕ್ಷಣ ಇಲ್ಲಿದೆ

223
00:19:08,460 --> 00:19:12,260
ಆದರೆ PHP ಯಲ್ಲಿ ನೀವು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಒಂದು ಫ್ಲೋಟ್ ಅದನ್ನು ಮಾಡುತ್ತದೆ ಏಕೆಂದರೆ.

224
00:19:13,430 --> 00:19:17,610
ಮತ್ತು ನಂತರ (7 + ನಿಜವಾದ); ನೀವು ಎಂದು ವಿಶೇಷವೇನು ಎಂದು ಏನು ಆಲೋಚಿಸುತ್ತೀರಿ ಏನು?

225
00:19:18,550 --> 00:19:23,640
ಇದು 1 ನಿಜವಾದ ಅರ್ಥೈಸಲು ವಿಶೇಷವೇನು ನಾನು 8 ಊಹೆ ನುಡಿದರು.

226
00:19:23,640 --> 00:19:25,740
ಇದು 8 ಕಾಣುತ್ತಿಲ್ಲ.

227
00:19:25,740 --> 00:19:31,710
>> ನಾವು ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಹಾಗೆ ಮಾಡಬಾರದು ಕಳೆದ 10 ನಿಮಿಷಗಳಲ್ಲಿ ಮಾಡಿದ ಏನು ಹಾಗೆ.

228
00:19:31,710 --> 00:19:39,870
ಈ ಮಾಡುತ್ತದೆ ಕೋಡ್ ನೋಡುತ್ತಾರೆ.

229
00:19:39,870 --> 00:19:42,700
ಇದು ಎಂದು ನೇರ ಎಂದು ಹೊಂದಿಲ್ಲ.

230
00:19:42,700 --> 00:19:47,240
ನೀವು 2 ಅಸ್ಥಿರ ಸಾಧ್ಯತೆಯಿದೆ, ಮತ್ತು 1 ವೇರಿಯಬಲ್ ಸ್ಟ್ರಿಂಗ್ ಸಂಭವಿಸಿದರೆ

231
00:19:47,240 --> 00:19:51,310
ಮತ್ತು ಇತರ ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ಒಂದು ಇಂಟ್ ಎಂದು ಸಂಭವಿಸುತ್ತದೆ, ಮತ್ತು ನಂತರ ನೀವು ಒಟ್ಟಿಗೆ ಈ ಅಸ್ಥಿರಗಳು ಸೇರಿಸಿ.

232
00:19:51,310 --> 00:20:00,120
PHP ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಟೈಪಿಸಿದ ಇದೆ ಮತ್ತು ನೀವು ಯಾವುದೇ ರೀತಿಯ ತಪಾಸಣೆ ಮಾಡಲು ಕಾರಣ

233
00:20:00,120 --> 00:20:03,640
ಮತ್ತು ಅದು ದುರ್ಬಲವಾಗಿ ಟೈಪಿಸಿದ ರ ಮತ್ತು ಇದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಒಟ್ಟಾಗಿ ಈ ವಸ್ತುಗಳನ್ನು ಎಸೆಯುವ ಏಕೆಂದರೆ

234
00:20:03,640 --> 00:20:11,490
ಮತ್ತು ಎಲ್ಲವೂ ಕೆಲಸ ಮಾಡುತ್ತದೆ, ಅದು, ಈ ವೇರಿಯಬಲ್ ಈಗ ಸ್ಟ್ರಿಂಗ್ ಮಾಡಬೇಕು ಎಂದು ತಿಳಿಯಲು ಕಷ್ಟ

235
00:20:11,490 --> 00:20:14,930
ಆದ್ದರಿಂದ ನಾನು ಒಂದು ಪೂರ್ಣಾಂಕ ಇದು, ಈ ವೇರಿಯಬಲ್ ಸೇರಿಸಿ ಮಾಡಬಾರದು.

236
00:20:18,780 --> 00:20:24,560
ಒಂದು ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ಸ್ಟ್ರಿಂಗ್ ವೇಳೆ ಅತ್ಯುತ್ತಮ ಪರಿಪಾಠವಾಗಿದೆ, ಶಾಶ್ವತವಾಗಿ ಸ್ಟ್ರಿಂಗ್ ಎಂದು ನೋಡಿಕೊಳ್ಳಿ.

237
00:20:24,560 --> 00:20:26,980
ಒಂದು ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ಒಂದು ಇಂಟ್ ವೇಳೆ, ಎಂದೆಂದಿಗೂ ಒಂದು ಇಂಟ್ ಎಂದು ನೋಡಿಕೊಳ್ಳಿ.

238
00:20:26,980 --> 00:20:30,770
ನೀವು, ಪೂರ್ಣಾಂಕಗಳು ಮತ್ತು ತಂತಿಗಳನ್ನು ವ್ಯವಹರಿಸಲು ಬಯಸಿದರೆ

239
00:20:30,770 --> 00:20:36,970
ನೀವು varsint ಬಳಸಬಹುದು - ಇವು JavaScript ನ.

240
00:20:36,970 --> 00:20:42,520
Intval. ನಾನು ಈ ಎಲ್ಲಾ ಬಾರಿ. PHP ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನಾನು ಎಲ್ಲವನ್ನೂ ಅಪ್ ಮಿಶ್ರಣ.

241
00:20:42,520 --> 00:20:47,600
ಆದ್ದರಿಂದ intval ಒಂದು ಚರಾಂಶದ ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯ ಮರಳಲು ಹೋಗುತ್ತದೆ.

242
00:20:47,600 --> 00:20:56,550
ನಾವು "ಮುದ್ರಣ (intval ('123 ')) ರಲ್ಲಿ ಹಾದು ವೇಳೆ; ನೀವು 123 ಸಿಗುತ್ತದೆ.

243
00:21:06,820 --> 00:21:15,850
Intval ಸ್ವತಃ ಪ್ರತ್ಯೇಕವಾಗಿ ಒಂದು ಪೂರ್ಣಾಂಕ ಎಂದು ನಮಗೆ ಚೆಕ್ ಮಾಡಲು ಹೋಗುತ್ತಿಲ್ಲ ಇದೆ.

244
00:21:15,850 --> 00:21:20,460
PHP ಕೈಪಿಡಿ, ಕೇವಲ ಅನೇಕ ಕಾರ್ಯಗಳನ್ನು ಲಭ್ಯವಿಲ್ಲ

245
00:21:20,460 --> 00:21:26,560
ಇಲ್ಲಿ ನಾನು ಏನು ನಾನು ಬಳಸುವ ಮೊದಲ is_numeric ಎಂದು.

246
00:21:26,560 --> 00:21:32,590
ನಾನು ತಪ್ಪು ಮರಳಿದರು ಎಂದು ಊಹಿಸಲು ನುಡಿದರು.

247
00:21:32,590 --> 00:21:35,780
ನಾವು === ಹೊಂದಿದೆ ಮೇಲೆ ಹೋಗಬೇಕಾಗುತ್ತದೆ ಮತ್ತೊಂದು ವಿಷಯ.

248
00:21:37,850 --> 00:21:44,020
ಆದ್ದರಿಂದ is_numeric ('123df '), ಆ ಮಾಹಿತಿ is_numeric ನಗರದ ಎಂದು.

249
00:21:44,020 --> 00:21:46,720
ಸಿ ಎಲ್ಲಾ ಪಾತ್ರಗಳ ಮೇಲೆ ತಿರುಗಿ ಇರಬೇಕು

250
00:21:46,720 --> 00:21:50,410
ಮತ್ತು ಪ್ರತಿ ಪಾತ್ರದ ಅಂಕಿಯ ಅಥವಾ ಯಾವುದೇ ವೇಳೆ ಪರೀಕ್ಷಿಸಿ.

251
00:21:50,410 --> 00:21:53,850
ಇಲ್ಲಿ is_numeric, ನಮಗೆ ಹಾಗೆ ಹೋಗುವ ಇದೆ

252
00:21:53,850 --> 00:21:56,520
ಮತ್ತು ಅದು ತಪ್ಪು ಮರಳಿದ ನ.

253
00:21:56,520 --> 00:22:02,120
ಹಾಗಾಗಿ ಆ ಮುದ್ರಿತ ಅದು, ಇಲ್ಲಿ ನಾನು ಅದನ್ನು ನೋಡಲು ಹೋಲಿಸುವ ನಾನು, ಏನೂ ಮುದ್ರಿತ

254
00:22:02,120 --> 00:22:05,490
ನೀವು ಸುಳ್ಳು ಎಂದು ಹೇಗಾಯಿತು? ಆದ್ದರಿಂದ ಈಗ 1 ಮುದ್ರಣ ಮಾಡಿದ.

255
00:22:05,490 --> 00:22:10,060
ಸ್ಪಷ್ಟವಾಗಿ ಇದು ಬದಲಾಗಿ ನಿಜವಾದ ಎಂದು ನಿಜವಾದ ಮುದ್ರಿಸುವ ನಿಜವಾದ ಎಂದು 1 ಮುದ್ರಿಸುತ್ತದೆ.

256
00:22:10,060 --> 00:22:15,790
ನಾನು print_r ನಾನು ಆಶ್ಚರ್ಯ. ಇಲ್ಲ, ಇದು ಇನ್ನೂ 1 ಮಾಡುತ್ತದೆ.

257
00:22:15,790 --> 00:22:26,760
>> === ಹಿಂದಕ್ಕೆ ಹೋಗಿ, == ಈಗಲೂ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ

258
00:22:26,760 --> 00:22:32,260
ಮತ್ತು ನೀವು ಟಾಮಿ ಮಾತನಾಡಲು ವೇಳೆ ಅವರು ಹೇಳುತ್ತೇನೆ == ನಿಖರವಾಗಿ ಉತ್ತಮವಾಗಿದೆ.

259
00:22:32,260 --> 00:22:37,700
ನಾನು == ಭಯಾನಕ ಮತ್ತು ನೀವು == ಇಲ್ಲ ಎಂದು ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ.

260
00:22:37,700 --> 00:22:44,870
ವ್ಯತ್ಯಾಸ == ವಿಷಯಗಳನ್ನು ಹೋಲಿಸುವ ಆಗಿದೆ

261
00:22:44,870 --> 00:22:48,450
ಅವರು ಅದೇ ರೀತಿಯ ಅಲ್ಲ ಸಹ ನಿಜವಾದ ಮಾಡಬಹುದು,

262
00:22:48,450 --> 00:22:53,810
=== ವಿಷಯಗಳನ್ನು ಹೋಲಿಸುತ್ತದೆ ಮೊದಲು ಚೆಕ್ ಅದೇ ರೀತಿಯ ಅವರು? ಆದರೆ

263
00:22:53,810 --> 00:22:58,010
ಹೌದು. ಸರಿ, ಈಗ ನಾನು ನಿಜವಾಗಿ ಸಮಾನ ಎಂದು ಹೋಲಿಸಿ ನೋಡಲು ಪಡೆಯಲಿದ್ದೇನೆ.

264
00:22:58,010 --> 00:23:08,890
ನೀವು 10 ರೀತಿಯ ವಿಚಿತ್ರವಾದ ವಿಷಯಗಳನ್ನು ಸಮನಾಗಿರುತ್ತದೆ ಪಡೆಯಲು - ಹೇಳುತ್ತಾರೆ ಎಂಬುದನ್ನು ನೋಡೋಣ.

265
00:23:08,890 --> 00:23:15,570
ಆದ್ದರಿಂದ ('10 '== '1 E1');

266
00:23:15,570 --> 00:23:17,980
ಈ ನಿಜವಾದ ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

267
00:23:17,980 --> 00:23:21,420
ಯಾರಾದರೂ ಈ ನಿಜವಾದ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಏಕೆ ಯಾವುದೇ ಊಹೆಗಳು ಹೊಂದಿದೆ?

268
00:23:25,180 --> 00:23:27,120
ಇದು ಕೇವಲ ಬಗ್ಗೆ ಅಲ್ಲ. ಬಹುಶಃ ಈ ಒಂದು ಸುಳಿವು ಹೊಂದಿದೆ.

269
00:23:27,120 --> 00:23:33,170
ಆದರೆ ನಾನು ಒಂದು F ಎಂದು ಬದಲಿಸಿದರೆ - ಇದು ಡಾರ್ನ್! ನಾನು ಎರಡು ಉಲ್ಲೇಖಗಳು ಅನ್ನು ಇರಿಸಿಕೊಳ್ಳಲು.

270
00:23:33,170 --> 00:23:38,780
ನಾನು ಎರಡು ಉಲ್ಲೇಖಗಳು ಈ ಇರಿಸಿದ್ದೇವೆ ಏಕೆಂದರೆ ಎರಡು ಉಲ್ಲೇಖಗಳು ನನಗೆ ಚೀರುತ್ತಾ ಹಾರಿದಂತೆ ಮಾಡಲಾಗುತ್ತದೆ ಕಾರಣ.

271
00:23:38,780 --> 00:23:43,850
ಹಾಗಾಗಿ ಇಲ್ಲಿ ಜೋಡಿ ಉದ್ಧರಣ ತಪ್ಪಿಸಿಕೊಳ್ಳಲು ಆದರೆ ತಂತುವನ್ನು ಸುಲಭವಾಗುತ್ತದೆ.

272
00:23:43,850 --> 00:23:49,120
ಆದ್ದರಿಂದ ('10 '== '1 F1'); ನಿಜವಾದ ಮುದ್ರಿಸಲು ಮಾಡುವುದಿಲ್ಲ. ('10 '== '1 E1'); ನಿಜವಾದ ಮುದ್ರಿಸುತ್ತದೆ.

273
00:23:49,120 --> 00:23:56,330
[ವಿದ್ಯಾರ್ಥಿ] ಇದು ಹೆಕ್ಸ್ ಈಸ್? >> ಇದು ಹೆಕ್ಸ್ ಅಲ್ಲ, ಆದರೆ ಅದು ಹಾಗೆ ಎಂದು ಹಂತದಲ್ಲಿದೆ -

274
00:23:56,330 --> 00:24:01,060
1e1, ವೈಜ್ಞಾನಿಕ ಸಂಕೇತಗಳನ್ನು.

275
00:24:01,060 --> 00:24:07,950
ಇದು 1 1e1 ಗುರುತಿಸುತ್ತದೆ * 10 ^ 1 ಅಥವಾ ಯಾವುದೇ.

276
00:24:07,950 --> 00:24:11,510
ಆ ಸಮಾನ ಪೂರ್ಣಾಂಕಗಳಾಗಿದ್ದು.

277
00:24:11,510 --> 00:24:15,930
ನಾವು === ಮಾಡಿದರೆ ಅದು ತಪ್ಪು ಎಂದು ವಿಶೇಷವೇನು.

278
00:24:15,930 --> 00:24:28,490
ನಾವು ನಾನು ವಾಸ್ತವವಾಗಿ ಕಲ್ಪನೆಯೂ ಇಲ್ಲ == ಏನು (10 ಮತ್ತು '10abc ') ಬಗ್ಗೆ;? ಎಲ್ಲಾ ಸರಿ. ಆದ್ದರಿಂದ ನಿಜ.

279
00:24:28,490 --> 00:24:35,940
, ಮತ್ತು ಅದನ್ನು 20 ಎಂದು; ಆದ್ದರಿಂದ ನೀವು (10 + '10abc ') ಮಾಡಿದರು ಯಾವಾಗ ಇಷ್ಟ

280
00:24:35,940 --> 00:24:38,800
ಇಲ್ಲಿ (10 == '10abc '); ನಿಜ.

281
00:24:38,800 --> 00:24:45,350
ಇನ್ನೂ ಗಂಭೀರವಾಗಿದೆ ವಿಷಯಗಳನ್ನು (ಸುಳ್ಳು == ಸಾಂಕೇತಿಕಕೊಂಡಿಯು) ಇವೆ; ನಿಜ

282
00:24:45,350 --> 00:24:52,210
ಅಥವಾ (ಸುಳ್ಳು == 0); ನಿಜ, (ತಪ್ಪು == []);

283
00:24:52,210 --> 00:25:00,970
ನ ವಿಲಕ್ಷಣ ಪ್ರಕರಣಗಳು - ಆ ವಿಲಕ್ಷಣ ಪ್ರಕರಣಗಳು ಒಂದಾಗಿದೆ.

284
00:25:00,970 --> 00:25:08,110
ಗಮನಿಸಿ ಆ (ಸುಳ್ಳು == []); ನಿಜ.

285
00:25:08,110 --> 00:25:11,950
('0 '== ಸುಳ್ಳು); ನಿಜ.

286
00:25:11,950 --> 00:25:16,090
('0 '== []); ತಪ್ಪಾಗಿದೆ.

287
00:25:16,090 --> 00:25:19,090
ಆದ್ದರಿಂದ == ಸಕರ್ಮಕ ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ.

288
00:25:19,090 --> 00:25:26,830
, ಒಂದು ಬೌ ಸಮನಾಗಿರಬೇಕು ಮತ್ತು ಒಂದು ಸಿ ಸಮಾನವಾಗಿರಬೇಕು ಮಾಡಬಹುದು

289
00:25:26,830 --> 00:25:29,340
ಆದರೆ ಬಿ ಸಿ ಸಮಾನವಾಗಿರುತ್ತದೆ ಇರಬಹುದು.

290
00:25:29,340 --> 00:25:35,580
ನನಗೆ ಒಂದು ಅಬೊಮಿನೇಷನ್, ಮತ್ತು ನೀವು ಯಾವಾಗಲೂ === ಬಳಸಬೇಕು.

291
00:25:35,580 --> 00:25:38,590
[ವಿದ್ಯಾರ್ಥಿ] ನಾವು ಮಾಡಬಹುದು! == ಹಾಗೆಯೇ? >> [ಬೌಡೆನ್] ಹೌದು.

292
00:25:38,590 --> 00:25:44,600
ಸಮಾನ ಎಂದು! = ಮತ್ತು! ==.

293
00:25:44,600 --> 00:25:48,230
ಈ ವಾಸ್ತವವಾಗಿ pset ನಿರ್ದಿಷ್ಟಪಡಿಸುವಿಕೆಯನ್ನು ಬೆಳೆದನು

294
00:25:48,230 --> 00:25:52,000
ಅಲ್ಲಿ ಕಾರ್ಯಗಳನ್ನು ಮರಳಿ ಸಾಕಷ್ಟು -

295
00:25:52,000 --> 00:25:53,890
PHP ಕೈಪಿಡಿಯ ಈ ಬಗ್ಗೆ ಒಳ್ಳೆಯದು.

296
00:25:53,890 --> 00:25:59,140
ಇದು "ದೋಷವುಂಟಾಗಿದೆ ಈ ತಪ್ಪು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.", ದೊಡ್ಡ ಕೆಂಪು ಪೆಟ್ಟಿಗೆಯಲ್ಲಿ ಹಾಕುತ್ತದೆ

297
00:25:59,140 --> 00:26:03,940
ಆದರೆ ಮರಳಿ 0 ಮರಳಲು ಸಂಪೂರ್ಣವಾಗಿ ಯೋಗ್ಯವಾದ ವಿಷಯ.

298
00:26:03,940 --> 00:26:08,250
ಒಂದು ಪೂರ್ಣಾಂಕ ವಾಪಸಾಗುವ ನಿರೀಕ್ಷೆಯಿತ್ತಾದರೂ ಯಾವುದೇ ಕಾರ್ಯದ ಬಗ್ಗೆ ಯೋಚಿಸಿ.

299
00:26:11,250 --> 00:26:17,880
ಲೆಟ್ಸ್ ಈ ಕಾರ್ಯವನ್ನು ಒಂದು ಕಡತ ಅಥವ ಏನೋ ಸಾಲುಗಳು ಸಂಖ್ಯೆಯನ್ನು ಹೇಳಲಾಗುವ ಹೇಳುತ್ತಾರೆ.

300
00:26:17,880 --> 00:26:23,490
ಸಾಮಾನ್ಯ ಸಂದರ್ಭಗಳಲ್ಲಿ, ನೀವು ಈ ಕಾರ್ಯವನ್ನು ಒಂದು ಕಡತ ಹಾದು

301
00:26:23,490 --> 00:26:27,120
ಮತ್ತು ರೇಖೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಒಂದು ಪೂರ್ಣಾಂಕ ಮರಳಲು ವಿಶೇಷವೇನು.

302
00:26:27,120 --> 00:26:30,820
ಫೈಲ್ ಕೇವಲ ಖಾಲಿ ವೇಳೆ ಆದ್ದರಿಂದ 0 ಸಂಪೂರ್ಣವಾಗಿ ಸಮಂಜಸವಾದ ಸಂಖ್ಯೆ.

303
00:26:30,820 --> 00:26:36,810
ನೀವು ಅಮಾನ್ಯ ಕಡತ ರವಾನಿಸಲು ಮತ್ತು ಆದರೆ ಕಾರ್ಯ ತಪ್ಪು ಮರಳಲು ಏನು ಸಂಭವಿಸುತ್ತದೆ

304
00:26:36,810 --> 00:26:38,860
ನೀವು ಅಮಾನ್ಯ ಕಡತ ಹಾದು ವೇಳೆ?

305
00:26:38,860 --> 00:26:46,500
ನೀವು ಮಾಡಿದರೆ == ನೀವು ಅಮಾನ್ಯ ಕಡತ ಮತ್ತು ಖಾಲಿ ಫೈಲ್ ನಡುವೆ ಸಂದರ್ಭದಲ್ಲಿ ವ್ಯತ್ಯಾಸ ಇಲ್ಲ.

306
00:26:48,870 --> 00:26:51,350
ಯಾವಾಗಲೂ === ಬಳಸಿ.

307
00:26:55,690 --> 00:26:58,000
ಆ ಎಲ್ಲಾ ಇಲ್ಲಿದೆ.

308
00:26:58,000 --> 00:27:01,660
>> PHP ಯಲ್ಲಿ, ರಚನೆಯ ಪ್ರಕಾರ ನೀವು ಸಿ ರಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ ಏನನ್ನು ಭಿನ್ನವಾಗಿದೆ

309
00:27:01,660 --> 00:27:06,650
ಈ ರೀತಿಯ ರಚನೆಯ ಎಂದು ಕಂಡಾಗ ವಾಸ್ತವವಾಗಿ, ನೀವು ಈಗಾಗಲೇ ಈ ಮೇಲೆ ಗಮನಿಸಬಹುದು.

310
00:27:06,650 --> 00:27:15,640
ಬ್ರಾಕೆಟ್ ವಾಕ್ಯ PHP ಯ ಹೊಸ ಆವೃತ್ತಿಗೆ ಇದು PHP 5.4 ನ ಹೊಸ ಹೊಂದಿದೆ.

311
00:27:15,640 --> 00:27:36,960
> 1, 'ಬಿ' - -> 2 ಈ ಮೊದಲು ನೀವು ಯಾವಾಗಲೂ ('ಒಂದು' ರಚನೆಯ ಬರೆಯಬೇಕಾಯಿತು.

312
00:27:36,960 --> 00:27:41,160
ಒಂದು ಶ್ರೇಣಿಗೆ ನಿರ್ಮಾಣಕಾರ ಆಗಿತ್ತು.

313
00:27:41,160 --> 00:27:45,950
ಈಗ PHP ಅಂತಿಮವಾಗಿ, ಕೇವಲ ಚದರ ಬ್ರಾಕೆಟ್ಗಳನ್ನು ಆಫ್ ಸಂತೋಷವನ್ನು ವಾಕ್ಯ ಸುಮಾರು ಬಂದಿದೆ

314
00:27:45,950 --> 00:27:50,900
ಇದು ರಚನೆಯ ಕೇವಲ ಆದ್ದರಿಂದ ಹೆಚ್ಚು ಉತ್ತಮ.

315
00:27:50,900 --> 00:27:54,480
ಆದರೆ PHP 5.4 ಪರಿಗಣಿಸಿ, ಹೊಸ ಆವೃತ್ತಿ

316
00:27:54,480 --> 00:27:59,090
ನೀವು ಸಹ PHP 5.3 ಹೊಂದಿಲ್ಲ ಸ್ಥಳಗಳನ್ನು ಎದುರಿಸಬಹುದು.

317
00:27:59,090 --> 00:28:08,220
PHP 5.3 ನಾವು APPLIANCE ಮೇಲೆ ಏನು ಎಂದು ಅಲ್ಲಿ ಬೇಸಿಗೆಯ ನಾವು, ಈ ಸಮಸ್ಯೆಯನ್ನು ಧಾವಿಸಿದರು

318
00:28:08,220 --> 00:28:14,480
ಆದರೆ ನಾವು ನಮ್ಮ ದರ್ಜೆಯ ಪುಸ್ತಕ ನಿಯೋಜಿಸಲಾಯಿತು ಮತ್ತು ಸಲ್ಲಿಸಲು ಮತ್ತು ಎಲ್ಲಾ ವಿಷಯವನ್ನು ಆ ಸರ್ವರ್

319
00:28:14,480 --> 00:28:16,750
PHP 5.4 ಆಗಿತ್ತು.

320
00:28:16,750 --> 00:28:23,060
ಈ ಅರಿವಿರದ, ನಾವು 5.3 ಅಭಿವೃದ್ಧಿ, 5.4 ತಳ್ಳಲಾಯಿತು

321
00:28:23,060 --> 00:28:25,660
ಮತ್ತು ಈಗ ನಮ್ಮ ಕೋಡ್ ಒಂದು ಹಠಾತ್ ಯಾವುದೂ ಎಲ್ಲಾ ಕೆಲಸ

322
00:28:25,660 --> 00:28:28,680
5.3 ಮತ್ತು 5.4 ನಡುವೆ ಬದಲಾವಣೆಗಳು ಎಂದು ಅಲ್ಲಿ ಸಂಭವಿಸಿದ ಕಾರಣ

323
00:28:28,680 --> 00:28:31,030
ಹಿಮ್ಮುಖ ಹೊಂದಿಕೆಯಾಗದು ಇವು,

324
00:28:31,030 --> 00:28:35,770
ಮತ್ತು ನಾವು ಹೋಗಿ ಮತ್ತು PHP 5.4 ಕೆಲಸ ಎಂಬುದನ್ನು ನಮ್ಮ ವಸ್ತುಗಳ ಎಲ್ಲಾ ಸರಿಪಡಿಸಲು ಹೊಂದಿರುತ್ತವೆ.

325
00:28:39,210 --> 00:28:42,320
APPLIANCE ಕಾರಣ ಈ ವರ್ಗದ, PHP 5.4 ಹೊಂದಿರುತ್ತವೆ

326
00:28:42,320 --> 00:28:45,490
ಇದು ಚದರ ಬ್ರಾಕೆಟ್ಗಳನ್ನು ಬಳಸಲು ನಿಖರವಾಗಿ ದಂಡ ಇಲ್ಲಿದೆ.

327
00:28:47,240 --> 00:28:50,440
ಆದರೆ ನೀವು ಇಂಟರ್ನೆಟ್ ಸುಮಾರು ವಿಷಯಗಳನ್ನು ಅಪ್ ಹುಡುಕುತ್ತಿರುವ ವೇಳೆ,

328
00:28:50,440 --> 00:28:54,880
ನೀವು ವ್ಯೂಹ ಸ್ಟಫ್ ರೀತಿಯ ಹುಡುಕುತ್ತಿರುವ ವೇಳೆ, ಬಹುಶಃ ನೀವು ನೋಡಲು ನೀನು

329
00:28:54,880 --> 00:29:02,020
PHP ಸುಮಾರಿಗೆ ಎಂದು ರಿಂದ ಶ್ರೇಣಿಯನ್ನು ನಿರ್ಮಾಣಕಾರ ವಾಕ್ಯ ಔಟ್ ಕಾಗುಣಿತ ಜನಿಸಿದರು

330
00:29:02,020 --> 00:29:07,340
ಮತ್ತು ಚೌಕಾಕಾರದ ಬ್ರಾಕೆಟ್ ವಾಕ್ಯ ಕಳೆದ ಒಂದೆರಡು ತಿಂಗಳು ರಷ್ಟಿದೆ

331
00:29:07,340 --> 00:29:10,020
ಅಥವಾ ಪ್ರಕಟಿಸಿದಾಗ 5.4 ಸುತ್ತ ಬಂದರು.

332
00:29:10,020 --> 00:29:12,710
ಇದು ಹೇಗೆ ನೀವು ಸೂಚ್ಯಂಕ.

333
00:29:12,710 --> 00:29:30,610
ಕೇವಲ ಸಿ ಇಷ್ಟ ಹೇಗೆ ನೀವು $ ರಚನೆಯ [0], $ ರಚನೆಯ [1], $ ರಚನೆಯ [2], ಹಾಗೆ ಚದರ ಬ್ರಾಕೆಟ್ಗಳನ್ನು ಮೂಲಕ ಸೂಚ್ಯಂಕ ವುಡ್

334
00:29:30,610 --> 00:29:36,320
ನೀವು ಸೂಚಿಯನ್ನು ನಿಮ್ಮ ಸೂಚ್ಯಂಕಗಳು ತಂತಿಗಳನ್ನು ಹೊಂದಿರುವುದು ಸಂಭವಿಸಿದಾಗ ರೀತಿಯಲ್ಲಿ.

335
00:29:36,320 --> 00:29:40,440
ಆದ್ದರಿಂದ $ ರಚನೆಯ ['ಒಂದು'] ಮತ್ತು $ ರಚನೆಯ ['ಬಿ'].

336
00:29:40,440 --> 00:29:47,410
$ ರಚನೆಯ [ಬೌ]. ಏಕೆ ಈ ತಪ್ಪು ಎಂದು?

337
00:29:52,490 --> 00:29:59,870
ಇದು ಬಹುಶಃ ಒಂದು ಎಚ್ಚರಿಕೆಯನ್ನು ರಚಿಸಲು ಆದರೆ ಇನ್ನೂ ಕೆಲಸ ಮಾಡುತ್ತದೆ. PHP ಹಾಗೆ ಕಾಣುತ್ತದೆ.

338
00:29:59,870 --> 00:30:04,890
ಇದು ಕೇವಲ, "ನಾನು ಈ ಬಗ್ಗೆ ಎಚ್ಚರಿಸುವ ಪಡೆಯಲಿದ್ದೇನೆ ಒಲವು, ಆದರೆ ನಾನು ಮುಂದುವರಿಸುವುದಕ್ಕೆ ಪಡೆಯಲಿದ್ದೇನೆ

339
00:30:04,890 --> 00:30:07,550
"ನಾನು ಸಾಧ್ಯವಾದಷ್ಟು ಏನೇ ಮಾಡಲು."

340
00:30:07,550 --> 00:30:11,500
ಬಹುಶಃ, ಸ್ಟ್ರಿಂಗ್ ಈ ಭಾಷಾಂತರಿಸುತ್ತದೆ

341
00:30:11,500 --> 00:30:15,000
ಆದರೆ ಹಿಂದೆ ಯಾರೋ ಕೆಲವು ಹಂತದಲ್ಲಿ ಹೇಳಿದರು ಸಾಧ್ಯ

342
00:30:15,000 --> 00:30:20,180
'ಹಲೋ ವರ್ಲ್ಡ್' ಎಂದು ಬೌ ವ್ಯಾಖ್ಯಾನಿಸಲು.

343
00:30:20,180 --> 00:30:28,740
ಈಗ ಬೌ ಸ್ಥಿರ ಮತ್ತು $ ಅರೇ ಆಗಿರಬಹುದು [ಬೌ] ವಾಸ್ತವವಾಗಿ 'ಹಲೋ ವರ್ಲ್ಡ್' ಮಾಡುವಾಗ.

344
00:30:28,740 --> 00:30:32,380
ನಾನು, ಈ ಹಂತದಲ್ಲಿ ಭಾವಿಸುತ್ತೇನೆ, ಅಥವಾ ಕನಿಷ್ಠ ನಮ್ಮ PHP ಸೆಟ್ಟಿಂಗ್ಗಳು

345
00:30:32,380 --> 00:30:37,870
ನೀವು ರಚನೆಯ ಒಳಗೆ ಸೂಚ್ಯಂಕ ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಪ್ರಮುಖ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ ಅದನ್ನು ವಿಫಲಗೊಳ್ಳುತ್ತದೆ.

346
00:30:37,870 --> 00:30:40,150
ಇದು ಕೇವಲ ನೀವು ಎಚ್ಚರಿಕೆ ಕಾಣಿಸುತ್ತದೆ ಯೋಚಿಸುವುದಿಲ್ಲ.

347
00:30:40,150 --> 00:30:44,560
ಅಥವಾ ಕೇವಲ ನೀವು ಎಚ್ಚರಿಕೆ ಎಂದು ಆದ್ದರಿಂದ ಕನಿಷ್ಠ ನೀವು ಹೊಂದಿಸಬಹುದು, ಇದು ನೇರವಾಗಿ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ.

348
00:30:44,560 --> 00:30:49,290
>> ನೀವು ನಿಜವಾಗಿ ಅಂತಹ ಸೂಚ್ಯಂಕವಿಲ್ಲದಿದ್ದರೂ ನೀವು ಪರೀಕ್ಷಿಸಿ ರೀತಿಯಲ್ಲಿ isset ಹೊಂದಿದೆ.

349
00:30:49,290 --> 00:30:54,690
ಆದ್ದರಿಂದ isset ($ ರಚನೆಯ ['ಹಲೋ ವರ್ಲ್ಡ್']) ತಪ್ಪು ಹಿಂತಿರುಗುವುದು.

350
00:30:54,690 --> 00:30:59,160
isset ($ ರಚನೆಯ ['ಬಿ']) ನಿಜವಾದ ಹಿಂತಿರುಗುವುದು.

351
00:31:06,830 --> 00:31:09,880
ನೀವು ಈ syntaxes ಮಿಶ್ರಣ ಮಾಡಬಹುದು.

352
00:31:15,060 --> 00:31:22,440
ನಾವು ಅದನ್ನು ಪರಿಶೀಲಿಸಬಹುದು - ನಾನು ಏನು ಈ ವ್ಯೂಹ ಎಂದು ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಎಂಬುದನ್ನು ಇದು ಬಹಳ ನನಗೆ ಖಾತ್ರಿಯಿದೆ.

353
00:31:43,290 --> 00:31:45,700
ಒಹ್, ನಾನು PHPWord ಅಗತ್ಯವಿದೆ.

354
00:31:53,960 --> 00:32:00,260
ಈ ಕೀಲಿಯನ್ನು ನೀವು ಏನು ಸೂಚಿಸಲು ಅಲ್ಲಿ ವಾಕ್ಯ ಮಿಶ್ರಣ ಇದೆ

355
00:32:00,260 --> 00:32:03,330
ಮತ್ತು ನೀವು ಕೀಲಿ ಎಂಬುದನ್ನು ಸೂಚಿಸಲು ಇಲ್ಲ.

356
00:32:03,330 --> 00:32:05,520
ಇಲ್ಲಿ 3 ಬಲ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ.

357
00:32:05,520 --> 00:32:08,080
ನೀವು ಸ್ಪಷ್ಟವಾಗಿ ಅದರ ಪ್ರಮುಖ ಎಂದು ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂದು ಹೇಳಿರುವುದು.

358
00:32:08,080 --> 00:32:11,670
ನೀವು ಅದರ ಪ್ರಮುಖ ಎಂದು ಹೋಗುತ್ತದೆ ಏನು ಆಲೋಚಿಸುತ್ತೀರಿ ಏನು?

359
00:32:11,670 --> 00:32:21,410
[ವಿದ್ಯಾರ್ಥಿ] 0. >> ನಾನು ನಾವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿರದಿದ್ದರೆ ಮೊದಲ ಒಂದು ಏಕೈಕ ಕಾರಣ 0 ಊಹೆ ನುಡಿದರು.

360
00:32:21,410 --> 00:32:23,500
ನಾವು ವಾಸ್ತವವಾಗಿ ಈ ಸಂದರ್ಭಗಳಲ್ಲಿ ಒಂದೆರಡು ಮಾಡಬಹುದು.

361
00:32:23,500 --> 00:32:28,030
ಆದ್ದರಿಂದ print_r ಪುನರಾವರ್ತಿತ ಮುದ್ರಿಸಲು ಹೊಂದಿದೆ. ಇದು ಸಂಪೂರ್ಣ ರಚನೆಯ ಮುದ್ರಿಸಲು ಕಾಣಿಸುತ್ತದೆ.

362
00:32:28,030 --> 00:32:32,700
ಯಾವುದೇ ಇದ್ದವು ಅದು ರಚನೆಯ subarrays ಮುದ್ರಿಸಲು ಎಂದು.

363
00:32:32,700 --> 00:32:36,630
ಆದ್ದರಿಂದ print_r ($ ಅರ್ರೆಯ್); php.test.php.

364
00:32:36,630 --> 00:32:38,810
ಅದು 0 ನೀಡಿದರು ಎಂದು ನೋಡಲು ಹೇಗಿದೆ.

365
00:32:38,810 --> 00:32:43,530
ಇಲ್ಲಿ ನೆನಪಿನಲ್ಲಿಡಿ ಏನಾದರೂ ವಾಸ್ತವವಾಗಿ, ಆದರೆ ಎರಡನೇ ಅದನ್ನು ಮತ್ತೆ ಪಡೆಯುತ್ತೀರಿ.

366
00:32:43,530 --> 00:32:45,850
ಆದರೆ ಏನು ಈ ಸೂಚ್ಯಂಕ 1 ಮಾಡಲು ಸಂಭವಿಸಿದಾಗ?

367
00:32:45,850 --> 00:32:51,170
PHP, ಸ್ಟ್ರಿಂಗ್ ಸೂಚ್ಯಂಕಗಳು ಮತ್ತು ಪೂರ್ಣಾಂಕ ಸೂಚ್ಯಂಕಗಳು ಬೇರ್ಪಡಿಸಲು ಇಲ್ಲ

368
00:32:51,170 --> 00:33:00,280
ಆದ್ದರಿಂದ ಈ ಹಂತದಲ್ಲಿ ನಾನು ಸೂಚ್ಯಂಕ 1 ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ನೀವು ಮತ್ತು ನಾನು ಎರಡೂ $ ರಚನೆಯ [1] ಮತ್ತು $ ರಚನೆಯ ['1 '] ಮಾಡಬಹುದು

369
00:33:00,280 --> 00:33:06,250
ಮತ್ತು ಅದೇ ಸೂಚ್ಯಂಕ ಮತ್ತು ಅದೇ ಪ್ರಮುಖ ಎಂದು ಕಾಣಿಸುತ್ತದೆ.

370
00:33:06,250 --> 00:33:13,000
ಈಗ ನೀವು 3 ಏರಲಿದೆ ಏನು ಆಲೋಚಿಸುತ್ತೀರಿ ಏನು? >> [ವಿದ್ಯಾರ್ಥಿ] 2. >> [ಬೌಡೆನ್] ನಾನು 2 ಊಹೆ ನುಡಿದರು.

371
00:33:16,000 --> 00:33:18,690
ಹೌದು. ಇದು 2 ನ.

372
00:33:18,690 --> 00:33:24,790
ಈ 10 ಮಾಡಿದರೆ, ಈ 4 ಎಂದರೇನು? ನೀವು 3 ಸೂಚಕ ಏರಲಿದೆ ಏನು ಆಲೋಚಿಸುತ್ತೀರಿ ಏನು?

373
00:33:27,360 --> 00:33:29,110
ನಾನು 11 ನಾನು ಯೋಚಿಸುತ್ತೇನೆ.

374
00:33:29,110 --> 00:33:33,060
PHP ಏನು ಎಂದು ನನ್ನ ಊಹೆ - ಮತ್ತು ನಾನು ಮೊದಲು ಈ ನೋಡಿದ್ದೇವೆ ಭಾವಿಸುತ್ತೇನೆ -

375
00:33:33,060 --> 00:33:39,760
ಇದು ಅದನ್ನು ಇಲ್ಲಿಯವರೆಗೆ ಬಳಸಲಾಗುತ್ತದೆ ಅತ್ಯುನ್ನತ ಸಂಖ್ಯಾ ಸೂಚ್ಯಂಕ ಯಾವುದು ಟ್ರ್ಯಾಕ್ನಲ್ಲಿರಿಸಿಕೊಳ್ಳುತ್ತಾರೆ ಇದೆ.

376
00:33:39,760 --> 00:33:44,230
ಇದು 3 ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಸೂಚ್ಯಂಕ ನಿಯೋಜಿಸಲು ಹೋಗುವ ಎಂದಿಗೂ. ಇದು ಯಾವಾಗಲೂ ಸಂಖ್ಯಾ ಸೂಚ್ಯಂಕ ಎಂದು ಕಾಣಿಸುತ್ತದೆ.

377
00:33:44,230 --> 00:33:47,690
ಆದ್ದರಿಂದ, 10 ಎಂದು ಸಂಭವಿಸುತ್ತದೆ ಇದು ಇಲ್ಲಿಯವರೆಗೆ ಅದಕ್ಕೆ ಅತ್ಯುನ್ನತ ಒಂದು, ಟ್ರ್ಯಾಕ್ನಲ್ಲಿರಿಸಿಕೊಳ್ಳುತ್ತಾರೆ

378
00:33:47,690 --> 00:33:52,540
ಮತ್ತು 3 ರಿಂದ 11 ನೀಡಲು ವಿಶೇಷವೇನು.

379
00:33:52,540 --> 00:34:02,110
ನಾನು ಮೊದಲು ವಿವರಿಸಿದ್ದಾನೆ, ಈ ರಚನೆಯ ಮುದ್ರಿಸುವ ರೀತಿಯನ್ನು ಗಮನಿಸಿ.

380
00:34:02,110 --> 00:34:06,850
ಇದು, ಪ್ರಮುಖ 4, ಪ್ರಮುಖ 11, ಕೀಲಿ d ಕೀಲಿಯನ್ನು 10 ಮುದ್ರಿಸುತ್ತದೆ.

381
00:34:06,850 --> 00:34:09,790
ಅಥವಾ ಹಾಗೆ ನಾವು -

382
00:34:15,760 --> 00:34:22,489
ನಾನು ಒಂದು 0 ಪುಟ್ ಇಲ್ಲ ಊಹೆ, ಆದರೆ ಮುದ್ರಣ 1, 2, 3, 4 ನ.

383
00:34:22,489 --> 00:34:29,330
ನಾನು ಇಲ್ಲಿ ಬದಲಾಯಿಸಲು ವೇಳೆ? ಅಥವಾ ಅವರ ವಾಸ್ತವವಾಗಿ ಈ 2 ಬದಲಾಯಿಸಲು ಅವಕಾಶ.

384
00:34:29,330 --> 00:34:31,940
ಈಗ 2, 1, 3, 4 ಮುದ್ರಿಸುತ್ತದೆ.

385
00:34:31,940 --> 00:34:41,270
PHP ಯ ಸಾಲುಗಳು ನಿಮ್ಮ ನಿಯಮಿತ ಹ್ಯಾಶ್ ಟೇಬಲ್ ಹಾಗೆ ಅಲ್ಲ.

386
00:34:41,270 --> 00:34:45,570
ಇದು ಹ್ಯಾಶ್ ಕೋಷ್ಟಕಗಳು ಸಮಯದ 99% ಅವರನ್ನು ಆಲೋಚಿಸಬೇಕು ನಿಖರವಾಗಿ ಸಮಂಜಸವಾದ ಇಲ್ಲಿದೆ.

387
00:34:45,570 --> 00:34:53,790
ಆದರೆ ನಿಮ್ಮ ಹ್ಯಾಶ್ ಕೋಷ್ಟಕಗಳು ವಸ್ತುಗಳನ್ನು ಸೇರಿಸಲಾಗಿದೆ ಯಾವ ಕ್ರಮದಲ್ಲಿ ಯಾವುದೇ ಅರ್ಥದಲ್ಲಿ ಇಲ್ಲ.

388
00:34:53,790 --> 00:34:56,639
ಆದ್ದರಿಂದ ನೀವು ನಿಮ್ಮ ಹ್ಯಾಶ್ ಟೇಬಲ್ಲಿಗೆ ಇದು ಸೇರಿಸಲು ಬೇಗ

389
00:34:56,639 --> 00:35:00,590
ಯಾವುದೇ ಲಿಂಕ್ ಪಟ್ಟಿ ಮತ್ತು ನೀವು ಲಿಂಕ್ ಪಟ್ಟಿ ಒಳಗೆ ಹಾಕಬೇಡ ಎಂದು ಊಹಿಸುತ್ತವೆ

390
00:35:00,590 --> 00:35:03,980
ಮೊದಲ ಸೇರಿಸಲಾಗುತ್ತಿತ್ತು.

391
00:35:03,980 --> 00:35:10,060
ಆದರೆ ಇಲ್ಲಿ ನಾವು ಮೊದಲ 2 ಸೇರಿಸಲಾಗಿದೆ ಮತ್ತು 2 ಮೊದಲ ಬರುತ್ತದೆ ಈ ರಚನೆಯ ಔಟ್ ಮುದ್ರಿಸುವ ಸಂದರ್ಭದಲ್ಲಿ ಇದು ಗೊತ್ತಿತ್ತು.

392
00:35:10,060 --> 00:35:13,090
ಅದು ಯಾವುದೇ ಕ್ರಮದಲ್ಲಿ ಇದು ಮುದ್ರಿಸುತ್ತದೆ ಮಾಡುವುದಿಲ್ಲ.

393
00:35:13,090 --> 00:35:17,550
ಅದನ್ನು ಬಳಸಿಕೊಂಡು ಎಂದು ತಾಂತ್ರಿಕ ಅಕ್ಷಾಂಶ ರಚನೆ ವ್ಯವಸ್ಥಿತ ನಕ್ಷೆ, ಆಗಿದೆ

394
00:35:17,550 --> 00:35:24,690
ಆದ್ದರಿಂದ ಮೌಲ್ಯಗಳನ್ನು ಕೀಗಳು ನಕಾಶೆಯನ್ನು ಆ ಕೀಲಿಗಳನ್ನು ಸೇರಿಸಲಾಗಿದೆ ಯಾವ ಕ್ರಮದಲ್ಲಿ ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ.

395
00:35:24,690 --> 00:35:31,600
ಮೂಲತಃ ಇದು ವಾಸ್ತವವಾಗಿ ಗೆ ಕಿರಿಕಿರಿ ಉಂಟು ಮಾಡಿದೆ ಅಲ್ಲಿ ಕೆಲವು ತೊಂದರೆಗಳಿಗೆ ಇಲ್ಲಿದೆ -

396
00:35:31,600 --> 00:35:34,510
ಲೆಟ್ಸ್ ನೀವು ಅರೇ 0, 1, 2, 3, 4, 5 ಹೊಂದಿವೆ ಹೇಳುತ್ತಾರೆ

397
00:35:34,510 --> 00:35:37,700
ಮತ್ತು ನೀವು ಸೂಚ್ಯಂಕ 2 ಔಟ್ ತೆಗೆದುಕೊಳ್ಳಲು ಬಯಸುವ.

398
00:35:37,700 --> 00:35:47,750
ಅದನ್ನು ಮಾಡುವ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ, ಎಂದು ತೋರುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ.

399
00:35:47,750 --> 00:35:50,410
0, 2, 1, 3, 4.

400
00:35:50,410 --> 00:35:54,880
ಹೊಂದಿಸಿಲ್ಲದ ಅಸ್ಥಿರಗಳು ಮತ್ತು ರಚನೆಯ ಸೂಚಿಗಳ ಹೊಂದಿಸದೆ ಸಂಭವಿಸಿದರೆ.

401
00:35:54,880 --> 00:35:58,630
ಆದ್ದರಿಂದ ಹೊಂದಿಸಿಲ್ಲದ ($ ರಚನೆಯ [2]);

402
00:35:58,630 --> 00:36:03,430
ಈಗ ಈ ರೀತಿ ವಿಶೇಷವೇನು? 2 ಕೇವಲ ಆಗಿಹೋಗಿದೆ, ಆದ್ದರಿಂದ ನಿಖರವಾಗಿ ದಂಡ ಇಲ್ಲಿದೆ.

403
00:36:03,430 --> 00:36:11,670
ನೀವು ವಿಷಯಗಳನ್ನು ವಾಸ್ತವವಾಗಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹಾಗೆ ಆಗಬೇಕು ವೇಳೆ ಹೆಚ್ಚು ಕಿರಿಕಿರಿ ಆಗಿದೆ.

404
00:36:11,670 --> 00:36:14,910
ನಾನು ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳನ್ನು ಹಾಕುತ್ತೇವೆ.

405
00:36:14,910 --> 00:36:20,400
ಈಗ ನನ್ನ ಸೂಚ್ಯಂಕಗಳು ಗಮನಿಸುವುದಿಲ್ಲ.

406
00:36:20,400 --> 00:36:26,860
1 - ಅದು 0 ರಿಂದ ಉದ್ದ ಹೋಗುತ್ತದೆ ಅಲ್ಲಿ ಅದು ಕೇವಲ ಸಿ ರಚನೆಯ ಹಾಗೆ ಆಗಬೇಕು

407
00:36:26,860 --> 00:36:30,810
ಮತ್ತು ನಾನು ಎಂದು ಅದನ್ನು ಮರಳಿ ಮಾಡಬಹುದು.

408
00:36:30,810 --> 00:36:38,520
ಆದರೆ ತಕ್ಷಣ ನಾನು ಸೂಚ್ಯಂಕ 3 ರಲ್ಲಿ ಇದ್ದ ಎರಡನೇ ಸೂಚ್ಯಂಕ, ಹೊಂದಿಸದೆ ಈಗ ಸೂಚ್ಯಂಕ 2 ನಾಗುವುದಿಲ್ಲ.

409
00:36:38,520 --> 00:36:44,790
ಬದಲಿಗೆ ಅದು ಕೇವಲ ಸೂಚ್ಯಂಕ ತೆಗೆದುಹಾಕುತ್ತದೆ ಮತ್ತು ಈಗ ನೀವು 0, 1, 3, 4 ಹೋಗಿ.

410
00:36:44,790 --> 00:36:48,740
ಈ ನಿಖರವಾಗಿ ಸಮಂಜಸವಾಗಿದೆ.

411
00:36:48,740 --> 00:36:53,950
ಇದು ಕೇವಲ ಕಿರಿಕಿರಿ ಮತ್ತು ನೀವು ವ್ಯೂಹ ಸ್ಪ್ಲೈಸ್ ವಿಷಯಗಳನ್ನು ಮಾಡಬೇಕು. ಹೌದು.

412
00:36:53,950 --> 00:36:57,200
>> [ವಿದ್ಯಾರ್ಥಿ] ನೀವು ಲೂಪ್ ಒಂದು ಹೊಂದಿತ್ತು ಏನಾಗಬಹುದು

413
00:36:57,200 --> 00:36:59,630
ಮತ್ತು ನೀವು ಎಲ್ಲಾ ಅಂಶಗಳ ಮೇಲೆ ಹೋಗಲು ಬೇಕಾಗಿದ್ದಾರೆ?

414
00:36:59,630 --> 00:37:02,290
ಇದು 2 ಹೊಡೆದಾಗ, ಇದು ನೀಡುತ್ತದೆ ಎಂದು?

415
00:37:02,290 --> 00:37:10,150
ಒಂದು ರಚನೆಯ ಮೇಲೆ Iterating. ನೀವು ಮಾಡಬಹುದು 2 ಮಾರ್ಗಗಳಿವೆ.

416
00:37:10,150 --> 00:37:12,770
ನೀವು ಲೂಪ್ ಒಂದು ಸಾಮಾನ್ಯ ಬಳಸಬಹುದು.

417
00:37:12,770 --> 00:37:22,000
ಈ PHP ಮತ್ತೊಂದು ಸಂಕೀರ್ಣತೆ ಹೊಂದಿದೆ.

418
00:37:22,000 --> 00:37:27,420
ಹೆಚ್ಚು ಭಾಷೆ, ನಾನು ಹೇಳಬಹುದು, ಉದ್ದ ಅಥವಾ ಲೆನ್ ಅಥವಾ ಏನಾದರೂ ಕೆಲವು ರೀತಿಯ ಹೊಂದಿವೆ

419
00:37:27,420 --> 00:37:30,470
ವ್ಯೂಹದ ಅವಧಿಯನ್ನು ಸೂಚಿಸುತ್ತದೆ.

420
00:37:30,470 --> 00:37:32,820
PHP ಅದನ್ನು ಲೆಕ್ಕ.

421
00:37:32,820 --> 00:37:36,160
ಆದ್ದರಿಂದ ಎಣಿಕೆ ($ ಅರ್ರೆಯ್); $ ನಾನು + +)

422
00:37:36,160 --> 00:37:42,950
ಲೆಟ್ಸ್ ಕೇವಲ ಮುದ್ರಣ ($ ರಚನೆಯ [$ i]);

423
00:37:45,920 --> 00:37:48,820
ಎಚ್ಚರಿಕೆ: ವಿವರಿಸಲಾಗದಿರ ಆಫ್ಸೆಟ್: 2.

424
00:37:48,820 --> 00:37:51,610
ಇದು ಕೇವಲ ವಿಫಲವಾದ ವಿಶೇಷವೇನು.

425
00:37:51,610 --> 00:38:03,020
ಈ ಬಹುತೇಕ ಭಾಗ, ಈ ರೀತಿಯ ಒಂದು ರಚನೆಯ ಮೇಲೆ ತಿರುಗಿ ಅವಶ್ಯಕತೆ ಇಲ್ಲ, ಕಾರಣ.

426
00:38:03,020 --> 00:38:07,110
ಇದು ಉತ್ಪ್ರೇಕ್ಷೆ ಇರಬಹುದು, ಆದರೆ ಈ ರೀತಿಯ ಒಂದು ರಚನೆಯ ಮೇಲೆ ತಿರುಗಿ ಅವಶ್ಯಕತೆಯಿಲ್ಲ

427
00:38:07,110 --> 00:38:19,410
PHP ಅಲ್ಲಿ foreach ($ ರಚನೆಯ ಮಾಹಿತಿ $ ಐಟಂ) ಅದರ foreach ವಾಕ್ಯ ಒದಗಿಸುತ್ತದೆ ಏಕೆಂದರೆ.

428
00:38:19,410 --> 00:38:31,830
ಈಗ ನಾವು ($ ಐಟಂ) ಮುದ್ರಿಸಲು ವೇಳೆ; - we'll ಎರಡನೇ ಅದನ್ನು ಚರ್ಚಿಸಲು - ಸಂಪೂರ್ಣವಾಗಿ ಉತ್ತಮ ಕೆಲಸ.

429
00:38:31,830 --> 00:38:38,960
foreach ಕೆಲಸ ರೀತಿಯಲ್ಲಿ ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್ ಮೇಲೆ iterating ನೀವು ರಚನೆ ಹೊಂದಿದೆ.

430
00:38:38,960 --> 00:38:44,060
ಮತ್ತು ಲೂಪ್ ಗಾಗಿ ಪ್ರತಿಯೊಂದು ಪಾಸ್ ಮೂಲಕ ಎರಡನೇ ಆರ್ಗ್ಯುಮೆಂಟ್, ಐಟಂ,

431
00:38:44,060 --> 00:38:52,690
ಇದು ಶ್ರೇಣಿಯಲ್ಲಿನ ಮುಂದೆ ಮೇಲೆ ತೆಗೆದುಕೊಳ್ಳುವುದು. ಆದ್ದರಿಂದ ರಚನೆಯ ಆದೇಶ ಹೊಂದಿದೆ ನೆನಪಿಡಿ.

432
00:38:52,690 --> 00:38:55,690
ಲೂಪ್ ಫಾರ್ ಮೂಲಕ ಮೊದಲ ಬಾರಿಗೆ, ಐಟಂ 123 ಏರಲಿದೆ

433
00:38:55,690 --> 00:38:59,540
ನಂತರ ಅದು 12 ಎಂದು ನಂತರ 13 ಎಂದು ನಂತರ 23 ಎಂದು ಅದು 213 ಆಗಿರುತ್ತದೆ.

434
00:38:59,540 --> 00:39:04,670
ನೀವು foreach ಸ್ವಲ್ಪ ಮಾಡಿದಾಗ ಥಿಂಗ್ಸ್ ನಿಜವಾಗಿಯೂ ವಿಲಕ್ಷಣ ಪಡೆಯಿರಿ.

435
00:39:04,670 --> 00:39:07,480
ನೀವು ಹಾಗೆ ಮಾಡಬಾರದು ಏಕೆಂದರೆ ಏನಾಗುತ್ತದೆ ನೋಡೋಣ.

436
00:39:07,480 --> 00:39:13,320
ಹೀಗಾದರೆ ನಾವು ಹೊಂದಿಸಿಲ್ಲದ ($ ರಚನೆಯ [1]);

437
00:39:20,410 --> 00:39:26,030
ಎಂದು ಬಹುಶಃ ನಿರೀಕ್ಷಿಸಲಾಗಿತ್ತು.

438
00:39:26,030 --> 00:39:30,950
ಈ ರಚನೆಯ ಮೇಲೆ iterating ನೀವು, ಮತ್ತು ಪ್ರತಿ ಬಾರಿ ನೀವು ಮೊದಲ ಸೂಚ್ಯಂಕ unsetting ಮಾಡುತ್ತಿದ್ದೇವೆ.

439
00:39:30,950 --> 00:39:39,720
ಆದ್ದರಿಂದ ಸೂಚ್ಯಂಕ 0 ಗೆ, ಮೊದಲ ವಿಷಯ, ಐಟಂ ಮೌಲ್ಯವನ್ನು 0 ಮೇಲೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಆದ್ದರಿಂದ 123 ಎಂದು ವಿಶೇಷವೇನು.

440
00:39:39,720 --> 00:39:44,630
ಆದರೆ ಒಳಗೆ ಕುಣಿಕೆಯ ನಾವು ಹೊಂದಿಸಿಲ್ಲದ ಸೂಚ್ಯಂಕ 1, ಆದ್ದರಿಂದ 12 ಹೋದ ಅರ್ಥ.

441
00:39:44,630 --> 00:39:57,480
ಆದ್ದರಿಂದ ಮುದ್ರಿಸಿ. PHP_EOL.

442
00:39:57,480 --> 00:40:03,580
PHP_EOL ಕೇವಲ ಹೊಸಸಾಲು ಹೊಂದಿದೆ, ಆದರೆ ಇದು ತಾಂತ್ರಿಕವಾಗಿ ಹೆಚ್ಚು ಪೋರ್ಟಬಲ್ ಇಲ್ಲಿದೆ

443
00:40:03,580 --> 00:40:08,890
ವಿಂಡೋಸ್ ನಲ್ಲಿ ಹೊಸ ಸಾಲುಗಳನ್ನು ಮ್ಯಾಕ್ ಮತ್ತು ಯುನಿಕ್ಸ್ ಮೇಲೆ ಹೊಸ ಸಾಲುಗಳನ್ನು ಭಿನ್ನವಾಗಿದೆ ರಿಂದ.

444
00:40:08,890 --> 00:40:18,040
ವಿಂಡೋಸ್ ರಂದು ಹೊಸಸಾಲು \ r \ n, ಉಳಿದೆಲ್ಲ ಕಡೆ ಆದರೆ ಕೇವಲ \ N ತಳಿಗಿಂತ ಇದೆ.

445
00:40:18,040 --> 00:40:25,150
ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಯ ಹೊಸಸಾಲು ಯಾವುದೇ ಬಳಸುತ್ತದೆ ಆದ್ದರಿಂದ PHP_EOL ಕಾನ್ಫಿಗರ್.

446
00:40:25,150 --> 00:40:29,310
ಆದ್ದರಿಂದ ಮುದ್ರಿಸಿ. ಕೊನೆಯಲ್ಲಿ ($ ಅರ್ರೆಯ್) print_r ನಿಲ್ಲಿಸೋಣ.

447
00:40:32,830 --> 00:40:37,390
ನಾನು ನಡವಳಿಕೆ ಎಂದು ಕಲ್ಪನೆ ಇರಲಿಲ್ಲ.

448
00:40:41,740 --> 00:40:48,960
ನಾವು ಶ್ರೇಣಿಯನ್ನು ಇದು ಮುನ್ನವೇ ನಾವು 12 ಹೊಂದಿಸದೆ ಕೂಡ ಐಟಂ ಇನ್ನೂ ಮೌಲ್ಯ 12 ರಂದು ನಡೆಯುತ್ತದೆ.

449
00:40:52,770 --> 00:40:58,840
ಈ ನನ್ನ ಪದ ತೆಗೆದುಕೊಳ್ಳಬಹುದು, ಆದರೆ foreach ರಚನೆಯ ಪ್ರತಿಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ ತೋರುತ್ತಿದೆ ಮಾಡಬೇಡಿ

450
00:40:58,840 --> 00:41:02,160
ತದನಂತರ ಐಟಂ ಎಂದು ಪ್ರತಿಯನ್ನು ಎಲ್ಲಾ ಮೌಲ್ಯಗಳ ಮೇಲೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

451
00:41:02,160 --> 00:41:07,760
ನೀವು ಲೂಪ್ ಫಾರ್ ಒಳಗೆ ರಚನೆಯ ಮಾರ್ಪಡಿಸಿ ಹಾಗಾಗಿ

452
00:41:07,760 --> 00:41:17,240
ಅದು ಕೇರ್ ಮಾಡುವುದಿಲ್ಲ. ಐಟಂ ಮೂಲ ಮೌಲ್ಯಗಳನ್ನು ಮೇಲೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

453
00:41:17,240 --> 00:41:19,240
ಇದನ್ನು unsetting ಪ್ರಯತ್ನಿಸೋಣ.

454
00:41:19,240 --> 00:41:24,460
ಏನು ಈ $ ರಚನೆಯ [1] ವೇಳೆ = "ಹಲೋ";

455
00:41:24,460 --> 00:41:31,770
ನಾವು ರಚನೆಯ ಒಳಗೆ "ಹಲೋ" ಪುಟ್ ಸಹ ಐಟಂ ಆ ಮೌಲ್ಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಇಲ್ಲ.

456
00:41:31,770 --> 00:41:37,430
ಕುಣಿಕೆಗಳು foreach ಮತ್ತೊಂದು ವಾಕ್ಯ ಇಲ್ಲ

457
00:41:37,430 --> 00:41:45,900
ಅಲ್ಲಿ ನೀವು ಬಾಣ ಪ್ರತ್ಯೇಕಿಸಲ್ಪಟ್ಟ 2 ಅಸ್ಥಿರ ಪುಟ್.

458
00:41:45,900 --> 00:41:49,680
ಈ ಮೊದಲ ವೇರಿಯಬಲ್, ಆ ಮೌಲ್ಯವನ್ನು ಪ್ರಮುಖ ಏರಲಿದೆ

459
00:41:49,680 --> 00:41:53,050
ಈ ಎರಡನೇ ವೇರಿಯಬಲ್ ಅದೇ ನಿಖರ ಐಟಂ ಎಂದು ಹೋಗುತ್ತದೆ.

460
00:41:53,050 --> 00:42:01,610
,> 1 - ಈ ಇಲ್ಲಿ ಆಸಕ್ತಿರಹಿತ, ಆದರೆ 'ಒಂದು' ನಮ್ಮ ಮೂಲ ಸಂದರ್ಭದಲ್ಲಿ ಹಿಂದಿರುಗಿ ವೇಳೆ ಇದೆ

461
00:42:01,610 --> 00:42:06,090
'ಬಿ' -> 1,

462
00:42:06,090 --> 00:42:14,470
ನಾವು ಐಟಂ ಪ್ರತಿ ಶ್ರೇಣಿಗೆ ಮರಳಿ ವೇಳೆ ಇಲ್ಲಿ, ಐಟಂ ಪ್ರತಿಯೊಂದು ಸಮಯ 1 ಏರಲಿದೆ.

463
00:42:14,470 --> 00:42:18,170
ಆದರೆ ನಾವು ಆ ಐಟಂ ಸಂಬಂಧಿಸಿದ ಪ್ರಮುಖ ತಿಳಿಯಲು ಬಯಸಿದಲ್ಲಿ

464
00:42:18,170 --> 00:42:25,230
> $ ಐಟಂ - ಆಗ ನಾವು $ ಪ್ರಮುಖ ಮಾಡಬೇಕು.

465
00:42:25,230 --> 00:42:31,980
. ':' ಈಗ ನಾವು ಮುದ್ರಣ ($ ಕೀಲಿ ಮಾಡಬಹುದು.

466
00:42:31,980 --> 00:42:39,380
ಈಗ ಅದನ್ನು iterating ಮತ್ತು ಪ್ರತಿ ಪ್ರಮುಖ ಮತ್ತು ಅದರ ಸಂಬಂಧ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಣ ಮಾಡಿದ.

467
00:42:39,380 --> 00:42:47,030
>> ನಾವು foreach ಆವರ್ತನೆಗಳಲ್ಲಿ ಮಾಡಬಹುದು ಹೆಚ್ಚುವರಿ ವಿಷಯ ಈ ವಾಕ್ಯ ವೀಕ್ಷಿಸಬಹುದು.

468
00:42:47,030 --> 00:42:54,770
ವೇರಿಯಬಲ್ ಹೆಸರುಗಳು ಮೊದಲು Ampersands PHP ಉಲ್ಲೇಖಗಳನ್ನು ಹೇಗೆ ಒಲವು.

469
00:42:54,770 --> 00:43:00,460
ಉಲ್ಲೇಖಗಳು ಪಾಯಿಂಟರ್ಸ್ ಇವೆ, ಅಲ್ಲಿ

470
00:43:00,460 --> 00:43:04,820
ನೀವು ಪಾಯಿಂಟರ್ಸ್ ಹೊಂದಿಲ್ಲ, ಆದ್ದರಿಂದ ನೀವು ನೇರವಾಗಿ ಮೆಮೊರಿ ವ್ಯವಹರಿಸಲು ಇಲ್ಲ.

471
00:43:04,820 --> 00:43:12,620
ಆದರೆ ನೀವು 1 ವೇರಿಯಬಲ್ ಮತ್ತೊಂದು ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ಅದೇ ವಿಷಯ ಸೂಚಿಸುತ್ತದೆ ಉಲ್ಲೇಖಗಳು ಹೊಂದಿಲ್ಲ.

472
00:43:12,620 --> 00:43:21,450
ಇಲ್ಲಿ ಒಳಗೆ ಐಟಂ $ ಏನು ನೋಡೋಣ. ನ 1, 10 ಹಿಂದಿರುಗಿ ನೋಡೋಣ.

473
00:43:21,450 --> 00:43:28,800
ಐಟಂ $ ಮಾಡೋಣ ನ + +; ಅದು ಇನ್ನೂ PHP ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ. ನೀವು ಇನ್ನೂ + + ಮಾಡಬಹುದು.

474
00:43:28,800 --> 00:43:38,260
php.test.php. ನಾನು ಅದನ್ನು ಮುದ್ರಿಸಲು ಹೊಂದಿರುತ್ತವೆ. print_r ($ ಅರ್ರೆಯ್);

475
00:43:38,260 --> 00:43:42,730
ನಾವು 2, 11 ಮುದ್ರಿಸಿ.

476
00:43:42,730 --> 00:43:49,560
(ಐಟಂ $ ಮಾಹಿತಿ $ ಅರ್ರೆಯ್) ನಾನು foreach ಮಾಡಿದ ವೇಳೆ ನಂತರ ಐಟಂ ಮೌಲ್ಯ 1 ಆಗಿರುತ್ತದೆ

477
00:43:49,560 --> 00:43:54,190
ಲೂಪ್ ಮೂಲಕ ಮೊದಲ ಬಾರಿಗೆ. ಇದು 2 1 ಹೆಚ್ಚಿಸಲು ಮತ್ತು ನಂತರ ನಾವು ಮುಗಿಸಿದ್ದೀರಿ.

478
00:43:54,190 --> 00:43:57,260
ಆದ್ದರಿಂದ ಅದು ಲೂಪ್ ಎರಡನೇ ಪಾಸ್ ಮೂಲಕ ಹೋಗುತ್ತದೆ ಮತ್ತು ಐಟಂ 10 ಆಗಿದೆ.

479
00:43:57,260 --> 00:44:01,570
ಇದು ಬೆಳವಣಿಗೆಗಳ 11 ಐಟಂ, ಮತ್ತು ನಂತರ ಕೇವಲ ಬಿಸಾಡಲಾಗಿದೆಯೆಂದು ಎಂದು.

480
00:44:01,570 --> 00:44:06,670
ನಂತರ ನಾವು print_r ($ ಅರ್ರೆಯ್) ಮತ್ತು ಈಗ ಈ, 10 ಕೇವಲ 1 ಎಂದು ನೋಡಿ.

481
00:44:06,670 --> 00:44:09,070
ಆದ್ದರಿಂದ ನಾವು ಮಾಡಿದ ಇನ್ಕ್ರಿಮೆಂಟ್ ಕಳೆದುಹೋಯಿತು.

482
00:44:09,070 --> 00:44:13,410
ಆದರೆ foreach ($ ರಚನೆಯ ಮಾಹಿತಿ & $ ಐಟಂ)

483
00:44:13,410 --> 00:44:21,910
ಈಗ ಈ ಐಟಂ ಇಲ್ಲಿ ಈ ಹಕ್ಕನ್ನು ಅದೇ ಐಟಂ. ಅದೇ ವಿಷಯ.

484
00:44:21,910 --> 00:44:26,820
ಆದ್ದರಿಂದ $ ಐಟಂ + + ಅರೇ 0 ಮಾರ್ಪಡಿಸುವ ಇದೆ.

485
00:44:29,330 --> 00:44:41,850
ಮೂಲಭೂತವಾಗಿ, ನೀವು $ K ಮಾಡಬಹುದು -> $ ಐಟಂ ಮತ್ತು ನೀವು $ ಮಾಡಬಹುದು ರಚನೆಯ [$ K] + +;

486
00:44:41,850 --> 00:44:48,650
>> ಅದನ್ನು ಮಾಡುವ ಇನ್ನೊಂದು ರೀತಿಯಲ್ಲಿ, ಆದ್ದರಿಂದ ನಾವು, ಐಟಂ ಮಾರ್ಪಡಿಸಲು ಉಚಿತ

487
00:44:48,650 --> 00:44:54,070
ಆದರೆ ನಮ್ಮ ಮೂಲ ರಚನೆಯ ಮಾರ್ಪಡಿಸಲಾಗುವುದಿಲ್ಲ.

488
00:44:54,070 --> 00:44:59,720
ನಮ್ಮ ಪ್ರಮುಖ ಇದರಲ್ಲಿ k, ಬಳಸಲು ಆದರೆ, ನಂತರ ನಮ್ಮ ರಚನೆಯ ಒಳಗೆ ಕೇವಲ ಸೂಚ್ಯಂಕ ಪ್ರಮುಖ ಬಳಸಿಕೊಂಡು ನಾವು ಮಾಡಬಹುದು

489
00:44:59,720 --> 00:45:01,530
ಮತ್ತು ಹೆಚ್ಚಿಸಲು.

490
00:45:01,530 --> 00:45:05,410
ಈ ಹೆಚ್ಚು ನೇರವಾಗಿ ನಮ್ಮ ಮೂಲ ರಚನೆಯ ಮಾರ್ಪಡಿಸುತ್ತದೆ.

491
00:45:05,410 --> 00:45:10,690
ಕೆಲವು ಕಾರಣಕ್ಕಾಗಿ ನೀವು ಮಾರ್ಪಡಿಸಲು ಸಾಮರ್ಥ್ಯವನ್ನು ಬಯಸಿದರೆ ನೀವು ಹಾಗೆ ಮಾಡಬಹುದು -

492
00:45:10,690 --> 00:45:13,510
ವಾಸ್ತವವಾಗಿ, ಈ ನಿಖರವಾಗಿ ಸಮಂಜಸವಾಗಿದೆ.

493
00:45:13,510 --> 00:45:16,020
ನೀವು ವ್ಯೂಹ $ ಬರೆಯಬೇಕು ಬಯಸಲಿಲ್ಲ [$ K] + +

494
00:45:16,020 --> 00:45:27,890
ನೀವು + ಐಟಂ $ ಬರೆಯಲು ಇಚ್ಛಿಸುತ್ತೇನೆ + ಆದರೆ ನೀವು ಇನ್ನೂ ಹೇಳಲು ಬಯಸಿದರೆ ($ K === 'ಒಂದು')

495
00:45:27,890 --> 00:45:30,620
ನಂತರ ಐಟಂ ಹೆಚ್ಚಿಸಲು ಮತ್ತು ನಂತರ ನಮ್ಮ ವ್ಯೂಹವನ್ನು ಮುದ್ರಿಸಿ.

496
00:45:30,620 --> 00:45:36,290
ಈಗ ನಾವು print_r ಮಾಡಲು ಏನನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು ಇಲ್ಲ? ಯಾವ ಮೌಲ್ಯಗಳನ್ನು ಮುದ್ರಿತ ಮಾಡಬೇಕು?

497
00:45:36,290 --> 00:45:43,770
[ವಿದ್ಯಾರ್ಥಿ] 2 ಮತ್ತು 10. >> ಕೀಲಿ ಎಂದು [ಬೌಡೆನ್] ಮಾತ್ರ 'ಒಂದು' ನಾವು ವಾಸ್ತವವಾಗಿ ಮುದ್ರಿಸುವ ಇಲ್ಲ.

498
00:45:51,940 --> 00:45:55,670
>> ನೀವು ಬಹುಶಃ ತುಂಬಾ ವಿರಳವಾಗಿ, ವೇಳೆ ಎಂದಿಗೂ, PHP ಕಾರ್ಯಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅಗತ್ಯವಿದೆ

499
00:45:55,670 --> 00:46:03,370
ನೀವು ಫಂಕ್ಷನ್ ಯಾವುದೇ ರೀತಿಯ ಕಾರ್ಯವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅಲ್ಲಿ ಆದರೆ ನೀವು ಹೋಲುವಂತಿರುವ ಏನನ್ನಾದರೂ ವೀಕ್ಷಿಸಬಹುದು.

500
00:46:03,370 --> 00:46:09,900
ಸಾಮಾನ್ಯವಾಗಿ ನೀವು ಹೇಳಬಹುದು (foo $ $ ಬಾರ್) ಮತ್ತು ನಂತರ ಯಾವುದೇ ಎಂದು ಇದು ವಿವರಿಸುತ್ತದೆ.

501
00:46:09,900 --> 00:46:17,580
ನಾನು ಹಾಗೆ ಆದರೆ ನಂತರ, ಯಾವುದೇ ಯಾವುದೇ ಕರೆಗಳನ್ನು ಅರ್ಥ

502
00:46:17,580 --> 00:46:25,110
ಬಾಜ್ ಕರೆಗಳನ್ನು ಏನೇ, ಬದಲಾಯಿಸಬಹುದು ಮೊದಲ ವಾದವನ್ನು ಬಾಜ್ ರವಾನಿಸಲಾಗಿದೆ ಆದ್ದರಿಂದ.

503
00:46:25,110 --> 00:46:38,100
$ Foo ಮಾಡೋಣ ನ + +;

504
00:46:38,100 --> 00:46:48,020
ಮತ್ತು ಒಳಗೆ ಇಲ್ಲಿ ಬಾಜ್ ($ ಐಟಂ) ಮಾಡಲು ನಾವು;

505
00:46:48,020 --> 00:46:52,250
ಈಗ ನಾವು ಒಂದು ಕಾರ್ಯ ಕರೆ ನೀಡುತ್ತಿವೆ.

506
00:46:52,250 --> 00:46:56,780
ವಾದವು ಉಲ್ಲೇಖವು ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ, ಇದು ಅರ್ಥ ನಾವು ಮಾರ್ಪಡಿಸಲು ವೇಳೆ

507
00:46:56,780 --> 00:47:00,390
ನಾವು ಸೈನ್ ರವಾನಿಸಲಾಗಿದೆ ಎಂದು ವಿಷಯ ಮಾರ್ಪಡಿಸುವ ನೀವು

508
00:47:00,390 --> 00:47:04,420
ಮತ್ತು ನಾವು ನಿರೀಕ್ಷಿಸಬಹುದು ಈ ಮುದ್ರಿಸುವ - ನಾನು ವಾಕ್ಯ ಅವ್ಯವಸ್ಥೆಯಿಂದ ಹೊರತು - ನಾವು, 2, 11 ದೊರೆತಿದೆ

509
00:47:04,420 --> 00:47:06,300
ಆದ್ದರಿಂದ ವಾಸ್ತವವಾಗಿ ವೃದ್ಧಿಯಾಗಲ್ಪಡಬಹುದು.

510
00:47:06,300 --> 00:47:08,790
ನಾವು 2 ಸ್ಥಳಗಳಲ್ಲಿ ಉಲ್ಲೇಖಗಳು ಅವಶ್ಯಕತೆ ಗಮನಿಸಿ.

511
00:47:08,790 --> 00:47:13,050
ನಾನು ಈ ಮಾಡಿದರೆ? ಇದರ ಅರ್ಥ ಏನು?

512
00:47:13,050 --> 00:47:15,810
[ವಿದ್ಯಾರ್ಥಿ] ಇದು ಬದಲಾಗುತ್ತದೆ. >> ಹೌದು.

513
00:47:15,810 --> 00:47:18,290
ಐಟಂ ಕೇವಲ ಶ್ರೇಣಿಯಲ್ಲಿನ ಮೌಲ್ಯದ ಪ್ರತಿಯನ್ನು ಹೊಂದಿದೆ.

514
00:47:18,290 --> 00:47:26,670
ಆದ್ದರಿಂದ ಐಟಂ 2 ಗೆ ಬದಲಾಗುತ್ತದೆ, ಆದರೆ ಸರಣಿ ['ಒಂದು'] ಇನ್ನೂ 1 ಆಗಿರುತ್ತದೆ.

515
00:47:26,670 --> 00:47:32,560
ಅಥವಾ ನಾನು ಇದನ್ನು ಮಾಡಿದರೆ?

516
00:47:32,560 --> 00:47:39,260
ಈಗ ಐಟಂ ಬಾಜ್ ಒಂದು ಪ್ರತಿಯನ್ನು ಕಳುಹಿಸಲಾಗುತ್ತದೆ.

517
00:47:39,260 --> 00:47:46,330
ಆದ್ದರಿಂದ ವಾದದ ನಕಲನ್ನು, 2 ವೃದ್ಧಿಯಾಗಲ್ಪಡಬಹುದು ಮಾಡಲಾಗುತ್ತದೆ

518
00:47:46,330 --> 00:47:49,240
ಆದರೆ ಐಟಂ ಸ್ವತಃ 2 ವೃದ್ಧಿಯಾಗಲ್ಪಡಬಹುದು ಎಂದಿಗೂ.

519
00:47:49,240 --> 00:47:52,880
ಮತ್ತು ಐಟಂ, ಸರಣಿ ಬ್ರಾಕೆಟ್ ಏನೇ ಅದೇ ವಿಷಯ

520
00:47:52,880 --> 00:47:55,380
ಆದ್ದರಿಂದ ರಚನೆಯ ವೃದ್ಧಿಯಾಗಲ್ಪಡಬಹುದು ಎಂದಿಗೂ.

521
00:47:55,380 --> 00:47:57,960
ಆದ್ದರಿಂದ ಆ ಸ್ಥಳಗಳನ್ನು ಎರಡೂ ಅಗತ್ಯತೆ.

522
00:47:57,960 --> 00:48:03,830
>> PHP ಸಾಮಾನ್ಯವಾಗಿ ಈ ಬಗ್ಗೆ ಬಹಳ ಚುರುಕು.

523
00:48:03,830 --> 00:48:06,570
ನೀವು ನಾನು ಉಲ್ಲೇಖವು ರವಾನಿಸ ಬೇಕೆಂದಿರುವ ಭಾವಿಸುತ್ತೇನೆ ಇರಬಹುದು -

524
00:48:06,570 --> 00:48:09,560
ಈ ವಾಸ್ತವವಾಗಿ psets ಒಂದು ಮೇಲೆ ಒಂದು ಪ್ರಶ್ನೆಯಾಗಿದೆ.

525
00:48:09,560 --> 00:48:14,480
ಇದು ಹೇಳಿದರು ಅಲ್ಲಿ ಒಂದು questions.txt ವಿಷಯ

526
00:48:14,480 --> 00:48:19,280
ಏಕೆ ನೀವು ಉಲ್ಲೇಖ ಈ struct ಹಾದು ಬಯಸಬಹುದು?

527
00:48:19,280 --> 00:48:21,250
ಆ ಉತ್ತರವನ್ನು ಯಾವುದು?

528
00:48:21,250 --> 00:48:25,100
[ವಿದ್ಯಾರ್ಥಿ] ನೀವು ದೊಡ್ಡ ಏನೋ ನಕಲಿಸಲು ಹೊಂದಿಲ್ಲ ಆದ್ದರಿಂದ. >> ಹೌದು.

529
00:48:25,100 --> 00:48:32,920
ಎ struct ನಿರಂಕುಶವಾಗಿ ದೊಡ್ಡ ಮಾಡಬಹುದು, ಮತ್ತು ನೀವು ಚರ್ಚೆಯಂತೆ ರಲ್ಲಿ struct ಹಾದುಹೋದಾಗ

530
00:48:32,920 --> 00:48:36,800
ಇದು, ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಇದು ಹಾದುಹೋಗಲು ಇಡೀ struct ನಕಲಿಸಿ ಅಗತ್ಯವಿದೆ

531
00:48:36,800 --> 00:48:40,410
ನೀವು ಉಲ್ಲೇಖವು struct ಹಾದು ವೇಳೆ ಆದರೆ

532
00:48:40,410 --> 00:48:46,530
ನಂತರ ಇದು ಕ್ರಿಯೆಯ ಚರ್ಚೆಯಂತೆ 4 ಬೈಟ್ ವಿಳಾಸಕ್ಕೆ ನಕಲಿಸಿ ಅಗತ್ಯವಿದೆ.

533
00:48:48,520 --> 00:48:52,320
PHP ಚುರುಕಾದ ಹೆಚ್ಚು ಸ್ವಲ್ಪ ಹೊಂದಿದೆ.

534
00:48:52,320 --> 00:49:00,650
ನಾನು ಕೆಲವು ಫಂಕ್ಷನ್ ಮತ್ತು ನಾನು ಅದನ್ನು 1,000 ವಸ್ತುಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹಾದು ವೇಳೆ,

535
00:49:00,650 --> 00:49:03,990
ಇದು ಆ ವಸ್ತುಗಳ ಎಲ್ಲಾ 1,000 ನಕಲಿಸಲು ಹೊಂದಲು ವಿಶೇಷವೇನು ಅರ್ಥವೇನು

536
00:49:03,990 --> 00:49:10,450
ಕಾರ್ಯ ಅದನ್ನು ರವಾನಿಸಲು? ತಕ್ಷಣ ಹಾಗೆ ಇರಬಹುದು.

537
00:49:10,450 --> 00:49:15,940
ಈ ಕಾರ್ಯದ ಒಳಗೆ ನಿಜವಾಗಿ foo ಮಾರ್ಪಡಿಸುವ, ಎಂದಿಗೂ ವೇಳೆ

538
00:49:15,940 --> 00:49:22,660
ಆದ್ದರಿಂದ ನಿಜವಾದ ಮರಳಿ ($ foo === 'ಹಲೋ') ವೇಳೆ.

539
00:49:22,660 --> 00:49:26,460
ನಾವು ವಾಸ್ತವವಾಗಿ ಈ ಕ್ರಿಯೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್ ಒಳಗೆ ಬದಲಾಯಿಸಲಾಗಿತ್ತು ಎಂದಿಗೂ ಗಮನಿಸಿ,

540
00:49:26,460 --> 00:49:30,010
ಇದು foo ನಕಲು ಅಗತ್ಯವಿದೆ ಎಂದೂ ಯಾವುದೇ ರಲ್ಲಿ ಅಂಗೀಕರಿಸಿತು ಅರ್ಥ

541
00:49:30,010 --> 00:49:32,100
ಅದನ್ನು ಮಾರ್ಪಡಿಸುವ ಏಕೆಂದರೆ.

542
00:49:32,100 --> 00:49:39,240
ಆದ್ದರಿಂದ PHP ಕೃತಿಗಳು ವಾದಗಳನ್ನು ಹೊಂದಿದೆ ಮಾರ್ಗವೇ ಉಲ್ಲೇಖವು ರವಾನಿಸಲ್ಪಡುತ್ತದೆ

543
00:49:39,240 --> 00:49:42,170
ನೀವು ನಿಜವಾಗಿಯೂ ಅದನ್ನು ಮಾರ್ಪಡಿಸಲು ಪ್ರಯತ್ನಿಸಿ ರವರೆಗೆ.

544
00:49:42,170 --> 00:49:51,160
ನಾನು $ foo + + ಹೇಳಲು ವೇಳೆ ಈಗ; ಈಗ ಮೂಲ foo ಪ್ರತಿಯನ್ನು ಮಾಡಲು ಮತ್ತು ನಕಲು ಮಾರ್ಪಡಿಸಿ ಕಾಣಿಸುತ್ತದೆ.

545
00:49:51,160 --> 00:49:53,090
ಈ ಕೆಲವು ಸಮಯವನ್ನು ಉಳಿಸುತ್ತದೆ.

546
00:49:53,090 --> 00:49:58,210
ಈ ಬೃಹತ್ ರಚನೆಯ ಸ್ಪರ್ಶಿಸುವ ಇಲ್ಲ, ನೀವು ನಿಜವಾಗಿಯೂ, ಇದು ಮಾರ್ಪಡಿಸಿ ಎಂದಿಗೂ

547
00:49:58,210 --> 00:50:02,360
ಇದು, ನಕಲು ಮಾಡಲು ಅಗತ್ಯವಿಲ್ಲ

548
00:50:02,360 --> 00:50:06,640
ನಾವು ಸಹ ನಕಲಿಸುವುದು ಇಲ್ಲ ಎಂದರೆ ಈ ವನ್ನಾಗಲಿ ಮಾಡಿದರೆ ಆದರೆ

549
00:50:06,640 --> 00:50:08,640
ನೀವು ಮಾರ್ಪಡಿಸಲು ಕೂಡ.

550
00:50:08,640 --> 00:50:10,680
ಈ ವರ್ತನೆಯನ್ನು ಪ್ರತಿಯನ್ನು ಮೇಲಿನ ಬರಹ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

551
00:50:10,680 --> 00:50:17,380
ನೀವು ಕಾರ್ಯವ್ಯವಸ್ಥೆಯನ್ನು ಕೋರ್ಸ್ ವಿಶೇಷವಾಗಿ, ಇತರ ಪ್ರದೇಶಗಳಲ್ಲಿ ಅದು ನೋಡುತ್ತಾರೆ.

552
00:50:17,380 --> 00:50:23,880
ಆನ್ ಬರೆಯುವ ನೀವು ಏನಾದರೂ ಪ್ರತಿಯನ್ನು ಮಾಡಲು ಅಗತ್ಯವಿಲ್ಲ ಅಲ್ಲಿ ಒಂದು ಬಹಳ ಸಾಮಾನ್ಯ ಮಾದರಿ

553
00:50:23,880 --> 00:50:26,650
ಇದು ವಾಸ್ತವವಾಗಿ ಬದಲಾವಣೆ ಮಾಡಿದ ಹೊರತು. ಹೌದು.

554
00:50:26,650 --> 00:50:29,520
ನೀವು, ಪರೀಕ್ಷಾ ಒಳಗೆ ಇನ್ಕ್ರಿಮೆಂಟ್ ಹೊಂದಿತ್ತು [ವಿದ್ಯಾರ್ಥಿ] ಹೀಗಾದರೆ

555
00:50:29,520 --> 00:50:33,700
ಆದ್ದರಿಂದ 1,000 ಹೊರಗೆ ಕೇವಲ 1 ಅಂಶ ಬದಲಿಸುವ ಅಗತ್ಯವಿದೆ ಎಂದು?

556
00:50:33,700 --> 00:50:38,770
ನಾನು ಖಚಿತವಿಲ್ಲ.

557
00:50:38,770 --> 00:50:51,250
ನಾನು ಸಂಪೂರ್ಣ ವಿಷಯವನ್ನು ನಕಲಿಸಿ ಯೋಚಿಸಿದ್ದೇವೆ, ಆದರೆ ಇದು ಸಾಕಷ್ಟು ಸ್ಮಾರ್ಟ್ ನ ಸಂಭಾವ್ಯ -

558
00:50:51,250 --> 00:51:00,020
ವಾಸ್ತವವಾಗಿ, ಯಾವ ನಾನು ನಾನು ಯೋಚಿಸುತ್ತೇನೆ ಈ ತೋರುತ್ತಿದೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿತ್ತು ಕಲ್ಪನೆ ಆಗಿದೆ: $ array2 = [

559
00:51:00,020 --> 00:51:11,000
ನಂತರ ಸೂಚ್ಯಂಕ 'ಒಂದು' [1 2 3 4], ಮತ್ತು ಸೂಚ್ಯಂಕ 'ಬಿ' ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಯಾವುದೇ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿದೆ.

560
00:51:11,000 --> 00:51:15,380
ಆ ಎಲ್ಲಾ ನಡುವೆ ಅರ್ಧವಿರಾಮ ಅಗತ್ಯವಿದೆ. ಅಲ್ಪವಿರಾಮಗಳಿಂದ ಇವೆ ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ.

561
00:51:15,380 --> 00:51:21,210
ನಂತರ 'ಸಿ' ಮೌಲ್ಯ 3.

562
00:51:24,210 --> 00:51:26,290
ಸರಿ.

563
00:51:26,290 --> 00:51:33,440
ಈಗ ನಮಗೆ $ ಬಾಜ್ ($ array2) ಏನು ಹೇಳುತ್ತಾರೆ;

564
00:51:33,440 --> 00:51:36,540
ಅಲ್ಲಿ ಬಾಜ್ ಉಲ್ಲೇಖ ಈ ತೆಗೆದುಕೊಳ್ಳುವುದಿಲ್ಲ.

565
00:51:43,510 --> 00:51:47,370
ಆದ್ದರಿಂದ $ foo ['ಸಿ'] + +;

566
00:51:47,370 --> 00:51:52,340
ಈ ನಾವು ಚರ್ಚೆಯಂತೆ array2 ಸಾಗಿ ಅಲ್ಲಿ ಅಂತಹ ಒಂದು ಉದಾಹರಣೆ

567
00:51:52,340 --> 00:51:57,010
ಮತ್ತು ನಂತರ ಇದು ಏರಿಕೆಯ ಮೂಲಕ ರಚನೆಯ ಒಂದು ನಿರ್ದಿಷ್ಟ ಸೂಚ್ಯಂಕ ಮಾರ್ಪಡಿಸುವ ಇದೆ.

568
00:51:57,010 --> 00:52:01,090
ನಾನು ಪ್ರಾಮಾಣಿಕವಾಗಿ PHP ಮಾಡಲು ಹೋಗುವ ಯಾವ ಕಲ್ಪನೆಯೂ ಇಲ್ಲ.

569
00:52:01,090 --> 00:52:07,200
, ಇದು ಸುಲಭವಾಗಿ ಸಂಪೂರ್ಣ ವಿಷಯವನ್ನು ಪ್ರತಿಯನ್ನು ಮಾಡಬಹುದು, ಆದರೆ ಇದು ಸ್ಮಾರ್ಟ್ ಇದ್ದರೆ

570
00:52:07,200 --> 00:52:15,030
ಇದು ತನ್ನ ವಿಶಿಷ್ಟವಾದ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುತ್ತದೆ ಅಲ್ಲಿ ಈ ಕೀಲಿಗಳನ್ನು ನಕಲನ್ನು ಮಾಡುತ್ತದೆ

571
00:52:15,030 --> 00:52:20,620
ಆದರೆ ಅದೇ ರಚನೆಯ 1,2,3,4 ಬೆಟ್ಟು ಮಾಡಬಹುದು

572
00:52:20,620 --> 00:52:22,320
ಮತ್ತು ಈ ಅದೇ ರಚನೆಯ ಬೆಟ್ಟು ಮಾಡಬಹುದು.

573
00:52:22,320 --> 00:52:24,170
ನಾನು ಐಪ್ಯಾಡ್ ಇದು ಮಾಡುತ್ತೇವೆ.

574
00:52:28,900 --> 00:52:45,950
ನಾವು, [1,2,3,4] ಗೆ, ಅಲ್ಲಿ ಈ ವ್ಯಕ್ತಿ ಅಂಕಗಳನ್ನು 3 ಈ ರಚನೆಯ ಈ ವ್ಯಕ್ತಿ ಅಂಕಗಳನ್ನು ಹಾದು

575
00:52:45,950 --> 00:52:51,350
ಈ ವ್ಯಕ್ತಿ ಅಂಕಗಳನ್ನು [34, ...]

576
00:52:51,350 --> 00:52:58,590
ಈಗ ನಾವು ಬಾಜ್ ಗೆ ಹಾದುಹೋಗುವ ನೀವು, ನಾವು ಈ ಮಾರ್ಪಡಿಸುತ್ತಿವೆ.

577
00:52:58,590 --> 00:53:03,550
PHP ಸ್ಮಾರ್ಟ್ ವೇಳೆ, ಇದು ಕೇವಲ ಮಾಡಬಹುದು -

578
00:53:11,850 --> 00:53:18,230
ನಾವು ಇನ್ನೂ ಸ್ವಲ್ಪ ಮೆಮೊರಿ ನಕಲಿಸಲು ಹೊಂದಿತ್ತು, ಆದರೆ ಈ ಬೃಹತ್ ಅಡಕಿಸಿದ subarrays ಇದ್ದವು ವೇಳೆ

579
00:53:18,230 --> 00:53:21,560
ನಾವು ಆ ನಕಲಿಸಿ ಇಲ್ಲ.

580
00:53:21,560 --> 00:53:27,530
ಅದು ಏನು ಇದ್ದರೆ ನನಗೆ ಗೊತ್ತಿಲ್ಲ, ಆದರೆ ನಾನು ಆ ಮಾಡುವುದರಿಂದ ಕಲ್ಪಿಸಬಹುದಾದ.

581
00:53:29,050 --> 00:53:36,690
ಇದು PHP ಮೇಲೆ ಸಿ ಒಂದು ಸಾಕಷ್ಟು ದೊಡ್ಡ ಪ್ರಯೋಜನವನ್ನು ಹೊಂದಿದೆ.

582
00:53:36,690 --> 00:53:40,320
>> PHP ಜೀವನ ತುಂಬಾ ಸುಲಭ ವಸ್ತುಗಳ ಬಹಳಷ್ಟು ಕಾಲ, ಮಾಡುತ್ತದೆ

583
00:53:40,320 --> 00:53:45,060
ಆದರೆ ನೀವು ರೀತಿಯ ಇದು ನಿರ್ವಹಿಸಲು ಎಷ್ಟು ಚೆನ್ನಾಗಿ ಸಂಪೂರ್ಣವಾಗಿ ಕಲ್ಪನೆಯೂ ಇಲ್ಲ

584
00:53:45,060 --> 00:53:52,530
ಇದು ವಸ್ತುಗಳ ಈ ನಕಲುಗಳನ್ನು ತಯಾರಿಸುವ ಸಂದರ್ಭದಲ್ಲಿ ನಾನು HOOD ಕೆಳಗಿರುವ ಕಲ್ಪನೆ ಇರಲಿಲ್ಲ ಏಕೆಂದರೆ,

585
00:53:52,530 --> 00:53:55,170
ಓಹ್, ಒಂದು ಸ್ಥಿರ ಸಮಯದಲ್ಲಿ ನಕಲು ಎಂದು ಹೋಗುತ್ತದೆ,

586
00:53:55,170 --> 00:54:01,140
ಇದು ಕೇವಲ 1 ಪಾಯಿಂಟರ್ ಬದಲಾಯಿಸಲು ಹೋಗುತ್ತದೆ, ಅದು ಹಾಸ್ಯಾಸ್ಪದವಾಗಿ ಕಷ್ಟ ರೇಖೀಯ ನಕಲು ಎಂದು ಹೋಗುತ್ತದೆ?

587
00:54:01,140 --> 00:54:03,000
ಇದು ಜಾಗವನ್ನು ಹುಡುಕಲು ಸಾಧ್ಯವಿಲ್ಲ ಏನಾಗುತ್ತದೆ?

588
00:54:03,000 --> 00:54:06,760
ಇದು ನಂತರ ಕೆಲವು ಹೆಚ್ಚು ಜಾಗವನ್ನು ಪಡೆಯಲು ಗಾರ್ಬೇಜ್ ಕಲೆಕ್ಷನ್ ರನ್ ಅಗತ್ಯವೇನು?

589
00:54:06,760 --> 00:54:11,210
ಮತ್ತು ಗಾರ್ಬೇಜ್ ಕಲೆಕ್ಷನ್ ಕ್ರಮವಿಲ್ಲದ ಉದ್ದವಾದ ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

590
00:54:11,210 --> 00:54:13,600
ಸಿ ಈ ವಿಷಯಗಳ ಬಗ್ಗೆ ಚಿಂತೆ ಇಲ್ಲ.

591
00:54:13,600 --> 00:54:19,780
ನೀವು ಬರೆಯಲು ಪ್ರತಿಯೊಂದು ಸಾಲು ನಿರ್ವಹಿಸಲು ವಿಶೇಷವೇನು ಹೇಗೆ ಅತ್ಯಧಿಕವಾಗಿ ಕಾರಣ ಮಾಡಬಹುದು.

592
00:54:26,800 --> 00:54:29,150
>> ನ ಈ ಹಿಂದೆ ನೋಡೋಣ.

593
00:54:35,400 --> 00:54:37,520
ಇದನ್ನು, ನೀವು ಹ್ಯಾಶ್ ಕ್ರಿಯೆಗಳನ್ನು ವ್ಯವಹರಿಸಲು ಇಲ್ಲ ಎಂದು ಹೇಗೆ ಸಂತೋಷ

594
00:54:37,520 --> 00:54:39,010
ಲಿಂಕ್ ಪಟ್ಟಿಗಳು, ಅಥವಾ ಹಾಗೆ ಏನು?

595
00:54:39,010 --> 00:54:41,980
ಹ್ಯಾಶ್ ಕೋಷ್ಟಕಗಳು ಕೆಲಸ ಈಗ ತುಂಬಾ ಸುಲಭ ಏಕೆಂದರೆ, ಇಲ್ಲಿ ಕೆಲಸ ಮಾಡಲು ಒಂದು ಮೋಜಿನ ಪಜಲ್ ಇಲ್ಲಿದೆ.

596
00:54:41,980 --> 00:54:45,920
Unique.php ಮತ್ತು ಅದರಲ್ಲಿ ಎಂಬ ಕಡತವನ್ನು ತೆರೆಯುತ್ತದೆ ಒಂದು PHP ಪ್ರೋಗ್ರಾಂ ಬರೆಯಲು

597
00:54:45,920 --> 00:54:48,330
(ಒಂದು "ಸ್ಕ್ರಿಪ್ಟ್" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ).

598
00:54:48,330 --> 00:54:55,700
ಅವರು ನೀವು ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ರನ್ ಚಿಕ್ಕ ವಿಷಯಗಳನ್ನು ನೀವು ನಾವು ಅವುಗಳನ್ನು ಸ್ಕ್ರಿಪ್ಟ್ಗಳನ್ನು ಕರೆ ಒಲವು.

599
00:54:55,700 --> 00:55:02,950
ಮೂಲಭೂತವಾಗಿ, ನೀವು ಕಂಪೈಲ್ ಇಲ್ಲ ಆದರೆ ನೀವು ಚಾಲನೆಗೊಳ್ಳುವಂತೆ ಎಂದು ನೀನು ಯಾವುದೇ ಭಾಷೆ

600
00:55:02,950 --> 00:55:05,920
ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ, ನೀವು ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಸ್ಕ್ರಿಪ್ಟ್ ಕರೆ ಮಾಡಬಹುದು.

601
00:55:05,920 --> 00:55:08,510
ನಾನು ಕೂಡ ಈ ವಾದಿಸಲಾಗದ ಸಿ ಪ್ರೋಗ್ರಾಂ ಬರೆಯಬಹುದಾದರೆ

602
00:55:08,510 --> 00:55:12,300
ನಾನು ಮೊದಲ ಇದು ಕಂಪೈಲ್ ತದನಂತರ ಅವಳಿ ರನ್ ಆದರೆ ನಾನು ಒಂದು ಸ್ಕ್ರಿಪ್ಟ್ ಕರೆ ಮಾಡಬೇಡಿ.

603
00:55:12,300 --> 00:55:15,480
ಆದರೆ ಈ PHP ಪ್ರೋಗ್ರಾಂ ನಾವು ಸ್ಕ್ರಿಪ್ಟ್ ಕರೆಯಲು ನೀನು.

604
00:55:15,480 --> 00:55:23,830
ಅಥವಾ ನಾವು ಪೈಥಾನ್ ಅಥವಾ ಪರ್ಲ್ ಅಥವಾ Node.js ಅಥವಾ ಆ ವಸ್ತುಗಳ ಯಾವುದೇ ಅದನ್ನು ಬರೆದ ವೇಳೆ,

605
00:55:23,830 --> 00:55:26,500
ನೀವು ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಅವಕ್ಕೆ ರನ್ ಏಕೆಂದರೆ ನಾವು ಅವರನ್ನು ಎಲ್ಲಾ ಸ್ಕ್ರಿಪ್ಟ್ಗಳನ್ನು ಕರೆ ಬಯಸುವ

606
00:55:26,500 --> 00:55:30,040
ಆದರೆ ನಾವು ಅವರನ್ನು ಕಂಪೈಲ್ ಇಲ್ಲ.

607
00:55:30,860 --> 00:55:33,400
ನಾವು ಬಹಳ ಬೇಗ ಈ ಮಾಡಬಲ್ಲರು.

608
00:55:36,960 --> 00:55:41,480
ನಾವು argv ಬಳಸಲು ವಿಶೇಷವೇನು ಇಲ್ಲ. ಈ ಮೂಲಕ ಪಸರಿಸಲು ಕೇವಲ ನೋಡೋಣ.

609
00:55:41,480 --> 00:55:45,730
ಇದು ಅನನ್ಯ ಕಾಲ್, ಬರೆಯುವ ಒಂದು ಪ್ರೊಗ್ರಾಮ್.

610
00:55:45,730 --> 00:55:49,400
ನೀವು ಇನ್ಪುಟ್ ಸಾಲಿಗೆ ಪದವು ಹೊಂದಿರುವ ಪಡೆದುಕೊಳ್ಳಬಹುದು.

611
00:55:49,400 --> 00:55:52,020
ವಾಸ್ತವವಾಗಿ, argv ಬಳಸಲು ಸಾಕಷ್ಟು ಕ್ಷುಲ್ಲಕ ಎಂದು ಕಾಣಿಸುತ್ತದೆ.

612
00:56:03,730 --> 00:56:06,720
unique.php.

613
00:56:08,550 --> 00:56:13,750
ಮೊದಲನೆಯದಾಗಿ ಮೊದಲ, ನಾವು 1 ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟನ್ನು ವರ್ಗಾವಣೆಯಾಗಿವೆ ನೀವು ಪರಿಶೀಲಿಸಲು ಬಯಸುವ.

614
00:56:13,750 --> 00:56:20,900
ನೀವು ಸಿ argc ಮತ್ತು argv ನಿರೀಕ್ಷಿಸಬಹುದು ಕೇವಲ ಎಂದು, ನಾವು ಇನ್ನೂ PHP ಆ ಹೊಂದಿರುತ್ತವೆ.

615
00:56:20,900 --> 00:56:33,900
ಆದ್ದರಿಂದ ನಾನು ಒಂದು ಸಂದೇಶ ಅಥವಾ ಏನು ಮುದ್ರಿಸುವ ವ್ಯವಹರಿಸುವುದಿಲ್ಲ ಕಾಣಿಸುತ್ತದೆ ($ argc! == 2) ವೇಳೆ.

616
00:56:33,900 --> 00:56:37,340
ನಾನು, 1 ದೋಷ ಕೋಡ್ ನಿರ್ಗಮಿಸಲು ಮಾಡುತ್ತೇವೆ.

617
00:56:37,340 --> 00:56:41,340
ನಾನು 1 ಹಿಂದಿರುಗಬಹುದು.

618
00:56:41,340 --> 00:56:53,180
ನಾವು ನೀವು ಅಲ್ಲಿ ವಿರಳವಾಗಿ PHP ರಲ್ಲಿ ಈ ರಾಜ್ಯದ ಹೆಚ್ಚು -

619
00:56:53,180 --> 00:56:57,820
ಸಾಮಾನ್ಯವಾಗಿ ನೀವು ಒಂದು ಕ್ರಿಯೆಯ ಎಂಬ ಕ್ರಿಯೆಯ ಮೂಲಕ ಎಂಬ ಕ್ರಿಯೆಯ ಮೂಲಕ ಎಂಬ ಕಾರ್ಯದಲ್ಲಿ ಆರ್.

620
00:56:57,820 --> 00:57:02,070
ಮತ್ತು ಏನಾದರೂ ತಪ್ಪಾದಲ್ಲಿ ಮತ್ತು ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಎಲ್ಲವೂ ನಿರ್ಗಮಿಸಲು ಬಯಸಿದರೆ,

621
00:57:02,070 --> 00:57:05,680
ನಿರ್ಗಮನ ಕೇವಲ ಕಾರ್ಯಕ್ರಮ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ.

622
00:57:05,680 --> 00:57:08,160
ಇದು ಸಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ

623
00:57:08,160 --> 00:57:10,700
ನೀವು ಒಂದು ಕಾರ್ಯದಲ್ಲಿ ಒಂದು ಕಾರ್ಯದಲ್ಲಿ ಒಂದು ಕಾರ್ಯದಲ್ಲಿ ಒಂದು ಕಾರ್ಯದಲ್ಲಿ ನೀವು

624
00:57:10,700 --> 00:57:17,540
ಮತ್ತು ನೀವು ಪ್ರೋಗ್ರಾಂ ಕೊಲ್ಲಲು ಬಯಸುವ, exit ಕರೆ ಮಾಡಬಹುದು ಮತ್ತು ಅದು ಕೇವಲ ನಿರ್ಗಮಿಸುತ್ತದೆ.

625
00:57:17,540 --> 00:57:23,120
ಆದರೆ PHP ಅದನ್ನು ನಾವು ಉನ್ನತ ಮಟ್ಟದಲ್ಲಿ ಇನ್ನಷ್ಟು ಅಪರೂಪದ ಇಲ್ಲಿದೆ.

626
00:57:23,120 --> 00:57:26,090
ಸಾಮಾನ್ಯವಾಗಿ ನಾವು ಕಾರ್ಯ ಕೆಲವು ರೀತಿಯ ಒಳಗೆ ನೀವು, ಆದ್ದರಿಂದ ನಾವು ನಿರ್ಗಮನ ಕರೆ

627
00:57:26,090 --> 00:57:29,650
ನಾವು ನಂತರ ಅರಿವಾಗುತ್ತದೆ ಇದು 1 ವಿಷಯ ಅಪ್ ಮರಳಲು ಹೊಂದಿಲ್ಲ ಆದ್ದರಿಂದ ದೋಷವುಂಟಾಗಿದೆ

628
00:57:29,650 --> 00:57:32,270
ಒಂದು ದೋಷ ಉಂಟಾಗಿದೆ ಗುರುತಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಅಪ್ ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

629
00:57:32,270 --> 00:57:35,270
ನಾವು (1) ನಿರ್ಗಮಿಸಲು, ಎಂದು ವ್ಯವಹರಿಸಲು ಬಯಸುವುದಿಲ್ಲ;

630
00:57:35,270 --> 00:57:38,240
ಲಾಭ (1); ಈ ಸಂದರ್ಭದಲ್ಲಿ ಸಮಾನ ಎಂದು.

631
00:57:38,240 --> 00:57:44,000
>> ನಂತರ ನಾವು ತೆರೆಯಲು ಯಾವ ನಾವು fopen ಬಯಸುವ.

632
00:57:44,000 --> 00:57:46,760
ವಾದಗಳನ್ನು ಸಾಕಷ್ಟು ಹೋಲುವ ರೀತಿಯಲ್ಲಿ ಕಾಣಿಸುತ್ತವೆ ಹೋಗುವ.

633
00:57:46,760 --> 00:57:51,600
ನಾವು fopen ($ argv [1], ಮತ್ತು ನಾವು ಓದಲು ಅದನ್ನು ತೆರೆಯಲು ಬಯಸುವ. ಬಯಸುವ

634
00:57:51,600 --> 00:57:55,720
ನಾವು ಎಫ್ ಕರೆಯಲು ನೀನು ಒಂದು ಸಂಪನ್ಮೂಲ ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

635
00:57:55,720 --> 00:58:02,180
ನಾವು ಫೈಲ್ನಲ್ಲಿ * ಹೇಳಲು ಇಲ್ಲ ಹೊರತುಪಡಿಸಿ ಸಿ ಅದು ಹೇಗೆ ಸಾಕಷ್ಟು ಹೋಲುತ್ತದೆ.

636
00:58:02,180 --> 00:58:06,170
ಬದಲಿಗೆ ನಾವು $ F ಹೇಳುತ್ತಾರೆ. ಸರಿ.

637
00:58:06,170 --> 00:58:17,190
ವಾಸ್ತವವಾಗಿ, ಈ ಕೂಡ ನಮಗೆ ಫೈಲ್ ಎಂಬ PHP ಕ್ರಿಯೆಯ ಒಂದು ಸುಳಿವನ್ನು ನೀಡುತ್ತದೆ ಭಾವಿಸುತ್ತೇನೆ. PHP ಕಡತ.

638
00:58:17,190 --> 00:58:23,990
ಏನು ಮಾಡಬೇಕೆಂದು ಹೋಗುವ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಒಂದು ಸಂಪೂರ್ಣ ಫೈಲ್ ಓದಲು.

639
00:58:23,990 --> 00:58:29,770
ನೀವು fopen ಇದು ಅಗತ್ಯವಿಲ್ಲ. ಇದು ನಿಮಗೆ ಹಾಗೆ ಹೋಗುವುದಿಲ್ಲ.

640
00:58:37,450 --> 00:58:43,700
ಆದ್ದರಿಂದ $ ಸಾಲುಗಳನ್ನು = ಕಡತ ($ argv [1]);

641
00:58:43,700 --> 00:58:49,680
ಈಗ ಫೈಲ್ ಸಾಲುಗಳನ್ನು ಎಲ್ಲಾ ಸಾಲುಗಳು ಇವೆ. ಈಗ ನಾವು ಸಾಲುಗಳನ್ನು ವಿಂಗಡಿಸಲು ಬಯಸುವ.

642
00:58:49,680 --> 00:58:52,180
ಹೇಗೆ ನಾವು ಸಾಲುಗಳನ್ನು ವಿಂಗಡಿಸಲು ಮಾಡಬಹುದು?

643
00:58:52,180 --> 00:58:54,920
ನಾವು ಸಾಲುಗಳನ್ನು ವಿಂಗಡಿಸಲು.

644
00:58:54,920 --> 00:58:58,080
ಮತ್ತು ಈಗ ನಾವು ಅವುಗಳನ್ನು ಅಥವಾ ಯಾವುದೇ ಮುದ್ರಿಸಬಹುದು.

645
00:58:58,080 --> 00:59:05,580
ಬಹುಶಃ ಸುಲಭವಾದ ಮಾರ್ಗವೆಂದರೆ foreach ($ ಲೈನ್ $ ಗೆರೆಗಳನ್ನು) ಸಾಲನ್ನು $ ಪ್ರತಿಧ್ವನಿ;

646
00:59:05,580 --> 00:59:10,960
[ವಿದ್ಯಾರ್ಥಿ] ನಾವು ರೀತಿಯ ಏನಾದರೂ ಪರಾಮರ್ಶಿಸುವುದರ ಮೂಲಕ ಸಾಲುಗಳನ್ನು ದಾಟಿ ಬಯಸುವಿರಾ?

647
00:59:10,960 --> 00:59:28,850
ರೀತಿಯ ಕಾರ್ಯವನ್ನು ರೀತಿಯ (ಮತ್ತು $ ಸರಣಿ) ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಎಂದು ಅಲ್ಲಿ ಇದು.

648
00:59:28,850 --> 00:59:32,650
ನೀವು ಕಾರ್ಯ ಕರೆ ನೀವು ಉಲ್ಲೇಖ ಮೂಲಕ ಹಾದು ಇಲ್ಲ.

649
00:59:32,650 --> 00:59:36,900
ಇದು ಉಲ್ಲೇಖವಾಗಿ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದ್ದು ಇದನ್ನು ವರ್ಣಿಸಬಹುದು ಕಾರ್ಯ ನ.

650
00:59:36,900 --> 00:59:40,900
ಈ ತಪ್ಪಾಗಿದೆ ಎಂಬುದನ್ನು ವಾಸ್ತವವಾಗಿ

651
00:59:40,900 --> 00:59:46,220
ನಾವು 5.3 ರಿಂದ 5.4 ಹೋದಾಗ ನಮ್ಮ ಸರ್ವರ್ಗಳಿಗೆ ಎಲ್ಲವೂ ಹುಟ್ಟುಹಾಕಿದಾಗ.

652
00:59:46,220 --> 00:59:53,800
5.4 ವರೆಗೆ, ಈ ನಿಖರವಾಗಿ ಸಮಂಜಸವಾದ ಆಗಿತ್ತು.

653
00:59:53,800 --> 00:59:58,740
ಒಂದು ಕಾರ್ಯದ ಉಲ್ಲೇಖ ಎಂದು ತೆಗೆದುಕೊಳ್ಳಲು ನಿರೀಕ್ಷಿಸಬಹುದು, ಆದರೆ ನೀವು ಉಲ್ಲೇಖವಾಗಿ ಸರಿಸುತ್ತದೆ

654
00:59:58,740 --> 01:00:02,860
ಕಾರ್ಯ ಅದನ್ನು ಮಾರ್ಪಡಿಸಲು ಹೀಗಾಗುತ್ತದೆ ಆದ್ದರಿಂದ ಅದನ್ನು ಇನ್ನೂ ಬದಲಾಯಿಸಲಾಗಿತ್ತು ನ.

655
01:00:02,860 --> 01:00:05,850
5.4 ರ, ನೀವು ಇದನ್ನು ಇಲ್ಲದಿರಬಹುದಾದ ಮಾಡುತ್ತಿದ್ದೇವೆ.

656
01:00:05,850 --> 01:00:11,740
ಕಾರ್ಯವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಅದನ್ನು ಈಗ ನೀವು ಉಲ್ಲೇಖ ಮೂಲಕ ಹಾದು ಏಕೈಕ ಮಾರ್ಗವಾಗಿದೆ.

657
01:00:11,740 --> 01:00:19,840
ನೀವು ಅದನ್ನು ಮಾರ್ಪಡಿಸಲು ಬಯಸದಿದ್ದರೆ, ನೀವು $ ಪ್ರತಿಯನ್ನು = $ ರೇಖೆಗಳು ಮತ್ತು ಪಾಸ್ ನಕಲು ಮಾಡಲು ಅಗತ್ಯವಿದೆ.

658
01:00:19,840 --> 01:00:24,820
ಈಗ ಸಾಲುಗಳನ್ನು ರಕ್ಷಿಸಲ್ಪಟ್ಟ ಮತ್ತು ನಕಲು ಬದಲಾಯಿಸಲಾಗುತ್ತದೆ.

659
01:00:27,670 --> 01:00:31,460
php.unique.php. ನಾನು ಏನೋ ಅವ್ಯವಸ್ಥೆಯಿಂದ ಸಾಧ್ಯತೆಯಿದೆ.

660
01:00:31,460 --> 01:00:33,190
ಅನಿರೀಕ್ಷಿತ 'ರೀತಿಯ'.

661
01:00:38,320 --> 01:00:43,850
ನಮಗೆ ಈ ಮಾಡುತ್ತದೆ ಎಂದು ಏನೋ ಇರುವಂತೆ ವಿಶೇಷವೇನು.

662
01:00:43,850 --> 01:00:45,820
ಇದು ಕೂಡ ಇಲ್ಲ.

663
01:00:45,820 --> 01:00:52,140
ನೀವು ಮೊದಲ ವಾದವನ್ನು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ಕೈಯಿಂದ ಓದುವಾಗ ಗಮನಿಸಿ

664
01:00:52,140 --> 01:00:56,490
ಮತ್ತು ಅದನ್ನು ಉಲ್ಲೇಖಿಸಿ ತೆಗೆದುಕೊಂಡ.

665
01:00:58,160 --> 01:01:03,540
ಏಕೆ ಈ ನನಗೆ ದೂರು ಇದೆ? ನಾನು ಬಯಸುವುದಿಲ್ಲ ಎಂದು ಇಲ್ಲಿ ಇನ್ನೂ ಈ ರೀತಿಯ ಕಾರ್ಯ ಕಾರಣ.

666
01:01:03,540 --> 01:01:09,210
ಸರಿ, php.unique.php. ನಾನು ಒಂದು ಕಡತವನ್ನು ಹೊಂದಿಲ್ಲ ಏಕೆಂದರೆ ನಾನು ವಾದವನ್ನು ಪೂರೈಸಲಿಲ್ಲ.

667
01:01:09,210 --> 01:01:13,560
ಇದು test.php ಮೇಲೆ php.unique.php ಇಲ್ಲಿದೆ.

668
01:01:13,560 --> 01:01:19,080
ಇಲ್ಲಿ ಎಲ್ಲಾ ಉತ್ತಮ ವಿಂಗಡಿಸಲಾದ ಸಲುವಾಗಿ ಔಟ್ ಮುದ್ರಿತ test.php ಹೊಂದಿದೆ.

669
01:01:19,080 --> 01:01:24,600
ವಿಂಗಡಿಸಲಾದ ಆದೇಶವು ಕೋಡ್ ಕಡತ ಬಗೆಯ ವಿಲಕ್ಷಣ ಆಫ್ ಗಮನಿಸಿ

670
01:01:24,600 --> 01:01:27,460
ನಮ್ಮ ಖಾಲಿ ಸಾಲುಗಳು ಎಲ್ಲಾ ಮೊದಲ ಕರೆದುಕೊಂಡು ಹೋಗುತ್ತಾರೆ ಏಕೆಂದರೆ

671
01:01:27,460 --> 01:01:30,190
ನಂತರ ನಮ್ಮ 1 ಮಟ್ಟದ ಭೂ ಎಲ್ಲಾ ಬಂದು ಹೋಗುವ

672
01:01:30,190 --> 01:01:33,360
ನಂತರ ನಮ್ಮ ಯಾವುದೇ ಭೂ ಎಲ್ಲಾ ಬನ್ನಿ.

673
01:01:33,360 --> 01:01:38,620
ಹೌದು. >> [ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ಮೂಲ ಕೋಡ್ ಅದು ಉಲ್ಲೇಖ ಮಂಜೂರು ಮಾಡಲಿಲ್ಲ?

674
01:01:38,620 --> 01:01:42,240
ಎಂದು ಸಾಮಾನ್ಯವಾಗಿ ಮೌಲ್ಯವನ್ನು ರವಾನಿಸಲಾಗಿದೆ?

675
01:01:42,240 --> 01:01:50,240
[ಬೌಡೆನ್] ನೀವು ಒಂದು ಕಾರ್ಯ ಕರೆ ಮಾಡಿದಾಗ, ಅದು ಉಲ್ಲೇಖ ಅಂಗೀಕರಿಸಿತು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ ಎಂದಿಗೂ.

676
01:01:50,240 --> 01:01:53,960
ಅದು ಉಲ್ಲೇಖ ಅಂಗೀಕರಿಸಿತು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ ಕಾರ್ಯ ವ್ಯಾಖ್ಯಾನ ಇಲ್ಲಿದೆ.

677
01:01:53,960 --> 01:01:59,450
ಮತ್ತು ರೀತಿಯ ಕಾರ್ಯವನ್ನು ವ್ಯಾಖ್ಯಾನವನ್ನು ನೋಡಿ ಅಥವಾ ಈ ನೋಡಿ,

678
01:01:59,450 --> 01:02:02,820
ಇದು ಉಲ್ಲೇಖಿಸಿ ವಾದವು ನಡೆಯುತ್ತದೆ.

679
01:02:02,820 --> 01:02:07,160
ಆದ್ದರಿಂದ ಲೆಕ್ಕಿಸದೆ ನೀವು ಉಲ್ಲೇಖ ಅದನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಬಯಸುವ ಎಂಬುದನ್ನು, ಅದು ಉಲ್ಲೇಖ ಇದು ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

680
01:02:07,160 --> 01:02:10,200
ಇದು ಸ್ಥಳದಲ್ಲಿ ರಚನೆಯ ಮಾರ್ಪಡಿಸುತ್ತದೆ.

681
01:02:10,200 --> 01:02:17,400
ಈ ಕೇವಲ ಅನುಮತಿಸಲಾಗುವುದಿಲ್ಲ. ಇದನ್ನು ಮಾಡಲು ಅನುಮತಿ ಇಲ್ಲ. >> [ವಿದ್ಯಾರ್ಥಿ] ಓಹ್, ಸರಿ.

682
01:02:17,400 --> 01:02:22,410
[ಬೌಡೆನ್] ಈ ರೀತಿಯ ಉಲ್ಲೇಖವು ಸಾಲುಗಳನ್ನು ತೆಗೆದುಕೊಂಡು ಅದನ್ನು ಮಾರ್ಪಡಿಸಲು ಹೋಗುತ್ತದೆ.

683
01:02:22,410 --> 01:02:26,850
ನೀವು ಹಾಗೆ ಮಾಡಲು ಬಯಸಿದಲ್ಲಿ ಮತ್ತು ಮತ್ತೆ, ನೀವು ರೀತಿಯ ನಕಲು ಮಾಡಬಹುದು.

684
01:02:26,850 --> 01:02:35,850
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಕಲು ವಾಸ್ತವವಾಗಿ ಸಾಲುಗಳನ್ನು ಪ್ರತಿಯನ್ನು ಅಲ್ಲ.

685
01:02:35,850 --> 01:02:40,620
ಇದು ಮೊದಲ ಬದಲಾಯಿಸಲಾಗಿತ್ತು ಮುಟ್ಟುತ್ತದೆ ತನಕ ಕೇವಲ ಒಂದೇ ಸೂಚಿತವಾಗಿರುತ್ತದೆ

686
01:02:40,620 --> 01:02:44,430
ಅಲ್ಲಿ ಇದು ಮೊದಲ ರೀತಿಯ ಕಾರ್ಯದಲ್ಲಿ ಬದಲಾಯಿಸಲಾಗಿತ್ತು ನಿಮಗೆ ವಿಶೇಷವೇನು

687
01:02:44,430 --> 01:02:50,940
ಅಲ್ಲಿ, ಏಕೆಂದರೆ ಅದು ಆನ್ ಬರೆಯಲು ಈಗ ನಕಲು ಪ್ರತಿಯನ್ನು ಮಾಡಬೇಕಾದ ಹೋಗುತ್ತದೆ.

688
01:02:57,500 --> 01:03:04,250
ನೀವು ಇದನ್ನು ಮಾಡಬಹುದು. ನೀವು ವನ್ನಾಗಲಿ ನೋಡಬಹುದು ಇತರ ಸ್ಥಳದಲ್ಲಿ ಆ.

689
01:03:04,250 --> 01:03:07,190
ನೀವು foreach ಕುಣಿಕೆಗಳು ಅದನ್ನು ನೋಡಿ, ನೀವು, ಫಂಕ್ಷನ್ ಘೋಷಣೆಗಳು ಇದನ್ನು ನೋಡಿ

690
01:03:07,190 --> 01:03:10,040
ಕೇವಲ ಅಸ್ಥಿರ ನಿಯೋಜಿಸುವ ಸಂದರ್ಭದಲ್ಲಿ ಮತ್ತು ನೀವು ಇದನ್ನು ನೋಡಿ.

691
01:03:10,040 --> 01:03:12,350
ಈಗ ನಾವು ಈ ಮಾಡುವುದರಿಂದ ಏನೂ ಸಾಧನೆಗೈದಿದ್ದಾರೆ

692
01:03:12,350 --> 01:03:15,600
ನಕಲು ಮತ್ತು ಸಾಲುಗಳು ಅಕ್ಷರಶಃ ಒಂದೇ ಕಾರಣ.

693
01:03:15,600 --> 01:03:19,940
ನೀವು ಸಾಲುಗಳನ್ನು ಬಳಸಿ ಮತ್ತು ವಿನಿಮಯ ನಕಲು ಮಾಡಬಹುದು.

694
01:03:19,940 --> 01:03:25,430
, ಮತ್ತು ಹೊಂದಿಸಿಲ್ಲದ ಸಾಲುಗಳನ್ನು ಮಾಡುವುದಿಲ್ಲ; ನೀವು ಹೊಂದಿಸಿಲ್ಲದ ($ ನಕಲನ್ನು) ಮಾಡಬಹುದು

695
01:03:25,430 --> 01:03:29,120
ನೀವು ಕೇವಲ ಒಂದೇ ನಿಮ್ಮ ಉಲ್ಲೇಖ ಕಳೆದುಕೊಳ್ಳಬಹುದು.

696
01:03:29,120 --> 01:03:33,440
ಆದ್ದರಿಂದ ಈ ಬಿಂದುವಿನ ಮಾಹಿತಿ, ಈಗ ಸಾಲುಗಳನ್ನು ನೀವು ಸಾಲುಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಏಕೈಕ ಮಾರ್ಗವಾಗಿದೆ.

697
01:03:36,450 --> 01:03:38,770
>> ಪ್ರಶ್ನೆಗಳು?

698
01:03:41,000 --> 01:03:42,460
ಹೌದು.

699
01:03:42,460 --> 01:03:45,880
ಸಂಪೂರ್ಣವಾಗಿ ವಿಷಯ ಆಫ್ [ವಿದ್ಯಾರ್ಥಿ], ಆದರೆ ನಿಮ್ಮೊಂದಿಗೆ PHP ಮುಚ್ಚಲು ಹೊಂದಿಲ್ಲ - ನೀವು >>.

700
01:03:45,880 --> 01:03:47,730
ಸರಿ.

701
01:03:47,730 --> 01:03:53,790
[ಬೌಡೆನ್] ಇದು ಅವುಗಳನ್ನು ಮುಚ್ಚಲು ಕೆಟ್ಟ ಅಭ್ಯಾಸ ಹೇಳುತ್ತಾರೆ ಎಂದು ನಾನು ದೂರದ ಹೋಗುತ್ತಿದ್ದೆ.

702
01:03:53,790 --> 01:03:57,580
ಎಂದು, ವಿಶೇಷವಾಗಿ ಒಂದು ಲಿಪಿಯಲ್ಲಿ, ಬಹುಶಃ ಒಂದು ಉತ್ಪ್ರೇಕ್ಷೆಯ ಇಲ್ಲಿದೆ

703
01:03:57,580 --> 01:04:03,740
ಆದರೆ ನಾನು ಹಾಗೆ ಏನಾಗುತ್ತದೆ ನೋಡೋಣ.

704
01:04:03,740 --> 01:04:08,890
ಎಂದು ಏನೂ ಮಾಡಲಿಲ್ಲ. ನಾನು ಬಯಸಿದ್ದ ಹೀಗಾದರೆ - [ನಿಟ್ಟುಸಿರ]

705
01:04:13,870 --> 01:04:16,960
ನಾನು ಒಂದು ವಾದವು ಪಾಸ್ ಅಗತ್ಯವಿದೆ.

706
01:04:19,000 --> 01:04:22,050
ಶೂಟ್. ನಾನು ಅದು ತಪ್ಪು ಎಂದು.

707
01:04:24,340 --> 01:04:28,310
ಒಂದು ವಾದವನ್ನು ಆದ್ದರಿಂದ php.unique.php.

708
01:04:28,310 --> 01:04:30,980
ಈಗ ನಾನು ಈ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.

709
01:04:34,520 --> 01:04:37,740
ನಾನು ಒಂದು ಮಾನ್ಯವಾದ ವಾದ ಪಾಸ್ ಮಾಡುತ್ತೇವೆ.

710
01:04:37,740 --> 01:04:42,050
ಇದು ಮುದ್ರಣ ನ ಯಾವುದೇ ಮುದ್ರಿತ.

711
01:04:45,260 --> 01:04:50,080
ನಾನು ಪ್ರತಿ ಮುದ್ರಿಸುವ ನಾನು ಮತ್ತು ಪ್ರತಿ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. ಸಾಲುಗಳನ್ನು ಆದ್ದರಿಂದ.

712
01:04:53,650 --> 01:04:58,270
ಅದು, ಎಲ್ಲವನ್ನೂ ಮುದ್ರಿತ, ತದನಂತರ ಇಲ್ಲಿ ಕೆಳಗೆ ಈ ಜಂಕ್ ಗಮನಕ್ಕೆ

713
01:04:58,270 --> 01:05:06,690
PHP ಏನು ಆ PHP ಟ್ಯಾಗ್ಗಳನ್ನು ಹೊರಗೆ ಕಾರಣ

714
01:05:06,690 --> 01:05:09,520
ಕೇವಲ ಅಕ್ಷರಶಃ ಮುದ್ರಿತ ಏರಲಿದೆ.

715
01:05:09,520 --> 01:05:18,050
ಏಕೆ HTML ಎಂದು, ನಾನು DIV blah, blah, blah ವರ್ಗ ಅಥವಾ ಯಾವುದೇ, ಮಾಡಬಹುದು ಆದ್ದರಿಂದ ಸಂತೋಷವನ್ನು ಇಲ್ಲಿದೆ

716
01:05:18,050 --> 01:05:25,140
ನಂತರ blah, blah, blah ಮತ್ತು ಕೆಲವು PHP ಕೋಡ್ ಮಾಡಿ ನಂತರ ಅಂತಿಮ DIV ಹಾಗೆ.

717
01:05:25,140 --> 01:05:36,460
ಈಗ, ನಾನು ಟಾಪ್ ಅಪ್ ನನ್ನ ಸಂತೋಷವನ್ನು DIV ಪಡೆಯಲು ಎಲ್ಲವನ್ನೂ ಈ ಮುದ್ರಿಸುವ ಎಂದು PHP ಮುದ್ರಿತ, ಕೆಳಭಾಗದಲ್ಲಿ DIV.

718
01:05:36,460 --> 01:05:43,510
ಈ ರೀತಿಯ ಸಂಭವಿಸಿದಾಗ ಹಾನಿಕಾರಕ, ಇದು ಬಹಳ ಸಾಮಾನ್ಯ

719
01:05:43,510 --> 01:05:47,930
ಫೈಲ್ ಕೆಳಭಾಗದಲ್ಲಿ ಕೇವಲ ಸ್ಟ್ರೇ ಹೊಸಸಾಲು.

720
01:05:47,930 --> 01:05:50,940
ನೀವು ಒಂದು ಒಪ್ಪಂದದ ದೊಡ್ಡ ಆಗುತ್ತದೆ ಎಂದು

721
01:05:50,940 --> 01:05:58,660
ನಿಮ್ಮ ಬ್ರೌಸರ್ ವಾಸ್ತವವಾಗಿ ಪರಿಗಣಿಸುತ್ತಾರೆ ತನಕ -

722
01:05:58,660 --> 01:06:03,880
>> ಹೇಗೆ ಕೆಲಸ ಪುನರ್ನಿರ್ದೇಶನಗಳು ಅಥವಾ ಮೂಲಭೂತವಾಗಿ ಯಾವುದೇ ಹೆಡರ್ ಕೆಲಸ,

723
01:06:03,880 --> 01:06:07,980
ನೀವು ವೆಬ್ಸೈಟ್ ನಿಮ್ಮ ಸಂಪರ್ಕವನ್ನು ಮತ್ತು ಎಲ್ಲಾ ಹೆಡರ್ಗಳು ಮತ್ತು ವಸ್ತುಗಳನ್ನು ಹಿಂದಕ್ಕೆ ಕಳುಹಿಸಿದಾಗ

724
01:06:07,980 --> 01:06:12,020
ಪ್ರತಿಕ್ರಿಯೆ 200 ಅಥವಾ ಪ್ರತಿಕ್ರಿಯೆ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಅಥವಾ ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ,

725
01:06:12,020 --> 01:06:18,230
ಡೇಟಾವನ್ನು ಮೊದಲ ಬೈಟ್ ಕಳುಹಿಸಲಾಗುತ್ತದೆ ರವರೆಗೆ ಹೆಡರ್ ಮಾತ್ರ ಮಾನ್ಯವಾಗಿರುವ.

726
01:06:18,230 --> 01:06:23,140
ನೀವು ಬಾರಿ ಸಾವಿರಾರು ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ, ಆದರೆ ತಕ್ಷಣ ಅಕ್ಷಾಂಶ ಮೊದಲ ಬೈಟ್ ಕಳುಹಿಸಲಾಗುತ್ತದೆ ಎಂದು ಮಾಡಬಹುದು

727
01:06:23,140 --> 01:06:26,120
ನೀವು ಮತ್ತೆ ಮರುನಿರ್ದೇಶಿಸಲು ಭಾವಿಸಲಾದ ಇಲ್ಲ.

728
01:06:26,120 --> 01:06:31,860
>> ನೀವು ಒಂದು ಕಡತದ ಕೆಳಭಾಗದಲ್ಲಿ ಸ್ಟ್ರೇ ಹೊಸಸಾಲು ಹೊಂದಿದ್ದರೆ

729
01:06:31,860 --> 01:06:37,260
ಮತ್ತು ಅವರ ಈ ಕಾರ್ಯವನ್ನು ಉಪಯೋಗಿಸಬಹುದು ಮತ್ತು ನಂತರ ನೀವು ಬಯಸುವ ಹೇಳಲು ಅವಕಾಶ -

730
01:06:41,580 --> 01:06:52,870
ಇದು index.php ಎಂದು ಇನ್ನೊಂದು ಫೈಲ್ ಹೇಳುತ್ತಾರೆ ಮತ್ತು ನೀವು ಏನನ್ನಾದರೂ require_once ಲೆಟ್ಸ್ -

731
01:06:52,870 --> 01:06:56,920
ಇದು ಒಂದು ಉತ್ತಮ ಉದಾಹರಣೆ ನಗರದ ಸಾಧ್ಯವಿಲ್ಲ.

732
01:06:56,920 --> 01:07:04,740
ಕೆಳಭಾಗದಲ್ಲಿ ಈ ಸಾಲಿನ ಪ್ರತಿಧ್ವನಿಸಿತು ಸೇರಿದಾಗ ಸಮಸ್ಯೆಯನ್ನು ಸಂಭವಿಸುತ್ತದೆ.

733
01:07:04,740 --> 01:07:08,660
ನೀವು ಇನ್ನೂ ಪ್ರತಿಧ್ವನಿಸಿತು ಎಂದು ಏನು ಬಯಸುವುದಿಲ್ಲ.

734
01:07:10,820 --> 01:07:15,700
ನೀವು ಕಾಣಿಸುವುದಿಲ್ಲ ಸಿಲುಕುವ ಏನು ಮೇಲೆ ಉದ್ದೇಶವನ್ನು ಹೊಂದಿರಲಿಲ್ಲ ಸಹ ಏನಾದರೂ ಪ್ರತಿಧ್ವನಿಸಿತು ಬಂದೆವು

735
01:07:15,700 --> 01:07:17,990
ಆದ್ದರಿಂದ ಈಗ ನೀವು ಯಾವುದೇ ಹೆಡರ್ ಕಳುಹಿಸಲು ಭಾವಿಸಲಾದ ಇಲ್ಲ

736
01:07:17,990 --> 01:07:20,030
ಮತ್ತು ನೀವು ದೂರುಗಳನ್ನು ಪಡೆಯಲು ನೀನು.

737
01:07:22,170 --> 01:07:24,420
ನೀವು ಆ ಮುಚ್ಚುವ ಟ್ಯಾಗ್ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.

738
01:07:24,420 --> 01:07:27,420
ನೀವು ಎಚ್ಟಿಎಮ್ಎಲ್ ಏನಾದರೂ ಮಾಡುವ ಯೋಜನೆ ಇದ್ದರೆ -

739
01:07:27,420 --> 01:07:30,490
ಮತ್ತು ಇಲ್ಲಿ DIV ಕೆಳಗೆ ಮಾಡಲು ಸರಿಯಾದ ಸಮಂಜಸವಾದ ನ ಯಾವುದೇ

740
01:07:30,490 --> 01:07:39,450
ತದನಂತರ ಈ ಹಂತದಲ್ಲಿ ನೀವು ಅಥವಾ ನೀವು ಸೇರಿಸಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಿಲ್ಲ ಮಾಡಬಹುದು.

741
01:07:39,450 --> 01:07:41,590
ಇದು ನಿಜವಾಗಿಯೂ ಅಪ್ರಸ್ತುತವಾಗುತ್ತದೆ.

742
01:07:41,590 --> 01:07:45,450
ಆದರೆ PHP ಸ್ಕ್ರಿಪ್ಟುಗಳಿಗೆ ಇದು ಮುಚ್ಚಲು ಅಪರೂಪದ ಇಲ್ಲಿದೆ.

743
01:07:45,450 --> 01:07:50,400
ಎಲ್ಲವನ್ನೂ PHP, ಸಂಪೂರ್ಣವಾಗಿ ಎಲ್ಲವೂ, ಯಾವಾಗ

744
01:07:50,400 --> 01:07:55,460
ನೀವು ಅದನ್ನು ಮುಚ್ಚಲು / ನೀವು ಮುಚ್ಚಿ ಮಾಡಬಾರದು ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.

745
01:08:02,030 --> 01:08:05,720
>> ತಂತಿಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ ಸಿ ಹೆಚ್ಚು ಒಳ್ಳೆಯದೆಂದು ಆಗಿದೆ

746
01:08:05,720 --> 01:08:09,470
PHP ನೀವು ಏಕೈಕ ಅಥವಾ ಎರಡು ಉದ್ದರಣ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಸೂಚಿಸಬಹುದು.

747
01:08:09,470 --> 01:08:12,820
ತಂತುವನ್ನು ನಿಮಗೆ "ಎಸ್ಕೇಪ್" ಸರಣಿಗಳು ಬಳಸುವಂತಿಲ್ಲ.

748
01:08:12,820 --> 01:08:17,640
ಸತತವಾಗಿ, blah, blah, blah ತಪ್ಪಿಸಿಕೊಳ್ಳಲು.

749
01:08:19,920 --> 01:08:24,010
ಆದ್ದರಿಂದ printf PHP ತುಂಬಾ ವಿರಳ.

750
01:08:24,010 --> 01:08:32,290
Pset 5 ನಿಮ್ಮನ್ನು sprintf ಅಥವಾ ಯಾವುದೇ ಬಳಸಲಾಗುತ್ತದೆ - ನಾನು ವಿಷಯ ಒಂದು ರೀತಿಯ ಮಾಡಲು ಬಯಸಿದರೆ ನನಗೆ printf ಬಳಸಲು ಎಂದು ಊಹೆ.

751
01:08:32,290 --> 01:08:36,060
ಆದರೆ ನೀವು 001.jpg ಮತ್ತು 002.jpg ಮಾಡಲು ಬಯಸುವ.

752
01:08:36,060 --> 01:08:40,300
ಆದ್ದರಿಂದ ವಿಷಯ ಆ ರೀತಿಯ ಗಾಗಿ ನಾನು printf ಬಳಸುವ ಪಠ್ಯ ಫಾರ್ಮಾಟ್ ಬಯಸುವ ಅಲ್ಲಿ.

753
01:08:40,300 --> 01:08:44,689
ಉಳಿದಂತೆ ನಾನು ತಂತುವಿನ ಪೋಣಿಸುವಿಕೆಯ ಬಳಸಬಹುದು.

754
01:08:44,689 --> 01:08:47,000
ನಾನು printf ಬಳಸಲು ಎಂದಿಗೂ.

755
01:08:49,229 --> 01:09:00,170
ನಾವು ಒಂದೇ ಉಲ್ಲೇಖಗಳು ಮತ್ತು ಜಂಟಿ ಉದ್ಧರಣಾ ಚಿಹ್ನೆಗಳನ್ನು ನಡುವಿನ ವಿವರಗಳು ವ್ಯತ್ಯಾಸ ಮಾಡುತ್ತಿದ್ದೇವೆ.

756
01:09:00,170 --> 01:09:07,490
ಅತಿದೊಡ್ಡ ವ್ಯತ್ಯಾಸವನ್ನು ಏಕ ಉದ್ಧರಣ, ಇದು ಅಕ್ಷರಶಃ ಮುದ್ರಿತ ಎಂದು ಆಗಿದೆ.

757
01:09:07,490 --> 01:09:15,390
PHP ಯಾವುದೇ ಚಾರ್ ಅಕ್ಷಾಂಶ ರೀತಿಯ, ಸಿ ಭಿನ್ನವಾಗಿ, ಈ ಸಮನಾಗಿರುತ್ತದೆ ಆದ್ದರಿಂದ.

758
01:09:15,390 --> 01:09:17,970
ಅವರು ಎರಡೂ ತಂತಿಗಳು ಆರ್.

759
01:09:17,970 --> 01:09:29,180
ಮತ್ತು ಏಕ ಉದ್ಧರಣ ತಂತಿಗಳ ಬಗ್ಗೆ ಸಂತೋಷವನ್ನು ನಾನು ಹೇಳಬಹುದು ಹೊಂದಿದೆ 'ಹಲೋ ವರ್ಲ್ಡ್!' blah, blah, blah,

760
01:09:29,180 --> 01:09:33,340
$ $ Wooo.

761
01:09:33,340 --> 01:09:38,260
ನಾನು ಇದು ಅಕ್ಷರಶಃ ಅದನ್ನು ಮುದ್ರಿಸಲು ನೋಡುತ್ತಾರೆ ಮುದ್ರಿಸಲು ಏನಾಗುತ್ತದೆ.

762
01:09:38,260 --> 01:09:40,680
ನಮ್ಮ ವಿಷಯವನ್ನು ಎಲ್ಲಾ ತೊಡೆದುಹಾಕಲು ಅವಕಾಶ.

763
01:09:40,680 --> 01:09:44,700
ಆದ್ದರಿಂದ $ str1 ಪ್ರತಿಧ್ವನಿಸಿದವು;

764
01:09:48,569 --> 01:09:56,570
, ಡಾಲರ್ ಸೈನ್ಸ್: ಇದು ಅಕ್ಷರಶಃ ಆ ಎಲ್ಲ ವಿಷಯಗಳ ಮುದ್ರಿತ

765
01:09:56,570 --> 01:09:58,770
ನೀವು ಹೊಸ ಸಾಲುಗಳನ್ನು ಆಗುತ್ತದೆ ಯಾವ backslash N, -

766
01:09:58,770 --> 01:10:01,500
ಆ ವಸ್ತುಗಳ ಎಲ್ಲಾ ಇದು ಅಕ್ಷರಶಃ ಮುದ್ರಿಸುತ್ತದೆ.

767
01:10:01,500 --> 01:10:05,650
ನೀವು ತಪ್ಪಿಸಿಕೊಳ್ಳಲು ಅವಶ್ಯಕತೆ ಮಾತ್ರ ವಿಷಯ ತಂತುವನ್ನು ಗಳು

768
01:10:05,650 --> 01:10:09,470
ಇಲ್ಲವಾದಲ್ಲಿ ಅದು ತಂತುವನ್ನು ಮುಚ್ಚುವ ವಿಶೇಷವೇನು ಯೋಚಿಸುವುದಿಲ್ಲ.

769
01:10:09,470 --> 01:10:15,050
ಜೋಡಿ ಉದ್ಧರಣ, ಸಂಪೂರ್ಣ ವಿಭಿನ್ನ.

770
01:10:20,300 --> 01:10:25,870
ನಾವು ಈಗಾಗಲೇ ವಾಕ್ಯ ಹೈಲೈಟ್ ಬಗ್ಗೆ ಭಯಾನಕ ತಪ್ಪು ಹೋಗಲು ಎಂಬುದನ್ನು ಮೇಲೆ ನಮಗೆ cluing ಇದೆ ನೋಡಿ.

771
01:10:25,870 --> 01:10:36,190
php.unique. ಸ್ಪಷ್ಟೀಕರಿಸದ ವೇರಿಯಬಲ್: wooo ಈ wooo ಎಂಬ ಮಾರ್ಪಡಿಸಬಹುದಾದ ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ.

772
01:10:36,190 --> 01:10:42,400
ಜೋಡಿ ಉದ್ಧರಣ ನೀವು ಮಾರ್ಪಡಿಸಬಹುದಾದ ಸೇರಿಸಲು ಅವಕಾಶ -

773
01:10:42,400 --> 01:10:52,730
$ ಹೆಸರು = "ರಾಬ್" ಹೇಳಲು ಲೆಟ್ಸ್;

774
01:10:52,730 --> 01:10:58,020
ಆದ್ದರಿಂದ "ಹಾಯ್, ನನ್ನ ಹೆಸರು ಹೆಸರು $ ಆಗಿದೆ!" ಪ್ರತಿಧ್ವನಿಸಿದವು;

775
01:10:58,020 --> 01:11:09,260
ಇದು ಒಂದು ವೇರಿಯೇಬಲ್ ಈ ಗುರುತಿಸುತ್ತದೆ.

776
01:11:09,260 --> 01:11:21,210
ನಾನು ರನ್ ಮಾಡುವಾಗ - ಮತ್ತು ನಾನು ಹೊಸಸಾಲು ಅಳವಡಿಸುವರು - ಹಾಯ್, ನನ್ನ ಹೆಸರು ರಾಬ್ ಆಗಿದೆ! ಮತ್ತು ಹಲೋ ವರ್ಲ್ಡ್!

777
01:11:21,210 --> 01:11:24,910
ನಾನು ಮೇಲಿನ wooo ಮುದ್ರಣದ ತೆಗೆದು ಎಂದಿಗೂ ಏಕೆಂದರೆ.

778
01:11:24,910 --> 01:11:30,020
ನೀವು ಮಾಡಬಹುದು 1 ಮುಂದಿನ ಹಂತದ ಇಲ್ಲ.

779
01:11:30,020 --> 01:11:39,250
$ ಅರೇ = [1, 2, 3];

780
01:11:39,250 --> 01:11:43,270
ನಾನು ರಚನೆಯ ಮೊದಲ ಸೂಚ್ಯಂಕ ಮುದ್ರಿಸಲು ಬಯಸಿದರೆ?

781
01:11:43,270 --> 01:11:45,150
ನೀವು $ ರಚನೆಯ [0] ಮಾಡಿ.

782
01:11:45,150 --> 01:11:49,280
ವಾಕ್ಯ ಹೈಲೈಟ್ ಒಂದು ಸುಳಿವು ಹೊಂದಿದೆ. ಈ ಮಾಡಲಿದ್ದೀಯಾ ಇದೆ?

783
01:11:52,320 --> 01:11:54,510
php.unique.

784
01:11:54,510 --> 01:11:59,860
ಹಾಯ್, ನನ್ನ ಹೆಸರು 1! ಇದು ನಾನು ಬೇಕಾಗಿದ್ದಾರೆ ಏನು ಅಲ್ಲ.

785
01:11:59,860 --> 01:12:05,050
ಸಿಂಟ್ಯಾಕ್ಸ್ ಹೈಲೈಟ್ ನನಗೆ ಸುಳ್ಳು ಹೇಳಿದ್ದಾನೆ.

786
01:12:05,050 --> 01:12:13,020
ಲೆಟ್ಸ್ ಪ್ರಯತ್ನಿಸಿ 'ಒಂದು' -> 1, 'ಬಿ' -> 2.

787
01:12:18,450 --> 01:12:21,440
ನಾನು ಇದನ್ನು ಬರೆಯಬೇಕು ಎಂದು ಹೇಗೆ.

788
01:12:26,350 --> 01:12:32,160
ಅನಿರೀಕ್ಷಿತ ಏಕ ಉದ್ಧರಣ (blah, blah, blah, blah, blah T_ENCAPSED).

789
01:12:32,160 --> 01:12:41,780
ಕಲ್ಪನೆಯನ್ನು ರಚನೆಯ ಭಾಗವಾಗಿ ಈ ಗುರುತಿಸುವುದು ದೊರೆಯದಿದ್ದಲ್ಲಿ ಹೊಂದಿದೆ.

790
01:12:41,780 --> 01:12:46,620
ಇದು ಅಕ್ಷರ ಸೂಚ್ಯಂಕದೊಡನೆ ರಚನೆಯ ಈ ಮಾನ್ಯತೆ ಅಲ್ಲ.

791
01:12:46,620 --> 01:12:49,870
ನೀವು, ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ಸುತ್ತಲೂ ಹಾಗೆ ಬಯಸುವ

792
01:12:49,870 --> 01:12:54,730
ಈಗ ಈ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ನಲ್ಲಿ ಯಾವುದೇ, ಪ್ರಕ್ಷೇಪಿಸಲು ಕಾಣಿಸುತ್ತದೆ

793
01:12:54,730 --> 01:13:00,340
ಇದು ನಾವು ಮಾಂತ್ರಿಕವಾಗಿ ಬಲ ಸ್ಥಳಗಳು ಈ ಅಸ್ಥಿರಗಳು ಅಳವಡಿಸುವ ಬಳಸುವ ಪದ.

794
01:13:00,340 --> 01:13:04,280
ಈಗ php.unique, ಈ ರೀತಿ, ಮತ್ತು ಹಾಯ್, ನನ್ನ ಹೆಸರು 1! ಎಂದು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ

795
01:13:04,280 --> 01:13:07,720
ಅಥವಾ ಹಾಯ್, ನನ್ನ ಹೆಸರು ರಾಬ್ ಆಗಿದೆ!

796
01:13:14,110 --> 01:13:23,130
ತಂತುವನ್ನು ಬಗ್ಗೆ ಸಂತೋಷವನ್ನು ಭಾಸವಾಗುತ್ತದೆ ಒಂದು ವಿಷಯ ಎಂದು -

797
01:13:23,130 --> 01:13:28,480
ಒಳತೂರಿದ ಕೆಲವು ಬೆಲೆ ಇಲ್ಲ.

798
01:13:30,520 --> 01:13:35,100
ನೀವು ಎರಡು ಉಲ್ಲೇಖಗಳು ಬಳಸಿದರೆ, ವ್ಯಾಖ್ಯಾನಕಾರರು, ಈ ಸಾಲನ್ನು ಮೇಲೆ ಹೋಗಲು ಹೊಂದಿದೆ

799
01:13:35,100 --> 01:13:41,500
, ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು "ಓಹ್, ಇಲ್ಲಿ ಒಂದು ವೇರಿಯೇಬಲ್ ನ. ಈಗ ನಾನು ವ್ಯತ್ಯಯ ಮತ್ತು ಇಲ್ಲಿ ಸೇರಿಸಲು ಕ್ರಮಿಸಬೇಕಾಗುತ್ತದೆ."

800
01:13:41,500 --> 01:13:48,930
ನೀವು ಯಾವುದೇ ಅಸ್ಥಿರ ಬಳಸಬೇಡಿ ಸಹ,

801
01:13:48,930 --> 01:13:52,220
ಈ ಎರಡು ಉಲ್ಲೇಖಗಳು ಒಳಗೆ ಏನೂ, ಪ್ರಕ್ಷೇಪಿಸಲು ಅಗತ್ಯವಿದೆ

802
01:13:52,220 --> 01:13:56,800
ಇದು ಜೋಡಿ ಉದ್ಧರಣ ಮೇಲೆ ಹೋಗಲು ಅಗತ್ಯವಿದೆ ಏಕೆಂದರೆ ಆದರೆ ಇನ್ನೂ ನಿಧಾನ ಎಂದು

803
01:13:56,800 --> 01:14:00,130
ಪ್ರಕ್ಷೇಪಿಸಲು ಅಗತ್ಯವಿದೆ ವಸ್ತುಗಳನ್ನು ಹುಡುಕುತ್ತಿರುವ.

804
01:14:00,130 --> 01:14:05,360
ಏನೂ ಪ್ರಕ್ಷೇಪಿಸಲು ಅಗತ್ಯವಿದೆ ಆದ್ದರಿಂದ ಏಕ ಉದ್ಧರಣ, ಸ್ವಲ್ಪ ವೇಗವಾಗಿ ಮಾಡಬಹುದು

805
01:14:05,360 --> 01:14:15,650
ಮತ್ತು ನಾನು 'ಹಾಯ್, ನನ್ನ ಹೆಸರು', ಒಂದೇ ಉಲ್ಲೇಖಗಳನ್ನು ಬಳಸಲು ಸಹ ಒಲವು. $ ರಚನೆಯ ['ಒಂದು'] ಹೇಗಾದರೂ.

806
01:14:15,650 --> 01:14:20,430
ನಾವು ಮೊದಲು ಯಾವುದೆಂದು ಸಮನಾಗಿರುತ್ತದೆ ಎಂದು ವಿಶೇಷವೇನು.

807
01:14:24,840 --> 01:14:28,440
ಆದರೆ ಆದ್ಯತೆ ಒಂದು ಮ್ಯಾಟರ್ ನ.

808
01:14:28,440 --> 01:14:34,750
ನೀವು PHP ಬಳಸುತ್ತಿದ್ದರೆ, ನೀವು ಬಹುಶಃ ವೇಗ ವ್ಯತ್ಯಾಸವು ಬಗ್ಗೆ ಹೆದರುವುದಿಲ್ಲ.

809
01:14:34,750 --> 01:14:39,480
ಆರಂಭಗೊಳ್ಳಬೇಕು ಅವರನ್ನು ಕಾರಣ ಸಾಕಷ್ಟು ಇಲ್ಲ.

810
01:14:39,480 --> 01:14:43,030
>> ಯಾವುದೇ ಅಂತಿಮ ಪ್ರಶ್ನೆಗಳು?

811
01:14:47,430 --> 01:14:51,710
>> ನಾವು ವಾಸ್ತವವಾಗಿ ಸಹ ಇದು ಎಲ್ಲಾ ಮೂಲಕ ಆಗಲಿಲ್ಲ, ಆದರೆ ಈ ವಿಷಯವನ್ನು ನೀರಸ ಆಗಿತ್ತು.

812
01:14:51,710 --> 01:14:59,080
ನೀವು HTML ವ್ಯವಹರಿಸುವಾಗ ಮಾಡಿದಾಗ PHP ಯಲ್ಲಿ ರೀತಿಯ ನೈಸ್ ಎಂದು ಕಡೆಯದಾಗಿ, ಆಗಿದೆ

813
01:14:59,080 --> 01:15:06,450
ನೀವು ವೇರಿಯಬಲ್ ಮುದ್ರಣಕಾರ್ಯಕ್ಕಾಗಿ ಇದು ಒಂದು ಬಿಟ್, ಆದ್ದರಿಂದ ಸಂತೋಷವನ್ನು ಶಾರ್ಟ್ಕಟ್ ವಾಕ್ಯ ಬಳಸಿ.

814
01:15:32,400 --> 01:15:36,730
ಇಲ್ಲಿ PHP ಪುಟ್ಟಿಂಗ್ ಇಲ್ಲದೆ, ಈ ಸಣ್ಣ ಟ್ಯಾಗ್ಗಳನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ.

815
01:15:36,730 --> 01:15:44,330
ಅಧಿಕೃತವಾಗಿ PHP 5.4 ರ, ಈ ವಿನಂತಿಸಲಾಗಿದೆ.

816
01:15:44,330 --> 01:15:48,640
ನೀವು PHP ಇರಿಸಲು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ.

817
01:15:48,640 --> 01:15:55,770
ಈ ಇನ್ನೂ <ಜೊತೆ ಆದ್ದರಿಂದ ಸಣ್ಣ ಟ್ಯಾಗ್ಗಳನ್ನು ಬೆಂಬಲಿತವಾಗಿದೆ? = ಇನ್ನೂ ನಿಖರವಾಗಿ ಉತ್ತಮವಾಗಿವೆ.

818
01:15:55,770 --> 01:16:02,480
ಇದು ಬೆಂಬಲ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ನೀವು ಬಯಸುವ ನೀವು ಈ ಬಳಸಬಹುದು, ಮತ್ತು ಅವರು ಬಹಳ ಅನುಕೂಲಕರ ಆರ್.

819
01:16:02,480 --> 01:16:05,700
>> ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು?

820
01:16:07,780 --> 01:16:09,270
ಎಲ್ಲಾ ಸರಿ.

821
01:16:10,840 --> 01:16:13,800
>> , ಸ್ಯಾನ್ ಡಿಯಾಗೋ ಕ್ಲಾಸಿ ಸ್ಟೇ.

822
01:16:13,800 --> 01:16:16,070
[Chuckles]

823
01:16:18,620 --> 01:16:22,660
ಬೈ. [ನಗು]

824
01:16:24,350 --> 01:16:28,470
[ಚಪ್ಪಾಳೆ] [ನಗು]

825
01:22:46,460 --> 01:22:49,460
>> [CS50.TV]