[Powered by Google Translate] [విభాగం 8 - అత్యంత సౌకర్యవంతమైన]
[రాబ్ బౌడెన్ - హార్వర్డ్ యూనివర్శిటీ]
[ఈ CS50 ఉంది. - CS50.TV]
>> ఈ వారం విభాగం నోట్స్, అందంగా చిన్న ఉంటాయని నేను
నేను మాట్లాడటం ఉంచండి వెళుతున్న కాబట్టి, మీరు అబ్బాయిలు, ప్రశ్నలను అడగడం ఉంచడానికి వెళ్తున్నారు
మరియు మేము సాధ్యమైనంత ఎక్కువ సమయం వరకు పూర్తి ప్రయత్నిస్తాము.
మంది ఈ pset తప్పనిసరిగా కష్టం కాదని అనుకుంటున్నాను, కాని అది చాలా పొడవుగా ఉంది.
pset స్పెక్ కూడా ఒక గంట చదవడానికి పడుతుంది.
మీరు బహుశా మీరు ఉపయోగించాలని కాలేదు SQL ఇచ్చాయి.
మేము చాలా ద్వారా మీరు నడక, కాబట్టి ఇది చాలా చెడ్డ కాదు.
ఎవరైనా ప్రారంభించారు లేదా పూర్తి?
గత pset ఉంది. ఓహ్, నా దేవుని.
సాధారణంగా క్యాలెండర్ మార్పు విషయాలను ఈ తరువాత ఒక JavaScript ఒకటి, కానీ
1 వారం తక్కువ ప్రతిదీ చేస్తుంది మరియు మేము ఇకపై ఒక JavaScript pset ఉన్నాయి.
నేను ఆ JavaScript పరీక్ష కనిపించే వెళ్లి అని ఎలా ప్రభావితం చేస్తుందో తెలియదు
లేదా 1 క్విజ్.
నేను మీరు JavaScript ఉన్నత స్థాయి విషయాలను తెలుసుకోవాలి లాగా, ఏదో ఉంటుంది ఊహించుకోండి
కానీ నేను మీరు నేరుగా JavaScript కోడ్ ఇవ్వడం కావలసిన సందేహమే
మీకు pset కలిగి కాబట్టి.
కానీ ఆ తరువాత వారం క్విజ్ సమీక్ష విషయాలను ఉంటుంది.
>> ప్రశ్నలు యొక్క విభాగం.
ఈ విషయాన్ని చాలా కొంతవరకు పేలవమైన పదాలతో కూడి ఉంది, కానీ మేము ఎందుకు చర్చించడానికి చేస్తాము.
సి కాకుండా, PHP ఒక "డైనమిక్ టైప్ చేసిన" భాష. ఈ ఏమి అర్ధం, మీరు అడగవచ్చు?
Well, ఆ చార్, ఫ్లోట్, Int, మరియు ఇతర కీలక పదాలు అన్ని సే గుడ్బై టు మీరు ఉపయోగించాలి
వేరియబుల్స్ మరియు C. లో విధులు ప్రకటించారు ఉన్నప్పుడు
PHP లో, ఒక వేరియబుల్ రకం ప్రస్తుతం హోల్డింగ్ ఆ విలువతో నిర్ణయించబడుతుంది.
మేము dynamic.php గా పిలువబడే ఒక ఫైల్ లో ఈ కోడ్ టైప్ కాబట్టి ముందు
PHP డైనమిక్ టైపు చేసినప్పుడు. ఆ నిజం.
నేను, మేము Int, చార్, ఫ్లోట్ కు వీడ్కోలు చెబుతున్న దాన్ని అర్థం వాస్తవం విభేదిస్తున్నారు
మరియు ఇతర కీలక పదాలు.
డైనమిక్ టైప్ చేసిన మరియు ప్రత్యామ్నాయ మధ్య ఖచ్చితమైన తేడాలు,
స్థిరంగా కూర్చబడిన ఇది, అని డైనమిక్ టైప్, మీ రకం పరిశీలన మరియు stuff అన్ని
, రన్ సమయంలో జరుగుతుంది స్థిరంగా కూర్చబడిన అయితే కంపైల్ సమయంలో జరుగుతుంది.
సాధారణంగా స్థిర పదం స్వరపరిచే సమయం విషయాలను అర్థం ఉంది.
నేను ఇతర ఉపయోగాలు ఉన్నాయి అంచనా, కానీ మీరు ఒక స్థిరమైన వేరియబుల్ డిక్లేర్ చేసినప్పుడు సి, లో
దాని నిల్వ కంపైల్ సమయంలో కేటాయించబడుతుంది.
ఇక్కడ, డైనమిక్ టైప్ కేవలం అర్థం -
సి లో మీరు కంపైల్ సమయంలో, ఒక స్ట్రింగ్ మరియు పూర్ణాంకం జోడించడానికి ప్రయత్నించండి ఉంటే,
ఇది మీరు ఒక Int మరియు ఒక పాయింటర్ జోడించలేరు అని జరగబోతోంది ఎందుకంటే ఫిర్యాదు చెప్పారు.
ఇది ఒక చెల్లుబాటు అయ్యే ఆపరేషన్ కాదు.
అంటే రెండవ లో చూస్తారు మరో విషయం.
కానీ తనిఖీ ఆ విధమైన స్వరపరిచే సమయం వద్ద ఫిర్యాదు వాస్తవం,
స్థిరమైన టైపు తనిఖీని ఉంది.
మీరు భస్మం, ఫ్లోట్, Int చెప్పడానికి లేదు భాషలలో, మరియు ఆ విషయాలు అన్ని ఉన్నాయి
కానీ భాష, ఇది రావలసిన ఏమి రకం విషయం యొక్క సందర్భం నుండి తెలియజేయవచ్చు
కాని ఇప్పటికీ స్థిరంగా చేసిన.
మీరు 51, OCaml పడుతుంది కాబట్టి, మీరు, ఈ రకాల ఉపయోగించడానికి అవసరం లేదు
కాని ఇప్పటికీ కంపైల్ సమయంలో మీరు ఒక Int మరియు స్ట్రింగ్ మిక్సింగ్ మీరు ఈ చెయ్యలేరు యున్నది.
డైనమిక్ టైప్ కేవలం కొంత అమలు సమయంలో మీరు ఒక ఫిర్యాదు పొందడానికి వెళుతున్న అర్థం.
మీరు కూడా సాధారణంగా, ముందు జావా ఉపయోగిస్తే, దాదాపు ఏ C-టైపు భాష
గణాంకపరంగా కాబట్టి C, C + +, Java, ఆ అన్ని సాధారణంగా స్థిరంగా కూర్చబడిన ఉంటాయి, టైప్ చేయడం అన్నారు.
జావా లో మీరు ఏదో కంపైల్ మరియు మీరు చెబుతున్న సమయంలో
స్ట్రింగ్ s, ఒక స్ట్రింగ్ కాదు కొత్త ఏదో సమానం
ఆ రకాల కేవలం మ్యాచ్ ఎందుకంటే ఫిర్యాదు చెప్పారు.
ఆ స్వరపరిచే సమయం వద్ద ఫిర్యాదు చెప్పారు.
మీరు ఏదో నటింపచేయాలని ప్రయత్నించండి అయితే అది కూడా విషయాలు కొన్ని డైనమిక్ సమయం
ప్రస్తుత రకం కంటే ఎక్కువ నిర్దిష్ట ఉన్న ఒక రకం,
ఆ తారాగణం విజయవంతం అన్నారు లేదో తనిఖీ కంపైల్ సమయంలో చేయవచ్చు ఏదీ లేదు.
జావా కూడా తనిఖీకి కొన్ని డైనమిక్ రకం కలిగి కోడ్ లైనును అవకాశంను వెంటనే
నిజానికి అమలు ఉన్నప్పుడు, అది, తారాగణం చేయడానికి జరగబోతోంది
ఆ తారాగణం మొదటి స్థానంలో చెల్లుబాటు అయ్యే, ఒకవేళ తనిఖీ
మరియు అది లేదు, అప్పుడు మీరు ఒక చెల్లని రకం అని ఫిర్యాదు చేస్తాడు.
డైనమిక్ రకం తనిఖీ.
Dynamic.php గా పిలువబడే ఒక ఫైల్ ఈ టైప్ చేయండి.
Dynamic.php.
నేను ఆ ఆకృతీకరణ అన్జిప్ చేస్తాము.
మేము, మేము పూర్ణాంక 7 సెట్, ఒక వేరియబుల్ కలిగి
అప్పుడు మేము దాన్ని మరియు% s ముద్రించడానికి వెళుతున్న -
ఓహ్, మనం రకపు ముద్రణ చేస్తున్నాం gettype వేరియబుల్ రకం తిరిగి అన్నారు.
మేము కేవలం మరియు విషయంలో రకపు ముద్రణ చేస్తున్నారు.
మేము php.dynamic.php.
మేము చూస్తారు ఆ పూర్ణాంక నుండి బూలియన్ కు స్ట్రింగ్ కు మార్పులు మేము ద్వారా వెళ్ళి వంటి.
సి ఏ బూలియన్ డేటా రకం ఉంది, ఏ తీగ డేటా రకం ఉంది.
అక్కడ చార్ * మరియు బూలియన్ కేవలం Int లేదా చార్ లేదా ఏదో ఉంటుంది.
PHP లో ఈ రకాల ఉన్నాయి, మరియు ఆ C పైగా PHP యొక్క పెద్ద ప్రయోజనాలు ఒకటి -
స్ట్రింగ్ ఆపరేషన్లు వారు పనిచేసేలా C. కంటే PHP లో అపరిమిత సులభంగా ఉంటాయి.
>> కాబట్టి మేము తిరిగి ఇక్కడికి వచ్చి.
మేము dynamic.php నడిచింది.
ఈ dynamic.php లో PHP కోడ్ అమలు చేయడానికి php అని PHP వ్యాఖ్యాత, చెపుతుంది.
మీరు ఫైల్ ఏదైనా లోపాలు ఉంటే, వ్యాఖ్యాత ఇత్సెల్ఫ్!
వ్యాఖ్యాత, ఈ PHP మరియు C. మధ్య మరొక పెద్ద తేడా
సి లో మీరు ఏదో కంపైల్ మరియు మీరు ఆ సంకలనం ఫైలు అమలు చేయాలి.
PHP లో మీరు ఏదైనా కంపైల్ ఎప్పుడూ.
కాబట్టి PHP వ్యాఖ్యాత ప్రధానంగా కేవలం గీత ఈ మాటకు ఉంది.
ఇది var = 7 అప్పుడు ఇది printf మరియు మొదలైనవి హిట్స్ తర్వాత var హిట్స్ printf తర్వాత హిట్స్ హిట్స్.
అక్కడ అది కంపైల్ ఒక బిట్, మరియు ఇది ఫలితాలు కాషె చేస్తుంది
ను అమలు చేస్తే తర్వాత మీరు, కొన్ని చేయవచ్చు
కానీ ప్రాథమికంగా అది విషయం యొక్క లైన్ దీని ద్వారా క్రమీకరించు ఒక లైన్.
ఆ మేము సి లో పొందుతారు ఆప్టిమైజేషన్లు చాలా, అర్థం
కంపైల్ వలె, ఇది కంపైలర్ మీరు యుక్తులు చాలా చేయవచ్చు కేవలం సాధారణంగా.
ఇది ఉపయోగించని వేరియబుల్స్ చేద్దామని, అది, విషయాలు ఈ రకమైన అన్ని చేయవచ్చు
అది తోక సూత్రం చేయవచ్చు.
PHP లో మీరు ఆ ప్రయోజనాన్ని పొందడానికి వెళ్ళి లేదు
ఇది లైన్ ద్వారా లైన్ ద్వారా లైన్ అమలు ఆరంభమవుతుంది ఎందుకంటే,
అది నిజంగా సులభంగా ఈ విషయాలను గుర్తించడం లేదు
అది 1 పెద్ద సంగ్రహం విషయం మీద పాస్ ఆపై అమలు కాదు నుంచి;
ఇది లైన్ ద్వారా కేవలం లైన్.
కాబట్టి ఆ వ్యాఖ్యాత ఉంది.
>> మా డైనమిక్ టైపింగ్ తిరిగి: చాలా బాగుంది, EH?
మీరు ఖచ్చితంగా C లో అలా కాదు!
మీరు క్రింద విలువలను ప్రతి రకం గుర్తించడానికి లేదో ఇప్పుడు చూడండి.
సూచన కోసం ఈ చూడండి.
3,50 కాబట్టి. మీరు చేస్తాడు ఆ ఏ రకం అనుకుంటున్నారు?
ఇక్కడ మనం రకాలు.
మేము bools, పూర్ణ, ఫ్లోటింగ్ పాయింట్లు, తీగలు, శ్రేణులు, వస్తువులు కలిగి
తరువాత అస్పష్టమైన రకం వనరులు, ఇది.
నేను ఒక ఉదాహరణ ఇక్కడ వాస్తవానికి ఉందని నేను అనుకుంటున్నాను.
అప్పుడు NULL ఉంది. NULL ప్రత్యేక రకం.
NULL కేవలం చిరునామా 0 తో పాయింటర్ ఉన్న సి కాకుండా,
PHP లో, NULL ఆ రకమైన మాత్రమే చెల్లుబాటు అయ్యే విషయం NULL దాని స్వంత రకం.
ఈ చాలా ఉపయోగకరంగా దోష పరిశీలన మాత్రమే.
మేము మీరు NULL తిరిగి ఉంటే పేరు ఈ సమస్యను కలిగి ఉన్న సి లో,
మీరు ఒక నల్ పాయింటర్ తిరిగి లేదా లోపం సూచిస్తుంది NULL ఉపయోగించే అర్థం లేదు
లేదా మేము ఒక సమయంలో కలిగి గందరగోళం అన్ని.
ఇక్కడ, NULL తిరిగి సాధారణంగా లోపం అర్థం.
విషయాలు చాలా కూడా లోపం కోసం తప్పుడు తిరిగి.
కానీ పాయింట్ NULL రకం, NULL రకం మాత్రమే విషయం NULL.
మీరు కొన్ని అనామక చర్యలు నిర్వచించలేదు వంటి అప్పుడు బ్యాక్ ఉంటుంది.
మీరు ఫంక్షన్ పేరు ఇవ్వడం లేదు, కానీ మీరు ఇక్కడ చేసే అవసరం లేదు.
వారు మాకు నువ్వు అనుకుంటున్నావా రకాల వద్ద గురించి,
మీరు 3,50 యొక్క రకం ఏమి ఆలోచిస్తాడు? >> [విద్యార్థి] ఫ్లోట్.
అవును.
కాబట్టి ఇక్కడ, మీరు ఈ రకం ఏమి ఆలోచిస్తాడు? >> [విద్యార్థి] Array.
అవును. మొదటి ఒక ఫ్లోట్ ఉంది, రెండవ వ్యూహం ఉంది.
ఈ శ్రేణి ఒక సి శ్రేణి వంటి కాదని గమనించండి
మీరు ఇండెక్స్ కలిగి ఉన్న 0 కొన్ని విలువ, ఇండెక్స్ 1 కొన్ని విలువను కలిగి ఉంది.
ఇక్కడ సూచీలు a, b మరియు c మరియు విలువలు 1, 2, మరియు 3 ఉంటాయి.
PHP లో ఒక అనుబంధ శ్రేణి మరియు కేవలం ఒక సాధారణ శ్రేణి మధ్య తేడా ఉంది
మీరు C. లో ఆలోచించి, అని
అక్కడ ఈ ఉంది, మరియు హుడ్ కింద ఒక సాధారణ శ్రేణి కేవలం ఒక అనుబంధ శ్రేణి
కొన్ని విలువ కొన్ని విలువ 0 Maps అదే విధంగా ఒక Maps.
ఈ కారణంగా, PHP వేగం కోడ్ / బెంచ్మార్కింగ్ విషయాల కోసం చాలా చెడ్డ ఉంటుంది
సి లో మీరు వరుసను ఉపయోగించి చేసినప్పుడు నుండి మీరు ఒక సభ్యుడు యాక్సెస్ స్థిరంగా సమయం అని తెలుసు.
PHP ఒక సభ్యుడు యాక్సెస్ ఎంత సమయం తెలిసిన ఉంది?
దాన్ని సరిగ్గా hashes అది బహుశా స్థిరంగా ఉంది.
ఎవరు అది నిజంగా హుడ్ కింద ఏమి తెలుసు?
మీరు నిజంగా ఆ వ్యవహరించే అవకాశముంది ఎలా చూడటానికి అమలు వద్ద చూడవలసిన అవసరం.
కాబట్టి అప్పుడు fopen.
నేను PHP మాన్యువల్ fopen తిరిగి టైప్ కు లెట్స్ ఇక్కడ భావిస్తున్నాను.
మీరు PHP మాన్యువల్లో చాలా చక్కని ఏదైనా ఫంక్షన్ చూసేందుకు ఇక్కడ చూడండి
మరియు ఈ PHP ఆఫ్ ద పేజీ యొక్క విధమైన ఉంది.
తిరిగి టైప్ వనరు అని అన్నారు.
నేను దానిని చూస్తూ ఎందుకు మమ్మల్ని వనరు నిర్వచించలేదు ఎందుకంటే ఆ చెప్పవచ్చు.
వనరు యొక్క ఆలోచన, C లో మీరు రకం ఫైల్ * లేదా ఎలాగైనా వచ్చింది;
PHP లో వనరు మీ ఫైల్ * ఉంది.
మీరు చదివిన కావడం ఏమి, అది మీకు వ్రాస్తున్నడని చూడాలని ఏమిటి.
ఇది సాధారణంగా బాహ్య, కనుక మీరు విషయాలు లాగడానికి విషయాలను విసిరివేయగలరు ఒక వనరు.
చివరకు, NULL రకం ఏమిటి? >> [విద్యార్థి] NULL.
అవును. కాబట్టి NULL అని మాత్రమే విషయం NULL.
NULL NULL.
>> PHP యొక్క రకాన్ని (మంచి లేదా తప్పుడు) ఒకటి ఫీచర్ రకాల మోసగించు దాని సామర్థ్యం ఉంది.
మీరు వివిధ రకాల విలువలు కలిపి PHP కోడ్ ఒక లైన్ వ్రాస్తున్నప్పుడు,
PHP సరైన పనిని చేయడానికి ప్రయత్నిస్తాము.
PHP కోడ్ క్రింది పంక్తులు ప్రతి ప్రయత్నించండి. ఏ ముద్రించిన యొక్క?
మీరు ఊహించిన దాని అవునా? ఎందుకు ఎందుకు లేదు?
PHP ఈ నిజానికి మేము బలహీనంగా టైప్ చేసిన కాల్ ఏది చేస్తుంది.
బలహీనంగా టైప్ మరియు బలంగా టైప్,
ఆ పదాలు కోసం వివిధ ఉపయోగాలు ఉన్నాయి
కానీ చాలా మంది విషయం ఈ విధమైన అర్థం బలహీనంగా టైప్ మరియు బలంగా టైప్ ఉపయోగించడానికి
పేరు ("1" + 2); ఆ పనిచేస్తుంది.
సి లో ఆ పని కాదు.
మీరు ఈ పని ఊహించవచ్చు.
మంది డైనమిక్ టైపింగ్ మరియు బలహీనమైన టైపింగ్ మరియు స్థిర టైపింగ్ మరియు బలమైన టైపింగ్ అప్ కలపాలి.
పైథాన్ డైనమిక్ టైప్ ఒక భాష యొక్క మరొక ఉదాహరణ.
మీరు వేరియబుల్స్ లో రకాలు చుట్టూ త్రో మరియు ఇది రన్ సమయంలో గుర్తించేందుకు జరగబోతోంది
ఏ లోపం checkings.
పైథాన్ లో ఈ నిర్వర్తించుటకు మరియు ("1" + 2) చూస్తారు జరగబోతోంది;
మీరు ఒక స్ట్రింగ్ మరియు పూర్ణాంకం జోడించలేరు చెప్పారు ఎందుకంటే మరియు ఈ విఫలమౌతుంది.
కేవలం డైనమిక్ టైప్ ఇది PHP లో, ఈ విఫలం కాదు.
బలహీనమైన టైపింగ్ అది రకాల పనులు చేసే వాస్తవం సంబంధం కలిగి ఉంటుంది,
నిజంగా అవసరం సమంజసం అని.
కాబట్టి ("1" + 2); నేను స్ట్రింగ్ 12 ఉండటం, నేను స్ట్రింగ్ 3 ఊహించవచ్చు ఊహించవచ్చు,
నేను పూర్ణాంక 3 ఊహించవచ్చు.
ఇది ఖచ్చితంగా బాగా నిర్వచించిన కాదు, మరియు మేము బహుశా ఇక్కడ చూడండి చూడాలని
మేము ప్రింట్ చేసినప్పుడు ("1" + 2) ఆ; అది వివిధ మాదిరిగా ముగించారు వెళుతున్న
ముద్రణ కంటే (1 + "2").
మరియు ఈ పరిస్థితి, నా అభిప్రాయం లో, ఉంటుంది.
ఇక్కడ మేము ఈ ప్రయత్నించవచ్చు.
PHP గురించి మరో చిన్న ట్రిక్ మీరు నిజంగా ఫైల్ను వ్రాయడానికి అవసరం లేదు ఉంది.
ఈ కమాండ్ మోడ్ అమలు కాదు.
Php-r కాబట్టి, అప్పుడు మేము ఇక్కడ ఆదేశం లో విసిరివేయగలరు:
"ముద్రణ ('1 '+ 2);" నేను ఒక కొత్త లైన్ త్రో చేస్తాము.
ఈ 3 ముద్రించబడింది.
ఇది 3 ముద్రిస్తుంది మరియు పూర్ణాంక 3 యొక్క కనిపిస్తుంది.
కాబట్టి ఇప్పుడు యొక్క చుట్టూ ఇతర మార్గం ప్రయత్నించండి తెలపండి:
"ముద్రణ (1 + '2 ');
మేము 3 పొందండి, మరియు అది కూడా పూర్ణాంక 3 ఉండబోతుంది? నిజాయితీగా సంఖ్య ఆలోచన ఉంది.
ఇది స్థిరంగా ఉంటుంది అనిపిస్తుంది.
అది స్ట్రింగ్ 12 లేదా ఏదైనా వంటి అనే అవకాశం కూడా ఇక్కడ ఉండదు
ఎందుకంటే చాలా PHP, కాకుండా JavaScript మరియు జావా,
జోడింపు కోసం ప్రత్యేక ఆపరేటర్లు కలిగి ఉంది.
PHP లో జోడింపు డాట్ ఉంది.
ముద్రణ కాబట్టి (1 '2 '.); మాకు 12 ఇవ్వాలని అన్నారు.
ఈ ప్రజలు STR + = వంటి ఏదో ఒకటి చేయడానికి ప్రయత్నించండి పేరు గందరగోళానికి దారితీస్తుంది ఉంటుంది
వారు వారి స్ట్రింగ్ చివర న జోడించదలచిన, మరియు ఆ విఫలం వెళుతున్న కొన్ని ఇతర విషయం.
మీరు STR చేయాలి. =
కాబట్టి PHP లో జోడింపు ఒక డాట్ ఉంది మరిచిపోకండి.
ప్రయత్నించడానికి ఇతర అంశాలు: ("CS" + 50) ప్రింట్;
నేను CS50 ఫలితంగా ఈ సంఖ్య ఆశ లేదు అని మీరు చెప్పారు చేసిన
జోడింపు + కాదు కాబట్టి.
మీరు ఈ మాదిరిగా ముగించారు అన్నారు ఏమి ఆలోచిస్తాడు?
నిజాయితీగా ఖచ్చితంగా సంఖ్య ఆలోచన ఉంది.
అది కేవలం 50 కనిపిస్తుంది.
ఇది స్ట్రింగ్ చూస్తాడు, మరియు మేము 123CS ఉంచితే నేను పందెం -
ఇది మొదటి స్ట్రింగ్ చూస్తాడు, అది దాని నుండి ఒక పూర్ణ సంఖ్య లేదా దాని నుండి అనేక చదవటానికి ప్రయత్నిస్తుంది.
ఈ సందర్భంలో అది 123CS చూస్తాడు.
"పూర్ణాంకం వంటి సమంజసం కాబట్టి నేను 123 భావిస్తారు వెళుతున్న."
123 కాబట్టి + 50 173 ఉంటుంది అన్నారు.
మరియు ఇక్కడ పూర్ణాంకం ఈ చదవడం ప్రారంభిస్తాడు.
ఇది ఏదైనా చూడండి లేదు, అది కేవలం అది 0 వంటి బహుమతులు కాబట్టి. 0 కాబట్టి + 50 50 అన్నారు.
నేను ఊహించి నేను ఈ పోలిన ఏదో ఒకటి అన్నారు.
నేను 99 ఆలోచిస్తున్నాను.
అవును, అది మొదటి తీసుకుని వెళుతున్న ఎందుకంటే -
99 కాబట్టి.
ఈ సి ఒకవేళ ఇక్కడ (10/7), ఏ చేరాడు?
[విద్యార్థి] 1. 10/7 2 పూర్ణాంకాల విభజన ఎందుకంటే >> అవును, అది 1 ఉంటుంది.
పూర్ణాంకం ద్వారా విభజించబడింది పూర్ణాంకం పూర్ణాంకం తిరిగి అన్నారు.
ఇది ఆ 1 పాయింట్ ఏ తిరిగి, అందువల్ల అది కేవలం 1 తిరిగి వెళుతున్న.
ఇక్కడ (10/7) ప్రింటింగ్; నిజానికి ఆ అనువదించేందుకు జరగబోతోంది.
మరియు ఈ అర్థం, మీరు నిజంగా ఆ వంటి పూర్ణాంక గుండ్రని మరియు పనులే చేస్తాం అనుకుంటే
మీరు ముద్రణ (ఫ్లోర్ (10/7)) ఏమి ఉంది;
సి లో, మీరు ఎప్పుడూ పూర్ణాంక truncation ఆధారపడవచ్చు ఆ బహుశా ఆశ్చర్యకరమని తెలిపాడు
కానీ PHP లో మీరు స్వయంచాలకంగా ఫ్లోట్ గా మారుతుంది కాదు ఎందుకంటే.
మరియు తర్వాత (7 + నిజమైన); మీరు చేస్తాడు ఆ ఏమి ఆలోచిస్తాడు?
అది 1 నిజమైన అర్థం వెళుతున్న నేను 8 ఊహించడం చేస్తున్నాను.
అది 8 యొక్క కనిపిస్తుంది.
>> మేము మీరు ఖచ్చితంగా ఏమి ఎప్పుడూ గత 10 నిమిషాల్లో చేసిన ఏదైనా కాబట్టి.
మీరు ఈ పని చేసే కోడ్ చూస్తారు.
ఈ వంటి సూటిగా లేదు.
మీరు 2 వేరియబుల్స్ చేశారు మరియు 1 వేరియబుల్ స్ట్రింగ్ నిర్మాణము
మరియు ఇతర వేరియబుల్ ఒక పూర్ణాంకానికి నిర్మాణము, మరియు అప్పుడు మీరు కలిసి అంశాలపై జోడించండి.
PHP డైనమిక్ టైప్ చేయబడింది మరియు మీరు ఏ రకం తనిఖీ చేయరు నుండి
మరియు అది బలహీనంగా చేసిన నుండి మరియు దీనిని స్వయంచాలకంగా కలిసి ఈ విషయాలు త్రో కనుక
మరియు ప్రతిది చక్కగా పని చేస్తుంది, ఇది కూడా ఈ వేరియబుల్ ఇప్పుడు ఒక స్ట్రింగ్ ఉండాలి తెలుసు కష్టం
నేను ఒక పూర్ణ సంఖ్య, ఈ వేరియబుల్ జోడించి లేదు.
ఒక వేరియబుల్ స్ట్రింగ్ ఉంటే ఉత్తమ పద్ధతి, ఎప్పటికీ స్ట్రింగ్ గా ఉంచండి.
ఒక వేరియబుల్ ఒక పూర్ణాంకానికి ఉంటే, ఎప్పటికీ ఒక పూర్ణాంకానికి గా ఉంచండి.
మీరు, పూర్ణ మరియు తీగలను వ్యవహరించే చేయాలనుకుంటే
మీరు varsint ఉపయోగించవచ్చు - ఆ JavaScript ఉంది.
Intval. నేను ఈ అన్ని మీకు. PHP మరియు JavaScript నేను ప్రతిదీ అప్ కలపాలి.
కాబట్టి intval ఒక వేరియబుల్ యొక్క పూర్ణాంక విలువ తిరిగి అన్నారు.
మేము "ముద్రణ (intval ('123 ')) లో పాస్ ఉంటే; మీరు 123 పొందండి.
Intval అది అది ప్రత్యేకంగా పూర్ణాంకం అని మాకు చెక్ చేయబోవడం లేదు.
PHP మాన్యువల్, కేవలం చాలా విధులు, అందుబాటులో ఉన్నాయి
ఇక్కడ నేను నేను ఉపయోగించే మొదటి is_numeric అనుకుంటాను.
ఆ తప్పుడు తిరిగి అంచనా చేస్తున్నాను.
అంటే === ఉంది వెళ్ళి ఉంటుంది మరొక విషయం.
కాబట్టి is_numeric ('123df '), మీరు ఆ వంటి is_numeric భావిస్తారు కాదు.
సి లో మీరు అన్ని అక్షరాల కంటే iterate వుంటుంది
మరియు ప్రతి పాత్ర అంకెల లేదా ఎలాగైనా ఉంటే తనిఖీ చేయండి.
ఇక్కడ is_numeric, మాకు అలా అన్నారు
మరియు అది తప్పుడు తిరిగి ఉంటుంది.
కాబట్టి ప్రింట్ చేసినప్పుడు, అది, ఇక్కడ నేను చూడాలనుకున్న పోల్చడం am, ఏమీ ముద్రించిన
మీరు తప్పుగా సంభవించింది? కాబట్టి ఇప్పుడు అది 1 ప్రింటింగ్ అన్నారు.
స్పష్టంగా ఇది బదులుగా నిజమైన నిజమైన ప్రింటింగ్ యొక్క నిజమైన వంటి 1 ముద్రిస్తుంది.
నేను print_r లేకపోతే ఐ వండర్. కాదు, అది ఇప్పటికీ 1 చేస్తుంది.
>> === కు వెళుతున్నారు, == ఇంకా, ఉంది
మరియు మీరు టామీ మాట్లాడితే అతను చెప్పే చేస్తాము == ఖచ్చితంగా ఉత్తమంగా ఉంటుంది.
నేను == భయంకరమైన మరియు మీరు == ఉపయోగించడానికి ఎప్పుడూ చెప్పడానికి వెళుతున్నాను.
తేడా == విషయాలు పోల్చి ఉంది
వారు ఒకే రకమైన కావు కూడా అది నిజమైన ఉండవచ్చు,
=== విషయాలు పోల్చి మరియు మొదటి అది తనిఖీలు అదే రకం వారు? అయితే
అవును. సరే, ఇప్పుడు నేను వారు నిజానికి సమానంగా పోల్చడానికి చూడండి వెళుతున్న.
మీరు 10 వంటి విచిత్రమైన విషయాలకు సమానం పొందండి - అని చెప్పే చూద్దాం.
కాబట్టి ('10 '== '1 E1');
ఈ నిజమైన తిరిగి.
ఎవరైనా ఈ నిజమైన తిరిగి ఎందుకు ఏ అంచనాలు కలిగి ఉందా?
ఇది ఆ కాదు. బహుశా ఈ సూచనను ఉంది.
కానీ నేను f ఆ మార్పు ఉంటే - అది రంధ్రాన్ని సరి చేయు! నేను డబుల్ కోట్స్ ఉపయోగించడం కొనసాగించండి.
నేను డబుల్ కోట్స్ లో ఈ ఉంచాము ఎందుకంటే డబుల్ కోట్స్ నా పదాన్ని ఉన్నాయి కారణం.
నేను ఇక్కడ డబుల్ కోట్స్ తప్పించుకోవడానికి, కానీ సింగిల్ కోట్స్ సులభం.
కాబట్టి ('10 '== '1 F1'); నిజమైన ప్రింట్ లేదు. ('10 '== '1 E1'); నిజమైన ముద్రిస్తుంది.
[విద్యార్థి] ఇది hex ఉందా? >> ఇది hex కాదు, కానీ ఇది ఎలా ఆ దగ్గరలో -
1e1, శాస్త్రీయ నోటేషన్.
ఇది 1 వంటి 1e1 గుర్తించింది * 10 ^ 1 లేదా ఎలాగైనా.
ఆ సమాన పూర్ణాంకాలుగా.
మేము === చేస్తే అప్పుడు అది తప్పు చేస్తాడు.
మేము నేను నిజంగా సంఖ్య ఆలోచన ఉంది == ఏ (10 మరియు '10abc ') గురించి;? అన్ని కుడి. కాబట్టి ఆ నిజం.
, మరియు ఇది 20 ఉంటుంది; కాబట్టి మీరు (10 + '10abc ') చేసుకుంది ఇష్టం
ఇక్కడ (10 == '10abc '); నిజం.
చెత్తగా వంటి వాటిని (తప్పుడు == NULL) ఉన్నాయి; నిజం
లేదా (తప్పుడు == 0); నిజం, (తప్పుడు == []);
యొక్క అసహజ కేసులు ఉన్నాయి - ఆ విచిత్రమైన కేసులు ఒకటి.
గమనించండి ఆ (తప్పుడు == []); నిజం.
('0 '== తప్పుడు); నిజం.
('0 '== []); FALSE.
కాబట్టి == సకర్మక ఏ విధంగా ఉంది.
a, b సమానంగా ఉంటుంది మరియు ఒక సి సమానంగా ఉంటుంది
కానీ బి సి సమానంగా కాదు.
ఆ నాకు ఒక అసహాయం, మరియు మీరు ఎల్లప్పుడూ === ఉపయోగించాలి.
[విద్యార్థి] మేము! == అదే? >> [బౌడెన్] అవును.
సమానం అవుతుంది! = మరియు! ==.
ఈ నిజానికి pset స్పెక్ లో పెంచబడ్డాడు
పేరు విధులు తిరిగి చాలా -
PHP మాన్యువల్ ఈ గురించి మంచి ఉంది.
ఇది "ఒక లోపం ఉంది ఈ తప్పుడు తిరిగి ఉంటుంది.", ఒక పెద్ద ఎర్ర బాక్స్ లో ఉంచుతుంది
కానీ తిరిగి 0 తిరిగి సంపూర్ణ సహేతుకమైన విషయం.
పూర్ణాంకం కోలుకుంటాడని ఉన్న ఏదైనా ఫంక్షన్ గురించి ఆలోచించండి.
లెట్ యొక్క ఈ ఫంక్షన్ ఒక ఫైల్ లేదా ఏదో లో పంక్తులు సంఖ్య లెక్కింపు కోరుకుంటున్నాము చెప్పారు.
సాధారణ పరిస్థితుల్లో, మీరు ఈ ఫంక్షన్ ఒక ఫైల్ పాస్
మరియు అది పంక్తుల సంఖ్య సూచించే పూర్ణాంకం తిరిగి వెళుతున్న.
ఫైలు కేవలం ఖాళీ ఉంటే కాబట్టి 0 సంపూర్ణ సహేతుకమైన సంఖ్య.
మీరు ఒక చెల్లని ఫైల్ పాస్ మరియు అయితే ఫంక్షన్ తప్పుడు తిరిగి ఏమి జరుగుతుందనే
మీరు ఒక చెల్లని ఫైల్ పాస్ ఉంటే?
మీరు ఇలా చేస్తే == మీరు చెల్లని ఫైల్ మరియు ఖాళీ ఫైల్ మధ్య కేసు విలక్షణమైన లేదు.
ఎల్లప్పుడూ === ఉపయోగించండి.
ఆ యొక్క అంతే.
>> PHP లో, అర్రే రకం మీరు C. లో ఉపయోగిస్తారు ఏమి భిన్నంగా ఉంటుంది
మీరు ఈ రకం శ్రేణి యొక్క అని భావించి నిజానికి, మీరు ఇప్పటికే ఈ పైన గమనించి ఉండవచ్చు.
బ్రాకెట్ సింటాక్స్ PHP యొక్క సరిక్రొత్త సంస్కరణకు ఇది PHP 5.4, యొక్క కొత్త ఉంది.
> 1, 'బి' - -> 2 ఈ ముందు మీరు ఎల్లప్పుడూ ('ఒక' శ్రేణి వ్రాయవలసి వచ్చేది.
ఆ వ్యూహం కోసం కన్స్ట్రక్టర్ ఉంది.
ఇప్పుడు PHP చివరకు, కేవలం చదరపు పరిధుల nice సింటాక్స్ సుమారు వచ్చింది
ఇది అర్రే కంటే చాలా బాగా ఉంది.
కానీ PHP 5.4 పరిగణలోకి, కొత్త వెర్షన్
మీరు కూడా PHP 5.3 లేని ప్రదేశాలలో ఎదుర్కొనవచ్చు.
PHP 5.3 మేము ఉపకరణంపై ఏ అక్కడ వేసవిలో మేము ఈ సమస్యను ఎదుర్కొంది
కానీ మేము మా గ్రేడ్ పుస్తకం అమలు మరియు submit మరియు అన్ని అంశాలను ఆ సర్వర్
PHP 5.4 ఉంది.
ఈ తెలియక, మేము 5.3 అభివృద్ధి, 5.4 ముందుకొచ్చింది
మరియు ఇప్పుడు మా కోడ్ అకస్మాత్తుగా none అన్ని పనిచేస్తుంది
5.3 మరియు 5.4 మధ్య మార్పులు కూడా చాలా తక్కువగా ఉంది కాబట్టి
వెనుకకు అనుకూలంగా లేని,
మరియు మేము వెళ్ళి PHP 5.4 కోసం పని చేయవని మా అన్ని విషయాలను పరిష్కరించడానికి ఉన్నాయి.
ఉపకరణం చేస్తుంది నుండి ఈ తరగతి, PHP 5.4 కలిగి
ఇది చదరపు బ్రాకెట్లలో ఉపయోగించడానికి సంపూర్ణ మంచిది.
కానీ మీరు ఇంటర్నెట్ లో విషయాలను అప్ మీకెప్పుడూ,
మీరు శ్రేణి stuff రకమైన అప్ మీకెప్పుడూ ఎక్కువగా మీరు చూడండి చూడాలని
PHP నుండి చుట్టూ అయిన తర్వాత శ్రేణి తయారీదారులు సింటాక్స్ అవుట్ స్పెల్ జన్మించాడు
మరియు చదరపు బ్రాకెట్ సింటాక్స్ గత రెండు నెలల్లో దాదాపు ఉంది
లేదా చేసినప్పుడు 5.4 చుట్టూ వచ్చింది.
ఈ విధంగా మీరు సూచిక.
జస్ట్ సి లో ఎన్ని మీరు $ శ్రేణి [0], $ శ్రేణి [1], $ శ్రేణి [2], వంటి చదరపు బ్రాకెట్లలో ద్వారా ఇండెక్స్ చేస్తాను
మీరు సూచిక మీ సూచీలు తీగలు ఉండటం కలిగి జరిగితే ఇదే విధంగా.
కాబట్టి $ శ్రేణి ['ఒక'] మరియు $ శ్రేణి ['బి'].
$ శ్రేణి [b]. ఎందుకు ఈ తప్పు అవుతుంది?
ఇది బహుశా ఒక హెచ్చరిక ఉత్పత్తి కానీ ఇంకా పనిచేస్తాయి. PHP అలా ఉంటుంది.
ఇది కేవలం, "నేను ఈ గురించి మిమ్మల్ని హెచ్చరిస్తుంది వెళుతున్న ఉంటుంది, కానీ నేను కొనసాగించడాన్ని వెళుతున్న
"మరియు నేను పనులను."
ఇది బహుశా, ఒక స్ట్రింగ్ ఈ అనువదిస్తుంది
కానీ గత ఎవరైనా ఏదో ఒక సమయంలో చెప్పారు అవకాశం ఉంది
'hello world' అని బి వివరిస్తాయి.
కాబట్టి ఇప్పుడు బి స్థిరమైన మరియు $ శ్రేణి ఉంటుంది [b] వాస్తవానికి 'హలో' చేస్తూ ఉంటుంది.
నేను, ఈ సమయంలో అనుకుంటున్నాను, లేదా కనీసం మా PHP సెట్టింగులు
మీరు ఒక అర్రే లోకి సూచిక ప్రయత్నించండి మరియు ఆ కీ లేకపోతే, అది విఫలమౌతుంది.
అది కేవలం మీరు హెచ్చరిస్తుంది భావించడం లేదు.
లేదా అది కేవలం మిమ్మల్ని హెచ్చరిస్తుంది చేయని విధంగా కనీసం మీరు సెట్ చేయవచ్చు, ఇది కేవలం సూటిగా విఫలమైతే.
>> మీరు నిజంగా అటువంటి ఒక ఇండెక్స్ ఉంటే చూడటానికి తనిఖీ మార్గం isset ఉంది.
కాబట్టి isset ($ శ్రేణి ['hello world']) తప్పుడు తిరిగి ఉంటుంది.
isset ($ శ్రేణి ['బి']) నిజమైన తిరిగి కనిపిస్తుంది.
మీరు ఈ వాక్య నిర్మాణములు కలపవచ్చు.
మేము దాన్ని పరీక్షించవచ్చు - ఏమి ఈ శ్రేణి మాదిరిగా ముగించారు చేస్తుంది అందంగా ఖచ్చితంగా అనుకుంటున్నాను.
ఓహ్, నేను PHPWord అవసరం.
ఈ మీరు కీ ఏమిటి పేర్కొనండి పేరు సింటాక్స్ కలవడం
మరియు మీరు కీ వివరిస్తాయి లేదు.
ఇక్కడ 3 హక్కు ఒక విలువ.
మీరు కాదు స్పష్టంగా దాని కీ మాత్రం ఏ చెప్పారు.
మీరు దాని కీ అన్నారు ఏమి ఆలోచిస్తాడు?
[విద్యార్థి] 0. >> నేను మేము పేర్కొన్న లేదు మొదటి ఒకటి మాత్రమే ఎందుకంటే 0 ఊహించడం చేస్తున్నాను.
మేము నిజంగా ఈ కేసులు రెండు చేయవచ్చు.
కాబట్టి print_r పునరావృత ప్రింట్ ఉంది. ఇది మొత్త ముద్రిస్తుంది.
ఏ అయితే శ్రేణి యొక్క subarrays ప్రింట్ చేస్తుంది.
కాబట్టి print_r ($ శ్రేణి); php.test.php.
ఇది 0 ఇచ్చారు కనిపించడం లేదు.
ఇక్కడ మీరు గుర్తుపెట్టుకోవలసిన ఏదో వాస్తవానికి, కానీ మేము రెండవ దానిని తిరిగి పొందుతారు.
కానీ నేను ఈ ఇండెక్స్ 1 తయారు జరిగితే?
PHP, స్ట్రింగ్ సూచీలు మరియు పూర్ణాంక సూచీలు మధ్య తేడా లేదు
ఈ సమయంలో నేను ఒక సూచిక 1 నిర్వచించిన మరియు నేను రెండు $ శ్రేణి [1] మరియు $ శ్రేణి ['1 '] చేయవచ్చు
మరియు అది అదే ఇండెక్స్ మరియు అదే కీ ఉంటుంది.
కాబట్టి ఇప్పుడు మీరు 3 ఉండబోతుంది ఏమి ఆలోచిస్తాడు? >> [విద్యార్థి] 2. >> [బౌడెన్] నేను 2 ఊహించడం చేస్తున్నాను.
అవును. ఇది 2 ఉంది.
మేము ఈ 10 చేస్తే, ఈ 4 ఏమిటి? మీరు 3 యొక్క సూచిక అని అన్నారు ఏమి ఆలోచిస్తాడు?
నేను 11 ఆలోచిస్తున్నాను.
PHP చేస్తుంది ఏమి నా అభిప్రాయం - నేను ముందు ఈ చూసిన ఆలోచన -
అది కేవలం అది ఇప్పటివరకు ఉపయోగిస్తారు ఎత్తైన సంఖ్యా సూచిక ఏమి ట్రాక్ చేస్తుంది.
ఇది 3 నుండి ఒక స్ట్రింగ్ సూచిక కేటాయించి వెళ్లి ఎప్పటికీ. ఇది ఎల్లప్పుడూ ఒక సంఖ్యా సూచిక ఉంటుంది.
అది 10 నిర్మాణము అది ఇప్పటివరకు కేటాయించిన ఎత్తైన ఒక, ట్రాక్
మరియు అది 3 నుంచి 11 ఇవ్వాలని జరగబోతోంది.
నేను ముందు మాట్లాడుతూ, ఈ శ్రేణి ప్రింటింగ్ విధానం గమనిస్తారు.
ఇది కీ 4, కీ 11, కీ d కీ 10 ముద్రిస్తుంది.
లేదా ఏమి లెట్స్ -
నేను ఒక 0 పెట్టలేదు అంచనా, కానీ ముద్రణ 1, 2, 3, 4.
నేను ఇక్కడ మారితే? లేదా యొక్క వాస్తవానికి ఈ 2 స్విచ్ అనుమతిస్తుంది.
ఇప్పుడు అది 2, 1, 3, 4 ముద్రిస్తుంది.
PHP యొక్క శ్రేణుల మీ సాధారణ హాష్ పట్టిక వంటి కాదు.
ఇది హాష్ పట్టికలు సమయం 99% వాటిలో ఆలోచించడం ఖచ్చితంగా తగిన ఉంది.
కానీ మీ హాష్ పట్టికలలో విషయాలు చేర్చబడ్డ క్రమంలో సంఖ్య అర్ధంలో ఉంది.
కాబట్టి మీరు, మీ హాష్ పట్టిక ఇన్సర్ట్ వెంటనే
అక్కడ ఏ లింక్ జాబితా మరియు మీరు ఒక లింక్ జాబితా లోపల నిర్ణయం కాలేదు ఊహించుకోవటం
ఇది మొదటి చేర్చడం జరిగింది.
కానీ ఇక్కడ మేము మొదటి 2 చేర్చబడ్డ మరియు 2 మొదటి వచ్చే ఈ శ్రేణి ముద్రించిన యొక్క అది తెలుసు.
ఇది ఏదైనా క్రమంలో దాన్ని ప్రింట్ లేదు.
అది ఉపయోగించి చేసే సాంకేతిక డేటా నిర్మాణం ఒక ఆర్డర్ మాన చిత్రం, ఉంది
కాబట్టి ఇది విలువలకు కీలు పటాలను మరియు ఇది ఆ కీలు చేర్చబడ్డ క్రమంలో గుర్తు.
నిజానికి ఇది నిజానికి కు బాధించే ఎక్కడ కొన్ని ఇబ్బందుల ఉంది -
మీరు ఒక అర్రే 0, 1, 2, 3, 4, 5 ఉన్నాయి, అవి
మరియు మీరు సూచిక 2 చేద్దామని అనుకుంటున్నారా.
ఇది ఇలాగ చేయడానికి ఒక పద్దతి, ఆ ఎలా చూద్దాం.
0, 2, 1, 3, 4.
అన్సెట్ వేరియబుల్స్ మరియు యెరే సూచీలు రెండు అన్ సెట్ నిర్మాణము.
కాబట్టి సెట్ ($ శ్రేణి [2]);
ఇప్పుడు ఈ లాగా జరగబోతోంది? 2 కేవలం పోయింది, కాబట్టి ఖచ్చితంగా మంచిది.
మీరు విషయాలు నిజానికి ఒక అర్రే వంటి కోరుకుంటే మరిన్ని బాధించే ఉంది.
నేను నియమరహిత సంఖ్యలు ఉంచుతాము.
ఇప్పుడు నా సూచీలు గమనిస్తారు.
1 - నేను 0 నుండి పొడవు వెళతాడు, అక్కడ అది కేవలం సి శ్రేణి వంటి ఉండాలనుకుంటున్నాను
మరియు నేను దానిని పైగా iterate చేయవచ్చు.
కానీ వెంటనే నేను ఇండెక్స్ 3 లో ఏమి రెండవ సూచిక, అన్ సెట్ వంటి ఇప్పుడు ఇండెక్స్ 2 కాదు.
దానికి ఆ సూచిక తొలగిస్తుంది మరియు ఇప్పుడు మీరు 0, 1, 3, 4 వెళ్ళండి.
ఈ ఖచ్చితంగా మంచిది.
ఇది కేవలం బాధించే మరియు మీరు శ్రేణి స్ప్లైస్ వంటి వాటిని చేయాలి. అవును.
>> [విద్యార్థి] మీరు లూప్ ఒక కలిగి ఏమి జరుగుతుంది
మరియు మీరు అన్ని అంశాలను వెళ్ళి భావించారా?
ఇది 2 కొట్టాడు, ఇది పొందవచ్చు?
వ్యూహం మీద Iterating. మీరు దీన్ని చెయ్యవచ్చు 2 మార్గాలు ఉన్నాయి.
మీరు లూప్ ఒక సాధారణ ఉపయోగించవచ్చు.
ఈ PHP యొక్క మరొక క్లిష్టత ఉంది.
చాలా భాషలు, నేను, పొడవు లేదా లెన్ లేదా ఏదో విధమైన కలిగి
వ్యూహం యొక్క పొడవు ఉంది.
PHP లో కౌంట్.
అందువల్ల లెక్కింపు ($ శ్రేణి); $ i + +)
లెట్ యొక్క కేవలం ముద్రణ ($ శ్రేణి [$ i]);
గమనిక: వివరించలేని ఆఫ్సెట్: 2.
ఇది కేవలం విఫలం చెప్పారు.
ఈ అధిక భాగం, మీరు ఈ వ్యూహం పై iterate అవసరం ఉండదు, కారణం.
ఇది ఒక అతిశయోక్తి కావచ్చు, కానీ మీరు ఈ వ్యూహం పై iterate అవసరం లేదు
PHP పేరు foreach ($ వ్యూహం $ అంశం) దాని foreach సింటాక్స్ అందిస్తుంది ఎందుకంటే.
ఇప్పుడు మేము ($ అంశం) ప్రింట్ ఉంటే; - we'll రెండవ లో చర్చించిన - సంపూర్ణ జరిమానా పనిచేస్తుంది.
foreach పనిచేస్తుందని విధంగా మొదటి వాదన మీద iterating చేస్తున్న శ్రేణి ఉంది.
మరియు లూప్ యొక్క ప్రతి పాస్ రెండవ వాదన, అంశం,
అది యెరే నందలి తదుపరి విషయాన్ని తీసుకుని వెళుతున్న. కాబట్టి శ్రేణి ఒక క్రమాన్ని కలిగివున్నాయి గుర్తుంచుకోవాలి.
లూప్ ద్వారా మొదటిసారి, అంశం 123 అవతరిస్తుంది
అప్పుడు 12 ఉంటుంది అప్పుడు 13 ఉంటుంది అప్పుడు 23 ఉంటుంది అప్పుడు 213 ఉంటుంది.
మీరు foreach వంటి ఏదో చేసినప్పుడు వస్తువులు నిజంగా అసాధారణ పొందండి.
మీరు దీన్ని ఎప్పుడూ ఎందుకంటే ఏమి చూద్దాం.
ఏం మేము సెట్ ($ శ్రేణి [1]);
ఆ బహుశా భావించారు.
మీరు ఈ శ్రేణి మీద iterating చేస్తున్నాము, ప్రతి మీరు మొదటి ఇండెక్స్ unsetting చేస్తున్నారు.
కాబట్టి సూచిక 0 కోసం, మొదటి విషయం, వస్తువు విలువ 0 తీసుకుంటుంది, కాబట్టి ఇది 123 చేస్తాడు.
కానీ లోపల యొక్క లూప్ మేము సెట్ సూచిక 1, తద్వారా 12 వెళ్లిపోయిన అర్థం.
కాబట్టి ప్రింట్. PHP_EOL.
PHP_EOL కేవలం NEWLINE, కాని ఇది సాంకేతికంగా చాలా చిన్నవిగా ఉంది
Windows లో న్యూ లైన్ Mac మరియు UNIX లో న్యూ లైన్ భిన్నంగా ఉంటుంది.
Windows న NEWLINE \ r \ n, ప్రతిచోటా else అయితే అది కేవలం \ n ఉంటుంది ఉంది.
మీ సిస్టమ్ యొక్క NEWLINE ఉండే వస్తువు ఉపయోగిస్తుంది కాబట్టి PHP_EOL కన్ఫిగర్.
కాబట్టి ఆ ప్రింట్. చివరిలో ($ శ్రేణి) print_r కాదు లెట్.
నేను ఆ ప్రవర్తన అని తెలియదు.
మనం శ్రేణి నుండి పొందిన ముందు మేము 12 అన్ సెట్ కూడా Item ఇప్పటికీ విలువ 12 న జరుగుతుంది.
ఈ నా పదం తీసుకుంటారు కానీ foreach శ్రేణి యొక్క ఒక నకలును కనిపిస్తుంది లేదు
తరువాత అంశం ఆ కాపీని అన్ని విలువలు తీసుకుంటుంది.
మీరు లూప్ లోపల శ్రేణి, సవరించండి కాబట్టి కూడా
అది శ్రద్ధ లేదు. Item అసలు విలువల పడుతుంది.
ఇది unsetting ప్రయత్నించండి లెట్.
ఈ $ శ్రేణి [1] ఉంటే = "హలో";
మేము శ్రేణి లోకి "హలో" ఇచ్చాడు ఉన్నప్పటికీ, అంశం ఆ విలువ తీసుకుంటుంది ఎప్పుడూ.
ఉచ్చులు foreach మరొక సింటాక్స్ ఉన్నాయి
మీరు ఒక బాణం వేరు 2 వేరియబుల్స్ ఉంచండి.
ఈ మొదటి వేరియబుల్, ఆ విలువ యొక్క కీ అన్నారు
మరియు ఈ రెండవ వేరియబుల్ అదే ఖచ్చితమైన అంశాన్ని అని అన్నారు.
,> 1 - ఈ ఇక్కడ రసహీనమైన, కాని మేము 'ఒక' మా యదార్థ తిరిగి వెళ్ళడానికి ఉంటుంది
'బి' -> 1,
మేము కేవలం అంశం ప్రతి శ్రేణి కోసం iterate ఉంటే ఇక్కడ, అంశం ప్రతి సమయం 1 అని అన్నారు.
కానీ మేము ఆ అంశానికి సంబంధించిన కీ తెలుసుకోవాలనుకుంటే
> $ అంశం - అప్పుడు మేము వంటి $ కీ చేయండి.
. ':' కాబట్టి ఇప్పుడు మేము ప్రింట్ ($ కీ చేయవచ్చు.
ఇప్పుడు దాని పై iterating మరియు ప్రతి కీ మరియు దాని అనుబంధిత విలువ ప్రింటింగ్ అన్నారు.
>> మేము foreach పాశ్యాలలో చేయవచ్చు ఒక అదనపు విషయం మీరు ఈ వాక్యనిర్మాణం చూడవచ్చు.
వేరియబుల్ పేర్లు ముందు Ampersands PHP సూచనలు ఎలా ఉంటాయి.
సూచనలు గమనికలు పోలి ఉంటాయి, ఎక్కడ
మీరు గమనికలు లేదు, కాబట్టి మీరు నేరుగా మెమరీ వ్యవహరించే ఎప్పుడూ.
కానీ మీరు 1 వేరియబుల్ మరొక వేరియబుల్ అదే విషయం సూచిస్తుంది పేరు సూచనలు ఉన్నాయి.
ఇక్కడ లోపలి అంశం $ చేయండి చూద్దాం. యొక్క 1, 10 తిరిగి వెళ్ళి తెలపండి.
అంశం $ తెలియజేసేలా యొక్క + +; ఆ ఇప్పటికీ PHP లో ఉంది. మీరు ఇప్పటికీ + + చేయవచ్చు.
php.test.php. నేను ప్రింట్ ఉంటుంది. print_r ($ శ్రేణి);
మేము 2, 11 ప్రింట్.
(అంశం $ $ వంటి శ్రేణి) నేను foreach చేసిన అప్పుడు అంశం విలువ 1 ఉంటుంది
లూప్ ద్వారా మొదటిసారి. ఇది 2 నుండి 1 పెంచడం మరియు అప్పుడు మేము పూర్తి చేసిన.
కాబట్టి అప్పుడు లూప్ యొక్క రెండవ పాస్ వెళ్తుంది మరియు ఆ అంశం 10 ఉంది.
ఇది ఇంక్రిమెంట్ 11 అంశం, మరియు అప్పుడు దూరంగా విసిరిన చేస్తుంది.
అప్పుడు మేము print_r ($ శ్రేణి); మరియు లెట్స్ ఈ, 10 కేవలం 1 ఉందని.
కాబట్టి మేము పెంపు పోయింది.
కానీ foreach ($ వ్యూహం & $ అంశం)
ఇప్పుడు ఈ అంశం ఇక్కడ ఈ కుడి అదే అంశం. ఇది అదే విషయం.
కాబట్టి $ అంశం + + శ్రేణి 0 సవరించుట ఉంది.
సాధారణంగా, మీరు కూడా $ k చేయవచ్చు -> $ అంశం మరియు మీరు $ చేయవచ్చు శ్రేణి [$ k] + +;
>> ఆ చేయడం వలన మరొక మార్గం కాబట్టి, మేము, ఐటెమ్ను సవరించేందుకు ఉచితం
కానీ మా అసలు శ్రేణి సవరించదు.
మేము మా కీ ఇది k, ఉపయోగించడానికి అయితే, అప్పుడు మా శ్రేణి లోకి కేవలం ఇండెక్స్ ఆ కీని ఉపయోగించి మేము
మరియు ఆ పెంచడం.
ఈ మరింత నేరుగా మా అసలు శ్రేణి సవరిస్తుంది.
కారణం చేత మీరు సవరించడానికి సామర్థ్యం కోరుకుంటే మీరు కూడా ఆ చేయవచ్చు -
నిజానికి, ఈ ఖచ్చితంగా మంచిది.
మీరు శ్రేణి $ రాయడానికి కావాలి లేదు [$ k] + +,
మీరు + అంశం $ రాయడానికి కోరుకున్నారు + కానీ మీరు ఇంకా చెప్పడానికి కోరుకుంటే ($ k === 'ఒక')
అప్పుడు అంశం పెంచడం మరియు అప్పుడు మా శ్రేణి ప్రింట్.
కాబట్టి ఇప్పుడు మేము print_r ఏమి అనుకుంటున్నావా? ఏ విలువలు ముద్రించిన చేయాలి?
[విద్యార్థి] 2 మరియు 10. >> కీ ఉంటే [బౌడెన్] మాత్రమే ఒక 'మేము నిజంగా ఆ ప్రింట్ చెయ్యాలి.
>> బహుశా మీరు చాలా అరుదుగా, ఉంటే ఎప్పుడైనా, PHP లో విధులు నిర్వచించడానికి అవసరం
మీరు ఏ ఫంక్షన్ వంటి ఫంక్షన్ నిర్వచించే పేరు కాని మీరు ఇలాంటి ఏదో చూడవచ్చు.
సాధారణంగా మీరు చెప్పే (foo $ $ బార్) మరియు తర్వాత మరేమిటి దానిని చెప్పబడతాయి.
నేను దీన్ని అయితే, ఆ, ఏ ఏ కాల్స్ అర్థం
బాజ్ కాల్స్ ఏ, మార్చవచ్చు మొదటి వాదన బాజ్ వశమైంది కనుక.
$ Foo తెలియజేసేలా యొక్క + +;
మరియు లోపల ఇక్కడ యొక్క బాజ్ ($ అంశం) ఏమి లెట్స్;
ఇప్పుడు మేము ఒక చర్యను కాల్ చేస్తారు.
వాదన సూచన తీసుకుంటారు, అంటే ఆ మేము అది సవరించడానికి ఉంటే
మేము సైన్ ఆమోదించింది ఆ విషయం సవరించుట చేస్తున్నారు
మరియు మేము భావిస్తున్నాము ఈ ప్రింటింగ్ - నేను సింటాక్స్ గందరగోళంలో తప్ప - మేము, 2, 11 వచ్చింది
కాబట్టి ఇది నిజానికి పెరిగినప్పటికీ.
మేము 2 ప్రదేశాలలో సూచనలు అవసరం నోటీసు.
నేను ఈ చేస్తే? దీని అర్థం ఏమిటి?
[విద్యార్థి] మారుతుంది. >> అవును.
Item కేవలం శ్రేణి విలువ యొక్క కాపీ.
కాబట్టి అంశం 2 మారుతుంది, కానీ శ్రేణి ['ఒక'] ఇంకా 1 ఉంటుంది.
లేదా నేను ఇలా చేస్తే?
ఇప్పుడు అంశం బాజ్ ఒక కాపీని వంటి పంపబడుతుంది.
కాబట్టి వాదన యొక్క కాపీని, 2 పెరిగిన ఉంటుంది
కానీ అంశమునందు 2 పెరిగిన కాలేదు.
మరియు అంశం, అర్రే బ్రాకెట్ ఏ అదే విషయం
కాబట్టి శ్రేణి పెరిగిన కాలేదు.
కాబట్టి ఆ ప్రదేశాలలో రెండు ఇది అవసరం.
>> PHP సాధారణంగా ఈ గురించి చాలా స్మార్ట్ ఉంది.
మీరు నేను సూచనగా పాస్ మీరు భావిస్తే ఉండవచ్చు -
ఈ నిజానికి psets ఒక దానిలో ప్రశ్న.
ఇది చెప్పబడిన ఒక questions.txt విషయం
ఎందుకు మీరు సూచనగా ఈ struct పాస్ అనుకోవచ్చు?
ఆ సమాధానం ఏమిటి?
[విద్యార్థి] మీరు పెద్ద ఏదో కాపీ లేదు కాబట్టి. >> అవును.
ఒక struct ఏకపక్ష పెద్ద కావచ్చు, మరియు మీరు ఒక వాదన గా struct పాస్ చేసినప్పుడు
ఇది ఫంక్షన్ కి పాస్ ఆ మొత్తం struct కాపీ అవసరం
మీరు సూచనగా struct పాస్ ఉంటే అయితే
అప్పుడు అది కు వాదన ఒక 4-బైట్ చిరునామా కాపీ అవసరం.
PHP తెలివిగా కంటే కొద్దిగా ఉంది.
నేను కొన్ని చర్య మరియు నేను దానిని 1,000 విషయాలు యొక్క వ్యూహం పాస్ ఉంటే,
అది ఆ విషయాలు అన్ని 1,000 కాపీ కలిగి జరగబోతోంది అర్థం లేదు
ఫంక్షన్ లో పాస్? ఇది వెంటనే అలా లేదు.
ఈ చర్యను లోపల నిజానికి foo మార్పు, ఎప్పుడూ ఉంటే
కాబట్టి నిజమైన తిరిగి ($ foo === 'హలో') ఉంటే.
మేము నిజంగా ఈ చర్యను వాదన లోపల చివరి మార్పు ఎప్పుడూ గమనించండి,
ఇది foo కాపీ అవసరం ఎప్పుడూ వంటి ఏ లో జారీ చేశారు అర్థం
ఇది సవరించుట కాదు.
కాబట్టి PHP రచనలు వాదనలు ఎలా ఉందో ఎల్లప్పుడూ సూచనగా జారీ
మీరు దీన్ని సవరించడానికి ప్రయత్నించండి వరకు.
నేను $ foo + + చెప్పుకోవాలంటే ఇప్పుడు, అది ఇప్పుడు అసలు foo ఒక కాపీని మరియు కాపీ సవరించడానికి కనిపిస్తుంది.
ఇది కొంత సమయం ఆదా చేస్తుంది.
మీరు ఈ భారీ శ్రేణి తాకడం ఎప్పుడూ, మీరు నిజంగా, ఇది సవరించడానికి ఎప్పుడూ
ఇది కాపీని అవసరం లేదు
మేము దానిని కూడా కాపీ లేదు అంటే ఈ ఆంపర్సండ్ చిహ్నం ఉంచితే అయితే
మీరు సవరించడానికి లేనప్పటికీ.
ఈ ప్రవర్తన నకలు వ్రాయడం అని పిలుస్తారు.
మీరు ఒక ఆపరేటింగ్ సిస్టమ్ కోర్సు పడుతుంది, ముఖ్యంగా ఇతర ప్రదేశాలలో దీనిని చూస్తారు.
నకలు వ్రాసే మీరు ఏదో ఒక కాపీని లేదు పేరు ఒక అందమైన సాధారణ క్రమం
నిజానికి మారుతున్న యొక్క తప్ప. అవును.
మీరు, పరీక్ష లోపల పెంపు కలిగి [విద్యార్థి] ఏం
కాబట్టి 1,000 నుండి మాత్రమే 1 మూలకం మార్చడానికి అవసరం?
నాకు ఖచ్చితంగా తెలియదు.
నేను మొత్తం విషయం కాపీ అనుకుంటున్నాను, కానీ అది తగినంత సమార్ట్స్ అవకాశం -
అసలైన, నేను ఆలోచిస్తున్నాను మేము ఈ కనిపించే వ్యూహం కలిగి ఊహించుకోండి ఉంది: $ array2 = [
అప్పుడు ఇండెక్స్ 'ఒక' [1 2 3 4], మరియు ఇండెక్స్ 'బి' యొక్క వ్యూహం ఉండే వస్తువు యొక్క ఒక శ్రేణి.
నేను ఆ అన్ని మధ్య కామాలతో అవసరం. కామాలతో ఉన్నాయి ఆలోచించండి.
అప్పుడు 'సి' విలువ 3.
సరే.
ఇప్పుడు లెట్స్ మేము $ బాజ్ ($ array2) చెప్పే;
పేరు బాజ్ సూచనగా ఈ తీసుకోదు.
కాబట్టి $ foo ['సి'] + +;
ఈ మేము ఒక వాదన వంటి array2 ప్రయాణిస్తున్న ఇక్కడ అటువంటి ఒక ఉదాహరణ
మరియు తర్వాత ఇది పెంచడం ద్వారా శ్రేణిని ఒక నిర్దిష్ట సూచిక సవరించుట ఉంది.
నిజాయితీగా PHP చేయబోవడం ఏమి సంఖ్య ఆలోచన ఉంది.
, ఇది సులభంగా మొత్తం విషయం యొక్క ఒక కాపీని చేయవచ్చు, కానీ స్మార్ట్ అయితే
ఈ తన విభిన్న విలువ ఉంటుంది పేరు ఈ కీలను రూపొందిస్తుంది
కానీ ఈ ఇప్పటికీ అదే శ్రేణి 1,2,3,4 విలువులకు లను సూచిస్తుంది
మరియు ఇది ఇప్పటికీ అదే శ్రేణి సూచిస్తుంది.
నేను ఐప్యాడ్ అది చేస్తాము.
మేము, [1,2,3,4 విలువులకు] కు, పేరు ఈ గై పాయింట్లు 3 ఈ శ్రేణి లో ఈ గై పాయింట్లు పాస్
ఈ గై పాయింట్లు [34, ...]
ఇప్పుడు మేము బాజ్ కు ఇది ప్రయాణిస్తున్న చేస్తున్న, మేము ఈ సవరించుట ఉంటాయి.
PHP స్మార్ట్ ఉంటే, అది కేవలం చేయవచ్చు -
మేము ఇంకా కొన్ని మెమరీ కాపీ వచ్చింది, కానీ ఈ భారీ సమూహ subarrays ఉన్నట్లయితే
మేము ఆ కాపీ అవసరం లేదు.
అది ఏమి చేస్తుంది అని నాకు తెలియదు, కానీ నేను ఆ చేయడం ఊహించవచ్చు.
ఈ కూడా PHP పైగా సి ఒక అందమైన పెద్ద ప్రయోజనం ఉండదు.
>> PHP జీవితం సులభం విషయాలు చాలా కోసం, చేస్తుంది
కానీ మీరు రకమైన ప్రదర్శించటానికి ఎలా బాగా ఖచ్చితంగా సంఖ్య ఆలోచన ఉంది
అది విషయాలను ఈ కాపీలు విషయములపై నేను హుడ్ కింద సంఖ్య ఆలోచన ఉంది ఎందుకంటే,
OH, ఒక స్థిరమైన సమయం కాపీ అని అన్నారు,
ఇది కేవలం 1 పాయింటర్ మార్చడానికి అంటే, అది ఒక హాస్యాస్పదమైన కష్టం సరళ కాపీ అని అన్నారు?
అది ఖాళీ దొరకదు ఏమి?
అది కొంత స్థలం పొందడానికి చెత్త సేకరణ అమలు మార్చాలి?
మరియు చెత్త సేకరణ ఏకపక్ష పొడవైన పడుతుంది.
సి మీరు ఈ విషయాల గురించి ఆందోళన లేదు.
మీరు వ్రాసే ప్రతి ఒక్క లైన్ ప్రదర్శించటానికి వెళుతున్న ఎలా చాలా చక్కని కారణం చెయ్యవచ్చు.
>> యొక్క ఈ తిరిగి చూద్దాం.
ఇది మీరు హాష్ విధులు నిర్వహించటానికి లేని ఎలా నైస్ ఉంది
లింక్ జాబితాలు, లేదా అలాంటిదే ఏదైనా?
హాష్ పట్టికలు పని ఇప్పుడు అంత సులభం కనుక, ఇక్కడ పని ఒక ఆహ్లాదకరమైన పజిల్ ఉంది.
Unique.php మరియు అది గా పిలువబడే ఒక ఫైల్ తెరిచి ఒక PHP ప్రోగ్రామ్ను రాయడం
(ఒక "స్క్రిప్ట్" గా పిలుస్తారు).
వారు మీరు కమాండ్ లైన్ వద్ద పనిచేసే చిన్న విషయాలు అయితే మేము వాటిని స్క్రిప్ట్ కాల్ ఉంటాయి.
సాధారణంగా, మీరు కంపైల్ లేదు కానీ మీరు ఎగ్జిక్యూటబుల్ను అమలు చూడాలని ఏ భాష
కమాండ్ లైన్ వద్ద, మీరు ఆ executable స్క్రిప్ట్ కాల్ చేయవచ్చు.
నేను అలాగే, ఈ పని చేసే ఒక సి కార్యక్రమం రాస్తుంది
నేను మొదట కంపైల్ మరియు అప్పుడు బైనరీ అమలు నుండి కాని దాన్ని స్క్రిప్ట్ కాల్ లేదు.
కానీ ఈ PHP కార్యక్రమం మేము స్క్రిప్ట్ కాల్ చూడాలని.
లేదా మేము Python లేదా Perl లేదా Node.js లేదా ఆ విషయాలు ఏ లో రాశారు ఉంటే,
మీరు కమాండ్ లైన్ వద్ద వాటిని అమలు ఎందుకంటే మేము వాటిని అన్ని స్క్రిప్ట్ కాల్ భావిస్తున్న
కానీ మేము వాటిని కంపైల్ లేదు.
మేము చాలా త్వరగా ఈ పని చేయడు.
మేము argv ఉపయోగించడానికి వెళ్ళడం లేదు. ఈ ద్వారా చెదరగొట్టి కేవలం యొక్క లెట్.
ఇది ఏకైక కాల్, ఒక ప్రోగ్రామ్ను రాయడం.
మీరు ఇన్పుట్ లైన్ కు ఒక పదం కలిగిన పొందవచ్చు.
అసలైన, argv ఉపయోగించడానికి చాలా చిన్నవిషయం ఉంటుంది.
unique.php.
మొదటి విషయం మొదటి, మేము 1 ఆదేశ పంక్తి వాదన జారీ వుంటేనే తనిఖీ మీరు.
మీరు C లో argc మరియు argv ఊహించిన దాని వలె, మేము ఇప్పటికీ PHP లో ఆ ఉంటాయి.
కాబట్టి నేను ఒక సందేశం లేదా ఏదైనా ప్రింటింగ్ వ్యవహరించే లేదు ($ argc! == 2) ఉంటే.
నేను, 1 లోపం కోడ్ నిష్క్రమించడానికి చేస్తాము.
నేను కూడా 1 తిరిగి కాలేదు.
మేము ఉన్నాము పేరు అరుదుగా PHP లో మీరు ఈ రాష్ట్రం ఉన్నాయి -
సాధారణంగా మీరు ఒక చర్య ద్వారా అనే చర్య ద్వారా అనే చర్య ద్వారా అనే ఫంక్షన్ లో ఉన్నాము.
మరియు ఏదో తప్పు జరిగితే, మీరు పూర్తిగా ప్రతిదీ నిష్క్రమించాలి అని మీరు అనుకుంటే,
నిష్క్రమణ కేవలం కార్యక్రమం ముగుస్తుంది.
ఈ కూడా C. ఉంది
మీరు ఒక ఫంక్షన్ లో ఒక ఫంక్షన్ లో ఒక ఫంక్షన్ లో ఒక ఫంక్షన్ లో అయితే
మరియు మీరు ప్రోగ్రామ్ చంపడానికి కావాలి, మీరు నిష్క్రమణ కాల్ మరియు ఇది కేవలం నిష్క్రమిస్తుంది.
కానీ PHP లో మేము ఈ ఉన్నత స్థాయిలో ఉన్నాయి మరింత అరుదైన ఉంది.
సాధారణంగా మనం ఫంక్షన్ విధమైన లోపల, కాబట్టి మేము నిష్క్రమణ కాల్
మేము అప్పుడు తెలుసుకుంటాడు ఇది 1 విషయం అప్ తిరిగి లేదు కాబట్టి ఒక లోపం ఉంది
ఒక లోపం ఉంది గుర్తించినట్లయితే, తద్వారా అప్ తిరిగి.
మేము (1) నిష్క్రమించడానికి, ఆ వ్యవహరించే అనుకుంటున్న;
తిరిగి (1); ఈ సందర్భంలో సమానం అవుతుంది.
>> అప్పుడు మేము తెరవడానికి ఏమి మేము fopen మీరు.
వాదనలు చాలా ఒకేలా ఇస్తున్నాయి.
మేము fopen ($ argv [1], మరియు మేము చదవడానికి దాన్ని తెరవడానికి మీరు. మీరు
అంటే F కాల్ చూడాలని ఒక వనరు తిరిగి.
మా ఫైల్లో * చెప్పడానికి లేదు తప్ప సి అది ఎలా అందంగా పోలి ఉంది.
బదులుగా మేము కేవలం $ f చెప్పారు. సరే.
అసలైన, నేను ఈ కూడా మాకు ఫైల్ అని PHP ఫంక్షన్ మనకు ఇస్తుంది అనుకుంటున్నాను. PHP ఫైలు.
ఈ విధంగా అన్నారు వ్యూహం ఒక మొత్తం చదవడం ఉంది.
మీరు కూడా fopen అది అవసరం లేదు. మీరు కోసం అలా చెప్పారు.
కాబట్టి $ పంక్తులు = ఫైల్ ($ argv [1]);
ఇప్పుడు ఫైల్ రేఖల అన్ని మార్గాలను ఉన్నాయి. ఇప్పుడు మేము పంక్తులు క్రమం మీరు.
మేము ఎలా పంక్తులు క్రమం చేయవచ్చు?
మేము పంక్తులు క్రమం.
ఇప్పుడు మేము వాటిని లేదా ఎలాగైనా ముద్రించవచ్చు.
బహుశా సులభమైన మార్గం foreach ($ లైన్ $ వంటి పంక్తులు) లైన్ $ ప్రతిధ్వని ఉంది;
[విద్యార్థి] మేము కూడా విధమైన లోకి ఏదో సూచిస్తూ ద్వారా హద్దులను లేదు?
విధమైన చర్య విధమైన (& $ శ్రేణి) గా పేర్కొంటారు ఇది ఉంది.
మీరు ఫంక్షన్ కాల్ మీరు సూచనగా ఇది అనుమతించబడవు.
ఇది సూచనగా అది తీసుకొని దానిని నిర్వచిస్తుంది ఫంక్షన్ ఉంది.
ఈ వాట్ వెంట్ రాంగ్ సరిగ్గా వాస్తవానికి
మేము 5.3 నుండి 5.4 వెళ్లినప్పుడు మా సర్వర్లకు ప్రతిదీ ఉంచండి ఉన్నప్పుడు.
5.4 వరకు ఈ ఖచ్చితంగా తగిన ఉంది.
ఒక ఫంక్షన్ సూచన భావించారు అంచనా లేదు, కానీ మీరు సూచనగా ఇది తరలిస్తారు
ఫంక్షన్ సవరించడానికి ఏర్పడుతుందా అయితే, ఇది చివరి మార్పు మాత్రమే.
5.4 నాటికి, మీరు దీన్ని కాబట్టి.
ఫంక్షన్ స్పష్టంగా అది చేస్తే ఇప్పుడు మీరు సూచనగా పాస్ మాత్రమే మార్గం.
మీరు ఇది సవరించాలని అనుకుంటున్నారా లేదు, అప్పుడు మీరు $ కాపీ = $ లైన్లు మరియు పాస్ కాపీ చేయాలి.
కాబట్టి ఇప్పుడు పంక్తులు మటుకు అలాగే ఉంచబడతాయి మరియు కాపీ మార్చబడతాయి.
php.unique.php. నేను ఏదో గందరగోళంలో ఉండవచ్చు.
ఊహించని 'క్రమీకరించు'.
మాకు ఈ పని చేసే ఏదో ఉన్నట్లు జరగబోతోంది.
ఇది కూడా అక్కడ కాదు.
మీరు మొదటి వాదన ఒక అర్రే అయి ఉంటుందని భావించే మాన్యువల్ చదివినపుడు గమనించండి
మరియు అది సూచనగా తీసుకువెళ్లారు.
ఎందుకు ఈ నాకు ఫిర్యాదు ఉంది? నేను అనుకుంటున్న ఇక్కడ ఇప్పటికీ ఈ ఫంక్షన్ విధమైన కలిగి ఉన్నారు.
సరే, php.unique.php. నేను ఒక ఫైల్ లేదు ఎందుకంటే నేను ఒక వాదన పాస్ లేదు.
ఇది test.php న php.unique.php ఉంది.
ఇక్కడ అన్ని ఒక నైస్ క్రమబద్ధీకరించబడతాయి క్రమంలో ముద్రించిన test.php ఉంది.
క్రమబద్ధీకరించబడింది ఆర్డర్ కోడ్ ఫైల్ రకం అసాధారణ యొక్క అని గమనించండి
మా ఖాళీ పంక్తుల అన్ని మొదటి వచ్చిన వెళ్తున్నారు ఎందుకంటే
అప్పుడు మా 1 స్థాయి indentations అన్ని వచ్చి వెళ్తున్నారు
అప్పుడు మా ఏ indentations అన్ని వస్తాయి.
అవును. >> [విద్యార్థి] కాబట్టి సోర్స్ కోడ్ కోసం సూచన ఆమోదించిన లేదు?
ఆ సాధారణంగా విలువ ద్వారా ముగిసింది?
[బౌడెన్] మీరు ఒక ఫంక్షన్ కాల్, ఇది సూచన ఆమోదించిన లేదో నిర్ణయిస్తుంది ఎప్పుడూ.
ఇది సూచన ఆమోదించిన లేదో నిర్ణయిస్తుంది ఫంక్షన్ నిర్వచనం ఉంది.
మరియు విధమైన చర్య నిర్వచనం చూడటం లేదా ఈ చూడటం,
ఇది సూచనగా వాదన పడుతుంది.
కాబట్టి సంబంధం లేకుండా మీరు సూచనగా తీసుకోబడుతుంది లేదో యొక్క, అది సూచనగా భావించారు.
ఇది స్థానంలో శ్రేణి సవరిస్తుంది.
ఇది అనుమతించబడదు. మీరు దీన్ని చెయ్యడానికి మీకు అనుమతి లేదు. >> [విద్యార్థి] ఓహ్, ఓకే.
[బౌడెన్] ఈ, క్రమీకరించు సూచనగా పంక్తులు తీసుకుని దానికి సవరించడానికి అన్నారు.
మీరు ఆ చేయాలనుకుంటున్నారా లేదు ఉంటే మళ్ళీ, మీరు విధమైన కాపీని చేస్తాయి.
కూడా ఈ విషయంలో, కాపీ వాస్తవానికి పంక్తులు కాపీని కాదు.
అది మొదటి చివరి మార్పు పొందేంత వరకు అది అదే పని పాయింతు
ఇక్కడ మొదటి, క్రమీకరించు ఫంక్షన్ లో చివరి మార్పు పరుచుట కొరకు
పేరు, ఎందుకంటే అది యొక్క నకలు వ్రాయటానికి, ఇప్పుడు కాపీ కాపీని తయారు అన్నారు.
మీరు కూడా చేయవచ్చు. మీరు ఆంపర్సండ్ చిహ్నం చూడగలరు ఇతర స్థలం పేర్కొంది.
మీరు foreach ఉచ్చులు లో చూడండి, మీరు, ఫంక్షన్ ప్రకటనలలో ఇది చూడండి
కేవలం వేరియబుల్స్ కేటాయించి ఉన్నప్పుడు మరియు మీరు చూడండి.
ఇప్పుడు మేము ఈ చేయడం ద్వారా ఏమీ సాధించవచ్చు చేశారు
కాపీ మరియు పంక్తులు అక్షరాలా ఇదే ఎందుకంటే.
మీరు పంక్తులు ఉపయోగించడానికి మరియు పరస్పరం కాపీ చేయవచ్చు.
, మరియు ఆ సెట్ పంక్తులు లేదు; మీరు సెట్ చేయకుండా ($ కాపీ) చేయవచ్చు
మీరు ఇదే మీ సూచన కోల్పోతారు.
కాబట్టి ఈ పాయింట్ వంటి, ఇప్పుడు పంక్తులు మీరు పంక్తులు యాక్సెస్ చేయవచ్చు మాత్రమే మార్గం.
>> ప్రశ్నలు?
అవును.
పూర్తిగా టాపిక్ ఆఫ్ [విద్యార్థి], కానీ మీరు PHP దగ్గరగా లేదు - మీరు లేదు >>.
సరే.
[బౌడెన్] వాటిని మూసివేసి తప్పుడు పద్ధతి చెప్పాలి నేను చాలా ప్రయత్నించాడు.
అంటే, ముఖ్యంగా ఒక లిపిలో, బహుశా ఒక అతిశయోక్తి యొక్క
కానీ నేను దీన్ని ఏమవుతుంది చూద్దాం.
ఆ ఏమీ చేయలేకపోయాడు. నాకు కావలసిన ఏం - [వీక్షణ ఒక విచార నిట్టూర్పుని]
నేను ఒక వాదన పాస్ అవసరం.
షూట్. నేను తప్పు అని.
ఒక వాదన కలిగిన php.unique.php.
ఇప్పుడు నేను కూడా ఈ అవసరం లేదు.
నేను అది చెల్లని వాదన పాస్ చేస్తాము.
ఇది ముద్రణ యొక్క ఏ ముద్రించబడింది.
నేను కాపీ ప్రింటింగ్ ఏళ్ళ కాపీ లేదు. పంక్తులు కాబట్టి.
ఇది ప్రతిదీ ముద్రించబడింది మరియు ఇక్కడ డౌన్ ఈ వ్యర్థ గమనించి
PHP ఏదైనా ఆ PHP టాగ్లు లేదు ఎందుకంటే
కేవలం సాహిత్యపరంగా ముద్రించబడిన అన్నారు.
ఎందుకు HTML అదే, నేను DIV బ్లా, బ్లా, బ్లా తరగతి లేదా ఎలాగైనా, చేయవచ్చు తద్వారా మంచిది
అప్పుడు బ్లా, బ్లా, బ్లా మరియు కొన్ని PHP కోడ్ చేసి మరియు అప్పుడు ముగింపు DIV చేయండి.
ఇప్పుడు, నేను టాప్ నా nice DIV పొందండి ప్రతిదీ ఈ ప్రింటింగ్ ఆ PHP PRINTED, దిగువన DIV.
ఈ వంటి ఏదో జరిగినప్పుడు ఘోరమైన, ఇది చాలా సాధారణం
ఫైలు దిగువన కేవలం ఒక దారితప్పిన NEWLINE.
మీరు ఒక ఒప్పందం పెద్ద ఉంటుందనుకుంటున్నాను కాదు
మీరు ఆ బ్రౌజర్లతో నిజానికి పరిగణలోకి వరకు -
>> ఎలా పని దారిమార్పులను లేదా ప్రధానంగా ఏ శీర్షికలు పని,
మీరు ఒక వెబ్ సైట్ కు మీ కనెక్షన్ మరియు అది ఈ శీర్షికలు మరియు విషయాలు తిరిగి పంపినప్పుడు
ప్రతిస్పందన 200 లేదా ప్రతిస్పందన మళ్ళింపు లేదా ఎలాగైనా వంటి,
డేటా మొదటి బైట్ పంపబడుతుంది వరకు శీర్షికలు మాత్రమే చెల్లుతాయి.
మీరు వేలసార్లు మళ్ళింపు, కానీ వెంటనే డేటా మొదటి బైట్ పంపబడుతుంది వంటి చేయవచ్చు
మీరు మళ్ళీ మళ్ళింపు కాబట్టి.
>> మీరు ఒక ఫైల్ దిగువన ఒక దారితప్పిన NEWLINE ఉంటే
మరియు యొక్క మీరు ఈ ఫంక్షన్ను ఉపయోగించడానికి మరియు అప్పుడు మీకు కావలసిన అని పిలవబడు -
అది index.php మరొక ఫైల్ చెప్పాలి మరియు మీరు ఏదో require_once లెట్ యొక్క -
నేను ఒక మంచి ఉదాహరణ భావిస్తారు కాదు.
దిగువన ఈ లైన్ ప్రతిధ్వనించిన అయినప్పుడు సమస్య జరుగుతుంది.
మీరు ఇంకా ప్రతిధ్వనించిన చేసినట్లు ఏదైనా లేదు.
మీరు ప్రతిధ్వనించిన విధానం ఏదైనా న భావించలేదు ఉన్నప్పటికీ, ఏదో ప్రతిధ్వనించిన వచ్చాం
అందువలన ఇప్పుడు మీరు ఏ శీర్షికలు పంపండి కాబట్టి
మరియు మీరు ఫిర్యాదులు పొందడానికి వెళుతున్న.
మీరు ఆ ముగింపు టాగ్లు అవసరం లేదు.
మీరు HTML తో చెయ్యడానికి ప్లాన్ ఉంటే -
మరియు అది ఇక్కడ DIV డౌన్ చేయడానికి ఖచ్చితంగా తగిన యొక్క ఏ
మరియు ఈ సమయంలో మీరు లేదా మీరు వాటిని ఉండరాదు చేయవచ్చు.
ఇది నిజంగా ప్రాధాన్యత లేదు.
కానీ PHP స్క్రిప్ట్స్ లో అది మూసి అరుదైన ఉంది.
ప్రతిదీ PHP, పూర్తిగా ప్రతిదీ, తర్వాత
మీరు నిజంగా అది మూసి / మీరు మూసివేయవద్దు అవసరం లేదు.
>> తీగలను వ్యవహారం C. కంటే NICER ఉంది
PHP లో మీరు ఒకటి లేదా రెండు కోట్ల ఒక స్ట్రింగ్ పేర్కొనవచ్చు.
సింగిల్ కోట్స్ మీరు "పలాయనం" సన్నివేశాలు ఉపయోగించలేరు.
నిరంతరం, బ్లా, బ్లా, బ్లా తప్పించుకుంటారు.
కాబట్టి printf PHP చాలా అరుదు.
Pset 5 లో మీరు sprintf లేదా ఎలాగైనా ఉపయోగిస్తారు - నేను విషయం ఒక విధమైన చేయాలనుకుంటున్నామని నేను printf ఉపయోగించే అంచనా.
కానీ మీరు 001.jpg మరియు 002.jpg చేయాలనుకుంటున్నారా.
కాబట్టి విషయం ఆ విధమైన కోసం నేను నిజంగా నేను printf ఉపయోగించే టెక్స్ట్ ఫార్మాట్ చోట.
అయితే నేను స్ట్రింగ్ జోడింపు ను ఉపయోగించాలి.
నేను నిజంగా printf ఎప్పుడూ ఉపయోగించవద్దు.
మేము సింగిల్ కోట్స్ మరియు డబుల్ కోట్స్ మధ్య వివరాలు విలక్షణమైన చేస్తున్నారు.
భారీ వ్యత్యాసం సింగిల్ కోట్స్, వాచ్యంగా ప్రింట్ చేయబడుతుంది ఉంది.
PHP లో చార్ డేటా రకం ఉంది, సి కాకుండా, ఈ ఈ సమానం కాబట్టి.
వారు రెండు రెమ్మలు ఉన్నారు.
మరియు ఒకే కోట్ తీగలను గురించి nice మాట చెప్పగల్గినవి ఉంది 'hello world!' బ్లా, బ్లా, బ్లా,
$ $ Wooo.
నేను ఈ వాచ్యంగా ప్రింట్ ఉంటుంది ప్రింట్ ఏమి జరుగుతుంది.
యొక్క అవర్ స్టఫ్ అన్ని వదిలించుకోవటం లెట్.
కాబట్టి $ str1 ప్రతిధ్వని;
, డాలర్ సైన్స్: ఇది అక్షరాలా ఆ విషయాలు అన్ని ముద్రిత
మీరు క్రొత్త పంక్తులను ఉంటుందనుకుంటున్నాను ఇది బాక్ స్లాష్ n, -
ఆ విషయాలు అన్ని వాచ్యంగా ముద్రిస్తుంది.
మీరు తప్పించుకోవడానికి అవసరం మాత్రమే విషయం సింగిల్ కోట్స్ ఉంటాయి
లేకపోతే ఎందుకంటే అది సింగిల్ కోట్స్ మూసివేయడం అని చెప్పారు.
డబుల్ కోట్స్, పూర్తిగా భిన్నమైన.
మేము ఇప్పటికే సింటాక్స్ హైలైటింగ్ గురించి భయంకరమైన తప్పు వెళ్ళడానికి ఏమి లో మాకు cluing ఉంది చూడండి.
php.unique. వివరించలేని వేరియబుల్: wooo ఈ wooo అనే వేరియబుల్ వివరించాలి ఎందుకంటే.
డబుల్ కోట్స్ మీరు వేరియబుల్స్ ఇన్సర్ట్ తెలియజేయండి -
$ పేరు = "రాబ్" అని పిలవబడు యొక్క;
కాబట్టి "హాయ్, నా పేరు పేరు $ ఉంది!" ఎకో;
ఇది ఒక వేరియబుల్ ఈ గుర్తించింది.
నేను రన్ చేసినప్పుడు - మరియు నేను NEWLINE ఇన్సర్ట్ చేస్తుంది - హాయ్, నా పేరు రాబ్ ఉంది! హలో వరల్డ్!
నేను పైన wooo యొక్క ప్రింటింగ్ తొలగించబడింది ఎప్పుడూ ఉంటుంది.
మీరు చేయవచ్చు 1 మరింత దశల ఉంది.
$ శ్రేణి = [1, 2, 3];
నేను శ్రేణి యొక్క మొదటి ఇండెక్స్ ప్రింట్ అనుకుంటే?
మీరు $ శ్రేణి [0] చేయండి.
వాక్యనిర్మాణం హైలైటింగ్ ఒక కీలకము ఉంది. ఈ ఏమి ఉండబోతుంది?
php.unique.
హాయ్, నా పేరు 1! ఇది నాకు కావలసిన ఏమి కాదు.
సింటాక్స్ హైలైటింగ్ నాతొ అబద్దం చెప్పాడు.
లెట్ యొక్క ప్రయత్నించండి 'ఒక' -> 1, 'బి' -> 2.
నేను వ్రాయుటకు ఉంటుంది ఎలా.
ఊహించని ఒకే కోట్ (బ్లా, బ్లా, బ్లా, బ్లా, బ్లా T_ENCAPSED).
దీనిని శ్రేణి భాగంగా ఈ గుర్తించి లేదు.
ఇది ఒక లేఖ ద్వారా సూచిక వ్యూహం ఈ గుర్తించి కాదు.
మీరు, గిరజాల జంట కలుపులు చుట్టూ ఆ చేయాలనుకుంటున్నారా
మరియు ఇప్పుడు ఈ కర్లీ జంట ఏమైనా అంతర్వేశనం ఉంటుంది
ఇది మేము అద్భుతంగా కుడి స్థలాలు ఈ చరరాశులు ఇన్సర్ట్ ఉపయోగించే పదం.
ఇప్పుడు php.unique, ఈ చేయడం, మరియు ఎక్కువ, నా పేరు 1! ఊహించిన
లేదా ఎక్కువ, నా పేరు రాబ్ ఉంది!
సింగిల్ కోట్స్ గురించి నీస్ రకంగా ఒక విషయం ఉంది -
Interpolating కొన్ని ఖర్చు ఉంది.
మీరు డబుల్ కోట్స్ ఉపయోగిస్తే, వ్యాఖ్యాత, ఈ స్ట్రింగ్ వెళ్ళి ఉంటుంది
, నిర్ధారించాడు "ఓహ్, ఇక్కడ ఒక వేరియబుల్. ఇప్పుడు నేను ఆ వేరియబుల్ పొందండి మరియు ఇక్కడ ఇన్సర్ట్ వెళ్లాలి."
మీరు ఏ వేరియబుల్స్ ఉపయోగించడానికి పోయినా,
ఈ డబుల్ కోట్స్ లోపలి ఏదీ, అంతర్వేశనం అవసరం
దానిని డబుల్ కోట్స్ వెళ్ళి అవసరం ఎందుకంటే కాని ఇప్పటికీ నెమ్మదిగా ఉంటుంది
అంతర్వేశనం అవసరం పనులు కోసం చూస్తున్న.
ఏమీ అంతర్వేశనం అవసరం చేస్తే సింగిల్ కోట్స్, ఒక బిట్ వేగంగా ఉంటుంది
మరియు నేను 'హాయ్, నా పేరు' కోసం సింగిల్ కోట్స్ ఉపయోగించడానికి కూడా ఉంటాయి. $ శ్రేణి ['ఒక'] ఏమైనప్పటికీ.
అంటే ముందు ఏ సమానంగా చెప్పారు.
కానీ ప్రాధాన్యత అంశంగా ఉంది.
మీరు PHP ఉపయోగించి, మీరు బహుశా వేగం వ్యత్యాసం గురించి పట్టించుకోను.
తో ప్రారంభించడానికి వాటిని కారణం తగినంత లేదు.
>> ఏదైనా చివరి ప్రశ్నలు?
>> మేము నిజంగా కూడా అది అన్ని ద్వారా రాలేదు, కానీ ఈ విషయాన్ని బోరింగ్ ఉంది.
మీరు HTML వ్యవహరించే చేసినప్పుడు PHP లో రకమైన నీస్ అని లాస్ట్ థింగ్, ఉంది
మీరు ఒక వేరియబుల్ ప్రింటింగ్ కోసం ఒక బిట్, సో నైస్ సత్వరమార్గం సింటాక్స్ ఉపయోగిస్తాము.
ఇక్కడ PHP ఉంచడం లేకుండా, ఈ చిన్న టాగ్లు అంటారు.
అధికారికంగా PHP 5.4 నాటికి, ఈ తీసివేయబడింది.
మీరు php ఉంచారు మంచిది.
ఈ ఇప్పటికీ <చాలా చిన్న టాగ్లు మద్దతిస్తోంది? = ఇప్పటికీ సంపూర్ణ జరిమానా ఉంటాయి.
ఇది మద్దతు అప్రమేయంగా, కాబట్టి మీరు అనుకుంటున్నారా గా మీరు ఉపయోగించవచ్చు, మరియు వారు చాలా అనువుగా ఉన్నాము.
>> ఏదైనా ప్రశ్నలు?
అన్ని కుడి.
>> , శాన్ డియాగో classy ఉండండి.
[Chuckles]
ఇక సెలవు. [నవ్విన]
[చప్పట్లు] [నవ్విన]
>> [CS50.TV]