>> [მუსიკალური სათამაშო]
>> ERIC Ouyang: Hey, ყველას.
მივესალმებით.
ეს არის სამშენებლო Dynamic ვებ აპლიკაციების Laravel.
ჩემი სახელი არის Eric Ouyang.
მე ვარ მეორე კურსის შესწავლა სოციალური კვლევები ერთად საშუალო კომპიუტერულ მეცნიერებაში,
და ვცხოვრობ Adams სახლი აქ ჰარვარდის.
>> ასე Laravel, მისი ყველაზე ძირითადი, არის MVC web app ფარგლებში.
ისე მომწონს, რა ბიჭები უკვე აკეთებს CS50 ფინანსთა,
Laravel არის ჩარჩო, რომელიც საშუალებას აძლევს თქვენ უნდა ავაშენოთ დინამიური ვებ apps.
ასე რომ თქვენ შეგიძლიათ ვფიქრობ, რომ ზოგიერთ გრძნობს როგორც გაგრძელების ტიპის პერსონალის
თქვენ უკვე აკეთებს CS50 ფინანსთა, მაგრამ სისტემა, რომელიც
ბევრი უფრო ძლიერი, ბევრი უფრო დახვეწილი ზოგიერთ გრძნობს,
და უზრუნველყოფს ბევრი ფუნქციონალური თქვენ
აშენება საკმაოდ რთული ვებ პროგრამა.
მოდით წავიდეთ მეშვეობით ძირითადი მახასიათებლები,
და მაშინ ჩვენ ჩაყვინთვის შევიდა მაგალითად მშენებლობის წაკითხვა
განაცხადის Laravel.
>> ასე რომ, ერთი პირველი რამ, რომ განასხვავებს მას MVC ტიპის მუშაობა
რომ თქვენ უკვე აკეთებს CS50 არის იგი მოიცავს ORM სისტემა.
ასე ORM დგას ობიექტი რელატიური რუკების.
ასე რომ, ეს საშუალებას გაძლევთ აშენება ფენა აბსტრაქცია
შორის მონაცემთა ბაზაში და კონტროლერები.
ასე რომ განსხვავებით CS50 ფინანსთა სადაც პირდაპირ რათა შეკითხვებს,
ORM ფენა საშუალებას გაძლევთ აბსტრაქტული რომ მოშორებით და შექმნას
მოდელები, რომელიც უფრო ძლიერი ვიდრე შეგიძლიათ პირდაპირ SQL შეკითხვებს.
>> სხვა საქმეა, რომ მართლაც სასარგებლო მემკვიდრეობით თარგები.
ასე რომ თქვენ შეამჩნევთ CS50 ფინანსთა, თქვენ დასრულდება მდე გადაწერა ბევრი რამ,
სადაც განათავსებს თქვენ შესაძლოა reuse რამ, რომ თქვენ არ შეუძლია.
ასე რომ აქ Laravel, შეგიძლიათ გამოიყენოთ, რა არის ცნობილია, როგორც დანა თარგი ძრავა
შექმნათ საძიებო განლაგებას.
და იქიდან, შეგიძლიათ მემკვიდრეობით ასე რომ sub-templates შეგიძლიათ რეალურად
მოიცავს ელემენტები რომ დიდი ბაზა თარგი.
>> მიგრაცია.
ასე რომ, ეს არის საკმაოდ სტანდარტული ფუნქცია ყველაზე თანამედროვე ვებ განაცხადის ფარგლებში.
ასე რომ, ეს გაძლევთ საშუალებას წარმოადგენს მონაცემთა ბაზის სქემა ცვლილებები კოდი.
ისე, რომ ვაპირებთ ამბობენ, phpMyAdmin, თქვენ შეგიძლიათ რეალურად შექმნა ამ მიგრაცია
სადაც თქვენ წარმოადგენს მონაცემთა schema იცვლება კოდი პირდაპირ.
და ეს საშუალებას გაძლევთ, რომელთა მიზანია განსაკუთრებით თუ თქვენ გაქვთ რამოდენიმე ადამიანი მუშაობს
იმავე ვებ application-- აკონტროლოთ ეს ცვლილებები,
ამბობენ, GitHub, ან სხვა საცავში.
>> ასე რომ, ეს მართლაც სასარგებლო და ამცირებს საჭიროება
, ვთქვათ, გაივლის გარშემო ბევრი SQL ნესტიანია.
და ბოლოს, კომპოზიტორი რაღაც მართლაც, მართლაც სასარგებლო
რომელიც საშუალებას გაძლევთ გამოიყენოთ სხვა ხალხის კოდი უნდა გავაკეთოთ რა რამ.
ასე Laravel ს სტრუქტურა რამდენიმე კომპოზიტორის პაკეტები.
ასე, რომ თუ სურდა, რათა in ავტორიზაციის პაკეტი
ან თუ უნდოდა, რათა ზოგიერთი სახის გენერატორი script ან admin
ინტერფეისი, შეგიძლიათ დანამატი და თამაში იმ კომპონენტს კომპოზიტორი.
>> ასე რომ, მოდით დავიწყოთ.
ნებისმიერ კითხვაზე თქვენ ბიჭები სანამ ჩვენ უნდა დავიწყოთ?
კითხვები არ?
მაგარი.
ასე რომ, პირველი ნაბიჯი არის დაყენების კომპოზიტორი.
ასე Composer საშუალებას გაძლევთ მართოს ეს დამოკიდებულებები,
თუ არა ეს Laravel ფარგლებში ან რაიმე სხვა მესამე მხარის გაფართოება.
პირველი ბრძანებას იძლევა თქვენ უნდა ჩამოტვირთოთ კომპოზიტორი,
და მეორე ბრძანება საშუალებას გაძლევთ გადაადგილება მას თქვენს ადგილობრივ bin ფოლდერი
ასე რომ თქვენ შეგიძლიათ აწარმოებს Composer პირდაპირ ტერმინალში.
>> ამის შემდეგ, წავიდეთ წინ და შექმნა ახალი Laravel პროექტი.
ჩვენ რეალურად აპირებს გამოყენება ზოგიერთი მაგალითი კოდი
რომ მე დააყენა ერთად შექმნა ამ დღიურში.
მაგრამ თუ თქვენ დაწყებული ნულიდან, შეგიძლიათ გამოიყენოთ ეს ბრძანება
აქ, კომპოზიტორი შექმნა პროექტი, laravel სლეში laravel და შემდეგ
სახელი თქვენი პროექტი.
და რომელიც მოიცავს ყველა განაწილების კოდი
დაწყების ახალი Laravel პროექტი.
ასე რომ, თქვენი CS50 საბოლოო პროექტი, თქვენ ალბათ გინდათ გამოიყენოთ ეს ბრძანება.
>> მაგრამ ჩვენ ვაპირებთ დავიწყოთ ამ.
ასე ერთხელ თქვენ კეთდება ის, რომ თქვენ აპირებთ მისაღებად
საკმაოდ ვრცელ ნომერი ფაილი blog50.
მოდით უბრალოდ გავლა ზოგიერთი კომპონენტი.
თქვენ შეამჩნევთ, რომ ეს მარშრუტი დირექტორია, არის app ფოლდერში.
შიგნით app ფოლდერში, არსებობს რამდენიმე სასარგებლო ფოლდერები.
შენიშვნა უნდა დაიწყოს ეს არის config საქაღალდე.
ასე რომ, ეს ქმნის როგორ თქვენი ვებ განაცხადის
აპირებს, ვთქვათ, სინამდვილის ადამიანი ან ნაღდი რამ ან დაკავშირება მონაცემთა ბაზა.
>> და რა არის ნამდვილად სასარგებლო ის არის, რომ Laravel
გაძლევთ საშუალებას შექმნას სხვადასხვა განვითარების გარემოში.
ასე, რაც ჩვენ გავაკეთეთ, აქ არის თუ ჩვენ წავიდეთ ქვეშ ადგილობრივი საქაღალდეში,
არსებობს database.php ფაილი.
და თქვენ შეამჩნევთ, რომ ჩვენ აქ შეიქმნა MySQL დაკავშირებით, რომ
საშუალებას აძლევს პირებს დაკავშირება MySQL სერვერზე, რომ
პირდაპირ CS50 ელექტრო მოწყობილობების.
და ჩვენ დამაკავშირებელი მონაცემთა რომ მე შეიქმნა ე.წ. Blog50.
>> მოდით რეალურად წავიდეთ წინ და აწარმოებს სამუშაო ვერსია,
მხოლოდ მისაღებად გრძნობა რა პროგრამა, რომელიც ჩვენ ვაშენებთ
ჰგავს.
ასე მაქვს ასლი ამ Blog50 დასრულდა.
ასე Laravel რეალურად ააშენა სერვერზე
რომ თქვენ შეგიძლიათ აწარმოებს პირდაპირ საწყისი ბრძანებათა სტრიქონიდან.
ასე რომ, ეს არის მსგავსი PSet ადრე, როდესაც თქვენ ნამდვილად
ავაშენოთ თქვენი საკუთარი სერვერზე C. ასე რომ, ისინი ერთი აგებულია ისე,
რომ თქვენ შეგიძლიათ აწარმოებს თქვენი Laravel apps პირდაპირ ბრძანებათა სტრიქონიდან.
>> ასე რომ, თუ ჩვენ გავაკეთებთ php ხელოსანთა ემსახურება, ამ დაიწყებს განვითარებას სერვერზე
პორტის 8,000.
ასე რომ, თუ ჩვენ წასვლა ადგილობრივი მასპინძელი 8000, შეამჩნევთ, რომ, hey.
ჩვენ გვაქვს ჩვენი ბლოგი და გაშვებული.
ასე Laravel აქ მომტანი წინა გვერდი ჩვენი ბლოგი.
ძალიან მარტივი პროგრამა.
მაგრამ არსებობს რამდენიმე მართლაც nifty თვისებები
რომ ის უზრუნველყოფს ქვეშ hood.
>> ასე წაკითხვა განცხადების პირდაპირი.
თუ გვინდოდა, რომ შევქმნათ ჩანაწერი, ჩვენ შეგვიძლია დააჭირეთ ღილაკს.
შეიძლება ითქვას, რომ "Hey, ყველას.
ეს არის მართლაც fun სემინარი ", მაგალითად.
და რაღაც დავწერო ქვემოთ აქ.
ტექსტის აქ.
თუ ჩვენ დააჭირეთ წარმოადგინოს, თქვენ შეამჩნევთ, რომ ჩვენი ახალი ბლოგი
პოსტი დაემატა წინა გვერდი წაკითხვა.
თუ ჩვენ დავბრუნდებით აქ, თქვენ შეამჩნევთ, რომ არსებობს გარკვეული კომენტარი უკვე
ბლოგზე.
ასე რომ, თუ ჩვენ გადახვევა ქვემოთ, თქვენ შეამჩნია, რომ ჯონათან Tan ამბობს
რომ იგი ძალიან დაინტერესდა ამ პოსტის.
>> ასე რომ, ჩვენ წასვლას როგორ ობიექტი რელატიური რუკების საშუალებას
თქვენ უნდა გავაკეთოთ ამ ურთიერთობების საკმაოდ seamless გზა, ისევე.
მაგარი.
რაიმე შეკითხვები ფუნქციონირებისთვის რასაც ჩვენ ვაპირებთ აშენება?
მაგარი.
მაშ ასე, დავიწყოთ ერთად რეალურად ქმნის მონაცემთა ბაზის ცხრილები.
>> ასე რომ გავიხსენოთ, რომ CS50 ფინანსთა, თქვენ ერთად მაგიდა ასაკი
ისევე როგორც აქციების თქვენს გადააჭარბა.
ასე რომ, როგორც ზემოთ ავღნიშნეთ, რაც ჩვენ ვიყენებთ Laravel
არის რაღაც ცნობილი როგორც მიგრაცია.
ასე რომ, თუ ჩვენ დაბრუნდეს განაწილების კოდი აქ,
პირველი ბრძანება, რომ სასარგებლოა, რომ Laravel საშუალებას გაძლევთ
ეს არის მიგრაცია ბრძანება.
ამიტომ ჩვენ შეგვიძლია გავაკეთოთ php ხელოსანთა მიგრაცია: მიიღოს.
ასე რომ, ეს საშუალებას გვაძლევს შევქმნათ მიგრაციის.
>> და მაშინ ჩვენ გვინდა შექმნათ მიგრაციის
მოუწოდა create_posts_table, რომელიც აპირებს
იქნება, სადაც ჩვენ ვაპირებთ იყოს შენახვის ჩვენი დღიურში შეტყობინება.
და თქვენ შეამჩნევთ აქ, რომ ის მუშაობს მეშვეობით რამდენიმე კოდი, რომელიც რეალურად
ქმნის ფაილი დრო ბეჭედი იგი.
ასე რომ, თუ ჩვენ წავიდეთ და შევხედოთ ბაზა, ჩვენ შეამჩნევთ ფარგლებში მიგრაციისა
რომ ის შექმნა ცარიელი ფაილი ჩვენთვის, რომელიც
აქვს boilerplate კოდი, სახელი რომ ჩვენ მითითებული, შექმნა შეტყობინება მაგიდასთან.
>> და მას აქვს ორი ფუნქცია მას.
Up არის ის, რაც ჩვენ გვინდა, რომ როცა მიგრაციის გამოიყენება მონაცემთა ბაზაში.
და ქვემოთ არის ის, რაც ჩვენ ვაპირებთ გავაკეთოთ როდესაც ჩვენ გვინდა, რომ შეცვალოს მიგრაცია.
ასე რომ, აქ მოდით დავიწყოთ წერის ეს მიგრაცია.
ასე რომ, არსებობს სასარგებლო კლასი in Laravel მოუწოდა Schema.
>> ასე რომ, ჩვენ ვაპირებთ აწარმოებს Schema :: შექმნა.
და ჩვენ ვაპირებთ, რომ შევქმნათ მაგიდა სახელწოდებით შეტყობინება.
და აქ ჩვენ ვრცელდება ამ გამოყენებით ფუნქცია.
და შიგნით აქ, ჩვენ ვაპირებთ, რომ რეალურად დაზუსტება შინაარსი ჩვენს მაგიდასთან.
ჩვენ ვაპირებთ, რომ შევქმნათ ID, რომელიც auto-ზრდა.
>> გარდა ამისა, ჩვენ ვაპირებთ შექმნათ სფეროში, რომელიც
წარმოადგენს ტიტული ჩვენი დღიურში.
ჩვენ ასევე ვაპირებთ შევქმნათ სფეროში შენახვის ტექსტში ჩვენი დღიურში.
და ბოლოს, ჩვენ ვაპირებთ შესანახად ზოგიერთი timestamps
მაშინ, როდესაც ჩვენი პოსტი შეიქმნა და როდესაც ის მხრიდან.
და down, ეს საკმაოდ მარტივია.
ყველა ჩვენ გვინდა, რომ არის drop მაგიდასთან რომ ჩვენ შევქმენით.
>> დიდი.
ნებისმიერი კითხვები?
ასე რომ, ახლა თუ ჩვენ წავიდეთ წინ and-- რეალურად, ადგილობრივი მასპინძელი,
ნება მომეცით წაშლა რა გვქონდა ადრე.
წასვლა მონაცემთა ბაზა.
მე ვაპირებ წაშლა რა გვქონდა ადრე.
ვარდნა ამ და შექმნას ახალი ბაზა Blog50.
ასე რომ, ახლა რა ჯადოსნური ნაწილი არის, რომ ჩვენ აქ
შეიძლება გამოიყენოს ეს მიგრაცია პირდაპირ მონაცემთა ბაზაში გამოყენებით ბრძანების
ინსტრუმენტი.
ასე რომ, თუ ჩვენ გავაკეთებთ php ხელოსანთა მიგრაცია, თქვენ შეამჩნევთ, რომ, hey.
ის შეიქმნა მიგრაციის მაგიდა, რომელიც ჩვენ შევხედოთ ცოტა,
და ის იყენებს ამ პირველი მიგრაცია.
>> ასე რომ ჩვენ Blog50, თქვენ შეამჩნევთ რომ ის შექმნილია ორი მაგიდები ჩვენთვის.
პირველი არის ის, მიგრაცია მაგიდასთან.
ასე რომ, თუ ჩვენ დაათვალიეროთ ამ, თქვენ შეამჩნევთ, რომ ამ მაგიდასთან არის საკმაოდ მარტივია.
ის უბრალოდ განაცხადა, რომ, hey.
ჩვენ მივმართეთ ეს მიგრაცია.
ჩვენ დავბრუნდებით და შევხედოთ შეტყობინება.
თქვენ შეამჩნევთ, რომ სტრუქტურა არის ზუსტად ის, რაც ჩვენ სთხოვა მას.
ჩვენ გვაქვს ავტო დამატება ID.
ჩვენ გვაქვს სიმებიანი შენახვის სათაური, და ტექსტური ველი
შენახვის შინაარსი.
დიდი.
მაგარი.
რაიმე შეკითხვები მიგრაცია მუშაობა, თუ როგორ უნდა გამოვიყენოთ ისინი?
არა?
მაგარი.
ასე რომ, ახლა ჩვენ ვაპირებთ წავიდეთ წინ და რეალურად შექმნა მოდელი.
ასე რომ, ჩვენ გვინდა შევქმნათ შეტყობინება მოდელი, რომელიც ინახავს აბსტრაქცია მონაცემთა ბაზაში.
ასე რომ, ვიდრე აკეთებს MySQL queries პირდაპირ, ჩვენ ვაპირებთ, რომ შევქმნათ.
ასე რომ, ჩვენ უნდა შევქმნათ საქაღალდეში მოუწოდა მოდელები.
და შიგნით აქ, ჩვენ ვაპირებთ შევქმნათ ფაილი სახელად post.php.
>> შიგნით ამ PHP ფაილი, ჩვენ ვაპირებთ, რომ შევქმნათ
კლასი ჩანაწერი, რომელიც ვრცელდება მჭერმეტყველი.
მჭერმეტყველი არის სახელი ORM ძრავი, რომელიც Laravel უზრუნველყოფს.
და აქ, ჩვენ შეიძლება ველოდოთ, რომ თქვენ რეალურად უნდა დაწეროთ რამდენიმე კოდი.
ჩვენ ვაპირებთ დავწეროთ ზოგიერთი დამხმარე ფუნქციები შემდეგ.
მაგრამ იმ ყუთში, ეს იქნება უკვე აღიარებს რა არის მონაცემთა ბაზაში
და ჩვენ შეუძლია, ვთქვათ, ტექსტი ჩვენი დღიურში ან სათაური,
და შექმნას პერსონალის პირდაპირ საკმაოდ ბევრი არ კოდი განაწილებაზე.
>> ისე, რომ ერთ-ერთი მაგიური კომპონენტები.
და ქარი ერთხელ ამ კლასში უფრო სრულფასოვანი,
ჩვენ მოიცავს ინფორმაციას, თუ რა ეს დაკავშირებული, ამიტომ კომენტარი.
ასევე შექმნათ ფუნქცია ასე რომ, ჩვენ შეიძლება რეალურად
პირდაპირ URL of დღიურში გვერდზე.
მაგარი.
რაიმე შეკითხვები, რომ?
პოსტები
მაგარი.
>> ახლა კიდევ ერთხელ, ჩვენ გვაქვს ჩვენი მოდელი, ჩვენ გსურთ შექმნათ კონტროლერი, რომ
შეუძლია ინტერფეისი ამ მოდელების, და შემდგომში მონაცემთა ბაზაში.
ასე რომ, თუ ჩვენ შევხედოთ BlogController, თქვენ
შეამჩნია, რომ იქ არ არის ბევრი აქ ახლა.
ყველა იქ არის ეს მაჩვენებელი ფუნქცია რომელიც ქმნის მთავარ გვერდზე,
მაგრამ გარეშე არაფერი არსებობს ცარიელია ამჟამად.
>> ასე რომ, პირველი ფუნქცია ჩვენ ვაპირებთ, რომ შევქმნათ
ერთ-ერთი, რომელიც საშუალებას გვაძლევს შევქმნათ დღიურში.
ამიტომ, ჩვენ ვაპირებთ, რომ განაცხადოს ახალი ფუნქცია მოუწოდა newPost.
და შიგნით აქ უბრალოდ, ჩვენ ვაპირებთ მითითებული განლაგება ამ გვერდზე
იყოს გაწევა ვერსია, თუ გავიხსენებთ CS50,
ამ თარგის მოუწოდა blog.new, რომელიც ჩვენ ვაპირებთ, რომ შევქმნათ ცოტა.
>> თქვენ შეამჩნევთ აქ on line ექვსი, რომ ჩვენ მითითებული ამ ცვლადი, განლაგებას.
და თუ ჩვენ შევხედოთ იმ ნახვები საქაღალდეში,
არსებობს დაბრუნება საქაღალდეში, რომელიც მოიცავს ძალიან ძირითადი HTML ფაილი.
და შენიშვნა, თქვენ შეამჩნევთ რომ ჩვენ გვაქვს ეს კონტეინერი
აქ რომ უკომპრომისო შინაარსი.
ასე შიგნით ჩვენი template ის, რასაც ჩვენ ვაპირებთ, რომ
შექმნათ რა იქნება მწვრთნელის უშუალოდ ამ განლაგებას.
>> ჩვენ ვთქვით, რომ ჩვენ გვინდა გაწევა თარგი მოუწოდა blog.new.
მაგრამ შიგნით დღიური, არსებობს არ არის ახალი template.
ამიტომ ჩვენ ვაპირებთ შევქმნათ ფაილი სახელად new.blade.php.
ეს ეუბნება Laravel რომ ამ PHP ფაილი უნდა
გასაწევი ერთად დანა template ძრავა.
ასე რომ, ეს არის საკმაოდ მარტივია ფაილი.
ეს იქნება ფორმა, რომლითაც ჩვენ რეალურად რჩეულებში დღიურში.
>> ამიტომ Magic აქ მემკვიდრეობა, რომ, hey.
ჩვენ გვინდა დააკონკრეტა, რომ განყოფილებიანი, შინაარსი განყოფილებაში
აქ, რომელიც განსაზღვრავს bysection დაstop.
რა არის შორის აქ აპირებს უნდა შეიცვალოს შევიდა საძიებო განლაგებას.
და აქ რა გვინდა გავაკეთოთ არის ძალიან მარტივად შექმნათ ახალი HTML ფაილი.
მოდით უბრალოდ დაამატოთ სწრაფი ტიტული.
დამატება დღიურში.
და მის ფარგლებში, ჩვენ აპირებთ შექმნათ ფორმა.
>> ამ ფორმით აპირებს action.
და ეს იქნება რაღაც რომ ჩვენ შეიცვალა მოგვიანებით,
და ვნახავთ, თუ როგორ routing ჯდება აქ.
მაგრამ ჩვენ უბრალოდ აპირებს განსაზღვროს ახლა რომ ეს მიდის URL მარშრუტის
საწყისი createPost.
და მაშინ ეს აპირებს აქვს მეთოდი პოსტი.
ფარგლებში აქ, ჩვენ ვაპირებთ აქვს ორი სფეროებში.
Div class = "ფორმა, ჯგუფი".
>> ჩვენ გამოყენებით ჩატვირთვის CSS ბიბლიოთეკა გულმოწყალედ გათვალისწინებული Twitter.
ასე რომ, ჩვენ ვაპირებთ, რომ შევქმნათ ორი.
ასე რომ, ეს პირველი შეყვანის იქნება ტიტული.
ამიტომ შეყვანის name = "სათაური".
Class = "FormControl".
Type = "text".
მე ვაპირებ დაამატოთ placeholder = "სათაური".
>> და მერე მეორე იქნება ტექსტის ტერიტორიაზე.
სახელი = "შინაარსი".
Class = "FormControl".
და placeholder = "დაწერეთ აქ".
იქ ჩვენ წავიდეთ.
და ბოლოს, ჩვენ ვაპირებთ რჩეულებში სწრაფი ღილაკს.
Type = "წარუდგინოს" class = "btn btn პირველადი".
ეს არის ყველა მახასიათებლები ჩატვირთვის ასე
რომ ეს შეიძლება იყოს ასახული გარეთ ისე, რომ
მტაცებელი შესახებ, ვიდრე შიშველი HTML.
>> ასე ჩვენ განსაზღვრული კონტროლერი აქ.
ჩვენ განსაზღვრული ძალიან მარტივი ხედი.
მაგრამ რა აკლია არის შემაერთებელი ქსოვილის.
ამრიგად, ამ ეტაპზე, Laravel არ ვიცი როგორ
ჩვენ ვაპირებთ, რომ რეალურად წვდომისათვის ეს კონტროლერი.
ასე რომ, ეს განსაზღვრულია ფაილი სახელად routes.php.
და ახლა, ჩვენ გვაქვს ერთი მარშრუტი.
რაც არის, როდესაც ჩვენ წასვლა მთავარი გზა ამ ნახვა,
ის აპირებს გამოიტანოს ინდექსი კონტროლერი.
ასე რომ, აქ რაც ჩვენ უნდა გავაკეთოთ, არის განახორციელოს ახალი მარშრუტის შექმნათ ჩანაწერი.
>> ასე რომ, ჩვენ ამ მეთოდის გამოყენება მიიღოს, რომელიც განსაზღვრავს
რომ როდესაც მომხმარებელი ცდილობს მიიღოს ამ page-- კონკრეტულად
პოსტი სლეში new page-- ის, რასაც ჩვენ ვაპირებთ, რომ
არის გამოიყენოს კონტროლერი მოუწოდა BlogController ახალი პოსტი.
ერთი, რომ ჩვენ შევქმენით.
და მაშინ ჩვენ ვაპირებთ to Alias ​​ეს როგორც newPost.
ჩვენ ვაპირებთ, რომ შევქმნათ ერთი ფუნქცია ცოტა.
მაგრამ რა არის აქ ქვეშ გასაღები ", როგორც" არის ის, რაც
ჩვენ შეგვიძლია ჩავანაცვლოთ ფარგლებში ჩვენი Blade თარგები.
ასე რომ, ახლა, მოდით, რეალურად ასევე აცხადებენ, რომ მარშრუტი.
ასე რომ, ჩვენ ასევე ვაპირებთ შექმნათ კონტროლერი
ასე რომ ჩვენ შეგვიძლია შევქმნათ ამ ფორუმზე.
ასე რომ, თუ მომხმარებლის პოსტები გვერდზე პოსტი სლეში ახალი, რასაც ჩვენ ვაპირებთ, რომ გავაკეთოთ,
არის იყენებს კონტროლერი ჩვენ ვაპირებთ, რომ შევქმნათ ერთხელ
მოუწოდა BlogController at createPost.
და ჩვენ ვაპირებთ alias ეს, როგორც createPost.
მაგარი.
>> ნებისმიერი კითხვები?
მაგარი.
მოდით აწარმოებს, რა გვაქვს ჯერჯერობით.
ასე რომ, თუ ჩვენ გავაკეთებთ php ხელოსანთა ემსახურება, ვნახავთ უამრავი შეცდომები.
ასე გამოიყურება ჩვენ გვაქვს სინტაქსური შეცდომა მარშრუტების ხაზი 27.
Ah.
დაკარგული მძიმით.
ასე რომ, თუ ჩვენ წასვლა 8000, დაინახავთ არაფერი აქ არ არის.
ასე რომ, ეს არის default მთავარ გვერდზე.
>> მაგრამ თუ ჩვენ წასვლა პოსტი სლეში ახალი, hey.
ეს იქნება ისეთი ფორმა, რომელიც ჩვენ შევქმენით.
ახლა, ჩვენ არ გვაქვს განხორციელებული ფუნქციონალური
როდესაც ჩვენ დააჭირეთ ღილაკს.
ასე რომ, თუ ჩვენ დააჭირეთ Submit ღილაკს, ის აპირებს, რომ აწარმოებს შეცდომა.
მაგრამ ჩვენ ვაპირებთ კოდი, რომელიც ახლა, ზუსტად ის რასაც ჩვენ
გსურთ, როდესაც პროფაილი წარუდგენს ამ ფორმით.
>> მოდით გავაკეთოთ, რომ.
დაბრუნდეს კონტროლერები ფაილი.
რასაც ჩვენ ვაპირებთ გავაკეთოთ არის განახორციელოს ამ ახალი ფუნქცია
რომელიც საშუალებას გვაძლევს შევქმნათ პოსტი.
განაცხადოს ახალი ფუნქცია.
საჯარო ფუნქციას createPost.
და ეს ფუნქცია იქნება ცოტა უფრო დახვეწილი ვიდრე ის, რაც
ჩვენ გვქონდა ადრე.
მაგრამ დაინახავთ, რომ ჩვენ აქ არ ვართ აპირებს რეალურად დაწეროთ ნებისმიერი SQL.
ORM, მჭერმეტყველი ORM, აპირებს საშუალებას
ჩვენთვის ამის გაკეთება ზოგიერთ გზები უფრო დახვეწილი გზა.
>> ასე რომ, ჩვენ ვაპირებთ, რომ შევქმნათ ახალი პოსტი.
და აქ ჩვენ instantiating ახალი ობიექტი
საწყისი მოდელი, რომელიც ჩვენ უბრალოდ განთავსებულია შემდგომი მოდელი.
და რასაც ჩვენ ვაპირებთ გავაკეთოთ არის სათაური ატრიბუტი ამ გამოყენებით რაღაც
რომ ვიღებთ სერვერზე.
ასე რომ, ეს არის მსგავსი რა ჩვენ გვქონდა ადრე CS50 ფინანსთა
სადაც ჩვენ ყველაფერს გააკეთებს, გამოყენებით Super Global Post ეძებს ტიტული.
>> ასე Laravel უზრუნველყოფს ზოგიერთი სანიტარული და whatnot გამოყენებით ამ დამხმარე ფუნქცია.
ასე რომ, ჩვენ ურჩევნია გამოიყენოს ეს ნაცვლად სწორედ ამ ძირითადი ნედლეული ფორმით PHP.
და შემდეგ, რასაც ჩვენ ვაპირებთ გავაკეთოთ არის შინაარსი მას შეყვანის მიიღოს შინაარსი.
ჩვენ რეალურად აპირებს გადაიტანოთ ეს სასარგებლო ფუნქცია
რომ PHP უზრუნველყოფს მოუწოდა nl2br, რომელიც გამოდის ახალი ხაზები, nls, შევიდა BRS, შესვენებები,
ასე რომ ჩვენ შეგვიძლია რეალურად აქვს სხვადასხვა პუნქტები ფარგლებში.
და ბოლოს, რასაც ჩვენ ვაპირებთ უნდა გავაკეთოთ არის გადარჩენა ამ პოსტის.
ასე რომ, ჩვენ მოვუწოდებთ ფუნქცია გადარჩენა ამ მოდელის.
ჩვენ ვაპირებთ, რომ გადავარჩინოთ პოსტი.
და ბოლოს, რასაც ჩვენ ვაპირებთ, რომ გავაკეთოთ, არის გადამისამართება შესახებ კონკრეტულად
მარშრუტი, რომელიც ჩვენ ვაპირებთ შექმნა მოკლედ, alias მიერ viewPost.
და ჩვენ ვაპირებთ კორიდორი არგუმენტები id, როგორც id ამ ახალი პოსტი.
>> დიდი.
ასე რომ, ახლა თუ ჩვენ რეალურად წასვლა და აწარმოებს ამ.
ჩვენ ვაპირებთ, რომ დაამატოთ ახალი პოსტი.
ვთქვათ, ეს არის სემინარი 50.
და ვთქვათ, რა თქმა უნდა.
Asdl.
როგორიც არ უნდა იყოს.
გარკვეული შინაარსი.
და წარუდგინოს იგი.
და ჩვენ შეამჩნევთ, რომ, hey. მარშრუტების არ არის განსაზღვრული.
მაგრამ თუ ჩვენ შევხედოთ phpMyAdmin და ვეძებოთ თუ არა ჩვენი ფუნქცია
არაფერი.
შეხედეთ Blog50 შეტყობინება.
ჩვენ შეამჩნევთ, რომ, hey.
ფაქტობრივად, ჩვენ არ უნდა შევქმნათ, რომ წაკითხვა პოსტი ერთად timestamps მითითებული.
>> ასე რომ, ახლა მოდით დავუბრუნდეთ და რეალურად შექმნა ეს სხვა ფუნქცია ჩვენს კონტროლერი,
კონკრეტულად viewPost კონტროლერი.
ასე საზოგადოებრივი ფუნქცია viewPost.
ასე რომ, აქ, რასაც ჩვენ გავაკეთებთ, ნაცვლად რომელსაც ცარიელი ფრჩხილები
ჩვენ გვინდა, რომ გაივლის პირადობის პოსტი, რომ ჩვენ შექმნის.
და აქ, რასაც ჩვენ ვაპირებთ, რომ რეალურად შეკითხვის მონაცემთა ბაზა მას.
>> ასე რომ, თუ ჩვენ არ შეგიძლიათ, არსებობს ფუნქცია მოუწოდა
ს, რომელიც საშუალებას გვაძლევს შეკითხვის მას ID.
კერძოდ, რეალურად, ჩვენ ვაპირებთ გამოიყენონ ალტერნატიული ვერსია ამ ე.წ.
ს ან Fail, რომელიც საშუალებას გვაძლევს დატოვა ამ ფუნქციის,
იმისათვის, რომ გამონაკლისი, თუ ID ჩვენ გაივლის, არ არსებობს.
და მაშინ ჩვენ ვაპირებთ, რომ რამე მსგავსი, რაც ჩვენ გავაკეთეთ ადრე
სადაც ჩვენ მითითებული შინაარსი ამ გვერდზე უნდა იყოს
გაწეული ვერსია ამ ახალი ხედვა რომელიც ჩვენ ვაპირებთ, რომ შევქმნათ, blog.view.
>> და ჩვენ ვაპირებთ გაივლის შევიდა it-- ისევე, როგორც CS50 გაწევა
ფუნქცია ლექსიკონი ცვლადები.
გასაღებები ამ ასოციაციურ მასივში გახდეს ცვლადები ფარგლებში თარგი.
ასე რომ, ჩვენ ვაპირებთ, რომ პოსტი პოსტი.
ასე გაივლის არაპირდაპირ პოსტი, ჩვენ გაეგზავნება მონაცემთა ბაზიდან. .
ახლა რა ჩვენ ვაპირებთ შეიქმნას ამ კალენდარი
ასე რომ ჩვენ შეგვიძლია რეალურად ნახოთ დღიურში შეტყობინება, რომ ჩვენ ავაშენეთ.
>> ამიტომ ჩვენ ვაპირებთ შევქმნათ ფაილი სახელად view.blade.php.
ასე რომ შიგნით ეს თარგი, ის, რასაც ჩვენ ვაპირებთ, რომ
დააყენა ერთად უბრალო, რომ საშუალებას გვაძლევს ცარიელია შინაარსი.
ასე რომ ჩვენ განყოფილებიანი, ეს ადრე შინაარსი.
შეჩერება.
და რასაც ჩვენ ვაპირებთ უნდა გავაკეთოთ ფარგლებში აქ
წერენ ზოგიერთი HTML ცარიელია ამ გვერდზე.
>> ასე რომ, ჩვენ ვაპირებთ, რომ გადაიტანოთ იგი ლამაზი ახალი HTML5 ელემენტია ე.წ. მუხლი.
და აქ, ჩვენ ვაპირებთ აქვს header სადაც
ჩვენ ვაპირებთ, რომ უბრალოდ უნდა h1, რომელიც მოიცავს პოსტ სათაური.
ასე რომ, თუ დავაკვირდებით ამ ორმაგი Curly გაუწიოს notation,
ამ ყველაფერს გააკეთებს არსებითად PHP ეხმიანება პოსტი სათაურით.
ასე რომ, ეს სასარგებლო სტენოგრამის რომ Laravel გვაძლევს.
ასე რომ, ჩვენ ვაპირებთ გამოვიყენოთ ამ notation ნაცვლად.
>> და აქ, ჩვენ ვაპირებთ, რომ ასევე ამობეჭდოთ შინაარსზე იგი.
და აქ, ჩვენ ვაპირებთ უნდა გავაკეთოთ ჩანაწერის შინაარსი.
და ქვემოთ ბოლოში რა ვართ ვაპირებთ გავაკეთოთ არის შექმნას ძირი.
და ძირი, ჩვენ ვაპირებთ პირველი ჩვენება, როდესაც ეს იყო განთავსებული.
ასე რომ, ეს იყო განთავსებული, განთავსებულია.
>> და Laravel იყენებს მართლაც ლამაზი თარიღი ბიბლიოთეკა მოუწოდა Carbon.
ასე რომ ჩვენ შეგვიძლია რეალურად რაღაც მოუწოდა difforHumans, რომელიც თქვენ ნახეთ ადრე.
როდესაც ჩვენ გამოქვეყნდა. იგი ყველაფერს ამბობენ, როგორიცაა, ხუთი წუთის წინ.
ასე რომ, ეს მართლაც ლამაზი ფუნქციონალური Laravel.
და ბოლოს, ჩვენ ვაპირებთ დახურვა ძირი.
>> ასე რომ, ახლა თუ ჩვენ დაბრუნდეს საწყისი გვერდი ჩვენ ვაპირებთ
ვხედავ, არაფერი აქ არ არის, რადგან ჩვენ არ კოდირებული up მთავარ გვერდზე.
მაგრამ თუ ჩვენ წასვლა პოსტი slash ერთი, ჩვენ ვაპირებთ, რომ ნახოთ გამონაკლისი.
ვინმეს თუ რატომ ჩვენ ვხედავთ, გამონაკლისი?
რა გვაქვს დაკარგული?
ნებისმიერი იდეები?
ასე რომ, რა ვქნათ ადრე ჩვენთვის რეალურად
განისაზღვროს, თუ როგორ არ მივიღებთ, კერძოდ კონტროლერები?
>> დინამიკები 1: მარშრუტი?
ERIC Ouyang: ჰო.
ასე რომ, ჩვენ მაინც უნდა განსაზღვროს მარშრუტი.
ასე რომ, ჩვენ დავბრუნდებით აქ უნდა routes.php.
თქვენ შეამჩნევთ, რომ ჩვენ რეალურად არ არის განსაზღვრული
როგორ ვაპირებთ მისაღებად ამ კონტროლერი.
ასე რომ, ახლა ჩვენ ვაპირებთ, რათა განისაზღვროს ამ გზით.
ეს საკმაოდ მარტივია, მსგავსი, რაც ჩვენ გავაკეთეთ ადრე.
მაგრამ, რასაც ჩვენ ვაპირებთ, რომ შეამჩნია აქ რომ ჩვენ ვაპირებთ აქვს placeholder.
>> ასე რომ, თუ ჩვენ გავაკეთებთ route.get slash post ID.
ასე ID ახლა არის რა ხდება უნდა შევიდა კონტროლერი.
ამ აპირებს გამოიყენოს კონტროლერი, რომ ჩვენ უბრალოდ
შექმნა, BlogController at viewPost.
და ჩვენ ვაპირებთ alias ეს როგორც viewPost.
დიდი.
ახლა ჩვენ ვაპირებთ, რომ შევქმნათ ეს მარშრუტი.
>> ასე რომ, ახლა თუ ჩვენ წავიდეთ აქ და განაახლეთ გვერდი,
ჩვენ, ფაქტობრივად, არ გვაქვს ჩვენი ახალი დღიურში.
ასე რომ, ეს არის ის, რაც ჩვენ ადრე შექმნილი.
ძალიან მარტივია გვერდზე, მაგრამ მონიტორები დღიურში, რომ ჩვენ შევქმენით.
მაგარი.
და თუ ჩვენ რეალურად გაიაროს მთელი შექმნის პროცესში ახალი დღიურში,
ჩვენ შეამჩნევთ, რომ ყველაფერი გადამისამართებების სწორად.
თუ მე ვიტყვი, "Hi.
მე Jonathan Tan ".
ამბობენ, "ეს არის ჩემი ბლოგის პოსტი".
და დასამტკიცებლად, შევქმნით ახალი დღიურში შეტყობინება ID 2,
რომელიც მდე, რაც ჩვენ გვქონდა ადრე და მონიტორები სწორად.
გასაოცარია.
>> ნებისმიერი კითხვები?
დიახ?
>> დინამიკები 2: არა Laravel სახელური sanitization და ყველაფერი თქვენთვის?
ERIC Ouyang: დიახ.
ასე რომ, როდესაც ჩვენ ვნახეთ ადრე, როდესაც ჩვენ გავაკეთეთ input COLON COLON მისაღებად,
რომ sanitates ნებისმიერი SQL ინექციების და whatnot
რომ ჩვენ დაგვჭირდება შეასრულოს თუ ჩვენ მუქარის შესახებ ვებგვერდზე.
ასე Laravel ამუშავებს ბევრი რომ კულუარებში.
კარგი კითხვაა.
>> ასე რომ, მოდით შევხედოთ მთავარ გვერდზე.
ასე რომ, თუ ჩვენ პირველად დაბრუნდეს კონტროლერი მთავარი გვერდი,
თქვენ შეამჩნევთ, რომ ეს არ გავაკეთოთ აქ.
თქვენ შეამჩნევთ, რომ ჩვენ არ ვართ გავლით შევიდა ეს კონტროლერი
არაფერი განსაკუთრებით სასარგებლო.
ეს მხოლოდ ამ ინდექსი ფაილი.
>> ასე რომ, მოდით გაივლის შევიდა ეს რაღაც სასარგებლო.
კერძოდ, ჩვენ აპირებს გაიაროს შეტყობინება.
და Laravel საშუალებას გვაძლევს უნდა გავაკეთოთ post ყველა, რომელიც
საშუალებას მოგვცემს მისაღებად ყველა პოსტი.
ახლა თუ ჩვენ დაბრუნდეს index.php, დაინახავთ, hey.
არაფერი აქ არ არის.
მაგრამ რა გვინდა გავაკეთოთ აქ რეალურად iterate მეშვეობით,
გავაკეთოთ foreach loop მეტი პოსტი, საშუალებას გვაძლევს ამობეჭდოთ შეტყობინება.
>> ასე foreach პოსტი პოსტი, რაც ჩვენ გვინდა გავაკეთოთ
არის ამობეჭდოთ content საქართველოს დღიურში.
მაგრამ ერთი რამ თქვენ შეამჩნევთ არის, რომ ჩვენ რეალურად დაწერა ყველაზე მეტად, რომ კოდი
უკვე, view.blade.php.
ასე რომ, ჩვენ ვაპირებთ, რომ მართლაც არის გამოიყენოთ ლამაზი სასარგებლო თვისება Blade
და ფაქტორი ამ საერთო კოდი.
ასე რომ, ჩვენ წავიდეთ აქ.
>> ჩვენ ვაპირებთ, რომ მიიღოს ამ შინაარსის სწორედ აქ, რასაც ჩვენ ვაპირებთ, რომ
შექმნა ახალი ფოლდერი.
მოდით უბრალოდ ეძახით partials.
და აქ, ჩვენ ვაპირებთ შექმნათ post.blade.php.
ასე რომ, ჩვენ factored გამოსავალი რომელიც ჩვენ გვინდა, რომ არიან ამ ფორუმზე.
და აქ, რასაც ჩვენ გავაკეთებთ ნაცვლად ფაქტობრივად, რომელსაც, რომ HTML პირდაპირ,
ჩვენ ვაპირებთ, რათა გამოიყენონ ეს დირექტივა მოუწოდა მოიცავს blog.partials.post.
>> და რასაც ჩვენ ვაპირებთ გავაკეთოთ აქ არის გაივლის პოსტ გვერდზე.
ასე რომ, ახლა თუ ჩვენ დავბრუნდებით აქ, ჩვენ შეამჩნია, რომ ფუნქციონირება კვლავ
იგივე.
მაგრამ ახლა ჩვენ გვაქვს ეს factored გარეთ კოდი, ამ HTML.
ამიტომ ჩვენ შეგვიძლია გამოვიყენოთ ეს ინდექსი.
ასე რომ, აქ, ამ ძალიან მარტივია.
ყველა ვაკეთებთ მოიცავს blog.partials.post და მასივი.
და სადღაც ადრე, ჩვენ გააკეთოს ჩანაწერი ჩანაწერი.
>> ასე რომ, ახლა თუ ჩვენ დაბრუნდეს მთავარი გვერდი, ჩვენ დავინახავთ, რომ, hey.
ჩვენ გვაქვს სია ყველა დღიურში შეტყობინება, რომ ჩვენ გვქონდა ადრე.
ჩვენ დაგვჭირდება დაამატოთ ზოგიერთი "თუ" პირობები და "სხვაგან" პირობები
ასე რომ, თუ ჩვენ არ გვაქვს არაფერი დღიურში,
ჩვენ გვინდა, რომ არიან რაღაც სასარგებლო.
როგორიცაა, hey.
იქ არ არის content ჯერ ბლოგზე.
და თუ ბიჭები რეალურად შევხედოთ განაწილების კოდი on GitHub,
დაინახავთ მაგალითია, თუ როგორ ჩვენ გაგვაჩნია.
>> მაგარი.
ნებისმიერი კითხვები?
დიახ.
>> დინამიკები 2: ვფიქრობ, მხოლოდ ფუნდამენტური კითხვა.
უკან მარშრუტი.
ERIC Ouyang: ჰო.
თუ ჩვენ შევხედოთ მარშრუტები.
>> დინამიკები 2: სად uses.blogcontroller at შექმნათ ჩანაწერი,
რა, რომ გვასწავლის?
ERIC Ouyang: ჰო.
Yeah.
>> დინამიკები 2: ან რა არის, რომ
ERIC Ouyang: ასე რომ, შევხედოთ, ვთქვათ, მაგალითად, ეს მარშრუტი უფლება აქ.
პირველი ნაწილი არის ფაქტობრივი URL, რომ მომხმარებელს წავა.
და ეს მასივი აქ, ასოციაციურ მასივში, განსაზღვრავს
როგორ გვინდა აქვს განაცხადის აქტი საპასუხოდ მას.
ასე იყენებს არის კონტროლერი, ფუნქცია, რომ ჩვენ
მინდა მოვუწოდო, როდესაც მომხმარებლის მიდის ამ URL.
ასე viewPost სწორედ აქ იყო ფუნქცია, რომელიც ჩვენ განსაზღვრული შიგნით
of BlogController--
>> დინამიკები 2: მე ვერ ვხედავ.
>> ERIC Ouyang: --so, რომ ჩვენ შეიძლება რეალურად გაწევა აზრით,
შეასრულოს გარკვეული გათვლებით, ურთიერთქმედება SQL მონაცემთა ბაზაში.
>> დინამიკები 2: OK.
>> ERIC Ouyang: და მერე სხვა ნაწილი ", როგორც" არის იგივე რომ ჩვენ ვიყენებთ.
ასე რომ, თუ ჩვენ შეამჩნია, როდესაც ჩვენ შევქმენით ფორმა,
თქვენ შეამჩნევთ, რომ URL :: routecreatePost.
ასე რომ, ეს შემცვლელი ფაქტობრივი URL ისე, რომ ჩვენ არ ვართ მძიმე
კოდირების ეს იმდენად ჩვენ შეგვიძლია შევცვალოთ ეს ერთხელ, რომ თუ გვინდოდა გადარქმევა.
ნაცვლად პოსტი slash ახალი, ჩვენ გვინდა, რომ მოსწონს, p
სლეში new მხოლოდ გაწმენდა up ჩვენი მისამართები ცოტა.
შეგვეცვალა მას ერთ ადგილზე საკმაოდ ვიდრე მთელი სხვადასხვა ფაილები.
>> მაგარი.
ეს არის კარგი.
ასე რომ, ახლა ჩვენ გვაქვს ძალიან ძირითადი წაკითხვა პლატფორმა.
ჩვენ, ალბათ, სურს, რომ დაამატოთ ღილაკს ასე რომ ჩვენ შეგვიძლია რეალურად შეიქმნას ახალი შეტყობინება.
ასე რომ, თუ ჩვენ შევხედოთ განლაგება ოსტატი,
ჩვენ გვაქვს მონაკვეთზე მოუწოდა Header Right რომ ჩვენ უბრალოდ განისაზღვრა ზედა.
ასე რომ, ჩვენ შეგვიძლია დავამატოთ ღილაკები ზედა header.
>> ასე რომ, თუ ჩვენ წასვლა index.blade.php, რეალურად ამისათვის არის განსაზღვრავს რა მიდის შიგნით აქ.
ასე რომ, ეს Header Right განყოფილებიანი, ის, რასაც ჩვენ ვაპირებთ, რომ
არის დაამატე ღილაკს წასვლა URL განისაზღვრება მარშრუტი ახალი პოსტი.
მხოლოდ გაწმენდა it up და ეს საკმაოდ და ყველა ჩატვირთვის,
ჩვენ ვაპირებთ, რათა ეს ძირითადად ღილაკს.
მოდით უბრალოდ, რათა ის დიდი for fun.
>> და მის შიგნით, ჩვენ ვერ დააყენა რაღაც ტექსტი.
მაგრამ რა Bootstrap უზრუნველყოფს glyphicons.
ასე რომ, ჩვენ შეგვიძლია შევკრიბოთ, რომ ლამაზი ფანქარი, რომელიც ჩვენ ვნახეთ ადრე.
Glyphicon.
Glyphicon ფანქარი.
ასე რომ, ეს მოგვცემს საშუალებას, რომ ბოლო ხატი ნაცვლად ტექსტი.
ახლა თუ ჩვენ არ შეწყვიტოს, ამ განსაზღვრავს ამ სექციაში.
და, hey.
ჩვენ გვყავს ლამაზი ღილაკს, რომელიც აკავშირებს us პირდაპირ რჩეულებში დღიურში გვერდზე.
>> ამიტომ ჩვენ გვაქვს საკმაოდ მარტივია წაკითხვა.
ჩვენ შეგვიძლია დავამატოთ პერსონალის მას.
მაგრამ რაც ჩვენ ზოგადად ველით საწყისი ბლოგები არის კომენტირებისას.
ასე რომ, ეს ჩვენთვის მნიშვნელოვანია, რომ აქვს, ამბობენ, თუ ვინმე სტუმრობს ნახვა
და ნამდვილად უყვარს პოსტი, რომელიც მათ შეუძლიათ ჩაერთონ დისკუსიაში
სხვა ადამიანები, რომლებიც ეწვევა გვერდზე.
ასე რომ, ჩვენ ვაპირებთ წასვლა და შექმნას ახალი მონაცემთა ბაზის მაგიდა და ახალი მოდელი
ასე რომ, ჩვენ შეგვიძლია გაერთიანდნენ კომენტარები ფორუმზე.
>> ამიტომ პირველი ნაბიჯი, ისევე, როგორც ადრე, არის, რომ ჩვენ უნდა აწარმოებს მიგრაცია.
ისე, როგორც ადრე, ვქნათ php ხელოსანთა მიგრაცია: მიიღოს.
და ჩვენ ვაპირებთ, რომ შევქმნათ ერთი მოუწოდა create_comments_table.
ეს შექმნის ფაილი რომელიც აქვს ჩვენს ახალ მიგრაცია.
და ჩვენ ვაპირებთ, როგორიცაა ადრე, განსაზღვროს ახალი მაგიდა.
ასე Schema :: შექმნა მაგიდა სახელწოდებით კომენტარი.
ამ ფუნქციას აქ.
და შიგნით ამ მაგიდასთან რა ჩვენ ვაპირებთ, რომ პირველი,
როგორც ადრე, დაავალოს ID.
მდე ID.
>> ჩვენ ვაპირებთ, რომ საშუალებას აძლევს მომხმარებლებს გაერთიანდნენ მათი სახელი კონკრეტული კომენტარი.
ჩვენ ვაპირებთ, რომ გარკვეული შინაარსი, რომელიც მიდის ერთად ამ, ტექსტის შინაარსი.
და აქ რა ჩვენ ვაპირებთ ამის გაკეთება რაღაც განსხვავებული.
ჩვენ ვაპირებთ შევქმნათ მთელი რომ ე.წ. post_id რომელიც
აპირებს ნიშნავდეს, რა პოსტი კერძოდ კომენტარის მიდის.
>> გარდა ამისა, ჩვენ რეალურად აპირებს მითითებული საგარეო გასაღები შეზღუდვა ამ.
ასე MySQL აღასრულებს, რომ.
ჩვენ არ ცდილობს მივანიჭოთ კომენტარის ნომერი
5 პოსტი 5,000 თუ ჩვენ არ გვაქვს ჰქონდა 5000 შეტყობინება მასზე.
ასე რომ, ჩვენ აქ, ჩვენ გავაკეთებთ საგარეო post_id
იქნება დაკავშირებული ID სფეროში მაგიდა შეტყობინება.
და ჩვენ რეალურად რაღაც სხვა სასარგებლო, არის onDelete.
>> ასე რომ, თუ ჩვენ წაშლა პოსტი ბაზაში,
ჩვენ გვინდა, რომ კასკადის წაშლის for კომენტარები.
იმიტომ, რომ ეს არ არის ძალიან გამოსადეგი ჩვენთვის აქვს კომენტარები ფორუმზე
რომ არ არსებობს.
და ბოლოს, როგორც ადრე, ჩვენ შექმნას აპირებს მარკების ამ.
და როგორც ადრე, ჩვენ ვაპირებთ საპირისპირო მიგრაციის იყოს
ჩაშვების კომენტარი მაგიდასთან.
>> ასე რომ, ახლა თუ ჩვენ დაბრუნდეს აქ, ჩვენ ვაპირებთ
აწარმოებს ამ მიგრაციის, ხელოსანთა მიგრაცია.
და ახლა ის გამოიყენება ამ მიგრაციის, რომ ჩვენ შევქმენით.
ასე რომ, თუ ჩვენ შევხედოთ phpMyAdmin, ჩვენ, ფაქტობრივად, ახლა
აქვს კომენტარები მაგიდა, რომელიც სტრუქტურა, რომელიც ჩვენ უბრალოდ მითითებული.
ისე, როგორც ადრე, ჩვენ ვაპირებ, რომ შევქმნათ ახალი მოდელი
აბსტრაქტული SQL მაგიდა რომ ჩვენ შევქმენით.
>> ასე რომ, მოდით დაამატეთ ახალი ფაილი.
ჩვენ ვაპირებთ ეძახით comment.php.
და ეს არის რეალურად იქნება საკმაოდ მარტივია უმნიშვნელო ცვლილება
ის, რაც ჩვენ გვქონდა ადრე.
ასე კლასის კომენტარები ვრცელდება მჭერმეტყველი.
და რასაც ჩვენ ვაპირებთ აქ არის განსაზღვროს
ფუნქცია, რომელიც არის ურთიერთობა სხვა მოდელები.
ამიტომ, ჩვენ ვაპირებთ აქვს პოსტ ფუნქცია აქ რომ ბრუნდება ეს ურთიერთობა.
ასე რომ, ჩვენ მიუთითებს, რომ ეს ეკუთვნის პოსტი,
ამბობენ, რომ ერთი პოსტი რომ ამ კომენტარის ეკუთვნის.
>> ეს რეალურად უნდა იყოს დედაქალაქში P მოდელი.
და ახლა მხოლოდ მეორეს flip მხარეს, ჩვენ უნდა ვთქვა, რომ, hey.
შეტყობინება აქვს კომენტარები.
ასე რომ, ჩვენ ვაპირებთ, რომ არის განსაზღვროს საჯარო ფუნქციის კომენტარი.
და აქ დაბრუნდა ეს ბევრი კომენტარი.
ასე რომ, ახლა magically როდესაც ჩვენ გვაქვს ჩანაწერი, ჩვენ შეგვიძლია მივიღოთ ატრიბუტი კომენტარები
და ეს კიდე მოეყვანა იგი ინფორმაცია მონაცემთა ბაზაში.
>> მოდით რეალურად გავლა და რჩეულებში ახალი ფუნქცია, ჩვენი აზრით ფაილი
ასე, რომ ჩვენ შეგვიძლია ჩვენება და შექმნა კომენტარი.
ამიტომ, ჩვენ ვაპირებთ, რომ განსაზღვროს ახალ სექციაში.
მოდით უბრალოდ გამოყოფოდა ჰორიზონტალური წესით.
განყოფილება id = "კომენტარი".
ის, რასაც ჩვენ ვაპირებთ, რომ აქ არის, როგორც ადრე,
iterate მეშვეობით ყველა კომენტარი.
ასე რომ, რეალურად, თუ როგორ გავაკეთოთ ეს, როგორც აღვნიშნე, საკმაოდ ჯადოსნური.
>> ჩვენ ვაკეთებთ დატოვოთ კომენტარი.
და მაშინ ჩვენ შეგვიძლია ამის გაკეთება თითოეული მარყუჟი აღემატება თითოეული კომენტარი.
და რა ჩვენ ვაპირებთ გავაკეთოთ არის div class კომენტარი,
და ჩვენ ვაპირებთ, რომ რეალურად ბეჭდვა ეს კომენტარი.
ასე არაა, რომ hey, კომენტარის name-- პირი
Who posted ამ comment-- ამბობს dot dot dot.
ჩვენ ვაპირებთ, რომ ამ ბლოკი გაცემა, უბრალოდ, რათა ის გამოიყურება ლამაზი.
და შემდეგ კომენტარს content ბლოკი გაცემა.
და foreach.
ასე რომ, ახლა ამ აპირებს loop ყველა კომენტარი
რომ არის დაკავშირებული თითოეული ფორუმზე
და არიან თითოეული მათგანი კომენტარი.
მე ვაპირებ დაამატოთ კიდევ ერთი მონაკვეთი ქვემოთ აქ, რაც საშუალებას გვაძლევს დაამატოთ კომენტარი.
ასე h3 კლასის.
განათავსეთ სათაური აქ.
კომენტარის დამატება.
და ჩვენ ვაპირებთ, რომ განსაზღვროს ახალი ფორმა.
>> ისე, როგორც ადრე, ჩვენ ვაპირებ ამის გაკეთებას ფორმა action.
და აქ, ახალი სამოქმედო ჩვენ აპირებს განსაზღვროს ახალი კონტროლერი, რომ
საშუალებას გვაძლევს ვუპასუხოთ პოსტი მოთხოვნა შექმნაში კომენტარი.
ასე URL :: მარშრუტი createComment.
მე ვაპირებ გაკეთებას პარამეტრი აქ.
ID პოსტ რომ ჩვენ შექმნის კომენტარი.
და შემდეგ საშუალებას ამ ფორმა იქნება პოსტი.
>> ახლა ჩვენ ვაპირებთ, რომ დაამატოთ ორ ველს, ფორმა ჯგუფი.
ეს იქნება შეყვანის სახელი "სახელი" და class = "ფორმა კონტროლი",
type = "text", და placeholder = "თქვენი სახელი".
ჩვენ ასევე ვაპირებთ, რომ განსაზღვროს სხვა ფორმით სფეროში, რომელიც
იქნება ტექსტი ტერიტორიაზე, როგორც ჩვენ გვქონდა ადრე.
ისევე, როგორც ადრე, მას შინაარსი.
Class = "ფორმა კონტროლი."
Placeholder = "დაწერეთ აქ."
>> და ასე რომ, ჩვენ შეიძლება რეალურად წარუდგინოს,
წარმოადგინოს ტიპის და class = "btn btn პირველადი".
დახურვა ფორმა.
დახურეთ ეს ქმედება.
ასე რომ, ახლა თუ ჩვენ ცარიელია ამ გვერდზე, სადაც ჩვენ გვაქვს, ვთქვათ, კონკრეტული პოსტი.
ჩვენ უნდა გადატვირთეთ სერვერი.
PHP ხელოსანთა ემსახურება.
გადატვირთეთ ეს.
ჩვენ უნდა განსაზღვროს მარშრუტი.
მაგრამ ახლა, მოდით, უბრალოდ მიიღოს ეს ისე, რომ ჩვენ შეგვიძლია რეალურად გაჩვენებთ
რა გვერდზე ჰგავს, და მაშინ ჩვენ, ფაქტობრივად, შექმნა, რომ მარშრუტი.
ასე რომ, hey.
ჩვენ გვაქვს ეს ახალი ფორმა ქვემოთ აქ ასე რომ ჩვენ შეგვიძლია შევქმნათ კომენტარი.
მოდით რეალურად განსაზღვროს ფუნქცია კონტროლერი
ასე რომ ჩვენ შეგვიძლია დაამატოთ კომენტარი.
მოდით დავუბრუნდეთ.
და შიგნით blogcontroller.php, ის, რასაც ჩვენ ვაპირებთ, რომ
შექმნათ ახალი ფუნქცია მოუწოდა შექმნა კომენტარი.
>> საჯარო ფუნქციას createComment.
ამ აპირებს აქვს ერთი პარამეტრი, ID პოსტი
რომ ჩვენ კომენტირებისას.
და ისევე, როგორც ადრე, ჩვენ აპირებს მიიღოს პირველი პოსტი.
ასე რომ პოსტი, findOrfail id.
ამის შემდეგ, ჩვენ ვაპირებთ შევქმნათ ახალი კომენტარის დამატება.
ასე კომენტარის = new კომენტარი.
კომენტარები name = შეყვანის :: მიიღოს სახელი.
კომენტარის დამატება content = იმავე ახალი ხაზი შევიდა შესვენებები შეყვანის :: მიიღოს შინაარსი.
>> და ბოლოს, ჩვენ ვაპირებთ, რომ უნდა გაერთიანდნენ ამ კომენტარის პოსტი.
ასე რომ, ჩვენ ვაპირებთ გამოვიყენოთ ეს ფუნქცია, კომენტარები,
რომელიც საშუალებას გვაძლევს შეინახე ეს ურთიერთობა.
ასე რომ, ახლა ეს კომენტარი მოუწევს ავტომატურად პოსტ ID.
ჩვენ შეგვიძლია ასევე მითითებული ეს ხელით, მაგრამ ეს
უფრო ადვილად წასაკითხი რამდენადაც როგორც ფუნქცია მიდის.
და შემდეგ ჩვენ შეასრულოს ეს, რა გვინდა გავაკეთოთ
არის გადამისამართება განსაზღვრული მარშრუტი viewPost
ერთად მასივში პარამეტრი პოსტ ID.
>> და ახლა, ასე, რომ ეს რეალურად ფუნქციები, ჩვენ უნდა განსაზღვროს ეს მარშრუტი.
მარშრუტი :: პოსტი.
და ახლა ჩვენ ვაპირებთ, რომ მოვუწოდო ამ ჩანაწერის სლეში ID slash კომენტარი.
Array იყენებს ახალი ფუნქცია რომ ჩვენ შევქმენით.
BlogController.
CreateComment როგორც createComment.
დიდი.
>> ასე რომ, ახლა იმედია, თუ ჩვენ განაახლეთ გვერდი და დაამატოთ კომენტარი, ვთქვათ, დავით Malan.
"იმედია, ეს სამუშაოები."
წარუდგინოს.
ჩვენ, ფაქტობრივად, აქვს კომენტარი ამ დღიურში.
მაგარი.
ახლა ჩვენ გვაქვს საკმაოდ ფუნქციური დღიურში.
ჩვენ უბრალოდ აპირებს დაამატოთ რამდენიმე შესწორებები ასე
რომ ჩვენ გვაქვს უფრო სასარგებლო ინფორმაცია ამ ფორუმზე.
>> ასე რომ, თუ ჩვენ დაბრუნდეს წინა გვერდი, ჩვენ არ გვაქვს გრძნობა
თუ რამდენი კომენტარი თითოეულ ამ ფორუმზე.
მერე რა რომ ჩვენ რეალურად აპირებს არ არის, შიგნით ჩვენი მოდელი,
განსაზღვრავს დამხმარე ფუნქცია, რომელიც საშუალებას იძლევა ჩვენს მიუთითოთ ნომერი კომენტარები
რომ წავიდეთ ერთად კონკრეტული პოსტი.
ასე რომ, ჩვენ ვაპირებთ, რომ შევქმნათ დამხმარე ფუნქცია.
>> საჯარო ფუნქციას.
GetNumCommentsStr.
ასე რომ სიმებიანი, რომელიც განსაზღვრავს ნომერი კომენტარები რომ წავიდეთ ერთად მას.
და რასაც ჩვენ ვაპირებთ გავაკეთოთ არის ამბობენ რომ num = ეს კომენტარები ითვლიან.
ასე რომ, ჩვენ ვაპირებთ ითვლიან რიგი კომენტარები.
და თუ ამ რაოდენობის შეადგენს 1, ჩვენ უბრალოდ დაბრუნებას აპირებს 1 კომენტარი.
და შემდეგ სხვაგვარად, ჩვენ გვინდა დაბრუნდეს გაერთიანების num და კომენტარები,
ამიტომ ჩვენ პლურალიზაცია სწორი.
უბრალოდ ეს ერთი გაცემა.
ერთი კომენტარი.
>> და ახლა ჩვენ შეგიძლიათ გამოიყენოთ ეს ფუნქცია პირდაპირ შიგნით ჩვენი აზრით.
ასე რომ, თუ ჩვენ დაბრუნდეს ნაწილობრივი პოსტი, რომელიც ჩვენ შევქმენით,
ახლა ჩვენ გვინდა რეალურად არიან ნომერი კომენტარები.
ასე რომ, რა შეგვიძლია გავაკეთოთ არის პოსტი, გამოიყენოთ ეს ფუნქცია
რომ ჩვენ მხოლოდ შეიქმნა არიან ნომერი კომენტარები.
ასე რომ, თუ ჩვენ ახლა ამოცნობა, ეს ამჯამად, ფაქტობრივად, ჩვენება
ნომერი კომენტარები რომ წავიდეთ ერთად მას.
>> თუ გვინდოდა იყოს ლამაზი თუ რეალურად შევხედოთ განაწილების კოდი,
ჩვენ შეგვიძლია რეალურად ბმული ეს კომენტარი.
თუ გავიხსენებთ, ჩვენ განსაზღვრული ფარგლებში სანახავად რომ ეს მონაკვეთი ID კომენტარი.
ასე რომ, თუ ჩვენ რეალურად სურდა ბმული პირდაპირ კომენტარი სექციაში, რა
ჩვენ ყველაფერს გააკეთებს აქ არის href URL მარშრუტი viewPost.
კორიდორი მასივი ID პოსტ ID.
და მაშინ ჩვენ გვინდა წასვლა კონკრეტულად კომენტარი სექციაში.
>> აქ მოდით დახუროს tag.
ასე რომ, ახლა თუ ჩვენ ცარიელია ეს გვერდი, ჩვენ დააჭირეთ ამ.
ჩვენ წავიდეთ პირდაპირ კომენტარი სექციაში.
თუ ჩვენ გვქონდა აღარ პოსტი, თქვენ შეგიძლიათ რეალურად ვხედავ ამ bounce ქვემოთ.
მაგრამ თქვენ შეამჩნევთ, რომ ეს არ ზედა გვერდზე.
მაგარი.
დიდი.
ასე რომ საკმაოდ მარტივია მაგალითად, თუ რაღაც მარტივი
რომ შეგიძლიათ გააკეთოთ Laravel.
>> მაგრამ თქვენ შეამჩნევთ, რომ აქ ჩვენ გავაკეთეთ ბევრი რამ
საკმაოდ მცირე კოდი.
Laravel საშუალებას გვაძლევს გავაკეთოთ SQL queries კულისებში.
ეს იმას სანიტარული ჩვენთვის კულისებში.
საშუალებას გვაძლევს გავაკეთოთ, რომ ეს ურთიერთობები ძალიან ადვილად გარეშე სჭირდება
გავაკეთოთ ნებისმიერი SQL შეუერთდეს განცხადებებს გაერთიანდება კომენტარი, რასაც ფორუმზე.
საშუალებას გვაძლევს გავაკეთოთ ეს მემკვიდრეობის თარგები
ასე რომ, ჩვენ შეგვიძლია განვსაზღვროთ ამ მობუდარი ფაილი ისე, რომ ჩვენ არ იმეორებს საკუთარ თავს,
ისევე, როგორც, როდესაც ჩვენ გვქონდა, რომ ჩვენება დღიურში შეტყობინება
რომ ჩვენ არ უნდა დააკოპირეთ და ჩასვით კოდი.
>> და აქ თქვენ შეძლოთ უფრო და უფრო რთული პროგრამები.
თქვენ წარმოიდგინეთ, თუ ჩვენ უნდოდა, შედით,
შეიძლება ითქვას, მოაქვს მესამე მხარის ფარგლებში, რომელიც საშუალებას გვაძლევს გავაკეთოთ, რომ.
არსებობს რამოდენიმე მათგანი ნამდვილად, ნამდვილად
დიდი რომ არ შეუძლია გააკეთოს, როგორიცაა, პაროლის აღდგენა.
და ეს გამოგიგზავნით გადატვირთვის დაგავიწყდათ ელ.
ჩვენ შეგვიძლია განვახორციელოთ ნებართვა ისე, რომ მე შეიძლება შექმნათ ჩანაწერი,
მაგრამ ვინმე არ გაქვთ.
ჩვენ შეგვიძლია განვახორციელოთ ფუნქციონალური წაშლა შეტყობინება.
>> მაგრამ თქვენ ხედავთ, რომ ჩვენ გვაქვს საკმაოდ ბევრი ყველა ჩანასახოვან კომპონენტები
ავაშენოთ ზოგიერთი მართლაც, მართლაც, დინამიური და საინტერესო ვებ apps.
ასე რომ, მე ვფიქრობ, რომ ჩვენ კარგი.
მიგაჩნიათ თუ არა ბიჭები გაქვთ რაიმე შეკითხვა?
დიახ?
>> დინამიკები 3: როგორ ფიქრობთ მიიღეთ კონტენტი?
>> ERIC Ouyang: Static შინაარსი.
ასე რომ თქვენ ვნახეთ მანამდე, როდესაც ჩვენ გვქონდა სწორედ აქ, ამ განლაგებას შინაარსის,
კალენდარი გააკეთოს, ჩვენ გვქონდა ამ გარეშე ამ მასივი შემდეგ.
Blog.index, ჩვენ გვქონდა ამ როგორც მხოლოდ სტატიკური ფაილი.
ასე რომ, თუ ჩვენ არ გაივლის არაფერი გასწვრივ მას,
ეს უბრალოდ გაწევა HTML პირდაპირ.
მაგრამ თუ ჩვენ გაივლის ამ ასოციაციურ array ფორუმზე, რომელიც დინამიურად
გამოყვანილია ბაზაში, ჩვენ შეუძლია გვერდზე დინამიური.
მაგარი.
ნებისმიერი სხვა კითხვები?
დინამიკები 3: როგორ შეადარებდით Laravel იქნებ რაიმე სხვა ვარიანტი?
ERIC Ouyang: რა თქმა უნდა.
Yeah.
ასე Laravel is--, რომ დიდი კითხვა
ერთი ბევრი ვარიანტები ვებ ფარგლებში.
ასე Ruby ლიანდაგზე არის ერთი რომ პოპულარულია.
მე მჯერა, Twitter გამოყენებული იქნება განხორციელებული Ruby ლიანდაგზე.
მე ვფიქრობ, რომ ისინი წლიდან გადავიდა.
არსებობს კიდევ ერთი ე.წ. FuelPHP.
>> ასე Ruby ლიანდაგზე იყენებს Ruby ენის და ახორციელებს ბევრი MVC პერსონალი
ჩვენ ვხედავთ, რომ აქ.
FuelPHP არის კიდევ ერთი PHP ფარგლებში.
Django არის ერთ ერთი ჩემი ჩადება.
ეს ვებგვერდი ფარგლებში Python.
ასე რომ თქვენ შეგიძლიათ დაწეროთ თქვენი ვებ app Python.
ასე რომ, არსებობს ტონა ვარიანტი.
>> Laravel, მე ვფიქრობ, და დიდი არის ჩემი საყვარელი უფლება
ახლა PHP მხოლოდ იმიტომ, ერთი კომპონენტი
რომ ჩვენ ვისაუბრეთ ადრე.
მისი Composer ჩართულია.
იგი მოიცავს ნამდვილად, ნამდვილად გამომხატველი ORM სისტემა.
ასევე აქვს მართლაც გასაოცარია templating ენა, რომ ზოგიერთი სხვა
უბრალოდ არ არის.
და მიგრაცია.
მიგრაცია გასაოცარია ასევე.
მაგარი?
გასაოცარია.
კარგად, მადლობა იმდენად თვალს ამ სემინარზე,
და წარმატებას გისურვებთ თქვენს საბოლოო პროექტები.