[Powered by Google Translate] [PHP సింటాక్స్]
[టామీ MacWilliam] [హార్వర్డ్ విశ్వవిద్యాలయం]
[ఈ CS50 ఉంది.] [CS50.TV]
>> ఈ వీడియో లో, మేము PHP పరిచయం చేస్తాము -
భాషలు ఒకటి మేము CS50 ఉపయోగించి అవుతారు
వెబ్ అభివృద్ధి మేము బదిలీ వంటి.
PHP, PHP హైపర్టెక్స్ట్ ప్రాసెసర్ ఉన్నచో
లేదా PHP హైపర్టెక్స్ట్ ప్రాసెసర్ హైపర్టెక్స్ట్ ప్రాసెసర్,
మరియు నేను అక్కడ ఆపడానికి ఉంటాం.
PHP నేను నిజంగా అద్భుతం భావించే ఒక రికర్సివ్ అక్రానిమ్, ఉంది.
>> సో, యొక్క వ్రాయడానికి వీలు 'hello world' PHP లో,
మేము తెలిసిన మరియు ప్రేమించడం మొదలుపెడతారు చేసిన సి లో 'hello world' కంటే కొంత భిన్నంగా ఉంటుంది.
బదులుగా hello.c అనే ఫైలు సృష్టించే,
మేము hello.php సృష్టిస్తారు.
మా PHP కోడ్ అన్ని <? Php మరియు?> మధ్య కలిగి ఉంటుంది.
మేము ఉన్న ఏ PHP కోడ్ కలిగి ఉంటే
ఈ ఆద్యంతాలు బయట, అది అమలు కాదు.
ఈ PHP బ్లాక్స్ యొక్క అనేక ఉండవచ్చు
మేము ఒక PHP ఫైలు లోపల కావలసిన.
PHP ఒక ప్రధాన క్రియకు అవసరం లేదు.
బదులుగా, మా PHP కోడ్ మా PHP ఫైలు కనిపిస్తుంది క్రమంలో అమలు అవుతుంది.
సి మరియు PHP రెండు డేటా ఔట్పుట్ కోసం ఒక 'printf' ఫంక్షన్ కలిగి.
కానీ PHP లో, మేము # standardIO.h వంటి ఏ శీర్షిక ఫైల్స్ అవసరం లేదు.
PHP లో మేము మా కోడ్ కంపైల్ కాదు ఎందుకంటే ఆ.
మేము సి కోడ్ వ్రాశాడు మా వర్క్ఫ్లో తెరవబడుతుంది మొగ్గు
ఒకటి లేదా ఎక్కువ. సి లేదా. h ఫైళ్లు, వాటిని మార్చడాన్ని, వాటిని కంపైల్,
మరియు ఫలితంగా బైనరీ నడుస్తున్న.
ఈ ప్రక్రియ గురించి మరింత సమాచారం కోసం సంకలనం వీడియో తనిఖీ.
>> కాకుండా సంకలనం - - భాష సి కాకుండా, PHP ఒక అర్థం ఉంది.
ఆ PHP కోడ్ మేము వ్రాయడానికి అర్థం
, ఒక వ్యాఖ్యాత అనే ప్రత్యేక కార్యక్రమం ద్వారా అమలు అవుతుంది
దీనిలో మా కోడ్ అమలు చేస్తుంది.
మా PHP కోడ్ నడుపుటకు,
మేము, దాని అమలు నిర్వహించడానికి ఇది PHP వ్యాఖ్యాత పాటు దీన్ని పంపుతాము
బదులుగా యంత్రం కోడ్ దానిని కంపైల్ కంటే.
యొక్క చర్య వ్యాఖ్యాత చూద్దాం.
మేము ఒక టెర్మినల్ తెరిచి PHP ఆదేశాన్ని చేస్తాము
మేము అమలు చేయాలనుకుంటే PHP ఫైలు మార్గం తరువాత.
మేము, 'php hello.php' అని వస్తుంది.
మరియు అక్కడ మేము వెళ్ళి. మా PHP కార్యక్రమం అవుట్పుట్ ఉంది.
మేము అన్ని వద్ద మా PHP ఫైలు కంపైల్ అవసరం లేదు.
PHP వ్యాఖ్యాత - బదులుగా, మేము మరొక ప్రోగ్రామ్ -
మేము వ్రాసాడు sourcecode అమలు.
>> PHP కేవలం printf కంటే చేయవచ్చు.
యొక్క కొన్ని క్లిష్టమైన PHP ప్రోగ్రాములను వ్రాయటానికి వీలు.
నిర్మాణాలు కోసం సింటాక్స్ - కోసం, అయితే, వేరే ఉంటే ఇష్టం, మరియు స్విచ్ -
PHP మరియు C. లో అదే
కేవలం సి వంటి, ఈ నిర్మాణాలను ప్రతి వారి శరీరం విభజన జంట కలుపులు ఉపయోగిస్తుంది
మరియు కేవలం సి మాదిరిగా, ప్రతి లైన్ మేము వ్రాయడానికి
ఒక సెమికోలన్ తో ముగియాలి;
అయితే, వేరియబుల్ PHP ఒక బిట్ భిన్నంగా నిర్వహించబడతాయి.
మొదటి, PHP లో అన్ని వేరియబుల్స్ డాలర్ సైన్ తో ప్రారంభం కావాలి.
ఇది మొదటి వద్ద కొద్దిగా అదృష్టము తెలుస్తోంది, కానీ మీరు ఉపయోగించే పొందుతారు.
రెండవ, PHP ఒక వదులుగా టైప్ చేసిన భాష
ఇది మీరు ప్రత్యేకంగా జాబితా అవసరం లేదు అంటే
మీరు దీన్ని సృష్టించడానికి ఒక వేరియబుల్ రకం.
సి లో మీరు చెప్పే అవసరం చోట Int x = 5;
లేదా చార్ y = 'ఒక';
PHP మేము కేవలం $ x = 5 చెప్పగలను;
మరియు $ y = 'ఒక';.
అదే విధంగా వర్తిస్తుంది.
అయితే Int f () {మా పనితీరు శరీరం} మాట్లాడుతూ కంటే,
PHP మేము ఫంక్షన్ f () {మా పనితీరు శరీరం} అని చేయబోతున్నామని.
మేము స్పష్టంగా మా ప్రమేయం f తిరిగి రకాన్ని పేర్కొనాలి లేదు.
PHP లో చర్యలు అదే రకం తిరిగి లేదు
ప్రతిసారీ వారు అమలవుతున్నాయి.
ఉదాహరణకు, మేము ఒక లోపం న తప్పుడు తిరిగి ఒక ఫంక్షన్ రాస్తుంది
మరియు మరొక రకమైన సఫలమైతే.
>> ఈ కూడా మరింత సాధారణ విధులు వ్రాయండి సహాయపడుతుంది.
ఉదాహరణకు, మేము ఒక యాడ్ ఫంక్షన్ రాస్తుంది
2 పూర్ణాంకాల ఇస్తారు ఉంటే పూర్ణాంకం తిరిగి చేయవచ్చు
లేదా ఫ్లోట్ 2 తేలటం ఇవ్వబడలేదు.
సి, మేము దీన్ని 2 ప్రత్యేక విధులు వ్రాయడానికి అవసరం ఇష్టం.
సి లో మేము ఒక రైజ్ మరియు తీగలను, కోసం గమనికలు ఉపయోగించడానికి
మేము PHP లో గమనికలు ఉపయోగించడానికి చేయలేరు.
బదులుగా, శ్రేణుల మరియు తీగలను రెండు PHP లో రకాలు అంతర్నిర్మిత ఉన్నాయి.
వారికి సరైన భాషలోకి నిర్మించారు చేస్తున్నారు.
మేము చెప్పగలను PHP ఒక అమరికను రూపొందించడానికి
$ ఒక = శ్రేణి (1, 2, 3);
లేదా కేవలం $ ఒక = [1, 2, 3];.
మేము ఈ శ్రేణి లోకి సూచిక మేము C. నుండి చేస్తున్నట్లుగానే అదే సింటాక్స్ ఉపయోగించి
మొదటి మూలకం పొందుటకు మేము చెప్పటానికి, $ ఒక [0] చేస్తాము;.
PHP కూడా అనుబంధ శ్రేణుల మద్దతు అంతర్నిర్మిత.
అనుబంధ శ్రేణుల మేము ఇప్పటికే చూసిన హాష్ పట్టిక డేటా నిర్మాణం వలె -
వారు ఒక విలువ ఒక కీ మ్యాప్.
>> యొక్క ఒక ఉదాహరణ పరిశీలించి లెట్.
మేము, $ సిబ్బంది చెప్పగలను = ["బోధకుడు" => "డేవిడ్", "TF" => "టామీ"];.
శిక్షకుడు మరియు TF - ఇక్కడ, నేను 2 కీలు తో ఒక అనుబంధ అమరిక కలిగి.
డబుల్ బాణం, లేదా సమానం అధికంగా కంటే,
ఒక కీ మరియు దాని సంబంధిత విలువ వేరు ఉపయోగిస్తారు.
సో, $ సిబ్బంది ["TF"] విలువ స్ట్రింగ్ "టామీ" ఉంది.
ఒక అనుబంధ అమరిక యొక్క విలువలు -
చాలా ఇతర శ్రేణి వంటి - ఏ రకం ఉంటుంది.
ఉదాహరణకు, మేము చెప్పగల్గినవి, $ సిబ్బంది = ["బోధకుడు" => "డేవిడ్", "TFS" => ["టామీ", "రాబ్"]];.
ఇప్పుడు 'TFS' విలువ ఒక శ్రేణి.
ఒక అనుబంధ శ్రేణిలో విలువలు వివిధ రకాల ఉంటుంది అర్థం.
>> PHP శ్రేణుల కూడా, ఒక నిర్దిష్ట పొడవు లేదు
కాబట్టి మేము ఒక అర్రే నుండి మూలకాలు జోడించడానికి లేదా తొలగించవచ్చు.
లెట్ యొక్క మేము $ వంటి సాధారణ శ్రేణి కలిగి చెబుతున్న = [1, 2, 3];.
ఈ శ్రేణి ఒక కొత్త మూలకం జోడించడానికి,
మేము చెప్పటానికి, $ ఒక [] = 4 చేయవచ్చు;.
[1, 2, 3, 4] - ఇప్పుడు మా శ్రేణి నాలుగు అంశాలు కలిగి ఉంది.
గుర్తు మేము సి లో ఈ వంటి ఏదో చేయాలని కోరుకుంటే,
మేము, ఒక సరికొత్త వ్యూహం కేటాయించుటకు కలిగి ఇష్టం
అది లోకి మా మొదటి శ్రేణి యొక్క కంటెంట్లను కాపీ,
ఆపై మా కొత్త విలువ కొత్త శ్రేణి యొక్క చివరి మూలకం సెట్.
ఈ PHP లో చాలా సులభం.
మా వ్యూహం ఒక అనుబంధ అమరిక ఉంటే,
మేము కేవలం ఒక అంశాన్ని సృష్టించడానికి ఒక కొత్త కీ నిర్వచించలేదు
అసలే లేదు ఉంటే.
$ సిబ్బంది - - మేము మా మునుపటి అర్రే కలిగి ఉంటే
మేము సిబ్బంది $ చెప్పగలను ["మొత్తం"] = 3;.
ఇప్పుడు మేము 3 విలువ ఒక కొత్త కీ కలిగి.
>> వ్యూహంలో మూలకాల సంఖ్య పొందుటకు,
మేము 'మొత్తం' ఫంక్షన్ ఉపయోగించవచ్చు.
మేము అని చెప్పుకోవాలంటే, ($ ఒక) కౌంట్;, 4 విలువ ఉంటుంది.
PHP లో, మేము, డబుల్ లేదా సింగిల్ కోట్స్ ఉపయోగించి తీగలను సృష్టించవచ్చు
కాబట్టి అంశాలపై రెండు రెమ్మలు ఉంటాయి.
S1 $ = "స్ట్రింగ్"; $ S2 = 'మరో స్ట్రింగ్';.
ఈ రెండు మధ్య తేడా ఏమిటి?
బాగా, అది ఉన్నాయి అనుకుంటున్నారా అందంగా సాధారణ వార్తలు
ఒక స్ట్రింగ్ యొక్క ఒక వేరియబుల్ లోపల విలువ.
దీన్ని ఒక మార్గం, PHP యొక్క డాట్ ఆపరేటర్లు ఉపయోగించడానికి ఉంటుంది
ఇది concatenates తీగలను.
మేము ఈ వంటి ఏదో అలా -
$ N = 5; $ s = 'n' N $.;.
ఇక్కడ మా n వేరియబుల్ ఒక పూర్ణ సంఖ్య.
కానీ మేము స్ట్రింగ్ తో concatenate ఉన్నప్పుడు,
PHP స్వయంచాలకంగా మాకు స్ట్రింగ్ అది మార్పిడి అవుతుందని.
లేదా మేము కేవలం స్ట్రింగ్ కూడా లోకి వేరియబుల్ ఉంచాలి డబుల్ కోట్స్ ఉపయోగించవచ్చు.
మేము, $ s చెప్పగలను = "N $ n ఉంది";.
ఇప్పుడు $ s యొక్క విలువ 'n 5' ఉంటుంది.
మేము బదులుగా సింగిల్ కోట్స్ ఉపయోగిస్తే, $ s లో = 'N $ n ఉంది';
లు విలువ ఉంటుంది 'N $ n ఉంది';.
మేము సింగిల్ కోట్స్ ఉపయోగిస్తే n విలువ, బదులుగా కాదు
మేము డబుల్ కోట్స్ ఉపయోగిస్తే కానీ ఉంటుంది.
మేము, ఒక స్ట్రింగ్ లో వ్యూహం విలువ చేర్చడానికి డబుల్ కోట్స్ ఉపయోగించడానికి కావాలా
మేము ఈ వంటి శ్రేణి చుట్టూ కర్లీ జంట కలుపులు, ఉన్నాయి చెయ్యాలి -
$ S = "{$ సిబ్బంది ['మొత్తం']}";.
>> ప్రస్తుతం సి లో ఒక చిన్న స్నిప్పెట్ పరిశీలించి మరియు PHP అది అనువాదం లెట్.
ఇక్కడ, మేము, ఒక స్ట్రింగ్ యొక్క పత్రాలను ముద్రిస్తుంది ఒక ఫంక్షన్ సృష్టిస్తున్నారు
ప్రతి లైనుకు ఒక పాత్ర.
PHP లో అదే పనిని లెట్ యొక్క.
మొదటి, మేము మా PHP ఆద్యంతాలు అవసరం.
మేము, మా ఫంక్షన్ రూపొందించినప్పుడు
మేము తిరిగి రకం లేదా దాని వాదన రకాన్ని పేర్కొనాలి లేదు.
మా లు వేరియబుల్ కూడా ఒక డాలర్ సైన్ తో ప్రారంభం కావాలి.
PHP యొక్క strlen ఫంక్షన్, మాకు ఒక స్ట్రింగ్ యొక్క పొడవు ఇస్తుంది
కేవలం సి యొక్క strlen వంటి మాకు ఒక స్ట్రింగ్ యొక్క పొడవు ఇస్తుంది.
దీనిలోనే అయితే, ఈ చర్యలను నిజానికి కొంత భిన్నంగా ఉంటాయి
ఒక స్ట్రింగ్ PHP ఒక అంతర్నిర్మిత రకం నుండి.
లూప్ 'కోసం' మా యొక్క సింటాక్స్ అదే.
>> PHP లో, మేము కూడా ఒక స్ట్రింగ్ యొక్క అక్షరాలు ఆక్సెస్ చెయ్యడానికి శ్రేణి సంజ్ఞామానం ఉపయోగించవచ్చు.
మేము ఇప్పుడు స్ట్రింగ్ యొక్క ప్రతి అక్షరం ముద్రించాలా ముద్రణ ఫంక్షన్ ఉపయోగించవచ్చు.
PHP యొక్క ముద్రణ ఫంక్షన్, మేము placeholders గురించి ఆందోళన అవసరం లేదు -
% d లేదా% సి వంటి - మేము ఒక స్ట్రింగ్ కాదు ఒక వేరియబుల్ ముద్రించాలా కావలసినప్పుడు.
బదులుగా, మేము కేవలం, ముద్రణ ఫంక్షన్ ఏ రకం యొక్క ఒక వేరియబుల్ తరలిస్తారు
మరియు అది ఒక స్ట్రింగ్ మార్చబడతాయి మరియు ప్రదర్శించబడుతుంది.
అంతే! లెట్ యొక్క ఇప్పుడు 'php print.php' తో మా ఫైలు అమలు.
మరియు మేము మా సి కార్యక్రమం నుండి చూసిన అవుట్పుట్ ఉంది.
>> PHP కూడా 'foreach' లూప్ అనే నిర్మాణం మద్దతు.
'Foreach' లూప్, కేవలం లూప్ 'కోసం' ఒక వంటిది
కానీ విషయాలు చదవదగ్గ చేయడానికి వాక్యనిర్మాణ చక్కెర బిట్ జతచేస్తుంది.
ఇక్కడ, మేము '$ శ్రేణి' అని ఒక కొత్త శ్రేణి సృష్టిస్తున్నారు.
ఇప్పుడు మేము (సంఖ్య $ వంటి $ శ్రేణి), foreach చెప్పగలను,
మరియు మేము $ సంఖ్య అవ్ట్ ముద్రించవచ్చు.
మేము ఈ ఫైల్ అమలు చేసినప్పుడు - php foreach.php-మేము తన సొంత లైన్ ప్రతి సంఖ్య చూడగలరు.
>> మేము సి కోడ్ రాసినప్పుడే అది తరచుగా ప్రత్యేక ఫైళ్లు లోకి మా కోడ్ నిర్వహించడానికి ఉపయోగపడే.
PHP లో, మేము అదే విషయం చేయవచ్చు.
లెట్ యొక్క మేము math.php పిలువబడే ఒక ఫైల్ లో కొన్ని విధులు అని.
నేను, calculator.php వంటి, మరొక PHP ఫైలు లో ఆ విధులు ఉపయోగించడానికి కావాలా
నేను PHP యొక్క require_once () ఫంక్షన్ ఉపయోగించవచ్చు.
Require_once కేవలం # ఉన్నాయి వంటిది.
ఒక ఫైల్ ఒక మార్గం ఇచ్చినపుడు, అది తప్పనిసరిగా విషయాలు కాపీ మరియు పేస్ట్ ఉంటుంది
ప్రస్తుత ఫైల్ ఆ ఫైలు యొక్క.
Require_once, ప్రతి ఫైల్ మాత్రమే ఒకసారి ప్రస్తుత ఫైల్లోకి చేర్చబడింది నిర్ధారిస్తుంది
మీరు ప్రతి ఇతర అవసరం PHP ఫైళ్లు పెద్ద సేకరణ కలిగి ఉంటే ఇది తోడ్పడుతుంది.
యొక్క ఒక ఉదాహరణ పరిశీలించి లెట్.
ఇక్కడ మేము నేను మరొక ఫైల్ లో ఉపయోగించడానికి చెయ్యాలనుకునే విధులు సమూహాన్ని కలిగి.
యొక్క మేము వాటిని ఉపయోగించవచ్చు ఎలా పరిశీలించి లెట్.
లైన్ 3 న, మేము math.php అవసరం ఉంటాయి.
'__DIR__' ప్రస్తుత డైరెక్టరీ ప్రాతినిధ్యం ప్రత్యేక స్థిరంగా
math.php మరియు calculator.php అదే డైరెక్టరీలో ఉన్న కనుక.
మేము math.php అవసరం తరువాత, మేము విధులు ఉపయోగించవచ్చు
ఒకవేళ మేము calculator.php వాటిని నిర్వచించవచ్చు చేసిన.
లెట్ యొక్క 'php calculator.php' తో ఈ అమలు. గ్రేట్!
>> ఇది PHP యొక్క సింటాక్స్ మా పరిచయం కోసం ఆ.
మరింత తెలుసుకోవడానికి, PHP.net తనిఖీ.
PHP అంతర్నిర్మిత ఫంక్షన్లు చాలా ఉంది, మరియు అదృష్టవశాత్తూ దాని డాక్యుమెంటేషన్ నిజంగా గొప్ప ఉంది.
నా పేరు టామీ ఉంది, మరియు ఈ CS50 ఉంది.
[CS50.TV]
>> ... బ్రాకెట్, నేను గది బయట రెడీ. ఇది డామన్! ఈ నేను కోడ్ పెద్ద పదాలు ఉపయోగిస్తారు గత వీడియో.