>> დევიდ ჯ Malan: ყველა უფლება.
ასე რომ, კეთილი იყოს პირველი CS50 postmortem განთავსების ვიქტორინა.
გვეგონა ჩვენ ავღნიშნო ინაუგურაცია ამ ტრადიციას წელს.
და ეს იქნება შესაძლებლობა გავლა
გადაწყვეტილებები ვიქტორინა.
და ჩვენ დააჩქაროს ან შენელდება საფუძველზე ინტერესი იმ აქ.
>> ასე რომ, თქვენ ალბათ აქ იმიტომ, რომ თქვენ დაინტერესებული, თუ როგორ შეიძლება ან
უნდა პასუხი ზოგიერთ ეს პრობლემები.
მაშ, რატომ არ უნდა შევხედოთ ამ განყოფილების პირველი?
ასე მიღების სტრიქონები.
ეს მისცა თქვენ სამი სხვადასხვა ვერსია პროგრამა რომ იყო, საბოლოო ჯამში,
იმას ნიშნავდა, რომ მიიღოს სიმებიანი საწყისი მომხმარებელი.
თუ არა ეს, რომ იყო დარჩა, რათა დადგინდეს.
>> და ჩვენ დასმული შეკითხვა 0, ვარაუდობენ, რომ მობილური 1
შედგენილი და დასაჯეს.
რატომ შეიძლება პროგრამის segfault?
ერთი შეხედვით, რაიმე შემოთავაზება რატომ?
ჰო.
>> აუდიტორია: ასე მახსოვს ხედავს ამ წინა მაგალითი ეძებს
char * s და ხედავს, რომ სკანირების და ხედავს, იმიტომ, რომ ეს მაჩვენებელი, თუ როგორ
არ შეეხება, რაც თქვენ დასკანირებული წელს?
ეს არის ავტორის ან მისამართი s?
>> დევიდ ჯ Malan: OK.
კარგი.
ასე რომ, საბოლოო ჯამში, წყაროს რაიმე პრობლემა სავარაუდოდ შემცირებას აპირებს
რომ ცვლადი s.
და ეს მართლაც განსხვავებულია.
მონაცემები ტიპის რომ ცვლადი არის char *, რაც იმას ნიშნავს, რომ ის აპირებს
შეიცავდეს მისამართი ხასიათი.
და მასში მდგომარეობს ინსაითი.
ის აპირებს შეიცავდეს მისამართი ხასიათი, უფრო ზოგადად,
მისამართი პირველი პერსონაჟი მთელი ბლოკი სიმბოლო.
>> მაგრამ დაჭერა არის, რომ სკანირების s, მიზანი ცხოვრება, ეძლევა მისამართი და მიეცა
ფორმატი კოდი, ისევე როგორც% s, წაკითხული სიმებიანი შევიდა ბლოკი
მეხსიერების იმ მისამართზე.
არამედ იმიტომ, რომ არ არსებობს თანაბარი ნიშანი ადრე რომ მძიმით პირველი
ხაზი კოდი, იმიტომ, რომ ჩვენ არ რეალურად გამოყოფს ნებისმიერი მეხსიერების
malloc, რადგან იგი პრაქტიკულად არ გამოყოფს მასივი ზოგიერთი size, ყველა
თქვენ აკეთებთ კითხულობს მომხმარებლის ანკეტის კლავიატურის input შევიდა ზოგიერთი სრული
ნაგვის ღირებულება, რომელიც არის ნანახია იყოს.
ასე რომ, შანსი თქვენ აპირებს segfault თუ რომ მისამართი არ უბრალოდ ასე მოხდეს
იყოს ღირებულება რომ თქვენ შეგიძლიათ, ფაქტობრივად, ვწერ.
ისე ცუდი არ გამოუყოს თქვენი მეხსიერება არსებობს.
>> ასე რომ, კითხვა 1, ვკითხეთ, ვარაუდობენ, რომ მობილური 2
შედგენილი და დასაჯეს.
რატომ შეიძლება ამ პროგრამის segfault?
ასე რომ, ეს ერთი არის ნაკლები buggy.
და იქ მართლაც მხოლოდ ერთი ნათელი გზა, სადაც შეგიძლიათ
გამოიწვიოს segfault აქ.
და ეს არის თემატური.
ნებისმიერ დროს ჩვენ გამოყენებით c მეხსიერებაში, რა შეგიძლიათ გააკეთოთ, რათა გამოიწვიოს segfault
ერთად ვერსია 2?
>> აუდიტორია: თუ თქვენ იყენებთ, რომ შეყვანის სიმებიანი რომ უმეტეს 49
სიმბოლო.
>> დევიდ ჯ Malan: ზუსტად.
ნებისმიერ დროს ხედავთ რაიმე ფიქსირებული სიგრძის როდესაც საქმე მასივი, თქვენი
რადარის უნდა წავიდეს off რომ ეს შეიძლება იყოს პრობლემატური თუ თქვენ არ შემოწმების
საზღვრების მასივი.
და ეს პრობლემა აქ.
ჩვენ ჯერ კიდევ გამოყენებით scanf.
ჩვენ ჯერ კიდევ გამოყენებით% s, რაც იმას ნიშნავს, ცდილობენ წაკითხვის string საწყისი მომხმარებელს.
ეს იქნება წაიკითხა შევიდა s, რომელიც, ამ ეტაპზე, ეფექტურად
მისამართი ბლოკი მეხსიერება ან ის ექვივალენტი.
ეს სახელწოდება მასივი გმირები მეხსიერება.
>> მაგრამ სწორედ რომ, თუ თქვენ წაიკითხა სიმებიანი რომ ის უფრო მეტია, ვიდრე 49 პერსონაჟი, 49
რადგან თქვენ უნდა ოთახი backslash 0, თქვენ აპირებს overflow
რომ ბუფერული.
და თქვენ შესაძლოა გაუმართლა და შეძლებს დაწერა 51 ხასიათი, 52, 53.
მაგრამ რაღაც მომენტში, OS თქმას, no.
ეს ნამდვილად არ არის მეხსიერების თქვენ საშუალება მისცა შეეხოთ.
და პროგრამა აპირებს segfault.
>> ასე რომ, იქ, heuristics უნდა იყოს დროს, თქვენ მოხვდით ფიქსირებული სიგრძის, თქვენ უნდა
რათა დარწმუნდეთ, რომ თქვენ შემოწმების ხანგრძლივობა რასაც ეს თქვენ ცდილობთ
წაკითხვის მივანიჭო.
>> აუდიტორია: ასე უნდა გადაწყვიტოს, რომ თქვენ შეიძლება არ ჰქონდა განაცხადი შემოწმების რეალურად
არის სიგრძეზე მეტი მეტი ან ნაკლები?
>> დევიდ ჯ Malan: აბსოლუტურად.
თქვენ უბრალოდ უნდა მდგომარეობაშია რომ ამბობს, თუ -
უფრო სწორად, თქვენ არ ემთხვეოდეს ვიცი წინასწარ რამდენი გმირები
მომხმარებლის აპირებს აკრიფოთ, რადგან თქვენ გაქვთ ქათამი და კვერცხი.
, სანამ თქვენ წაიკითხავს ერთად scanf შეგიძლიათ გაერკვნენ, თუ რამდენი ხანი არის.
მაგრამ იმ ეტაპზე, ძალიან გვიან, რადგან თქვენ უკვე წაიკითხა იგი
ზოგიერთი ბლოკი მეხსიერება.
ასე რომ, როგორც განზე, CS50 ბიბლიოთეკა თავს არიდებს ეს საკითხი საერთოდ, გაწვევას
გამოყენებით fgetc.
და ასე ერთი ხასიათი დროს, tip-toeing ერთად, იცის, რომ თქვენ
ვერ overflow ხასიათი თუ წაიკითხოთ ერთ დროს.
>> დაჭერა არის GetString გაწვევას არის რომ ჩვენ მუდმივად ხელახლა ზომა
რომ ბლოკი მეხსიერება, რომელიც მხოლოდ ტკივილი.
ეს ბევრი ხაზები კოდი გაგვაჩნია.
ასე რომ, კიდევ ერთი მიდგომა იქნებოდა რეალურად გამოიყენოს დეიდაშვილი, ასე რომ,
ვთქვათ, scanf.
არსებობს ვარიანტი ბევრი ამ ფუნქციები, რომელიც რეალურად შესამოწმებლად
ხანგრძლივობა რამდენი გმირები თქვენ შეიძლება წაიკითხოთ მაქსიმალურად.
და თქვენ ვერ დააკონკრეტა, არ კითხულობენ 50 ზე მეტი პერსონაჟი.
ასე რომ იქნება კიდევ ერთი მიდგომა, მაგრამ ნაკლებად დამთმობი დიდი საშუალებებით.
>> ასე რომ, კითხვა 2 სთხოვს, ვივარაუდოთ, რომ მობილური 3 შედგენილია და დასაჯეს.
რატომ შეიძლება, რომ პროგრამა segfault?
ასე რომ, ეს არის რეალურად იგივე პასუხის გაცემა, მიუხედავად იმისა, რომ
გამოიყურება პატარა fancier.
ჩვენ გამოყენებით malloc, რომელიც იგრძნობა ჩვენ ვაძლევთ საკუთარ თავს დამატებითი პარამეტრები.
და მაშინ ჩვენ ათავისუფლებს, რომ მეხსიერების დასასრულს.
ეს ჯერ კიდევ მხოლოდ 50 ბაიტი მეხსიერება.
ასე რომ, ჩვენ შეიძლება მაინც ცდილობენ წაიკითხონ 51, 52, 1000 bytes.
ის აპირებს segfault for ზუსტად იგივე მიზეზის გამო.
>> მაგრამ არსებობს კიდევ ერთი მიზეზი იყო.
რა შეიძლება malloc დაბრუნების გარდა, მისამართი ბლოკი მეხსიერება?
ეს შეიძლება დაუბრუნდეს null.
და იმიტომ, რომ ჩვენ არ შემოწმების რომ, ჩვენ შეიძლება თავისსავე
stupid კიდევ ერთი მიზეზი, რომელიც არის ის, რომ ჩვენ შეიძლება ვეუბნებოდი scanf, წაკითხული
მომხმარებლის შეყვანის კლავიატურის თარგმნეს 0 ადგილას, AKA null.
და რომ, ძალიან, აუცილებლად გამოიწვიოს segfault.
ისე ვიქტორინა განზრახვა, რომ ჩვენ არ მიიღება არც იმ, როგორც
მოქმედებს მიზეზი.
ერთი იდენტურია.
ერთი არის ცოტა უფრო რთული.
>> და ბოლოს, დაკავშირებით პროგრამის გამოყენების მეხსიერება, როგორ ვერსია 2 და
ვერსია 3 განსხვავდება?
ასე რომ, თუ რა ღირს, ჩვენ ვნახეთ როგორც ჩანს, გაუთავებელი მიწოდების შესაძლო
პასუხი ამ.
და მათ შორის ხალხის პასუხი, რა ვიყავით იმედი, მაგრამ ჩვენ მიღებული სხვა
რამ, გარკვეული ნახსენები ის ფაქტი, რომ ვერსია 2 გამოყენებით
ე.წ. დასტის.
Version 3 იყენებს ბევრი.
და ფუნქციურად, ეს ნამდვილად არ ყველა რომ ბევრი განსხვავება.
დასასრულს დღეს, ჩვენ ჯერ კიდევ უბრალოდ მიღების 50 ბაიტი მეხსიერება.
>> მაგრამ ეს იყო ერთი შესაძლო პასუხი რომ ჩვენ ეძებს.
მაგრამ თქვენ ნახავთ, როგორც თქვენ თქვენი ტესტებში უკან TFs, რომ ჩვენ გავაკეთეთ
მიიღოს სხვა დისკუსიებში მათი განსხვავებული მიზნებისათვის მეხსიერების ასევე.
მაგრამ დასტის და ბევრი იქნებოდა მარტივი პასუხი წასვლა.
რაიმე შეკითხვა?
მე გაძლევთ Rob.
>> რობ Bowden: ასე რომ, პრობლემა 4.
ეს არის, სადაც თქვენ უნდა შეავსოთ რაოდენობის ბაიტი out of ყველა
ამ სხვადასხვა ტიპის გამოყენებული.
ასე რომ, პირველი, რაც ჩვენ ვხედავთ.
ვივარაუდოთ, 32-bit არქიტექტურის, მოსწონს ეს CS50 ელექტრო მოწყობილობების.
ასე რომ, ერთი ფუნდამენტური რამ 32-bit არქიტექტურის, რომელიც გვეუბნება,
ზუსტად რამდენად დიდი მაჩვენებელი აპირებს იყოს არქიტექტურა.
>> ასე რომ, დაუყოვნებლივ, ჩვენ ვიცით, რომ ნებისმიერი მაჩვენებელი ტიპის 32 ბიტი ან 4 ბაიტი.
ასე შევხედავთ ამ მაგიდასთან, კვანძის * მომცეთ ტიპის.
ეს იქნება 4 ბაიტი.
Struct კვანძის *, რომ ფაქტიურად იდენტური კვანძის ვარსკვლავი.
და ისე, რომ იქნება 4 ბაიტი.
სიმებიანი, ასე რომ არ ჰგავს მაჩვენებელი არ არის, მაგრამ typedef,
string მხოლოდ char *, რომელიც არის მაჩვენებელი ტიპის.
ასე რომ იქნება 4 ბაიტი.
>> ასე რომ, ეს სამი არიან 4 ბაიტი.
ახლა კვანძის და სტუდენტი არის ცოტა უფრო რთული.
ასე ეძებს კვანძის და სტუდენტი, ჩვენ ვხედავთ კვანძის, როგორც მთელი რიცხვი და მაჩვენებელი.
და სტუდენტი არის ორი პოინტერები შიგნით მას.
ასე რომ, როგორც მინიმუმ, ჩვენს შემთხვევაში აქ, სხვათა შორის, რომ ჩვენ დასრულდება მდე გაანგარიშების ზომა
ამ struct მხოლოდ დაამატოთ მდე ყველაფერი რომ არის შიგნით struct.
>> ასე რომ, კვანძში, ჩვენ მთელი რიცხვი, რომელიც არის 4 ბაიტი.
ჩვენ მომცეთ, რომელიც 4 ბაიტი.
და ა.შ. ერთი კვანძის აპირებს დასჭირდეს 8 ბაიტი.
და ანალოგიურად სტუდენტი, ჩვენ გვაქვს მაჩვენებელი, რომ 4 ბაიტი და სხვა
მაჩვენებელი, რომ 4 ბაიტი.
ასე რომ აპირებს დასრულდება მდე 8 ბაიტი.
ასე რომ კვანძის და სტუდენტური 8 bytes.
და ეს სამი არიან 4 ბაიტი.
კითხვები რომ?
დიახ.
>> აუდიტორია: ეს იყო 64-bit არქიტექტურა, იქნებოდა, რომ
გაორმაგება ყველა მათგანი?
>> რობ Bowden: ეს არ გაორმაგება ყველა მათგანი.
ასე რომ, 64-bit არქიტექტურის, ეს, კიდევ ერთხელ, ცვლილებები, რომ ფუნდამენტური რამ, რომ
მაჩვენებელი არის 64 ბიტი.
ჰო.
ასე რომ კურსორი არის 8 ბაიტი.
ასე რომ, ეს რომ იყო 4 bytes იქნება 8 ბაიტი.
სტუდენტი, რომელიც ორ მითითებას, კარგად, ახლა ის აპირებს
იქნება 8 ბაიტი, 8 bytes.
ის აპირებს, რომ 16 bytes.
>> მაგრამ კვანძის ჯერ კიდევ 4 ბაიტი.
ასე რომ, ეს მაჩვენებელი აპირებს უნდა იყოს 8 ბაიტი.
ეს არის 4 ბაიტი.
ასე რომ კვანძის მხოლოდ აპირებს უნდა იყოს 12 ბაიტი.
ნებისმიერი სხვა სახის კითხვებით, რომ ერთი?
ასე რომ, მომდევნო ერთი, ეს არის HTTP სტატუსის კოდები.
და თქვენ უნდა აღწერს გარემოებები რომლის თანახმადაც, ეს შეიძლება
დაუბრუნდება თქვენ.
ერთი პრობლემა, რომ გავიგე, რომ ზოგიერთი სტუდენტი ის არის, რომ ისინი ცდილობდნენ, რათა
შეცდომები იყოს კლიენტის ბოლომდე.
ასე რომ, როდესაც ჩვენ ვცდილობთ, რათა თხოვნა სერვერზე, რაღაც მიდის
არასწორი ჩვენს ბოლომდე.
მაგრამ ზოგადად, ეს კოდები მიმდინარეობს დაბრუნდა სერვერის მიერ.
ასე რომ ჩვენ გვინდა, რომ გაერკვნენ, თუ რა ხდება არასწორი ან უფლება სერვერზე,
იწვევს ეს ყველაფერი უნდა დაბრუნდნენ.
რატომ შეიძლება სერვერზე ბრუნდება სტატუსის კოდი 200?
ნებისმიერი აზრები?
>> ჰო.
ასე რომ, რაღაც შესახებ წარმატებით მოთხოვნის გაიარა.
და ისინი დაიბრუნებენ რასაც თქვენ სთხოვა.
ასე რომ, ყველაფერი იყო ჯარიმა.
რაც შეეხება 302 ვიდეო?
ჰო.
>> აუდიტორია: სერვერის ეძებდა რას მოითხოვა.
მაგრამ ეს ვერ პოულობთ მას.
ასე რომ იქ შეცდომა.
>> რობ Bowden: ასე სერვერი ეძებს რა უნდოდა.
ასე რომ, უბრალოდ ეძებს აქ, 302 ი, ეს იყო მიაგნეს.
>> აუდიტორია: მე უკაცრავად.
ნაპოვნია იმას ნიშნავს, რომ ისინი არ საპოვნელად.
უკაცრავად.
>> რობ Bowden: ასე რომ 302 ი.
სერვერზე ვერ პოულობენ რა უნდოდა.
>> აუდიტორია: მაგრამ ეს არ აჩვენებს ეს?
>> რობ Bowden: განსხვავება ამ 302 და 200 არის ის, რომ
იცის, რა გსურთ.
მაგრამ ეს არ არის ზუსტად სადაც თქვენ სურდა ვთხოვო.
ასე რომ 302 არის ტიპიური გადამისამართება.
ასე რომ, თქვენს მიერ მოთხოვნილი გვერდი.
მან იცის, რა, მინდა უკან დაბრუნებას თქვენ ამ.
მაგრამ ეს არის სხვადასხვა URL.
ასე რომ, hey, თქვენ ნამდვილად გინდათ ეს.
>> დევიდ ჯ Malan: ეს ნაჭერი რომ განაცხადა, რომ მივეცით თქვენ ბიჭები გადამისამართება
ფუნქცია, რომელიც გამოიყენება header ფუნქცია რაც, თავის მხრივ, იბეჭდება ადგილმდებარეობა,
მსხვილი ნაწლავის და შემდეგ URL რომლის გსურთ უარყოფს შესახებ.
მიუხედავად იმისა, რომ თქვენ ვერ ვხედავ 302 ღიად არსებობს, რომ არის ის, რაც PHP
რომ magically ჩასმა როგორც header ამბობდა ზუსტად რა რობ განაცხადა, რომ -
ი.
მაგრამ აქ ნაცვლად.
>> რობ Bowden: OK.
ასე რომ, რაც დაახლოებით 403 აკრძალულია?
>> აუდიტორია: მე ვფიქრობ, რომ სერვერზე ძირითადად განაცხადა, რომ კლიენტის
ვერ შედიხართ მთავარ გვერდზე.
>> რობ Bowden: ასე რომ, დიახ.
ისე, ტიპიური პასუხი ჩვენ ველოდებით რაღაც, ფაილი
არ chmodded სათანადოდ.
ეს, ალბათ, რა პირობებში თქვენ ხედავთ მათ.
მაგრამ არის მიზეზი იმისა, რომ კლიენტის შეიძლება იყოს დამნაშავე აქ.
იქ რეალურად კიდევ ერთი შემოწმება კოდი -
401.
ასე რომ, ეს ძალიან ჰგავს.
>> 401 არის არასანქცირებული.
და 403 აკრძალულია.
და ასე არასანქცირებული თქვენ მხოლოდ კიდევ თუ თქვენ არ ხართ შემოსული
მაგრამ შესასვლელად შეიძლება ნიშნავდეს რომ თქვენ უფლება.
მაგრამ თუ თქვენ უკვე სისტემაში ხართ და თქვენ ჯერ კიდევ არ გაქვთ, მაშინ
ასევე შეგიძლიათ აკრძალულია.
ასე რომ, თუ თქვენ ხართ და არ გაქვთ ნებართვის აკრძალულია ასევე
რაღაც შეგიძლიათ მიიღოთ.
>> დევიდ ჯ Malan: და მექანიზმი რომელიც ამ პრობლემების, როგორც წესი,
მოგვარდება სერვერზე არის მეშვეობით რა ბრძანება?
Chmod, თუ ის, რა თქმა უნდა, უფლებები საკითხი ფაილი ან დასტა.
>> რობ Bowden: მაშინ 404 არ არის ნაპოვნი.
ჰო.
ასე განსხვავებით 302, სადაც ეს არ იყო ზუსტად სადაც თქვენ გეკითხებით, მაგრამ ეს იცის, რა
გსურთ,, ეს უბრალოდ აქვს არ ვიცი, რა გსურთ.
და თქვენ არ ვითხოვთ რაღაც მოქმედებს.
418 ვარ ჩაიდანი და შემდეგ 500 შიდა სერვერზე.
რატომ შეიძლება თქვენ, რომ?
>> ასე segfault -
მე რეალურად არ ვიცი შეფასების სტანდარტული ამ.
მაგრამ თუ თქვენი PHP კოდი ჰქონდა რაღაც არასწორი ის, თეორიულად, ეს შეიძლება
რეალურად segfault, ამ შემთხვევაში, ეს 500 შიდა შეცდომა სერვერზე, რაღაც
არასწორია თქვენი სერვერის კონფიგურაცია.
ან არსებობს სინტაქსური შეცდომა თქვენი PHP კოდი.
ან რაღაც ცუდი ხდება.
>> დევიდ ჯ Malan: ჩვენ არ ვხედავთ segfault შორის რამდენიმე ხალხის პასუხი.
და ტექნიკურად, ეს არ შეიძლება მოხდეს.
მაგრამ ეს იქნება PHP, პროგრამა დაწერილი სხვა ადამიანებს, რეალურად
segfaulted, რომელიც მხოლოდ იმ შემთხვევაში, თუ იმ ხალხს, ბრალია და დაწერა buggy კოდექსი
მათი თარჯიმანის იქნება PHP თავად segfault.
ასე რომ, მიუხედავად იმისა, რომ 500 ჰგავს segfault სული, ის თითქმის ყოველთვის
შედეგი კონფიგურაციის ფაილი საკითხი თქვენი სერვერზე, ან, როგორც Rob განაცხადა,
სინტაქსური შეცდომა, ისევე როგორც თქვენ არ დახუროს გაცემა.
ან თქვენ დაკარგული მძიმით სადღაც.
>> აუდიტორია: ასე რომ Shuttle pset, მე ვფიქრობ, როდესაც მე ეს ერთხელ მე დაწკაპავთ
ბრაუზერი, მაგრამ არაფერი გამოვიდა, იმას, რასაც თეთრი გვერდზე.
მაგრამ ეს იყო, რადგან კოდი.
ვფიქრობ, რომ JavaScript, არა?
>> რობ Bowden: ჰო.
>> აუდიტორია: Would რომ შეცდომა კვლავ ამუშავება?
>> რობ Bowden: ასე რომ, თქვენ არ მიღებული ეს შეცდომა, რადგან ყველაფერი
ეხლა სერვერზე პერსპექტივა სრულიად ჯარიმა.
მაგრამ თქვენ მოითხოვა index.html.
თქვენს მიერ მოთხოვნილი shuttle.js და service.js.
და ეს შეძლო წარმატებით დაბრუნდნენ თქვენ ყველა იმ რამ -
200.
OK.
ეს მხოლოდ მაშინ, როდესაც თქვენს ბრაუზერში ცდილობდა ინტერპრეტაცია JavaScript კოდი, რომელიც
ეს იგივეა, დაველოდოთ, ეს არ არის ძალაშია JavaScript შეცდომა.
ნებისმიერი სხვა კითხვები?
ყველა უფლება.
>> დევიდ ჯ Malan: ასე რომ, მომავალ up იყო ნომერი 11.
11 იყო scariest ბევრი ადამიანი.
ასე რომ, ყველაზე მნიშვნელოვანი რამ აღვნიშნო აქ იყო, რომ ეს იყო, რა თქმა უნდა, დაახლოებით
ორმაგად უკავშირდება სიაში.
მაგრამ ეს არ იყო იგივე, რაც გასულ წელს ორმაგად უკავშირდება სიაში პრობლემა,
რომელიც არ მოგცემთ caveat რომ სიაში შეიძლება, ფაქტობრივად, იქნება დაუხარისხებელი.
>> ასე რომ, ის ფაქტი, რომ სიაში იყო დაუხარისხებელი და ის ფაქტი, რომ სიტყვა იყო
ხაზი გაუსვა იქ იყო გათვლილი გადმომეცა რომ ეს არის რეალურად გამარტივება
რა სხვაგვარად იქნებოდა უფრო რთული პრობლემა
და აღარ იყო.
ასე რომ ჩვეულებრივი შეცდომა აქ იყო შეეძლო შარშანდელი გადაწყვეტა თქვენი ერთი
მასალა და შემდეგ უბრალოდ ბრმად კოპირება რომ ქვემოთ, როგორც პასუხი, რომელიც არის სწორი
პასუხი სხვადასხვა კითხვაზე მსგავსი სულისკვეთება.
მაგრამ subtleties აქ იყო შემდეგნაირად.
>> ასე რომ, ერთი, ჩვენ კვანძის განაცხადა და განსაზღვრული ჩვეულ აქ.
მაშინ ჩვენ განსაზღვრული სიაში იყოს გლობალური მაჩვენებელი ინიციალიზაცია to null.
შემდეგ, როგორც ჩანს, არსებობს ორი ფუნქცია ჩვენ პროტოტიპები აქ, insert
და ამოიღონ.
და მაშინ ჩვენ გვაქვს რამოდენიმე ნიმუში კოდი აქ აკეთებს bunch of insertions.
და მაშინ ჩვენ გთხოვთ შეავსოთ განხორციელების insert ქვემოთ ასეთი
ისე, რომ ეს ჩანართები n შეყვანილი მუდმივ დრო, ასევე ხაზი გაუსვა,
მაშინაც კი, თუ უკვე იმყოფება.
>> ასე რომ, სილამაზის, რათა ჩადეთ მუდმივ დრო არის, რომ ეს გულისხმობს
რომ თქვენ უნდა ჩაწეროთ ახალი კვანძის სად?
Into წინ.
ასე რომ, ეს გამორიცხავს, ​​საბედნიეროდ, მაინც ერთ შემთხვევაში, რომელიც მოითხოვს
კიდევ უფრო ხაზი კოდი, როგორც ეს გააკეთა გასულ წელს კი კლასში, როდესაც ჩვენ
ისაუბრა ამ სახის რამ ადამიანები და ზოგიერთი
სიტყვიერი ფსევდო კოდი.
ასე რომ, გამოსავალი აქ, მოდით გამოტოვოთ მეტი რომ მხოლოდ აქვს ვიზუალური on
ეკრანზე.
>> გაითვალისწინეთ, რომ ჩვენ ვაკეთებთ შემდეგ.
ასევე შეამჩნევთ სხვა გამარტივებას იყო ის, რომ თუნდაც ეს
უკვე, ასე რომ, ეს იმას ნიშნავს, მაშინაც კი, თუ ნომერი უკვე არსებობს, თქვენ შეგიძლიათ
უბრალოდ ბრმად ჩადეთ მეორე ასლი.
და რომ, ძალიან, იყო გათვლილი უნდა იყოს გამარტივება, ასე რომ თქვენ შეიძლება
ფოკუსირება, მართლაც, ზოგიერთი უფრო ინტელექტუალურად საინტერესო ნაწილი და
არა მხოლოდ რამდენიმე დამატებითი შეცდომების შემოწმების მოცემული შეზღუდული დრო.
>> ასე რომ, ამ ნიმუში გადაწყვეტა, ჩვენ გამოყოფს მომცეთ მარცხენა ხელი
მხარეს აქ კვანძში.
ახლა, გააცნობიეროს, რომ მაჩვენებელი, როგორც Rob თქმით, მხოლოდ 32 ბიტი.
და ის ფაქტობრივად არ შეიცავს მისამართი, სანამ
მივანიჭოთ მას მისამართზე.
და ჩვენ გავაკეთებთ, რომ მარჯვენა მხარე მეშვეობით malloc.
მსგავსად კარგი მოქალაქე, ჩვენ შეამოწმოთ, რომ malloc არ არის, ფაქტობრივად, null, ისე, რომ
ჩვენ არ შემთხვევით შექმნა segfault აქ.
და ნებისმიერ დროს თქვენ იყენებთ malloc ცხოვრებაში, თქვენ უნდა შემოწმების for null, ნუუკუე
თქვენ გაქვთ დახვეწილი bug.
>> მაშინ ჩვენ ინიციალიზაცია რომ null მიერ მინიჭების n და წინა და მომავალი.
და ამ შემთხვევაში აქ, მე ინიციალიზაცია წინა null, რადგან ამ
კვანძის იქნება ახალი დასაწყისში ჩემს სიაში.
ასე რომ არ იქნება არაფერი სანამ.
და მინდა არსებითად დამატება არსებულ სიას ახალი კვანძის მიერ
შექმნის შემდეგ ტოლია სიაში თავად.
მაგრამ მე არ კეთდება მხოლოდ ამჟამად.
ასე რომ, თუ სიაში თავად უკვე არსებობდა, და იყო მინიმუმ ერთი კვანძის
უკვე ადგილი, თუ ეს სია აქ მე და ჩადეთ ახალი კვანძის აქ, მე
უნდა დავრწმუნდეთ, რომ ჩემი ყოფილი კვანძის მიუთითებს პირდაპირ ჩემს ახალ კვანძში,
რადგან ეს არის, კიდევ ერთხელ, ორმაგად უკავშირდება სიაში.
>> ასე რომ, ჩვენ გავაკეთოთ საღი აზრის ქვითარი.
თუ სია არ null, თუ არსებობს უკვე ერთი ან მეტი კვანძების არსებობს, მაშინ
დავამატებთ, რომ უკან მინიშნება ასე ვთქვათ.
და შემდეგ ძალიან ბოლო რაც ჩვენ გვჭირდება, ამის გაკეთება რეალურად განახლება გლობალურ
ცვლადი სიაში თავად აღვნიშნო რომ ახალი კვანძში.
ჰო.
>> აუდიტორია: In მაჩვენებელი arrow [INAUDIBLE] უტოლდება null, აკეთებს, რომ
გამკლავება სიაში იმიტომ, სიაში null?
>> დევიდ ჯ Malan: Nope.
ეს უბრალოდ ჩემთვის მყოფი პროაქტიულად ფრთხილად, რომ თუ ეს არის ჩემი
ორიგინალური სიაში შესაძლოა, კიდევ რამდენიმე კვანძების მეტი აქ და მე ჩასმა my
ახალი კვანძის აქ, იქ უნდა არაფერი აქ.
და მინდა ხელში ამ იდეის მიიღწევა წინა
null ახალ კვანძში.
და, სავარაუდოდ, იმ შემთხვევაში, თუ ჩემი კოდი სწორია და არ არსებობს სხვა გზა ჩადეთ
კვანძების, გარდა ამ ფუნქციას, სავარაუდოდ, მაშინაც კი, თუ სიაში უკვე აქვს
ერთი ან მეტი კვანძების ის, სავარაუდოდ, სიაში, პირველი კვანძის, ექნება
წინა კურსორი of null თავად.
>> აუდიტორია: და მხოლოდ შემდგომი.
მიზეზი თქვენ დააყენა მაჩვენებელი მომდევნო შეადგენს სია თქვენ მიღების მაჩვენებელი
ადრე სია, რომ ის მიუთითებს მომდევნო, მე ვფიქრობ, -
I don't -
უბრალოდ ჩამოთვლილია?
>> დევიდ ჯ Malan: ზუსტად.
და მოდით რეალურად განვიხილოთ ორი შემთხვევა, აქ ნამდვილად, მიუხედავად იმისა,
იმისათვის, ჩვენ მიგვაჩნია, რომ მათ არ არის საკმაოდ იგივე როგორც კოდი.
მაგრამ მაღალი დონის, თუ ეს წარმოადგენს სიაში და ეს არის 32-bit
მაჩვენებელი, მარტივი სცენარი რომ ეს null იყოს.
და ვარაუდობენ, მინდა ჩადეთ ნომერი 50 იყო პირველი ნომერი.
ამიტომ მე ვაპირებ წავიდეთ წინ და გამოყოფს კვანძში, რომელიც აპირებს შეიცავს
სამი სფეროებში -
n, წინა და მომდევნო.
>> მე ვაპირებ დააყენა ნომერი 50 აქ, რადგან ეს იქნება n.
ეს იქნება მომავალი.
და ეს იქნება წინა.
და მერე რა გავაკეთო ამ შემთხვევაში?
ისე, მე უბრალოდ გაკეთდეს ხაზი 1 აქ.
Pointer n იღებს n.
მე მაშინ ამბობდა, წინა უნდა null.
ასე რომ, ეს იქნება null.
მაშინ მე ვაპირებ ვთქვა შემდეგი აპირებს მიიღოს სიაში.
>> და ეს უბრალოდ მუშაობს კარგად.
ეს არის null.
და ა.შ. მე ვამბობ, რომ ახალი კვანძის მომდევნო სფეროში უნდა მიიღოს, რასაც ეს.
ასე რომ აყენებს სხვა null არსებობს.
და მაშინ ბოლო რამ მე არის გადაამოწმოთ აქ.
თუ სიაში არ არის ტოლი null, მაგრამ ეს უდრის null, ამიტომ ჩვენ გამოტოვოთ, რომ
საერთოდ.
და ა.შ. ყველა გავაკეთო მომავალი სია იღებს მაჩვენებელი, რომელიც pictorially შედეგები
სურათი იგრძნობა.
ასე რომ, ერთი სცენარი.
>> და ერთი, რომ თქვენ გეკითხებით კონკრეტულად არის სიტუაცია მოსწონს,
სადაც ჩვენ უკვე გვაქვს ერთი კვანძის სიაში.
და თუ მე დაბრუნდეს ორიგინალური პრობლემის განაცხადი, შემდეგ ჩვენ გამოგიგზავნით
ჩადეთ ვთქვათ 34, მხოლოდ გულისთვის დისკუსია.
ამიტომ მე ვაპირებ უბრალოდ მოხერხებულად მიაპყროს, რომ მეტი აქ.
მე უბრალოდ malloced.
მოდით ვივარაუდოთ, მე შემოწმების for null.
>> ახლა, მე ვაპირებ ინიციალიზაცია n იყოს 34.
და ეს იქნება n.
ეს იქნება მომავალი.
და ეს იქნება წინა.
მოდით დარწმუნდით მე არ მიიღოს ეს უკან.
წინა მოდის პირველი ამ განმარტებას.
ნება მომეცით დაფიქსირება ამ.
ეს არის წინა.
ეს არის მომავალი.
მიუხედავად იმისა, რომ ეს არის იდენტური, მოდით შენარჩუნება ეს შეესაბამება.
>> წინა.
ეს არის მომავალი.
ასე რომ მე უბრალოდ malloced ჩემი შენიშვნა, შეამოწმეს for null მინიჭებული 34 წუთზე კვანძში.
წინა იღებს null.
ასე რომ მაძლევს, რომ.
შემდეგი იღებს სიაში.
ასე რომ, სიაში არის ეს.
ასე რომ, ეს იგივეა ახლა, როგორც ხატვის ამ arrow, ასე რომ აღვნიშნო, რომ ერთი
იმავე.
და მაშინ მე შემოწმების თუ სიაში არ არის ტოლი null.
და ეს არ არის ამ დროს.
შემდეგ მე ვაპირებ გავაკეთოთ სია წინა იღებს მაჩვენებელი.
>> ასე რომ სიაში previous იღებს PTR.
ასე რომ, ეს ეფექტი აყენებს გრაფიკული arrow აქ.
და ეს სულ ცოტა wavy, ხაზები.
და მერე ბოლოს, მე განახლება სიაში აღვნიშნო კურსორი.
ასე რომ, ახლა ეს მიუთითებს ამ ბიჭს.
და ახლა, მოდით სწრაფი საღი აზრის ქვითარი.
>> აი ჩამონათვალი, რომელიც გლობალური ცვლადი.
პირველი კვანძის არის, რა თქმა უნდა, 34, იმიტომ, მე შემდეგ, რომ arrow.
და ეს სწორია იმიტომ, რომ მინდა ჩადეთ დასაწყისში სიაში
ყველა ახალი კვანძების.
მისი მომავალი ველი გამახსენა ამ ბიჭს.
თუ მე შენარჩუნებას აპირებს, მე მოხვდა მომავალი null.
ასე რომ არ არის უფრო სიაში.
თუ მე მოხვდა წინა, მივიღებ უკან, სადაც მე ველოდოთ.
>> ასე რომ, ჯერ კიდევ არსებობს რამდენიმე მითითებას, ცხადია, მანიპულირება.
მაგრამ ის ფაქტი, რომ თქვენ განუცხადა უნდა გააკეთოს ამ მუდმივ დრო ნიშნავს, რომ თქვენ მხოლოდ
აქვს სასრული რაოდენობის რამ თქვენ უფლება არ.
და რა არის ის, რომ ნომერი?
ეს შეიძლება იყოს ერთი ნაბიჯია.
ეს შეიძლება იყოს ორი.
ეს შეიძლება იყოს 1,000 ნაბიჯი.
მაგრამ სასრული, რაც იმას ნიშნავს, თქვენ არ შეგიძლიათ რაიმე სახის looping მიმდინარეობს
აქ, არ უკან, არ მარყუჟების.
უბრალოდ რაღაც უნდა იყოს მყარი კოდირებული ხაზები კოდი, როგორც ჩვენ ამ ნიმუში.
>> ასე რომ, მომდევნო პრობლემა 12 გვთხოვა შეავსოთ განხორციელების remove
ქვემოთ ისე, რომ ეს ხსნის n სიიდან ხაზოვანი დროს.
ასე, რომ თქვენ გაქვთ ცოტა მეტი wiggle ოთახი არის.
თქვენ შეიძლება ვივარაუდოთ, რომ n, თუ დღემდე სიაში, იქნება წარმოდგენილი
არა უმეტეს ერთხელ.
და რომ ძალიან იგულისხმება იყოს ვიქტორინა დაფუძნებული გამარტივების ვარაუდი, ასე რომ,
იმ შემთხვევაში, თუ თქვენთვის ნომერი 50 სადმე სიაში, თქვენ ასევე არ
უნდა ფიქრი გრძელდება iterate, ეძებს ყველა შესაძლო
ასლი 50, რომელიც მხოლოდ გადაეცემა შევიდა ზოგიერთი minutia შეზღუდული დრო.
>> ასე რომ ამოიღონ, ეს იყო ნამდვილად უფრო რთული და მეტი
კოდი დაწერა.
მაგრამ ერთი შეხედვით, გულწრფელად, შესაძლოა, გამოიყურება დიდი და რაღაც
არ არსებობს გზა, თქვენ შეიძლება ამუშავება on ვიქტორინა.
მაგრამ თუ ჩვენ ფოკუსირება ინდივიდუალური ნაბიჯები, იმედია, ის მოულოდნელად
გაფიცვის თქვენ, რომ თითოეული ეს ინდივიდუალური ნაბიჯები რაც აშკარა აზრი
ამ დროის.
მოდით შევხედოთ.
>> ასე რომ, პირველ რიგში, ჩვენ ინიციალიზაცია მაჩვენებელი უნდა იყოს სიაში თავად.
რადგან მინდა ხაზოვანი დროს, რომ საშუალება მე ვაპირებ გარკვეული loop.
და გავრცელებული გზა iterate მეტი კვანძების სია სტრუქტურის ან რაიმე სახის
სტრუქტურა iteratively არის მიიღოს მომცეთ წინაშე მონაცემები
სტრუქტურა და შემდეგ დავიწყო განახლება და ფეხით თქვენი გზა
მეშვეობით მონაცემთა სტრუქტურას.
ასე რომ, მე ვაპირებ ზუსტად რომ.
>> მიუხედავად იმისა, რომ მაჩვენებელი, ჩემი დროებითი ცვლადი, არ არის ტოლი null, მოდით
წავიდეთ წინ და შეამოწმოთ.
მივიღებ გაუმართლა?
არის n სფეროში კვანძის მე ვარ ამჟამად ეძებს ტოლია
ნომერი ვეძებ?
და თუ ასეა, მოდით რაღაც.
ახლა შეამჩნია ეს თუ მდგომარეობა გარს მთელი
შემდეგ ხაზი კოდი.
ეს არის ერთადერთი, რაც მე აინტერესებს - მოძიებაში ნომერი კითხვა.
ასე რომ არ არის სხვა, რაც ამარტივებს რამ კონცეპტუალურად ცოტა.
>> მაგრამ ახლა მივხვდი, და ალბათ მხოლოდ მიხვდა, შემდეგ ფიქრი
ის მეშვეობით bit, იქ რეალურად ორი შემთხვევა აქ.
ერთი არის, სადაც კვანძის არის დასაწყისში სიაში, რომელიც
პატარა შემაშფოთებელი, რადგან ეს არის ის, განსაკუთრებული შემთხვევა, რადგან თქვენ უნდა გაუმკლავდეთ
ამ რამ, რაც ერთადერთი ანომალიაა.
ყველგან სიაში, ეს არის იგივე.
არსებობს წინა კვანძის და მომდევნო კვანძის წინა კვანძის მომდევნო კვანძის.
მაგრამ ეს ბიჭი არის პატარა სპეციალური თუ ის დასაწყისში.
>> ასე რომ, თუ მაჩვენებელი შეადგენს სიაში თავისთავად, ასე რომ, თუ მე ვარ დასაწყისში
სიაში და მე აღმოვაჩინე n, მე უნდა გავაკეთოთ რამოდენიმე რამ.
ერთი, მე უნდა შეიცვალოს სია აღვნიშნო, რომ მომავალი ველი, 50.
ასე რომ, ვფიქრობ, რომ მე ვცდილობ წაშლა 34.
ასე რომ, ეს ბიჭი წასვლა მოშორებით რაღაც მომენტში.
>> ამიტომ მე ვაპირებ ვთქვა, სია იღებს მაჩვენებელი მომავალი.
ისე, ეს მაჩვენებელი.
შემდეგი მიუთითებს მეტი აქ.
ასე რომ ეს იცვლება ამ ისარს უფლება ახლა აღვნიშნო, რომ ამ ბიჭს აქ.
ახლა, მახსოვს, ჩვენ დროებითი ცვლადი.
ასე რომ, ჩვენ არ ობოლი ნებისმიერი კვანძების, იმიტომ, რომ მე ასევე აქვს ამ ბიჭს ჩემი
განხორციელების ამოიღონ.
ახლა, თუ სიაში თავად არ null, მე უნდა დააფიქსიროს პატარა რაღაც.
>> მე უნდა ახლა დავრწმუნდეთ, რომ ეს ისარი, რომელიც ადრე მიუთითებს
50 34, ამ აქვს მიდიან, იმიტომ, რომ თუ მე ვცდილობ, თავი დაეღწია
34, 50 ჰქონდა უკეთესი არ შენარჩუნება ნებისმიერი სახის უკან მინიშნება, როგორც
arrow შესთავაზა.
ასე რომ მე უბრალოდ ეს ხაზი.
ასე რომ მაშინ მე გაკეთდეს.
ასეთ შემთხვევაში რეალურად საკმაოდ მარტივია.
Chopping off უფროსის სია შედარებით მარტივია.
>> სამწუხაროდ, არ არის ეს შემაშფოთებელი else ბლოკი.
ახლა, მე უნდა განიხილოს საქმე იქ, სადაც არის რაღაც ცენტრიდან.
მაგრამ ეს არ არის ძალიან საშინელი, გარდა განთავსების სინტაქსი მოსწონს ეს.
ასე რომ, თუ მე არ ვარ დასაწყისში სიაში, მე სადღაც შუა.
და ამ ხაზის აქ ამბობს, დასაწყისიდან რასაც კვანძის თქვენ.
გადასვლა წინა კვანძის მომდევნო სფეროში და აღვნიშნო, რომ მაჩვენებელი.
>> მოდით ეს ხატოვნად.
ეს იყო მიღების რთული.
ასე რომ, თუ მაქვს დამთვალიერებლები აქ - მოდით ეს - მომავალ სფეროებში აქ.
მე ვაპირებ გამარტივება ჩემი პოინტერები საკმაოდ გარდა მიაპყროს მთელი bunch
ყველაფერი უკან და მეოთხე crisscrossing ერთმანეთს.
და ახლა, მოდით უბრალოდ, ვამბობთ, ეს არის 1, 2, 3 გულისთვის დისკუსია, თუნდაც
მიუხედავად იმისა, რომ არ გამოდიან პრობლემის საკითხი.
>> ასე რომ, აქ არის ჩემი უკავშირდება სიაში.
ვცდილობ ამოიღონ ორი ამ კერძოდ, მობილური ამბავი.
ასე რომ მე განახლებული მომცეთ იქნება მიუთითებს ამ ბიჭს.
ასე რომ, ეს PTR.
ის მიუთითებს აქ.
ეს არის სია, რომელიც არსებობს გლობალურად, როგორც ადრე.
და ის მიუთითებს აქ არ აქვს მნიშვნელობა რა.
და ახლა, ვცდილობ ამოიღონ ორი.
>> ასე რომ, თუ მაჩვენებელი მიუთითებს აქ, სადაც მე ვარ აპირებს დაიცვას, როგორც ჩანს,
წინა მაჩვენებელი, რომელიც აყენებს ჩემთვის 1.
მე მაშინ აპირებს ამბობენ, რომ მომავალი სფეროში, რომელიც მოაქვს ჩემთვის მეტი ამ
ყუთი აქ, აპირებს თანაბარი მაჩვენებელი მომავალი.
ასე რომ, თუ ეს მაჩვენებელი, ეს არის მომავალი.
ეს ნიშნავს, რომ ამ ისარს საჭიროებების აღვნიშნო, რომ ამ ბიჭს.
>> მერე რა, რომ ხაზი კოდი ახლახანს გაკეთდეს ცოტა ეს.
და ახლა, ეს ეძებს მოსწონს ნაბიჯი სწორი მიმართულებით.
ჩვენ არსებითად გსურთ snip 2 out შუა 1 და 3.
ასე რომ აზრი, რომ ჩვენ გვინდა მარშრუტი ეს მაჩვენებელი გარშემო.
ასე რომ, ეს მეორე ხაზი შემოწმების თუ მაჩვენებელი მომავალი არ null, არსებობს
მართლაც ვინმეს უფლება, 2, ეს ნიშნავს, რომ ჩვენ ასევე უნდა გავაკეთოთ
პატარა snip აქ.
>> ასე რომ, მე ახლა უნდა დაიცვას ეს მაჩვენებელი განახლება და წინა მაჩვენებელი წლის
ამ ბიჭს უნდა გავაკეთოთ ცოტა Workaround აქ წერტილი აქ.
და ახლა, ვიზუალურად ეს არის ლამაზი.
ეს პატარა ბინძურ, რომ იქ არავინ მიუთითებს 2 უქმნით.
2 მიუთითებს მარცხენა.
და 2 მიუთითებს უფლება.
მაგრამ მას არ შეუძლია გააკეთოს რაც მას სურს, რადგან ის შესახებ უნდა გათავისუფლდეს.
და არა აქვს მნიშვნელობა, თუ რა იმ ღირებულებები უქმნით.
>> მნიშვნელოვანია, რომ დარჩენილი ბიჭები routing ზემოთ
და ქვემოთ მას ახლა.
და მართლაც, ის, რაც ჩვენ გავაკეთოთ შემდეგი.
ჩვენ თავისუფალი მაჩვენებელი, რაც იმას ნიშნავს, ვუთხრა ოპერაციული სისტემის, თქვენ მივესალმებით
დაბრუნდეს ეს.
და მერე ბოლოს, ჩვენ დაბრუნდება.
Else მინიშნებით, თუ ჩვენ არ დაუბრუნებიათ ჯერ,
გვაქვს შენარჩუნება ეძებს.
ასე მაჩვენებელი შეადგენს მაჩვენებელი მომავალი მხოლოდ ნიშნავს გადაადგილება ამ ბიჭს აქ.
გადაადგილება ამ ბიჭს აქ.
გადაადგილება ამ ბიჭს აქ, თუ, ფაქტობრივად, ჩვენ არ იპოვოს ნომერი
ჩვენ ვეძებთ ამჟამად.
>> ასე რომ, სიმართლე გითხრათ, ეს გამოიყურება სრულიად დიდი, მე ვფიქრობ, პირველ რიგში,
ერთი შეხედვით, განსაკუთრებით თუ ბრძოლა ამ დროს ინტელექტუალური მერე ვნახოთ
რაღაც მსგავსი.
და თქვენ pat თავს უკან.
ასევე, არ არსებობს გზა მე შეიძლება ამუშავება, რომ ვიქტორინა.
მაგრამ მე ვიტყოდი, შეგიძლიათ თუ დაარღვიოს მას down შევიდა ამ ინდივიდუალური
შემთხვევებში და მხოლოდ ფეხით მეშვეობით ფრთხილად, თუმცა, უნდა აღინიშნოს, ქვეშ
სტრესულ ვითარებაში.
>> საბედნიეროდ, სურათზე გააკეთა ყველაფერი ბედნიერი.
თქვენ შეიძლება შევაჩერო ამ ნებისმიერი რაოდენობის გზები.
თქვენ არ უნდა გავაკეთოთ crisscrossing რამ აქ.
თქვენ ეს სწორი ხაზები მოსწონს ეს.
მაგრამ არსი ამ პრობლემა, ზოგადად, იყო ის, რომ გააცნობიეროს, რომ
სურათზე ბოლომდე უნდა გამოიყურებოდეს პატარა რაღაც, რადგან
მუდმივი დრო იგულისხმება, რომ თქვენ გაქვთ jamming და jamming და jamming
ახალი კვანძების დასაწყისში სიაში.
რაიმე შეკითხვა?
ალბათ ყველაზე რთული და რა თქმა უნდა, კოდირების შეკითხვებს.
>> აუდიტორია: ასე სიაში მსგავსი უხელმძღვანელებს წინა მაგალითი.
>> დევიდ ჯ Malan: ზუსტად, ზუსტად.
უბრალოდ სხვადასხვა სახელი გლობალური ცვლადი.
მსოფლიო რა?
>> რობ Bowden: OK.
ასე რომ, ეს არის ის, სადაც თქვენ ჰქონდა დაწერა მე.
ზოგიერთი ადამიანი დაწერა ესეები ამ კითხვაზე.
მაგრამ თქვენ უბრალოდ უნდა გამოვიყენოთ ამ ექვსი თვალსაზრისით აღწერს რა ხდება, როდესაც
თქვენ ცდილობენ დაუკავშირდეთ facebook.com.
ასე რომ მე უბრალოდ გაიგო პროცესში გამოყენებით ამ თვალსაზრისით.
ასე, რომ ჩვენს ბრაუზერში ვწერთ facebook.com და დააჭიროთ.
ასე რომ, ჩვენი ბრაუზერის აპირებს ააშენოს HTTP მოითხოვოს, რომ ის აპირებს გამოაგზავნოს
ზოგიერთი პროცესი Facebook for Facebook უპასუხოს ჩვენს
HTML მისი გვერდზე.
>> რა არის პროცესი, რომელიც HTTP მოთხოვნა
რეალურად იღებს Facebook?
ასე რომ, პირველი, ჩვენ უნდა თარგმნოს Facebook.com.
ასე რომ მხოლოდ სახელს Facebook.com, სადაც რეალურად აკეთებს HTTP მოთხოვნის
უნდა წავიდეთ?
ამიტომ, ჩვენ უნდა თარგმნოს Facebook.com IP მისამართი, რომელიც ცალსახად
განსაზღვრავს, თუ რა მანქანა ჩვენ რეალურად გსურთ გააგზავნოთ ამ მოთხოვნით.
თქვენი ლეპტოპი აქვს IP მისამართი.
არაფერს ინტერნეტთან აქვს IP მისამართი.
>> ასე რომ, DNS, დომენური სახელის სისტემა, რომელიც რა ხდება გაუმკლავდეს თარგმანი
ეხლა facebook.com IP მისამართი, რომელიც თქვენ ნამდვილად გინდათ დაუკავშირდეს.
ასე რომ, ჩვენ დაუკავშირდით DNS სერვერები და ვთქვათ, რა არის facebook.com?
ის ამბობს, oh, ეს IP მისამართი 190,212 რაღაც, რაღაც, რაღაც.
ყველა უფლება.
ახლა, მე ვიცი, რა მანქანა მინდა კონტაქტი.
>> ასე რომ მაშინ გამოაგზავნოთ თქვენი HTTP მოთხოვნის მეტი რომ მანქანა.
ასე რომ, რამდენად შეესაბამება ეს მისაღებად რომ მანქანა?
ასევე, თხოვნით მიდის როუტერი როუტერი bouncing.
მახსოვს მაგალითად კლასში, სადაც ჩვენ რეალურად დაინახა მარშრუტი, რომ
პაკეტი აიღო როდესაც ჩვენ შევეცადეთ კომუნიკაცია.
ჩვენ ვნახეთ, რომ ხტომა მეტი Atlantic Ocean ერთ მომენტში ან რასაც.
>> ასე რომ, ბოლო ვადა პორტი.
ასე რომ, ეს არის თქვენს კომპიუტერში.
თქვენ შეგიძლიათ მრავალი რამ გაკეთებული კომუნიკაციის ინტერნეტში.
ასე, რომ შეიძლება იყოს გაშვებული, ვთქვათ, Skype.
მე შეიძლება ვებ ბრაუზერი ღია.
მე შეიძლება რაღაც რომ torrenting ფაილი.
ასე რომ, ყველა ამ საკითხზე არის ურთიერთობისას
ინტერნეტით რამდენიმე გზა.
>> ასე რომ, როდესაც თქვენს კომპიუტერში იღებს ზოგიერთი მონაცემები ინტერნეტით, როგორ აკეთებს ამას
ვიცი, რა განცხადება, ფაქტობრივად, სურს მონაცემები?
რამდენად შეესაბამება ეს თუ არა ამ კონკრეტულ მონაცემები გათვლილი
torrenting განაცხადის როგორც ეწინააღმდეგებოდა ვებ ბრაუზერის?
ასე რომ, ეს არის მიზანი პორტები, რომ ყველა ამ განაცხადების
ამტკიცებდა პორტი თქვენს კომპიუტერში.
ასე რომ, თქვენს ბრაუზერში ამბობს, hey, მე მოსმენის პორტის 1000.
და თქვენი torrenting პროგრამა ამბობს, მე მოსმენის პორტის 3000.
და Skype ამბობს, მე გამოყენებით პორტში 4000.
>> ასე რომ, როდესაც თქვენ მიიღეთ რაიმე მონაცემები, რომლებიც მიეკუთვნება ერთი ეს პროგრამები, მონაცემები
აღინიშნება, რომლის პორტი ის რეალურად უნდა გაიგზავნოს ერთად.
ასე რომ, ეს ამბობს, oh, მე ეკუთვნის პორტი 1000.
მე ვიცი, მაშინ მე უნდა მიაწოდოს ერთად ჩემს ბრაუზერში.
ასე რომ, იმ მიზეზით, რომ ის შესაბამისი აქ ის არის, რომ ვებ სერვერები ტენდენცია
მოუსმინოს პორტის 80.
ასე რომ, როდესაც მე დაუკავშირდეთ Facebook.com, მე ვარ ურთიერთობისას რამდენიმე მანქანა.
მაგრამ მე უნდა ვთქვა, რომელიც პორტში რომ მანქანა მინდა დაუკავშირდეს.
და ვებ სერვერები, როგორც წესი, მოსმენის პორტის 80.
>> თუ უნდოდათ, ისინი ვერ ვაყენებთ მას ისე ეს ჩამოთვლილია როგორც საპორტო 7000.
და შემდეგ ბრაუზერში, შემეძლო ხელით ჩაწერეთ Facebook.com: 7000 to
გაუგზავნე მოთხოვნით პორტში 7000 Facebook-ის სერვერზე.
>> დევიდ ჯ Malan: და ამ შემთხვევაში, მაშინაც კი, მიუხედავად იმისა, რომ ჩვენ არ მოითხოვს, რომ ადამიანი
აღვნიშნო, რომ ეს, ამ შემთხვევაში, რა port რომ მოთხოვნა რეალურად წასვლა?
ცადეთ კიდევ ერთხელ.
ზუსტად.
არ ეძებს, მაგრამ დელიკატურობა რომ იქ არც უკანასკნელი.
>> რობ Bowden: ასე რომ, HTTPS, რადგან მოსმენის სპეციალურად
დაშიფრული, ეს პორტის 4430.
>> აუდიტორია: და წერილებს 25, არა?
>> დევიდ ჯ Malan: Outbound წერილებს, 25, yep.
>> რობ Bowden: მე კი არ იციან ყველაზე - ყველა ქვედა პირობა, როგორც წესი,
დაცულია რამ.
მე ვფიქრობ, რომ ყველაფერი 1024 დაცულია.
>> აუდიტორია: რატომ ამბობთ 3 იყო არასწორი ნომერი?
>> რობ Bowden: იმის გამო, რომ IP მისამართი, არსებობს ოთხი დაჯგუფებების ციფრისგან.
და ისინი from 0 to 255.
ასე რომ 192.168.2.1 არის საერთო ლოკალური ქსელის IP მისამართზე.
ყურადღება მიაქციეთ ყველა იმ ნაკლებია 255.
ასე რომ, როდესაც დავიწყე 300, რომელიც ვერ შესაძლოა აქვს
იყო ერთ ნომრები.
>> დევიდ ჯ Malan: მაგრამ ეს სულელური clip დან: - იყო ეს CSI, სადაც მათ ჰქონდათ
ნომერი, რომელიც იყო ძალიან დიდი იმ IP-მისამართი.
>> რობ Bowden: ნებისმიერი კითხვები ამ?
მომდევნო ერთი, ასე რომ სრული ცვლილება თემა, მაგრამ ჩვენ ამ PHP მასივი
სახლების quad.
და ჩვენ გვაქვს უწესრიგო სია.
და ჩვენ გვინდა, რომ ამობეჭდოთ თითოეული სიის ელემენტი უბრალოდ შემცველი სახლის სახელი.
ამიტომ ჩვენ გვაქვს foreach loop.
ასე მახსოვს, სინტაქსი არის foreach array როგორც საქონლის მასივი.
ასე რომ მეშვეობით თითოეულ iteration of მარყუჟის, სახლში აპირებს ერთი
ღირებულებები შიგნით მასივი.
>> პირველ iteration, სახლი იქნება Cabot სახლი.
მეორე iteration, სახლი იყოს კურიერი სახლი და ასე შემდეგ.
ასე რომ, თითოეული quad როგორც სახლში, ჩვენ უბრალოდ აპირებს ბეჭდვა -
თქვენ ასევე შეეძლო გაიმეორა -
სიაში ნივთი და შემდეგ სახლში სახელი და შემდეგ დახურეთ სია ერთეულზე.
Curly აფრთხილებს სურვილისამებრ აქ.
>> და მაშინ ჩვენ ასევე განაცხადა, კითხვა თავისთავად, მახსოვს დახურვა
უწესრიგო სია აქვს.
ამიტომ, ჩვენ უნდა გამოხვიდეთ PHP რეჟიმი იმისათვის, რომ ამის გაკეთება.
ან ჩვენ შეეძლო გამოეხმაურა დახურვა უწესრიგო სია აქვს.
>> დევიდ ჯ Malan: ასევე ჯარიმა აქ იქნება უკვე გამოიყენოს ძველი სკოლა
loop ერთად $ i = 0 0 და გამოყენებით ითვლის to გაერკვნენ სიგრძეზე ray.
მთლიანად ჯარიმა ძალიან, უბრალოდ პატარა wordier.
>> აუდიტორია: ასე რომ, თუ თქვენ აპირებს [INAUDIBLE], რომ თქვენ ამის გაკეთება -
მე დაგვავიწყდეს, თუ რა loop [INAUDIBLE] არის.
გსურთ $ quad bracket i?
>> დევიდ ჯ Malan: ზუსტად.
ჰო, ზუსტად.
>> რობ Bowden: არაფერი?
>> დევიდ ჯ Malan: ყველა უფლება.
ვაჭრობის ღ.
ასე იყო bunches პასუხი შესაძლებელია თითოეული მათგანი.
ჩვენ მართლაც მხოლოდ ეძებს რაღაც მყარი განთავსების upside და
downside.
და ნომერი 16 სთხოვეს, Validating მომხმარებლების input კლიენტის მხარის, როგორც JavaScript,
ნაცვლად სერვერის მხარეს, როგორც PHP.
რა upside of აკეთებს კლიენტის მხარის?
>> ისე, ერთი რამ შევთავაზეთ არის რომ თქვენ შეამციროს შეყოვნება, რადგან თქვენ
არ გადაიტვირთოთ საკონტაკტო სერვერზე, რომელიც შეიძლება რამდენიმე
მილიწამებში ან თუნდაც რამდენიმე წამში ავლით, და მხოლოდ
წევრები მომხმარებლების input კლიენტის მხარის მიერ გამშვები on წარადგინოს კურატორმა და
უბრალოდ შემოწმების, ისინი აკრიფოთ რაღაც განთავსების სახელი?
ისინი აკრიფოთ რაღაც in ფოსტის მისამართი?
ისინი აირჩიოს dorm დან ჩამოსაშლელი მენიუ?
>> თქვენ შეგიძლიათ მივცეთ გამდინარე კავშირი გამოყენებით gigahertz კომპიუტერი
ან რასაც მათ აქვთ, რომ რეალურად მათ მაგიდასთან.
ასე რომ, ეს უბრალოდ უკეთესი შესახებ განიცდიან, როგორც წესი.
მაგრამ downside აკეთებს კლიენტის მხარის დადასტურება, თუ თქვენ ამის გარეშე ასევე
აკეთებს სერვერის მხარეს დადასტურება ის არის, რომ საუკეთესო ვინმეს გამოდის CS50 იცის
რომ თქვენ შეგიძლიათ უბრალოდ გამოგვიგზავნეთ ნებისმიერი მონაცემების გსურთ სერვერზე ნებისმიერი რაოდენობის გზები.
სიმართლე, უმეტეს ნებისმიერი ბრაუზერი, შეგიძლიათ დააჭირეთ გარშემო პარამეტრების და მხოლოდ
გამორთეთ JavaScript, რაც, შესაბამისად, გაუქმდება ნებისმიერი ფორმით
ძალადაკარგულია.
>> მაგრამ თქვენ ასევე შეიძლება გავიხსენოთ, რომ ჯერ კიდევ მე გარკვეული arcane რამ კლასში გამოყენებით
telnet და რეალურად თითქოს იყოს ბრაუზერის გაგზავნით მისაღებად
ითხოვს სერვერზე.
და ეს რა თქმა უნდა არ გამოყენებით JavaScript.
ეს მხოლოდ მე აკრეფით ბრძანებები დროს კლავიატურაზე.
ასე რომ, რეალურად, ნებისმიერი პროგრამისტი შიგნით საკმარისი კომფორტი ინტერნეტში და HTTP
შეიძლება გაგზავნას რასაც მონაცემები მას სურს სერვერზე შემოწმების გარეშე.
და თუ თქვენს სერვერზე არ არის, ასევე შემოწმების, მომცეს სახელი, არის
ეს რეალურად მოქმედი ელექტრონული ფოსტის მისამართი, გააკეთა ისინი აირჩიოს dorm, თქვენ შეიძლება დასრულდება
up ჩასმა ყალბი ან უბრალოდ ცარიელი მონაცემები თქვენი მონაცემთა ბაზა, რომელიც, სავარაუდოდ,
არ იქნება კარგია თუ თქვენ ვთქვათ, რომ ეს იყო.
>> ასე რომ ეს არის შემაშფოთებელი რეალობა.
მაგრამ ზოგადად, კლიენტის მხარის დადასტურება არის დიდი.
მაგრამ ეს იმას ნიშნავს ორჯერ მეტი მუშაობა.
მიუხედავად იმისა, რომ გავაკეთოთ, არსებობს სხვადასხვა ბიბლიოთეკების, JavaScript ბიბლიოთეკა
მაგალითად, რომ ეს ბევრად, გაცილებით ნაკლები თავის ტკივილი.
და თქვენ შეგიძლიათ reuse ზოგიერთი კოდი სერვერის მხარეს, კლიენტის მხარეს.
მაგრამ გვესმის, რომ ეს არის, როგორც წესი, დამატებითი სამუშაო.
ჰო.
>> აუდიტორია: ასე რომ, თუ ჩვენ მხოლოდ განაცხადა, ნაკლებად უსაფრთხო -
>> დევიდ ჯ Malan: [იცინის]
Ugh.
ეს არის ყოველთვის რთული ვინც განიხილავს.
>> რობ Bowden: რომ უკვე მიღებულია.
>> დევიდ ჯ Malan: What?
>> რობ Bowden: მე შექმნილი ეს პრობლემა.
რომ იქნებოდა მიღებული.
>> დევიდ ჯ Malan: ჰო.
>> აუდიტორია: Cool.
>> რობ Bowden: მაგრამ ჩვენ არ მიიღოს პირველად ერთ -
კარგად, რასაც ჩვენ ვეძებთ არის რაღაც არ უნდა
დაუკავშირდეს სერვერს.
ჩვენ არ მიიღოს მხოლოდ სწრაფად.
>> აუდიტორია: რა არ განაახლეთ გვერდი?
>> რობ Bowden: დიახ.
ეს იყო მიღებული პასუხი.
>> დევიდ ჯ Malan: არაფერი სადაც ჩვენ იგრძნო ეს უფრო სავარაუდოა, ვიდრე არ სჩანს
რომ იცოდნენ, რას განაცხადა, რომ, რომელიც მკაცრი
ონლაინ მიაპყროს ხანდახან.
გამოყენება უკავშირდება სიაში ნაცვლად მასივი შენარჩუნება
დახარისხებული სია რიცხვებით.
ასე upside ჩვენ ხშირად მოჰყავთ უკავშირდება სიები, მოტივირებული მთელი
შესავალი იყო, თქვენ მიიღებთ დინამიკას.
მათ შეუძლიათ იზრდება.
მათ შეუძლიათ შემცირება.
ასე რომ თქვენ არ უნდა ხტომა მეშვეობით hoops რეალურად შევქმნათ მეტი მეხსიერების
მასივი.
ან თქვენ არ უნდა უბრალოდ ამბობენ, უკაცრავად, შესახებ.
მასივი ივსება.
იმდენად დინამიური ზრდა სიაში.
Downside თუმცა უკავშირდება სიები?
>> აუდიტორია: ეს არის სწორხაზოვანი.
ძიება უკავშირდება სია წრფივი ნაცვლად იმისა, რასაც თქვენ შეხვიდეთ სისტემაში
>> დევიდ ჯ Malan: ზუსტად.
ძიება უკავშირდება სიაში არის წრფივი, მაშინაც კი, თუ ეს დახარისხებული, რადგან თქვენ შეგიძლიათ
მხოლოდ დაიცვას ეს პური crumbs, ამ პოინტერები, დაწყების სიაში
ბოლომდე.
თქვენ არ შეგიძლიათ ბერკეტები წვდომის და, ამდენად, ორობითი ძებნა, მაშინაც კი, თუ ის
დახარისხებული, რომ შეიძლება ვუყოთ მასივი.
და არსებობს კიდევ ერთი ღირებულება.
ჰო.
>> აუდიტორია: Memory არაეფექტური?
>> დევიდ ჯ Malan: ჰო.
ისე, მე არ ემთხვეოდეს ამბობენ, არაეფექტური.
მაგრამ ეს არ დაგიჯდებათ მეტი მეხსიერების, რადგან თქვენ უნდა 32 ბიტი ყველა
კვანძის დამატებითი მაჩვენებელი, at მაინც საგნით უკავშირდება სიაში.
ახლა, თუ თქვენ მხოლოდ შენახვის რიცხვებით და თქვენ დასძინა მაჩვენებელი, რომ
რეალურად სახის არასამთავრობო ტრივიალური.
ის გააორმაგოს თანხის მეხსიერება.
მაგრამ სინამდვილეში, თუ თქვენ შენახვა უკავშირდება სიაში structs რომ შესაძლოა
8 ბაიტი, 16 ბაიტი, კიდევ უფრო გარდა ამისა, შესაძლოა, ეს ნაკლებად
ზღვრული ღირებულება.
მაგრამ ეს ღირებულება მაინც.
ასე რომ, არც იმ იქნებოდა ეგ ყოფილა ჯარიმა, როგორც downsides.
>> 18.
გამოყენება PHP ნაცვლად C დაწერა ბრძანების ხაზი პროგრამა.
ასე რომ, აქ, ეს ხშირად უფრო სწრაფად გამოიყენოს ენა, როგორიცაა PHP ან Ruby ან Python.
უბრალოდ სწრაფად გახსნა მდე ტექსტური რედაქტორი.
თქვენ კიდევ ბევრი ფუნქციები ხელმისაწვდომი.
PHP აქვს სამზარეულო რადიატორის ფუნქციები, ხოლო C, თქვენ
ძალიან, ძალიან ცოტა.
ფაქტობრივად, ბიჭები ვიცი რთული გზა რომ თქვენ არ უნდა hash მაგიდები.
თქვენ არ უკავშირდება სიები.
თუ გსურთ ის, რაც თქვენ უნდა განახორციელოს მათ თავს.
>> ასე რომ ერთი თავდაყირა of PHP ან მართლაც ნებისმიერ ინტერპრეტირებული ენა არის rapidity
რომელიც შეგიძლიათ დაწეროთ კოდი.
მაგრამ downside, ჩვენ ვნახეთ, როდესაც მე სწრაფად whipped მდე misspeller
შესრულების ლექცია გამოყენებით PHP, არის რომ გამოყენებით ინტერპრეტირებული ენა
ჩვეულებრივ ნელი.
და ჩვენ ვნახეთ, რომ demonstrably ერთად ზრდის დროს 0.3 წამში 3
წამი, იმის გამო, რომ განმარტების რომ რეალურად ხდება.
>> სხვა upside იყო, რომ თქვენ არ უნდა შეადგინოს.
ასე რომ, ეს ასევე სიჩქარის განვითარება სხვათა შორის, იმის გამო, რომ თქვენ არ გაქვთ
ორი ნაბიჯი გაშვებული პროგრამა.
თქვენ უბრალოდ უნდა ერთი.
და ისე, რომ საკმაოდ მყარი, როგორც კარგად.
გამოყენება SQL მონაცემთა ბაზის ნაცვლად CSV ფაილი შესანახად მონაცემები.
ასე რომ SQL მონაცემთა ბაზაში გამოიყენება pset7.
CSV ფაილი თქვენ არ გამოიყენოს ბევრი.
მაგრამ თქვენ გამოიყენება მას ირიბად pset7 როგორც ასევე საუბარი Yahoo ფინანსები.
>> მაგრამ CSV ისევე Excel ფაილის მაგრამ სუპერ მარტივი, სადაც სვეტების
უბრალოდ მკაცრ დემარკაციას ასახელებს მიერ მძიმეები შიგნით სხვაგვარად ტექსტური ფაილი.
და გამოყენებით SQL მონაცემთა ბაზა ცოტა უფრო მყარი.
ის upside, რადგან თქვენ კიდევ რამ ისევე როგორც შერჩევა და ჩადეთ და წაშლა.
და თქვენ, სავარაუდოდ, ინდექსები, რომ MySQL და სხვა მონაცემთა ბაზები, როგორიცაა
Oracle, აშენება თქვენთვის მეხსიერება, რომელიც ნიშნავს, რომ თქვენი არჩევა, ალბათ, არ
იქნება ხაზოვანი ზემოდან.
ეს რეალურად იქნება რაღაც ისევე, როგორც ორობითი ძებნა ან რამე
მსგავსი სულისკვეთება.
ასე რომ, ისინი ზოგადად უფრო სწრაფად.
>> მაგრამ downside არის, რომ უბრალოდ უფრო მეტი მუშაობა.
ეს არის უფრო მეტი ძალისხმევა.
თქვენ უნდა გვესმოდეს ბაზაში.
თქვენ უნდა მითითებული it up.
თქვენ უნდა სერვერის გასაშვებად რომ მონაცემთა ბაზაში.
თქვენ უნდა გვესმოდეს როგორ უნდა დააკონფიგურიროთ იგი.
ასე რომ ეს არის მხოლოდ ამ სახის ვაჭრობის ღ.
ვინაიდან CSV ფაილი, თქვენ შეგიძლიათ შექმნა იგი gedit.
და თქვენ კარგი წასვლა.
არ არსებობს სირთულის მიღმა.
>> გამოყენება trie ნაცვლად hash table ცალკე chaining შესანახად
ლექსიკონი სიტყვები თქვენში საქართველოს pset5.
ამიტომ ცდილობს upside, თეორიულად მაინც, რა არის?
მუდმივი დროს, მინიმუმ, თუ თქვენ hashing თითოეულ ინდივიდუალური
ასო ერთი სიტყვით, როგორც თქვენ შეიძლება ჰქონდეს pset5.
რომ შეიძლება იყოს ხუთი ჰეშები, ექვსი ჰეშები თუ არსებობს ხუთი ან ექვსი
ასო სიტყვა.
და ეს საკმაოდ კარგი.
და თუ არსებობს ზედა ზღვარი, თუ როგორ ხანგრძლივი თქვენი სიტყვა შეიძლება იყოს, რომ
მართლაც asymptotically მუდმივი დრო.
>> ხოლო hash table ცალკე chaining, პრობლემა არ არსებობს, რომ
სახის მონაცემები სტრუქტურა არის ის, რომ შესრულება თქვენი ალგორითმები, როგორც წესი,
დამოკიდებულია რამ უკვე მონაცემები სტრუქტურა.
და რომ ნამდვილად საქმე ჯაჭვები, რომლის დროსაც უფრო პერსონალის თქვენ დააყენა
შევიდა hash table, აღარ იმ ჯაჭვების წასვლა, რაც იმას ნიშნავს, უარეს
შემთხვევაში, რაც თქვენ შეიძლება ეძებს არის ყველა გზა ბოლოს ერთი
იმ ჯაჭვების, რომელიც ეფექტურად devolves შევიდა რაღაც სწორხაზოვანი.
>> ახლა, პრაქტიკულად, ეს შეიძლება აბსოლუტურად იმ შემთხვევაში, რომ hash მაგიდა
ჯაჭვებით არის სწრაფად, ვიდრე შესაბამისი trie განხორციელება.
მაგრამ ეს სხვადასხვა მიზეზების გამო, მათ შორის, რომელიც ცდილობს გამოიყენოს მთელი ბევრი
მეხსიერება, რომელიც შეიძლება, ფაქტობრივად, ნელი რამ down, იმიტომ, რომ თქვენ არ მიიღოს nice
სარგებელი რაღაც მოუწოდა ქეშირების, სადაც ყველაფერი, რომ ახლოს ვართ ერთად
მეხსიერების შესაძლებელია ხშირად უფრო სწრაფად.
და ზოგჯერ შეგიძლიათ ამუშავება ნამდვილად კარგი ქეშირების ფუნქცია.
მაშინაც კი, თუ თქვენ გაქვთ დაგვრჩა ცოტა მეხსიერება, ალბათ, მართლაც, შეძლებს
რამ სწრაფად და არ როგორც ცუდი ხაზოვანი.
>> ასე მოკლედ, არ იყო აუცილებელი ნებისმიერი ამ ერთი ან თუნდაც ორი
კონკრეტული რამ, ჩვენ ეძებდნენ.
ნამდვილად არაფერი დამაჯერებელი როგორც upside და downside
ზოგადად დაიჭირეს ჩვენი თვალი.
>> რობ Bowden: ასე რომ upside, ჩვენ არ მიიღოს საკუთარი "სწრაფად". თქვენ
უნდა ვთქვა რამე ამის შესახებ.
მაშინაც კი, თუ თქვენ თქვით, თეორიულად უფრო სწრაფად, ვიცოდით, რომ თქვენ სახის გაგებული
ის, რომ 0 და 1.
და hash table, თეორიულად, არ არის 0 და 1.
მოხსენიების შესახებ არაფერი runtime ზოგადად მივიღე თქვენ რაოდენობა.
მაგრამ "სწრაფად", ყველაზე გადაწყვეტილებები დიდი board, რომ ლელო იყო
ობიექტურად ნელა, ვიდრე გადაწყვეტილებები რომ იყო hash მაგიდები.
ასე სწრაფად და თავისთავად არ არის ჭეშმარიტი.
>> დევიდ ჯ Malan: Dom de dom dom.
მე ალბათ მხოლოდ ერთი, რომ ხვდება, ასე რომ უნდა
ცხადდება, არა?
>> რობ Bowden: მე მქონდა რეალურად არ ვიცი.
>> დევიდ ჯ Malan: ეს გააკეთა გრძნობა ჩემი უფროსი.
>> რობ Bowden: მე ვაკეთებ ეს ერთი.
OK.
ასე რომ, ეს არის ის, სადაც თქვენ უნდა დახაზოთ გრაფიკაზე მსგავსი ალბათ
მინახავს გასული გამოცდები.
მოდით შევჩერდეთ ამ.
ასე რომ HTML კვანძის, ჩვენ გვაქვს ორი ბავშვები, ხელმძღვანელი და სხეულის.
ასე რომ, ჩვენ ფილიალი - ხელმძღვანელი და სხეულის.
უფროსი აქვს სათაური აქვს.
ამიტომ ჩვენ გვაქვს ტიტული.
>> ახლა ერთი რამ, ბევრი ადამიანი დაავიწყდა, რომ ეს ტექსტური კვანძების
ელემენტების ფარგლებში ამ ხეს.
ასე რომ, აქ ჩვენ არ უნდა დავხატოთ მათ ovals დიფერენცირება მათ ამ
სახის კვანძების.
მაგრამ ცნობა აქ ჩვენ ზედა, შუა და ქვედა დასრულდება მდე მიმდინარეობს
ტექსტური კვანძების.
ასე რომ ივიწყებს იმ გარკვეულწილად საერთო შეცდომა.
>> ორგანოს სამი შვილი ჰყავს - ამ სამი divs.
ასე რომ, div, div, div, შემდეგ კი ტექსტი კვანძის ბავშვები იმ divs.
რომ საკმაოდ ბევრი ეს რომ შეკითხვებს.
>> დევიდ ჯ Malan: და ეს უნდა აღინიშნოს, მიუხედავად იმისა, რომ ჩვენ არ შევჩერდებით ამ
ვრცლად დროს ვხარჯავთ JavaScript, რომ იმისათვის აკეთებს,
ფაქტია, რომ ამ საკითხზე ტექნიკურად.
ასე რომ, თუ ხელმძღვანელი მოდის ადრე ორგანოს HTML, მაშინ იგი უნდა როგორც ჩანს,
მარცხენა სხეულის ფაქტობრივი DOM.
რომ მისი, ზოგადად, უბრალოდ შეგახსენებთ, რაღაც მოუწოდა დოკუმენტი, რათა, სადაც
მას არ აქვს მნიშვნელობა.
და თუ თქვენ ახორციელებს parser, პროგრამა, რომელიც ნათქვამია HTML შენობაში
up ხე მეხსიერებაში, რომ იყოს პატიოსანი, რომ არის ინტუიციურად ალბათ ის, რაც თქვენ
ამის გაკეთება მაინც - ყველაზე ქვედა, მარცხნიდან მარჯვნივ.
>> რობ Bowden: კითხვები რომ?
უნდა გავაკეთოთ მომდევნო ერთი?
>> დევიდ ჯ Malan: რა თქმა უნდა.
>> რობ Bowden: OK.
ასე რომ, ეს ბუფერული გაუსწრო თავდასხმის საკითხი.
მთავარია აღიაროს აქ არის, ისევე, როგორ შეიძლება მოწინააღმდეგის შეასრულა
ამ პროგრამის თარგმნეს შესრულებაში თვითნებური კოდი?
ასე argv1, პირველი ბრძანების არგუმენტი ამ პროგრამის, რომელიც შეიძლება იყოს
თვითნებურად ხანგრძლივი.
მაგრამ აქ ჩვენ გამოყენებით memcpy კოპირება argv1, რომელიც აქ არის ბარი.
ჩვენ ავლით მას, როგორც არგუმენტი.
და ასე აღების სახელწოდების ბარი.
>> ასე რომ ჩვენ memcpying ბარი ამ ბუფერული გ.
რამდენი ბაიტი ჩვენ გადაწერა?
კარგად, მაგრამ ბევრი bytes ბარი ხდება გამოყენებით, სიგრძით, რომ არგუმენტი.
მაგრამ c მხოლოდ 12 ბაიტი კარს.
ასე რომ, თუ ჩვენ აკრიფოთ ბრძანება ხაზი არგუმენტი რომ ის უფრო მეტია, ვიდრე 12 ბაიტი, ჩვენ
აპირებს overflow ამ კერძოდ ბუფერული.
ახლა, როგორ შეიძლება მოწინააღმდეგის შეასრულა პროგრამა შევიდა შესრულებაში თვითნებური კოდი?
>> ასე მახსოვს, რომ აქ მთავარ მოუწოდებს foo.
და ასე შემდეგ მთავარ მოუწოდებს foo.
მოდით დავხატოთ ეს.
ასე რომ, ჩვენ გვაქვს ჩვენი Stack.
და ძირითადი აქვს დასტის ჩარჩო ბოლოში.
რაღაც მომენტში, მთავარ მოუწოდებს foo.
ასევე, დაუყოვნებლივ, მთავარ მოუწოდებს foo.
და ასე foo იღებს საკუთარი დასტის ჩარჩო.
>> ახლა, რაღაც მომენტში, foo დაბრუნებას აპირებს.
და წავიდა foo ბრუნდება, ჩვენ უნდა ვიცოდეთ at რა ხაზი კოდი შიგნით ძირითადი ჩვენ
იყო იმისათვის, რომ ვიცი, სადაც ჩვენ უნდა განაახლონ მთავარ.
ჩვენ შეგვიძლია მოვუწოდებთ foo ეხლა მთელი bunch სხვადასხვა ადგილებში.
ვიცით, სად უნდა დაბრუნდნენ?
კარგად, ჩვენ გვჭირდება შესანახად რომ სადღაც.
>> ასე რომ სადღაც უფლება გარშემო აქ, ჩვენ ვინახავთ სადაც ჩვენ უნდა დაუბრუნდეს ერთხელ
foo ბრუნდება.
და ეს არის დაბრუნების მისამართზე.
ასე რომ, თუ მოწინააღმდეგე შეიძლება ისარგებლოს ეს არის ის ფაქტი, რომ
ამ ბუფერული c ინახება, მოდით ამბობენ, სწორედ აქ არის გ.
ამიტომ, ჩვენ მივიღეთ 12 ბაიტი გ.
ეს არის გ.
და ეს არის foo-ს დასტის ბეჭედი.
ასე რომ, თუ მუქარის მომხმარებლის შემოდის მეტი ბაიტი, ვიდრე 12 ან ისინი შეიყვანოთ ბრძანება
ხაზი არგუმენტი, რომ ის უფრო მეტია, ვიდრე 12 პერსონაჟი, მაშინ ჩვენ ვაპირებთ
overflow ამ ბუფერული.
>> ჩვენ შეგვიძლია შევინარჩუნოთ აპირებს.
და რაღაც მომენტში, ჩვენ შორს საკმარისი, რომ ჩვენ ვიწყებთ
overwriting ამ დაბრუნების მისამართზე.
ასე რომ ერთხელ ჩვენ გადავაწერო დაბრუნების მისამართი, ეს იმას ნიშნავს, რომ როდესაც foo
ბრუნდება, ჩვენ ბრუნდება იქ, სადაც მუქარის შესახებ ეუბნება ის მიერ
რასაც ღირებულება შევიდა, რასაც გმირები პროფაილი შევიდა.
და ასე თუ მუქარის შესახებ მიმდინარეობს განსაკუთრებით ჭკვიანი, მას შეუძლია ჰქონდეს ამ
დაბრუნდება სადღაც printDef ფუნქცია ან სადღაც malloc
ფუნქცია, მხოლოდ სადმე თვითნებური.
>> მაგრამ კიდევ უფრო ჭკვიანი არის ის, რაც, თუ მას აქვს მომხმარებლის დაბრუნების უფლება აქ.
და მაშინ იწყება შესრულებაში ეს როგორც ხაზების კოდი.
ასე რომ, იმ ეტაპზე, მომხმარებელს შეუძლია შევიდეს რასაც მას სურს ამ რეგიონში.
და მას აქვს სრული კონტროლი თქვენი პროგრამა.
კითხვები რომ?
ასე რომ, შემდეგი კითხვა არის სრული reimplementation of foo იმგვარად
რომ ის აღარ არის დაუცველი.
>> ასე რომ არსებობს რამდენიმე გზა თქვენ შეიძლება გაკეთდეს ეს.
ჩვენ ჯერ კიდევ გვაქვს c მხოლოდ მიმდინარეობს სიგრძე 12.
თქვენ შეიძლება შეიცვალა ამ როგორც ნაწილი თქვენი გადაწყვეტა.
ჩვენ ასევე დასძინა, გამშვები, რათა დარწმუნებული ვარ, ბარი არ იყო null.
მიუხედავად იმისა, რომ თქვენ არ უნდა რომ სრული საკრედიტო.
ასე რომ, ჩვენ შემოწმების პირველი სიმებიანი სიგრძე ბარი.
თუ ის მეტია, ვიდრე 12, მაშინ რეალურად არ გავაკეთოთ ასლი.
ასე რომ ერთი გზა აფიქსირებს მას.
>> სხვა გზა აფიქსირებს ის ნაცვლად მქონე c მხოლოდ სიგრძის 12, აქვს ეს
იყოს სიგრძით strlen (ბარი).
სხვა გზა აფიქსირებს, რომ ეს არის რეალურად უბრალოდ დააბრუნოს.
ასე რომ, თუ თქვენ ახლახანს მიღებული მოშორება ყველა , თუ თქვენ ახლახანს წაშლილია ყველა
ხაზი კოდი, თქვენ მიღებული სრული საკრედიტო, რადგან ეს ფუნქცია
ფაქტობრივად არ მიდის.
ის გადაწერა command line არგუმენტი შევიდა ზოგიერთი მასივი
მისი ადგილობრივი დასტის ჩარჩო.
და შემდეგ ის ბრუნდება.
და რაც დასრულებული გაქრა.
ასე რომ, დაბრუნების, ასევე, საკმარისი გზა მიღების სრული საკრედიტო.
>> დევიდ ჯ Malan: არ არის საკმაოდ სულისკვეთებით კითხვაზე, მაგრამ მისაღებია პოსტი
სპეც მაინც.
>> რობ Bowden: კითხვები ნებისმიერ, რომ?
ერთი რამ, რომ თქვენ, სულ ცოტა, საჭიროა არ შედგენის კოდი.
ასე რომ, მიუხედავად იმისა, რომ ტექნიკურად არ ხართ სოციალურად დაუცველი თუ თქვენი კოდი არ
შედგენა, ჩვენ არ მიიღოს, რომ.
კითხვები?
OK.
>> დევიდ ჯ Malan: გნებავთ ამბობენ, რომ ეს სათაური?
>> რობ Bowden: არა
>> დევიდ ჯ Malan: ასე რომ, ამ ერთი, ამ იყო ან კარგი ამბავია და ცუდი ამბავი.
ეს არის ფაქტიურად იგივე პრობლემა როგორც პირველი ვიქტორინა.
და ეს თითქმის იგივე პრობლემა pset1.
მაგრამ ეს იყო შეგნებულად გამარტივებული იყოს მარტივი პირამიდის, რომელიც შეიძლება იყოს
გადაწყდეს ოდნავ მარტივი iteration.
და მართლაც, რა ჩვენ მიღების დროს აქ იყო არა იმდენად ლოგიკით,
იმიტომ, რომ, ალბათ, ამ ეტაპზე, თქვენ უფრო კომფორტული ვიდრე იყავით
კვირაში ერთი მარყუჟების ან რატომ მარყუჟების, მაგრამ ნამდვილად აჯავრებენ გარდა, რომ
თქვენ ცოტა კომფორტულად მოსაზრება, რომ PHP არ არის მხოლოდ იმაზე, თუ რა
პროგრამირების.
მას შეუძლია რეალურად გამოყენებულ იქნას როგორც ენის დაწერა command line პროგრამები.
>> და მართლაც, ის, რაც ჩვენ ცდილობდნენ გავამახვილო თქვენი ყურადღება.
ეს არის command line PHP პროგრამა.
ასე რომ, C კოდი აქ, ხოლო სწორი დო, არ არის სწორი PHP.
მაგრამ კოდი ნამდვილად არ არის იგივე.
თუ შევადარებთ გადაწყვეტილებები Quiz 0 წინააღმდეგ Quiz 1, თქვენ ნახავთ, რომ
ის თითქმის იდენტურია, გარდა ზოგიერთი დოლარის ნიშნები და
არ არსებობს მონაცემები ტიპის.
კერძოდ, თუ გადავხედავთ აქ, თქვენ ნახავთ, რომ ჩვენ iterate, ამ
შემთხვევაში, 1 მეშვეობით 7.
>> ჩვენ შეგვეძლო გავაკეთეთ 0 ინდექსი.
მაგრამ ზოგჯერ, მე ვფიქრობ, რომ ეს მხოლოდ გონებრივი ადვილია ვიფიქროთ რამ
1 დან 7.
თუ გსურთ ერთი ბლოკი, მაშინ განიხილება ორი ბლოკები, შემდეგ სამი, მაშინ
dot, dot, dot შვიდი.
ჩვენ j მიმდინარეობს ინიციალიზაცია 1 და შემდეგ იმედი მდე i.
და ყველაფერი აქ არის წინააღმდეგ შემთხვევაში იდენტურია.
მაგრამ აღსანიშნავია, რამდენიმე რამ.
ჩვენ მოგაწვდით ამ ორ წყებას, ეს პირველი ერთი, goofily ასახელებენ shebang
მკვეთრი bang.
და რომ მხოლოდ განსაზღვრავს გზა, საქაღალდეში, რომელშიც პროგრამა შეიძლება
აღმოჩნდა, რომ გსურთ გამოიყენოთ ინტერპრეტაცია ამ ფაილის.
>> და მაშინ ხაზის შემდეგ, რომ, რა თქმა უნდა, იმას ნიშნავს, შეიყვანოთ PHP რეჟიმში.
და ხაზი ძალიან ბოლოში ნიშნავს გასასვლელში PHP რეჟიმში.
და ეს სამუშაოები, საერთოდ, ინტერპრეტირებული ენებზე.
ეს არის სახის შემაშფოთებელი თუ წერთ პროგრამის ფაილი სახელად foo.php.
და შემდეგ თქვენი წევრებს უნდა, ისევე, მახსოვს, OK, აწარმოებს ამ პროგრამის მე
უნდა აკრიფოთ "php ფართი foo.php". კეთილი შემაშფოთებელი თუ სხვა არაფერი.
და ის ასევე ცხადყოფს, რომ თქვენი პროგრამა დაწერილი PHP, რომელიც არ არის
რომ გასანათებელი შესახებ.
>> ასე რომ თქვენ შეგიძლიათ ამოიღონ. Php საერთოდ გავიხსენოთ ლექცია.
და თქვენ შეგიძლიათ რეალურად გავაკეთოთ. / Foo თუ თქვენ chmodded ის მიერ მიღების იგი
გაშვება.
ასე რომ chmod + x foo არ კეთდება, რომ.
და თუ ასევე shebang აქ.
მაგრამ რეალურად, პრობლემა მიღების დროს დაბეჭდვისას რაღაც მსგავსი.
არარის HTML, არ C-კოდი რა თქმა უნდა, რამოდენიმე PHP.
ასე Milo შემდეგ დაბრუნდა პრობლემა 25.
და 25 თქვენ გადაეცათ შემდეგ ჩონჩხის კოდი, რომელიც
საკმაოდ მარტივი ვებ გვერდი.
და წვნიანი ნაწილი HTML ბრძენი იყო ქვემოთ აქ, სადაც ჩვენ შიგნით ორგანო
ფორმა, რომელიც აქვს უნიკალური ID საშუალებებით შიგნით რაც იყო ორი საშუალებებით, ერთი
იდეა სახელწოდება, ერთი იდეა ღილაკს.
>> პირველი ტიპის ტექსტი, მეორე ტიპის წარუდგინოს.
ასე რომ, ჩვენ მისცა თქვენ, ფაქტობრივად, უფრო ინგრედიენტები, ვიდრე თქვენ საჭირო, მხოლოდ ისე,
თქვენ ბიჭები ჰქონდა ვარიანტი, რომელიც ამ პრობლემის მოგვარებას.
თქვენ არ მკაცრად უნდა ყველა ამ პირადობის მოწმობა.
მაგრამ ეს საშუალებას გაძლევთ გადაწყვიტოს ის სხვადასხვა გზით.
და ზედა შეამჩნევთ, რომ მიზანი იყო გამოწვევა
ფანჯარა მსგავსი -
Hello, Milo, -
პოპ up ბრაუზერის გამოყენებით სუპერ მარტივია, თუ
არა მახინჯი, alert ფუნქცია.
ასე რომ, საბოლოო ჯამში, ამ დაყვანა კონცეპტუალურად, რათა როგორმე მოსმენის
წარდგინება ფორმის კლიენტის მხარის არა სერვერის მხარეს, რატომღაც
რეაგირებს, რომ წარდგენის grabbing ღირებულება, რომ მომხმარებლის აკრეფილი
ამ სახელს ველი, და შემდეგ აჩვენებს მას სხეულის alert.
>> ასე რომ ერთი გზა ამისათვის არის jQuery, რომელიც გამოიყურება პატარა
syntactically perplexing პირველი.
შეგიძლიათ გააკეთოთ ეს სუფთა DOM კოდი - document.getelement ით.
მაგრამ მოდით შევხედოთ ამ ვერსიაში.
მე მაქვს რამდენიმე მნიშვნელოვანი ხაზები პირველი.
ასე რომ, ერთი, ჩვენ ამ ხაზის, რომელიც იდენტური, თუ რა შეიძლება მინახავს
წელს, მე მჯერა, form2.html ეხლა კლასის week 9.
და ეს უბრალოდ ვამბობ, შეასრულოს შემდეგი კოდი, როდესაც
დოკუმენტი მზად არის.
ეს მიმდინარეობს მნიშვნელოვანი მხოლოდ იმიტომ, HTML გვერდები წაკითხვის დაბრუნება
ბოლოში, მარცხნიდან მარჯვნივ.
>> და ამიტომ, თუ თქვენ ცდილობენ გააკეთონ რაღაც კოდი აქ ზოგიერთი DOM
ელემენტი, ზოგიერთი HTML tag, რომ ქვემოთ აქ, თქვენ ამის გაკეთება ძალიან მალე,
იმიტომ, რომ ეს არც კი უკვე წაიკითხა მეხსიერებაში.
ასე რომ ამ document.ready ხაზი, ჩვენ ვამბობთ,
აქ არის რამდენიმე კოდი, ბრაუზერში.
მაგრამ არ შეასრულოს ეს სანამ მთელი დოკუმენტი მზად არის, რომ არის DOM
ხე არსებობს მეხსიერებაში.
ეს ერთი არის ცოტა მეტი მარტივია, თუ syntactically
ცოტა განსხვავებული, სადაც მე ვამბობ, დაიბრუნოს HTML-ის ელემენტი, რომელთა უნიკალური
მაიდენტიფიცირებელი საშუალებებით.
სწორედ hash tag აღნიშნავს, უნიკალური ID.
და შემდეგ მე მოუწოდებდა. წარუდგინოს.
>> ასე. წარმოადგინონ აქ არის ფუნქცია, წინააღმდეგ შემთხვევაში, ცნობილია, როგორც საშუალებას, რომ
შიგნით ობიექტის მარცხენა მხარეს, რომ არ გააშუქებს.
ასე რომ, თუ ფიქრობთ საშუალებებით როგორც ობიექტი მეხსიერება - და მართლაც ეს არის.
ის კვანძის ხე -
. წარმოადგინონ საშუალებით, როდესაც ეს ფორმა ამ ID წარედგინება, შეასრულოს
შემდეგი კოდი.
მე არ მაინტერესებს რა სახელი ფუნქცია მე შესრულებაში.
ასე რომ აქ მე გამოყენებით, როგორც ადრე, რა არის მოუწოდა ლამბდა ფუნქცია ან
ანონიმური ფუნქცია.
ეს არ არის ყველა ინტელექტუალურად საინტერესო გარდა მას არა აქვს სახელი,
რომელიც არის ჯარიმა, თუ თქვენ მხოლოდ ოდესმე აპირებს ეძახით ერთხელ.
და შიგნით არსებობს მე რეალურად უმკლავდება წარდგენის ფორმით.
მე პირველად განაცხადოს ცვლადი ე.წ. ღირებულება.
და მაშინ რა არის ეფექტი ამ ხაზგასმით ნაწილი აქ არის?
რას აკეთებთ მაღალი დონის ჩემთვის?
>> აუდიტორია: იგი იღებს ღირებულება, რომელიც შესახებ არ შეუძლიათ HTML ქვემოთ.
იგი იღებს, რომ ID და შემდეგ აღმოაჩენს ღირებულება მას.
>> დევიდ ჯ Malan: ზუსტად.
ის grabs კვანძის, რომლის უნიკალურ მაიდენტიფიცირებელი სახელი.
იგი იღებს ღირებულება მასში, რომელიც არის, სავარაუდოდ, რა შესახებ
აკრეფილი მას თავად.
და შემდეგ იგი ინახავს რომ ცვლადში ღირებულება.
როგორც განზე, თქვენ შეიძლება ასევე გაკეთდეს ამ პატარა განსხვავებულად.
სრულიად მისაღები თავისსავე ტყუილი var ღირებულება იღებს
document.getElementById.
და ამიტომ ეს პატარა tedious არ გამოიყენოთ jQuery.
"სახელი". ღირებულება.
ასე რომ, სრულიად მისაღებია.
სხვადასხვა გზა ამის გაკეთება. jQuery მხოლოდ იხრება უფრო ლაკონური და
ნამდვილად უფრო პოპულარული მათ შორის პროგრამისტები.
>> ახლა, მე ვაკეთებ ცოტა საღი აზრის შემოწმება, რადგან პრობლემა
განცხადებაში ჩვენ მკაფიოდ განაცხადა, იმ შემთხვევაში, თუ მომხმარებელს ჯერ არ აკრეფილი მისი
სახელი, არ ჩანს შეტყობინებები.
მაგრამ შეგიძლიათ შეამოწმოთ, რომ მხოლოდ შემოწმების ცარიელი სიმებიანი
ციტირებით-unquote, თუ არსებობს არაფერი რეალურად არსებობს.
მაგრამ თუ ეს არ არის ტოლი ციტირებით-unquote, მინდა მოვუწოდო შეტყობინებები.
და საინტერესო ის არის, რომ ჩვენ გამოყენებით პლუს ოპერატორი, რომელიც
აკეთებს რა JavaScript?
Concatenate.
ასე რომ, ეს როგორც PHPs dot ოპერატორი.
იგივე იდეა, ოდნავ განსხვავებული სინტაქსი.
და მე უბრალოდ შექმნაში სიმებიანი რომ თქვენ ხედავთ ეკრანზე shot -
Hello, ასე და ასე.
>> და მერე ბოლო დეტალი არის ამ.
რატომ დაბრუნების ცრუ შიგნით ამ ანონიმური ფუნქცია?
>> აუდიტორია: არ არსებობს ღირებულება.
თქვენ ამას ფორმით.
უბრალოდ ამბობს, თუ ღირებულება არ არის ტოლი ცარიელი, მაშინ ამის გაკეთება.
არ იყო ცარიელი, რომ წარდგენის.
>> დევიდ ჯ Malan: OK.
ფრთხილად, თუმცა.
იქ არავინ აქ.
და რომ დაბრუნების ცრუ გარეთ იმ შემთხვევაში, თუ პირობები.
ასე რომ, ეს ხაზი გაუსვა ხაზი, დაბრუნების ცრუ, ახორციელებს არა აქვს მნიშვნელობა რა, როდესაც
სახით წარმოდგენილი.
რას დაბრუნების ცრუ შიგნით ამ ღონისძიება დამმუშავებლის, როგორც მას უწოდებენ,
ღონისძიება კითხვა მიმდინარეობს წარდგენა?
>> აუდიტორია: იმიტომ, რომ მხოლოდ ერთხელ არის.
>> დევიდ ჯ Malan: მხოლოდ ერთხელ ხდება.
არა საკმაოდ.
ჰო?
>> აუდიტორია: ეს ხელს უშლის ფორმა წარუდგინოს ნაგულისხმევი ქცევის,
რომელიც გახდის გვერდზე განახლება.
>> დევიდ ჯ Malan: ზუსტად.
ამიტომ მე გადატვირთვის ტერმინი წარდგენა აქ, იმიტომ, რომ მე ვამბობ, ფორმა
მიმდინარეობს წარმოდგენილი.
მაგრამ, როგორც თქვენ ვარაუდობენ, რომ ეს რეალურად არ არის წარედგინა ნამდვილი HTTP გზა.
როდესაც თქვენ დააჭირეთ შეტანა, რადგან ჩვენი onSubmit კურატორმა, ჩვენ მოსმენებისა
რომ ფორმა წარდგენის ასე ვთქვათ.
ჩვენ მაშინ ვაკეთებთ რამ და JavaScript კოდი.
მაგრამ მე შეგნებულად დაბრუნების ცრუ, რადგან ის, რაც მე არ მინდა, რომ მოხდეს
გაყოფილი მეორე მოგვიანებით მთელი ფორმა თავად წარსადგენი ვებგვერდი
სერვერზე გასაღები ღირებულება წყვილი შეცვლით URL უნდა იყოს რაღაც
q = cats ან რასაც ჩვენ გავაკეთეთ, მაგალითად, კლასში.
მე არ მინდა, რომ მოხდეს, რადგან არ არსებობს სერვერზე მოსმენის ამ
შექმნას წარდგენა.
ის მხოლოდ გაკეთდეს JavaScript კოდი.
და ამიტომ მე კი არ აქვს action ატრიბუტის ჩემი სახით, იმიტომ, რომ მე
არ ვაპირებთ, რომ ეს ოდესმე წასვლა სერვერზე.
>> ასე რომ, ეს ხდება წარმოდგენილი.
მაგრამ ჩვენ მოსმენებისა, რომ ფორმა წარდგენის და თავიდან აცილების ნაგულისხმევი
ქცევა, რომელიც რეალურად წავიდეთ ყველა გზა სერვერზე.
>> აუდიტორია: ასე რომ, შენახვის კლიენტის მხარეს.
>> დევიდ ჯ Malan: Keeping ის კლიენტის მხარეს.
სწორედ.
შემდეგი up იყო ჩემი oh MySQL.
>> რობ Bowden: OK.
ასე რომ, ეს პირველი კითხვა იყო ზოგადად უხეში ადამიანი.
თუმცა მოგვიანებით პირობა წავიდა უკეთესი.
ასე, რომ თქვენ უნდა აირჩიოს სწორი მონაცემები სახის ორივე სვეტით.
და ორივე აქვს გარკვეული რამ, რომ
არჩევანი რთულია.
ასე int არ იყო სწორი ტიპის ნომერი.
მიზეზი იმისა, რომ 12 ციფრი ანგარიში ნომერი, int არ არის დიდი საკმარისი
შესანახად სულ თანრიგისაგან.
ასე რომ, სწორი არჩევანი იქნებოდა დიდი int თუ მოხდება არა რომ.
სხვა არჩევანი იქნებოდა char სფეროში სიგრძე 12.
ასე რომ, არც იმ იქნებოდა მუშაობდა.
Int არა.
>> ახლა, ბალანსი, ვფიქრობ, უკან pset7.
ასე რომ, ჩვენ სპეციალურად გამოიყენება ათწილადის შენახვის ღირებულება აქციების ან -
>> დევიდ ჯ Malan: Cash.
>> რობ Bowden: Cash.
ჩვენ გამოიყენება ათობითი შესანახად თანხის ნაღდი, რომ მომხმარებელს გაკეთებული აქვს.
ასე რომ, მიზეზი ჩვენ გავაკეთებთ, რომ არის რადგან, გახსოვდეთ, მოძრავი.
არსებობს მცურავი პუნქტიანი სიზუსტით.
მას არ შეუძლია ზუსტად შესანახად ფულადი ღირებულებები როგორც ჩვენ გვინდა აქ.
ასე ათობითი შეუძლია ზუსტად მაღაზია რაღაც, ვთქვათ, ორი ათობითი ადგილებში.
ამიტომაც ბალანსი, ჩვენ გვსურს უნდა იყოს ათობითი და არა ათწილადი.
>> დევიდ ჯ Malan: და ასევე, ძალიან, თუმცა ეს შეიძლება ყოფილიყო ჭკვიანი სხვა
კონტექსტში ვფიქრობ, იქნებ ამ არის შანსი int.
მე უბრალოდ ტრეკზე რამ pennies.
იმიტომ, რომ ჩვენ მკაფიოდ აჩვენა რა ღირებულება მყოფი 100.00, რომელიც
იმას ნიშნავს, რომ შეიძლება მხოლოდ int.
და კიდევ ერთი სინატიფით ძალიან ნომრით იყო, რომ იგი არ გულისხმობს
უნდა იყოს შეასრულა კითხვაზე.
მაგრამ გავიხსენოთ, რომ int in MySQL, როგორც C, მაინც
მოწყობილობების, 32-bit.
და მიუხედავად იმისა, რომ ჩვენ არ ველით, რომ თქვენ ვიცი ზუსტად რამდენი ციფრები,
საშუალება, არ გავიხსენოთ, რომ ყველაზე თქვენ შეგიძლიათ წარმოადგენს პოტენციურად
ერთად 32-bit ნომერი დაახლოებით რა?
>> რა რაოდენობის ჩვენ ყოველთვის ვამბობ?
2 დან 32, რომელიც არის ის, რაც დაახლოებით?
თქვენ არ უნდა იცოდეთ ზუსტად.
მაგრამ დაახლოებით სასარგებლოა ცხოვრებაში.
ეს დაახლოებით 4 მილიარდი.
ამიტომ ჩვენ განაცხადა, რომ რამდენჯერმე.
მე ვიცი, მე ვთქვი, რომ რამდენიმე ჯერ.
და ეს არის დაახლოებით 4 მილიარდი.
და ეს კარგი წესი ცერის ვიცი.
თუ თქვენ გაქვთ 8 ბიტი, 256 არის ჯადოსნური ნომერი.
თუ თქვენ გაქვთ 32 ბიტი, 4 მილიარდი მისცეს ან მიიღოს.
ასე რომ, თუ თქვენ უბრალოდ დაწერეთ 4 მილიარდი, თქვენ ნახავთ, რომ ეს ნაკლები ციფრისგან ვიდრე
12, რაც იმას ნიშნავს, რომ აშკარად არ საკმარისი გამომსახველობა ხელში
12 ციფრი ანგარიშის ნომერი.
>> რობ Bowden: OK.
ასე რომ, სხვა პირობა წავიდა უკეთესი.
ასე რომ, ვფიქრობ, რომ ბანკი აკისრებს $ 20 თვეში
მომსახურების საკომისიო ყველა ანგარიშები.
რა SQL შეკითხვაზე შეეძლო ბანკის ჩამოჭრა $ 20 ყოველი რაოდენობა, თუნდაც
ეს იწვევს უარყოფით ნაშთები?
ასე რომ, ძირითადად, არის ოთხი ძირითადი ტიპის queries -
ჩასასმელად, აირჩიეთ, განახლება და წაშლა.
ასე რომ, რას ვფიქრობთ ჩვენ აპირებს გამოიყენოს აქ?
განახლება.
>> მოდით შევხედოთ.
ასე რომ აქ ჩვენ განახლებაზე.
რა მაგიდასთან ჩვენ განახლებაზე ანგარიშები?
ასე განახლებაზე ანგარიშები.
და შემდეგ სინტაქსი ამბობს, რა ანგარიშების ჩვენ განახლებაზე?
ისე, ჩვენ შექმნის ბალანსი უდრის მიმდინარე ღირებულება ბალანსი მინუს 20.
ასე რომ, ეს განაახლებს ყველა რიგები ანგარიშები, გამოკლება
20 $ დან ბალანსი.
>> დევიდ ჯ Malan: ჩვეულებრივი შეცდომა აქ, მიუხედავად იმისა, რომ ზოგჯერ აპატია ის,
იყო რეალურად PHP კოდი აქ მოუწოდებდა შეკითხვის ფუნქცია ან აყენებს
შეთავაზებები გარშემო ყველაფერი, რაც არ უნდა იყოს იქ.
>> რობ Bowden: გახსოვდეთ, რომ MySQL არის ცალკე ენა PHP.
ჩვენ არ უნდა იყოს წერილობით MySQL PHP.
და PHP მაშინ გაგზავნის მას მეტი MySQL სერვერზე.
მაგრამ თქვენ არ უნდა PHP, რათა ურთიერთობა MySQL სერვერზე.
>> დევიდ ჯ Malan: ზუსტად.
ასე რომ არ ცვლადს დოლარის ნიშნები უნდა იყოს ამ კონტექსტში.
ეს შეიძლება უბრალოდ ყველა math ფარგლებში მონაცემთა ბაზის თავად.
>> რობ Bowden: OK.
ასე რომ, მომდევნო ერთი.
ეს არის მომდევნო ერთი?
ჰო.
ასე რომ, რა SQL შეკითხვაზე შეეძლო ბანკის ვიღებ ანგარიშის ნომერი და მისი
მდიდარი მომხმარებელს, ვისაც ნაშთების მეტია 1.000?
ასე რომ რაც ოთხი ძირითადი ტიპი ჩვენ ვაპირებთ გინდათ აქ?
შერჩევა.
ამიტომ, ჩვენ უნდა აირჩიოთ.
რას უნდა აირჩიოთ?
რა სვეტი გვინდა აირჩიოთ?
ჩვენ კონკრეტულად მინდა აირჩიოთ ნომერი.
მაგრამ თუ თქვენ თქვით, ვარსკვლავი, ჩვენ ასევე დაადასტურა, რომ.
>> ასე რომ, აირჩიეთ ნომერი რა მაგიდა?
ანგარიშები.
და შემდეგ იმ პირობით, ჩვენ გვინდა?
სადაც ბალანსი აღემატება 1000.
ჩვენ ასევე დაადასტურა მეტი მეტი ან ტოლი.
ბოლო ერთი.
რა SQL შეკითხვაზე შეეძლო ბანკის ახლოს, ანუ, წაშლის, ყველა ანგარიში, რომელიც
აქვს ბალანსი $ 0?
ასე რომ რაც ოთხი ვართ ჩვენ აპირებს გინდათ გამოიყენოთ?
წაშლა.
ასე რომ, სინტაქსი, რომ?
წაშალე რა მაგიდა?
ანგარიშები.
და შემდეგ იმ პირობით, რომელიც ჩვენ გვინდა წაშლა -
სადაც ბალანსი ნულის ტოლი.
ასე რომ, წაშლა ყველა რიგები ანგარიშები სადაც ბალანსი არის ნული.
კითხვები ნებისმიერ ამ?
მინდა მდგომ?
>> დევიდ ჯ Malan: Queue სახელმძღვანელო.
ასე რომ, ამ ერთი, მივეცით თქვენ გარკვეულწილად ნაცნობი სტრუქტურა, რომელიც ჩვენ შესწავლილი
ცოტა კლასში ერთად of structs, რომელიც მონაცემები
სტრუქტურა დაკავშირებული სული.
განსხვავება თუმცა მდგომ რომ ჩვენ უნდა რატომღაც მახსოვს ვინ
იყო წინაშე მდგომ, დიდი ნაწილი ისე, რომ ჩვენ შეგვიძლია უფრო მეტი
ეფექტური გამოყენება მეხსიერება, მინიმუმ თუ ჩვენ გამოყენებით მასივი.
>> იმის გამო, რომ გავიხსენოთ, თუ ჩვენ გვაქვს მასივი, თუ, მაგალითად, ეს არის თვალწინ
მდგომ, თუ მე შეღწევას მდგომ აქ, და მერე ვინმე იღებს ხაზი
ჩემს უკან, ჩემს უკან, ჩემს უკან, და ერთი ადამიანი ნაბიჯები out of ხაზი, თქვენ
შეიძლება, როგორც დავინახეთ, ჩვენი ზოგიერთი ადამიანის მოხალისეები კლასში, ყველას
გადაიტანოს ამ გზით.
მაგრამ ზოგადად, რომელმაც ყველას გაკეთება რაღაც არ არის საუკეთესო გამოყენების დროს
პროგრამა, რადგან ეს ნიშნავს, რომ თქვენი ალგორითმი არის გაშვებული რა
ასიმპტოტური ქრონომეტრაჟი?
ეს არის სწორხაზოვანი.
>> და ვგრძნობ, როგორიცაა, რომ სახის სულელური.
იმ შემთხვევაში, თუ მომდევნო ხაზი არის შემდეგი პირი, რომელიც უნდა წასვლას
მაღაზია, მათ არ აქვთ გადატანა ერთად.
უბრალოდ ნება, რომ ადამიანი უნდა plucked off როცა დრო მოდის, მაგალითად.
ასე რომ ჩვენ შეგვიძლია გადარჩენა ცოტა დრო იყო.
და ასე უნდა გავაკეთოთ, რომ მიუხედავად იმისა, რომ საშუალება რომ ხელმძღვანელი მდგომ ან
წინაშე მდგომ აპირებს თანდათანობით გადავიდეს უფრო და უფრო ღრმად
შევიდა მასივი და საბოლოოდ შეიძლება რეალურად გადაიტანოთ გარშემო, თუ ჩვენ გამოყენებით
array შესანახად ადამიანი ამ რიგიდან.
ასე რომ თქვენ შეგიძლიათ თითქმის ვფიქრობ array როგორც წრიული მონაცემები
სტრუქტურა ამ თვალსაზრისით.
>> ასე, რომ თქვენ როგორღაც უნდა ტრეკზე ზომა, ან მართლაც ბოლომდე მას
და მაშინ, სადაც დასაწყისში ეს არის.
ამიტომ ჩვენ გთავაზობთ, რომ თქვენ გამოაცხადოს ერთი ასეთი რიგში, მოწოდება
ეს q, მხოლოდ ერთი წერილი.
მაშინ ჩვენ ვთავაზობთ, რომ წინა უნდა იყოს ინიციალიზაცია ნულოვანი და რომ ზომა
ინიციალიზდება ნულოვანი.
>> ასე რომ, ახლა, არაფერი შიგნით რომ რიგიდან.
და ჩვენ ვთხოვთ თქვენ დასრულებას განხორციელების enqueue ქვემოთ
ისე, რომ ფუნქცია დასძენს n to ბოლოს q და შემდეგ ბრუნდება ნამდვილი.
მაგრამ თუ q სავსეა ან უარყოფითი, ფუნქცია უნდა ნაცვლად დაბრუნების ცრუ.
და მივეცით თქვენ რამდენიმე ვარაუდები.
მაგრამ ისინი ნამდვილად არ ფუნქციურად შესაბამისი, უბრალოდ, რომ bool არსებობს,
იმიტომ, რომ ტექნიკურად, bool არ არსებობს C თუ არ არის
გარკვეული header ფაილი.
ასე რომ, უბრალოდ დარწმუნდით, რომ არ არსებობს არცერთი ეს ხრიკი
კითხვა სახის რამ.
>> ასე რომ enqueue, ჩვენ შეთავაზებული ნიმუში გადაწყვეტილებების განსახორციელებლად ასეთია.
ერთი, ჩვენ პირველად შემოწმება მარტივია, დაბალი ჩამოკიდებული ხილი.
იმ შემთხვევაში, თუ მდგომ არის სრული ან ნომერი, რომელიც თქვენ ცდილობთ ჩადეთ ნაკლებია,
ვიდრე ნულოვანი, რაც ჩვენ განაცხადა, დაზუსტება პრობლემა უნდა
არ დაიშვება, რადგან ჩვენ მხოლოდ გვინდა არასამთავრობო უარყოფით ღირებულებებს, მაშინ უნდა
უბრალოდ დააბრუნოს ყალბი დაუყოვნებლივ.
ასე რომ ზოგიერთი შედარებით ადვილი შეცდომა შემოწმებისას.
იმ შემთხვევაში, თუ იმისა, რომ თქვენ გსურთ დაამატოთ, რომ ფაქტობრივი ნომერი, თქვენ უნდა გაეკეთებინათ ცოტა
ფიქრი აქ.
და ეს არის, სადაც ეს პატარა შემაშფოთებელი გონებრივად, რადგან თქვენ უნდა
გაერკვნენ, თუ როგორ უნდა გაუმკლავდეს wraparound.
>> მაგრამ ჩანასახები იდეა აქ რომ საქართველოს ჩვენთვის საინტერესო ის არის, რომ wraparound
ხშირად გულისხმობს მოდულარული არითმეტიკა და mod ოპერატორი, პროცენტი მხარეს,
სადაც შეგიძლიათ წასვლა უფრო დიდი ღირებულება უკან ნულის და მერე ერთი და ორი და
სამი და შემდეგ უკან გარშემო ნულის, ერთი და ორი და სამი და ა.შ.
ისევ და ისევ.
ასე რომ გზა ჩვენ ვთავაზობთ ამით არის რომ ჩვენ გვინდა ინდექსი შევიდა
array მოუწოდა ნომრები, საიდანაც ჩვენი რიცხვებით სიცრუეა.
მაგრამ იქ, ჩვენ პირველად გსურთ რაც არ უნდა ზომა მდგომ არის, მაგრამ
შემდეგ დავამატოთ, რომ რასაც თვალწინ სიაში.
და ეფექტი, რომელიც დააყენა ჩვენთვის სწორი პოზიცია მდგომ და
არ ვივარაუდოთ, რომ პირველი პირი ონლაინ არის დასაწყისში, რომელიც მან ან
იგი აბსოლუტურად შეიძლება თუ ჩვენ ასევე გადავიდა ყველას.
მაგრამ ჩვენ უბრალოდ შექმნაში მუშაობა საკუთარ თავს თუ ავიღეთ
რომ კონკრეტული გზა.
>> ასე რომ ჩვენ შეგვიძლია შევინარჩუნოთ ის შედარებით მარტივი.
ჩვენ უნდა გვახსოვდეს, რომ ჩვენ მხოლოდ დამატებული int მდგომ.
და მაშინ ჩვენ უბრალოდ დააბრუნოს ჭეშმარიტი.
იმავდროულად, dequeue, ჩვენ ვთხოვეთ თქვენ უნდა გავაკეთოთ შემდეგი.
განახორციელოს იგი იმგვარად, რომ dequeues, რომელიც შლის და ანაზღაურება,
int წინაშე მდგომ.
ამოიღონ int, საკმარისია დაივიწყებს.
თქვენ არ უნდა გადაფაროს მისი bit.
ასე რომ ჯერ კიდევ რეალურად არსებობს.
ისევე, როგორც მონაცემების მყარ დისკზე, ჩვენ უბრალოდ იგნორირება იმისა,
ის, რომ ახლა იქ.
და თუ q არის ცარიელი, ჩვენ უნდა ნაცვლად დაბრუნების უარყოფითი 1.
ასე რომ, ეს გრძნობს თვითნებური.
რატომ დაბრუნდნენ -1 ნაცვლად ყალბი?
ჰო.
>> აუდიტორია: Q შენახვის დადებითი ღირებულებებს.
მას შემდეგ, რაც თქვენ მხოლოდ შესანახად დადებითი მნიშვნელობები ამ q, უარყოფითი არის შეცდომა.
>> დევიდ ჯ Malan: OK, მართალია.
ასე რომ, რადგან ჩვენ მხოლოდ შენახვის დადებითი ღირებულებები ან ნულოვანი, მაშინ ეს ჯარიმა
დაბრუნების უარყოფითი ღირებულება, როგორც Sentinel ღირებულება, სპეციალური სიმბოლო.
მაგრამ თქვენ გადაწერა ისტორიაში არსებობს, რადგან იმ მიზეზით, ჩვენ მხოლოდ
დაბრუნების არასამთავრობო უარყოფით ღირებულებებს იმიტომ, რომ ჩვენ გვინდა
აქვს Sentinel ღირებულება.
ასე რომ, უფრო კონკრეტულად კი, რატომ არა მხოლოდ დაბრუნების ცრუ შემთხვევებში შეცდომები?
ჰო.
>> აუდიტორია: თქვენ ვერ დაბრუნების რიცხვი.
>> დევიდ ჯ Malan: ზუსტად.
და ეს არის სადაც C იღებს საკმაოდ შეზღუდულია.
თუ თქვენ ამბობდა თქვენ აპირებს დაბრუნების int, თქვენ მოხვდით
დაბრუნებას int.
თქვენ არ შეგიძლიათ მიიღოთ ლამაზი და დაიწყოს დაბრუნების bool ან float ან
სიმებიანი ან რამე მაგდაგვარს.
ახლა კი, JavaScript და PHP და ზოგიერთი სხვა ენებზე სისტემაში, ფაქტობრივად,
თქვენ დაბრუნების სხვადასხვა ტიპის ფასეულობები.
და რომ შეიძლება რეალურად იყოს სასარგებლო, სადაც თქვენ შეიძლება დაბრუნდეს დადებითი ints, zeros,
უარყოფითი ints, ან ცრუ ან null კი ნიშნავდეს შეცდომა.
მაგრამ ჩვენ არ გვაქვს, რომ versatility in C.
>> ასე რომ dequeue, რასაც ჩვენ ვთავაზობ, რომ გააკეთოთ, არის -
>> რობ Bowden: თქვენ შეგიძლიათ დაბრუნების ცრუ.
უბრალოდ, ცრუ არის hash განსაზღვრავს ცრუ ნულოვანი.
ასე რომ, თუ დაბრუნების ცრუ, თქვენ დაბრუნების ნულოვანი.
და ნულოვანი არის სწორი, რაც ჩვენი მდგომ, ხოლო უარყოფითი 1 არ არის, თუ
ცრუ მოხდა იყოს უარყოფითი 1.
მაგრამ თქვენ არ უნდა უნდა ვიცოდეთ, რომ.
>> დევიდ ჯ Malan: ეს რატომ არ ვთქვათ.
>> რობ Bowden: მაგრამ ეს არ იყო ნამდვილი რომ თქვენ ვერ დაბრუნების ცრუ.
>> დევიდ ჯ Malan: რა თქმა უნდა.
ასე რომ dequeue შეამჩნევთ, ჩვენ ვიღებთ ბათილად, როგორც მისი არგუმენტი.
და ეს იმიტომ, რომ ჩვენ არ ვართ გავლის არაფერს შემოსული
ჩვენ გვსურს მხოლოდ ამოიღონ ელემენტს წინაშე მდგომ.
ასე რომ, როგორ შეგვიძლია წავიდეთ შესახებ ამით?
ისე, პირველ რიგში, მოდით ეს სწრაფი საღი აზრის ქვითარი.
იმ შემთხვევაში, თუ მდგომ ზომა არის 0, არსებობს სამუშაო უნდა გაკეთდეს.
დაბრუნება უარყოფითი 1.
შესრულებულია.
ასე რომ, რამდენიმე ხაზი ჩემი პროგრამა.
ასე რომ, მხოლოდ ოთხი ხაზები რჩება.
>> ასე რომ აქ მე ვწყვიტავ decrement ზომა.
და decrementing ზომა ეფექტურად იმას ნიშნავს, რომ მე დავიწყება
რაღაც არსებობს.
მაგრამ მე ასევე უნდა განახლდეს, სადაც თვალწინ ნომრები.
ასე უნდა გავაკეთოთ, რომ, მე უნდა გააკეთოს ორი რამ.
მე პირველად უნდა გვახსოვდეს, რა რაოდენობის არის წინაშე მდგომ,
იმიტომ, რომ მე უნდა დაბრუნდეს რომ რამ.
ასე რომ, მე არ მინდა, რომ შემთხვევით დაგვავიწყდეს ამის შესახებ და მერე გადაწერა იგი.
მე უბრალოდ აპირებს მახსოვს int.
>> და ახლა, მინდა განახლება q.front უნდა q.front +1.
ასე რომ, თუ ეს იყო პირველი პირი ხაზი, ახლა, მინდა plus 1
აღვნიშნო მომდევნო ხაზი.
მაგრამ უნდა გაუმკლავდეს, რომ wraparound.
და თუ მოცულობა არის გლობალური მუდმივი, რომ აპირებს ნება მიბოძეთ დარწმუნდით
როგორც მე აღვნიშნო, რომ ძალიან ბოლო პირი ხაზი, modulo ოპერაცია მოუტანს
ჩემს უკან ნულოვანი წინაშე მდგომ.
და რომ ამუშავებს wraparound აქ.
და მერე გაგრძელება დაბრუნებას n.
>> ახლა, მკაცრად რომ ვთქვათ, მე არ უნდა განაცხადოს n.
მე არ უნდა დაიბრუნოს ის და ჩაწეროთ იგი დროებით, რადგან ღირებულება
ჯერ კიდევ არსებობს.
მე ვერ უბრალოდ უფლება არითმეტიკული დაბრუნებას ყოფილი ხელმძღვანელი
რიგიდან.
მაგრამ მე უბრალოდ იგრძნო, რომ ეს იყო უფრო ნათელი რეალურად დაიბრუნოს int, დაუსვან მას
in n, და შემდეგ დაბრუნდნენ, რომ სიცხადე გულისთვის, მაგრამ
არ არის მკაცრად აუცილებელია.
Psst.
ისინი ყველა pronounceable ჩემი უფროსი.
>> რობ Bowden: ასე რომ, პირველი კითხვა, არის ორობითი ხე პრობლემა.
ასე რომ, პირველი კითხვა, ჩვენ მოცემულია ამ ნომრებზე.
და ჩვენ გვინდა, რომ როგორმე ჩადეთ მათ ამ კვანძების ასეთი, რომ ეს არის
მოქმედებს ორობითი ძებნა ხე.
ასე რომ, ერთი რამ უნდა გვახსოვდეს შესახებ ორობითი ძებნა ხეები არის, რომ ეს არ არის
მხოლოდ, რომ ის მარცხენა ნაკლებია და, რაც უნდა
მარჯვენა არის უფრო დიდი.
ეს უნდა იყოს, რომ მთელი ხე მარცხენა არის ნაკლები, და მთელი ხე
მარჯვნივ არის დიდი.
>> ასე რომ, თუ მე ზუსტად 34 აქ ზედა, და შემდეგ მე ზუსტად 20 აქ, ასე რომ მოქმედებს ისე,
შორს, რადგან 34 აქ.
20 აპირებს მარცხნივ.
ასე რომ ნაკლებია.
მაგრამ მე ვერ მაშინ 59 აქ, რადგან მიუხედავად იმისა, რომ 59 არის მარჯვენა 20,
ეს ჯერ კიდევ მარცხენა 34.
ასე რომ შეზღუდვა გათვალისწინებით, უმარტივეს გზას, ალბათ, პრობლემის
პრობლემა ის არის, რომ მხოლოდ ერთგვარი ამ ნომრებზე -
ასე რომ, 20, 34, 36, 52, 59, 106.
და შემდეგ ჩადეთ იმ მარცხნიდან მარჯვნივ.
>> ასე რომ, 20 მიდის აქ.
34 მიდის აქ.
36 მიდის აქ.
52, 59, 106.
და ასევე შეიძლება არ figured out ერთად ზოგიერთი ჩართვის და ხვდებიან,
oh, დაველოდოთ, მე არ მაქვს საკმარისი ნომერი შეავსოთ ეს მეტი აქ.
ასე რომ, მე უნდა reshift რა ჩემი მარშრუტი შენიშვნა იქნება.
მაგრამ შეამჩნია, რომ ბოლო სამი, თუ წაიკითხოთ მარცხნიდან მარჯვნივ, ეს
გაზრდის მიზნით.
>> ახლა, ჩვენ გვინდა, რომ გამოაცხადოს, თუ რა struct იქნება, რომ
კვანძების ამ ხეს.
ასე რომ, რა გვჭირდება in ორობითი ხე?
ამიტომ ჩვენ გვაქვს ღირებულება ტიპი int, ამიტომ ზოგიერთი int ღირებულება.
მე არ ვიცი, რასაც ჩვენ მოუწოდა ეს გადაწყვეტა -
int n.
ჩვენ უნდა მომცეთ მარცხენა ბავშვის და მომცეთ უფლება შვილი.
ასე რომ, ის აპირებს გამოიყურებოდეს.
და ეს კიდე რეალურად გამოიყურება ადრე როდის ორმაგად დაკავშირებული
სიაში პერსონალი, ასე რომ ცნობა -
მე ვაპირებ უნდა გადახვევა ყველა გზა უკან ქვემოთ პრობლემა 11.
>> ასე რომ შეამჩნია ეს გამოიყურება იდენტურია ამ, გარდა ჩვენ უბრალოდ არ უნდა მოვუწოდებთ ამ
სხვადასხვა სახელები.
ჩვენ ჯერ კიდევ მთელი რიცხვი ღირებულება და ორი პოინტერები.
უბრალოდ, იმის ნაცვლად, მკურნალობის მითითებები, როგორც მიუთითებს შემდეგი რამ
და წინა რამ, ჩვენ სამკურნალოდ პოინტერები აღვნიშნო, მარცხენა ბავშვი
მარჯვენა და ბავშვი.
OK.
ასე რომ ჩვენი struct კვანძში.
და ახლა, ერთადერთი ფუნქცია, ჩვენ უნდა განახორციელოს ეს არის ტრავერსზე, რომელიც
ჩვენ გვინდა წავიდეთ მეტი ხე, ბეჭდვა out ღირებულებების ხე მიზნით.
>> ასე ეძებს აქ, ჩვენ გვინდა ბეჭდვა out 20, 34, 36, 52, 59 და 106.
როგორ შეგვიძლია მიზნის მისაღწევად, რომ?
ასე რომ საკმაოდ მსგავსია.
თუ დაინახა წარსულში გამოცდა პრობლემა რომ თქვენ სურდა ამობეჭდოთ
მთელი ხე მძიმეები შორის ყველაფერი, ეს იყო რეალურად კი
უფრო ადვილია, ვიდრე, რომ.
ასე რომ, აქ არის გამოსავალი.
ეს მნიშვნელოვნად ადვილი თუ ეს რეკურსიული.
მე არ ვიცი, თუ ვინმეს სცადა ამის გაკეთება iteratively.
>> მაგრამ პირველი, ჩვენ ჩვენი ბაზის შემთხვევაში.
რა მოხდება, თუ root არის null?
მაშინ ჩვენ უბრალოდ აპირებს დაბრუნებას.
ჩვენ არ გვინდა ბეჭდვა არაფერი.
Else ჩვენ ვაპირებთ traverse რეკურსიული ქვემოთ.
ბეჭდვა მთელი მარცხენა subtree.
ასე რომ, ბეჭდვა ყველაფერი ნაკლები ვიდრე ჩემი დღევანდელი ღირებულება.
და შემდეგ მე ვაპირებ ბეჭდვა თავს.
და შემდეგ მე ვაპირებ recurse ქვემოთ ჩემი მთელი მარჯვენა subtree, ყველაფერი
უფრო მეტი, ვიდრე ჩემს ღირებულება.
და ეს აპირებს ბეჭდვა ყველაფერი წესრიგშია.
კითხვები, თუ როგორ ეს რეალურად ახორციელებს, რომ?
>> აუდიტორია: მე მაქვს შეკითხვა წლის [INAUDIBLE].
>> რობ Bowden: ასე რომ ერთი გზა უახლოვდება ნებისმიერი რეკურსიული პრობლემა ის არის, უბრალოდ ვფიქრობ
ამის შესახებ მინდა თქვენ უნდა ვიფიქროთ ყველა კუთხეში შემთხვევაში.
ასე მიიჩნევენ, რომ ჩვენ გვინდა ბეჭდვა ეს მთელი ხე.
ასე რომ, ყველა ჩვენ ვაპირებთ ფოკუსირება არის ამ კონკრეტულ კვანძის -
36.
რეკურსიული ზარი, ჩვენ ვითომ იმ უბრალოდ მუშაობა.
ასე რომ აქ, ამ რეკურსიული ზარი ტრავერსზე, ჩვენ გარეშე კი ფიქრობდა
ამის შესახებ, უბრალოდ გამავალი მარცხენა სამი, წარმოიდგინეთ, რომ უკვე ბეჭდავს 20
34 ჩვენთვის.
და მაშინ, როდესაც ჩვენ საბოლოოდ რეკურსიული დარეკეთ ტრავერსზე შესახებ
უფლება, რომელიც სწორად ბეჭდვა 52, 59, და 106 ჩვენთვის.
>> ასე რომ, იმის გათვალისწინებით, რომ ეს შეიძლება ბეჭდვა 20, 34, და სხვა შეგიძლიათ ამობეჭდოთ 52, 59, 108,
ყველა ჩვენ უნდა გამოუვა არის ბეჭდვის ourself შუა რომ.
ასე რომ ამობეჭდოთ ყველაფერი ჩვენს წინაშე.
ბეჭდვა ourself, ისე მიმდინარე კვანძის print 36, რეგულარული printf და შემდეგ
ბეჭდვა ყველაფერი ჩვენს შემდეგ.
>> დევიდ ჯ Malan: ეს არის სადაც უკან იღებს მართლაც ლამაზი.
ის ამ საოცარი ნახტომი რწმენის, სადაც თქვენ აკეთებთ tiniest ცოტა მუშაობა.
და მაშინ მოდით ვინმე სხვაგან არ დანარჩენი.
და, რომ ვინმე არის, ირონიულად, თქვენ.
ასე რომ, სერიოზული brownie ქულა, თუ თქვენ გადახვევა up on კითხვა -
>> რობ Bowden: On კითხვებს?
>> დევიდ ჯ Malan: და ქვემოთ პატარა ციფრები, ვინმეს იცით, სადაც
ეს ციფრები მოდის?
>> რობ Bowden: მე არ სიტყვასიტყვით არ ვიცი.
>> დევიდ ჯ Malan: ისინი, როგორც ჩანს, მთელი ვიქტორინა.
>> აუდიტორია: არიან ისინი იგივე ნომრები?
>> დევიდ ჯ Malan: ეს ნომრები.
პატარა აღდგომის კვერცხი.
ასე რომ, იმ თქვენ თვალს ონლაინ მთავარი, თუ შეგიძლიათ გვითხრათ ფოსტით
heads@CS50.net რა მნიშვნელობა ეს განმეორებადი ექვსი ნომრები
მთელი Quiz 1, ჩვენ საშხაპე თქვენ საოცარი ყურადღება საბოლოო
ლექცია და სტრესი დაადასტურა.
ლამაზი, დახვეწილი.
>> რობ Bowden: ნებისმიერი ბოლო შეკითხვები არაფერი on ვიქტორინა?