[მიმოხილვა: Quiz 1]
 [Ali Nahm, Oreoluwa Barbarinsa, Lucas Freitas, რობ Bowden] [ჰარვარდის უნივერსიტეტის]
 [ეს არის CS50.] [CS50.TV]
 [Lucas Freitas] მოგესალმებით ყველას. ეს არის რეცენზია ვიქტორინა 1.
 ისევე როგორც უარყოფა, ეს - მე ვგულისხმობ, ჩვენ ვაპირებთ ცდილობენ, დაფარონ
 იმდენი მასალა, როგორც შესაძლებელია, მაგრამ ეს არ ნიშნავს იმას, რომ
 ჩვენ ვაპირებთ დაფარავს ყველა რამ, რომ შეიძლება ვიქტორინა 1.
 ასე რომ დარწმუნებული უნდა იყოს, თქვენ ასევე შევხედოთ ლექცია, სექციები, ყველაფერი, რაც თქვენ შეგიძლიათ.
 Quiz 1 იქნება ოთხშაბათს, მომავალ ოთხშაბათს.
 ასე რომ დარწმუნებული უნდა სწავლა. ეს იქნება, საკმაოდ ბევრი, როგორც პირველი ვიქტორინა
 დაკავშირებით თავისი ფორმატით, მაგრამ ეს, ალბათ, იქნება ბევრად უფრო რთული.
 ყოველ შემთხვევაში, შარშან, როდესაც მე მივიღე 50, მე ვფიქრობდი, რომ ეს იყო ბევრად უფრო რთული.
 ასე რომ შეისწავლოს ბევრი.
 

მე ვაპირებ დაფარავს მონაცემები სტრუქტურებისა და Huffman კოდირების.
 ეს არის ის, რომ ბევრი ადამიანი ფიქრობს, არის რთული,
 მაგრამ მე ვაპირებ ცდილობენ, რათა ის მარტივი როგორც შესაძლებელი.
 პირველ რიგში, რაც ჩვენ გვინდა, თქვენ ბიჭები ვიცი ვიქტორინა 1 არის
 მესმის კონცეპტუალური აღწერილობები თითოეული მონაცემები სტრუქტურები, რომ მე ვაპირებ წარმოადგინოს.
 ეს იმას ნიშნავს, რომ თქვენ არ უნდა რეალურად
 განხორციელების hash table თქვენს ვიქტორინა 1.
 ჩვენ არ გვინდა თქვენ განახორციელოს მთელი hash table, ალბათ, ჩვენ შევეცდებით
 იმისათვის, რომ თქვენ განახორციელოს გარკვეული ფუნქციები,
 ყველაზე გავრცელებული ოპერაციების, მაგრამ ჩვენ არ ვაპირებთ, რომ თქვენ განახორციელოს ყველაფერი.
 ამიტომ მნიშვნელოვანია, რომ გესმით კონცეფციის მიღმა ყოველ მონაცემები სტრუქტურა
 და ასევე, რომ თქვენ შეგიძლიათ კოდექსის C,
 უბრალოდ ყველაზე გავრცელებული ოპერაციების აქვთ თითოეული მონაცემები სტრუქტურა.
 და ასევე შეძლებთ განიხილავს მაჩვენებლებისა და structs,
 იმიტომ, რომ ისინი, როგორც ჩანს, ბევრი რამ ამ მონაცემების სტრუქტურები.
 

პირველ რიგში, უკავშირდება სიები. დაკავშირებული სიები რეალურად ძალიან ჰგავს მასივები,
 მაგრამ განსხვავება უკავშირდება სიაში და მასივი,
 პირველ რიგში, ის არის, რომ უკავშირდება სიაში აქვს ძალიან მოქნილი ზომა,
 ხოლო კოლექტორები თქვენ უნდა აირჩიოთ ძალიან დიდი ზომა მასივი,
 ასე რომ თქვენ იცით, რომ თქვენ იქნება შეუძლია შეინახოს ყველა თქვენი მონაცემები, რომ მასივი,
 ან თქვენ უნდა გამოიყენოთ malloc აქვს მოქნილი სიგრძეზე მასივი.
 In უკავშირდება სიები ძალიან ადვილია უბრალოდ უფრო ელემენტები,
 უფრო მეტი ელემენტები უკავშირდება სიაში ან წაშლა ელემენტები.
 და რეალურად, თუ თქვენ არ გსურთ უკავშირდება სია იყოს დახარისხებული,
 თქვენ შეგიძლიათ მოძებნოთ და ამოიღონ ელემენტების მუდმივ დრო,
 ასე რომ O (1) დრო, ასე, რომ ეს ძალიან მოსახერხებელია.
 თქვენ უბრალოდ უნდა იყოს ფრთხილად, რომ ყოველთვის გვახსოვდეს, რომ malloc და თავისუფალი კვანძების,
 მხოლოდ იმიტომ, რომ თუ არ, თქვენ უნდა მეხსიერების გაჟონვის.
 ასე უკავშირდება სიები - განმარტებას კვანძში არის ისევე, როგორც ის, რაც ჩვენ უფლება არსებობს.
 მე ზუსტად int n, მაგრამ თქვენ შეგიძლიათ შეინახოთ ნებისმიერი მონაცემები გსურთ.
 ასე რომ, თუ გსურთ შეინახოთ სიმებიანი, ეს ჯარიმა.
 თუ გსურთ შესანახად struct, ეს ჯარიმა, ორმაგი, რაც გაგიხარდებათ.
 მე უბრალოდ დააყენა int n, რომ მაგალითები აქ.
 და თქვენ უნდა მომცეთ შემდეგი კვანძში.
 ასე რომ, ძირითადად, უკავშირდება სიაში აქვს გარკვეული მონაცემები, და მაშინ იგი მიუთითებს შემდეგი კვანძში.
 თუ ეს ბოლო ელემენტს უკავშირდება სიაში, ის აპირებს აღვნიშნო, რომ null.
 ასე რომ, ეს არის მაგალითი უკავშირდება სიაში.
 

Okay, ასე რომ, ახლა ვნახოთ, რა უნდა გააკეთოს, თუ მინდა ჩადეთ ელემენტს უკავშირდება სიაში.
 პირველი, ფუნქციის ჩანართით იქნება ტიპის ბათილად
 იმიტომ, რომ მე არ მინდა დაბრუნდეს არაფერი.
 და მე ვაპირებ მიიღოს int როგორც არგუმენტი,
 რადგან მინდა, რომ ვიცი, რა მინდა ჩადეთ.
 რა არის პირველი რაც უნდა გავაკეთოთ? ისე, მე უნდა malloc on newnode,
 ასე, რომ ეს არის პირველი ხაზი.
 მე უბრალოდ შექმნას ახალი კვანძის ამუშავებას უკავშირდება სიაში.
 მერე რა ვქნა? კარგად ვიცით, რომ ჩვენი განსახორციელებლად დაკავშირებული სიები
 კლასში, ჩვენ ყოველთვის დააყენა ხელმძღვანელი როგორც გლობალური ცვლადი.
 ასე რომ, რა შეგვიძლია გავაკეთოთ არის შეცვალოს ხელმძღვანელი.
 მე შემიძლია ეს ახალი კვანძის იყოს ახალი ხელმძღვანელი,
 და ის აპირებს აღვნიშნო, რომ წინა ხელმძღვანელი.
 როგორ შეგვიძლია ამის გაკეთება? პირველი, რაც უნდა გავაკეთო
 შეცვალოთ 'n' ახალ კვანძის ღირებულება,
 რომელიც გადაეცა ფუნქცია.
 მაშინ newnode მომდევნო იქნება ხელმძღვანელი.
 უფროსი იქნება newnode. ასე რომ, ეს საკმაოდ მარტივია.
 წაშლის კვანძში, ჩვენ შეგვიძლია ამის გაკეთება, როგორიცაა -
 ერთი გზა, ჩვენ შეგვიძლია გავაკეთოთ, რომ ვთქვა,
 okay, თუ მინდოდა წაშლა, მაგალითად, 3,
 რა შეიძლება გავაკეთოთ მხოლოდ აღვნიშნო წინა კვანძის
 მომდევნო კვანძის 3.
 ასე რომ მე უბრალოდ რამე მაგდაგვარს.
 მაგრამ რა არის პრობლემა აკეთებს, რომ?
 მაქვს მეხსიერების გაჟონვის, ამიტომ მე არ მაქვს ხელმისაწვდომობის ნომერი 3 უქმნით.
 პრობლემა რომ არის, რომ მე არ ვაპირებ, რომ შეძლებს გასათავისუფლებლად რომ კვანძის.
 მე ვაპირებ აქვს მეხსიერების გაჟონვის და (გაუგებარია) აპირებს სიძულვილი ჩემთვის.
 ასე რომ ნაცვლად აკეთებს, რომ მე უნდა ალბათ დროებითი მაჩვენებელი.
 ამიტომ დააყენა დროებითი. ის აპირებს აღვნიშნო, რომ კვანძის რომ მინდა წაშლა.
 და მერე შეიძლება გადავიდეს წინა კვანძების წერტილი მომდევნო კვანძის
 კვანძის რომ მინდა წაშლა.
 და ბოლოს, მე შემიძლია გასათავისუფლებლად მაჩვენებელი.
 მაქვს გასათავისუფლებლად მაჩვენებელი, მე შექმნილი უფლება არსებობს?
 მე არ მაქვს, მხოლოდ იმიტომ, რომ -
 განსხვავება ისაა, რომ ამ კვანძის შეიქმნა გამოყენებით malloc,
 ასე რომ, ეს არის ბევრი, ხოლო ეს ერთი იყო მხოლოდ გამოცხადდა NULL შეცვლა Stack. ასე რომ, მე არ მაქვს გასათავისუფლებლად იგი.
 

Okay. ახლა მოდით ვისაუბროთ stacks.
 Stacks საკმაოდ მარტივია.
 ჩვენ გავაკეთეთ stacks და რიგები კლასში მხოლოდ გამოყენებით მასივები,
 მაგრამ თქვენ უნდა იყოს ნაცნობი - უბრალოდ უნდა იცოდეს,
 რომ თქვენ ასევე შეგიძლიათ გააკეთოთ stacks რიგები გამოყენებით დაკავშირებული სიები ასევე.
 ასე რომ, თუ თქვენ გაქვთ მასივი, რა იქნება დასტის?
 დასტის, პირველი, მოუწევს ზომა.
 თქვენ უნდა ჩაწეროთ რა არის ზომა დასტის, რომ თქვენ ახლა.
 თქვენ ასევე ექნება მასივი, ამ შემთხვევაში ნომრები,
 მაგრამ თუ გსურთ, ეს შეიძლება იყოს მასივი
 სიმები, მასივი struct, არაფერი რომ გსურთ შეინახოთ.
 მომხმარებლის დასტის: განსხვავება დასტის და უკავშირდება სიაში
 ის არის, რომ დასტის თქვენ მხოლოდ ხელი მიუწვდება ბოლო ელემენტს, რომელიც დასვა Stack.
 ეს მოუწოდა ბოლო წელს, პირველი გარეთ.
 ისევე, როგორც თქვენ გაქვთ Stack of ქაღალდის,
 თუ თქვენ დააყენა tray ზედა დასტის,
 თქვენ უნდა ამოიღონ, რომ უჯრა პირველი ჰქონდეს სხვა უჯრები.
 ეს იგივე stacks.
 ასე რომ, თუ მინდა, მაგალითად, დაამატოთ ელემენტი დასტის, რა უნდა ვქნა?
 ეს ე.წ. ბიძგი და ეს საკმაოდ მარტივია.
 პირველი, რაც თქვენ უნდა გააკეთოთ შეამოწმეთ თუ ზომის დასტის
 არ არის დიდი ან ტოლია რანგში Stack.
 იმის გამო, რომ, თუ თქვენ უკვე ხართ სრული დატვირთვით, თქვენ ვერ შეძლებთ დაამატოთ არაფერი.
 და თუ არა, თქვენ უბრალოდ უნდა დაამატოთ ელემენტი Stack.
 და ბოლოს, ნამატი ზომა. ასე რომ, ეს საკმაოდ მარტივია.
 ასე რომ, მე უბრალოდ დაამატე ნომერი 2.
 და თუ მინდა პოპ, რაც იმას ნიშნავს, რომ მინდა წაშლა
 ბოლო ელემენტს რომ დაემატა და დაბრუნების ღირებულება ელემენტს,
 პირველი, რაც მე უნდა შეამოწმოთ ის არის, რომ დასტის არ არის ცარიელი.
 რადგან თუ ეს ცარიელი, მე ვერ დაბრუნდებიან არაფერი.
 ამ შემთხვევაში, მე დაბრუნების -1.
 წინააღმდეგ შემთხვევაში, მე ვაპირებ decrement ზომა Spec,
 და დაბრუნების ნომრები (s.size).
 რატომ decrement ზომა და შემდეგ დაბრუნდნენ s.size?
 ეს იმიტომ, რომ, ამ შემთხვევაში, სპეც ზომის 4,
 და მინდა დაბრუნდეს მეოთხე ელემენტს, არა?
 მაგრამ რა არის ინდექსი მეოთხე ელემენტს? სამი.
 მას შემდეგ, რაც მე ზომა - იქნება 3, მე შემიძლია უბრალოდ დააბრუნოს s.numbers (s.size)
 იმიტომ, რომ ეს 3. ასე რომ, ეს უბრალოდ ინდექსი.
 

ახლავე რიგები. რიგები არის საკმაოდ ბევრი იგივე.
 ერთადერთი განსხვავება ის არის, რომ ნაცვლად, რომელმაც ბოლო წელს, პირველი out,
 თქვენ გაქვთ პირველი, პირველი გარეთ.
 ალბათ, თუ თქვენ ელოდება წასვლა კონცერტი,
 თქვენ არ იქნება ბედნიერი, თუ ჰქონდა დასტის ნაცვლად რიგიდან.
 Being ბოლო პირი მოსვლა იქნება პირველი პირი შესვლის კონცერტი.
 თქვენ ალბათ არ იქნებოდა ბედნიერი.
 მდგომ, პირველი პირი, მიიღონ ასევე პირველი პირი გავიდნენ.
 ასე რომ, ამ განმარტებას მდგომ, გარდა მქონე ზომის მასივი,
 თქვენ ასევე უნდა ჰქონდეს ხელმძღვანელი, რომელიც ინდექსი ხელმძღვანელს Stack.
 ამიტომ პირველ ელემენტს ახლა.
 Enqueue არის იგივე როგორც დააყენებს, stacks.
 თუ ძალიან გულუბრყვილო, თქვენ უბრალოდ, ვამბობთ,
 ასევე, მე შემიძლია უბრალოდ ზუსტად იგივე როგორც მე ბიძგი.
 მე შემიძლია მხოლოდ შეამოწმოთ, თუ ის არ სცილდება მოცულობა.
 თუ ეს არის, მე დაბრუნების ცრუ, წინააღმდეგ შემთხვევაში, მე შემიძლია მხოლოდ საექსპორტო ახალი ღირებულება
 და მაშინ ნამატი ზომა.
 მაგრამ რატომ არის ეს არასწორია?
 ვნახოთ ეს მაგალითი.
 ვცდილობ enqueue bunch პერსონალის,
 და შემდეგ მე ვაპირებ dequeue და enqueue.
 არსებობს ბევრი ბრძანებები, მაგრამ ეს ძალიან მარტივია.
 მე ვაპირებ enqueue 5, ისე დაამატოთ 5, შემდეგ კი 7,
 1, 4, 6, და მერე მინდა dequeue რაღაც,
 რაც იმას ნიშნავს, რომ მე ვაპირებ ამოიღონ პირველი ელემენტს.
 ამიტომ მე ვაპირებ ამოიღონ ნომერი 3, არა?
 პირველი ელემენტს. Okay.
 ახლა, თუ ვცდილობ enqueue რაღაც, რა მოხდება?
 ჩემი განხორციელების,
 მივდიოდი დააყენა შემდეგი ნომერი ინდექსის q.size.
 ამ შემთხვევაში, ზომა არის 8,
 ასე ინდექსი 8 იქნება სწორედ აქ, ბოლო პოზიცია.
 თუ ვცდილობ enqueue 1 სწორედ აქ, მე overwriting ბოლო თანამდებობა
 რაოდენობის 1, რომელიც სრულიად არასწორია.
 რა მინდა გავაკეთოთ არის გადაიტანოთ გარშემო და წასვლა პირველი პოზიცია.
 იქნებ, უბრალოდ, ვამბობთ, ასევე, მე უბრალოდ უნდა შეამოწმოს
 თუ შემიძლია რეალურად დააყენა რაღაც არსებობს.
 თუ არა, მე უბრალოდ, ვამბობთ, oh, ახალი სრული დატვირთვით
 რეალურად სიმძლავრე - 1, და ვერ დააყენა ელემენტს არსებობს.
 მაგრამ რა არის პრობლემა? პრობლემა ისაა, რომ თუ უბრალოდ dequeue ყველაფერი აქ
 და მერე ცდილობენ დაამატოთ რაღაც, რომ ის უბრალოდ, ვამბობთ,
 კარგად, თქვენ სრული დატვირთვით, რომელიც 0.
 ასე რომ თქვენი მდგომ გაქრა.
 თქვენ უნდა გადაიტანოთ გარშემო, და გზა შესაფუთი გარშემო
 რომ თქვენ ბიჭები შეიტყო ქმედითი და სხვა psets იყენებდა mod.
 შეგიძლიათ ცდილობენ სახლში მესმის, რატომ თქვენ ყველაფერს გააკეთებს q.size + q.head
 mod მოცულობა, მაგრამ თუ თქვენ შეამოწმოთ სწორედ აქ,
 ჩვენ ვხედავთ, რომ ის მუშაობს.
 ასე რომ, ბოლო მაგალითი, q.size იყო 8
 და ხელმძღვანელი იყო 1, რადგან ეს იყო ამ თანამდებობაზე აქ მასივი.
 ასე რომ, ეს იქნება 8 + 1, 9. Mod მოცულობა 9 იქნებოდა 0.
 იგი წავიდოდა ინდექსი 0. ჩვენ ვიქნებით სწორი პოზიცია. და მაშინ ცადეთ მდგომ სახლში.
 რამდენიმე მნიშვნელოვანი რამ: ცდილობენ ესმით განსხვავება დასტის და რიგიდან.
 სახლში, ცდილობენ ძალიან იცნობს განხორციელების enqueue, dequeue, ბიძგი და საესტრადო.
 და ასევე კარგად გვესმის, როდესაც თქვენ გამოიყენოთ თითოეული მათგანი.
 

მოდით მოდუნების 10 წამში ერთად bunch of Pokemons.
 და ახლა მოდით დავუბრუნდეთ მონაცემები სტრუქტურებში.
 Hash მაგიდები. ბევრი ადამიანი იყვნენ ეშინია hash მაგიდები.
 in პრობლემა კომპლექტი 6, Spell Checker.
 Hash მაგიდები და ცდილობს, ბევრი ხალხი შეშინებულია მათგანი.
 მათ მიაჩნიათ, რომ ისინი იმდენად რთული გასაგებია. ჰო?
 [Rob Bowden] პრობლემა კომპლექტი 5. 

პრობლემა მითითებული 5, yeah. Thanks Rob.
 ჰო. ექვსი იყო Huff n 'Puff, yeah.
 პრობლემა მითითებული 5 იყო მართლწერის შემოწმება, და თქვენ უნდა გამოიყენოთ hash მაგიდასთან ან ცდილობენ.
 ბევრი ადამიანი ფიქრობდა, რომ ისინი super ძნელი გასაგებია, მაგრამ ისინი რეალურად საკმაოდ მარტივია.
 რა არის hash table, ძირითადად? Hash table არის მასივი უკავშირდება სიები.
 ერთადერთი განსხვავება array და hash მაგიდა
 ის არის, რომ hash table თქვენ გაქვთ რაიმე მოუწოდა ქეშირების ფუნქცია.
 რა არის ქეშირების ფუნქცია?
 მე არ ვიცი თუ ბიჭები შეგიძლიათ წაიკითხოთ აქ.
 ეს არის მაგალითი იმისა, hash მაგიდასთან.
 ასე რომ, თქვენ ხედავთ, რომ თქვენ გაქვთ მასივი 31 ელემენტები.
 და რას ვაკეთებთ hash მაგიდა აქვს ქეშირების ფუნქცია
 რომ აპირებს თარგმნოს გასაღები, თითოეული int to ინდექსი.
 იმ შემთხვევაში, თუ, მაგალითად, თუ მინდა აირჩიოს B. ჰარისონი,
 მინდა დააყენა B. Harrison ჩემი hash ფუნქციები,
 და hash ფუნქცია დაბრუნდნენ 24.
 ასე რომ, მე ვიცი, რომ მინდა შესანახად B. Harrison 24.
 ასე რომ სხვაობაა მხოლოდ მქონე მასივი და მქონე hash მაგიდასთან.
 In hash მაგიდასთან თქვენ ფუნქცია რომ აპირებს გითხრათ,
 სადაც შესანახად მონაცემები, რომ გსურთ შეინახოთ.
 იყიდება ქეშირების ფუნქცია, გსურთ ვეძებთ ქეშირების ფუნქცია
 რომ არის deterministic და კარგად ნაწილდება.
 როგორც ხედავთ აქ, თქვენ ხედავთ, რომ უამრავი მონაცემები, რომ მინდოდა მაღაზია იყო, ფაქტობრივად, 19
 ნაცვლად გამოყენებით 31 და 30 და 29, რომლებიც ყველა უფასო.
 ამიტომ ქეშირების ფუნქცია, რომ მე გამოიყენება არ იყო ძალიან კარგად ნაწილდება.
 როდესაც ჩვენ ვამბობთ, კარგად ნაწილდება, ეს იმას ნიშნავს, რომ ჩვენ გვინდა,
 დაახლოებით, მინიმუმ 1 ან 2 თითოეული -
 მოსწონს, განსხვავება 1 ან 2 თითოეული ინდექსების მასივები.
 გსურთ აქვს, დაახლოებით, იგივე რაოდენობის ელემენტები თითოეულ უკავშირდება სიაში მასივი.
 და ადვილი, რათა შეამოწმოთ, თუ ის მართებული hash table, ნახოთ როგორც hash მაგიდები.
 

მაშინ ხეები. ეს არის ხე.
 ხეები კომპიუტერულ მეცნიერებაში არიან თავდაყირა რატომღაც.
 ასე რომ აქ თქვენ გაქვთ ხის ფესვი და შემდეგ ფოთლები.
 თქვენ უნდა მხოლოდ ვიცით ნომენკლატურა მშობლები და ბავშვი.
 თითოეული კვანძის აქვს თავისი ბავშვები, რომლებიც კვანძების, რომლებიც ქვემოთ მშობელი.
 ასე, მაგალითად, 2 იქნება მშობელი ამისთვის 3 და სხვა ბავშვის უფლება არსებობს,
 ხოლო 3 იქნება მშობელი 1 და სხვა ბავშვები რომ არსებობს.
 და 1 იქნება 3 შვილი, და ასე შემდეგ.
 ჩვენ გვაქვს რაღაც ბევრად უფრო საინტერესო, მოუწოდა ორობითი ძებნა ხე,
 რომელშიც ყველა ფასეულობებზე უფლება კვანძში
 ვაპირებთ იყოს მარჯვენა, სწორედ აქ - მარჯვენა
 ვაპირებთ, რომ იყოს მეტი ელემენტია root.
 ასე რომ, თუ მაქვს ნომერი 5 უფლება აქ, ყველა ელემენტები მარჯვენა
 იქნება უფრო მეტი, ვიდრე 5 და მარცხენა
 ყველა ელემენტების ვაპირებთ იყოს ნაკლები 5.
 რატომ არის ეს სასარგებლო?
 ისე, თუ მინდა შევამოწმო, თუ ნომერი 7 აქ, მაგალითად,
 მე უბრალოდ წასვლა 5 პირველი და მე ვაპირებ, რომ ნახოთ, 7 მეტი ან ნაკლები 5?
 ეს არის დიდი, ასე რომ მე ვიცი, რომ ის აპირებს უნდა იყოს უფლება ხე.
 ასე რომ, მე გაცილებით ნაკლები პერსონალის შევხედოთ.
 განხორციელებაში ორობითი ძებნა ხე, კვანძში, მე უბრალოდ აპირებს უნდა ჰქონდეს მონაცემები,
 ასე int n; თქვენ შეიძლება ასევე აქვს string
 ან არაფერი უნდოდა.
 თქვენ უბრალოდ უნდა ფრთხილად განსაზღვრის შესახებ, თუ რა არის უფრო, რა ნაკლებად.
 ასე რომ, თუ თქვენ გქონდათ სიმები, მაგალითად, თქვენ შეიძლება განსაზღვროს
 რომ ყველა იმ რამ, მარჯვენა ვაპირებთ აქვს უფრო დიდი სიგრძის,
 მარცხენა ვაპირებთ აქვს ქვედა lengths, ამიტომ ნამდვილად თქვენზეა.
 

როგორ შემიძლია განახორციელოს მოვძებნოთ BST?
 პირველი, რაც ჩვენ უნდა გავაკეთოთ არის შეამოწმოს თუ root არის NULL.
 თუ ეს NULL, ეს ნიშნავს, რომ ის იქ არ არის
 იმიტომ, რომ თქვენ კი არ ხე, არა?
 ასე რომ, მე დაბრუნების ცრუ.
 წინააღმდეგ შემთხვევაში, მე ვაპირებ შეამოწმოს თუ ნომერი მეტი
 მეტი ღირებულების root.
 მე ვაპირებ ცდილობენ იპოვონ ელემენტს მარჯვენა
 ხე.
 თქვენ ხედავთ, რომ მე გამოყენებით უკან აქ.
 ხოლო შემდეგ, თუ ეს ნაკლებად, მე ვაპირებ შევხედოთ მარცხენა.
 და ბოლოს, წინააღმდეგ შემთხვევაში, თუ ეს არ არის ნაკლებად ან საერთოდ არ მეტი,
 ეს იმას ნიშნავს, რომ ის ღირებულება თავისთავად.
 ასე რომ, მე უბრალოდ დააბრუნოს ჭეშმარიტი.
 ხედავთ აქ, რომ მე გამოიყენება, თუ, თუ, თუ.
 და მახსოვს, ამ ვიქტორინაში 0, გვქონდა პრობლემა რომ ჰქონდა, თუ, თუ, თუ,
 და თქვენ უნდა იპოვოთ არაეფექტურობას,
 და არაეფექტურობა იყო, რომ თქვენ გამოიყენება, თუ. თქვენ უნდა გამოეყენებინა თუ სხვაგან, თუ სხვაგან, თუ და სხვა.
 ასე რომ, უნდა გამოვიყენო სხვაგან, თუ სხვაგან, თუ სხვაგან აქ?
 ვინმეს - Yeah?
 [სტუდენტური მოლაპარაკე, inaudible]
 რომ სრულყოფილი. ასე რომ, მან განაცხადა, რომ არ აქვს მნიშვნელობა,
 მხოლოდ იმიტომ არაეფექტურობა, რომ ჩვენ გვქონდა ადრე
 ის იყო, რომ იმის გამო, რომ, შესაძლოა, თუ გარკვეული მდგომარეობა დაკმაყოფილდა,
 ასე რომ თქვენ არ შესრულდა ქმედება, მაგრამ მაშინ აპირებს შეამოწმოს ყველა სხვა პირობები.
 მაგრამ ამ შემთხვევაში, იგი დაბრუნდა დაუყოვნებლივ, ასე რომ მნიშვნელობა არ აქვს.
 ასე რომ თქვენ არ უნდა გამოიყენოთ სხვაგან თუ.
 

და ბოლოს, მოდით ვისაუბროთ ლელო,
 რომელიც ყველას საყვარელი.
 ლელო არის ხე მასივები.
 ეს ძალიან სწრაფად გამოიყურებოდეს up ღირებულებები, მაგრამ იგი იყენებს მეხსიერების დიდ ნაწილს.
 და ეს, როგორც წესი, რათა გავფილტროთ სიტყვა, ასე რომ, როდესაც თქვენ
 სურთ განახორციელონ, მაგალითად, მე არ ვიცი, ისევე როგორც სატელეფონო წიგნი თქვენი ტელეფონი
 და გსურთ შეძლებს აკრიფოთ B
 და უბრალოდ სახელები ადამიანები, რომლებიც B.
 ძალიან ადვილია განსახორციელებლად რომ გამოყენებით ცდილობენ, მაგალითად.
 როგორ განვსაზღვროთ node in ლელო?
 თქვენ უბრალოდ უნდა ჰქონდეს bool, რომ აპირებს is_word.
 რომელიც წარმოადგენს, რომ ყველა პერსონაჟი მანამდე კვანძის,
 თქვენ შეუძლია შექმნას ერთი სიტყვით,
 და მაშინ გვექნება მასივი მითითებას კვანძების.
 ხედავთ, რომ ჩვენ გვყავს მასივი მშობელი კვანძების, ასე რომ კვანძის * მასივი? ჰო?
 მოდით ვნახოთ, როგორ იმუშავებს. განთავსების მართლწერის შემოწმება,
 ჩვენ მასივი 27 ელემენტები,
 რადგან ჩვენ გვაქვს ყველა წერილი plus აპოსტროფი.
 ადრე აქ მე უბრალოდ აპირებს გამოიყენოს 2 რადგან მინდა შეძლონ წერა ფორუმში.
 Okay. ასე რომ, ეს არის მაგალითი იმისა, ცდილობენ.
 თუ უბრალოდ განსაზღვროს პირველი კვანძი, მე გვექნება მასივი 2 ელემენტები
 რომლებიც 2 მითითებას NULL, ამიტომ მე უბრალოდ დააყენა "ა" და "ბ".
 და მე ვაპირებ აქვს bool რომ ამბობს is_word.
 ეს იქნება ყალბი პირველი,
 მხოლოდ იმიტომ, რომ, ადრე, რომ თქვენ არ აქვს არც ერთი სიმბოლო.
 ასე რომ ცარიელი სიტყვა არ არის სიტყვა. ასე რომ, ეს სიცრუეა.
 იმ შემთხვევაში, თუ მინდა დაამატოთ 'a' ამ ლექსიკონი, რა უნდა გავაკეთო?
 მე უბრალოდ უნდა malloc ახალი კვანძის for "ა",
 და შემდეგ დაამატოთ თავისი სიტყვა ჭეშმარიტი.
 ასე რომ, ეს უბრალოდ წარმოადგენს, რომ მას "ა" იქნება ჭეშმარიტი. აზრი?
 თუ მინდა დაამატოთ 'ba', მე უნდა malloc 1 "ბ",
 და შემდეგ მე ვაპირებ შეიქმნა ლოგიკური ცრუ,
 იმის გამო, რომ "ბ" თავისთავად არ არის სიტყვა.
 მაშინ მე ვაპირებ malloc კიდევ ერთი "ა", ისე "ba ',
 და შემდეგ მე ვაპირებ შეიქმნა ეს სიტყვა ჭეშმარიტი.
 რადგან "ა" არის სიტყვა.
 და მაშინ თუ მინდა, რომ თუ "ბ" არის ამ ლექსიკონი,
 შემიძლია უბრალოდ წასვლა პირველი, "ბ". მე ქვევით, და მე შევხედოთ არის სიტყვა, და ეს ამბობს, სიცრუეა.
 ასე რომ, ეს არ არის სიტყვა. იმ შემთხვევაში, თუ მინდა შევამოწმო 'ba',
 მე წასვლა პირველი, "ბ", შემდეგ კი "ა", და მე ვხედავ ასეა, ასე, რომ ეს არის სიტყვა. აზრი?
 ბევრი ადამიანი დაბნეული ლელო. არა?
 

საბოლოოდ, Huffman კოდირების. Huffman კოდირების არის ძალიან სასარგებლო,
 გადარჩენა მეხსიერება და შეკუმშოს ტექსტური ფაილი,
 მხოლოდ იმიტომ, რომ ბევრი ჯერ თქვენ გამოიყენოს "ა" და "ე", მაგალითად,
 თქვენი დოკუმენტები, მაგრამ არ ვიცი თუ ბიჭები გამოიყენოთ 'Q' ან 'z' იმდენი.
 რომელსაც მხოლოდ 1 byte თითოეული ხასიათი,
 თითოეული - 256 სიმბოლო, რომ გვაქვს ASCII მაგიდასთან არ არის ძალიან ოპტიმალური,
 მხოლოდ იმიტომ, რომ არსებობს გარკვეული სიმბოლოების, რომ თქვენ გამოიყენოთ გაცილებით მეტი,
 ასე რომ თქვენ უნდა ალბათ გამოიყენოს ნაკლები მეხსიერების იმ.
 როგორ უნდა გამოვიყენო Huffman კოდირების?
 ჩვენ უნდა გავაკეთოთ Huffman ხე.
  Huffman ხე აქვს კვანძების
 რომ აქვს სიმბოლო, რომ აპირებს იყოს, "ა", "ბ", "გ", წერილი,
 რასაც წერილი გაქვთ, სიხშირე, რომ არის სიხშირე, რომ სიტყვა ჩნდება ტექსტი
 რომ თქვენ შექმნაში Huffman ხე,
 და შემდეგ კვანძის რომ აპირებს აღვნიშნო, რომ მარცხნივ Huffman ხე
 და კიდევ ერთი კვანძის რომ აპირებს აღვნიშნო უფლება. ასე რომ, ისევე, როგორც ხე.
 როგორ უნდა ავაშენოთ Huffman ხე?
 თქვენ აპირებს აირჩიოთ 2 კვანძების რომ აქვს ყველაზე დაბალი სიხშირეები.
 თუ თქვენ გაქვთ ჰალსტუხი თქვენ აპირებს აირჩიოთ 2 კვანძების
 რომ აქვს ყველაზე დაბალი ASCII ღირებულებები ისევე.
 მაშინ თქვენ აპირებს, რათა შეიქმნას ახალი ხე აქედან 2 კვანძების
 რომ აპირებს აქვს კომბინირებული სიხშირით მშობელი კვანძი.
 და მაშინ თქვენ აპირებს ამოიღონ 2 ბავშვები ტყეში
 და შეცვლის მათ მშობელს.
 და თქვენ ვაპირებთ გავიმეორო, რომ სანამ თქვენ მხოლოდ 1 ხე ტყეში.
 მოდით ვნახოთ, თუ როგორ გავაკეთოთ Huffman ხე Zamyla.
 თქვენ ხედავთ, რომ ყველა წერილი აქვს სიხშირე 1 გარდა 'A', რომელსაც აქვს სიხშირე 2.
 ასე რომ, მე შექმნილი კვანძების ყველა წერილებს მე ზუსტად მიზნით ASCII ღირებულება და სიხშირე.
 ასე რომ, თუ მინდა, რომ შევქმნათ პირველი ხე, ეს იქნება 'L "და" M ".
 ასე რომ აქ. სიხშირე წყვილი იქნება 2
 იმიტომ, რომ 1 + 1, მაშინ შემდეგი 2 ყველაზე დაბალი სიხშირეების არიან 'Y' და 'Z'.
 და მაშინ მე ყველა მათგანს - აქვს სიხშირე 2.
 ასე რომ რაც პირობა არის პირობა, რომ აქვს ყველაზე დაბალი ASCII ღირებულება მომავალი ერთი?
 'A' და 'L'. ასე რომ, მე შეიქმნას ახალი კვანძის,
 და ბოლოს, ეს 4 და 2, ასე რომ 2 იქნება მარცხენა.
 და ეს არის Huffman ხე. თუ მინდა დაწერა რაიმე ტექსტი,
 როგორც ორობითი კონვერრტაციისთვის ტექსტი გამოყენებით Huffman ხე ძალიან მარტივია.
 მაგალითად, თუ მე ვიტყვი, რომ გადასვლის მარცხენა არის 0 და გადასვლის უფლება არის 1,
 რა არის, რომ აპირებს წარმოადგენს?
 ასე რომ 1, 1, ასე რომ უფლება, უფლება,
 და მაშინ 0, ასე რომ მარცხენა იქნებოდა L, და შემდეგ 1, 0, 0.
 ასე რომ, 1, 0, ასე რომ მხოლოდ 1, 0, 'A'.
 და მაშინ 0, 1, ასე რომ 'Z'.
 და შემდეგ 1, 0, 0 - არა.
 0, 0 იქნება "Y", ასე Lazy.
 ასე რომ ყველა ჩემთვის, რობ აპირებს მეტი.
 

[Rob Bowden] ასე რომ, week 7 პერსონალი.
 ჩვენ მივიღეთ ბევრი წასვლა მართლაც სწრაფი.
 Bitwise ოპერატორები, ბუფერული overflow,
 CS50 ბიბლიოთეკაში, მაშინ HTML, HTTP, CSS.
 ყველა მსგავსად 15 დან 20 წუთის განმავლობაში.
 Bitwise ოპერატორები. არსებობს 6 მათგანი, რომ თქვენ უნდა იცოდეთ.
 Bitwise და bitwise ან, XOR, მარცხენა ცვლა, მარჯვენა ცვლა, და არა.
 მარჯვენა Shift და არა თქვენ ძლივს ვნახე ლექცია ყველა.
 ჩვენ წავიდეთ მეტი იგი სწრაფად, მაგრამ კარგია, რომ ვიცით, რომ ეს არის 6 რომ არსებობს.
 გახსოვდეთ, რომ bitwise ოპერატორები არიან როგორც, როდესაც თქვენ 3 + 4.
 თქვენ არ საქმე ორობითი 3 და 4.
 With bitwise ოპერატორების თქვენ რეალურად საქმე ინდივიდუალურ ბიტი ნომრები 3 და 4.
 

ასე რომ, პირველი, რომ ჩვენ ვთქვათ, არის bitwise არ,
 და ყველა ის არ არის Flip ყველა ბიტი.
 ასე რომ აქ, თუ თქვენ წერა ამ დო, თქვენ არ დაწერა
 როგორც ~ 11011 ან რასაც, თქვენ ამას წერენ მას მოსწონს ~ 4,
 და მაშინ flip ორობითი წარმომადგენლობა 4.
 ასე რომ აქ, ~ ზოგიერთი ბინარული ნომერი 1101101 აპირებს ზუსტად Flip ყველა 1 ს 0 და ყველა 0 ს 1 ს.
 როგორც მე ვიტყვი, იქ, ხშირი გამოყენების შემდეგ,
 და ვნახავთ, ეს ცოტა არ არის, როგორც ჩვენ გვინდა ამუშავება ზოგიერთი ნომერი
 სადაც ყველა ბიტი არის 1, გარდა ერთი მათგანი.
 ასე რომ, როგორც წესი, უფრო ადვილია გამოვხატო ნომერი
 სადაც მხოლოდ, რომ ერთი bit არის მითითებული,
 და შემდეგ მიიღოს ~, ასე რომ ყველა სხვა bit არის მითითებული გარდა, რომ ერთი.
 ასე რომ, ის, რასაც ჩვენ ვაპირებთ გამოვიყენოთ უფრო ცოტა.
 

Bitwise ან. აქ არის 2 ორობითი რიცხვი და ამ 2 ნომრები
 საკმაოდ წარმომადგენლობითი, რადგან ისინი წარმოადგენენ ყველა შესაძლო
 კომბინაცია ბიტი თქვენ შეიძლება უნდა მოქმედებს.
 აქ, როცა მე or'd თითოეული bit, ჩვენ უბრალოდ აპირებს შედარების სწორი ქვემოთ.
 ასე რომ მარცხენა მხარეს გვაქვს 1 და 1.
 როდესაც მე bitwise | მათ, რა ვარ მე აპირებს მიიღოს? ერთი.
 მაშინ bitwise | 0 და 1 აპირებს მომეცი? ერთი.
 Bitwise 1 და 0 იქნება იგივე, ერთი.
 Bitwise 0 | 0 აპირებს მომეცი 0.
 ასე რომ ერთადერთი შემთხვევა, როდესაც მივიღებ 0 არის 0 | 0 შემთხვევაში.
 და შეგიძლიათ წარმოიდგინოთ, რომ, ისევე, როგორც თქვენი ლოგიკური ORS.
 ასე რომ, თუ ფიქრობთ 1 როგორც ჭეშმარიტი და 0 როგორც ყალბი, იგივე ეხება აქ.
 ამიტომ ჭეშმარიტი ან ნამდვილი მართალია, ჭეშმარიტი ან მცდარი მართალია.
 ყალბი ან ნამდვილი მართალია, ყალბი ან მცდარი არის ერთადერთი, რაც რეალურად ყალბი.
 აი, მაგალითად, რომ თქვენ უნდა იცოდეს,
 როგორც საკმაოდ კარგი მაგალითია, როდესაც bitwise ოპერატორები გამოიყენება.
 აქ თუ ჩვენ ან კაპიტალის "ერთად Ox20,
 და ჩვენ შევხედოთ ამ მეორე, მივიღებთ რაღაც.
 და თუ ჩვენ, ან ამას "ერთად Ox20, მივიღებთ რაღაც.
 მოდით დახევის up ASCII მაგიდასთან.
 Okay. აქ ჩვენ ვხედავთ, რომ 'A' არის -
 აქ ჩვენ გვაქვს 'A' არის ათობითი 65.
 მაგრამ მე წასვლა თექვსმეტობითი, რომელიც Ox41.
 დარწმუნებული ვარ, ჩვენ ვნახეთ, რომ კლასი. ვფიქრობ, ჩვენ ვნახეთ, რომ კლასი
 რომ ეს საკმაოდ ადვილი დააკონვერტიროთ საწყისი თექვსმეტობითი ორობითი.
 ასე რომ აქ, თუ მინდა დააყენა 4 შევიდა ორობითი,
 ეს მხოლოდ იქნება 0100.
 ეს არის 1 ადგილი 2 ადგილი, 4 ის ადგილი, ასე რომ ეს არის 4.
 მერე შეგიძლიათ გაყოფილი 1 შევიდა ორობითი, რომელიც იქნება 0001.
 და ეს იქნება წარმომადგენლობა 'A' ორობითი.
 Taking ამას "ა", ის ახლა იქნება Ox61,
 სადაც, გაყოფა ამ up შევიდა მისი ორობითი, ასე რომ 6 -
 მოდით რეალურად გაკეთება - იქ არ საშლელი? Eraser.
 Ox61. ასე გაყოფა 6 შევიდა ორობითი იქნება 0 + 4 + 2 + 0.
 და გაყოფა 1 იქნება 0001.
 ეძებს განსხვავება ამ 2,
 ჩვენ ვხედავთ, რომ მხოლოდ განსხვავება ამას და კაპიტალის 'A' ეს ერთჯერადი bit.
 ასე ბრუნდება აქ - okay.
 ბრუნდება აქ, თუ დავაკვირდებით, რა ცოტა Ox20 არის,
 ასე გაყოფა Ox20 მის ორობითი,
 არის 0010, 0000.
 Ox20, მხოლოდ ცოტა რომ არის ეს bit, რომ ჩვენ დაინტერესებული,
 გადართვის შორის კაპიტალი და ამას 'a'.
 თუ მე ან 'A', რომელიც ამ ერთი, 'A',
 თუ მე ან "ერთად Ox20,
 რა ვარ მე აპირებს მიიღოს?
 [სტუდენტი inaudible] 

მხედრულ "ა", იმიტომ, რომ ის აპირებს Flip ამ მწირი 1.
 და თუ მე ან "ერთად Ox20, რა ვარ მე აპირებს მიიღოს?
 ამას, იმიტომ, რომ მხოლოდ Oring "ა" ერთად Ox20,
 მე უბრალოდ უნდა Oring ამ ერთი მწირი 1, ეს უკვე 1, ასე რომ მნიშვნელობა არ აქვს.
 ამიტომ ჩვენ კიდევ "ა" და "ა".
 

Bitwise და. ისევ და ისევ, ჩვენ შეგვიძლია ვიფიქროთ, რომ ეს ჩვენი ლოგიკური და კოლეგას.
 მარცხენა მხარეს ჩვენ გვყავს ჭეშმარიტი და მართალია.
 ეს იქნება ჭეშმარიტი, და ყველა შემთხვევაში,
 ცრუ და ჭეშმარიტი ან ნამდვილი და ყალბი, ან ცრუ და ყალბი,
 არც იმ რამ არის ჭეშმარიტი.
 მერე რა ჩვენ დასრულდება მდე მიღების 1000.
 ახლა, აქ, აქ, სადაც მე გამოიყენება სანდო bitwise არ,
 სადაც ჩვენ გვქონდა Ox20. ასე რომ, ეს Ox20.
 ახლა რა მინდა, bitwise ~ საქართველოს Ox20.
 რომ აპირებს Flip ყველა ბიტი.
 ასე რომ, მე მაქვს 1101, 1111.
 და ასე 'A' anded დავუკავშირდეთ ~ Ox20 აპირებს მომეცი რა?
 მხოლოდ ცოტა ჩვენ ნამდვილად უნდა ვიფიქროთ, ეს ერთი,
 რადგან, თუ ყველა ამ ბიტი დაყენებულია 1,
 მაშინ ჩვენ ვაპირებთ, რომ მიიღოთ ზუსტად ის, რაც 'A' იყო,
 გარდა, შესაძლოა, რა ამ ცოტა არის.
 რადგან თუ ეს იყო 1, ახლა ის აპირებს იყოს მითითებული 0,
 რადგან ყველაფერი ეს არის, anded ამ იქნება 0.
 რა არის 'A' და ~ Ox20 აპირებს მომეცი?
 [სტუდენტები პასუხი, inaudible] 

რა არის "ა" და - ის 'A'.
 და რა არის "ა" და ~ Ox20 აპირებს მომეცი?
 'ა' იმიტომ, რომ ეს არის გაკეთებული 1.
 Anding ამ 0 აპირებს, რათა ის 0,
 და ახლა ჩვენ ვაპირებთ, რომ მიიღოთ 'A'.
 

ორივე 'A' და ბოლო, მაგრამ არანაკლებ ამ ტიპის,
 ჩვენ XOR. ეს ძალიან ჰგავს, ან,
 გარდა ეს ნიშნავს მხოლოდ ან.
 ეს არის მსგავსი იმისა, რაც ჩვეულებრივ ფიქრობენ, როგორც ან რეალურ სამყაროში.
 ასე რომ თქვენ ან 'x' ან 'y', მაგრამ არა ორივე.
 აქ 1 ^ 1 იქნება 0.
 იმის გამო, რომ მართალია, ეს - ეს არ მუშაობს ასევე ლოგიკური ჭეშმარიტი და ყალბი
 როგორც bitwise & და ან არ,
 მაგრამ ჭეშმარიტი ^ ჭეშმარიტი არის ყალბი.
 იმის გამო, რომ ჩვენ მხოლოდ გვინდა TRUE თუ მხოლოდ ერთი მათგანი არის ჭეშმარიტი.
 ამგვარად 1 ^ 1 არის 0. რაც შეეხება 0 ^ 1?
 არის 1. 1 ^ 0 არის 1, 0 ^ 0 არის 0.
 ასე ქვეშ ყველა გარემოება, 0 bitwise რაღაც 0 იქნება 0.
 1 bitwise რაღაც 0 ან 0 bitwise 1,
 თუ ის | ან ^, ეს იქნება 1, და თუ ის და ეს იქნება 0.
 და ერთადერთი შემთხვევა სადაც 1 bitwise 1 არ არის 1 არის ექსკლუზიური ან.
 ეს არის ის, 0110.
 ასე რომ, აქ არის, გამოყენებით XOR - ასე ჩვენ უკან 20.
 'A' ^ Ox20 არის ამ 2 ბიტი ჩვენ შედარებით.
 ასე რომ 1 ^ 0 აპირებს მომეცი რა? ერთი.
 'A' ^ Ox20 აპირებს მომეცი? მხედრულ.
 'A' ^ Ox20 აპირებს მომეცი? კაპიტალური ა
 იმის გამო, რასაც ეს აკეთებს, ამ XORing ერთად Ox20
 ეფექტურად flipping რასაც ამ ცოტა არის.
 იმ შემთხვევაში, თუ ეს არის 0, ის ახლა აპირებს გახდეს 1.
 რადგან ეს არის 1, 1 ^ 1 არის 0.
 ასე რომ, ჩვენი 'a' გახდა 'A', და ჩვენი 'A' გახდა 'a'.
 ასე XOR არის მართლაც მოსახერხებელი გზა უბრალოდ flipping შემთხვევაში.
 გსურთ iterate მეტი სიმებიანი წერილები
 და ალტერნატიული შემთხვევაში თითოეული ხასიათი,
 უბრალოდ XOR ყველაფერი Ox20.
 

ახლა ჩვენ არ დაუტოვებიათ ცვლა. მარცხენა ცვლა მხოლოდ აპირებს, ძირითადად,
 დააყენებს ყველა ციფრები შევიდა, ან მარცხნივ, და ჩადეთ 0 ს მათ უკან.
 ასე რომ აქ გვაქვს 00001101.
 ჩვენ ვაპირებთ დააყენებს 3 0 ს, მარჯვენა ფლანგიდან
 და მივიღებთ 01101000.
 In nonbinary თვალსაზრისით,
 ჩვენ ვხედავთ, რომ მართლაც საქმე 13 მარცხენა გადაინაცვლებს 3, რომელიც გვაძლევს 104.
 ასე რომ მარცხნივ გადავიდა, ჩვენ ვხედავთ აქ, x << y ძირითადად x * 2 ^ y.
 13 * 2 ^ 3, 2 ^ 3 არის 8, ასე 13 * 8 104.
 თუ თქვენ უბრალოდ ვიფიქროთ ორობითი ზოგადად, როგორ თითოეული ციფრი,
 თუ ჩვენ დავიწყებთ, მარჯვენა ეს 1 ადგილს, მაშინ 2 ის ადგილი, მაშინ 4 ის ადგილი.
 ასე ავლით in 0 ს, მარჯვენა ფლანგიდან
 ჩვენ უბრალოდ უბიძგებს რამ, რომ იყო 4 ის ადგილი, რათა 8 ის ადგილი,
 და რაც იყო 8 ის ადგილი 16 ადგილი.
 თითოეული ცვლა მხოლოდ multiplies მიერ 2. ჰო?
 [სტუდენტი] რა მოხდება თუ გადავიდა მიერ 5?
 [Bowden] თუ გადავიდა მიერ 5 თქვენ უბრალოდ დაკარგავს თანრიგისაგან.
 აუცილებლად, ეს იგივე. მსგავსად, რიცხვებით მხოლოდ 32 ბიტი,
 ასე რომ, თუ თქვენ დაამატოთ 2 მართლაც დიდი რიცხვებით, ეს უბრალოდ არ შეესაბამება რიცხვი.
 ასე რომ იგივე აქ. თუ გადავიდა 5,
 ჩვენ უბრალოდ დაკარგავს, რომ ერთი.
 და რომ სახის რას ვგულისხმობ "უხეში"
 აქ თუ გადაეტანა ძალიან შორს, აგებთ ბიტი.
 

მარჯვენა Shift იქნება, პირიქით,
 სადაც ჩვენ ვაპირებთ shove 0 ს off ბოლოს,
 და ჩვენი მიზნებისთვის, შეავსოთ 0 ნახვა მარცხნიდან.
 ასე რომ, ამით, ჩვენ ძირითადად უკუქცევის რაც ჩვენ უკვე გავაკეთეთ.
 და ჩვენ ვხედავთ, რომ სამი 0 ს მარჯვენა ახლახანს დაეცა off,
 და ჩვენ მივიღებთ 1101 ყველა გზა უფლება.
 ამ აკეთებს 104 

3, რომელიც, პრაქტიკულად, x / 2 ^ y.
 ახლა, აქ, ეს მსგავსი იდეა.
 რატომ არის მხოლოდ დაახლოებით x / 2 ^ y, და არა რეალურად x / 2 ^ y?
 იმიტომ, რომ თუ მე გადაინაცვლებს 4, მე არ დაკარგა 1.
 ძირითადად, რა ფიქრობთ, უბრალოდ ვფიქრობ მთელი სამმართველოს კულტურას.
 ასე რომ, ისევე როგორც 5/2 2. ეს არ არის 2.5.
 ეს იგივე იდეა აქ. როდესაც ჩვენ გავყოთ 2,
 ჩვენ შეიძლება დაკარგოს უცნაური ბიტი გასწვრივ გზა.
 ასე რომ, ახლა - ეს ის bitwise. ეს ყველაფერი თქვენ უნდა იცოდეთ.
 დამახსოვრება გამოყენების შემთხვევაში ჩვენ ვნახეთ კლასში,
 მოსწონს bit ნიღაბი არის სასარგებლო bitwise ოპერატორები,
 ან თქვენ მათი გამოყენება bit ნიღბები.
 ასოებით და ამას წერილები, კონვერტაციის არის საკმაოდ prototypical მაგალითი.
 

Okay, ასე რომ ბუფერული overflow თავდასხმები.
 ვინმეს გახსოვთ რა იყო არასწორი, რომელზეც ეს ფუნქცია?
 გაითვალისწინეთ განვუცხადეთ მასივი 12 ბაიტი, 12 სიმბოლო,
 და მაშინ ჩვენ კოპირება ჩვენს ბუფერული of 12 chars მთელი სიმებიანი ბარი. რა პრობლემა აქ?
 ჯადოსნური ნომერი 12 უნდა საკმაოდ ბევრი დაუყოვნებლივ პოპ out როგორც - რატომ 12?
 რა მოხდება, თუ ბარი ხდება, რომ იყოს მეტი 12 გმირები?
 რა მოხდება, თუ ბარი არის მილიონობით გმირები?
 აქ საკითხი memcpy. თუ ბარი არის ხანგრძლივი საკმარისი,
 ეს იქნება მხოლოდ მთლიანად - "გ", "დ" არ აღელვებს, რომ ეს იყო მხოლოდ 12 სიმბოლო;
 'C' არ აღელვებს, რომ მას არ შეუძლია მოერგოს რომ ბევრი bytes.
 ის უბრალოდ სრულიად გადავაწერო char, 12 ბაიტი ჩვენ გამოყოფილი ის,
 და ყველაფერი წარსულში იგი მეხსიერებაში, რომ ფაქტობრივად არ ეკუთვნის, რომ ბუფერული
 რასაც სიმებიანი ბარი.
 ასე რომ, ეს იყო სურათზე ვნახეთ კლასში
 სადაც ჩვენ გვაქვს ჩვენი დასტის იზრდებოდა.
 თქვენ უნდა იყოს გამოყენებული ეს სურათები ან გაეცნოს მათ კიდევ ერთხელ.
 ჩვენ ჩვენი დასტის იზრდებიან, მეხსიერების მისამართები იწყება 0 ზედა
 და იზრდება ქვემოთ მინდა 4 მილიარდი ბოლოში.
 ჩვენ გვაქვს ჩვენი array 'c' სადღაც მეხსიერებაში,
 მაშინ ჩვენ გვაქვს ჩვენი მომცეთ ბარიერი უფლება ქვევმოთ იგი,
 და მაშინ ჩვენ ამ შენახული კარკასი მაჩვენებელი ჩვენი დაბრუნების მისამართი და ჩვენი მშობელი რუტინული მიერ Stack.
 მახსოვს რა დაბრუნების მისამართი?
 ეს მაშინ, როდესაც მთავარ მოუწოდებს ფუნქცია foo, მოუწოდებს ფუნქცია ბარი,
 აუცილებლად, ბარი ბრუნდება.
 ასე რომ, როდესაც ბარი ანაზღაურება, მათ უნდა იცოდნენ, რომ ის ბრუნდება foo რომ უწოდა.
 ასე რომ, დაბრუნების მისამართი მისამართი ფუნქცია, რომ მას აქვს დაბრუნებას როდესაც ფუნქცია დააბრუნებს.
 იმ მიზეზით, რომ მნიშვნელოვანია ბუფერული overflow თავდასხმები იმიტომ, მოხერხებულად,
 ჰაკერები მინდა რომ შეიცვალოს, რომ დაბრუნების მისამართზე.
 იმის ნაცვლად, რომ ბრუნდება foo, მე ვაპირებ დაბრუნდეს იქ, სადაც hacker სურს ჩემგან დაბრუნდეს.
 და მოხერხებულად, სადაც hacker ხშირად უნდა დაბრუნდეს
 არის დაწყების ბუფერული რომ ჩვენ თავდაპირველად ჰქონდა.
 ასე რომ შეამჩნია, კიდევ ერთხელ, პატარა Indian.
 ელექტრო არის მაგალითი პატარა ინდური სისტემით,
 ასე მთელი რიცხვი ან კურსორი ინახება ერთად bytes საპირისპიროა.
 ასე რომ, აქ ჩვენ ვხედავთ, - არის ეს? ჰო.
 ჩვენ ვხედავთ Ox80, OxC0, Ox35, OxO8.
 დამახსოვრება თექვსმეტობითი ციფრები?
 ჩვენ არ შეცვალოს თექვსმეტობითი ციფრები პატარა ინდური,
 რადგან 2 თექვსმეტობითი ციფრები შეადგინოს ერთი ბაიტი, და ჩვენ დავამარცხებთ bytes.
 ამიტომ, ჩვენ არ შესანახად, როგორიცაა, 80530CO8.
 ჩვენ ვინახავთ, ამის ნაცვლად, თითოეული წყვილი 2 ციფრით, დაწყებული უფლება.
 რომ მისამართი ეხება მისამართი დაწყება
 ჩვენი ბუფერული რომ ჩვენ რეალურად სურდა კოპირება შევიდა პირველ რიგში.
 იმ მიზეზით, რომ სასარგებლო არის, რადგან, თუ თავდამსხმელი
 მოხდა, ნაცვლად, რომელმაც სიმებიანი რომ იყო
 უვნებელია სიმებიანი მოსწონს, მათი სახელი ან რამე,
 რა, თუ, ნაცვლად, რომ სიმებიანი იყო რამოდენიმე თვითნებური კოდი
 გააკეთა, რასაც უნდოდა ამის გაკეთება?
 ასე რომ მათ შეეძლოთ - ვერ ვფიქრობ ნებისმიერი cool კოდი.
 ეს შეიძლება იყოს არაფერს, თუმცა. ნებისმიერი საშინელი კოდი.
 თუ უნდოდათ, მათ შეეძლოთ მხოლოდ რაღაც ეტაპზე seg ხარვეზებით, მაგრამ ეს იქნება უაზრო.
 ისინი როგორც წესი, მას hack თქვენს სისტემაში.
 

Okay. CS50 ბიბლიოთეკაში.
 ეს, ძირითადად, GetInt, GetString, ყველა იმ ფუნქციებს ჩვენ გათვალისწინებული თქვენ.
 ასე რომ, ჩვენ char * სიმებიანი, და ეს აბსტრაქცია რომ ჩვენ ააფეთქეს მოშორებით
 რაღაც მომენტში დროს სემესტრში.
 გახსოვდეთ, რომ სიმებიანი მხოლოდ მასივი სიმბოლო.
 ასე რომ, აქ ჩვენ ვხედავთ შემოკლებული ვერსია GetString.
 თქვენ უნდა ვიხსენებთ მას ახსოვს, თუ როგორ ეს რეალურად განხორციელდება.
 ძირითადი დეტალები შეამჩნევთ, მივიღებთ ერთ ხასიათი დროს
 სტანდარტული წელს, რომელიც, ისევე, როგორც ჩვენთვის აკრეფის დროს კლავიატურაზე.
 ასე რომ, ერთი ხასიათი დროს, და თუ ჩვენ კიდევ ძალიან ბევრი პერსონაჟი,
 ასე რომ, თუ n + 1 მეტია მოცულობა,
 მაშინ ჩვენ უნდა ტევადობის გაზრდისა ჩვენი ბუფერული.
 ასე რომ აქ ჩვენ გააორმაგოს ზომა ჩვენი ბუფერული.
 და რომ ინახავს აპირებს, ჩვენ ჩადეთ ხასიათი ჩვენს ბუფერული
 სანამ მივიღებთ ახალი ხაზი ან ფაილის დასასრულს ან რასაც,
 ამ შემთხვევაში, ჩვენ გაკეთდეს სიმებიანი და შემდეგ რეალურ GetString
 აარიდოს მეხსიერება, მოსწონს თუ ჩვენ გამოყოფილი ძალიან ბევრი მეხსიერების ის დავბრუნდებით და shrink bit.
 ასე რომ, ჩვენ არ ჩანს, მაგრამ მთავარი იდეა არის
 მას აქვს წაკითხვის ერთი ხასიათი დროს.
 მას არ შეუძლია უბრალოდ წაიკითხა მთელი რამ ერთბაშად,
 რადგან მათი ბუფერულ არის მხოლოდ გარკვეული ზომით.
 ასე რომ, თუ სიმებიანი, რომ ცდილობს ჩადეთ ბუფერული არის ძალიან დიდი, მაშინ overflow.
 ასე რომ აქ ჩვენ იმისთვის, რომ მხოლოდ კითხულობს ერთ ხასიათი
 დროს და მზარდი როდესაც ჩვენ გვჭირდება.
 ასე რომ GetInt და სხვა CS50 ბიბლიოთეკის ფუნქციები ტენდენცია გამოიყენოს GetString
 მათი შესრულება.
 ასე რომ, მე ხაზგასმით მნიშვნელოვანი რამ აქ.
 ის მოუწოდებს GetString მიიღოს სიმებიანი.
 იმ შემთხვევაში, თუ GetString ვერ დაბრუნების მეხსიერება,
 გახსოვდეთ, რომ GetString mallocs რაღაც, ასე რომ როცა მოვუწოდებთ GetString
 თქვენ არ უნდა (გაუგებარია) უფასო რომ სიმებიანი რომ თქვენ გაქვთ.
 ასე რომ აქ, თუ ეს ვერ მოხერხდა malloc რაღაც, ვბრუნდებით INT_MAX როგორც მხოლოდ დროშა რომ,
 hey, ჩვენ არ ვიყავით რეალურად შეუძლია მიიღოს რიცხვი.
 თქვენ უნდა იგნორირება, რასაც მე დაბრუნდება, ან
 თქვენ არ უნდა ჩათვალოს როგორც მოქმედებს შეყვანის. საბოლოოდ, ვთქვათ, რომ არ გამოუვათ, ჩვენ ვიყენებთ sscanf რომ სპეციალური დროშა,
 რაც იმას ნიშნავს, პირველი მატჩი რიცხვი,
 მაშინ დაემთხვა რომელიმე პერსონაჟი მას შემდეგ, რაც მთელი რიცხვი.
 ასე რომ შეამჩნია ჩვენ გვინდა, რომ გაუტოლდება 1.
 ამიტომ sscanf ანაზღაურება რამდენი შედეგიდან თუ წარმატებით გააკეთა?
 იგი დაბრუნდება 1 თუ იგი წარმატებით შესაბამისი რიცხვი,
 ეს დაბრუნდება 0 თუ იგი არ შეესაბამება რიცხვი, და ეს დაბრუნდება 2
 თუ იგი შესაბამისი რიცხვი მოსდევს გარკვეული ხასიათი.
 ასე რომ შეამჩნია ჩვენ გაიმეორეთ თუ ჩვენ ემთხვევა არაფერი მაგრამ 1.
 ასე რომ, თუ შევედით 1, 2, 3, C, ან 1, 2, 3, X,
 შემდეგ 1, 2, 3 დაიჭერს ინახება რიცხვი,
 X დაიჭერს ინახება ხასიათი,
 sscanf დაბრუნდნენ 2, და ჩვენ გაიმეორეთ, რადგან ჩვენ მხოლოდ გვინდა რიცხვი.
 

სწრაფად აფეთქებით მეშვეობით HTML, HTTP, CSS.
 HyperText Markup Language სტრუქტურა და სემანტიკა ვებგვერდი.
 აქ არის მაგალითი ლექცია სადაც ჩვენ HTML tags.
 ჩვენ გვყავს ხელმძღვანელი tags, სხეულის tags,
 ჩვენ მაგალითები ცარიელი tags სადაც ჩვენ რეალურად არ გვაქვს დაწყება და ახლო tag,
 ჩვენ უბრალოდ ლინკი და იმიჯი.
 არ არსებობს დახურვის იმიჯი tag, იქ მხოლოდ ერთი tag რომ ახორციელებს ყველაფერს tag უნდა გააკეთოს.
 ლინკები არის მაგალითად, ჩვენ დავინახავთ, თუ როგორ დაუკავშირონ CSS,
 სცენარი არის მაგალითი იმისა, თუ როგორ დაუკავშირონ გარე JavaScript.
 ეს საკმაოდ მარტივია, და მახსოვს, HTML არ არის პროგრამირების ენა.
 აქ, გახსოვთ, თუ როგორ განსაზღვრავს ფორმა ან თუნდაც რა ამ ყველაფერს გააკეთებს?
 ასეთი ფორმით აქვს აქცია და მეთოდი.
 მეთოდები თქვენ მხოლოდ ოდესმე ვხედავ არიან GET და POST.
 ასე რომ კიდევ არის ვერსია, სადაც ის იღებს დასვა URL.
 POST არის, სადაც ეს არ არის დასვა URL.
 სამაგიეროდ, ნებისმიერი მონაცემების სახით ჩაემატება მეტი ჩაფლული HTTP მოთხოვნის.
 ასე რომ, აქ, სამოქმედო განსაზღვრავს სადაც HTTP მოთხოვნის მიდის.
 სადაც ეს ხდება არის google.com / search.
 მეთოდი. დამახსოვრება განსხვავებები GET და POST,
 და, უბრალოდ, ვამბობთ, როგორც მაგალითად, თუ თქვენ გსურთ სარჩევში რაღაც.
 თქვენ ვერასოდეს სანიშნეზე POST URL
 რადგან მონაცემები არ შედის URL.
 

HTTP, ახლა, არის ჰიპერტექსტის გადაცემის პროტოკოლი.
 ჰიპერტექსტის გადაცემის პროტოკოლი, თქვენ მოელოდა მას გადასცეს
 HyperText Markup Language, და ეს ასეა.
 მაგრამ ეს ასევე გადადის ნებისმიერი images თქვენთვის ინტერნეტში,
 ნებისმიერი ჩამოტვირთვების თქვენ დაიწყოს როგორც HTTP მოთხოვნის.
 ასე რომ, HTTP მხოლოდ ენას World Wide Web.
 აქ თქვენ უნდა აღიაროს ამ ტიპის HTTP მოთხოვნის.
 აქ HTTP/1.1 მხარეს უბრალოდ ამბობს, რომ ის, მობილური
 ოქმის მე გამოყენებით.
 ეს საკმაოდ ბევრი ყოველთვის იქნება HTTP/1.1, როგორც თქვენ ნახავთ მას.
 მაშინ დავინახავთ, რომ ეს იყო GET, ალტერნატიული, რომ ჩანაწერი, რომ თქვენ შეიძლება ნახოთ.
 და URL, რომ მე ვცდილობდი ვიზიტი www.google.com/search?q = blah, blah, blah.
 ასე მახსოვს, რომ ამ, კითხვის ნიშნის q = blah blah blah,
 არის ერთგვარი პერსონალი, რომელიც მიერ წარმოდგენილი ფორმით.
 პასუხი ეს შეიძლება დაბრუნდება ჩემთან გამოიყურება რაღაც მსგავსი.
 ერთხელ, დაწყებული პროტოკოლს, რომელიც იქნება, რომ,
 რასაც მოჰყვა სტატუსის კოდი. აქ ის 200 OK.
 და ბოლოს, ვებ გვერდზე, რომელიც მე რეალურად ითხოვა მოჰყვება.
 შესაძლო მდგომარეობა კოდი თქვენ ალბათ ხედავთ, და თქვენ უნდა იცოდეს, რამდენიმე მათგანი.
 200 OK თქვენ ალბათ მინახავს ადრე.
 403 აკრძალული, 404 არ ნაპოვნია 500 Internal Server Error
 ჩვეულებრივ, თუ მიდიხარ ნახვა და რაღაც გატეხილი ან მათი PHP კოდი დამსხვრევაზე,
 ხოლო მოწყობილობის გვაქვს, რომ დიდი ფორთოხლის ყუთი
 რომ მოდის და ამბობს, მოსწონს, რაღაც არასწორია, ეს კოდი არ მუშაობს
 ან ამ ფუნქციის ცუდი.
 ჩვეულებრივ საიტებზე არ მინდა, იცის, რა ფუნქციები რეალურად ცუდი,
 ასე რომ ნაცვლად ისინი მხოლოდ მოგცემთ 500 შინაგან Server შეცდომები.
 

TCP / IP არის 1 ფენის ქვეშ HTTP.
 გვახსოვდეს, რომ არსებობს ინტერნეტ გარეთ მსოფლიო აბლაბუდა.
 Like თუ თქვენ თამაშობთ ონლაინ თამაში, რომელიც არ გადის HTTP,
 ის გადის სხვადასხვა - ის ჯერ კიდევ გამოყენებით ინტერნეტი,
 მაგრამ ეს არ გამოიყენოს HTTP.
 HTTP მხოლოდ ერთი მაგალითია ოქმი აგებული TCP / IP.
 IP სიტყვასიტყვით ნიშნავს ინტერნეტ ოქმი.
 ყველა კომპიუტერს აქვს IP მისამართი, ისინი იმ 4 ციფრი რამ
 როგორიცაა 192.168.2.1, ან რასაც, რომ tends იყოს ადგილობრივი ერთი.
 მაგრამ ეს არის ნიმუში IP მისამართი.
 ასე რომ, DNS, დომენური სახელის სამსახურის,
 ის, რაც ითარგმნება რამ, როგორიცაა google.com ფაქტობრივი IP მისამართი.
 ასე რომ, თუ თქვენ ჩაწერეთ რომ IP მისამართი შევიდა URL,
 რომ მოუტანს თქვენ Google, მაგრამ თქვენ, როგორც წესი, არ უნდა გვახსოვდეს იმ რამ.
 თქვენ ტენდენცია გვახსოვს google.com ნაცვლად.
 ბოლო რაც ჩვენ გვაქვს არის პორტები, სადაც ეს არის TCP ნაწილი IP.
 TCP აკეთებს სხვა. ვფიქრობ, ისევე, როგორც, თქვენ ბრაუზერში გაშვებული.
 იქნებ თქვენ გაქვთ ზოგიერთი ელ განაცხადის გაშვებული;
 იქნებ თქვენ გაქვთ რაიმე სხვა პროგრამა, რომელიც იყენებს ინტერნეტში გაშვებული.
 ისინი ყველა უნდა ინტერნეტი,
 მაგრამ თქვენს კომპიუტერში მხოლოდ აქვს 1 WiFi ბარათი ან რასაც.
 ასე რომ, პორტები, ისე, რომ ჩვენ შეუძლია გაყოფილი up
 როგორ შეიძლება ამ განაცხადების შეგიძლიათ გამოიყენოთ ინტერნეტში.
 თითოეული პროგრამა იღებს 1 კონკრეტული პორტი, რომ მას შეუძლია მოუსმინოს on,
 და იყოს, HTTP იყენებს port 80. ზოგიერთი ელ მომსახურება გამოიყენოს 25.
 დაბალი დანომრილი პირობა ტენდენცია იყოს დაცულია.
 თქვენ, როგორც წესი, შეუძლია მიიღოს მაღალი დანომრილი პირობა თავს.
 

CSS, კასკადური სტილების.
 ჩვენ სტილი ვებ გვერდები CSS, არა HTML.
 არსებობს 3 ადგილებში თქვენ შეგიძლიათ განათავსოთ თქვენი CSS.
 ეს შეიძლება იყოს inline, შორის სტილის tags, ან მთლიანად ცალკე ფაილი და შემდეგ უკავშირდება შემოსული
 და აქ მხოლოდ მაგალითი CSS.
 თქვენ უნდა აღიაროს ეს ნიმუში,
 სადაც პირველი მაგალითია ჩვენ შესატყვისი სხეულის tag,
 და აქ ჩვენ centering ორგანოს აქვს.
 მეორე მაგალითი, ჩვენ შესატყვისი რამ
 პირადობის ძირი, და ჩვენ გამოყენებით გარკვეული სტილის რომ.
 გაითვალისწინეთ, რომ ID ძირი ტექსტის aligns მარცხნივ,
 ხოლო სხეულის ტექსტის aligns ცენტრი.
 Footer არის შიგნით ორგანო.
 ეს იქნება, ნაცვლად, text-align მარცხენა, მიუხედავად იმისა, რომ სხეულის ამბობს ტექსტის გასწორება ცენტრი.
 ეს არის მთელი კასკადური ნაწილს.
 თქვენ შეგიძლიათ - თქვენ შეგიძლიათ მიუთითოთ სტილის ორგანოს,
 და შემდეგ რამ ორგანოს შეგიძლიათ მიუთითოთ უფრო კონკრეტული სტილის,
 და რამ მუშაობა, როგორც თქვენ მოველით.
 უფრო კონკრეტული CSS specifiers უპირატესი.
 მე ვფიქრობ, რომ ეს არის ის.
 

[Ali Nahm] Hi ყველას. თუ შეიძლება უბრალოდ თქვენი ყურადღება.
 მე ალი და მე ვაპირებ გავლა PHP და SQL მართლაც სწრაფი.
 ასე რომ, ჩვენ შეიძლება დაიწყოს. PHP არის მოკლე PHP: ჰიპერტექსტის preprocessor.
 და თქვენ ყველამ უნდა იცოდეს, რომ ეს არის სერვერული სკრიფტინგის ენა,
 და ჩვენ ვიყენებთ მას უკან ბოლომდე საიტებზე,
 და როგორ აკეთებს ბევრი computations, უკან სცენები ნაწილი.
 სინტაქსი. ეს იმას არ ნიშნავს C, სიურპრიზი, სიურპრიზი.
 იგი ყოველთვის უნდა დაიწყოს, თუ თქვენ ხედავთ, - მე ვერ გადაადგილება წინ.
 თქვენ ხედავთ, თქვენ გჭირდებათ ახალი სახის braces და მაშინ ასევე უნდა? Php.
 რომ ყოველთვის, თუ როგორ უნდა ვიზრუნოთ თქვენი PHP ტექსტი, თქვენი PHP კოდი.
 ასე რომ, ეს არ შეუძლიათ უბრალოდ იყოს, როგორიცაა C, სადაც თქვენ სახის დააყენა იგი პირველი.
 თქვენ უნდა ყოველთვის გარს მას.
 და ახლა, ძირითადი სინტაქსური არის, რომ ყველა ცვლადები უნდა დაიწყოს $ ხასიათი.
 თქვენ უნდა გავაკეთოთ, როდესაც თქვენ განსაზღვრავს მათ, თქვენ უნდა გავაკეთოთ
 როდესაც თქვენ გულისხმობდა მათ მოგვიანებით.
 თქვენ ყოველთვის უნდა, რომ $. ეს თქვენი ახალი საუკეთესო მეგობარი, საკმაოდ ბევრი.
 თქვენ არ - განსხვავებით C, თქვენ არ უნდა დააყენოს რა სახის ცვლადი type ეს არის.
 ასე რომ, ხოლო თქვენ გჭირდებათ $, თქვენ არ უნდა დააყენოს, ისევე,
 int x ან string Y, etcetera, etcetera.
 ასე რომ უმნიშვნელო განსხვავებაა.
 შედეგად, ეს იმას ნიშნავს, რომ PHP არის სუსტად ტიპის.
 PHP არის სუსტად ტიპის ენაზე და მას სუსტად აკრეფილი ცვლადები.
 სხვა სიტყვებით, ეს ნიშნავს, რომ თქვენ შეგიძლიათ გადახვიდეთ შორის სხვადასხვა სახის ცვლადი ტიპები.
 თქვენ შეგიძლიათ შეინახოთ თქვენი ნომერი 1, int,
 თქვენ შეგიძლიათ შეინახოთ იგი როგორც სიმებიანი, და შეგიძლიათ შეინახოთ იგი როგორც float,
 და ეს ყველაფერი უნდა იყოს, რომ 1.
 მიუხედავად იმისა, რომ თქვენ შენახვის იგი სხვადასხვა ფორმით,
 მაინც - ცვლადი ტიპის დაკავებულია დასასრულს.
 ასე რომ, თუ გადავხედავთ აქ, თუ გახსოვთ საწყისი pset 7,
 ბევრ თქვენგანს ალბათ ჰქონდა საკითხები ამ.
 ორი თანაბარი ნიშნები, 3 თანაბარი ნიშნები, 4 თანაბარ ნიშნები.
 Okay, არ არსებობს 4 თანაბარ ნიშნები, მაგრამ არსებობს 2 და 3.
 თქვენ გამოიყენოთ 2 თანაბარი ნიშნები შესამოწმებლად ღირებულებებს.
 მას შეუძლია შეამოწმოს მთელი ტიპის.
 ასე რომ, თუ თქვენ ხედავთ პირველ მაგალითად,
 მაქვს num_int == num_string.
 ასე რომ თქვენი int და სიმებიანი ორივე, ტექნიკურად, 1,
 მაგრამ ისინი სხვადასხვა სახის. მაგრამ ორმაგი შეადგენს, ის ისევ გაივლის.
 თუმცა, სამმაგი შეადგენს, ის ამოწმებს ღირებულება, ისევე როგორც სხვადასხვა სახის.
 ეს იმას ნიშნავს, რომ ის არ აპირებს გაიაროს ამ მეორე შემთხვევაში აქ,
 სადაც თქვენ იყენებთ 3 თანაბარი ნიშნები ნაცვლად.
 ასე რომ, ძირითადი განსხვავება, რომ თქვენ უნდა ყველა აჩვენა ახლა.
 

სიმებიანი გაერთიანების კიდევ ერთი ძლიერი რამ თქვენ შეგიძლიათ გამოიყენოთ PHP.
 ეს, ძირითადად, მხოლოდ ამ მოსახერხებელი dot ნოტაცია,
 და რომ ის, თუ როგორ შეიძლება სავალდებულოა strings ერთად.
 ასე რომ, თუ თქვენ გაქვთ კატა და თქვენ უნდა ძაღლი, და გსურთ დააყენა 2 strings ერთად,
 თქვენ შეგიძლიათ გამოიყენოთ პერიოდში, და რომ ერთგვარი როგორ მუშაობს.
 ასევე შეგიძლიათ მხოლოდ განათავსებს მათ მომდევნო ერთმანეთს,
 როგორც ხედავთ აქ ბოლოში მაგალითად,
 სადაც მე არ echo string 1, სივრცე string 2.
 PHP ეცოდინებათ შეცვლის მათ, როგორც ასეთი.
 მასივები. ახლა კი, PHP, არის 2 სხვადასხვა სახის მასივები.
 თქვენ შეგიძლიათ რეგულარული კოლექტორები, და თქვენ შეგიძლიათ ასევე აქვს ასოციაციური მასივები,
 და ჩვენ ვაპირებთ გავლა მათ ახლა.
 რეგულარული კოლექტორები მხოლოდ ამ დო,
 და ა.შ. თქვენ გაქვთ ინდექსების რომ დათვლილია.
 ახლა ჩვენ უბრალოდ აპირებს, რომ შევქმნათ ერთი და დასვა -
 ასე რომ, ეს არის, თუ როგორ შექმნათ ცარიელი მასივი, მაშინ ჩვენ ვაპირებთ
 შევიდა ინდექსის რიცხვის 0.
 ჩვენ ვაპირებთ დააყენა ნომერი 6, ღირებულება 6.
 შეგიძლიათ ნახოთ ეს ბოლოში აქ.
 Where's - ზე ინდექსის რიცხვის 1 ჩვენ ვაპირებთ დააყენა ღირებულება ნომერი 4,
 და ასე რომ თქვენ ხედავთ არსებობს 6, არსებობს 4,
 და მაშინ ჩვენ დაბეჭდვის რამ,
 როდესაც ვცდილობთ და ამობეჭდოთ ღირებულება ინახება ინდექსის რიცხვის 0,
 მაშინ ჩვენ დავინახავთ ღირებულება 6 იბეჭდება out. Cool?
 ასე რომ, რეგულარულ კოლექტორები თქვენთვის.
 კიდევ ერთი გზა, ასევე შეგიძლიათ დაამატოთ რამ რეგულარული კოლექტორები now
 შეგიძლიათ უბრალოდ დამატება მათ დასასრულს. ეს იმას ნიშნავს, რომ თქვენ არ უნდა მიუთითოთ კონკრეტული ინდექსი.
 თქვენ ხედავთ ნომერი, და შემდეგ კვადრატულ ფრჩხილებში არ არსებობს ინდექსი მითითებული.
 და ეს ვიცით - PHP ეცოდინებათ უბრალოდ დაამატოთ ეს სიის ბოლოში, მომავალი უფასო ადგილზე.
 ასე რომ, თქვენ ხედავთ, 1 უფლება არსებობს იმ 0 ლაქა,
 2 წავიდა იქ პირველ ადგილზე.
 3 მიდის - ემატება იქ.
 ასე რომ ასეთი სახის აზრი. თქვენ უბრალოდ მუდმივად დასძინა, რომ,
 და მაშინ, როდესაც ჩვენ echoing ინდექსი ნომერი 1,
 ეს იქნება ამობეჭდოთ ღირებულება 2.
 

მაშინ ჩვენ გვაქვს მასივები, რომლებიც ასოციაციურ მასივები.
 ასოციაციური მასივები, ნაცვლად, რომელმაც რიცხვითი მაჩვენებლები,
 რას აკეთებს, აქვთ მაჩვენებლების, რომლებიც სიმებიანი.
 ხედავთ, ნაცვლად - მე მოიშორეს ყველა იმ რაოდენობის მაჩვენებლების,
 და ახლა ეს key1, key2, key3, და ისინი ორმაგ ბრჭყალებში ნიშნავდეს, რომ ისინი ყველა strings.
 ასე რომ, ჩვენ შეიძლება ჰქონდეს მაგალითია.
 მაგალითი არის ის, რომ ჩვენ გვაქვს tf, და ეს მაჩვენებელი სახელი.
 ჩვენ ვაპირებთ დააყენა "ალი", როგორც სახელი, საღამოს ინდექსი, კალორიებს შეჭამეს,
 ჩვენ შეგვიძლია დააყენა int ამ დროს ნაცვლად სიმებიანი,
 და შემდეგ ინდექსი მოსწონს, ჩვენ შეგვიძლია დააყენა მთელი მასივი შიგნით მას.
 ასე რომ, ეს სახის - ის მსგავსი კონცეფცია, თუ როგორ გვქონდა
 მაჩვენებლები ნომრები, მაგრამ ახლა ჩვენ შეგვიძლია შევცვალოთ ინდექსების გარშემო
 იმისათვის, რომ მათ, როგორც სიმები ნაცვლად.
 თქვენ ასევე შეგიძლიათ ამის გაკეთება, გარდა უბრალოდ აკეთებს ამას ინდივიდუალურად,
 თქვენ შეგიძლიათ ეს გააკეთოთ ყველა ერთ ბლოკი. ასე რომ, თქვენ ხედავთ, რომ tf რომ მასივი,
 და მაშინ ჩვენ მათი ყველა ერთ გიგანტური კვადრატული ფრჩხილი კომპლექტი.
 ასე რომ, შეიძლება დაჩქარდეს რამ მდე.
 ეს უფრო სტილისტური არჩევანი, ვიდრე არა.
 ჩვენ ასევე გვაქვს მარყუჟების.
 In C გვაქვს მარყუჟების, რომ მუშაობა მოსწონს ეს.
 ჩვენ გვქონდა ჩვენი array და წავედით ეხლა ინდექსი 0 ბოლომდე სიაში,
 და ჩვენ ბეჭდვა ეს ყველაფერი, არა?
 გარდა პრობლემა ის არის, რომ ასოციაციური მასივები,
 ჩვენ არ ემთხვეოდეს ვიცი იმ რიცხვითი მაჩვენებლები
 რადგან ახლა ჩვენ გვაქვს string მაჩვენებლები.
 ახლა ჩვენ ვიყენებთ foreach მარყუჟების, რომელიც, კიდევ ერთხელ, თქვენ იმედია გამოყენებული pset 7.
 Foreach მარყუჟების მხოლოდ ვიცით თითოეული ნაწილი სიაში.
 და ეს არ ვიცი ზუსტად რიცხვითი ინდექსი, რომ თქვენ გაქვთ.
 ასე რომ, თქვენ გაქვთ foreach სინტაქსი, ამიტომ foreach, თქვენ დააყენა მასივი.
 ასე რომ, ჩემი მასივი ეწოდება pset, ხოლო შემდეგ, სიტყვა, როგორც
 და მაშინ დააყენა ამ ადგილობრივი დროებითი ცვლადი, რომ თქვენ აპირებთ გამოიყენოთ
 უბრალოდ კონკრეტული რამ, რომ აპირებს გამართოს კონკრეტული -
 ერთ შემთხვევაში ან ერთი განყოფილების მასივი.
 Pset num გამართავს 1, და შემდეგ იქნებ გამართავს ნომერი 6,
 და მაშინ იგი გამართავს ნომერი 2.
 მაგრამ ეს გარანტირებული გავლა თითოეულ ღირებულება რომ მასივი.
 სასარგებლო ფუნქცია, რაც თქვენ უნდა იცოდეს PHP არიან მოითხოვს,
 ასე რომ, რაც დარწმუნებული ვარ, რომ თქვენ მათ შორის გარკვეული ფაილები, ეხო, გასასვლელი, ცარიელი.
 უაღრესად გირჩევთ შევხედოთ pset 7 და შევხედოთ იმ ფუნქციებს.
 თქვენ უნდა იცოდეს, იმ,
 ასე რომ მე ნამდვილად ვიცი, რა, ზუსტად, იმ ყველა აკეთებს.
 

ახლა ჩვენ ვაპირებთ გავლა ფარგლებს მართლაც სწრაფად.
 ფარგლებს, PHP არის სახის ხმაურიანი რამ განსხვავებით, C,
 და ა.შ. ჩვენ უბრალოდ აპირებს გავლა იგი სწრაფად.
 ასე ვთქვათ ჩვენ ვიწყებთ იმ arrow რომ ჩვენ იქ.
 და ჩვენ ვაპირებთ დავიწყოთ $ i. ასე ცვლადი 'i' იქნება 0,
 და ჩვენ უბრალოდ აპირებს შეინარჩუნოს ბეჭდვას ის, რომ დიდი თეთრი ყუთი იქ.
 ჩვენ ვაპირებთ დავიწყოთ î0 და შემდეგ ჩვენ ვაპირებთ echo იგი.
 ასე რომ 0.
 და მაშინ ჩვენ ვაპირებთ ნამატი მას ამისთვის მარყუჟის,
 და მაშინ იქნება ღირებულება 1.
 ერთი არის არანაკლებ 3, ასე რომ, ის აპირებს გაიაროს, რომ მარყუჟი,
 და მაშინ ჩვენ ვაპირებთ, რომ ნახოთ იგი ნაბეჭდი ერთხელ.
 ჩვენ ვაპირებთ, რომ იყოს იგი კვლავ 2,
 და 2 ნაკლებია, ვიდრე 3, ასე რომ თქვენ გაივლის for loop, და ეს კიდე ბეჭდვა 2.
 მაშინ თქვენ აღვნიშნო, რომ 3 არანაკლებ 3, ასე რომ ჩვენ შესვენება გარეთ ამისთვის loop.
 ახლა ჩვენ დასრულების, და შემდეგ ჩვენ ვაპირებთ წასვლას aFunction.
 Okay. ასე რომ თქვენ უნდა გაითვალისწინოთ, რომ ეს ცვლადი, რომელიც ჩვენ შევქმენით,
 'i' ცვლადი, არ ადგილობრივად scoped.
 ეს იმას ნიშნავს, რომ ეს არ არის ადგილობრივი მარყუჟის,
 და რომ ცვლადი, ჩვენ მაინც გაქვთ და შეცვლის შემდეგ, და ეს იქნება ეფექტური.
 ასე რომ, თუ თქვენ წასვლას ფუნქცია ახლა, თქვენ ნახავთ, რომ ჩვენ ასევე გამოიყენოთ 'i' ცვლადი,
 და ჩვენ ვაპირებთ ნამატი 'i' + +.
 თქვენ ფიქრობთ, პირველ რიგში, ეფუძნება C, რომ ეს არის ის ასლი 'i' ცვლადი.
 ეს სრულიად განსხვავებული რამ, რაც არის სწორი.
 ასე რომ, როდესაც ჩვენ ბეჭდვა, ჩვენ ვაპირებთ ბეჭდვა 'i' + +, რომელიც აპირებს ამობეჭდოთ, რომ 4,
 და მაშინ ჩვენ ვაპირებთ - უკაცრავად.
 მაშინ ჩვენ ვაპირებთ დავასრულოთ გარეთ რომ ფუნქცია,
 და ჩვენ ვაპირებთ, რომ იყოს, სადაც, რომ arrow არის ახლა.
 ეს ნიშნავს, რომ მაშინ, თუმცა, მიუხედავად იმისა, რომ ფუნქცია შეიცვალა ღირებულება 'i',
 ეს არ შეცვლილა გარეთ ფუნქცია,
 იმიტომ, რომ ფუნქცია აქვს ცალკე ფარგლებს.
 ეს იმას ნიშნავს, რომ როდესაც ჩვენ echo 'i', იგი არ შეცვლილა ფარგლებში ფუნქცია,
 და ასე შემდეგ, ჩვენ ვაპირებთ ბეჭდვა 3 ერთხელ.
 სხვა რამ ფარგლებს PHP, ვიდრე C. 

ახლავე PHP და HTML.
 PHP გამოიყენება, რათა ვებ გვერდების დინამიური.
 ეს ერთგვარი რაც რამ სხვადასხვა.
 ჩვენ ეს განსხვავებული HTML.
 HTML-თან ერთად, ჩვენ ყოველთვის მხოლოდ იგივე სტატიკური რამ, როგორიცაა, თუ როგორ Rob აჩვენა,
 ხოლო PHP, შეგიძლიათ შეცვალოს საფუძველზე, რომელიც მომხმარებელს.
 ასე რომ, თუ მაქვს ეს, მე, "თქვენ შემოხვედით, როგორც -" და შემდეგ სახელი,
 და მე შეგიძლიათ შეცვალოთ სახელი. ასე რომ, ახლა სახელი იოსებ,
 და მას აქვს "ჩემ შესახებ", მაგრამ მაშინ მე ასევე შეგიძლიათ შეცვალოთ სახელი აქვს ტომი.
 და რომ იყოს განსხვავებული რამ.
 ასე რომ მაშინ ჩვენ ასევე შეუძლია შეცვალოს სხვადასხვა რამ მის შესახებ,
 და ეს გამოჩნდება სხვადასხვა შინაარსის საფუძველზე სახელი.
 ასე PHP შეუძლია სახის შეცვლის რა ხდება თქვენი ნახვა.
 იგივე აქ. მიუხედავად ამისა, აღნიშნავენ, რომ მათ აქვთ განსხვავებული შინაარსი,
 მიუხედავად იმისა, რომ ტექნიკურად მაინც წვდომის იმავე ვებ გვერდზე ზედაპირზე.
 გამოიმუშავებს HTML. არსებობს 2 სხვადასხვა გზები, რომ თქვენ შეგიძლიათ ამის გაკეთება.
 ამიტომ ჩვენ გაიაროს, რომ ახლა. პირველი გზა არის, თქვენ - yeah, უკაცრავად.
 ასე, რომ თქვენ უბრალოდ უნდა თქვენი რეგულარული for loop in PHP,
 და მაშინ echo PHP და თქვენ echo გარეთ HTML.
 გამოყენება რა რობ აჩვენა თქვენ HTML script
 და შემდეგ გამოყენებით PHP ბეჭდვითი უბრალოდ ამობეჭდოთ ვებ გვერდზე.
 ალტერნატიული გზა არის ამას თუ გამოყოფთ out PHP და HTML.
 ასე რომ თქვენ შეგიძლიათ აქვს ხაზი PHP რომ იწყება იმ მარყუჟის,
 მაშინ თქვენ შეგიძლიათ ხაზი HTML ცალკე რამ,
 და მაშინ დასრულდება მარყუჟის, კიდევ ერთხელ, ერთად PHP.
 ასე რომ, ეს სახის ჰყოფს იგი out.
 მარცხენა მხარეს, შეგიძლიათ, რომ თქვენ გაქვთ ყველა -
 უბრალოდ 1 ბლოკი PHP.
 მარჯვენა თქვენ ხედავთ, რომ თქვენ გაქვთ ხაზი PHP,
 თქვენ გაქვთ ხაზი HTML, და თქვენ უნდა ხაზი PHP ერთხელ.
 ასე ჰყოფს იგი out შევიდა რა ისინი აკეთებენ.
 და თქვენ აღვნიშნო, რომ არც გზა, არც ერთი მათგანი,
 ისინი ჯერ კიდევ ამობეჭდოთ იმიჯი, იმიჯი, იმიჯი,
 ასე რომ HTML კვლავ იბეჭდება იგივე გზით.
 და შემდეგ თქვენ კვლავ ვხედავთ 3 images გამოჩნდება თქვენი ნახვა.
 ასე რომ 2 სხვადასხვა გზები აკეთებს იგივე.
 

ახლა ჩვენ გვაქვს ფორმები და მოთხოვნები. როგორც რობ აჩვენა თქვენ,
 არსებობს ფორმები HTML, და ჩვენ მხოლოდ ნიავი მეშვეობით.
 თქვენ გაქვთ მოქმედება და თქვენ გაქვთ მეთოდი და თქვენი ქმედება
 სახის გიჩვენებთ სადაც თქვენ აპირებთ გაგზავნას, და მეთოდი არის თუ არა
 ეს იქნება GET, ან POST.
 და GET თხოვნა, როგორც რობ თქმით, იმას ნიშნავს, რომ თქვენ აპირებს დააყენოს ის ფორმა
 და თქვენ ნახავთ, როგორც URL, ხოლო POST თხოვნით თქვენ ვერ ვხედავ URL.
 ასე რომ უმნიშვნელო განსხვავებაა.
 თუმცა, ერთი რამ, რომ მსგავსი რამ
 ის არის, რომ POST და GET თანაბრად დაუცველად.
 ასე, რომ თქვენ შეიძლება ფიქრობთ, რომ მხოლოდ იმიტომ, რომ თქვენ ვერ ვხედავ მას URL,
 ეს ნიშნავს, რომ POST არის უფრო უსაფრთხო,
 მაგრამ თქვენ მაინც ნახოთ იგი თქვენს cookies ინფორმაციას, რომ თქვენ გაგზავნის.
 ასე რომ, არა მგონია, რომ ერთი ან მეორე.
 კიდევ ერთი რამ უნდა აღვნიშნო, რომ თქვენ ასევე უნდა მონაკვეთზე ცვლადები.
 თქვენ ბიჭები გამოიყენება ეს pset 7 მიიღოთ თქვენი მომხმარებლის ID ინფორმაციას.
 რა მოხდა იყო ის, რომ თქვენ შეგიძლიათ გამოიყენოთ ეს ასოციაციურ მასივში,
 $ _SESSION და შემდეგ თქვენ ღებულობთ წვდომას სხვადასხვა რამ
 და შესანახად სხვადასხვა რამ მასშტაბით გვერდებზე.
 

ბოლო ის არის, რომ ჩვენ გვაქვს SQL, სტრუქტურირებული შეკითხვის ენა,
 და ეს არის პროგრამირების ენა მართოთ ბაზაში.
 რა, ზუსტად, არის მონაცემთა ბაზა? ისინი კოლექციების მაგიდები,
 და თითოეულ მაგიდაზე შეიძლება ჰქონდეს მსგავსი სახის ობიექტები.
 ამიტომ ჩვენ გვქონდა მაგიდასთან მომხმარებლებს თქვენს ფინანსთა pset.
 და რატომ არიან ისინი სასარგებლო? იმიტომ, რომ ეს გზა მუდმივად შენახვის.
 ეს გზა თვალთვალის რამ და მართვის რამ
 და რეალურად ხედავს მას სხვადასხვა გვერდებზე და შენახვა ტრეკზე.
 ხოლო თუ თქვენ უბრალოდ შეინახოს იგი, რომ ერთ უშუალო მომენტი
 და შემდეგ გამოიყენოთ იგი მოგვიანებით, თქვენ ვერ შეძლონ არაფერი რომ თქვენ გადაარჩინა.
 ჩვენ გვყავს 4 ძირითადი რამ, რომ ჩვენ ვიყენებთ SQL ბრძანებები.
 ჩვენ აირჩიეთ, ჩადეთ, წაშლის, და განახლება.
 იმ მართლაც მნიშვნელოვანია, რომ თქვენ ბიჭები იცოდეს თქვენი ვიქტორინა.
 

ჩვენ სწრაფად წასვლა აირჩიეთ ახლა.
 ძირითადად, თქვენ შერჩევის რიგები მონაცემთა ბაზაში.
 ასე რომ, თუ თქვენ გაქვთ, სწორედ აქ -
 ჩვენ ამ 2 სხვადასხვა რამ, და ჩვენ გვინდა აირჩიოთ კლასების მაგიდა
 სადაც გასაოცარია - სადაც გასაოცარია სვეტი ღირებულება არის 1.
 ასე რომ თქვენ ხედავთ აქ, ჩვენ გვაქვს ამ 2 რამ კლასის სახელი,
 CS50 და Stat110, და ჩვენ გვაქვს კლასის პირადობის მოწმობა და სლოგანი.
 ასე რომ ჩვენ გვინდა აირჩიეთ ყველა იმ ინფორმაციას.
 მაშინ დაინახავ უფლება აქ რომ ის სახის კრეფა გარეთ რომ გასაოცარია სვეტი,
 სადაც ყველა რამ 1 და შემდეგ მას კლასის ID, კლასის სახელი და სლოგანი, რომ მას შეუძლია აირჩიოთ out.
 როგორ ზუსტად გავაკეთოთ ეს კოდი? თქვენ უნდა გამოიყენოთ PHP.
 ასე რომ, ერთგვარი როგორ PHP და SQL დაკავშირებულია ერთმანეთთან.
 ახლა ჩვენ გვაქვს ჩვენი კოდი, და ჩვენ ვაპირებთ გამოვიყენოთ ჩვენი ხერხისთვის ფუნქცია
 როგორც ჩვენ გააკეთა pset 7, და ჩვენ ვაპირებთ აწარმოებს SQL შეკითხვაზე.
 მაშინ ჩვენ ვაპირებთ აქვს -
 ჩვენ ყოველთვის უნდა შეამოწმოთ, თუ row ს სამმაგი თანაბარი თუ ცრუ. ასე რომ კიდევ ერთხელ, გსურთ შეამოწმოთ ტიპისა და ღირებულება,
 და თუ ეს არ იმუშავებს, მაშინ ვუხდით ბოდიშს, როგორც ყოველთვის, როგორც ჩვენ გააკეთა pset 7.
 წინააღმდეგ შემთხვევაში, თქვენ გსურთ loop მეშვეობით ყველაფერს იმ მოსახერხებელი
 foreach მარყუჟების, რომ ჩვენ უბრალოდ წავიდა.
 არის, რომ ჩვენ looping მეშვეობით და ჩვენ გახადა წარსულში,
 მოდით ვივარაუდოთ, რომ ჩვენი ხერხისთვის გავიდა, ახლა ჩვენ გვაქვს ჩვენი foreach loop.
 და პირველ რიგში მას აქვს, ამიტომ აქ ზედიზედ, სწორედ აქ, ის boxed.
 ის აპირებს ამობეჭდოთ ყველა ინფორმაციას, რომ ის მიღებული.
 ასე რომ, ის აპირებს ამობეჭდოთ ბოლოში "Wanna Learn HTML?"
 შემდეგ ის აპირებს წასვლა მომდევნო ზედიზედ, იმიტომ, რომ ის დასრულდა პირველი მარყუჟის,
 და ასე შემდეგ ის აპირებს ამობეჭდოთ მეორე ხაზი, რომ,
 რომელიც იქნება STAT110, მოძებნა ყველა Moments.
 

ერთი ბოლო რამ არის SQL ხარვეზებს.
 მე ვიცი, დავით შეეხო ამ ცოტა ლექციების.
 შეგიძლიათ წაიკითხოთ ამ მოგვიანებით. ეს მართლაც სასაცილოა.
 SQL Injection არის ერთგვარი სახიფათო რამ.
 ვთქვათ, რომ თქვენ მხოლოდ გამყარებაში იმ ცვლადების უფლება თქვენს შეკითხვაზე,
 როგორც ხედავთ, რომ პირველი ხაზი.
 ასე რომ, როგორც ჩანს, ჯარიმა, არა? თქვენ უბრალოდ აყენებს მომხმარებლის სახელი
 და პაროლი თქვენი SQL შეკითხვაზე, და გსურთ დაძრულიყო ეს off და მიიღეთ რაც თქვენს მონაცემები მაგიდასთან.
 რომ როგორც ჩანს საკმაოდ მარტივია. ასე ვთქვათ, ვინმე აყენებს,
 ამისთვის დაგავიწყდათ, ამ ან ტექსტი აქ -
 რეალურად უნდა იყოს წითელი ყუთი.
 მოდით ვთქვათ, რომ ისინი, რომ დაგავიწყდათ შევიდა - რომ ის, რასაც ისინი შევა.
 ასე რომ, ისინი აყენებს ან "1" = 1.
 კეთილი სულელური დაგავიწყდათ ჰქონდეს.
 ახლა მოდით უბრალოდ შეცვლის მას, და თქვენ აღვნიშნო, რომ ამ SQL query ახლა,
 იგი აფასებს ყოველთვის ასეა, რადგან თქვენ აღვნიშნო, რომ
 თქვენ შეგიძლიათ SQL query შეარჩიოთ ყველა ამ ინფორმაციას
 ან შეგიძლიათ მხოლოდ 1 = 1.
 ასე რომ ყოველთვის აპირებს შეაფასოს ჭეშმარიტი.
 რომ არ აპირებს, რომ ნამდვილად მუშაობს, რადგან ეს ნიშნავს, რომ ჰაკერი შეიძლება დაარღვიოს თქვენი სისტემა.
 გამოსავალი არის ის, რომ თქვენ უნდა გამოიყენოთ სახალხო დამცველის სისტემა,
 რაც იმას ნიშნავს, რომ თქვენ უნდა გამოიყენოთ კითხვის ნიშნები,
 რაც ბიჭებს გამოყენებული pset 7,
 სადაც თქვენ აპირებთ გამოიყენოთ კითხვის ნიშნის ადგილას, სადაც გსურთ განათავსოთ რაღაც,
 და მაშინ ვაპირებთ აქვს მძიმე, და მაშინ გვექნება ამის შემდეგ,
 შემდეგ თქვენი ტექსტი, სხვადასხვა ცვლადები, რომ გსურთ შეცვლის თქვენი კითხვის ნიშნის.
 ასე რომ თქვენ აღვნიშნო, რომ ახლა მაქვს ეს წითელი კითხვის ნიშნები.
 მერე დააყენა ცვლადების შემდეგ ჩემი strings ასე ვიცი შეცვლის მათ ამ მიზნით შემდეგ.
 რომ დარწმუნდნენ, რომ, თუ ვინმე აკეთებს ასე,
 და მათ აქვთ or 1 = 1 სიტუაციას, რომელიც დარწმუნდით,
 უკან ბოლოს, დარწმუნდით, რომ ის რეალურად არ დაარღვიოს SQL შეკითხვაზე.
 Okay, ასე რომ საკმაოდ ბევრი ის, whirlwind PHP და SQL.
 საუკეთესო luck ყველას, და ახლა Ore.
 

[Oreoluwatomiwa Babarinsa] Okay ყველას. ახლა წავიდეთ მეტი რამდენიმე JavaScript
 და ზოგიერთი სხვა რამ ძალიან სწრაფად ამიტომ ჩვენ არ გამართავს თქვენ up tonight.
 JavaScript. დიახ. JavaScript არის სახის cool რამ, სავარაუდოდ.
 რამ ნამდვილად უნდა იცოდეთ შესახებ JavaScript, ეს ერთგვარი მოსწონს
 კლიენტის მხარის ბოლოს რა თქვენი web app იქნება აკეთებს.
 არსებობს გარკვეული რამ, რაც უბრალოდ არ მინდა იზრუნოს ყველა დროის სერვერის მხარეს.
 ყველა პატარა ურთიერთქმედების, შეფერადება ერთი რამ, რაც რაღაც ქრება.
 ნამდვილად არ მინდა, რომ უნდა გაიგო თქვენს სერვერზე ყველა დრო, რომ.
 და ზოგიერთი, რომ არ არის გამორიცხული, აკეთებთ სერვერის მხარეს.
 სწორედ ამიტომ, ჩვენ გვჭირდება რაღაც JavaScript.
 Cool რამ JavaScript: ეს არის დინამიურად აკრეფილი.
 რა ეს იმას ნიშნავს, რომ თქვენი პროგრამა არ უნდა იცოდეს,
 რა, ზუსტად, ცვლადები როდესაც ვწერთ ის.
 ეს კიდე უბრალოდ სახის გაერკვნენ ის, როგორც ეს გაშვებული.
 სხვა რამ არის cool შესახებ: ეს Curly გაუწიოს ენაზე
 რაც იმას ნიშნავს, სინტაქსის მსგავსია C და PHP.
 თქვენ არ გაქვთ ბევრი რამ rework როცა თქვენ სწავლის JavaScript.
 აქ ჩვენ გვაქვს ცოტა JavaScript.
 საინტერესო რამ აქ არის ის, რომ, თუ თქვენ შეხედეთ მას,
 ჩვენ ცოტა JavaScript უფლება იქ ხელმძღვანელი ტეგით.
 რა არის ამჯამად ძირითადად მხოლოდ შეიცავდეს JavaScript ფაილი.
 ეს არის ერთი გზა შეგიძლიათ JavaScript თქვენს პროგრამას.
 შემდეგ მეორე ცოტა რეალურად რამდენიმე inline JavaScript,
 ძალიან ჰგავს inline სტილის CSS,
 და თქვენ მხოლოდ წერა რამდენიმე კოდი ძალიან სწრაფად არსებობს.
 JavaScript აქვს მასივები.
 კიდევ ერთი გზა შენარჩუნება მონაცემები გარშემო, ძალიან სასარგებლო.
 ძალიან ლამაზი და მარტივი სინტაქსი.
 თქვენ გამოიყენოთ კვადრატულ ფრჩხილებში წვდომისათვის ყველაფერი შენარჩუნებას და ყველაფერი ერთად.
 არაფერი ძალიან რთული.
 მაგარი რამ JavaScript და სკრიფტინგის ენებზე ზოგადად
 არის, რომ თქვენ არ უნდა ფიქრი მასივი ზომის.
 შეგიძლიათ უბრალოდ გამოიყენოთ array.length და ტრეკზე ის,
 და ასევე მასივი შეგიძლიათ იზრდება ან მცირდება, როგორც თქვენ უნდა მას.
 ასე რომ, თქვენ არ გჭირდებათ ფიქრი ნებისმიერი სახის,
 oh, მე უნდა გამოყოს რამ, ან რამე მსგავსი.
 

მაგარი ისაა, რომ JavaScript რაღაც მოუწოდა ობიექტები. ის ობიექტზე ორიენტირებული ენა, ასე რომ ეს არ არის, არსებითად,
 გზა თქვენ ჯგუფი მონაცემები ერთად, გარკვეულწილად მსგავსი struct,
 მაგრამ თქვენ შეგიძლიათ თქვათ ეს მოსწონს struct ან ასოციაციურ მასივში სინტაქსი.
 ეს არის საკმაოდ მარტივი და რა შეგიძლიათ გააკეთოთ, რომელზეც ეს არის ჯგუფი მონაცემები ერთად
 თუ თქვენ გაქვთ bunch of მონაცემები რომ დაკავშირებული.
 იმიტომ, რომ ეს ყველაფერი, თქვენ უნდა აღწერს მანქანა,
 თქვენ არ უნდა მას bunch სხვადასხვა ადგილებში.
 თქვენ შეგიძლიათ მხოლოდ გამყარებაში მას 1 ობიექტი JavaScript.
 როგორც თქვენ ალბათ იცით, iterating არის ერთი იმ tedious ამოცანა.
 თქვენ მხოლოდ ამის მეტი კიდევ. თქვენ უნდა გაიგო, რომ ყველა ობიექტი მანქანაში,
 ან თქვენ უნდა გაიაროს ყველა ელემენტის სიაში ან რამე მაგდაგვარს.
 ასე რომ, JavaScript აქვს, მსგავსი PHP, foreach სინტაქსი.
 ამ შემთხვევაში, ის ამ loop.
 გსურთ გამოიყენოთ ეს მხოლოდ ობიექტები.
 არსებობს გარკვეული პრობლემები რომ მოხდეს, თუ თქვენ გამოიყენოს ეს მასივები.
 ეს ზოგადად არის ერთი იმ რამ, რომ არის ძალიან სასარგებლო,
 იმიტომ, რომ თქვენ აღმოფხვრას ბევრი ოვერჰედის
 იმიტომ, რომ თქვენ არ უნდა გაიყვანოს ყველაფერი თქვენი ობიექტის თავს.
 თქვენ არ უნდა გვახსოვდეს ყველა გასაღები სახელები.
 თქვენ უბრალოდ სახის მისაღებად მათ უკან ამ სინტაქსს.
 ამ, ერთად, თქვენ უბრალოდ უნდა გვახსოვდეს
 რომ თქვენ დავუბრუნდეთ ყველა გასაღებები, ძალიან მსგავსი გზა hash მაგიდასთან.
 თუ გახსოვთ, რომ, როდესაც თქვენ დასვა string თქვენ ვერ რაიმე
 რომ ექნება ასოცირებული ღირებულება მას.
 რა შეგიძლიათ გააკეთოთ, რომელზეც ეს თქვენ შეიძლება ითქვას, ყველა უფლება,
 მე დასვა მანქანა, და მე მას Ferrari.
 ასე, რომ თქვენ შეგიძლიათ განათავსოთ სიმებიანი Ferrari მოგვიანებით, და შეგიძლიათ მიიღოთ, რომ.
 და შეგიძლიათ გააკეთოთ, რომ მარყუჟი, ერთად ამ loop.
 ასე რომ მხოლოდ უფრო მეტი ობიექტების. მთავარია, ამ, თქვენ უნდა გვახსოვდეს
 არის, რომ თქვენ შეგიძლიათ გამოიყენოთ ობიექტზე struct მოსწონს სინტაქსის მაშინ, როცა გნებავთ ამ,
 გარდა, თუ რა თქვენი აპირებს გამოიყენოს როგორც სიმებიანი არ არის სწორი ცვლადის სახელი.
 ასე რომ, თუ გადავხედავთ, რომ არ არსებობს, ჩვენ გვაქვს გასაღების სივრცეებს.
 ასევე, თუ თქვენ დააყენა object.key, სივრცე, ერთად, სივრცეში, ფართები,
 რომ უბრალოდ არ აქვს აზრი syntactically.
 ასე რომ თქვენ მხოლოდ შეგვიძლია გავაკეთოთ, რომ ამ სახის bracket სინტაქსი.
 

ასევე, JavaScript ძალიან ფარგლებს ბრძენი to PHP.
 თქვენ გაქვთ 2 გზებს მიმართავენ ფარგლებს.
 თქვენ არ შეგიძლიათ var თვალწინ ცვლადი,
 და რომ მხოლოდ იმას ნიშნავს, რომ ეს არის გლობალური.
 თქვენ ხედავთ, რომ ყველგან. მაშინაც კი, თუ თქვენ უნდა დააყენოს ამ თუ განაცხადი,
 სადმე სხვაგან თქვენი კოდი ამის შემდეგ ეტაპზე თქვენ ვერ ვხედავ, რომ ცვლადი.
 კიდევ ერთი რამ, თუმცა, არის ერთად var, ის შემოიფარგლება რასაც ფუნქცია თქვენ შემოსული
 თუ თქვენ არ ფუნქცია, ასევე, ის გლობალური.
 მაგრამ თუ ფუნქცია ეს მხოლოდ ჩანს, რომ ფუნქცია.
 მე არ მაქვს მაგალითად, მაგრამ, yeah. ეს არის ერთ ერთი იმ რამ, სადაც
 თქვენ შეგიძლიათ მართოთ რა ცვლადები გსურთ გლობალური,
 რა ცვლადები გსურთ იყოს ადგილობრივი, მაგრამ თქვენ უნდა ფრთხილად ამ,
 იმიტომ, რომ თქვენ არ გაქვთ ტიპის ჯარიმა მარცვლეულის კონტროლის თქვენ გავაკეთოთ C,
 სადაც თუ რამე გამოცხადებული ამისთვის მარყუჟის, ის აპირებს დარჩენას, რომ მარყუჟი.
 რაც ჩვენ რეალურად აინტერესებს გამოყენებით JavaScript ამისთვის არის მანიპულირების ვებ გვერდები, არა?
 ვგულისხმობ, ამიტომ ჩვენ ამით.
 

ამისათვის, ჩვენ ვიყენებთ რაღაც მოუწოდა DOM.
 დოკუმენტის ობიექტური მოდელი.
 ძირითადად, თუ რას აკეთებს არის ის იღებს ყველა თქვენი HTML
 და მოდელები იგი out შევიდა bunch ობიექტების, რომლებიც წყობილი ფარგლებში ერთმანეთს.
 თქვენ იწყებთ ერთად რაღაც მსგავსი.
 გაქვთ, მარჯვენა ჩემთვის, bunch of კოდი იქ რომ სახის -
 თქვენ ფიქრობთ, რომ მინდა იყოს ძალიან რთული მანიპულირება,
 იმიტომ, რომ თქვენ მინდა იყოს parsing მეშვეობით bunch of ტექსტი
 და რომელსაც ცალი გარდა რამ. და თუ ეს არ იყო სწორად დაფორმატებული?
 ცუდი რამ მოხდებოდა.
 ასე რომ, JavaScript ზრუნავს ამ თქვენთვის, და თქვენ ლამაზი მონაცემები სტრუქტურის,
 ისევე როგორც ერთი ჩემი მარცხენა, სადაც თქვენ უბრალოდ აქვს დოკუმენტი,
 და შიგნით რომ თქვენ გაქვთ რაღაც მოუწოდა HTML,
 და შიგნით რომ თქვენ გაქვთ ხელმძღვანელი და სხეულის,
 და შიგნით რომ head თქვენ გაქვთ სათაური, და ა.შ. და ა.შ. და ა.შ..
 ეს ამარტივებს მანიპულირების ვებ გვერდზე ისე, რომ ეს უბრალოდ,
 oh, მე უბრალოდ მინდა გაიგო, რომ ეს ობიექტი.
 სახის ძალიან მსგავსი გზა თქვენ ამას გაიგო სხვა ობიექტი თქვენ გააკეთა თავს.
 როგორც ვთქვი, ყველა DOM არის დოკუმენტი ობიექტი.
 ან უბრალოდ ერთ ადგილას და მაშინ წავიდეთ შიგნით მას იპოვოს რამ,
 და თქვენ შეგიძლიათ ამის გაკეთება - ეს არის ძველი სტილი ამის გაკეთება, იქ,
 სადაც თქვენ აკეთებთ document.getElementById და შემდეგ სახელი,
 და როგორც თქვენ ალბათ გითხრათ, ამ იღებს ძალიან unwieldy შემდეგ, ხოლო.
 ასე, რომ თქვენ ალბათ არ მინდა ამის გაკეთება. სწორედ ამიტომ ჩვენ
 შემდეგი რამ ჩვენ ვაპირებთ ვისაუბროთ შემდეგ.
 გასაღები რამ აქ არის ის, რომ ყველა უფლება, თქვენ გაქვთ ყველა ამ ელემენტების, არა?
 იქნებ მე შეგიძლიათ შეცვალოთ ფერი რამე როცა გვერდი იტვირთება.
 მერე რა? რა მოხდება, თუ ჩემი მომხმარებელი დააჭერს რაღაც?
 მინდა, რომ რაღაც საინტერესო, როდესაც ისინი დააწკაპუნეთ რაღაც.
 ამიტომ, ჩვენ მოვლენები. თქვენ შეგიძლიათ, ძირითადად, იპოვით ნებისმიერ ელემენტს თქვენს DOM,
 და მერე ამბობენ, hey. როდესაც ამ დატვირთვების ან ვინმე დააჭერს ეს,
 ან როდესაც ისინი მაუსის მეტი იგი, რაღაც იგი.
 და რა გაქვთ, თქვენ ფუნქციები, რომ გაუმკლავდეს ამ თქვენთვის.
 ეს ფუნქციები ღონისძიება ელფოსტის.
 რა they're - უბრალოდ ლამაზი გზა ამბობდა,
 ეს ფუნქცია მხოლოდ შესრულებული, როდესაც ეს მოვლენა ხდება.
 ასე რომ ამუშავებს იმ შემთხვევაში, თუ ხდება.
 ეს არის, თუ როგორ ქმნის out ღონისძიება დამმუშავებლის.
 მაქვს გარკვეული ღილაკს, და როდესაც თქვენ დააჭირეთ მას, აფეთქდა.
 ასე რომ არ დააჭიროთ ღილაკს.
 ეს არის ერთი გზა უახლოვდება მას, არა?
 თქვენ გაქვთ ღილაკს tag, და click თქვენ გაქვთ სიმებიანი, რომელიც ამბობს,
 oh, სხვათა შორის, მე ამ აფეთქებენ ჩემთვის.
 წინააღმდეგ შემთხვევაში, ეს ისევე, როგორც რეგულარული ღილაკს უბრალოდ გააკეთა.
 ასევე შეგიძლიათ გააკეთოთ სხვა გზა,
 მიერ grabbing DOM ელემენტს, მაგრამ ჩვენ გადარჩენა, რომ მას შემდეგ, რაც ჩვენ ვსაუბრობთ jQuery.
 

JQuery: ეს არის ბიბლიოთეკა, რომელიც არის cross-ბრაუზერი.
 თქვენ შეგიძლიათ გამოიყენოთ ის საკმაოდ ბევრი რამე.
 და ეს მხოლოდ გაძლევთ უამრავი ინსტრუმენტი მუშაობა.
 იმის გამო, რომ JavaScript, ხოლო ძლიერი, არ გააჩნია ყველა ინსტრუმენტები გჭირდებათ
 იმ ყუთში ნამდვილად დაძლევის web app თქვენ შეიძლება გსურთ.
 ასე რომ, ეს ამარტივებს ბევრი რამ, გაძლევთ უამრავი ფუნქციები
 იმ ყუთში, რომ თქვენ ჩვეულებრივ უნდა დაწეროს საკუთარ თავს, მეტი და მეტი და კიდევ.
 და მხოლოდ ხდის რამ ძალიან მარტივია.
 თქვენ ასევე selectors, რომელიც გაძლევთ მიიღოს ყველა იმ ელემენტების
 თქვენი DOM ბევრად უფრო მარტივად, იმის ნაცვლად, რომელმაც უნდა გამოიყენოს ეს ძალიან დიდი ფუნქცია ზარები.
 მეტი ამ სელექციონერები. გაქვთ, იქ თქვენ, ვთქვათ,
 მინდა კიდევ ელემენტს ერთად ID "Rock".
 ასევე, jQuery, უბრალოდ $ და შემდეგ სიმებიანი რომ აქვს ფუნტი, და შემდეგ "Rock".
 ეს ძალიან მარტივია და ბევრი უფრო სწრაფად, ვიდრე ტრადიციული JavaScript გზა მოგვარება ამ პრობლემის.
 და თქვენ გაქვთ მსგავსი რამ კლასები და ელემენტს ტიპები.
 jQuery არის ერთ - ერთი მაგარი მახასიათებლები არის შეგიძლიათ სახის შეკუმშოს
 ქვემოთ თქვენი queries თქვენს DOM ძალიან, ძალიან სწრაფად.
 ახლა ჩვენ უკან ღონისძიების გატარება, და ეს არის, თუ როგორ გაუმკლავდეს ერთი მოვლენა jQuery.
 ასე რომ, რასაც ჩვენ ვაპირებთ აქ არის ჩვენ ვამბობთ, ყველა უფლება. მაქვს სცენარი აქვს, არა?
 ასე რომ, მე ამ inline JavaScript.
 ის, რასაც ჩვენ ვაპირებთ, ჩვენ ვაპირებთ ამბობენ, ყველა უფლება.
 როდესაც დოკუმენტი მზად არის, რაც იმას ნიშნავს, რომ დოკუმენტი უკვე დატვირთული,
 ჩვენ ვაპირებთ წავიდეთ რომ ფუნქცია, და ჩვენ ვაპირებთ ამბობენ, ყველა უფლება,
 ეს ფუნქცია რეალურად აკეთებს რაღაც.
 ის ძირითადად ამბობდა, ყველა უფლება, get me ელემენტს ერთად ID "myid".
 და მაშინ მისცეს ამ ფუნქციის დამმუშავებლის რომ ახორციელებს, როდესაც თქვენ დააჭირეთ მას.
 ძირითადად რა ეს იმას არის, ის ამბობს, ყველა უფლება.
 გვერდი იტვირთება, ამიტომ მე ვაპირებ წელს, იპოვეთ ამ ელემენტის,
 მისცეს მას ამ ღონისძიების კურატორმა, და ეს ძირითადად ქმნის თქვენს გვერდზე თქვენთვის.
 და ეს არის, თუ როგორ გსურთ ვიფიქროთ ღონისძიების გატარება.
 თქვენ უბრალოდ უნდა ვიფიქროთ, ყველა უფლება, როდესაც რაღაც ხდება, რაც არ მინდა, რომ მოხდეს?
 თქვენ არ მინდა ფიქრი, okay, მე უნდა დავრწმუნდეთ ამ რამ მოლაპარაკებები ამ რამ,
 ეს საგანი blah blah blah, რადგან გსურს გაიგო, რაც თვალსაზრისით მოვლენები.
 როცა ეს მოხდება, ეს მოხდება. როცა ეს ხდება, რომ ხდება.
 და თუ რამ გამოიწვიოს სხვა რამ, რომ დიდი.
 მაგრამ თქვენ არ გსურთ ცდილობენ და ამის გაკეთება რთული კოდი
 სადაც თქვენ გამოიწვია მრავალი რამ ამავე დროს,
 რადგან თქვენ მხოლოდ აპირებს თავის ტკივილი.
 

ყველა უფლება. ახლა ჩვენ შეგვიძლია მივიღოთ ჩვენი გვერდი გაუმკლავდეს მოვლენების,
 მაგრამ ასე ვთქვათ ჩემი მომხმარებელი დააჭერს ღილაკს.
 რა მოხდება, თუ გსურთ გააგზავნოთ მოთხოვნა თავში სერვერზე,
 მაგრამ მე არ მინდა, რომ განაახლეთ გვერდი, რადგან მქონე განაახლეთ ახალი გვერდი
 თითოეული დრო იღებს სახის tedious და რატომ მჭირდება
 გაიყვანოს ქვემოთ header ერთხელ, და ძირი ისევ,
 და ყველა ელემენტების გვერდზე ერთხელ
 უბრალოდ ამოცნობა მისალმებები ან დრო?
 ასე რომ, ამიტომ ჩვენ რაღაც Ajax.
 რა შეგვიძლია გავაკეთოთ აქ აიაქსი არის, ჩვენ შეგვიძლია ვთქვათ, ყველა უფლება,
 მინდა გაგზავნას ზოგიერთი მონაცემების სერვერზე,
 და მინდა კიდევ საპასუხოდ უკან ასე, რომ შეიძლება განაახლოს ჩემი გვერდი,
 ან იქნებ უბრალოდ რაღაც ალგორითმული გაანგარიშება, რომ სულაც არ ნახოთ არაფერს შესახებ.
 რას უნდა გავაკეთოთ ეს? ასევე, თქვენ უნდა URL გჭირდებათ გაიგო.
 თქვენს სერვერზე ვერ უბრალოდ magically მოსმენა არსად.
 თქვენ უნდა კონკრეტული ადგილი თქვენ გაგზავნის ამ მონაცემებს.
 და თქვენ ასევე უნდა ზოგიერთი მონაცემების გაგზავნას, ან იქნებ ის dataless შეკითხვაზე.
 გსურთ PING თავში სერვერზე და აცხადებენ, hey, მე ვარ ცოცხალი, ან რამე მაგდაგვარს.
 და შემდეგ გსურთ ფუნქცია, რომელიც ძირითადად სახელურები წარმატება.
 ვთქვათ თქვენ დავუბრუნდეთ გარკვეული ინფორმაცია თქვენს სერვერზე,
 და თქვენ გსურთ შეცვალოთ შესახებ სათაური მათი გვერდზე.
 ასე, რომ თქვენ, რომ ინფორმაცია დაბრუნება,
 და თქვენ დააყენებს, რომ ეკრანზე.
 რა ხდება, როდესაც გვერდი მზად არის,
 თქვენ შექმნით on click ფუნქცია ამ ღილაკს მოუწოდა greeter. რა ეს მაშინ არ არის, როცა ღილაკი აიძულა,
 თქვენ ესაუბრეთ greetings.php, თქვენ გააკეთებთ POST მოთხოვნით,
 და თქვენ ამბობთ, hey, ჩემთვის რაღაც თქვენი გვერდი.
 ჩვენ ნამდვილად არ უნდა აღწერდეს, მაგრამ greetings.php,
 მოდით უბრალოდ, ვამბობთ, აძლევს უკან "Hello World".
 ასე რომ, ჩვენ დავუბრუნდეთ ამ "Hello World", და წარმატება ამ,
 ვთქვათ არაფერი მიდის არასწორი, მაშინ ჩვენ უბრალოდ ამ მიზნის ადგილი
 რომ ჩვენ მითითებული და ჩვენ მხოლოდ გამყარებაში პასუხი არსებობს.
 და ეს არის ძალიან მარტივი გზა შექმნის აიაქსი შეკითხვა.
 

ძალიან სწრაფად, რობ სახის აღნიშნული ამ უკვე,
 რამ შეიძლება წავიდეთ არასწორი, ცუდი რამ შეიძლება მოხდეს,
 ასე გსურთ გაეცანით ამ HTTP პასუხი კოდები.
 რა ეს არის უბრალოდ, ისევე როგორც, 200, ყველაფერი წავიდა okay.
 რაღაც, ცუდი რამ მოხდა.
 ეს ზოგადად რამ გსურთ მახსოვს.
 მაგრამ ეს ლამაზი იცოდეს ეს ყველაფერი.
 და ბოლოს, ერთხელ ჩვენ გავიარეთ ყველა რომ,
 ჩვენ გვჭირდება გაიგო ძალიან სწრაფად დაახლოებით დიზაინი,
 და მაშინ ჩვენ შეგვიძლია მოგცემთ ყველა დაეტოვებინა.
 დიზაინი. რამ გსურთ მახსოვს.
 ჰკითხეთ საკუთარ თავს ეს კითხვები: ვინ უნდა გამოყენებით ეს?
 რა იქნება მათი გამოყენება? რა ჩემი წევრებს არ აინტერესებს?
 რა არ აინტერესებთ?
 თქვენ უბრალოდ არ გინდათ app და მოდით უბრალოდ იზრდება
 და გახდეს ამ გიგანტური, ყველა მოითხოვს, რომ თქვენ ვერ დასრულდება.
 გსურთ აქვს დისკრეტული მიზნები და გეგმები და რამ მინდა მივმართო.
 რათა ის effortless. ყველა ამ თქმით, ძირითადად,
 გაადვილება მომხმარებელს გამოიყენოს იგი, არ იყოს იგი გიგანტური blob ტექსტის მოსწონს ეს slide არის, ფაქტობრივად.
 უბრალოდ მინდა, რომ იყოს რაღაც, სადაც ძალიან ადვილია ვინმეს რომ წავიდეს
 და რა უნდათ ამის გაკეთება.
 თქვენ არ მინდა მათ უნდა ნავიგაცია 5 გვერდი
 მიიღოს თქვენს პრემიერ ფუნქცია თქვენს საიტზე.
 იმ შემთხვევაში, თუ Google ჰქონდა 5 გვერდები სანამ კი მოძებნოთ რამე,
 არავინ გამოიყენოს იგი.
 და ბოლოს, ქაღალდის პროტოტიპი, ფოკუს ჯგუფი.
 კარგი დიზაინი და ტესტირების პრაქტიკა.
 მხოლოდ იმიტომ, რომ ვფიქრობ, ეს მუშაობს თქვენთვის,
 არ ნიშნავს, რომ ვინმეს მიაჩნია მუშაობს.
 მაგრამ ჰო, რომ არის ის.
 [CS50.TV]