>> ROB: ყველა უფლება.
სტუმარს პირველ ნაწილში.
მე Rob.
>> JOSEPH: მე ვარ იოსები.
>> ROB: ასე რომ, ჩვენ ჩაყვინთვის უფლება შემოსული
პირველი, რაც უნდა ვისაუბროთ არის ელექტრო.
ასე რომ იმედია ყველაზე გაქვთ გადმოწერილი ეს უკვე.
მაგრამ ხედავთ ინსტრუქციები at cs50.net/appliance.
Oh ღმერთი, ახლა მე თვითმმართველობის შეგნებული.
მე მაინც მოისმინოს ეს.
>> JOSEPH: Wow, ეს ჟღერს ეს disoriented.
>> ROB: ასე რომ, ზოგიერთი ადამიანი არ მქონე საკითხები, ასე რომ არ დაველოდოთ
ბოლო წუთს პრობლემა მითითებული ცდილობენ და გადაწყვიტოს ელექტრო და
მოძიებაში, რომ ის არ მუშაობს.
>> JOSEPH: და თუ რამე არ მუშაობს და თქვენ გჭირდებათ დახმარება, თქვენ შეგიძლიათ წასვლა
cs50.net/discussion, სადაც ჩვენ აქვს ფორუმი, სადაც თქვენ
შეგიძლიათ თქვენი კითხვები.
და ჩვენ კიდევ, რომ მათ საბოლოოდ.
>> ROB: ყველა უფლება.
ასე რომ, ეს არის ის, რაც ელექტრო ჰგავს.
ერთხელ, ის უბრალოდ სრულიად ცალკე ოპერაციული სისტემა გაშვებული ფარგლებში
რასაც ოპერაციული სისტემა გაშვებული თქვენი ლეპტოპი.
და მთავარი რამ თქვენ გამოყენებით არის gedit.
ასე რომ იმედია ეს უკვე გახდა ნაცნობი საიტზე.
ტერმინალში.
>> და ასევე შეგიძლიათ აწარმოებს Chrome ფარგლებში მოწყობილობების.
არსებობს რამდენიმე ადამიანი ვინც არ ინფორმაციით ინტერნეტით
არ მუშაობს მოწყობილობების.
და ზოგიერთი მათგანი ახლახან აიღო რომ არ უნდა იყოს
ინტერნეტის მოწყობილობების.
მაგრამ დიახ, იქ უნდა უნდა იყოს ინტერნეტში.
>> მე ვიტყვი ახლა, მაგრამ ეს იმას არ ნამდვილად არაფერს ნიშნავს.
იმ შემთხვევაში, თუ ინტერნეტში არ მუშაობს, ეს არის ის, რაც თქვენ, როგორც წესი, უნდა
აწარმოებს გაასწორონ ის.
თუ თქვენ მქონე ინტერნეტით საკითხები, არ მახსოვს, უბრალოდ პოსტი on
განიხილავს და ჩვენ ვიტყვით, აწარმოებს, რომ.
მაგრამ ინტერნეტში უნდა არსებობდეს.
>> ასე რომ, ერთადერთი რამ - yeah, არაფერი სხვაგან მართლაც აქტუალურია.
მაგრამ მე უბრალოდ სურდა აღვნიშნო, რომ -
ხედავთ ამ ქვედა მარჯვენა კუთხეში.
ასე რომ თითოეული თქვენი ტექნიკა უნდა აქვს IP მისამართი.
და შემდეგ სემესტრში, ამ IP მისამართი გახდება უფრო მნიშვნელოვანი, როდესაც
თქვენ მუშაობს ვებ p-set, რადგან თქვენ უნდა შეძლონ
ნახვა თქვენ მუშაობს თქვენი ადგილობრივი Chrome გამოყენებით ამ IP მისამართზე.
>> მაგრამ რა მომწონს გამოიყენოს IP მისამართი - და თქვენ არ უნდა გავაკეთოთ ეს, მე
უბრალოდ მინდა აღვნიშნო ის -
აქ არის.
ასე რომ, ეს არის ტერმინალის ფანჯარა ჩემი Mac, ეს არ არის
ელექტრო ყველა.
და თქვენ შეგიძლიათ ეძებოთ რა ამ ბრძანების აკეთებს.
მაგრამ მე ვაპირებ SSH პირდაპირ ჩემი მოწყობილობების.
მე არ ვიცი, რა IP არის.
>> JOSEPH: 168 -
>> 168.224.1.0.
>> ROB: ასე რომ, კიდევ მე გაკეთდეს ამ, შეხვიდეთ სისტემაში
ახლა, ძირითადად, ეს არის იდენტური ტერმინალის ფანჯარაში ფარგლებში ჩემი მოწყობილობების.
ასე რომ, მე საკმაოდ ბევრი არასოდეს რეალურად მუშაობდა შიგნიდან ელექტრო თავად.
მე, უბრალოდ, ყოველთვის მას გაშვებული ფონზე დაყვანილი
და SSHed მივანიჭო.
>> საკითხი ეს თქვენ არ აპირებენ შეძლებს გამოიყენოს gedit ადვილად
პირდაპირ ამ.
მაგრამ თუ გვინდა, რომ იყოს რეალური cool ჰაკერი, მაშინ უნდა შეეგუოს
ბრძანების ტექსტური რედაქტორი მაინც.
ასე რომ, Vim და Emacs და ნანო, ყველა ეს სხვადასხვა ალტერნატივები.
Nano tends უნდა იყოს მარტივი.
და ვფიქრობ, რომ მას არა აქვს სინტაქსის შეფერადება.
ოჰ, არა, ის მთლიანად აკეთებს.
ასე, რომ თქვენ შეგიძლიათ გამოიყენოთ Nano, რადგან რომ ერთი საკმაოდ მარტივია.
>> ხედავთ ყველა ეს ბრძანებები ბოლოში.
ამ პატარა სტაფილოს სიმბოლო.
თუ თქვენ არ მინახავს ადრე, თქვენ ალბათ ბევრი არის.
ეს ზოგადად ნიშნავს, რომ კონტროლის სტაფილო, ისევე, როგორც ქვედა მარცხენა თქვენს კლავიატურაზე
კონტროლის ხასიათი.
ასე რომ, აქ ის მეუბნებოდა ქვემოთ აქ -
oh, ეს არ შეწყვიტა, თუ მე zoom სისტემაში
ასე რომ, კონტროლის, X, თუ ​​რამდენად მე ვაპირებ გასვლა.
და ეს ამბობს მე ვერ მოხვდა Y for დიახ, გადარჩენის, N განთავსების პოსტები
ასე რომ Nano.
>> Vim და Emacs ტენდენცია იყოს ოდნავ მეტი რთული და დაუძლეველი.
მაგრამ შეგიძლიათ შეეგუება ეს, და მაშინ თქვენ მიყვარს ეს.
ასე რომ, რომ.
>> JOSEPH: არ უნდა გავაკეთოთ, რომ.
>> ROB: ჰო.
თქვენ თავისუფლად შეგიძლიათ გამოიყენოთ gedit, რომ დარჩენილი სემესტრში.
ასე რომ ნებისმიერი მოწყობილობის დაკავშირებული კითხვები?
თუ თქვენ გაქვთ რაიმე მოსაზრებები იმის შესახებ, თუ რა უნდა საუბრობდნენ შესახებ
ელექტრო?
დიახ.
>> დინამიკები 1: როცა SSHed თქვენს რამ იყო დაგავიწყდათ Crimson?
>> ROB: ჰო.
დაგავიწყდათ საკმაოდ ბევრი ყველაფერი ელექტრო აპირებს
უნდა იყოს Crimson.
>> დინამიკები 2: ინსტალაციის როგორც ნამდვილი IDE on ელექტრო მოწყობილობების, იქნება ეს მუშაობა?
>> ROB: მე წარმოვიდგენდი Eclipse აქვს Fedora მობილური, ამ შემთხვევაში, დიახ,
თქვენ შეგიძლიათ ამის გაკეთება.
ეს, ალბათ, ნამდვილად არ ღირს.
>> დინამიკები 2: OK.
ასე რომ, ეს, ალბათ, უფრო ადვილია, თუ მინდოდა გამოყენება Eclipse, უბრალოდ გამოიყენოთ შექმნილი და
მაშინ ატვირთეთ -
>> ROB: Oh, ესეც, ალბათ, უფრო ადვილია.
მაგრამ თქვენ შეგიძლიათ მიიღოთ ეს სამუშაო ფარგლებში მოწყობილობების.
>> JOSEPH: და კამერა, კითხვა იყო, შეგიძლიათ დააყენოთ სხვა
IDE შიგნით ელექტრო?
>> ROB: Eclipse მიმდინარეობს მაგალითი IDE.
ნებისმიერი სხვა ელექტრო კითხვები?
ყველა უფლება.
>> ასე რომ, ახლა ჩვენ გადაადგილება command line ინტერფეისი დაკავშირებული რამ, ასე CLI.
ისევ და ისევ, მე უბრალოდ აპირებს მუშაობას აქ, რადგან ეს არის იდენტური
სამუშაო ფარგლებში ტერმინალის ფანჯარაში ფარგლებში მოწყობილობების.
როგორ არის, რომ font ეძებს?
ის არის, რომ დიდი საკმარისი?
ყველა უფლება.
>> ასე რომ, არსებობს უამრავი ბრძანებები, თქვენ უნდა მიიღოს საკმაოდ გამოყენებული
მთელ სემესტრში.
დიდი ორი სანავიგაციო არის ls, სია ფაილები ამ დირექტორიაში და
cd, ასე რომ შეცვალოს დირექტორია.
ასე რომ, მე ვერ შეცვლის დესკტოპის და შემდეგ ძალიან გავრცელებული ნიმუში cd to
დირექტორია და დაუყოვნებლივ ls რა არის დირექტორია.
>> ასევე ზოგჯერ არ ესმოდეს რომ Tab დასრულების რამ.
ასე მოსწონს CD, vh, და მერე მოხვდა Tab.
მე თითქმის არასდროს აკრიფოთ out მთელი რამ.
და თუ მე შენარჩუნება hitting Tab ერთხელ, ის ყველაფერს ავტომატურად
დაიწყოს ჩამონათვალი ჩემთვის.
ასე რომ, შემიძლია cd vhosts, ადგილობრივი მასპინძელი.
და ეს უბრალოდ აპირებს -
იმ შემთხვევაში თუ თქვენ არ გამიგია ტერმინი ადრე, დირექტორია არის კიდევ ერთი სიტყვა
დირექტორია.
ახლა თუ ხედავთ -
მოდით მოუტანს, რომ ზედა.
>> ახლა თუ ხედავთ ფრჩხილებში, თქვენ იხ. პატარა tilde, ხაზი, vhost,
slash, ადგილობრივი მასპინძელი.
ასე რომ tilde, რომელიც ეხება ჩემი მთავარი დირექტორია.
ის დირექტორია, თქვენ როდესაც SSH შემოსული
ეს არის დირექტორია, თქვენ, როდესაც თქვენ გახსენით ტერმინალი.
ეს არის, სადაც თქვენ დაიწყოს.
და ამიტომ მე შიგნით ჩემი მთავარი დირექტორია, და მე შიგნით vhost
დირექტორია შიგნით ჩემს სახლში დირექტორია.
და მაშინ მე შიგნიდან ადგილობრივი უმასპინძლებს დირექტორია შიგნით რომ.
>> ასე რომ ზოგიერთი სხვა სასარგებლო რამ cd -
ან კარგად, ზოგადად, ასე dot ყოველთვის ეხება მიმდინარე დირექტორიაში.
Cd, dot არის საკმაოდ უსარგებლო ბრძანება.
მაგრამ ეს იცვლება მიმდინარე დირექტორიაში.
უფრო სასარგებლოა, ერთი თვალსაზრისით cd არის dot, dot, რომელიც
უბრალოდ ერთი დირექტორია.
>> და აღნიშნავენ, რომ ეს -
მინდა ვთქვა, მაგალითი, მაგრამ ეს სიმბოლოები, dot და dot, dot, ვინც მუშაობა
საკმაოდ ბევრი ნებისმიერი ბრძანება თქვენ იქნება ფიქრი გაშვებული.
ასე მოსწონს cd ალბათ სადაც თქვენ გექნებათ გამოყენებით საუკეთესო, მაგრამ ეს არ არის
რამ, რომ მხოლოდ cd ესმის.
ეს საკმაოდ ბევრი რამე თქვენი მთელი ბრძანების ესმის.
ბევრი პროგრამების ესმით, dot და dot, dot.
>> ასე რომ, სხვა სასარგებლო პირობა - CD, dash.
ისე, რომ შეტანას აპირებს ჩემთვის ბოლო დირექტორია, რომ მე ვიყავი შემოსული
ასე რომ ხანდახან მე გავაკეთებ რაღაც, oh, მე მუშაობა აქ.
და მე ვერ ვხედავ რაიმე შეცდომა რაღაც, და მე წასვლა გამოიძიოს აპირებს
შემთხვევითი დირექტორია სადღაც.
და მე არ ვიცი, თუ ის ყველაფერს ნება მომეცით იქ.
ეს იქნება.
ასე რომ გავაკეთო, რასაც მინდა ამ დირექტორიაში.
Blah, blah, blah, blah, blah.
მე კი, როგორიცაა, ყველა უფლება, მე მინდა დაბრუნდეს, სადაც მე ვიყავი.
cd, ტირე, და მას მოაქვს ჩემთვის უფლება უკან.
>> ამიტომ მე ვაპირებ იმისათვის, რომ ბევრი ამ დროს თქვენ დღეს.
მე არ ველით, რომ თქვენ memorize ყველა მათგანი.
ეს არის სახის უბრალოდ ვიცი რომ ისინი არსებობენ.
და შემდეგ, როდესაც თქვენ, როგორიცაა, hmm, მე მინდა დავუბრუნდეთ
დირექტორია, რომ მე ვიყავი მხოლოდ, oh, დაველოდოთ, რაღაც რომ არსებობს.
თქვენ არ გაქვთ უბრალოდ აკრიფოთ მთელი დირექტორია ერთხელ.
>> JOSEPH: და საბოლოოდ თქვენ მხოლოდ მათი გამოყენება უსასრულოდ, და
ეს გავხდებით კუნთების მეხსიერება.
>> ROB: ჰო.
ასე რომ, თუ ვთქვი, რომ tilde არის თქვენი მთავარი დირექტორია.
ასე რომ, შემიძლია, CD, tilde.
მაგრამ მე კი არ უნდა გავაკეთოთ, რომ თუ უბრალოდ -
მე დაბრუნდეს დირექტორია, ისე ეს არ არის უაზრო მაგალითი.
მაგრამ თუ მე უბრალოდ cd, რომელიც ასევე ისევე, როგორც, წასვლა ჩემი მთავარი დირექტორია.
გავაკეთო Command, K.
>> JOSEPH: ასევე შეგიძლიათ აკრიფოთ ნათელი, სიტყვა, და ეს უნდა გარკვევა იგი.
>> ROB: ვფიქრობ, ასევე კონტროლის, L ასევე აკეთებს.
ასე რომ, ბევრი სხვადასხვა გზა.
მე ვფიქრობ, რომ არსებობს გარკვეული განსხვავებები, სადაც ნათელი და კონტროლი, L მხოლოდ
ნამდვილად დააყენებს მას ზედა და მე მაინც გადახვევა უკან.
Command, K ფაქტიურად ანადგურებს ყველაფერი, და თქვენ
ვერ გადახვევა უკან მდე.
სულ ცოტა, რომ როგორ მუშაობს iTerm2.
მე არ ვიცი, როგორ სხვა რამ -
oh.
>> With SSHing ასე რომ, თუ თქვენ Windows, თქვენ აპირებთ უნდა ჩამოტვირთოთ საბაღე
რათა SSH რადგან Windows არ აქვს როგორიცაა ჩაშენებული SSH ინსტრუმენტი.
ეხლა Macs, შეგიძლიათ მხოლოდ SSH პირდაპირ საწყისი ტერმინალის ფანჯარაში.
OK.
კითხვები?
>> With ls, ასე რომ რაღაც შეეგუება უმეტესობა ამ ბრძანებების არის -
ასევე, მე უბრალოდ ერთი.
Ls, ტირე, ლ.
ასე რომ, ტირე, ლ არის, რასაც ჩვენ ვაპირებთ მოვუწოდებთ დროშა ls.
და ბევრი ეს ბრძანებები აქვს flags რომ თქვენ ვერ გაივლის მათ.
ასე რომ, ამ შემთხვევაში, ტირე, ლ არის დროშა რომ ეუბნება ის მომეცი სრული
ჩამონათვალი ყველა ინფორმაცია ეს ფაილი.
>> ასე რომ, ჩვენ ვხედავთ, რომ desktop იყო შეცვლილია 30 ივლისი at 12:54.
გადმოწერა შეიცვალა at 6 სექტემბერს.
ეს არის მიმდინარე და ზომის bytes ამ დასტა.
თქვენ არ უნდა გვესმოდეს ყველა ამ.
>> ამ პერსონალის მარცხენა, ამ drwx ის, რომელიც გახდება ბევრად უფრო შესაბამისი
მოგვიანებით, როდესაც თქვენ უნდა გაუმკლავდეთ -
რომ უნდა გააკეთოს, რომელსაც აქვს უფლებები შევხედოთ ეს ფაილი.
და ასე თუ არ იყო მხოლოდ მომხმარებელი ამ კომპიუტერს, თქვენ შეძლებს
ვთქვათ, OK, მე უნდა იყოს მხოლოდ ერთი დასაშვებია შევხედოთ ამ ფაილის ან მე ვარ
აპირებს საშუალებას ყველას შევხედოთ ამ ფაილის.
ასე რომ ვინმე ჩემს კომპიუტერში შეგვიძლია შევხედოთ ამ ფაილის.
ისიც კი არ ვიცით, რა ამ - რას აკეთებთ?
>> JOSEPH: მე არ ვარ საკმაოდ დარწმუნებული ვარ, რეალურად.
>> ROB: არა იდეა.
>> JOSEPH მაგრამ თუ თქვენ არ იცით, არსებობს გამოსადეგი ბრძანება, რომელიც შეგიძლიათ გამოიყენოთ
გითხრათ რა გამომავალი ნიშნავს.
და თუ ჩაწერეთ კაცი ადრე ბრძანება -
ისე M-A-N. ROB: Man.
ასე რომ, ადამიანი არის კიდევ ერთი ეს არის ძალიან სასარგებლო.
და კაცი, ls.
ასე რომ, კაცი გვერდებზე, მათ აქვთ როგორც ბრძანებები, რომ თქვენ უნდა გამოყენებით
ბრძანებათა ხაზი, და აქვთ ფუნქციები, რომელიც იქნება შესაბამისი
ერთად C. ასე რომ თქვენ შეგიძლიათ Man -
და მე იგნორირებას 3.
მაგრამ man 3 printf შეტანას აპირებს up C მობილური printf.
მაგრამ თუ მე უბრალოდ კაცი printf, ეს არის აპირებს ზრდიან ბრძანება printf
რომ ხდება ბრძანებათა სტრიქონიდან.
>> ასე რომ, ადამიანი, ls.
კაცი გვერდებზე შეიძლება იყოს საკმაოდ აბსოლუტური.
აქ, თუმცა, თქვენ ნახავთ ამ ჩამონათვალი ყველა ამ flags რომ ls
ესმის.
ასე რომ, თუ ჩვენ წასვლა ტირე, ლ, და -
მე უბრალოდ აპირებს იმისათვის, რომ ეს თქვენ.
მაგრამ იმისათვის, რომ მოძებნოთ, გნებავთ პირველი მოხვდა კითხვა
ნიშნის ან slash ღილაკს.
ასე რომ სლეში.
>> და მერე შეგიძლიათ მოძებნოთ რაც მე მინდა.
ამიტომ მე ვაპირებ სლეში განთავსების ტირე, ლ.
და იქ იყო.
ასე რომ გამოიყენოთ გრძელი ჩამონათვალი ფორმატში.
რომელიც არ დამეხმარება გაერკვნენ, თუ რა რომ კონკრეტული სვეტი ნიშნავდა, მაგრამ მე
ვივარაუდოთ, სადღაც აქ ეს იქნებოდა აეხსნა, რომ.
ასე რომ გამოიყენოთ კაცი გვერდებზე ნებისმიერი ბრძანება რომ თქვენ არ მაშინვე ესმით.
>> დარწმუნებული ვარ, თქვენ კი კაცი, კაცი.
ინტერფეისი ონლაინ მინიშნება სახელმძღვანელოები.
ოჰ, ერთი ბოლო ერთი რომ ცოტა შესაბამის არის ls, ტირე, ა.
ასე რომ შეამჩნია, თუ მე უბრალოდ ls, მე კიდევ ამ ხუთი ფაილი.
თუ გავაკეთო ls, ტირე,, მე კიდევ უფრო მეტს ფაილი.
ასე რამ აქვთ საერთო შორის ყველა ამ ახალი ფაილი არის dot წინასწარ.
>> ასე რომ, კონვენციის არის ის, რომ ფაილი, რომელიც იწყება dot იმალება.
ასე რომ თქვენ არ გვინდა, რომ ფაილი, თქვენ არ მინდა, რომ ეს არეულობა
თქვენი დირექტორია ჩამონათვალი.
ეს მხოლოდ მაშინ, როდესაც მკაფიოდ ვთხოვთ, ყველა უფლება, ls, ტირე,, ეჩვენებინა.
დგას ყველა ფაილი, მათ შორის, ფარული მიიჩნიეს.
ასე რომ, ზოგიერთი სხვა ბრძანებები.
Oh, კითხვები იმ ეტაპზე?
დიახ.
>> დინამიკები 3: როცა ls, , რა dot, dot?
>> ROB: Oh.
ასე რომ, ეს არის ის, რაც მე საუბარი.
ეს იგივე სადაც შემიძლია მინდა cd, dot, dot.
ისე ტექნიკურად, dot და dot, dot არის ფაილი, რომელიც არსებობს თითოეული
დირექტორია სადაც dot ფაილის ეხება მიმდინარე დირექტორიაში.
ასე რომ, თუ მე cd, dot, მე უბრალოდ აპირებს დარჩენა დირექტორია.
და dot, dot ყოველთვის ეხება წინა დირექტორია ერთ დონეზე up.
ასე რომ, თუ მე წასვლას ჟურნალი და ls, ტირე, al, მე ვხედავ dot, dot. cd to dot, dot
მოაქვს ჩემთვის წინა დირექტორია.
ჰო.
OK.
>> ასე რომ, კიდევ ერთი საკმაოდ მნიშვნელოვანი ბრძანება rm.
ასე რომ, რასაც ჩვენ ვაპირებთ გამოყენება ამოიღონ.
და ნება მომეცით რეალურად გავაკეთოთ სხვა ბრძანების პირველი.
ასე რომ, mkdir.
Mkdir არის, თუ როგორ შეგიძლიათ შევქმნათ დასტა.
და მე დროებითი საქაღალდის შექმნა და წასვლას, რომ დროებითი დირექტორია.
და, როგორც მოსალოდნელია, ის ცარიელი.
მაგრამ თუ მე ls, ტირე,, კიდევ მაქვს dot და dot, dot, რადგან dot ეხება
მიმდინარე დირექტორიაში.
და dot, dot ეხება წინა დირექტორია.
და ის ყოველთვის იარსებებს არ აქვს მნიშვნელობა, დირექტორია ხართ შემოსული
>> და ეს არის სრულიად არასაჭირო ბრძანება, მაგრამ შეხება.
მე უბრალოდ იყენებს მას, რადგან ეს მარტივი გზა შექმნათ ფაილი.
ასე რომ შეეხოთ, შეეხოთ b, c შეეხოთ მხოლოდ აპირებს შექმნას სამი ფაილი მოუწოდა,
b და c, რომლებიც სრულიად ცარიელია.
ასე რომ წერტილი me შექმნაში იმ პირველ რიგში, მხოლოდ ისე, რომ rm არის
როგორ შეგვიძლია ამოიღონ მათ.
ასე რომ, rm, ა.
ის აპირებს მკითხავთ, წაშლა რეგულარული ცარიელი ფაილი?
და მაშინ მე ვიტყვი, დიახ.
>> ასე რომ, თუ მე ვიცი, რომ მინდა წაშლას რომ ფაილი გარეშე იქნება
მოთხოვნილია, ამოიღონ რეგულარული ცარიელი ფაილი?, მაშინ rm, ტირე, f იქნება
დროშა, რომელიც ამბობს, აიძულოს ამოიღონ გარეშე კი რითაც ჩემთვის, oh, თქვენ
ნამდვილად გსურთ წაშალოთ ფაილი?
დიახ, დარწმუნებული ვარ.
ასე რომ, rm, ტირე, fb მხოლოდ ამის გარეშე ითხოვს.
>> ასე რომ, მოდით კიდევ რამდენიმე დასტა.
mkdir, tmp2, CD, tmp2, შეეხოთ, შეეხოთ ბ.
OK.
ასე რომ, ახლა მე მინდა ამოიღონ tmp2 როგორც დირექტორია.
ასე რომ, rm tmp2.
თქვენ ვერ ამოიღონ tmp2, ეს არის დირექტორია.
ასე რომ საკითხი ისაა, რომ rm არ დაუყოვნებლივ მუშაობა დირექტორიების.
ის მხოლოდ იმას ნიშნავდა, ფაილი, როგორიცაა არასამთავრობო დირექტორია ფაილი.
>> და ასე შემდეგ რა შეგვიძლია გავაკეთოთ აქ არის rm, ტირე, რ.
რომ დგას რეკურსიული, რომელიც შეიძლება არაფერს ნიშნავს, რომ თქვენ ამჟამად.
მაგრამ როდესაც თქვენ მიიღებთ უკან, ეს კიდე ნიშნავს მეტი.
ასე რომ, rm, ტირე, r, tmp2 აპირებს რეკურსიული წასვლას რომ დირექტორია.
ასე წარმოშობის შევიდა დირექტორია tmp2?
დიახ, მოდით წასვლას რომ.
გვინდა ამოიღონ tmp2 / a?
დიახ.
გვინდა ამოიღონ tmp2 / b?
დიახ.
ახლა გვინდა წაშლა დირექტორია tmp2?
დიახ.
და ახლა დირექტორია და ყველაფერი შიგნით
ის უკვე წაშლილია.
>> არ არის ტექნიკურად ბრძანება rmdir რომ თქვენ შეგიძლიათ გამოიყენოთ წაშლა
დირექტორიები, მაგრამ ეს მხოლოდ სამუშაოები ცარიელი დასტა მაინც.
და ვხედავ, რომ, მოდით უბრალოდ გავაკეთოთ mkdir, tmp2 ერთხელ.
Tmp2, შეეხოთ.
OK.
ასე თუ ცდილობენ ამოიღონ dirtmp2, ეს თქვენ ამბობენ, რომ დირექტორია არ არის ცარიელი.
ასე რომ, მე საკმაოდ ბევრი არასდროს არ გამოიყენოთ remove რეჟ ბრძანება მაინც, რადგან rm, ტირე,
r იმუშავებს ცარიელია დირექტორიები და არასამთავრობო ცარიელი დასტა.
>> ასევე, თუ მე არ მინდა, რომ უნდა გავლა, რომ მთელი პროცესი
დაღმავალი შევიდა დირექტორიაში და მოხსნის თითოეული ფაილი, rm,
ტირე, rf, tmp2.
და ახლა ის წავიდა.
>> რაღაც ფრთხილად შესახებ არის rm, ტირე, rf.
და ეს scares ჩემთვის კი აკრიფოთ ის, იმიტომ, რომ თუ მე შემთხვევით
დააჭიროთ ან რამე.
ასე რომ, rm, ტირე, rf, tilde რომ გარეშე რითაც ჩემთვის, f არ შეეკითხება
ჩემთვის, ეს იქნება ავტომატურად წაშლა მთელი ჩემი მთავარი დირექტორია და
ყველაფერი ეს.
ასე რომ თქვენ შეიძლება ვფიქრობ, რომ ის სულელური რამ უნდა გააკეთოს.
და ასევე, ის არის.
>> მაგრამ ეს შეიძლება მოხდეს ძალიან ადვილად უბედური შემთხვევა თუ, ვთქვათ, მინდოდა წაშლა
ჩემი ხაზი, vhost დირექტორია.
და მხოლოდ სწრაფი აკრეფით, მე შემთხვევით ამის გაკეთება.
რომ ამოიღონ რეკურსიული როგორც ჩემი მთავარი დირექტორია და vhost დირექტორია
ამ კონკრეტულ დირექტორია, რომელიც მხოლოდ ხდება არ არსებობს ახლა.
მაგრამ ეს მაინც ამოიღონ მთელი ჩემი მთავარი დირექტორია.
მაინც არ მქონე f, ეს იქნებოდა შეეკითხება ჩემთვის პირველი.
და მე მინდა იყოს, როგორიც, რა, არა, მე არ მინდა ამის გაკეთება.
მაგრამ ხალხი, ირიბის, მათ შორის, მე, როგორც წესი, მოხვდება
ჩვევა ყოველთვის rf-Ing.
მაშინაც კი, ჩვეულებრივი ფაილი, რომელიც მე შემიძლია მხოლოდ RM, c, მე, როგორც წესი, მხოლოდ rm, ტირე, rf, გ.
უბრალოდ ფრთხილად, როდესაც თქვენ rf-Ing.
>> დინამიკები 4: რა C გავაკეთოთ?
>> ROB: C არის მე ვსაუბრობ, რომ C ფაილი ამ დირექტორიაში, რომელიც rm, გ.
>> JOSEPH: და უფრო სახიფათო, თუ თქვენ იყენებთ ვარსკვლავი, ეს ეხება ყველაფერს
დირექტორია.
ასე რომ, რაც მე ხშირად ტენდენცია გავაკეთოთ არის მე წასვლას დირექტორია და მინდა
ამოიღონ ყველა ფაილი არსებობს.
ასე რომ, rm, ტირე, rf, ვარსკვლავი.
>> ROB: ჰო.
Rm, ტირე, rf, ვარსკვლავი.
>> JOSEPH: თუ თქვენ არ ფრთხილად რა დირექტორია, თქვენ -
მე არ temp, მაგრამ მე შემთხვევით ჩემი მთავარი დირექტორია,
მაშინ მე ამოიღონ ყველაფერი ჩემი მთავარი დირექტორია.
და მე რეალურად გაკეთდეს, რომ ადრე, და მე ვფიქრობ, თქვენ გავაკეთეთ ეს ადრე თუ
Jay გააკეთა, რომ ადრე.
>> ROB: მე შემთხვევით ამოღებულ -
ასე იგნორირება, რომ ბრძანება ცოტა.
>> JOSEPH არ fun.
>> ROB: ასე რომ slash bin დირექტორია bunch of ორობითი ფაილი იქ, სადაც ყველაფერს
იყოს ნაცნობი პირობა, როგორიცაა Clang.
ასევე, Clang და ძირითადად ყველა ამ რამ, რომ მე გაშვებული ბრძანებათა
ხაზი ამ slash bin დირექტორია.
>> JOSEPH: Like ls არის აქ.
>> ROB: ასე dot, ირიბის, ls სურს სიაში ამ დირექტორია.
>> JOSEPH: Rm ასევე ამ დირექტორიაში.
>> ROB: მე არ შემთხვევით RM, rf-ed bin, რომელიც ამოღებულ ნებისმიერი ბრძანება შემეძლო
შესაძლოა ოდესმე გვინდა.
რომელიც შემდეგ მე უბრალოდ გადაყენება ახალი ელექტრო იმ ეტაპზე.
>> JOSEPH ასე რომ ძალიან ფრთხილად, როდესაც თქვენ გამოიყენოს ეს ბრძანება.
>> აუდიტორია: [INAUDIBLE]?
>> ROB: დიახ.
რომ ასევე ცუდი ჩვევა შეღწევას.
თუ თქვენ შეამჩნევთ, მე ახლა -
ასევე, თქვენ ვერ შეამჩნევთ, მაგრამ ჩემი zoom-in იქნებ შეგიძლიათ.
ასე რომ, მე ახლა root @ მოწყობილობების.
ასე რომ jharvard არის მომხმარებლის გვინდა თქვენ ყოველთვის გამოყენებით.
ფესვი მომხმარებელს, რომელსაც აქვს ნებართვა გავაკეთოთ აბსოლუტურად არაფერი.
>> ასე რომ შეამჩნია, როდესაც მე jharvard, თუ ვცდილობ cd -
რა არის დირექტორია, რომ?
Oh, root არის კარგი მაგალითი.
ასე რომ, CD, root.
ნებართვა უარყო.
რადგან თუ გადავხედავთ ამ ჩამონათვალს -
და კიდევ ერთხელ, თქვენ არ უნდა მთლიანად ესმით.
მაგრამ ამ სამი dashes ვამბობთ რომ არ დაუშვა რაიმე სხვა
შესახებ ამ დირექტორიაში.
და დირექტორია ხდება უნდა მფლობელია შესახებ root.
>> ასე რომ ის ფაქტი, რომ მე ვარ jharvard და არა ვინც არ არის root არის შეუშვეს
ამ დირექტორიაში, რაც იმას ნიშნავს, რომ მე ვარ აპირებს მისაღებად ნებართვის უარყო, როდესაც მე
ცდილობენ cd მივანიჭო.
ასე რომ, როდესაც მე ვარ root, მაქვს ნებართვა გავაკეთოთ აბსოლუტურად არაფერი, მათ შორის,
წაშლა არსებითი ფაილი ელექტრო და
გაანადგუროს მთელი რამ.
>> ასე რომ, ეს ცუდი ჩვევა შეღწევას უბრალოდ მოხეტიალე გარშემო
ოპერაციული სისტემა, როგორც root.
მე ამას მაინც.
კითხვები?
და მე გასვლა root, დარჩება, როგორც jharvard.
OK.
>> უფრო შესაბამისი ბრძანებები.
ასე ბრუნდება ჩვენს temp, mv ბრძანება დგას ნაბიჯი.
თქვენ შეგიძლიათ გადაადგილება.
ახლა ჩვენ გვინდა ეძახით b, ასე რომ, ახლა ეს ე.წ. ბ.
ან იქნებ გვინდა ვიაროთ ბ გაეზარდა დირექტორია.
ასე რომ, ახლა ამ დირექტორიაში ცარიელი.
მე დაბრუნდეს ჩემი მთავარი დირექტორია, და ჩვენ ვხედავთ, რომ ბ არის აქ, რადგან
მთავარი დირექტორია იყო ერთ დირექტორიაში მდე დირექტორია, რომ b იყო შემოსული
>> არსებობს ასევე cp.
ასე რომ cp არის კოპირება super განყოფილებიანი, dot, ტექსტი.
მე მოვუწოდებ მას s, dot, ტექსტი.
ახლა ჩვენ ორივე super განყოფილებიანი, dot, ტექსტი და s, dot, ტექსტი.
ეს ასევე მუშაობს დირექტორიების.
I RF-ed ერთი ფაილი.
ასე რომ cp -
ასევე, პირველი მოდით ცდილობენ cp, tmp, tmp2.
ასე რომ, omitting დირექტორია tmp.
ასე რომ, მსგავსი RM, რა ქცევა არის, რომ არ იმუშაოს დირექტორიების.
>> და ისევ, მსგავსი RM, რა ქცევა - კარგად, მიღების ეს მუშაობა
ერთად დირექტორიები არის, ტირე-r დაშორებით.
ასე რომ გადაწერეთ რეკურსიული temp დირექტორია შევიდა tmp2.
და ახლა ჩვენ ორივე tmp და tmp2, და რომ არ არის, რომ სასარგებლოა, რადგან tmp
ცარიელი იყო, პირველ რიგში.
Tmp2.
>> ახლა მოდით კოპირება tmp თარგმნეს tmp2.
და ჩვენ ვხედავთ, რომ tmp2 ასევე აქვს ფაილის იმის გამო, რომ დირექტორიაში და
ყველაფერი შიგნით რომ დირექტორია იყო გადაწერილი.
და რომ შეიძლება იყოს გარკვეულწილად სასარგებლო თუ, ვთქვათ თქვენ ვმუშაობთ
on პრობლემა მითითებული ერთ -
ან რეალურად, მოგვიანებით პრობლემა კომპლექტი კიდევ უფრო მნიშვნელოვანია, რადგან არსებობს
იქნება მთელი bunch ფაილი და რამ.
>> მაგრამ გსურს, გაყოფილი მეორე, თქვენ, ისევე როგორც, ყველა უფლება, მე ვარ
ვაპირებ ცდილობენ რაღაც განსხვავებული.
ნება მომეცით უბრალოდ დააკოპირეთ მთელი ჩემი pset1 დირექტორია შევიდა pset1 სარეზერვო ასე რომ თუ
მე დასრულდება მდე screwing რამ, მე არ შემიძლია დავუბრუნდეთ ჩემს სარეზერვო დირექტორია.
არსებობს უფრო მისაღები გზები versioning ვაცოცხლებთ თქვენი კოდი, მაგრამ
ეს ყოველთვის სწრაფი გზა მხოლოდ დარწმუნდით აქვს ასლი რაღაც
რომ თქვენ უნდა ცვლილებები.
>> ასე რომ echo ასევე ერთჯერადი ბრძანება, რომ სახის sillily მხოლოდ ბეჭდვა
ბრძანების ზუსტად რა თქვენ სურდა ეხმიანება.
ასე ეხმიანება hi.
ჩვენ უბრალოდ ბეჭდვა hi.
Echo მიესალმები მსოფლიოში.
ჩვენ ბეჭდვა Hello World.
რომელიც ძალაში გამოყენება როდესაც თქვენ დაიწყოს აერთიანებს ბრძანებები.
>> ისევ და ისევ, არ ველით, რომ თქვენ მთლიანად მესმის ეს, მაგრამ ეს
რაღაც დაინახოს.
და შემდეგ თუ თქვენ Googling მაგალითები ან ხვდები გსურთ
რაღაც, ეს შეიძლება იყოს სასარგებლო.
მოდით, მაგალითად, ასე რომ, ls, ტირე, ლ.
ასე რომ აქ მე ვხედავ გამომავალი საქართველოს ls, ტირე, ლ.
და მე ვიტყვი, OK, მე მინდა შესანახად რომ შევიდა ფაილი.
ყველა ამ output აქ, მინდა ექსპლუატაციაში შევიდა ცალკე ფაილი.
>> ასე რომ, ეს ცოტა უფრო მეტი, ვიდრე სიმბოლო არის ის, რასაც ჩვენ ვაპირებთ მოვუწოდებთ.
ჩვენ გადამისამართება გამომავალი შევიდა ფაილი.
მოდით მოვუწოდებთ ფაილის blah, იმიტომ, რომ ის, რაც მე, როგორც წესი, ყოველთვის ეძახით.
ახლა ჩვენ ვხედავთ, რომ ჩვენ გვაქვს ფაილის blah უფლება აქ.
და თუ გავხსნა ეს, მე ვხედავ, რომ ეს ზუსტად გამომავალი ბრძანება
რომ მე უბრალოდ გაიქცა.
და ანალოგიურად, შეგიძლიათ -
თუ ეს იყო გამომავალი ფაილი, ამ არის კიდევ შეყვანის ფაილი.
რა არის ბრძანება, რომ მე -
>> JOSEPH ვფიქრობ, შეგიძლიათ გამოიყენოთ ნაკლები ან მეტი, ალბათ.
>> ROB: მაგრამ რა უბრალოდ ნაკლები blah?
მე არ ვიცი.
თუ თქვენ მოვიდეს ამ სცენარით, როგორც იქ psets რომ ის სასარგებლოა.
>> JOSEPH შეგიძლიათ მილის შევიდა echo.
Pipe ფაილის შევიდა echo რომ ნახოთ იგი.
>> ROB: ეს არის მილის.
>> JOSEPH: უკაცრავად.
>> ROB: ყველა უფლება.
ასე რომ, ეს არის გამომავალი ფაილი.
ეს არის მიიღოთ ტექსტური ფაილი და გადასცემს პროგრამა.
და თქვენ ასევე ვხედავთ ამ ბიჭს.
ასე რომ, ეს სახის აკეთებს ორივე ერთდროულად.
და რეალურად, მე წარმოგიდგინოთ ორი ახალი ბრძანებები მხოლოდ გამოიყენოს იგი.
>> ისტორია არის მოსახერხებელი ბრძანება, რომ მხოლოდ აპირებს ამობეჭდოთ ჩამონათვალი
არაფერი მე ოდესმე აწარმოებს ბრძანებათა სტრიქონიდან.
ასე რომ, ჩვენ ვხედავთ, აქ ყველაფერი, რაც მე მაქვს გაშვებული მთელი ამ ხნის განმავლობაში.
უამრავი ls-ს.
>> და კიდევ ერთი სასარგებლო ბრძანება grep, რომ მისი მიზანია მოძიება მეტი
ტექსტის ეძებს ნიმუშების, ასევე, ეძებს რასაც თქვენ
მინდა, რომ უნდა ვეძებოთ.
და ასე მოსახერხებელი გამოყენება აქ არის, ვთქვათ ჩვენ გვინდა, რომ დაიბრუნოს ისტორია.
და მინდა ვეძებოთ ბრძანებები სადაც მე - რა
სასარგებლო ერთი ვეძებთ?
>> JOSEPH: [INAUDIBLE]?
>> ROB: Or მოდით შევჩერდეთ ყველა ეხება, სხვადსხვა მიზეზის გამო.
ასე რომ, ეს არის ის, რაც გამოიყურება ასე.
და თქვენ არ უნდა მთლიანად მესმის, რომ.
მაგრამ იდეა აქ არის, ისტორიის მიცემა იგივე გამომავალი ეს აქ
სადაც ეს დაბეჭდვისას მთელი ისტორიაში ყველაფერი მე ოდესმე აწარმოებს.
ჩვენ მაშინ ავლით, რომ -
ასე რომ ნაცვლად ბეჭდვას ის ეკრანზე, ჩვენ გვინდა, რომ გაივლის, რომ
ბრძანება grep რომელიც ეძებს ყველა ინსტანციის სიტყვა touch.
>> და ა.შ. გამოყენებით ამ კომბინაცია ინსტრუმენტები ისტორია და grep, მე ვხედავ, OK,
აქ არის ყველა ბრძანებას მე ოდესმე აწარმოებს, და აქ გარკვეულწილად საერთო ერთი.
ჩვენ ბოლოში.
და ეს ასევე მაძლევს ბრძანება მე უბრალოდ გაიქცა რომ ჰქონდა
სიტყვა touch მას.
მაგრამ მილის არის საკმაოდ სასარგებლო რამ აერთიანებს სხვადასხვა პროგრამები.
და რეალურად, ეს კომბინაცია for let me გამომავალი history შეიტანოს blah, და
ნება მომეცით grep გამოყენებით ფაილის blah რაც მინდა გამოიყურებოდეს მეტი.
ასე რომ, მილის არის მხოლოდ მალსახმობი ამ ორი ბრძანებები.
დიახ.
>> დინამიკები 4: [INAUDIBLE]?
>> ROB: დიახ.
რა არის -
Oh.
მოდით შეამოწმოთ.
ასე რომ, კატა, ძაღლი, თევზი.
ასე რომ, მინდა grep.
Dash, r, კიდევ ერთხელ, იქნება რეკურსიული, ამიტომ მინდა წარმოშობის ქვემოთ
ყველა დასტა.
მინდა რეკურსიული grep ყველა - და ნება მომეცით დროებით მისაღებად
ამ გზას.
იგნორირება ჩემთვის.
OK.
>> ასე რომ, მინდა დროებით grep for ყველა ინსტანციის სიტყვა თევზი.
და ა.შ. აქ, რასაც მე ვაკეთებ არის grepping რეკურსიული სიტყვა თევზი.
და ვარსკვლავი იმას ნიშნავს, რომ მთელი ამ ფაილები ამ დირექტორიაში.
ასე რომ, ეს მომცა ნებართვა უარყო, იმიტომ, რომ ეს არ არის დაშვებული წავიკითხე, რომ
კერძოდ ფაილი.
მაგრამ ეს არ არის ნაპოვნი თევზი ფაილის ტესტი.
>> მე შეიძლება ითქვას, კერძოდ, მე მხოლოდ გსურთ გამოიყურება ფაილი blah, in
შემთხვევაში იგი ვერ პოულობენ არაფრის.
მე მხოლოდ მინდა გამოიყურებოდეს ფაილი, ტესტი.
იგი იპოვის თევზი.
ეს არის საკმაოდ სასარგებლო ბრძანება უნდა იცოდეს ზოგადად.
არსებობს გარკვეული ალტერნატივები grep რომ უნდა იყოს უფრო
პროგრამისტი მეგობრული, მაგრამ მე, როგორც წესი, კიდევ დაეცემა უკან grep.
კითხვები?
OK.
>> არსებობს სხვა ბრძანებები?
Oh.
მხოლოდ ერთი off ერთი, რომ მე ყოველთვის მოძებნეთ იყოს fun არის კალ.
ასე რომ შეამჩნია, როდესაც მე ამ lovely სრული ეკრანის რეჟიმში, მე არ მაქვს, როგორიც დაბრუნება
პანელი ან არაფერი.
ასე რომ, cal მხოლოდ მაძლევს ლამაზი პატარა კალენდარი რომ უფლება
ახლა შეწყვიტა, მე ვივარაუდოთ.
მაგრამ ლამაზი პატარა ბრძანება.
>> JOSEPH: ეს არის [INAUDIBLE].
სხვა ბრძანებები, რომ თქვენ შეიძლება ჩანს მოიცავს clang და.
ჩვენ წავიდეთ მეტი მათ უფრო დეტალურად მოგვიანებით.
მაგრამ თუ თქვენ უკვე მუშაობენ pset, თქვენ უნდა იყოს
იცნობს იმ.
>> ROB: ყველა უფლება.
კითხვები command line რამ?
ყველა უფლება.
მოდით გადაადგილება ზოგიერთი C დაკავშირებული პერსონალი.
ცვლადები მათემატიკის.
OK.
ასე რომ, ისევე, როგორც ჩვენ გვქონდა მათემატიკის Scratch, ასევე, შეგიძლიათ გამოიყენოთ მათემატიკის C.
>> სანამ არ მივიღებთ, რომ მთლიანად, ასე რომ ცვლადები.
გახსოვდეთ, რომ როდესაც თქვენ გამოაცხადოს ცვლადი, როგორიცაა int x ან float y, თქვენ
უნდა მისცეს მას აკრიფოთ ადრე ცვლადის სახელი.
ასე რომ სახის ჩვენ ვნახეთ ჯერჯერობით int, float, ორმაგი, ხანგრძლივი ხანგრძლივი, რომელიც მე
რეალურად არ ვიცი, თუ ჩვენ ჩანს, რომ ჯერჯერობით.
>> არსებობს რამდენიმე სხვა პირობა.
ჩვენ ვხედავთ, char.
არსებობს მოკლე, რომელიც როგორც ის საპირისპირო ხანგრძლივი ხანგრძლივი, სადაც ეს
ნაკლებია რიცხვი.
ჩვენ ასევე ვნახეთ, სიმებიანი.
რა არის განსაკუთრებული სიმებიანი?
რატომ ვამბობ, რომ ეს არ საკმაოდ მოსწონს int?
>> დინამიკები 4: ეს ნამდვილად არ არსებობს.
>> ROB: ჰო.
ასე რომ ერთადერთი მიზეზი გვაქვს string იმიტომ, რომ, როდესაც თქვენ
hash, მოიცავს cs50.h.
და ვნახავთ მაგალითები მოგვიანებით - oh, რომ არ ერევა, რომ კარგად -
სადაც cs50.h აკეთებს რაღაც გასწვრივ ხაზი ტიპის
def, char ვარსკვლავი, სიმებიანი.
>> და ისე, რომ ის ამბობდა, რომ ჩვენ კი არა იცით, რა char ვარსკვლავი არავის გაუკეთებია.
მაგრამ ეს ამბობდა ჩვენ გვინდა string.
ნებისმიერ ადგილას თქვენ უკვე გამოყენებით string, თქვენ შეეძლო გამოყენებით char ვარსკვლავი,
რომელიც რეალურად არის ტიპის, რომ არსებობს C ენაზე.
მაგრამ ამას კიდევ რომ.
ოჰ, და მიდის უფლება უკან.
სისუფთავე.
>> ასე რომ, იგივე bool სადაც ჭეშმარიტი და ცრუ.
ეს არ არის ინტეგრირებული ტიპის C. იმის ნაცვლად, რომ, უბრალოდ, ნიშნავს ეს აქვს
ღირებულება ნულოვანი?
მაშინ ჩვენ უბრალოდ მიგვაჩნია, ეს უნდა იყოს ცრუ.
ნიშნავს თუ არა ეს აქვს ღირებულება -
ასევე, ნიშნავს ეს რაიმე ღირებულება, რომელიც არ არის ნულოვანი?
მაშინ ჩვენ მიგვაჩნია, რომ ეს უნდა იყოს ნამდვილი.
ასე რომ, ერთი მართალია, ორი მართალია, არაფერს nonzero მართალია.
ასე რომ, ეს არის იმ.
კითხვები გამოცხადების ცვლადები და ცვლადი ტიპები და ყველა რომ?
ჰო.
>> დინამიკები 4: For ხანგრძლივი ხანგრძლივი, წიგნი, ის ამბობს, რომ ეს უნდა იყოს ხანგრძლივი ხანგრძლივი int.
მაგრამ მხოლოდ ხანგრძლივი ხანგრძლივი მუშაობა?
>> ROB: ასე რომ, ამ ტიპის მოდიფიკატორები.
ასე int x.
ასე რომ ჩვენ შეგვიძლია ასევე აცხადებენ, unsigned int x.
შეიძლება ითქვას, მოკლე int x.
ჩვენ შეგვიძლია ვთქვათ, ხანგრძლივი ხანგრძლივი int x.
მაგრამ საკმაოდ ბევრი ნებისმიერი იმ რამ I მხოლოდ განაცხადა, unsigned int, მოკლე int,
ხანგრძლივი ხანგრძლივი int, თქვენ შეგიძლიათ მოშორება int და ეს მხოლოდ ვივარაუდოთ,
რომ თქვენ იმას ნიშნავდა, int.
ასე რომ, unsigned x, რომელიც მხოლოდ იმას ნიშნავს -
თქვენ იცით, როგორ წესი, ერთად int, შეიძლება ითქვას, x უდრის უარყოფითი 3?
With unsigned int, თქვენ არ შეგიძლიათ.
>> JOSEPH: ისევ და ისევ, კამერა, კითხვა იყო, რა განსხვავებაა
შორის ხანგრძლივი ხანგრძლივი int და მხოლოდ ხანგრძლივი ხანგრძლივი?
>> ROB: ჰო.
ასე რომ მე თითქმის არასდროს წერა ხანგრძლივი ხანგრძლივი int.
I დაწერს ხანგრძლივი ხანგრძლივი.
>> JOSEPH: ნებისმიერი კითხვები?
>> ROB: OK.
ასე რომ სულელური პატარა შეხსენება, რომ ასე ვაცხადებთ ცვლადი და ინიციალიზაცია
ცვლადი და აცხადებენ, სხვა ცვლადი და ინიციალიზაცია
ეს ყველაფერი ერთი ნაბიჯია.
ასე რომ დეკლარაცია ცვლადი და ინიციალიზაციისას ცვლადი არ აქვს
, მაგრამ შეიძლება იყოს იგივე ხაზი.
>> ასე რომ ჩვენ გვაქვს სტანდარტული მათემატიკის ოპერატორები რომ თქვენ გამოიყენება -
პლუს, მინუს, გაყოფა, ჯერ.
არსებობს ასევე modulo, რომელიც ჩვენ დავინახავთ.
არ არსებობს, ყოველ შემთხვევაში, C, ჩაშენებული ძალა
exponentiation caret ოპერატორს.
ასევე, არსებობს caret ოპერატორი, მაგრამ ეს არ არის ძალა.
>> JOSEPH მაგრამ ეს არ exponentiation, დიახ.
>> ROB: არ გამოიყენოთ caret უნდა ვივარაუდოთ, რომ ეს იმას ნიშნავს,
ისევე როგორც squared ან რასაც.
ასე რომ ზოგიერთი რამ შენარჩუნება იბადება გაყოფის შესახებ.
მე დგანან.
ასე განაცხადა ინიციალიზაცია პასუხი.
ასე რომ, ჩვენ ვამბობთ, float პასუხი შეადგენს 1 იყოფა 10.
ბეჭდვა პასუხი ორ ათობითი ადგილებში.
>> და ეს არის სახის რამ, რომ მე რომ კაცი printf გაერკვნენ, რომ
რა ჯანდაბა არ%, dot, 2F ნიშნავს?
და რომ მხოლოდ იმას ნიშნავს, ისევე, იგნორირება 0.2.
და%, f არის ის, რაც ჩვენ ვიყენებთ ბეჭდვა ათწილადი.
0.2 ამბობს, print, რომ ათწილადი ორ ათობითი ადგილებში.
ასე რომ, ამ პროგრამას აქვს bug, და თქვენ შეიძლება მინახავს ეს ადრე ზოგიერთ
ადრე CS რა თქმა უნდა.
მაგრამ რა არის ის, რომ bug?
>> დინამიკები 5: Zero.
>> ROB: ჰო.
ასე რომ, როდესაც ჩვენ ვამბობთ, პასუხი უდრის 1 იყოფა 10, ჩვენ გვინდა
პასუხი იყოს 0.1.
მაგრამ 1 იყოფა 10 1 რიცხვი, 10 რიცხვი.
, და ასე რომ, როდესაც ჩვენ გავაკეთებთ რიცხვი იყოფა მთელი რიცხვი, ჩვენ ვაპირებთ დავუბრუნდეთ
მთელი რიცხვი.
ასე რომ 1 იყოფა 10 არის 0.1.
>> მას შემდეგ, რაც მას სჭირდება, რათა მოგვცეს რიცხვი, უბრალოდ აპირებს გადაყარეთ, რომ
ათობითი ადგილი და აცხადებენ, რომ პასუხი არის 0.
და ამრიგად, როდესაც ჩვენ ბეჭდვა უპასუხოს აქ, ის აპირებს ბეჭდვა 0.00.
>> JOSEPH: და როგორც აღნიშნავენ, რეალურად ისვრის შორს, რაც შემდეგ
ათობითი წერტილი.
ასე რომ, თუ ნაცვლად ჰქონდა 6 ​​იყოფა 10, თქვენ ალბათ ფიქრობთ, რომ გადმოგცეთ
0.6 და მაშინ გარშემო up to 1.
მაგრამ რეალურად, თუ რა ხდება, როდესაც იგი აკრიფოთ ამოცანები არის ის, რომ მცირდება, თუ რა არის
მას შემდეგ, რაც ათობითი წერტილი.
ასე რომ 0.6 არ გახდეს 0.
>> ROB: ჰო.
და ჩვენ ვიტყვით, truncate რომ.
ასე რომ, როდესაც თქვენ მიცემული to int, ათობითი არის შემოკლებული.
ასე რომ გადავწყვიტოთ, რომ - არსებობს ფაქტობრივად, ორი.
და მე ვაპირებ, რომ მეორე, იმიტომ, რომ ეს ერთი არის ბევრად უფრო ადვილია, სარემონტო.
>> ასე რომ ერთი სარემონტო არის გამოიყენოს მოძრავი გაყოფა.
და მართლაც, თქვენ მხოლოდ უნდა ერთი მათგანი float.
მაგრამ ეს გარკვეულწილად ნათელი მხოლოდ რათა ორივე მოძრავი.
ასე რომ, 1.0 იყოფა 10.0 არის გამყოფი ორი მოძრავი.
ასე რომ, პასუხი იქნება დასრულდება მდე მიმდინარეობს float, და ა.შ. თქვენ
სწორად ბეჭდვა 0.10 აქ.
>> რომ რაღაც არ მუშაობს ისე კარგად ამის შესახებ არის, ასევე, რა თქმა უნდა, ეს იყო მარტივი
საკმარისი გადაიყვანო 1 float მიერ მიღების იგი 1.0.
მაგრამ რა, თუ ნაცვლად ჩვენ გვქონდა ორი რიცხვებით ისევე როგორც int x უდრის 1 და int y
შეადგენს 10, ხოლო შემდეგ გვინდოდა რომ ჩვენგან x იყოფა y?
ასე რომ, ეს არ არის ადვილი, უბრალოდ გავაკეთოთ x.0 ან რამე.
>> ასე რომ გადავწყვიტოთ, რომ კასტინგის.
ასე რომ ჩამოსხმის არის გზა C გარდაქმნას ერთი ცვლადის ტიპის სხვა.
ასე რომ აქ, 1 არის მთელი რიცხვი.
და აყენებს ამ float წინ ეს, ჩვენ აძლევენ 1 float.
და ეს იქნება კონვერტირება 1 1.0.
და ეს დააკონვერტიროთ 10 10.0.
>> და შემდეგ რამ მოიქცევა მსგავსად წინა ვერსია, ჩვენ უბრალოდ აჩვენა
სადაც, როგორც მოსალოდნელი იყო, მივიღებთ 0.10 და ეს კიდე ბეჭდვა, რომ.
და ჩვენ შეგვიძლია ამის გაკეთება ცვლადები, ძალიან.
ასე რომ, შეიძლება ითქვას, float x იყოფა float y.
>> JOSEPH: ნებისმიერი კითხვები?
>> ROB: ასე რომ, ისევე, როგორც რეგულარული მათემატიკის, ჩვენ ოპერატორის პრეცენდენტის.
ასე რომ, მათემატიკის კლასის, თქვენ უფრო ეძახით ბრძანებით ოპერაციებში.
აქ, ოფიციალური ვადა ოპერატორის პრეცენდენტის.
მაგრამ ოპერატორის პრეცენდენტის, ან ყველაზე ოპერატორები, როგორც თქვენ მოელოდა.
>> ასე რომ, ისევე, როგორც მათემატიკის, 2 ჯერ 10 არის იქნება დაჯგუფებულია უფრო მჭიდროდ, ვიდრე
ამ 10 იყოფა 2 და შემდეგ 2.
ბრძანებით ოპერაციების, ის ყველაფერს გააკეთებს 2 ჯერ 10, 10 იყოფა 2, და შემდეგ
ის ყველაფერს გააკეთებს, 20 პლუს 5 plus 2.
ასე რომ, როგორც მოსალოდნელია, და შეგიძლიათ გამოიყენოთ ფრჩხილებში ჯგუფის გამონათქვამები.
თქვენ არ შეგიძლიათ გამოიყენოთ კვადრატულ ფრჩხილებში ჯგუფი გამონათქვამები.
ჰო?
>> დინამიკები 5: იქნებ რეალურად უბრალოდ დაბრუნდეს ერთი მეორე?
შეგიძლიათ მიცემული int სიმებიანი?
>> ROB: ასე რომ, C, შეგიძლიათ მიცემული არაფერს გსურთ არაფერი გსურთ.
ეს იმას არ ნიშნავს, რომ ეს კარგი რამ უნდა გააკეთოს.
ასე რომ, როდესაც თქვენ მიცემული int to სიმებიანი, ეს ნიშნავს, რომ -
და ჩვენ კიდევ ამ ბევრად უფრო კარგად -
>> JOSEPH: გაცილებით გვიან.
>> ROB: მე არ მინდა ვთქვა, გაცილებით გვიან, ასე რომ მე შევეცადე, რომ შევცვალო ჩემი წინადადება.
ჩვენ შეღწევას ეს ბევრად უფრო საფუძვლიანად მოგვიანებით, სადაც მართლაც, როდესაც თქვენ გაქვთ
string ცვლადი -
ასე რომ სიმებიანი შეიძლება თვითნებურად ხანგრძლივი, არა?
და ჩვენ ვამბობდით, რომ int არის ოთხი ბაიტი და ხანგრძლივი ხანგრძლივი რვა
bytes და float ოთხი bytes.
ასე რომ, ტექსტი, ისევე, როგორც int, მხოლოდ გარკვეული რაოდენობის ბაიტი მას.
და რომ იქნება ოთხი bytes.
>> მაგრამ სიმებიანი შეიძლება იყოს საკმაოდ თვითნებურად ხანგრძლივი, არა?
ასე რომ მიესალმები მსოფლიოში უკვე, თუ ეს 10 სიმბოლო ან რასაც, რომ უკვე
იქნება მეტი 4 bytes შემიძლია ჯდება სიმებიანი.
და ასე როგორ strings ნამდვილად მუშაობს ის არის, რომ ისინი, სადაც მეხსიერება, string
მიმდინარეობს ინახება.
>> და ა.შ. აქ, როდესაც ვამბობ, რომ string x შეადგენს Hello World, შიგნით x არის
უბრალოდ ვამბობ, oh, hello world ინახება ამ კონკრეტულ ადგილზე მეხსიერებაში.
ასე რომ, თუ ჩვენ ვცდილობთ მიცემული რიცხვი string, მაშინ ჩვენ ვცდილობთ ინტერპრეტაცია
შემთხვევითი ნაწილი მეხსიერება როგორც სიმებიანი.
და რომ თითქმის ყოველთვის არღვევს რამ.
>> JOSEPH მაგრამ თუ ეს confuses თქვენ, ჩვენ გააშუქებს იგი
უფრო სიღრმისეული შემდეგ.
>> ROB: ჰო.
ეს არის სადაც თქვენ აპირებთ შეღწევას პოინტერები.
და ეს არის მნიშვნელოვანი ბლოკი ორი კვირის განმავლობაში ამ კურსს.
>> დინამიკები 6: იგი მუშაობს როგორც ობიექტები სხვა ენებზე თუ არა მართლა?
>> ROB: ასე რომ სხვა ენებზე, ობიექტების იქნება წარმოდგენილია გამოყენებით პოინტერები.
ეს არ არის იგივე, თუმცა.
ნებისმიერი აზრები?
>> JOSEPH: არა
არარის აზრები.
>> ROB: OK.
>> JOSEPH შემდეგი.
>> ROB: უბრალოდ რომ.
ყველა უფლება.
ასე modulo.
ისევე, როგორც ჩვენ პლუს, მინუს, გაყოფა და გამრავლება.
ასე modulo ერთი შეგიძლიათ არ მინახავს ადრე.
და ეს უბრალოდ ამბობს, მისცეს me დარჩენილი.
ასე 55% 10.
დარჩენილი აკეთებს 55 გაყოფილი 10 იქნება 5.
ასე 55% 10 5.
და 3% 5 იქნებოდა 3.
8% 8 იქნება 0.
16% 15 იქნება 1.
>> JOSEPH: ერთი რამ აღვნიშნო, ამ, ძალიან, არის, ეს შესაძლოა არ იმუშაოს როგორც მოსალოდნელია
თუ თქვენ იყენებთ უარყოფითი რიცხვი.
ასე რომ, უარყოფითი 5% 4, ზოგიერთი ადამიანი შეიძლება ვიფიქროთ, რომ არის -
რას ვფიქრობ, უარყოფითი 5% 4 იქნება?
>> დინამიკები 5: One.
>> JOSEPH: ასე ამბობენ ერთი, ზოგიერთი ამბობს უარყოფითი ერთი.
მაგრამ რა -
>> ROB: მე კი არ განაცხადა ერთ იმ.
>> JOSEPH ორი, უკაცრავად.
ზოგიერთი ადამიანი ამბობს -
>> ROB: სამი.
>> JOSEPH სამი?
>> ROB: Negative -
რა იყო - ნეგატიური ხუთ -
>> JOSEPH სამი, სამი, სამი.
უკაცრავად.
იმის გამო, რომ Modulo, ზოგადად, როდესაც თქვენ ჩანს, რომ სხვაგან, ეს როგორც წესი ნიშნავს
დაბრუნების დადებითი რიცხვი, არა?
>> ROB: ასე რომ, როდესაც ჩვენ ვამბობთ, მათემატიკის,% 10 ის, ისინი როგორც წესი, მინდა გადმოგცეთ -
თუ ჩვენ mod 10, მაშინ ჩვენ ველით, რომ მიიღეთ რიცხვი 0 და 9.
აქ, რომ არ არის საქმე, რომ თქვენ მიიღებს უარყოფითი რიცხვები დაბრუნდა.
>> JOSEPH ასე რომ უარყოფითი 5% 4 იქნება უარყოფითი 1.
>> ROB: მაგრამ ეს იშვიათი, რომ თქვენ mod-ing უარყოფითი რიცხვები უნდა დაიწყოს.
გამოტოვოთ ეს.
>> JOSEPH: ჰო.
>> ROB: Meh.
OK.
ასე რომ, ერთი რამ აღვნიშნო შესახებ მოძრავი არის ის საშიში საქციელი,
მაგრამ მოძრავი არ არის ზუსტი წარმომადგენლობა.
ასე ბრუნდება bytes ერთხელ, მახსოვს, რომ int ყოველთვის ოთხი ბაიტი და
float ყოველთვის ოთხი bytes.
ასე რომ, Lucas მაგალითი არის საკმაოდ კარგი.
>> ასე რომ, ვფიქრობ 1 იყოფა 3.
ასე 0,3333333.
იმ შემთხვევაში, თუ მე მხოლოდ 32 ბიტი, როგორ შეიძლება მე შესანახად 0,33333 ზუსტად?
და იქნებ, სხვადსხვა მიზეზის გამო, თქვენ ამბობთ, ყველა უფლება, ასევე, მოდით უბრალოდ, ვამბობთ
რომ ამ კონკრეტულ 1011001, მოდით უბრალოდ, ვამბობთ, რომ უნდა იყოს 0,333333.
ისე, თქვენ მხოლოდ აქვს სასრული რაოდენობის იმ ბიტი, ასე რომ შეუძლებელია
წარმოადგენს თითოეული მცურავი წერტილი ღირებულება მოცემულია მხოლოდ 32 ბიტი.
>> ასევე, შეუძლებელია წარმოადგენს მცურავი წერტილი ღირებულება მოცემულია უსასრულო -
ასევე, მოცემული ნებისმიერი სასრული რაოდენობის ბიტი.
ასე რომ, საკითხი აქ არის, ასევე, როდესაც ჩვენ გამოყენებული ბეჭდვა ორ ათობითი ადგილებში,
ჩვენ არ სწორად მიიღოს პასუხი 0.10.
მაგრამ ქვეშ Hood, ეს ნამდვილად მიმდინარეობს ინახება ახლოს როგორც შესაძლებელია
0.10 რადგან იმ ბიტი შეგიძლიათ წარმოადგენენ.
ეს არის მომდევნო slide?
თუ არა?
>> JOSEPH: ჰო, ის, რომ.
>> ROB: Blegh, blegh.
>> JOSEPH: Yeah, შეგიძლიათ უბრალოდ გაიყვანოს შენიშვნები up bit.
>> ROB: მე უბრალოდ აპირებს მასშტაბირება წლის ბოლო, რომ.
Oh my gosh, რომ [INAUDIBLE].
ასე რომ, ნომერი.
რომ არის რა დაიბეჭდება თუ ჩვენ აწარმოებს, რომ პროგრამა.
და შენიშნავს, რომ ნამდვილად არ არის დიდი გარიგება თუ ჩვენ მხოლოდ ზრუნვა, როგორებიცაა
ორ სამ ათობითი ადგილებში.
როგორც ჩვენ მხოლოდ თავდაპირველად ბეჭდვითი 0.10, და ამიტომაც ჩვენ ვნახეთ, არაფერი ცუდი.
მაგრამ ერთხელ ჩვენ ვიწყებთ მისაღებად შევიდა ზუსტი, ზუსტი რიცხვი, რომ
წარმოადგენს, ჩვენ ვხედავთ, რომ მას არ შეუძლია ზუსტად წარმოადგენს 0.1.
>> და ნაწილი პრობლემა აქ ის არის, როგორიც, ყველა უფლება, რომ ჯარიმა, მაგრამ, ასევე,
პირველი, რა, თუ ჩვენ შევეცადეთ, პასუხი უდრის უდრის 0.1?
ის არის, რომ დაბრუნებას აპირებს ჭეშმარიტი ან მცდარი?
ასე რომ, ეს ძნელი სათქმელია.
მე ვფიქრობ, რომ რეალურად შეიძლება TRUE.
იქნება ეს პირველი -
მე არ ვიცი.
პასუხი ერთხელ თქვენ დაიწყოს საქმე ერთად მცურავი პუნქტიანი ღირებულებებს, თქვენ საკმაოდ
ბევრი არ უნდა იყოს გამოყენებით თანასწორობა რადგან ამ ორაზროვნება.
>> და თქვენ იცით, რომ ეს მეასედ ათობითი ადგილი რომ
მცურავი პუნქტიანი ვერ შეძლო სწორად გაუმკლავდეს.
და ა.შ. თანასწორობა უბრალოდ ვერ კი მიუხედავად იმისა, რომ ნომერი, - თუ ყოფილა
გამოყენებით ზუსტი ციფრები, ნომრები უნდა უკვე ზუსტად იგივე.
ის განმავლობაში, ისევე როგორც 50 გათვლებით გამოყენებით მცურავი
წერტილი ღირებულებები, შეცდომა შეძლოთ up და და და
რამ უბრალოდ არასწორია.
>> JOSEPH: და იქ არ ყოფილა ნამდვილად ცნობილი მაგალითები გვაქვს.
Like NASA ინჟინრებმა მიღებული ამ არასწორი, რამაც რაკეტები აფეთქდეს
საჰაერო შემდეგ მათ უკვე დაიწყო.
და უამრავი საკითხებზე, როგორიცაა, რომ.
ასე რომ, yeah.
>> დინამიკები 6: როცა ამბობენ, 0.3 f, იგი truncate დანარჩენი?
ან იგი გარშემო up ან down?
>> ROB: Will printf რაუნდი ეს?
>> JOSEPH ვფიქრობ, printf truncates.
>> ROB: OK.
ასე რომ ჩვენ შეგვიძლია ასეთივე წავიდეს მოპირდაპირე მიმართულებით ეს, სადაც, ამ შემთხვევაში,
უახლოესი ის შეიძლება წარმოადგენდეს 0.1 იყო ამ ნომერზე.
უახლოესი ის შესაძლოა წარმოადგენს 0.2 არის საპირისპირო
მიმართულებით, 0,199999996356 ან რამე.
ასე რომ, თუ ჩვენ წავედით იმ მიმართულებით რამ, მაშინ printf 0.3 f დაბრუნდნენ
1.99 ნაცვლად 2.00.
>> JOSEPH: და მე არ ვარ მთლად დარწმუნებული ვარ, რომ.
დაგვჭირდება წერენ პატარა, პატარა პროგრამა მხოლოდ შეამოწმოს, რომ.
>> ROB: მიუხედავად იმისა, რაც ჩვენ დარწმუნებული ვართ, ის არის, რომ თუ ცდილობდა მიცემული, რომ
int, და აძლევენ to int აპირებს იწვევს ის truncate ათობითი, თუ
თქვენ ცდილობენ მიცემული 1.9999999 to int, თქვენ მიიღებთ 1.
და ასე რომ თქვენ უნდა ზოგადად გამოიყენოთ მრგვალი ფუნქცია მათემატიკის ბიბლიოთეკაში.
კითხვები?
OK.
>> JOSEPH: So მოძრავი პირობები და ლოგიკური გამონათქვამები.
ასე რომ თქვენ არ მინახავს ეს ადრე.
და ფაქტობრივად, ნება მომეცით დარწმუნდით ჩემი კომპიუტერის ფორმატი აქ.
ფართი.
უკაცრავად, ჩვენ ვაპირებთ, რომ უნდა გაუმკლავდეთ ცოტა ათვლის საათზე კიდეები.
>> მაგრამ ჰო, თქვენ ბიჭები მინახავს ადრე Scratch.
ასე რომ, ეს სწორედ აქ არის გამოხატულება რომელიც გამოიყენება
პირობითი განცხადებაში.
ასე რომ, პასუხი გასცეს მეტი ნულოვანი ნების გითხრათ, ჭეშმარიტი ან მცდარი.
და ეს ნამდვილად მნიშვნელოვანია, რადგან ისინი საშუალებას მოგვცემს გააცნობს
ლოგიკა ჩვენი კოდი.
>> ასე მაგალითად, ეს არის პროგრამა დაწერილი Scratch რომ სთხოვს შესახებ
განთავსების რიცხვი და ეუბნება, თუ არა მთელი რიცხვი, რომ მისცა თქვენ იყო
დადებითი ან უარყოფითი რიცხვი.
და კონვერტაციის მეტი აქ არის თქვენ პირველი ამობეჭდოთ განცხადება,
მომეცი რიცხვი.
და მაშინ ვთხოვთ რიცხვი.
>> და მაშინ გამოვიყენოთ პირობითი ლოგიკა მეტი აქ თუ არა, რომ ნომერი
რეალურად მეტი ნულოვანი თუ არა.
ასე რომ აქ გვაქვს ლოგიკური გამოხატვის შიგნით პირობითი იმ შემთხვევაში, თუ განცხადებაში.
არის თუ არა რაიმე კითხვა?
არსებობს რაიმე შეკითხვები, რომ?
OK.
>> ასე რომ იქ უფრო მეტია ვიდრე უბრალოდ მეტი, რა თქმა უნდა.
შეგიძლიათ მშენებლობა ლოგიკური გამონათქვამები გამოყენებით ყველაზე სახის რამ თქვენ
ვფიქრობ, წელს მათემატიკის.
ასე აღემატება.
ეს უნდა იყოს ნაკლები.
უკაცრავად.
და ინტერვალი.
>> ROB: ღმერთმა ნუ ქნას, დატოვოს იგი.
>> JOSEPH ყველა უფლება.
ასე რომ, მეტი, ნაკლები, უფრო მეტი ვიდრე, ან ტოლია ნაკლები
ვიდრე, ან ტოლია.
ჩვენ ვიყენებთ ორმაგი შეადგენს შემოწმება თანასწორობა, რადგან ერთი უდრის საშუალებით
დავალება, არა?
დიახ.
და მაშინ ჩვენ შეგვიძლია ასევე არ უდრის მიერ გამოყენებით ძახილის ნიშნის, შეადგენს.
>> და ეს ძახილის ნიშნის სიმბოლო სისტემაში ასევე უნდა გაგრძელდეს ასე, რომ თუ გსურთ
ინვერსიის ნებისმიერი სახის ლოგიკური გამოხატვის, თქვენ შეგიძლიათ ამის გაკეთება.
ასე რომ, ეს შეაფასებს ჭეშმარიტი იმ შემთხვევაში, თუ პასუხი არის ნაკლები
ვიდრე ან ნულის ტოლია.
ნებისმიერი კითხვები რომ?
OK.
>> ასე, რომ თქვენ, აგრეთვე, შეგიძლიათ დააკავშიროთ ამ გამოსახულებების გამოყენებით ლოგიკური და და
ლოგიკური ან.
ასე რომ, ეს არის მხოლოდ და სიმბოლო, რომელიც უნდა იყოს Shift, 7.
და ეს არის მილის სიმბოლო, რომელიც არა ქვედა L. ეს ერთი
ეს უფლება ზემოთ თქვენი შეიყვანეთ გასაღები.
ასე, რომ თქვენ გამოიყენოთ ორ სიმბოლოს ლოგიკური და ლოგიკური Or.
>> ასე რომ, ეს იქნება მხოლოდ TRUE თუ პასუხი ერთი, ორი, სამი, ან ოთხი.
და ეს მხოლოდ TRUE თუ პასუხი სცილდება, რომ ორივე მხარეს.
ასე რომ, ეს არ არის ერთი, ორი, სამი, ან ოთხი.
და ისე გამოიყენებს რომ გამოხატვის -
>> ROB: ან ნულოვანი ან ხუთ.
>> JOSEPH: Zero ან ხუთ.
უკაცრავად.
დიახ, დიახ, დიახ.
OK.
და აი აქ, ახლა, იმავე გზით თქვენ გამოიყენებს, რომ გამოხატვის, პატარა
გამოხატვის მხარეს თუ პირობითი განაცხადი, თქვენ ასევე შეგიძლიათ ეს
ანალოგიურად მხოლოდ აყენებს მას შიგნით ფრჩხილებში, რომ იმ შემთხვევაში, თუ განცხადებაში.
ასე რომ, ეს printf მხოლოდ ცეცხლი, თუ პასუხი ერთი, ორი, სამი, ან ოთხი.
ნებისმიერი კითხვები აერთიანებს გამონათქვამები?
>> ასე რომ, არსებობს კიდევ ერთი პირობითი მშენებლობა მოვუწოდებთ თუ / სხვა.
ასე რომ, ძირითადად, ეს ახლა იმას ნიშნავს, OK, თუ რაღაც მინდოდა ამის შემოწმება არ იყო
მართალია, მაშინ წავიდეს სხვაგან და ასრულებს, რომ სხვა action.
ასე რომ, ამ შემთხვევაში, მე ვკითხე მომხმარებელს რიცხვი.
არის მთელი რიცხვი მეტი ნულოვანი?
დიახ?
კარგად, მაშინ აიყვანეს დადებითი რიცხვი.
თუ არა, მაშინ მას უნდა ჰქონდეს იყო უარყოფითი და ნულოვანი.
ასე, რომ თქვენ აიყვანეს უარყოფითი რიცხვი ან ნულოვანი ამ შემთხვევაში.
დიახ.
ან ნულოვანი.
>> და მაშინ ჩვენ ასევე გვაქვს თუ / სხვაგან, იმ შემთხვევაში, თუ და სხვა.
ასე რომ, ეს საშუალებას გვაძლევს შეასრულოს თანმიმდევრობა ყველაფერი მხოლოდ იმ შემთხვევაში თუ პირველი, ვინც ვერ.
ასე რომ, ამ შემთხვევაში, ახლა ჩვენ მიღების ბოლო ერთი თქვენ შეარჩიო ნულოვანი.
ასე რომ, თუ არც აიყვანეს დადებითი და არც უარყოფითი რიცხვი, მაშინ ისინი უნდა
არ აიყვანეს ნულოვანი.
ასე რომ, ეს მხოლოდ მიდის ქვემოთ ჯაჭვის მოსწონს ეს.
>> ასე მაგალითად, თუ როგორ იმ შემთხვევაში, თუ განსხვავდება -
იმ შემთხვევაში, თუ / Else განსხვავდება უბრალოდ თანმიმდევრობა IFS.
და ეს არის საერთო საკითხი, რომ ხალხი ითხოვს, რომელიც, ასევე, თუ თქვენ, როგორც
95 CS50, რა იქნება ამ პროგრამა გითხრათ?
>> დინამიკები 5: თქვენ მიიღო A.
>> JOSEPH: დიახ.
შენ ყოველი ერთი იმ უფლება.
შენ, შენ B, თქვენ მივიღე C და D, არა?
ასე რომ, ყველა ამ მისაღებად შეაფასა მიზნით.
ასე რომ, ხოლო 95 მეტია 90 ის ასევე აღემატება 80, ასევე,
უფრო მეტი, ვიდრე 70, და ეს ასევე მეტია 60.
ასე რომ თქვენ გაქვთ ყველა იმ კლასის.
და მე ვივარაუდოთ, თქვენ ამას მხოლოდ მინდა A.
>> გზა დაფიქსირება, რომ არის შეცვლის იმ Else / თუ 's.
ასე რომ, ამ სცენარით, ის ხედავს, რომ 95 არის უფრო მეტი, ვიდრე 90, და მაშინ იგი აკეთებს
არ შეაფასოთ დანარჩენი განცხადებების.
რაიმე შეკითხვები, რომ?
>> ასე რომ, არსებობს კიდევ ერთი პირობითი სახის სტრუქტურა, რომელიც ჩვენ აქ, რომელიც ჩვენ
მოვუწოდებთ შეცვლა განცხადებაში.
ასე რომ, ეს საშუალებას გაძლევთ, ძირითადად შემოწმება რა ღირებულება რიგი თქვენ დააყენა
შევიდა switch განცხადება.
ასე რომ, ამ სცენარით, ჩვენ გადართვის ი n, და ჩვენ ვამბობთ, OH, თუ N არის
ერთი, მაშინ ბეჭდვა ეს განცხადება.
და შემდეგ შესვენება, რაც იმას ნიშნავს exit გარეთ შეცვლა განცხადებაში.
>> თუ ეს არ იყო, მაშინ, კარგად, უბრალოდ საბოლოოდ, შეამოწმოს ყველა იმ შემთხვევებში.
და ასე ამოწმებს, თუ ის ერთი ან ორი ან სამი, და იგი ბეჭდავს შესაბამისად.
და რა ეს ნაგულისხმევი სიტყვით ქვემოთ აქ საშუალებით, თუ ისინი არ მიუთითოთ ნებისმიერი
იმ, მაშინ ვიტყვი, არასწორი.
ასე ვთქვათ ვთხოვ N და მომხმარებლის მაძლევს ოთხ.
ისე, ეს მატჩები არც იმ შემთხვევაში, ასე რომ ამობეჭდოთ რა
სტანდარტულ სექციაში.
დიახ, კითხვის ნიშნის ქვეშ?
>> დინამიკები 5: შეგიძლიათ გამოიყენოთ ლოგიკური გამოხატვის ნაცვლად
ერთი, ორი, ან სამი?
>> JOSEPH ასე რომ კითხვა შეგიძლიათ გამოიყენოთ ლოგიკური გამონათქვამები ერთის ნაცვლად,
ორი და სამი?
და C, მე მჯერა, თქვენ ვერ გავაკეთოთ, რომ.
არამედ სხვა ენებზე, რაც ალბათ ექმნებათ დასასრულს
სემესტრის როგორიცაა JavaScript, თქვენ შეგიძლიათ.
ასევე, თქვენ უნდა გამოთვლაც პირველი რომ ღირებულება და შემდეგ გამოიყენოთ იგი
გადახვიდეთ განცხადებაში.
ჰო?
>> ROB: So ნაწილი სასარგებლოდ შეცვლა განცხადებებია ვფიქრობ, თუ ეს
როგორც იმ შემთხვევაში, თუ / სხვა დანარჩენი, ასე მოსწონს თუ n შეადგენს შეადგენს ერთი ან რასაც.
Else / თუ n უდრის უდრის ორი, რასაც.
Else / თუ n უდრის უდრის სამი.
ასე რომ გზა პროგრამაში მიიღებს არის იქნება თანამიმდევრულად დაცემას რომ სიაში
და შეამოწმოს, არის N ერთი?
Nope.
არის n ორი?
Nope.
არის n სამი?
ჰო.
ამის გაკეთება.
>> ხოლო ერთად შეცვლა განცხადებებს, რეალურად შეუძლია შეადგინოს, რომ იყოს
მართლაც სწრაფი.
და როგორც კი იგი აცხადებს, შეცვლა, ეს ამბობს, ყველა უფლება, n არის ორი, მე ვარ
დაუყოვნებლივ აპირებს ხტომა, სადაც მე უნდა დაიწყოს შესრულებაში.
მე არ ვაპირებ პირველი შემოწმება, არის n ერთი, N ორი?
მას შეუძლია დაუყოვნებლივ დაიწყოს აკეთებს რასაც ის უნდა გავაკეთოთ.
>> და იმის გამო, რომ მას არ შეუძლია მიიღოს ლოგიკური პირობები.
ანდა ეს უნდა გააკეთოს მორიგი, ისევე როგორც, ყველა უფლება, არის n
მეტი ნულოვანი?
დანარჩენი n მეტი 10 ან რასაც.
>> JOSEPH: ამ შემთხვევაში, თუ გამოიყენება იმ შემთხვევაში, თუ / სხვაგან, იმ შემთხვევაში, თუ ის, მაშინ switch იქნება
აწარმოებს დაახლოებით სამჯერ სწრაფად, ვიდრე იმ შემთხვევაში, თუ / სხვაგან, იმ შემთხვევაში, თუ.
ჩვენ შეგვიძლია ორგანიზება შეცვლა ასეთ ისე, რომ ჩვენ არ დაარღვიოს
შემდეგ თითოეულ შემთხვევაში.
ასე რომ, ამ შემთხვევაში, მე დანაწევრება ციფრები, რომ ვირჩევთ ერთ და
ორი მყოფი მაღალი არ ნომრები და სამი მყოფი დიდი რაოდენობით.
>> ასე რომ, ამ შემთხვევაში, თუ N არის ერთი ან ორი, მოხვდა საქმე და მაშინ იგი
ჩავარდნას, რადგან არ არსებობს შესვენება.
და დასრულდება აქ.
ასე რომ, თუ ჩვენ აირჩიოთ ერთი, ის ყველაფერს გააკეთებს printf და შემდეგ შესვენება ისე, რომ არც
ეს არის შესრულებული.
და რა თქმა უნდა, თუ ისინი შევა სამი ან რაღაც, მაშინ გამოტოვოთ
იმ და არა იქ, და ეს განახორციელებს ნაცვლად
შესაბამისი ხაზი.
არსებობს რაიმე შეკითხვები, რომ?
დიახ?
>> დინამიკები 4: თუ თქვენ გაქვთ შეცდომა, თუ თქვენ ჰქონდა შესვენების შემდეგ შემთხვევაში, თუ ერთი, მაგრამ ეს
არ აქვს რაღაც რომ გავაკეთოთ?
>> JOSEPH: ასე რომ, კითხვა, რომ თქვენ მიიღებთ შეცდომა, თუ თქვენ გაქვთ შესვენების შემდეგ
შემთხვევაში ერთი მაგრამ არაფერი გავაკეთოთ?
და პასუხი არ არის.
თქვენ არ რეალურად მიიღონ შეცდომა.
ჰო, mm hmm.
>> ასე რომ, როგორც ერთგვარი პატარა ცვლილება აქ, მე ვაპირებ დააყენოს printf აქ.
Whoops.
მერე რა, რომ ამ ამობეჭდოთ თუ მე ზუსტად ერთი, როგორც შეყვანის?
ჰო.
ის რომ გითხრათ, ეს არ დიდი რაოდენობით ორჯერ, არა?
იმიტომ, რომ მოხვდა, რომ პირველ შემთხვევაში, ეს არ დაარღვიოს, და ეს იქნებოდა დაეცემა
გადის მეორე შემთხვევაში.
რაიმე შეკითხვები, რომ?
>> ROB: ჯერ თქვენ გაქვთ სხვა კითხვები?
>> JOSEPH: OK, გაგრილებას.
ყველა უფლება.
ასე რომ, არსებობს რაღაც ჩვენ მოვუწოდებთ ternary ოპერატორი, რომელიც ძირითადად
ალტერნატიული სინტაქსი აკეთებს იმ შემთხვევაში, თუ და მერე სხვა დანარჩენი.
და ის საშუალებას გაძლევთ ამის გაკეთება ყველა ერთ ხაზს.
ამიტომ ამ კონკრეტული პროგრამა, მე გეკითხებით მომხმარებელს n.
და თუ n მეტია 100, მე ვუთხრა ისინი აიყვანეს დიდი რაოდენობით.
სხვაგან მე გეტყვით მათ აიყვანეს დაბალი ნომერი.
>> ასე რომ ჩვენ შეგვიძლია გამოვიყენოთ ეს მართლაც ხანგრძლივი სინტაქსი, string, S, და შემდეგ შეამოწმეთ თუ N არის
აღემატება 100 და მივანიჭოთ ის შესაბამისად.
მაგრამ ჩვენ შეგვიძლია, რომ ეს ბევრად უფრო ლაკონურად გამოყენებით ამ ternary ოპერატორი სინტაქსი
რომელიც მოიცავს კითხვა მარკა და მსხვილი ნაწლავის.
ასე რომ, კითხვის ნიშნის არსებითად სვამს კითხვას, არა?
>> ROB: შესაძლოა მიუახლოვდით რომ.
>> JOSEPH: დიახ.
კარგი წერტილი.
ასე, რომ ეს არის ternary ოპერატორს.
მე პირველად კითხვა, არის n აღემატება 100?
თუ ეს არის, მაშინ შეასრულოს პირველი ნაწილი ადრე მსხვილი ნაწლავის.
თუ ეს არ არის, მაშინ მე შესრულდეს მეორე ნაწილი შემდეგ მსხვილი ნაწლავის.
ასე რომ, თუ n მეტია 100, მაშინ ეს მწვერვალებით მაღალი და აყენებს
რომ შევიდა string s.
თუ n ნაკლებია, ვიდრე 100, ის Picks დაბალი და შემდეგ აყენებს რომ შევიდა string s.
ისე, რომ condense დიდი ბლოკი ქვემოთ შევიდა, რომ მხოლოდ ერთი ხაზი.
>> დინამიკები 5: ის არის, რომ პოპულარული?
>> JOSEPH: დიახ, ეს საკმაოდ პოპულარული რამ, სადაც არსებითად გსურთ
არ დავალების საფუძველზე გარკვეული მდგომარეობაში.
და ამ შემთხვევაში, ჩვენ ვცდილობთ, დაავალოს ღირებულება string s.
ეს ასე არ არის -
ვფიქრობ, ნამდვილად არ ურჩევნია ეს სხვა შემთხვევებში.
მაგრამ ეს განსაკუთრებით სასარგებლოა ეს დავალება.
>> ROB: ეს არის საკმაოდ გავრცელებული ნიმუში სადაც თქვენ უნდა გარკვეული ცვლადი რომ
თქვენ აპირებს ვთქვა, თუ რამე, მითითებული ამ ცვლადის ერთ ღირებულება; სხვაგან, მითითებული
ამ ცვლადის სხვა ღირებულება.
და ეს არის სცენარი სადაც გამოიყენოთ ternary.
>> JOSEPH: და თქვენ გადარჩენა უამრავი ხაზი, უფლება?
და ეს მხოლოდ ხდის თქვენი კოდი, სავარაუდოდ, ცოტა მეტი იკითხება.
დიახ, კითხვის ნიშნის ქვეშ?
>> დინამიკები 6: იყიდება ternary, ვერ წახვალ, string s შეადგენს ნანახია, კითხვის ნიშნის?
და მაშინ შეიძლება, ვთქვათ, ხუთი სხვადასხვა პარამეტრები.
და დამოკიდებულია იმაზე, თუ რა რაოდენობის n იყო, რომ თქვენ ერთი იმ?
>> JOSEPH: ასე კითხვა, არსებობს სახის სინტაქსური სადაც შეგიძლიათ გააკეთოთ string
s უდრის n, და შემდეგ უფრო მეტი, ვიდრე ორი პარამეტრები შემდეგ, რომ კითხვის ნიშნის?
და მარტივი პასუხი არ არის, იქ არ არის მართლაც კარგი გზა უნდა გააკეთოს, რომ თუ
გსურთ ბუდე მრავალჯერადი ternary ოპერატორები შიგნით ერთმანეთს.
>> თქვენ შეიძლება არ მოსწონს n აღემატება 100, კითხვის ნიშნის, და შემდეგ სხვა
ternary ოპერატორი, n აღემატება 50, კითხვის ნიშნის, და ბუდე, რომ გზა.
მაგრამ ამ სცენარით, თქვენი კოდი არის მიღების სახის unreadable და ბინძურ,
და ეს შეიძლება იყოს უკეთესი უბრალოდ წასვლა იმ შემთხვევაში, თუ / Else განცხადება იმ ეტაპზე.
>> ROB: და ასევე, როგორც მინიშნება, PHP არასწორად ახორციელებს ternary
ოპერატორი ისეთი, რომ წყობილი ternaries კი არ მუშაობენ, როგორც მათ უნდა.
>> JOSEPH: ჰო.
ასე რომ იღებს ცოტა გაუგებარია, განსაკუთრებით მაშინ, როდესაც მიდიხარ
სხვადასხვა ენებზე.
>> ROB: ეს დამაბნეველი საკმარისი, რომ languages ​​არასწორია ამის შესახებ.
>> JOSEPH: ასე რომ, რეალურად, უბრალოდ გარკვევა, ამჯამად ყველას ვიცი რა, რომ
% S არ აქ?
რაიმე შეკითხვები, რომ?
ვფიქრობ, მხოლოდ კამერა,% s ძირითადად საშუალებას გვაძლევს დააყენა placeholder
სიმებიანი.
და მერე ბოლოს, ჩვენ დააკონკრეტა, რომ ცვლადი ჩვენ გვინდა ამოქმედებული ამ
ადგილზე მფლობელი s.
ასე რომ, ძირითადად იღებს s და ეს აყენებს მას აქ.
და მაშინ ამობეჭდოთ, თქვენ აიყვანეს მაღალი ან თქვენ აიყვანეს დაბალი ნომერი.
OK.
>> ასე მარყუჟების საშუალებას გაძლევთ შეასრულოს რამ in წრიული მოძრაობით, არა?
თქვენ შეიძლება არ შეექმნა ამ Scratch სახით Forever მარყუჟების
ან გაიმეორეთ სანამ ან გაიმეორეთ კონკრეტული რაოდენობის ჯერ.
რატომ არის ეს კარგი ჩვენთვის?
ასევე, C, ვთქვათ, ჩვენ ამ სიმღერა განხორციელებული Scratch, რომ
მღერის, ეს სიმღერა რომ არასოდეს მთავრდება.
უბრალოდ მიდის და და სამუდამოდ და სამუდამოდ.
ისე, თქვენ ნამდვილად ვერ მიიღოს პროგრამა რომელსაც აქვს უსასრულო რაოდენობის printf
განცხადებები იგი, არა?
>> ასე რომ, ამ კონკრეტულ სცენარი, ერთი გზა რომ თქვენ შეიძლება, რომ ეს მუშაობა და
რათა ის ბეჭდვა სამუდამოდ არის ნაცვლად გამოიყენოთ ხოლო loop.
ამიტომ მიუხედავად იმისა, რომ loop განახორციელებს, რა არის სხეულში ორი აფრთხილებს, რომ
ეკუთვნის რის საფუძველზე მდგომარეობა.
ასე რომ, ამ კონკრეტულ მაგალითად ადრე, თუ ჩვენ გვინდა ბეჭდვა სამუდამოდ, რა
შეიძლება გავაკეთოთ?
ისე, რა თქმა უნდა, არა?
>> ასე რომ, ეს სახის აერთიანებს იდეა ზოგიერთი ლოგიკური გამოხატვის
ერთად loop.
და ჩვენ შეიტყო ლოგიკური გამონათქვამები ადრე.
ასე რომ როდესაც პირობით შიგნით რომ მიუხედავად იმისა, რომ რჩება ჭეშმარიტი, ამ loop
განახორციელებს და და.
და ამ შემთხვევაში, თუ ჩვენ მხოლოდ მიაწოდოს მას ჭეშმარიტი, ეს იწვევს უსასრულო
loop რომელიც ბეჭდავს სიმღერა და და როგორც ჩვენ სასურველ ადრე გარეშე
მქონე პროგრამა, რომელიც უსასრულო ნომერი printf განცხადებები, რომლებიც არ არის
არ არის შესაძლებელი.
>> ასე უფრო compellingly, თუმცა, თქვენ შეგიძლიათ გამოიყენოთ ეს ერთად
ცვლადი და მდგომარეობა.
ასე ვთქვათ ჩვენ გვინდა გავიმეოროთ ფრაზა, სრულიად loopy, 10 ჯერ.
ასე რომ, რა შეგიძლიათ გააკეთოთ, ხოლო loop არის შეგიძლიათ პირველი ინიციალიზაცია counter
ცვლადი გარეთ ხოლო loop 10.
და შემდეგ, პრაქტიკულად, ყოველ დროს, თქვენ წავიდეთ მეშვეობით ხოლო მარყუჟის, თქვენ ამობეჭდოთ
განცხადებას და მაშინ შემცირება counter ცვლადი, სანამ დასასრულს,
რაღაც მომენტში, კიდევ ერთხელ გამოვაკლებთ მე საკმარისი ჯერ, 1 I საკმარისი - ჯერ
და მხოლოდ განმარტავს, მე მინუს მინუს იმას ნიშნავს, მე უდრის მე მინუს 1.
>> ეს ძირითადად მოუტანს I ქვემოთ წერტილში, სადაც კიდევ ერთხელ მე მოხვდა ნულოვანი, ამ
მდგომარეობა აღარ არის ჭეშმარიტი და ასე რომ ითიშება გარეთ loop.
ასე რომ, სრულიად loopy მხოლოდ ბეჭდავს 10 ჯერ.
რაიმე შეკითხვები, ხოლო loop?
OK.
>> ასე რომ, არსებობს გზა, ჩვენ შეგვიძლია გავაკეთოთ ის, რაც ჩვენ უბრალოდ გააკეთა უფრო ლაკონურ წესით
რაც ჩვენ მოვუწოდებთ იყიდება loop.
ასე რომ მარყუჟი შედგება ინიციალიზაციისას, მდგომარეობა და
განახლება, ისევე, როგორც ჩვენ გვქონდა ადრე ამ ხოლო loop.
მოდით შევხედოთ.
ამ ხოლო მარყუჟის, ჩვენ გვქონდა ინიციალიზაცია, მაშინ ჩვენ გვქონდა
პირობით, რომ ჩვენ შემოწმდება.
და მაშინ ჩვენ გვქონდა განახლება ნაბიჯი ზედა.
>> ერთად მარყუჟის, ეს ძირითადად იღებს ეს სამი რამ და კონდენსირდება იგი
ქვემოთ ერთ ხაზი.
ასე რომ, პირველი, რაც ამას ადგილი აქვს მარყუჟის არის ინიციალიზაცია.
და მაშინ გავაკეთებთ, მძიმით, და შემდეგ თქვენ აკეთებთ მდგომარეობა, რომელიც მე
მეტი ნულოვანი მიდის იქ, და შემდეგ update ნაბიჯი.
ასე რომ, ეს იღებს შესრულდა ბოლომდე loop ორგანო.
ასე რომ, ეს ორი პროგრამა არსებითად ექვივალენტი.
>> რაიმე შეკითხვა?
რა არის ერთი განსხვავება ამ ორ?
შეიძლება ვინმეს აღვნიშნო ის?
ეს შეიძლება იყოს bit დახვეწილი.
ეს მხოლოდ ძალიან მცირე განსხვავება.
დიახ?
>> დინამიკები 5: თქვენ ვერ შეძლებს გამოიყენოს მე ცვლადი გარეთ მარყუჟის
[INAUDIBLE]?
>> JOSEPH: ზუსტად.
ასე რომ, ეს არის ის, რაც ჩვენ კიდევ მოგვიანებით მოუწოდა ცვლადი ფარგლებს.
მაგრამ არსებითად, ამ int i ცხოვრება გარეთ ამ ხოლო loop.
ასე რომ ერთხელ ეს მიუხედავად იმისა, რომ მარყუჟი კეთდება შესრულებაში, მე შეძლებთ გამოიყენოთ მოგვიანებით
ამ პროგრამაში.
>> ვინაიდან ამ მარყუჟის, ეს int I არის scoped შიგნით ამ loop.
და რადგან ეს არის შიგნით ამ ნაწილის ამისთვის loop, რომელიც იწყება
at ფრჩხილებში და მთავრდება Curly გაუწიოს იქ.
არაფერი რომ განაცხადა შიგნით აქ არ შეიძლება გამოყენებულ გარეთ.
ასე თუ ცდილობენ გამოიყენონ I გარეთ, იგი ყველაფერს მითხრათ, გამოუცხადებელ სიმბოლო.
და არსებითად, მე არ შეძლებს გამოიყენოს იგი.
>> ROB: და ასევე, 10 წლის წინ, ფაქტიურად ყველა შემთხვევაში, curly აფრთხილებს არიან
რა თქვენ გამოყენებული, რათა დადგინდეს ფარგლებში ცვლადი.
ასე რომ, იქ, int i შეადგენს 10 ცხადდება შიგნით ამ
მითითებული curly აფრთხილებს.
და ასე შემდეგ, რადგან თქვენ ცდილობენ გამოიყენონ I ადრე Curly გაუწიოს, ეს ჯარიმა.
თქვენ ალბათ ხედავთ, როდესაც თქვენ აკრიფოთ მიიღოს, თქვენ იხილეთ dash, ტირე, std, ტოლობის, c99.
>> ასე რომ, მოგვიანებით მობილური C რომ GCC განახორციელა, რომელიც ასევე აძლევს
ეს კომბინაცია.
ასე რომ, ეს გამოყენებული არ დაიშვება in C. და ხედავთ, რატომ, იმიტომ, რომ ეს int
მე გარეთ ამ Curly გაუწიოს, მაგრამ ის ჯერ კიდევ ითვლება
ფარგლებში ამ curly აფრთხილებს.
მაგრამ ეს არის ძალიან მოსახერხებელი რამ, და ამიტომ არის კარგი გაფართოება.
>> JOSEPH: ნებისმიერი კითხვები?
OK.
რა არის უფრო სასარგებლო არის, რომ ზოგჯერ გსურთ სახის დინამიზმის
თქვენი მარყუჟის, არა?
თქვენ არ მინდა უბრალოდ აუცილებლად ბეჭდვა სრულიად loopy ყველა დროის, თქვენ
გსურთ ითვლიან ქვემოთ 10 ან რამე.
და ასე რომ თქვენ შეგიძლიათ გამოიყენოთ counter ცვლადი შიგნით რომ loop ისევე.
და ამ შემთხვევაში, ეს პროგრამა უბრალოდ ითვლის ქვემოთ 10 ყველა გზა down.
და რას არ ბეჭდვა?
ეს არ ბეჭდვა ნულოვანი, უფლება, რადგან, როდესაც -
დიახ, ეს ასევე არ ბეჭდვა 11.
>> ასე რომ არ ბეჭდვა zero, რადგან, როდესაც I არის ნულოვანი, გახსოვდეთ, იგი აფასებს
იმ პირობით, სანამ იგი მიდის შეასრულოს loop ორგანო.
და როცა არის ნულოვანი, ეს არის ყალბი, ასე რომ, იგი არ ამობეჭდოთ დათვლის ქვემოთ
zero, უბრალოდ ბეჭდავს out დათვლა ქვემოთ 10 ყველა გზა ქვემოთ 1.
თუ ჩვენ რეალურად უნდოდა ბეჭდვა ნულოვანი, მაშინ ჩვენ დააყენა თანაბარი ნიშანი
მას შემდეგ, რაც ამ მეტია ნიშანი.
OK.
>> ასე რომ ერთი გზა ამის შეყვანის ძალადაკარგულია, რომელიც როდესაც თქვენ ეკითხებით შესახებ უნდა გააკეთოს
რაღაც, თქვენ გვინდა დავრწმუნდეთ, რომ ისინი დაიცვას თქვენი ინსტრუქციები, გამოყენება
მიუხედავად იმისა, მარყუჟის, არა?
ასე რომ, ამ შემთხვევაში, მე გეკითხებით დადებითი ნომერი და მაშინ მე
ელოდება შეყვანის.
>> და შემდეგ მე შევამოწმე მიუხედავად იმისა, რომ შეყვანის არის ნაკლებია, ვიდრე ნულოვანი, შეინახოს ეკითხება მათ.
ასე რომ, რადგან ისინი მომეცი ნომერი რომ არ არის დადებითი, შეინახოს ეკითხება,
შეინახოს ეკითხება, შეინახოს ითხოვს.
მაგრამ რა არის ერთგვარი უცნაური ამის შესახებ?
ან რა არ ჩანს, ოპტიმალური შესახებ ამ სტრუქტურის უფლება აქ?
ვინმეს?
დიახ?
>> დინამიკები 6: თქვენ იმეორებს ინსტრუქცია ორჯერ.
>> JOSEPH უფლება.
ამიტომ ჩვენ გვაქვს ორი printf განცხადებები აქ, არა?
ასე რომ, არსებობს გზა, ჩვენ ვერ ეს მხოლოდ ქვემოთ ერთი, რომ ეს ჩვენი
კოდი ადვილი წასაკითხი და ცოტა უფრო სუფთა.
და მაშინ ჩვენ არ უნდა არ მიიღეთ ორჯერ კარგად.
და ერთი გზა ამისათვის არის გამოყენებით do-ხოლო loop.
>> და do-ხოლო loop ძირითადად სხვადასხვა ფორმის მიუხედავად იმისა loop სადაც
რაც ფარგლებში curly აფრთხილებს იღებს შესრულებული ერთხელ მაინც.
ასე რომ, აქ, მე ვაცხადებ, int input გარეთ პირველი.
და მერე უბრალოდ, ვამბობთ, ამისათვის ინსტრუქცია ხოლო input
ნაკლებია, ვიდრე ნულოვანი.
ასე რომ, ეს ჰიტები Do პირველი.
ის ყოველთვის შეასრულოს ეს მინიმუმ ერთხელ, ასე რომ ყოველთვის ვთხოვ შესახებ
შეყვანის ერთხელ მაინც.
და მაშინ იგი აფასებს, რომ input, და ეს გრძელდება წრეში.
დიახ, კითხვის ნიშნის ქვეშ?
>> დინამიკები 6: არის გზა ამის გაკეთება [INAUDIBLE] ტიპის, მოსწონს თუ თქვენ ამბობთ,
GetString, და ვინმე [INAUDIBLE]
არის გზა [INAUDIBLE]
>> JOSEPH ასე რომ კითხვაზე, არსებობს გზა ამის შეყვანის ძალადაკარგულია თუ მომხმარებელი
არ დასვა უფლება ტიპის ცვლადი?
ასე რომ, თუ ჩვენ ვთხოვთ int და ისინი მოგვცეს string ნაცვლად.
და ფუნქციები, რომ ჩვენ განხორციელება თქვენ, GetInt, GetString ყველა
იმ ფუნქციებს, ისინი რეალურად უკვე გავაკეთოთ, რომ სახის ძირითადი ტიპის input
ძალადაკარგულია ქვეშ hood.
ასე რომ, თუ თქვენ იყენებთ ფუნქციებს, რომ ჩვენ მისცა, თქვენ ნამდვილად არ უნდა.
>> მაგრამ თუ გსურთ უფრო, თუ როგორ თქვენ შეგიძლიათ რეალურად გავაკეთოთ, რომ თქვენ შეგიძლიათ შეხედოთ
ქვეშ hood at ფაილი I/O--
არ შეიტანოს, სტანდარტული I / O ფუნქციები მოსწონს კითხულობს სტანდარტული input და
სტანდარტული გამომავალი.
და შეგიძლიათ მიიღოთ უკეთესი გრძნობა თუ როგორ შეიძლება ამის გაკეთება.
>> ROB: ერთი საკითხი, თუმცა, კონკრეტულად ერთად მაგალითად
განაცხადა, თქვენ ველით string და მე შევა int.
როგორ გითხრათ განსხვავებაა შორის განზრახ სურვილს
string 123 წინააღმდეგ სურვილს int 123?
ასე რომ, string, ის საკმაოდ ბევრი არ არსებობს დადასტურება, უბრალოდ, რასაც
შევიდა თქვენ ინტერპრეტაცია როგორც სიმებიანი.
>> Int უფრო ადვილია, იმიტომ, რომ არა აქვს მნიშვნელობა input თქვენ მიიღოს მომხმარებელს, თქვენ
ყოველთვის აღების სიმებიანი.
და ისე, რომ string შეგიძლიათ შემდეგ შეამოწმეთ, ყველა ამ
რეალურად რიცხვითი ციფრისგან?
>> JOSEPH: OK.
რაიმე შეკითხვები do-ხოლო loop?
>> ROB: Oh, და ეს არის -
ბრუნდება ფარგლებს, გარკვეულწილად საერთო შეცდომა ცდილობს გამოიყენოს ზოგიერთი ადგილობრივი
ცვლადი ამ Do-მიუხედავად იმისა, loop შიგნით ამ მდგომარეობაში.
და რეალურად, თუ ჩვენ უბრალოდ მოიშორეს და განაცხადა, int შეყვანის უდრის
GetInt, მაშინ კომპილატორი დაწეროთ ჩვენთვის, რადგან input არ არსებობს
საზღვარგარეთის ფარგლებში ამ curly აფრთხილებს.
>> JOSEPH: და ამიტომ საჭიროა ამ შემადგენლობით აქ.
OK.
ასე, რომ თქვენ, აგრეთვე, შეგიძლიათ შესვენება გარეთ loop დასაწყისში თუ გსურთ.
ასე რომ, ეს არის განსხვავებულ გზას ახორციელებს რა ჩვენ უბრალოდ განხორციელდა.
ნაცვლად გამოყენებით მდგომარეობაში ფარგლებში ფრჩხილებში, ჩვენ გამოყენებით
იმ შემთხვევაში, თუ განაცხადი შიგნით ორგანო საქართველოს do-ხოლო loop.
>> და ძირითადად, როდესაც input საბოლოოდ მეტი ნულოვანი, ჩვენ
შესვენება გარეთ loop.
და ასე წავალთ ყველა გზა ქვემოთ აქ.
და თქვენ ხედავთ, რომ ეს ალბათ უნდოდა ამ
სცენარი, იმიტომ, რომ ეს პატარა ცოტა სუფთა და პატარა
ცოტა ადვილი წასაკითხი.
ვინაიდან, თქვენ ერთგვარი აქვს ზედმეტი ხაზების იგი.
უბრალოდ ცოტა uglier, ვფიქრობ, ამ თვალსაზრისით.
დიახ, კითხვის ნიშნის ქვეშ?
>> დინამიკები 4: იქნება შესვენება მხოლოდ თქვენ გარეთ ერთი კომპლექტი აფრთხილებს?
>> JOSEPH უფლება.
ასე რომ, საკითხი იქნება შესვენება მხოლოდ თქვენ out ერთი loop?
და პასუხი არის დიახ.
ასე რომ, თუ თქვენ არ წყობილი ამისთვის მარყუჟების, ამისთვის მაგალითად, თუ მაქვს int მე უდრის 0
სანამ 10 და შემდეგ int J უდრის 0 სანამ 10, მე შესვენება out შიდა
loop, მე მაინც წავიდეთ გარე loop.
ასე რომ, გავაგრძელებთ ასრულებენ ოპერაციების გარეთ.
რაიმე შეკითხვები, რომ?
დიახ?
>> დინამიკები 5: მაგრამ შესვენება მხოლოდ ფუნქციები განთავსების curly აფრთხილებს, არა სხვა
განცხადებები?
[INAUDIBLE]
>> JOSEPH ასე რომ საკითხი იქნება შესვენება ერთადერთი ფუნქცია მარყუჟების როგორც ეწინააღმდეგებოდა
სხვა განცხადებების მსგავსად თუ?
და დიახ, ეს ასეა, იმიტომ, რომ თქვენ არღვევს out of მარყუჟის, უფლება,
გრძნობა.
>> ROB: In უმრავლეს შემთხვევაში, ეს ეს არის ერთგვარი თუ რამე,
მაშინ შესვენება.
ასე რომ თქვენ არ უნდა დაარღვიოს მიმართოს თუ ეს არის შესაფუთი გარშემო.
ასევე, ეს არ არის დიდი მარყუჟის, მაგრამ გახსოვდეთ, რომ კონცენტრატორები ასევე
გატეხილი მიერ შესვენებები.
ჩვენ ვნახეთ შეღავათები გამოიყენება ერთად კონცენტრატორები ადრე.
>> JOSEPH: თქვენ ასევე შეგიძლიათ მათ ხოლო მარყუჟების და მარყუჟების.
რაიმე შეკითხვა?
OK.
ასე რომ, შემდეგი up არის ფუნქციები.
ასე რომ თქვენ შეიძლება არ გამოიყენება ერთი ამ BYOB ბლოკები თქვენი Scratch პროექტი.
და ეს ძირითადად საშუალებას თქვენ უნდა განსაზღვროს კომპლექტი
ინსტრუქციები მოჰყვება.
>> და რას ვგულისხმობ მიერ რომ არის მოდით ვიფიქროთ თავში მათემატიკის, უფლება, ალგებრა.
თქვენ უნდა რაც ჩვენ მოვუწოდებთ ფუნქცია x, რამდენიმე ცვლადი და ვთქვათ ამ
ფუნქცია f of x უდრის x პლუს 5.
ასე რომ, შეგიძლიათ წარმოიდგინოთ ვ x, რადგან ეს შავი ყუთი რომ იღებს 15 და შემდეგ
აწარმოებს 20.
>> ასე რომ, ზოგადად, ფუნქცია ის, რასაც სჭირდება გარკვეული მასალები და
მაშინ აწარმოებს გარკვეული შედეგები.
და რატომ არიან ფუნქციების კარგი?
ისინი კარგი რიგი მიზეზების გამო.
ასე რომ ვინმეს სურს მიიღოს stab რა ორგანიზაცია ნიშნავს?
თვალსაზრისით რატომ ფუნქციები გამოსადეგი?
დიახ?
>> დინამიკები 4: რაც თქვენი კოდი უფრო იკითხება.
>> JOSEPH უფლება.
ასე რომ, ერთი რამ არის ის, რაც თქვენი კოდი უფრო იკითხება, არა?
იმის მაგივრად, როგორიცაა int x უდრის x ჯერ x ჯერ x, შემიძლია აქვს კუბი x,
რაც უფრო გასაგები და მეტი გასაგები მკითხველს.
>> ორგანიზაცია ასევე თვალსაზრისით გაყოფის up თქვენი კოდი შევიდა მართვადი
ნაწილი, ასე რომ ნაცვლად ცდილობს განხორციელების ყველა ერთ მონაკვეთზე
მთავარ, შეგიძლიათ სახის გაყოფილი it up თარგმნეს მოსწონს, OK, მოდით დავწეროთ ფუნქცია
to Cube რაღაც, მოდით დავწეროთ ფუნქციონირებს მოედანზე რაღაც.
ამ გზით თქვენ შეგიძლიათ გაყოფილი ეს დაყოფილია პატარა, პატარა ნაწილები, რომ თქვენ შეგიძლიათ დაძლევის
როგორც ეწინააღმდეგებოდა ცდილობს გაუმკლავდეს დიდი პრობლემა ერთდროულად.
>> ROB: ან თუნდაც პატარა, პატარა ნაწილები, თქვენ და პარტნიორი შეიძლება დაძლევის.
>> JOSEPH: ჰო.
>> ROB: ასე რომ ნაცვლად ორივე თქვენ ცდილობთ იმპლანტის ერთი
ფუნქციონირებს ამავე დროს.
>> JOSEPH: გამარტივება.
არავის სურს მიიღოს ვხვდები?
დიახ?
>> დინამიკები 5: More განმეორება.
>> JOSEPH უფლება.
ასე რომ, ერთი რამ, რომ შეგიძლიათ გააკეთოთ გამარტივება არის ის, რომ ეს ერთგვარი on
იგივე ხაზები როგორც ხელახლა გამოყენებადობა არის, რომ ერთხელ ვწერ კუბი ფუნქცია, შემიძლია
უბრალოდ გამოიყენოთ, რომ მეტი და მეტი ისევ ჩემი პროგრამა ნაცვლად აკრეფით
x ჯერ x ჯერ x მეტი და უსასრულოდ.
და გამარტივებას აქ ასევე მხოლოდ იმას ნიშნავს, რომ რაც თქვენი კოდი სახის
ადვილია გამართვის ერთხელ თქვენ გაყოფილი ამ დაყოფილია ფუნქციები.
რადგან მაშინ შეგიძლიათ ლოკალიზება, სადაც თქვენი პრობლემები ერთგვარი არიან.
რაიმე შეკითხვა?
>> ასე რომ, კიდევ ერთი იდეა არის აბსტრაქცია, არა?
ეს შავი ყუთი.
Like იცით რა GetInt აკეთებს მიიღოს შეიტანენ მომხმარებელი?
ჩვენ ნამდვილად არ გითხარით, არა?
ყველა ჩვენ გითხარით არის GetInt აკეთებს ზუსტად რა წერია ეს ასეა.
ისე კი, თუ ჩვენ არ გეტყვით, რამდენად მუშაობს, თქვენ მაინც იცით.
>> ასე რომ, ამ შემთხვევაში, ეს არის quadruple ფუნქცია, რომელიც აკეთებს
სხვადასხვა რამ შეყვანის წარმოების გამომავალი.
და თქვენ შეგიძლიათ quadruple ნომერი გამრავლებით იგი ოთხ.
ან თქვენ შეგიძლიათ, რაც ჩვენ მოვუწოდებთ ცოტა გადაიტანოს ეს ორი.
და ჩვენ დაფარავს ამ ცოტა მოგვიანებით.
და არ უნდა იცოდეს, თუ როგორ ეს ფუნქცია რეალურად მუშაობს, რადგან ეს
მუშაობს როგორც განაცხადა.
>> ასე რომ, ქვეშ Hood, მე შეიძლება იყოს როგორიცაა, დაბრუნდნენ შეყვანის ჯერ
რვა იყოფა ორ.
და თქვენ არ იცით, არა?
ყველა თქვენ უნდა იცოდეთ არის ეს იმას თუ რას ამბობს.
ასე რომ სასარგებლო რამ შესახებ აბსტრაქცია.
>> და კიდევ ერთი რამ არის ერთგვარი ამ იდეის საქართველოს ლოკალიზებას თქვენი კოდი ერთ
კერძოდ მონაკვეთზე.
ასე რომ, თუ თქვენ გაქვთ პრობლემა, თქვენ არ უნდა წავიდეს მთელი თქვენი კოდი ცდილობს
დაფიქსირება, სადაც პრობლემა იყო.
ასე რომ, ამ შემთხვევაში, მე განხორციელდა Cube არასწორია.
მეგონა კუბი იყო გამრავლებით სამი.
>> ასე რომ, ამ შემთხვევაში, ეს არის ერთი პროგრამა რომ უბრალოდ არ გამრავლებით სამი
ყველგან.
და არის კიდევ ერთი პროგრამა, რომელიც factored cube შევიდა ფუნქცია.
და ახლა თუ მინდა დაფიქსირება ჩემი შეცდომა აქ, მე უნდა დააფიქსიროს თითოეული ხაზი
კოდი ამ პროგრამაში.
ხოლო მეორეს მხრივ, თუ გამოვიყენო ფუნქცია, მე მხოლოდ უნდა შეიცვალოს
რა იყო არასწორი ერთ ადგილას.
>> ასე რომ, კომპიუტერულ მეცნიერებაში, ჩვენ დარეკეთ საშუალებებით და შედეგები.
პორტები უწოდებენ პარამეტრების ან არგუმენტები, და შედეგები უწოდებენ
დაბრუნების ღირებულებებს.
და ვნახავთ, თუ როგორ ეს გვეხმარება სახის საქართველოს განსაზღვრავს ფუნქცია მეორე.
ასე რომ, ეს არის ფუნქცია განმარტება განთავსების cubing.
ასე რომ, ეს იღებს შეყვანის და შემდეგ ის დააბრუნებს, რომ ნომერი ჯერ
თავად სამჯერ.
მოდით დაარღვიოს ეს ქვემოთ.
>> ამიტომ ჩვენ გვაქვს ფუნქცია header, რომელიც ძირითადად შედგება სამი რამ.
ასე რომ, ჩვენ პარამეტრების, რომელიც არიან, როგორც ვთქვი,
საშუალებებით ამ ფუნქციას.
და მაშინ ჩვენ მისცეს ფუნქციის სახელი.
ამ შემთხვევაში, ეს ე.წ. კუბი.
და მაშინ ჩვენ დააკონკრეტა, თუ რა ტიპის დაბრუნების ღირებულება.
>> ასე რომ, ამ შემთხვევაში, ჩემი კუბი ფუნქცია იღებს რიცხვი და ასევე
ბრუნდება რიცხვი.
ასე რომ, თუ მე გაივლის ორ, ორი რიცხვი, ის დააბრუნებს რვა ჩემთვის, რომელიც
არის მთელი რიცხვი.
ასე რომ, დაბრუნების ტიპის სახელწოდება პარამეტრები.
კითხვები რომ?
>> და შემდეგ დაბრუნების ღირებულება ფაქტიურად მითითებული დასასრულს განაცხადა დაბრუნება
და შემდეგ დაბრუნების რასაც შეიცავს დაბრუნების ღირებულება.
ასე რომ, ამ შემთხვევაში, თუ ჩვენ ეს ყველაფერი ერთად, ფუნქცია იღებს
პარამეტრების, ეს ე.წ. რაღაც, და ის დააბრუნებს, რომ რაღაც ტიპის
რომ ჩვენ ვამბობთ, ის იქნება.
რაიმე შეკითხვა?
>> ასე როგორ უნდა გამოიყენოთ ფუნქცია?
ისე, ჩვენ წერენ ფუნქცია და შემდეგ ჩვენ ვიყენებთ მას ჩვენი პროგრამა, არა?
ასე რომ, მე მას კუბი, და მაშინ შემიძლია კუბი.
>> მაგრამ რა უნდა აღინიშნოს, ის არის, რომ იმისათვის საკითხებზე.
თუ მაქვს cube ქვემოთ ძირითადი, ეს აპირებს გადაეყარონ კუბი.
და ამ ეტაპზე, არაფერი მოუწოდა კუბი პროგრამაში, და ეს
უბრალოდ იქნება, როგორიც, მაქვს არ ვიცი, რა კუბი არის.
>> ასე რომ გეტყვით, დაფარული დეკლარაცია ფუნქცია.
ეს არის ის შეცდომა, რომელიც აჩვენებს მდე.
და ა.შ. ამ შემთხვევაში, კუბი არის ქვემოთ მთავარი, ასე რომ ის არ აპირებს
უნდა იცოდეს ამის შესახებ.
>> დინამიკები 5: So მთავარი ჩვეულებრივ უკანასკნელი ფუნქცია განსაზღვრული?
>> JOSEPH: ასე რომ, კითხვა, ძირითადი წესი ბოლო
რამ, რომ ნეტავ განსაზღვროს?
და არა.
ეს იმიტომ, რომ ჩვენ, როგორც წესი, მოსწონთ მთავარი უნდა იყოს ზედა, არა?
იმიტომ, რომ პირველი, რაც თქვენ მინდა პროგრამისტი გახსნის
პროგრამა ვხედავ.
და ა.შ. როგორ უნდა გადაწყვიტოს ეს საკითხი ჩვენ მინდა ძირითად იყოს ზედა, მაგრამ
ფუნქციებს, რომ ჩვენ გვინდა, ჩვენ გვინდა, ქვემოთ მთავარ ამჟამად შეძლებთ გამოიყენოთ
მათ შიგნით ძირითადი?
>> ასევე, ვიყენებთ, რაც ჩვენ მოვუწოდებთ ფუნქციის პროტოტიპი.
ასე რომ, რა ფუნქცია პროტოტიპი არსებითად არის იგი პირველი იღებს რა
ხელმოწერის ან ფუნქცია header რა გვინდა განხორციელება ქვემოთ
აქ, და ჩვენ მას ზედა პროგრამა.
>> ასე რომ, ამ შემთხვევაში, ჩვენ ვამბობთ, რომ, ასევე, მოგვიანებით ჩვენი პროგრამა, ჩვენ ვაპირებთ
რათა დაპირებას შევასრულებთ ფუნქცია მოუწოდა int cube, რომელიც იღებს
მთელი შეყვანა.
ახლა, რადგან ეს არის ზემოთ ძირითადი, მთავარი, ის აპირებს ვთქვა, oh, ასევე,
მოგვიანებით, პროგრამა, რომელიც იქნება ასე შემიძლია ეხება, ასე რომ მე გამოგიგზავნით
უბრალოდ ასეც გადის ახლა.
>> და შემდეგ ბოლოში, ჩვენ განხორციელება კუბი.
და მერე მთავარი იქნება უბრალოდ, ვამბობთ, ასევე, ეს იქნება დასალაგებლად of ლინკი
ეს ორი სიმბოლო ერთად.
და ჩვენ დაფარავს რა, რომ ნიშნავს მოგვიანებით.
და ასე რომ თქვენ იცით, რომ ეს არის კუბი ფუნქცია რომ უნდა გამოიყენოთ.
>> ROB: [INAUDIBLE] დაახლოებით სურვილს მთავარი ბოლოში ან
თავზე, მე ვნახე ორივე.
არსებობს რამ, რომ უბრალოდ მინდა დააყენოს ძირითად ბოლოში.
მაგრამ ერთხელ პროექტის იღებს განსაკუთრებით დიდი, როგორც წესი, მთავარი არის
წარადგინოს ყველა საკუთარი.
და იმ ეტაპზე, ისევე როგორც int cube ხაზი -
შიგნით stdio.h არის bunch ხაზები ისევე, რომ int
cube int input ონლაინ.
>> და ისე იმ პროტოტიპები რამ ტენდენცია შევიდა header ფაილი at
სადაც წერტილი, მნიშვნელობა არ აქვს.
ისე, ეს არ აქვს.
იმ ყოველთვის ზედა.
და თუ მთავარი არ არის ფაილი ყველა საკუთარი, თქვენ არ უნდა ფიქრი აყენებს
ინდივიდუალური ფუნქცია პროტოტიპები ფაილი.
>> JOSEPH: და ჩვენ კიდევ, რომ პატარა ცოტა მოგვიანებით, როცა Rob იწყებს საუბარს
დაახლოებით შედგენა.
და ა.შ. არსებობს ასევე სხვაობა შორის პარამეტრი და არგუმენტი.
და პარამეტრი არის მხოლოდ ის, რაც ჩვენ მოვუწოდებთ ამ საშუალებებით როდესაც
ჩვენ განვსაზღვროთ ფუნქცია.
და მოვუწოდებთ ეს არგუმენტი, როდესაც ჩვენ რეალურად გაივლის ის ფუნქცია.
>> ასე რომ, ამ შემთხვევაში, ეს არის პარამეტრი, როგორც ჩვენ განაცხადა ადრე.
და როდესაც ჩვენ რეალურად გამოვიყენოთ იქ, კუბი x, მაშინ x თავისთავად
რაც ჩვენ მოვუწოდებთ არგუმენტი ფუნქცია cube.
>> ROB: So პარამეტრი არგუმენტაცია -
არსებობს ეს განსხვავება, ძალიან დაბნეული interchangeably.
ამ ეტაპზე, ჩემთვის, ის, როგორც ერთი ეს სიტყვები, რომ როდესაც მე ვხედავ მას გარეთ
ველური, მე ვერ დაეხმარება, მაგრამ მაშინვე თუ არა ისინი იყენებენ მას
სწორი კონტექსტში, რადგან განსხვავება არის დახვეწილი საკმარისი, რომ უბრალოდ
ყველას აპირებს -
მე თითქმის ყოველთვის ვამბობ არგუმენტი მიუხედავად იმისა, რას ვგულისხმობ.
>> JOSEPH: და ფუნქციები ასევე სასარგებლო რა ჩვენ მოვუწოდებთ გვერდითი მოვლენები.
ასე რომ, ფუნქცია, შეუძლია არ საშუალებებით და მას ასევე შეუძლია აწარმოოს არა შედეგები.
ასე რომ, ამ შემთხვევაში, მე ვარ განსაზღვრის subroutine რომ არ აქვს
დაბრუნების ღირებულება.
და იმისათვის, რომ მიუთითოს, რომ, ჩვენ ვიყენებთ რაც ჩვენ მოვუწოდებთ ბათილად აქ.
ასე რომ გვერდითი ეფექტი ამ ფუნქციის არის ის, რომ უბრალოდ ბეჭდავს პერსონალი
out გვერდზე.
ეს ფაქტობრივად არ მიიღოს ნებისმიერი პორტები, და არ
რეალურად აწარმოოს ნებისმიერი მასალები.
>> მაგრამ ეს შეიძლება იყოს სასარგებლო იმ გაგებით, თუ გსურთ, მაგალითად, debug
რაღაც თქვენს პროგრამაში, თუ გსურთ წერენ პატარა subroutine რომ
ბეჭდავს out, ვთქვათ, შინაარსი მეხსიერების ან რამე.
და ა.შ. ეს გვერდითი მოვლენები ზოგჯერ სასარგებლო გარეთ კონტექსტში
უბრალოდ მინდა საშუალებებით და შედეგები.
რაიმე შეკითხვა?
>> და ბოლოში ამ კონკრეტულ სეგმენტში, რას პროგრამა გავაკეთოთ?
მე მივცემ თქვენ ბიჭები რამდენიმე წამში წაკითხვის საშუალება.
ძალიან საბაზისო დონეზე, რაც ჩვენ გვსურს ამბობენ, არის ის, რომ სვოპების x და y, არა?
>> ასე რომ, რამდენი თქვენგანი რეალურად ვფიქრობ ეს იქნება სვოპ x და y?
ამაღლება თქვენი მხრივ.
არავინ.
OK.
ვინც ფიქრობს, რომ ეს არ სვოპ x და y?
და თანხა რომ იყო არა მთელი ოთახი.
ასე რომ, ზოგიერთი ადამიანი არ ვარ დარწმუნებული.
OK.
ეს არის ის გონივრული.
>> მოდით გავლა რა ხდება, როდესაც თქვენ სინამდვილეში ფუნქციების პირველი
იმისათვის, რომ ამ კითხვაზე პასუხი.
ასე რომ, ეს არის ის, რაც მეხსიერების სახის ჰგავს.
ეს არის ერთგვარი მოსწონს გამარტივებული მოდელი რა მეხსიერების ჰგავს, როდესაც
თქვენ აწარმოებს პროგრამა.
ასე რომ არსებობს რაღაც მოუწოდა დასტის ქვემოთ აქ და
რაღაც მოუწოდა ბევრი.
და ეს იზრდება მიმართ შუა მეხსიერება.
>> ასე რომ, ამ კონკრეტულ შემთხვევაში, როდესაც რეკავთ ფუნქცია, მას
იღებს ჩაიცვი დასტის.
და მაშინ რასაც შეიცავს, რომ ფუნქცია რჩება, რაც ჩვენ მოვუწოდებთ, რომ
ფუნქციის დასტის ჩარჩო.
და ასე მიიღოს ლამაზი ვიზუალიზაცია ამ let's - მაგალითად, ჩვენ გვქონდა
პროგრამის ძირითადი ადრე.
და შიგნით ძირითადი, ჩვენ მოუწოდა კუბი.
ასე რომ, მთავარი, პირველ წასვლა დასტის ვიზრუნოთ, რადგან ეს პირველი ფუნქცია
რომ უწოდებენ.
>> და მაშინ, როდესაც cube ეწოდება შიგნით მთავარი, იგი იღებს დააყენა თავზე მთავარი
შიგნით მეხსიერება.
ასე რომ, რაც თქვენ შეამჩნევთ აქ ის არის, რომ კუბი აქვს საკუთარი პარამეტრები და მისი
საკუთარი ადგილობრივები.
ასე რომ, როდესაც თქვენ რეალურად გაივლის რაღაც ფუნქცია, პარამეტრების, რომ ეს
იღებს ასლები, თუ რა იყო გავიდა მთავარი.
>> და სახის ახსნას ამ, მოდით გავლა პროგრამა.
ამიტომ, ჩვენ უნდა დასტის, ეს არის მხოლოდ დასტის ნაწილი.
და რას ვაკეთებთ არის ჩვენ პირველი ინიციალიზაცია x და y ერთი და ორი.
ასე რომ, ჩვენ ამ პატარა ყუთები.
ისინი სხედან მთავარ მიერ დასტის ვიზრუნოთ Stack.
ისინი შეიცავენ ერთი და ორი.
>> ახლა ჩვენ მოვუწოდებთ swap.
რა ხდება ჩვენ გაივლის x და y შევიდა swap, და swap ქმნის საკუთარი ასლები
იმ ცვლადების გამოყენება შიგნით მისი დასტის ჩარჩო.
ახლა იქ, ჩვენ გვაქვს, რომელიც შეიცავს ღირებულება, რომელიც x ჰქონდა და b,
რომელიც შეიცავს ღირებულება, რომელიც y ჰქონდა.
ასე რომ, ერთი, ორი.
>> და თქვენ შეამჩნევთ, რომ ეს არის ცალკე დან x და y შიგნით ძირითადი.
ასე რომ, ჩვენ ახლა შექმნას დროებითი ცვლადი შეიცავდეს.
ჩვენ დავსახეთ ტოლია B, ასე რომ იცვლება ერთი ორი.
და მაშინ ჩვენ მითითებული ბ ტოლია to temp, რომელიც არის ერთ ერთი.
>> და მაშინ ჩვენ ახლა გაითიშება ამ ფუნქციის.
როდესაც გამოხვიდეთ გარეთ ფუნქცია, დასტის ჩარჩო იღებს popped off Stack.
ჩვენ მოვუწოდებთ მას დააყენებს.
თქვენ დააყენებს დასტის ჩარჩო გადატანა დასტის და თქვენ პოპ თუ off Stack.
და ასე შემდეგ რა ხდება, ყველაფერი, სწორედ ამ დასტის ჩარჩო ერთგვარი მხოლოდ
მიდის up in Flames.
და ისე, რომ აღარ არსებობს.
>> მაგრამ რა ვამჩნევთ?
ჩვენ არასოდეს რეალურად შეიცვალა ღირებულებები x და y, არა?
ასე რომ იმ დარჩა ადგილობრივი ძირითადი.
და გავლით რამ შევიდა swap, ჩვენ ფაქტობრივად არ შეცვლილა იმ ღირებულებებს.
და რა ჩვენ მოვუწოდებთ ამ?
ჩვენ მოვუწოდებთ ამ ავლით ღირებულება.
>> ასე რომ, C, როდესაც თქვენ გაივლით რამ შევიდა ფუნქციები, გადის მათ ღირებულება და
რაც ასლი მათ ფუნქციის გამოყენება.
და ჩვენ ვისწავლოთ რაღაც მოუწოდა ავლით მინიშნება შემდეგ, მაგრამ ეს
ისე, თქვენ შეგიძლიათ ამ პრობლემის მოგვარებას.
მაგრამ ჩვენ არ აღელვებს რომ სანამ მოგვიანებით.
>> ROB: და ფაქტობრივად, ეს ტერმინი, გავლის მინიშნება, ასე რომ C კი არ აქვს
ავლით მითითება.
C ექსკლუზიურად უკვე ავლით ღირებულება.
არ აქვს მნიშვნელობა, თუ რას აკეთებთ, თქვენ ყოველთვის გავლით ასლი რაღაც.
უბრალოდ, რომ, როგორც მე სახის აღნიშნა რომ სანამ პოინტერები
და რომ string მართლაც მხოლოდ ოთხი ბაიტი მიუთითებს ადგილას მეხსიერებაში.
>> ისე, თუ მაქვს ეს სიმებიანი და ეს მეუბნებოდა, რომ არის, სადაც string -
ასევე, თუ მაქვს ეს მაჩვენებელი ამ განათავსეთ მეხსიერებაში, მაშინ მე ვერ გაივლის
ასლი, რომ მომცეთ ფუნქცია და ეს ფუნქცია ჯერ კიდევ არ იცის, სადაც
მეხსიერების ეს არის.
ასე რომ, ორივე პოინტერები მიუთითებს იმ ადგილას მეხსიერებაში, და
ასე ჩვენ ვაპირებთ შეძლებს ცვლილებები რამ მიღმა
მიმდინარე დასტის ჩარჩო.
>> JOSEPH: არ გსურთ შედგენა?
>> ROB: არა, ეს 5:30.
>> JOSEPH: OK.
ეს არის 5:30.
OK.
ასე რომ, ჩვენ დაფარავს შედგენის ვფიქრობ in მომდევნო მონაკვეთის, ან თქვენი განყოფილებაში
ლიდერი იმ ეტაპზე.
და -
>> ROB: ნებისმიერი კითხვები?
>> JOSEPH: ნებისმიერი კითხვები?
დიახ?
>> დინამიკები 5: გამოყენება strings საწყისი CS50, ნებისმიერი ფუნქციები, რომ ჩვენ გვინდა გამოვიყენოთ
ის, რომ უნდა იყოს, ისევე როგორც C ფუნქციები.
CS50 არ წავიდა და რაიმე დამატებით.
>> ROB: სწორი.
ნებისმიერ C როგორიცაა [INAUDIBLE] თქვენ რომ გამოიყენოთ ეს ჩვენი სიმები.
>> JOSEPH: და ერთი ბოლო რამ მინდა ნახსენები არ არის, რომ ჩვენ გვაქვს სტილის სახელმძღვანელო
ამ კლასში.
>> ROB: Oh, yeah.
>> JOSEPH ასე რომ, თუ თქვენ მოდის პროგრამირების ფონზე ადრე, თქვენ
შესაძლოა გარკვეული კონვენციების, როდესაც თქვენ წერა კოდი მოსწონს აყენებს
braces იმავე ხაზის ან კონკრეტული გზები indenting
ან დასახელებისგან თქვენი ცვლადები.
ამ კლასში, ჩვენ გვინდა, რომ დაიცვას კონკრეტული სტილის სახელმძღვანელო მხოლოდ იმიტომ,
ასევე, თუ თქვენ გარეთ და იმუშაოს მრეწველობის, თქვენ აპირებთ უნდა ველოდოთ
დაიცვას სტილის სახელმძღვანელო კომპანია, რომელიც თქვენ წასვლა.
>> მაგალითად, Facebook ვფიქრობ განსაკუთრებული სახის დასახელებისგან
კონვენციას.
და არსებობს განსხვავებები camel გარსაცმები ცვლადები და ისევე, როგორც
ჰყოფს მათ ტირეებით.
ასევე, ვფიქრობ, ყველაზე მნიშვნელოვანია, ისევე როგორც მაგალითად, წანაცვლება, არა?
>> ჩვენ არ curly აფრთხილებს დაიწყება, სადაც მდგომარეობა, და ისინი
არიან მომდევნო ხაზი.
და ჩვენ ასევე დააყენა curly აფრთხილებს in მაშინაც კი, თუ ეს მხოლოდ ერთი ხაზი.
და ბევრი ჯერ, არსებობს გზები, რათა გააკეთოს ეს სადაც შეგიძლიათ დატოვონ ეს აფრთხილებს
off, თუ ეს მხოლოდ ერთი ხაზი ფარგლებში იმ შემთხვევაში, თუ განცხადებაში.
მაგრამ ამ კლასის, ჩვენ გვინდა, რომ დაიცვას კონკრეტული სტილის სახელმძღვანელო უბრალოდ ასე რომ თქვენ მიიღოთ
გამოიყენება, რომ სახის რამ.
>> ROB: ჰო, და სტილი 50 აპირებს აღასრულოს ამ სტილის სახელმძღვანელო, და ჩვენ
აპირებს გამოიყენოს სტილი 50 to grade თქვენს კოდი.
ასე რომ, რაც რამ ადვილია ჩვენთვის და იმედია არ უნდა მიიღოს, რაც
გაცილებით უარესი თქვენთვის მოცემული სტანდარტული სტილი არ უნდა იყოს, რომ
არარეალურია.
>> JOSEPH: და ბოლოს, რათა იპოვოს სტილი პროგრამა, წასვლა manual.cs50.net/style.
და yeah.
>> დინამიკები 4: აპირებთ თუ არა აღასრულოს ნებისმიერი სიმბოლო თითო ხაზზე?
>> ROB: დიახ.
>> JOSEPH: უკაცრავად, ბიჭები.
>> ROB: ეს იგივეა, ერთადერთი პირობა.
ამ ეტაპზე, მე ვარ OK 120.
მე კარგად განაცხადა, რომ 120 სიმბოლო თითო ხაზზე.
მე მესმის, იქ მყოფი გარკვეული ლიმიტი.
მე ვფიქრობ, რომ 80 არის იმდენად მცირე, მაგრამ ჩვენ აღსრულების იგი.
>> JOSEPH: პირადად მე ვფიქრობ C, 80 სიმბოლო უფრო OK.
ერთხელ თქვენ დაიწყოს მიღების სხვა ენებს, როგორიცაა JavaScript და PHP, არ
ასე რომ, გონივრული უბრალოდ ზღუდავს მას 80 სიმბოლო.
OK.
ისე, რომ იყო სუპერ მონაკვეთზე.
ვინმეს გსურთ candy?
>> დინამიკები 4: დიახ.