>> DOUG LLOYD: ყველა უფლება, მოდით ვისაუბროთ მარყუჟების.
ასე რომ, მარყუჟების სახის cool რადგან ისინი საშუალებას თქვენი პროგრამა
შეასრულოს ხაზების კოდი მეტი და მეტი და მეტი.
არაერთხელ, გარეშე ასლი და ჩასვით ან სხვაგვარად ვიმეორებ მათ.
არსებობს სამი ძირითადი სახის მარყუჟების დაინახავთ.
თქვენ ალბათ შემთხვევა გამოყენება თითოეული ადამიანი, როგორც თქვენ პროგრესის გზით CS50.
ზოგიერთი მარყუჟების საკმაოდ ნაცნობი თქვენ Scratch,
ასე რომ, კიდევ ერთხელ, როგორც ჩვენ გავაკეთეთ პირობით, ჩვენ დააყენა მათ გვერდით
თუ არსებობს ანალოგია შეგვიძლია.
>> პირველი არის ის სამუდამოდ Scratch, რომელიც ადარებს ხოლო (ნამდვილი).
ეს არის ის, რაც ჩვენ მოვუწოდებთ უსასრულო ციკლი.
ხაზების კოდი შორის curly braces, ჰგავს თავსატეხი ცალი
რომ ჯდება შიგნით C საქართველოს სამუდამოდ ბლოკირება,
შეასრულოს არაერთხელ ზემოდან ქვედა, მეტი და მეტი და მეტი,
სამუდამოდ.
მას შემდეგ, რაც ყველა, თუ გავიხსენებთ ჩვენი განხილვის ლოგიკური გამონათქვამები,
ჭეშმარიტი ყოველთვის მართალია.
ასე რომ, თუ ჩვენ ვაკეთებთ რაღაც ისე ხანგრძლივი, როგორც ნამდვილი
არის ჭეშმარიტი, როგორც ჩანს, ცოტა silly-- ჭეშმარიტი ყოველთვის მართალია, ასე რომ თქვენ ყოველთვის აწარმოებს.
ის ყველაფერს აწარმოებს სამუდამოდ და სამუდამოდ და ოდესმე, სანამ ჩვენ
იპოვოს გზა შესვენება out of იგი შესვენების განცხადებაში, რომელიც კიდევ ერთხელ,
ჩვენ ვნახეთ, ცოტა ხნის წინ ჩვენ იყო საუბარი შეცვლა.
>> ან სხვაგვარად უბრალოდ მოკვლა ჩვენი პროგრამა, რომელიც, სხვათა შორის,
თუ თქვენ ოდესმე აღმოჩნდეთ სიტუაცია უსასრულო ციკლი
და თქვენ არ იცით, თუ როგორ უნდა შეწყვიტოს თქვენი პროგრამა გაშვებული.
უბრალოდ მოხვდა კონტროლი და C და რომ კლავს თქვენი პროგრამა თქვენთვის.
მაგრამ ეს, კიდევ ერთხელ, მოუწოდა უსასრულო ციკლი.
ეს არის ციკლი, რომელიც აწარმოებს სამუდამოდ.
ახლა, ხოლო მარყუჟების არ არის ყოველთვის უსასრულო, რადგან ასევე
ჩვენ შეგვიძლია შევცვალოთ ლოგიკური გამოხატვის რაღაც
ცოტა უფრო სასარგებლოა, ვიდრე უბრალოდ ჭეშმარიტი.
ასე რომ, აქ არის კიდევ ერთი მაგალითი.
მიუხედავად იმისა, რომ და გარკვეული ლოგიკური გამოხატვისა და მერე curly აფრთხილებს.
ეს არის საკმაოდ ბევრი ანალოგიური ვიმეორებ, სანამ, ნულიდან.
მიუხედავად იმისა, რომ მეორე, მე აგიხსნით განსხვავება.
>> ასე რომ, C, თუ ლოგიკური გამოხატვის შიგნით, ხოლო მარყუჟის
აფასებს მართალია, ხაზი კოდი შორის curly აფრთხილებს
შეასრულოს არაერთხელ და მეტი და მეტი, ვიდრე ლოგიკური გამოხატვის
აფასებს მცდარია.
ასე მაგალითად, თქვენ შეიძლება აქვს გარკვეული counter.
ასე რომ ვთქვათ, თქვენ დასაწყისში ამ მარყუჟის, რომ int x ნულის ტოლია.
მიუხედავად იმისა, რომ x ნაკლებია, ვიდრე 100, ამის გაკეთება რამდენიმე რამ შიგნით რომ Curly braces,
შემდეგ დასასრულს თქვენი ციკლი, თქვენ ამბობთ, x plus plus, თქვენ დაამატეთ x.
საბოლოოდ x მიიღებს 100 და თქვენ
შეწყდეს იმიტომ, რომ მდგომარეობა x ნაკლებია, ვიდრე 100
აღარ იქნება ჭეშმარიტი, როგორც მალე x უდრის 100.
100 არ არის 100-ზე ნაკლები.
>> ახლა გარკვეულწილად confusingly, ქცევის საქართველოს ნულიდან ბლოკი შეცვალა.
ასე რომ იყოს ნამდვილად ფრთხილად, თუ ეს თქვენი პირველი ნაბიჯი გამოყენებით მარყუჟების.
ძირითადად, განმეორებითი სანამ ბლოკი Scratch
ვიმეორებ რაღაც მეტი და მეტი და მეტი,
სანამ გამოხატვის, ლოგიკური გამოხატვის hexagon მართალია.
ასე რომ, ეს აკეთეთ სანამ ეს სიმართლეა.
იმავდროულად, ხოლო loop გააგრძელებს ამის გაკეთება მანამ, სანამ იგი არ არის ყალბი.
ასე რომ, ისინი საკმაოდ მსგავსია, მაგრამ იქ რომ პატარა განსხვავება მხოლოდ
ფრთხილად, განსაკუთრებით, როგორც თქვენ თქვენი პირველი ნაბიჯი ეხლა გადასვლის
ნაკაწრი შევიდა გ.
შემდეგი სახის მარყუჟის რეალურად საკმაოდ მსგავსია.
ეს მოუწოდა do ხოლო loop.
ეს loop შეასრულოს ყველა ხაზები კოდი შორის curly აფრთხილებს ერთხელ,
და მაშინ ის შეამოწმებს ლოგიკური გამოხატვის.
იმ შემთხვევაში, თუ ლოგიკური გამოხატვის აფასებს მართალია,
ის დავბრუნდებით და ვიმეორებ რომ პროცესი და მეტი
და მეტი, ვიდრე ლოგიკური გამოხატვის აფასებს მცდარია.
ასე რომ, ამ მარყუჟის, განსხვავებით ხოლო მარყუჟის, არის გარანტირებული აწარმოებს მინიმუმ ერთ დროს.
ეს შეიძლება იყოს საკმაოდ სასარგებლო.
>> და ბოლოს, ჩვენ გვაქვს ამისთვის loop.
ამისთვის მარყუჟების სახის სინტაქსურად მიმზიდველი
და იქ არის ბევრი აპირებს აქ, ასე რომ აგებს ჩემთან ერთად
როგორც ჩვენ ვცდილობთ და შესვენება ეს დარტყმები გარდა.
საერთოდ, გამოყენების შემთხვევაში ამისთვის loop არის თუ არა
მინდა გავიმეორო რაღაც კონკრეტული რაოდენობის ჯერ.
ამ მაგალითში, მაქვს განმეორებითი ბლოკი
ნულიდან, რომელიც ანალოგიური for loop
C, იმეორებს რაღაც 10 ჯერ.
და ამისთვის loop on მარცხენა არსებობს, რომელიც
არის ოთხი მარყუჟი, რომ იგივეს რამ.
ეს წავიდოდა 10-ჯერ.
დათვლა ნულიდან, ჩვენ ნამატი ყოველ უღელტეხილზე loop.
ჩვენ აკეთეთ, რომ სანამ მე ნაკლებია 10.
>> ასე რომ, რა ხდება?
არსებობს მთელი ბევრი კოდი არსებობს.
მოდით დაარღვიოს ეს ქვემოთ რა ხდება ნაბიჯი
ნაბიჯ, როგორც ჩვენ იჭრება მეშვეობით for loop.
პირველი, რაც მოხდა, არის Counter ცვლადი არის ცენტრში.
იმისათვის, რომ მარცხნივ რომ პირველი მძიმით შიგნით ფრჩხილებში
ხორციელდება.
ამ შემთხვევაში, ჩვენ ვართ ამბობდა int i = 0.
გამოცხადების ახალი ცვლადში i, რომ ცვლადები არის ტიპის რიცხვი
და ჩვენ ვამბობთ, ღირებულება შიგნით რომ ცვლადი იქნება ნულოვანი.
>> მეორე, რასაც ვაკეთებთ არის ჩვენ მაშინ დაუყოვნებლივ შეაფასონ
ლოგიკური გამოხატვის.
ლოგიკური გამოხატვის არის შუა ორი semicolons.
მე ნაკლებია 10.
ეს სიმართლეა აქ, არა?
ჩვენ მხოლოდ ის განაცხადა, მე უდრის ნულოვანი, და ასე 0 ნაკლებია, ვიდრე 10,
და ისე, რომ მდგომარეობა მართალია, და ჩვენ ახლა
გაგრძელება, რათა შესრულდეს ორგანოს loop.
თუ ეს იყო ყალბი.
თუ, მაგალითად, მე ვთქვი, ნაცვლად i = 0 აქ მე ვუთხარი, უდრის 15
int i შეადგენს 15.
ისე 15 არის არანაკლებ 10, ამიტომ ჩვენ არასოდეს შევა ორგანოს მარყუჟის
იმის გამო, რომ ლოგიკური გამოხატვის არ შეაფასებს, რომ ტყუილია.
>> მას შემდეგ, რაც ჩვენ გაიაროს ზემოდან უნდა ბოლოში, ვხვდებით, რომ დახურვის Curly გაუწიოს,
მესამე რამ ხდება.
Counter ცვლადი არის incremented, ან უფრო სწორად, ხაზები
კოდი განცხადების შემდეგ მეორე მძიმით შიგნით
მარყუჟების ფრჩხილებში არის შესრულებული.
ამიტომ, ჩვენ დავიწყებთ მიერ ამბობდა int i = 0.
მაშინ ჩვენ შეამოწმოს თუ არა ლოგიკური გამოხატვის მართალია.
0 ნაკლებია, ვიდრე 10, ასე რომ ეს სიმართლეა.
ასე რომ, ჩვენ ვაპირებთ გაგრძელება სხეულის ციკლი.
რამ მოხდება შიგნით მარყუჟის, და როდესაც ჩვენ ვაწყდებით, რომელიც შემოსილი
გაუწიოს, შემდეგი რამ არის ჩვენ ვთქვათ, მე plus, plus.
მე ვიყავი ნულოვანი ახლა არის ერთი.
ამის შემდეგ, ჩვენ კიდევ ერთხელ შეამოწმოს ღირებულება ლოგიკური გამოხატვის შუა.
ერთი არის არანაკლებ 10.
ასე რომ, ჩვენ გაიაროს ეს დამუშავება ისევ და ისევ.
ჩვენ კიდევ დახურვის Curly გაუწიოს ერთხელ.
ჩვენ ნამატი მე ეხლა 1 დან 2 და 2-დან 3.
და ასე შემდეგ და ასე შემდეგ და ასე შემდეგ, სანამ საბოლოოდ i ღირებულების ხდება 10.
10 10-ზე ნაკლები?
No.
დათვლა 0, ჩვენ წავიდა მეშვეობით 10 ლოზუნგებისგან loop.
ჩვენ მეორდება 10-ჯერ, უბრალოდ როგორც ჩვენ გავაკეთეთ Scratch ბლოკი.
ასე რომ, ის, ძირითადად, პროცესი ოთხი ციკლი.
>> ახლა წაიღეს ფაქტობრივი კოდი და აყენებს მას
მხოლოდ ზოგიერთი ძირითადი ზოგადი განცხადებები.
აი, რა მოხდება.
ყველა განცხადებებს დაიწყოს სრულდება პირველი.
თქვენ შეიძლება ჰქონდეს ერთზე მეტი.
ამის შემდეგ, ლოგიკური გამოხატვის არის გადამოწმებული.
თუ გამოხატვის აფასებს მართალია, შეასრულოს ორგანოს მარყუჟის ერთ დროს.
თუ გამოხატვის აფასებს ცრუ, ჩვენ გავაკეთეთ.
ჩვენ არ შეასრულოს ორგანოს მარყუჟის ყველა.
მას შემდეგ, რაც ჩვენ შესრულებული სხეულის მარყუჟის ერთ დროს,
ჩვენ მაშინ, რა არის ნამატი ნაწილში.
რომელიც ჩვეულებრივ იქნება რაღაც მე პლუს, პლუს
ან რამე მაგდაგვარს, რომელიც ცვლის counter ცვლადი.
მას შემდეგ, რაც ჩვენ ნამატი, ჩვენ შემოწმება გამოხატვის ერთხელ
და ვიმეორებ, იმ ნაბიჯებს, მეტი და მეტი და მეტი, ვიდრე გამოხატვის
აღარ არის ჭეშმარიტი.
>> ასე რომ, რა გამოყენების შემთხვევაში მარყუჟის?
გამოიყენეთ თქვენ იყენებთ ხოლო მარყუჟის, როდესაც გსურთ loop გავიმეორო
უცნობი რაოდენობის ჯერ, მაგრამ ეს შესაძლოა შესაძლოა არ აწარმოებს ყველა.
მართლაც გავრცელებული მაგალითი ხოლო looping გამოიყენება
აწარმოებს კონტროლის ნაკადის თამაში.
თქვენ შეიძლება არ ვიცი, რამდენ ხანს შესახებ იქნება სათამაშო,
მაგრამ თქვენ გსურთ, რომ შევინარჩუნოთ აკეთებს იმავეს.
განახლება პოზიციების სხვადასხვა sprites ფორუმში.
გსურთ შენარჩუნება რამ მოძრავი ნებისმიერ დროს,
მაგრამ თქვენ არ იცით, როდის მომხმარებლის აპირებს შეჩერება
ან როდესაც ისინი აპირებენ ამოიწურა ცხოვრება.
ასე რომ, ხოლო loop მართლაც კარგი რამე მაგდაგვარს.
ეს არის კარგი გამოყენების შემთხვევაში.
>> იყიდება do ხოლო მარყუჟის, ეს საკმაოდ მსგავსი.
გსურთ loop გავიმეორო მიეკუთვნებიან უცნობი რამდენჯერმე, მაგრამ ერთხელ მაინც.
თქვენ შეიძლება გამოიყენოთ ეს თამაში ძალიან, მაგრამ ნამდვილად საერთო სარგებლობის შემთხვევაში
რითაც მომხმარებელს შეყვანა.
ზოგადად, თქვენ შეიძლება ითქვას, მინდა, მომეცი დადებითი რიცხვი,
და ალბათ ისიც, რომ შიგნით do ხოლო loop.
ასე რომ, ეს ყოველთვის ვთხოვ მათ ერთხელ მაინც დადებითი რიცხვი.
თუ ისინი მოგცემთ დადებითი რიცხვი, თქვენ შეიძლება დაარღვიოს გარეთ loop.
თქვენ შეიძლება გაკეთდეს.
ბულის გამოხატვის გაკეთება, ხოლო შეიძლება იყოს ყალბი.
>> და თქვენ არ ვთხოვთ მათ კიდევ ერთხელ.
თუ ისინი მოგცემთ უარყოფითი რიცხვი, სადაც ისინი აკრიფოთ ზოგიერთი სიტყვა ან, რომ რაღაც
არა ნამდვილად სასარგებლო თქვენ, თქვენ შეიძლება გამოიყენოთ
გთხოვთ, ხოლო loop უკან და ამის ეს ისევ და ისევ და ისევ.
თქვენ აუცილებლად მინდა ვკითხო მათ მოგცემთ რიგი ერთხელ,
მაგრამ თქვენ არ ვიცი, რამდენჯერ მას შემდეგ, რაც, შესაძლოა, მათ თავიდან ასაცილებლად.
ასე რომ, ნუ ხოლო ის დიდი გამოყენება საქმე რამაც მომხმარებლის შეყვანის.
და მარყუჟების გამოყენება იმ შემთხვევაში, როგორც წესი, არის ის, როდესაც
თქვენ მინდა გავიმეორო მარყუჟის დისკრეტული რაოდენობის ჯერ,
მიუხედავად იმისა, რომ თქვენ შეიძლება არ ვიცი, რამდენჯერმე
ამ დროისათვის პროგრამა შედგენილია.
>> ასე მაგალითად, იქნებ თქვენ გაქვთ პროგრამა სადაც თქვენ შეეკითხება მომხმარებელს ნომერი.
და მოვიდის 100.
და მაშინ თქვენი ამისთვის loop იმ შემთხვევაში, აწარმოებს 100-ჯერ.
ან იქნებ ისინი შევა 1000 თქვენი პროგრამა
და შემდეგ აწარმოებს loop 1,000 ჯერ.
ეს არის კონკრეტული რაოდენობის ჯერ.
არ არის აუცილებელი იცით, რა, რომ ნომერი
არის მომენტი პროგრამა შედგენილია.
ეს იმას არ ნიშნავს, ხოლო loop სადაც ეს შეიძლება იყოს უსასრულო.
ეს საკმაოდ დიდი რაოდენობით რომ თქვენ უბრალოდ არ ვიცი.
ახლა კი, მიუხედავად იმისა, რომ მე გახმოვანებული ყველა ამ გამოყენების შემთხვევაში,
თქვენ უნდა იცოდეს, რომ საკმაოდ ბევრი ყველა გარემოება,
თქვენ შეგიძლიათ გაცვლის ყველა სამი მარყუჟების.
თქვენ შეგიძლიათ გამოიყენოთ for loop, სადაც თქვენ იქნებოდა სხვაგვარად გამოყენება ხოლო loop.
თქვენ შეგიძლიათ გამოიყენოთ for loop, სადაც ნეტავ გამოიყენოთ do ხოლო მარყუჟის და ასე შემდეგ.
ეს შეიძლება იყოს პატარა სახიფათო ზოგჯერ, ისე, ზოგადად, ეს არის კარგი პრაქტიკა
ვიცავთ ტიპიური გამოყენების შემთხვევაში.
გამოიყენეთ do ხოლო loop თუ მინდოდა რაღაც ერთხელ მაინც.
გამოიყენეთ for loop თუ გსურთ ამის გაკეთება რაღაც კონკრეტული რაოდენობის ჯერ.
ყოველივე ამის შემდეგ, სწორედ ამიტომ არსებობს სამი სხვადასხვა სახის მარყუჟების.
>> ასე რომ, ისინი შეიძლება გამოყენებულ იქნას სწორი კონტექსტში.
მაგრამ თქვენ შეგიძლიათ გაცვლის მათ, თუ გსურთ.
თუ გრძნობთ კომფორტულად ხოლო მარყუჟების და თქვენ ყოველთვის გვინდა, რომ გამოიყენოთ, ხოლო მარყუჟების.
ეს არის ის, თქვენ შეგიძლიათ ამის გაკეთება, მიუხედავად იმისა, რომ
შეიძლება ცოტა სინტაქსურად სახიფათო, სადაც ამისთვის მარყუჟის
იქნება ბევრი უფრო მარტივია.
>> ჩემი სახელი არის Doug Lloyd და ეს არის CS50.