>> DOUG LLOYD: ასე რომ, ჩვენ გვაქვს კეთდება ბევრი მუშაობა C,
და C არის მართლაც მაგარი ენის, რადგან იგი გაძლევთ
უნარი ჩაყვინთვის ნამდვილად დაბალი დონე თქვენი პროგრამები.
ჩვენ უნდა გავაკეთოთ ყველაფერი, როგორც ნამდვილად წუთი, როგორც მანიპულირების
ინდივიდუალური ბაიტი მეხსიერება.
შეგახსენებთ, რომ პოინტერები მართლაც საშუალებას გვაძლევს, რომ მოქნილობა.
>> მაგრამ ჩვენ ყოველთვის უნდა რომ ჯარიმის მარცვლეულის დონეზე დეტალურად
ჩვენი პროგრამები?
ალბათ, არა?
და თუ ჩვენ ვაპირებთ აქვს ვაჭრობის შორის მიმდინარეობს
შეუძლია გააკეთოს რეალურად, მართლაც წუთი რამ და რეალურად, მართლაც
დიდი რამ, რომ ჩვენ არ უნდა ვიფიქროთ შესახებ, ჩვენ არ უნდა განახორციელოს
ეს მართლაც დიდი იდეები, თუ ისინი უკვე აშენდა ჩვენთვის,
ზოგადად მშენებლობის დიდი პროგრამები და დიდი პროექტები,
ჩვენ, ალბათ, აპირებს err მხარეს რომელმაც მეტი ენის პერსონალის აშენდა
ჩვენთვის, ნაცვლად, რომელმაც დაბალი დონის პერსონალი.
და რომ სადაც PHP ნამდვილად მოდის.
>> ახლა, ერთ-ერთი მიზეზი რომ ჩვენ გასწავლით PHP in CS50
ის არის, რომ ის მძიმედ შთაგონებული C. და ფაქტობრივად, ჩემი აზრით,
რეალურად, ორ წინამორბედი ენებზე, რომ
ძალიან გავრცელებული დღეს.
C და LISP.
და ისინი წინამორბედი ენებზე იმიტომ, რომ ყველა სხვა თანამედროვე პროგრამირების
ენის, რომელიც შეიმუშავა მას შემდეგ არის შთაგონებული
ერთი ან მეორე სინტაქსურად.
PHP ძალიან ჰგავს სინტაქსურად C, ხოლო ენებზე, როგორიცაა სქემა,
მაგალითად, რომელიც თქვენ შეიძლება არ მსმენია,
მძიმედ შთაგონებული ენის მოუწოდა LISP, რომელიც არის ძველი ენაზე.
>> ასე რომ, იმ მიზეზით, ჩვენ გასწავლით PHP in CS50 არის, რომ,
იცის C, როგორც ფუნდამენტურად როგორც თქვენ აკეთებთ ამ ეტაპზე,
კრეფა up PHP, რომელიც გაძლევთ უნარი გააკეთოს ბევრად უფრო მაღალ დონეზე რამ
ვიდრე C აკეთებს, არ არის რომ ბევრი დაბრკოლება,
იმიტომ, რომ თქვენ უკვე გაქვთ ძირითადი იდეა სინტაქსი.
C უკვე გარშემო თითქმის 45 წლის ამ ეტაპზე.
PHP იყო, დაახლოებით 20 წლის განმავლობაში.
და ამ 25 წლის შორის, პროგრამისტები
დადგინდა, რომ ისინი ბევრად საკმაოდ აქვს მაღალ დონეზე შესაძლებლობები,
და შეცდომები და ბრძოლას 20 წლის განმავლობაში შორის
გამოიწვია PHP და სხვა თანამედროვე ენებზე.
>> PHP ის დიდი არჩევანი ენის პროგრამული უზრუნველყოფა
რომ allow-- for პროგრამული უზრუნველყოფა that--, სადაც თქვენ
უნდა გავაკეთოთ ყველაფერი, რომ C არის რეალურად რთული.
ასე მაგალითად, სამუშაო სიმები დო
არის ძალიან რთული, იმიტომ, რომ როგორც ვიცით, სიმებისათვის C
მართლაც მხოლოდ მასივები სიმბოლო.
ეს არ არის ჩაშენებული მონაცემები ტიპის.
ან უფრო ფუნდამენტურად, ის, რომ ჩვენ კი არ მოიცავს C,
რა მოხდება, თუ თქვენ უნდა გავაკეთოთ ზოგიერთი კომპიუტერული ქსელის?
ყველა უფლება?
>> C აქვს უნარი ამის გაკეთება, მაგრამ ეს ასე arcane და ასე ძნელია რეალურად გავაკეთოთ.
თუ არ იქნება ლამაზი, თუ ენის ჰქონდა ჩამონტაჟებული, მარტივი გზა
განახორციელოს ქსელის?
და PHP არის ენა, რომელიც ხდის, რომ, ან ხელს უწყობს, რომ საკმაოდ ცოტა მეტი.
როგორც ვთქვი, PHP ძალიან მძიმედ შთაგონებული მიერ C. სინტაქსი ძალიან ჰგავს.
ასე რომ, ეს უნდა იმედია გადასვლას ერთი სხვა
ცოტა რბილი, ვიდრე ზოგიერთი სხვა ენებზე შეიძლება იყოს.
>> იმისათვის, რომ დაიწყოს წერა PHP, უბრალოდ გახსენით ფაილი php ფაილი გაფართოება.
ტექნიკურად ეს არ არის რეალურად საჭირო,
მაგრამ თუ გსურთ რამ, როგორიცაა სინტაქსის ხაზს უსვამს ამ IDE, ისე, რომ ტიპი
სახელები, ან ცვლადი სახელები, ფუნქციები, თქვენ იცით, რომ სიტყვა, ენის
მოინიშნება კონკრეტული ფერის, თქვენ საერთოდ
გსურთ ასახელებს თქვენი ფაილი კონკრეტული ფაილის გაფართოება.
ასე რომ, ჩვენ დაასახელა ჩვენი ფაილი .php გაფართოება, მაგრამ შემდეგ ასევე PHP,
ყველა PHP კოდი ვწერთ, რომ ფაილი უნდა იყოს ჩასმული ამ PHP
delimiters, რომ ჩვენ ვხედავთ აქ ეკრანზე.
კუთხური ფრჩხილი? Php უნდა დაიწყოს.
მაშინ ჩვენ წერენ ყველა ჩვენი PHP კოდი რომ ჩვენ გვინდა შორის.
და მერე?
კუთხური ფრჩხილი დახუროს.
>> თუ ჩვენ არ გააკეთებს, მაშინ რა მოხდება?
ის არ აპირებს მისაწოდებლად.
ეს არ აპირებს ნამდვილად ჩაშლის ჩვენი პროგრამა.
მაგრამ ის არ აპირებს ეფექტი, რომ ჩვენ გვინდა.
რა მოხდება, მართლაც, არის რომ როდესაც ჩვენ ვცდილობთ და გაუშვით ეს პროგრამა,
ყველაფერი არა იმათ შორის delimiters აპირებს დაიბეჭდება Verbatim.
ეს არ აპირებს რეალურად შეასრულოს კოდი,
ის აპირებს, რომ მხოლოდ დაბეჭდეთ Verbatim.
>> ახლა რატომ არის ასე?
ასე რომ C არის ის, რაც ცნობილია როგორც შედგენილი ენაზე.
თქვენ ალბათ იცნობს ნაბიჯი მიღების თქვენი პროგრამების,
გარდამტეხი გ ფაილი და თ ფაილები ერთ შემსრულებელი გააკეთოს,
კერძოდ გამოყენებით Clang როგორც ჩვენი შემდგენელი.
PHP, თუმცა, არ აქვს ამ ექვივალენტს.
PHP არის რასაც ინტერპრეტირებული ენაზე.
და რას ნიშნავს ეს?
>> ისე, ეს ნიშნავს, რომ ჩვენ არ უნდა გარდაქმნას ჩვენს კოდის zeros და პირობა
წინასწარ.
უფრო მეტიც, არსებობს პროგრამის, რომელიც ასევე მოუწოდა
PHP, რომ ესმის, PHP და შეიძლება ერთგვარი, რათა ის fly.
ეს არ არის ზუსტად ზუსტი, მაგრამ ეს არის საკმაოდ კარგი ანალოგია
რა ხდება.
ეს წერით ვინც zeroes და პირობა შეესრულებინა.
ასე რომ, თუ ეს არ ვიცი როგორ გადაამუშავებს რაღაც,
თუ ეს არ იცის, თუ როგორ უნდა პროცესი PHP, ალბათ,
მოინდომა, რომ ტექსტი, არა?
>> თქვენ ალბათ უნდოდა ამით კოდი იქ, მაშინაც კი, თუ ეს არ არის შორის PHP--
რომ PHP delimiters.
But-- ასე რომ ის არ აპირებს წაშლა თქვენთვის,
ეს უბრალოდ აპირებს ძირითადად გაუქმება იგი.
ასე რომ, ის აპირებს ბეჭდვა ის, რომ ეკრანზე.
>> ეს, როგორც ჩანს, რომ ეს არის ცუდი რამ, მაგრამ რეალურად ეს
იქნება ნამდვილად კარგია, რადგან ჩვენ გამოგიგზავნით
ვხედავ, როდესაც ჩვენ ვსაუბრობთ PHP ვებ განვითარება,
იმიტომ, რომ ეს ნიშნავს, რომ ჩვენ შეუძლია ენაცვლება PHP და HTML.
ჩვენ შეგვიძლია გამოვიყენოთ მათ ერთად შექმნას უფრო დინამიური ვებ-გვერდზე.
მაგრამ უფრო, რომ ვიდეო PHP ვებ განვითარების.
>> რა არის სინტაქსი PHP?
სწორედ ამ ვიდეო არის ყველაფერი.
მოდით ვისაუბროთ მას.
>> ასე რომ დაიწყოს, ცვლადები.
PHP ცვლადები არსებობს.
არსებობს მხოლოდ ორი დიდი განსხვავებები C.
პირველი არის ის, რომ იქ არ ტიპის specifier.
ჩვენ არ უნდა ვთქვა, int, char, ათწილადი, ყველა რომ პერსონალი.
ჩვენ არ უნდა გავაკეთოთ, რომ მთელი მსოფლიოს მასშტაბით.
PHP არის თანამედროვე ენაზე.
მას შეუძლია გაერკვნენ, თუ რა თქვენ ცდილობს გააკეთოს და მიიღოს საუკეთესო
ვხვდები, თუ რა თქვენ ცდილობთ.
ასე რომ, საკმაოდ ლამაზი.
>> მეორე ის არის, რომ ყველა ცვლადი სახელები უნდა დაიწყოს დოლარის ნიშანი.
ეს არის ის რაღაც შეეგუება.
ეს ცოტა უცნაურია, რადგან ეს ისე, რომ PHP შეუძლია გაიგოს,
რა არის ცვლადი და რა არა.
ასე რომ, ყველა ცვლადის სახელი იწყება დოლარის ნიშანი.
ასე რომ, C, ჩვენ შეიძლება ითქვას, როგორც ეს, int x = 54.
ჩვენ არ უნდა გავაკეთოთ, რომ აღარ PHP.
შეგვიძლია ვთქვათ $ x = 54.
და შეიძლება ითქვას, მაგალითად, C, თუ ჩვენ ფუნტი მოიცავდა CS50 თ
header ფაილი, შეიძლება ითქვას, სიმებიანი ფრაზა = "ეს არის CS50."
ჩვენ არ უნდა გავაკეთოთ, რომ PHP, თუმცა.
შეგვიძლია ვთქვათ $ ფრაზა = "ეს არის CS50."
და სინამდვილეში, string არის ჩაშენებული მონაცემები ტიპის PHP,
უფრო სწორად PHP ესმის რა სტრიქონს.
ეს ცალკე მასივი პერსონაჟების მსგავსად C.
ყველა თქვენი საყვარელი პირობითი ეხლა C
ჯერ კიდევ შესაძლებელია, რომ გამოიყენოთ.
ასე რომ, არ არის დიდი გარდამავალი არსებობს.
ჩვენ შეგვიძლია ვთქვათ, რომ შეგვიძლია, თუ განცხადებებს მოსწონს ეს.
თუ $ y 43, ან $ z = 15.
ასე რომ, საკმაოდ მარტივია.
ჩვენ შეგვიძლია, თუ სხვაგან.
ჩვენ შეგვიძლია თუ სხვაგან, თუ.
>> და შეამჩნია რაღაც საკმაოდ ლამაზი აქ, და ეს
არის ერთგვარი ერთი იმ უპირატესობა PHP წინააღმდეგ C, ცნობა
რა ფუნქცია ჩვენ არ იყენებს აქ?
ჩვენ გამოყენებით == შედარება ცვლადი, $ სახელი, სიმებიანი.
ჩვენ ვერ გავაკეთებთ, რომ C, არა?
ჩვენ უნდა გამოვიყენოთ ფუნქცია მოუწოდა StrComp ან StrEndComp ან
მისი თანმხლები ბიძაშვილები.
>> ასე რომ, უკვე ჩვენ ვხედავთ, ეს უპირატესობა.
ჩვენ არ გვაქვს, რომ რამე როგორც სულელური ან შესაძლოა დამაბნეველია
როგორც ფუნქცია მოუწოდა StrComp თუ უბრალოდ გსურთ შეამოწმოთ
თუ არა მნიშვნელობა უდრის სიმებიანი.
შემეძლო უბრალოდ გამოიყენოთ შეადგენს შეადგენს, მე ვერ არაფერი.
ასე რომ, არსებობს უპირატესობა.
>> ზოგჯერ, სხვათა შორის, თქვენ შეიძლება იხილეთ სხვა თუ, როგორც ერთი სიტყვით, elseif.
და ეს OK in PHP ასევე.
ასე რომ, ზოგჯერ თქვენ, რომ.
ეს არ არის typo.
PHP რეალურად ესმის elseif.
მე არ ვიცი, რატომ გადაწყვიტა განახორციელოს, რომ
მაგრამ, როგორც ჩვენ ვნახეთ ბევრი ჯერ მთელი ჩვენი videos, ჯერჯერობით,
ჩვენ პროგრამისტები მიყვარს, თუ ჩვენ შეგვიძლია გავაკეთოთ რამ სწრაფად,
ასე მოშორების, რომ სივრცე აშკარად დიდი უპირატესობა.
>> ასე რომ, თუ და elseif.
ჩვენ ასევე გვაქვს ternary ოპერატორი, გაწვევას კითხვის ნიშნის მსხვილი ნაწლავის,
მართლაც მოკლე ფორმა თუ სხვაგან ან პირობითი განშტოებაზე.
და როგორც ჩანს, ამ, რასაც ჩვენ ვცდილობთ გავაკეთოთ აქ
არის მივანიჭოთ ცვლადს $ წერილი ან ჭეშმარიტი ან ცრუ,
დამოკიდებულია თუ არა $ var არის ანბანური ხასიათი.
ასე რომ, ეს არის საკმაოდ მსგავსია isalpha რომ ჩვენ იცნობს C.
ეს არის ერთგვარი ექვივალენტი PHP.
ფუნქცია, როგორც ჩანს, მოუწოდა ctype_alpha,
მაგრამ, როგორც ჩვენ ამას PHP.
ასე რომ, ეს ყველაფერი იქნება არის, თუ $ var არის წერილი, $ წერილი მართალია.
თუ $ var არ არის წერილი, $ წერილი არის ყალბი.
>> ჩვენ ასევე გვაქვს გადახვიდეთ განცხადებები მაინც.
შეგახსენებთ, იმ C ისევე.
ძალიან ზევით არსებობს, რომ, თუ როგორ გავაკეთოთ რაღაც კიდევ int და სიმებიანი.
ასე რომ, PHP აქვს, რომ აშენდა.
ჩვენ არ გვჭირდება CS50 ბიბლიოთეკა აღარ.
ჩვენ შეგვიძლია მხოლოდ გამოიყენოთ ფუნქცია readline.
რა, რომ აპირებს ამის გაკეთება არის ბეჭდვის out გაგზავნა, "შენი სახელმწიფო,
გთხოვთ, "და შემდეგ მოციმციმე სწრაფი ელოდება მომხმარებელს შეყვანის
გარკვეული ინფორმაცია.
ახლა შეამჩნია, თუ რა შეგვიძლია შეცვლა.
თუ თქვენ უკვე გამოიყენება ეს ადრე, თქვენ შეიძლება გავიხსენოთ, რომ შეცვლა
შემოიფარგლება საკმაოდ ბევრი რიცხვებით და გმირები, მაგრამ ახლა ჩვენ შეგვიძლია გამოვიყენოთ სიმები.
და სინამდვილეში, შეცვლა განცხადება in PHP საკმაოდ ცოტა უფრო მოქნილი
ვიდრე მისი ბიძაშვილი C.
მარყუჟების.
ისევე, როგორც პირობით, ყველა ძველი დამატება ჯერ კიდევ არსებობს.
ჩვენ გვყავს ხოლო მარყუჟების, რომ ითვლიან 1 დან 100 ამ შემთხვევაში.
ჩვენ ნუ ხოლო მარყუჟების რომ იმედი 1 100,
და ჩვენ გვაქვს ამისთვის მარყუჟების რომ ითვლიან 1-დან 100-მდე.
ასე რომ, არ არის დიდი ნახტომი იყო.
სინტაქსი საკმაოდ ბევრი ზუსტად იგივე,
გარდა ახლა ჩვენ გამოყენებით დოლარის ნიშანი ცვლადი ნაცვლად
გამოცხადების მთელი ცვლადები და რაღაც რომ ჩვენი მრიცხველები.
>> აქ, სადაც რამ კიდევ უკეთესი, ვიდრე C, თუმცა.
მასივები.
ასე რომ გავიხსენოთ, როდესაც ჩვენ ვსაუბრობთ C, იმისათვის,
ჩვენთვის იზრდება და მცირდება კომპლექტი ინფორმაცია,
ჩვენ საჭირო დასალაგებლად დეფოლტის ამ იდეას უკავშირდება სია,
იმიტომ, რომ C კოლექტორები დაფიქსირდა ზომა.
ჩვენ ვერ შემცირება მათ.
ჩვენ ვერ იზრდება მათ.
ჩვენ უნდა გადაანაწილოს მეხსიერება და ყველაფერი ეს სიგიჟე
ან გამოიყენოთ უკავშირდება სიები, რომელიც დასჭირდეს საკმაოდ ცოტა მეტი სივრცე.
მაგრამ PHP, კოლექტორები არ არის ფიქსირებული ზომის აღარ.
მათ შეუძლიათ იზრდება და მათ შეუძლიათ შემცირება.
ასე რომ კიდევ ერთხელ, ამ 20 წლის განმავლობაში, რომელიც არსებობდა შორის პირველი გათავისუფლებას C
და პირველი რელიზი PHP, ჩვენ გადავწყვიტეთ, რომ თქვენ იცით,
ეს იქნება ძალიან დიდი თუ ჩვენ შეგვიძლია ამის გაკეთება.
ასე რომ, ჩვენ განხორციელებული ეს.
>> ასე რომ, PHP მასივები არ არის დაფიქსირებული ზომა, და რადგან PHP ნამდვილად არ
აქვს პროგრამისტი წინა წინაშე ცნებები ტიპის,
ჩვენ შეგვიძლია ავურიოთ მონაცემთა ტიპები ჩვენს მასივები, ძალიან.
ასე რომ, ჩვენ კი არ უნდა გამოვიყენოთ ყველა რიცხვებით ან ყველა მცურავი ქულა,
ჩვენ შეგვიძლია ნაზავი ყველა სხვადასხვა სახის ერთ მასივი.
გამოცხადების მასივი საკმაოდ მარტივია.
ეს, ისევე, როგორც ნებისმიერი სხვა ცვლადი.
$ nums = array (1, 2, 3, 4), array, რომ ფუნქცია
რომ ჩაშენებული PHP, რომ შექმნის მასივი თქვენთვის.
ეს ქმნის მასივი ოთხი ღირებულებები, ნომრები, ამ შემთხვევაში, მოუწოდა $ nums.
და იქ უფრო, ვიდრე ერთი გზა ამის გაკეთება.
და ჩვენ ვაპირებთ რომ ეს ბევრი PHP.
PHP შემუშავებულია სხვადასხვა ადამიანი და იზრდება და იზრდება და იზრდება.
არსებობს, როგორც წესი, არ არის მხოლოდ ორი ან სამი გზა რაღაც PHP,
იქ, როგორც წესი, 10 ან 20.
აქ არის კიდევ ერთი საერთო გზა განაცხადოს მასივი.
$ nums = კვადრატული ფრჩხილი 1, 2, 3, 4.
ასე რომ, ეს არის ერთგვარი მსგავსი C- ს კუთხე br-- Curly გაუწიოს notation, საკმაოდ. $ -
ან ეს იქნება int nums მოედანზე ფრჩხილებში ტოლია Curly გაუწიოს 1, 2, 3, 4.
In PHP ის $ nums = მოედანზე ფრჩხილებში 1, 2, 3, 4.
მაგრამ ეს ორივე მაგალითები აქ მომეცი მასივი ოთხი ამ შემთხვევაში რიცხვებით.
>> რა მოხდება, თუ მინდა დაყენება რაღაც ახლა?
ისე, მე შემიძლია მხოლოდ ვთქვა $ nums 4, რომელიც კიდევ ერთხელ, ჩვენ ჯერ კიდევ დათვლის 0 აქ
PHP, იქნება მეხუთე ელემენტს მასივი.
მე შემიძლია მხოლოდ ვთქვა, რომ.
მე არ ვაპირებ განიცდიან seg ბრალია, იმიტომ, რომ ჩემი მასივი მხოლოდ
გაიზრდება გადაიდგა, რომ.
ეს არის საკმაოდ ლამაზი, არა?
და სინამდვილეში, მე კი არ უნდა დააკონკრეტა, სადაც მე მინდა, რომ ეს.
მე შემიძლია მხოლოდ ვთქვა, რომ ამ და მხოლოდ მადლობა მას უფლება ბოლომდე,
ან მე ვერ კი მხოლოდ ამბობენ $ nums 20 ან 1000.
ეს ნამდვილად არ აქვს.
ის ჯერ კიდევ მხოლოდ აპირებს მადლობა მას უფლება ბოლომდე.
>> ასე რომ, შემიძლია იზრდება, და as-- ჩვენ არ ვაპირებ მოიცავს იგი აქ,
მაგრამ შემიძლია splice ან ზოლები ელემენტები გარეთ მასივი, ისევე,
და მასივი შემცირდება გადაიდგა რომ ახლა დაკარგული ან ცარიელი სივრცე.
არსებობს კიდევ ერთი გზა დაყენება რაღაც გადატანა მასივი,
რომელიც არის ფუნქცია მოუწოდა array_push.
ასე რომ, კიდევ ერთხელ, მხოლოდ ამ იდეა გამოუვა რამ სხვადასხვა გზები.
ასე რომ, ჩვენ ვნახეთ სამი სხვადასხვა გზა ახლა რომ Tack კიდევ ერთი ელემენტი გადატანა მასივი.
ასე რომ, ეს დასძენს კიდევ ერთი ელემენტი რომ ბოლოს $ nums მასივი.
და ჩვენ შეგვიძლია აღრევას ჩვენი მონაცემთა ტიპები.
ასე რომ მე ვერ მასივი არა 1, 2, 3, 4, მაგრამ 1, მართალია, 3, 4,
სადაც ჭეშმარიტი არის ლოგიკური, და მაშინ თუ მინდა, მადლობა კიდევ ერთი ელემენტი
რომ მასივი, ალბათ სიმებიანი, სიმებიანი "ხუთი" მე შეიძლება ამის გაკეთება.
და ახლა ჩემი მასივი გვინდა იყოს 1, მართალია, 3, 4, ხუთ.
სიტყვა ხუთი, არ რიცხვი 5.
ასე რომ, ბევრი მოქნილობა არსებობს.
>> მოქნილობა იღებს კიდევ უკეთესი, თუმცა,
იმიტომ, რომ PHP მხარდაჭერა აქვს რაღაც მოუწოდა ასოციაციურ მასივში.
ჩვენ ერთგვარი ბუნდოვნად ისაუბრა შესახებ ასოციაციური მასივების დო
კონტექსტში hash მაგიდები, იმიტომ, რომ რა ასოციაციური მასივების მართლაც ყველა
შესახებ მიღების გასაღები ღირებულება წყვილი mappings.
და ამ შემთხვევაში, keys-- თუ ჩვენ იცნობს კოლექტორები C,
გასაღებები ინდექსის ნომრები.
0, 1, 2, 3.
და ღირებულებები, რასაც ჩვენ ვხედავთ, რომ მასივი 0, მასივი 1, მასივი 2, და ასე შემდეგ.
ასე რომ გასაღებები ინდექსები, და ღირებულებები
რა არის, რომ მასივი ადგილმდებარეობა, განსაზღვრული, რომ ინდექსი.
>> მაგრამ PHP, ჩვენ არ უნდა გავაკეთოთ ეს ცნება მასივი 0, მასივი 1, მასივი 2
აღარ.
ახლა ჩვენ შეგვიძლია გამოვიყენოთ ფაქტობრივი სიტყვა რუკაზე გასაღებები ღირებულებებს.
ასე რომ, მე ვიტყოდი, რაღაც მოსწონს ეს.
მე ვერ შექმნათ მასივი გამოყენებით კვადრატული ფრჩხილი სინტაქსის ასეთია.
$ pizzas = კვადრატული ფრჩხილი "ყველი" და შემდეგ
ეს ერთგვარი ორმაგი ისარი notation, 8.99 ", pepperoni," arrow 10.99-- 9.99,
და ასე შემდეგ.
ასე რომ, რა ხდება აქ?
რა ვარ მე რეალურად აკეთებს?
მე შექმნაში გასაღები ღირებულება წყვილი mappings.
ასე რომ ნაცვლად ამბობდა, მაგალითად, pizzas 0, ცალი 1, pizzas 2,
შემიძლია ახლა ვთქვა pizzas ყველი, pizzas pepperoni,
და ეხება ფასეულობებს მათთან ასოცირებული.
>> ასე რომ, აქ არის ჩვენი გასაღებები მწვანე.
ყველი, pepperoni, ბოსტნეულის, buffalo ქათამი.
აქ არის arrow, რომელიც იღებს გასაღები ღირებულება წყვილი რუკების.
და მერე აქ არის ის ღირებულებები, იმ მასივი ადგილმდებარეობა.
ასე რომ, როგორც ამბობდა მასივი 0 უდრის 8.99.
გასაღები არის 0.
ღირებულება არის 8.99.
შემიძლია ახლა ვთქვა მასივი ყველი, ან ამ შემთხვევაში pizzas ყველი, არის გასაღები,
და რაც მე at pizzas ყველი 8.99.
ეს არის ღირებულება, რომელიც მე იქ.
>> ასე რომ, შემიძლია ვთქვა რამ მინდა. $ pizza ყველი = 7.99.
ამბობენ, რომ მე მქონე იყიდება.
მინდა dis-- მინდა ვარდნა ფასი ყველის პიცა.
ან შემიძლია ბოსტნეულის პიცა, როგორც ნაწილი მდგომარეობაში,
ან მე შეგიძლიათ ახალი ელემენტი ჩემი მასივი, ისევე, როგორც მე ვერ გავაკეთებ ადრე.
მე შეგიძლიათ ახალი ელემენტი ამ ასოციაციურ მასივში გასაღები "ბეკონი"
და ღირებულება 13,49.
>> მაგრამ ამ სახის წარუდგენს პრობლემა, თუ ფიქრობთ, რომ ეს მეორე.
როგორ ჩვენ iterate მეშვეობით ამ მასივი?
მარჯვენა?
In C, ჩვენ უბრალოდ აქვს ამისთვის მარყუჟის, როგორც წესი, რომელიც
რომ აწარმოებს 0 to ზომა მასივი მინუს 1.
მასივი აქვს n ელემენტების, იმ მოქმედი ინდექსების 0 ო მინუს 1.
ასე რომ, ჩვენ შეგვიძლია გამოვიყენოთ ამისთვის loop ნაბიჯ მეშვეობით თითოეული ელემენტი.
>> მაგრამ ეს არ არის ნამდვილად საქმე აღარაა, არა?
ახლა, სადაც ჩვენ გვაქვს გასაღები ღირებულება წყვილი mappings, სადაც ღილაკები სიტყვა,
როგორ უნდა iterate ყველა სიტყვა?
ისე, საბედნიეროდ, PHP აქვს გზა გაუმკლავდეთ ამ ძალიან,
და ამიტომ ჩვენ ხტომა უკან რომ მარყუჟების მეორე
დანერგვა მეოთხე სახის მარყუჟის, რომელიც არსებობს PHP მოუწოდა foreach loop.
და რა foreach loop აკეთებს არის ეს, ძირითადად, იგივე იდეა.
თქვენ შეგიძლიათ გამოიყენოთ იგი ნებისმიერი სახის მასივი.
მაგრამ ეს, ძირითადად, იგივე იდეა, ამისთვის მარყუჟის,
გარდა ნაცვლად გამოყენებით ინდექსის ნომრები, უბრალოდ
აქვს ამ უცნაური სინტაქსის სადაც რეკავთ თითოეული ელემენტი
სახელი მიზნებისათვის ამ loop.
>> ასე რომ, ამ შემთხვევაში, foreach ($ წყობის $ გასაღები).
ძირითადად, იმის გამო, რომ კომენტარის აღნიშნავს, შიგნით რომ foreach loop,
ის აპირებს წასვლა თითოეული ელემენტის $ მასივი, რომელიც, როგორც წესი,
იქნება ასოციაციურ მასივში, მაგრამ შეიძლება მართლაც იყოს ნებისმიერი სახის მასივი
რომ გსურთ PHP.
და ყოველ ჯერზე, რომ ამისთვის მარყუჟის ალბათ
არ თქვა $ array კვადრატულ ფრჩხილებში $ i, თქვენ შეიძლება უბრალოდ, ვამბობთ $ გასაღები.
ასე რომ, $ გასაღები ხდება alias ყველა ინდექსი თქვენი PHP ასოციაციურ მასივში,
და ასე რომ თქვენ შეგიძლიათ გამოიყენოთ ეს იგრძნობა.
>> ასე მაგალითად, ჩვენ გვაქვს ახლა მივიღე ჩვენი pizzas მასივი.
მე სახის მოახერხა ეს კუთხეში არსებობს
ასე რომ ჩვენ შეგვიძლია გამოვიყენოთ რომ გავაკეთოთ სწრაფი მაგალითი.
თუ მე ვიტყვი, foreach ($ pizzas როგორც $ pizza), ასევე, რა ხდება?
ისე, მე ვაპირებ iterate მეშვეობით ყოველ ერთ ელემენტს მასივი $ pizzas,
და ამით, მე ვაპირებ მოვუწოდო ყველა ელემენტს, როდესაც მე შიგნით
სხეულის რომ მარყუჟი, $ პიცა.
>> ასე რომ, ერთგვარი დავდგეთ-in, გავიხსენოთ, რომ $ pizza
არის სტენდი წელს ამბობდა $ pizzas კვადრატულ ფრჩხილებში $ i
თუ ჩვენ გამოყენებით ამისთვის მარყუჟის, სადაც ჩვენ შეიძლება წავიდეს ეხლა $ i = 0, ამ შემთხვევაში,
$ i = 3.
თუ ჩვენ არ გვაქვს გასაღები ღირებულება წყვილი აქ, ეს იქნება ელემენტს 0, 1, 2, 3,
და ჩვენ გამოიყენოს ამისთვის loop წასვლა $ pizzas 0 $ pizzas 1, $ pizzas 2,
$ pizzas 3.
ასე რომ, ახლა მხოლოდ $ პიცა შემცვლელი რომ ინდივიდუალური გასაღები.
>> ასე რომ, რა არის ეს აპირებს ამობეჭდოთ?
მე დაბეჭდვისას $ პიცა.
რა ვარ მე აპირებს იპოვოს at-- თუ ამობეჭდოთ $ pizzas, $ i?
მარჯვენა?
თუ მე ვაპირებ ამობეჭდოთ შ ელემენტს pizzas,
რა ვარ მე აპირებს ბეჭდვა?
მე ვაპირებ ამობეჭდოთ ღირებულებები იმ ადგილას, არა?
Like თუ ვაკეთებდით ამ კონტექსტში C,
ჩვენ არ ჩვეულებრივ გამოიყენოთ ჩვენი iterator ცვლადი, int i = 0, i ნაკლებია, ვიდრე 3,
i ++, ამობეჭდოთ 0, 1, 2, 3.
ჩვენ დაბეჭდვისას მასივი 0, მასივი 1, მასივი 2, მასივი 3.
და მერე რა ეს ბეჭდავს out არის ეს.
ეს არის ფასების სია.
8.99, 9.99, 10,99, 11.99.
>> ახლა სწრაფი შენიშვნა აქ.
Foreach მარყუჟის სულაც არ ბეჭდვა რამ მიზნით.
ეს არ არის გარანტირებული.
ეს, როგორც წესი აქვს.
ეს, როგორც წესი საფუძველზე წესრიგი ელემენტები ემატება მასივი,
ასე რომ მხოლოდ აგებს, რომ გონება.
ეს არ უნდა იყოს, რათა.
მაგრამ foreach მარყუჟის iterate მასშტაბით თითოეული ელემენტის
მასივი კითხვა.
ამ შემთხვევაში, კიდევ ერთხელ, მასივი $ pizzas.
>> შემიძლია შეცვლის სინტაქსი, თუმცა, თუ მე მინდა ორივე გასაღები და მნიშვნელობა.
იმის ნაცვლად, რომ $ pizzas როგორც $ პიცა, შემიძლია ვთქვა.
და თუ თქვენ შეხედეთ რა მე მონიშნულია მწვანე აქ,
ეს ჰგავს გასაღები ღირებულება წყვილი რუკების.
ასე რომ, თუ you-- მაშინაც კი, თუ თქვენ არ ხართ მთლიანად დარწმუნებული რა ეს უნდა გავაკეთოთ,
თქვენ ალბათ შეუძლია გამოიცნოს რომ $ topping აპირებს
იყოს გასაღები ამ შემთხვევაში და $ ფასი იქნება მნიშვნელობა.
ასე რომ, მე შემცვლელი ახლა ყოველ ელემენტს of $ pizzas როგორც გასაღები ღირებულება წყვილი,
და ახლა შემიძლია ეხება გასაღები და ღირებულება, რომელიც შეიძლება მოსახერხებელი,
მაგალითად, ასეთია.
>> "მთელი" - ეს არის ბევრი ბეჭდვის ხდება აქ "მთელი"
topping "pizza ღირს $" ფასი, და შემდეგ მე ამობეჭდოთ პერიოდში და წარმატებული ო.
ასე რომ, ახლა შეამჩნია, ერთხელ მაქვს ხელმისაწვდომობის გასაღები, $ topping, და ღირებულება, $ ფასი.
ასე რომ, შეგიძლიათ გამოიცანით რა ამ აპირებს ამობეჭდოთ?
არსებობს უამრავი ბეჭდვითი განცხადებებს, მაგრამ იქ მხოლოდ ერთი წარმატებული ო,
ასე რომ, ის აპირებს ბეჭდვა რაღაც entire-- ერთი ხაზი კოდი.
>> თუ შემიძლია ეხება გასაღები და ღირებულება, მაშინ ახლა,
ნაცვლად მხოლოდ მას შეუძლია ამობეჭდოთ ფასები,
შემიძლია ამობეჭდოთ რაღაც მსგავსი.
"მთელი ყველის პიცა ღირს $ 8.99."
და ახლა მე გამოყენებით ყველა keys-- ყველი, pepperoni, ბოსტნეულის,
buffalo chicken-- და ღირებულებებს.
8.99, 9.99, 10,99, 11.99 ასე რომ არის, უბრალოდ განსხვავებული გზა
გავაკეთოთ foreach loop, რომ ნაცვლად მხოლოდ გაძლევთ ხელმისაწვდომობის ღირებულებები,
უბრალოდ აძლევს you-- ეს გაძლევთ ხელმისაწვდომობის გასაღებები და ღირებულებები.
>> ასე რომ, დაბეჭდვისას ინფორმაცია.
მე უკვე გაკეთდა მას რამდენიმე სხვადასხვა გზები, რომ თქვენ შეიძლება არ შეამჩნია.
ორი ფუნქცია ჩვენ, პირველ რიგში, ჩანს ბეჭდვითი და ეხო.
და საკმაოდ ბევრი განცდა მიზნით, ისინი ზუსტად იგივე.
They're-- არ არის ძალიან დახვეწილი განსხვავება ისაა, რომ კი არ ღირს
მისაღებად შევიდა, მაგრამ ძირითადად ყველგან თქვენ შეგიძლიათ გამოიყენოთ ბეჭდვითი თქვენ ალბათ შეუძლია გამოიყენოს
echo ასევე.
>> და ეს არ არის მხოლოდ ორი.
PHP აქვს ბევრი სხვადასხვა გზები ბეჭდვა რამ out,
და მას ასევე აქვს ინტეგრაცია ცვლადები შევიდა შუა სიმებიანი.
ასე რომ გავიხსენოთ, C, თქვენ გვახსოვდეს, თუ რა ფუნქცია
ჩვენ შეგვიძლია გამოვიყენოთ შეიცვალა ცვლადები შევიდა რამ გვინდა ამობეჭდოთ?
თქვენ, ალბათ, გამოიყენოთ ეს ფუნქციონირებს საკმაოდ ბევრი.
printf, არა?
ასე რომ, ეს არის ის, რაც ჩვენ გვქონდა ადრე შიგნით კონტექსტში ჩვენი foreach loop.
ჩვენ გვქონდა ამ ხუთ ცალკე ბეჭდვითი განცხადებებს,
იმიტომ, რომ ეს იყო მხოლოდ გზა მე ნამდვილად იცოდა იმ დროს,
როგორ ამობეჭდოთ შეტყობინებები.
მე არ ვიცი, როგორ ინტეგრირება ცვლადი $ topping ჩემი PHP კოდი.
ისე, თუ მე მხოლოდ მიღებული ველური ამოიცნობთ, printf, ის რეალურად არ მუშაობდა.
printf არის ფუნქცია, რომელიც მე შეიძლება გამოიყენოს PHP, ისევე, როგორც მე შეიძლება გამოიყენოს იგი C.
>> ასე რომ, რაღაც, printf, კიდევ ერთხელ, ჩვენ იცნობს, რომ.
პირველი% s შეიცვალა ღირებულება $ topping.
მეორე% s შეიცვალა ღირებულება $ ფასი.
ასე რომ, მე interpellating, რომელიც უბრალოდ ლამაზი გზა
ამბობდა, მე გაკვრა ცვლადი იყო.
ასე რომ, მე ჩართვის $ topping, სადაც წითელი% s და $ ფასი სადაც ლურჯი% s
არის, და მერე მიიღებს გაგზავნა, "მთელი ყველის პიცა ღირს $ 8.99."
>> არ არის ერთადერთი გზა მე შემიძლია ამის გაკეთება, თუმცა.
იქნებ მე მინდა, რომ ეს მეთოდი.
ეს არის რეალურად რა არის ყველაზე ხშირად უწოდებენ ცვლადი interpellation.
მე შეიძლება გამოიყენოს ეხმიანება.
მე ვერ გამოიყენებს ბეჭდვითი ძალიან, როგორც ვნახავთ.
მაგრამ, რა ხდება აქ?
>> პირველ რიგში, მე უნდა გაქცევა დოლარის ნიშანი.
იმიტომ, რომ მახსოვს, როდესაც ჩვენ რეალურად ბეჭდვის ფასები pizzas,
მე რეალურად გაფორმებით მათ, როგორც მონეტარული მაჩვენებლები დოლარის ნიშანი.
მაგრამ ჩვენ გამოყენებით დოლარის ნიშნები წარმოადგენს ცვლადი სახელები PHP,
კერძოდ, როდესაც მე ამ მეთოდით, რომ curly
გაუწიოს ცვლადი interpellation მეთოდი, მე უნდა
გაქცევა ჩემი დოლარის ნიშანი ასე რომ არ ვფიქრობ, მე ვსაუბრობ ცვლადი.
ის აპირებს, ფაქტობრივად, ფაქტიურად ბეჭდვა დოლარის ნიშანი.
>> ასე რომ, ერთგვარი ანალოგიური მას რა ხედავთ ბოლოს არსებობს.
ის ფაქტობრივად არ ბეჭდვითი წარმატებული ო, არა?
იგი ბეჭდავს out ახალი ხაზი ხასიათი.
ეს is-- ის არ აპირებს ბეჭდვითი წარმატებული დოლარის ნიშანი,
ის აპირებს ამობეჭდოთ მხოლოდ დოლარის ნიშანი ხასიათი.
იგივე იდეა.
გაქცევა sequences, რა ამას უწოდებენ.
>> მაგრამ შეამჩნია, რომ მე არ აკეთებს ნებისმიერ% s ჩანაცვლების,
მე უბრალოდ სიტყვასიტყვით ჩართვის ამ ცვლადებს.
ასე რომ, ამას, რა მოხდებოდა აქ ის არის, რომ ღირებულება $ topping-- ერთხელ,
უბრალოდ შენახვა, რაც ჩვენ უკვე ვსაუბრობთ, ასე far-- ყველი დაიჭერს
plugged არსებობს.
და $ ფასი იქნება რასაც მნიშვნელობა განთავსებულია pizzas, კვადრატულ ფრჩხილებში, ყველი,
რომელიც იყო 8.99.
ასე რომ, ეს ასევე დაბეჭდვა "მთელი ყველის პიცა ღირს $ 8.99."
და როგორც ვთქვი, მე ვერ გამოიყენებს ბეჭდვა აქ ნაცვლად ექო,
და ფუნქციონალური იქნება საკმაოდ ბევრი ზუსტად იგივე.
ეს იქნებოდა ამობეჭდოთ იგივე.
>> არსებობს კიდევ ერთი გზა ამის გაკეთება, და ეს არის კიდევ ერთი უპირატესობა
საქართველოს PHP მუშაობის სიმები.
ჩვენ შეგვიძლია ამის გაკეთება სიმებიანი გაერთიანების.
ჩვენ შეგვეძლო ამის გაკეთება C, ძალიან, გამოყენებით ფუნქციის მოუწოდა strcat,
მაგრამ კიდევ ერთხელ, ჩვენ გვქონდა დარეკეთ ცალკე ფუნქციები.
ეს იყო მთელი ეს არეულობა უნდა გააკეთოს.
ჩვენ უნდა ფუნტი string.h.
ეს იყო წარმოების, არა?
მაგრამ ახლა შემიძლია უბრალოდ გამოიყენოთ ეს dot ოპერატორი to concatenate სიმები ერთად.
>> ასე რომ, მე ინტეგრირების "მთელი" და მაშინ რასაც ღირებულება $ topping არის,
და შემდეგ სხვა სიმებიანი, "პიცა ხარჯები $"
და მაშინ concatenating რასაც ღირებულება $ ფასი,
და შემდეგ ბოლომდე ვარ tacking on პერიოდში წარმატებული ო.
ასე რომ, ეს ასევე ამობეჭდოთ "მთელი" - კიდევ ერთხელ,
თუ ჩვენ ვსაუბრობთ პირველი ელემენტს, რომ pizzas მასივი
"მთელი ყველის პიცა ღირს $ 8.99."
პერიოდი, წარმატებული ო, კიდევ ერთხელ, იმ $ topping და $ ფასი შემცვლელი
რა გვქონდა მითითებული ჩვენი foreach loop როგორც გასაღები ღირებულება წყვილი რუკების.
>> PHP შეუძლია ფუნქციები.
ფუნქციები იყო ერთგვარი განუყოფელი C, როგორც დავინახეთ.
ისევე როგორც ცვლადი, ჩვენ არ უნდა მიუთითოთ დაბრუნების ტიპის ფუნქცია,
იმიტომ, რომ ეს ნამდვილად არ აქვს.
და ჩვენ არ დააკონკრეტა მონაცემთა ტიპები ნებისმიერი პარამეტრების,
იმიტომ, რომ ისინი ნამდვილად არ ამ საკითხზე, როგორც ჩვენ ვნახეთ PHP.
ყოველი ფუნქცია გააცნო ფუნქცია სიტყვით.
სწორედ ასე მიუთითოს PHP, რომ ის, რაც ჩვენ ვსაუბრობთ ფუნქცია.
>> და ჩვენ არ უნდა გაუმკლავდეთ მთავარი ყველა,
იმის გამო, რომ თარჯიმანი, PHP თარჯიმანი, მუშაობს ზემოდან,
მიუხედავად.
თუ ის ხედავს თქვენ შეგიძლიათ ფუნქცია ზარი, იგი ყველაფერს
წასვლა ფუნქცია ზარი, მაშინაც კი, თუ საქმე მოგვიანებით.
მაგრამ ის აპირებს წაკითხვის ზემოდან ბოლოში, ამიტომ ჩვენ არ უნდა მიუთითოთ,
აქ არის, სადაც თქვენ დაიწყოს.
თქვენ დაიწყოს ხაზი 1 თქვენი PHP და მუშაობა იქიდან.
>> ასე რომ, აქ არის როგორ უნდა შექმნა ფუნქცია მოუწოდა hard_square.
ეს აშკარად იღებს ერთ-ერთ პარამეტრი, რომელიც მე მოუწოდებდა $ x.
ეს ფუნქცია რთული მხოლოდ იმის საჩვენებლად, სხვადასხვა ნივთები.
ჩვენ ჯერ კიდევ დაბრუნების ღირებულებებს.
მე გამოყენებით ამისთვის loop აქ.
მაგრამ ეს, ძირითადად, მხოლოდ, რა ეს შეადგენს მხოლოდ $ x-ჯერ $ x.
რა მე რეალურად აკეთებს მხოლოდ და დასძინა, x 0 x times ან $ x ნულოვანი $ x-ჯერ.
მაგრამ ეს ეფექტურად ზუსტად იგივე, რაც გამრავლებით $ x-ჯერ $ x.
მე მაინც დაბრუნდება მნიშვნელობა, ამ შემთხვევაში $ შედეგად,
და მე გააკეთა ფუნქცია PHP.
>> აი როგორ შეიძლება გამოვიყენოთ ეს კონტექსტში.
ასე რომ, შესაძლოა, მე შიგნით ზოგიერთი PHP ფაილი.
ყურადღება მიაქციეთ, ლურჯი, რომ მე გამოიყენება ჩემი PHP delimiters,
კუთხე bracket კითხვის ნიშნის php.
შორის იმ ყველა , PHP, რომ მინდა დაწერა.
ასე რომ, მე აშკარად აპირებს მივიღო მე ვაპირებ უბიძგონ შესახებ
მომეცი ნომერი, მაღაზიაში, რომელიც ცვლადი, მაღაზიის, რომ ცვლადი $ x,
რაც არ უნდა მომცეს.
ამის შემდეგ მე ვაპირებ ეხმიანება hard_square რომ ღირებულება,
და აშკარად აპირებს რომ Tack ახალი ხაზი
ისევე, და შემდეგ მოგვიანებით მე განვსაზღვროთ ფუნქცია hard_square ასე
რომ როდესაც მე მოვუწოდებთ hard_square,
ის იცის, რა მე ვსაუბრობ.
>> ახლა, მე შეიძლება გააკეთოს რაღაც მსგავსი.
ეს არის ოდნავ განსხვავებული.
ეს არის თითქმის ზუსტად იგივე, რაც ჩვენ ვნახეთ ადრე,
გარდა ნაცვლად ამბობდა მხოლოდ $ x იქ, როგორც პარამეტრი hard_square,
მე ვამბობ, $ x = 10.
ასე რომ, ეს არის მაგალითი იმისა, თავდაცვითი პროგრამირება,
დაცვა თქვენი პროგრამები წინააღმდეგ მუქარის მომხმარებლებს.
>> ეს არის ერთ-ერთი გზა ამის გაკეთება რამდენიმე შეცდომა შემოწმების, რომ ჩვენ ნამდვილად არ
აქვს როგორც ვარიანტი C. ჩვენ ვერასოდეს მიუთითოს რა მნიშვნელობა რაღაც.
ჩვენ ყოველთვის უნდა შეამოწმოს თუ არა, მაგალითად,
თუ ჩვენ მივიღეთ ზარი GetString, ეს იყო ყველაზე სწორი, თუ მაშინვე ჩვენ
შემოწმდება, რომ, ჩვენ შეამოწმა თუ არა სტრიქონი
რომ მომხმარებლის მოგვცა არ არის ტოლი null,
იმიტომ, რომ ჩვენ არ გვინდა, რომ დაიწყოს მუშაობის null სიმებიანი.
>> აქ, ეს არის გზა დასაცავად წინააღმდეგ, რომ.
იმ შემთხვევაში, თუ მომხმარებელი არ მოგვაწოდოთ რაღაც რატომღაც, რას აპირებს?
ისე, ჩვენ, უბრალოდ, ვამბობთ რასაც ისინი არ მოგვაწოდა,
ჩვენ უბრალოდ აპირებს შეაერთედ 10 ნაცვლად.
ასე რომ, თუ ისინი არ გვაძლევენ მნიშვნელობა, უბრალოდ გამოიყენოთ 10 by default. ასე რომ, აქ,
შეამჩნია, რომ მე მიღების ზარი hard_square,
მაგრამ იქ არ არის სწრაფი საქართველოს შესახებ, უფლება?
მე უბრალოდ მიღების ცარიელი ზარი.
>> მაგრამ ჩემი ფუნქცია hard_square ელოდება პარამეტრი.
რა არის ეს აპირებს ამობეჭდოთ?
ის აპირებს ამობეჭდოთ 100, არა?
იმის გამო, რომ მომხმარებელს არ მომეცი არაფერი.
ასე რომ, მე უბრალოდ აპირებს ვივარაუდოთ, რომ 10-- 10 ნაგულისხმები მნიშვნელობა.
ასე რომ, ეს იქნებოდა ბეჭდვა 100 საკუთარი ხაზი.
>> PHP ფაილი არ უნდა იყოს მხოლოდ ერთი ფაილი.
თქვენ შეგიძლიათ დააკავშიროთ რამოდენიმე ფაილი ერთად, ისევე, როგორც თქვენ შეგიძლიათ C. გზა
ჩვენ გავაკეთეთ, რომ C იყო, როგორც წესი, ამის გაკეთება # include მისაღებად header ფაილი გამოყვანილია.
ჩვენ არ გავაკეთოთ, რომ PHP.
ჩვენ ამას ვაკეთებთ, რაღაც მოუწოდა require_once.
და მერე იქ მთელი ეს რამ, რა არის ეს __dir__?
ეს მხოლოდ სპეციალური ცვლადი, ან სპეციალური მუდმივი,
მართლაც, რომელიც განსაზღვრავს რა თქვენი მიმდინარე დირექტორია.
ასე რომ, ეს აპირებს გამოიყურებოდეს თქვენი მიმდინარე დირექტორია
ფაილი მოუწოდა cs50.php ამ მაგალითში,
და ის აპირებს გამყარებაში, რომ ფაილი ზედა თქვენი PHP პროგრამა,
ვთქვათ, რომ თქვენ დააყენა მოითხოვს კიდევ ერთხელ ხაზი ზედა თქვენი PHP ფაილი.
>> ასე რომ, PHP, პირველ რიგში გამოიყენება, მაგრამ არა მხოლოდ გამოყენებული,
როგორც ენის ვებ დაფუძნებული პროგრამირების.
ეს მართლაც, თუ როგორ აღმოჩნდა.
მაგრამ ეს არის სრული ენის, როგორც ჩვენ ვნახეთ.
ჩვენ ვნახეთ საკმაოდ ბევრი რამ რომ მას შეუძლია გააკეთოს, რომ მსგავსი C,
და მას შეუძლია გააკეთოს heck საქართველოს ბევრი მეტია.
>> მაგრამ რადგან ეს არის სრული ენა და ჩვენ შეგიძლიათ გააკეთოთ command line პროგრამირების იგი.
ჩვენ შეგვიძლია გაუშვით ბრძანება ხაზი პროგრამები.
ყველა რომ აუცილებელია აწარმოებს ბრძანება ხაზი პროგრამა, რომელიც დაწერილი PHP
არის, რომ თქვენ გაქვთ PHP თარჯიმანი.
ასე რომ, ეს არის ერთგვარი ანალოგიური რომელსაც შემდგენელი თქვენს სისტემაში
თუ გსურთ შედგენის თქვენი C კოდი გადაქცევას შესრულებადი ფაილი.
თქვენ უნდა აქვს PHP ინტერპრეტატორი რომ არსებობს თქვენი სისტემა
ასე რომ თქვენ შეგიძლიათ ინტერპრეტაცია PHP ფაილი.
>> ვთქვათ თქვენ, და, როგორც წესი, ამ თარჯიმანი ეწოდება PHP,
და ეს, როგორც წესი, შეფუთული ყველაზე ჩამოტვირთვების ან დანადგარები PHP
რომ თქვენ შეგიძლიათ მიიღოთ ონლაინ და რა თქმა უნდა სახელი PHP ინტერპრეტატორი
გვაქვს CS50, IDE.
ყველა თქვენ არის ტიპის php ფაილი.
და რა თქვენი პროგრამის ვაპირებთ გავაკეთოთ, არის ის,
აპირებს მეშვეობით თარჯიმანი, ის
ვაპირებ იგნორირება ყველაფერი, რაც არის არა შორის კითხვა mark--
ან კუთხე bracket კითხვის ნიშნის PHP, რომ PHP delimiters, და ამობეჭდოთ,
და ეს ინტერპრეტაცია და შეასრულოს კოდი შიგნით თქვენი PHP delimiters.
>> მოდით პოპ მეტი CS50 IDE და აქვს შევხედოთ რამდენიმე PHP ფაილები,
სულ რამდენიმე PHP ფაილები, ბრძანების ინტერფეისი of CS50 IDE.
ასე რომ, აქ ვართ CS50 IDE, და მე აღებული თავისუფლების
გახსნის ფაილი სახელად hello1.php.
და როგორც ჩანს, შინაარსი ამ ფაილი მხოლოდ PHP delimiters იქ,
და მათ შორის, echo ("Hello, World").
ეს არის საკმაოდ მარტივი PHP პროგრამა.
მე უბრალოდ აპირებს გადახვევა ქვემოთ ჩემი ტერმინალის ფანჯარაში აქ,
და მე ვაპირებ აკრიფოთ php hello1.php, დააჭიროთ.
Hello, world.
ეს, ალბათ, რა ვიყავით ველოდებით, რომ ეს, არა?
>> მოდით წავიდეთ და მიიღოს სხვა შევხედოთ პროგრამა.
hello2.php.
საკმაოდ ბევრი იგივე, არ არის ბევრი ხდება აქ.
ამჯერად, თუმცა, მე ვაპირებ შეეკითხება მომხმარებლის მომეცი მათი სახელები.
მე გამოყენებით, რომელიც readline ფუნქცია ერთხელ.
$ name = readline.
ეს არის სწრაფი, "რა გქვია?"
>> როგორც ჩანს მე ბეჭდვა ის საკუთარი ხაზი.
და შემდეგ, ასე ხაზის ქვემოთ რომ იქნება სწრაფი
სადაც მომხმარებელს შეუძლია შევიდეს მათი სახელი.
და მაშინ მე გამოყენებით ცოტა ცვლადი interpellation აქ ხაზი 3
ამობეჭდოთ "Hello" და რასაც მომხმარებლის ტიპის.
ასე რომ, ეს არის ანალოგიური ამბობდა, Hello, მძიმე,% s თუ ჩვენ გამოყენებით printf in C.
>> მოდით წავიდეთ და ინტერპრეტაცია ამ პროგრამის.
ასე რომ, კიდევ ერთხელ, მე გადახვევა ქვემოთ ჩემი ტერმინალის ფანჯარაში.
php hello2.php.
რა გქვია?
Doug.
Hello, Doug.
ასევე მაქვს სხვა ფაილი სახელად hello3.php.
მე ვაპირებ გარკვევა ჩემი ეკრანი კონტროლის L,
და მე ვაპირებ შეასრულოს, რომ.
რა გქვია?
Doug.
Hello, Doug.
ასე რომ, ქცევის იდენტურია hello2.php, მაგრამ რატომ არის ეს hello3.php?
>> ისე, აქ არის განსხვავება.
ამ შემთხვევაში, ცნობა რომ ხაზი 1 აქ,
მე მაქვს რაღაც რომ არ არის შორის PHP delimiters.
მე უბრალოდ ბეჭდვის out-- ან მე უბრალოდ აკრეფილი, "რა გქვია?"
როდესაც PHP ინტერპრეტატორი ხედავს, ეს ჯერ არ ვიცი, როგორ ინტერპრეტაცია, როგორც PHP,
და ასე რომ, ნაცვლად, რომელმაც ვერ შეძლო, ის უბრალოდ აპირებს შამფურზე ის.
>> ასე რომ შეამჩნია on line 3 ახლა, ჩემი მოწოდება readline, არ არსებობს დროული მთელი მსოფლიოს მასშტაბით.
მე უბრალოდ რეალურად აპირებს, რომელთა მიზანია, როდესაც PHP ინტერპრეტატორი ხედავს,
ის აპირებს ამობეჭდოთ "რა გქვია?"
მაშინ ის ხედავს, oh, OK, here's-- ყველაფერი იქნება
გაგებული, როგორც PHP, ასე რომ სწორედ ამიტომ ეს სამუშაოები.
მე არ უნდა აუცილებლად შეეკითხება მომხმარებლის რომელთა მიზანია შიგნით readline,
შემიძლია უბრალოდ გარეთ საქართველოს PHP delimiters
და საშუალებას თარჯიმანი უბრალოდ ამობეჭდოთ ჩემთვის.
>> ასე რომ, თქვენ არ რეალურად მხოლოდ აქვს ერთი კომპლექტი PHP delimiters
თქვენი პროგრამა.
თქვენ შეგიძლიათ რეალურად გვაქვს რამდენიმე მათგანი, გახსნის და დახურვის მათ, როგორც საჭიროა.
მოდით შევხედოთ დროს რამდენიმე პროგრამები
ამ CS50 IDE, სადაც ჩვენ საილუსტრაციოდ ამ იდეის მქონე
მრავალჯერადი კომპლექტი delimited PHP.
>> OK, ასე რომ მე გახსნა ფაილი აქ მოუწოდა add1.php.
და შეამჩნია, რა ხდება აქ.
ისევე, როგორც ადრე, მაქვს ერთ PHP მითითებული delimiters.
მე ვაპირებ ამობეჭდოთ გაგზავნა "გთხოვთ, მომეცი ნომერი."
ამის შემდეგ მე ვაპირებ წაკითხვის ხაზი და ჩაწეროთ იგი ცვლადი $ num1.
ამის შემდეგ მე ვაპირებ ამობეჭდოთ ერთხელ.
მომეცი მეორე ნომერი.
დაწვრილებით ხაზი შესახებ, მაღაზია რასაც ისინი აკრეფილი წელს $ num2.
სანიშნეს მათ ერთად და შესანახად, რომ გამოიწვიოს ცვლადში $ თანხა,
და შემდეგ ამობეჭდოთ, რომ " თანხა ამ ორი ნომრები
არის ", და შემდეგ interpellate არსებობს ცვლადი $ თანხა.
მოდით უბრალოდ გაუშვით ეს მეშვეობით თარჯიმანი
იმის დასადასტურებლად, რომ ეს არის ის, რაც ჩვენ ველით.
php add1.php.
გთხოვთ, მომეცი ნომერი, 3.
გთხოვთ, მომეცი მეორე ნომერი, 4.
თანხა ამ ორი ნომრები 7.
სწორედ 3 + 4.
OK?
ასე რომ, არაფერი საშინლად ლამაზი არსებობს.
>> ახლა მოდით გახსენით add2.php.
აქ, მე მივიღე რამდენიმე PHP delimited კომპლექტი, არა?
ხაზები 1 3-- ხაზების 1 და 3 არ აქვს PHP delimiters.
ასე რომ, როდესაც თარჯიმანი ხედავს მათ, უბრალოდ,
აპირებს Spit out ზუსტად რა აკრეფილი არსებობს.
ასე რომ, სადაც მე ვარ აკეთებს ყველა ჩემს რითაც.
On ხაზები 2 და 4, ჩვენ ვხედავთ, რომ ძალიან ნაცნობი $? php ერთგვარი delimiters,
ასე რომ, ეს ორი ხაზი აპირებს შეასრულოს როგორც PHP.
და მერე line 5, მე მაქვს ეს უცნაური რამ აქ, არა?
ეს კუთხე bracket კითხვის ნიშნის თანაბარი ნიშანი.
მე კი მიუახლოვდით ცოტა უფრო.
თქვენ ხედავთ, ეს არის ის, რაც მე ვსაუბრობთ აქ, ამ $? =.
>> გამოდის, რომ ეს იმდენად გავრცელებული, რომ იმის გამო, რომ ჩვენ გახსენით კომპლექტი PHP
delimiters არის ამობეჭდოთ მნიშვნელობა.
და ეს ყველაფერი ჩვენ ვაპირებთ, რომ გავაკეთოთ.
მაგრამ არსებობს კიდევ სტენოგრამის რომ.
$? = არის PHP სტენოგრამის განაცხადა, რაღაც $? php echo თანხა
საქართველოს num1 და num2.
ასე რომ, ეს არის კიდევ ერთი სტენოგრამის რომ.
>> ასე რომ, თუ მე აწარმოებს ამ პროგრამის, php add2.php.
მე zoom ქვემოთ ცოტა.
გთხოვთ, მომეცი ნომერი, 4.
გთხოვთ, მომეცი მეორე ნომერი.
მას შემდეგ, რაც მე ნამდვილად არ აინტერესებს მონაცემთა ტიპები PHP, შემიძლია ვთქვა, 4.8.
თანხა ამ ორი ნომრები არის 8.8.
ეს ფუნქცია იქცევა საკმაოდ ბევრი ზუსტად ისევე, როგორც ჩვენ ველით,
ისევე.
და მე კიდევ ერთი გახსნა აქ მოუწოდა dice.php.
სცადეთ ამ ერთხელ.
მაქვს კიდევ ერთი აქ მოუწოდა dice1.php, რომელიც ასევე, ვხედავ,
აქვს, რომ კუთხური ფრჩხილი კითხვა აღსანიშნავად თანაბარი ნიშანი notation იქ,
მაგრამ შეამჩნია, რომ ამ შემთხვევაში მე ვარ მოუწოდებენ ფუნქცია rand, რომელიც, როგორც თქვენ
შეიძლება ველოდოთ წარმოშობს შემთხვევითი ნომერი.
"თქვენ შემოვიდა," და ის აპირებს გამოთვალოთ შემთხვევითი ნომერი, mod 6 +
1.
ასე რომ ყველაფერს მომეცი ნომერი სპექტრი 1 6.
>> გახსოვდეთ, რომ mod 6 მომცემდნენ რიგი სპექტრი 0 დან 5,
მაგრამ თუ მე სიმულაცია კამათელი რულონები, რაც მე ვაკეთებ აქ,
მე არ მინდა ამ კამათელი წასვლა 0 5, მე მინდა კამათელი რომ 1-დან 6.
ასე რომ, ეს არის გზა მე სპექტრი 1 6.
მე ამით ორჯერ.
ასე რომ, როგორც ჩანს, მე მოძრავი ორი კამათელი ამ პროგრამაში.
>> ასე რომ, მე გარკვევა ჩემი ეკრანზე, და მე გავაკეთებ php dice1.php.
თქვენ შემოვიდა 4 და 2.
და თუ მე აწარმოებს პროგრამა ერთხელ, თქვენ შემოვიდა 5 და 5.
ასე რომ, ყოველ ჯერზე მე აწარმოებს პროგრამა, მე მიღების სხვადასხვა ნომრები,
იმიტომ, რომ ყოველ ჯერზე გავაკეთო ასე რომ, ის იწყებს მეტი.
ის აპირებს გენერირება ახალი მითითებული შემთხვევითი ნომრები ჩემთვის.
>> ასე რომ, თუ ჩვენ გამოიყენება გაშვებული პროგრამების C,
ჩვენ გამოიყენება აკრეფით ./ ასახელებს პროგრამა, უფლება?
სწორედ ასე ვაკეთებ ყველა ჩვენი პროგრამების C ჯერჯერობით.
ჩვენ შეგვიძლია ამის გაკეთება PHP ასევე დამატებით რაღაც მოუწოდა
shebang ზედა ჩვენი PHP ფაილი.
მე ვიცი, რომ სახის სულელური სიტყვა.
ეს არის მოკლე hash bang.
ეს არის პირველი ორი გმირები იქ.
დამახსოვრება, ჩვენ მოვუწოდებთ ძახილის წერტილი ხშირად bang კომპიუტერულ მეცნიერებათა.
იგი ასევე შეიძლება იყოს მკვეთრი bang.
არსებობს რამდენიმე გზა ინტერპრეტაცია მას.
მაგრამ ეს, ძირითადად, განსაკუთრებული სახის ბრძანება რომ PHP ინტერპრეტატორი
ესმის, როგორც, რა, მე მინდა თქვენ შეასრულოს ეს პროგრამა,
რომელიც, როგორც ჩანს / user / bin / php, რომელიც რეალურად, სადაც PHP ინტერპრეტატორი
კონკრეტულად ცხოვრობს ჩვენი სისტემა.
ასე რომ, it's--, რა ხდება აქ თარჯიმანი ესმის, oh,
მე აშკარად უნდა გამოიყენოს ამ პროგრამის გასაშვებად ეს ფაილი.
ასე რომ, ეს გაძლევთ საშუალებას გამოტოვოთ მეტი ნაბიჯი
მქონე ვთქვა, php something.php.
არსებობს ერთი დაჭერა აქ, არის ის, რომ თუ ჩვენ
მინდა ჩვენი პროგრამების მუშაობა, როგორც მოსალოდნელია, რომ ჩვენ
უნდა გავაკეთოთ რაღაც მოუწოდა ფაილი ნებართვა ცვლილება.
და ჩვენ go-- და ვსაუბრობთ პატარა ცოტა მეტი ფაილი ნებართვის ცვლილებები
ჩვენი ვიდეო MVC, მაგრამ საკმარისია ამბობენ, რომ ეს არის ის, რაც თქვენ უნდა გააკეთოთ
იმისათვის, რომ თქვენი .php ფაილი გაშვება.
მოდით შევხედოთ, როგორც ჩვენი საბოლოო მაგალითად დასრულდა CS50 IDE.
>> ასე რომ, აქ IDE მაქვს ორი ფაილი ამ PHP დირექტორია, რომელიც, როგორც ჩანს, არ უნდა იყოს
მოუწოდა .php.
მაქვს ფუნქცია მოუწოდა add-- მე მაქვს ფაილი სახელად add3
და ფაილი სახელად dice2.
მოდით მიიღოს სწრაფი გამოიყურება და გახსენით add3.
და როგორც ხედავთ, დასაწყისში ჩემი ფაილი მაქვს ამ shebang, არა?
ეს hash ნიშნის ძახილის წერტილი.
ახლა, თქვენ ასევე შესაძლოა შეამჩნია, რომ რატომღაც,
მე არ მაქვს არანაირი სინტაქსი ხაზს უსვამს აღარ,
და ეს არის ის, რაც მე გააკეთა მინიშნება ადრე, რაც იყო, რომ თუ მე არ ასახელებს ჩემი ფაილი
php, მე არ ექნებათ სინტაქსის შეფერადება მთელი მსოფლიოს მასშტაბით.
ეს ნამუშევარი უბრალოდ მოუწოდა add3.
ასე რომ, შემიძლია გაუშვით მოგვიანებით ერთად ./ add3 და არა ./ add3.php.
>> ასე რომ, reason-- ეს ჯერ კიდევ ჯარიმა, ეს ჯერ კიდევ ძალაშია PHP,
მაგრამ ეს არ სინტაქსის მონიშნულია, რადგან ეს ფაილი არ არის მოუწოდა something.php.
ეს არის ერთადერთი რეალური განსხვავება აქ, პლუს shebang.
მოდით ვნახოთ, რა მოხდება, როდესაც მე ვცდილობ და გაუშვით ეს პროგრამა.
./ Add3, ისევე, როგორც მე ამას C. Bash.
./ Add3 ნებართვა მიეცა.
ეს არის ის, რაც თქვენ ვაპირებთ თუ თქვენ დაგავიწყდებათ
გამოიყენოს chmod ბრძანება შეცვალოს ნებართვების ფაილი.
>> როგორც ირკვევა, რეგულარული PHP ფაილი არ შეუძლიათ უბრალოდ იყოს შესრულებული.
ისინი შეიძლება იყოს გაგებული, მაგრამ ჩვენ აკეთებს რაღაც ცოტა განსხვავებული აქ.
ჩვენ შესრულებაში მას.
ასე რომ, მე უნდა დაამატოთ ნებართვა აღსრულების, chmod + x to add3.
მაშინ შემიძლია ვთქვა ./ add3.
გთხოვთ, მომეცი ნომერი.
5, 6.
თანხა ამ ორი ნომრები 11.
>> ანალოგიურად, მე უკვე chmoded dice2, ასე რომ, შეგიძლიათ უბრალოდ აკრიფოთ ./ dice2,
თქვენ შემოვიდა 1 და 1, შემოვიდა 5 და 4, და ასე შემდეგ.
>> ასე რომ, საკმაოდ ბევრი იდეა PHP სინტაქსი, არა?
არსებობს ბევრი მისაღებად მეშვეობით, ვიცი.
მაგრამ იმედია, რომ თქვენ ვნახე ახლა, რომ PHP ნამდვილად არ არის, რომ განსხვავებული C
და ნამდვილად გვაძლევს შესაძლებლობას მიიღოს რამ up მაღალი დონის ან ორი.
ჩვენ ნამდვილად არ უნდა ფიქრი ძალიან ბევრი ამაზე ჩვენ ნამდვილად არ
უნდა ინერვიულოთ ძალიან ბევრი შესახებ დაბალი დონის დეტალები ჩვენ
ჰქონდა ფიქრი C, არა?
ჩვენ შეგვიძლია ფოკუსირება უმაღლესი დონე პერსონალის, რომ PHP
საშუალებას გვაძლევს გავაკეთოთ და მიიღოს თავისთავად, რომ ეს იქნება ჩვენთვის მუშაობა.
ასე რომ, ეს გვაძლევს შესაძლებლობას, ახლა, გადასვლის C PHP,
რათა პროგრამები, რომლებიც ბევრად უფრო რთული და ალბათ ბევრი უფრო ძლიერი.
>> ასე რომ, იმედი მაქვს, რომ თქვენ გაქვთ fun სამუშაო PHP, და მე Doug Lloyd.
ეს არის CS50.