>> [მუსიკალური სათამაშო]
HANNAH: Hi, ყველას.
დიდი მადლობა ბიჭებს იმდენად გამოდის ამ ამაზრზენი ამინდი ვიქტორინა ერთი
განხილვის სხდომაზე.
როგორც თქვენ ბიჭები ვიცი, ვიქტორინა ერთი არის ოთხშაბათს.
ასე რომ, ჩვენ ვაპირებთ წავიდეთ მეშვეობით bunch of თემა.
Davin: Hey, შემიძლია ვთქვა, რაღაც რეალური სწრაფი?
HANNAH: ჰო, Davin აპირებს ამბობენ, რომ რაღაც რეალური სწრაფი.
Davin: უკაცრავად.
მხოლოდ რეალური სწრაფი, თუ თქვენ გაქვთ შეკითხვები შესახებ ვიქტორინა, შეგიძლიათ ონლაინ.
წასვლა 2014 ვიქტორინა ერთი, შესახებ ვიქტორინა.
ის მივიღე ლოგისტიკის შესახებ სად უნდა წავიდეს, როდესაც წასვლა.
თუ თქვენ ერთდროულად ჩაირიცხა, ჩვენ აპირებს აქვს სახე ვიქტორინა at 5:30.
ან თუ გამომგზავნა საკითხი, თქვენ გაქვთ რაიმე სხვა საკითხი.
მაგრამ 5:30 არის მაკიაჟი ოთხშაბათს.
მაგრამ თუ თქვენ გაქვთ შეკითხვები, ზოგადი კითხვები,
ამჟამად ყველა ლოგისტიკის.
ამიტომ შეამოწმეთ იქ პირველი.
>> HANNAH: გასაოცარია.
ასე რომ, აქ არის დიდი ჩამონათვალი თემები რომ ჩვენ ვაპირებთ გავლა დღეს.
მე ვაპირებ დაფარავს ყველა C პერსონალი, რომელიც არის, რომ პირველი სვეტი.
ასე რომ, C პერსონალი, რომ ჩვენ დაფარული შემდეგ ვიქტორინა ნულოვანი.
დაწყებული უკავშირდება სია, რომელიც მოიცავს მითითებას.
>> ყველა უფლება, ასე ჩვენ ვნახეთ ამ ბოლო განხილვის სხდომაზე,
ამიტომ მე ვაპირებ გავლა ეს არის ცოტა უფრო სწრაფია.
მხოლოდ გაზარდოთ თქვენი მხრივ, თუ გსურთ ჩემთვის შენელდება ან სიტყვით რაიმე შემდგომი.
მაგრამ ჩვენ ვიყენებთ დაკავშირებული სიები, რადგან ჩვენ დავიწყეთ C მასივები.
და კოლექტორები არის დიდი, მაგრამ პრობლემა ის არის, რომ მათ აქვთ ფიქსირებული ზომა.
დაკავშირებული სიები საშუალებას მოგვცემს შევქმნათ დინამიურად ზომის მონაცემთა სტრუქტურები.
>> და ჩვენ გვაქვს ჩვენი ძირითადი ოპერაციები, ჩადეთ, წაშლა, და ძიება.
და ჩვენ შეგვიძლია გავაკეთოთ ჩასმა უარეს შემთხვევაში მუდმივი დრო
თუ ჩვენ უბრალოდ დააყენა იგი თავიდანვე.
წაშლა და ძებნის, უარეს საქმე დიდი oh of n დროს.
ასე რომ კიდევ ერთხელ, უბრალოდ flip მეშვეობით ეს სურათები,
მე ვიცი, რომ ჩვენ ვნახეთ ამ ბოლო დროს, მაგრამ ჩვენ გვინდა, რომ შევინარჩუნოთ სიმღერა ჩვენი უკავშირდება სია
მიერ შენახვა სიმღერა ხელმძღვანელი ჩვენს უკავშირდება სიაში.
იმიტომ, რომ ჩვენ ვიცით, რომ თითოეული ჩვენი კვანძების
უბრალოდ აპირებს აღვნიშნო, რომ შემდეგი კვანძის ჩვენს უკავშირდება სიაში.
>> ასე რომ, თუ ჩვენ ტრეკზე.
მიუხედავად იმისა, რომ ეს არ არის უწყვეტი ცალი მეხსიერების,
ჩვენ შეგვიძლია მოვძებნოთ მათ მხოლოდ შემდეგ სხვადასხვა ისრებით.
აქ არის ჩვენი სტრუქტურა უკავშირდება სიაში კვანძის.
ჩვენ ვნახეთ ამ ბოლო დროს.
ჩვენ გვაქვს ჩვენი struct კვანძში.
და მას აქვს ორი თვისებები.
ნომერ პირველი, ფაქტობრივი მნიშვნელობა გვინდა შესანახად.
ამ შემთხვევაში, ის რიცხვი.
ეს შეიძლება იყოს ტექსტი, იგი იქნებოდა იყოს char, რაც თქვენ გინდათ.
და შემდეგ, ჩვენ უნდა შევინარჩუნოთ სიმღერა შემდეგი კვანძის ჩვენს უკავშირდება სიაში.
ასე რომ, ეს იქნება მომცეთ შემდეგი კვანძში.
თუ თქვენ მხოლოდ აკეთებს ძებნა, როგორც ვთქვი ადრე,
ნეტავ უნდა დაიცვას თქვენი ისრებით ქვემოთ.
Insertion, თქვენ შენარჩუნება სიმღერა სადაც დანარჩენი თქვენი სია.
და გსურთ გადამისამართება ხელმძღვანელი უნდა აღვნიშნო, რომ ჩვენს ახალ ელემენტს, რომელიც
ამ შემთხვევაში არის ერთი, და მაშინ ერთი იქნება აღვნიშნო,
დარჩენილი უკავშირდება სიაში.
ასე რომ კიდევ ერთხელ, მე ვიცი, რომ ეს არის პატარა ცოტა განმეორებითი from ვიქტორინა ნულოვანი.
ამიტომ ჩვენ უნდა ვიყოთ ძალიან ფრთხილად, შესახებ ბრძანება, სადაც ჩვენ
გავაკეთოთ ეს pointings ასე რომ, ჩვენ არ დასაკარგი სიმღერა უკან სიაში.
OK, ნებისმიერი კითხვები უბრალოდ საგნით უკავშირდება სიები?
გასაოცარია, OK, მაგარი.
>> ახლა, ჩვენ ვაპირებთ წასვლა გადატანა რაღაც ოდნავ უფრო რთული,
ორმაგად უკავშირდება სიები.
ასე რომ, გარდა შენახვის სიმღერა შემდეგი კვანძში,
ჩვენ ასევე გვინდა, რომ შევინარჩუნოთ სიმღერა წინა კვანძის.
და ეს საშუალებას გვაძლევს, თუ ჩვენ რაღაც მომენტში ჩვენი უკავშირდება სია,
არა მხოლოდ წავიდეთ წინ, მაგრამ ასევე iterate უკან.
იმიტომ, რომ, როგორც ჩვენ ვნახეთ საგნით უკავშირდება სია,
თუ ჩვენ ვიყავით რაღაც კვანძი, და უეცრად, ჩვენ გადავწყვიტეთ,
ფაქტობრივად, მინდა წასვლა კვანძის უფლება ჩემს წინაშე,
ნეტავ უნდა წავიდეთ ყველა გზა უკან ხელმძღვანელი
და iterate მეშვეობით სანამ ი კვანძის ეძებდით.
>> ასე რომ, ეს ხდის რამ ოდნავ უფრო ადვილია, როგორც ჩვენ
ცდილობს iterate ჩვენი უკავშირდება სიაში.
მაგრამ ეს მოითხოვს, რომ შევინარჩუნოთ სიმღერა ერთი მეტი მაჩვენებელი, ამიტომ კიდევ ერთი კვანძის ვარსკვლავი.
ყველა უფლება, ამიტომ აქ მოდის fun ნაწილი.
ჩვენ ვაპირებთ, რომ პრაქტიკაში ახორციელებს ამოიღონ ორმაგად უკავშირდება სიები.
ასე რომ, ეს არის ის, რომ სრულიად სამართლიანი თამაში ვიქტორინა.
რომ გამოჩნდა წარსულში ტესტებში.
ამიტომ აუცილებლად უნდა მომზადდეს კოდირებისათვის ცოტა C.
ნუ დაგავიწყდებათ, რომ ყველა ამ fun PHP და JavaScript,
ჩვენ ჯერ კიდევ უნდა გვახსოვდეს უნდა გავაკეთოთ C. ასე ფუნჯი up on რომ
თუ თქვენ შეგრძნება ჟანგიანი.
>> ყველა უფლება, მოდით ვნახოთ, თუ ჩვენ შეგვიძლია ამის გაკეთება.
OK, მაგარი.
ასე რომ, ჩვენ ვაპირებთ, რომ ცდილობენ რედაქტირება უფლება აქ,
და იმედია ეს მიდის როგორც დაგეგმილი.
ყველა უფლება, ვინმეს სურს, რომ მომეცი წინადადება, თუ როგორ მე უნდა დაიწყოს?
ეს მხოლოდ ვარაუდია ვარ მიღების, რომ მე უკვე
არ სტრუქტურა განისაზღვრება, ერთი მე აჩვენა ბოლო გვერდზე,
ბოლო slide.
და მე შენახვის ხელმძღვანელი ჩემი უკავშირდება სიაში გარკვეული მაჩვენებელი მოუწოდა სიაში.
ჯერ არავის მინდა ჩემთვის დაიწყო?
>> აუდიტორია: შეგიძლიათ შექმნათ ახალი კვანძის მოვუწოდებთ მეშვეობით სიაში?
>> HANNAH: გასაოცარია, ასე ჩვენ ვაპირებთ, რომ შევქმნათ
ახალი კვანძის სეირნობისას მეშვეობით სიაში.
მინდა, რომ.
მე უბრალოდ ეძახით მაჩვენებელი, თუ ეს OK.
და სად უნდა ეს თავდაპირველად დავიწყოთ?
>> აუდიტორია: ალბათ at უფროსი სიაში.
HANNAH: Beautiful.
ჩვენ გვინდა, რომ დაიწყოს ხელმძღვანელი, რომელიც მე ვთქვი, რომ იქნება შენახული სიაში.
გასაოცარია.
ჯერჯერობით, იმდენად კარგი.
და ახლა, ჩვენი მიზანია iterate მეშვეობით სია
სანამ ჩვენ კვანძის მნიშვნელობა n, რომ ჩვენ გვინდა წაშლა.
OK?
>> ასე რომ, ახლა არის ის ნაწილი, სადაც ჩვენ გვინდა iterate მეშვეობით.
შეიძლება ვინმეს ვარაუდობენ გზა iterate მეშვეობით?
>> აუდიტორია: loop.
>> HANNAH: loop.
მე მიყვარს იგი.
კერძოდ, ჩვენ შეგვიძლია ვცდილობთ ხოლო loop.
OK, და ჩვენ ვიცით, რომ ჩვენ მიაღწია ბოლოს ჩვენი სიაში, როდესაც რა?
აუდიტორია: როდესაც კურსორი არის null.
HANNAH: როდესაც კურსორი არის null.
ლამაზი, მე მიყვარს იგი.
OK, მაგარი.
ასე რომ, ბოდიში თუ ჩემი bounding გაუწიოს არის სახის დაცემით off ეკრანზე.
ჩვენ მოიტანა უკან.
OK, მაგარი.
რა არის შემდეგი?
>> ასე ვიცით ჩვენ გვინდა წაშლა კვანძში, რომელსაც აქვს მნიშვნელობა n.
მოდით ვიპოვოთ იმ შემთხვევაში, თუ ჩვენ რეალურად ჩვენი კვანძში.
ისე როგორ იქნებოდა I შეამოწმოს, რომ?
მე უბრალოდ ვიტყვი, თუ მაჩვენებელი, და მაშინ, თუ მე გვინდა ღირებულების მაჩვენებელი,
მე უბრალოდ arrow n, უდრის n, პარამეტრი
რომელიც ჩვენ მივეცით ამ ფუნქციას, კვანძში, რომ ჩვენ გვინდა, რომ რეალურად წაშლა.
რაიმე შეკითხვები წლამდე აქ?
ყველა უფლება.
OK, ასე რომ, ახლა მოდით დავხატოთ სწრაფი სურათი ფორუმში, რათა წარმოვიდგინოთ.
>> ასე ვთქვათ, იქ ჩვენი ლამაზი კვანძი.
და მას აქვს მნიშვნელობა, მე უბრალოდ, ვამბობთ ოთხ.
და ეს მიუთითებს შემდეგი კვანძის ჩვენს უკავშირდება სიაში.
და არაფერი, სანამ.
ასე რომ, ჩვენ გვაქვს ჩვენი წინა მიუთითებს არაფერი.
ამ შემთხვევაში, ჩვენ აღვნიშნო უკან.
OK, უბრალოდ შექმნის ჩემი უკავშირდება სიაში აქ.
და ჩვენ გვაქვს სია, რომელიც მიუთითებს ამ სტრუქტურის უნდა დაიწყოს.
მე მიაპყროს კიდევ ერთი გულისთვის სისრულეზე.
OK.
მე აღვნიშნო ამ პროცესის შეჩერება.
და მე მინდა აღვნიშნო, რომ ერთი უკან.
Oops, უკაცრავად.
ჰო, მე მივიღე ეს უკან.
ამას კიდევ ერთხელ.
OK, იქ ჩვენ წავიდეთ.
ყველა უფლება მიიღო.
OK, აქ არის ჩვენი სურათი.
>> OK, ასე რომ ჩვენ გვინდა განვიხილოთ ორი შემთხვევა.
პირველ შემთხვევაში, თუ კვანძის გვინდა წაშლა
არის ძალიან დაწყების ჩვენს სიაში.
და შემდეგ, მეორე შემთხვევაში, რომ ჩვენ გვინდა განიხილოს არის, თუ ის არსად.
მესმის, რომ ეს სრულიად messy ხატვის ყველა ჩემი erasing,
მაგრამ იმედია, ჩვენ შევეცდებით ეს ნათელია რამდენიმე კოდი.
>> OK, მოდით მოიცავს საქმე სადაც ჩვენ ვნახეთ ჩვენი კვანძის,
და ეს ძალიან დაიწყოს ჩვენი უკავშირდება სიაში.
ვინმეს მომეცი წინადადება, აქ, რა
მე უნდა გავაკეთოთ იმისათვის, რომ რეალურად ამოიღონ ჩვენი კვანძის?
ეს არის პატარა სახიფათო.
OK?
>> აუდიტორია: თქვენ უნდა მიიღოს კვანძი, რომელიც იქნება, სანამ ის
და რათა ის აღვნიშნო, რომ ერთი, რომ იქნება მას შემდეგ,
და მიიღოს კვანძი, რომელიც იქნება მას შემდეგ და
ის აღვნიშნო, რომ კვანძის მის წინაშე.
HANNAH: ზუსტად.
OK, ასე რომ ეს არის საქმე where-- ჩვენ გვაქვს ორი შემთხვევა.
ჩვენ გვაქვს საქმე, სადაც კვანძში, რომ ჩვენ ვეძებთ
არის წინა სიაში.
OK, შემდეგ კი იმ შემთხვევაში, რომ თქვენ აღწერილი, წინააღმდეგ შემთხვევაში, უფლება?
ეს სხვაგან სიაში.
ასე რომ თქვენ განაცხადა, ჩვენ უნდა შევხედოთ კვანძის წინა,
და წინა კვანძის აღვნიშნო, რომ მომდევნო კვანძის.
ასე ვთქვათ ჩვენ ცდილობს აიღოს ხუთ
ჩემი ძალიან რთული ნახაზი აქ.
ჩვენ გვინდა დავრწმუნდეთ, რომ ოთხი ახლა რაოდენობა ექვსი.
ოთხი მომდევნო რაოდენობა ექვსი.
და ექვსი წინა რაოდენობა ოთხ.
ეს ჩვენი მიზანი აქ, არა?
ეს არის ის, რაც მე ვფიქრობ, თქვენ უბრალოდ ამბობს იქ.
>> OK, მოდით, რომ პირველ ჯერზე.
მოდით აქვს წინა მაჩვენებელი წინა.
ამიტომ ოთხი მომდევნო უნდა აღვნიშნო, რომ რა?
ზუსტად, ამ შემთხვევაში, ექვსი.
ასე რომ, ჩვენ უნდა ვთქვათ, მაჩვენებელი, შემდეგი.
OK?
ყველა უფლება.
მოდით, თავი დაეღწია ამ მახინჯი სურათი და ცდილობენ მიაპყროს ოდნავ უკეთესი ერთი.
ჩვენ გვაქვს ჩვენი სია ხელმძღვანელი აქ.
და რომელიც მიუთითებს პირველი კვანძი, ჩვენი უკავშირდება სია, რომელშიც ნათქვამია, არის ოთხი.
აქ არის ჩვენი მეორე კვანძის, ხუთი.
და ჩვენი მესამე კვანძის, ექვსი.
უბრალოდ ცდილობს გავამახვილო ზუსტად იგივე სურათი, უბრალოდ ცოტა მეტი cleanly.
OK, ასე რომ ოთხი შემდეგი თავდაპირველად აღნიშნავს ხუთ.
ხუთი მომდევნო რაოდენობა ექვსი.
ექვსი წინა რაოდენობა ხუთ.
და ხუთ წინა რაოდენობა ოთხ.
იმდენად გავალამაზოთ,
OK, მაგარი.
>> ახლა, რაც ჩვენ გავაკეთეთ მხოლოდ აქ, ამ ხაზი კოდი,
რომელიც ამბობს მაჩვენებელი წინა შემდეგი, ასე რომ, რას ნიშნავს?
ეს ნიშნავს, რომ თუ ჩვენ შევხედავთ ხუთი, წასვლა წინა კვანძის,
და ეს მომავალი უნდა წერტილი ხუთი მომდევნო.
ასე რომ, არსებითად, რა, რომ აკეთებს ის არის, რომ ის წაშლა ამ arrow
და რაც გამოტოვოთ უფლება ხუთ.
არის, რომ წმინდა?
მე ვიცი, რომ შეიძლება ცოტა არადამაჯერებელი.
მე ვხედავ ზოგიერთი ხელმძღვანელი nods.
ეს არის კარგი.
OK, მაგარი.
ახლა, რა არის შემდეგი ნაბიჯი?
>> მე გადატვირთვის შემდეგ.
ახლა, რაც სხვა arrow შემიძლია უნდა შეცვალოს?
ამ ერთი უფლება აქ.
ექვსი წინა.
ჩვენ არ გვინდა, რომ ექვსი წინა უნდა აღვნიშნო, რომ ხუთ აღარ.
ჩვენ გვინდა, რომ აღვნიშნო, რომ ოთხი.
იმას, რომ სურათი აზრი?
ასე რომ, ახლა ჩვენ შეგვიძლია რეალურად ხუთ out.
მოდით, რომ ცალი.
რა უნდა გავაკეთოთ, სანამ მე გადატვირთვის ექვსი წინა ოთხი?
ნებისმიერი იდეები იქ?
>> აუდიტორია: უფასო კვანძის შორის მათ მიიღწევა მას null?
HANNAH: Cool.
აუცილებლად, ჩვენი თვითმიზანი არ არის იქნება გასათავისუფლებლად კვანძის.
ასე რომ, ჩვენ შეგვიძლია გავაკეთოთ, რომ უფლება აქ.
უფასო მაჩვენებელი.
აბსოლუტურად.
მაგრამ მანამდე, მოდით just-- ჩვენი მიზანი
აქ არის მითითებული მომცეთ შემდეგი წინა ტოლია მაჩვენებელი წინა.
მე ვიცი, რომ ეს ხდება დაფარული.
OK, მოდით take-- cool.
შეგიძლიათ ყველამ ნახოთ ეს დედააზრი?
თუ ეს სუპერ პატარა?
>> ასე რომ, სანამ ჩვენ შეასრულოს ამ ხაზის აქ, ჩვენ გვინდა
დარწმუნდით, რომ მაჩვენებელი მომავალი არ null.
იმიტომ, რომ თუ მაჩვენებელი მომავალი null, რა სახის შეცდომა
მივიღებ როდესაც ვცდილობ მითითებას null მაჩვენებელი?
აუდიტორია: Seg ბრალია.
HANNAH: seg ბრალია, ლამაზი.
OK, ასე რომ, თუ არ არის null, მაშინ ჩვენ შეგვიძლია გადატვირთვის.
და ჩვენ გვაქვს ექვსი წერტილი ერთხელ ოთხ.
კითხვები წლამდე ამ ეტაპზე?
დიახ?
>> აუდიტორია: თქვენი პირველი თუ განაცხადი, არ
ნიშნავს, რომ ისარი შემდეგი, ან [INAUDIBLE]?
HANNAH: ვგულისხმობდი მაჩვენებელი ისარი n.
ასე რომ, ძირითადად, რასაც მე ვცდილობ ამბობენ, მიმდინარე კვანძის რომ მე ვარ
iterating მეტი, მიმდინარე კვანძის რომ მე ეძებს, მე შენახვის მაჩვენებელი.
და მინდა იცოდეს მაჩვენებელი ღირებულება, რომელიც ამ შემთხვევაში არის n.
და მე მინდა, არის კვანძის ვეძებ
კვანძის მე მიზნად ისახავს წაშლა?
სწორედ ამიტომ ჩვენ გვაქვს აქ მაჩვენებელი n.
>> აუდიტორია: ასე arrow აპირებს ო, თქვენ მითითებული ღირებულება
და შეინახოს იგი კვანძის მოუწოდა n?
>> HANNAH: ასე რომ, თუ მე ვარ გადის ამ სიაში
და მიუთითებს ხუთ.
თუ მინდა, რომ მიიღოს, რომ ღირებულება, თუ მინდა კიდევ, რომ ნომერი, 5,
მე უნდა გავაკეთოთ მაჩვენებელი ისარი n.
მაგარი?
Yeah.
>> აუდიტორია: არის n ცვლადის სახელი?
HANNAH: დიახ.
ასე რომ, თუ ჩვენ Flip უკან ერთი slide, n არის სახელი
ღირებულება შიგნით კვანძის ჩვენს უკავშირდება სიაში.
და მე ვიცი, რომ შეიძლება კიდევ ცოტა ცოტა გაუგებარია, რადგან ჩვენ ასევე
მოუწოდებენ რამ ჩვენ გვინდა, რომ წაშალოთ n.
ასე რომ, სადაც, რომ ერთი ხაზი მოდის.
ჰო?
>> აუდიტორია: რა გაქვთ [INAUDIBLE] როგორ მუშაობს?
მაჩვენებელი [INAUDIBLE]?
>> HANNAH: რა თქმა უნდა.
თქვენ ვსაუბრობთ ამაზე ხაზი?
აუდიტორია: ბოლო ხაზი [INAUDIBLE].
>> HANNAH: რა თქმა უნდა, OK.
ასე რომ, მოდით შევხედოთ სურათს იმისათვის, რომ ცდილობს ახსნას ამ.
მე ვწუხვარ, რომ კამერა, კითხვა იყო
ავხსნათ მაჩვენებელი arrow შემდეგი მაჩვენებელი წინა.
OK, ასე ვთქვათ ჩვენ ვართ ხუთ და ჩვენი მიზანია წაშლა ხუთ.
ამიტომ კურსორი შემდეგ, რაც ამ სამი კვანძების გვაძლევს?
რომ მოაქვს მეექვსე კვანძის, არა?
>> OK, ასე რომ, ახლა ჩვენ ითხოვს იმ ექვსი წინა.
OK?
და ჩვენ გადატვირთვის ეს თანაბარი უნდა იყოს ოთხი,
რაც მოხდა, რომ ხუთ წინა.
მე ვიცი, ეს სუპერ იმისთვის, რომ შევინარჩუნოთ სიმღერა.
მე ნამდვილად გირჩევთ გავამახვილო სურათები თუ თქვენ გაქვთ შეკითხვა მოსწონს ეს.
დიახ?
>> აუდიტორია: არის მიზეზი, რომ ჩვენ არ გვაქვს [INAUDIBLE]?
>> HANNAH: ზუსტად.
ასე რომ კითხვა იყო, რატომ ჩვენ არ უნდა შეამოწმეთ აქ?
რატომ არ გვჭირდება, რათა შეამოწმოს, მაჩვენებელი წინა არ არის ტოლი null?
და ეს იმიტომ, რომ ჩვენ უკვე გამოყოფილია
იმ შემთხვევაში, თუ მაჩვენებელი თავიდანვე.
ძალიან კარგი კითხვაა.
არაფერი ეს?
OK, მაგარი.
მოდით დავამთავროთ ეს up.
ჩვენ თითქმის არ არსებობს.
>> ასე რომ, თუ ის არის უფროსი?
რა, თუ ნაცვლად ცდილობს წაშლა ხუთ,
ჩვენ რეალურად სურდა წაშლა ოთხი?
რა უნდა გავაკეთოთ?
ისე, მე მინდა აღადგინოთ ჩემი უფროსი, თუ რა?
Shout it out?
აუდიტორია: ერთი მის შემდეგ.
HANNAH: Beautiful.
OK, ასე რომ, ჩვენ გვინდა სია უნდა მიუთითებს რაც არ უნდა ჩვენი მომცეთ შემდეგი კვანძის.
კარგი.
და მხოლოდ სისრულის მიერ გულისთვის, ჩვენ გვინდა
გსურთ შეამოწმოთ, რომ სანამ ჩვენს სიაში არ არის null, რადგან ჩვენს სიაში არ არის
ცარიელი, მაშინ ჩვენ გვინდა მითითებული ჩვენი წინა ტოლია null.
კითხვა აქამდე?
ერთი ნაბიჯია აქედან?
>> აუდიტორია: უნდა იყოს თუ სიაში არ არის ტოლი null?
>> HANNAH: დიახ, თქვენ მთლიანად უფლება.
მე ასე უკაცრავად.
არის სიაში არ არის ტოლი null.
გასაოცარია.
ცდილობს, რომ ეს ყველაფერი ეკრანზე.
ეს სახის დაცემა off.
უკაცრავად, ბიჭები.
და ბოლო, მაგრამ არანაკლებ, ყველა ჩვენ უნდა გავაკეთოთ არის დაბრუნების.
OK.
ეს იყო ბევრი გაჭედილია მართლაც სწრაფად.
მიიღოს მეორე შევხედოთ ამ დასრულდა.
მეუბნებოდა, თუ თქვენ გაქვთ რაიმე შეკითხვები.
ჰო?
>> აუდიტორია: თუ სიაში არის ხელმძღვანელი, შემდეგ კი დაველოდოთ, nevermind.
>> HANNAH: OK, კარგი.
ასე რომ, ეს არის, თუ სიაში არის ხელმძღვანელი, ჩვენ ამოიღონ ის რაც ჩვენ შეიყვანეს.
ჰო?
>> აუდიტორია: ახსნით პირველი, თუ განაცხადი კიდევ ერთხელ?
თუ მომცეთ n უდრის n?
HANNAH: რა თქმა უნდა.
ამიტომ ჩვენი მიზანია ეს მთელი ფუნქცია წაშლა კვანძში, რომელსაც აქვს მნიშვნელობა n.
ასე რომ, თუ ჩვენ, როგორც ჩვენ iterating მეშვეობით ჩვენს სიაში,
კვანძის ღირებულების n, რომ ერთი გვინდა წაშლა.
ასე რომ, ყველა წაშლა ხდება შიგნით რომ დიდი თუ განცხადებაში.
ამჯამად რომ აზრი?
მაგარი.
ჰო?
>> აუდიტორია: იქნებ უბრალოდ ვერ ვხედავ ეს, მაგრამ არ თქვენ ასევე უნდა ხაზი
სენსორული მეშვეობით სიაში?
HANNAH: გასაოცარია.
მოდით, რათა ეს up ცოტა, და ჩვენ ყველაფერს იმისათვის, რომ უფლება ბოლოში.
იქნებ ფორუმში გვაქვს უკვე ოდნავ უკეთესი იდეა.
ისე როგორ იქნებოდა მე გადაადგილება მაჩვენებელი ნაბიჯია?
>> აუდიტორია: Pointer შეადგენს მაჩვენებელი პლუს ერთი.
>> HANNAH: Beautiful.
ასე რომ საშუალებას გვაძლევს გაგრძელდება iterating მეშვეობით.
OK.
აუდიტორია: თუ არ იყოს, სხვა?
HANNAH: კიდევ ერთხელ?
აუდიტორია: თუ არ იყოს, სხვაგან შემდეგ დიდი ძველი თუ
განაცხადი [INAUDIBLE]?
HANNAH: რომელი ნაწილი?
მე ბოდიში.
>> აუდიტორია: traversal, არ იყოს, სხვა?
HANNAH თქვენ აბსოლუტურად შეიძლება ჰქონდეს სხვა.
იმიტომ, რომ მე დაბრუნების უფლება არსებობს, თქვენ არ გჭირდებათ სხვა.
მაგრამ ჰო, კარგი კითხვა.
OK, არა?
აუდიტორია: ჩვენ ვფიქრობთ მაჩვენებელი რომ მოძრაობს მეშვეობით სია
როგორც აღების ღირებულება თითოეული კვანძის სიაში?
ან უნდა ვიფიქროთ, რომ ეს სახის გარე სიაში?
>> HANNAH: ან ერთი ჯარიმა, ვფიქრობ.
სხვათა შორის, მე წარმომიდგენია, რომ ეს არის მე ვიტყვი, OK, მე ვარ მაჩვენებელი.
და ეს არის ჩემთვის.
ეს არის ჩემი მხრივ.
მე ვაპირებ აღვნიშნო, რომ სხვადასხვა რამ, რომ მინდა iterate მეშვეობით.
პირველი, მე ვაპირებ აღვნიშნო ხელმძღვანელი სიაში.
და რომ მეუბნება მე აპირებს აღვნიშნო, რომ ოთხი.
და ასე ჩემთვის, როგორც გარე სია, მე შემიძლია აღვნიშნო, რომ თითოეული ეს ელემენტები.
ასე რომ, მე ვფიქრობ, რომ თავს მაჩვენებელი.
აუდიტორია: ასე რომ, როდესაც თქვენ წაშლა ერთი იმ ელემენტებს,
წაშლა თავს, ასე ვთქვათ.
HANNAH: ზუსტად.
ასე რომ თქვენ წაშლა რამ თქვენ მიუთითებს.
ასე მაგალითად, რომ ჩვენ ვნახეთ, სადაც ჩვენ ვართ
ცდილობს წაშლა ხუთ, როდესაც მე მიუთითებს ხუთ,
მინდა წაშლა რამ მე მიუთითებს.
სწორედ.
დიახ?
აუდიტორია: გვაქვს აღებული ზრუნვა იმ შემთხვევაში, სადაც n არ არის სიაში?
HANNAH: თუ n არ არის სიაში?
ყველა რომ მოხდება არის თქვენ აპირებს iterate მეშვეობით და iterate
მეშვეობით, ხოლო შემდეგ, თქვენ აპირებს მისაღებად მაჩვენებელი მყოფი null,
და მაშინ თქვენ უნდა გაკეთდეს.
>> აუდიტორია: ასე რომ, ჩვენ გვაქვს დაბრუნდეს არაფერი?
HANNAH: ჩვენ შეგვეძლო.
ისე, რომ თუ განსაზღვრული ამ ფუნქცია, მე უბრალოდ, ვამბობთ, რომ ის დააბრუნებს
ბათილად მიუხედავად.
მაგრამ თქვენ შეიძლება რაღაც როგორიცაა დაბრუნების რიცხვი,
და არ დაბრუნდება უარყოფითი 1 თუ იგი არ.
რაღაც ამის მსგავსი.
კითხვები with-- yes?
აუდიტორია: [INAUDIBLE]?
HANNAH: ბოდიში?
აუდიტორია: [INAUDIBLE]?
HANNAH: რა თქმა უნდა.
ასე რომ actual-- ერთხელ ჩვენ ამ ყველაფერს მუშაობის მოძრავი
ყველა ამ ისრებით გარშემო, მთელი ჩვენი მიზანი იყო, თავი დაეღწია კვანძის
ჩვენ ვეძებთ.
ასე რომ, ამ შემთხვევაში, ათავისუფლებს მაჩვენებელი, თუ მე მიუთითებს ხუთ,
ეს იგივეა, წაშლა ამ შუა კვანძის.
ეს არის ის, უფასო მაჩვენებელი ნაწილი.
რომ აზრი?
>> აუდიტორია: ასე კი ფიქრობდა თქვენ არ [INAUDIBLE]?
>> HANNAH: ასე რომ, ჩვენ ვივარაუდოთ დასაწყისში ჩვენ გვქონდა სია, რომელიც იყო already--
მათ დააყენა ერთად.
ასე რომ, რათა მშენებლობა სიაში, ისინი must've [INAUDIBLE].
მაგარი.
არაფერი ეს?
დიახ?
>> აუდიტორია: რა მოხდება, თუ სიაში არ გაუტოლდება null ხაზი?
[INAUDIBLE]?
HANNAH: მარჯვენა აქ?
აუდიტორია: Yeah.
HANNAH: OK, ყველა მე ვაკეთებ არის მე უბრალოდ მიღების დარწმუნებული ვარ,
რომ სანამ ვცდილობ dereference სია, ადრე ვცდილობ წვდომისათვის წინა,
მინდა, რათა დავრწმუნდეთ, რომ ეს არ არის null ასე რომ არ მიიღოთ seg ბრალია.
მაგარი.
>> OK, მე ვიცი, ეს იყო საკმაოდ ბევრი მისაღებად მეშვეობით.
ასე რომ, ეს slide იქნება ხელმისაწვდომი თქვენ.
ასე რომ თქვენ შეგიძლიათ გაიაროს ეს უფრო დეტალურად.
დიახ?
>> აუდიტორია: რატომ სია [INAUDIBLE]?
HANNAH: რა თქმა უნდა.
ასე სიაში ნამდვილად მიუთითებს ამ ელემენტს უფლება აქ,
პირველი ელემენტია სიაში.
ასე რომ არ აქვს წინა.
დიახ?
>> აუდიტორია: არა მომცეთ წერტილი იმავე მისამართზე მეხსიერება?
ჯერ ეს აღვნიშნო, რომ იგივე მისამართი მეხსიერებაში, როგორც კვანძის
რომ ეს მიუთითებს?
>> HANNAH: დიახ, ეს მიუთითებს, ამ კვანძის მეხსიერებაში.
>> აუდიტორია: მარჯვენა, როდესაც თქვენ [INAUDIBLE]?
>> HANNAH: In გრძნობა, დიახ.
OK.
ყველა უფლება, მოდით გადაადგილება ერთად ამ.
და თუ თქვენ გაქვთ მეტი შეკითხვები გამყარებაში გარშემო დასასრულს,
და ჩვენ შეგვიძლია გაიაროს კიდევ ერთხელ.
OK, მაგარი.
ახლა ჩვენ კიდევ გადაადგილება რომ hash მაგიდები, ლელო,
და ხეები, რომლებიც თქვენ მიიღო super იცნობს p-ხუთ, speller.
>> ასე hash მაგიდასთან მხოლოდ array საგნით დაკავშირებული სიები
ან ორმაგად უკავშირდება სიები მოდის off მას.
ასე რომ, ჩვენ გვაქვს გარკვეული ასოციაციური მასივი.
და ვიცით, რომელიც ამ კოლექტორები თაიგულების შეღწევას,
ჩვენ ვიყენებთ ქეშირების ფუნქცია.
ასე რომ, ამ შემთხვევაში, შეიძლება ვინმეს გამოიცანით რა hash ფუნქცია
იქნება უბრალოდ ეფუძნება ზოგიერთი შემავალი და გამომავალი?
>> აუდიტორია: Letter ნომერი ანბანი.
HANNAH: ზუსტად.
უბრალოდ აყენებს მათ ანბანური თანმიმდევრობით.
ყველაფერი, რაც იწყება შევიდა პირველი bucket.
ყველაფერი B არის ამოქმედებული მეორე bucket, ასე შემდეგ, და ასე შემდეგ.
გასაოცარია, OK.
და ქეშირების ფუნქცია არის ნებისმიერი ფუნქცია, რომელიც იღებს სიტყვა
და გეტყვით, თუ რა bucket იგი ეკუთვნის.
ასე რომ, რომელიც შესვლის ჩვენს array მას ეკუთვნის.
>> ასე რომ ყოველ ჯერზე მე ვაძლევ ჩემს hash ფუნქციონირებს ერთი სიტყვით,
უნდა გითხრათ, მე იგივე განათავსეთ თითოეული დრო.
ასე რომ, თუ ჩვენ ვიყენებთ hash ფუნქცია საწყისი წინა slide
სადაც ჩვენ დახარისხება მიერ პირველი წერილი ანბანი,
ყოველ ჯერზე მე ვაძლევ ჩემს hash ფუნქცია "ვაშლის"
იგი ყოველთვის უნდა მისცეს ჩემს უკან 0.
ასე რომ, თუ მე მაქვს ვაშლი დააყენა ჩემი hash მაგიდა,
თუ მე "ვაშლის" ჩემი hash ფუნქცია, უნდა ვთქვა, რომ წავიდეს დააყენოს ის bucket 0.
თუ ვეძებ apple ჩემი hash მაგიდასთან
და მე ვიტყვი, სად შეიძლება ვაშლის ცოცხალი, თქვენ თქვენს hash ფუნქცია.
და ამბობს, რომ წასვლა bucket 0.
ყველა უფლება?
კითხვები hash ფუნქციები?
გასაოცარია.
>> აქ არის ოდნავ მეტი დეტალური ახსნა
რა hash ფუნქცია შეიძლება გამოიყურებოდეს.
ყველა უფლება.
ახლა, პრობლემა hash ფუნქციები იდეალური მსოფლიოში,
ჩვენ გვინდა მხოლოდ ერთი რამ თითოეულ bucket.
მაგრამ სინამდვილეში, არსებობს არა მხოლოდ ერთი სიტყვა
რომელიც იწყება A. იქ არ არის მხოლოდ ერთი სიტყვა, რომელიც იწყება B. ასე
ამ შემთხვევაში, თუ ჩვენ მოულოდნელად მისაღებად "berry"
და ჩვენ გვინდა ვთქვათ ჩვენი hash მაგიდა,
და ჩვენ ვხედავთ, ო, არა, banana არის უკვე არსებობს, რასაც ჩვენ ვაპირებთ გავაკეთოთ?
>> ასევე, ჩვენ გვაქვს ორი ვარიანტი.
პირველი ვარიანტი ხაზოვანი probing, რომელიც
მხოლოდ იმას ნიშნავს, წასვლა შემდეგი ცარიელი bucket.
წასვლა მომდევნო ცარიელ მასივი ჩანაწერს.
და მხოლოდ დააყენა "berry" არსებობს.
ასე რომ მე ვიცი, ის უნდა წავიდეთ ერთად ბანანის bucket ერთი.
მაგრამ მხოლოდ მისი bucket სამი, იმიტომ, bucket სამი ცარიელია.
კიდევ ერთი ვარიანტი, ალბათ, რას განხორციელება
თქვენს p-set, სადაც თქვენ ჰქონდა ცალკე chaining.
ისე თითოეული თაიგულების, თითოეული თქვენი მასივი ელემენტები,
არა მხოლოდ ფლობს ერთი სიტყვა, მაგრამ რეალურად ფლობს მომცეთ სია სიტყვები.
ასე რომ, თუ თქვენ გქონდათ ბანანის თქვენი hash მაგიდასთან
და თქვენ მოულოდნელად სურდა დაამატოთ berry, არ არის პრობლემა.
უბრალოდ დაამატოთ berry წლის ბოლომდე, ან დასაწყისში, თქვენი უკავშირდება სიაში.
OK, გასაოცარია.
კითხვები hash მაგიდები, სანამ ჩვენ?
>> ყველა უფლება.
ხეები და ლელო.
OK, ასე რომ, ეს იყო კიდევ ერთი ვარიანტი განხორციელების ლექსიკონი.
თქვენ შეეძლო გააკეთა ცდილობენ.
ასე რომ, ეს განსაკუთრებული სახის ხე, რომელიც ისე იქცევა, როგორც მრავალ დონის hash მაგიდასთან.
ასე რომ თქვენ ხედავთ სურათზე სადაც თქვენ უნდა მასივი,
მიუთითებს bunch of კოლექტორები რომ წერტილი bunch of კოლექტორები
რომ წერტილი bunch of მასივები.
და ვნახავთ ზუსტად რა, რომ არ ჰგავს სამომავლო slide.
და საერთოდ, ხე არის მხოლოდ ნებისმიერი მონაცემები სტრუქტურა
რომელშიც მონაცემები ორგანიზებული გარკვეული იერარქია.
ასე რომ, სადაც ჩვენ ვნახეთ, რომ ჩვენ გვაქვს გარკვეული გაგებით
დაბრუნება დონეზე, მომდევნო დონეზე, მომდევნო დონეზე, მომდევნო დონეზე.
ასე რომ, ეს, ალბათ, ყველაზე ნათელი ზოგიერთი კონკრეტული მაგალითები.
ასე რომ აქ ჩვენი ხე.
თქვენ ხედავთ, რომ ეს აქვს კონკრეტული დონეზე
რომ ჩვენ დავიწყებთ რომ ძირეული კვანძის, ერთი.
და ჩვენ შეგვიძლია წავიდეთ ქვემოთ ჩვენი ხე.
>> ორობითი ხე არის კონკრეტული ტიპის ხე.
და ერთადერთი დაზუსტება ორობითი ხე
ის არის, რომ თითოეული კვანძის აქვს ორი საუკეთესო ფოთლები.
ასე რომ თქვენ არ ვაპირებთ, რომ ნებისმიერი ამ კვანძების სამი ან ოთხი
ან რაიმე სხვა ფოთლები.
შემდეგ კი კიდევ უფრო კონკრეტული არის ორობითი ძებნა ხე
სადაც ყველა კვანძის მარცხენა კვანძის აქვს მნიშვნელობა მცირეა.
და ყოველ ღირებულებას, უფლება იქნება დიდი.
ასე რომ, თუ ხედავთ 44 არის ჩვენი root, მარცხნივ, 11, 22, და 33
უფრო დაბალია, ვიდრე ჩვენი root.
და მარჯვენა ყველა ციფრები უფრო დიდი 66, 55 და 77.
და ეს ქონება ეხება ყველა დონეზე ხე.
>> ასე რომ, როდესაც ჩვენ დაცემას 22, 11 და 33, ჯერ კიდევ 11
მცირეა 22 და 33 მეტია, ვიდრე 22.
და ეს ხდის ადვილია მოძებნა რადგან თუ ჩვენ ვეძებთ ნომერი,
ჩვენ ვიცით, კონკრეტულად რომელი ფილიალი დაიცვას ქვემოთ.
ასე რომ, ეს უნდა შეგახსენოთ ცოტა ორობითი ძებნა.
ჰო?
>> აუდიტორია: ასე რომ, როდესაც თქვენ აღწერს ორობითი,
თქვენ თქვით, რომ მას აქვს ორი საუკეთესო ფოთლები?
HANNAH: Mm-hm.
აუდიტორია: იქნებ ეს უნდა ნაკლებად?
HANNAH: ჰო.
ასე ვთქვათ, მაგალითად, თქვენ არ აქვს კი რაოდენობის ნივთები
და თქვენ ვერ შეავსოთ თქვენი ფოთლები, ეს ჯარიმა, თუ ერთი.
OK?
გასაოცარია.
ნებისმიერი სხვა კითხვები ხეები?
OK.
>> უკან ჩვენი ცდილობს რაც მე საუბარი შესახებ ცოტა უფრო ადრე,
როგორ გვაქვს ამ მრავალ დონის მასივები.
ასე რომ, ამ შემთხვევაში, ჩვენ დავიწყოთ ზედა.
და ჩვენ შეგიძლიათ მიყევით ნებისმიერი მოცემული სიტყვა ქვემოთ.
ასე ვთქვათ გვინდოდა უნდა ვეძებოთ Turing.
ჩვენ ვიწყებთ T, დაიცვას იგი ქვემოთ მასივი, რომელიც შეიცავს U,
და დაიცვას იგი ქვემოთ სანამ ჩვენ მიღწევა ამ პატარა delta რომელიც
გვეუბნება, დიახ, თქვენ ი სიტყვა.
ნათელი on ლელო?
არაფერი წასვლა იქ?
დიახ?
აუდიტორია: არა სიმბოლო delta უნდა ეკავოს სივრცის ფარგლებში ლელო?
HANNAH: ჰო, ასე რომ არ აუცილებლად კი უნდა იყოს delta.
მაგრამ ჩვენ გვჭირდება გარკვეული გზა ვუთხრა ჩვენს კომპიუტერში უკაცრავად,
ასე, რომ ჩვენ ვიცით, რომ TUR არ არის სიტყვა.
იმის გამო, რომ ვთქვათ, ჩვენ არ გვაქვს ეს კონცეფცია დელტა, ეს კონცეფცია
გილოცავთ, თქვენ ი სიტყვა, ის გავლა და iterate T-U-R,
და მერე ამბობენ, რა, მე ვერ!
ეს უნდა იყოს სიტყვა.
მაგრამ ეს ნამდვილად არ არის.
ჩვენ გვინდა მთელი Turing იყოს სიტყვა.
ასე უნდა გვქონდეს რაღაც ბოლოს, რომელიც ამბობს, რომ, გილოცავთ,
თქვენ ი ლეგიტიმური სიტყვა.
აუდიტორია: ასე რომ, თუ ჰქონდა, როგორიც 26 ასო ანბანი,
რომ თქვენ ნამდვილად აქვს 27 keys თქვენს ლელო?
>> HANNAH: Awesome, yeah.
ასე რომ, რეალურად, მე ვფიქრობ, რომ იქნება შემდეგი slide.
Ta-da!
სადაც, თუ თქვენ გაქვთ კვანძის თქვენს ლელო, თქვენ
აპირებს აქვს 27 ბავშვები არა 26.
რაიმე შეკითხვები, რომ?
ჰო?
აუდიტორია: რატომ ცდილობს გააშუქოს ასე ბევრი სივრცე [INAUDIBLE], როგორც თქვენ წავიდეთ?
რატომ არის იგი ითვლება [INAUDIBLE]?
HANNAH: რა თქმა უნდა.
მოდით დავუბრუნდეთ.
კითხვაზე, თუ რატომ არიან ლელო იმდენად დიდი
ვიდრე რაღაც hash მაგიდასთან.
ასე რომ, თითოეული ამ დონეზე, მაშინაც კი, თუ ისინი არ შედგენილი აქ,
თქვენ უნდა ყველა 26 სიმბოლო.
და მიზეზი, რომ თქვენ ვერ თქვათ, მაგრამ ისევე, როგორც Turing, I
არ უნდა გვაქვს იმ იგივე რამ დონეზე U. ისე,
თუ მოულოდნელად უნდოდა დამატება რაღაც რომ იყო T-H,
ნეტავ უნდა ჰქონდეს შესაძლებლობების და დასძინა, რომ სიტყვა.
ასე რომ, ყოველ ერთი წერილი, თქვენ ვაპირებთ აქვს
აქვს bunch of კოლექტორები მოდის off მას.
ასე რომ თქვენ ხედავთ, როგორ მინდა მისაღებად მართლაც დიდი, მართლაც სწრაფი.
ნებისმიერი სხვა კითხვები?
ყველა უფლება.
ჰო?
>> აუდიტორია: როცა არიან ლელო უფრო სწრაფად, ვიდრე hash მაგიდები?
>> HANNAH: როდის ლელო უფრო სწრაფად, ვიდრე hash მაგიდები?
ასე რომ, თუ თქვენ მართლაც ცუდი hash ფუნქცია.
ასე ვთქვათ, მე კი, როგორიცაა, აქ არის თქვენი hash ფუნქცია.
არ აქვს მნიშვნელობა რა სიტყვა მომეცი, მე ყოველთვის
აპირებს დააყენოს ის მასივი შესვლის 0.
ასე რომ, ჩვენ დასრულდება up ერთად მხოლოდ აყენებს ყველაფერი ერთი დიდი ხნის უკავშირდება სიაში.
და ასე lookup დრო დასჭირდება უარეს n თუ ეს ძალიან ბოლომდე ჩვენს სიაში.
ერთად ცდილობენ, ჩვენ უბრალოდ უნდა iterate მეშვეობით წერილები სიტყვა.
ისე კი, თუ ჩვენ დასძინა რამოდენიმე მეტი სიტყვა ჩვენი ლელო,
ის არ მიიღებს us აღარ რათა იპოვოს კონკრეტული სიტყვა.
>> ყველა ჩვენ უნდა გავაკეთოთ არის, მაგალითად, ამ შემთხვევაში,
ვთქვათ, ჩვენ ვეძებთ zoom, ჩვენ უბრალოდ უნდა iterate
Z-O-O-M, ოთხი ასო.
ასე რომ, ეს მხოლოდ ხანგრძლივობა სიტყვა zoom.
არ აქვს მნიშვნელობა, რამდენი მეტი სიტყვა ჩვენ დააყენა ამ ცდილობენ.
ჩვენ ყოველთვის შეგიძლიათ მიიღოთ ეს იმ ოთხი ნაბიჯები.
გასაოცარია.
დიახ?
>> აუდიტორია: ასე რომ [INAUDIBLE] მასივი, არა?
>> HANNAH: Mm-hm.
აუდიტორია: თუ თქვენ ეძებს [INAUDIBLE],
რომ თქვენ უნდა გაიაროს თქვენი მასივი იპოვონ [INAUDIBLE]?
HANNAH: რა თქმა უნდა.
აუდიტორია: არ, რომ მეტი დრო?
HANNAH: თუ მე ვაპირებ ამბობენ, რომ ჩემი მასივი ყოველთვის
იქნება A, B, C, D, E, F, G, blah blah blah,
ასე რომ, თუ მე ყოველთვის ვიცი, რომ ეს იმავე ზუსტი მიზნით,
თუ მე ყოველთვის ვიცი, რომ ეს ანბანური თანმიმდევრობით,
მე შემიძლია მხოლოდ ვთქვა, O არის ნომერი ასე და ასე ანბანი.
უბრალოდ გადადით ამ ადგილას.
იმიტომ, რომ მახსოვს, მასივები, ჩვენ შეუძლია
ნებისმიერი ელემენტი, რომ მასივი მუდმივ დროს, თუ ჩვენ ვიცით, სადაც ჩვენ ვეძებთ.
ჰო?
>> აუდიტორია: წინა ლღობას [INAUDIBLE] 27
მაგრამ 26 პირველი.
>> HANNAH: ბოდიში?
>> აუდიტორია: პირველი არ არის ერთი 0, ასე რომ არ იყოს, 26?
>> HANNAH: რა თქმა უნდა, ასე რომ, როდესაც ჩვენ ვამბობთ, 27, რომ აპირებს მოგვცეს მაჩვენებლების 0 მეშვეობით 26.
მაგრამ თუ თქვენ ნამდვილად ითვლიან იმ გარეთ, ეს იქნება 27.
კარგი კითხვაა.
არაფერი?
ჰო?
>> აუდიტორია: ასე რომ, ლელო ნელა, ვიდრე hash მაგიდები?
>> HANNAH: ლელო ვაპირებთ იყოს, თეორიულად, ვიდრე hash მაგიდები
მაგრამ დასჭირდეს მეტი მეხსიერება.
ჰო?
აუდიტორია: [INAUDIBLE]?
>> HANNAH: მე ბოდიში, მე არ მესმის თქვენ.
აუდიტორია: [INAUDIBLE].
0 დან 25 გაძლევთ 26.
>> HANNAH: 0-დან 25 რომ გაძლევთ 26, მარჯვნივ.
>> აუდიტორია: და მერე [INAUDIBLE].
HANNAH: Right.
ასე რაოდენობის ჩვენ მითითებით არის ხმების რამ ჩვენს მასივი.
ასე რომ, თუ ჩვენ გვაქვს 27, ის აპირებს მოგვცეს 0
მეშვეობით 26, რომელიც მისცემს ჩვენს ოთახში, ამ შემთხვევაში,
მე არ ჩათვლით აპოსტროფი.
ასე რომ, ჩვენ ვიღებთ 0 მეშვეობით 25 პირველი 26 ასო ანბანი,
ან 26 ასო ანბანი.
და შემდეგ რომ ბოლო რამ, ჩანაწერში არის 26 წლის
იქნება გამშვები ნიშნის, ან delta.
არაფერი?
გასაოცარია.
დავკარგე სივრცეში.
OK, მაგარი.
>> ასე რომ, ჩვენ უკვე შეეხო ამ.
მაგრამ დიდი სავაჭრო off შორის ლელო და hash მაგიდები
ის არის, რომ ცდილობს უზრუნველყოფს, თეორიულად, მუდმივი ეძებოთ
ჯერ, მაგრამ გამოიყენოს მთელი მეხსიერების დიდ ნაწილს.
ყველა უფლება, ახლა ჩვენ გვაქვს ოდნავ ნაკლებია რთული სტრუქტურები,
და ჩვენ უნდა გაკეთდეს C, და ჩვენ გადაადგილება უფლება გასწვრივ.
>> ასე stacks, ჩვენ ვნახეთ ეს ლექცია, სადაც თქვენ
აქვს რაღაც დასტის ქაღალდის, სადაც
ბოლო რამ დააყენა დასტის აპირებს
უნდა იყოს პირველი, რაც თქვენ მიიღოს off.
ასე რომ, ეს რა განსაზღვრავს დასტის ის არის, რომ ბოლო რამ დააყენა
იქნება პირველი რამ თქვენ მიიღოს off.
და ტერმინოლოგიის, რომ ჩვენ ვიყენებთ თუ ჩვენ ვაპირებთ, რომ რაღაც,
თუ ჩვენ ვაპირებთ, რომ დაამატოთ რამე ჩვენი დასტის, ჩვენ მოვუწოდებთ, რომ უბიძგებს.
და თუ ჩვენ რაღაც off, ჩვენ მას popping.
და თუ ჩვენ ვაპირებთ განახორციელონ დასტის, ჩვენ
უნდა იყოს დარწმუნებული, რომ ტრეკზე ორივე ზომა და მოცულობა.
ასე რომ საერთო რაოდენობის ელემენტები ჩვენ შეგვიძლია გამართავს და მიმდინარე რაოდენობის ელემენტები
რომ ჩვენ ვაწარმოებთ.
>> და ძალიან ანალოგიურად, ჩვენ გვაქვს რიგები.
და ერთადერთი განსხვავება ნაცვლად ერთად stacks,
ჩვენ ვთქვით, ბოლო რაც ჩვენ დააყენა პირველი, რაც ჩვენ გამეხადა.
ასე რიგები, პირველი, რაც ჩვენ დააყენა
იქნება პირველი, რაც ჩვენ აიღოს.
ასე რომ, ეს, როგორიცაა, თუ თქვენ რეალურად უგულებელყოფა მდე მაღაზიაში
და თქვენ მიმდინარეობს დაეხმარა, მაშინ პირველი პირი ხაზი
უნდა იყოს პირველი, ვინც დაეხმარა.
ისე, რომ იქნება მდგომ.
>> ასე რომ, ჩვენ უნდა შევინარჩუნოთ სიმღერა ზომა, მოცულობა, და ხელმძღვანელი რადგან ჩვენ
აპირებს ყველას off წინა სიის ნაცვლად უკან.
კითხვები რომ?
ნებისმიერი C კითხვებს, რაც აწუხებდა თქვენ?
მონაცემთა სტრუქტურები, რომელიმე რომ fun stuff?
ყველა უფლება, ზემოთ.
ასე რომ მე გადასცემს Alison to ხტომა შევიდა კიდევ რამდენიმე პროგრამირების.
>> ALISON: Oh, ჩვენ დავინახავთ.
ჩვენ დავინახავთ, თუ რამდენად კარგად გავაკეთო აქ.
OK, მე ვაპირებ ცდილობენ და ფრენა ამ პერსონალის, ბიჭები.
Hannah წავიდა ძალიან in სიღრმე ყველა მისი რამ.
მე ვაპირებ ცდილობენ, რათა თქვენ სწრაფი აფეთქების მიმოხილვა
ასე რომ ჩვენ შეგვიძლია მივიღოთ Davin ყველა გართობა JavaScript და უსაფრთხოების საკითხებზე,
რომ იქნებ რეალურად გვინდა მოვისმინოთ მეტი.
>> OK, როგორც Hannah თქმით, თუ თქვენ გაქვთ რაიმე შეკითხვები,
მე ვაპირებ ძალიან სწრაფი, გთხოვთ, ნება მომეცით ვიცი.
მე უპასუხოს კითხვებს, როგორც საჭიროა.
ასე უნდა დაიწყოს, ჩვენ ვაპირებთ, რომ დაიწყოს ალბათ ერთ-ერთი პირველი რამ
თქვენ ისწავლა ვებ პროგრამირების, ნებართვები.
ასე chmod, თქვენ ბიჭები უნდა უკვე ოსტატები ამ ყველა ვებ
პროგრამირების, რომ თქვენ აკეთებდა ბოლო პერიოდში.
ეს, ძირითადად, მხოლოდ ბრძანება რომელიც ცვლის ნებართვები
ან წვდომის უფლებები ჩვენი ფაილური სისტემის ობიექტების.
რა თქმა უნდა, რეალურად ვხედავ ამ, თუ თქვენ
რაიმე პრობლემები ამ დროს თქვენი პრობლემა კომპლექტი,
თქვენ შეიძლება არ გამოიყენება ls-l, რომელიც დიდი ხნის განმავლობაში, მისაღებად კალენდარი სახის როგორც ეს,
სადაც თქვენ რეალურად ვხედავ ყველა ნებართვების ფაილი.
>> და მართლაც, ჩვენ უბრალოდ აპირებს მეშვეობით საკმაოდ სწრაფად მხოლოდ საკმაოდ
ბევრი რა თითოეული ეს ნიშნავს.
ასე რომ, ჩვენ არ მინდა სწორედ აქ, რომელიც უბრალოდ დგას დირექტორია.
ცხადია, აქ, ჩვენ ვხედავთ, rwx, რომელიც იკითხება, ჩაწერა და გაშვება.
ეს შეიძლება წარმოდგენილია როგორც ბიტი, რომელიც ჩვენ შეღწევას მომდევნო გვერდზე.
ასე რომ, ყოველ triad, რომ ჩვენ ვნახეთ აქ, ასე რომ ეს სამი triads.
ჩვენ rwx, r არაფერი x და r არაფერი x ამ პირველი ფაილი.
ეს ამ ზოგადი სტრუქტურა.
>> ასე რომ, ჩვენ გვაქვს დირექტორია.
ჩვენ გვაქვს გარკვეული ჯგუფი ამ უფლებები.
ზოგიერთი ჯგუფი, რომელიც აქვს ეს უფლებები, და მსოფლიოს, რომ აქვს ნებართვა.
თქვენ შეგიძლიათ ვფიქრობ, ეს როგორც triad.
თქვენ შეგიძლიათ ვფიქრობ, ეს როგორც სამი ბიტი.
ასე რომ მათ შეუძლიათ გამართავს ღირებულებები ყველგან 0-
7, რის გამოც ზოგჯერ ჩვენ გვქონდა, რომ თქვენ ამის chmod
600 ნაცვლად chmod rw რასაც.
ჩვენ შეღწევას მაგალითად.
მაგრამ, ძირითადად, შეგიძლიათ წარმოიდგინოთ, ეს როგორც ან უბრალოდ rwx,
ან შეგიძლიათ ვფიქრობ, რომ მათ გარკვეული ნომერი, სადაც ეს პირველი აქ
წარმოადგენს დან 0 და 7, მეორე
წარმოადგენს დან 0 7, ხოლო მესამე
წარმოადგენს რიცხვი 0 და 7, OK?
>> r აქვს მნიშვნელობა 4. w აქვს მნიშვნელობა 2, და x
აქვს მნიშვნელობა 1, რის გამოც ეს ნებართვა აქ იქნება chmod 700.
რადგან ამ შემთხვევაში აქ, იგი ამბობს, რომ ჩვენ არ პირველად ცოტა იქ სავალი შესახებ.
ამიტომ ჩვენ გვაქვს 4 წაკითხული.
მეორე ცოტა სავალი on for w, რომელიც 2, ახლა ჩვენ 6.
და მესამე ცოტა სავალი on x, რომელიც 1, ამიტომ ჩვენ კიდევ შვიდი.
და რა თქმა უნდა, ჩვენი ჯგუფი და ჩვენი სამყაროს თითოეული 0.
ასე რომ, ეს არის ასევე ექვივალენტი chmod 700.
და მე აუცილებლად ცდილობენ მესმის რუკების შორის იმ.
მე არ ვარ დარწმუნებული, თუ მას ამუშავება ვიქტორინა ადრე,
მაგრამ ეს იქნება კითხვა, რომელიც მე შეიძლება ვთხოვოთ.
>> უბრალოდ ცოტა აპირებს კი შემდგომი chmod აქ, აქ
არის ძალიან ზოგადი სტრუქტურა chmod ზარი.
ასე რომ, რა თქმა უნდა, ჩვენ არ chmod აქ.
მითითება, თუ რა ეს შეეხება არის რომლებიც ჩვენ ვაძლევთ ამ ნებართვას
ან რომლებიც ჩვენ აღების ამ ნებართვების დაშორებით.
ამიტომ ჩვენ გვაქვს აქ უფლებები, როგორიცაა ჩვენ მოცემული chmod პლუს x,
როგორც ვნახავთ მალე.
მხოლოდ იმას ნიშნავს, რომ მისცეს ამ კონკრეტული ნებართვების ყველას.
მისცეს მათ ყველა.
ასე რომ თქვენ შეიძლება ძალიან კარგად აქვს u + x ან გ plus x ან o plus x ან მრავალჯერადი
მისი.
ასე რომ, პირველი ნაწილი ყოველთვის იქნება ცნობას.
ვინ ვართ ჩვენ ვაძლევთ ამ ნებართვას, ან რომლებიც ჩვენ არ წაერთმიათ ისინი?
>> მეორე ოპერატორი.
ასე რომ თქვენ ბიჭები ძირითადად შეეხო plus.
ეს აძლევს უფლებები ვინც თქვენ მათთვის,
ხოლო მინუს, ლოგიკურად, შლის მათ.
ასე რომ არაფერი ძალიან საშინელი იყო.
და შემდეგ რეჟიმები არის ის, რაც ჩვენ ვისაუბრეთ ერთად კითხვის, წერის, ან შესრულებაში.
ასე პლუს x ნიშნავს მისცეს შემსრულებელი ნებართვების ყველას.
და მაშინ, რა თქმა უნდა, რომელიც კონკრეტული ფაილი ან დირექტორია.
OK?
ყველას კარგი chmod?
არ არის ძალიან ცუდი?
>> OK, ასე რომ HTML, რომელიმე ხართ ძველი საკმარისი, რომელთა მიზანია: MySpace ასაკი?
მე გაგზავნილი ამ ჩემს განყოფილებიანი, და ფაქტიურად ნახევარი ხალხი
შემომხედა, როგორიც მე ვიყავი გიჟები.
მე კი, როგორიცაა, ბიჭები, ჩვენ არა ვართ, რომ ძველი.
მოდის.
ასე HyperText Markup Language, ეს პატიოსნად მხოლოდ გზა, რომ თქვენ
არაა გარკვეული რამ ინტერნეტში.
ასე რომ, ეს მარკირებას ენა.
ეს არ არის სკრიფტინგის ენა.
არ არსებობს ლოგიკა მას.
ეს არის უბრალოდ შეცვალოს გზა რაღაც არის ნაჩვენები.
OK, ასე რომ, ეს არის მნიშვნელოვანი განსხვავება მიიღოს.
ეს ითვლება მარკირებას ენაზე არ არის სკრიფტინგის ენა.
>> ასე რომ, აქ ჩვენ გვაქვს ჩვენი HTML tags.
ამ slide, ალბათ, ყველაზე პირობა, რომ თქვენ უნდა იყოს იცნობს
და მართლაც კომფორტულად.
ამიტომ ცხადია, რომ ჩვენ გვაქვს ჩვენი HTML tag, რომელიც
ნიშნავს, რომ ყველაფერი ამ ორ იქნება HTML.
ჩვენ გვაქვს გარკვეული კავშირი, რომელიც აშკარად მოგცემთ
ბმული გარე ვებ გვერდზე.
ზოგიერთი სათაური, ჩვენს ხელმძღვანელი აქ.
და ჩვენ გვაქვს ჩვენი სხეულის h1, რომელიც არის header,
ასე რომ ყველაფერს, რათა ის ლამაზი და თამამი და დიდია.
და შემდეგ, ჩვენ გვაქვს p, რომელიც არის პარაგრაფი.
თქვენ ალბათ იცით, და იყოს იცნობს რამ
როგორიცაა, თუ როგორ ჩასვათ გამოსახულება, რომლებიც არსებობს რაიმე სხვა header კლასი?
მე აუცილებლად იქნება კომფორტული div.
ასე რომ, ეს უმრავლესობას tags რომ თქვენ უნდა იყოს იცნობს.
მაგრამ, რა თქმა უნდა, როგორც ყველაფერს CS 50, სია არ არის ამომწურავი.
ასე რომ დარწმუნდით ფუნჯი up on რომ.
>> CSS, ასე რომ CSS, თუ რომელიმე თქვენგანი უყურებს ჩემი სემინარი ორი კვირის წინ,
მართლაც მხოლოდ გზა სტილი თქვენი ვებ გვერდი?
OK, ასე რომ, ჩვენ გვაქვს გარკვეული მარკირებას ენაზე.
HTML, რომელიც ზრუნავს მხოლოდ ტექსტი და სადაც არ უნდა იყოს ის გვერდზე.
მაგრამ CSS მართლაც რა ხდის საკმაოდ.
თქვენ შეიძლება ეს თქვენს HTML ფაილი, მაგრამ, როგორც ჩვენ ვსაუბრობთ შემდეგ,
მე დარწმუნებული ვარ, რომ შესაძლოა იყოს შემდეგი slide, ის
ჩვეულებრივი პრაქტიკაა, და რეალურად პრაქტიკაში, რომ ჩვენ ნამდვილად მოგიწოდებთ,
თქვენ შენარჩუნება მათ გამოეყო, როდესაც ჩვენ ვისაუბროთ MVC და რომ მთელი პარადიგმა.
ეს მართლაც რა ამ არხებს.
>> ასე რომ CSS არის მხოლოდ გზა რათა რამ გამოიყურება საკმაოდ.
რამ აქ, ისევე, სხეულის და #title და .info,
ეს ეწოდება სელექციონერები და რა ისინი აკეთებენ, ისინი შერჩევა კონკრეტული რამ
თქვენი HTML ფაილი და ვრცელდება რასაც სტილი,
რასაც სახის რამ, რომ გსურთ, რომ კონკრეტული ელემენტის თქვენი ვებ
გვერდზე.
ასე რომ, აქ, ჩვენ გვაქვს ფონის ფერი და ფერი
და შრიფტის ოჯახი, რომელიც მიმდინარეობს მიმართა, რაც არის სხეულში.
ასე რომ, თუ ჩვენ ჩანდა უკან აქ, არ ვრცელდება ტიტული.
ეს მხოლოდ ვრცელდება, რა არის ამ ორგანოს სელექციონერები, OK?
>> სათაური აქ, ეს არის იქნება იგივე,
ფერი ტექსტი მყოფი ლურჯი მხოლოდ აპირებს
რომ მოახდენს რა არის შიგნით სათაური სელექციონერები.
ისევე, როგორც ინფორმაცია აქ, ტექსტი იქნება ვარდისფერი,
რასაც ის ინფორმაცია, რომელიც არის სწორი აქ.
ასე რომ, მხოლოდ ის, რომ იქნებოდა ვარდისფერი ამ გვერდზე
არის თარიღი, Monday, November 17, 2014.
OK, ასე რომ CSS არის მხოლოდ გზა უფრო მეტი კონტროლი over-- yes?
>> აუდიტორია: რატომ უნდა გამოიყენოთ hash სათაური?
>> HANNAH შემდეგი slide, გპირდებით!
ჩვენ იქ.
სწორედ ამიტომ ჩვენ უნდა გამოვიყენოთ hash.
ასე სელექციონერები მიიღოს სამი ძირითადი ფორმები, რომ ჩვენ გაიგო, რომ ბიჭების შესახებ.
მე fyou გსურთ შეიტყოთ უფრო, არსებობს უამრავი არსებობს.
არსებობს დიდი CSS დოკუმენტაცია.
არსებობს tag სახელი, რომელიც უნდა გააკეთოს მხოლოდ თქვენი ნორმალური ტეგები HTML.
ასე h1, p, div, h2, იმ სახის ნივთები.
და ჩვენ შეგვიძლია მხოლოდ ასახელებს იმ, როგორც არის.
ასე რომ, როგორც ვხედავთ აქ ორგანო, ნორმალური აქვს.
ასე რომ ჩვენ შეგვიძლია დააყენა სხეულის, როდესაც ჩვენ ვსაუბრობთ ჩვენი CSS ფაილი.
>> სათაური, მთელი მიზეზი აქვს ამ hash გვაქვს, რა არის
ითვლება ID.
ასე ID ყოველთვის უნდა იყოს უნიკალური თქვენი HTML გვერდი
ასე რომ, როდესაც თქვენ ხართ მხედველობაში ის, რომ თქვენ
იცით, რომ თქვენ მხოლოდ გულისხმობდა ერთი კონკრეტული რამ.
ასე რომ, ამ შემთხვევაში აქ, ჩვენს h1 აქ, CS 50 განხილვის სხდომაზე,
ჩვენ გვაქვს id სათაური.
ასე რომ, რათა უბრალოდ ეხება, რომ ნაწილი ჩვენი HTML, ვაკეთებთ hash სათაური.
მხოლოდ კონვენციის, პირადობის ინიშნებიან ერთად hash მათ წინაშე.
იმ გზით, ჩვენ ვხედავთ, ინფორმაცია აქ არის კლასი.
და ასე კლასი CSS არის დანიშნული როგორც dot კლასის
ან dot რასაც კლასში.
ასე რომ, ამ შემთხვევაში აქ, ეს ინფორმაცია.
>> ასე რომ მე მას უკან.
ორივე ეს იქნება ვარდისფერი ჩვენი CSS აქ
რადგან ორივე კლასში ინფორმაცია.
და ჩვენი CSS ფაილი, ჩვენ გვყავს რომ არაფერი ერთად კლასის ინფორმაცია
უნდა იყოს ვარდისფერი.
ამჯამად რომ აზრი?
დიახ?
>> აუდიტორია: თუ იყო, რათა ყველაფერი ორგანო თეთრი,
და შემდეგ თქვენ ცდილობენ რაღაც შიგნით ლურჯი,
მინდა, რომ გამოიწვიოს პრობლემები?
>> HANNAH: So CSS არის კასკადური სტილების.
ასე რომ, რაც არის მიმართული ბოლოში იქნება უპირატესი.
ასე რომ, თუ თქვენ რაღაც სხეულის, და თქვენ ყველაფერი თეთრი,
და შემდეგ თქვენ სახელწოდების შეცვლის ან შეცვალოთ ტექსტი ფარგლებში ორგანოს,
მას overwrites რომ.
ისე არაფერი მიმართ ბოლოში იქნება უპირატესი.
დიახ?
>> აუდიტორია: და პირადობის მოწმობები არის უნიკალური, მაგრამ კლასების შეიძლება იყოს მეტი?
HANNAH: Right.
ასე პირადობის მოწმობები უნდა იყოს უნიკალური და კლასი საიტიდან ეხება, როგორც ბევრი რამ, როგორც თქვენ გსურთ.
ნებისმიერი სხვა კითხვები?
დიახ.
>> აუდიტორია: [INAUDIBLE].
მე მაინტერესებს, არის თუ არა რომ ქმნის განსხვავებას.
HANNAH: მე ბოდიში, რა იყო კითხვა?
აუდიტორია: არსებობს პატარა "ვ" და კაპიტალის "ფ"
HANNAH: ასე რომ, განსხვავება შორის მცირე "ვ" და კაპიტალის "F"
არ უნდა მიიღოს განსხვავება.
ასე რომ, "ვ" იქნება 15 ან გზა.
მაგარი, არაფერი?
ყველას კარგი, CSS?
დიახ?
>> აუდიტორია: უკაცრავად.
შეგიძლიათ აქვს კლასი და ID?
>> HANNAH: დიახ, შეგიძლიათ.
რამ შეიძლება ორივე კლასი და პირადობის მოწმობა.
და მე მაღალ რეკომენდაციას ტესტირება ეს თქვენი საკუთარი.
CSS თქვენ შეისწავლით საუკეთესო მხოლოდ მიღების რაღაც, ძალიან მარტივი ვებ გვერდზე,
შედგენის ზოგიერთი CSS, და მხოლოდ ხედავს, თუ როგორ შეარჩიონ.
და თქვენ მოიპოვოს ძალიან კარგი, ინტუიციური გრძნობა როგორ მუშაობს.
>> OK, ყველას კარგი CSS?
თქვენ ყველა აპირებს, რათა ლამაზი საიტებზე CSS ახლა.
OK, საუკეთესო პრაქტიკის, უბრალოდ რამ უნდა გვახსოვდეს, რამ
that-- ამიტომ დოკის თქვენ დიზაინერი და whatnot.
ასე ახლოს ყველა თქვენი HTML tags.
ასე რომ, თუ თქვენ გაქვთ ღია ორგანოს, არ უნდა იყოს ახლოს სხეულის.
თუ თქვენ გაქვთ ღია პუნქტის, არ უნდა იყოს ახლოს პუნქტში.
შეამოწმეთ თქვენი გვერდი ამტკიცებს.
თქვენ ბიჭები უნდა იყოს ძალიან ნაცნობი ამ გვ-შვიდი
ერთად CS 50 ფინანსთა ერთად W3 დამტკიცება.
და, როგორც ვთქვი, ჩვენი ერთ-ერთი დიდი პარადიგმები
არის ჰყოფს თქვენი სტილის ცენტრთან თქვენი markup, რომელიც HTML.
და მაშინ, რა თქმა უნდა, ჩვენ გვაქვს ამ დიდი xkcd ქვემოთ აქ.
Yay, კომიკური რელიეფის,
>> OK, TCP / IP.
შორის და HTTP, ძირითადად ისინი ორივე ოქმები.
ასე რომ თქვენ შეიძლება უბრალოდ ვფიქრობ, მათ, როგორც კომპლექტი წესები
რომ არეგულირებს, თუ როგორ რამ გადაადგილება მთელს ინტერნეტში.
ასე გადამცემი კონტროლის ოქმი, ან ინტერნეტ ოქმი,
მხოლოდ გზა დარწმუნდით რომ მონაცემები იღებს, სადაც ის აპირებს
და რომ ჩვენ ვიცით, თუ ჩვენ ოდესმე დაკარგული მონაცემები.
ასე რომ, თუ თქვენ ბიჭები ვფიქრობ, უკან ლექცია რამდენიმე კვირის წინ, დავით
სადაც ჩვენ გვქონდა ოთხი კონვერტები, ისინი იყო დათვლილია, როგორც ერთი ოთხი,
ორი ოთხი, სამი, ოთხი, ოთხი ოთხი, ეს არის უბრალოდ წესები.
ჩვენ ვთქვით, OK, როდესაც ჩვენ გაგზავნის ერთზე მეტი პაკეტი,
ჩვენ ვაპირებთ ნომერზე იგი, რა რაოდენობის, რომ ეს
და რამდენი საერთო, რომ მომხმარებელი უნდა მიიღოს.
>> და ეს უბრალოდ ვეუბნებოდი ყველას, ვინც იღებს მონაცემებს თუ არა ისინი
მიღებული ყველაფერი ან თუ რაღაც დაიკარგა გასწვრივ გზა.
და მათ უნდა ვთხოვო მას ერთხელ.
ეს არის ნამდვილად წესები.
ეს არის ის, თუ როგორ შეიძლება ვიფიქროთ, რომ ეს, OK?
და ასევე, ის განსაზღვრავს პორტი, რომელიც თქვენ ბიჭები can-- ვიცი დროს ლექცია,
მათ ჰქონდათ მთელი სია პორტები.
მაგრამ ჩვენ არ გვაქვს, რომ მათ აქ ახლა.
>> ასე ჰიპერტექსტის გადაცემის პროტოკოლი კიდევ ერთხელ, ეს არის კიდევ ერთი ოქმი.
ასე რომ, ეს არის კიდევ ერთი კომპლექტი წესები რომ მართოს, ამ შემთხვევაში,
როგორ ჰიპერტექსტის გადაეცემა.
ასე რომ, ეს უბრალოდ საშუალებას ბრაუზერები საუბარი ვებ სერვერები.
და, როგორც ვთქვით, აქ ეს როგორიცაა ადამიანის handshaking.
ეს უბრალოდ გზა მართავენ როგორ სერვერზე არის
ხდება ურთიერთქმედება თქვენი ბრაუზერის.
და ჩვენ გვაქვს მხოლოდ რამდენიმე მაგალითი.
ჩვენ გვაქვს გარკვეული მოთხოვნები აქ სადაც GET მეთოდი.
ჩვენ გვაქვს HTTP 1.1, რომელიც ოქმის ვერსია ჩვენთვის.
და მაშინ, მასპინძელი, რაც ჩვენ რეალურად ცდილობს წვდომას.
და შემდეგ, როგორც ხედავთ აქ, ჩვენ მიიღოთ გარკვეული პასუხი ამ 200
OK, როგორც ჩვენი HTTP რეაგირების კოდი.
ჩვენ გვაქვს დიდი ჩამონათვალი მე ვაპირებ დახევის up ერთ წამში
რომ თქვენ ბიჭები უნდა იყოს იცნობს.
და ჩვენ გვაქვს ამ შინაარსის ტიპის ტექსტის / HTML, რომელიც მხოლოდ ამბობს თუ რა სახის მონაცემები
ვართ ჩვენ მიღების სერვერზე, OK?
ამ მასპინძელი და ამ შინაარსის ტიპი ნაწილი ვართ HTTP სათაურებში.
თქვენ შეგიძლიათ როგორც რამდენიმე ან როგორც პატარა, როგორც საჭირო კონტექსტში, რა
თქვენ საქმე.
ზოგჯერ თქვენ უნდა ბევრი ინფორმაცია მოდის თქვენს სერვერზე.
იქნებ ისინი მოთხოვნის ბევრი ინფორმაციის შესახებ.
ეს დამოკიდებულია კონტექსტში.
თუ გადავხედავთ CS 50 კვლევა, არსებობს ბევრი უფრო, რომ.
მაგრამ ჩვენ გვაქვს ბევრი მისაღებად მეშვეობით, ისე მე ვაპირებ
წასვლა უფლება ადრე თუ ეს OK თქვენ ბიჭები?
მაგარი.
გაიმართება.
მე ნამდვილად აქვს, რომ მთელი სია of-- huh!
მე არ ვიცი, ამიტომ ეს ყველა გზა აქ.
ვფიქრობდი, სიტყვასიტყვით გადავიდა ეს მაშინ, როცა მე ვიყავი sitting--
>> Davin გსურთ ასწავლოს მას?
ან გინდა, ასწავლოს მას?
>> აუდიტორია: ვფიქრობდი, რომ უბრალოდ ვაჩვენოთ იწყება.
ვგულისხმობ, თქვენ შეგიძლიათ შეხვიდეთ მათ შემდგომი, მაგრამ მე
ეგონა, რომ ეს კიდევ უფრო გრძნობა, რადგან მე იყო უბრალოდ ვსაუბრობთ HTTP სტატუსის მიხედვით.
ასე რომ, აქ არის მთელი სია.
ვფიქრობ, რა მოხდება არის Davin აპირებს წასვლას მათ მოგვიანებით.
მაგრამ არსებობს მთელი სია, ესკიზი გემოვნების მოვა.
OK, ჩვენ ვაპირებთ blow-- ამ აპირებს იყოს PHP ავარიის კურსი, როგორც სხვა.
>> ასე PHP, ჰიპერტექსტის preprocessor, ეს რეკურსიული backronym,
რაც იმას ნიშნავს, მას ეწოდა რაღაც.
და მაშინ ისინი ისევე, როგორც ეს ნამდვილად არ აქვს აზრი.
ასე რომ, ისინი მხოლოდ დასახელებული it-- და ეს იყო აკრონიმი,
ასე რომ, ისინი მხოლოდ გააკეთა ის PHP ჰიპერტექსტის preprocessor, რომელიც
უბრალოდ აზრი არ აქვს.
სახალისო ამბავი.
ის პროგრამირების ენაზე.
ასე რომ, როგორც მე აღვნიშნო, რომ HTML არ არის პროგრამირების ენა,
ეს მარკირებას ენა, PHP არის პროგრამირების ენა.
როგორ თქვენ იცით, რომ ეს არის იმიტომ, რომ იქ არის ლოგიკა.
არსებობს პირობით.
ჩვენ გვაქვს ცვლადები, ჩვენ კი აქვს არც ერთი იმ რამ HTML.
>> ყველა უფლება, მაშინ ჩვენ გვაქვს ამ პატარა ცოტა აქ, რომ ისევე, გემოვნების PHP.
ასე საფუძვლებს, ცვლადი სახელები დაიწყოს დოლარის ნიშანი.
უამრავი ადამიანი, როგორც ეს.
მოგვაგონებს us ფული.
ეს ყველაფერი დიდი.
ჩვენ ყველას გვინდა PHP.
ასე რომ, ჩვენ არ დააკონკრეტა ცვლადი ს ტიპის აღარ.
იგი განისაზღვრება პერსპექტივაში დრო.
თარჯიმანი იქნება, oh, ჩვენ უბრალოდ აწარმოებს მეშვეობით,
და კონტექსტის მიხედვით, ჩვენ დავინახავთ, თუ რა სახის სახის
ეს ცვლადები უნდა ჰქონდეს.
არ ძირითადი ფუნქცია.
რამ მხოლოდ აწარმოებს.
თქვენ ბიჭები თქვენი იმპორტის თქვენი ბოლო p მითითებული, თქვენ შეამჩნევთ ამ.
არსებობს ნამდვილად არ იყო მთავარი ფუნქცია.
თქვენ უბრალოდ დაწერა რა თქვენ სურდა მოხდეს.
და ეს მხოლოდ სახის მოხდა.
ისე, რომ PHP თქვენთვის.
>> კოლექტორები ძალიან ჰგავს.
ჩვენ ჯერ კიდევ გვაქვს ამ bracket.
აქ, ჩვენ გვაქვს რამდენიმე ცვლადი მოუწოდა arr, და ეს თანაბარი
რომელთა მიზანია ჩვენ გვაქვს ჩვენი ნორმალური bracket notation.
და ჩვენ გვაქვს გასაღები ღირებულება.
და დიდი განსხვავება შორის C და PHP მასივები
არის, რომ ჩვენ შეგვიძლია ამ ასოცირებული ჩვენ შეგვიძლია გაერთიანდნენ ფასეულობები გასაღებები.
ასე რომ ნაცვლად მხოლოდ მქონე მასივი, რომ ინდექსირებული
რაოდენობის და პოზიცია რომ ელემენტს მასივი,
ჩვენ შეგვიძლია რეალურად გაიგივებას გასაღები.
სადაც ჩვენ შეგვიძლია ვთქვათ, OK, მე მინდა რასაც მნიშვნელობა უკავშირდება ხილი.
და იქნებ ჩვენ გვაქვს ხილის წავიდა ბანანი.
ასე რომ, მინდა დაბრუნდეს ბანანის ჩვენთვის.
>> მაგრამ, ძირითადად, ყველაზე ძლიერი რამ შესახებ ეს
არის, რომ თუ ბიჭები გახსოვთ დემო ლექცია სადაც ჩვენ ძირითადად
Rewrote speller PHP, და ეს was-- lookup მართლაც მხოლოდ მინდა,
ჯერ ეს გასაღები არსებობს?
რომ მართლაც ასეთი ძალა მას.
თქვენ არ უნდა iterate მეშვეობით თქვენი მასივი.
თქვენ არ უნდა იცოდეთ რა ადგილი არის.
ეს შეიძლება იყოს ბოლოს ან დასაწყისში.
რადგან თქვენ იცით გასაღები რომ ასოცირდება ღირებულება,
PHP შეიძლება მხოლოდ შამფურზე, რომ ღირებულება უფლება უკან out at თქვენ, OK?
>> და შემდეგ, ჩვენ ასევე მხოლოდ აქვს მხოლოდ იმიტომ, რომ ჩვენ
შეიძლება ჰქონდეს გასაღები ღირებულება წყვილი იმას არ ნიშნავს, რომ თქვენ უნდა.
ასევე შეგიძლიათ მხოლოდ შექმნა ნორმალური მასივი, როგორიც აქ,
ბოლოში, სადაც ის მხოლოდ ერთი, ორი, სამი, ოთხი.
ესენი არიან ჩვენი ღირებულებები.
და სხვათა შორის, მათი გასაღებები არიან მაჩვენებლები.
ასე გასაღები ერთი იქნება ნულოვანი.
საკვანძო ორი იქნება ერთი.
ასე შემდეგ და ასე შემდეგ, თუ თქვენ მკაფიოდ დაავალოს გასაღები,
თქვენ შეიძლება ვივარაუდოთ, რომ მნიშვნელობა არის მათი ინდექსი.
არა, რომ აზრი, რომ ყველასთვის?
კითხვები არ?
გასაოცარია.
>> OK, foreach არის გზა iterate საშუალებით თქვენი მასივები.
ამიტომ ჩვენ გვაქვს რაღაც აქ, მხოლოდ ზოგადი სტრუქტურა.
ასე foreach, სახელი ჩვენი მასივი, რაც არ
თქვენ მინდა მოვუწოდო თითოეულ ელემენტის თქვენს მასივი,
და ჩვენ შეგვიძლია გავაკეთოთ რაღაც ერთად რომ ელემენტს და რომ ღირებულება.
ასე რომ, ჩვენ გვაქვს მაგალითი აქ.
ჩვენ გვაქვს ასოციაციურ array ამ ორ მასალა
ბარ მიმდინარეობს ასოცირდება foo და qux, რომელიც დაკავშირებულია baz.
ასე გასაღებები foo და baz.
ღირებულებები ბარი და qux.
ასე foreach, ჩვენ ჩვენი მასივი აქ, როგორც გასაღები ღირებულება წყვილი.
ეს საშუალებას გვაძლევს ხელმისაწვდომობის როგორც გასაღები და მნიშვნელობა.
იქნებ უბრალოდ გვინდა მნიშვნელობა, ამ შემთხვევაში
თქვენ შეიძლება უბრალოდ, როგორიცაა arr როგორც $ მნიშვნელობა, და მაშინ
უბრალოდ წვდომის ღირებულება რადგან თქვენ iterate მეშვეობით.
მაგრამ იქნებ, რამდენიმე ამიტომ, თქვენ გჭირდებათ გასაღები,
რის გამოც მე აირჩია ეს მაგალითი ნაცვლად.
ასე რომ თქვენ შეგიძლიათ რეალურად მანიპულირება გასაღები და მნიშვნელობა ამ შემთხვევაში.
OK?
კითხვა?
>> აუდიტორია: თუ უნდოდა უბრალოდ მანიპულირება გასაღები, რომ
თქვენ უნდა გავაკეთოთ foreach--
>> ALISON: Right.
ასე რომ, თუ თქვენ სურდა მანიპულირება მხოლოდ ძირითადი,
თქვენ მაინც უნდა ეს სინტაქსი რადგან თუ მხოლოდ
აქვს arr როგორც რაღაც, როგორც ერთი რამ, ის
შეითავსებს გსურთ ღირებულება, არ გასაღები.
ასე რომ, თუ თქვენ ოდესმე უბრალოდ უნდა, ისევე, როგორც arr რადგან, შესაძლოა, ეს მოსწონს $ ელემენტის,
ის აპირებს ვივარაუდოთ, რომ თქვენ გეკითხებით მხოლოდ ღირებულება ყოველ ეტაპზე.
თუ თქვენ ღიად გვინდა რამე ერთად გასაღები,
მაშინაც კი, თუ თქვენ არ ვაპირებთ არაფერი ღირებულება,
თქვენ გჭირდებათ ეს სტრუქტურა რომ ჩვენ გვაქვს აქ
სადაც თქვენ მკაფიოდ ითხოვს ორივე გასაღები და ღირებულება.
დიდი კითხვა.
არაფერი?
მაგარი.
>> ყველა უფლება, PHP და HTML.
Oh, ჩვენ უკან p-შვიდი ერთხელ.
ასე რომ, ეს უნდა გამოიყურებოდეს ცოტა ნაცნობი.
ასე რომ ეს არის რამდენიმე მარტივი HTML ფორმა რომ აქვს input სახელი hello.
და ჩვენ ვხედავთ, რომ ჩვენ გვაქვს ჩვენი მეთოდი GET.
და თუ ჩვენ გვახსოვს ჩვენი p-set, როდესაც ამ ფორმით არის წარმოდგენილი,
ის აგზავნის მასივი მოუწოდა $ _GET, რომელსაც აქვს ყველა ამ საშუალებებით ან ცვლადი საწყისი
ფორმა, რომელიც უნდა იყოს მანიპულირება ჩვენი PHP.
ასე რომ, ამ შემთხვევაში, მომხმარებელს დააყენა მათი სახელი.
ისინი წარუდგინოს.
და ჩვენ ვხედავთ, რომ ჩვენ გარკვეული მასივი აქ.
ჩვენ გვაქვს ჩვენი GET მასივი.
და ჩვენ წვდომის სახელი.
>> ასე რომ ამბობს, OK, მომეცი ღირებულება, რომელიც დაკავშირებულია სახელი,
სახელი მიმდინარეობს გასაღები აქ.
და რომ რუკები პირდაპირ რა ჩვენ ვთქვით, რომ ჩვენი წვლილი სახელი.
ასე რომ, ეს იყო გაწვდით გასაღები, თუ რა იქნება თქვენი მასივი აქ.
არა, რომ აზრი, რომ ყველასთვის?
დიახ?
>> აუდიტორია: არა სახელი GET ეხება რომ purple ხაზი [INAUDIBLE]?
>> ALISON: ეს ეხება ეს აქ.
ასე რომ, ეს ველი შეიცავს, სწორედ აქ, ეს ეხება ამ სახელით აქ.
ასე რომ ეს შეიძლება უკვე დაასახელა როგორიცაა ტელეფონის ნომერი, ან რასაც.
ეს სახელი ამბობს, რა მოუწოდებენ, ამ სფეროში?
როგორ აპირებთ ეხება ამ სფეროში?
და ეს სახელი რეალურად მინდა, ჩვენ ამბობდა ეს ველი ეწოდება სახელი.
ეს არის ის, თუ როგორ ვაპირებთ ვებგვერდზე.
>> აუდიტორია: ასე არის ეს მინდა, input სახელი შეადგენს Bob, and--
>> ALISON: მარჯვენა, მაშინ თქვენ დაიჭერს Bob დახვდა.
ზუსტად.
ყველას მაგარი?
ყველა უფლება, ასე GET წინააღმდეგ POST, ეს არის ორი ძირითადი გზა
რომ ჩვენ გაიარონ მონაცემები HTTP მოთხოვნის.
თქვენ ბიჭები უნდა გენახათ ორივე ეს იმედია.
ასე GET, ინფორმაცია გადის URL.
ასე რომ, თუ თქვენ ოდესმე გააკეთოს Google ძიება, YouTube, თქვენ
ალბათ შეამჩნია რამდენიმე კითხვის ნიშნის.
და შემდეგ, ყველა სიტყვა რომ თქვენ უბრალოდ დააყენა იქ.
და POST აკეთებს მონაცემები ამ HTTP გაგზავნა ორგანო.
ასე რომ, განსხვავებით, თქვენ სახის განიხილოს რომ მონაცემები დაუმალა შესახებ.
მაგრამ რა მართლაც მნიშვნელოვანია იმის გაგება,
ის არის, რომ ეს ჯერ კიდევ ისევე როგორც არასაიმედო, როგორც GET.
ანალოგია მომწონს გამოიყენოს იმ შემთხვევაში, თუ თქვენ უნდა თქვენი საბანკო ანგარიშის ნომერი
და თქვენ დაწერა გარეთ კონვერტში, რომ საკმაოდ სახიფათო.
თუ თქვენ დაწერა ეს ცალი ქაღალდი და მისი შიგნით კონვერტში,
ეს ჯერ კიდევ მართლაც სახიფათო, რადგან ყველა თქვენ უნდა გააკეთოთ გახსნა რომ
და შევხედოთ ფაქტობრივი შინაარსი გზავნილი, რომ.
ასე რომ, ეს "ფარული" და ადამიანი მიყვარს ვფიქრობ, რომ ეს უსაფრთხო, მაგრამ ეს ნამდვილად არ არის.
და დარწმუნებული ვარ, Davin იქნება შეღწევას, რომ უფრო, ალბათ.
მაგრამ ეს არის მნიშვნელოვანი განსხვავება რათა
და მართლაც რაღაც კარგი გასაგებია.
>> OK, SQL, სტრუქტურირებული შეკითხვის ენა.
ყველა პერსონალი, ჩვენ ვხედავთ, ცოტა ხნის წინ,
ასე რომ, ეს, ძირითადად, მხოლოდ შექმნილია, ცხადია, მართვის მონაცემები.
თქვენ ბიჭები ჰქონდა დიდი გამოცდილება ამ თქვენს მაგიდები PHP MyAdmin.
და არსებობს ოთხი საერთო queries რომ ჩვენ გვინდა თქვენ ბიჭები იცოდეს.
ასე რომ, არსებობს განახლება, კულტურა, შერჩევა და წაშლა.
ასე რომ დარწმუნდით, რომ თქვენ იცით, იმ მართლაც კარგად.
ჩვენ ვაპირებთ წავიდეთ მათი მეშვეობით მართლაც სწრაფი.
>> ასე რომ განაახლოს, რეალურად, რა თქვენ ალბათ ფიქრობთ, რომ ეს ასეა,
ეს მხოლოდ განაახლებს მონაცემებს თქვენს მონაცემთა ბაზაში.
ასე რომ, ჩვენ გვაქვს მაგალითად აქ.
ეს არ არის ზოგადი სტრუქტურა განახლება შეკითხვაზე.
ასე რომ, ჩვენ განახლება მაგიდა რომ ჩვენ ვსაუბრობთ.
და გვინდა, რომ გარკვეული ღირებულებები, გარკვეული სვეტები
ტოლია კონკრეტული ღირებულებები.
ასე რომ, ეს მხოლოდ განაახლებს მაგიდა, იცვლება ღირებულებების რიგები ამ შემთხვევაში.
ასე რომ ამ ერთი ქვემოთ აქ, ფაქტობრივი მაგალითად, ჩვენ გვაქვს ჩასასმელად ბოდიში.
რომ slide მოწინავე ჩემს გარეშე ხვდებიან მას.
>> ასე რომ, ეს განახლებები მაგიდა და col1 თანაბარი to val1, სადაც სახლი უდრის "კურიერი".
რა ეს არ არის ეს მხოლოდ ცვლის, ეს მხოლოდ
განახლებები ეს ღირებულებების კონკრეტულ ადგილებში.
ასე რომ, ეს პირველი, ეს ცვლის ამ ღირებულებების ყველაფერი თქვენი მაგიდა,
OK?
ის აპირებს შეცვალოს ეს სვეტი თითოეული შესვლის,
თითოეული ზედიზედ.
მაგრამ ეს, სადაც, თქვენ ვერ ვფიქრობ, რომ ეს შესარჩევი.
ასე რომ, ეს მხოლოდ აპირებს შეცვალოს ეს ძალიან კონკრეტულ ადგილებში.
ასე რომ, p-შვიდი, როცა იქნებ მხრიდან თანხის ნაღდი
რომ თქვენი მომხმარებლის ჰქონდა, ალბათ, ჰქონდა ზოგიერთი, სადაც ID ტოლია სხდომა ID, არა?
>> იმიტომ, რომ თქვენ არ სურს იცვლება თანხის ნაღდი
ყველა ადამიანმა, ვინც გამოყენებით თქვენი ნახვა.
თქვენ სურდა შეცვლის ეს ერთი კონკრეტული პირი, რომელიც პირს,
ვინც იყო გამოყენებით იგი იმ დროს.
არა?
OK, ასე რომ ჩადეთ, კულტურა გარკვეული ღირებულებები მაგიდები.
ეს არის, როგორც, როდესაც თქვენ შექმნა ახალი მომხმარებელი.
ზოგადი სტრუქტურა აქ არის ჩადეთ რასაც მაგიდა
ჩვენ ვსაუბრობთ.
ღირებულებები, როგორც ღირებულებები, რომ ჩვენ რეალურად გვინდა ჩადეთ.
OK, ასე რომ, როგორც ვხედავთ, აქ, ჩვენ არ ჩადეთ მაგიდასთან.
ეს არის კონკრეტული სვეტები მათი შეესაბამებოდა ღირებულებებს.
ასე რომ, ეს ამბობს, კულტურა ახალი ზედიზედ შემცველი
ღირებულებები val1 და val2 ქვეშ ამ კონკრეტული სვეტები.
>> იქნებ თქვენ მხოლოდ მინდა, რომ შეავსოთ ნახევარი რამ ამ row.
სწორედ ეს ნაწილი აქ გაძლევთ გააკეთოთ.
ეს გაძლევთ რეალურად განსაზღვრავს, თუ რომელი ნაწილი.
დიახ?
>> აუდიტორია: შეგიძლიათ მხოლოდ [INAUDIBLE] უჯრედების row [INAUDIBLE]?
>> ALISON: თუ თქვენ მხოლოდ შეავსოთ გარკვეული ნაწილების თქვენი row,
დანარჩენი იმ საკნებში მხოლოდ ცარიელი.
რადგან თქვენ მათ იყოს ცარიელი, ეს არ არის პრობლემა.
თუ თქვენ ცდილობენ, რათა შეამოწმონ მათ, დაბრუნებას აპირებს გარკვეული ცარიელი ელემენტს.
მაგრამ მნიშვნელოვანია, ვიცოდეთ, რომ გარკვეული მაგიდები,
ისინი არ უნდა მიეცეს საშუალება იყოს null.
თქვენ შეიძლება არ გადაეყარონ პრობლემა დროს თქვენი p-set
იმიტომ, რომ ჩვენ არ დავუშვებთ, რომ რომელიმე თქვენი ღირებულებები იყოს null.
მაგრამ თქვენ შეგიძლიათ მიუთითოთ სურვილისამებრ მნიშვნელობა თქვენს მაგიდასთან.
>> OK, აირჩიეთ, ასე რომ ეს არის უბრალოდ გზა
კონკრეტული მონაცემები მაგიდაზე ზოგიერთი იდენტიფიკატორი, რომელიც გსურთ.
ასე select ვარსკვლავი მაგიდასთან, სადაც col უდრის რაღაც მხოლოდ იმას ნიშნავს,
მომეცი ყველა მონაცემი დაკავშირებული სადაც ეს კონკრეტული სვეტი არის ჭეშმარიტი.
ასე რომ ვარსკვლავი ამ საქმეს დაბრუნდეს მთელი რიგი, რომ თქვენ, OK?
>> და შემდეგ, ამ შემთხვევაში, შეარჩიეთ ვარსკვლავი მაგიდა მხოლოდ გაძლევთ მთელი მაგიდა.
და მაშინ, წაშლის, რა თქმა უნდა, ეს მხოლოდ წაშლის row მაგიდასთან.
ასე წაშლა მაგიდა, რასაც მაგიდასთან ჩვენ
მითითება, სადაც რამდენიმე კონკრეტული იდენტიფიკატორი ან რაღაც პირობა არის ჭეშმარიტი.
დიახ?
>> აუდიტორია: კითხვა.
რატომ გამოყენებით ორმაგი შეთავაზებები, და თუ
გავაკეთოთ ორმაგი ბრჭყალები ან ერთი შეთავაზებები, იგი განსხვავებას?
>> ALISON: Double შეთავაზება ან ერთჯერადი შეთავაზებები არ მიიღოს განსხვავება SQL.
ვფიქრობდი, ვნახე კიდევ ერთი შეკითხვა.
დიახ?
>> აუდიტორია: არ იმოქმედებს რა იღებს გაიქცა პასუხების შემთხვევაში?
>> ALISON: Rob?
>> ROB: რას გულისხმობთ გაიქცა პასუხების შემთხვევაში?
>> აუდიტორია: თუ ვინმეს აქვს ერთ შეკითხვაზე სახით of--
>> ROB: თუ ვინმე იყო ბოლო ერთი გაცემა,
შემდეგ, რადგან თქვენ სანიტარია თქვენი input, მაშინ მნიშვნელობა არ აქვს.
მაგრამ თუ თქვენ იყენებთ ერთი პასუხის და თქვენ არასწორად
აფარებს თქვენი პორტები, შემდეგ კი, მათ უნდა
იმისათვის, რომ ერთი გაცემა, რათა დაარღვიოს თქვენი კოდი. თუ თქვენ იყენებთ ორმაგი შეთავაზებები,
მათ უნდა დააყენოს ორმაგი ციტირებით დაარღვიოს თქვენი კოდი.
მაგრამ რადგან თქვენ გაქცევა რამ სწორად, მას არ აქვს.
ის უბრალოდ უნდა თარგმნა სწორი სიმბოლო მაინც.
>> აუდიტორია: რას გაქცევის ნიშნავს?
ALISON: ისე, როგორც სანიტარია და გაქცევის.
გამოცდა რომ ჩვენ, დიდი xkcd კომიკური, რომ ისინი დახევის up, სადაც თქვენ უნდა,
oh--
ROB: ეს ბოლო slide.
ALISON: ეს ბოლო slide, მართლა?
Oh ღმერთი ჩემი.
იქ წასვლა, სრულყოფილი.
OK, ასე რომ, ძირითადად, თქვენ შეიძლება მიეცეს რაღაც ამ SQL query
სადაც იგი არღვევს თქვენი კოდი, ან როგორც დავით აჩვენა
კლასში, თუ ჩვენ გვაქვს რაღაც ერთი პასუხის 1 უდრის 1 და თუ ჩვენი კოდი,
ჩვენ უბრალოდ პირდაპირ კოპირება, რომ, და ჩვენ გვაქვს დამთავრებული ერთი გაცემა,
რა ხდება, მივიღებთ ზოგიერთი სიტყვა, რომელიც
აფასებს ჭეშმარიტი, რომელიც მოდით ვინმე შევიდეს ჩვენს მონაცემთა ბაზაში
და მიიღონ მონაცემები, რომ ჩვენ არ მინდა მათ მისაღებად.
ასე სანიტარია საშუალებებით მხოლოდ იმას ნიშნავს, მიღების დარწმუნებული ვარ,
რომ ჩვენ აფარებს ამ გმირები და აღმნიშვნელი მათ
როგორც სიმბოლო და არა რამ რომ დაშვებული უნდა იყოს
უნდა გავიგოთ როგორც ჩვენი SQL განცხადებაში.
>> ასე რომ დიდი რამ, რომ ჩვენ ვთქვით, რომ თქვენ ბიჭები უნდა გამოყენებით
იყო HTML სპეციალური სიმბოლო, რომელიც არის ის,
რომ დაგვჭირდება შევხედოთ.
OK, წაშლა.
მონაცემთა ტიპები, ეს იქნება ყველა ონლაინ რეჟიმში.
მას შემდეგ, რაც ჩვენ 15-ე წუთზე დატოვა, მე უბრალოდ აპირებს წავიდეს უფლება მეშვეობით.
PHP და SQL, ძირითადად ეს არის უბრალოდ გვქონდა შეკითხვის ფუნქცია რომ
დაეხმარა დაიცვას ამ მუქარის თავდასხმები.
ასე რომ, როდესაც თქვენ იყენებთ შეკითხვაზე, ჩვენ მიღების დარწმუნებული ვარ,
რომ ყველაფერი შერაცხული და whatnot.
>> MVC მხოლოდ დიზაინი პარადიგმა, ასე მოდელის, ხედი, კონტროლერი.
ეს უბრალოდ გზა შენარჩუნება რამ ლამაზი და გაყოფილი up იგივე გზა
რომ ჩვენ, როგორც წესი, ფაქტორი out კოდი შევიდა ფუნქციები.
ეს არის მხოლოდ ვებ დიზაინი ფარგლებში რომელიც საშუალებას გაძლევთ გავაკეთოთ იგივე.
მე ვაპირებ გამოტოვოთ ეს.
>> ეს არის ის, რაც მე იქნება სუპერ კომფორტული ერთად.
ეს არის დიდი პატარა მაგიდაზე.
ეს გაძლევთ ფუნქცია მაგალითად მოდელი.
მე უბრალოდ აპირებს ამ გზით იმიტომ, რომ მე ნამდვილად გსურთ Davin შეძლებს გაიგო.
თუ თქვენ გაქვთ რაიმე შეკითხვები, გთხოვთ მოგერიდებათ.
მე ვიქნები აქ შემდეგ.
უბრალოდ მოვიდა გაიგო ჩემთვის.
რომ, ჩვენ გვაქვს HTTP სტატუსის მიხედვით.
და Davin აპირებს აფეთქება ამ 15 წუთის განმავლობაში.
ეს იქნება დიდი.
>> Davin: OK.
Uh, თქვენი მიკროფონი?
Yeah.
უკაცრავად.
ALISON: Way უნდა იყოს მომზადებული.
Davin: არა, მე მზად ვარ.
მე მზად ვარ.
მოდით ეს.
ის მზად არის.
OK.
უკაცრავად.
მე დაღვრილი ყავის თავს.
მე არ ვიცი, თუ მე უფრო დაარღვიოს, რომ მე სულელური,
ან, რომ მე არ მაქვს ყავა აღარ.
ყოველ შემთხვევაში, უბრალოდ სწრაფი განცხადება შესახებ ფურცელი თქვენ ბიჭები გვყავს.
ასე რომ, ეს ფურცელი თქვენ ბიჭები არ არის ოფიციალური რა არის ვიქტორინა.
ეს არის ოფიციალური რა არის ვიქტორინა.
გარდა ამისა, ვებგვერდზე, ჩვენ ვეუბნებით თქვენ, OK, ეს იქნება ვიქტორინა.
ასე რომ, პატარა cheat ფურცელი თქვენ გაქვთ, არ არის ოფიციალური.
და არსებობს შეცდომები იგი.
ასე რომ არ უბრალოდ ბრმად გამოიყენოს იგი.
ისე ჰო, სწორედ რომ.
მოდით ამ რეალური სწრაფი.
>> ასე HTTP სტატუსის მიხედვით.
რა ხდება, როდესაც ნახვა, ყველაფერი კარგად არის.
ყველაფერი კარგადაა.
ყველაფერი ბრუნდება თქვენ გზა გსურთ იგი.
თქვენ მიიღებთ 200 OK.
301, სადაც ჩვენ ვხედავთ, რომ 301 ადრე?
დაველოდოთ, რა ხდება?
უკაცრავად.
ჩვენ ვნახეთ i tin ლექცია განმავლობაში უსაფრთხოებას.
ასე რომ, როდესაც უსაფრთხოების, ასე რომ, თუ David აკრეფილი http და შემდეგ შეეცადა წასვლა cs50.net,
თქვენ ვაპირებთ, 301 გადავიდა.
რატომ?
იმიტომ, რომ ეს ხდება გადამისამართება თქვენ ავტომატურად ჩვენი HTTPS.
>> ასე 301 გადავიდა, მხოლოდ ის ძირითადად გადამისამართება.
და შეგიძლიათ ვიფიქროთ მოსწონს ეს.
ნებისმიერი სტატუსის, რომ იწყება 2, იმ მოსწონს, OK, ყველაფერი კარგადაა.
ნებისმიერი სტატუსის, რომ დაიწყოს 3, ეს არის გადამისამართება.
სტატუსები რომ იწყება 4, ანუ არსებობს გარკვეული კლიენტის შეცდომა.
სტატუსები რომ იწყება 5, რომ ზოგიერთი სახის სერვერზე შეცდომა.
ასე რომ თქვენ სახის გაწყვეტის სტატუსი იგრძნობა.
ასე 304 არა არ შეცვლილია, თქვენი server.c p-კომპლექტი, ასე ვთქვათ,
დატვირთული cat.html.
ყველაფერი ბრუნდება, თქვენ გაქვთ 200s, OK, დიდი.
>> ვთქვათ თქვენ განახლება იგი.
ისე, შიგნით, რომ cat.html, თქვენ გაქვთ JPEG.
ისე, რომ JPEG არ არის აპირებს მიიღოს Reloaded.
თქვენ არ აპირებს პოსტი სხვა ოჯახის თხოვნით, სერვერზე,
და მერე კიდევ, რომ ყველა ინფორმაცია უკან.
ის აპირებს უბრალოდ be-- რომ სურათი არის იქნება ქეშირებული თქვენი მანქანა.
და ისე, რომ გამოსახულება იქნება 304.
ასე რომ, ის არ შეცვლილა.
თუ მაშინ დახუროს out, ნათელი cookies, და მაშინ ამოცნობა
და ცდილობენ რომ ჩატვირთვა გვერდი ერთხელ, თქვენ ვაპირებთ, 200s.
თქვენ არ ვაპირებთ, რომ 304.
>> 400, ცუდი მოთხოვნით, რეალური სწრაფი, ასე, თუ თქვენ
მიდიოდნენ გააგზავნოთ JSON ობიექტი სერვერზე
და თქვენი JSON ობიექტი იყო არასწორი, დაინახავთ რაღაც მსგავსი.
403, აკრძალულია.
როდესაც ამას ხედავთ აკრძალული?
ალბათ ალბათ?
აუდიტორია: Chmod.
Davin: Chmod, yeah.
ასე რომ თქვენ არ აქვს მითითებული ნებართვების სწორად.
404, არ არის ნაპოვნი.
ეს უბრალოდ არ არსებობს.
ასე რომ, თუ თქვენ აკრიფოთ არასწორი URL.
500, შიდა სერვერზე შეცდომის სერვერზე ალბათ არ კონფიგურაცია სწორად.
რაღაც არა თქვენი ბოლომდე, მაგრამ რაღაც სერვერის მხარეს.
და 503?
ბევრი ადამიანი დაინახა 503s ბოლო p-set.
როდის იქნება, რომ მოხდეს?
გავიგე ჩურჩული.
>> აუდიტორია: როცა Google გადაწყვეტს თქვენ რობოტი.
Davin: ჰო, როდესაც Google გადაწყვეტს თქვენ რობოტი, თქვენ 503s.
ასე რომ, გადატვირთვა.
თუ თქვენ სთხოვა სერვერზე ძალიან ბევრი, რომ, როგორც წესი, დროებითი.
და ყველაზე შენიშნა.
ასე რომ თქვენ დაინახა 503.
თქვენ ალბათ მიღებული პატარა შესვენების შემდეგ 503s წავიდა,
და ყველაფერი კარგად იყო.
>> GABE: Real სწრაფი, როდესაც თქვენ ბიჭები მისაღებად 500 ალბათ, ამ ბოლო პრობლემა კომპლექტი?
დიახ?
>> აუდიტორია: ჩვეულებრივ, თუ სერვერზე ფაილი სხვა თემაა
ან [INAUDIBLE] მათი მანქანა [INAUDIBLE].
>> GABE: ასე რომ, ეს შეიძლება იყოს კონფიგურაციის ეს საკითხი თქვენი PHP თქვენს სერვერზე.
მაგრამ ეს შეიძლება იყოს მხოლოდ ის, როგორიცაა მძიმით, რომ თქვენი დაავიწყდა.
თუ თქვენ აკრეფით PHP, ზოგიერთი არაზუსტი სინტაქსი
შესაძლოა თქვენ, ასე რომ.
OK?
>> Davin: Cool.
გსურთ ჩემთვის ამის გაკეთება მხოლოდ წლამდე AJAX?
>> GABE: [INAUDIBLE].
Davin: OK.
რა არის DOM?
რას DOM დავდგეთ?
>> აუდიტორია: დოკუმენტი ობიექტის მოდელი.
Davin: Nice.
და რატომ მომწონს?
გასაოცარია.
უფლება, ასე რომ, ეს უბრალოდ გვაძლევს საშუალებას ხელმისაწვდომობის HTML, იხილოთ ჩვენი გვერდი ძალიან სწრაფად.
რატომ?
იმიტომ, რომ ჩვენ სამკურნალოდ ჩვენი გვერდი, მკურნალობის ჩვენი HTML tags,
მკურნალობის ყველაფერი თითქოს ისინი ობიექტები.
თუ ჩვენ სამკურნალოდ მათ, როგორც ისინი ობიექტები, მაშინ რა ვქნათ?
ასევე, ჩვენ შეგვიძლია მოვუწოდებთ ფუნქციები მათ.
და ეს მნიშვნელოვანია, რატომ?
კარგად, იმიტომ, რომ ჩვენ ვაპირებთ გამოვიყენოთ JavaScript განაახლოს ჩვენი HTML,
განახლება ამ ობიექტების.
ასე რომ, თუ ჩვენ მკურნალობა, მათ როგორც ობიექტები ჩვენ შეგვიძლია მაშინ მოვუწოდებთ ფუნქციები მათ.
მე ვაპირებ შეღწევას ამ პატარა უფრო მაშინ, როდესაც მე წასვლას JavaScript,
მაგრამ თქვენ ყველა მინახავს, ​​როგორიცაა document.getElementByID.
ასე რომ დოკუმენტი არის თქვენი ელემენტს, მიიღოს ელემენტს ით,
ასე რომ თქვენ ვაპირებთ შევხედოთ ზოგიერთი ID in HTML tag.
და შემდეგ, შეგიძლიათ გააკეთოთ რაღაც რომ.
მაგალითად, როგორიცაა document.body, მაშინ შეგიძლიათ დამატება ბავშვი.
ასე რომ, თქვენ აპირებს იპოვოს დოკუმენტი.
თქვენ გაქვთ დოკუმენტი.
თქვენ აპირებს იპოვოს ორგანო.
თქვენ ცხედარი.
და შემდეგ, თქვენ აპირებს მოვუწოდებ ზოგიერთი ფუნქცია იგი.
ასე დამატება შვილი, და თქვენ შეგიძლიათ დამატება ზოგიერთი HTML გადატანა ბოლომდე შიგნით თქვენი სხეულის.
ასე რომ, ძირითადად, თქვენ მხოლოდ მკურნალობის ეს როგორც ობიექტი.
თქვენ სამკურნალოდ HTML tags, როგორც ობიექტი.
და ეს ხდის ძალიან მარტივია და სწრაფი გავლა მათ.
მაგრამ ეს ასევე საშუალებას გაძლევთ მოვუწოდებთ ფუნქციები მათ
ასე რომ თქვენ შეგიძლიათ მანიპულირება და შეცვლის ელემენტები.
>> GABE: აქედან გამომდინარე, რატომ არის JavaScript ასეთი ლამაზი ენის ურთიერთქმედება HTML?
შანსები, როდესაც ადამიანი არჩევის ენის ბრაუზერი,
კლიენტის მხარეს, JavaScript მართლაც ლამაზი,
ეს მართლაც კარგად გატარება ობიექტები.
და ობიექტების ტიპის მოსწონს ობიექტი, რომელიც, როგორც ჩანს, HTML,
ასე რომ, ეს ძალიან ადვილია, JavaScript უნდა გავაკეთოთ, რომ სახის დამუშავება.
Davin: Nice.
ასე რომ, აქ მხოლოდ მაგალითია.
ასე რომ, მე ვფიქრობ, რომ გასული წლის ვიქტორინა, ან იქნებ ორი წლის წინ, ჩვენ
გთხოვეთ, რათა შეიქმნას ხე.
ასე რომ, ეს არის ზუსტად ის, რაც თქვენ მინდა გააკეთოს.
ასე რომ თქვენ დაიწყოს ერთად დოკუმენტი.
და მაშინ ძირითადად შევჩერდეთ tags.
ასე რომ, თუ გადავხედავთ, ჩვენ იწყება HTML tag.
და შემდეგ, თქვენ clues, თუ როგორ უნდა ამისათვის ეფუძნება წანაცვლება.
ასე ხელმძღვანელი სახის ფილიალი off.
შიგნით ხელმძღვანელი, ჩვენ გვაქვს სხვა tag სათაური.
ასე რომ, ჩვენ გვაქვს ტიტული აქვს.
და შიგნით რომ, ჩვენ გვაქვს გარკვეული სიმებიანი.
ასე რომ, ჩვენ წარმოადგენს სიმებიანი წრეში.
და ყველა ტეგები მოედნებზე.
>> და თუ გადავხედავთ, თუ ჩვენ ვფიქრობ ეს ხე,
და ვთქვათ, რომ HTML არის მშობელი, მაშინ ხელმძღვანელი და სხეულის
ვაპირებთ, რომ ძმა.
ისინი ორივე იქნება შვილები რომ მშობელი.
ასე იმიტომ, რომ ისინი ორივე ძმა, ისინი
იქნება სახის შემდეგი ერთმანეთს ჩვენი ხე მოდელი.
და შემდეგ, თქვენ ძირითადად გააკეთოს ზუსტად იგივე რამ.
ასე არ არის რთული, მაგრამ ჩვენ ვთხოვეთ კითხვები, როგორც ეს ადრე ვიქტორინა.
GABE: ვინმეს აქვს გაქვთ შეკითხვები აქამდე?
არის კარგი?
Davin: Cool.
JavaScript, OK, კარგი პერსონალი.
ასე JavaScript, რა არის JavaScript?
ასევე, JavaScript is-- ეს რთული, მაგრამ ეს
ზოგიერთი მაჩვენებლები რომ თქვენ უნდა გვახსოვდეს.
პირველი, ის თავისუფლად აკრეფილი.
რას ნიშნავს ეს?
ასე PHP was-- yeah, რა ხდება?
>> აუდიტორია: თქვენ არ უნდა პირდაპირ სახელმწიფო რა ტიპის ცვლადი ეს.
Davin: Perfect.
ასე რომ, მან განაცხადა, რომ თქვენ არ უნდა მკაფიოდ განვაცხადო ტიპის ცვლადი.
სწორედ უფლება.
ასე რომ, C, თითქოს მე int i უდრის 50, მაშინ PHP, ის ისევე, $ i,
შეადგენს 50.
მაშინ JavaScript, რა იქნებოდა ზარი იყოს?
Var, არა?
ეს მინდა იყოს var i უდრის 50.
მაგრამ თქვენ არ უნდა იყოს როგორიცაა, OK, ეს არის int.
OK, ეს არის ტექსტი.
არ უნდა გავაკეთოთ, რომ.
ეს ინტერპრეტირებული ენა.
ასე რომ, რას ნიშნავს?
>> აუდიტორია: არ შედგენილი.
>> Davin: რა არ არის შედგენილი ნიშნავს?
ჰო?
>> აუდიტორია: თქვენ არ გაქვთ რესტრუქტურიზაცია კოდი
მიიღოს იგი მზად კომპიუტერული გაუშვით.
ის მხოლოდ მიღებული დროს აღსრულება და კომპიუტერული [INAUDIBLE].
Davin: ჰო, ის აპირებს გადის თარჯიმანი.
მაგრამ თქვენ სწორედ.
ასე რომ თქვენ არასოდეს არ აპირებს კომპილირება, არა?
როდესაც აკეთებს თქვენი PHP და JavaScript კოდი,
არასდროს მოუწოდა კომპილირების.
არასდროს მოუწოდა რაღაც მიიღოს ან რამე მსგავსი.
ეს იმიტომ, რომ ის ინტერპრეტაცია.
ამიტომ ყოველ ჯერზე იგი გადის ბრაუზერი, იგი გადის თარჯიმანი.
და რომ აპირებს ინტერპრეტაცია მხოლოდ რეალურ დროში დაუყოვნებლივ თქვენთვის.
რა არის ზოგიერთი დადებითი და უარყოფით მქონე ინტერპრეტირებული ენა
და რომელსაც შედგენილი ენაზე?
ასე compiling-- yeah, რა ხდება?
>> აუდიტორია: ინტერპრეტაცია არის ნელი.
Davin: რა გაგებით?
>> აუდიტორია: მას შემდეგ, რაც თქვენ შედგენა, თქვენ არ გაქვთ
გავაკეთოთ ნებისმიერი დამატებითი ნაბიჯები, რათა შეასრულოს ის, ხოლო ამ [INAUDIBLE].
>> Davin: მარჯვენა, სრულყოფილი.
ასე, რას ამბობს არის ძირითადად, შედგენა,
როდესაც თქვენ შედგენის, თქვენ გაქვთ ბევრი upfront ხარჯები, არა?
თქვენ აპირებს კომპილირება.
მაგრამ მას შემდეგ, თქვენ კომპილირება, შემდგენელი აპირებს ოპტიმიზაცია.
ეს იქნება სწრაფი.
ის აპირებს ძირითადად იყოს, როგორც სწრაფად, როგორც ეს შეიძლება იყოს.
წერით, თქვენ არასდროს აქვს, რომ upfront ღირებულება.
პირიქით, ეს იქნება ოდნავ ნელა ყოველ დროს, თქვენ ინტერპრეტაცია.
და თქვენ აპირებთ უნდა ინტერპრეტაცია თითოეული დრო.
ასე ნაცვლად, რომელმაც ამ ერთ დროს ღირებულება, ახლა თქვენ
აპირებთ უნდა ინტერპრეტაცია ყოველი გვერდი უწევს.
>> ასე interpreters არის კარგი, რადგან თქვენ არ გაქვთ მისი კომპილირება,
მაგრამ ისინი ცუდი, რომ ყველა ახლა გვერდი იტვირთება, ეს
აპირებთ უნდა ინტერპრეტაცია ამ JavaScript.
და ის აპირებს, რომ აწარმოებს ოდნავ ნელა ვიდრე თუ იყო კომპილირება.
გაძლევთ საშუალებას communicate-- oh, დაველოდოთ.
გამოიყენება მანიპულირება შინაარსი და გამოჩენა.
ჩვენ უბრალოდ საუბრობდა.
იგი იყენებს DOM.
AJAX, ჩვენ შეღწევას AJAX ცოტა.
და მაშინ, კლიენტის მხარეს.
ასე PHP არის სერვერის მხარეს.
JavaScript არის კლიენტის მხარეს.
რა დადებითი, რომ?
ის ამბობს, რომ.
ეს უფრო სწრაფად, არა?
იმიტომ, რომ თქვენ არ აქვს, რომელთა მიზანია, რომ ეს სწრაფად.
თქვენ არ გაქვთ კომუნიკაცია ზოგიერთი სხვა მოწყობილობა.
თუ თქვენ მხოლოდ თქვენი კლიენტს, რომ თქვენ არასოდეს
აპირებთ უნდა წავიდეს და ვნახოთ, რა არის სერვერზე
და მხოლოდ ამის შემდეგ ან რამე მაგდაგვარს.
ასე კლიენტის მხარეს ტენდენცია იყოს ცოტა უფრო სწრაფად.
>> GABE: ჰო, მაგრამ ეს არ ნიშნავს, PHP არის
უფრო სწრაფად, ვიდრე JavaScript ან არაფერი მოსწონს.
ისინი აწარმოებს სახის იგივე სიჩქარე, რადგან ისინი ორივე
ინტერპრეტირებული ენებზე.
საქმე იმაშია, რომ ნელი აქ არის მოთხოვნა.
ასე რომ თქვენ რეალურად აპირებს ყველა გზა ბრაზილიაში
მიიღონ გარკვეული ინფორმაცია რომ ცხოვრობს.
მაგრამ PHP და JavaScript, ისინი სახის აწარმოებს იგივე სიჩქარე.
ეს არ არის, რომ ერთი სწრაფად, ვიდრე სხვა.
ეს, ასევე, შეასრულა კითხვა აქ.
ასე JavaScript არასოდეს გახდება მანქანა კოდი, ჭეშმარიტი ან მცდარი?
>> აუდიტორია: False.
GABE: False.
მას აქვს გახდეს მანქანა კოდი რადგან მანქანა კოდი არის
ერთადერთი, რაც მანქანა ესმის.
მიუხედავად იმისა, რომ ეს არ არის შედგენილი, ეს ჯერ კიდევ ხდება მანქანა კოდი
იმის გამო, რომ თარჯიმანი მხოლოდ პროგრამა, რომელიც მიდის ხაზს
და გარდაქმნას, რომ ხაზი რაღაც კომპიუტერი ესმის.
OK?
მაგარი.
>> Davin: აქ არის ძალიან ძირითადი hello world JavaScript პროგრამა.
ასე რომ, მე არ ვიცი, if-- ვნახე ეს.
მაგრამ თქვენ უბრალოდ უნდა HTML აქ.
და ნაცვლად რეალურად აყენებს JavaScript სკრიპტი tags,
ისე ნეტავ ჩვეულებრივ დააყენოს ის ხელმძღვანელი.
თქვენ უნდა script tags.
თქვენ ჩამოაგდეს ის არსებობს.
ყველა ჩვენ გავაკეთეთ აქ ჩვენ უკავშირდება in-- ასე რომ, ჩვენ უკავშირდება JavaScript ფაილი
მოსწონს ეს.
და თქვენ ყველა გაკეთდეს, არა?
ასე რომ, როდესაც თქვენ იყენებთ jQuery და underscore.js ბოლო p-set,
თქვენ არ გაქვთ ტონა კოდი მდე თქვენი script tags, up თქვენს ხელმძღვანელი.
თქვენ შეიძლება ამის გაკეთება, მაგრამ ნაცვლად თქვენ უბრალოდ აკავშირებს მას.
და თქვენ აკავშირებს მას ისევე, როგორც თქვენ CSS.
ასე რომ, ეს უბრალოდ ხდის ადვილია წაკითხვის ასე თქვენი კოდი არ მომწონს 1,000 ხაზები ხანგრძლივი
ტონა ფუნქციები, რომელიც თქვენ შეიძლება არ იყოს გამოყენებით.
>> ნაცვლად, უბრალოდ დაუკავშირონ ის.
ეს compartmentalizes იგი.
ეს იგივეა, რომ წერა რამდენიმე header ფაილი, და მაშინ მათ, რომ header ფაილი C.
ვფიქრობ, რომ ეს უბრალოდ მოსწონს ეს.
ასე რომ, რას გააკეთებს?
ასევე, ამ აპირებს.
ის აპირებს გაფრთხილება.
ასე რომ თქვენ აპირებთ მისაღებად პატარა პოპ up მოუწოდა hello მსოფლიოში.
სწრაფი კითხვა, მხოლოდ საღი აზრის შემოწმება, ასე რომ თქვენ აქ ორგანო,
ამბობენ, ორგანო, HTML აქ.
რა მოდის პირველი?
ვხედავ, ორგანო, HTML აქ, ან მე ვერ ვხედავ alert პირველი?
>> აუდიტორია: Alert.
>> Davin: Right.
ის ამბობს alert.
რატომ?
>> აუდიტორია: იმიტომ, რომ თქვენ გადასვლა ზემოდან.
>> Davin: დიახ.
სრულყოფილი.
ასე ამბობს, მიდიხარ ზემოდან ბოლოში, რომელიც არის აბსოლუტურად სწორი.
თქვენ ვაპირებთ წავიდეთ ზემოდან უნდა ბოლოში.
და JavaScript, jQuery, თქვენ გაქვთ ფუნქცია, რომელიც იგივეა onload, ან მზად არის,
და რომ ამბობს, OK, დაველოდოთ ყველა ამ HTML დატვირთული.
და მაშინ, მოვუწოდებთ JavaScript.
იმიტომ, რომ ჩვენ არ გვაქვს, რომ აქ, ძალიან პირველი რაც მოხდება
არის ის აპირებს წავიდეს ზემოდან უნდა ბოლოში.
ის აპირებს მოხვდა, რომ სს მოვუწოდებთ, ის აპირებს პირთა.
ამის შემდეგ ვაწვებით OK, რომ alert მიდის.
შემდეგ ის აპირებს აჩვენებს თქვენ სხეულის HTML აქ.
ლამაზი.
>> OK, ასე რომ მხოლოდ რეალური სწრაფი, წერა in JavaScript არის სუპერ სწრაფი.
რათა განაცხადოს ცვლადი, var სახელი.
ასე რომ, C, თქვენ გაქვთ int i, თქვენ უნდა განაცხადოს რა სახის ტიპის ეს.
PHP, $.
JavaScript, var.
ჩვენ ვისაუბრეთ ამ.
ყველა უფლება, მოდით წავიდეთ.
>> მარყუჟების, იგივე.
იგივე.
ფუნქცია დეკლარაციების, ასე ისევე, როგორც თქვენ ვნახეთ C.
ერთადერთი განსხვავებული ასე რომ, როდესაც თქვენ გაქვთ სხვა პროგრამირების ენები,
ასე, როდესაც თქვენ მიიღოს 51 შემდეგი სემესტრში და თქვენ აკეთებთ OCaml,
თქვენ შეგიძლიათ გაუმკლავდეთ ანონიმური ფუნქციები.
ასე რომ, ეს არის ზუსტად ის, რაც თქვენ აქ.
ასე რომ გსურთ დააყენა თანხა, გარკვეული სახის თანხა ღირებულება.
მაგრამ თქვენ შეიძლება მხოლოდ უნდა ამის გაკეთება ერთ დროს.
ასე რომ თქვენ არ გსურთ ეძახით ფუნქცია თანხა, რათა ეს ფუნქცია დეკლარაცია.
ნაცვლად, უბრალოდ გამოყენება როგორც ანონიმური ფუნქცია.
და ვნახე ეს ბევრი.
თქვენ ხედავთ, მაგალითად ამ რამდენიმე სლაიდები.
ჰო, ჩვენ დავინახავთ.
GABE: კარგი კითხვაა.
როდესაც შესაძლოა გსურთ გამოიყენოთ ანონიმური ფუნქცია აქ?
ძირითადად, როცა გინდათ რამე, როგორიც ღონისძიება, უნდა მოხდეს.
ასე რომ, როდესაც მაუსი არის დააწკაპებთ, მაგალითად,
გსურთ რამდენიმე ფუნქცია შეიძლება ეწოდოს.
ასე რომ თქვენ გაივლის ღონისძიება კურატორმა, გაივლის იმ შემთხვევაში,
სახის, ფუნქცია, რომელიც გსურთ ეწოდოს.
და რა თქვენ გადადის ჰგავს, ბოლოს
დღეს, მხოლოდ მომცეთ რომ დავალებით, რათა ფუნქცია.
ასე რომ, ეს იმას არ ნიშნავს, თქვენ გადადის მთელი კოდი, ისევე როგორც
მომცეთ ფუნქცია.
და მაშინ, როდესაც ვინმეს დაწკაპუნებით თაგვის, მაშინ ეს ფუნქცია იღებს მოუწოდა.
>> Davin: მასივები, ასე რომ თქვენ აქვს მასივი დეკლარაცია.
შემდეგ, მასივი დააყენოს რამ.
რეალური სწრაფი, რა იქნება ამ ამობეჭდოთ?
რა იქნება მესამე ელემენტს იყოს?
>> აუდიტორია: "JS".
>> Davin: მარჯვენა, ეს იქნება "JS."
დაველოდოთ, დაბრუნდეს.
რა არის სიგრძეზე?
>> აუდიტორია: Three.
Davin: სამი, არა?
ზუსტად რას ფიქრობთ.
OK, ახლა წასვლა.
კოლექტორები, თქვენ შეგიძლიათ დაამატოთ რამ მათ.
ასე რომ თქვენ შეგიძლიათ სცილდება მათი თავდაპირველი ფარგლებს გარეთ.
უბრალოდ რაღაც გვახსოვდეს.
PHP, JavaScript, ისინი პატარა ცოტა უფრო მიმტევებელი თვალსაზრისით რამ
როგორიცაა, რომ.
ობიექტები, ძალიან ჰგავს structs C, ძალიან
როგორიცაა ასოციაციური მასივების PHP.
თქვენ გვქონდა გამოცდილება აქვთ.
ასე JSON, როდესაც თქვენ ავლით JSON უკან და მეოთხე p მითითებული რვა,
ეს არის თქვენი ობიექტი.
>> ისე ჰო, მაგალითად, რეალური სწრაფი მაგალითად.
აქ არის ობიექტი.
გზა თქვენ მითითების ეს ობიექტი, ასე რომ მხოლოდ რეალური სწრაფი,
მოდით ვთქვათ მინდოდა გარეთ, OK, რა არის, რა თქმა უნდა?
და ასე ობიექტის სახელი აქ არის CS50.
და მაშინ, თუ მქონდა ასოციაციურ მასივი, როგორ გავაკეთო რომ?
მე გამოყენებით გასაღები, არა?
ასე მაქვს სახელი მასივი.
მაქვს bracket, შეთავაზებები, გასაღები, ბოლოს quotes, ბოლომდე bracket,
და რომ მითითებას, რომ ელემენტის შიგნით ჩემი ასოციაციურ მასივში.
როგორ შემიძლია დამოწმებული რა თქმა უნდა, შიგნით ჩემი ობიექტი?
ვინმემ იცის?
>> აუდიტორია: [INAUDIBLE].
>> Davin: რა ხდება?
აუდიტორია: CS50.course.
Davin: მარჯვენა, yeah.
ასე CS50.course.
ასე რომ გზა მითითება რამ შიგნით JSON ობიექტი წერტილით.
>> აუდიტორია: თქვენ, აგრეთვე, შეგიძლიათ გამოიყენოთ მასივში სინტაქსი.
>> Davin: OK, ჯარიმა.
>> GABE: ასევე, შეგიძლიათ გამოიყენოთ CS50 bracket, სიმებიანი, როგორიცაა ციტატა ნიშნები.
აუდიტორია: ვფიქრობ, ეს იდენტური PHP.
GABE: ეს იგივე.
Davin: Fine!
მაგრამ თქვენ, რომ ეს სხვა ადგილებში.
ჰო, ისე შენარჩუნებას აპირებს.
ეს არის ის, რაც მე უბრალოდ განაცხადა.
ასე შევიდა JavaScript jQuery მაგალითად.
ასე რომ, ეს არის ჩემი DOM, არა?
რეალური სწრაფი, ასე რომ მაქვს ხელმძღვანელი, hello world, ორგანო.
მაქვს ღილაკს.
იგი აცხადებს, რომ "დააყენებს me," მე მინდა დააყენებს მას.
და მე მინდა, რომ რამე როდესაც ის დაწკაპავთ.
უფლება, შემდეგი.
>> უფლება, ასე რომ, ეს არის ჩემი JavaScript.
ასე რომ jQuery უბრალოდ ადვილი გზა წერენ JavaScript.
ასე რომ, ეს, და რა მე ვაპირებ აჩვენებს თქვენ მომდევნო, იქნება jQuery,
იდენტურია.
ისინი ყველაფერს გააკეთებენ ამას.
უბრალოდ jQuery tends უნდა იყოს ცოტა ადვილი.
ხალხი ტენდენცია მომწონს უფრო.
მას აქვს ბევრი ფუნქციები.
ასე რომ, ადამიანებს ტენდენცია გამოიყენოთ jQuery.
თქვენ ყველა გამოყენებული jQuery ბოლო p-set.
მერე რა იქნება ამ შემთხვევაში?
რა იქნება ეს JavaScript-- ასე ეს არის მხოლოდ უბრალო JavaScript.
რა იქნება ამ შემთხვევაში?
რას გააკეთებს ის?
>> ასე რომ, პირველი, თქვენ ხედავთ window onload.
არა?
ასე რომ, ჩვენ არ ვხედავთ, რომ ადრე.
ასე რომ, ეს აპირებს დაველოდოთ სანამ მთელი window იტვირთება.
ასე რომ, ის აპირებს დაველოდოთ HTML, ყველა images დატვირთვის
სანამ აკეთებს არაფერი.
ასე ვთქვათ, ჩვენი DOM დატვირთული.
ყველაფერი არსებობს.
მაშინ რა მოხდება?
ჰო?
>> აუდიტორია: Button ჩანს.
>> Davin: ღილაკი უკვე არსებობს.
ჰო, ისე ღილაკს უკვე არსებობს.
მაგრამ ეს ხდება იმის თქმა, OK, თუ მე დააჭირეთ ღილაკს,
ასე ღილაკს უკვე იქ, ისევე როგორც, რომ HTML tag.
დაველოდოთ, დაბრუნდეს რეალური სწრაფი.
ამ tag უფლება სწორედ აქ არის იქნება ღილაკს უკვე.
იქ უკვე ღილაკს.
მაგრამ შემდეგ, JavaScript tag, სწორედ აქ,
ის ამბობს, OK, მე მინდა მისაღებად ელემენტს ით,
ასე ძიების ღილაკს უბრალოდ ამბობს, OK, მე მინდა რუკაზე ამ ცვლადის რომ ღილაკს.
ასე რომ ცვლადი მხოლოდ ადვილი გზა, რათა შეამოწმონ რომ ღილაკს.
და მე ვიტყვი, OK, თუ მე დააჭირეთ რომ ღილაკს, ასე რომ, თუ მე დააჭირეთ რომ ელემენტს,
და ამ ელემენტს ეხება ღილაკს, თუ მე დაწკაპეთ იგი,
მაშინ მინდა მოვუწოდო ფუნქცია.
აქ არის ერთი იმ ანონიმური ფუნქციები ჩვენ ვსაუბრობთ.
>> უბრალოდ მოვუწოდებ ზოგიერთი ფუნქცია.
შიგნით რომ ფუნქცია, ძირითადად რაღაც ჩვენ ვნახეთ ბევრი, მზადყოფნაშია მოყვანილი.
თქვენ დააჭირეთ ღილაკს ძებნა.
ის აპირებს ძირითადად ღილაკს.
თქვენ დააჭირეთ მას.
თქვენ, რომ მზადყოფნაში.
X out.
ეს არის ის.
ჰო?
>> აუდიტორია: ასე რომ, თუ თქვენ დააყენა script [INAUDIBLE], script tag თქვენი HTML?
>> Davin: შეგიძლიათ დააყენა script tag სწორი ხელმძღვანელი
იმიტომ, რომ თქვენ გაქვთ ეს onload.
ის ასევე, რომ თქვენ გაქვთ დაჭერით.
ასე რომ, ის აპირებს დაველოდოთ თქვენ დააჭირეთ რაღაც.
მაგრამ onload უბრალოდ უნდა იყოს უსაფრთხო, რათა დარწმუნებული ვარ, ყველაფერი ტვირთის თქვენი HTML
წინასწარ.
ჰო?
თქვენ მინდა ვთქვა რამე?
>> GABE: [INAUDIBLE].
Davin: ჰო.
>> აუდიტორია: ასე onload თავს არიდებს განსაზღვრის ცვლადი ძიების ღილაკს
მხოლოდ ამბობდა document.getElementByID ძებნის ღილაკს dot [INAUDIBLE].
>> Davin: აუცილებლად, მაგრამ შემდეგ თქვენი string უბრალოდ იღებს დიდია.
ზუსტად, ასე რომ ეს არის მხოლოდ გაუადვილოს თქვენ, yeah.
დიახ?
>> აუდიტორია: სად ჩვენ შექმნა window.onload?
ან document.ready?
>> Davin: დიახ, არსებობს.
დიახ, არსებობს, მე შევამოწმე.
>> GABE: არ მათ აღელვებთ.
>> Davin: OK, ასე რომ მე ვაპირებ გითხრათ მაინც.
ასე რომ, ძირითადად, მხოლოდ ზოგადად, ასე window.onload ელოდება სანამ თქვენი DOM, ყველა
თქვენი HTML, იტვირთება.
მას ელოდება სანამ თქვენი სურათები დატვირთვა.
მას ელოდება სანამ ყველაფერი იტვირთება.
document.ready, ეს მხოლოდ ელოდება სანამ თქვენი DOM იტვირთება.
ერთხელ HTML არის ყველა, ერთხელ თქვენი DOM არის, იწყება გაშვებული.
ეს არის ერთადერთი განსხვავება.
>> GABE: სწრაფი საღი აზრის შესამოწმებლად აქ.
ასე რომ, ეს შეიძლება ჩანს სახის როგორიცაა ხაზი კოდი, უფლება?
იმიტომ, რომ ეს window.onload უდრის bunch of პერსონალი.
როდესაც JavaScript ნათქვამია ამ, ჭეშმარიტი ან ყალბი, ფუნქციის იღებს დასაჯეს.
ყალბი.
OK?
რა ხდება აქ, თქვენ უბრალოდ გავლით ეს ფუნქცია ანონიმური ფუნქციები
to window.onload.
და მაშინ, როდესაც იგი აპირებს რეალურად მიიღოთ შესრულებული?
როდესაც window იტვირთება.
რომ არის ღონისძიება.
ისე, რომ გა t რამ ჩვენ ვსაუბრობთ ადრე, არა?
ასე რომ, როდესაც მოვლენა ხდება, ფუნქცია ხდება.
იგივე რამ onclick.
>> Davin: OK, ასე რომ ვიღაცამ წამოიღო მოშორებით document.ready.
მაგრამ ეს იქნება ზუსტად იგივე
აუდიტორია: დოლარის ნიშანი, რომ არის document.ready.
რომ კომბინაცია.
>> Davin: Oh, რომ არის?
OK, ასე რომ, ეს იმას ნიშნავს, document.ready, კომბინაცია.
მაგრამ ეს არ არის იგივე, რაც window.onload გარდა იმისა, რომ მცირე განსხვავება
მე გითხარით.
და ეს არის jQuery.
ასე რომ, ეს არის ზუსტად იგივე რამ ეს არის JavaScript.
ეს just-- ზოგიერთი ადამიანი ვფიქრობ, რომ ეს როგორც უფრო მსუბუქი წონა, გლუვი ვერსია
რომელსაც აქვს უამრავი ფუნქციები რომ თქვენ ალბათ გამოყენებით.
ასე რომ, ეს აკეთებს ზუსტად იგივე რამ.
>> ასე რამ სახის აღვნიშნო.
ასე რომ სხვა, მაგალითად, ჩვენ ჰქონდა document.getElementByID,
ასე რომ, ჩვენ ამ ხნის სიმებიანი რომ აპირებს მიიღოს
ელემენტს ნებისმიერი ID მას.
რომ შეიცვალოს ეს მოწოდება უფლება აქ.
ასე რომ თქვენ ხედავთ დოლარის ნიშანი, შემდეგ ხედავთ გაცემა, hashtag.
Hashtag ყოველთვის selector.
იგი ამბობს, OK, ეს უნდა გააკეთოს ID.
რა არის selector for კლასში?
>> აუდიტორია: Dot.
>> Davin: Dot, მარჯვნივ.
თუ თქვენ უბრალოდ აპირებს აირჩიეთ tag, რა არის ეს?
უბრალოდ tag, ზუსტად.
და თქვენ შეიძლება გამოიყენოთ, რომ აქ, ისევე.
>> GABE: And by tag, იგულისხმება, როგორიცაა div, მაგალითად, ან ხელმძღვანელი.
>> Davin: ან ორგანოს ან p ან არაფერი რომ, yeah.
ასე რომ, აქ, OK, ნაცვლად ამბობდა document.getElementByID,
ეს არის უბრალოდ ზუსტად იგივე რამ.
მხოლოდ jQuery, მოკლე.
ასე რომ, ეს მარტივია.
ასე შემდეგ, აღარ onclick, უბრალოდ დააჭირეთ.
jQuery ფუნქცია, დარეკეთ ამ ფუნქციას.
Alert არის ზუსტად იგივე.
ასე რომ, ეს ცოტა პატარა, ან ცოტა
მოკლე, პატარა bit-- ფიქრობს ხალხი ეს ცოტა ადვილი დაწერა,
ცოტა ადვილი გასაგებია.
მაგრამ ეს არის jQuery.
ბევრი ადამიანი კიდევ ცოტა ცოტა დაბნეული და შეშფოთებული
და ჰგონიათ, OK, jQuery განსხვავებულია, ვიდრე JavaScript.
უნდა გვახსოვდეს, რომ ეს ორი სხვადასხვა რამ.
ეს არ არის.
ვგულისხმობ, ეს სხვადასხვა სინტაქსი.
მაგრამ jQuery არის JavaScript.
ეს მხოლოდ ერთი შეხედვით უკეთესი ვერსია, რომ
შესაძლოა ადვილი მესმის, რომ ხალხი გამოიყენოს.
GABE: ჰო, იყოს პატიოსანი, რომ დოლარის ნიშანი
რომ ხედავთ jQuery, რომ მხოლოდ დასახელება ფუნქცია, რომელიც jQuery განსაზღვრავს.
მას არ აქვს არაფერი განსაკუთრებული.
არის უბრალოდ სახელით ფუნქცია, ისევე, როგორც თქვენ შეიძლება განსაზღვროს დოლარის ნიშანი.
>> Davin: ჰო, ასე ისაუბრა.
სასარგებლო რამ.
მე ეძებდა უკან ძველ ტესტებში.
ბოლო რამდენიმე ტესტები, ისინი უნდა გამოიყენოს რამ მოსწონს ეს.
ასე document.ready, ასე დარწმუნდით ყველაფერი
დატვირთული სანამ დაიწყება აკეთებს რამ.
აირჩიეთ ID, ან აირჩიეთ კლასის, ეს უბრალოდ
იყოს პასუხის dot გარკვეული კლასის, ბოლოს გაცემა.
წარუდგინოს, ასე რომ, თუ თქვენ წარდგენის ფორმით და ზარი
ამ ფუნქციის შემდეგ ფორმით წარუდგენს.
ღირებულება, ასე ვთქვათ, მე მქონდა ფორმა წარდგენის, როგორიცაა მომხმარებლის სახელი, ელექტრონული ფოსტის,
რასაც.
მე მქონდა ტექსტში ყუთი.
ამიტომ მე აკრეფით შევიდა, რომ ტექსტი ყუთში.
ისე, თუ გსურთ მიიღოთ ღირებულება გარეთ რომ ტექსტში ყუთი, თქვენ იყენებთ dot val.
და შემდეგ, აქ ქვემოთ, dot HTML არის იგივე
არის როგორც დოკუმენტის dot getElementByID dot innerHTML.
ისე, რომ დაბრუნებას აპირებს თქვენ HTML, რომ ID.
აქ, თქვენ უბრალოდ გამოიყენოთ რამდენიმე ID ან რასაც dot HTML.
რომ მიიღებთ HTML რომ ელემენტს.
თუ თქვენ სურდა მაშინ შეცვლის, რომ HTML, შეგიძლიათ გაიაროს ეს რაღაც.
ასე რომ თქვენ მინდა იყოს dot HTML, და შემდეგ შიგნით, შეთავაზებები, ახალი HTML ან რამე.
>> GABE: OK, ასე AJAX.
მე ნამდვილად მინდა გვესმოდეს, AJAX ნამდვილად კარგად.
ამიტომ, მე მინდა თქვენ ბიჭები მესმის AJAX ნამდვილად კარგად.
რადგან, თუ, თქვენ საკმაოდ ბევრი აპირებს
უნდა გვესმოდეს, რომ ყველაფერი უნდა გავაკეთოთ ერთად HTTP, PHP,
JavaScript იმიტომ რომ ყველა მოდის ერთად AJAX.
AJAX არ არის ენა.
AJAX ტექნიკა.
და იგი იყენებს უამრავი სხვადასხვა ინსტრუმენტები.
AJAX დგას ასინქრონული JavaScript XML.
ამიტომ მეთოდი, ენა მონაცემები.
>> ასე რომ, ძირითადი ენა, რომ ჩვენ ვიყენებთ in AJAX გამოიწვიოს ყველაფერი
და გაუმკლავდეს ყველაფერი მოგვიანებით არის JavaScript.
სწორედ ამიტომ, ეს ეხება ძალიან ახლოს JavaScript.
და შემდეგ ასინქრონული არის იმიტომ, რომ ჩვენ არ გავაკეთებთ
ერთდროულად, როდესაც ჩვენ დატვირთვის გვერდზე.
ეს არის სწორედ ის, რომ ჩვენ შეგვიძლია გავაკეთოთ რამ სახის პარალელურად.
ძირითადი იდეა AJAX, რომ გსურთ
რომ მივიღოთ კონკრეტული ინფორმაცია.
მაგალითად, როდესაც თქვენ აკრეფით new მომხმარებლის სახელი, როდესაც თქვენ რეგისტრირდებით მომხმარებლის სახელი,
ჩემი პროფაილი სახელი abc123.
და შემდეგ, ბოლოს ფორმა, თქვენ უნდა დააჭირეთ Submit.
და მას წასვლა სერვერზე, და შემდეგ შეამოწმეთ თუ მონაცემთა ბაზაში,
abc123 უკვე არსებობს.
და თუ ეს უკვე არსებობს, იგი აცხადებს, მომხმარებლის სახელი უკვე მონაცემთა ბაზაში.
და მათ, თქვენ უნდა შეავსოთ მთელი ფორმით კიდევ ერთხელ.
და ეს იყო ნამდვილად, ნამდვილად ცუდი.
>> და მერე ამბობენ, OK, რატომ არ შეიძლება ჩვენ მხოლოდ
გავაკეთოთ პატარა HTTP მოთხოვნის მხოლოდ შეამოწმოს თუ ეს შესახებ მონაცემთა ბაზაში
ადრე მომხმარებლის ჰქონდა წარმოადგინოს მთელი ფორმა?
ასე მაგალითად, როდესაც პროფაილი სრულდება აკრეფით abc123,
მოდით უბრალოდ წასვლა სერვერზე პატარა ცოტა და უბრალოდ ჭეშმარიტი ან მცდარი
სერვერზე, რომ, თუ რომ სწორი მომხმარებლის სახელი ან არა.
OK, ასე რომ ერთ-ერთი მთავარი იყენებს of AJAX დღეს, მაინც.
>> Davin: So რეალური სწრაფი, in Ajax ზარის jQuery,
თქვენ შეიძლება ნიშნავდეს, რომ თქვენ გვინდა, რომ იყოს სინქრონული.
თქვენ არ უნდა გავაკეთოთ ეს.
მაგრამ შეგიძლიათ ამის გაკეთება.
და თუ კი, რა მოხდებოდა?
ასევე, მაგალითად, როდესაც თქვენ მიღების ამბების ან რასაც,
თქვენი ბრაუზერის მხოლოდ აპირებს დაველოდოთ სანამ, რომ მთელი ზარი სრული
ნაცვლად გაქირავების თქვენ სხვა რამ შემდეგ, რაც თქვენ დაწკაპეთ იგი.
>> GABE: ეს არ გავლით აღარ.
Oh ღმერთი ჩემი.
უკაცრავად!
Yup.
"წარსულში, კლიენტის საჭირო თხოვნა
მთელი შინაარსი ნახვა. "
ეს არის ის, რაც მე ვთქვი.
ეს საშუალებას გვაძლევს გაგზავნას დამატებითი GET და POST
მოთხოვნები გარეშე განაახლეთ ჩვენი ბრაუზერის.
ასე რომ, დღის ბოლოს, ჩვენ რეალურად მიღების HTTP მოთხოვნა
აქ გამოყენებით JavaScript.
იმის გამო, რომ ადრე, ჩვენ გამოიყენება მხოლოდ JavaScript შეცვალოს HTML, რომ უკვე მოვიდა.
და ახლა, ჩვენ შეგვიძლია გამოვიყენოთ ინტერფეისი ვებ სერვერები ისევე.
გზა ეს ხდება ჩვენ უნდა კლიენტს.
Davin კლიენტს.
და მას აქვს ყველა JavaScript გაშვებული, რადგან HTML მითუმეტეს.
JavaScript არის ჭკვიანი.
ასე davin Davin აქვს თავისი ჭკვიანი ნაწილი მუნჯი ნაწილი.
ის აპირებს გამოიყენოს თავისი ჭკვიანი ნაწილი ახლა.
ის აპირებს გამოიყენოს JavaScript მოითხოვოს, მაგალითად,
თუ არა abc123 არის მონაცემთა ბაზის თუ არა.
>> ასე Davin, გთხოვთ, უბრალოდ გამომიგზავნეთ HTTP მოთხოვნის.
მადლობა.
ასე რომ, ის უბრალოდ გაგზავნილი HTTP მოთხოვნის.
ხედავთ, რომ?
და ეს მხოლოდ იგივე გზა რომ ნებისმიერი HTTP მოთხოვნა გაიგზავნა.
ბრაუზერი, Google Chrome ან რამე, არის
ვაპირებთ, რომ Davin მიერ ცდილობს გაგზავნას HTTP მოთხოვნის,
აპირებს დაეხმაროს hm ცოტა.
და რომ ის აპირებს ყველა გზა სერვერზე.
ახლა, სერვერზე აპირებს აქვს PHP აქ, ან ნებისმიერ სხვა ენაზე.
უბრალოდ მინდა ნორმალური HTTP მოთხოვნის.
ეს არის საკმაოდ ბევრი ნორმალური HTTP მოთხოვნის.
>> და შემდეგ, სერვერზე თქმას, OK,
Davin სურს ჩემთვის შეამოწმოს თუ არა ამ abc123 მონაცემთა ბაზაში.
მერე გაიგო, რომ მოდელი.
მოდელი ამბობს, რომ ეს ასე არ არის. abc123 არის კარგი მომხმარებლის სახელი.
და შემდეგ, სერვერზე აპირებს გამოყენება PHP აღმოუჩინოს ზოგი ფორმა ფაილი.
ეს შეიძლება იყოს უბრალოდ სიტყვასიტყვით ფაილი რომელიც შეიცავს "დიახ", ან "არა,
ან რამე მაგდაგვარს.
ეს შეიძლება იყოს ნებისმიერი ფაილი.
>> ეს შეიძლება იყოს, როგორიცაა მე ვაპირებ გაუგზავნე Davin სურათს იხვი
თუ ის მონაცემთა ბაზაში და გაუგზავნე სურათს hamster
თუ ეს არ არის მონაცემთა ბაზაში.
რომ იქნება ერთგვარი მითუმეტეს, მაგრამ ის იმუშავებს.
OK, ასე რომ გაუგზავნე იხვი Davin.
Davin მიიღო იხვი.
და ახლა, ვინც აპირებს გაუმკლავდეს იხვი?
Davin ჭკვიანი ნაწილი ისევ, ასე JavaScript, არა?
JavaScript გაუგზავნა მოთხოვნა და JavaScript
აპირებს მიიღოს თხოვნა და ინტერპრეტაცია გარკვეული ფორმით.
>> და ამ თვალსაზრისით, ის აპირებს იტყვით, თუ იხვი მაშინ მე კარგი.
თუ hamster, მაშინ მე ვაპირებ ვთქვათ, არ, მომხმარებლის სახელი უკვე
არსებობს მონაცემთა ბაზაში.
მაგრამ, როგორც წესი, თქვენ არ ვაპირებ გაგზავნას იხვი.
თქვენ აპირებთ გაგზავნას რაღაც ოდნავ ჭკვიანია.
და რა ჩვენ ვიყენებთ არის XML.
და მეტი ხნის წინ, ჩვენ ვიყენებთ JSON.
JSON არის მხოლოდ JavaScript Object ნოტაცია, რომელიც
ძირითადად თქვენ გაქვთ მთელი JavaScript ობიექტი.
და დააყენა ის ფაილი, ისევე, როგორც რომ CS50 ობიექტი, რომელიც თქვენ ბიჭები დაინახა.
დააყენა ეს ფაილი და თქვენ გადასცემს მას Davin.
>> ასე რომ, ამ შემთხვევაში, მე რათა JavaScript ობიექტი
და უბრალოდ, ვამბობთ, შესახებ არსებობს, დიახ.
ან მომხმარებლის არსებობს, არ.
და უკან მას.
და რატომ JSON?
იმიტომ, რომ პირი რომელიც მიიღეთ ეს არის
აპირებთ გამოიყენოთ JavaScript გაუმკლავდეს პასუხი.
და JavaScript მუშაობს ისე კარგად, იმიტომ, ეს ე.წ. JavaScript Object ნოტაცია.
არა?
ასე რომ მას შეუძლია მხოლოდ მოვუწოდებთ ფუნქცია და მიიღეთ ამ ლამაზი ობიექტი პასუხი.
და შემდეგ, ის აპირებს თუ არა რომ შესახებ მონაცემთა ბაზაში ან არა.
>> ასე რომ თქვენ ხედავთ, ყველა ეს მოდის ერთად სერვერზე,
და მერე იქ ერთი HTTP მოთხოვნის და ერთი HTTP პასუხი და ყველაფერი.
ასე რომ დარწმუნდით, რომ თქვენ ბიჭები მესმის, რომ ეს AJAX ზარი
იმიტომ, რომ ეს გეხმარებათ ესმით ყველა ცნებები ჩვენ ვსაუბრობთ.
>> ასე რომ, აქ არის მაგალითი აიაქსი ერთად jQuery.
და აქ, ჩვენ გავაკეთებთ get JSON.
ასე რომ, ჩვენ არ ცდილობს იმიჯი კატა აქ, ან იხვი.
ჩვენ ვცდილობთ, JSON ფაილი.
და მაშინ ჩვენ დაველოდოთ ეს კეთდება, dot გაკეთდეს.
ეს ნიშნავს, რომ მე ველოდები პასუხს.
ეს შესაძლოა ცოტა ხნით.
მაშინ, ხედავთ პატარა loading.
თუ თქვენ გსურთ, რომ თქვენი ნახვა.
ასე dot გაკეთდეს, და მერე რა ხდება მაშინ, როდესაც ეს კეთდება?
თქვენ გაივლის ანონიმური ფუნქცია, ისევე, როგორც ჩვენ ვნახეთ ადრე.
იმის გამო, რომ გაკეთდეს არის ღონისძიება, უბრალოდ როგორიცაა დაწკაპვით მაუსის ან რასაც,
for jQuery.
ასე რომ თქვენ გაივლის ამ ფუნქციის მონაცემები, ტექსტი, სტატუსი, და jqXHR.
და, ძირითადად, ეს არის ის, უბრალოდ ზოგიერთი ცვლადის
რომელიც შეგიძლიათ გამოიყენოთ, შემდეგ კი აქვს სტატუსი HTTP მოთხოვნის,
მონაცემები, რომ ის აპირებს გაგზავნის უკან თქვენ.
ასე მაშინ შეგიძლიათ მოგვიანებით ინტერპრეტაცია და რაღაც აზრიანი იგი.
და თუ ეს ვერ მოხერხდა, როდესაც შეიძლება ეს ვერ?
ასევე, როდესაც HTTP მოთხოვნის აძლევს თქვენ 500 ან რამე მაგდაგვარს.
მაშინ, ის აპირებს გითხრათ მდგომარეობა, თუ რა სახის მარცხი იყო, რომ,
და ყველა სახის რამ.
თქვენ უნდა დავრწმუნდეთ, გაუმკლავდეს ორივე შემთხვევაში,
წინააღმდეგ შემთხვევაში პროგრამა მიდის გიჟები.
>> Davin: ასე რომ, ჰო, ეს არის ზუსტად რას დაინახა თქვენი ბოლო p-set.
ფაქტობრივი AJAX ზარი არის get JSON.
რომ არის მოწოდება.
და მაშინ, dot გაკეთდეს ჰგავს ამოწმებს, თუ ის წარმატებული.
თუ ეს წარმატებული, გსურთ რომ რამე მონაცემები.
თქვენ უკან, რომ JSON მოთხოვნით მონაცემები.
რომ არის ის, რაც თქვენ დავუბრუნდეთ.
ასე რომ, თუ გახსოვთ თქვენი p-set, ბევრი თქვენგანი იყო ისევე, როგორც მონაცემების bracket i
ან რასაც, dot ლინკი ან სათაური.
რასაც ბრუნდებოდა რომ JSON, რაც
სფეროებში, რომ JSON ობიექტი, რომ ის, რაც თქვენ დავუბრუნდეთ.
მონაცემები, რაც თქვენ დავუბრუნდეთ.
ტექსტის სტატუსი, რაღაც ისეთი, რომ გაძლევთ ვიცი რა მოხდა.
და შემდეგ, jqXHR, ეს მხოლოდ jQuery XML HTTP მოთხოვნის.
სწორედ ისევე, როგორც ობიექტი.
და მაშინ ვერ, ისევე, როგორც Gabe განაცხადა.
GABE: ჩვენი პატარა მაგალითია abc123 მხოლოდ შესამოწმებლად, თუ ეს მონაცემთა ბაზაში
თუ არა, მონაცემები იქნება რაღაც თქვენ ყველაფერს გააკეთებს, თუ მონაცემები dot მომხმარებლის სახელი არსებობს,
რაც თქვენი PHP გენერირებული თქვენ, თუ მონაცემები dot მომხმარებლის სახელი არსებობს, მაშინ
მე ვაპირებ პირთა, შესახებ სახელით უკვე არსებობს.
სხვაგან, მე უბრალოდ აპირებს, რათა პროფაილი გაგრძელება შევსების ფორმა.
OK, უსაფრთხოების, მაგარი.
>> Davin: გინდა?
>> GABE: მე მიყვარს ეს ერთი.
ასე რომ რაღაც გამოიყურება ნაცნობი.
ჩვენ თითქმის გაკეთდეს.
ასე რომ, ეს უბრალოდ მაგალითია თქვენ ბიჭები დაინახა კლასში.
თქვენ გამოყენებით argv1 აქ.
ასეთი ბრძანების არგუმენტი.
და ჩვენ MEM კოპირება, რომ შევიდა ბუფერული ზომა 12.
რა არის პრობლემა აქ?
ბუფერული overflow!
იმიტომ რომ ჩვენ გვაქვს ბუფერული ზომა 12.
argv1 შეიძლება ჰქონდეს ზომა შეადგინა.
ჩვენ არ რაიმე საზღვრის შემოწმება.
ასე რომ, ჩვენ შეიძლება კოპირება მეხსიერების დიდ ნაწილს.
და ჩვენ უნდა განსაკუთრებით ცუდი.
რა შეგვიძლია გავაკეთოთ, რომ ძალიან, ძალიან ნიშნავს ამ შემთხვევაში?
დიახ?
აუდიტორია: Part ორი მილიარდი რამ შეიცავს შესრულებადი კოდი, რომელიც ბრუნდება
[INAUDIBLE].
GABE: ზუსტად.
ასე რომ, ეს სახის რამ, რომ ხალხი გამოიყენოს
რომ jailbreak iPhone, მაგალითად.
ასე, რომ ასეთი რამ.
იმიტომ, რომ თქვენ შეგიძლიათ მხოლოდ მიიღოს მოწყობილობა შეასრულოს რაიმე კოდი, რომელიც გსურთ.
სარემონტო, ასე სარემონტო არის ადვილი.
უბრალოდ შემოწმება ფარგლებს გარეთ.
თქვენ შეამოწმოთ null რადგან ჩვენ ყოველთვის შევამოწმოთ null
როდესაც ჩვენ საქმე სტრიქონები.
და შემდეგ, თქვენ მიიღოს სიმებიანი სიგრძე ადრე.
და თუ სიმებიანი სიგრძე არის სწორი string
სიგრძის, რომელიც არის შიგნით 0 და 12, მაშინ ჩვენ კარგი.
>> Davin: თუ თქვენ არ ვამოწმებ null, რეალური სწრაფი, რა მოხდება?
ეს კიდე seg ბრალია.
რატომ იქნება ეს seg ბრალია?
იმიტომ, რომ თქვენ მოუწოდებდა strlen on null.
GABE: ჰო.
ჭეშმარიტი ან მცდარი, გამოყენებით დაგავიწყდათ არის კარგი იდეა.
>> აუდიტორია: False.
>> GABE: False.
ბევრი პაროლები, და დიდი, გრძელი მიიჩნიეს.
ბოქლომი ხატები უსაფრთხოების უზრუნველსაყოფად.
>> აუდიტორია: False.
>> GABE: False.
ეს არაფერს არ ნიშნავს.
ეს არის მხოლოდ ხატი.
SSL იცავს კაცი შუა თავდასხმა.
აუდიტორია: False.
GABE: False.
OK, ასე რომ ყველა, ვინც ცრუ.
ლამაზი.
[INAUDIBLE]
მინდა ვისაუბრო ეს?
თქვენი მხრივ.
Davin: სახის თავდასხმები, კაცი შუა.
რა არის კაცი შუა თავდასხმა?
აუდიტორია: [INAUDIBLE].
Davin: თუ თქვენ გაგზავნის HTTP მოთხოვნით, ისინი შეიძლება ამის გაკეთება, არა?
მაგრამ თუ თქვენ გაგზავნის HTTPS, ისინი ალბათ ვერ შეძლებს ამის გაკეთება.
არსებობს უამრავი რაოდენობა ერთად თქვენი კავშირი.
თქვენ უნდა მარშრუტიზატორები.
თქვენ უნდა DNS სერვერები.
თუ ვინმე შეუძლია ფიზიკურად ვნახოთ, რა თქვენ გაგზავნის,
ასე რომ ვინმე შეძლებს რეალურად მიიღონ შორის,
კლიენტს და სერვერზე, და ნახოს, რა თქვენ გაგზავნის,
ეს არის ადამიანი, შუა თავდასხმა.
ასე, რომ თქვენ ცდილობთ მიიღონ სერვერზე, ან შეუძლია ვხედავ უარესი,
თქვენ შეიძლება ნახოს cookies ან რამე მაგდაგვარს.
>> ასე მაგალითად, თუ თქვენ არ იყენებთ SSL, მან
შეიძლება ნახოს თქვენი იდ cookies.
და ეს ჰქვია სესიაში შემოჭრის რადგან ხედავს თქვენი ID cookies,
და მაშინ მას შეუძლია წავიდეს, რომ ნახვა და პრეტენზია იყოს თქვენთვის.
იმის გამო, რომ ისევე, როგორც PHP, მახსოვს როდესაც ჩვენ შესული სისტემაში, რა ვქნათ?
ჩვენ დავსახეთ სხდომა ID ტოლია ID.
ასე, რომელიც განსაზღვრავს თქვენ.
ამიტომ, თქვენ შეგიძლიათ ნახოთ თქვენი პორტფელის და არა ყველას სხვისი გადააჭარბა.
>> ისე, თუ მე შეუძლია მიიღოს, რომ cookie, მერე შეგიძლიათ შეხვიდეთ გადატანა, რომ გვერდზე.
და მაშინ, მე შემიძლია მხოლოდ ვხედავ თქვენი პერსონალი და დაიწყოს ყიდვის და გაყიდვის პერსონალი.
ასე რომ, ეს სესიაში შემოჭრის.
მაგრამ თქვენ არ უნდა შეეძლოს, რომელთა მიზანია, ასე რომ თქვენ შეგიძლიათ გამოიყენოთ კაცი შუა თავდასხმა
მაშინაც კი, თუ ისინი გამოყენებით SSL.
მაგრამ თქვენ არ უნდა შეეძლოს.
თუ ისინი გამოყენებით SSL, თქვენ არ შეგიძლიათ სხდომაზე გაიტაცეს.
რატომ?
იმიტომ, რომ ეს ყველა დაშიფრული, არა? თუ ეს დაშიფრული,
და მე მაინც კაცი შუა, მე მაინც თქვენი მონაცემები.
ეს ჯარიმა.
მაგრამ ეს დაშიფრული.
ასე რომ, მე ნამდვილად არ გამოიყენოთ იგი.
ასე რომ, ორი.
>> რეალური სწრაფი, ჯვრის საიტის მოთხოვნა გაყალბების.
რომ ეს მხოლოდ იმ შემთხვევაში, თუ არსებობს ლინკი და ბმული აკეთებს რაღაც
რომ თქვენ არ ვფიქრობ, რომ ეს უნდა გავაკეთოთ.
ასე მაგალითად, თუ რგოლი იყო აპირებს აქციების შესაძენად ან გაყიდოს აქციები,
და თქვენ არ ვიცი, რომ.
თქვენ დაკლიკავთ რგოლი, თხოვნით შეიძინა
ან გაყიდული რაღაც, რომ თქვენ არ ნიშნავს, რომ გავაკეთოთ.
ეს რომ.
>> ჯვრის საიტზე სკრიფტინგის, ასე რომ აქ, თქვენ გავლის მეშვეობით ცვლადი q,
ნაცვლად გადადის გარკვეული სახის ღირებულება, შესაძლოა q ჰგავს სახელი.
ასე რომ, ნაცვლად გავლის q ტოლობის Davin ან რამე მაგდაგვარს,
თუ თქვენ არ იყენებთ HTML სპეციალური სიმბოლო, თუ
არ გაქცევა ეს დავრწმუნდეთ, რომ ეს OK, მაშინ მე ვერ გაივლის ნაცვლად,
მოდით ვთქვათ, აქ მე ვამბობ, ბეჭდვით ან რამე მაგდაგვარს,
მაშინ მე ვერ გაივლის აქ სკრიპტის ზარი.
>> ასე რომ, ნაცვლად უბრალოდ მიღების ცვლადი,
მე მაშინ შეასრულოს ეს სკრიპტი ზარი.
ასე რომ შიგნით რომ script მოვუწოდებთ, რას აკეთებთ?
დოკუმენტის dot ადგილმდებარეობა, რომ აპირებს შეიცვალოს მდებარეობა დოკუმენტი.
ამიტომ, მე ვაპირებ გადამისამართება სხვაგან.
ეს ე.წ. ცუდი ბიჭი ამ მაგალითად, ძალიან კარგი.
ვერ ვფიქრობ სიტყვა.
და მაშინ, რა არის კი უარესი ის არის, რომ მე ვაპირებ
რომ შემდეგ შეიქმნა cookie, რომელიც რამდენიმე ცვლადი მაქვს ამ ნახვა.
მე ვაპირებ ვაყენებთ მას ტოლი დოკუმენტის dot cookie.
ამიტომ, მე ვაპირებ მოიპარონ თქვენი cookie.
და მე ვაპირებ გადამისამართება ზოგიერთი ინფორმაციის ნახვა
რომ თქვენ არ უნდა იყოს წვდომის.
და ეს ყველაფერი ხდება იმიტომ, რომ თქვენ არ აფარებს რა ვნახე.
ჰო?
>> აუდიტორია: ასე რომ მხოლოდ რათა, რომ ნათელი, ის
vulnerable.com რომ დაუცველი ამ.
ისე, რომ რგოლი შეიძლება, როგორც ჩანს, ნებისმიერ გვერდზე.
ვინმე დააჭერს ეს, მიდის vulnerable.com.
თქვენ გაქვთ ბმულების vulnerable.com.
მოდით ვთქვათ Facebook არის დაუცველი, ამიტომ facebook.com.
თქვენ გაქვთ თქვენი Facebook cookie.
რას აკეთებს, თქვენ აპირებს facebook.com,
ის მაშინვე გადამისამართება თქვენ badguy.com,
მაგრამ მათ შორის თქვენი cookie ინფორმაცია.
ასე რომ, ეს არის სწრაფი გადამისამართება, მაგრამ თქვენი Facebook cookie
შედის, რომ გადამისამართება, და ასე ისინი [INAUDIBLE].
GABE: ჰო, იქ ზოგიერთი ძალიან ნიშნავს რამ
რომ ადამიანს შეუძლია გააკეთოს, თუ არსებობს ამ.
მაგალითად, თუ Facebook დაშვებული ყველას, შეცვალოთ თქვენი მომხმარებლის სახელი,
და ისინი არ რაიმე საღი აზრის ამოწმებს, ასე რომ თქვენ
შეიძლება ჩადეთ JavaScript რამ, რომ ცვლის თქვენი ფოტო hamster.
და რომელიც განათავსებს იგივე JavaScript შევიდა ყველას, ვინც შენს გვერდზე.
ასე რომ ყველას, ვინც შენს გვერდი აქვს იგივე მომხმარებლის სახელი.
და რადგან ეს ვირუსი, იგი ავრცელებს exponentially.
Davin: ჩვენ გამოტოვოთ ბოლო ერთი, და მაშინ ჩვენ გავაკეთეთ.
ასე რომ, ეს არის კიდევ ერთი მაგალითი.
ასე რომ, ეს არის, რომ ისინი არ აფარებს მათი SQL მაგიდასთან.
ასე რომ თქვენ შეგიძლიათ ჩამოაგდეს ის.
ასე რომ გსურთ გაქცევა რამ.
რომ იყო წინა მაგალითში ჯვრის საიტზე სკრიფტინგის.
უკაცრავად ჩვენ გაიქცა ცოტა გვიან.
ხვალ, ბოდიში!
ხვალ, ჩვენ გვაქვს საათებში.
ასე ოფისში საათი Cabbot 8:00 11:00.
სამუშაო საათებია მკაცრად ინტელექტუალური კითხვები.