[Powered by Google Translate] [ნაწილში 8 - უფრო კომფორტული]
[Rob Bowden - ჰარვარდის უნივერსიტეტი]
[ეს არის CS50. - CS50.TV]
>> ეს კვირაში მონაკვეთზე აღნიშნავს ვაპირებთ იყოს საკმაოდ მოკლე,
ამიტომ მე უბრალოდ აპირებს შეინარჩუნოს ვსაუბრობთ, თქვენ ბიჭები ვაპირებთ შენარჩუნება სვამს კითხვებს,
და ჩვენ შევეცდებით შეავსოთ იმდენი დრო რაც შეიძლება.
ბევრი ფიქრობს, რომ ეს pset არ არის აუცილებლად რთული, მაგრამ ეს ძალიან ხანგრძლივი.
Pset სპეც თავად იღებს საათობრივად წაიკითხოს.
ჩვენ მოგცემთ ბევრი SQL თქვენ შეიძლება უნდა გამოვიყენოთ.
ჩვენ ფეხით თქვენ მეშვეობით ბევრი, ასე რომ არ უნდა იყოს ძალიან ცუდი.
აქვს ვინმეს დაიწყო ან დასრულდება?
ეს ბოლო pset. ოჰ, ღმერთი ჩემი.
ჩვეულებრივ არსებობს JavaScript ერთი ამის შემდეგ, მაგრამ კალენდარი შეცვალოს
აკეთებს ყველაფერს 1 კვირაში მოკლეა, და ჩვენ უკვე აღარ გვაქვს JavaScript pset.
მე არ ვიცი როგორ გავლენას ახდენს, რომ თუ არა JavaScript აპირებს გამოჩნდება გამოცდა
ან Quiz 1.
მე წარმოიდგინეთ ეს იქნება რაღაც თქვენ უნდა იცოდეთ მაღალი დონის რამ JavaScript,
მაგრამ ეჭვი მაქვს, რომ ჩვენ უბრალოდ მოგცემთ სწორი JavaScript კოდი
მას შემდეგ, რაც თქვენ არ ჰქონდათ pset მას.
მაგრამ ეს იქნება კონკურსები და ინტელექტუალური მიმოხილვა მომავალ კვირას.
>> სექცია კითხვებზე.
ბევრი ამ პერსონალის გარკვეულწილად ცუდად ფორმულირებული, მაგრამ ჩვენ განვიხილავთ, თუ რატომ.
განსხვავებით C, PHP არის "დინამიურად-აკრეფილი" ენა. რას ნიშნავს ეს, თქვენ ეკითხებით?
ისე, Say Goodbye ყველა იმ char, ათწილადი, int და სხვა Keywords თქვენ უნდა გამოვიყენოთ
როდესაც გამოცხადების ცვლადები და ფუნქციები C.
PHP-ში, ცვლადი ს ტიპის განისაზღვრება ღირებულება რომ ის გაკეთებული ჩატარების.
ასე რომ სანამ ჩვენ აკრიფოთ ეს კოდი შევიდა ფაილი სახელად dynamic.php,
PHP არის დინამიურად აკრეფილი. რაც თავისთავად ასეა.
მე არ ეთანხმებიან იმ ფაქტს, რომ ეს ნიშნავს, რომ ჩვენ ვამბობთ, მშვიდობით რომ char, ათწილადი, int,
და სხვა საკვანძო სიტყვები.
ზუსტი განსხვავება დინამიურად აკრეფილი და ალტერნატიული,
რომელიც statically აკრეფილი, არის ის, რომ დინამიურად აკრეფილი, ყველა თქვენი ტიპის შემოწმება და პერსონალი
ხდება პერსპექტივაში დრო, ხოლო statically აკრეფილი ეს ხდება კომპილირების დროს.
სიტყვა სტატიკური ზოგადად, როგორც ჩანს, ნიშნავს კომპილირების დროს რამ.
ვფიქრობ არსებობს სხვა მიზნებისათვის ამისთვის, მაგრამ C, როდესაც თქვენ გამოაცხადოს სტატიკური ცვლადი,
მისი შენახვა გამოყო, კომპილირების დროს.
აქ, დინამიურად აკრეფილი მხოლოდ იმას ნიშნავს, რომ -
In C, თუ თქვენ ცდილობენ დაამატოთ სიმებიანი და რიცხვი, როდესაც თქვენ კომპილირება,
ის აპირებს უჩივიან, რადგან იგი აპირებს ამბობენ, რომ თქვენ ვერ შეძლებთ დაამატოთ int და მაჩვენებელი.
უბრალოდ არ მოქმედებს ოპერაცია.
რომ სხვა საქმეა, რომ ჩვენ კიდევ ამ მეორე.
მაგრამ ეს ერთგვარი შემოწმება, ის ფაქტი, რომ უჩივის საათზე კომპილირების დროს,
არის სტატიკური ტიპის შემოწმებას.
არსებობს ენებზე, სადაც თქვენ არ უნდა ვთქვა, char, ათწილადი, int, და ყველა იმ რამ,
მაგრამ ენა, შეუძლია თქვას კონტექსტში რამ რა ტიპის ის უნდა იყოს,
მაგრამ მაინც statically აკრეფილი.
ასე რომ, თუ თქვენ მიიღოს 51, OCaml, თქვენ არასოდეს უნდა გამოვიყენოთ ნებისმიერი ამ ტიპის,
მაგრამ ეს ჯერ კიდევ იქნება საათზე კომპილირების დროს ამბობენ ვერ ვაკეთებთ, რადგან თქვენ შერევას int და სიმებიანი.
დინამიურად აკრეფილი მხოლოდ იმას ნიშნავს, რომ შუალედში დროს აწარმოებს ახლა თქვენ აპირებს მიიღოს საჩივარი.
თუ თქვენ ასევე გამოიყენება Java ადრე, ზოგადად, თითქმის ნებისმიერი C-ტიპის ენა
იქნება statically აკრეფილი, ამიტომ C, C + +, Java, ყველა იმ ზოგადად statically აკრეფილი.
ჯავაში, როდესაც თქვენ შედგენის რაღაც და თქვენ ამბობდა
string s უდრის ახალი რაღაც რომ არ არის ტექსტი,
რომ აპირებს უჩივიან, რადგან იმ ტიპის უბრალოდ არ ემთხვევა up.
რომ აპირებს უჩივიან საათზე კომპილირების დროს.
მაგრამ მას ასევე აქვს გარკვეული დინამიური დრო რამ, როგორიცაა, თუ თქვენ ცდილობენ მიცემული რაღაც
to type რომ უფრო კონკრეტული, ვიდრე მის დღევანდელ ტიპის,
არაფერი მას შეუძლია გააკეთოს საათზე კომპილირების დროს, რათა შეამოწმოს თუ არა, რომ მსახიობი აპირებს კიდეც.
ჯავის ასევე აქვს გარკვეული დინამიური ტიპის შემოწმების, რომ როგორც კი იგი იღებს, რომ ხაზი კოდი
როცა ეს რეალურად შესრულებაში, იგი აპირებს მსახიობი,
შეამოწმეთ თუ ეს მსახიობი იყო მართებული პირველ რიგში,
და თუ ეს არ იყო, მაშინ იგი აპირებს ჩივიან, რომ თქვენ გაქვთ არასწორი ტიპი.
დინამიური ტიპის შემოწმების.
შეიტანეთ ამ შევიდა ფაილი სახელად dynamic.php.
Dynamic.php.
მე unzip რომ გაფორმებით.
ჩვენ გვყავს ცვლადი, ჩვენ ვაყენებთ მას მთელი რიცხვი 7,
მაშინ ჩვენ ვაპირებთ ბეჭდვა და% s -
ოჰ, ჩვენ დაბეჭდვის ტიპის, ასე რომ gettype დაბრუნებას აპირებს ტიპის ცვლადი.
ჩვენ უბრალოდ ბეჭდვის ტიპი უსასრულოდ.
ჩვენ უბრალოდ php.dynamic.php.
ჩვენ დავინახავთ, რომ იგი იცვლება მთელი რიცხვი უნდა string to ლოგიკური როგორც ჩვენ გაიაროს.
დო არ არსებობს ლოგიკური მონაცემები ტიპის, არ არსებობს სიმებიანი მონაცემები ტიპის.
არსებობს char * და ლოგიკური მხოლოდ tends უნდა იყოს int ან char ან რამე.
PHP-ში ამ ტიპის არსებობენ, და რომ ერთ ერთი დიდი უპირატესობა PHP ზე C -
რომ სიმებიანი ოპერაციებს უსასრულოდ ადვილია PHP-ში, ვიდრე C. ისინი უბრალოდ მუშაობა.
>> ამიტომ, ჩვენ დავბრუნდებით აქ.
ჩვენ გაიქცა dynamic.php.
ეს ეუბნება PHP ინტერპრეტატორი, მოუწოდა PHP, აწარმოებს PHP კოდი dynamic.php.
თუ თქვენ გაქვთ რაიმე შეცდომები ფაილი, თარჯიმანი გეტყვით!
თარჯიმანი, ეს არის კიდევ ერთი დიდი სხვაობა PHP და C.
In C, თქვენ უნდა შეადგინონ რაღაც და მაშინ აწარმოებს, რომ შედგენილი ფაილი.
PHP-ში თქვენ არასდროს კომპილაციის არაფერი.
ასე რომ PHP ინტერპრეტატორი ძირითადად მხოლოდ კითხულობს ამ ხაზს.
ეს ურტყამს var = 7 მაშინ ჰიტები printf მაშინ ჰიტები var მაშინ ჰიტები printf და ასე შემდეგ.
არსებობს ცოტა შედგენის ეს ასეა, და ეს caches შედეგები
ასე რომ, თუ თქვენ აწარმოებს სცენარის later შეგიძლიათ დაკავდით,
მაგრამ ძირითადად ეს ხაზს სახის რამ.
ეს იმას ნიშნავს, რომ ბევრი ოპტიმიზაციით, რომ მივიღებთ დო,
მოსწონს შედგენა, უბრალოდ ზოგადად შემდგენელი შეუძლია გააკეთოს ბევრი ხრიკები თქვენთვის.
მას შეუძლია აიღოს გამოუყენებელი ცვლადები, მას შეუძლია გააკეთოს ყველა ამ სახის ნივთები,
მას შეუძლია გააკეთოს კუდი უკან.
PHP-ში თქვენ არ აპირებს მიიღოს, რომ უპირატესობა
რადგან ეს მხოლოდ იწყებს შესრულებაში ხაზის მიერ ხაზს,
და ეს ნამდვილად არ აღიარებს ეს ყველაფერი ადვილად
რადგან არ 1 დიდი კრებული უღელტეხილზე მეტი რამ და შემდეგ აღსრულება;
უბრალოდ ხაზს.
ასე რომ თარჯიმანი.
>> თავში ჩვენი დინამიური აკრეფით: საკმაოდ გრილი, eh?
თქვენ აუცილებლად ვერ რომ C!
ახლა ვნახოთ, თუ შეგიძლიათ გაერკვნენ ტიპის თითოეულ შემდეგ ფასეულობებს.
იხილეთ ამ ცნობისთვის.
ასე რომ 3.50. რა ტიპისა ფიქრობთ, რომ იქნება?
აქ არის სახის გვაქვს.
ჩვენ გვყავს bools, რიცხვებით, მცურავი ქულა, სიმები, მასივები, ობიექტების,
და მაშინ რესურსების, რომელიც სახის ბუნდოვანია.
ვფიქრობ, სინამდვილეში მაგალითად აქ.
მაშინ არსებობს null. NULL არის სპეციალური ტიპის.
განსხვავებით C აქ NULL მხოლოდ კურსორი ერთად მისამართზე 0,
in PHP, NULL არის საკუთარი ტიპის სადაც ძალაშია მხოლოდ ისაა, რომ ტიპის null.
ეს არის ბევრად უფრო სასარგებლოა შეცდომა შემოწმებისას.
In C, სადაც ჩვენ გვქონდა ამ საკითხთან დაკავშირებით, სადაც თუ დაბრუნების NULL,
ნიშნავს ეს თქვენ დაბრუნების NULL კურსორი ან NULL to ნიშნავდეს შეცდომა
ან ყველა, რომ დაბნეულობა გვქონდა ერთ მომენტში.
აქ დაბრუნების NULL ზოგადად ნიშნავს შეცდომა.
ბევრი რამ ასევე დაბრუნების ცრუ ამისთვის შეცდომა.
მაგრამ საქმე იმაშია არის NULL ტიპი, ერთადერთი იმ NULL ტიპი არის NULL.
მაშინ გადმორეკე ჰგავს შეგიძლიათ განსაზღვროს გარკვეული ანონიმური ფუნქციები.
თქვენ არ მისცეს ფუნქციის სახელი, მაგრამ თქვენ არ უნდა გაუმკლავდეთ, რომ აქ.
შევხედავთ იმ ტიპის რომ მათ ველოდებით us იცოდეს,
როგორ ფიქრობთ რა ტიპის 3.50 არის? >> [სტუდენტი] Float.
Yeah.
ასე შემდეგ აქ, როგორ ფიქრობთ რა ტიპის ეს? >> [სტუდენტი] მასივი.
Yeah. პირველი იყო float, ხოლო მეორე არის მასივი.
გაითვალისწინეთ, რომ ეს წყობა არ მოსწონს C მასივი
სადაც თქვენ ინდექსი 0 აქვს გარკვეული მნიშვნელობა, ინდექსი 1 აქვს გარკვეული მნიშვნელობა.
აქ ინდექსების არიან, B, და C და ღირებულებები 1, 2, და 3.
PHP-ში არ არსებობს განსხვავება შორის ასოციაციურ მასივში და მხოლოდ რეგულარული მასივი
როგორც თქვენ ამას ვფიქრობ მას C.
არსებობს მხოლოდ ამ, და ქვეშ the hood რეგულარული მასივი მხოლოდ ასოციაციურ მასივში
სადაც 0 რუკების გარკვეული მნიშვნელობა ისევე რუკების გარკვეული მნიშვნელობა.
ამ მიზეზით, PHP შეიძლება საკმაოდ ცუდი ნამდვილად სწრაფად კოდი / ბენჩმარკინგი რამ
რადგან C, როდესაც თქვენ იყენებთ მასივი თქვენ იცით, რომ წვდომის წევრი არის მუდმივი დრო.
In PHP წვდომის წევრი არის ვინ იცის რამდენ ხანს?
ალბათ მუდმივი თუ ის ჰეშები სწორად.
ვინ იცის, რა ეს ნამდვილად აკეთებს ქვეშ hood?
თქვენ ნამდვილად გესაჭიროებათ შევხედოთ განხორციელების ვნახავთ, როგორ აპირებს გაუმკლავდეთ რომ.
ასე რომ მაშინ fopen.
ვფიქრობ აქ მოდით უბრალოდ PHP სახელმძღვანელო fopen შევხედოთ დაბრუნების ტიპის.
ჩვენ ვხედავთ, აქ თქვენ შეგიძლიათ ეძებოთ საკმაოდ ბევრი ნებისმიერი ფუნქცია PHP სახელმძღვანელო
და ეს არის ერთგვარი კაცს გვერდზე PHP.
დაბრუნება ტიპის იქნება რესურსი.
ამიტომ ჩანდა ეს, რადგან ჩვენ არ ნამდვილად განსაზღვრავს რესურსი.
იდეა რესურსი, დო თქვენ სახის მივიღე ი * ან რასაც;
PHP-ში რესურსი არის თქვენი ფაილი *.
ეს არის ის, რაც თქვენ უნდა კითხულობს საწყისი, ეს არის ის, რაც თქვენ უნდა წერილობით.
ეს, როგორც წესი, გარე, ამიტომ რესურსი შეგიძლიათ დახევის ნივთები და გადაყარეთ რამ.
და ბოლოს, რა არის გაცნობის NULL? >> [სტუდენტი] null.
Yeah. ასე, რომ ერთადერთი, რაც არის NULL არის NULL.
NULL არის NULL.
>> ერთი თვისება PHP-ის ტიპის სისტემით (უკეთესი ან უარესი) არის მისი უნარი juggle ტიპები.
როდესაც ვწერთ ხაზი PHP კოდი, რომელიც აერთიანებს ფასეულობებს სხვადასხვა ტიპის,
PHP შეეცდება გააკეთოს გონივრული რამ.
სცადეთ out ყოველი შემდეგი ხაზი PHP კოდი. რა ამობეჭდილი?
არის თუ არა, რაც თქვენ მოსალოდნელია? რატომ ან რატომ არა?
ეს ფაქტი იმის შესახებ, PHP არის რა ხდის, რაც ჩვენ მოვუწოდებთ სუსტად აკრეფილი.
სუსტად აკრეფილი და კატეგორიულად აკრეფილი,
არსებობს სხვადასხვა მიზნებისათვის შეეხება იმ თვალსაზრისით,
მაგრამ ყველაზე ადამიანი სარგებლობს სუსტად აკრეფილი და კატეგორიულად აკრეფილი ნიშნავს ასეთი რამ
სადაც ("1" + 2); რომ მუშაობს.
In C, რომელიც არ მუშაობს.
თქვენ წარმოიდგინეთ ეს არ მუშაობს.
ბევრი ადამიანი აღრევას დინამიური აკრეფით და სუსტი აკრეფით და სტატიკური აკრეფით და ძლიერი აკრეფით.
პითონი არის კიდევ ერთი მაგალითი იმისა, ენა რომ დინამიურად აკრეფილი.
შეგიძლიათ გადააგდოთ გარშემო ტიპების ცვლადები და ის აპირებს განსაზღვრავს პერსპექტივაში დრო
ნებისმიერი შეცდომა checkings.
In Python ის აპირებს შეასრულოს ეს და ის დაინახავს ("1" + 2);
და ეს ვერ რადგან ის ამბობს თქვენ ვერ შეძლებთ დაამატოთ სიმებიანი და რიცხვი.
PHP-ში, რომელიც, ისევე როგორც დინამიურად აკრეფილი, ეს არ ჩავარდება.
სუსტი აკრეფით უნდა ვუყოთ იმ ფაქტს, რომ ეს ასეა რამ ერთად ტიპის
რომ ნამდვილად არ აქვს აზრი აუცილებლად.
ასე რომ ("1" + 2); მე წარმომიდგენია, რომ სიმებიანი 12, მე წარმომიდგენია იგი სიმებიანი 3,
მე წარმომიდგენია იგი იყო მთელი რიცხვი 3.
ეს აუცილებლად არ ჩამოყალიბებული და ჩვენ ალბათ აპირებს აქ
რომ როდესაც ჩვენ ბეჭდვა ("1" + 2); ალბათ აპირებს დასრულდება მდე მიმდინარეობს სხვადასხვა
ვიდრე ბეჭდვის (1 + "2").
და ეს ტენდენცია რომ იყოს, ჩემი აზრით, ამისთვის უარესი.
აქ ჩვენ შეგვიძლია ვცდილობთ ამ.
კიდევ ერთი პატარა ხრიკი შესახებ PHP არის არ გჭირდებათ რეალურად ჩაწეროს ფაილი.
ეს იმას არ აწარმოებს ამ ბრძანების რეჟიმი.
ასე PHP-ს, მაშინ ჩვენ შეგვიძლია ჩააგდოს ბრძანების აქ:
"ბეჭდვის ('1 '+ 2);" და მე ჩააგდოს ახალი ხაზი.
ეს ნაბეჭდი 3.
როგორც ჩანს ეს ბეჭდავს 3 და ეს რიცხვი 3.
ახლა მოდით შევეცადოთ პირიქით:
"ბეჭდვის (1 + '2 ');
ჩვენ კიდევ 3 და იგი ასევე იქნება მთელი რიცხვი 3? მე ნამდვილად არ ვიცი.
როგორც ჩანს, რომ არის თანმიმდევრული.
არსებობს არასდროს ნებისმიერი მოსალოდნელი იგი იყო სიმებიანი 12 ან არაფერი რომ
რადგან PHP, განსხვავებით JavaScript და ჯავის ძალიან,
აქვს ცალკე ოპერატორი გაერთიანების.
გაერთიანების PHP-ში არის dot.
ამიტომ ბეჭდვის (1. '2 '); აპირებს მოგვცეს 12.
ეს tends უნდა გამოიწვიოს დაბნეულობა სადაც ადამიანები ცდილობენ რაღაც მოსწონს ქ + =
ზოგიერთი სხვა რამ, რომ მათ სურთ დაამატოთ on ბოლომდე მათი სიმებიანი და ეს აპირებს ჩავარდება.
თქვენ გევალებათ ქ. =
ამიტომ, ნუ დაგავიწყდებათ გაერთიანების PHP-ში არის dot.
სხვა რამ ცდილობენ: ბეჭდვა ("CS" + 50);
მე გითხარით, რომ არ არსებობს იმედი ამ შედეგადაც CS50
წლიდან გაერთიანების არ არის +.
რას ფიქრობთ ამ აპირებს დასრულდება მდე მიმდინარეობს?
მე ნამდვილად აქვს აბსოლუტურად წარმოდგენა არ.
როგორც ჩანს ეს მხოლოდ 50.
იგი ხედავს სიმებიანი და მე დადებს თუ ჩვენ დააყენა 123CS -
იგი ხედავს პირველი ტექსტი, იგი ცდილობს წაიკითხა მთელი მისგან ან ნომრის იგი.
ამ შემთხვევაში იგი ხედავს 123CS.
"ეს არ აქვს აზრი, როგორც მთელი რიცხვი, ასე რომ მე უბრალოდ აპირებს ვფიქრობ 123."
ასე რომ 123 + 50 იქნება 173.
და აქ იწყება შორის როგორც მთელი რიცხვი.
იგი ვერაფერს ხედავს, ასე რომ მხოლოდ ეპყრობა, როგორც 0. ასე 0 + 50 იქნება 50.
ეს მე თუ ვთქვათ აპირებს რაიმე მსგავსი.
მე ვფიქრობ 99.
ჰო, რადგან ის აპირებს პირველი -
ასე 99.
აქ (10/7), თუ ამ were C, რა, რომ დაბრუნდეს?
[სტუდენტი] 1. >> Yeah, ეს იქნება 1, რადგან 10/7 არის გამყოფი 2 რიცხვებით.
მთელი რიცხვი იყოფა მთელი რიცხვი დაბრუნებას აპირებს მთელი რიცხვი.
იგი ვერ ბრუნდება 1 ქულა რასაც არ იქნება, ამიტომ უბრალოდ აპირებს დაბრუნებას 1.
აქ ბეჭდვა (10/7); ის აპირებს რეალურად ინტერპრეტაცია რომ.
ეს კი იმას ნიშნავს, რომ თუ თქვენ ნამდვილად გსურთ მთელი დამრგვალება და პერსონალის მოსწონს რომ,
თქვენ გევალებათ ბეჭდვითი (სართული (10/7));
In C ალბათ უცნაური, რომ შეგიძლიათ დაეყრდნოთ რიცხვი truncation რეგულარულად,
მაგრამ PHP ვერ რადგან ეს ავტომატურად ჩართოთ იგი მიმოქცევაში.
და მაშინ (7 + ნამდვილი); როგორ ფიქრობთ რომ აპირებს იყოს?
მე გამოცნობა 8 თუ იგი ხდება ინტერპრეტაცია ჭეშმარიტი როგორც 1.
როგორც ჩანს ეს 8.
>> ასე რომ არაფერი ჩვენ გავაკეთეთ წარსულში 10 წუთში თქვენ უნდა აბსოლუტურად არ ვაკეთებთ.
დაინახავთ კოდი, რომელიც აკეთებს ამას.
იგი არ უნდა იყოს, როგორც პირდაპირი, როგორც ეს.
თქვენ შეიძლება 2 ცვლადები და 1 variable ხდება იყოს სიმებიანი
და სხვა variable ხდება იყოს int, და შემდეგ თქვენ დაამატოთ ეს ცვლადები ერთად.
მას შემდეგ, PHP არის დინამიურად აკრეფილი და იგი ამას არ გააკეთებს ნებისმიერი ტიპის მოსინჯვის თქვენ
და რადგან სუსტად აკრეფილი და რადგან ის მხოლოდ ავტომატურად გადაყარეთ ეს ყველაფერი ერთად
და ყველაფერი მხოლოდ მუშაობს, ძნელია კი იცის, რომ ეს variable უნდა იყოს სიმებიანი ახლა,
ასე რომ მე არ უნდა დაამატოთ ეს ამ ცვლადი, რომელიც არის მთელი რიცხვი.
საუკეთესო პრაქტიკა თუ ცვლადი ტექსტი, შეინახოს იგი როგორც სიმებიანი სამუდამოდ.
თუ ცვლადი int, შეინახოს იგი როგორც int სამუდამოდ.
თუ გსურთ გაუმკლავდეთ რიცხვებით და სიმები,
თქვენ შეგიძლიათ გამოიყენოთ varsint - რომ JavaScript.
Intval. მე ამის გაკეთება ყველა დროის. PHP და JavaScript მე აღრევას ყველაფერი.
ამიტომ intval დაბრუნებას აპირებს რაც მთელი რიცხვი მიაღწევს ღირებულება ცვლადში.
თუ ჩვენ კორიდორი "ბეჭდვის (intval ('123 ')); თქვენ 123.
Intval თავად არ აპირებს გამშვები ჩვენთვის, რომ მხოლოდ მთელი რიცხვი.
, PHP მექანიკური, არსებობს მხოლოდ ამდენი ფუნქციები ხელმისაწვდომია,
ამიტომ აქ მე ვფიქრობ რა მინდა გამოყენება is_numeric პირველი.
მე გამოცნობა რომ დაბრუნდა ყალბი.
სწორედ სხვა რამ გვაქვს გასავლელი მეტი არის ===.
ამიტომ is_numeric ('123df '), თქვენ არ ვფიქრობ, რომ როგორც is_numeric.
In C თქვენ უნდა iterate ყველა გმირები
და შეამოწმეთ, რომ თითოეული ხასიათი არის ციფრი ან რასაც.
აქ is_numeric გაკეთებას აპირებს, რომ ჩვენთვის,
და ეს დაბრუნების ცრუ.
ასე რომ, როდესაც მე დაბეჭდილი, რომ იგი ნაბეჭდი არაფერი, ასე რომ აქ ვარ შედარებით მას ვხედავთ,
did თქვენ მოხდეს იქნება ყალბი? და ა.შ. ახლა კი ბეჭდვა 1.
როგორც ირკვევა ბეჭდავს 1 როგორც ჭეშმარიტი ნაცვლად ბეჭდვა ჭეშმარიტი როგორც ჭეშმარიტი.
მაინტერესებს, თუ print_r. არა, ეს ჯერ კიდევ 1.
>> ბრუნდება ===, == ისევ არსებობს,
და თუ გაიგო Tommy მაშინ ამბობენ == სრულიად ჯარიმა.
მე ვაპირებ ვთქვა, რომ == არის საშინელი და თქვენ არასდროს არ უნდა გამოიყენოს ==.
განსხვავება ისაა, რომ == ადარებს რამ
სადაც მას შეუძლია იყოს ჭეშმარიტი მაშინაც კი, თუ ისინი არ არის იგივე ტიპის,
ხოლო === ადარებს რამ და პირველი ის ამოწმებს არიან ისინი იმავე ტიპის?
დიახ. Okay, ახლა მე ვაპირებ თუ ისინი რეალურად შედარებით იყოს თანაბარი.
თქვენ მიიღებთ უცნაური რამ, როგორიცაა 10 შეადგენს - ვნახოთ რა, რომ ამბობს.
ასე რომ ('10 '== '1 E1');
ეს დააბრუნებს true.
ვინმეს აქვს რაიმე მიხვდება რატომ ბრუნდება მართალია?
ეს არ არის მხოლოდ შესახებ, რომ. იქნებ ეს არის მინიშნება.
მაგრამ თუ შევცვალო რომ ვ - darn ეს! მე შენარჩუნება გამოყენებით ორმაგი შეთავაზებები.
ამის მიზეზი ორმაგი ფასები yelling at me არის, რადგან მე დააყენა ამ ორმაგ ბრჭყალებში.
ასე რომ, მე კი გაქცევა მოახერხეს ორმაგი შეთავაზებები აქ, მაგრამ მარტოხელა შეთავაზებები გაუადვილოს.
ასე რომ ('10 '== '1 F1'); არ ბეჭდვა ჭეშმარიტი. ('10 '== '1 E1'); ბეჭდავს ჭეშმარიტი.
[სტუდენტი] ეს hex? >> ეს არ hex, მაგრამ ახლოს რომ მოსწონს -
1e1, სამეცნიერო ნოტაცია.
იგი აღიარებს 1e1 როგორც 1 * 10 ^ 1 ან რასაც.
იმ თანაბარი რიცხვებით.
თუ ასე === მაშინ იქნება ყალბი.
მე რეალურად არ ვიცი, თუ რა == შესახებ (10 და '10abc '); ყველა უფლება. ასე რომ მართალია.
ასე რომ ისევე როგორც მაშინ, როდესაც თქვენ გააკეთეთ (10 + '10abc '); და იქნებოდა 20,
აქ (10 == '10abc '); მართალია.
კიდევ უფრო უარესი არიან რამ, როგორიცაა (ყალბი == NULL); მართალია
ან (ყალბი == 0); მართალია, (ყალბი == []);
არსებობს უცნაური შემთხვევები - ეს ერთი იმ უცნაური შემთხვევები.
გაითვალისწინეთ, რომ (ყალბი == []); მართალია.
('0 '== ყალბი); მართალია.
('0 '== []); სიცრუეა.
ასე == არ არის გარდამავალი.
შეიძლება იყოს ტოლი ბ და შეიძლება იყოს ტოლი გ,
მაგრამ ბ შეიძლება არ იყოს ტოლი გ.
სწორედ უმსგავსოება ჩემთვის, და თქვენ ყოველთვის უნდა გამოიყენოს ===.
[სტუდენტი] გავაკეთოთ? == ისევე? >> [Bowden] დიახ.
ეკვივალენტი იქნება! = და, ==.
ეს ფაქტობრივად აღიზარდოს ამ pset Spec
აქ ბევრი ფუნქციები დაბრუნების -
, PHP სახელმძღვანელო არის კარგი ამის შესახებ.
იგი აყენებს დიდ წითელ ყუთში, "ეს დაბრუნდება ცრუ თუ არა რაიმე შეცდომა."
მაგრამ დაბრუნების 0 არის შესანიშნავად გონივრული რამ დაბრუნებას.
იფიქრეთ რაიმე ფუნქცია, რომელიც მოსალოდნელია დაბრუნების რიცხვი.
ვთქვათ ეს ფუნქცია უნდა ქონოდა რაოდენობის ხაზები ფაილი ან რამე.
ნორმალურ პირობებში, თქვენ გაივლით ამ ფუნქციის ფაილი
და ის აპირებს დაბრუნებას მთელი რიცხვი რომელიც წარმოადგენს რიცხვი ხაზები.
ასე რომ 0 არის შესანიშნავად გონივრული რაოდენობის თუ ფაილი არის მხოლოდ ცარიელი.
მაგრამ რა, თუ თქვენ მსგავ ფაილის მცდარი და ფუნქცია ხდება დაბრუნების ცრუ
თუ გაიაროს ეს არასწორი ფაილი?
თუ თქვენ უბრალოდ == თქვენ არ გამიჯვნის შემთხვევაში შორის ფაილის მცდარი და ცარიელი ფაილი.
ყოველთვის გამოიყენეთ ===.
ეს იყო იმ.
>> PHP-ში, მასივის ტიპის განსხვავდება თუ რას გამოიყენება in C.
მართლაც, თქვენ შეიძლება უკვე შენიშნა ეს ზემოთ, როდესაც თქვენ ხედავთ, რომ ეს არის ტიპის მასივი.
The bracket სინტაქსი არის ახალი როგორც PHP 5.4, რომელიც არის უახლესი ვერსია PHP.
მანამდე კი თქვენ ყოველთვის ჰქონდა დაწერა array ('' -> 1, "ბ" -> 2.
ეს იყო მშენებელი for მასივი.
არის PHP საბოლოოდ მოდის გარშემო ლამაზი სინტაქსის მხოლოდ კვადრატულ ფრჩხილებში,
რაც არის ბევრად უკეთესი, ვიდრე მასივი.
მაგრამ იმის გათვალისწინებით, PHP 5.4 არის უახლესი ვერსია,
თქვენ შეიძლება ექმნებათ ადგილებში, სადაც კი არ PHP 5.3.
Over ზაფხულში ჩვენ შეუვარდნენ ამ საკითხზე, სადაც PHP 5.3 იყო ის, რაც ჩვენ გვქონდა on ელექტრო მოწყობილობების,
მაგრამ სერვერზე რომ ჩვენ განლაგებული ყველა ჩვენი კლასის წიგნი და წარმოადგინოს და ყველა რომ პერსონალის to
იყო PHP 5.4.
არ იცოდა, ჩვენ განვითარებული 5.3, აიძულა to 5.4,
და ახლა უეცრად არა ჩვენი კოდი მუშაობს
რადგან იქ მოხდა უკვე ცვლილებების შორის 5.3 და 5.4
რომლებიც არ არიან უკან თავსებადი,
და ჩვენ უნდა წავიდეთ და დაფიქსირება ყველა ჩვენი რამ, რომ არ მუშაობენ PHP 5.4.
ამისთვის ამ კლასში, რადგან ელექტრო აქვს PHP 5.4,
ეს შესანიშნავად ჯარიმა გამოიყენოს კვადრატულ ფრჩხილებში.
მაგრამ თუ თქვენ ეძებთ up რამ გარშემო ინტერნეტი,
თუ თქვენ ეძებთ გარკვეული სახის მასივი პერსონალის, როგორც ჩანს, ვაპირებთ ვხედავ
სიტყვიერად მასივი მშენებელი სინტაქსის მას შემდეგ უკვე გარშემო წლიდან PHP დაიბადა
და კვადრატული ფრჩხილი სინტაქსის უკვე გარშემო, უკანასკნელი რამდენიმე თვის განმავლობაში
ან როცა 5.4 მოვიდა გარშემო.
ეს არის, თუ როგორ ინდექსი.
ისევე, C, როგორ ინდექსი მიერ კვადრატულ ფრჩხილებში მსგავსად $ array [0] $ array [1], $ array [2],
თქვენ ინდექსი ანალოგიურად, თუ მოხდება თქვენი მაჩვენებლების მყოფი სტრიქონები.
ასე რომ $ array [''] და $ array ['B'].
$ Array [B]. რატომ უნდა იყოს ეს მიზეზი?
ეს ალბათ გენერირება გაფრთხილება, მაგრამ მაინც გვემსახურება. PHP tends გაგვაჩნია.
იგი აპირებს უბრალოდ, "მე ვაპირებ გაფრთხილებთ ამაში, მაგრამ მე უბრალოდ აპირებს შეინარჩუნოს აპირებს
"და ნუ რასაც შემიძლია."
ეს ალბათ თარგმნოს ეს ტექსტი,
მაგრამ შესაძლებელია, რომ რაღაც მომენტში წარსულში ვინმე ამბობს
განისაზღვროს B იქნება "Hello World".
ახლა B შეიძლება იყოს მუდმივი და $ array [b] რეალურად უნდა აკეთებს "Hello World".
ვფიქრობ, ამ ეტაპზე, ან თუნდაც ჩვენი PHP პარამეტრების,
თუ თქვენ ცდილობენ ინდექსი შევიდა array და რომ გასაღები არ არსებობს, ამას ვერ.
მე არ ვფიქრობ, ეს იქნება მხოლოდ გაფრთხილებთ.
ან მინიმუმ შეგიძლიათ დააყენეთ ისე, რომ ეს სულაც არ არის მხოლოდ გაფრთხილებთ, ეს მხოლოდ სწორი მდე ვერ.
>> გზა თქვენ შეამოწმეთ თუ რეალურად არის ასეთი ინდექსი არის isset.
ამიტომ isset ($ array ['Hello World']) დაბრუნდება ცრუ.
isset ($ array ['B']) დაბრუნდება ნამდვილი.
თქვენ შეგიძლიათ ავურიოთ ამ syntaxes.
მე საკმაოდ დარწმუნებული რა ამ მასივი რომ დასრულდება მდე მიმდინარეობს არის - ჩვენ შეგვიძლია შევამოწმოთ იგი out.
ოჰ, მე უნდა PHPWord.
ეს არის შერევას სინტაქსის სადაც თქვენ დააკონკრეტა, თუ რა არის გასაღები
და თქვენ არ დააკონკრეტა, თუ რა არის გასაღები.
ასე 3 უფლება აქ არის ღირებულება.
თქვენ არ არის მკაფიოდ განაცხადა რა თავისი გასაღები იქნება.
როგორ ფიქრობთ მის გასაღები აპირებს იყოს?
[სტუდენტი] 0. >> მე გამოცნობა 0 მხოლოდ იმიტომ რომ პირველი ჩვენ არ არის მითითებული.
ჩვენ შეგვიძლია მართლაც რამდენიმე ასეთ შემთხვევებში.
ამიტომ print_r არის ბეჭდვის რეკურსიული. ეს იქნება ბეჭდვა მთელი მასივი.
ეს იქნებოდა ბეჭდვა subarrays of array თუ იყო რაიმე.
ამიტომ print_r ($ array); php.test.php.
ეს იმას ჰგავს ეს მისცა 0.
არსებობს რეალურად რაღაც გვახსოვდეს, მაგრამ ჩვენ დავუბრუნდეთ მას მეორე.
მაგრამ რა მოხდება თუ მე მოხდეს, რათა ეს მაჩვენებელი 1?
PHP არ განსხვავდება ერთმანეთისგან სიმებიანი მაჩვენებლების და მთელი ინდექსები,
ამრიგად, ამ ეტაპზე მე მხოლოდ განსაზღვრული ინდექსი 1 და შემიძლია ორივე $ array [1] და $ array ['1 ']
და ეს იქნება ანალოგიური მაჩვენებელი და იგივე გასაღები.
ახლა როგორ ფიქრობთ 3 აპირებს იყოს? >> [სტუდენტი] 2. >> [Bowden] მე გამოცნობა 2.
Yeah. ეს 2.
რა მოხდება, თუ ეს გავაკეთეთ არის 10, ეს არის 4? როგორ ფიქრობთ მაჩვენებელი 3 აპირებს იყოს?
მე ვფიქრობ 11.
ჩემი ამოიცნობთ, როგორი PHP აკეთებს - და ვფიქრობ მე ვნახე ამ ადრე -
იგი მხოლოდ ინახება რა უმაღლესი რიცხვითი ინდექსის ის გამოიყენება იმდენად, რამდენადაც არის.
არასდროს აპირებს დაავალოს სიმებიანი ინდექსი დან 3. ეს ყოველთვის იქნება რიცხვითი ინდექსი.
ასე რომ ინახება უმაღლესი ერთი ის ენიჭება ჯერჯერობით, რომელიც ხდება უნდა იყოს 10,
და ის აპირებს 11 დან 3.
რა ვთქვი, შეამჩნია გზა იგი ბეჭდვა ამ მასივი.
იგი ბეჭდავს გასაღები 10, გასაღები 4, გასაღები 11, გასაღები დ.
ან თუნდაც მოდით -
ვფიქრობ მე არ დააყენოს 0, მაგრამ ბეჭდვა 1, 2, 3, 4.
რა მოხდება თუ მე გადართოთ აქ? ან მოდით რეალურად გადართოთ ეს 2.
ახლა კი ბეჭდავს 2, 1, 3, 4.
PHP-ს კოლექტორები არ არიან, ისევე, როგორც თქვენი რეგულარული hash მაგიდასთან.
ეს შესანიშნავად გონივრული ვიფიქროთ, მათ hash მაგიდები 99% დაფიქსირდა.
მაგრამ თქვენს hash მაგიდები არ გრძნობა წესრიგზე, რომლის ნივთები ჩასმული.
ამიტომ, როგორც კი თქვენ ჩადეთ იგი თქვენი hash მაგიდა,
ვივარაუდოთ, არ უკავშირდება სიაში და შეგიძლიათ იმსჯელოთ ფარგლებში უკავშირდება სია
რომელიც ჩასმული პირველი.
მაგრამ აქ ჩვენ ჩასმული 2 პირველი და იგი დარწმუნებულია, როცა ეს დაბეჭდვისას მასივისათვის რომ 2 მოდის პირველი.
იგი არ ამობეჭდოთ მხოლოდ გარეშე.
ტექნიკური მონაცემები სტრუქტურის, რომ ის გამოყენებით არის უბრძანა რუკა,
ასე რომ რუკები გასაღებები ღირებულებებს და მას ახსოვს წესრიგზე, რომლის იმ გასაღებები were ჩასმული.
ძირითადად ეს ზოგიერთ გართულებები, სადაც ეს შემაშფოთებელი რეალურად -
ვთქვათ თქვენ გაქვთ მასივი 0, 1, 2, 3, 4, 5
და გსურთ აიღოს ინდექსი 2.
ერთი გზა ამის გაკეთება, ვნახოთ რა, რომ ჰგავს.
0, 2, 1, 3, 4.
ამორთვისთვის ხდება ამორთვისთვის ორივე ცვლადები და array ინდექსების.
ამიტომ ამორთვისთვის ($ array [2]);
ახლა რა არის ეს აპირებს გამოიყურებოდეს მოგწონთ? 2 მხოლოდ წასული, ასე რომ შესანიშნავად ჯარიმა.
სხვა შემაშფოთებელი არის თუ გინდათ რამ რეალურად იყოს მასივი.
მე დააყენა შემთხვევითი რიცხვების.
ახლა შეამჩნია ჩემი მაჩვენებლების.
მინდა მას უბრალოდ იყოს C მასივი, სადაც იგი მიემართება 0 სიგრძე - 1
და შემიძლია iterate მას, როგორც ასეთი.
მაგრამ როგორც კი ამორთვისთვის მეორე ინდექსი, რა იყო ინდექსი 3 არ არის გახდეს ინდექსი 2.
ამის ნაცვლად უბრალოდ შლის, რომ ინდექსი და ახლა მიდიხარ 0, 1, 3, 4.
ეს არის იდეალურად გონივრული.
უბრალოდ შემაშფოთებელი და თქვენ უნდა გააკეთოთ რამ, როგორიცაა მასივი splice. Yeah.
>> [სტუდენტი] რა მოხდება, თითქოს ამისთვის loop
და თქვენ უნდოდა ყველა ელემენტები?
როდესაც იგი მოხვდა 2, რომ ეს გამოიღო ოდესმე?
Iterating მეტი მასივი. 2 გზა არსებოსბს თქვენ შეგიძლიათ ეს გააკეთოთ.
თქვენ შეგიძლიათ გამოიყენოთ რეგულარული ამისთვის loop.
ეს არის კიდევ ერთი intricacy of PHP.
ყველაზე ენებზე, მე ვიტყოდი, აქვს გარკვეული სიგრძის ან len ან რამე
მითითებით სიგრძეზე მასივი.
PHP-ში ეს რაოდენობა.
ასე რომ ჯამში ($ array); $ i + +)
მოდით უბრალოდ ბეჭდვის ($ array [$ i]);
Notice: Undefined offset: 2.
უბრალოდ აპირებს ჩავარდება.
ეს არის მიზეზი, რომ დიდი ნაწილი, თქვენ არასოდეს უნდა iterate მეტი მასივი მოსწონს ეს.
ეს შეიძლება იყოს გადაჭარბებული, მაგრამ თქვენ არასოდეს უნდა iterate მეტი მასივი მოსწონს
რადგან PHP უზრუნველყოფს მის foreach სინტაქსი აქ foreach ($ წყობის $ პუნქტში).
ახლა თუ ჩვენ ბეჭდვა ($ item); - we'll განიხილოს იგი მეორე - რომ მუშაობს შესანიშნავად ჯარიმა.
ისე, რომ foreach მუშაობს არის პირველი არგუმენტი არის array, რომ თქვენ iterating დასრულდა.
და მეორე არგუმენტი, ნივთი, მეშვეობით თითოეულ უღელტეხილზე ამისთვის loop
ის აპირებს მომდევნო რამ მასივი. ასე გვახსოვს მასივი აქვს წესრიგს.
პირველად მეშვეობით ამისთვის მარყუჟის, item იქნება 123
მაშინ ეს იქნება 12 მაშინ ეს იქნება 13 მაშინ ეს იქნება 23 მაშინ ეს იქნება 213.
რამ მისაღებად ნამდვილად უცნაური როცა რაღაც foreach.
ვნახოთ რა ხდება იმიტომ, რომ თქვენ არასოდეს არ უნდა ამის გაკეთება.
რა მოხდება, თუ ჩვენ ამორთვისთვის ($ array [1]);
ამის ალბათ მოსალოდნელია.
თქვენ iterating ამ მასივი, და ყოველ ჯერზე თქვენ unsetting პირველი ინდექსი.
ასე რომ ინდექსი 0, პირველი, რაც, item იღებს ღირებულების 0, ამიტომ იქნება 123.
მაგრამ შიგნით ამისთვის loop ჩვენ ამორთვისთვის ინდექსი 1, ასე რომ იმას ნიშნავს, 12 გაქრა.
ამიტომ ბეჭდვა. PHP_EOL.
PHP_EOL მხოლოდ სტრიქონების გადატანით, მაგრამ ეს ტექნიკურად უფრო პორტატული
რადგან newlines in Windows განსხვავდება newlines on Mac და UNIX.
On Windows სტრიქონების გადატანით არის \ r \ n, ხოლო ყველგან მას tends უბრალოდ უნდა იყოს \ n.
PHP_EOL არის კონფიგურირებული ისე, რომ იგი იყენებს რასაც სტრიქონების გადატანით თქვენი სისტემა.
ასე რომ ბეჭდვა. ნუ print_r ($ array) დასასრულისათვის.
არ მქონდა იდეა, რომ ეს იქნება ქცევა.
საქონელი კვლავ იღებს ღირებულება 12 მიუხედავად იმისა, რომ ჩვენ ამორთვისთვის 12 სანამ ჩვენ ოდესმე მიიღო, რათა მას მასივი.
არ მიიღოს სიტყვას ამ, მაგრამ ეს ჰგავს foreach ქმნის ასლი მასივი
და შემდეგ პუნქტში იღებს ყველა ღირებულებებს რომ ასლი.
ასე რომ, თუნდაც ცვლილებები მასივი შიგნით ამისთვის მარყუჟის,
ეს არ აღელვებს. საქონელი მიიღებს on ორიგინალური ღირებულებებს.
მოდით ვეცადოთ unsetting იგი.
რა მოხდება, თუ ეს $ array [1] = "Hello";
მიუხედავად იმისა, რომ ჩვენ "Hello" შევიდა მასივი, item არასოდეს იღებს, რომ ღირებულება.
არსებობს კიდევ ერთი სინტაქსი უნდა foreach მარყუჟების
სადაც თქვენ დააყენა 2 ცვლადები გამოყოფილი arrow.
ეს პირველი ცვლადი იქნება გასაღები, რომ ღირებულება,
და ეს მეორე ცვლადი იქნება იგივე ზუსტი ნივთი.
ეს არის uninteresting აქ, მაგრამ თუ ჩვენ დავუბრუნდებით ჩვენი ორიგინალური შემთხვევაში '' -> 1,
"ბ" -> 1,
აქ თუ ჩვენ მხოლოდ iterate თითოეული წყობის პუნქტის, ნივთი იქნება 1 ყველა დროის.
მაგრამ თუ ჩვენ ასევე გვინდა ვიცოდეთ გასაღები ასოცირდება, რომ ნივთი
შემდეგ ვაკეთებთ, როგორც $ გასაღები -> $ ნივთი.
ახლა ჩვენ შეგვიძლია გავაკეთოთ ბეჭდვითი ($ გასაღები. ':'.
ახლა კი iterating მეტი და დაბეჭდვის თითოეული გასაღები და მისი ასოცირდება ღირებულება.
>> დამატებითი რამ შეგვიძლია გავაკეთოთ foreach მარყუჟების არის თქვენ შეიძლება ნახოთ ამ სინტაქსს.
Ampersands ადრე ცვლადი სახელები ტენდენცია იყოს როგორ PHP ს ცნობას.
სად ცნობას ძალიან ჰგავს პოინტერები,
თქვენ არ გჭირდებათ, ასე რომ თქვენ არასოდეს გაუმკლავდეთ მეხსიერების პირდაპირ.
მაგრამ თუ თქვენ ჩვენგან აქვს რეკომენდაციები ვისგანაც 1 ცვლადი ეხება იგივე მორიგ ცვლადი.
შიგნით აქ მოდით $ ნივთი. მოდით დავუბრუნდეთ 1, 10.
მოდით $ ნივთი + +, რომ ჯერ კიდევ არსებობს PHP. შეგიძლიათ ისევ გავაკეთებთ + +.
php.test.php. მე უნდა დაბეჭდეთ. print_r ($ array);
ჩვენ ბეჭდვა 2, 11.
თუ ვიყავი გაკეთდეს foreach ($ წყობის $ ნივთი), მაშინ ნივთი იქნება ღირებულება 1
პირველად მეშვეობით loop. ეს იქნება ნამატი 1 დან 2 და შემდეგ ჩვენ გავაკეთეთ.
ასე რომ მაშინ გაივლის მეორე უღელტეხილზე მარყუჟის და რომ საქონელი 10.
ეს increments ელემენტის 11, და შემდეგ ეს მხოლოდ დააგდეს დაშორებით.
მაშინ ჩვენ print_r ($ array); და ვნახოთ, რომ ეს არის მხოლოდ 1, 10.
ამიტომ ნამატი გავაკეთეთ დაიკარგა.
მაგრამ foreach ($ წყობის & $ item)
ახლა ეს საქონელი იმავე საგანს როგორც ამ უფლების აქ. ეს იგივე.
ასე რომ $ ნივთი + + არის შეცვლის მასივი 0.
ძირითადად, ასევე, შეგიძლიათ ამის გაკეთება $ K -> $ ნივთი და შეგიძლიათ გააკეთოთ $ array [$ K] + +;
>> ასე რომ სხვა გზა კეთების რომ, ჩვენ თავისუფლად ცვლილებები პუნქტის,
მაგრამ, რომ არ ცვლილებები ჩვენი ორიგინალური მასივი.
მაგრამ თუ ჩვენ ვიყენებთ K, რომელიც ჩვენი გასაღები, მაშინ ჩვენ შეგვიძლია მხოლოდ ინდექსი ჩვენს მასივი გამოყენებით რომ გასაღები
და წუთობრივი რომ.
ეს უფრო პირდაპირ modifies ჩვენი ორიგინალური მასივი.
თქვენ კი ასე თუ რაიმე მიზეზით თქვენ სურდა უნარი ცვლილებები -
სინამდვილეში, ეს სრულიად სამართლიანია.
თქვენ არ სურს უნდა დაწეროს $ array [$ K] + +,
უბრალოდ სურდა დაეწერა $ ნივთი + +, მაგრამ თქვენ ისევ უნდოდა იმის თქმა, თუ ($ K === '')
მაშინ ნამატი ნივთი და შემდეგ ბეჭდვა ჩვენი მასივი.
ახლა რას ველოდოთ print_r ვაკეთოთ? რა ღირებულებებს უნდა იყოს დაბეჭდილი?
[სტუდენტი] 2 და 10. >> [Bowden] თუ გასაღები იყო '' ჩვენ რეალურად ბეჭდვა რომ.
>> ალბათ ძალიან იშვიათად, თუ ოდესმე, უნდა განისაზღვროს ფუნქციების PHP,
მაგრამ თქვენ ალბათ შეამჩნევთ რაიმე მსგავსი, სადაც თქვენ განსაზღვროს ფუნქცია მოსწონს ფუნქცია რასაც.
ჩვეულებრივ თქვენ ვიტყოდი ($ foo, $ ბარი) და შემდეგ განსაზღვრავს, რომ იყოს რასაც.
მაგრამ, თუ ეს, მაშინ ეს ნიშნავს, რომ რაც არ უნდა უწოდებს რასაც,
რასაც მოუწოდებს baz, ამიტომ პირველი არგუმენტი გადასცა baz შეიძლება შეიცვალოს.
მოდით $ foo + +;
და შიგნით აქ მოდით baz ($ item);
ახლა ჩვენ მოუწოდებენ ფუნქცია.
არგუმენტი იღებს მინიშნება, რაც იმას ნიშნავს, რომ თუ ჩვენ ცვლილებები მას
ჩვენ შეცვლის, რაც მიღებულ იქნა შემოსული
და ბეჭდვა ამ ველოდოთ - სანამ არ არევა სინტაქსი - მივიღეთ 2, 11,
ასე რომ რეალურად incremented.
Notice გვჭირდება წყარო 2 ადგილებში.
რა მე რომ ამ საკითხთან დაკავშირებით? რას ნიშნავს ეს?
[სტუდენტი] ეს შეიცვლება. >> Yeah.
საქონელი არის მხოლოდ ასლი ღირებულების მასივი.
ასე რომ ნივთი შეიცვლება 2, მაგრამ array [''] მაინც 1.
ან რა რომ ამის გაკეთება?
არის ნივთი იგზავნება როგორც ასლი baz.
ამიტომ ასლი არგუმენტი იქნება incremented 2,
მაგრამ ნივთი თავისთავად არასოდეს incremented დან 2.
და საქონელი იგივე როგორც მასივი bracket რასაც,
ასე რომ მასივი არასოდეს incremented.
ასე რომ ორივე იმ ადგილებში სჭირდება.
>> PHP ჩვეულებრივ საკმაოდ ჭკვიანი ამის შესახებ.
თქვენ ალბათ ფიქრობთ, მინდა გაივლის მიერ მინიშნება -
ეს იყო რეალურად საკითხი ერთ psets.
ეს იყო questions.txt რამ, სადაც იგი ამბობს,
რატომ შეიძლება გსურთ გაივლის ამ struct მიერ მინიშნება?
რა იყო პასუხი ამაზე?
[სტუდენტი] ასე რომ თქვენ არ უნდა კოპირება რაღაც დიდი. >> Yeah.
Struct შეიძლება თვითნებურად დიდი, და როდესაც თქვენ გაივლით struct როგორც არგუმენტი
მას სჭირდება კოპირება რომ მთელი struct გავლა მას ფუნქცია,
ხოლო თუ თქვენ უბრალოდ გაივლის struct მიერ მინიშნება
მაშინ უბრალოდ სჭირდება კოპირება 4-byte მისამართი როგორც არგუმენტი ფუნქცია.
PHP არის ცოტა სასურველი სტუმარი გახდებით ვიდრე ამას.
თუ მაქვს ზოგიერთი ფუნქცია და მე გაივლის მას მასივი 1,000 ნივთები,
ნიშნავს ეს ის აპირებს კოპირება ყველა 1,000 იმ რამ
უნდა გაიაროს ეს შევიდა ფუნქცია? ეს არ უნდა გავაკეთოთ, რომ დაუყოვნებლივ.
თუ შიგნით ამ ფუნქციის მას არასოდეს რეალურად modifies foo,
ასე რომ, თუ ($ foo === 'მიესალმები') იქნება TRUE.;
გაითვალისწინეთ ჩვენ არასოდეს რეალურად შეცვლილია არგუმენტი შიგნით ამ ფუნქციას,
რაც იმას ნიშნავს, რომ რაც მიღებულ იქნა საქართველოს, როგორც არასდროს foo საჭიროებს გადაწერილი
რადგან ეს არ შეცვლის მას.
ასე რომ გზა PHP სამუშაოების არგუმენტები ყოველთვის გაიარა მინიშნება
სანამ თქვენ ნამდვილად ცდილობენ ცვლილებები მას.
ახლა თუ ვიტყვი $ foo + +, ეს ახლა მიიღოს ასლი ორიგინალური foo და ცვლილებები ასლი.
ეს ზოგავს გარკვეული დრო.
თუ თქვენ არასდროს არ ეხება ამ მასიური მასივი, არასოდეს რეალურად ცვლილებები ის,
მას არ დასჭირდება, რათა ასლი,
ხოლო თუ ჩვენ უბრალოდ დააყენა ამ ampersand რაც იმას ნიშნავს, რომ ეს კი არ კოპირება
მაშინაც კი, თუ თქვენ ჩვენგან ცვლილებები მას.
ეს ქცევა ეწოდება ასლი-on-ჩაწერის.
თქვენ ნახავთ მას სხვა ადგილებში, მით უფრო ოპერაციული სისტემის რა თქმა უნდა.
Copy-on-ჩაწერის არის საკმაოდ ჩვეულებრივი ნიმუში სადაც თქვენ არ უნდა მიიღოს ასლი რაღაც
თუ ეს სინამდვილეში იცვლება. Yeah.
[სტუდენტი] რა თუ ჰქონდა ნამატი შიგნით ტესტი,
ასე მხოლოდ 1 ელემენტს გარეთ 1,000 იქნებოდა საჭიროებს შეიცვალა?
მე არ ვარ დარწმუნებული.
მე ვფიქრობ, რომ კოპირება მთელი რამ, მაგრამ ეს შესაძლებელია ეს ჭკვიანი საკმარისი, რომ -
სინამდვილეში, რა მე ვფიქრობ არის წარმოიდგინეთ გვქონდა მასივი, რომ ასე გამოიყურება: $ array2 = [
მაშინ ინდექსი '' არის მასივი [1 2 3 4], და ინდექსი "ბ" არის მასივი რასაც.
მჭირდება მძიმეები შორის ყველა იმ. წარმოიდგინეთ არსებობს მძიმეები.
მაშინ 'c' არის ღირებულება 3.
Okay.
ახლა ვთქვათ ვაკეთებთ $ baz ($ array2);
აქ baz არ იღებს ამ მიერ მითითება.
ასე რომ $ foo ['გ'] + +;
ეს არის ასეთი მაგალითი, სადაც ჩვენ გადიან array2 როგორც არგუმენტი
და მაშინ შეცვლის კონკრეტული მაჩვენებელი მასივი მიერ დამატება იგი.
მე ნამდვილად არ ვიცი რა PHP გაკეთებას აპირებს.
ეს შეიძლება ადვილად ასლი მთელი რამ, მაგრამ თუ ეს ჭკვიანი,
ის გააკეთებს ასლი ამ გასაღებები, სადაც ეს ექნება თავისი განსხვავებული ღირებულება
მაგრამ ეს ჯერ კიდევ აღვნიშნო, რომ იგივე მასივი 1,2,3,4
და ეს შეიძლება კვლავ აღვნიშნავთ, რომ იგივე მასივი.
მე iPad იგი.
ჩვენ გაივლის ამ მასივი, სადაც ეს ბიჭი ქულა 3, ამ ბიჭს მიუთითებს [1,2,3,4],
ამ ბიჭს მიუთითებს [34, ...]
არის, რომ ჩვენ ავლით მას უნდა baz, ჩვენ შეცვლის ამ.
თუ PHP არის ჭკვიანი, მას შეუძლია უბრალოდ -
ჩვენ ჯერ კიდევ კოპირება გარკვეული მეხსიერება, მაგრამ თუ იყო ამ დიდი წყობილი subarrays
ჩვენ არ გვჭირდება კოპირება იმ.
მე არ ვიცი, თუ არის ის, რაც ეს ასეა, მაგრამ მე წარმომიდგენია ეს აკეთებს, რომ.
ეს არის ასევე საკმაოდ დიდი უპირატესობა C ზე PHP.
>> PHP ხდის ცხოვრება იმდენად ადვილი ბევრი რამ,
მაგრამ თქვენ სახის აბსოლუტურად წარმოდგენა არ რამდენად კარგად ეს შეასრულებს
რადგან არ ვიცი ქვეშ Hood როცა ეს მიღების ეს ასლები რამ,
OH, რომ იქნება მუდმივი დრო ასლი,
არის უბრალოდ შეიცვლება 1 კურსორი, იგი იქნება ridiculously რთული ხაზოვანი ასლი?
მერე რა, რომ ვერ პოულობენ მოცულობა?
ამჯამად მაშინ უნდა აწარმოებს ნაგვის შეგროვების მივიღოთ მეტი სივრცე?
და ნაგვის შეგროვების შეუძლია თვითნებურად ხანგრძლივი.
In C თქვენ არ ფიქრი ეს ყველაფერი.
თითოეული ხაზი წერთ თქვენ შეგიძლიათ საკმაოდ ბევრი მიზეზი, თუ როგორ ის აპირებს შეასრულოს.
>> მოდით ვიხსენებთ ამ.
როგორ ლამაზი არის ის, რომ თქვენ არ უნდა გაუმკლავდეთ hash ფუნქციები,
უკავშირდება სიები, ან არაფერი ასე?
წლიდან მუშაობს hash მაგიდები არის ადვილი არის, აქ არის სახალისო თავსატეხი მუშაობა.
გახსენით ფაილი სახელად unique.php და მასში წერენ PHP პროგრამა
(ასევე ცნობილი როგორც "Script").
ჩვენ გვსურს წავახალისოთ მოვუწოდებთ მათ სკრიპტები თუ ისინი მოკლე რამ, რომ თქვენ აწარმოებს ბრძანებათა ზოლს.
ძირითადად, ნებისმიერ ენაზე, რომ თქვენ არ კომპილირდება მაგრამ თქვენ აპირებთ აწარმოებს შესრულებადი
ბრძანებათა ზოლს, შეგიძლიათ დარეკოთ, რომ შესრულებადი Script.
შემეძლო მხოლოდ ასევე წერენ C პროგრამა, რომელიც აკეთებს ამას,
მაგრამ მე არ ეძახით Script რადგან მე პირველი კომპილირება და შემდეგ აწარმოებს ორობითი.
მაგრამ ეს პროგრამა PHP ჩვენ ვაპირებთ მოვუწოდებთ Script.
ან თუ ჩვენ წერდა იგი Python ან Perl ან Node.js ან იმ რამ,
ჩვენ გვინდა მოვუწოდებთ მათ ყველა სკრიპტები იმიტომ, რომ თქვენ აწარმოებს მათ ბრძანებათა ზოლს
მაგრამ ჩვენ არ კომპილირდება მათ.
ჩვენ შეგვეძლო ამის გაკეთება საკმაოდ სწრაფად.
ჩვენ არ ვაპირებთ, გამოვიყენოთ argv. მოდით უბრალოდ აფეთქება მეშვეობით.
ზარის ეს უნიკალური, დაწერეთ პროგრამა.
თქვენ შეიძლება ვივარაუდოთ, რომ შეყვანის შეიცავს ერთი სიტყვით თითო ხაზზე.
სინამდვილეში, argv იქნება საკმაოდ ტრივიალური გამოიყენოს.
unique.php.
პირველი, რაც პირველ რიგში, ჩვენ გვინდა, რომ შეამოწმოთ, თუ ჩვენ უკვე გავიდა 1 ბრძანების ხაზი არგუმენტი.
ზუსტად ისე, როგორც თქვენ მოელოდა argc და argv დო, ჩვენ დღემდე იმ PHP.
ასე რომ, თუ ($ argc! == 2) მაშინ მე არ გაუმკლავდეთ დაბეჭდვის გაგზავნა ან არაფერი.
მე უბრალოდ გასასვლელი, შეცდომა კოდი 1.
მე შეიძლება დაბრუნდეს 1.
იშვიათად PHP ხართ ამ სახელმწიფო სადაც ჩვენ at -
ჩვეულებრივ თქვენ ფუნქცია რომელსაც ფუნქცია რომელსაც ფუნქცია რომელსაც ფუნქცია.
და თუ რამე მიდის არასწორი და თქვენ უბრალოდ გასასვლელად ყველაფერი მთლიანად,
გასასვლელში უბრალოდ დამთავრდა პროგრამა.
ეს ასევე არსებობს C.
თუ თქვენ ფუნქცია ფუნქცია ფუნქცია ფუნქცია
და გსურთ მხოლოდ მოკვლა პროგრამა, შეგიძლიათ დარეკოთ გასასვლელში და იგი მხოლოდ გაითიშება.
მაგრამ PHP ეს კიდევ უფრო იშვიათი, რომ ჩვენ ვართ ამ უმაღლესი დონის.
ჩვეულებრივ ჩვენ შიგნით გარკვეული ფუნქცია, ამიტომ ჩვენ მოვუწოდებთ გასასვლელში
ასე რომ ჩვენ არ გვაქვს დასაბრუნებელი up 1 რამ რაც მაშინ ხვდება, იქ შეცდომა
ასე რომ ბრუნდება up თუ რომელიც აღიარებს იყო შეცდომა.
ჩვენ არ გვინდა, რომ გაუმკლავდეთ, რომ, ასე გასვლა (1);
დაბრუნების (1); ამ შემთხვევაში იქნებოდა ექვივალენტს.
>> აბა რა გვინდა გახსნა გვინდა fopen.
არგუმენტები ვაპირებთ შევხედოთ საკმაოდ მსგავსი.
ჩვენ გვინდა fopen ($ argv [1], და გვინდა, რომ იგი უნდა გახსნას წასაკითხად.
რომ ბრუნდება რესურსი, რომელიც ჩვენ ვაპირებთ მოვუწოდებთ ვ.
ეს გამოიყურება საკმაოდ მსგავსია როგორ C ს გარდა არ გვაქვს იმის თქმა ფაილ *.
ამის ნაცვლად ჩვენ უბრალოდ, ვამბობთ $ ვ. Okay.
სინამდვილეში, ვფიქრობ, ეს კი გვაძლევს მინიშნება როგორც PHP ფუნქცია მოუწოდა ფაილი. PHP ფაილი.
რა ამ გაკეთებას აპირებს წაკითხვის მთელი ფაილის შევიდა მასივი.
თქვენ კი არ უნდა fopen იგი. ის აპირებს, რომ თქვენ.
ასე რომ $ ხაზები = ფაილი ($ argv [1]);
ახლა ყველა ხაზების ფაილებს, რომლებიც არიან ხაზები. ახლა ჩვენ გვინდა დასალაგებლად ხაზები.
როგორ შეგვიძლია დასალაგებლად ხაზები?
ჩვენ დასალაგებლად ხაზები.
და ახლა ჩვენ შეგვიძლია ბეჭდვა მათ ან რასაც.
ალბათ იოლი გზა არის foreach ($ ხაზები როგორც $ ხაზი) ​​echo $ ხაზი;
[სტუდენტი] არ ჩვენ კი გადაკვეთს ხაზების მიერ referencing რაღაც შევიდა დალაგება?
ეს არის სადაც სახის იქნება განსაზღვრული როგორც ფუნქცია sort (& $ მასივი).
როცა რეკავთ ფუნქცია თქვენ არ უნდა გაიაროს ეს მიერ მითითება.
ეს ფუნქცია, რომელიც განსაზღვრავს, როგორც აღების, როგორც მითითება.
ეს არის რეალურად სწორედ ის, რაც მოხდა ისე
როდესაც ჩვენ ყველაფერი ჩვენი სერვერები როდესაც წავედით საწყისი 5.3 დან 5.4.
დღემდე 5.4, ეს იყო შესანიშნავად გონივრული.
ფუნქცია არ ელის მიიღოს ეს როგორც მინიშნება, მაგრამ თქვენ ვერ გაივლის მას, როგორც მინიშნება
ასე რომ, თუ ფუნქცია არ მოხდეს ცვლილებები, ეს დღემდე შეცვლილია.
როგორც 5.4, თქვენ არ უნდა გავაკეთოთ ეს.
ახლა ერთადერთი გზა თქვენ გაივლით მიერ მინიშნება არის თუ ფუნქციის მკაფიოდ აკეთებს.
თუ თქვენ არ გსურთ მას ცვლილებები, მაშინ თქვენ გჭირდებათ რომ გააკეთოთ $ ასლი = $ ხაზები და უღელტეხილზე ასლი.
ახლა ხაზები შენარჩუნებული იქნება და ასლი შეიცვლება.
php.unique.php. მე შეიძლება რაღაც messed up.
მოულოდნელი 'დალაგების ".
აქ იქნება ის, რაც ჯერ ეს ჩვენთვის.
ეს კი არ არსებობს.
გაითვალისწინეთ, როდესაც წაიკითხავთ სახელმძღვანელო რომ პირველი არგუმენტი იქნება მასივი
და ის მიერ გადაღებული მითითება.
რატომ არის ეს უკმაყოფილო მე? რადგან ამ ფუნქციას დალაგების კვლავ აქ რომ არ მინდა.
Okay, php.unique.php. მე არ უნდა გაიაროს ეს არგუმენტი, რადგან მე არ მაქვს ფაილი.
ეს php.unique.php on test.php.
აქ არის test.php ყველა ნაბეჭდი გარეთ ლამაზი დახარისხებული მიზნით.
გაითვალისწინეთ, რომ დალაგებულია ბრძანება სახის უცნაური ამისთვის კოდი ფაილი
რადგან ყველა ჩვენი ცარიელი ხაზები ვაპირებთ მოდის პირველი
მაშინ ვაპირებთ მოვიდეს ყველა ჩვენი 1 დონის indentations
შემდეგ მოდის ყველა ჩვენი არ indentations.
Yeah. >> [სტუდენტი] ასე რომ კოდის არ იყო გაიარა მინიშნება?
ის არის, რომ ზოგადად მიერ მიღებულ მნიშვნელობა?
[Bowden] როცა რეკავთ ფუნქცია, მას არასოდეს განსაზღვრავს თუ არა მიღებულ იქნა საქართველოს მიერ მითითება.
ეს ფუნქცია განმარტება, რომელიც განსაზღვრავს თუ არა მიღებულ იქნა საქართველოს მიერ მითითება.
და ეძებს ფუნქციის განსაზღვრება დალაგება ან უბრალოდ ეძებს ამ,
სჭირდება არგუმენტი მითითება.
ასე რომ მიუხედავად იმისა გსურთ მიიღოს ეს მიერ მინიშნება, ის არ მიიღოს იგი მითითება.
ეს modifies მასივი ადგილზე.
ეს მხოლოდ ნებადართული არ არის. თქვენ არ გაქვთ უფლება ამის გაკეთება. >> [სტუდენტი] Oh, okay.
[Bowden] ეს, დალაგება აპირებს მიიღოს ხაზების მიერ მინიშნება და ცვლილებები მას.
ისევ და ისევ, თუ არ გსურთ მას ამის გაკეთება, თქვენ შეიძლება მიიღოს ასლი ჯიშია.
მაშინაც კი, ამ შემთხვევაში, ასლი არ არის რეალურად ასლი ხაზები.
ეს უბრალოდ მიუთითებს იგივე სანამ პირველი იღებს შეცვლილია,
სადაც ეს პირველი აპირებს მისაღებად შეიცვალოს დალაგების ფუნქცია,
სადაც, რადგან ეს ის ასლი-on-წერენ, ახლა ასლი ასლი აპირებს გაკეთდება.
თქვენ ასევე შეგიძლიათ ამის გაკეთება. სწორედ სხვა ადგილს ხედავთ ampersand.
ხედავთ ის foreach მარყუჟების, ხედავთ ის ფუნქცია დეკლარაციების,
და ხედავთ, როცა მხოლოდ მინიჭების ცვლადები.
ახლა ჩვენ დავასრულეთ არაფერი ამით
რადგან ასლი და ხაზები სიტყვასიტყვით იგივე.
თქვენ შეგიძლიათ გამოიყენოთ ხაზები და კოპირება interchangeably.
ამის გაკეთება შეგიძლიათ ამორთვისთვის ($ ასლი); და რომ არ ამორთვისთვის ხაზები,
უბრალოდ დაკარგოთ მინიშნება იგივე.
ასე რომ, როგორც ამ ეტაპზე, არის ხაზები არის ერთადერთი გზა შეგიძლიათ ხაზები.
>> კითხვები?
Yeah.
[სტუდენტი] სრულიად თავისუფალი თემა, მაგრამ თქვენ არ დახუროს PHP ერთად - >> თქვენ არ.
Okay.
[Bowden] მინდა წასვლა რამდენადაც ვთქვა ეს ცუდი პრაქტიკა დახუროს მათ.
სწორედ ალბათ გაზვიადება, განსაკუთრებით სკრიპტი,
მაგრამ ვნახოთ, რა მოხდება, თუ ამ.
რომ არაფერი. რა მოხდება, თუ მინდოდა - [sighs]
მე უნდა გაიაროს არგუმენტი.
ესროლეთ. მე მას არასწორი.
ამიტომ php.unique.php ერთად არგუმენტი.
ახლა ისიც კი არ გვჭირდება.
მე მსგავ სწორი არგუმენტი.
ეს დაბეჭდილი რასაც ეს ბეჭდვა.
მე დაბეჭდვის ასლი და ასლი არ არსებობს. ასე რომ ხაზები.
ეს ყველაფერი დაბეჭდილი და შემდეგ შეამჩნევთ ყველა ამ უსარგებლო ქვემოთ აქ,
რადგან PHP რამე რომ არის გარეთ PHP tags
უბრალოდ აპირებს დაიბეჭდება სიტყვასიტყვით.
ამიტომ HTML, ასე ლამაზი, რომ შემიძლია div blah, blah, blah კლასის ან რასაც,
blah, blah, blah და შემდეგ დაკავდით PHP კოდი და მერე ბოლომდე DIV.
და ახლა ბეჭდვა ამ მივიღო ჩემი ლამაზი div დასაწყისშივე, ყველაფერი, რაც PHP ბეჭდური, div ქვედა.
დამღუპველი, როდესაც მსგავსი რამ ხდება, რაც საკმაოდ გავრცელებული,
უბრალოდ მაწანწალა სტრიქონების გადატანით ბოლოში ფაილი.
თქვენ არ ვფიქრობ, რომ იქნებოდა, რომ დიდი გარიგება
სანამ თქვენ ამ ფაქტს, რომ ბრაუზერები -
>> როგორ გადამისამართებების ნაწარმოების ან ძირითადად ნებისმიერი headers მუშაობა,
როდესაც თქვენ გააკეთეთ თქვენი კავშირი ნახვა და ის აგზავნის უკან ყველა ეს ზედა და რამ
მოსწონს საპასუხოდ 200 ან საპასუხოდ გადამისამართება ან რასაც,
სათაურებში მხოლოდ ძალაშია პირველი byte of მონაცემები გაიგზავნება.
შეგიძლიათ გადამისამართება ათასობით ჯერ, მაგრამ როგორც კი პირველი ბაიტი მონაცემთა იგზავნება
თქვენ არ უნდა გადამისამართება ერთხელ.
>> თუ თქვენ გაქვთ მაწანწალა სტრიქონების გადატანით ბოლოში ფაილი
და ვთქვათ, რომ თქვენ გამოიყენოთ ეს ფუნქცია და შემდეგ გსურთ -
ვთქვათ ეს არის კიდევ ერთი ფაილი, რომელიც არის index.php და თქვენ require_once რაღაც -
მე ვერ ვფიქრობ კარგი მაგალითია.
საკითხი ხდება, როდესაც ამ ხაზის ბოლოში იღებს გაიმეორა.
თქვენ არ მინდა არაფერი არ გაიმეორა ამჟამად.
მიუხედავად იმისა, რომ თქვენ არ აპირებდა შესახებ არაფერი მიღების გაიმეორა, რაღაც საერთოდ მისაღებად გაიმეორა
და ა.შ. ახლა თქვენ არ უნდა გააგზავნოთ აღარ სათაურებში
და თქვენ აპირებს მიიღოს საჩივრები.
თქვენ უბრალოდ არ გვჭირდება იმ დახურვის tags.
თუ თქვენ აპირებთ თავისსავე HTML-თან ერთად -
და ეს შესანიშნავად გონივრული გავაკეთოთ ქვემოთ აქ div რასაც
და მაშინ ამ ეტაპზე შეგიძლიათ ან ვერ შედის მათთან.
ეს ნამდვილად არ აქვს.
მაგრამ PHP სკრიპტების ის იშვიათი დახუროს იგი.
როდესაც ყველაფერი PHP, აბსოლუტურად ყველაფერი,
თქვენ ნამდვილად არ უნდა დახუროთ ეს / თქვენ არ უნდა დახუროს იგი.
>> საქმე სიმები ბევრად გავალამაზოთ, ვიდრე C.
PHP-ში შეგიძლიათ მიუთითოთ სიმებიანი ერთი ან ორმაგი შეთავაზებები.
ერთი შეთავაზებები თქვენ არ შეგიძლიათ გამოიყენოთ "გაქცევის" sequences.
მუდმივად გაქცევა, blah, blah, blah.
ამიტომ printf ძალიან იშვიათია PHP.
ვფიქრობ მინდა გამოიყენოთ printf თუ მინდოდა გავაკეთოთ ერთგვარი რამ - ში pset 5 გამოყენებულია sprintf ან რასაც.
მაგრამ გსურთ 001.jpg 002.jpg და.
ასე რომ სახის რამ, სადაც მე ნამდვილად გინდათ ფორმატის ტექსტი მინდა გამოიყენოთ printf.
მაგრამ სხვა მინდა უბრალოდ გამოიყენოთ სიმებიანი გაერთიანების.
მე არასოდეს ნამდვილად გამოიყენოს printf.
ჩვენ უბრალოდ გამიჯვნის დეტალები შორის ერთჯერადი შეთავაზებები და ორმაგი შეთავაზებები.
ყველაზე დიდი განსხვავება ისაა, რომ ერთჯერადი შეთავაზებები, ის დაიბეჭდება სიტყვასიტყვით.
არ არსებობს მონაცემები char ტიპის PHP, განსხვავებით C, ამიტომ ეს არის ეკვივალენტი ამ.
ისინი ორივე სტრიქონები.
და ლამაზი რამ შესახებ მარტოხელა ციტირებით სიმები არის მე შეიძლება ითქვას, 'Hello world!' blah, blah, blah,
$ $ Wooo.
რა ხდება, როდესაც მე ბეჭდვა ეს იქნება ბეჭდვა ეს სიტყვასიტყვით.
მოდით დავაღწიოთ ყველა ჩვენი პერსონალი.
ამიტომ echo $ str1;
ეს სიტყვასიტყვით დაბეჭდილი ყველა იმ რამ: დოლარის ნიშნები,
backslash N, რომელიც თქვენ იფიქრებენ იქნებოდა newlines -
ყველა იმ რამ იგი ბეჭდავს სიტყვასიტყვით.
ერთადერთი, რაც გჭირდებათ გაქცევა არის ერთჯერადი შეთავაზებები
რადგან სხვაგვარად იქნებოდა ვფიქრობ დახურვის ერთჯერადი შეთავაზებები.
ორმაგი შეთავაზებები, სრულიად განსხვავებული.
ჩვენ უკვე ვხედავთ სინტაქსის შეფერადება cluing ჩვენთან თუ რა დაახლოებით წასვლა საშინლად არასწორი.
php.unique. Undefined variable: wooo რადგან ეს გაგებული, როგორც ცვლადში wooo.
ორმაგი შეთავაზებები მოგცემთ ჩაწეროთ ცვლადები შევიდა -
ვთქვათ $ name = "რობ";
ამიტომ echo "Hi, ჩემი სახელი არის $ სახელი!";
იგი აღიარებს, როგორც ცვლადი.
როდესაც მე აწარმოებს, რომ - და მე ჩადეთ სტრიქონების გადატანით - Hi, ჩემი სახელი არის რობ! და Hello world!
ეს იმიტომ რომ მე არასდროს მოიხსნება ბეჭდვა wooo ზემოთ.
არსებობს 1 შემდგომი ნაბიჯი თქვენ შეუძლია გააკეთოს.
$ Array = [1, 2, 3];
რა მოხდება, თუ მინდა ბეჭდვა პირველი მაჩვენებელი მასივი?
თქვენ ჩვენგან $ array [0].
სინტაქსის შეფერადება არის ნახავ. რა არის ეს აპირებს გავაკეთო?
php.unique.
Hi, ჩემი სახელი არის 1! რომელიც არ არის ის რაც მინდოდა.
სინტაქსის შეფერადება lied to me.
მოდით ვეცადოთ "'-> 1," ბ "-> 2.
ასე მე დაწერა.
მოულოდნელი ერთჯერადი ციტატა (T_ENCAPSED blah, blah, blah, blah, blah).
იდეა ისაა, რომ ეს არ აღიარების ამ ნაწილს მასივი.
ეს არ აღიარებენ ამას, როგორც მასივი ინდექსირებული წერილით.
გსურთ, რომ გარშემორტყმული Curly braces,
და ახლა რაც ამ Curly გაუწიოს იქნება interpolated,
რომელიც სიტყვას ჩვენ ვიყენებთ magically ჩასმა ამ ცვლადების სწორი ადგილებში.
ახლა აკეთებს ეს php.unique და Hi, ჩემი სახელი არის 1! როგორც მოსალოდნელია
ან Hi, ჩემი სახელი არის რობ!
ერთი რამ, რომ სახის ლამაზი შესახებ ერთჯერადი შეთავაზებები არის, რომ -
არსებობს გარკვეული ღირებულება interpolating.
თუ იყენებთ ორმაგი შეთავაზებები, თარჯიმანი უნდა წავიდეს ამ სტრიქონს,
მიღების დარწმუნებული ვარ, რომ, "ო, აქ ცვლადი. ახლა უნდა წავიდეთ მისაღებად რომ ცვლადი და ჩადეთ აქ."
მაშინაც კი, თუ თქვენ არ გამოიყენოთ ნებისმიერი ცვლადები,
არაფერი შიგნით ამ ორმაგი შეთავაზებები საჭიროებს interpolated,
მაგრამ ის მაინც იყოს ნელა იმიტომ, რომ ეს სჭირდება წასვლა მეტი ორმაგი შეთავაზებები
ეძებს რამ, რომლებიც უნდა interpolated.
ამიტომ ერთჯერადი შეთავაზებები შეიძლება იყოს ცოტა უფრო სწრაფად თუ არაფერი საჭიროებს interpolated,
და მე როგორც წესი, თუნდაც გამოიყენოთ ერთჯერადი კვოტების, 'Hi, ჩემი სახელი არის ". $ Array [''] მაინც.
რომ იქნება ექვივალენტური რა გვქონდა ადრე.
მაგრამ ეს საკითხი უპირატესობა.
თუ თქვენ იყენებთ PHP, თქვენ ალბათ არ აინტერესებს სიჩქარე სხვაობა.
არ არის საკმარისი, რომ მიზეზი მათ უნდა დაიწყოს.
>> ნებისმიერი საბოლოო კითხვები?
>> ჩვენ რეალურად კი არ მიიღოთ მეშვეობით ყველა, მაგრამ ამ პერსონალის იყო მოსაწყენი.
ბოლო რამ, რომ სახის ლამაზი PHP-ში არის, როდესაც თქვენ საქმე HTML,
თქვენ გამოიყენოს იგი ცოტა, ასე ლამაზი კომბინაცია სინტაქსი ბეჭდვა ცვლადი.
არ აყენებდა PHP აქ, ამ ეწოდება მოკლე tags.
ოფიციალურად როგორც PHP 5.4, ეს უარყოფილია.
თქვენ რეკომენდირებული დააყენოს php.
ეს ჯერ კიდევ დაუჭირა მხარი, ასე მოკლე tags ერთად <? = დღესაც შესანიშნავად ჯარიმა.
ეს თავისთავად ცხადია მხარდაჭერა, ასე რომ თქვენ შეგიძლიათ გამოიყენოთ ეს როგორც თქვენ გსურთ, და ისინი საკმაოდ მოსახერხებელია.
>> ნებისმიერი კითხვები?
ყველა უფლება.
>> იყავი classy, ​​სან დიეგო.
[Chuckles]
Bye. [იცინის]
[ტაში] [იცინის]
>> [CS50.TV]