1
00:00:00,000 --> 00:00:05,340

2
00:00:05,340 --> 00:00:07,370
>> ಡೌಗ್ LLOYD: ನಾವು ಬಂದಿದೆ
ಸಿ ಕೆಲಸ ಬಹಳಷ್ಟು ಮಾಡಿದ,

3
00:00:07,370 --> 00:00:09,536
ಮತ್ತು C ಒಂದು ನಿಜವಾಗಿಯೂ ಸುಂದರವಾಗಿದೆ
ಭಾಷೆ ಇದು ನೀವು ನೀಡುತ್ತದೆ ಏಕೆಂದರೆ

4
00:00:09,536 --> 00:00:12,840
ನಿಜವಾಗಿಯೂ ಧುಮುಕುವುದಿಲ್ಲ ಸಾಮರ್ಥ್ಯವನ್ನು
ನಿಮ್ಮ ಯೋಜನೆಗಳನ್ನು ಕಡಿಮೆ ಮಟ್ಟದ.

5
00:00:12,840 --> 00:00:16,810
ನಾವು ಕೆಲಸಗಳನ್ನು ಪಡೆಯಲು
ಮ್ಯಾನಿಪುಲೇಟ್ ನಿಜವಾಗಿಯೂ ನಿಮಿಷ

6
00:00:16,810 --> 00:00:18,800
ಮೆಮೊರಿ ಪ್ರತ್ಯೇಕ ಬೈಟ್ಗಳು.

7
00:00:18,800 --> 00:00:21,420
ನಿಜವಾಗಿಯೂ ಪಾಯಿಂಟರ್ಸ್ ಸ್ಮರಿಸುತ್ತಾರೆ
ನಮಗೆ ಆ ನಮ್ಯತೆ ಅವಕಾಶ.

8
00:00:21,420 --> 00:00:25,260
>> ಆದರೆ ನಾವು ಯಾವಾಗಲೂ ಹೊಂದಿರುವ ಬೇಕು
ವಿವರ ಆ ದಂಡ ಧಾನ್ಯ ಮಟ್ಟದ

9
00:00:25,260 --> 00:00:26,820
ನಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ?

10
00:00:26,820 --> 00:00:28,210
ಬಹುಶಃ ಇಲ್ಲ, ಬಲ?

11
00:00:28,210 --> 00:00:30,376
ಮತ್ತು ನಾವು ನೀನು
ನಡುವಿನ ತುಲನೆಯನ್ನು

12
00:00:30,376 --> 00:00:32,911
ನಿಜವಾಗಿಯೂ ಮಾಡಲು ಸಾಧ್ಯವಾಯಿತು
ನಿಮಿಷದ ಸಂಗತಿಗಳು ಮತ್ತು ನಿಜವಾಗಿಯೂ

13
00:00:32,911 --> 00:00:35,910
ನಾವು ಯೋಚಿಸುವುದು ಹೊಂದಿಲ್ಲ ಎಂದು ದೊಡ್ಡ ವಸ್ತುಗಳನ್ನು
ಬಗ್ಗೆ, ನಾವು ಜಾರಿಗೆ ಇಲ್ಲ

14
00:00:35,910 --> 00:00:40,290
ಈ ನಿಜವಾಗಿಯೂ ದೊಡ್ಡ ಆಲೋಚನೆಗಳನ್ನು ವೇಳೆ
ಅವರು ಈಗಾಗಲೇ, ನಮಗೆ ನಿರ್ಮಿಸಲಾಯಿತು ನೀವು

15
00:00:40,290 --> 00:00:43,980
ಸಾಮಾನ್ಯವಾಗಿ ದೊಡ್ಡ ನಿರ್ಮಾಣಕ್ಕಾಗಿ
ಕಾರ್ಯಕ್ರಮಗಳು ಅಥವಾ ದೊಡ್ಡ ಯೋಜನೆಗಳು,

16
00:00:43,980 --> 00:00:49,130
ನಾವು ಬಹುಶಃ ಬದಿಯಲ್ಲಿ ತಪ್ಪುಮಾಡು ನೀನು
ಹೆಚ್ಚು ಭಾಷೆ ವಿಷಯವನ್ನು ನಿರ್ಮಿಸಿದ ನಂತರ

17
00:00:49,130 --> 00:00:51,300
ನಮಗೆ, ಬದಲಿಗೆ ಹೊಂದುವ
ಕೆಳಮಟ್ಟದ ಸ್ಟಫ್.

18
00:00:51,300 --> 00:00:53,970
PHP ನಿಜವಾಗಿಯೂ ಬರುತ್ತದೆ ಮತ್ತು ಇಲ್ಲಿದೆ.

19
00:00:53,970 --> 00:00:58,200
>> ಈಗ, ಕಾರಣಗಳಲ್ಲಿ ಒಂದು
ನಾವು CS50 ಪಿಎಚ್ಪಿ ಕಲಿಸುವ

20
00:00:58,200 --> 00:01:01,020
ಇದು ಅತೀವವಾಗಿ ಸ್ಫೂರ್ತಿ ವಿಶೇಷವೇನು ಎಂದು
ಸಿ ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ನನ್ನ ಅಭಿಪ್ರಾಯದಲ್ಲಿ,

21
00:01:01,020 --> 00:01:05,140
ಎರಡು ನಿಜವಾಗಿಯೂ ಇವೆ
ಮೂಲಗಳು ಭಾಷೆಗಳು

22
00:01:05,140 --> 00:01:08,200
ಇತ್ತೀಚಿನ ದಿನಗಳಲ್ಲಿ ತುಂಬಾ ಸಾಮಾನ್ಯವಾಗಿದೆ.

23
00:01:08,200 --> 00:01:10,110
ಸಿ ಮತ್ತು ಲಿಸ್ಪ್.

24
00:01:10,110 --> 00:01:13,280
ಅವರು ಮೂಲಗಳು ಭಾಷೆಗಳಲ್ಲಿ ನೀವು
ಪ್ರತಿಯೊಂದು ಆಧುನಿಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಕಾರಣ

25
00:01:13,280 --> 00:01:17,380
ಬೆಳೆದಂತೆ ಭಾಷೆ
ನಂತರ ಸ್ಫೂರ್ತಿ

26
00:01:17,380 --> 00:01:20,330
ಒಂದು ಅಥವಾ ಇತರ syntactically ಮೂಲಕ.

27
00:01:20,330 --> 00:01:26,160
ಪಿಎಚ್ಪಿ syntactically ಹೋಲುತ್ತದೆ
ಸಿ, ಯೋಜನೆ ಮುಂತಾದ ಭಾಷೆಗಳಲ್ಲಿ ಆದರೆ,

28
00:01:26,160 --> 00:01:27,900
ಉದಾಹರಣೆಗೆ, ಇದು
ನೀವು ಕೇಳಿರಬಹುದು

29
00:01:27,900 --> 00:01:32,070
ಬಹಳವಾಗಿ ಭಾಷೆ ಸ್ಫೂರ್ತಿ
ಹಳೆಯ ಭಾಷೆ ಇದು ಎಂದು ಲಿಸ್ಪ್,.

30
00:01:32,070 --> 00:01:34,220
>> ನಾವು ಕಲಿಸಲು ವಿವೇಚನೆಯ
CS50 ರಲ್ಲಿ ಪಿಎಚ್ಪಿ ಎಂದು,

31
00:01:34,220 --> 00:01:37,730
ಮೂಲಭೂತವಾಗಿ ಸಿ ತಿಳಿದುಕೊಂಡು
ಈ ಹಂತದಲ್ಲಿ ಮಾಡುವಂತೆ,

32
00:01:37,730 --> 00:01:41,280
ನೀವು ನೀಡುತ್ತದೆ ಪಡೆದ ಪಿಎಚ್ಪಿ,
ಹೆಚ್ಚಿನ ಮಟ್ಟದ ಕೆಲಸಗಳನ್ನು ಸಾಮರ್ಥ್ಯವನ್ನು

33
00:01:41,280 --> 00:01:44,710
ಸಿ ಹೆಚ್ಚಿನ, ಅಲ್ಲ
ಒಂದು ಅಡಚಣೆಯಿಂದ ಹೆಚ್ಚು,

34
00:01:44,710 --> 00:01:48,230
ನೀವು ಈಗಾಗಲೇ ಹೊಂದಿರುವ ಕಾರಣ
ವಾಕ್ಯ ಮೂಲ ಕಲ್ಪನೆಯನ್ನು.

35
00:01:48,230 --> 00:01:50,590
ಸಿ ಬಹುತೇಕ ಕಾಲ ಸುತ್ತುತ್ತಿರುತ್ತದೆ
ಈ ಹಂತದಲ್ಲಿ 45 ವರ್ಷಗಳ.

36
00:01:50,590 --> 00:01:52,780
ಪಿಎಚ್ಪಿ 20 ವರ್ಷಗಳ ಕಾಲ ಸುತ್ತುತ್ತಿರುತ್ತದೆ.

37
00:01:52,780 --> 00:01:57,080
ಮತ್ತು 25 ವರ್ಷಗಳಲ್ಲಿ
, ಪ್ರೋಗ್ರಾಮರ್ಗಳು ನಡುವೆ

38
00:01:57,080 --> 00:02:01,540
ನಿರ್ಣಯಿಸಿತು ಅವರು ಹೆಚ್ಚು ಎಂದು
ಬದಲಿಗೆ, ಉನ್ನತ ಮಟ್ಟದ ಸಾಮರ್ಥ್ಯಗಳನ್ನು

39
00:02:01,540 --> 00:02:04,970
ಮತ್ತು ತಪ್ಪುಗಳು ಮತ್ತು ಹೋರಾಟಗಳು
ನಡುವೆ 20 ವರ್ಷಗಳ

40
00:02:04,970 --> 00:02:08,210
PHP ಮತ್ತು ಇತರ ಆಧುನಿಕ ಭಾಷೆಗಳು ಕಾರಣವಾಯಿತು.

41
00:02:08,210 --> 00:02:11,039
>> ಪಿಎಚ್ಪಿ ಒಂದು ದೊಡ್ಡ ಆಯ್ಕೆ
ಸಾಫ್ಟ್ವೇರ್ ಭಾಷೆಯನ್ನು

42
00:02:11,039 --> 00:02:14,042
ಫಾರ್ allow-- ಎಂದು
ಅಲ್ಲಿ ನೀವು ಆ ತಂತ್ರಾಂಶ

43
00:02:14,042 --> 00:02:16,250
ಆ ಕೆಲಸಗಳನ್ನು ಮಾಡಬೇಕಾಗುತ್ತದೆ
ಸಿ ವಾಸ್ತವವಾಗಿ ಸಂಕೀರ್ಣವಾಗಿದೆ.

44
00:02:16,250 --> 00:02:18,480
ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ಕೆಲಸ
ಸಿ ತಂತಿಯನ್ನು

45
00:02:18,480 --> 00:02:21,709
ಏಕೆಂದರೆ, ಬಹಳ ಸಂಕೀರ್ಣವಾಗಿದೆ
ನಾವು ತಿಳಿದಿರುವಂತೆ, ಸಿ ತಂತಿ

46
00:02:21,709 --> 00:02:23,250
ನಿಜವಾಗಿಯೂ ಕೇವಲ ಅಕ್ಷರಗಳನ್ನು ಸರಣಿಗಳಿವೆ.

47
00:02:23,250 --> 00:02:25,230
ಇದು ಒಂದು ಅಂತರ್ನಿರ್ಮಿತ ಮಾಹಿತಿ ಪ್ರಕಾರ ಅಲ್ಲ.

48
00:02:25,230 --> 00:02:28,220
ಅಥವಾ ಬಹುಶಃ ಹೆಚ್ಚು ಮೂಲಭೂತವಾಗಿ
ನಾವು ಸಿ ಒಳಗೊಂಡಿರುವುದಿಲ್ಲ ಏನೋ,

49
00:02:28,220 --> 00:02:30,360
ನೀವು ಮಾಡಬೇಕಾದ್ದು ಏನು
ಕೆಲವು ಕಂಪ್ಯೂಟರ್ ನೆಟ್ವರ್ಕಿಂಗ್?

50
00:02:30,360 --> 00:02:30,860
ಆಯ್ತು?

51
00:02:30,860 --> 00:02:34,920
>> ಸಿ ಅದನ್ನು ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿದೆ, ಆದರೆ ಅದು ಇಲ್ಲಿದೆ
ರಹಸ್ಯ ಮತ್ತು ವಾಸ್ತವವಾಗಿ ಮಾಡಲು ಕಷ್ಟವಾದ.

52
00:02:34,920 --> 00:02:37,580
ಇದು ವೇಳೆ ಚೆನ್ನಾಗಿ ಎಂದು
ಭಾಷೆ ಒಂದು ಅಂತರ್ನಿರ್ಮಿತ, ಅವಕಾಶವಿದ್ದರೆ

53
00:02:37,580 --> 00:02:38,910
ನೆಟ್ವರ್ಕಿಂಗ್ ಕಾರ್ಯಗತಗೊಳಿಸಲು?

54
00:02:38,910 --> 00:02:43,420
ಮತ್ತು ಪಿಎಚ್ಪಿ ಮಾಡುತ್ತದೆ ಒಂದು ಭಾಷೆ,
ಅಥವಾ, ಎಂದು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸುಗಮಗೊಳಿಸುತ್ತದೆ.

55
00:02:43,420 --> 00:02:47,740
ನಾನು ಹೇಳಿದಂತೆ, ಪಿಎಚ್ಪಿ ಅತ್ಯಂತ ಹೆಚ್ಚು ಸ್ಫೂರ್ತಿ
ಸಿ ವಾಕ್ಯ ಹೋಲುತ್ತದೆ.

56
00:02:47,740 --> 00:02:51,760
ಮತ್ತು ಆದ್ದರಿಂದ ಆಶಾದಾಯಕವಾಗಿ ಮಾಡಬೇಕು
ಒಂದರಿಂದ ಇತರ ಪರಿವರ್ತನೆ

57
00:02:51,760 --> 00:02:54,710
ಕೆಲವು ಹೆಚ್ಚು ಸ್ವಲ್ಪ ಮೃದುವಾದ
ಇತರ ಭಾಷೆಗಳಿಗೆ ಇರಬಹುದು.

58
00:02:54,710 --> 00:02:58,800
>> PHP ಬರೆಯಲು ಪ್ರಾರಂಭಿಸಲು, ಕೇವಲ ತೆರೆಯುತ್ತದೆ
ಪಿಎಚ್ಪಿ ಕಡತದಲ್ಲಿ ವಿಸ್ತರಣೆಯೊಂದಿಗೆ ಕಡತ.

59
00:02:58,800 --> 00:03:00,670
ತಾಂತ್ರಿಕವಾಗಿ ಈ ಅಲ್ಲ
ವಾಸ್ತವವಾಗಿ ಅಗತ್ಯವಿದೆ,

60
00:03:00,670 --> 00:03:04,495
ಆದರೆ ನೀವು ವಾಕ್ಯ ವಿಷಯಗಳನ್ನು ಬಯಸಿದರೆ
ಆ ರೀತಿಯ ಆದ್ದರಿಂದ, ಐಡಿಇ ಹೈಲೈಟ್

61
00:03:04,495 --> 00:03:07,620
ಹೆಸರುಗಳು, ಅಥವಾ ವೇರಿಯಬಲ್ ಹೆಸರುಗಳು, ಕಾರ್ಯಗಳು,
ನೀವು ಭಾಷೆಯ ಕೀವರ್ಡ್ಗಳನ್ನು ಗೊತ್ತು

62
00:03:07,620 --> 00:03:10,090
ಒಂದು ಹೈಲೈಟ್
ನಿರ್ದಿಷ್ಟ ಬಣ್ಣ, ನೀವು ಸಾಮಾನ್ಯವಾಗಿ

63
00:03:10,090 --> 00:03:14,020
ನಿಮ್ಮ ಕಡತಗಳನ್ನು ಹೆಸರಿಸಲು ಬಯಸುವ
ನಿರ್ದಿಷ್ಟ ಕಡತ ವಿಸ್ತರಣೆಯನ್ನು.

64
00:03:14,020 --> 00:03:18,430
ನಾವು ಒಂದು ಪಿಎಚ್ಪಿ ನಮ್ಮ ಫೈಲ್ ಎಂಬ ಬಂದಿದೆ
ವಿಸ್ತರಣೆ, ಆದರೆ ಸಹ ಪಿಎಚ್ಪಿ,

65
00:03:18,430 --> 00:03:23,310
ನಾವು ಬರೆಯುವುದು ಎಲ್ಲಾ ಪಿಎಚ್ಪಿ ಕೋಡ್
ಫೈಲ್ ಈ ಪಿಎಚ್ಪಿ ಮೇಲ್ಛಾವಣಿಗೆ ಹೊಂದಿದೆ

66
00:03:23,310 --> 00:03:25,190
ನಾವು ನೋಡಿ ಎಲ್ಲೆಗಳನ್ನು
ಇಲ್ಲಿ ತೆರೆಯಲ್ಲಿ.

67
00:03:25,190 --> 00:03:27,910
ಕೋನ ಆವರಣ? ಪಿಎಚ್ಪಿ ಆರಂಭಿಸಲು.

68
00:03:27,910 --> 00:03:30,860
ನಂತರ ನಮ್ಮ ಪಿಎಚ್ಪಿ ಎಲ್ಲಾ ಬರೆಯಲು
ನಾವು ನಡುವೆ ಬಯಸುವ ಕೋಡ್.

69
00:03:30,860 --> 00:03:32,260
ತದನಂತರ?

70
00:03:32,260 --> 00:03:34,710
ಕೋನ ಆವರಣ ಮುಚ್ಚಲು.

71
00:03:34,710 --> 00:03:37,170
>> ಈ, ನಂತರ ಮಾಡದಿದ್ದರೆ
ತೀರುತ್ತದೆ ವಿಶೇಷವೇನು?

72
00:03:37,170 --> 00:03:38,170
ಇದು ಕುಸಿತಕ್ಕೆ ಹಿಂದಿರುಗಬಹುದೆಂದು.

73
00:03:38,170 --> 00:03:39,410
ಇದು ಹಿಂದಿರುಗಬಹುದೆಂದು
ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಹಾಳು.

74
00:03:39,410 --> 00:03:41,440
ಆದರೆ ಹೊಂದಿವೆ ಹಿಂದಿರುಗಬಹುದೆಂದು
ನಾವು ಬಯಸುವ ಪರಿಣಾಮ.

75
00:03:41,440 --> 00:03:44,540
ತೀರುತ್ತದೆ ಏನು, ನಿಜವಾಗಿಯೂ, ಆಗಿದೆ
ನಾವು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಈ ಪ್ರೋಗ್ರಾಂ ಎಂದು,

76
00:03:44,540 --> 00:03:50,330
ಎಲ್ಲವೂ ಆ ಎಲ್ಲೆಗಳನ್ನು ನಡುವೆ
ಶಬ್ದಶಃ ಮುದ್ರಿತ ಏರಲಿದೆ.

77
00:03:50,330 --> 00:03:52,210
ಇದು ಹಿಂದಿರುಗಬಹುದೆಂದು
ವಾಸ್ತವವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ,

78
00:03:52,210 --> 00:03:56,010
ಇದು ವಿಶೇಷವೇನು ಕೇವಲ
ಶಬ್ದಶಃ ಮುದ್ರಿಸುತ್ತದೆ.

79
00:03:56,010 --> 00:03:57,320
>> ಈಗ ಏಕೆ ಸಂದರ್ಭದಲ್ಲಿ?

80
00:03:57,320 --> 00:04:00,416
ಆದ್ದರಿಂದ ಸಿ ಯಂತೆ ಏನು
ಒಂದು ಸಂಕಲನ ಭಾಷೆಯಾಗಿ.

81
00:04:00,416 --> 00:04:03,040
ನೀವು ಬಹುಶಃ ಪರಿಚಿತವಾಗಿರುವ
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು ಮಾಡುವ ಹಂತ,

82
00:04:03,040 --> 00:04:07,820
ಸಿ ಕಡತಗಳನ್ನು ಮತ್ತು H ಕಡತಗಳನ್ನು ತಿರುವು
ಮೇಕಪ್ ಒಂದೇ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ,

83
00:04:07,820 --> 00:04:11,130
ನಿರ್ದಿಷ್ಟವಾಗಿ ಬಳಸಿ
ನಮ್ಮ ಕಂಪೈಲರ್ ಎಂದು ಖಣಿಲು.

84
00:04:11,130 --> 00:04:13,030
ಪಿಎಚ್ಪಿ, ಆದರೂ, ಇಲ್ಲ
ಈ ಸಮಾನ ಹೊಂದಿವೆ.

85
00:04:13,030 --> 00:04:15,600
ಪಿಎಚ್ಪಿ ಒಂದು ಎಂದು ಏನನ್ನು
ತಿಳಿಯುತ್ತದೆ ಭಾಷೆ.

86
00:04:15,600 --> 00:04:16,760
ಮತ್ತು ಏನು?

87
00:04:16,760 --> 00:04:20,680
>> ಅಲ್ಲದೆ, ಇದು ನಾವು ಪರಿವರ್ತಿಸಲು ಹೊಂದಿಲ್ಲ ಎಂದರ್ಥ
ಸೊನ್ನೆಗಳು ಮತ್ತು ಬಿಡಿಗಳ ನಮ್ಮ ಮೂಲ ಕೋಡ್

88
00:04:20,680 --> 00:04:21,470
ಮೊದಲೇ.

89
00:04:21,470 --> 00:04:23,900
ಬದಲಿಗೆ, ಒಂದು ಪ್ರೋಗ್ರಾಂ ಇಲ್ಲ,
ಇದು ಕರೆಯಲಾಗುತ್ತದೆ

90
00:04:23,900 --> 00:04:29,771
PHP ಮತ್ತು ಅರ್ಥ ಮಾಡಿಕೊಳ್ಳುವ ಪಿಎಚ್ಪಿ,
ರೀತಿಯ ಫ್ಲೈ ಅದನ್ನು ಮಾಡಬಹುದು.

91
00:04:29,771 --> 00:04:32,520
, ನಿಜವಾಗಿಯೂ ನಿಖರವಾಗಿ ನಿಖರ ಅಲ್ಲ
ಆದರೆ ಒಂದು ಒಳ್ಳೆಯ ಸಾದೃಶ್ಯದ ಇಲ್ಲಿದೆ

92
00:04:32,520 --> 00:04:33,760
ಆಫ್ ಏನು ಸಂಭವಿಸುತ್ತಿದೆ.

93
00:04:33,760 --> 00:04:37,230
ಇದು ಆ ವ್ಯಾಖ್ಯಾನಿಸುವ ವಿಶೇಷವೇನು
ಹಾರಾಡುತ್ತ ಸೊನ್ನೆಗಳ ಮತ್ತು ಬಿಡಿಗಳ.

94
00:04:37,230 --> 00:04:40,160
ಮತ್ತು ಹಾಗಾಗಿ ಅದು ಗೊತ್ತಿಲ್ಲ
ಹೇಗೆ ಏನೋ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು,

95
00:04:40,160 --> 00:04:42,800
ಅದು ಗೊತ್ತಿಲ್ಲ ವೇಳೆ ಹೇಗೆ
ಪ್ರಕ್ರಿಯೆ ಪಿಎಚ್ಪಿ, ನೀವು ಬಹುಶಃ

96
00:04:42,800 --> 00:04:44,680
ಸರಿ, ಆ ಪಠ್ಯ ಹಾಕಲು ಬೇಕಾಗಿದ್ದಾರೆ?

97
00:04:44,680 --> 00:04:48,960
>> ನೀವು ಬಹುಶಃ ಕೋಡ್ ಹಾಕಲು ಬೇಕಾಗಿದ್ದಾರೆ
ಅಲ್ಲಿ, ಇದು PHP ಯಲ್ಲಿ ನಡುವೆ ಅಲ್ಲ ಸಹ

98
00:04:48,960 --> 00:04:50,035
ಪಿಎಚ್ಪಿ ಡಿಲಿಮಿಟರ್.

99
00:04:50,035 --> 00:04:51,910
But-- ಆದ್ದರಿಂದ ಹಿಂದಿರುಗಬಹುದೆಂದು
ನೀವು ಅದನ್ನು ತೆಗೆದು ಹಾಕಲು,

100
00:04:51,910 --> 00:04:53,576
ಇದು ಮೂಲತಃ ತಿರಸ್ಕರಿಸಲು ಹೋಗುವುದಿಲ್ಲ.

101
00:04:53,576 --> 00:04:55,550
ಆದ್ದರಿಂದ ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು
ಇದು ಪರದೆಯ ಔಟ್.

102
00:04:55,550 --> 00:04:57,150
>> ಇದು ಒಂದು ಕೆಟ್ಟ ರೀತಿ ಕಾಣುತ್ತದೆ
ವಿಷಯ, ಆದರೆ ವಾಸ್ತವವಾಗಿ ಇದು

103
00:04:57,150 --> 00:04:58,220
ನಿಜವಾಗಿಯೂ ಎಂದು ನಾನು
ಒಳ್ಳೆಯದು, ನಾವು ಮಾಡುತ್ತೇವೆ ಎಂದು

104
00:04:58,220 --> 00:05:00,390
ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡಿ ನೋಡಿ
ಪಿಎಚ್ಪಿ ವೆಬ್ ಅಭಿವೃದ್ಧಿ,

105
00:05:00,390 --> 00:05:04,010
ಇದು ಅರ್ಥ ಏಕೆಂದರೆ ನಾವು
PHP ಮತ್ತು HTML intersperse.

106
00:05:04,010 --> 00:05:06,640
ನಾವು ಅವುಗಳನ್ನು ಒಟ್ಟಿಗೆ ಬಳಸಬಹುದು
ಒಂದು ಹೆಚ್ಚು ಡೈನಾಮಿಕ್ ವೆಬ್ ಪುಟ ರಚಿಸಲು.

107
00:05:06,640 --> 00:05:10,650
ಆದರೆ ಆ ಮೇಲೆ ಹೆಚ್ಚು
ಪಿಎಚ್ಪಿ ವೆಬ್ ಅಭಿವೃದ್ಧಿ ವೀಡಿಯೊ.

108
00:05:10,650 --> 00:05:12,021
>> ಆದ್ದರಿಂದ ಪಿಎಚ್ಪಿ ವಾಕ್ಯ ಏನು?

109
00:05:12,021 --> 00:05:13,520
ಈ ವೀಡಿಯೊ ಎಲ್ಲಾ ಬಗ್ಗೆ ಏನು.

110
00:05:13,520 --> 00:05:14,850
ಅವರ ಬಗ್ಗೆ ಮಾತನಾಡೋಣ.

111
00:05:14,850 --> 00:05:16,490
>> ಆದ್ದರಿಂದ, ಅಸ್ಥಿರ ಔಟ್ ಆರಂಭಿಸಲು.

112
00:05:16,490 --> 00:05:18,030
ಪಿಎಚ್ಪಿ ಅಸ್ಥಿರ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ.

113
00:05:18,030 --> 00:05:20,067
ಕೇವಲ ದೊಡ್ಡ ಎರಡು ಇವೆ
ಸಿ ವ್ಯತ್ಯಾಸಗಳು

114
00:05:20,067 --> 00:05:21,900
ಮೊದಲ ಇತ್ತು ಎಂಬುದು
ಯಾವುದೇ ರೀತಿಯ ನಿಷ್ಕೃಷ್ಟ.

115
00:05:21,900 --> 00:05:24,245
ನಾವು ಇಂಟ್ ಹೇಳಲು ಇಲ್ಲ
ಚಾರ್, ಫ್ಲೋಟ್, ಎಲ್ಲಾ ಸಂಗತಿಗಳನ್ನು.

116
00:05:24,245 --> 00:05:25,620
ನಾವು ಇನ್ನು ಮುಂದೆ ಹಾಗೆ ಹೊಂದಿಲ್ಲ.

117
00:05:25,620 --> 00:05:26,810
ಪಿಎಚ್ಪಿ ಆಧುನಿಕ ಭಾಷೆಯಾಗಿದೆ.

118
00:05:26,810 --> 00:05:28,910
ನೀವು ಏನನ್ನು ಲೆಕ್ಕಾಚಾರ
ಅಥವಾ ಒಂದು ಉತ್ತಮ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುವ

119
00:05:28,910 --> 00:05:30,451
ನೀವು ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಬಗ್ಗೆ ಊಹೆ.

120
00:05:30,451 --> 00:05:31,700
ಆದ್ದರಿಂದ ಬಹಳ ಸಂತೋಷವನ್ನು ಇಲ್ಲಿದೆ.

121
00:05:31,700 --> 00:05:35,330
>> ಇತರ ವಿಷಯ ಎಲ್ಲಾ ವೇರಿಯಬಲ್ ಎಂದು
ಹೆಸರುಗಳು ಡಾಲರ್ ಚಿಹ್ನೆ ಪ್ರಾರಂಭಿಸಬೇಕು.

122
00:05:35,330 --> 00:05:36,940
ಆ ಬಳಸಲಾಗುತ್ತದೆ ಮಾಡಲು ವಿಷಯ.

123
00:05:36,940 --> 00:05:39,496
ಇದು ಏಕೆಂದರೆ, ಸ್ವಲ್ಪ ವಿಲಕ್ಷಣ ಇಲ್ಲಿದೆ
ಪಿಎಚ್ಪಿ ತಿಳಿಯುವ ಹಾಗೆ ಇದು

124
00:05:39,496 --> 00:05:40,870
ಯಾವ ಒಂದು ವೇರಿಯಬಲ್ ಮತ್ತು ಏನು ಅಲ್ಲ.

125
00:05:40,870 --> 00:05:43,340
ಆದ್ದರಿಂದ ಪ್ರತಿ ವೇರಿಯಬಲ್ ಹೆಸರು
ಒಂದು ಡಾಲರ್ ಚಿಹ್ನೆ ಆರಂಭವಾಗುತ್ತದೆ.

126
00:05:43,340 --> 00:05:46,884
ಆದ್ದರಿಂದ ಸಿ ನಾವು ಏನಾದರೂ ಹೇಳಬಹುದು
ಈ ರೀತಿಯ, ಇಂಟ್ X = 54.

127
00:05:46,884 --> 00:05:48,550
ನಾವು ಪಿಎಚ್ಪಿ ಎಲ್ಲಿಯೂ ಮಾಡಲು ಹೊಂದಿಲ್ಲ.

128
00:05:48,550 --> 00:05:52,540
ನಾವು ಕೇವಲ X = 54 $ ಹೇಳಬಹುದು.

129
00:05:52,540 --> 00:05:55,920
ಮತ್ತು ನಾವು ಸಿ, ಉದಾಹರಣೆಗೆ, ಹೇಳಬಹುದು,
ನಾವು CS50 ಎಚ್ ಪೌಂಡ್ ಒಳಗೊಂಡಿತ್ತು ವೇಳೆ

130
00:05:55,920 --> 00:06:00,314
ಹೆಡರ್ ಕಡತವನ್ನು ನಾವು ಹೇಳಬಹುದು
ಸ್ಟ್ರಿಂಗ್ ಹೊಂದಿಕೆ = "ಈ CS50 ಹೊಂದಿದೆ."

131
00:06:00,314 --> 00:06:01,980
ನಾವು ಆದರೂ, ಪಿಎಚ್ಪಿ ಹಾಗೆ ಹೊಂದಿಲ್ಲ.

132
00:06:01,980 --> 00:06:04,865
ನಾವು ಕೇವಲ $ ನುಡಿಗಟ್ಟು ಹೇಳಬಹುದು
= "ಈ CS50 ಹೊಂದಿದೆ."

133
00:06:04,865 --> 00:06:08,760
ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ಸ್ಟ್ರಿಂಗ್ ಈಗ
ಪಿಎಚ್ಪಿ ಒಂದು ಅಂತರ್ನಿರ್ಮಿತ ಮಾಹಿತಿ ಪ್ರಕಾರ,

134
00:06:08,760 --> 00:06:10,950
ಅಥವಾ ಬದಲಿಗೆ ಪಿಎಚ್ಪಿ ಅರ್ಥ
ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ ಎಂಬುದನ್ನು.

135
00:06:10,950 --> 00:06:15,612
ಇದು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಇಲ್ಲಿದೆ
ಪಾತ್ರಗಳ ಇದು ಸಿ ಹೇಗಿದೆಯೋ

136
00:06:15,612 --> 00:06:17,570
ಎಲ್ಲಾ ನಿಮ್ಮ ನೆಚ್ಚಿನ
ಸಿ ಷರತ್ತಿನ ಹೇಳಿಕೆಗಳು

137
00:06:17,570 --> 00:06:19,520
ಇನ್ನೂ ನೀವು ಬಳಸಲು ಲಭ್ಯವಿದೆ.

138
00:06:19,520 --> 00:06:21,140
ಆದ್ದರಿಂದ ಯಾವುದೇ ದೊಡ್ಡ ಪರಿವರ್ತನೆ.

139
00:06:21,140 --> 00:06:23,400
ನಾವು ಹೊಂದಬಹುದು ಹೇಳಲು ಮಾಡಬಹುದು
ಈ ರೀತಿಯ ಹೇಳಿಕೆಗಳನ್ನು ವೇಳೆ.

140
00:06:23,400 --> 00:06:28,210
$ ವೈ 43, ಅಥವಾ $ z = 15.

141
00:06:28,210 --> 00:06:29,690
ಆದ್ದರಿಂದ ಬಹಳ ಸರಳ.

142
00:06:29,690 --> 00:06:31,980
ನಾವು ಬೇರೆ ವೇಳೆ ಮತ್ತು ಹೊಂದಬಹುದು.

143
00:06:31,980 --> 00:06:34,210
ನಾವು ಬೇರೆ ವೇಳೆ ಮತ್ತು ವೇಳೆ ಹೊಂದಬಹುದು.

144
00:06:34,210 --> 00:06:36,430
>> ಮತ್ತು ಏನೋ ಗಮನಕ್ಕೆ
ಬಹಳ ಇಲ್ಲಿ ಸಂತೋಷವನ್ನು, ಮತ್ತು ಈ

145
00:06:36,430 --> 00:06:39,620
ಆ ಒಂದು ತೆರನಾದ
ಸಿ, ಸೂಚನೆ ವಿರುದ್ಧ ಪಿಎಚ್ಪಿ ಅನುಕೂಲಗಳು

146
00:06:39,620 --> 00:06:41,510
ಯಾವ ಕಾರ್ಯವನ್ನು ನಾವು ಇಲ್ಲಿ ಬಳಸಿ ಇಲ್ಲ?

147
00:06:41,510 --> 00:06:47,737
ನಾವು ಒಂದು ಹೋಲಿಕೆ == ಬಳಸುತ್ತಿರುವ
ವೇರಿಯಬಲ್, $ ಹೆಸರು, ಸ್ಟ್ರಿಂಗ್.

148
00:06:47,737 --> 00:06:49,070
ನಾವು, ಸಿ ಹಾಗೆ ಆಗಲಿಲ್ಲ?

149
00:06:49,070 --> 00:06:53,200
ನಾವು ಎಂಬ ಕ್ರಿಯೆಯ ಬಳಸಬೇಕಿತ್ತು
StrComp ಅಥವಾ StrEndComp ಅಥವಾ ಯಾವುದೇ

150
00:06:53,200 --> 00:06:54,840
ಅದರ ಸಂಬಂಧಿತ ಸೋದರ.

151
00:06:54,840 --> 00:06:56,980
>> ಆದ್ದರಿಂದ ಈಗಾಗಲೇ ನಾವು ಈ ಅನುಕೂಲಗಳು ನೋಡಿ.

152
00:06:56,980 --> 00:07:00,930
ನಾವು ಏನನ್ನಾದರೂ ಮಾಡಬೇಕು ಇಲ್ಲ
ಸಿಲ್ಲಿ ಅಥವಾ ಬಹುಶಃ ಬೇರೇಯೇ ಆದ

153
00:07:00,930 --> 00:07:03,540
ಎಂಬ ಕಾರ್ಯ ಕರೆ
StrComp ನಾನು ಪರೀಕ್ಷಿಸಲು ಬಯಸಿದರೆ

154
00:07:03,540 --> 00:07:05,237
ಎಂಬುದನ್ನು ಈ ಕೆಳಗಿನ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಸಮನಾಗಿರುತ್ತದೆ.

155
00:07:05,237 --> 00:07:07,820
ನಾನು ಸಮ ಸಮ ಬಳಸಬಹುದಾಗಿತ್ತು
ಹಾಗೆ ನನಗೆ ಬೇರೇನೂ ಇಲ್ಲ.

156
00:07:07,820 --> 00:07:09,560
ಆದ್ದರಿಂದ ಅನುಕೂಲ ಇಲ್ಲ.

157
00:07:09,560 --> 00:07:13,350
>> ಕೆಲವೊಮ್ಮೆ, ಮೂಲಕ, ನೀವು ಇರಬಹುದು
elseif, ಬೇರೆ ವೇಳೆ ಒಂದು ಪದ ನೋಡಿ.

158
00:07:13,350 --> 00:07:14,910
ಮತ್ತು ಜೊತೆಗೆ ಪಿಎಚ್ಪಿ ಒಕೆ.

159
00:07:14,910 --> 00:07:17,020
ಆದ್ದರಿಂದ ಕೆಲವೊಮ್ಮೆ ನೀವು ನೋಡಬಹುದು.

160
00:07:17,020 --> 00:07:17,790
ಇದು ಮುದ್ರಣದೋಷ ಅಲ್ಲ.

161
00:07:17,790 --> 00:07:21,830
ಪಿಎಚ್ಪಿ ವಾಸ್ತವವಾಗಿ elseif ಅರ್ಥ.

162
00:07:21,830 --> 00:07:23,980
ನನಗೆ ಗೊತ್ತಿಲ್ಲ ಏತಕ್ಕಾಗಿ
ಎಂದು ಅಳವಡಿಸಲು ನಿರ್ಧರಿಸಿದ್ದಾರೆ,

163
00:07:23,980 --> 00:07:28,220
ಆದರೆ ನಾವು ಅನೇಕ ಬಾರಿ ನೋಡಿದ
ಇದುವರೆಗೆ ನಮ್ಮ ವೀಡಿಯೊಗಳನ್ನು ಉದ್ದಕ್ಕೂ,

164
00:07:28,220 --> 00:07:30,460
ನಾವು ಪ್ರೋಗ್ರಾಮರ್ಗಳು ಅದನ್ನು ತುಂಬಾ ಇಷ್ಟಪಡುತ್ತೇನೆ
ನಾವು ತ್ವರಿತವಾಗಿ ಕೆಲಸಗಳನ್ನು ಮಾಡಬಹುದು

165
00:07:30,460 --> 00:07:33,660
ಆದ್ದರಿಂದ ಆ ಜಾಗವನ್ನು ತೊಡೆದುಹಾಕಿದ್ದೇವೆ
ಸ್ಪಷ್ಟವಾಗಿ ದೊಡ್ಡ ಪ್ರಯೋಜನವನ್ನು ಹೊಂದಿದೆ.

166
00:07:33,660 --> 00:07:34,800
>> ಆದ್ದರಿಂದ ವೇಳೆ ಮತ್ತು elseif ಇಲ್ಲಿದೆ.

167
00:07:34,800 --> 00:07:37,540
ನಾವು ತ್ರಯಾತ್ಮಕ ಆಯೋಜಕರು ಹೊಂದಿವೆ,
ಮರುಸ್ಥಾಪನೆ ಪ್ರಶ್ನೆ ಗುರುತು ಕೊಲೊನ್,

168
00:07:37,540 --> 00:07:43,262
ಬೇರೆ ವೇಳೆ ನಿಜವಾಗಿಯೂ ಕಡಿಮೆ ರಚನೆ
ಅಥವಾ ಷರತ್ತುಬದ್ಧ ಕವಲೊಡೆಯುವ.

169
00:07:43,262 --> 00:07:45,470
ಮತ್ತು ಸ್ಪಷ್ಟವಾಗಿ, ಈ,
ಇಲ್ಲಿರುವುದು ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ

170
00:07:45,470 --> 00:07:49,720
ವೇರಿಯಬಲ್ ನಿಯೋಜಿಸಲು ಇದೆ
ಸರಿ ಅಥವಾ ತಪ್ಪು ಎರಡೂ $ ಪತ್ರ

171
00:07:49,720 --> 00:07:54,110
$ ವರ್ ಎಂಬುದನ್ನು ಅವಲಂಬಿಸಿ
ಒಂದು ಅಕ್ಷರಮಾಲೆ ಪಾತ್ರ.

172
00:07:54,110 --> 00:07:57,320
ಆದ್ದರಿಂದ ಈ isalpha ಸಾಕಷ್ಟು ಹೋಲುತ್ತದೆ
ನಾವು ಸಿ ಪರಿಚಿತವಾಗಿರುವ

173
00:07:57,320 --> 00:07:59,010
ಈ ಪಿಎಚ್ಪಿ ಸಮಾನ ತೆರನಾದ.

174
00:07:59,010 --> 00:08:01,550
ಕಾರ್ಯ ಸ್ಪಷ್ಟವಾಗಿ
ctype_alpha ಕರೆದು

175
00:08:01,550 --> 00:08:03,450
ಆದರೆ ನಾವು ಪಿಎಚ್ಪಿ ಇದನ್ನು ಹೇಗೆ.

176
00:08:03,450 --> 00:08:08,560
ಆದ್ದರಿಂದ ಈ ವೇಳೆ, ಎಂದು ಇದೆ ನಾನು
$ ವರ್ ಒಂದು ಪತ್ರ, $ ಅಕ್ಷರದ ನಿಜ.

177
00:08:08,560 --> 00:08:13,820
$ ವರ್ ಪತ್ರ ಇದ್ದರೆ,
$ ಅಕ್ಷರದ ತಪ್ಪಾಗಿದೆ.

178
00:08:13,820 --> 00:08:15,820
>> ನಾವು ಇನ್ನೂ ಸ್ವಿಚ್ ಹೇಳಿಕೆಗಳನ್ನು ಹೊಂದಿವೆ.

179
00:08:15,820 --> 00:08:17,870
ನಾವು ಸಿ ಆ ಹಾಗೂ ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ.

180
00:08:17,870 --> 00:08:22,480
ಅಲ್ಲಿ ತುಂಬಾ ಮೇಲ್ಭಾಗದಲ್ಲಿ, ನಾವು ಮಾಡಬೇಕು ಹೇಗೆ
ಇಂಟ್ ಪಡೆಯಲು ಅಥವಾ ಸ್ಟ್ರಿಂಗ್ ಪಡೆಯಲು ರೀತಿಯ.

181
00:08:22,480 --> 00:08:23,845
ಆದ್ದರಿಂದ PHP ಕಟ್ಟಿಸಿದ ಹೊಂದಿದೆ.

182
00:08:23,845 --> 00:08:25,470
ನಾವು ಎಂದಿಗೂ CS50 ಗ್ರಂಥಾಲಯದ ಅಗತ್ಯವಿಲ್ಲ.

183
00:08:25,470 --> 00:08:27,237
ನಾವು ಕಾರ್ಯ readline ಬಳಸಬಹುದು.

184
00:08:27,237 --> 00:08:29,820
ಏನು ಮಾಡಲು ವಿಶೇಷವೇನು ಮುದ್ರಣ
ಸಂದೇಶವನ್ನು, "ನಿಮ್ಮ ರಾಜ್ಯದ,

185
00:08:29,820 --> 00:08:33,820
, ದಯವಿಟ್ಟು "ಮತ್ತು ನಂತರ ಪ್ರಾಂಪ್ಟ್ ಮಿಟುಕಿಸುವುದು
ಇನ್ಪುಟ್ ಬಳಕೆದಾರರು ಕಾಯುತ್ತಿರುವ

186
00:08:33,820 --> 00:08:34,739
ಕೆಲವು ಮಾಹಿತಿ.

187
00:08:34,739 --> 00:08:36,530
ಈಗ ಇನ್ನೇನು ಗಮನಕ್ಕೆ
ನಾವು ಸ್ವಿಚ್ ಮಾಡಲು ಸಾಧ್ಯ.

188
00:08:36,530 --> 00:08:39,105
ನೀವು ಮೊದಲು ಬಳಸಿದ್ದರೆ,
ನೀವು ಸ್ವಿಚ್ ಸ್ಮರಿಸಿಕೊಳ್ಳಲು

189
00:08:39,105 --> 00:08:44,960
ಪೂರ್ಣಾಂಕಗಳ ಬಹುಮಟ್ಟಿಗೆ ಸೀಮಿತವಾಗಿದ್ದು
ಪಾತ್ರಗಳು, ಆದರೆ ಈಗ ನಾವು ತಂತಿಗಳನ್ನು ಬಳಸಬಹುದು.

190
00:08:44,960 --> 00:08:50,190
ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ಸ್ವಿಚ್ ಸ್ಟೇಟ್ಮೆಂಟ್
ಪಿಎಚ್ಪಿ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಮೃದುವಾಗಿರುತ್ತದೆ

191
00:08:50,190 --> 00:08:54,880
ಸಿ ತನ್ನ ಸೋದರಸಂಬಂಧಿ ಹೆಚ್ಚು

192
00:08:54,880 --> 00:08:55,380
ಸೇರಿರುವ.

193
00:08:55,380 --> 00:08:58,130
ಕೇವಲ ಸಂಭಾವನಾ ನಂತಹ ಎಲ್ಲಾ
ನಿಮ್ಮ ಹಳೆಯ ಮೆಚ್ಚಿನವುಗಳು ಇನ್ನೂ ಇವೆ.

194
00:08:58,130 --> 00:09:00,740
ನಾವು ಎಣಿಕೆ ಸಂದರ್ಭದಲ್ಲಿ ಕುಣಿಕೆಗಳು ಹೊಂದಿವೆ
1 ರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ 100.

195
00:09:00,740 --> 00:09:03,940
ನಾವು ಕುಣಿಕೆಗಳು ಮಾಡುವಾಗ ಮಾಡಬೇಕಾದ
ಎಂದು, 1 ರಿಂದ 100 ಎಣಿಕೆ

196
00:09:03,940 --> 00:09:06,200
ಮತ್ತು ನಾವು ಕುಣಿಕೆಗಳು ಹೊಂದಿವೆ
ಆ 1 ರಿಂದ 100 ಎಣಿಕೆ.

197
00:09:06,200 --> 00:09:07,220
ಆದ್ದರಿಂದ ಯಾವುದೇ ದೊಡ್ಡ ಅಧಿಕ.

198
00:09:07,220 --> 00:09:09,360
ವಾಕ್ಯ ಬಹಳ ಆಗಿದೆ
ಒಂದೇ ಹೆಚ್ಚು,

199
00:09:09,360 --> 00:09:11,760
ಈಗ ನಾವು ಬಳಸುತ್ತಿರುವ ಹೊರತುಪಡಿಸಿ
ಡಾಲರ್ ಚಿಹ್ನೆ ವೇರಿಯಬಲ್ ಬದಲಿಗೆ

200
00:09:11,760 --> 00:09:17,260
ಪೂರ್ಣಾಂಕ ಅಸ್ಥಿರ ಘೋಷಿಸುವ ಅಥವಾ
ನಮ್ಮ ಕೌಂಟರ್ ಆ ರೀತಿಯ.

201
00:09:17,260 --> 00:09:20,090
>> ವಿಷಯಗಳನ್ನು ಪಡೆಯಲು ಅಲ್ಲಿ ಇಲ್ಲಿ
ಆದರೂ, ಸಿ ಹೆಚ್ಚು ಬಹಳಷ್ಟು ಉತ್ತಮ.

202
00:09:20,090 --> 00:09:21,020
ಅರೆಸ್.

203
00:09:21,020 --> 00:09:23,020
ಆದ್ದರಿಂದ ನಾವು ನೆನಪಿಸಿಕೊಂಡು ಮಾಡಿದಾಗ
ಸಲುವಾಗಿ, ಸಿ ಬಗ್ಗೆ

204
00:09:23,020 --> 00:09:25,560
ನಮಗೆ ಬೆಳೆಯಲು ಮುಳುಗಿ ಫಾರ್
ಮಾಹಿತಿಯನ್ನು ಸೆಟ್,

205
00:09:25,560 --> 00:09:28,310
ನಾವು ಕರ್ತವ್ಯಲೋಪದ ವಿಂಗಡಿಸಲು ಅಗತ್ಯವಿದೆ
ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಈ ಕಲ್ಪನೆಗೆ,

206
00:09:28,310 --> 00:09:30,780
ಸಿ ರಚನೆಗಳು ಗಾತ್ರ ರಲ್ಲಿ ಸರಿಪಡಿಸಲಾಗಿದೆ ಏಕೆಂದರೆ.

207
00:09:30,780 --> 00:09:31,800
ನಾವು ಅವುಗಳನ್ನು ಕುಗ್ಗಿಸಿ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.

208
00:09:31,800 --> 00:09:32,930
ನಾವು ಅವುಗಳನ್ನು ಬೆಳೆಯಲು ಸಾಧ್ಯವಾಗಿಲ್ಲ.

209
00:09:32,930 --> 00:09:36,074
ನಾವು ಮೆಮೊರಿ ಪುನರ್ವಿಂಗಡಿಸು ಹೊಂದಿತ್ತು
ಮತ್ತು ಈ ಹುಚ್ಚು ಮಾಡಲು

210
00:09:36,074 --> 00:09:38,490
ಅಥವಾ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ಬಳಸುವ
ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸ್ಥಳವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

211
00:09:38,490 --> 00:09:41,590
ಆದರೆ PHP, ಸರಣಿಗಳಿವೆ
ಇನ್ನು ಮುಂದೆ ಗಾತ್ರದಲ್ಲಿ ಸ್ಥಿರವಾಗಿಲ್ಲ.

212
00:09:41,590 --> 00:09:43,240
ಅವರು ಬೆಳೆಯುವ ಮತ್ತು ಅವರು ಕುಗ್ಗಿಸಿ ಮಾಡಬಹುದು.

213
00:09:43,240 --> 00:09:46,660
ಆದ್ದರಿಂದ ಮತ್ತೆ, ಈ 20 ವರ್ಷಗಳ ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದ
ಸಿ ಮೊದಲ ಬಿಡುಗಡೆಯ ಮಧ್ಯೆ

214
00:09:46,660 --> 00:09:49,440
ಮತ್ತು ಮೊದಲ ಬಿಡುಗಡೆ ಪಿಎಚ್ಪಿ,
ನಾವು, ನಿಮಗೆ ತಿಳಿದಿರುವ, ಎಂದು ನಿರ್ಧರಿಸಿದರು

215
00:09:49,440 --> 00:09:51,670
ಇದು ನಿಜವಾಗಿಯೂ ಶ್ರೇಷ್ಠ ಎಂದು
ನಾವು ಈ ಸಾಧ್ಯವಾದರೆ.

216
00:09:51,670 --> 00:09:54,100
ಆದ್ದರಿಂದ ನಾವು ಈ ಜಾರಿಗೆ.

217
00:09:54,100 --> 00:09:58,040
>> ಆದ್ದರಿಂದ PHP ಸರಣಿಗಳ ಸ್ಥಿರ
ಗಾತ್ರ, ಮತ್ತು ಪಿಎಚ್ಪಿ ಏಕೆಂದರೆ ನಿಜವಾಗಿಯೂ

218
00:09:58,040 --> 00:10:03,090
ಪ್ರೋಗ್ರಾಮರ್ ಮುಖ ಹೊಂದಿವೆ
ರೀತಿಯ ತತ್ವಗಳನ್ನು

219
00:10:03,090 --> 00:10:05,110
ನಾವು ಮಾಹಿತಿ ಬಗೆಯ ಮಿಶ್ರಣ ಮಾಡಬಹುದು
ನಮ್ಮ ಸರಣಿಗಳ ತುಂಬಾ.

220
00:10:05,110 --> 00:10:08,100
ಆದ್ದರಿಂದ ನಾವು ಬಳಸಲು ಹೊಂದಿಲ್ಲ
ಪೂರ್ಣಾಂಕಗಳ ಅಥವಾ ಎಲ್ಲಾ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್,

221
00:10:08,100 --> 00:10:12,826
ನಾವು ಎಲ್ಲಾ ಮಿಶ್ರಣವನ್ನು ಹೊಂದಬಹುದು
ಒಂದೇ ಶ್ರೇಣಿಯಲ್ಲಿನ ವಿವಿಧ ರೀತಿಯ.

222
00:10:12,826 --> 00:10:14,700
ಒಂದು ರಚನೆ ಘೋಷಿಸುವ
ಬಹಳ ಸರಳ.

223
00:10:14,700 --> 00:10:16,116
ಇದು ಯಾವುದೇ ಇತರ ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ಅನಿಸುತ್ತದೆ.

224
00:10:16,116 --> 00:10:20,020
$ nums = ಸರಣಿ (1, 2, 3,
4), ಶ್ರೇಣಿಯಲ್ಲಿನ ಒಂದು ಕಾರ್ಯ ಎಂಬ

225
00:10:20,020 --> 00:10:22,760
ಪಿಎಚ್ಪಿ ಒಳಗೆ ನಿರ್ಮಾಣವಾಗಿರುವ
ನೀವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುತ್ತದೆ.

226
00:10:22,760 --> 00:10:28,315
ಈ ನಾಲ್ಕು ಮೌಲ್ಯಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ,
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಸಂಖ್ಯೆಗಳು, $ nums ಕರೆಯಲಾಗುತ್ತದೆ.

227
00:10:28,315 --> 00:10:29,940
ಮತ್ತು ಅದನ್ನು ಮಾಡಲು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ರೀತಿಯಲ್ಲಿ ಇಲ್ಲ.

228
00:10:29,940 --> 00:10:32,420
ಮತ್ತು ನಾವು ನೀನು
ಈ ಪಿಎಚ್ಪಿ ಬಹಳಷ್ಟು ನೋಡಿ.

229
00:10:32,420 --> 00:10:36,380
ಪಿಎಚ್ಪಿ ವಿವಿಧ ಅಭಿವೃದ್ಧಿ ಮಾಡಲಾಗಿದೆ
ಜನರು ಬೆಳೆಯುತ್ತದೆ ಮತ್ತು ಬೆಳೆಯುತ್ತದೆ ಮತ್ತು ಬೆಳೆಯುತ್ತದೆ ಮತ್ತು.

230
00:10:36,380 --> 00:10:40,050
ಸಾಮಾನ್ಯವಾಗಿ ಇಲ್ಲ ಕೇವಲ ಎರಡು ಅಥವಾ
ಪಿಎಚ್ಪಿ ಏನಾದರೂ ಮೂರು ವಿಧಾನಗಳ

231
00:10:40,050 --> 00:10:42,170
ಸಾಮಾನ್ಯವಾಗಿ 10 ಅಥವಾ 20 ರೀತಿಯ ಇಲ್ಲ.

232
00:10:42,170 --> 00:10:45,300
ಇಲ್ಲಿ ಮತ್ತೊಂದು ಸಾಮಾನ್ಯವಾಗಿದೆ
ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಲು ದಾರಿ.

233
00:10:45,300 --> 00:10:48,310
$ nums = ಚೌಕಾಕಾರದ ಬ್ರಾಕೆಟ್ 1, 2, 3, 4.

234
00:10:48,310 --> 00:10:53,170
ಆದ್ದರಿಂದ ಈ ರೀತಿಯ ಸಿ ಕೋನಕ್ಕೆ ಆಫ್ ಹೋಲುತ್ತದೆ
ಬದಲಿಗೆ, ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ಸಂಕೇತ br--. $ -

235
00:10:53,170 --> 00:10:58,525
ಅಥವಾ ಇದು ಇಂಟ್ nums ಚದರ ಎಂದು
ಆವರಣ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ 1, 2, 3, 4 ಸಮನಾಗಿರುತ್ತದೆ.

236
00:10:58,525 --> 00:11:02,710
PHP ಅದನ್ನು $ nums = ಚೌಕದ
ಆವರಣ 1, 2, 3, 4.

237
00:11:02,710 --> 00:11:08,920
ಆದರೆ ಈ ಉದಾಹರಣೆಗಳನ್ನು ಎರಡೂ ಇಲ್ಲಿ ನನಗೆ ನೀಡಲು
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಪೂರ್ಣಾಂಕಗಳ ನಾಲ್ಕು ಒಂದು ಶ್ರೇಣಿಯನ್ನು.

238
00:11:08,920 --> 00:11:10,920
>> ನಾನು ಈಗ ಏನೋ ಸ್ಪಂದನ ಬಯಸಿದರೆ ಏನು?

239
00:11:10,920 --> 00:11:14,760
ಸರಿ ನಾನು $ nums 4, ಹೇಳಬಹುದು ಇದು
ಮತ್ತೆ, ನಾವು ಇನ್ನೂ ಇಲ್ಲಿ 0 ಲೆಕ್ಕ ನೀವು

240
00:11:14,760 --> 00:11:17,800
ಪಿಎಚ್ಪಿ ಐದನೇ ಎಂದು
ರಚನೆಯ ಅಂಶ.

241
00:11:17,800 --> 00:11:18,990
ನಾನು ಎಂದು ಹೇಳಬಹುದು.

242
00:11:18,990 --> 00:11:22,860
ನಾನು ಒಂದು seg ಬಳಲುತ್ತಿದ್ದಾರೆ ನಾನೇನು
ನನ್ನ ರಚನೆಯ ಕೇವಲ ಏಕೆಂದರೆ, ತಪ್ಪು

243
00:11:22,860 --> 00:11:24,337
ಎಂದು ಸರಿಹೊಂದಿಸಲು ಬೆಳೆಯಲು ಹೋಗುತ್ತದೆ.

244
00:11:24,337 --> 00:11:25,420
ಅದು ಸರಿ, ಬಹಳ ಸಂತೋಷವನ್ನು ಇಲ್ಲಿದೆ?

245
00:11:25,420 --> 00:11:28,400
ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ನಾನು ಅಗತ್ಯವಿಲ್ಲ
ನಾನು ಹಾಕಲು ಬಯಸುವ ಅಲ್ಲಿ ಸೂಚಿಸಿ.

246
00:11:28,400 --> 00:11:31,220
ನಾನು ಈ ಮತ್ತು ಹೇಳಬಹುದು
ಬಲ ಕೊನೆಯಲ್ಲಿ ಮೇಲೆ ಸ್ಪಂದನ,

247
00:11:31,220 --> 00:11:34,099
ಅಥವಾ ನಾನು ಕೇವಲ ಸಾಧ್ಯವೋ
$ nums 20 ಅಥವಾ 1,000 ಹೇಳುತ್ತಾರೆ.

248
00:11:34,099 --> 00:11:35,140
ಇದು ನಿಜವಾಗಿಯೂ ಅಪ್ರಸ್ತುತವಾಗುತ್ತದೆ.

249
00:11:35,140 --> 00:11:38,330
ಇನ್ನೂ ಕೇವಲ ವಿಶೇಷವೇನು
ಕೊನೆಯಲ್ಲಿ ಬಲಭಾಗದಲ್ಲಿ ಇದು ಸ್ಪಂದನ.

250
00:11:38,330 --> 00:11:41,490
>> ಹಾಗಾಗಿ ಬೆಳೆಯುತ್ತವೆ, ಮತ್ತು ನಾವು ಆರ್ as-- ಮಾಡಬಹುದು
ಇಲ್ಲಿ ಅದನ್ನು ರಕ್ಷಣೆ ಇಲ್ಲ,

251
00:11:41,490 --> 00:11:45,360
ಆದರೆ ನಾನು ಟ್ರ್ಯಾಶ್ ಅಥವಾ ನಷ್ಟವಾಗಬಹುದು
ಹಾಗೂ ರಚನೆಯ ಅಂಶಗಳನ್ನು,

252
00:11:45,360 --> 00:11:50,064
ಮತ್ತು ಶ್ರೇಣಿಯನ್ನು ಸರಿಹೊಂದಿಸಲು ಕುಗ್ಗುವಿಕೆ
ಈಗ ಕಾಣೆಯಾಗಿದೆ ಅಥವಾ ಖಾಲಿ.

253
00:11:50,064 --> 00:11:52,230
ಸ್ಪಂದನ ಮತ್ತೊಂದು ದಾರಿ ಇಲ್ಲ
ಸರಣಿಗಳ ಮೇಲೆ ಏನೋ,

254
00:11:52,230 --> 00:11:54,330
ಇದು array_push ಎಂಬ ಕ್ರಿಯೆ ಇಲ್ಲ.

255
00:11:54,330 --> 00:11:57,860
ಆದ್ದರಿಂದ ಮತ್ತೆ, ಎಂಬ ಈ ಕಲ್ಪನೆ
ವಸ್ತುಗಳ ವಿವಿಧ ರೀತಿಯಲ್ಲಿ ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

256
00:11:57,860 --> 00:12:01,950
ನಾವು ಈಗ ಮೂರು ವಿವಿಧ ರೀತಿಯಲ್ಲಿ ನೋಡಿದ
ಸರಣಿಗಳ ಮೇಲೆ ಮತ್ತೊಂದು ಅಂಶ ಸ್ಪಂದನ.

257
00:12:01,950 --> 00:12:06,900
ಆದ್ದರಿಂದ ಈ ಮತ್ತೊಂದು ಅಂಶ ಸೇರಿಸುತ್ತದೆ
$ nums ರಚನೆಯ ಅಂತ್ಯ.

258
00:12:06,900 --> 00:12:08,340
ಮತ್ತು ನಾವು ನಮ್ಮ ಡೇಟಾ ಪ್ರಕಾರಗಳು ಮಿಶ್ರಣ.

259
00:12:08,340 --> 00:12:13,110
ಆದ್ದರಿಂದ ನಾನು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ತೋರಿಸಬಹುದಿತ್ತು
1, 2, 3, 4, ಆದರೆ 1, ನಿಜ, 3, 4,

260
00:12:13,110 --> 00:12:16,420
ಅಲ್ಲಿ ನಿಜವಾದ ಒಂದು ಬೂಲಿಯನ್, ಮತ್ತು ನಂತರ
ನಾನು ಮತ್ತೊಂದು ಅಂಶ ಸ್ಪಂದನ ಬಯಸಿದರೆ

261
00:12:16,420 --> 00:12:20,860
ವ್ಯೂಹ, ಬಹುಶಃ ಸ್ಟ್ರಿಂಗ್,
ಸ್ಟ್ರಿಂಗ್ "ಐದು," ನಾನು ಹಾಗೆ ಮಾಡಲಾಗಲಿಲ್ಲ.

262
00:12:20,860 --> 00:12:26,110
ಈಗ ನನ್ನ ರಚನೆಯ ಎಂದು
ನಿಜ 1, 3, 4, ಐದು ಎಂದು.

263
00:12:26,110 --> 00:12:28,640
ಪದ ಐದು ಅಲ್ಲದ ಪೂರ್ಣಾಂಕ 5.

264
00:12:28,640 --> 00:12:31,270
ಆದ್ದರಿಂದ ನಮ್ಯತೆ ಬಹಳಷ್ಟು.

265
00:12:31,270 --> 00:12:33,290
>> ನಮ್ಯತೆ ಪಡೆಯುತ್ತದೆ
ಉತ್ತಮ, ಆದರೂ,

266
00:12:33,290 --> 00:12:37,530
ಪಿಎಚ್ಪಿ ಏನೋ ಬೆಂಬಲವನ್ನು ಹೊಂದಿದೆ ಏಕೆಂದರೆ
ಒಂದು ಸಹಾಯಕ ರಚನೆಯ ಎಂದು.

267
00:12:37,530 --> 00:12:40,660
ಮತ್ತು ನಾವು ರೀತಿಯ ಅಸ್ಪಷ್ಟವಾಗಿ ಮಾತನಾಡಿದರು
ಸಿ ಬಗ್ಗೆ ಸಹಾಯಕ ರಚನೆಗಳು

268
00:12:40,660 --> 00:12:44,740
ಹ್ಯಾಶ್ ಕೋಷ್ಟಕಗಳು ಸನ್ನಿವೇಶದಲ್ಲಿ, ಏಕೆಂದರೆ
ಏನು ಸಹಾಯಕ ರಚನೆಗಳು ನಿಜವಾಗಿಯೂ ಎಲ್ಲಾ

269
00:12:44,740 --> 00:12:48,950
ಪ್ರಮುಖ ಮಾಡುತ್ತಿದ್ದಾರೆ ಬಗ್ಗೆ
ಮೌಲ್ಯ ಜೋಡಿ ಮ್ಯಾಪಿಂಗುಗಳು.

270
00:12:48,950 --> 00:12:53,410
ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ, keys--
ನಾವು, ಸಿ ರಚನೆಗಳು ಪರಿಚಿತವಾಗಿರುವ

271
00:12:53,410 --> 00:12:55,440
ಕೀಲಿಗಳನ್ನು ಸೂಚ್ಯಂಕ ಸಂಖ್ಯೆಗಳು.

272
00:12:55,440 --> 00:12:57,530
0, 1, 2, 3.

273
00:12:57,530 --> 00:13:03,070
ಮತ್ತು ಮೌಲ್ಯಗಳನ್ನು ನಾವು ಕಂಡು ಏನು
ಅರೇ 0, ಸರಣಿ 1, ಹೀಗೆ ಸರಣಿ 2, ಮತ್ತು.

274
00:13:03,070 --> 00:13:06,310
ಆದ್ದರಿಂದ ಕೀಲಿಗಳನ್ನು ಸೂಚಿಕೆಗಳನ್ನು ಇವೆ,
ಮತ್ತು ಮೌಲ್ಯಗಳು

275
00:13:06,310 --> 00:13:10,060
ವ್ಯೂಹ ಸ್ಥಳ ಏನು,
ಸೂಚ್ಯಂಕ ಸೂಚಿಸಲಾದ.

276
00:13:10,060 --> 00:13:15,130
>> ಆದರೆ PHP, ನಾವು ಇದನ್ನು ಇಲ್ಲ
ಅರೇ 0 ಕಲ್ಪನೆ, ಸರಣಿ 1, ಸರಣಿ 2

277
00:13:15,130 --> 00:13:15,830
ಇನ್ನು ಮುಂದೆ.

278
00:13:15,830 --> 00:13:21,025
ನಾವು ಈಗ ನಿಜವಾದ ಪದಗಳನ್ನು ಬಳಸಬಹುದು
ಮೌಲ್ಯಗಳನ್ನು ಕೀಗಳು ನಕ್ಷೆ.

279
00:13:21,025 --> 00:13:22,650
ಆದ್ದರಿಂದ ನಾನು ಈ ರೀತಿಯ ಹೇಳಬಹುದು.

280
00:13:22,650 --> 00:13:26,710
ನಾನು ಬಳಸಿಕೊಂಡು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಲು
ಕೆಳಗಿನಂತೆ ಚೌಕಾಕಾರದ ಬ್ರಾಕೆಟ್ ವಾಕ್ಯ.

281
00:13:26,710 --> 00:13:30,685
$ ಪಿಜ್ಜಾಗಳು = ಚೌಕಾಕಾರದ ಬ್ರಾಕೆಟ್
"ಚೀಸ್" ತದನಂತರ

282
00:13:30,685 --> 00:13:37,210
ಎರಡು ಬಾಣದ ಸಂಕೇತ ಈ ರೀತಿಯ,
8,99 "ಪೆಪ್ಪೆರೋನಿ,", 10.99-- 9.99 ಬಾಣದ

283
00:13:37,210 --> 00:13:37,880
ಮತ್ತು ಇತ್ಯಾದಿ.

284
00:13:37,880 --> 00:13:39,060
ಆದ್ದರಿಂದ ಇಲ್ಲಿ ಇಂದಿನ ವಿಶೇಷವೇನು?

285
00:13:39,060 --> 00:13:41,040
ನಾನು ವಾಸ್ತವವಾಗಿ ಏನು ಡುಯಿಂಗ್?

286
00:13:41,040 --> 00:13:43,990
ನಾನು ಪ್ರಮುಖ ಮೌಲ್ಯ ಜೋಡಿ ಮ್ಯಾಪಿಂಗುಗಳು ರಚಿಸಲು ನಾನು.

287
00:13:43,990 --> 00:13:49,060
ಬದಲಿಗೆ ಹೇಳುವ ಆದ್ದರಿಂದ, ಉದಾಹರಣೆಗೆ,
ಪಿಜ್ಜಾಗಳು 0, ತುಣುಕುಗಳನ್ನು 1, ಪಿಜ್ಜಾಗಳು 2,

288
00:13:49,060 --> 00:13:52,350
ನಾನು ಈಗ ಪಿಜ್ಜಾಗಳು ಹೇಳಬಹುದು
ಚೀಸ್, ಪಿಜ್ಜಾಗಳು ಪೆಪ್ಪೆರೋನಿ,

289
00:13:52,350 --> 00:13:55,120
ಮತ್ತು ಮೌಲ್ಯಗಳು ನೋಡಿ
ಅವರಿಗೆ ಸಂಬಂಧಿಸಿದ.

290
00:13:55,120 --> 00:13:56,970
>> ಇಲ್ಲಿ ನಮ್ಮ ಕೀಲಿಗಳನ್ನು ಗ್ರೀನ್ ನಲ್ಲಿ ಇವೆ.

291
00:13:56,970 --> 00:13:59,870
ಚೀಸ್, ಪೆಪ್ಪೆರೋನಿ,
ತರಕಾರಿ, ಬಫಲೋ ಚಿಕನ್.

292
00:13:59,870 --> 00:14:04,200
ಇಲ್ಲಿ ಮಾಡುವ ಬಾಣ
ಈ ಪ್ರಮುಖ ಮೌಲ್ಯ ಜೋಡಿ ಮ್ಯಾಪಿಂಗ್.

293
00:14:04,200 --> 00:14:07,420
ತದನಂತರ ಇಲ್ಲಿ ಮೌಲ್ಯಗಳು
ರಚನೆಯ ಸ್ಥಳದಲ್ಲಿ.

294
00:14:07,420 --> 00:14:10,330
ಆದ್ದರಿಂದ ಶ್ರೇಣಿಯಲ್ಲಿನ 0 8,99 ಸಮನಾಗಿರುತ್ತದೆ ಹೇಳುವ ರೀತಿಯಲ್ಲಿ.

295
00:14:10,330 --> 00:14:11,720
ಪ್ರಮುಖ 0.

296
00:14:11,720 --> 00:14:13,600
ಮೌಲ್ಯದ 8.99 ಆಗಿದೆ.

297
00:14:13,600 --> 00:14:19,370
ನಾನು ಈಗ ಶ್ರೇಣಿಯನ್ನು ಚೀಸ್ ಹೇಳಲು, ಅಥವಾ ಈ ಮಾಡಬಹುದು
ಸಂದರ್ಭದಲ್ಲಿ ಪಿಜ್ಜಾಗಳು, ಚೀಸ್, ಕೀಲಿಯಾಗಿದೆ

298
00:14:19,370 --> 00:14:23,340
ಮತ್ತು ನಾನು ಕಂಡುಹಿಡಿಯಲು
ಪಿಜ್ಜಾಗಳು ಚೀಸ್ 8.99 ಆಗಿದೆ.

299
00:14:23,340 --> 00:14:25,540
ನಾನು ಅಲ್ಲಿ ಹೇಗೆ ಮೌಲ್ಯವನ್ನು ಇಲ್ಲಿದೆ.

300
00:14:25,540 --> 00:14:28,124
>> ಹಾಗಾಗಿ ವಿಷಯಗಳನ್ನು ಇಷ್ಟ ಹೇಳಬಹುದು.
$ ಪಿಜ್ಜಾ ಚೀಸ್ = 7.99.

301
00:14:28,124 --> 00:14:29,040
ನಾನು ಮಾರಾಟ ಅನುಭವಿಸುತ್ತಿದ್ದೇನೆ ಸೇ.

302
00:14:29,040 --> 00:14:31,750
ನಾನು ಬಿಡಿ ಬಯಸುವ dis-- ಬಯಸುವ
ಚೀಸ್ ಪಿಜ್ಜಾ ಬೆಲೆ.

303
00:14:31,750 --> 00:14:35,620
ಅಥವಾ ನಾನು ತರಕಾರಿ ಬಳಸಬಹುದು
ಪಿಜ್ಜಾ ಸ್ಥಿತಿ ಭಾಗವಾಗಿ,

304
00:14:35,620 --> 00:14:39,990
ಅಥವಾ ನಾನು ಹೊಸ ಅಂಶ ಸೇರಿಸಬಹುದು ನನ್ನ
ಅರೇ, ನಾನು ಹಿಂದೆ ಹಾಗೆ ಇಲ್ಲ.

305
00:14:39,990 --> 00:14:44,680
ನಾನು ಈ ಹೊಸ ಅಂಶ ಸೇರಿಸಬಹುದು
ಕೀಲಿ "ಬೇಕನ್" ಜೊತೆ ಸಹಾಯಕ ರಚನೆಯ

306
00:14:44,680 --> 00:14:49,250
ಮತ್ತು ಮೌಲ್ಯವನ್ನು 13,49.

307
00:14:49,250 --> 00:14:53,820
>> ಆದರೆ ಈ ರೀತಿಯ ಸಮಸ್ಯೆ ಪರಿಚಯಿಸುತ್ತದೆ
ನೀವು ಎರಡನೇ ಬಗ್ಗೆ ಆ.

308
00:14:53,820 --> 00:14:55,721
ಹೇಗೆ ನಾವು ಈ ರಚನೆಯ ಮೂಲಕ ಮರಳಿ ಎಂದು?

309
00:14:55,721 --> 00:14:56,220
ರೈಟ್?

310
00:14:56,220 --> 00:14:59,820
ಸಿ, ನಾವು ಕೇವಲ ಒಂದು ಹೊಂದಿರುತ್ತದೆ
ಲೂಪ್, ಸಾಮಾನ್ಯವಾಗಿ, ಆ

311
00:14:59,820 --> 00:15:03,650
0 ಓಡುತ್ತವೆ
1 ಮೈನಸ್ ರಚನೆಯ ಗಾತ್ರ.

312
00:15:03,650 --> 00:15:08,060
ಸರಣಿ ರಲ್ಲಿ N ಅಂಶಗಳನ್ನು ಹೊಂದಿದೆ,
ಮಾನ್ಯ ಸೂಚಿಕೆಗಳನ್ನು ಎನ್ ಮೈನಸ್ 1 ಗೆ 0.

313
00:15:08,060 --> 00:15:11,530
ನಾವು ಲೂಪ್ ಒಂದು ಬಳಸಬಹುದಾಗಿತ್ತು
ಪ್ರತಿಯೊಂದು ಅಂಶ ಹೆಜ್ಜೆ.

314
00:15:11,530 --> 00:15:13,530
>> ಆದರೆ ನಿಜವಾಗಿಯೂ ಅಲ್ಲ
ಸಂದರ್ಭದಲ್ಲಿ ಇನ್ನು ಮುಂದೆ, ಬಲ?

315
00:15:13,530 --> 00:15:17,360
ಈಗ ನಾವು ಪ್ರಮುಖ ಮೌಲ್ಯ ಜೋಡಿ ಅಲ್ಲಿ
ಕೀಲಿಗಳನ್ನು ಪದಗಳು ಅಲ್ಲಿ ಮ್ಯಾಪಿಂಗುಗಳು,

316
00:15:17,360 --> 00:15:19,970
ಹೇಗೆ ನಾವು ಪದಗಳನ್ನು ಎಲ್ಲಾ ಮೇಲೆ ತಿರುಗಿ ಇಲ್ಲ?

317
00:15:19,970 --> 00:15:22,420
ಸರಿ, ಅದೃಷ್ಟವಶಾತ್, ಪಿಎಚ್ಪಿ ಹೊಂದಿದೆ
ಒಂದು ರೀತಿಯಲ್ಲಿ, ತುಂಬಾ ಈ ವ್ಯವಹರಿಸಲು

318
00:15:22,420 --> 00:15:24,580
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಮತ್ತೆ ನೆಗೆತ ಮಾಡುತ್ತೇವೆ
ಎರಡನೇ ಸೇರಿರುವ ಗೆ

319
00:15:24,580 --> 00:15:30,780
ಲೂಪ್ ನಾಲ್ಕನೇ ರೀತಿಯ ಪರಿಚಯಿಸಲು ಎಂದು
ಪಿಎಚ್ಪಿ ಒಂದು foreach ಲೂಪ್ ಎಂಬ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

320
00:15:30,780 --> 00:15:34,430
ಮತ್ತು ಒಂದು foreach ಲೂಪ್ ಮಾಡುತ್ತದೆ
ಇದು ಮೂಲತಃ ಅದೇ ಉಪಾಯ.

321
00:15:34,430 --> 00:15:36,060
ನೀವು ರಚನೆಯ ಯಾವುದೇ ರೀತಿಯ ಬಳಸಬಹುದು.

322
00:15:36,060 --> 00:15:38,100
ಆದರೆ ಮೂಲತಃ
ಲೂಪ್ ಒಂದು ಅದೇ ಕಲ್ಪನೆ,

323
00:15:38,100 --> 00:15:40,750
ಬದಲಿಗೆ ಬಳಸಿ ಹೊರತುಪಡಿಸಿ
ಇಂಡೆಕ್ಸ್ ನಂಬರ್ಸ್, ನೀವು

324
00:15:40,750 --> 00:15:45,830
ಈ ವಿಲಕ್ಷಣ ವಾಕ್ಯ ಅಲ್ಲಿ ಹೊಂದಿವೆ
ನೀವು ಪ್ರತಿಯೊಂದು ಅಂಶಗಳು ಕರೆ

325
00:15:45,830 --> 00:15:47,550
ಈ ಲೂಪ್ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಹೆಸರನ್ನು.

326
00:15:47,550 --> 00:15:49,258
>> ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ,
foreach ($ ಪ್ರಮುಖ ಮಾಹಿತಿ $ ಅರ್ರೆಯ್).

327
00:15:49,258 --> 00:15:52,900

328
00:15:52,900 --> 00:15:56,450
ಮೂಲತಃ, ಕಾಮೆಂಟ್ ಟಿಪ್ಪಣಿಗಳನ್ನು,
ಎಂದು foreach ಲೂಪ್ ಒಳಗೆ,

329
00:15:56,450 --> 00:16:00,466
ಇದು ಪ್ರತಿಯೊಂದು ಮೇಲೆ ಹೋಗುತ್ತಿದ್ದೇವೆ
ಸಾಮಾನ್ಯವಾಗಿ ಇದು $ ರಚನೆಯ ಅಂಶ

330
00:16:00,466 --> 00:16:03,340
ಒಂದು ಸಹಾಯಕ ರಚನೆಯ ಎಂದು ನಾನು,
ಆದರೆ ನಿಜವಾಗಿಯೂ ರಚನೆಯ ವಿಮೆಎನಿಸಿದೆ

331
00:16:03,340 --> 00:16:05,419
ನೀವು PHP ಬಯಸುವ.

332
00:16:05,419 --> 00:16:07,210
ಮತ್ತು ಪ್ರತಿ ಬಾರಿ
ಲೂಪ್ ಒಂದು ಅಧಿಕಬಲ

333
00:16:07,210 --> 00:16:13,780
$ ಅರೇ ಚದರ ಬ್ರಾಕೆಟ್ಗಳನ್ನು ಹೇಳಿರುವುದು
$ ನಾನು, ನೀವು ಕೇವಲ $ ಪ್ರಮುಖ ಹೇಳಬಹುದು.

334
00:16:13,780 --> 00:16:22,340
ಆದ್ದರಿಂದ $ ಪ್ರಮುಖ ಪ್ರತಿ ಅಲಿಯಾಸ್ ಆಗುತ್ತದೆ
ನಿಮ್ಮ ಪಿಎಚ್ಪಿ ಸಹವರ್ತನೀಯ ರಚನೆಯ ಸೂಚ್ಯಂಕ

335
00:16:22,340 --> 00:16:23,710
ಮತ್ತು ಆದ್ದರಿಂದ ಆ ರೀತಿಯಲ್ಲಿ ಬಳಸಬಹುದು.

336
00:16:23,710 --> 00:16:25,897
>> ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ನಾವು
ಈಗ ನಮ್ಮ ಪಿಜ್ಜಾಗಳು ಶ್ರೇಣಿಯನ್ನು ಪಡೆದರು.

337
00:16:25,897 --> 00:16:27,730
ನಾನು ರೀತಿಯ ಇದು ಕೂಡಿಸಿದ ಬಂದಿದೆ
ಅಲ್ಲಿ ಮೂಲೆಯಲ್ಲಿ

338
00:16:27,730 --> 00:16:31,080
ಆದ್ದರಿಂದ ನಾವು ತ್ವರಿತ ಉದಾಹರಣೆಗೆ ಮಾಡಲು ಬಳಸಬಹುದು.

339
00:16:31,080 --> 00:16:36,420
ನಾನು foreach ($ ಪಿಜ್ಜಾಗಳು ಹೇಳಿದರೆ
$ ಪಿಜ್ಜಾ), ಜೊತೆಗೆ, ಏನು ನಡೆಯುತ್ತಿದೆ?

340
00:16:36,420 --> 00:16:42,400
ನಾನು ಪ್ರತಿ ಮೂಲಕ ಮರಳಿ ಪಡೆಯಲಿದ್ದೇನೆ
ಸರಣಿ $ ಪಿಜ್ಜಾಗಳು ಒಂದು ಅಂಶ,

341
00:16:42,400 --> 00:16:46,670
ಹೀಗೆ ಮಾಡುತ್ತ, ನಾನು ಕರೆ ಪಡೆಯಲಿದ್ದೇನೆ
ಪ್ರತಿ ಅಂಶ, ನಾನು ಒಳಗೆ ಮನುಷ್ಯ

342
00:16:46,670 --> 00:16:49,400
ಲೂಪ್ ಎಂದು ದೇಹದ, ಪಿಜ್ಜಾ $.

343
00:16:49,400 --> 00:16:52,440
>> ಆದ್ದರಿಂದ ಒಂದು ರೀತಿಯ ಇಲ್ಲಿದೆ
ಸ್ಟ್ಯಾಂಡ್ ನಲ್ಲಿ, ಮರುಸ್ಥಾಪನೆ, ಎಂದು $ ಪಿಜ್ಜಾ

344
00:16:52,440 --> 00:16:59,140
ಒಂದು ಸ್ಟ್ಯಾಂಡ್ ನಲ್ಲಿ ಹೇಳುವ ಆಗಿದೆ
$ ಪಿಜ್ಜಾಗಳು ಚದರ ಬ್ರಾಕೆಟ್ಗಳನ್ನು $ ನಾನು

345
00:16:59,140 --> 00:17:03,370
ನಾವು ಲೂಪ್, ಅಲ್ಲಿ ನಾವು ಒಂದು ಬಳಸಿಕೊಂಡು ವೇಳೆ
ಈ ಸಂದರ್ಭದಲ್ಲಿ $ ನಾನು = 0 ಗೆ, ಹೋಗಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ,

346
00:17:03,370 --> 00:17:06,089
$ ನಾನು 3 =.

347
00:17:06,089 --> 00:17:09,780
ನಾವು ಪ್ರಮುಖ ಮೌಲ್ಯ ಜೋಡಿ ಹೊಂದಿರಲಿಲ್ಲ ವೇಳೆ
ಇಲ್ಲಿ, ಈ ಅಂಶ 0, 1, 2, 3 ಎಂದು,

348
00:17:09,780 --> 00:17:16,390
ಮತ್ತು ನಾವು ಹೋಗಲು ಲೂಪ್ ಒಂದು ಬಳಸಬಹುದು
$ ಪಿಜ್ಜಾಗಳು 0, $ ಪಿಜ್ಜಾಗಳು 1, $ ಪಿಜ್ಜಾಗಳು 2,

349
00:17:16,390 --> 00:17:17,750
$ ಪಿಜ್ಜಾಗಳು 3.

350
00:17:17,750 --> 00:17:23,130
ಈಗ ಕೇವಲ ಪಿಜ್ಜಾ ಆದೇಶಿಸುವ ಡಾಲರ್ಗಳಿಗೆ
ಪ್ರತ್ಯೇಕ ಕೀಲಿ.

351
00:17:23,130 --> 00:17:25,630
>> ಹಾಗಾಗಿ ಈ ಔಟ್ ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ?

352
00:17:25,630 --> 00:17:29,030
ನಾನು $ ಪಿಜ್ಜಾ ಔಟ್ ಮುದ್ರಿಸುವ ನಾನು.

353
00:17:29,030 --> 00:17:35,270
ನಾನು at-- ಹುಡುಕಲು ನಾನು
ನಾನು, $ ಪಿಜ್ಜಾಗಳು $ ಮುದ್ರಿಸುತ್ತದೆ?

354
00:17:35,270 --> 00:17:35,770
ರೈಟ್?

355
00:17:35,770 --> 00:17:38,680
ನಾನು ಮುದ್ರಿಸುತ್ತದೆ ಪಡೆಯಲಿದ್ದೇನೆ
ಪಿಜ್ಜಾಗಳು ಇತ್ ಅಂಶ,

356
00:17:38,680 --> 00:17:40,070
ನಾನು ಮುದ್ರಿಸಲು ನಾನು?

357
00:17:40,070 --> 00:17:42,580
ನಾನು ಮುದ್ರಿಸುತ್ತದೆ ಪಡೆಯಲಿದ್ದೇನೆ
ಆ ಸ್ಥಳ ಮೌಲ್ಯಗಳನ್ನು, ಬಲ?

358
00:17:42,580 --> 00:17:45,370
ನಾವು ಮಾಡುವ ವೇಳೆ ಲೈಕ್
ಸಿ ಸಂದರ್ಭದಲ್ಲಿ ಈ,

359
00:17:45,370 --> 00:17:49,786
ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ನಮ್ಮ iterator ಬಳಸಬೇಡಿ
ವೇರಿಯಬಲ್, ನಾನು = 0, ನಾನು 3 ಕಡಿಮೆ ಇಂಟ್

360
00:17:49,786 --> 00:17:52,900
ನಾನು 0, 1, 2, 3 ಮುದ್ರಿಸುತ್ತದೆ, ++.

361
00:17:52,900 --> 00:17:57,500
ನಾವು ಸರಣಿ 0 ಮುದ್ರಿಸುವ ಬಳಸುತ್ತಿದ್ದರೆ
ಸರಣಿ 1, ಸರಣಿ 2, ಸರಣಿ 3.

362
00:17:57,500 --> 00:17:59,580
ಆದ್ದರಿಂದ ಈ ಔಟ್ ಮುದ್ರಿಸುತ್ತದೆ ಏನು ಇದು.

363
00:17:59,580 --> 00:18:01,150
ಇದು ಬೆಲೆಗಳ ಪಟ್ಟಿ ಇಲ್ಲಿದೆ.

364
00:18:01,150 --> 00:18:05,750
8,99 9.99, 10.99, 11,99.

365
00:18:05,750 --> 00:18:06,900
>> ಈಗ ಇಲ್ಲಿ ಒಂದು ತ್ವರಿತ ಟಿಪ್ಪಣಿ.

366
00:18:06,900 --> 00:18:10,900
ಒಂದು foreach ಲೂಪ್ ಅಗತ್ಯವಾಗಿ ಮಾಡುವುದಿಲ್ಲ
ಸಲುವಾಗಿ ವಿಷಯಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

367
00:18:10,900 --> 00:18:12,770
ಇದು ಭರವಸೆ ವಿಶೇಷವೇನು.

368
00:18:12,770 --> 00:18:13,550
ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಮಾಡುತ್ತದೆ.

369
00:18:13,550 --> 00:18:17,667
ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಸಲುವಾಗಿ ಆಧರಿಸಿ
ಇದು ಅಂಶಗಳನ್ನು ಶ್ರೇಣಿಯಲ್ಲಿನ ಸೇರಿಸಲಾಗುತ್ತದೆ,

370
00:18:17,667 --> 00:18:18,750
ಆದ್ದರಿಂದ ಕೇವಲ ಮನಸ್ಸಿನಲ್ಲಿ ಆ ಪಡೆದಿವೆ.

371
00:18:18,750 --> 00:18:20,830
ಇದು ಸಲುವಾಗಿ ಇರಬಹುದು.

372
00:18:20,830 --> 00:18:23,930
ಆದರೆ foreach ಲೂಪ್ ತಿರುಗಿ ಕಾಣಿಸುತ್ತದೆ
ಪ್ರತಿಯೊಂದು ಅಂಶ ಅಡ್ಡಲಾಗಿ

373
00:18:23,930 --> 00:18:25,060
ಪ್ರಶ್ನೆ ರಚನೆಯ.

374
00:18:25,060 --> 00:18:27,980
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಮತ್ತೆ,
ವ್ಯೂಹ $ ಪಿಜ್ಜಾಗಳು ಆಗಿದೆ.

375
00:18:27,980 --> 00:18:32,920
>> ನಾನು, ಆದರೂ, ವಾಕ್ಯ ಬದಲಾಯಿಸಬಹುದು
ನಾನು ಕೀಲಿ ಮತ್ತು ಮೌಲ್ಯ ಎರಡೂ ಬಯಸುವ.

376
00:18:32,920 --> 00:18:37,179
ಬದಲಿಗೆ $ ಪಿಜ್ಜಾಗಳು ಹೇಳುವುದರ
$ ಪಿಜ್ಜಾ, ನಾನು ಈ ಹೇಳಬಹುದು.

377
00:18:37,179 --> 00:18:39,470
ಮತ್ತು ನೀವು ನಾನು ನೀವು ಏನನ್ನು ನೋಡಲು ವೇಳೆ
ಇಲ್ಲಿ ಹಸಿರು ಹೈಲೈಟ್,

378
00:18:39,470 --> 00:18:42,130
ಇದು ಒಂದು ಪ್ರಮುಖ ಮೌಲ್ಯ ಜೋಡಿ ಮ್ಯಾಪಿಂಗ್ ತೋರುತ್ತಿದೆ.

379
00:18:42,130 --> 00:18:45,980
ಮತ್ತು ಆದ್ದರಿಂದ ನೀವು ನೀವು ಅಲ್ಲ ಸಹ
ಸಂಪೂರ್ಣವಾಗಿ ಅದನ್ನು ನಡೆಯುತ್ತಿದೆ ಖಚಿತವಾಗಿ,

380
00:18:45,980 --> 00:18:49,300
ನೀವು ಬಹುಶಃ ಊಹೆ ಮಾಡಬಹುದು
ಎಂದು $ ಮೇಲೇರಿ ಹೋಗುತ್ತದೆ

381
00:18:49,300 --> 00:18:53,800
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಪ್ರಮುಖ ಎಂದು ಮತ್ತು
$ ಬೆಲೆ ಮೌಲ್ಯವನ್ನು ಎಂದು ನಾನು.

382
00:18:53,800 --> 00:18:59,200
ಹಾಗಾಗಿ ಈಗ ಪ್ರತಿ ಅಂಶ ಆದೇಶಿಸುವ ಬಾಗುತ್ತೇನೆ
$ ಒಂದು ಪ್ರಮುಖ ಮೌಲ್ಯ ಜೋಡಿ ಎಂದು ಪಿಜ್ಜಾಗಳು,

383
00:18:59,200 --> 00:19:03,900
ಮತ್ತು ಈಗ ನಾನು ಪ್ರಮುಖ ಉಲ್ಲೇಖಿಸಬಹುದು ಮತ್ತು
ಮೌಲ್ಯ, ಅವುಗಳು ಸೂಕ್ತ,

384
00:19:03,900 --> 00:19:05,590
ಉದಾಹರಣೆಗೆ, ಅನುಸರಿಸುತ್ತದೆ.

385
00:19:05,590 --> 00:19:10,170
>> "ಒಂದು ಇಡೀ" - ಈ ಸಾಕಷ್ಟು ಎಂದು
ಮುದ್ರಣ ಇಲ್ಲಿ "ಒಂದು ಇಡೀ" ವಿಶೇಷವೇನು

386
00:19:10,170 --> 00:19:17,300
ಅಗ್ರ ನಂತರ ಬೆಲೆ, ಮತ್ತು "ಪಿಜ್ಜಾ $ ಖರ್ಚಾಗುತ್ತದೆ"
ನಾನು ಒಂದು ಅವಧಿಯಲ್ಲಿ ಮತ್ತು ಒಂದು backslash N ಮುದ್ರಿಸುತ್ತದೆ.

387
00:19:17,300 --> 00:19:23,420
ಈಗ, ಸೂಚನೆ ಮತ್ತೆ ನಾನು ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುತ್ತದೆ
ಪ್ರಮುಖ, $ ಮೇಲೇರಿ, ಮತ್ತು ಈ ಕೆಳಗಿನ, $ ಬೆಲೆ.

388
00:19:23,420 --> 00:19:26,647
ನೀವು ಏನು ಈ ಊಹೆ ಮಾಡಬಹುದು
ಔಟ್ ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ?

389
00:19:26,647 --> 00:19:29,480
ಮುದ್ರಣ ಹೇಳಿಕೆಗಳು ಬಹಳಷ್ಟು ಇಲ್ಲ,
ಆದರೆ ಕೇವಲ ಒಂದು ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ಎನ್ ಇಲ್ಲ,

390
00:19:29,480 --> 00:19:33,410
ಆದ್ದರಿಂದ ಅದರ ಮೇಲೆ ಏನೋ ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು
ಕೋಡ್ ಒಂದು ಸಾಲಿನ ಮೇಲೆ entire--.

391
00:19:33,410 --> 00:19:36,965
>> ನಾನು ಪ್ರಮುಖ ಉಲ್ಲೇಖಿಸಬಹುದು ವೇಳೆ
ಮತ್ತು ಮೌಲ್ಯವನ್ನು, ನಂತರ ಈಗ,

392
00:19:36,965 --> 00:19:39,090
ಬದಲಿಗೆ ಕೇವಲ ಸಮರ್ಥವಾಗಿ
ಬೆಲೆ ಮುದ್ರಿಸುತ್ತದೆ,

393
00:19:39,090 --> 00:19:41,330
ನಾನು ಈ ರೀತಿಯ ಮುದ್ರಿಸುತ್ತದೆ.

394
00:19:41,330 --> 00:19:43,780
"ಒಂದು ಇಡೀ ಚೀಸ್ ಪಿಜ್ಜಾ $ 8,99 ಖರ್ಚಾಗುತ್ತದೆ."

395
00:19:43,780 --> 00:19:47,150
ಮತ್ತು ಈಗ ನಾನು keys-- ಎಲ್ಲಾ ಬಳಸಿಕೊಂಡು ಬಾಗುತ್ತೇನೆ
ಚೀಸ್, ಪೆಪ್ಪೆರೋನಿ, ತರಕಾರಿ,

396
00:19:47,150 --> 00:19:49,640
ಎಮ್ಮೆ chicken-- ಮತ್ತು ಮೌಲ್ಯಗಳು.

397
00:19:49,640 --> 00:19:53,980
8,99 9.99, 10.99, 11,99 ಆದ್ದರಿಂದ
ಕೇವಲ ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಇಲ್ಲಿದೆ

398
00:19:53,980 --> 00:19:57,840
ಒಂದು foreach ಲೂಪ್ ಮಾಡಲು ಎಂದು ಬದಲಿಗೆ
ಕೇವಲ, ನೀವು ಮೌಲ್ಯಗಳನ್ನು ಪ್ರವೇಶ ನೀಡುವ

399
00:19:57,840 --> 00:20:02,950
ಇದು ನೀವು ನೀಡುತ್ತದೆ you-- ಇದು ಕೇವಲ ನೀಡುತ್ತದೆ
ಕೀಸ್ ಮತ್ತು ಮೌಲ್ಯಗಳನ್ನು ಪ್ರವೇಶವನ್ನು.

400
00:20:02,950 --> 00:20:04,411
>> ಆದ್ದರಿಂದ ಮಾಹಿತಿ ಮುದ್ರಿಸುವ.

401
00:20:04,411 --> 00:20:07,410
ನಾನು ಈಗಾಗಲೇ ಒಂದೆರಡು ಮಾಡಿದ
ವಿವಿಧ ರೀತಿಯಲ್ಲಿ, ನೀವು ಸೂಚಿಸಿದ್ದೇವೆ ಇರಬಹುದು.

402
00:20:07,410 --> 00:20:11,080
ಎರಡು ಕಾರ್ಯಗಳನ್ನು ನಾವು ಮುಖ್ಯವಾಗಿ ಬಂದಿದೆ
ಮುದ್ರಣ ಮತ್ತು ಪ್ರತಿಧ್ವನಿ ಕಂಡುಬರುತ್ತದೆ.

403
00:20:11,080 --> 00:20:14,380
ಮತ್ತು ಬಹುಮಟ್ಟಿಗೆ ಎಲ್ಲಾ ಆಶಯಗಳು ಮತ್ತು
ಉದ್ದೇಶಗಳಿಗಾಗಿ, ಅವರು ಒಂದೇ ಆರ್.

404
00:20:14,380 --> 00:20:17,130
They're-- ಅತಿ ಸೂಕ್ಷ್ಮವಾದ ಇಲ್ಲಿದೆ
ಸಹ ಯೋಗ್ಯವಾಗಿರುವುದಿಲ್ಲ ಎಂದು ವ್ಯತ್ಯಾಸ

405
00:20:17,130 --> 00:20:21,130
ಮೂಲತಃ ಎಲ್ಲೆಡೆ ಬರುವುದು, ಆದರೆ
ನೀವು ಬಹುಶಃ ಬಳಸಬಹುದು ನೀವು ಮುದ್ರಣ ಬಳಸಬಹುದು

406
00:20:21,130 --> 00:20:22,370
ಹಾಗೂ ಪ್ರತಿಧ್ವನಿ.

407
00:20:22,370 --> 00:20:23,610
>> ಮತ್ತು ಕೇವಲ ಎರಡು ಅಲ್ಲ.

408
00:20:23,610 --> 00:20:26,970
ಪಿಎಚ್ಪಿ ವಿವಿಧ ಬಹಳಷ್ಟು ಹೊಂದಿದೆ
ವಿಷಯಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ರೀತಿಯಲ್ಲಿ,

409
00:20:26,970 --> 00:20:30,520
ಮತ್ತು ಇದು ಸಂಯೋಜಿಸಲು ಮಾರ್ಗಗಳನ್ನು ಹೊಂದಿದೆ
ಸ್ಟ್ರಿಂಗ್ ಮಧ್ಯದಲ್ಲಿ ಮಾರ್ಪಡಿಸಬಹುದಾದ.

410
00:20:30,520 --> 00:20:32,860
ಆದ್ದರಿಂದ ಸಿ ಮರುಪಡೆಯಲು, ನೀವು
ಯಾವ ಕಾರ್ಯ ಮರೆಯದಿರಿ

411
00:20:32,860 --> 00:20:37,580
ನಾವು ಅಸ್ಥಿರ ಬದಲಿಗೆ ಬಳಸಬಹುದು
ವಿಷಯಗಳನ್ನು ನಾವು ಮುದ್ರಿಸುತ್ತದೆ ಬಯಸುವ?

412
00:20:37,580 --> 00:20:40,160
ನೀವು ಬಹುಶಃ ಈ ಬಳಸಲು
ಸಾಕಷ್ಟು ಕೆಲಸ.

413
00:20:40,160 --> 00:20:42,290
printf, ಬಲ?

414
00:20:42,290 --> 00:20:45,290
ಈ ನಾವು ಒಳಗೆ ಮೊದಲು ಏನು
ನಮ್ಮ foreach ಲೂಪ್ ಸನ್ನಿವೇಶದಲ್ಲಿ.

415
00:20:45,290 --> 00:20:48,000
ನಾವು ಈ ಐದು ಹೊಂದಿತ್ತು
ಪ್ರತ್ಯೇಕ ಮುದ್ರಣ ಹೇಳಿಕೆಗಳನ್ನು

416
00:20:48,000 --> 00:20:50,330
ಮಾತ್ರ ಏಕೆಂದರೆ
ರೀತಿಯಲ್ಲಿ ನಾನು ಸಮಯದಲ್ಲಿ ತಿಳಿದಿತ್ತು

417
00:20:50,330 --> 00:20:52,450
ಹೇಗೆ ಸಂದೇಶಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

418
00:20:52,450 --> 00:20:59,560
ನಾನು ಸಂಯೋಜಿಸಲು ಹೇಗೆ ತಿಳಿದಿರಲಿಲ್ಲ
ನನ್ನ ಪಿಎಚ್ಪಿ ಕೋಡ್ ಒಳಗೆ ಅಗ್ರ ವೇರಿಯಬಲ್ $.

419
00:20:59,560 --> 00:21:03,700
ಜೊತೆಗೆ, ನಾನು ಕಾಡು ಊಹೆ ತೆಗೆದುಕೊಂಡರೆ,
printf, ಇದು ವಾಸ್ತವವಾಗಿ ಕೆಲಸ ಎಂದು.

420
00:21:03,700 --> 00:21:08,980
printf ನಾನು ಬಳಸಬಹುದಾದ ಕ್ರಿಯೆಯಾಗಿದೆ
ಪಿಎಚ್ಪಿ, ನಾನು ಸಿ ಬಳಸಬಹುದು ಇಷ್ಟ

421
00:21:08,980 --> 00:21:11,880
>> ಆದ್ದರಿಂದ ಈ ರೀತಿಯ, printf
ಪುನಃ ನಾವು ಪರಿಚಿತವಾಗಿರುವ ಆರ್.

422
00:21:11,880 --> 00:21:16,420
ಮೊದಲ% s ಬದಲಿಸಲಾಗಿದೆ
$ ಮೇಲೇರಿ ಮೌಲ್ಯವನ್ನು.

423
00:21:16,420 --> 00:21:19,700
ಎರಡನೇ% s ಬದಲಿಸಲಾಗಿದೆ
$ ಬೆಲೆಯ ಮೌಲ್ಯವನ್ನು.

424
00:21:19,700 --> 00:21:22,630
ಮತ್ತು ಆದ್ದರಿಂದ ನಾನು interpellating ಬಾಗುತ್ತೇನೆ,
ಇದು ಕೇವಲ ಒಂದು ಅಲಂಕಾರಿಕ ಮಾರ್ಗವಾಗಿದೆ

425
00:21:22,630 --> 00:21:25,400
ಹೇಳುವ ನಾನು ಅಂಟದಂತೆ ನಾನು
ಆ ಸ್ಥಳ ಮಾರ್ಪಡಿಸಬಹುದಾದ.

426
00:21:25,400 --> 00:21:31,000
ಹಾಗಾಗಿ ಅಗ್ರ ರಲ್ಲಿ $ ಪ್ಲಗಿಂಗ್ ಬಾಗುತ್ತೇನೆ ಅಲ್ಲಿ
ಕೆಂಪು% s $ ಬೆಲೆ ಅಲ್ಲಿ ನೀಲಿ% s ಮತ್ತು

427
00:21:31,000 --> 00:21:36,060
, ಮತ್ತು ನಂತರ ನಾನು ಸಂದೇಶವನ್ನು ಹೋಗಬಹುದು,
"ಒಂದು ಇಡೀ ಚೀಸ್ ಪಿಜ್ಜಾ $ 8,99 ಖರ್ಚಾಗುತ್ತದೆ."

428
00:21:36,060 --> 00:21:37,750
>> ನಾನು ಆದರೂ, ಅದನ್ನು ಕೇವಲ ರೀತಿಯಲ್ಲಿ.

429
00:21:37,750 --> 00:21:39,760
ಬಹುಶಃ ನಾನು ಈ ವಿಧಾನವನ್ನು ಬಳಸಲು ಬಯಸುತ್ತೇನೆ.

430
00:21:39,760 --> 00:21:44,890
ಇದು ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾಗಿ ಎಂಬುದನ್ನು ವಾಸ್ತವವಾಗಿ
ವೇರಿಯಬಲ್ ಅಡ್ಡಪ್ರಶ್ನೆ ಕೇಳುವುದು ಯಾ ಆ ಅಡ್ಡಪ್ರಶ್ನೆ ಕರೆಯಲಾಗುತ್ತದೆ.

431
00:21:44,890 --> 00:21:45,690
ನಾನು ಪ್ರತಿಧ್ವನಿ ಬಳಸಬಹುದು.

432
00:21:45,690 --> 00:21:47,737
ನಾವು ನೋಡುತ್ತಾರೆ ಎಂದು ನಾನು ತುಂಬಾ ಒಂದು ಮುದ್ರಣ ಬಳಸಬಹುದಾಗಿತ್ತು.

433
00:21:47,737 --> 00:21:48,820
ಆದರೆ ಇಲ್ಲಿ ಏನು ನಡೆಯುತ್ತಿದೆ?

434
00:21:48,820 --> 00:21:51,520
>> ಎಲ್ಲಾ ಮೊದಲ, ನಾನು ಹೊಂದಿವೆ
ಡಾಲರ್ ಚಿಹ್ನೆ ತಪ್ಪಿಸಿಕೊಳ್ಳಲು.

435
00:21:51,520 --> 00:21:55,140
ನಾವು ವಾಸ್ತವವಾಗಿ ಆಗ, ಮರೆಯದಿರಿ
ಪಿಜ್ಜಾಗಳು ಬೆಲೆಗಳು ಮುದ್ರಿಸುವ,

436
00:21:55,140 --> 00:21:59,370
ನಾನು ವಾಸ್ತವವಾಗಿ ಅವುಗಳನ್ನು ಫಾರ್ಮಾಟ್ ಮಾಡಲಾಯಿತು
ಒಂದು ಡಾಲರ್ ಚಿಹ್ನೆ ವಿತ್ತೀಯ ಅಂಕಿ.

437
00:21:59,370 --> 00:22:05,635
ಆದರೆ ನಾವು ಡಾಲರ್ ಸೈನ್ಸ್ ಬಳಸುತ್ತಿರುವ
ಪಿಎಚ್ಪಿ ವೇರಿಯಬಲ್ ಹೆಸರುಗಳು ಪ್ರತಿನಿಧಿಸಲು,

438
00:22:05,635 --> 00:22:08,010
ಮತ್ತು ವಿಶೇಷವಾಗಿ ನಾನು ಇರುವಾಗ
ಕರ್ಲಿ ಈ ವಿಧಾನವನ್ನು ಬಳಸಿ

439
00:22:08,010 --> 00:22:10,040
ಬ್ರೇಸ್ ವೇರಿಯಬಲ್
ಅಡ್ಡಪ್ರಶ್ನೆ ಕೇಳುವುದು ಯಾ ಆ ಅಡ್ಡಪ್ರಶ್ನೆ ವಿಧಾನ, ನಾನು ಅಗತ್ಯವಿದೆ

440
00:22:10,040 --> 00:22:13,490
ಹಾಗಾಗದೆ ನನ್ನ ಡಾಲರ್ ಚಿಹ್ನೆ ತಪ್ಪಿಸಿಕೊಳ್ಳಲು
ನಾನು ವೇರಿಯಬಲ್ ಬಗ್ಗೆ ಬಾಗುತ್ತೇನೆ ಆಲೋಚಿಸುತ್ತೀರಿ.

441
00:22:13,490 --> 00:22:16,920
ಇದು ವಾಸ್ತವವಾಗಿ ವಿಶೇಷವೇನು
ಅಕ್ಷರಶಃ ಡಾಲರ್ ಚಿಹ್ನೆ ಮುದ್ರಿಸಲು.

442
00:22:16,920 --> 00:22:19,530
>> ಆದ್ದರಿಂದ ರೀತಿಯ ಅದನ್ನು ಸದೃಶವೆಂದು
ನೀವು ಕೊನೆಯಲ್ಲಿ ನೋಡಿದರು.

443
00:22:19,530 --> 00:22:22,832
ಇದು ನಿಜವಾಗಿ
ಮುದ್ರಣ backslash N, ಬಲ?

444
00:22:22,832 --> 00:22:24,290
ಇದು ಹೊಸ ಲೈನ್ ಪಾತ್ರದ ಮುದ್ರಿಸುತ್ತದೆ.

445
00:22:24,290 --> 00:22:26,750
ಇದು ಹಿಂದಿರುಗಬಹುದೆಂದು is--
ಮುದ್ರಣ ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ಡಾಲರ್ ಚಿಹ್ನೆ,

446
00:22:26,750 --> 00:22:30,130
ಇದು ಕೇವಲ ಔಟ್ ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು
ಒಂದು ಡಾಲರ್ ಚಿಹ್ನೆ ಪಾತ್ರ.

447
00:22:30,130 --> 00:22:30,640
ಅದೇ ಕಲ್ಪನೆ.

448
00:22:30,640 --> 00:22:32,760
ಅನುಕ್ರಮಗಳನ್ನು ಎಸ್ಕೇಪ್, ಏನು
ಈ ವಿಷಯಗಳನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ.

449
00:22:32,760 --> 00:22:37,080
>> ಆದರೆ ನಾನು ಮಾಡುತ್ತಿರಲಿಲ್ಲ ನಾನು ಗಮನಕ್ಕೆ
% s ಬದಲಿ ಯಾವುದೇ ರೀತಿಯ,

450
00:22:37,080 --> 00:22:40,050
ನಾನು ಅಕ್ಷರಶಃ ಪ್ಲಗಿಂಗ್ ಬಾಗುತ್ತೇನೆ
ಈ ಅಸ್ಥಿರ.

451
00:22:40,050 --> 00:22:45,110
ಆದ್ದರಿಂದ this-- ಇಲ್ಲಿ ಏನಾಗಬಹುದು
, ಎಂದು $ topping-- ಮೌಲ್ಯವನ್ನು ಮತ್ತೆ

452
00:22:45,110 --> 00:22:48,390
ನಾವು ಇಲ್ಲಿಗೆ ಯಾವ ಅನುಗುಣವಾಗಿ
ಆದ್ದರಿಂದ far-- ಚೀಸ್ ಬಗ್ಗೆ ಹೋಗಬಹುದು

453
00:22:48,390 --> 00:22:49,720
ಅಲ್ಲಿ ಕೇಳಿಬರುತ್ತದೆ.

454
00:22:49,720 --> 00:22:54,780
ಮತ್ತು $ ಬೆಲೆ ಏನೇ ಮೌಲ್ಯವನ್ನು ಎಂದು
ಪಿಜ್ಜಾಗಳು ನಲ್ಲಿ, ಚೌಕಾಕಾರದ, ಚೀಸ್,

455
00:22:54,780 --> 00:22:56,270
ಇದು 8.99 ಆಗಿತ್ತು.

456
00:22:56,270 --> 00:23:01,860
ಮತ್ತು ಆದ್ದರಿಂದ ಇದು ಮುದ್ರಿಸುತ್ತದೆ ಎಂದು
"ಒಂದು ಇಡೀ ಚೀಸ್ ಪಿಜ್ಜಾ $ 8,99 ಖರ್ಚಾಗುತ್ತದೆ."

457
00:23:01,860 --> 00:23:05,160
ನಾನು ಹೇಳಿದ ಹಾಗೆ, ನಾನು ಬಳಸಬಹುದಾಗಿತ್ತು
ಬದಲಿಗೆ ಪ್ರತಿಧ್ವನಿ ಇಲ್ಲಿ ಮುದ್ರಿಸಲು,

458
00:23:05,160 --> 00:23:08,040
ಮತ್ತು ಕಾರ್ಯಗಳನ್ನು ಎಂದು
ಒಂದೇ ಬಹುಮಟ್ಟಿಗೆ.

459
00:23:08,040 --> 00:23:09,660
ಇದು ಒಂದೇ ಮುದ್ರಿಸುತ್ತದೆ ಎಂದು.

460
00:23:09,660 --> 00:23:12,680
>> ಅದನ್ನು ಮತ್ತೊಂದು ರೀತಿಯಲ್ಲಿ ಇಲ್ಲ,
ಮತ್ತು ಈ ಮತ್ತೊಂದು ಅನುಕೂಲವೆಂದರೆ

461
00:23:12,680 --> 00:23:14,710
ಪಿಎಚ್ಪಿ ತಂತಿಗಳನ್ನು ಕೆಲಸ.

462
00:23:14,710 --> 00:23:17,130
ನಾವು ತಂತುವಿನ ಪೋಣಿಸುವಿಕೆಯ ಮಾಡಬಹುದು.

463
00:23:17,130 --> 00:23:19,660
ನಾವು, ಸಿ ಈ ಇಲ್ಲ
strcat ಎಂಬ ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು,

464
00:23:19,660 --> 00:23:21,180
ಆದರೆ ಮತ್ತೆ, ನಾವು ಹೊಂದಿತ್ತು
ಪ್ರತ್ಯೇಕ ಕಾರ್ಯಗಳನ್ನು ಕರೆ.

465
00:23:21,180 --> 00:23:22,640
ಅದನ್ನು ಇಡೀ ಅವ್ಯವಸ್ಥೆ ಆಗಿತ್ತು.

466
00:23:22,640 --> 00:23:24,590
ನಾವು ಹೊಂದಿತ್ತು string.h ಪೌಂಡ್ ಸೇರಿವೆ.

467
00:23:24,590 --> 00:23:25,780
ಅದು ಸರಿ, ಒಂದು ಉತ್ಪಾದನಾ?

468
00:23:25,780 --> 00:23:30,070
ಆದರೆ ಈಗ ನಾನು ಈ ಡಾಟ್ ಆಯೋಜಕರು ಬಳಸಬಹುದು
ಒಟ್ಟಿಗೆ ತಂತಿಗಳನ್ನು concatenate ಗೆ.

469
00:23:30,070 --> 00:23:34,910
>> ಹಾಗಾಗಿ "ಒಂದು ಇಡೀ" concatenating ಬಾಗುತ್ತೇನೆ ಮತ್ತು
ನಂತರ ಯಾವುದೇ $ ಮೇಲೇರಿ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ

470
00:23:34,910 --> 00:23:38,860
ತದನಂತರ ಮತ್ತೊಂದು
ಸ್ಟ್ರಿಂಗ್, "ಪಿಜ್ಜಾ ವೆಚ್ಚ $"

471
00:23:38,860 --> 00:23:42,340
ತದನಂತರ concatenating ಯಾವುದೇ
$ ಬೆಲೆ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ

472
00:23:42,340 --> 00:23:45,670
ತದನಂತರ ಅತ್ಯಂತ ಕೊನೆಯಲ್ಲಿ ನಾನು
ಅವಧಿಯಲ್ಲಿ ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ಎನ್ ಮೇಲೆ ಅದಕ್ಕೆ ದಾರ ಕಟ್ಟಬೇಕಾಗುತ್ತಿತ್ತು.

473
00:23:45,670 --> 00:23:47,926
ಮತ್ತು ಆದ್ದರಿಂದ ಇದು ಎಂದು
"ಒಂದು ಇಡೀ" ಮುದ್ರಿಸುತ್ತದೆ - ಮತ್ತೆ,

474
00:23:47,926 --> 00:23:50,550
ನಾವು ಮೊದಲ ಬಗ್ಗೆ ಬಳಸುತ್ತಿದ್ದರೆ
ಎಂದು ಪಿಜ್ಜಾಗಳು ರಚನೆಯ ಅಂಶ

475
00:23:50,550 --> 00:23:54,710
"ಒಂದು ಇಡೀ ಚೀಸ್ ಪಿಜ್ಜಾ $ 8,99 ಖರ್ಚಾಗುತ್ತದೆ."

476
00:23:54,710 --> 00:24:01,260
ಅವಧಿಯ, ಮತ್ತೆ backslash N, ಜೊತೆಗೆ
$ ಮೇಲೇರಿ ಮತ್ತು $ ಬೆಲೆ ಬದಲಿಯಾಗಿ

477
00:24:01,260 --> 00:24:06,580
ನಾವು ನಮ್ಮ foreach ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಏನು ಫಾರ್
ಪ್ರಮುಖ ಮೌಲ್ಯ ಜೋಡಿ ಮ್ಯಾಪಿಂಗ್ ಲೂಪ್.

478
00:24:06,580 --> 00:24:08,050
>> ಪಿಎಚ್ಪಿ ಕಾರ್ಯಗಳನ್ನು ನಿಭಾಯಿಸಬಲ್ಲದು.

479
00:24:08,050 --> 00:24:11,250
ಕಾರ್ಯಗಳು ರೀತಿಯ ಎಂದು
ಸಿ ಅವಿಭಾಜ್ಯ, ಎಂದು ನಾವು ನೋಡಿದ.

480
00:24:11,250 --> 00:24:14,870
ಅಸ್ಥಿರ ನಮಗೂ ಅಗತ್ಯವಿಲ್ಲ
, ಕ್ರಿಯೆಯ ರಿಟರ್ನ್ ವಿಧ ಸೂಚಿಸಿ

481
00:24:14,870 --> 00:24:16,350
ಇದು ನಿಜವಾಗಿಯೂ ಅಪ್ರಸ್ತುತವಾಗುತ್ತದೆ ಏಕೆಂದರೆ.

482
00:24:16,350 --> 00:24:18,660
ನಾವು ಸೂಚಿಸಲು
ಯಾವುದೇ ನಿಯತಾಂಕಗಳನ್ನು ಡೇಟಾ ಪ್ರಕಾರಗಳು,

483
00:24:18,660 --> 00:24:21,410
ಅವರು ನಿಜವಾಗಿಯೂ ಏಕೆಂದರೆ
ವಿಷಯವಾಗಿರುವ, ಪಿಎಚ್ಪಿ ನೋಡಿರುವ ಹಾಗೆ.

484
00:24:21,410 --> 00:24:24,510
ಪ್ರತಿ ಕಾರ್ಯ ಪರಿಚಯಿಸಲಾಗಿದೆ
ಕಾರ್ಯ ಕೀವರ್ಡ್.

485
00:24:24,510 --> 00:24:27,920
ನಾವು ಪಿಎಚ್ಪಿ ಸೂಚಿಸುತ್ತದೆ ಹೇಗೆ
ನಾವು ಬಗ್ಗೆ ನೀವು ಕ್ರಿಯೆಯಾಗಿದೆ.

486
00:24:27,920 --> 00:24:29,720
>> ನಾವು ಹೊಂದಿಲ್ಲ
ಎಲ್ಲಾ ಮುಖ್ಯ ಎದುರಿಸಲು,

487
00:24:29,720 --> 00:24:33,690
ಇಂಟರ್ಪ್ರಿಟರ್ ಏಕೆಂದರೆ, ಪಿಎಚ್ಪಿ
ನಿರೂಪಕರಾದ ಕೆಳಕ್ಕೆ ಕೆಲಸ,

488
00:24:33,690 --> 00:24:34,190
ಇರಲಿ.

489
00:24:34,190 --> 00:24:35,640
ನೋಡುವ ನೀವು ಮಾಡಬಹುದು
ಒಂದು ಕಾರ್ಯ ಕರೆ, ಇದು ಮಾಡುತ್ತೇವೆ

490
00:24:35,640 --> 00:24:37,850
ಕಾರ್ಯ ಕರೆ ಹುಡುಕಲು ಹೋಗಿ
ಅದನ್ನು ನಂತರ ಬಂದಾಗ.

491
00:24:37,850 --> 00:24:40,360
ಆದರೆ ಮೇಲಿನಿಂದ ಓದಲು ವಿಶೇಷವೇನು
ಕೆಳಗೆ, ನಾವು ಸೂಚಿಸಲು ಅಗತ್ಯವಿಲ್ಲ,

492
00:24:40,360 --> 00:24:41,500
ನೀವು ಆರಂಭಿಸಲು ಅಲ್ಲಿ ಇಲ್ಲಿ.

493
00:24:41,500 --> 00:24:46,700
ನೀವು ಸಾಲಿನ 1 ಆರಂಭಿಸಲು ನಿಮ್ಮ
ಪಿಎಚ್ಪಿ ಅಲ್ಲಿಂದ ಕೆಳಗೆ ಕೆಲಸ ಮತ್ತು.

494
00:24:46,700 --> 00:24:49,690
>> ಇಲ್ಲಿ ನಾವು ರಚಿಸಲು ಹೇಗೆ ಆಗಿದೆ
ಕಾರ್ಯ hard_square ಕರೆಯಲಾಗುತ್ತದೆ.

495
00:24:49,690 --> 00:24:54,100
ಇದು ಸ್ಪಷ್ಟವಾಗಿ ಒಂದು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ನಿಯತಾಂಕ, ನಾನು $ X ಎಂದು ನುಡಿದರು ಇದು.

496
00:24:54,100 --> 00:24:58,424
ಈ ಕ್ರಿಯೆ ಕೇವಲ ಜಟಿಲವಾಗಿದೆ
ವಿವಿಧ ವಿಷಯಗಳನ್ನು ವಿವರಿಸಲು.

497
00:24:58,424 --> 00:24:59,590
ನಾವು ಇನ್ನೂ ಹಿಂದಿರುಗುವ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿವೆ.

498
00:24:59,590 --> 00:25:00,870
ನಾನು ಇಲ್ಲಿ ಲೂಪ್ ಒಂದು ಬಳಸಿಕೊಂಡು ಬಾಗುತ್ತೇನೆ.

499
00:25:00,870 --> 00:25:04,970
ಆದರೆ ಮೂಲತಃ ಕೇವಲ, ಈ ಇಲ್ಲಿದೆ
ಕೇವಲ $ X ಬಾರಿ $ ಕ್ಷ ಆಗಬಹುದು.

500
00:25:04,970 --> 00:25:10,520
ನಾನು ವಾಸ್ತವವಾಗಿ ಕೇವಲ ಸೇರಿಸುವ ಮಾಡುತ್ತಿರುವೆ
ಎಕ್ಸ್ ಎಕ್ಸ್ ಬಾರಿ 0 ಅಥವಾ $ ಶೂನ್ಯ $ X ಬಾರಿ ಮಾಡಲು X.

501
00:25:10,520 --> 00:25:15,850
ಆದರೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿಖರವಾಗಿ
$ X ಬಾರಿ $ X ಗುಣಿಸಿದಾಗ ಅದೇ.

502
00:25:15,850 --> 00:25:18,700
ನಾನು ಇನ್ನೂ ಒಂದು ಮೌಲ್ಯವನ್ನು ಮರಳಬಹುದು,
ಈ ಸಂದರ್ಭದಲ್ಲಿ $ ಪರಿಣಾಮವಾಗಿ,

503
00:25:18,700 --> 00:25:22,060
ಮತ್ತು ನಾನು PHP ಯಲ್ಲಿನ ಕಾರ್ಯ ಮಾಡಿದ.

504
00:25:22,060 --> 00:25:24,160
>> ಇಲ್ಲಿ ನೀವು ಸಂದರ್ಭದಲ್ಲಿ ಇದನ್ನು ಬಳಸಬಹುದು ಹೇಗೆ.

505
00:25:24,160 --> 00:25:26,020
ಆದ್ದರಿಂದ ಬಹುಶಃ ನಾನು ಕೆಲವು ಪಿಎಚ್ಪಿ ಕಡತ ಒಳಗೆ ಮನುಷ್ಯ.

506
00:25:26,020 --> 00:25:29,240
ಆ ನೀಲಿ ಗಮನಿಸಿ
ನನ್ನ ಪಿಎಚ್ಪಿ ಡಿಲಿಮಿಟರ್ ಬಳಸಲಾಗುತ್ತದೆ ಬಂದಿದೆ,

507
00:25:29,240 --> 00:25:31,010
ಕೋನ ಆವರಣ ಪ್ರಶ್ನೆ ಗುರುತು ಪಿಎಚ್ಪಿ.

508
00:25:31,010 --> 00:25:35,180
ಆ ನಡುವೆ ಎಲ್ಲಾ
ನಾನು ಬರೆಯಲು ಬಯಸುವ ಪಿಎಚ್ಪಿ.

509
00:25:35,180 --> 00:25:37,840
ಹಾಗಾಗಿ ಸ್ಪಷ್ಟವಾಗಿ ಸಿಗುವುದು ಹೋಗುವ ಬಾಗುತ್ತೇನೆ
ನಾನು ಬಳಕೆದಾರರು ಪ್ರಾಂಪ್ಟ್ ಮಾಡಲು ಪಡೆಯಲಿದ್ದೇನೆ

510
00:25:37,840 --> 00:25:41,550
ನನಗೆ ಹಲವಾರು ಅಂಗಡಿ ನೀಡಲು
ವೇರಿಯಬಲ್, ವೇರಿಯಬಲ್ $ x ನಲ್ಲಿನ ಅಂಗಡಿ,

511
00:25:41,550 --> 00:25:43,320
ಯಾವುದೇ ಅವರು ನನಗೆ ನೀಡಿದ.

512
00:25:43,320 --> 00:25:48,590
ನಂತರ ನಾನು ಪ್ರತಿಧ್ವನಿಸುವಂತೆ ಪಡೆಯಲಿದ್ದೇನೆ
ಆ ಮೌಲ್ಯದ hard_square,

513
00:25:48,590 --> 00:25:50,370
ಮತ್ತು ಸ್ಪಷ್ಟವಾಗಿ ಹೋಗುವ
ಹೊಸ ಲೈನ್ ಸ್ಪಂದನ

514
00:25:50,370 --> 00:25:53,590
ಜೊತೆಗೆ, ಮತ್ತು ನಂತರ ನಾನು ಮಾಡುತ್ತೇವೆ
ಆದ್ದರಿಂದ hard_square ಕಾರ್ಯ

515
00:25:53,590 --> 00:25:55,550
ನಾನು ಮಾಡುತ್ತಾರೆ ಎಂದು
hard_square ಕರೆ,

516
00:25:55,550 --> 00:25:58,160
ಇದು ನಾನು ಬಗ್ಗೆ ನನಗೆ ತಿಳಿದಿಲ್ಲ.

517
00:25:58,160 --> 00:26:00,705
>> ಈಗ, ನಾನು ಇಲ್ಲ
ಈ ರೀತಿಯ.

518
00:26:00,705 --> 00:26:02,050
ಈ ಸ್ವಲ್ಪ ಭಿನ್ನವಾಗಿದೆ.

519
00:26:02,050 --> 00:26:04,190
ಸರಿಸುಮಾರು ನಿಖರವಾಗಿ ಇಲ್ಲಿದೆ
ನಾವು ಮೊದಲು ಕಂಡ ಅದೇ,

520
00:26:04,190 --> 00:26:08,400
X ಬದಲಿಗೆ ಕೇವಲ $ ಹೇಳುವ ಹೊರತುಪಡಿಸಿ
ಅಲ್ಲಿ ನಿಯತಾಂಕ hard_square ಎಂದು,

521
00:26:08,400 --> 00:26:11,730
ನಾನು $ X = 10 ಹೇಳುವ ನುಡಿದರು.

522
00:26:11,730 --> 00:26:14,330
ಆದ್ದರಿಂದ ಈ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ
ರಕ್ಷಣಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್,

523
00:26:14,330 --> 00:26:17,070
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು ಕಾವಲು
ದುರುದ್ದೇಶಪೂರಿತ ಬಳಕೆದಾರರು ವಿರುದ್ಧ.

524
00:26:17,070 --> 00:26:20,020
>> ಈ ಕೆಲವು ದೋಷ ಮಾಡಲು ಒಂದು ಮಾರ್ಗವಾಗಿದೆ
ನಾವು ಮಾಡಲಿಲ್ಲ ತಪಾಸಣೆ

525
00:26:20,020 --> 00:26:24,670
ಸಿ ಆಯ್ಕೆಯಾಗಿ ಹೊಂದಿವೆ ನಾವು ಸಾಧ್ಯವೋ ಎಂದಿಗೂ
ಏನೋ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ಸೂಚಿಸಲು.

526
00:26:24,670 --> 00:26:27,010
ನಾವು ಯಾವಾಗಲೂ ಪರಿಶೀಲಿಸಲು ಹೊಂದಿತ್ತು
ಎಂದು, ಉದಾಹರಣೆಗೆ,

527
00:26:27,010 --> 00:26:30,820
ನಾವು GetString ಕರೆ ಮಾಡಿದ ವೇಳೆ, ಇದು
ಅತ್ಯಂತ ಸರಿಯಾದ ತಕ್ಷಣ ನಾವು ನಂತರ

528
00:26:30,820 --> 00:26:33,300
, ನಾವು ಪರಿಶೀಲಿಸಿದ ಪರಿಶೀಲಿಸಿದ
ಸ್ಟ್ರಿಂಗ್ ಎಂದು

529
00:26:33,300 --> 00:26:35,504
ಬಳಕೆದಾರ ನಮಗೆ ನೀಡಿದ
ಶೂನ್ಯ ಸಮಾನವಾಗಿರುವುದಿಲ್ಲ

530
00:26:35,504 --> 00:26:37,920
ನಾವು ಆರಂಭಿಸಲು ಬಯಸುವುದಿಲ್ಲ ಏಕೆಂದರೆ
ಒಂದು ಶೂನ್ಯ ಸ್ಟ್ರಿಂಗ್ ಕೆಲಸ.

531
00:26:37,920 --> 00:26:39,670
>> ಇಲ್ಲಿ, ಈ ಒಂದು ದಾರಿ
ಎಂದು ರಕ್ಷಿಸಿಕೊಳ್ಳಲು.

532
00:26:39,670 --> 00:26:43,480
ಬಳಕೆದಾರ ನಮಗೆ ಏನೋ ಒದಗಿಸದಿದ್ದರೆ
ಹೇಗಾದರೂ, ನಾವು ಏನು ಮಾಡೋಣ?

533
00:26:43,480 --> 00:26:46,080
ವೆಲ್, ನಾವು ಹೇಳುತ್ತೇನೆ ಯಾವುದೇ
ಅವರು ನಮಗೆ ನೀಡಿಲ್ಲ,

534
00:26:46,080 --> 00:26:47,705
ನಾವು ಬದಲಿಗೆ 10 ಪ್ಲಗ್ ನೀನು.

535
00:26:47,705 --> 00:26:52,030
ಅವರು ನಮಗೆ ಈ ಕೆಳಗಿನ ನೀಡಿಲ್ಲ ಆದ್ದರಿಂದ,
ಕೇವಲ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ 10 ಬಳಸಿ. ಮತ್ತು ಇಲ್ಲಿ,

536
00:26:52,030 --> 00:26:53,940
ನಾನು ಮಾಡುವ ಬಾಗುತ್ತೇನೆ ಗಮನಿಸಿ
ಒಂದು hard_square ಕರೆ,

537
00:26:53,940 --> 00:26:55,980
ಆದರೆ ಯಾವುದೇ ಪ್ರಾಂಪ್ಟ್ ಇಲ್ಲ
ಬಳಕೆದಾರರಿಗೆ, ಬಲ?

538
00:26:55,980 --> 00:26:57,540
ನಾನು ಖಾಲಿ ಕರೆ ಮಾಡುವ ಬಾಗುತ್ತೇನೆ.

539
00:26:57,540 --> 00:27:00,860
>> ಆದರೆ ನನ್ನ ಕಾರ್ಯ hard_square
ಒಂದು ನಿಯತಾಂಕ ನಿರೀಕ್ಷಿಸುತ್ತಿದೆ.

540
00:27:00,860 --> 00:27:02,222
ಏನು ಈ ಔಟ್ ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ?

541
00:27:02,222 --> 00:27:03,680
ಅದು ಸರಿ, 100 ಔಟ್ ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು?

542
00:27:03,680 --> 00:27:05,720
ಬಳಕೆದಾರ ಕಾರಣ
ನನಗೆ ಏನು ನೀಡಲು.

543
00:27:05,720 --> 00:27:08,970
ಮತ್ತು ಆದ್ದರಿಂದ ನಾನು ಊಹಿಸುತ್ತವೆ ಹೋಗುವ ಬಾಗುತ್ತೇನೆ
10-- 10 ಪೂರ್ವನಿಯೋಜಿತ ಮೌಲ್ಯವಾಗಿದೆ.

544
00:27:08,970 --> 00:27:13,760
ಆದ್ದರಿಂದ ಈ ಮುದ್ರಿಸಲು ಎಂದು
100 ತನ್ನದೇ ಸಾಲಿನಲ್ಲಿ.

545
00:27:13,760 --> 00:27:16,390
>> PHP ಕಡತಗಳನ್ನು ಇಲ್ಲ
ಕೇವಲ ಒಂದು ಕಡತ ಎಂದು.

546
00:27:16,390 --> 00:27:19,480
ನೀವು ಒಟ್ಟಿಗೆ ಅನೇಕ ಕಡತಗಳನ್ನು ಒಂದುಗೂಡಿಸಬಹುದು,
ಕೇವಲ ಸಿ ನಲ್ಲಿ ರೀತಿ

547
00:27:19,480 --> 00:27:24,330
ನಾವು ಸಿ ಒಂದು ಮಾಡಲು ಸಾಮಾನ್ಯವಾಗಿ ಎಂದು ಮಾಡಿದರು
# ಸೇರಿವೆ ಹೆಡರ್ ಕಡತಗಳನ್ನು ನಿಲ್ಲಿಸಲು ಪಡೆಯಲು.

548
00:27:24,330 --> 00:27:26,180
ನಾವು ಪಿಎಚ್ಪಿ ಹಾಗೆ ಮಾಡಬೇಡಿ.

549
00:27:26,180 --> 00:27:29,110
ನಾವು require_once ಎಂದು ಕರೆಯುವುದನ್ನು ಮಾಡಲು.

550
00:27:29,110 --> 00:27:33,360
ತದನಂತರ ಈ ಇಡೀ ಇಲ್ಲ
ವಿಷಯ, ಈ __DIR__ ಇಲ್ಲಿದೆ?

551
00:27:33,360 --> 00:27:36,510
ಕೇವಲ ಒಂದು ವಿಶೇಷ
ವೇರಿಯಬಲ್, ಅಥವಾ ವಿಶೇಷ ನಿರಂತರ,

552
00:27:36,510 --> 00:27:39,030
ನಿಜವಾಗಿಯೂ, ಏನು ಸೂಚಿಸುತ್ತದೆ
ನಿಮ್ಮ ಪ್ರಸ್ತುತ ಕೋಶವಾಗಿದೆ.

553
00:27:39,030 --> 00:27:41,320
ಮತ್ತು ಆದ್ದರಿಂದ ಇದು ನೋಡಲು ವಿಶೇಷವೇನು
ನಿಮ್ಮ ಪ್ರಸ್ತುತ ಕೋಶದಲ್ಲಿ

554
00:27:41,320 --> 00:27:44,900
ಎಂಬ ಕಡತವನ್ನು cs50.php ಫಾರ್
ಇಲ್ಲಿ ಈ ಉದಾಹರಣೆಯಲ್ಲಿ,

555
00:27:44,900 --> 00:27:50,490
ಮತ್ತು ಆ ಕಡತ ಅಂಟಿಕೊಂಡು ವಿಶೇಷವೇನು
ನಿಮ್ಮ ಪಿಎಚ್ಪಿ ಕಾರ್ಯಕ್ರಮದ ಅಗ್ರ,

556
00:27:50,490 --> 00:27:56,980
ನೀವು ದಿ ಅಗತ್ಯವಿರುವ ಹಾಕಲು ಎಂದುಕೊಂಡರು
ನಿಮ್ಮ ಪಿಎಚ್ಪಿ ಕಡತದ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಲೈನ್ ಒಮ್ಮೆ.

557
00:27:56,980 --> 00:28:01,474
>> ಆದ್ದರಿಂದ PHP ಪ್ರಾಥಮಿಕವಾಗಿ, ಬಳಸಲಾಗುತ್ತದೆ
ಆದರೆ ಪ್ರತ್ಯೇಕವಾಗಿ ಬಳಸಲಾಗುವುದಿಲ್ಲ

558
00:28:01,474 --> 00:28:03,140
ವೆಬ್-ಆಧರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಒಂದು ಭಾಷೆಯಾಗಿ.

559
00:28:03,140 --> 00:28:05,270
ಅದು ಬಂತು ನಿಜವಾಗಿಯೂ ಹೇಗೆ.

560
00:28:05,270 --> 00:28:06,980
ಆದರೆ ಪೂರ್ಣ ಆಗಿದೆ
ನಾವು ನೋಡಿದ್ದೇವೆ ಎಂದು ಭಾಷೆ,.

561
00:28:06,980 --> 00:28:10,105
ನಾವು ಬಹುಮಟ್ಟಿಗೆ ಎಲ್ಲಾ ವಿಷಯಗಳನ್ನು ನೋಡಿದ
ಇದು ಸಿ ಹೋಲುವ ಮಾಡಬಹುದು,

562
00:28:10,105 --> 00:28:13,290
ಮತ್ತು ಇದು ಒಂದು ಬೀಟಿಂಗ್ ಮಾಡಬಹುದು
ಹೆಚ್ಚು ಬಹಳಷ್ಟು.

563
00:28:13,290 --> 00:28:16,950
>> ಆದರೆ ಏಕೆಂದರೆ ಪೂರ್ಣ ಭಾಷೆ ಮತ್ತು ನಾವು
ಇದು ಆಜ್ಞಾ ಸಾಲಿನ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾಡಬಹುದು.

564
00:28:16,950 --> 00:28:18,630
ನಾವು ಆಜ್ಞಾ ಸಾಲಿನ ಕಾರ್ಯಕ್ರಮಗಳು ಚಲಾಯಿಸಬಹುದು.

565
00:28:18,630 --> 00:28:22,580
ಎಲ್ಲಾ ಒಂದು ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ ತಯಾರಿಸಲಾಗುತ್ತಿದೆ
PHP ಯಲ್ಲಿ ಬರೆಯಲ್ಪಟ್ಟಿತು ಎಂದು ಸಾಲಿನ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ

566
00:28:22,580 --> 00:28:24,260
ನೀವು PHP ಇಂಟರ್ಪ್ರಿಟರ್ ಹೊಂದಿರುತ್ತವೆ.

567
00:28:24,260 --> 00:28:27,460
ಆದ್ದರಿಂದ ಇದು ರೀತಿಯ ಹೋಲುತ್ತದೆ ಇಲ್ಲಿದೆ
ನಿಮ್ಮ ಗಣಕದಲ್ಲಿ ಒಂದು ಕಂಪೈಲರ್ ಹೊಂದಿರುವ

568
00:28:27,460 --> 00:28:31,100
ನಿಮ್ಮ ಸಿ ಕೋಡ್ ಕಂಪೈಲ್ ಬಯಸಿದರೆ
ಕಾರ್ಯಗತಗೊಳ್ಳಬಹುದಾದ ಕಡತಗಳು ಅದನ್ನು ಮಾಡಲು.

569
00:28:31,100 --> 00:28:33,810
ನೀವು PHP ಇಂಟರ್ಪ್ರಿಟರ್ ಮಾಡಬೇಕು
ನಿಮ್ಮ ಗಣಕದಲ್ಲಿರುವ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ

570
00:28:33,810 --> 00:28:37,330
ಆದ್ದರಿಂದ ನೀವು PHP ಕಡತಗಳನ್ನು ಅರ್ಥೈಸಬಹುದಾಗಿದೆ.

571
00:28:37,330 --> 00:28:40,370
>> ನೀವು ಭಾವಿಸಿಕೊಂಡು, ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ
ಈ ವಿವರಣೆಯನ್ನು, ಪಿಎಚ್ಪಿ ಕರೆಯಲಾಗುತ್ತದೆ

572
00:28:40,370 --> 00:28:44,300
ಮತ್ತು ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಅತ್ಯಂತ ಜತೆಗೂಡಿಸಲ್ಪಟ್ಟಿದ್ದ
ಡೌನ್ಲೋಡ್ಗಳು ಅಥವಾ ಪಿಎಚ್ಪಿ ಅನುಸ್ಥಾಪನೆಗಳು

573
00:28:44,300 --> 00:28:47,430
ನೀವು ಖಚಿತವಾಗಿ ಆನ್ಲೈನ್ ಪಡೆಯಲು, ಮತ್ತು ಎಂದು
PHP ಇಂಟರ್ಪ್ರಿಟರ್ ಹೆಸರು

574
00:28:47,430 --> 00:28:49,550
ನಾವು, CS50 ರಲ್ಲಿ ಐಡಿಇ ಹೊಂದಿವೆ.

575
00:28:49,550 --> 00:28:51,819
ನೀವು ಎಲ್ಲಾ ರೀತಿಯ ಪಿಎಚ್ಪಿ ಕಡತವಾಗಿರುತ್ತದೆ.

576
00:28:51,819 --> 00:28:53,610
ಮತ್ತು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ
ಹಾಗೆ ಹೋಗಿ ಅದು ಆಗಿದೆ

577
00:28:53,610 --> 00:28:55,360
ಮೂಲಕ ರನ್ ಹೋಗುವ
ನಿರೂಪಕರಾದ ಅಷ್ಟೇ

578
00:28:55,360 --> 00:28:58,040
ಎಲ್ಲವೂ ನಿರ್ಲಕ್ಷಿಸಿ ಹೋಗುವ
ಅಲ್ಲ ಪ್ರಶ್ನೆ mark-- ನಡುವೆ

579
00:28:58,040 --> 00:29:03,160
ಅಥವಾ, ಕೋನ ಆವರಣ ಪ್ರಶ್ನೆ ಗುರುತು ಪಿಎಚ್ಪಿ,
ಪಿಎಚ್ಪಿ ಡಿಲಿಮಿಟರ್, ಮತ್ತು, ಮುದ್ರಿಸುತ್ತದೆ

580
00:29:03,160 --> 00:29:07,660
ಮತ್ತು ವಿವರಿಸುವುದಕ್ಕೆ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಲು
ನಿಮ್ಮ ಪಿಎಚ್ಪಿ ಡಿಲಿಮಿಟರ್ ಒಳಗೆ ಕೋಡ್.

581
00:29:07,660 --> 00:29:12,850
>> ಆದ್ದರಿಂದ, CS50 ಐಡಿಇ ಗೆ ಪಾಪ್ ಅವಕಾಶ ಮತ್ತು
ಪಿಎಚ್ಪಿ ಕಡತಗಳ ಒಂದೆರಡು ಒಂದು ನೋಟ ಹೊಂದಿವೆ,

582
00:29:12,850 --> 00:29:19,850
ರಲ್ಲಿ, ಪಿಎಚ್ಪಿ ಫೈಲ್ಸ್ ಒಂದೆರಡು ಚಾಲನೆಯಲ್ಲಿರುವ
CS50 IDE ಯ ಕಮಾಂಡ್ ಲೈನ್ ಇಂಟರ್ ಫೇಸ್.

583
00:29:19,850 --> 00:29:22,100
ಇಲ್ಲಿ ನಾವು CS50 ಐಡಿಇ ಇವೆ,
ಮತ್ತು ನಾನು ಸ್ವಾತಂತ್ರ್ಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು

584
00:29:22,100 --> 00:29:25,800
ಆಫ್ hello1.php ಎಂಬ ಕಡತ ತೆರೆಯುವ.

585
00:29:25,800 --> 00:29:29,920
ಈ ಮತ್ತು ಸ್ಪಷ್ಟವಾಗಿ, ್ಷೀಸಿ
ಫೈಲ್, ಕೇವಲ ಪಿಎಚ್ಪಿ ಡಿಲಿಮಿಟರ್ ಇವೆ

586
00:29:29,920 --> 00:29:32,220
ಮತ್ತು, ಪ್ರತಿಧ್ವನಿ ನಡುವೆ ("ಹಲೋ, ವರ್ಲ್ಡ್").

587
00:29:32,220 --> 00:29:34,710
ಈ ಒಂದು ಸುಂದರ ಸರಳ ಪಿಎಚ್ಪಿ ಕಾರ್ಯಕ್ರಮ.

588
00:29:34,710 --> 00:29:37,670
ನಾನು ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ಪಡೆಯಲಿದ್ದೇನೆ
ಇಲ್ಲಿ ನನ್ನ ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ,

589
00:29:37,670 --> 00:29:44,320
ನಾನು PHP ಟೈಪ್ ಪಡೆಯಲಿದ್ದೇನೆ
hello1.php, ನಮೂದಿಸಿ ಹಿಟ್.

590
00:29:44,320 --> 00:29:44,950
ಹಲೋ, ವರ್ಲ್ಡ್.

591
00:29:44,950 --> 00:29:48,110
ನಾವು ಬಗ್ಗೆ ಬಹುಶಃ ಇಲ್ಲಿದೆ
ಅದನ್ನು ನಿರೀಕ್ಷಿಸಿರಲಿಲ್ಲ, ಬಲ?

592
00:29:48,110 --> 00:29:51,140
>> ನ ಹೋಗುತ್ತಾರೆ ಮತ್ತು ತೆಗೆದುಕೊಳ್ಳೋಣ
ಮತ್ತೊಂದು ಒಂದು ಪ್ರೋಗ್ರಾಂ ನೋಡಲು.

593
00:29:51,140 --> 00:29:52,924
hello2.php.

594
00:29:52,924 --> 00:29:55,090
ಬಹುಮಟ್ಟಿಗೆ ಒಂದೇ,
ಬಹಳಷ್ಟು ಇಲ್ಲಿ ಇಲ್ಲ.

595
00:29:55,090 --> 00:29:57,190
ಈ ಬಾರಿ, ಆದರೂ, ನಾನು ಪ್ರಾಂಪ್ಟ್ ಪಡೆಯಲಿದ್ದೇನೆ
ಬಳಕೆದಾರ ನನಗೆ ತಮ್ಮ ಹೆಸರನ್ನು ನೀಡಲು.

596
00:29:57,190 --> 00:29:59,290
ನಾನು ಮತ್ತೆ ಆ readline ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ನಾನು.

597
00:29:59,290 --> 00:30:01,340
$ ಹೆಸರು = readline.

598
00:30:01,340 --> 00:30:03,070
ಪ್ರಾಂಪ್ಟ್, ಇಲ್ಲಿದೆ "ನಿಮ್ಮ ಹೆಸರೇನು?"

599
00:30:03,070 --> 00:30:04,880
>> ಸ್ಪಷ್ಟವಾಗಿ ನಾನು ಮುದ್ರಿಸುವ ನನಗೆ
ಇದು ತನ್ನದೇ ಸಾಲಿನಲ್ಲಿ.

600
00:30:04,880 --> 00:30:07,220
ತದನಂತರ, ಆದ್ದರಿಂದ ರೇಖೆಗಿಂತ ಕೆಳಗೆ
ಎಂದು ಪ್ರಾಂಪ್ಟ್ ಆಗಿರುತ್ತದೆ

601
00:30:07,220 --> 00:30:08,750
ಅಲ್ಲಿ ಬಳಕೆದಾರ ತಮ್ಮ ಹೆಸರನ್ನು ನಮೂದಿಸಬಹುದು.

602
00:30:08,750 --> 00:30:12,030
ಮತ್ತು ನಂತರ ನಾನು ಸ್ವಲ್ಪ ಆಫ್ ಬಳಸಿಕೊಂಡು ಬಾಗುತ್ತೇನೆ
ಲೈನ್ 3 ಇಲ್ಲಿ ವೇರಿಯಬಲ್ ಅಡ್ಡಪ್ರಶ್ನೆ ಕೇಳುವುದು ಯಾ ಆ ಅಡ್ಡಪ್ರಶ್ನೆ

603
00:30:12,030 --> 00:30:14,780
"ಹಲೋ" ಮುದ್ರಿಸುತ್ತದೆ ಮತ್ತು
ಯಾವುದೇ ಬಳಕೆದಾರ ರೀತಿಯ.

604
00:30:14,780 --> 00:30:22,040
ಆದ್ದರಿಂದ ಈ ಹಲೋ, ಹೇಳುವ ಹೋಲುತ್ತದೆ,
ಅಲ್ಪವಿರಾಮ% s ಸಿ printf ಬಳಸಿಕೊಂಡು ವೇಳೆ

605
00:30:22,040 --> 00:30:24,910
>> ಆದ್ದರಿಂದ ಹೋಗಿ ಈ ಪ್ರೋಗ್ರಾಂ ವ್ಯಾಖ್ಯಾನಿಸಲು ಅವಕಾಶ.

606
00:30:24,910 --> 00:30:27,400
ಆದ್ದರಿಂದ ಮತ್ತೆ, ನಾನು ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ಮಾಡುತ್ತೇವೆ
ನನ್ನ ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ.

607
00:30:27,400 --> 00:30:29,070
ಪಿಎಚ್ಪಿ hello2.php.

608
00:30:29,070 --> 00:30:31,920

609
00:30:31,920 --> 00:30:33,820
ನಿನ್ನ ಹೆಸರೇನು?

610
00:30:33,820 --> 00:30:35,490
ಡೌಗ್.

611
00:30:35,490 --> 00:30:36,526
ಹಲೋ, ಡೌಗ್.

612
00:30:36,526 --> 00:30:39,440
ನಾನು ಇನ್ನೊಂದು
ಕಡತ hello3.php ಕರೆಯಲಾಗುತ್ತದೆ.

613
00:30:39,440 --> 00:30:42,850
ನಾನು ತೆರವುಗೊಳಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ ನನ್ನ
ಕಂಟ್ರೋಲ್ ಎಲ್ ಪರದೆ,

614
00:30:42,850 --> 00:30:46,210
ಮತ್ತು ನಾನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಹೋಗುವ ಬಾಗುತ್ತೇನೆ.

615
00:30:46,210 --> 00:30:47,640
ನಿನ್ನ ಹೆಸರೇನು?

616
00:30:47,640 --> 00:30:49,020
ಡೌಗ್.

617
00:30:49,020 --> 00:30:49,780
ಹಲೋ, ಡೌಗ್.

618
00:30:49,780 --> 00:30:56,540
ಆದ್ದರಿಂದ ವರ್ತನೆಯನ್ನು ಹೋಲುವಂತಿರುತ್ತದೆ
hello2.php, ಆದರೆ ಏಕೆ hello3.php ಇದೆ?

619
00:30:56,540 --> 00:30:58,040
>> ಬಾವಿ, ಇಲ್ಲಿ ವ್ಯತ್ಯಾಸ ಇಲ್ಲಿದೆ.

620
00:30:58,040 --> 00:31:00,620
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸೂಚನೆ
ಇಲ್ಲಿ ಲೈನ್ 1 ರಂದು,

621
00:31:00,620 --> 00:31:04,270
ನಾನು ಅಲ್ಲ ವಿಷಯ ಹೊಂದಿವೆ
ಪಿಎಚ್ಪಿ ಡಿಲಿಮಿಟರ್ ನಡುವೆ.

622
00:31:04,270 --> 00:31:07,760
ನಾನು out-- ಅಥವಾ ನಾನು ಮುದ್ರಿಸುವ ನಾನು
ಕೇವಲ "ನಿಮ್ಮ ಹೆಸರು ಏನು?", ಟೈಪ್

623
00:31:07,760 --> 00:31:12,060
PHP ಇಂಟರ್ಪ್ರಿಟರ್ ಈ ನೋಡಿದಾಗ, ಇದು
ಕಲ್ಪನೆ ಹೇಗೆ ಪಿಎಚ್ಪಿ ಎಂದು ಅರ್ಥೈಸಿ ಹೊಂದಿದೆ,

624
00:31:12,060 --> 00:31:15,060
ಮತ್ತು ಆದ್ದರಿಂದ ಬದಲಿಗೆ, ವಿಫಲವಾದ
ಇದು ಕೇವಲ ಇದನ್ನು ಭೂಶಿರ ಹೋಗುವುದಿಲ್ಲ.

625
00:31:15,060 --> 00:31:19,010
>> ಆದ್ದರಿಂದ, ಈಗ ಲೈನ್ 3 ನನ್ನ ಕರೆ ಗಮನಕ್ಕೆ
readline, ಇನ್ನು ಮುಂದೆ ಯಾವುದೇ ಪ್ರಾಂಪ್ಟ್ ಇಲ್ಲ.

626
00:31:19,010 --> 00:31:21,750
ನಾನು ವಾಸ್ತವವಾಗಿ to-- ಮಾಡಿದಾಗ ಪಡೆಯಲಿದ್ದೇನೆ
PHP ಇಂಟರ್ಪ್ರಿಟರ್ ಈ ನೋಡುತ್ತಾನೆ

627
00:31:21,750 --> 00:31:23,400
ಇದನ್ನು ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು
"ನಿನ್ನ ಹೆಸರೇನು?"

628
00:31:23,400 --> 00:31:25,941
ನಂತರ here's--, ಸರಿ, ಓ, ನೋಡುತ್ತಾನೆ
ಉಳಿದಂತೆ ಎಂದು ನಾನು

629
00:31:25,941 --> 00:31:29,970
ಆದ್ದರಿಂದ, ಪಿಎಚ್ಪಿ ತಿಳಿಯುತ್ತದೆ
ಈ ಕೆಲಸ ಏಕೆ ಎಂದು ಇಲ್ಲಿದೆ.

630
00:31:29,970 --> 00:31:34,990
ನಾನು ಅಗತ್ಯವಾಗಿ ಪ್ರಾಂಪ್ಟ್ ಮಾಡಲು ಹೊಂದಿಲ್ಲ
readline ಒಳಗೆ ಬಳಕೆದಾರ to--,

631
00:31:34,990 --> 00:31:37,490
ನಾನು ಹೊರಗೆ ಹೊಂದಬಹುದು
ಪಿಎಚ್ಪಿ ಡಿಲಿಮಿಟರ್

632
00:31:37,490 --> 00:31:41,490
ವ್ಯಾಖ್ಯಾನಕಾರರಾಗಿ ಅವಕಾಶ
ನನಗೆ ಇದು ಮುದ್ರಿಸುತ್ತದೆ.

633
00:31:41,490 --> 00:31:45,364
>> ಆದ್ದರಿಂದ ವಾಸ್ತವವಾಗಿ ಮಾತ್ರ ಇಲ್ಲ
ಪಿಎಚ್ಪಿ ಡಿಲಿಮಿಟರ್ ಒಂದು ಸೆಟ್

634
00:31:45,364 --> 00:31:46,030
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ.

635
00:31:46,030 --> 00:31:49,887
ನೀವು ವಾಸ್ತವವಾಗಿ, ಅವುಗಳಲ್ಲಿ ಹಲವಾರು ಹೊಂದಬಹುದು
ತೆರೆದು ಅವುಗಳನ್ನು ಅಗತ್ಯವಿದೆ ಮುಚ್ಚುವ.

636
00:31:49,887 --> 00:31:51,720
ಆದ್ದರಿಂದ ಅವಲೋಕಿಸೋಣ
ಕಾರ್ಯಕ್ರಮಗಳು ಒಂದೆರಡು

637
00:31:51,720 --> 00:31:55,070
ಅಲ್ಲಿ CS50 ಐಡಿಇ ನಾವು
ಹೊಂದುವ ಈ ಕಲ್ಪನೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ

638
00:31:55,070 --> 00:31:58,376
ಲಿಮಿಟೆಡ್ ಪಿಎಚ್ಪಿ ಅನೇಕ ವರ್ಗಗಳು.

639
00:31:58,376 --> 00:32:02,010
>> ಸರಿ, ಆದ್ದರಿಂದ ನಾನು ಒಂದು ಕಡತ ತೆರೆಯಿತು ಬಂದಿದೆ
ಇಲ್ಲಿ add1.php ಕರೆಯಲಾಗುತ್ತದೆ.

640
00:32:02,010 --> 00:32:03,390
ಮತ್ತು ಇಲ್ಲಿ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.

641
00:32:03,390 --> 00:32:08,077
ಕೇವಲ ಮೊದಲು, ನಾನು ಒಂದು
ಏಕ ಪಿಎಚ್ಪಿ ಡಿಲಿಮಿಟರ್ ಸೆಟ್.

642
00:32:08,077 --> 00:32:10,660
ನಾನು ಮುದ್ರಿಸುತ್ತದೆ ಪಡೆಯಲಿದ್ದೇನೆ
ಸಂದೇಶ, "ಅಂತ ಸಂಖ್ಯೆಯನ್ನು ನೀಡಿ."

643
00:32:10,660 --> 00:32:13,394
ನಂತರ ನಾನು ಒಂದು ಸಾಲು ಓದಿ ಪಡೆಯಲಿದ್ದೇನೆ ಮತ್ತು
ವೇರಿಯಬಲ್ $ num1 ಶೇಖರಿಸಿಡಬೇಕು.

644
00:32:13,394 --> 00:32:14,810
ನಂತರ ನಾನು ಮತ್ತೆ ಮುದ್ರಿಸುತ್ತದೆ ಹೋಗುವ ಬಾಗುತ್ತೇನೆ.

645
00:32:14,810 --> 00:32:16,310
ನನಗೆ ಎರಡನೇ ಸಂಖ್ಯೆಯನ್ನು ನೀಡಿ.

646
00:32:16,310 --> 00:32:20,450
ಬಳಕೆದಾರ, ಅಂಗಡಿಯಿಂದ ಒಂದು ಸಾಲಿನ ಓದಿ
ಅವರು $ num2 ರಲ್ಲಿ ಬೆರಳಚ್ಚಿಸಿದ ಯಾವುದೇ.

647
00:32:20,450 --> 00:32:23,980
ಅವುಗಳನ್ನು ಒಟ್ಟಿಗೆ ಸೇರಿಸಲು ಮತ್ತು ಆ ಶೇಖರಿಸಿಡಲು
$ ಮೊತ್ತ ಎಂಬ ಮಾರ್ಪಡಿಸಬಹುದಾದ ಕಾರಣವಾಗುತ್ತದೆ,

648
00:32:23,980 --> 00:32:26,180
ತದನಂತರ ", ಮುದ್ರಿಸುತ್ತದೆ
ಈ ಎರಡು ಸಂಖ್ಯೆಗಳ ಮೊತ್ತ

649
00:32:26,180 --> 00:32:29,254
, "ಮತ್ತು ನಂತರ ಅಡ್ಡಪ್ರಶ್ನೆ ಕೇಳು
ಅಲ್ಲಿ ವೇರಿಯಬಲ್ $ ಮೊತ್ತ.

650
00:32:29,254 --> 00:32:31,170
ಆದ್ದರಿಂದ ಅವರ ಈ ರನ್ ಅವಕಾಶ
ವಿವರಣೆಯ ಮೂಲಕ

651
00:32:31,170 --> 00:32:33,720
ಈ ನಾವು ನಿರೀಕ್ಷಿಸಬಹುದು ಏನು ಎಂದು ಖಚಿತಪಡಿಸಲು.

652
00:32:33,720 --> 00:32:37,540
ಪಿಎಚ್ಪಿ add1.php.

653
00:32:37,540 --> 00:32:38,665
ನನಗೆ ಹಲವಾರು 3 ನೀಡಿ.

654
00:32:38,665 --> 00:32:40,410
ನನಗೆ ಎರಡನೇ ಸಂಖ್ಯೆ, 4 ನೀಡಿ.

655
00:32:40,410 --> 00:32:43,370
ಈ ಎರಡು ಸಂಖ್ಯೆಗಳ ಮೊತ್ತ 7.

656
00:32:43,370 --> 00:32:45,030
3 + 4 ಇಲ್ಲಿದೆ.

657
00:32:45,030 --> 00:32:45,530
ಸರಿ?

658
00:32:45,530 --> 00:32:47,770
ಅಲ್ಲಿ ಹಾಗೆ ಏನೂ ಆಪತ್ತು ಅಲಂಕಾರಿಕ.

659
00:32:47,770 --> 00:32:51,080
>> ಮತ್ತು ಈಗ add2.php ತೆರೆದುಕೊಳ್ಳಲು ಅವಕಾಶ.

660
00:32:51,080 --> 00:32:54,460
ಇಲ್ಲಿ, ನಾನು ಪಿಎಚ್ಪಿ ಒಂದೆರಡು ಪಡೆದಿರುವಿರಿ
ಅಲ್ಲಿ ಸೆಟ್ ಲಿಮಿಟೆಡ್, ಬಲ?

661
00:32:54,460 --> 00:32:59,107
ಲೈನ್ಸ್ 1, 3-- ಸಾಲುಗಳು 1 ಮತ್ತು
3 ಯಾವುದೇ PHP ಎಲ್ಲೆಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.

662
00:32:59,107 --> 00:33:00,940
ಆದ್ದರಿಂದ ಇಂಟರ್ಪ್ರಿಟರ್
ಇದು ಕೇವಲ, ಅವುಗಳನ್ನು ನೋಡುವ

663
00:33:00,940 --> 00:33:03,220
ನಿಖರವಾಗಿ ಔಟ್ ಕಕ್ಕುವ ಹೋಗುತ್ತದೆ
ಏನು ನಾನು ಟೈಪ್ ಮಾಡಿದ.

664
00:33:03,220 --> 00:33:05,011
ನಾನು ಅಲ್ಲಿ ಆದ್ದರಿಂದ ಇಲ್ಲಿದೆ
ನನ್ನ ಪ್ರೇರೇಪಿಸಿತು ಮಾಡುತ್ತಿದ್ದಾರೆ.

665
00:33:05,011 --> 00:33:11,220
ಸಾಲುಗಳನ್ನು 2 ಮತ್ತು 4 ರಂದು, ನಾವು ನೋಡಿ ತುಂಬಾ
ಪರಿಚಿತ $? ಡಿಲಿಮಿಟರ್ ಪಿಎಚ್ಪಿ ರೀತಿಯ,

666
00:33:11,220 --> 00:33:15,210
ಆದ್ದರಿಂದ ಆ ಎರಡು ರೇಖೆಗಳು
ಪಿಎಚ್ಪಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಹೋಗುತ್ತದೆ.

667
00:33:15,210 --> 00:33:18,270
ತದನಂತರ ಸಾಲಿನಲ್ಲಿ 5 ರಂದು, ನಾನು ಈ ಹೊಂದಿವೆ
ಇಲ್ಲಿಯೇ ವಿಲಕ್ಷಣ ವಿಷಯ, ಬಲ?

668
00:33:18,270 --> 00:33:20,480
ಈ ಕೋನ ಆವರಣ
ಪ್ರಶ್ನೆ ಗುರುತು ಸಮ ಚಿಹ್ನೆ.

669
00:33:20,480 --> 00:33:22,660
ನಾನು ಸ್ವಲ್ಪ ಮುಂದೆ ಜೂಮ್ ಮಾಡುತ್ತೇವೆ.

670
00:33:22,660 --> 00:33:29,270
ಈ ನಾನು ಏನು ನೋಡಬಹುದು
, ಬಲ ಅಲ್ಲಿ ಬಗ್ಗೆ ಈ $ ಮಾತನಾಡುವ? =.

671
00:33:29,270 --> 00:33:33,420
>> ಇದು ಆದ್ದರಿಂದ ಸಾಮಾನ್ಯ ಎಂದು ತಿರುಗಿದರೆ
ನಾವು ಪಿಎಚ್ಪಿ ಒಂದು ಸೆಟ್ ತೆರೆಯುತ್ತದೆ ಕಾರಣವನ್ನು

672
00:33:33,420 --> 00:33:36,055
ಎಲ್ಲೆಗಳನ್ನು ಮೇಲಿಂಗ್ ಮುದ್ರಿಸಲು ಆಗಿದೆ.

673
00:33:36,055 --> 00:33:37,430
ಮತ್ತು ನಾವು ಮಾಡಲು ನೀನು ಅಷ್ಟೆ.

674
00:33:37,430 --> 00:33:39,220
ಆದರೆ ಅದಕ್ಕಾಗಿ ಸಹ ಸಂಕ್ಷಿಪ್ತ ಇಲ್ಲ.

675
00:33:39,220 --> 00:33:46,490
$? = ಹೇಳುವ ಪಿಎಚ್ಪಿ ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸಲ್ಪಟ್ಟಿದೆ
$ ರೀತಿಯ? ಪ್ರತಿಧ್ವನಿ ಪಿಎಚ್ಪಿ ಮೊತ್ತ

676
00:33:46,490 --> 00:33:48,350
num1 ಮತ್ತು num2 ಆಫ್.

677
00:33:48,350 --> 00:33:51,900
ಆದ್ದರಿಂದ ಈ ಕೇವಲ ಇನ್ನೊಂದು
ಸಂಕ್ಷಿಪ್ತ.

678
00:33:51,900 --> 00:33:55,550
>> ಈ ಪ್ರೋಗ್ರಾಂ, ಪಿಎಚ್ಪಿ add2.php ರನ್ ಆದ್ದರಿಂದ.

679
00:33:55,550 --> 00:33:57,530
ನಾನು ಸ್ವಲ್ಪ ಕೆಳಗೆ ಜೂಮ್ ವಿಲ್.

680
00:33:57,530 --> 00:33:59,000
ನನಗೆ ಹಲವಾರು 4 ನೀಡಿ.

681
00:33:59,000 --> 00:34:00,350
ನನಗೆ ಎರಡನೇ ಸಂಖ್ಯೆ ನೀಡಿ.

682
00:34:00,350 --> 00:34:04,650
ಮತ್ತು ನಾನು ನಿಜವಾಗಿಯೂ ಕಾಳಜಿ ನೀಡದಿರುವುದರಿಂದ
ಪಿಎಚ್ಪಿ ಡೇಟಾ ಪ್ರಕಾರಗಳು, ನಾನು 4.8 ಹೇಳಬಹುದು.

683
00:34:04,650 --> 00:34:07,160
ಈ ಎರಡು ಸಂಖ್ಯೆಗಳ ಮೊತ್ತ 8.8.

684
00:34:07,160 --> 00:34:10,179
ಆ ಕ್ರಿಯೆ ಬಹುಮಟ್ಟಿಗೆ ವರ್ತಿಸುತ್ತದೆ
ನಾವು ನಿರೀಕ್ಷಿಸಬಹುದು ಎಂದು ಒಂದೇ,

685
00:34:10,179 --> 00:34:10,989
ಜೊತೆಗೆ.

686
00:34:10,989 --> 00:34:13,114
ಮತ್ತು ನಾನು ಒಂದು ತೆರೆದಿದ್ದೀರಿ
ಇಲ್ಲಿ dice.php ಕರೆಯಲಾಗುತ್ತದೆ.

687
00:34:13,114 --> 00:34:25,625

688
00:34:25,625 --> 00:34:26,250
ಮತ್ತೆ ಈ ಪ್ರಯತ್ನಿಸಿ.

689
00:34:26,250 --> 00:34:29,429

690
00:34:29,429 --> 00:34:33,280
ನಾನು ಇಲ್ಲಿ ಹೆಚ್ಚು ಎಂಬ
ಸಹ, ನೋಡುವ dice1.php,

691
00:34:33,280 --> 00:34:37,440
ಆ ಕೋನ ಆವರಣ ಪ್ರಶ್ನೆ
ಹಾಗಾದರೆ ಸಮ ಚಿಹ್ನೆ ಸಂಕೇತ ಗುರುತು,

692
00:34:37,440 --> 00:34:40,659
ಆದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾನು ಗಮನಕ್ಕೆ
ಕಾರ್ಯ ರಾಂಡ್, ಕರೆ ಇದು ನೀವು

693
00:34:40,659 --> 00:34:42,790
ಅಪೇಕ್ಷಿಸಬಹುದು ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ ಉತ್ಪತ್ತಿ ಮಾಡುತ್ತದೆ.

694
00:34:42,790 --> 00:34:46,889
"ನೀವು, ಒಂದು ಸುತ್ತಿಕೊಂಡ" ಮತ್ತು ಇದು ವಿಶೇಷವೇನು
+ ಕೆಲವು ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ, ಅಳತೆಯ 6 ಲೆಕ್ಕ

695
00:34:46,889 --> 00:34:47,389
1.

696
00:34:47,389 --> 00:34:49,989
ಆದ್ದರಿಂದ ನನಗೆ ಸಂಖ್ಯೆ ನೀಡುತ್ತೇನೆ
1 ರಿಂದ 6 ವ್ಯಾಪ್ತಿಯಲ್ಲಿ.

697
00:34:49,989 --> 00:34:53,040
>> ಅಳತೆಯ 6 ನನಗೆ ಕೊಡಲು ನೆನಪಿಡಿ
0 5 ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಹಲವಾರು

698
00:34:53,040 --> 00:34:56,630
ಆದರೆ ನಾನು ಡೈಸ್ ರೋಲ್ ಅನುಕರಿಸುವ ಬಾಗುತ್ತೇನೆ ವೇಳೆ,
ಇದು ನಾನು ಇಲ್ಲಿ ಏನು ಮಾಡುತ್ತಿರುವೆ ಆಗಿದೆ,

699
00:34:56,630 --> 00:35:00,040
ಈ ಡೈಸ್ 0 ಹೋಗಲು ಬಯಸುವುದಿಲ್ಲ
5, ನಾನು 1 ರಿಂದ 6 ಹೋಗಿ ಎಂದು ಡೈಸ್ ಬಯಸುವ.

700
00:35:00,040 --> 00:35:02,800
ಆದ್ದರಿಂದ ಈ ಪಡೆಯಲು ಒಂದು ಮಾರ್ಗವಾಗಿದೆ
1 ರಿಂದ 6 ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ನನಗೆ.

701
00:35:02,800 --> 00:35:04,720
ನಾನು ಎರಡು ಬಾರಿ ಈ ಮಾಡುತ್ತಿರುವೆ.

702
00:35:04,720 --> 00:35:08,630
ಆದ್ದರಿಂದ ಸ್ಪಷ್ಟವಾಗಿ ನಾನು ರೋಲಿಂಗ್ ನಾನು
ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಎರಡು ದಾಳಗಳು.

703
00:35:08,630 --> 00:35:15,210
>> ಹಾಗಾಗಿ ನನ್ನ ಪರದೆಯ ತೆರವುಗೊಳಿಸಿ ಮಾಡುತ್ತೇವೆ,
ನಾನು PHP dice1.php ಮಾಡುತ್ತೇನೆ.

704
00:35:15,210 --> 00:35:16,640
ನೀವು 4 ಮತ್ತು 2 ಸುತ್ತವೇ.

705
00:35:16,640 --> 00:35:19,156
ನಾನು ಪ್ರೋಗ್ರಾಂ
ಮತ್ತೆ, ನೀವು 5 ಮತ್ತು 5 ಸುತ್ತವೇ.

706
00:35:19,156 --> 00:35:21,780
ಹಾಗಾಗಿ ಪ್ರೋಗ್ರಾಂ ಪ್ರತಿ ಬಾರಿ,
ನಾನು ವಿವಿಧ ಸಂಖ್ಯೆಗಳನ್ನು ಪಡೆಯುವಲ್ಲಿ ಬಾಗುತ್ತೇನೆ

707
00:35:21,780 --> 00:35:24,280
ಏಕೆಂದರೆ ನಾನು ಪ್ರತಿ ಬಾರಿ
ಆದ್ದರಿಂದ, ಅದನ್ನು ಶುರುವಾಗುತ್ತಿದೆ.

708
00:35:24,280 --> 00:35:27,250
ಇದು ಒಂದು ಹೊಸ ಸೃಷ್ಟಿಸಲು ವಿಶೇಷವೇನು
ನನಗೆ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳ ಸೆಟ್.

709
00:35:27,250 --> 00:35:29,790
>> ನಾವು ಬಳಸಲಾಗುತ್ತದೆ ಬಳಸುತ್ತಿದ್ದರೆ ಆದ್ದರಿಂದ
ಸಿ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು,

710
00:35:29,790 --> 00:35:32,520
ನಾವು ./ ಟೈಪ್ ಬಳಸಲಾಗುತ್ತದೆ ನೀವು
ಸರಿ, ಒಂದು ಕಾರ್ಯಕ್ರಮದ ಹೆಸರು?

711
00:35:32,520 --> 00:35:35,090
ನಾವು ಎಲ್ಲಾ ಮಾಡಿದ ಹೇಗೆ
ಸಿ ನಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳ ಇಲ್ಲಿಯವರೆಗೆ.

712
00:35:35,090 --> 00:35:37,555
ನಾವು ಹಾಗೂ PHP ಈ ಮಾಡಬಹುದು
ಸ್ವಲ್ಪ ಸೇರಿಸುವ ಮೂಲಕ ಎಂಬ

713
00:35:37,555 --> 00:35:40,026
ನಮ್ಮ ಪಿಎಚ್ಪಿ ಫೈಲ್ ಮೇಲಕ್ಕೆ ಒಂದು ಸಂಗತಿ.

714
00:35:40,026 --> 00:35:41,400
ನಾನು ಇದು ಒಂದು ಸಿಲ್ಲಿ ಪದ ಭಾಸವಾಗುತ್ತದೆ ಗೊತ್ತು.

715
00:35:41,400 --> 00:35:44,540
ಇದು ಹ್ಯಾಶ್ ಬ್ಯಾಂಗ್ ಷಾರ್ಟ್.

716
00:35:44,540 --> 00:35:46,300
ಅಲ್ಲಿ ಮೊದಲ ಎರಡು ಪಾತ್ರಗಳು ಇಲ್ಲಿದೆ.

717
00:35:46,300 --> 00:35:50,030
ನಾವು ಕೂಗಾಟ ಕರೆ ನೆನಪಿಡಿ
ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿ ಆಗಾಗ್ಗೆ ಅಬ್ಬರದಿಂದ.

718
00:35:50,030 --> 00:35:51,690
ಇದು ಸರಿಯಾದ ಬ್ಯಾಂಗ್ ಇರಬಹುದು.

719
00:35:51,690 --> 00:35:53,273
ವಿವರಿಸುವುದಕ್ಕೆ ಒಂದೆರಡು ರೀತಿಯಲ್ಲಿ ಇಲ್ಲ.

720
00:35:53,273 --> 00:35:57,320
ಆದರೆ ಇದು ಮೂಲತಃ ಒಂದು ವಿಶೇಷ ರೀತಿಯ ಇಲ್ಲಿದೆ
ಆಜ್ಞೆಯನ್ನು PHP ಇಂಟರ್ಪ್ರಿಟರ್

721
00:35:57,320 --> 00:36:00,160
ಓಹ್, ನಾನು ಬಯಸುವ, ಎಂದು ಅರ್ಥ
ನೀವು ಈ ಪ್ರೋಗ್ರಾಂ ಕಾರ್ಯಗತಗೊಳಿಸಿ,

722
00:36:00,160 --> 00:36:05,250
ಇದು ಸ್ಪಷ್ಟವಾಗಿ / ಬಳಕೆದಾರ / bin / php, ಇದು
ಅಲ್ಲಿ PHP ಇಂಟರ್ಪ್ರಿಟರ್ ವಾಸ್ತವವಾಗಿ

723
00:36:05,250 --> 00:36:08,590
ವಿಶೇಷವಾಗಿ ನಮ್ಮ ವ್ಯವಸ್ಥೆಯ ವಾಸಿಸುತ್ತಾನೆ.

724
00:36:08,590 --> 00:36:12,530
It's-- ಹಾಗಾಗಿ ಇಲ್ಲಿ ನಡೆಯುತ್ತದೆ
ಇಂಟರ್ಪ್ರಿಟರ್, ಓಹ್, ಅರ್ಥ

725
00:36:12,530 --> 00:36:17,270
ನಾನು ಸ್ಪಷ್ಟವಾಗಿ ಬಳಸಲು ಭಾವಿಸಲಾದ ನುಡಿದರು
ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಈ ಕಡತವನ್ನು ಚಲಾಯಿಸಲು.

726
00:36:17,270 --> 00:36:20,010
ಮತ್ತು ಆದ್ದರಿಂದ ನೀವು ಅನುಮತಿಸುತ್ತದೆ
ಹಂತವನ್ನು

727
00:36:20,010 --> 00:36:22,979
ಪಿಎಚ್ಪಿ something.php ಹೇಳಲು ಹೊಂದಿರುವ.

728
00:36:22,979 --> 00:36:25,020
ಮತ್ತೊಂದು ಕ್ಯಾಚ್ ಇಲ್ಲ
ಇಲ್ಲಿ, ಅದು ನಾವು

729
00:36:25,020 --> 00:36:27,320
ನಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು ಬಯಸುವ
ನಿರೀಕ್ಷೆಯಂತೆ, ನಾವು ಕೆಲಸ

730
00:36:27,320 --> 00:36:30,220
ಕರೆಯುವುದನ್ನು ಮಾಡಬೇಕಾದ್ದು
ಒಂದು ಫೈಲ್ ಅನುಮತಿ ಬದಲಾವಣೆ.

731
00:36:30,220 --> 00:36:33,380
ನಾವು go-- ಮಾಡುತ್ತೇವೆ ಮತ್ತು ನಾವು ಸ್ವಲ್ಪ ಮಾತನಾಡಲು
ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಬಗ್ಗೆ ಫೈಲ್ ಅನುಮತಿ ಬದಲಾವಣೆಗಳನ್ನು

732
00:36:33,380 --> 00:36:37,550
ನಮ್ಮ ಅಲ್ಲದ MVC ಮೇಲೆ ವೀಡಿಯೊ, ಆದರೆ ಇದನ್ನು ಸಾಕಾಗುತ್ತದೆ
ಈ ನೀವು ಮಾಡಬೇಕಾದ್ದು ಏನು ಎಂದು ಹೇಳಲು

733
00:36:37,550 --> 00:36:42,760
ಮಾಡಲು ನಿಮ್ಮ
ಪಿಎಚ್ಪಿ ಕಡತಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳ್ಳುವ.

734
00:36:42,760 --> 00:36:49,330
ಆದ್ದರಿಂದ ಈ ಒಂದು ಅವಲೋಕಿಸೋಣ
CS50 ಐಡಿಇ ನಮ್ಮ ಅಂತಿಮ ಉದಾಹರಣೆಗೆ ಮೇಲೆ.

735
00:36:49,330 --> 00:36:53,910
>> ಇಲ್ಲಿ ಐಡಿಇ ನಾನು ಈ ಎರಡು ಕಡತಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ
ಎಂದು ಅಲ್ಲ ಕಂಡುಬರುವ ಪಿಎಚ್ಪಿ ಕೋಶವನ್ನು

736
00:36:53,910 --> 00:36:55,310
PHP ಎಂಬ.

737
00:36:55,310 --> 00:36:58,170
ನಾನು ಕಾರ್ಯ ಎಂಬ add--
ನಾನು ಎಂಬ ಕಡತವನ್ನು add3 ಹೊಂದಿವೆ

738
00:36:58,170 --> 00:37:00,650
ಮತ್ತು ಕಡತ dice2 ಕರೆಯಲಾಗುತ್ತದೆ.

739
00:37:00,650 --> 00:37:03,680
ಆದ್ದರಿಂದ ಒಂದು ತ್ವರಿತ ನೋಡೋಣ
ನೋಡಲು ಮತ್ತು add3 ತೆರೆಯುತ್ತದೆ.

740
00:37:03,680 --> 00:37:08,300
ಮತ್ತು ನೀವು ಆರಂಭದಲ್ಲಿ, ನೋಡಬಹುದು
ನನ್ನ ಫೈಲ್ ನಾನು, ಈ ವಿಷಯ ಹೊಂದಿವೆ?

741
00:37:08,300 --> 00:37:11,420
ಈ ಹ್ಯಾಷ್ ಮಾರ್ಕ್ ಕೂಗಾಟ.

742
00:37:11,420 --> 00:37:15,115
ಈಗ, ನೀವು ಬಹುಶಃ ಸಹ ಮಾಡುತ್ತೇವೆ
ಕಾರಣಕ್ಕೆ ಗಮನಕ್ಕೆ,

743
00:37:15,115 --> 00:37:16,990
ನಾನು ಯಾವುದೇ ವಾಕ್ಯ ಇಲ್ಲ
ಇನ್ನು ಮುಂದೆ ನಿಮಗೆ ಹೈಲೈಟ್,

744
00:37:16,990 --> 00:37:20,198
ಮತ್ತು ಈ, ನಾನು ಹಿಂದಿನ ಪ್ರಸ್ತಾಪಿಸುತ್ತಾನೆ ಏನು
ಇದು ನನ್ನ ಫೈಲ್ ಹೆಸರು ಹೋದರೆ ಎಂದು

745
00:37:20,198 --> 00:37:23,040
ಪಿಎಚ್ಪಿ, ನಾನು ಲಾಭ ಇಲ್ಲ
ವಾಕ್ಯ ಎಲ್ಲಿಯೂ ಹೈಲೈಟ್.

746
00:37:23,040 --> 00:37:26,220
ಈ ಕಡತ add3 ಕರೆಯಲಾಗುತ್ತದೆ.

747
00:37:26,220 --> 00:37:30,960
ನಾನು ನಂತರ ಚಲಾಯಿಸಲು ಇದರಿಂದ
./ add3 ಮತ್ತು ./ add3.php ಜೊತೆ.

748
00:37:30,960 --> 00:37:33,680
>> ಆದ್ದರಿಂದ ಕಾರಣ ಅದು ಇನ್ನೂ
ದಂಡ, ಇದು ಇನ್ನೂ ಮಾನ್ಯ PHP ಇಲ್ಲಿದೆ,

749
00:37:33,680 --> 00:37:37,000
ಆದರೆ ಏಕೆಂದರೆ, ಹೈಲೈಟ್ ವಾಕ್ಯ ಅಲ್ಲ
ಈ ಕಡತ something.php ಎಂದು ಇಲ್ಲ.

750
00:37:37,000 --> 00:37:41,580
ಆ ನಿಜವಾದ ವ್ಯತ್ಯಾಸ ಇಲ್ಲಿದೆ
ಇಲ್ಲಿ, ಜೊತೆಗೆ ವಿಷಯ.

751
00:37:41,580 --> 00:37:45,170
ಆದ್ದರಿಂದ ಯಾವಾಗ ಏನಾಗುತ್ತದೆ ನೋಡೋಣ
ನಾನು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಈ ಪ್ರೋಗ್ರಾಂ.

752
00:37:45,170 --> 00:37:50,780
./ Add3, ನಾನು ಸಿ ಬ್ಯಾಷ್ ಜೊತೆಗೆ ರೀತಿಯಲ್ಲಿ.

753
00:37:50,780 --> 00:37:53,190
./ Add3 ಅನುಮತಿಯನ್ನು ನಿರಾಕರಿಸಿದರು.

754
00:37:53,190 --> 00:37:55,390
ನೀವು ನೀನು ಏನು
ನೀವು ಮರೆಯಬೇಡಿ ನೋಡಲು

755
00:37:55,390 --> 00:37:59,280
ಬದಲಾಯಿಸಲು chmod ಆಜ್ಞೆಯನ್ನು ಬಳಸಲು
ಕಡತದ ಅನುಮತಿಗಳನ್ನು.

756
00:37:59,280 --> 00:38:03,845
>> ಇದು, ಸಾಮಾನ್ಯ ಪಿಎಚ್ಪಿ ತಿರುಗಿದರೆ
ಕಡತಗಳನ್ನು ಕೇವಲ ಕಾರ್ಯರೂಪಕ್ಕೆ ಸಾಧ್ಯವಿಲ್ಲ.

757
00:38:03,845 --> 00:38:06,970
ಅವರು ಭಾಷ್ಯವಾಗಿದೆ, ಆದರೆ ನಾವು ನೀವು
ಇಲ್ಲಿ ಸ್ವಲ್ಪ ಬೇರೆ ಏನು.

758
00:38:06,970 --> 00:38:07,761
ನಾವು ಪಾಲಿಸಲು ಆಗಿರುವ.

759
00:38:07,761 --> 00:38:12,970
ಮತ್ತು ಆದ್ದರಿಂದ ನಾನು ಅನುಮತಿ ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ
ಮರಣದಂಡನೆಯ, ಒಂದು + X ಗೆ add3 chmod.

760
00:38:12,970 --> 00:38:15,680
ನಂತರ ನಾನು ./ add3 ಹೇಳಬಹುದು.

761
00:38:15,680 --> 00:38:16,860
ಅಂತ ಸಂಖ್ಯೆಯನ್ನು ನೀಡಿ.

762
00:38:16,860 --> 00:38:18,060
5, 6.

763
00:38:18,060 --> 00:38:20,490
ಈ ಎರಡು ಸಂಖ್ಯೆಗಳ ಮೊತ್ತ 11.

764
00:38:20,490 --> 00:38:26,530
>> ಹಾಗೆಯೇ, ನಾನು ಈಗಾಗಲೇ chmoded ಎಂದು
dice2, ಆದ್ದರಿಂದ ನಾನು, dice2 ./ ಟೈಪಿಸಿದರೆ

765
00:38:26,530 --> 00:38:31,260
ನೀವು 1 ಮತ್ತು 1 ಸುತ್ತವೇ, ನೀವು
ಹೀಗೆ ಒಂದು 5 ಮತ್ತು 4 ಮತ್ತು ಸುತ್ತಿಕೊಂಡ.

766
00:38:31,260 --> 00:38:33,680
>> ಆದ್ದರಿಂದ ಬಹುಮಟ್ಟಿಗೆ ಇಲ್ಲಿದೆ
ಒಂದು ಪಿಎಚ್ಪಿ ವಾಕ್ಯ ಕಲ್ಪನೆ, ಬಲ?

767
00:38:33,680 --> 00:38:35,221
ಮೂಲಕ ಪಡೆಯಲು ಸಾಕಷ್ಟು, ನನಗೆ ಗೊತ್ತು.

768
00:38:35,221 --> 00:38:39,160
ಆದರೆ ಆಶಾದಾಯಕವಾಗಿ ಆ ಪಿಎಚ್ಪಿ ಈಗ ನೋಡಿದ
ಸಿ ನಿಜವಾಗಿಯೂ ವಿವಿಧ ಅಲ್ಲ

769
00:38:39,160 --> 00:38:43,670
ಹಾಗೂ ನಮ್ಮ ಸಾಮರ್ಥ್ಯವನ್ನು ನೀಡುತ್ತದೆ
ಒಂದು ಹಂತ ಅಥವಾ ಎರಡು ವಸ್ತುಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು.

770
00:38:43,670 --> 00:38:48,230
ನಾವು ನಿಜವಾಗಿಯೂ ಚಿಂತೆ ಇಲ್ಲ
ನಾವು ನಿಜವಾಗಿಯೂ about-- ತುಂಬಾ

771
00:38:48,230 --> 00:38:51,605
ಬಗ್ಗೆ ತುಂಬಾ ಚಿಂತೆ
ಕಡಿಮೆ ಮಟ್ಟದ ವಿವರಗಳು ನಾವು

772
00:38:51,605 --> 00:38:52,980
ಬಲ, ಸಿ ಬಗ್ಗೆ ಚಿಂತೆ ಬಂತು?

773
00:38:52,980 --> 00:38:56,170
ನಾವು ಹೆಚ್ಚಿನ ಗಮನ
ಮಟ್ಟದ ವಿಷಯವನ್ನು ಪಿಎಚ್ಪಿ

774
00:38:56,170 --> 00:39:01,090
ನಮಗೆ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ ಮತ್ತು ತೆಗೆದುಕೊಳ್ಳುವ
ಇದು ನಮಗೆ ಕೆಲಸ ಎಂದು ಮಂಜೂರು.

775
00:39:01,090 --> 00:39:04,350
ಆದ್ದರಿಂದ, ಈಗ ನಮಗೆ ಸಾಮರ್ಥ್ಯವನ್ನು ನೀಡುತ್ತದೆ
ಪಿಎಚ್ಪಿ ಸಿ ರಿಂದ ಪರಿವರ್ತಿಸುವುದರಿಂದ,

776
00:39:04,350 --> 00:39:08,280
ಬಹಳಷ್ಟು ಹೆಚ್ಚು ಎಂದು ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಮಾಡಲು
ಸಂಕೀರ್ಣ ಮತ್ತು ಬಹುಶಃ ಬಹಳ ದೃಢವಾದ.

777
00:39:08,280 --> 00:39:13,070
>> ಹಾಗಾಗಿ ನೀವು ವಿನೋದ ಕೆಲಸ ಆಶಿಸುತ್ತೇವೆ
ಪಿಎಚ್ಪಿ, ಮತ್ತು ನಾನು ಡೌಗ್ ಲಾಯ್ಡ್ ಮನುಷ್ಯ.

778
00:39:13,070 --> 00:39:15,050
ಈ CS50 ಹೊಂದಿದೆ.

779
00:39:15,050 --> 00:39:17,637