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
సాధారణంగా క్యాలెండర్ మార్పు విషయాలను ఈ తరువాత ఒక JavaScript ఒకటి, కానీ

14
00:01:05,400 --> 00:01:09,560
1 వారం తక్కువ ప్రతిదీ చేస్తుంది మరియు మేము ఇకపై ఒక JavaScript pset ఉన్నాయి.

15
00:01:09,560 --> 00:01:12,310
నేను ఆ JavaScript పరీక్ష కనిపించే వెళ్లి అని ఎలా ప్రభావితం చేస్తుందో తెలియదు

16
00:01:12,310 --> 00:01:15,510
లేదా 1 క్విజ్.

17
00:01:15,510 --> 00:01:22,260
నేను మీరు JavaScript ఉన్నత స్థాయి విషయాలను తెలుసుకోవాలి లాగా, ఏదో ఉంటుంది ఊహించుకోండి

18
00:01:22,260 --> 00:01:26,460
కానీ నేను మీరు నేరుగా JavaScript కోడ్ ఇవ్వడం కావలసిన సందేహమే

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
ఈ విషయాన్ని చాలా కొంతవరకు పేలవమైన పదాలతో కూడి ఉంది, కానీ మేము ఎందుకు చర్చించడానికి చేస్తాము.

23
00:01:43,870 --> 00:01:50,220
సి కాకుండా, PHP ఒక "డైనమిక్ టైప్ చేసిన" భాష. ఈ ఏమి అర్ధం, మీరు అడగవచ్చు?

24
00:01:50,220 --> 00:01:53,830
Well, ఆ చార్, ఫ్లోట్, Int, మరియు ఇతర కీలక పదాలు అన్ని సే గుడ్బై టు మీరు ఉపయోగించాలి

25
00:01:53,830 --> 00:01:56,190
వేరియబుల్స్ మరియు C. లో విధులు ప్రకటించారు ఉన్నప్పుడు

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
నేను, మేము Int, చార్, ఫ్లోట్ కు వీడ్కోలు చెబుతున్న దాన్ని అర్థం వాస్తవం విభేదిస్తున్నారు

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
స్థిరంగా కూర్చబడిన ఇది, అని డైనమిక్ టైప్, మీ రకం పరిశీలన మరియు stuff అన్ని

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
ఇది మీరు ఒక Int మరియు ఒక పాయింటర్ జోడించలేరు అని జరగబోతోంది ఎందుకంటే ఫిర్యాదు చెప్పారు.

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
మీరు భస్మం, ఫ్లోట్, Int చెప్పడానికి లేదు భాషలలో, మరియు ఆ విషయాలు అన్ని ఉన్నాయి

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
కాని ఇప్పటికీ కంపైల్ సమయంలో మీరు ఒక Int మరియు స్ట్రింగ్ మిక్సింగ్ మీరు ఈ చెయ్యలేరు యున్నది.

49
00:03:58,700 --> 00:04:05,650
డైనమిక్ టైప్ కేవలం కొంత అమలు సమయంలో మీరు ఒక ఫిర్యాదు పొందడానికి వెళుతున్న అర్థం.

50
00:04:05,650 --> 00:04:13,430
మీరు కూడా సాధారణంగా, ముందు జావా ఉపయోగిస్తే, దాదాపు ఏ C-టైపు భాష

51
00:04:13,430 --> 00:04:20,070
గణాంకపరంగా కాబట్టి C, C + +, Java, ఆ అన్ని సాధారణంగా స్థిరంగా కూర్చబడిన ఉంటాయి, టైప్ చేయడం అన్నారు.

52
00:04:20,070 --> 00:04:22,910
జావా లో మీరు ఏదో కంపైల్ మరియు మీరు చెబుతున్న సమయంలో

53
00:04:22,910 --> 00:04:26,670
స్ట్రింగ్ s, ఒక స్ట్రింగ్ కాదు కొత్త ఏదో సమానం

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
అప్పుడు మేము దాన్ని మరియు% s ముద్రించడానికి వెళుతున్న -

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
అక్కడ చార్ * మరియు బూలియన్ కేవలం Int లేదా చార్ లేదా ఏదో ఉంటుంది.

75
00:06:00,500 --> 00:06:05,690
PHP లో ఈ రకాల ఉన్నాయి, మరియు ఆ C పైగా PHP యొక్క పెద్ద ప్రయోజనాలు ఒకటి -

76
00:06:05,690 --> 00:06:13,290
స్ట్రింగ్ ఆపరేషన్లు వారు పనిచేసేలా C. కంటే 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 అని PHP వ్యాఖ్యాత, చెపుతుంది.

80
00:06:26,710 --> 00:06:30,250
మీరు ఫైల్ ఏదైనా లోపాలు ఉంటే, వ్యాఖ్యాత ఇత్సెల్ఫ్!

81
00:06:30,250 --> 00:06:39,110
వ్యాఖ్యాత, ఈ PHP మరియు C. మధ్య మరొక పెద్ద తేడా

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 మరియు మొదలైనవి హిట్స్ తర్వాత var హిట్స్ 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
ఆ మేము సి లో పొందుతారు ఆప్టిమైజేషన్లు చాలా, అర్థం

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
మీరు ఖచ్చితంగా C లో అలా కాదు!

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
అప్పుడు NULL ఉంది. NULL ప్రత్యేక రకం.

109
00:08:43,740 --> 00:08:47,140
NULL కేవలం చిరునామా 0 తో పాయింటర్ ఉన్న సి కాకుండా,

110
00:08:47,140 --> 00:08:54,930
PHP లో, NULL ఆ రకమైన మాత్రమే చెల్లుబాటు అయ్యే విషయం NULL దాని స్వంత రకం.

111
00:08:57,560 --> 00:09:00,670
ఈ చాలా ఉపయోగకరంగా దోష పరిశీలన మాత్రమే.

112
00:09:00,670 --> 00:09:04,310
మేము మీరు NULL తిరిగి ఉంటే పేరు ఈ సమస్యను కలిగి ఉన్న సి లో,

113
00:09:04,310 --> 00:09:08,660
మీరు ఒక నల్ పాయింటర్ తిరిగి లేదా లోపం సూచిస్తుంది NULL ఉపయోగించే అర్థం లేదు

114
00:09:08,660 --> 00:09:12,380
లేదా మేము ఒక సమయంలో కలిగి గందరగోళం అన్ని.

115
00:09:12,380 --> 00:09:18,440
ఇక్కడ, NULL తిరిగి సాధారణంగా లోపం అర్థం.

116
00:09:20,860 --> 00:09:27,300
విషయాలు చాలా కూడా లోపం కోసం తప్పుడు తిరిగి.

117
00:09:27,300 --> 00:09:33,140
కానీ పాయింట్ NULL రకం, NULL రకం మాత్రమే విషయం NULL.

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
కాబట్టి ఇక్కడ, మీరు ఈ రకం ఏమి ఆలోచిస్తాడు? >> [విద్యార్థి] Array.

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
ఇక్కడ సూచీలు a, b మరియు c మరియు విలువలు 1, 2, మరియు 3 ఉంటాయి.

128
00:10:26,320 --> 00:10:33,980
PHP లో ఒక అనుబంధ శ్రేణి మరియు కేవలం ఒక సాధారణ శ్రేణి మధ్య తేడా ఉంది

129
00:10:33,980 --> 00:10:36,740
మీరు C. లో ఆలోచించి, అని

130
00:10:36,740 --> 00:10:43,040
అక్కడ ఈ ఉంది, మరియు హుడ్ కింద ఒక సాధారణ శ్రేణి కేవలం ఒక అనుబంధ శ్రేణి

131
00:10:43,040 --> 00:10:50,000
కొన్ని విలువ కొన్ని విలువ 0 Maps అదే విధంగా ఒక Maps.

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
దాన్ని సరిగ్గా hashes అది బహుశా స్థిరంగా ఉంది.

136
00:11:18,970 --> 00:11:21,620
ఎవరు అది నిజంగా హుడ్ కింద ఏమి తెలుసు?

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
వనరు యొక్క ఆలోచన, C లో మీరు రకం ఫైల్ * లేదా ఎలాగైనా వచ్చింది;

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
చివరకు, NULL రకం ఏమిటి? >> [విద్యార్థి] NULL.

149
00:12:26,520 --> 00:12:30,650
అవును. కాబట్టి NULL అని మాత్రమే విషయం NULL.

150
00:12:30,650 --> 00:12:33,480
NULL NULL.

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
పైథాన్ లో ఈ నిర్వర్తించుటకు మరియు ("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, కాకుండా JavaScript మరియు జావా,

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
సి లో, మీరు ఎప్పుడూ పూర్ణాంక truncation ఆధారపడవచ్చు ఆ బహుశా ఆశ్చర్యకరమని తెలిపాడు

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 మరియు JavaScript నేను ప్రతిదీ అప్ కలపాలి.

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
సి లో మీరు అన్ని అక్షరాల కంటే iterate వుంటుంది

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
కాబట్టి ప్రింట్ చేసినప్పుడు, అది, ఇక్కడ నేను చూడాలనుకున్న పోల్చడం am, ఏమీ ముద్రించిన

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
[విద్యార్థి] ఇది hex ఉందా? >> ఇది hex కాదు, కానీ ఇది ఎలా ఆ దగ్గరలో -

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
చెత్తగా వంటి వాటిని (తప్పుడు == NULL) ఉన్నాయి; నిజం

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 '== []); FALSE.

287
00:25:16,090 --> 00:25:19,090
కాబట్టి == సకర్మక ఏ విధంగా ఉంది.

288
00:25:19,090 --> 00:25:26,830
a, b సమానంగా ఉంటుంది మరియు ఒక సి సమానంగా ఉంటుంది

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 లో, అర్రే రకం మీరు C. లో ఉపయోగిస్తారు ఏమి భిన్నంగా ఉంటుంది

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 చివరకు, కేవలం చదరపు పరిధుల nice సింటాక్స్ సుమారు వచ్చింది

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 మేము ఉపకరణంపై ఏ అక్కడ వేసవిలో మేము ఈ సమస్యను ఎదుర్కొంది

318
00:28:08,220 --> 00:28:14,480
కానీ మేము మా గ్రేడ్ పుస్తకం అమలు మరియు submit మరియు అన్ని అంశాలను ఆ సర్వర్

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
మరియు ఇప్పుడు మా కోడ్ అకస్మాత్తుగా none అన్ని పనిచేస్తుంది

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
ఉపకరణం చేస్తుంది నుండి ఈ తరగతి, 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
మీరు శ్రేణి stuff రకమైన అప్ మీకెప్పుడూ ఎక్కువగా మీరు చూడండి చూడాలని

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
$ శ్రేణి [b]. ఎందుకు ఈ తప్పు అవుతుంది?

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
'hello world' అని బి వివరిస్తాయి.

343
00:30:20,180 --> 00:30:28,740
కాబట్టి ఇప్పుడు బి స్థిరమైన మరియు $ శ్రేణి ఉంటుంది [b] వాస్తవానికి 'హలో' చేస్తూ ఉంటుంది.

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 ($ శ్రేణి ['hello world']) తప్పుడు తిరిగి ఉంటుంది.

350
00:30:54,690 --> 00:30:59,160
isset ($ శ్రేణి ['బి']) నిజమైన తిరిగి కనిపిస్తుంది.

351
00:31:06,830 --> 00:31:09,880
మీరు ఈ వాక్య నిర్మాణములు కలపవచ్చు.

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
మరియు నేను దానిని పైగా iterate చేయవచ్చు.

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
అందువల్ల లెక్కింపు ($ శ్రేణి); $ i + +)

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
ఈ అధిక భాగం, మీరు ఈ వ్యూహం పై iterate అవసరం ఉండదు, కారణం.

426
00:38:03,020 --> 00:38:07,110
ఇది ఒక అతిశయోక్తి కావచ్చు, కానీ మీరు ఈ వ్యూహం పై iterate అవసరం లేదు

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 కేవలం NEWLINE, కాని ఇది సాంకేతికంగా చాలా చిన్నవిగా ఉంది

443
00:40:03,580 --> 00:40:08,890
Windows లో న్యూ లైన్ Mac మరియు UNIX లో న్యూ లైన్ భిన్నంగా ఉంటుంది.

444
00:40:08,890 --> 00:40:18,040
Windows న NEWLINE \ r \ n, ప్రతిచోటా else అయితే అది కేవలం \ n ఉంటుంది ఉంది.

445
00:40:18,040 --> 00:40:25,150
మీ సిస్టమ్ యొక్క NEWLINE ఉండే వస్తువు ఉపయోగిస్తుంది కాబట్టి 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 అన్ సెట్ కూడా Item ఇప్పటికీ విలువ 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
అది శ్రద్ధ లేదు. Item అసలు విలువల పడుతుంది.

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
మేము కేవలం అంశం ప్రతి శ్రేణి కోసం iterate ఉంటే ఇక్కడ, అంశం ప్రతి సమయం 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
Item కేవలం శ్రేణి విలువ యొక్క కాపీ.

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
అది విషయాలను ఈ కాపీలు విషయములపై నేను హుడ్ కింద సంఖ్య ఆలోచన ఉంది ఎందుకంటే,

585
00:53:52,530 --> 00:53:55,170
OH, ఒక స్థిరమైన సమయం కాపీ అని అన్నారు,

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
కమాండ్ లైన్ వద్ద, మీరు ఆ executable స్క్రిప్ట్ కాల్ చేయవచ్చు.

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
లేదా మేము Python లేదా Perl లేదా 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
మీరు C లో 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
ఈ కూడా C. ఉంది

623
00:57:08,160 --> 00:57:10,700
మీరు ఒక ఫంక్షన్ లో ఒక ఫంక్షన్ లో ఒక ఫంక్షన్ లో ఒక ఫంక్షన్ లో అయితే

624
00:57:10,700 --> 00:57:17,540
మరియు మీరు ప్రోగ్రామ్ చంపడానికి కావాలి, మీరు నిష్క్రమణ కాల్ మరియు ఇది కేవలం నిష్క్రమిస్తుంది.

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
అంటే F కాల్ చూడాలని ఒక వనరు తిరిగి.

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 స్థాయి indentations అన్ని వచ్చి వెళ్తున్నారు

672
01:01:30,190 --> 01:01:33,360
అప్పుడు మా ఏ indentations అన్ని వస్తాయి.

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 బ్లా, బ్లా, బ్లా తరగతి లేదా ఎలాగైనా, చేయవచ్చు తద్వారా మంచిది

716
01:05:18,050 --> 01:05:25,140
అప్పుడు బ్లా, బ్లా, బ్లా మరియు కొన్ని PHP కోడ్ చేసి మరియు అప్పుడు ముగింపు DIV చేయండి.

717
01:05:25,140 --> 01:05:36,460
ఇప్పుడు, నేను టాప్ నా nice DIV పొందండి ప్రతిదీ ఈ ప్రింటింగ్ ఆ PHP PRINTED, దిగువన DIV.

718
01:05:36,460 --> 01:05:43,510
ఈ వంటి ఏదో జరిగినప్పుడు ఘోరమైన, ఇది చాలా సాధారణం

719
01:05:43,510 --> 01:05:47,930
ఫైలు దిగువన కేవలం ఒక దారితప్పిన NEWLINE.

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
>> మీరు ఒక ఫైల్ దిగువన ఒక దారితప్పిన NEWLINE ఉంటే

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
మీరు HTML తో చెయ్యడానికి ప్లాన్ ఉంటే -

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
>> తీగలను వ్యవహారం C. కంటే NICER ఉంది

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
నిరంతరం, బ్లా, బ్లా, బ్లా తప్పించుకుంటారు.

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
మరియు ఒకే కోట్ తీగలను గురించి nice మాట చెప్పగల్గినవి ఉంది 'hello world!' బ్లా, బ్లా, బ్లా,

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
మీరు క్రొత్త పంక్తులను ఉంటుందనుకుంటున్నాను ఇది బాక్ స్లాష్ 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
నేను రన్ చేసినప్పుడు - మరియు నేను NEWLINE ఇన్సర్ట్ చేస్తుంది - హాయ్, నా పేరు రాబ్ ఉంది! హలో వరల్డ్!

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
ఊహించని ఒకే కోట్ (బ్లా, బ్లా, బ్లా, బ్లా, బ్లా 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
Interpolating కొన్ని ఖర్చు ఉంది.

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
>> , శాన్ డియాగో classy ఉండండి.

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]