>> [მუსიკის დაკვრა]
>> DAN AMRMENDARIZ ყველას, მივესალმები CS50 სემინარი,
iOS App განვითარების Swift.
მე Dan Armendariz, და მე preceptor კომპიუტერულ მეცნიერებათა აქ ჰარვარდის.
>> და მომდევნო საათი იქნება Whirlwind ტური იმდენი პერსონალი
ამ თემაზე, როგორც ჩვენ ეტევა.
მე პოსტი ყველა კოდის რომ ნახავთ დღეს ონლაინ რეჟიმში.
ჩვენ შეიძლება ვერ შეძლებს რეალურად წავიდეთ მეტი ყველაფერი
რომ მე ვარ, რომ მე ვარ გვიჩვენებს, თუ ამ საათში.
მაგრამ მაინც იმედია მეშვეობით კომენტარი კოდის,
თქვენ გექნებათ ცდილობენ გაერკვნენ, თუ რა ზუსტად ხდება იმ რამ,
რომ ჩვენ არ საკმაოდ მისაღებად.
>> საერთო ჯამში, სტრუქტურა დღევანდელი განხილვა იქნება შემდეგი.
ჩვენ დავიწყებთ აკეთებს ზოგიერთი ძირითადი სინტაქსი ერთად Swift ენის,
შესვლის ზოგიერთი მოწინავე სინტაქსი Swift ენაზე.
იმის გამო, რომ ენის მართლაც, თანამედროვე და ეს
აქვს უამრავი მაღალი დონის თვისებები, რამ, რომ ჩვენ არ გვაქვს
ჩანს C მთელი CS50, ან კიდევ რამდენიმე სხვა ენებზე
რომ დავიწყეთ გამოყენებით ამ CS50, როგორიცაა PHP,
ასე რომ, მე ვაპირებ, რომ უნდა ვეცადოთ, რომ დანერგვა, ასევე რამდენიმე თემა, რომელიც
რომლებიც ეხება უმაღლესი დონის ენებზე რომ თქვენ შეიძლება ვერ ვხედავ სიღრმის CS50,
მაგრამ ნახავთ მოგვიანებით კომპიუტერულ მეცნიერებათა კლასების.
ასე რომ, ეს იქნება მჭიდროდ შეფუთული საათი.
და გთხოვთ მოგერიდებათ მიადევნე თვალი თუ თქვენ გაქვთ რაიმე შეკითხვები.
ასე რომ, თუ თქვენ დაინტერესებული ამით განვითარების
ერთად Swift, ან მართლაც ნებისმიერი iOS app განვითარების,
არსებობს რამდენიმე მოთხოვნები.
პირველ რიგში, თქვენ უნდა იყოს გამოყენებით Mac, გაშვებული მაგალითები
რომ ჩვენ ვაპირებთ იყოს გამოყენებით დღეს, შედარებით ახალი ვერსია OS
X. ამ შემთხვევაში, მე გაშვებული X 10.5.
თქვენ შეიძლება იყოს გაშვებული 10.11 თუ გინდათ.
მაგრამ ყველაფერი, რაც თქვენ ვაპირებთ ხედავთ არის ჩართვის Xcode 7 და მოგვიანებით,
რომელსაც აქვს უახლესი ვერსია საქართველოს Swift, რომელიც Swift 2.0.
ეს არის რეალურად საკმაოდ მნიშვნელოვანი განსხვავება.
ბევრი სინტაქსი აქვს შეიცვალა საკმაოდ მნიშვნელოვნად
რიგ შემთხვევებში საწყისი Swift 1.0, რომელიც გამოიცა გასულ წელს,
to Swift 2.0, რომელიც უბრალოდ გამოვიდა ამ შემოდგომაზე.
ასე რომ, ჩვენ ვაპირებთ, Swift 2.0.
ბევრი რამ, რომ თქვენ მოძებნოთ ონლაინ
როდესაც თქვენ ცდილობთ მიიღოთ დამატებითი ინფორმაცია სხვადასხვა ნივთები,
თქვენ მოისურვეთ მკაფიოდ ძიება Swift 2
ვიდრე მხოლოდ ბარის ძველ Swift რათა დარწმუნებული ვარ, რომ თქვენ სინტაქსი სწორი.
>> ფაქტობრივად, ეს არის ზოგადად ასეა.
აქ არის სწრაფი რაოდენობის განვითარების ხდება Swift ენის
მას შემდეგ, რაც Apple გამოუშვა, მე ვფიქრობ, რა, ეს იყო ცოტა მეტი წლის
ახლა.
და რამ შეიცვალა მკვეთრად იმ დროს.
ასე რომ არ იყოს იმედგაცრუებული იმ შემთხვევაში, თუ, როდესაც თქვენ ეძებს გარშემო
თემები on Swift და როგორ განახორციელოს რაღაც იყენებთ მაგალითად კოდი
ან რამე, რომ არ რეალურად მუშაობა Swift 2.0.
დარწმუნდით, რომ თქვენ ეძებს სპეციალურად, რომ ვერსია
ცდილობენ მინიმუმამდე ეფექტი სხვადასხვა ვერსიები და იმ სახის ნივთები.
>> ვეცდები აღვნიშნო, უბრალოდ ზოგი რამ რომლებიც სხვადასხვა ძველი ვერსიები.
მაგრამ ეს არის ის, რომ ფრთხილად.
ეს, ალბათ, იქნება ერთ-ერთი ყველაზე დიდი ტკივილი
რომ თქვენ გაქვთ Swift პოულობს მაგალითად კოდი, რომელიც არის ძველი, თუნდაც მხოლოდ
რამდენიმე თვის განმავლობაში, ცდილობს გამოიყენოს ეს თქვენი უფრო თანამედროვე პროექტი.
და ეს უბრალოდ არ მუშაობს.
თქვენ მიღების შემდგენელი შეცდომები, სინტაქსი შეცდომები, ყველა სახის გიჟები პერსონალი.
ასე რომ მხოლოდ მოთმინება რომ, და თქვენ იმედია
აქვს საკმაოდ კარგი გამოცდილება ერთად Swift საერთო.
>> ახლა თქვენ შეგიძლიათ რეალურად join-- და იმედი მაქვს, ჩვენ, ფაქტობრივად, ჯერ კიდევ აქვს ამ ამ წლამდე
CS 50 Apple app განვითარების გუნდი, რომელიც
რომელიც საშუალებას გაძლევთ დააყენოთ ნებისმიერი apps რომელიც თქვენ შექმნათ თქვენი iOS მოწყობილობების.
ასე რომ შევხედოთ ამ URL, თუ თქვენ ხართ დაინტერესებული აკეთებს, რომ.
>> ასე რომ, მხოლოდ რამდენიმე რამ Swift თავად.
ეს არის შედგენილი ენაზე.
მაგრამ თქვენ ნახავთ, რომ ზოგიერთი თავისებურება, რომ ჩვენ ვიყენებთ
საშუალებას იძლევა იგი გამოყენებულ იქნას ასევე ცოტა როგორც გაგებული, გზა, ისევე.
>> ბევრი სინტაქსი არის ნასესხები საწყისი C. ის საფუძველზე და დაწერილი C.
ასე რომ, ჩვენ ვხედავთ, რომ არსებობს ბევრი takeaways
თქვენი არსებული ცოდნა საწყისი C, რომ ჩვენ შეგვიძლია პორტი Swift.
>> მაგრამ არსებობს რამ, რომ რათა ის ძალიან განსხვავდება C.
ეს არის ძალიან მკაცრად აკრეფილი.
არსებობს ავტომატური მეხსიერების მართვა.
თქვენ არ აპირებს უნდა გამოიყენოთ malloc და თავისუფალი სადმე.
ის განკუთვნილია ზოგადი.
სხვა სიტყვებით, შეგიძლიათ გამოიყენოთ იგი ყველა სახის კონტექსტში, Apple- ის Watch
to iPhone ყველა გზა მდე OS X, და კიდევ რამდენიმე სერვერები, ზოგიერთი სკრიპტირების.
მაგრამ ჩვენ ვხედავთ, რომ მხარდაჭერა სკრიფტინგის
არ არის იქ კიდევ, როგორც ეს არის სხვა ენებზე.
ასე რომ, სავარაუდოდ, თქვენ უნდა გამოყენებით ეს მხოლოდ განვითარების
თქვენი Mac ან თქვენი iPhone.
>> და მას აქვს ბევრი თანამედროვე მახასიათებლები.
და ბევრი რამ არის პერსონალი, რომ ჩვენ ვაპირებთ, რომ ცდილობენ მიმართოს დღეს,
არამედ ჩვენი თემა, რომ გულწრფელად, ჩვენ შეგვიძლია დაუთმოს მთელი კურსები.
ფაქტობრივად, CS 51, რომელიც არის შესთავაზა მომდევნო სემესტრში,
ყურადღებას ბევრი ამ თემებზე რომ აღწერილია ქვემოთ.
ასე რომ, თქვენ შეგიძლიათ გაატაროთ მთელი სემესტრის გაგება ამ საკითხზე.
მაგრამ ჩვენ ვაპირებთ, რომ ცდილობენ მათი მეშვეობით
მინიმუმ საკმარისი, რომ თქვენ მესმის, რა არის
მიმდინარეობს, როდესაც თქვენ შეხედეთ ერთი Swift პროგრამა
და შეძლებს hack თქვენი გზა მეშვეობით საბოლოო პროექტი.
>> ახლა ერთი საუკეთესო გზა, რომ თქვენ დამატებითი ინფორმაციის მისაღებად ამ
გულწრფელად მხოლოდ მეშვეობით Apple- ის გათვალისწინებული დოკუმენტაცია Swift.
არსებობს ბევრი APIs რომ არის შესაძლებელი.
და ეს არის კარგი ბაზის თქვენთვის უნდა ვეძებოთ, კონკრეტული რამ, რომ თქვენ
მინდა ამის გაკეთება რომელზეც API ჩართვის iOS.
თუ გსურთ გამოიყენოთ კამერა მაგალითად, შეგიძლიათ დაიწყოს ეძებს აქ,
და ასევე გამოიყენოთ Google და დასტის Overflow როგორც თქვენ ჩვეულებრივ.
>> ნებისმიერი კითხვები ამ სანამ ჩვენ გადასვლა უფლება?
კარგი.
მოდით გადაადგილება.
>> ასე რომ, პირველი, მე მაქვს ნომერი მაგალითად ფაილი.
და მე ვაპირებ შევეცდებოდით მათი მეშვეობით შედარებით სწრაფად.
ეს არის Hello World ფაილი Swift.
ეს ძალიან მარტივია.
იქ უფრო მეტი კომენტარები ვიდრე არსებობს ფაქტობრივი კოდი.
ყურადღება მიაქციეთ, ფაქტობრივი კოდი არის ძალიან ბოლოში on line 14.
იგი აცხადებს, რომ ბეჭდვითი.
და შემდეგ ეს ფუნქცია ზარი.
ჩვენ გავლით შევიდა ეს სიმებიანი მოუწოდა გაუმარჯოს CS50.
ყურადღება მიაქციეთ, რომ არ არსებობს semicolons.
ყურადღება მიაქციეთ, რომ არ არსებობს int ძირითადი.
არსებობს არც ერთი cruft, რომ ჩვენ გვქონდა C.
როდესაც ჩვენ ვიყენებთ Swift ამ გზით, რომელიც მხოლოდ წერილობითი ტექსტური ფაილი
და ინახება ჩემი კომპიუტერი, მაშინ შემიძლია კომპილირება და გაუშვით.
>> გაითვალისწინეთ, რომ აქ ვარ არ იყენებთ CS50 IDE.
ეს გულისხმობს, რომ მე ვარ და რომ მე ვარ OS X,
და, რომ მე არ Xcode უკვე დაყენებული ეს მანქანა, რათა ამ
რეალურად ფუნქცია.
მაგრამ ეს არ არის მხოლოდ ჩვეულებრივი ტექსტური ფაილი რომ ჩვენ შეგვიძლია მაშინ შედგენა და რედაქტირება.
მოდით ვნახოთ, როგორ ეს რეალურად მუშაობს.
რა მოხდება, თუ მინდა კომპილაციის ეს?
swiftc 1.swift.
შემდეგ მომენტში ან ორი, დაინახავთ, რომ ჩვენ ახლა გვაქვს
შედგენილი ამ შევიდა ფაილი სახელად 1.
და ახლა ჩვენ არ იბეჭდება ჩვენი CS50, ჩვენი Hello World პროგრამა საკმაოდ.
>> გაითვალისწინეთ ერთი რამ, როგორც კარგად არის, რომ ჩვეულებრივ,
ჩვენ არ უნდა შეყვანის ა / ო ბეჭდვა ახალი ხაზი.
სტანდარტულად, ბეჭდვითი ფუნქცია Swift ბეჭდვა ახალი ხაზი თქვენთვის.
თქვენ შეგიძლიათ გადასცეთ არასავალდებულო დამატებითი პარამეტრი გითხრათ, რომ ეს არ არის ამის გაკეთება.
მაგრამ Google დამატებითი ინფორმაცია, რომ.
ჩვეულებრივ, ის ყველაფერს გააკეთებს ბეჭდვის ხაზი.
>> ყველა უფლება, მოდით გადაადგილება მაშინ სხვა რამ.
მაშ, როგორ შეგვიძლია რეალურად განსაზღვრავს ცვლადები?
ჩვენ შეგვიძლია გავაკეთოთ, რომ გამოყენებით ერთი ორი მეთოდები.
და ერთი, რომ მე მინდა გითხრათ, შესახებ პირველი არის let განმარტება.
და ეს არის მნიშვნელოვანი იმიტომ, რომ ეფექტურად
ის, რასაც ჩვენ ვაკეთებთ განსაზღვრის მუდმივი.
ჩვენ ვაპირებთ, რომ შევქმნათ ცვლადი, უფრო სწორად მუდმივი მოუწოდა სახელი,
გთავაზობთ მას გარკვეული მონაცემები და ამ შემთხვევაში, სიმებიანი დან.
მაგრამ გამოყენებით ამ let სიტყვით, ჩვენ ვამბობთ
რომ ეს ცვლადი ან ერთხელ constant-- ე.წ.
სახელი არასდროს შეიცვლება.
ეს იქნება უცვლელი მთელი ხანგრძლივობა ამ პროგრამის
ან მთელი ხანგრძლივობა კონტექსტში
, რომ ცვლადი არის შესაძლებელი.
>> ეს მართლაც მნიშვნელოვანია, რომ როდესაც თქვენ გაქვთ ზოგიერთი მონაცემებით, რომელიც არ არის
შეიცვლება თქვენი პროგრამა, და დაინახავთ სხვადასხვა მაგალითები
როდესაც ჩვენ გვინდა გამოვიყენოთ მიადევნე წინააღმდეგ სხვა სინტაქსი,
მნიშვნელოვანია, რომ თქვენ იყენებთ მიადევნე სადაც შესაძლებელია, რადგან ეს აცნობებს
ენა, რომ ეს არის არ შეიცვლება,
და ეს შეიძლება რეალურად შეასრულოს ბევრი ოპტიმიზაციით
გააუმჯობესოს სიჩქარე და უსაფრთხოების პროგრამა.
და უსაფრთხოების, მე ვგულისხმობ არა მიადევნე ავარიის გიჟები შეცდომები
რომ შეიძლება იყოს მიჩვეული ხედავს in C.
>> მაშინ ჩვენ შეგვიძლია გამოვიყენოთ სიმებიანი ინტერპოლაცია რომ encapsulate ამ ფარგლებში სიმებიანი.
ასე რომ, ჩვენ ვხედავთ ბეჭდვის ხაზი, ბეჭდვა hello,
და შემდეგ გამოყენებით წარმატებული ღია parens, და შემდეგ სახელი ჩემი ცვლადი,
ამ შემთხვევაში, მუდმივი, დახურვა ფრჩხილებში.
მე არსებითად შემდეგ აყენებს შინაარსი ამ ცვლადში სახელი
შიგნით სიმებიანი და შემდეგ დაბეჭდვის შედეგი იყო.
>> არსებობს ერთი ცვლილება ამ ფაილის რაც არის, რომ მე მაქვს, ძალიან ზევით,
მა shebang ხაზი, რომელიც ძირითადად მხოლოდ განსაზღვრავს
რომ მინდა გამოიყენოთ Swift თარჯიმანი, რაც
იმას ნიშნავს, რომ მე აღარ უნდა შეადგინონ ამ კონკრეტულ პროგრამას.
მე შემიძლია უბრალოდ გაუშვით როგორც საკუთარი დამწერლობა აქვს.
მაგრამ ეს არ არის, ამ შემთხვევაში, უკან სცენები იქმნება და შემდეგ
მიმდინარეობს აწარმოებს.
ეს მხოლოდ უხილავი ჩვენთვის.
>> ყველა უფლება, მოდით გადაადგილება.
ასე რომ, ცოტა მოსატყუებლად რომ მოხდა ადრე.
მე აჩვენა, რომ მე შეიძლება განისაზღვროს მუდმივი.
და მე ვერ გთავაზობთ ზოგიერთი მონაცემების ამის გაკეთება.
მაგრამ ამ შემთხვევაში, შეამჩნია, რომ მე არ რეალურად დააკონკრეტა ტიპის მონაცემები
ეს არის.
და ეს იმიტომ, რომ შემდგენელი, Swift შეუძლია
დასკვნის ტიპის მონაცემები უბრალოდ საფუძველზე წლის მონაცემები, რომ მე ეს.
იმის გამო, რომ იცის, რომ შეფასებისას ეს ცვლადი სწორედ აქ, ამ მონაცემების უფლება
აქ, იცის, რომ ეს არის ტექსტი.
ასე რომ, ეს მუდმივი სახელი ამიტომ იქნება სიმებიანი ისევე.
>> მაგრამ ჩვენ ასევე შეიძლება გამოკვეთილ ტიპის შესახებ, რომ
ჩვენ ვაპირებთ, რომ გამოიყენოთ მუდმივები და ცვლადები
გამოყენებით ამ სინტაქსი instead-- მიადევნე სახელი ნაწლავის სიმებიანი ტოლია
Dan, რომელიც ამ შემთხვევაში ნიშნავს იმას, რომ ჩვენ აპირებს განსაზღვროს მუდმივი მოუწოდა სახელი.
ეს იქნება ტიპის სიმებიანი.
და ღირებულება იქნება დან.
ახლა სხვა გზა, რომ ჩვენ შეგვიძლია შევქმნათ ცვლადები
და ეს არის mutable ცვლადები, რომელიც იმას ნიშნავს, რომ ჩვენ, ფაქტობრივად, აპირებს
შეცვალოს მათი შინაარსი შუალედში ხანგრძლივობა კონტექსტში
, რომ ცვლადი defined-- ჩვენ გამოიყენოთ var სიტყვით ნაცვლად მისცეს.
მაგრამ ერთხელ, ჩვეულებრივ, თუ თქვენ არ იცით რომ თქვენ უნდა მანიპულირება, რომ მონაცემები,
ცდილობენ გამოიყენონ მიადევნე for შესრულების გაუმჯობესება.
>> ამ შემთხვევაში, მე შეიძლება მაშინ დააკონკრეტა ტიპის მონაცემები
ჩვენ ველით, რომ იყოს შიგნით ახალი ცვლადში იარლიყი.
ეს იქნება სიმებიანი.
და ჩვენ ვაპირებთ, რომ მაშინ concatenate ორი strings ერთად, სიმებიანი hello,
და სიმებიანი მიერ წარმოდგენილი ცვლადი, უფრო სწორად, მუდმივი სახელი.
>> ასე რომ, ეს არის კარგი, რადგან ამ გარკვეულწილად PHP, როგორც, რომ ჩვენ
აქვს ძალიან მარტივი სიმებიანი გაერთიანების.
ჩვენ არ უნდა ავტომატურად გამოიყენოთ ნებისმიერი სახის მეხსიერების მართვა
ზომის გაზრდა და ამის ნებისმიერი სახის სასაცილო რამ არსებობს.
ეს მუშაობს, როგორც ჩვენ გვინდა რეალურად ველოდოთ.
>> ყველა უფლება, ნებისმიერი კითხვები ამ?
>> ახლა სხვა მიზეზის გამო, რომ ჩვენ უნდა თქვენ გაქვთ შესაძლებლობა
შეძლებს განსაზღვროს, თუ რა ტიპის მონაცემები ცვლადები
იმიტომ რომ ზოგჯერ ჩვენ არ მინდა ინიციალიზაცია ცვლადები
ზოგიერთი მონაცემები წერტილი განმარტება.
ასე რომ, ამ შემთხვევაში, ვთქვათ, რომ მინდა, რომ დაიწყოს შესაყვანი
ზოგიერთი შეფასება შევიდა კლასის წიგნში.
კარგად ვიცი, რომ ერთ-ერთი ცვლადები, რომ მინდა იყოს
აპირებს იყოს mutable კლასის.
ჩვენ ასევე ვიცით, რომ ჩვენ მინდა, რომ ეს იყოს მთელი რიცხვი.
მაგრამ იქნებ ჯერ არ ვიცით, აქვს, რომ კლასის შესაძლებელი.
>> In Swift, თქვენ უნდა განსაზღვრავს ტიპის მონაცემები
რომ არის დაკავშირებული ცვლადი ან მიადევნე მუდმივი
სანამ რეალურად გამოყენება, რომ ცვლადი.
იმის გამო, რომ იგი კატეგორიულად აკრეფილი, თქვენ უნდა გაერთიანდნენ ტიპი
ამ ცვლადებს.
>> ასე რომ, ამ შემთხვევაში, თუ მე არ არის სათანადოდ ინიციალიზაცია პირველი გარკვეული მნიშვნელობა,
მაშინ მე უნდა გითხრათ Swift რა ვიმედოვნებ, რომ მონაცემები ტიპის უნდა იყოს.
და ის აპირებს დარჩეს რომ იგივე მონაცემების ტიპის
მთელი ისტორიის ეს პროგრამა.
>> ახლა თქვენ შეიძლება ცდუნება, როგორც კი მე შევქმენი ეს grade ცვლადი
და იმ პირობით, მას რიცხვი 100, ახლა თუ მე
შევეცდები, რომ concatenate სიმებიანი რომ რიცხვი,
შეიძლება ცდუნება მაინც გამოიყენოს რომ სიმებიანი გაერთიანების ოპერატორი
როგორც ჩვენ გავაკეთეთ მხოლოდ რამდენიმე ხაზი ადრე.
მაგრამ სამწუხაროდ, ეს, ფაქტობრივად, არ
მუშაობა, იმიტომ, რომ თქვენ არსებითად ასრულებენ
ოპერაცია ორი სხვადასხვა ტიპის.
>> ეს არის ძალიან განსხვავდება სხვა ენებს, როგორიცაა PHP, რომელიც ნამდვილად
loosey goosey მათი ერთგვარი ტიპის.
ისინი უბრალოდ მინდა, ჰო, რაც არ უნდა, მე არ მაინტერესებს.
უბრალოდ მომეცი ერთი ტიპის, და იქნებ მე გავაკეთოთ სწორი.
>> ამ შემთხვევაში, Swift არის ძალიან მკაცრი სახის
რომ თქვენ საქმე.
ეს summation ოპერატორი ან გაერთიანების ოპერატორი
ძირითადად რამდენიმე სხვადასხვა შესაძლო ვარიანტი.
თქვენ შეგიძლიათ ამის summation მთელი რიცხვები, ან თქვენ
შეგიძლიათ გააკეთოთ სიმებიანი გაერთიანების და ალბათ ზოგიერთი სხვა რამ, ისევე.
მაგრამ, თუ ოპერატორი არ აღიარებს რა არის ორივე მხარეს,
უფრო სწორად მოიცავს იმ ორი სახის, არ არის ის ელოდება,
შემდეგ ის აპირებს გამოიწვიოს მარცხი.
>> ასე რომ, ამ შემთხვევაში, რას ნიშნავს ეს აქვს სიმებიანი პლუს რიცხვი?
ისე კონტექსტში ეს, ჩვენ, ალბათ, სურს
გავაკეთოთ სიმებიანი გაერთიანების ოპერაცია.
მაგრამ რა თქმა უნდა კომპიუტერი არ აქვს, რომ ერთგვარი კონტექსტში.
ასე რომ, ჩვენ უნდა უზრუნველყოს რომ დამატებითი ინფორმაცია
ასეც ვიცი, თუ რა ის არის, რომ ჩვენ გვინდა გავაკეთოთ.
>> სხვა სიტყვებით, ის ფაქტი, რომ Swift მკაცრად აკრეფილი
იმას ნიშნავს, თქვენ უნდა გავაკეთოთ ცოტა დამატებითი სამუშაო
უნდა მიიღოს იგი მუშაობას გზა, რომ თქვენ გსურთ.
მაგრამ შედეგად, ეს არის უსაფრთხო.
და კიდევ თქვენ გაქვთ მიიღოს მხედველობაში იმ ტიპის,
რამ უბრალოდ გულწრფელად დაიწყოს მუშაობა კარგად.
>> ასე რომ, ამ შემთხვევაში, ჩვენ მაშინ ასრულებს სიმებიანი გაერთიანების
მიერ მკაფიოდ აძლევენ მთელი სიმებიანი
შესაფუთი მას ამ კაპიტალის S სიმებიანი ფუნქცია,
და შემდეგ გამოყენებით სიმებიანი გაერთიანების ოპერატორი ცვლილებები ჩვენი ეტიკეტების ცვლადი,
და შემდეგ ამობეჭდოთ.
>> ჯერჯერობით, იმდენად კარგი?
ყველა უფლება, მოდით გადაადგილება.
>> ახლა არსებობს სხვადასხვა მონაცემები ტიპის, რომ ჩვენ შეგვიძლია გამოვიყენოთ Swift.
როგორც თქვენ არ შეეჩვია, ჩვენ შეგვიძლია შევქმნათ mutable მასივი.
და რომ მასივი მხოლოდ შეიცავს ერთი ტიპის.
>> ასე რომ, ამ შემთხვევაში, ჩვენ ვაპირებთ, რომ შევქმნათ mutable მასივები რიცხვებით, რომლებიც
ჩვენ მოვუწოდებთ შეფასება და ჩვენ შევძლებთ შესანახად, რომ ამ კვადრატული ფრჩხილი
ფორმატი, როგორც თქვენ გაიზარდა მიჩვეული რომ სხვადასხვა სხვა ენებზე.
მაგრამ შეამჩნია, რომ აქ ჩვენ განსაზღვრის რამდენიმე რამ.
შეფასება არის mutable ცვლადი ჩვენ არ გამოიყენოთ let სიტყვით.
ასე რომ, ეს ნიშნავს, რომ ჩვენ შეგვიძლია შემდეგ ცვლილებები შინაარსი ამ მასივი.
ეს არის ტიპის Array Int, და ჩვენ შეგვიძლია ვთქვათ, რომ
საფუძველზე ამ კვადრატულ ფრჩხილებში აქ.
>> ახლა ერთი კარგი რამ არის ის, რომ ჩვენ
გვაქვს წვდომა ბევრი დამატებითი ინფორმაცია
შესახებ მასივი უბრალოდ გამოყენებით რამდენიმე მარტივი dot ნოტაცია.
ასე მაგალითად, grades.count უზრუნველყოფს ჩვენთან
რაოდენობის საკითხი, რომელიც არსებობს, რომ მასივი, რომელიც ჩვენ შეგვიძლია შემდეგ შედიხართ საკმაოდ
ადვილად უბრალოდ გამოყენებით, რომ dot ნოტაცია.
>> თუ გსურთ დამატებითი ელემენტი ამ მასივი,
თქვენ ვერ PHP სტილი სადაც თქვენ უბრალოდ მკაფიოდ განსაზღვრა,
მოცემულ ინდექსი, გარკვეული მნიშვნელობა რომ გსურთ ჩადეთ.
იმის ნაცვლად, რომ, გამოიყენოთ დამატება მეთოდი მასივი ტიპი
დამატება, რომ საქონელი, 95, ამ სიაში.
>> ასე რომ, ახლა ამ მასივი აქვს შემდეგი contents-- 100, 0, 90, 85.
და ახლა ჩვენ ჩაჯდება 95 რომ ისევე.
>> არსებობს სხვა გზები ჩვენ შეგვიძლია დავამატოთ რამ.
თქვენ შეგიძლიათ რეალურად გამოვიყენოთ summation ოპერატორი,
რომელიც უნდა განიმარტოს, როგორც მასივი დამატება ოპერაცია.
და შეგიძლიათ შემდეგ დამატება სხვა მასივი, რომლის შინაარსი 70 და 80,
რომ მასივი.
ასე რომ, ახლა ჩვენ გვაქვს შინაარსი ამ ცვლადის
grades-- 100, 0, 90, 85, 95, 70 და 80.
ეს არის უბრალოდ ლამაზი პატარა სინტაქსური შაქრის Swift უზრუნველყოფს ჩვენთვის.
>> ასე რომ, თუ ჩვენ გვინდა, რომ მთლიანობაში შეფასება, ჩვენ, ალბათ,
აპირებს გვინდა iterate ყოველ ერთეულზე ამ loop.
და ჩვენ არ გვაქვს, Swift, ცნება ამისთვის loop როგორც თქვენ მოელოდა.
მაგრამ ისე, რომ ჩვენ მიუთითოს სპექტრი ოდნავ განსხვავებული.
ასე რომ, ამ შემთხვევაში, მთლიანობაში ყველაფერი, ჩვენ გამოგიგზავნით
აპირებს შექმნას დროებითი ცვლადში თანხა, რათა ჩვენთვის
რომ შევინარჩუნოთ ეს რაოდენობა.
>> და შენიშნავს, ჩვენი for loop სამშენებლო აქ.
ინდექსის 0 .. <grade.count.
ასე რომ, ეს მშენებლობა, 0 .. <grades.count არის მთელი რიგი ოპერაცია, სადაც ჩვენ ვართ
ამბობდა, რომ ჩვენ ვაპირებთ, რომ შევქმნათ რიგი რიცხვებით 0 მდე
მაგრამ გარდა grades.count.
ასე რომ, ეს იქნება 0, 1, 2, 3, 4, 5 წლამდე თუმცა ბევრი ერთი
ადრე grades.count.
>> ასე რომ, ეს არის განსხვავებული, თუ როგორ როგორც წესი, გამოიყენება მარყუჟების
სადაც თქვენ უნდა გარკვეული ინდექსი ცვლადი, ვაყენებთ მას ტოლი 0, პირველ რიგში,
და შემდეგ ინტეგრირება, რომ სანამ რაღაც მნიშვნელობა ნაკლებია გრაფი ნივთები
რომ მასივი.
>> ასე რომ, არ არის მოდიფიკაცია ამ, ფაქტობრივად,
რაც საშუალებას გვაძლევს ძალიან მარტივად შექმნას სხვადასხვა სახის მერყეობს.
თუ თქვენ შეცვალოს ეს სპექტრი სამი წერტილი, 0 ... grade.count,
ეს წარმოადგენს სპექტრი 0 რომ grades.count ჩათვლით,
რაც იმას ნიშნავს, რომ, რომ ნომერი, ასევე შემდეგ შედის, რომ დიაპაზონი.
>> მაგრამ ეს არის ძალიან მოსახერხებელი ამ ზუსტი რამ,
როდესაც ჩვენ უნდა შეასრულოს გამეორების მეტი loop
იმიტომ, რომ ეს ინდექსები ნულოვანი ინდექსირებული, როგორც ვნახეთ სხვა ენებზე
როგორც.
ნებისმიერი კითხვები ამ for loop?
>> ასე რომ, არსებობს ფარული განმარტება ამ ინდექსის ცვლადი,
რომლის ღირებულება იწყება 0, და გრძელდება ყოველ loop იტერაციული
გაიზრდება 1 წლამდე წერტილი რომ უდრის grades.count,
სადაც წერტილი, მარყუჟის ხერხდება.
>> გაითვალისწინეთ, რომ ჩვენი სიმებიანი ინტერპოლაცია აქ,
ჩვენ შეგვიძლია რეალურად შეასრულოს რამდენიმე მარტივი მანიპულაცია იმ ღირებულებებს.
ასე რომ, ინდექსი + 1, ფაქტობრივად, შეასრულოს summation რომ მნიშვნელობა
რადგან ინდექსი არის, ამ შემთხვევაში, რიცხვი.
და იმ ეტაპზე, ის მაშინ გარდაიქმნება string
და ჩაამატეს ამ სიმებიანი აქ, და იბეჭდება როგორც ჩვენ მოელოდა. .
>> და ლამაზი რამ შესახებ კოლექტორები აქ არის
ჩვენ ასევე შეუძლია ჰქონდეს მიღება ფასეულობები და შექმნის ღირებულებები
გამოყენებით კვადრატული ფრჩხილი ნოტაცია ჩვენ ვნახეთ სხვა ენებზეც.
>> ყველა უფლება, ასე რომ, ჩვენ ახლა გამოთვლაც ჩვენი თანხა ყველა ჩვენი შეფასება.
ახლა ერთგვარი შემდეგი ლოგიკური იქნებოდა,
გავაკეთოთ სამმართველოს ოპერაციის მოძიების out საშუალო იმ შეფასება.
მაგრამ რაღაც მნიშვნელოვანი აქ ხდება, რომელიც
ის არის, რომ ეს თანხა ალბათ რიცხვი.
მაგრამ ჩვენ უნდა შეასრულოს გარკვეული ერთგვარი ორმაგი გაყოფა.
და ეს იქნება ძალიან მნიშვნელოვანია, როდესაც
ჩვენ გვინდა, რომ ამ ოპერაციის, იმიტომ, რომ რასაც ჩვენ ვამბობთ,
ის არის, რომ ჩვენ უნდა რეალურად ასრულებს სამმართველოს ორი ორადგილიანი.
ისევ და ისევ, იმიტომ, რომ Swift ძალიან მკაცრად აკრეფილი,
ჩვენ მკაფიოდ უნდა მითითებული ყველა ნივთები ორადგილიანი სანამ ჩვენ რეალურად
ასრულებს, რომ ოპერაცია.
>> ასე რომ, იმისათვის, რომ შეასრულოს ორმაგი განყოფილება,
ეს არ არის საკმარისი მხოლოდ ერთი იმ ელემენტი უნდა იყოს ორმაგი.
ორივე მათგანი უნდა იყოს ორმაგი რათა სწრაფი
დარწმუნებული უნდა იყოს, რომ ეს არის ის, რაც ჩვენ გვინდა გავაკეთოთ.
ასე რომ, ჩვენ მაშინ მკაფიოდ typecast თანხა, რომელიც ჩვენ გამოითვლება ზემოთ
და დათვლის კლასის ორადგილიანი და მაშინ ასრულებს, რომ ოპერაცია და მაღაზია
რომ ამ ახალი ცვლადი, უფრო სწორად, ახალი მუდმივი მოუწოდა საშუალოდ
რომელსაც ექნება რა ტიპის, წარმოგიდგენიათ?
ორმაგი, yeah.
ასე რომ, ამ შემთხვევაში, ჩვენ არ უნდა მიუთითოთ ის
იმიტომ, რომ ეს შეიძლება გაკეთდეს დასკვნა, ოპერაცია რა ტიპის მონაცემები საშუალოდ
იქნება.
და Swift ზოგადად საკმაოდ კარგი შესახებ, რათა დავასკვნათ ტიპის.
>> გსურთ, რომ ეს აწარმოებს, ან შემიძლია გადაადგილება?
მე მინდა, რომ აპირებს.
ნებისმიერი კითხვები ნებისმიერ ამ?
შესანიშნავი.
>> ახლა ჩვენ ვაპირებთ, რომ დაიწყოს, რათა კარგი stuff-- განმსაზღვრელი ფუნქციები,
და რამდენიმე სხვა ტიპები რომ არიან უნიკალური Swift რომ თქვენ არა გაქვთ
ჩანს სხვა ენებზე სანამ ამ ეტაპზე,
მაგრამ ისინი იმყოფებიან სხვა ენებზე, რომ თქვენ შეიძლება მოგვიანებით.
ასე რომ, პირველი, თუ გსურთ განსაზღვროს ფუნქცია,
თქვენ განსაზღვრავს, ხმაურიანი სიტყვა ფუნქცია, და შემდეგ ფუნქციის სახელი,
ხოლო შემდეგ ფრჩხილებში, არგუმენტები რომ გსურთ რომ ფუნქცია მიიღოს.
არგუმენტები ასევე უნდა specify-- ზოგადად
ასევე უნდა განსაზღვროს ტიპის მონაცემები, რომ ისინი, თუ ისინი არ შეიძლება დასკვნა გაკეთდეს.
ჩვენ დავინახავთ, რომ პატარა გაფრთხილება მხოლოდ ცოტა.
>> ასე რომ, ამ შემთხვევაში ჩვენ გვაქვს ფუნქცია მოუწოდა printGradeCount.
ჩვენ ვაპირებთ, რომ მიიღოს ცვლადი უფრო სწორად, ამ შემთხვევაში,
constant-- მოუწოდა gradebook.
და ეს იქნება საქართველოს ტიპი მასივი რიცხვებით.
ახლა არის რაღაც რომ მართლაც მნიშვნელოვანია აქ
რომ მე მინდა გვესმოდეს.
ეს არის ის, რომ იყოს, ეს არგუმენტები რომ საშუალებებით ამ ფუნქციის
განისაზღვრება ფარული let სიტყვით, რაც იმას ნიშნავს, რომ მე არ შემიძლია შეცვალოთ
gradebook ცვლადი აქ.
და რომ ერთგვარი აზრი, იმიტომ, რომ თქვენ გავლის მონაცემები.
და თქვენ, ალბათ, არ მინდა, უნდა შეიცვალოს ქვეშ თქვენ.
არ არის გამორიცხული, მკაფიოდ აღვნიშნო, რომ ეს არის ცვლადი აყენებს
var სიტყვით აქ.
მაგრამ ეს არის gotcha, რომ ჩვენ შენიშნა ადამიანი არ კეთდება წარსულში
ის არის, რომ ისინი ფიქრობდნენ, რომ ის აპირებს იყოს ცვლადი, როდესაც, ფაქტობრივად, ეს
არის მუდმივი.
>> ყველა უფლება, მაშინ აქ, ამ შემთხვევაში, ჩვენ არ მითითებით დაბრუნების ტიპის.
ჩვენ გაჩვენებთ, თუ როგორ უნდა გავაკეთოთ რომ რაღაც მომენტში.
მაგრამ შეამჩნია, რომ აქ ჩვენ გვაქვს უბრალოდ მარტივი თუ მდგომარეობა.
იმ შემთხვევაში, თუ gradebook არის ცარიელი, რომელიც ამ შემთხვევაში
მხოლოდ ქონების ეს რიცხვი მასივი, მაშინ ჩვენ ამობეჭდოთ რაღაც.
წინააღმდეგ შემთხვევაში, ჩვენ გავაკეთოთ რაღაც.
>> საკმაოდ მარტივია იმდენად, რამდენადაც ვფიქრობ.
მაგრამ შეჩერება ჩემთან თუ თქვენ გაქვთ რაიმე შეკითხვები.
>> ახლა ეს ფუნქცია, საშუალო, ასევე იღებს გარკვეული არგუმენტები, უფრო სწორად ერთი არგუმენტი,
რომელიც არის gradebook, და ამ დროს დაბრუნებას აპირებს ორმაგი ტიპის.
იმიტომ, რომ ეს არის კომპიუტერული საშუალო და ეს
აპირებს რეალურად დაბრუნებას, რომ კომპიუტერული საშუალოდ ნომრებზე ონლაინ.
>> ამ შემთხვევაში, ჩვენ დააკონკრეტა დაბრუნდეს მას შემდეგ, ისარი.
და ეს, შესაძლოა, გრძნობენ სახის უცნაური პირველი.
თქვენ გაიზარდა მიჩვეული შექმნის სანაცვლოდ
ტიპი ადრე სახელით ფუნქცია.
მაგრამ თუ თქვენ ფიქრობთ ამ თვალსაზრისით მათემატიკა,
ასე, როდესაც თქვენ გაქვთ მათემატიკის რომ განსაზღვრავს ფუნქცია,
თქვენ გაქვთ ფუნქცია რამდენიმე საშუალებებით, და აწარმოებს გამოშვება.
და სწორედ ის, რაც ეს უნდა mimic.
და იქ რამდენიმე სხვა ენებზე რომ მსგავსი სინტაქსი, ისევე,
მაგრამ ალბათ არა, რომ ვნახე CS50.
მაგრამ მაინც არ იყოს დაბნეული მიერ.
Arrow ნიშნავს, რა ხდება უნდა დაუბრუნდეს ამ შემთხვევაში.
OK, ასე რომ, თუ ჩვენ ვაპირებთ გამოთვლაც ამ საშუალოდ?
ისე, თუ gradebook არის ცარიელი, ასევე მაშინ ჩვენ
დაბრუნებას აპირებს 0, რომელიც, შესაძლოა, გონივრული გზა მკურნალობა.
მე არ ვიცი, მოდით მოვიდა უკან რომ ცოტა.
ეს არ რეალურად იყოს გონივრული გზა
გამოთვლაც საშუალოდ თუ ჩვენ გვაქვს ცარიელი gradebook.
>> მაშინ ჩვენ მხოლოდ ასრულებს ჩვენი summation.
გაითვალისწინეთ, რომ აქ ჩვენ რეალურად გვაქვს ალტერნატიული ვერსია
მარყუჟის, რომელიც საშუალებას გვაძლევს iterate მეტი თითოეული ელემენტის მასივი
და თითოეული ელემენტი საკუთარი ცვლადი.
განსაზღვრით კლასის gradebook, რასაც ჩვენ ვამბობთ,
ის არის, რომ ჩვენ ვაპირებთ, რომ ირიბად შექმნა ახალი მუდმივი მოუწოდა
კლასის, რომ აპირებს წარმოადგენს ყველა უნიკალური ნივთი gradebook
ყოველ ჯერზე, რომ ამისთვის loop iterates.
ასე რომ, პირველად რომ ის აწარმოებს, grade იქნება
იყოს პირველი პუნქტის gradebook.
მეორედ ეს იქნება მეორე პუნქტის, ასე შემდეგ და ასე შემდეგ
სანამ gradebook აქვს თავი ამოწურა ელემენტები.
მაშინ ჩვენ შევძლებთ, რომ თანხა, რომ grade ჩვენი summation ცვლადი
და დავიბრუნოთ ჩვენი საშუალოდ როგორც ჩვენ ვნახეთ ადრე.
OK, ნებისმიერი კითხვები?
დიახ?
აუდიტორია: მე მაქვს ორი შეკითხვა.
ნომერი ერთი, პირობითად, შეიძლება თქვენ აწარმოებს მთელი ამ ერთი?
არ უნდა იყოს ორმაგი, არის ის, რომ სწორი?
DAN AMRMENDARIZ: შეგიძლიათ ვიმეორებ, რომ ამ საკითხთან დაკავშირებით?
აუდიტორია: შემიძლია რიცხვი, როგორც საშუალო?
DAN AMRMENDARIZ: შეგიძლიათ ამის რიცხვი, როგორც საშუალო?
ასე რომ დაბრუნდეს რიცხვი საშუალო ნაცვლად ორმაგი?
>> აუდიტორია: დაბრუნდება თუ არა აქვს, რომ ახლა ქვემოთ.
DAN AMRMENDARIZ: სწორედ აქ, დაბრუნდნენ 0.0?
აუდიტორია: Yeah, დააბრუნებს 0.
ასე რომ, ეს იქნება ან 80 ან 85, მაგრამ არა 85.2.
>> DAN AMRMENDARIZ: ასე რომ, ამ შემთხვევაში, ასე რომ, რამდენიმე განსხვავებული გზები
პასუხის გაცემა.
ნება მომეცით პასუხი მათ მიზნით.
ასე რომ, თუ უბრალოდ ეს დაბრუნების 0, 0 არის მთელი მნიშვნელობა.
და ისე, რომ გამოიწვევს ტიპის შეცდომა ამ შემთხვევაში
იმიტომ, რომ ის ელოდება ორმაგი მაგრამ შემდეგ დაბრუნების რიცხვი.
თუ მინდა დაბრუნდეს რიცხვი, შემიძლია.
შემიძლია მითითებული დაბრუნების ტიპის to int, დაბრუნდნენ 0 აქ,
და არ შეასრულოს ორმაგი გაყოფა.
მაგრამ მაშინ იქნება ამით მთელი განყოფილება.
ასე რომ, ჩვენ მაშინ არ მიიღოს საშუალოდ, რომ ჩვენ შესაძლოა ველოდოთ.
მაგრამ დიახ, ჩვენ შეგვიძლია ცვლილებები სახის, რომ გზა.
>> აუდიტორია: მეორეც, თქვენ აქვს ერთი ორმაგი ზედა.
მაგრამ ქვემოთ, როდესაც თქვენ გავაკეთოთ დაბრუნების Double Double,
რომ უკვე ავტომატურად დაბრუნების ორმაგი ფორმატში.
რატომ მაინც უნდა განსაზღვროს ის ერთად arrow თავზე ორმაგი?
>> DAN AMRMENDARIZ: ასე რომ, იმ შემთხვევაში, თუ ეს არის ნაწილი
საქართველოს the-- ასე გავიმეორო შეკითხვა, იმიტომ, რომ ეს ფარული ეხლა დაბრუნების
სახის აქ, რა ტიპის ეს რეალურად არის, ჩვენ უნდა გამოკვეთილ ერთად Swift
ის, რაც ჩვენ გვინდა დაბრუნდეს out ამ ფუნქციის
ასე რომ, როდესაც იგი ასრულებს ტიპი შემოწმების, ეს შეიძლება დარწმუნდით
რომ ის, რაც ჩვენ რეალურად დაწერილი ქვემოთ რეალურად შეესაბამება, რომ.
ასე რომ, ეს ერთგვარი მოსწონს გამშვები თავს ერთგვარი სიტუაცია.
მაგრამ არსებობს are--
>> აუდიტორია: [INAUDIBLE] arrow?
>> DAN AMRMENDARIZ: არის შემთხვევები, როდესაც ჩვენ შეუძლია მიუთითოს, რომ ჩვენ შეგვიძლია ირიბად
მითითებული დაბრუნების ტიპის.
მაგრამ ამ შემთხვევაში, მე არ ვფიქრობ, რომ იმუშავებს.
არსებობს რამდენიმე სხვა სინტაქსის რომ ვნახავთ, მოგვიანებით.
>> ყველა უფლება, ასე რომ ეს წყარო კოდი არის ცოტა განსხვავებული
იმიტომ, რომ ეს parses არგუმენტები ფუნქცია, რომელიც ჩვენ მოუწოდებდა.
ნება მომეცით, თუ როგორ მუშაობს სანამ ჩვენ რეალურად გადავიდეს
ზოგიერთი საინტერესო რამ რომ ხდება Swift.
>> ასე რომ, ამ შემთხვევაში, მე უბრალოდ გაუშვით ეს კოდი შეამჩნევთ, რომ რასაც ის აკეთებს
is-- ხოლო, სახის მაძლევს უცნაური შეცდომა.
მე უნდა გაიაროს ეს რამდენიმე რიცხვებით, როგორც ბრძანების არგუმენტი.
ასე რომ, ვნახოთ, 150 და 80, და დააჭიროთ გაირკვეს, თუ რა ეს რეალურად აკეთებს.
ის მიღების თითოეული ეს ფასეულობები რიცხვებით.
ეს შესაყვანი მათ gradebook.
და მაშინ ის ასრულებდა საშუალო გაანგარიშება
და outputting, რომ როგორც ჩვენ მოელოდა.
>> მაგრამ, ცხადია, იქ რაღაც ხდება შესახებ ამ უარის თქმის რაიმე
რაღაც, როგორც მთელი რიცხვი.
როგორც თქვენ ალბათ გახსოვთ, როდესაც ჩვენ საქმე ბრძანების არგუმენტები
C და სხვა ენებზე, პირველი 0-ე პუნქტი, რომ ბრძანების არგუმენტი
სიაში არის სახელი ბრძანება რომ ჩვენ რეალურად შესრულებული.
ასე რომ, ამ შემთხვევაში, მე უბრალოდ looping მთელ ბრძანების არგუმენტები.
მაგრამ მე არ აკეთებს რაიმე ლამაზი შეამოწმეთ, გაფართოებული გამო, რომ პირველი.
მე უბრალოდ პირდაპირ ან მე ირიბად შემოწმების, რომელიც ამ ტიპის
რიცხვებით ადრე მე რეალურად ასრულებს ამ გამოთვლები.
>> და რომ არსებითად რა ხდება აქ.
ყველა არგუმენტი პროცესი არგუმენტებს,
მე ვაპირებ შეასრულოს გარკვეული ქვითარი.
და ამ შემთხვევაში, მე ვაპირებ ცდილობენ პირველი კონვერტირება
რომ არგუმენტი რიცხვი მიერ შესრულების გამოკვეთილ typecast,
იმიტომ, რომ ეს არის, შეყვანის, სიმებიანი და, ფაქტობრივად, არ არის მთელი რიცხვი.
>> მაგრამ ეს არის ერთგვარი უცნაური სინტაქსი, თუ მიადევნე grade შეადგენს Int (არგუმენტი).
რა ხდება რეალურად აქ არის ძალიან
მნიშვნელოვანია, რომ თქვენი გამოყენებით Swift.
ეს არის გამოყენებით რა არის ე.წ. სურვილისამებრ ტიპის.
>> ასე რომ, ეს ფუნქცია, Int (არგუმენტი), ბრუნდება არა მხოლოდ რიცხვი, მაგრამ ბრუნდება
რასაც სურვილისამებრ რიცხვი.
ასე რომ, ეს არის ერთგვარი ტიპის თავზე ტიპის.
შეგიძლიათ სახის წარმოიდგინეთ ეს მოსწონს ეს დაბრუნების, როგორც პაკეტი.
და როცა გახსნა, რომ პაკეტი, არც
აქვს მთელი რიცხვი, რომელიც არის შედეგი, და მას აქვს აბსოლუტურად არაფერი საერთოდ.
და ეს არის სასარგებლო, როგორც შეცდომა შემოწმება მექანიზმი, რადგან ამ შემთხვევაში
ჩვენ შეგვიძლია გავარკვიოთ, იყო ეს ტიპის კონვერტაციის წარმატებული?
თუ ეს იყო, მაშინ ეს არის, ფაქტობრივად, აპირებს აქვს მთელი შიგნით.
წინააღმდეგ შემთხვევაში, ის აპირებს, რომ გარკვეული ღირებულება, რომელიც ჩვენ მოვუწოდებთ nil, რომელიც
წარმომადგენელი არ რიცხვი ყველა.
ეს მართლაც წარმომადგენელი არაფერი.
>> ასე რომ, თუ მშენებლობა საშუალებას გვაძლევს unwrap რომ პაკეტი,
რომ სურვილისამებრ სავალდებულო.
და თუ ჩვენ შეგვიძლია unwrap, რომ პაკეტი და იპოვოს მთელი შიგნით,
მაშინ, რასაც ჩვენ ვამბობთ აქ არის ის, რომ ჩვენ მაშინ
საშუალებას იძლევა, რომ ღირებულება უნდა ამოქმედდა ეს მუდმივი მოუწოდა კლასის.
და ეს ნაწილი, თუ განაცხადი, ზედა ნაწილი, თუ განაცხადი
მიიღებს, იმიტომ, რომ Unwrap წარმატებული იყო.
>> თუ ეს ასე მოხდება, რომ იქ იყო შეცდომა, ალბათ,
ამ გამოკვეთილ ტიპის კონვერტაციის სიმებიანი რიცხვი, შესაძლოა,
ის ღირებულება ABC მაგალითად.
და ეს არის რეალურად არ აპირებს კონვერტირება რიცხვი.
მაშინ იგი დაბრუნდება ნული, რომელიც არ არის მთელი რიცხვი.
და ეს თუ განაცხადი კარგად მაშინ ვერ.
grade არ არსებობს, რადგან მას არ აქვს მთელი შინაარსი.
და მას მიიღებს ამ სხვა ბლოკი ნაცვლად.
დიახ?
>> აუდიტორია: Nil არის N-I-L?
DAN AMRMENDARIZ: ნული არის N-I-L, დიახ.
>> ასე რომ, ეს, შესაძლოა, ერთ-ერთი უმძიმესი რამ Swift,
განსაკუთრებით მაშინ, როდესაც თქვენ სარეველას შესახებ iOS app
და თქვენ რეალურად ცდილობს უნდა გავაკეთოთ ზოგიერთი განვითარების არსებობს.
ეს იქნება ყვირილი თქვენ შესახებ სურვილისამებრ.
ეს იქნება გეკითხებით კითხვის ნიშნები და ძახილის რაოდენობა.
მაგრამ ერთხელ თქვენ გაერკვნენ out-- თუ გამოიჩინოს გარკვეული დრო მჭიდროდაა
რა ხდება პირობითი ტიპის, თქვენ გადარჩენა თავს ბევრი თავის ტკივილი
როგორც თქვენ ცდილობთ დაწერა ოთახი Swift.
>> ეს, ფაქტობრივად, ძალიან ძლიერი ფუნქცია.
და თქვენ უბრალოდ უნდა ჩემს სიტყვას, რომ ახლა.
მაგრამ ჩვენ ვხედავთ, ეს მშენებლობა და სხვები მომწონს
ზოგიერთი სხვა კოდის რომ ჩვენ გავხდით, თუ მხოლოდ ცოტა.
>> არსებობს რაიმე საწყის კითხვები აქ?
ამიტომ მნიშვნელოვანია takeaway არის, რომ სურვილისამებრ ტიპის არის ერთგვარი metatype.
ეს არც აქვს მნიშვნელობა, და თუ ეს ასეა, მაშინ ეს
ალბათ აქვს, რომ ასოცირებული მნიშვნელობა მას, ან მას არ აქვს მნიშვნელობა განაწილებაზე,
და იგი წარმოადგენდა ნული.
დანარჩენი ეს არის ალბათ როგორც თქვენ მოელოდა.
>> მოდით გაეზარდათ სირთულე კიდევ ერთხელ.
და ამ დროს, მოდით შევხედოთ ზოგიერთი სხვა მონაცემთა ტიპები რომ რეალურად არსებობს.
ერთ-ერთი მათგანი ლექსიკონები, რომელიც ძალიან ჰგავს Python ლექსიკონები.
ეს გარკვეულწილად მსგავსი hash მაგიდა C. ეს არსებითად რუკების ღილაკები
გასაღებები შეიძლება სტრიქონები.
და როდესაც თქვენ ეძებოთ იმ გასაღებები, იმ გასაღებები ექნება მნიშვნელობა.
ასე რომ, ეს არ არის საკმაოდ მასივი, მაგრამ ნაცვლად, უფრო მჭიდროდ უკავშირდება
რომ hash რუკა ან hash მაგიდა.
>> ვნახოთ, როგორ ეს უნდა მუშაობა, სანამ ჩვენ რეალურად
წასვლას კოდის თავად.
თუ უბრალოდ აწარმოებს, არაფერი არ ხდება.
ის მეუბნებოდა, რომ მე ველოდებით ზოგიერთი პარამეტრების შემდეგ ტიპის.
ამიტომ, მე ვაპირებ, რათა უზრუნველყოს მას რამდენიმე პრობლემა კომპლექტი სახელები,
ასე pset0, იქნებ მე მივიღე 100.
და pset1, მე მივიღე 5.
და მერე გამოცდა, მე გააკეთა ნამდვილად კარგად და მიიღო 30.
და oops, მე მოხვდა სივრცეში აქ.
>> როდესაც მე დააჭიროთ, ხედავთ იგი ასრულებს გამოთვლები.
იგი აცხადებს, რომ gradebook სამი შეფასება, pset1, pset0, გამოცდა.
და gradebook აქვს ამ კონკრეტულ საშუალოდ.
ასე რომ კიდევ ერთხელ, ჩვენ ვმუშაობთ ამ gradebook იდეა,
მაგრამ ჩვენ ვაპირებთ გავაგრძელოთ iterating სირთულის ჩვენი ფუნქცია.
>> ასე რომ, დაწყების, ჩვენ უბრალოდ შექმნას აპირებს ფუნქცია, რომელიც
პასუხისმგებელია დაბეჭდვის გამოყენება.
და არსებობს ამ გასასვლელი ფუნქცია რომელიც მხოლოდ
იძულებით დატოვა განაცხადს.
ეს არ არის ის, რაც თქვენ გამოიყენოთ iOS app.
ეს არის მხოლოდ, რომ ამ შემთხვევაში, ბრძანების არგუმენტი.
შემდეგი დავიწყებთ სვლას Xcode.
მაგრამ ეს არის კონკრეტული ბრძანება ხაზის სტილი პროგრამის Swift.
>> მოდით შევხედოთ ზოგიერთი საინტერესო რამ აქ.
ვნახოთ, მხოლოდ რამდენიმე საინტერესო რამ, რომ აღარაფერი ვთქვათ, ალბათ,
არის, რომ ჩემი ფუნქცია ბეჭდვის რაოდენობის შეფასება,
ალბათ გახსოვთ, რომ მე მქონდა, რომ სიაში საქართველოს items-- pset1, pset0 და გამოცდა.
თქვენ შეგიძლიათ რეალურად სწრაფად და მარტივად ამისათვის
აღების gradebook, რომელიც არის ლექსიკონი, რომელიც გასაღებები და ღირებულებები.
ს ყველა გასაღები მეშვეობით the dot გასაღებები მეთოდი აქ,
და შემდეგ გამოიყენოს ეს joinWithSeparator, რომელიც მაშინ ყველა გასაღებები
, რომ ჩვენ აკრეფილი, pset1-- ან უკაცრავად, pset0, pset1 და exam--
და concatenate მათ ერთად გამოყენებით მძიმით და სივრცეში
რომ შევქმნათ ერთი ხანგრძლივი string.
ეს ოპერაციას მხოლოდ ფენომენალურად სასარგებლო სხვადასხვა კონტექსტში.
ასე რომ, ეს არის ამ joinWithSeparator.
>> და ეს არის ერთი რამ, რომ შეიცვალა Swift 1 Swift 2.
არ უნდა იყოს Python style-- თუ თქვენ
იცნობს Python-- პითონის სტილი შეუერთდეს მეთოდი სიმები.
მაგრამ რომ აღარ არის იმ შემთხვევაში, Swift 2.
გსურთ გამოიყენოთ თუ გსურთ to concatenate მასივი პერსონალი
ერთად სიმებიანი.
>> ასე რომ, ალბათ მაშინ ჩვენი განხილვა საშუალოდ ადრე,
ის, რაც ცოტა მეტი აზრი ჩვენთვის მითითებული საშუალო ფუნქცია
უნდა იყოს სურვილისამებრ ორმაგი საკმაოდ ვიდრე უბრალოდ გამოკვეთილ ორმაგი.
იმის გამო, რომ ჩვენ გვქონდა, რომ უჩვეულო მდგომარეობა, სადაც,
რა მოხდება, თუ gradebook რეალურად არ გააჩნია ღირებულებები მასში?
რა უნდა საშუალო სანაცვლოდ?
>> ისე იქნებ C თქვენ რომ არ კეთდება რამე
როგორიცაა გათვალისწინებული Sentinel ღირებულება, როგორც 0.0, ან იქნებ უარყოფითი ნომერი,
ან რაღაც წარმოადგენს ის ფაქტი, რომ გარკვეული შეცდომა მდგომარეობა
და თქვენ ალბათ არ რეალურად უნარი გამოთვლაც, რომ საშუალო.
კარგად სილამაზის განსაზღვროს სურვილისამებრ ტიპის იქნება ამის გაკეთება.
და მე ახლა ვამბობ, რომ ყველა ეს სიტყვა, მაგრამ ეს, ფაქტობრივად, არ გამოიყენოთ optionals.
მაგრამ ჩვენ ვხედავთ, რომ მხოლოდ -ე, სადაც ჩვენ შეგვიძლია მითითებული საშუალოდ
უნდა იყოს სურვილისამებრ მონაცემები ტიპის ისე, რომ იმ შემთხვევაში, თუ ის რეალურად ბრუნდება გარკვეული მონაცემები, მაშინ
დავიბრუნებთ, რომ მონაცემები.
წინააღმდეგ შემთხვევაში დავიბრუნებთ nil და განაცხადა, რომ ამ
არ მნიშვნელოვანი გამოთვლები.
>> მოდით გადაადგილება რაღაც.
ასე რომ, აქ, ჩვენ უკვე ეძებს ყველა ეს მაგალითები ბრძანების.
მაგრამ რეალურად, თუ რას აპირებს იყოს საქმე არის Xcode.
ერთ-ერთი ყველაზე ლამაზი რამ Xcode, და კონკრეტულად Swift,
ის არის, რომ ჩვენ გვაქვს ეს რამ მოუწოდა მოედანი.
და Playground არის საერთოდ iOS app.
მაგრამ ეს გაძლევთ საშუალებას ექსპერიმენტი ერთად Swift ძალიან მარტივი გზა.
შეგიძლიათ აკრიფოთ ყველა თქვენი კოდი.
ეს ლამაზად სინტაქსის მონიშნულია აქ.
როდესაც თქვენ შექმნათ ახალი ფაილი, ეს იქნება ითხოვენ თუ თქვენ გსურთ შექმნათ მოედანი.
მაგრამ ლამაზი რამ შესახებ Playground ის არის, რომ მარჯვენა ფანჯარა,
ის რეალურად გაჩვენებთ გამომავალი თქვენი კოდი.
ასე რომ, თუ მე გადახვევა ქვემოთ, ჩვენ ვხედავთ, თუ რა გამომავალი სხვადასხვა ხაზების კოდი
რეალურად ხდება, რომ იყოს.
>> ასე რომ, ამ შემთხვევაში, ჩვენ ვაპირებთ შეცვლის მიმართულებით ცოტა
და ვისაუბროთ რაღაც რომ მართლაც მნიშვნელოვანია, რომ ამ მაღალი დონის გზა
რომ Swift მუშაობს, და ეს ამ იდეას დახურვა.
და თქვენ ალბათ გინახავთ ეს ცოტა JavaScript.
იმ თქვენ, რომ არის CS50, დახურვა
ძალიან პოპულარულია, ძალიან კარგი გზა აკეთებს მაღალი დონის რამ თანამედროვე ენებზე.
მაგრამ ეს ასევე სახის რთული გადაიტანოთ თქვენი უფროსი გარშემო პირველად.
ასე რომ, თუ შევხედავთ ამ პირველად, რომ კარგადაა.
უბრალოდ შევხედოთ წყარო კოდი და ვნახოთ თუ შეგიძლიათ გაერკვნენ ის სახლში.
>> ასე რომ, ამ შემთხვევაში, ვთქვათ, რომ ჩვენ გსურთ შექმნათ უამრავი ექსპონატი
გარკვეული ფიქსირებული ღირებულება.
ასე რომ, ამ შემთხვევაში, მე შეიძლება შეიქმნას ფუნქცია.
მე ვაპირებ მოვუწოდო მას ძალა 2, რომლის ერთადერთი მიზანი ცხოვრებაში
არის გარკვეული შეყვანის და ორმაგი მას, და დაბრუნდება რომ ღირებულება.
ყურადღება მიაქციეთ, რომ აქ ვარ მიღების ერთ-ერთი ტიპის მონაცემები.
ეს იქნება ცვლადში x.
ეს არის ტიპის ორმაგი.
და მე ვაპირებ დაბრუნებას ორმაგი აქ.
და მე უბრალოდ აპირებს ძალიან, სიმართლე გითხრათ, საკმაოდ
გულუბრყვილო გზა გაორმაგდა მნიშვნელობა.
და მე გაჩვენებთ, თუ რატომ ეს სასარგებლო მხოლოდ მეორე.
>> გაითვალისწინეთ, რომ აქ ჩვენ გვაქვს ეს სპექტრი ერთხელ. რაღაც 1, dot
dot dot, 2, რაც ნიშნავს, რომ ამ მარყუჟის ორჯერ.
მაგრამ ეს წარმოადგენს რაღაც ცვლადი.
ეს იმას ნიშნავს, რომ მე ნამდვილად არ აპირებს გამოყენებით, რომელიც ცვლადი სადმე
შიგნით ამ loop.
მე უბრალოდ მინდა ეს ხაზი კოდი აწარმოებს ორჯერ,
გარეშე სჭირდება იცოდეს ღირებულება რომ დიაპაზონი.
>> ასე რომ, ამ შემთხვევაში, მე გაშვებული შედეგი ჯერ x ორჯერ, რომელიც არსებითად
იმას ნიშნავს, რომ მე squaring მნიშვნელობა.
და ეს მოხდება, მუშაობა, როგორც ჩვენ მოველით.
სიმძლავრე 2 გავლით ღირებულება 2.0 გვაძლევს გამოშვება 4.
3.2 სამუშაოების 10,24.
>> ახლა ჩვენ შეგვიძლია გავაკეთოთ მსგავსი რამ ძალა 3.
მაგრამ ახლა შეცვლის მხოლოდ სპექტრი.
იყიდება რაღაც ცვლადი 1 მეშვეობით 3, გამრავლების 3-ჯერ,
და იგივე რამ.
>> ასე რომ, ეს შეიძლება გრძნობენ ცოტა contrived.
მაგრამ არ არის მნიშვნელოვანი რამ აქ, რომელიც
ის არის, რომ ჩვენ შევხედავთ ეს ორი ფუნქცია, არსებობს
მხოლოდ ერთი რამ, რომ სხვადასხვა, რომელიც ამ ღირებულების სპექტრი.
ყველაფერი დანარჩენი ამ ორი ფუნქციები, ძალა 3 და ძალა 2,
რომლებიც, ფაქტობრივად, ერთნაირი, რადგან ისინი მუშაობენ იგივე გზით.
>> ასე რომ, ამ ეტაპზე, ცოტა განგაშის ზარი უნდა აპირებს off.
იმედია, თუ რას ამბობდა, თქვენ იცით, რომ ეს გრძნობს ცოტა
ისევე როგორც დუბლირებას ძალისხმევა.
ალბათ არსებობს გზა, რომ მე შეძლებს encapsulate ყველა ამ
და ფუნქცია ან შექმნათ ფუნქცია, რომელიც
ჯერ ზუსტად რა მინდა გარეშე სჭირდება აკრიფოთ ის მკაფიოდ.
და ეს არის ის, რაც ძალა ერთი დახურვის საშუალებას გვაძლევს გავაკეთოთ.
მოდით შევხედოთ ეს.
და მე გაატარონ რამდენიმე წუთი, რადგან ეს
საკმაოდ მნიშვნელოვანია Swift.
ჩვენ ვხედავთ, ეს ყველა დროის.
ჩვენ ვაპირებთ, რომ განსაზღვრავს ფუნქცია.
ის აპირებს ეწოდოს powerOf.
იგი აპირებს მიიღოს პარამეტრი ეწოდება y ტიპის Int.
მაგრამ შევხედოთ დაბრუნების ტიპის.
დაბრუნების ტიპის არის, ფრჩხილებში, ორმაგი ისარი ორმაგი.
რაც იმას ნიშნავს, რომ ამ ფუნქციას, ამ ფუნქციის powerOf,
დაბრუნების ფუნქცია.
ეს იღებს ორმაგი და დაბრუნების ორმაგი.
ასე რომ, შეიძლება გასწავლოთ სახის გიჟები, მაგრამ მოდით გადახვევა ქვემოთ ცოტა
და დაინახოს, რა მოხდება.
ჩვენ შიგნით ამ ფუნქციის powerOf.
ჩვენ ქმნის ახალი ფუნქცია მოუწოდა exponentiator,
მაგრამ ეს არ აქვს მნიშვნელობა, რა არის.
>> გაითვალისწინეთ, რომ ეს შეყვანის ღირებულების x.
და ეს არის აღების ორმაგი და დაბრუნების ორმაგი.
და ეს არის ერთი და იგივე კოდი რომ ჩვენ დაინახა ზემოთ, გარდა იმისა, რომ ღირებულება 2
ან ღირებულება 3, რომელიც ზედა ზღვარი ამ სპექტრი,
უკვე შეცვალა ეს ღირებულება y, რომელიც
იყო თავდაპირველი პარამეტრი ჩვენი powerOf ფუნქცია.
და ამ ეტაპზე, ჩვენ დაბრუნდეს exponentiator.
ჩვენ დაბრუნების ფუნქცია.
>> ეს არის ერთგვარი მოსწონს პატარა გონება აფეთქებით.
მაგრამ წარმოიდგინეთ, რა მოხდება როდესაც მე მოვუწოდებ ამ ფუნქციის powerOf
და გაივლის მას გარკვეული მნიშვნელობა, როგორიცაა 2.
რას ნიშნავს ეს, რომ ახლა აქვს მნიშვნელობა
2 y, რაც იმას ნიშნავს, რომ ეს მნიშვნელობა y ამ exponentiator ფუნქცია
იქნება, რომ ღირებულების 2.
მაგრამ მე დაბრუნების exponentiator ფუნქცია.
>> ასე რომ შეამჩნია რა Swift ამბობს, რომ მე შევქმენით ამ შემთხვევაში.
მიადევნე მოედანზე განმარტება, რომ ეს ფუნქცია, რომელიც იღებს ორმაგი
და დააბრუნებს ორმაგი.
მე შევქმენი ფუნქცია რომ მოედნები რაღაც
ამ მექანიზმის გამოყენებით უფლება აქ.
და მართლაც, რა ხდება, ის, რომ დაბრუნების ფუნქცია
exponentiator, მაგრამ ეს მნიშვნელობა y გახვეული შიგნით მას.
ასე რომ, ახლა ყოველ ჯერზე გამოვიყენო ეს ცვლადი და მუდმივი მოუწოდა
მოედანზე, ეს ის აპირებს უნდა მოიქცეს როგორც ფუნქცია.
ასე რომ, მე მაშინ მოვუწოდებთ, რომ ცვლადი როგორც მე მინდა მოვუწოდო ფუნქცია,
და გაივლის შევიდა რიგი, როგორც ამ შემთხვევაში 3.
და მე მაშინ კვადრატში მნიშვნელობა.
ასე რომ 3 კვადრატი შემდეგ გახდა 9, როგორც ვხედავთ, აქ.
>> მართლაც გიჟები, მაგრამ ეს ახლა საშუალებას იძლევა საშუალებას,
შექმნათ სხვა powerOf ფუნქციები.
ისევე, როგორც მე შემიძლია ვთქვა, OK, ასევე ახლა მინდა რათა შეიქმნას ახალი ფუნქცია, powerOf (3),
და შესანახად, რომელიც შევიდა მუდმივი მოუწოდა კუბი.
ახლა კუბი იქნება ცალკე ფუნქცია, რომელიც შემდეგ
გარკვეული მნიშვნელობა როგორც შეყვანის და კუბი რომ მნიშვნელობა როგორც ვხედავთ, ქვედა ხაზი
აქ.
კუბი 2 აპირებს გამოიწვიოს 8.
>> იმედია საკმაოდ სუფთა პერსონალი.
თქვენ არასოდეს მინახავს ეს ადრე.
მე გარწმუნებთ, რომ შეესწავლათ დახურვა და გამოიძიოს ამ ცოტა მეტი.
ეს მართლაც ძლიერი პერსონალი ჩვენ ვხედავთ ბევრი JavaScript და სხვა ენებზე.
ეს მართლაც მნიშვნელოვანია, რომ გაგება APIs ასევე
რომ ჩვენ კიდევ მხოლოდ მეორე.
დიახ?
>> აუდიტორია: როდესაც თქვენ powerOf (2), ფრჩხილებში, და შემდეგ
სხვა ფრჩხილებში, კიდევ შეყვანის თქვენ ძირითადად შეცვლის მოედანზე.
DAN AMRMENDARIZ: ასე გამოიყურება ძალიან ბოლო ხაზი აქ.
სინამდვილეში ეს არის სრულიად შესაძლებელია გავაკეთოთ, რომ მიჯაჭვის როგორც თქვენ შესთავაზა.
ასე რომ, powerOf (5) ნიშნავს, რომ ჩვენ ვაპირებთ აქვს exponentiator 5 აქ.
ასე რომ, ეს არსებითად იქნება იგივე 4 მეხუთე ძალა,
იმიტომ, რომ ჩვენ შევქმენით exponentiating ფუნქციონირებს მეხუთე ძალა,
და ჩვენ გავლით შევიდა რომ ფუნქციონირებას ღირებულება 4.
და მივიღებთ, რომ ღირებულება რომ ჩვენ ველით, 1024.
აუდიტორია: ეს არ არის ასახელებს, ასე რომ ხდის ადვილია
წავიკითხე, მოედანზე რასაც.
>> DAN AMRMENDARIZ: მარჯვენა, ზუსტად.
ასე რომ, სანამ უბრალოდ განათავსოთ შევიდა მუდმივი აქ ასე
რომ გახადა მარტივი, რომ სახელი.
დიახ?
>> აუდიტორია: ამ კონტექსტში powerOf, ეს ნაწილი
პროგრამირების ენა როგორც ეწინააღმდეგებოდა გზა
ვფიქრობ, powerOf [INAUDIBLE]?
DAN AMRMENDARIZ: ასე რომ, ამ შემთხვევაში, powerOf
უბრალოდ სახელი ფუნქცია, რომ მე განსაზღვრული აქ.
ასე რომ, ეს არ არის დამახასიათებელი ენაზე თავისთავად,
არამედ, ეს, უბრალოდ, ფუნქცია, რომელიც აქვს
ეს სახელი იმიტომ, რომ მე მისთვის, რომ სახელი.
ნებისმიერი სხვა კითხვები?
კარგი.
>> ახლა ეს არის დიდი.
მაგრამ თქვენ არ აპირებს ვხედავ ბევრი დახურვის ფუნქციები, რომელიც
არის მსგავსი, სადაც თქვენ განსაზღვრავს, ქვეყნის შიგნით ერთ-ერთი ფუნქცია, სხვა ფუნქცია.
და თქვენ შეგიძლიათ ამის გაკეთება.
მაგრამ ეს ერთგვარი არა მართლაც აუცილებელია, არა?
მსგავსად რატომ განსაზღვრავს ფუნქცია მოუწოდა exponentiator
და შემდეგ დაუყოვნებლივ დაბრუნება.
რატომ არ შეიძლება უბრალოდ დაუყოვნებლივ დაბრუნდეს ამ ფუნქციას?
>> და სინამდვილეში, ეს არის ზუსტად იდეა უკან კონცეფციის მოუწოდა
ანონიმური ფუნქციები, სადაც ანონიმური ფუნქციები არ რეალურად
აქვს სახელი, რადგან ისინი არ უნდა ერთი.
ასე რომ, ამ შემთხვევაში, 7B, ჩვენ შეგვიძლია ვიპოვოთ ზუსტად რომ.
ეს ყველაფერი იგივე კოდი, ზუსტად იგივე,
მაგრამ ახლა ჩვენ შეიცვალა მას ოდნავ ასე რომ ეს powerOf ფუნქცია დაუყოვნებლივ
ბრუნდება ფუნქცია.
გაითვალისწინეთ, რომ დაბრუნების შემდეგ, არსებობს ღია curly კონსოლი.
ველოდებით ამ შეყვანის ორმაგი.
ველოდებით, რომ გამომავალი ორმაგი.
და შემდეგ სიტყვით ჰყოფს კოდი თავად.
ასე რომ, ეს ანონიმური ფუნქცია.
ეს ფაქტობრივად არ აქვს სახელი, ხოლო ადრე მას ეწოდა exponentiator.
მაგრამ, როგორც დავინახეთ, უბრალოდ მართლა არ ეხება exponentiator
გარეთ რომ ფუნქცია.
ასე რომ, ეს არ აქვს მნიშვნელობა.
ასე რომ, ეს ანონიმური ფუნქცია ე.წ. იმიტომ, რომ ის უსახელო,
მაგრამ ეს ჯერ კიდევ გამოიყენება კონტექსტში ეს კოდი.
>> მომდევნო რამდენიმე პირობა, რომ მე ვარ აპირებს გააგრძელოს იმედია
აფეთქება თქვენი გონება ცოტა.
ჩვენ შეგვიძლია გავამარტივოთ ეს კიდევ უფრო მეტი.
იმის გამო, რომ, როგორც იყო astutely აღვნიშნეთ,
ალბათ, ჩვენ რეალურად ვიცი, inferring ამ კოდი, რაც
გამოშვება ეს კოდი იქნება.
და სინამდვილეში, ამ ანონიმური ფუნქცია, ჩვენ შეიძლება რეალურად კიდე სახის მონაცემები.
>> ასე რომ, ეს ერთი, ჩვენ აღარ უნდა მკაფიოდ განსაზღვრავს
ტიპის მონაცემები, რომ მიმდინარეობს შემავალი და გამომავალი ამ ფუნქციის
რამდენიმე მიზეზის გამო.
ერთი ის, რომ ჩვენ განსაზღვრული, ზე პროტოტიპი შემცველი ფუნქცია,
რა ტიპის მონაცემები ანონიმური ფუნქცია უნდა შემავალი და გამომავალი.
და მეორე, ჩვენ შეიძლება ითქვას, საწყისი კოდი
ქვემოთ აქ, რომ ჩვენ ვიღებთ შეტანის რომ ტიპის ორმაგი
და დაბრუნების ორმაგი.
>> გაითვალისწინეთ, რომ აქ ჩვენ არ გვაქვს მკაფიოდ განისაზღვრება სახელები არგუმენტები
ეს ფუნქცია იღებს.
ასე რომ, ჩვენ ვხედავთ, რომ ჩვენ შეუძლია მიმართოს იმ პარამეტრების გამოყენებით $ 0 $ 1,
ასე შემდეგ და ასე შემდეგ, რაც დამოკიდებულია რაოდენობის, რომ პარამეტრი გამოიყენება
ამ ფუნქციას.
>> ეს არის ის, რომ თქვენ აპირებთ იმისათვის, რომ ნახოთ ბევრი ეს არის ღია curly კონსოლი
განმარტება მოჰყვა $ 0, და შემდეგ რამდენიმე ოპერაცია,
და შემდეგ დახურულ curly კონსოლი.
ეს არის ანონიმური ფუნქცია რომელიც ახორციელებს ამ ოპერაციაში.
მას აქვს ეს პარამეტრი, სადაც ის ტიპის სავარაუდო.
ეს პირველი პარამეტრი არის $ 0.
და ზოგიერთი ოპერაცია ხდება, რომ $ 0.
>> აუდიტორია: ასე დოლარის ნიშანი ნიშნავს პარამეტრი, ძირითადად,
და 0 ნიშნავს პირველი?
DAN Armendáriz: ეს არის სწორი.
ასე რომ, დოლარის ნიშანი ნიშნავს იმას, პარამეტრი და 0 ნიშნავს პირველი.
მაგრამ ეს მუშაობს კონკრეტულად ამ შემთხვევაში, სადაც მე არ დაასახელა
არგუმენტები ჩემი ანონიმური ფუნქცია.
>> აუდიტორია: არა Perl ან რამე აქვს ამ დოლარის ნიშანი დოლარის 0 იქ?
DAN Armendáriz: არა, რომელიც, მე ბოდიში?
აუდიტორია: Perl აქვს ამ დოლარის 0 დოლარის 1--
DAN Armendáriz: მე არ ვარ ძალიან კარგად იცნობს Perl,
მაგრამ PHP, რაც განსაზღვრავს ცვლადები საფუძველზე დოლარის ნიშნები.
და არ შეიძლება იყოს ზოგიერთ ენაზე რომ აქვს ფუნქციები, როგორიცაა ამ.
ფაქტობრივად, Swift სესხულობს ბევრი თვისებები მოსწონს ეს
ბევრი სხვა ენებზე.
ჩვენ ვხედავთ, მინიშნებები Python იგი.
ეს განსაზღვრება ტიპი როგორც ჩანს, მოდის OCaml.
და ჩვენ გვაქვს მხოლოდ მთელი bunch of პერსონალის უამრავი სხვადასხვა ენებზე.
ეს არის ერთ-ერთი ყველაზე ლამაზი რამ Swift
არის ის, რომ იღებს ბევრი საუკეთესო იდეები რამოდენიმე ენაზე
და shoehorns მათ ყველა ერთად ერთ სუპერ ენაზე.
სინამდვილეში, თუ თქვენ ნება მიბოძეთ გაგრძელდება აფეთქება თქვენი გონება,
ასე რომ, ჩვენ უკვე აკეთებს ყველა ამ.
ჩვენ შეგვიძლია ალბათ გაამარტივებს ამ პატარა ცოტა ხვდებიან, რომ, რა თქმა უნდა,
Swift აქვს exponentiating ფუნქცია აგებული.
თუ მე იმპორტი Darwin, რომელიც მხოლოდ ბიბლიოთეკა,
აქვს ეს ფუნქცია მოუწოდა pow, ახლა მე შეიძლება გამარტივდეს ჩემი ძალა ფუნქცია
უნდა იყოს შემდეგ.
იგი აპირებს დაბრუნების ეს ანონიმური ფუნქცია.
>> მაგრამ შეხედეთ როგორ მარტივი ეს არის.
ეს არის ანონიმური ფუნქცია, რომელიც იღებს რაიმე სახის მონაცემები,
და ეს იქნება ერთ-ერთი არგუმენტი, კერძოდ,
დამოწმებული at $ 0 რომ არის ტიპის ორმაგი.
ეს დაბრუნებას აპირებს ტიპის ორმაგი.
მაგრამ დაბრუნების განაცხადი არის დაფარული.
>> და ეს არის ზუსტად ეს სტილი, რომელიც ძალიან, ძალიან გავრცელებული Swift,
მთელი ადგილი.
ჩვენ ვაპირებთ, რომ ეს ყველა დროის Swift.
ასე რომ, მე აჩვენებს ყველა ამ თქვენ, რადგან ეს სინტაქსი.
ეს არის ძალიან გავრცელებული იმისათვის, რომ ნახოთ, რაც იმას ნიშნავს,
ანონიმური ფუნქცია რომ არის საშემსრულებლო
ზოგიერთი ოპერაცია არგუმენტები.
და არ არსებობს ფარული დაბრუნებას.
ასე რომ, ეს არის აბსოლუტურად იგივე ჩვენთვის რომ ვთქვათ, ეს, სწორედ აქ.
>> იმიტომ, რომ ეს curly bracket არის ფუნქცია,
ჩვენ ამ ოპერაციის პირველი არგუმენტი.
ჩვენ ვაპირებთ დაბრუნებას, რომ.
მაგრამ ამ გარე დაბრუნების დაბრუნების რომ მთელი ფუნქცია,
რომ მთელი ანონიმური ფუნქცია რომ ჩვენ მხოლოდ ის.
ნებისმიერი სხვა კითხვები?
ყველა უფლება, მე არ ვიცი, თუ თქვენ ბიჭები არიან მზად,
მაგრამ ჩვენ შეგვიძლია წასვლა კი crazier ერთად Swift.
თქვენ მზად?
OK, ეს არის დიდი.
>> ახლა ჩვენ რეალურად აქვს უნარი რომ, Swift, რადგან, თუ როგორ მოდულარული
და როგორ ოქმის საფუძველზე, ის არის, განსაზღვროს საკუთარი freaking ოპერატორები.
ისევე, როგორც ამ შემთხვევაში, ჩვენ არ გვქონდა ოპერატორი exponentiation-- კარგად,
შესრულების უფლებამოსილების რაღაც.
მაგრამ მე არ შემიძლია, ამ Swift, განსაზღვროს ახალი ოპერატორი, რომელიც აკეთებს ზუსტად რომ.
ასე რომ, ამ შემთხვევაში არ არის რამოდენიმე სინტაქსი აქ.
და მე გაძლევთ საშუალებას შევხედოთ მას სახლში, როდესაც თქვენ შეხედეთ ეს.
მაგრამ ჩვენ განსაზღვრის ამ infix ოპერატორი, **, რომელიც შემდეგ საშუალებას მოგვცემს,
განსაზღვრავს რა, რომ ფუნქცია ** რეალურად
ამჯამად, მიიღოს მარცხენა ხელის მხარეს და მარჯვენა მხარეს,
და შემდეგ დაუბრუნდეს მაჩვენებლებით, რომ მარცხენა მხარეს მარჯვენა მხარეს.
>> ასე რომ, ახლა უეცრად მე შევქმენით ახალი მრიცხველი.
ასე რომ 2 ** 3 იმას ნიშნავს, 2 მესამე ძალა.
[გონება ხმის] ეს მიერ თავად უნდა გააკეთოს თქვენ იყოს,
OK, ხრახნიანი C. მე ვაპირებ Swift ყველა გზა.
დიდებულია.
ეს არის საკმაოდ ფანტასტიური.
>> მიუხედავად იმისა, რომ ეს არის დიდი მაგალითია.
მაგრამ მე არასოდეს ერთხელ გარეთ ამ მაგალითად რეალურად
განსაზღვრული ჩემს ოპერატორს.
მაგრამ მაინც, ეს გვიჩვენებს, ბევრი ძალა Swift
და ამიტომ ეს არის რეალურად მართლაც ძალიან მაგარი.
OK, არა?
აუდიტორია: თუ თქვენ განსაზღვრის საკუთარი ოპერატორი,
როგორ იცით თქვენ არ შემთხვევით ცდილობენ და შექმნას ოპერატორი, რომელიც არის
სადღაც C, როგორიცაა იმალება სადღაც Swift,
როგორც ბუნდოვანი ერთი, რომ თქვენ შეიძლება არ მინახავს ადრე.
>> DAN Armendáriz: ასე რომ, თუ თქვენ ცდილობთ განსაზღვროს საკუთარი ოპერატორები,
არსებობს რისკი განსაზღვრის ერთი ზე არსებული ოპერატორი.
რომ გადადის დონეზე დეტალურად რომ მე არ ვფიქრობ, რომ ჩვენ გვაქვს დრო წასვლა.
მაგრამ ეს არის რისკი.
და ეს არის, ფაქტობრივად, მიზეზი, რის გამოც მე არ გამოიყენოთ caret სიმბოლო, რომელიც
როდესაც ჩვენ აკრეფით გარეთ ძალა, ჩვენ, როგორც წესი, გამოყენება 4 პატარა caret 5 ან რამე
როგორც, რომ, უბრალოდ, როდესაც ჩვენ Gchatting მეგობრებთან ან რასაც.
მაგრამ იმ შემთხვევაში, რომ რეალურად გამოიწვევდა შეჯახება.
ასე რომ, მე თავიდან აცილება მხოლოდ იმიტომ, მე მოხდა ვიცი, ამ შემთხვევაში
, რომ ეს გამოიწვევს, რომ შეჯახება.
>> კარგი.
ახლა სამწუხაროდ, ბოლო შვიდი წუთი,
უნდა შევინარჩუნოთ აფეთქებით თქვენი გონება ცოტა.
ასე რომ, ნება მიბოძეთ გაჩვენებთ ზოგიერთი სხვა რამ, ისევე.
>> ჩვენ გაჩვენეთ ეს იდეა რომელსაც ეს ანონიმური ფუნქციები,
ამ დახურვა, რომელიც საშუალებას გაძლევთ სახის გაივლის ფუნქციები გარშემო.
თქვენ შეგიძლიათ დავუბრუნოთ.
თქვენ შეგიძლიათ მანიპულირება მათ.
ამის გაკეთება შეგიძლიათ ყველა სახის გიჟები პერსონალი.
>> მაგრამ ერთი რამ, რომ ხდება, რომ სასარგებლო
ეს არის უნარი, როგორც ეწინააღმდეგებოდა დაბრუნების იმ ფუნქციებს,
ფუნქცია, უნდა გაიაროს ფუნქცია როგორც პარამეტრი სხვა ფუნქცია.
ალბათ ფიქრობდა, ასევე რატომ დედამიწაზე მინდა რამე მაგდაგვარს?
>> ისე, ვთქვათ, რომ მინდა იმისათვის, რომ ეს ოპერატორი, რომელიც მე
მუშაობდა იმისთვის, რომ შექმნათ და ვრცელდება მას bunch სხვადასხვა ნომრები
მასივი.
ასე რომ, ამ შემთხვევაში მაქვს მასივი integers-- 1, 4, 7, 2, 5, 10, 56.
და მე მინდა, რომ ორმაგი მათ ყველა.
ისე, რომ ჩვენ, როგორც წესი, ამის გაკეთება არის უბრალოდ დაწერა
მარტივი მარყუჟი, რომ iterates მეტი ყველა მათგანი
და შეასრულოს გარკვეული კვადრატული ოპერაცია მათზე,
შესაყვანი იმ ახალი ღირებულებების new ცვლადი, უფრო სწორად, ახალი მასივი აქ.
და ღირებულება გამოშვება შედეგი ის არის, მაშინ ყველა იმ მასივები,
უფრო სწორად ყველა იმ ელემენტები, კვადრატი.
>> და ჩვენ შეგვიძლია გავაკეთოთ იგივე რამ cubing ის,
მაგრამ ცოტა განგაშის ზარი უნდა წახვიდე
განაცხადა, რომ, შესაძლოა, იქ რამდენიმე გზა, რომ ჩვენ გვინდა
შეძლებს გაამარტივებს ამ ცოტა.
და ფაქტობრივად არ არსებობს.
რა მოხდება, თუ ჩვენ შეგვიძლია შევქმნათ ფუნქცია, რომელიც საშუალებას გვაძლევს
მიიღოს, როგორც მტაცებელი, ფუნქცია?
ასე რომ, ამ შემთხვევაში, მიიღოს შევხედოთ ამ არგუმენტები.
ჩვენ ვაპირებთ, რომ მიიღოს სიაში ორჯერ.
და მაშინ ჩვენ ვაპირებთ მიიღოს ფუნქცია
ცვლადში ვ, რომ აპირებს მიიღოს ორმაგი და დააბრუნოს ორმაგი.
და მთელი გამომავალი მთელი ამ ფუნქციის
მოუწოდა mapper აპირებს დაბრუნდება მასივი ეწოდება ორმაგი.
>> რა ეს მაშინ ნება მიბოძეთ არ არის, რომ გადაურბინოთ რომ სიაში
და გავაკეთოთ იგივე, მაგრამ ახლა მიმართოს, რომ ფუნქცია თითოეულ
ინდივიდუალური ღირებულებების, რომ სიაში.
ასე რომ, მე ნამდვილად არ ვიცი, რა f არის.
არ აქვს მნიშვნელობა, ჩემთვის.
მაგრამ სანამ ის იღებს ორმაგი, ასრულებს ზოგიერთი ოპერაციის შესახებ,
და შემდეგ დააბრუნებს ორმაგი, მე მაშინ იქნება
შეუძლია რუკაზე რომ ფუნქცია მასშტაბით თითოეული ელემენტის სიაში.
>> და ამ ტიპის პროგრამირების მოუწოდა რათა უმაღლესი ფუნქციები,
სადაც ჩვენ ავლით ფუნქციები დაახლოებით ისე, როგორც პარამეტრების
და აკეთებს რამ ფუნქციები.
ეს არის ერთგვარი მოსწონს აღების ყველა ამ იდეები, რომ ჩვენ ვისწავლეთ CS50
და გადაჰყავდა სახის საქართველოს მომდევნო დონეზე.
და ეს არის ყველა CS51 სტილი პერსონალი.
ასე რომ, ჩვენ წავიდეთ სიღრმისეული მეტი კატეგორიები, როგორიცაა, რომ.
>> მაგრამ ეს ასევე აქ მნიშვნელოვანია იმიტომ, რომ ჩვენ
ვხედავ ბევრი ფუნქციები რომელიც გამოიყენება Swift
რომელიც არსებითად აკეთებს ამ, სადაც ჩვენ გვაქვს
ზოგიერთი ნომრები, ზოგიერთი მასივი ნომრები.
ჩვენ ვაპირებთ, რომ გაივლის მასივი ჩვენი mapper.
ჩვენ ასევე ვაპირებთ გაივლის რამდენიმე ფუნქცია, რომელიც
ჩვენ უკვე განსაზღვრული აქ.
ეს იქნება მოედანზე.
და ჩვენ ვაპირებთ, რომ მაშინ მოედანზე ყველა იმ ნომრები
და შენახვის, რომ ამ შედეგს აქ.
>> ასე რომ, ამ შემთხვევაში ჩვენ განსაზღვრული ჩვენი საკუთარი ფუნქცია მოუწოდა mapper.
მაგრამ ეს ზუსტად ის არის, ფაქტობრივად, ჩაშენებული Swift.
არსებობს სხვადასხვა ფუნქციები მოუწოდა რუკაზე.
არსებობს რუკა ფუნქცია, არსებობს შემცირება ფუნქცია,
და იქ ფილტრის ფუნქცია, რომელიც არსებითად ვრცელდება ფუნქციები
თითოეული ელემენტის სიაში ცვლილებები მათ რამდენიმე გზა.
>> აუდიტორია: ასე რომ მას შემდეგ, რაც თქვენ გარდაქმნის მონაცემები სხვა ფორმატში
მეშვეობით ფუნქცია
DAN Armendáriz: მარჯვენა.
ჰო, ასე ფუნქცია რომ ჩვენ მიღების
გარდაქმნის მონაცემებს რამდენიმე გზა.
ამ შემთხვევაში, ჩვენ არც squaring ის, ან ჩვენ cubing ის,
ან მართლაც, ჩვენ ვერ ასრულებს არსებობს ოპერაცია საერთოდ.
>> მაგრამ ნება მომეცით მაშინ, თუ როგორ ეს აპირებს გამოიყურებოდეს პრაქტიკაში.
ისევ და ისევ, მე გაშვებული ცოტა დრო. ასე რომ, მე არ ვარ
აპირებს შეძლებს წავიდეთ ყველა კოდის აქ დეტალურად.
მაგრამ მე მოგიწოდებთ თქვენ, რომ.
ჩვენ პოსტი, როგორც კი შესაძლებელია შემდეგ ეს განხილვა.
>> მაგრამ თუ თქვენ შევხედოთ ამ, ვივარაუდოთ, რომ ჩვენ გვაქვს სიაში ნომრები,
მასივი ნომრები ამ ცვლადში ნომრები.
ამის შემდეგ ჩვენ გვინდა, რომ შეასრულოს ეს ფილტრი ოპერაცია იმ ნომრები.
ასე რომ, ფილტრი უმაღლესი იმისათვის, ფუნქცია, რომელიც
ადასტურებს მასივი და ფუნქცია.
და ყოველ ელემენტს, რომ მასივი, იგი ასრულებს, რომ ფუნქცია.
>> იმ შემთხვევაში, თუ ფუნქცია დააბრუნებს მართალია, ის ინარჩუნებს, რომ ნივთი.
იმ შემთხვევაში, თუ ფუნქცია დააბრუნებს false, ის ისვრის შორს რომ ნივთი.
და მაშინ ის დააბრუნებს სია შემდეგ, რომელიც შედგება ყველა
იმ საქონელს, რომ უკვე გაფილტრული.
>> ასე რომ, სხვა სიტყვებით, ეს არის იგივე იდეა, gradebook.
ჩვენ შეიძლება სხვადასხვა შეფასება ამ მნიშვნელობა მოუწოდა ნომრები.
შეიძლება იყოს 100 და 70, და 40, და ასე შემდეგ.
რა ეს ფილტრი არ არის ცნობა რომ ეს არის, რომ სინტაქსური შაქარი
ანონიმური ფუნქცია.
ეს არის ანონიმური ფუნქცია განაცხადა, რომ პარამეტრი, რომელიც მე მიღება
იქნება, თუ იგი უფრო მეტი, ვიდრე 70,
მაშინ ეს დაბრუნდება ნამდვილი, რაც იმას ნიშნავს, რომ რომ ნივთი იქნება დაცული ამ ფილტრი.
მოდით ცოტა უფრო კონკრეტული შესახებ.
თუ მე მაქვს ამ მასივი ნომრები და იგი შედგება 100, 70 და 40,
მე ასრულებს ამ ფილტრი ოპერაციის თითოეული ერთი იმ.
ასე რომ, პირველი ის არის, რომ ეს ღირებულება 100.
100 მეტია ან ტოლია 70 არის ნამდვილი, რომელიც
იმას ნიშნავს, რომ 100 ინახება ახალი ასლი მასივი.
70 ასევე გადის.
მაგრამ 40 არ არის.
ასე რომ, რა ბრუნდება passingCount არის რიგი ელემენტები 100 და 70--
100, მძიმე, 70.
ეს იყო მხოლოდ ორი ნივთები, რომლებიც ინახებოდა.
ასე რომ, იმ მიზეზით, მე სწრაფად გაიარა ბევრი ასეთი მაღალი მიზნით
რამ, რადგან ეს არის ის, რომ საერთო ის, რომ თქვენ ნახავთ Swift საკმაოდ
ხშირად ასრულებს რაიმე ოპერაცია გამოყენებით ამ ანონიმური ფუნქცია სინტაქსი.
>> არსებობს გარკვეული მაგარი რამეები.
კომუტატორები მართლაც ძლიერი Swift, ვგულისხმობ, ისევე, როგორც გიჟები, გიჟები ძლიერი.
თქვენ შეგიძლიათ გამოიყენოთ შეცვლა და თქვენ შეგიძლიათ რეალურად ვრცელდება მათ
მერყეობს, რომელიც სახის გიჟები, და ნუ ლამაზი ნივთები, როგორიცაა, რომ.
>> მაგრამ ბოლო რამდენიმე წუთში, მინდა გამოტოვოთ წინ საკმაოდ შორს
და აჩვენებს, თუ კონკრეტული მაგალითია, თუ როგორ ჩვენ შეგვიძლია შევქმნათ iOS app გამოყენებით Swift.
ასე რომ, როდესაც თქვენ აკეთებთ ამ, თქვენ უნდა მიიღოს
გადავხედავთ Apple- ის დოკუმენტაცია, მათ
აქვს ბევრი ძალიან კარგი გაკვეთილები შექმნა თქვენი პირველი განაცხადი.
და მე გარწმუნებთ, რომ რომ რადგან ისინი
ყველა ნაბიჯები, თუ რა ზუსტად დააწკაპუნეთ შექმნათ iOS განცხადება.
>> მაგრამ აქ ჩვენ გვაქვს ეს iOS app.
და ეს არის საკმაოდ მარტივი app ნამდვილად.
თუ მე აწარმოებს, ნება მომეცით გაჩვენოთ თქვენ რას ჰგავს.
ყველა ეს არსებითად არის ის, გაიყვანს ეხლა ინტერნეტში JSON ფაილი
რომ მე არ ინახება სერვერზე.
და რომ JSON ფაილი განსაზღვრავს სურათები, რომელიც საშუალებას
ჩემთვის მაშინ ციკლი, ჩემი app, სურათები ჩემი სერვერზე.
>> ასე რომ, მე აქ getNextImage.
ეს ტვირთავს გამოსახულება ინტერნეტში, და შემდეგ აჩვენებს ეკრანზე.
>> ასე რომ, ეს არის საკმაოდ მარტივია.
მაგრამ მიზანი არის ის, რომ, როგორც ჩანს თუ როგორ შეგვიძლია გაერთიანდება რამ
ამ უკანასკნელს რამდენიმე კვირის CS50 შევიდა ფაქტობრივი iOS განცხადება.
სხვა სიტყვებით, ალბათ ერთ ერთი რამ, რომ თქვენ გსურთ ამის გაკეთება
გვქონდეს iOS პროგრამა, რომელიც შეგიძლიათ დახევის მონაცემების ინტერნეტით
და დავანახოთ შესახებ გარკვეული ინფორმაცია.
ეს არის მთლიანად წერტილი, ამ კოდის აქ.
>> ასე რომ, არსებობს ბევრი უნდა ითქვას როგორ უნდა გავაკეთოთ ფაქტობრივი iOS განვითარება.
არსებობს ბევრი გიჟები სინტაქსი რომ ჩვენ არ მინახავს საკმაოდ არის
როგორც კლასი, რა დონის რეალურად არის.
ჩვენ შეგვიძლია მეტწილად რომ ამ დროისათვის.
>> მაგრამ შეამჩნია, რომ ჩვენ არ შეიცავდა ამ სხვადასხვა ნივთები
რომ ჩვენ უკვე დავინახეთ, როგორიცაა ფუნქციები, რომელიც კონკრეტული სახელები და გვარები.
და როდესაც ჩვენ მისცეს იმ ფუნქციონირებს სწორი სახელები
რომელიც სავარაუდოდ მიერ iOS, ფაქტობრივად ამ გრძნობს ცოტა ჯადოსნური.
მაგრამ როდესაც თქვენ შექმნით iOS განაცხადის, არ
კონკრეტული ფუნქცია სახელები, ეწოდება თავად ტელეფონი
განაცხადის ჩატვირთვის ცდილობენ შექმნათ პროცესი, რომელიც, ფაქტობრივად,
გადის თქვენი განაცხადი.
ასე რომ კიდევ ერთხელ, იქ არის ბევრი რამ, რომ მე უნდა დაივიწყონ აქ, რათა ჩვენთვის
ვისაუბროთ ამ კონკრეტულად.
მაგრამ მე გარწმუნებთ, რომ შევხედოთ, ალბათ, სხვა iOS სემინარი, არამედ გარკვეული
გაკვეთილები ხაზზე, რომელიც გააკეთებს ბევრად უკეთესი სამუშაო, სადაც აღწერილია
კონკრეტული ინფორმაცია.
>> მაგრამ ჩვენ ვხედავთ, რამდენიმე რამ, რომ საინტერესო საწყისი კოდი აქ.
გაითვალისწინეთ, რომ ჩვენ გვაქვს თუ განცხადებებს.
სხვათა შორის, ერთ-ერთი მნიშვნელოვანი რამ თუ განცხადებები
ის არის, რომ ფრჩხილებში გარშემო ლოგიკური გამოხატვის სურვილისამებრ.
მაგრამ curly აფრთხილებს არ არის პირობითი, არ აქვს მნიშვნელობა, თუ რამდენად ცოტა ან ბევრი ხაზები კოდი
გაქვთ თუ განაცხადი.
თქვენ არ გაქვთ, თუ განცხადებები გარეშე curly აფრთხილებს in Swift.
>> და ეს არის, ასევე, ერთგვარი სულელური.
მაგრამ არსებობს ისტორიული მიზეზების გამო, რომ.
ეს უნდა გადარჩენა თქვენ თავს.
ისევე, როგორც ეს მაგალითად, თქვენ არ შეგიძლიათ აღმოფხვრას curly აფრთხილებს გარშემო, რომ
თუ განცხადებაში.
ისინი, ფაქტობრივად საჭირო.
ასე რომ, მე გარწმუნებთ, რომ შევხედოთ ეს.
მაგრამ არსებობს კიდევ ერთი მშენებლობა, რაც მე მინდა
რომ ნახოთ, თუ შესახებ Swift, რომ არის ახალი Swift 2.0 შედარებით
ძველი ვერსიები Swift, რომელიც შემდეგ.
ვნახოთ, სად მე აქ?
>> ასე რომ, ამ ფუნქციის მოუწოდა fetchJSON, ამ ფუნქციის
პასუხისმგებელია უბიძგებენ, რომ JSON ფაილის მისამართი, რომელიც უბრალოდ ისე ხდება
გაშვებული ჩემს CS50 IDE.
მე უბრალოდ დაიწყო Apache, დააყენა ჩემი JSON ფაილი არსებობს,
და მე შეუძლია შემდეგ გაიყვანოს, რომ მონაცემების ინტერნეტში
ეს ფუნქცია და ამ URL, რომელიც არ არის გათვალისწინებული ტელეფონში.
ეს გათვალისწინებული ბიბლიოთეკა, რომელიც თქვენ იყენებთ, როდესაც
თქვენ აკეთებთ ზოგიერთი iOS app განვითარებას.
>> მიაქციეთ, რომ აქ არ არის ეს არაჩვეულებრივი სინტაქსური შენება მოუწოდა მცველი.
და მართლაც ეს ყველაფერი Swift არის გზა დამადასტურებელი
რომ ზოგიერთი რამ აქვს უკვე შეხვდა, სანამ
გააგრძელოს დანარჩენი ფუნქცია.
ასე რომ, მე შეიძლება, გამოყენებით სურვილისამებრ ტიპის,
მე ვერ იპოვეს URL მიერ გაშვებული ამ NSURL ფუნქცია
და შენახვის, რომ URL, მუდმივი და შემდეგ შემოწმების
იმისათვის, რომ ნახოთ თუ URL იყო ნული, იმიტომ, რომ ეს იყო დაბრუნებას აპირებს სურვილისამებრ ტიპის.
და თუ ეს იყო ნული, მაშინ მე ამობეჭდოთ შეცდომა და შემდეგ დაბრუნდნენ.
>> მაგრამ ამის ნაცვლად, რა მცველი საშუალებას ჩვენთვის არ არის, რომ ძალიან რამ,
მაგრამ, იმისათვის, რომ ეს არის სინამდვილეში საქმე, რომ url
სწორად დადგენილი NSURL.
და თუ ეს ასეა, მაშინ ის ნახტომი მეტი, და ეს
საშუალებას მოგცემთ გაგრძელება url რომელსაც სწორად განსაზღვრული.
მაგრამ თუ ეს საქმე, რომ url არ არის სათანადოდ განსაზღვრული,
თუ ეს ფუნქცია დააბრუნებს შეცდომის ან სხვა გაუთვალისწინებელი რამ
რეალურად ხდება, ეს მცველი მშენებლობა საშუალებას გვაძლევს შემდეგ გამომავალი რომ შეცდომა
და დაბრუნებას დაუყოვნებლივ.
დიახ?
>> აუდიტორია: ასე რომ, ეს სახის მოსწონს თუ მაშინ სხვა?
DAN Armendáriz: ეს არის სახის როგორც თუ მაშინ სხვა, დიახ,
გარდა იმისა, რომ ამ url შემდეგ განსაზღვრულია ქვემოთ ყველაფერი ეს.
თუ გადის ამ მცველი, მაშინ იგი რეალურად ივსება მონაცემების
და გამოსადეგი დარჩენილი კოდის თქვენს ფუნქცია.
ასე რომ, მე ეჭვი მაქვს, რომ თქვენ აპირებს დაიწყება ვხედავთ ამ დაცვის, ასევე.
და მავიწყდება, რომ.
>> ასე რომ მხოლოდ შევხედავთ რამდენიმე სხვა რამ, სწორედ აქ არის ის, რაც
როგორ ფიქრობთ, უბრალოდ რის საფუძველზე ჩვენ ვსაუბრობთ ადრე?
>> აუდიტორია: ვფიქრობ, რომ აწარმოებს სიაში?
>> DAN Armendáriz: ასე რომ ახლოს.
ეს არის ფუნქცია, რომელიც ჩვენ განსაზღვრას.
ჩვენ შესაყვანი, რომ ფუნქცია როგორც არგუმენტი ამ ფუნქციას აქ.
>> აუდიტორია: [INAUDIBLE] თუ არა ნული.
ასე რომ, ეს არის სიაში, უფლება?
>> DAN Armendáriz: თუ შეცდომა არ არის ნული, ასე, რომ არის ამიტომ უნდა გადახვევა.
ისე, ვნახოთ, მე ნამდვილად ვერ გადადით აქ.
შეცდომა არის არგუმენტი, რომ მიმდინარეობს გავიდა ეს ანონიმური ფუნქცია.
ეს არის ანონიმური ფუნქცია.
მას არ აქვს სახელი.
მაგრამ ჩვენ ვიღებთ ამ სამი არგუმენტები, მონაცემები, პასუხი, და შეცდომა.
და ის აპირებს დაბრუნებას ბათილად, ისე, ის არ აპირებს დაბრუნებას არაფერი.
და ეს არის შინაარსი ამ ფუნქციას.
და მაშინ ჩვენ გვაქვს წვდომა შიგნით რომ ფუნქცია, რომ თითოეული ეს არგუმენტები.
>> ასე რომ, ეს ქარიშხალი ტური ენაზე.
მაგრამ იმედი მაქვს, ეს, იმედია, როგორც თქვენ მიიღოს
შევხედოთ ზოგიერთი გაკვეთილები სპეციფიკური iOS განვითარების Swift,
მით უმეტეს, თუ წასვლა Apple- ის დეველოპერი ვებ გვერდზე
მათ აქვთ ბევრი ძალიან კარგი გაკვეთილები მისაღებად თქვენ დაიწყო.
მაგრამ იმედია მხოლოდ ამ საათში საუბარი შესახებ სინტაქსი თავად მისცა
თქვენ საკმარისი უნდა დავიწყოთ, რომ.
>> ჩვენ პოსტი ყველა ამ წყაროს კოდი სემინარზე ნახვა
რაც შეიძლება მალე, და ასევე სლაიდები ასე რომ თქვენ გაქვთ მინიშნება ყველა იმ.
მაგრამ წარმატებებს გისურვებთ თქვენი პროექტები.
და დიდი მადლობა თქვენ ძალიან ბევრი მოდის.
>> [ტაში]