>> [Zenelejátszási]
>> DAN AMRMENDARIZ: Mindenki, Üdvözöljük a CS50 szeminárium,
iOS App Fejlesztési Swift.
Én vagyok Dan Armendariz, és én vagyok tanító a számítógép-tudomány itt a Harvardon.
>> És a következő órában lesz a forgószél túra annyi cuccot
erről a témáról, mint mi elfér.
Én is hozzászólok összes forráskód hogy látni fogja a mai napon az interneten.
Lehet, hogy nem lesz képes valóban megy át mindent
hogy én vagyok, hogy én vagyok amely megmutatja, ebben az órában.
De legalább remélhetőleg keresztül A hozzászólások a forráskód,
Ön képes lesz arra, hogy megpróbálja kitalálni, mit Pontosan történik azokért a dolgokért,
hogy nem elég eljutni.
>> Összességében, a szerkezet a mai vita lesz a következő.
Kezdjük ki csinál néhány alapvető szintaxis a Swift nyelv,
megy néhány fejlettebb szintaxis a Swift nyelven.
Mert a nyelv valóban modern és
van egy csomó magas szintű jellemzők, amikkel nem
látott C-szerte CS50, vagy még néhány más nyelveken
hogy már megkezdődött használja a CS50, mint a PHP,
így fogom meg kell próbálnunk bevezetésére is néhány téma, hogy
kapcsolódnak a magasabb szintű nyelvek hogy nem lehet látni a mélység CS50,
de látni fogja a későbbi számítástechnika osztályok.
Szóval ez lesz a tömje óra.
És ne habozzon hadd tudom, ha bármilyen kérdése van.
Tehát, ha érdekel ennek során fejlesztés
Swift, vagy tényleg minden iOS app fejlesztés,
van egy pár a követelményeknek.
Először is, meg kell használni Mac, fut a példák
hogy mi lesz használva ma, egy viszonylag új verzióját OS
X. Ebben az esetben az X fut 10.5.
Akkor fut 10.11, ha akarod.
De mindent, hogy meg fogsz lásd bevonja Xcode 7 és újabb,
amely a legújabb verzió A Swift, ami Swift 2.0.
Ez valójában egy nagyon Fontos különbséget.
Sok a szintaxis területén megváltozott elég jelentősen
néhány esetben ettől Swift 1.0, amely tavaly jelent meg,
Swift 2.0, amely most jött ki idén ősszel.
Mi is így fogjuk mutatni Swift 2.0.
Egy csomó olyan dolog, hogy keres online
ha akarsz, hogy további információkat a különböző dolgokat,
érdemes lehet kifejezetten keresni Swift 2
ahelyett, hogy csak a jó öreg Swift, hogy arról, hogy Önnek a szintaxis helyes.
>> Tény, hogy ez általában igaz.
Van egy gyors mennyiségű fejlesztési történik a Swift nyelven
Amióta az Apple kiadta, azt hiszem, mi, ez már egy kicsit több mint egy éve
Most.
És minden megváltozott drámaian abban az időben.
És így nem lehet csalódott ha, ha éppen nézett körül
A téma a Swift, vagy hogyan kell elérni valami segítségével néhány példa kód
vagy valami, hogy nem ténylegesen munkát Swift 2.0.
Győződjön meg arról, mit keres a kifejezetten erre a változat
hogy megpróbálja minimalizálni hatása a különböző változatok és azok a dolgok.
>> Megpróbálom kiemelni csak néhány dolog, amelyek különböznek a régebbi verziók.
De ez valami, hogy néz ki.
Ez valószínűleg lesz az egyik legnagyobb fejfájást
hogy lesz a Swift megtalálása Például kódot, ami a régebbi, akár csak
néhány hónap, akarják használni ez a modern projektet.
És ez egyszerűen nem működik.
Kezdesz fordító hibákat, szintaxis hibák, mindenféle őrült dolgot.
Szóval, csak légy türelmes ezt, és remélhetőleg
Van egy nagyon szép élmény Swift összességében.
>> Most már tényleg join-- és remélem, mi még mindig van ez ebben year--
CS 50-es Apple app fejlesztőcsapat, amely
lehetővé teszi, hogy telepíteni alkalmazásokat amely létrehozza az iOS eszközök.
Szóval vessünk egy pillantást az alábbi URL-ha érdekli, hogy ezt tegyük.
>> Szóval csak egy pár dolog Swift magát.
Ez egy összeállított nyelvet.
De látni fogja, hogy bizonyos jellemzője, hogy az általunk használt
Ügyeljünk arra, hogy használni is egy kicsit mint egy értelmezhető módon is.
>> Sok a szintaxis kölcsönzött C. Ez alapján és a C nyelven írt
És így majd meglátjuk, hogy van egy csomó elvitelre
a meglévő ismeretek ettől C, hogy tudjuk port Swift.
>> De vannak dolgok, hogy nagyon különbözik a C.
Ez nagyon erősen típusos.
Van automatikus memória kezelése.
Ugye nem kell majd használja malloc vagy ingyenes bárhol.
Úgy tervezték, az általánosság.
Más szóval, akkor azt mindenféle kontextusban, az Apple Watch
iPhone egészen a OS X, és még néhány szerverek, még néhány script.
De majd meglátjuk, hogy a támogatja a script
Nem igazán van még, mint ez más nyelveken.
Tehát valószínűleg fel fog használni ez kizárólag a fejlesztési
a Mac vagy az iPhone.
>> És van egy csomó modern funkciókat.
És sok ilyen dolog dolog, hogy fogjuk próbálni, hogy kezelni tudja a jelenlegi,
hanem a téma, hogy őszintén, tudjuk szentelni egész tanfolyamok.
Tény, hogy a CS 51, amely a felajánlotta a következő félévben,
összpontosít sokat ezekről a témákról hogy az alábbiakban ismertetjük.
Szóval lehet tölteni egy egész szemesztert megértjük ezeket a dolgokat.
De megyünk próbálni hogy rajtuk keresztül
legalább elég, hogy Megértem, mi
folyik, ha megnézed egy Swift programot
és képesnek kell lennie csapkod az utat rajta keresztül a végleges projekt.
>> Most az egyik legjobb módja, hogy tudsz további kiegészítő információkat kaphat ezen a
őszintén szólva csak az Apple előírt dokumentáció Swift.
Van egy csomó API-k hogy rendelkezésre állnak.
És ez egy jó kiindulópont legyen Ön keresni, konkrét dolog, amit
akarok egy API bevonásával iOS.
Ha szeretné használni a kamerát Például, akkor elkezd keres itt,
és azt is használja a Google és a Stack Túlfolyó a szokásos módon.
>> Kapcsolatos kérdéseket a következő mielőtt ugrani?
Minden rendben.
Menjünk tovább.
>> Tehát először, van egy számú példa fájlokat.
És én fogom próbálni, hogy lemond rajtuk keresztül viszonylag gyorsan.
Ez a Hello World fájl Swift.
Ez nagyon egyszerű.
Van út több hozzászólás mint ahány tényleges kódot.
Figyeljük meg a tényleges kód van a legalján on line 14.
Azt mondja, print.
És akkor ez egy függvényhívás.
Mi megy bele a karakterlánc úgynevezett Helló CS50.
Figyeljük meg, hogy nincs pontosvessző.
Figyeljük meg, hogy nincs int main.
Itt nem a cruft, hogy mi volt a C
Amikor mi használ Swift ezen a módon, amely most írt egy szöveges fájlt
és tárolni a számítógépen, majd Tudom, hogy elkészítse és futtatni.
>> Figyeljük meg, hogy itt vagyok, nem használja a CS50 IDE.
Ez azt feltételezi, hogy én vagyok fut, és hogy én vagyok az OS X,
és hogy én Xcode már telepítve Ezen a gépen ahhoz, hogy ez
hogy ténylegesen funkciót.
De ez csak egy normál szöveges fájl hogy tudunk majd össze és szerkesztheti.
Nézzük, hogy ez hogyan is működik.
Mit tegyünk, ha az összeállításhoz?
swiftc 1.swift.
Miután egy-két pillanat, hogy látni fogja, hogy mi most
összeállított ezt figyelembe nevű fájlt 1.
És most már kinyomtatott mi CS50, a Hello World alkalmazása helyett.
>> Figyeljük meg egy másik dolog is, mint valamint az, hogy alapértelmezés szerint,
mi nem kell bevinnie A / N nyomtatni egy új sort.
Alapértelmezésben a nyomtatási funkció Swift kiírja egy új sort az Ön számára.
Akkor át egy opcionális kiegészítő paramétert, hogy mondja el, hogy ne erre.
De a Google több információt, hogy.
Alapértelmezésben fog tenni a nyomtatási sort.
>> Rendben, menjünk tovább majd néhány más dolog.
Tehát hogyan tudjuk valójában megadott változók?
Tehetünk ez a két módszer egyikével.
És az egyik, hogy azt akarom mondani, mintegy első ez let meghatározását.
És ez fontos mert hatékonyan
mit csinálunk a meghatározó állandó.
Fogunk egy változó, vagy inkább állandó nevű nevet,
biztosítani kell, hogy néhány data-- a Ebben az esetben, a húr Dan.
De ezzel a let kulcsszó, mondjuk
hogy ez változó-- vagy újra constant-- úgynevezett
név nem is fog változtatni kell.
Ez lesz megváltoztathatatlan egész időtartamának ez a program
vagy az egész időtartama összefüggésben
hogy a változó elérhető.
>> Ez nagyon fontos, hogy amikor Van néhány adat, amely nem
változni fog a programban, és látni fogod a különböző példák
mikor akarjuk használni hagyja a másikkal szemben szintaxist,
ezért fontos, hogy használd Amikor csak lehetséges, mert ez nem értesíti
A nyelv, hogy Nem fog változni,
és ez ténylegesen elvégzi Sok optimalizáció
hogy javítsa a sebesség és biztonsága érdekében a programban.
És a biztonság alatt azt értem, nem hagyja, ez összeomlás őrült hibákat
hogy mi lehet megszokta, hogy a C.
>> Akkor tudjuk használni karakterlánc interpoláció hogy magukba ez egy húr.
Tehát láthatjuk, ebben a nyomtatási sort, nyomtassa hello,
majd a backslash nyitott parens, majd a neve a változó,
ebben az esetben állandó, zárja be a zárójelet.
Én alapvetően majd üzembe a tartalmát a változó nevű név
belül a húr, majd nyomtatás eredménye van.
>> Van még egy változás, hogy ezt a fájlt ami az, hogy én, az egyik legfontosabb,
valósult meg a kocsma vonal, amely alapvetően csak pontosítja
hogy szeretném használni a Swift értelmező, amely
azt jelenti, hogy már nem kell lefordítani ezt a különleges programot.
Én is csak futtatni, mint a saját forgatókönyvet.
De ez, ebben az esetben, mögött A színfalak összegyűjtötték, és majd
futtat.
Ez csak láthatatlanok számunkra.
>> Rendben, menjünk tovább.
Szóval van egy kis trükk hogy csak előtt történt.
Megmutattam, hogy én meghatározhatják állandó.
És tudtam, hogy bizonyos adatokat kell csinálni.
De ebben az esetben, észre, hogy én nem ténylegesen meghatározza, hogy milyen típusú adatok
ez az.
És ez azért van, mert a fordító, SWIFT
következtetni, hogy milyen típusú adatok alapján csak az adatokra, hogy tettem bele.
Mert tudja, hogy értékeli ezt változó itt, ez az adat jobb
Itt, mert tudja, hogy ez egy húr.
És így ez az állandó nevet tehát lesz egy string is.
>> De mi is lehet explicit a típus, ami
fogunk használni konstans vagy változó
segítségével ezt a szintaxist instead-- hadd nevét kettőspont karakterlánc megegyezik
Dan, ami ebben az esetben azt jelenti vagyunk fogja meghatározni állandó nevű nevét.
Ez lesz a String.
És az értéke lesz Dan.
Most a másik irányba, hogy mi is létrehozhatunk variables--
és ezek változékony változók, amelyek azt jelenti, hogy mi, sőt, megy
megváltoztatni azok tartalmát valamikor időtartamának összefüggésben
hogy ez a változó defined-- vagyunk Használja a var kulcsszó helyett hadd.
De ismétlem, alapértelmezés szerint, ha nem tudod, hogy meg kell manipulálni az adatokat,
próbálja használni hagyja a teljesítmény növekedéssel.
>> Ebben az esetben, tudok majd adja meg, milyen adatok
hogy elvárjuk, hogy belül a Az új változó nevű címkét.
Ez lesz a húr.
És mi lesz akkor összefűzni két húr együtt, a húr hello,
és a húr által képviselt változó, vagy inkább a konstans neve.
>> Szóval ez jó, mert ez némileg PHP, mint az, hogy mi
nagyon könnyen szövegösszefűzés.
Nem kell, hogy automatikusan Használja bármiféle memória kezelése
méretének növelése és do bármilyen furcsa dolog van.
Ez úgy működik, ahogy azt az elemzők.
>> Rendben, bármilyen kérdése ezzel kapcsolatban?
>> Most a másik oka annak, hogy szükségünk van a képesség,
hogy képes legyen meghatározni, mit típusú adatok változók
azért van, mert néha nem szeretnénk, hogy a változók inicializálása
Néhány adat a pont meghatározása.
Tehát ebben az esetben, mondjuk hogy szeretnék kezdeni megadásával
néhány osztályt egy fokozatú könyvet.
Hát én tudom, hogy az egyik változók, hogy én akarok lenni
lesz egy változékony minőségű.
És azt is tudjuk, hogy mi szeretné, hogy legyen egy egész szám.
De talán még nem Van, hogy a kategória áll rendelkezésre.
>> Ebben Swift, meg kell meghatározzák az adatok típusa
társított egy változó vagy állandó legyen
Mielőtt ténylegesen használni, hogy a változó.
Mivel erősen típusos, meg kell társítani típusú
ezekkel a változókkal.
>> Tehát ebben az esetben, ha már nem megfelelően inicializált az első néhány érték,
akkor azt kell mondanom, hogy mit Swift Elvárom az adatok típusát, hogy legyen.
És ez meg fog maradni Ugyanezen adatok típusa
története során ez a program.
>> Most lehet, hogy a kísértés, amint Én hoztam létre ezt fokozatú változó
és feltéve, hogy az értéke 100, ha most
szeretném kipróbálni, hogy összefűzni A karakterlánc, hogy egész,
Csábító lehet még használni hogy sztring:
mint mi, csak egy pár sort, mielőtt.
De sajnos, ez ténylegesen nem
dolgozni, mert te Lényegében teljesítő
egy művelet két különböző típusú.
>> Most ez nagyon különbözik a többi nyelvek, mint a PHP, amelyek igazán
Loosey goosey azok a fajta típusok.
Olyanok, mint, igen, bármi, engem nem érdekel.
Adj egy típusa, és talán majd a helyes dolgot.
>> Ebben az esetben, Swift a rendkívül szigorú a típusok
hogy van dolga.
Ez összegzése üzemeltető vagy operátor
lényegében egy pár különböző lehetséges opciókat.
Meg tudod csinálni összegzése egész számokkal, vagy
tehetünk szövegösszefűzés, és talán néhány más dolgot is.
De ha ez a vállalkozó nem ismeri mi mindkét oldalán úgy,
vagy inkább a kombináció az említett Két típusú, nem az, ami már várja,
akkor ez lesz a meghibásodást okozhat.
>> Tehát ebben az esetben, mit jelent hogy egy húr, plusz egy egész szám?
Nos összefüggésben ezt, érdemes
hogy nem egy szövegösszefűzés működését.
De természetesen a számítógép Nincsenek hogy a fajta összefüggésben.
És így meg kell, hogy hogy kiegészítő információkat
hogy tudassa, mit az, hogy meg akarjuk csinálni.
>> Más szóval, az a tény, hogy a SWIFT erősen típusos
azt jelenti, hogy nem egy kis kiegészítő munka
hogy ez hogy működik a módja, amit szeretne.
De az eredmény, ez biztonságosabb.
És ha már megteszi véve az ilyen típusú,
dolgok csak őszintén indul hogy a munka elég jól.
>> Tehát ebben az esetben, mi majd lenne végre szövegösszefűzés
által kifejezetten öntés Az egész egy húr
a csomagolás is ebben a tőke S sztring függvény,
majd az szövegösszefűzés üzemeltetőt, hogy módosítsa a kiadónk változó,
majd nyomtassa ki.
>> Eddig jó?
Rendben, menjünk tovább.
>> Most van a különböző adatok típusok, hogy tudjuk használni a Swift.
Ahogy már megszokták, mi is létrehozhatunk egy változékony tömb.
És ez elrendezés csak tartalmaz egyetlen típusát.
>> Tehát ebben az esetben, megyünk létrehozni mutable tömbök egész számok, amelyek
fogjuk hívni a kategóriák, és képesek leszünk tárolni, hogy ebben a szögletes zárójel
formátum ahogy már megszokta hogy a különböző más nyelveken.
De észre, hogy itt vagyunk meghatározó egy-két dolgot.
évfolyamon egy változékony változó-- mi nem használja az let kulcsszó.
Szóval ez azt jelenti, hogy majd módosítani tartalmának ezt a tömböt.
Ez a típus Array Int, és meg tudjuk mondani, hogy
ezek alapján a szögletes zárójelben van.
>> Most az egyik szép dolgokat ez, hogy mi
van, hogy egy csomó további információ
a tömb csak használ Néhány egyszerű dot jelöléssel.
Így például, grades.count nyújt nekünk
a tételek számát, hogy létezik, hogy tömb, ahol tudunk majd elérni, elég
egyszerűen csak használ, hogy pont jelöléssel.
>> Ha azt szeretnénk, hogy adjunk további adatokat ehhez a tömb,
Ön nem tud a PHP stílusban ahol csak kifejezetten meg kell határozni,
egy adott index, néhány érték hogy a beszúrni kívánt.
Ehelyett használja az append módszer a tömb típus
hozzáfűzni, hogy a tétel, 95, ehhez a listához.
>> Tehát most ez a tömb a következő contents-- 100, 0, 90, 85.
És most már csatolt 95, hogy is.
>> Vannak más módon tudunk hozzáfűzni dolgokat.
Ténylegesen használni egy összegzése üzemeltető,
amely kell értelmezni, mint tömb append műveletet.
És akkor majd fűzze a másik tömb, amelynek tartalma 70 és 80,
az, hogy a tömb.
Tehát most már a tartalmát ebben a változó
grades-- 100, 0, 90, 85, 95, 70, és 80.
Ez csak egy szép kis szintaktikai cukor Swift biztosít számunkra.
>> Tehát ha azt akarjuk összefoglalni a évfolyamon, vagy talán mi
szeretne majd ismételget mint minden tétel ebben a hurok.
És mi van, a Swift, az elképzelés, A for ciklus, ahogy az elvárható.
De az is, hogy jelezzük, egy sor némileg eltérő.
Tehát ebben az esetben, hogy Összefoglalva mindent, akkor
fog létrehozni egy ideiglenes nevű változó összeget, hogy a számunkra
hogy fenntartsák ezt a száma.
>> És észre mi az loop építkezés itt.
Mert index 0 .. <grade.count.
Szóval ez a konstrukció, 0 .. <grades.count Egy sor művelet, ahol vagyunk
mondván, hogy fogunk létrehozni egy sor egész számok 0-tól
nagyobb, de grades.count.
Így ez lesz 0, 1, 2, 3, 4, 5, egészen akárhány egy
előtt grades.count.
>> Szóval ez nem más, mint hogy miként jellemzően használt hurkok
ahol van néhány index változó, állítsd 0-val egyenlő az első,
majd integrálni, hogy amíg egy értéke kisebb, mint a gróf tételek
abban a tömbben.
>> Tehát van egy módosítás e, valóban,
amely lehetővé teszi számunkra, hogy nagyon könnyen állítsa különböző tartományokban.
Ha megváltoztatja ezt az intervallumot három pont, 0 ... grade.count,
ez képviseli a tartomány 0 hogy grades.count befogadó,
vagyis ez a szám is majd ebbe a tartományba.
>> De ez nagyon hasznos ezeket pontosan a dolgokat,
amikor már, hogy végre ismétléseket több mint hurok
mert azok indexek nulla indexelt, mint láttuk más nyelveken
is.
Bármilyen kérdésre ez a for ciklus?
>> Szóval van definíciója E mutató változó,
amelynek értéke kezdődik 0, és folytatódik minden iteráció
hogy növekszik 1-ig egy pont amely egyenlő grades.count,
ekkor, a hurok megszakad.
>> Figyeljük meg, hogy a mi húr interpoláció itt,
mi is valójában végezni néhány egyszerű manipulációk azokat az értékeket.
Tehát index plusz 1 ténylegesen végre egy összegzése az értéket
mert index, a Ebben az esetben, egy egész szám.
És ezen a ponton, akkor majd átalakíthatjuk egy string
és interpolált ebbe húr van, és nyomtatható a elvárnánk. .
>> És a szép dolog a tömbök itt
hogy mi is képesek, hogy elbűvölő értékek és a beállítási értékeket
használja a szögletes zárójel jelölő táblázatnak láttunk más nyelveken is.
>> Rendben, tehát innen, most kiszámítja a összege minden kedves fokozat.
Most egyfajta következő logikus lépés lenne,
hogy csinál egy osztás találni ki az átlagos ezeknek az osztályoknak.
De valami fontosat Itt történik, amely
az, hogy ez az összeg talán egy egész szám.
De el kell végezni néhány egyfajta kettős részlege.
És ez lesz rendkívül fontos, amikor
azt akarjuk, hogy végre ezt a műveletet, mert amit mondanak
az, hogy mi kell, hogy ténylegesen végre részlege két páros.
És újra, mert Swift nagyon erősen típusos,
kifejezetten meg kell állítania az összes tételek páros, mielőtt ténylegesen
a művelet elvégzésére.
>> Tehát ahhoz, hogy számunkra, hogy Végezze dupla részlege,
ez nem elegendő csupán egy Ezen elemek is kettős.
Mindkettő kell, hogy a kétágyas annak érdekében, hogy gyors
hogy biztos, hogy ez a az, amit akarok.
Így lesz majd kifejezetten typecast az összeg, amit már fentebb kiszámított
és a gróf a fokozatok a páros, és Ezután a művelet elvégzésére és tárolja
hogy ebbe az új változó, vagy inkább Az új állandó nevű Átlagosan
amely már milyen, tudod képzelni?
Kétágyas, igen.
Tehát ebben az esetben, mi Nem is meg kell adnunk
mert lehet következtetni a működése milyen típusú adatot átlagos
lesz.
És Swift általában elég jó arról szól, hogy képes következtetni a típusok.
>> Szeretné látni ezt futni, vagy tudok lépni?
Azt akarom, hogy folytassam.
Bármilyen kérdésre sem ezt?
Nagy.
>> Most fogunk kezdeni, hogy a A jó stuff-- meghatározó funkciók,
és egy pár más típusú, amelyek egyedi Swift arra, hogy ne
látott más nyelveken eddig a pontig,
de ezek jelen vannak más nyelveken, hogy lehet találni a későbbiekben.
Tehát először, ha azt szeretné, meghatározni egy függvény,
határozná meg a funky szó funkciót, majd a függvény neve,
majd zárójelben, érvek kívánt ezt a funkciót, hogy elfogadja.
Az érveket is specify-- generally--
kell határoznia azt is, hogy milyen típusú adatok azok, hacsak nem lehet következtetni.
És majd meglátjuk, hogy a kis kivétellel csak egy kicsit.
>> Tehát ebben az esetben van egy nevezett funkció printGradeCount.
Megyünk, hogy elfogadja a változó-- vagy inkább ebben az esetben,
Egy constant-- nevű Gradebook.
És ez lesz a írja tömb egész számokat.
Most van valami ez nagyon fontos itt
hogy én akarom, hogy megértsd.
Azaz, hogy alapértelmezés szerint ezek az érvek amelyek bemenetek e funkcióval
meghatározott implicit let kulcsszó, ami azt jelenti, hogy nem tudok módosítani a
Gradebook változó itt.
És ez a fajta van értelme, mert te halad adatokat.
És akkor talán nem akarod meg kell változtatni alól Önnek.
Lehetőség van kifejezetten említi hogy ez egy változó által üzembe
var kulcsszó itt.
De ez egy fontos dolog, amire, hogy már Észrevettem ember volna a múltban
az, hogy azt feltételezték, hogy ez lesz hogy egy változó, amikor valójában, ez
egy konstans.
>> Rendben, akkor itt, ebben az esetben, nem vagyunk mindenféle külön visszatérési típus.
Megmutatjuk, hogyan kell csinálni hogy csak egy pillanatra.
De észre, hogy itt van csak egy egyszerű, ha a feltétel.
Ha a Gradebook van üres, amely ebben az esetben
csak tulajdonát ezt az egész tömb, akkor nyomtassa ki valamit.
Különben valami mást.
>> Elég egyértelmű, amennyiben azt hiszem.
De megállítani, ha bármilyen kérdése van.
>> Most ez a funkció, átlagos, szintén úgy néhány érv, vagy inkább egy érv,
amely a Gradebook, és ezúttal fog visszatérni kettős jellege.
Mert számítási az átlagos és ez
fog ténylegesen visszatér, hogy számított átlagos a hívó vonal.
>> Ebben az esetben azt adja meg az visszatérési típus után egy nyíl.
És ez talán úgy érzi, Elég furcsa az elején.
Már megszokta, a beállítás a visszatérő
írja előtt a funkció neve.
De ha úgy gondolja, ennek tekintve a matematika,
mint akkor, ha a matematika amelyek meghatározzák a funkciót,
Van egy funkció bizonyos bemenetek, és az általa előállított egy kimenetet.
És pontosan ez az, amit ez állítólag utánozza.
És van egy pár más nyelveken amelyek hasonló szintaxist is,
de valószínűleg egyik sem láttad a CS50.
De még mindig nem szabad összekeverni azt.
A nyíl azt jelenti, hogy mi folyik vissza kell ebben az ügyben.
OK, így hogyan fogunk kiszámításához ez az átlag?
Nos, ha a Gradebook üres, majd jól vagyunk
fog visszatérni 0, ami talán ésszerű módon kezelni ezt.
Nem tudom, térjünk vissza, hogy egy kicsit.
Ez valójában nem valószínű ésszerű módon
hogy kiszámolja az átlagos, ha van egy üres Gradebook.
>> Akkor most végre mi összegzése.
Figyeljük meg, hogy itt valójában Van egy másik változata
A hurok, amely lehetővé teszi számunkra, hogy ismételget mint minden egyes darab egy tömbben
és helyezze minden eleme a saját változó.
Megadásával az évfolyamon Gradebook, amit mondanak
az, hogy megyünk implicit hozzon létre egy új állandó úgynevezett
évfolyam hogy fogja képviselni Minden egyedi tárgyat a Gradebook
minden alkalommal, hogy a for ciklus.
Tehát az első alkalom, hogy ez fut, jegye
az első elem a Gradebook.
A második alkalommal ez lesz a második elem, így tovább és így tovább
amíg Gradebook van kifulladt elemek.
Akkor leszünk képesek összefoglalni, hogy évfolyam a mi összegzése változó
és visszatér a mi átlagos mint láttuk korábban.
OK, bármilyen kérdése?
Igen?
Közönség: Két kérdésem van.
Számú, elméletileg lehet futtatja egész ebben egyet?
Nem kell, hogy kettős, igaz?
DAN AMRMENDARIZ: Tud ismételje meg ezt a kérdést?
Közönség: Tehetek egész, mint az átlag?
DAN AMRMENDARIZ: Tud nem egész, mint egy átlagos?
Szóval Ha egész Átlagosan helyett egy dupla?
>> Közönség: Return-- Önnek van, hogy most az alábbiakban.
DAN AMRMENDARIZ: Itt vagyok, visszatér 0.0?
Közönség: Igen, csak vissza 0.
Így lesz ez sem 80 vagy 85, de nem 85,2.
>> DAN AMRMENDARIZ: Tehát ebben az esetben, így van egy pár különböző módon
válaszolni.
Hadd válaszoljak őket sorrendben.
Szóval ha csak, hogy ez a visszatérés 0, egy 0 egész szám értékét.
És így fog okozni típusú hiba ebben az esetben
mert vár egy dupla de aztán visszatért egész.
Ha azt akarom, hogy visszatérjen egész, én is.
Azt lehet állítani a visszatérési típus int, return 0 itt,
és nem hajt végre kettős részlege.
De akkor mi lenne Ennek egész osztás.
És így aztán nem kap a Átlagban, hogy mi lenne esetleg várni.
De igen tudjuk módosítani A típus az említett módon.
>> Közönség: És másodszor, akkor van egy dupla tetején.
De odalent, ha nem tér vissza Kétágyas,
ez már automatikusan visszatérő Dupla formátumban.
Miért is kell definiálni A nyíl a tetején egy dupla?
>> DAN AMRMENDARIZ: Tehát Abban az esetben, ez a rész
A the-- így ismételje meg a kérdést, mert ez implicit a visszatérő
típusok itt, milyen ez valójában van, mi kell explicit Swift
mit akarunk visszatérni ki ezt a funkciót
úgy, hogy amikor elvégzi írja ellenőrzésére, akkor győződjön meg róla,
hogy amit valóban írt lent ténylegesen megfelel-e.
Tehát ez a fajta, mint egy csekket magaddal ilyen helyzetben.
De are--
>> Közönség: [hallható] nyíl?
>> DAN AMRMENDARIZ: Vannak esetek, amikor tudjuk meg, hogy mi lehet implicit
állítsa a visszatérési típus.
De ebben az esetben, én nem úgy gondolja, hogy működni fog.
Van néhány más szintaxist hogy később látni fogjuk.
>> Rendben, így ez a forrás kód egy kicsit más
mert ez értelmezi érvek A funkció, amit hívsz.
Hadd mutassam meg, hogyan működik mielőtt ténylegesen lépni
hogy néhány érdekes dolgot hogy történik Swift.
>> Tehát ebben az esetben, ha én csak futtatni ezt kódot, észreveheti, hogy mit is csinál
is-- közben, ez a fajta ad nekem egy furcsa hibát.
Azt kell, hogy adja át egy pár egészek, mint egy parancssori argumentum.
Tehát lássuk, 150 és 80, és nyomd meg az Entert hogy megtudja, milyen is valójában csinál.
Ez elfogadó minden egyes ezek az értékek egész számok.
Ez bevitelére őket egy Gradebook.
És akkor teljesít, hogy az átlagszámítás
és a kimenetre, hogy ahogy várnánk.
>> De nyilván van valami megy ezzel elutasította valamit
valami olyan egész szám.
Amint lehet előhívni, amikor mi voltunk foglalkozó parancssori paramétereket
C és más nyelveken, a legelső 0-edik elem, hogy a parancssori argumentum
listán a neve a parancsot hogy mi is végeztek.
Tehát ebben az esetben, én csak hurok az egész parancssori paramétereket.
De én nem csinálok semmiféle képzelet ellenőrizze, hogy átugorják, hogy első.
Én csak nyíltan vagy burkoltan vagyok ellenőrzésére, amely az ilyen típusú
egészek mielőtt valóban Ezen számítás végrehajtására.
>> És ez alapvetően mi történik itt.
Minden érv A folyamat érveit,
Megyek végezni néhány ellenőrzést.
És ebben az esetben, megyek hogy megpróbálja első megtért
Ez az érv egy egész által hajt végre közvetlen betűöntő,
mert, a bemenet, egy string és valójában nem egy egész szám.
>> De ez a fajta furcsa szintaxist, Ha hagyja, hogy beosztásnyi Int (érv).
Mi is történik Itt rendkívül
Fontos, hogy a használó Swift.
Ez a mi úgynevezett opcionális típusú.
>> Szóval ezt a funkciót, Int (argumentum), vissza nem csak egész szám azonban visszatér
az úgynevezett opcionális egész.
És így ez a fajta típusú tetején egy típus.
Akkor valami elképzelni, mint ez visszatérő, mint egy csomagot.
És amikor megnyitja hogy csomagot, vagy
van egy egész, ami annak az eredménye, vagy ez egyáltalán semmi nem volt egyáltalán.
És ez hasznos, mint egy hibaellenőrzés mechanizmus, mert ebben az esetben
találunk ki, ez volt típusú átalakítás sikeres?
Ha ez volt, akkor valójában megy, hogy egy egész szám belsejében.
Egyébként ez megy, hogy néhány értéke, hogy fogjuk hívni nulla, ami
reprezentatív nincs egész egyáltalán.
Ez tényleg képviselője sem.
>> És így ez ha az építési lehetővé teszi számunkra, hogy bontsa fel azt a csomagot,
hogy nem kötelező erejű.
És ha képesek vagyunk kicsomagolni, hogy csomagolására és talál egy egész szám belsejében,
akkor azt mondjuk itt az, hogy mi lesz majd
lehetővé teszik, hogy az értéket kell beállítani a ez az állandó nevezett fokozat.
És ez a része az if, A felső része az if
fog futni, mert ez Csomagolja sikeres volt.
>> Ha ez csak azért történik, hogy hiba volt talán
ebben az explicit típus-átalakítás egy húr egy egész, talán
ez az érték az ABC például.
És ez tényleg nem megy átalakítani, hogy egy egész szám.
Aztán visszatér nulla, ami nem egész szám.
És ez a kijelentés is, ha majd sikerül.
évfolyam nem fog létezni, mert nincs egész tartalmat.
És akkor megy ez mást blokk helyett.
Igen?
>> Közönség: Nil N-I-L?
DAN AMRMENDARIZ: nulla N-I-L, igen.
>> Tehát ez talán az egyik legnehezebb dolog a Swift,
különösen akkor, ha te vagy a A gyomok egy iOS app
és te tényleg próbál hogy némi fejlődés is.
Ez lesz kiabált rád mintegy opcionális.
Meg fog kérni, hogy kérdőjelek és felkiáltójelek.
De ha egyszer a out-- ha szenteljen egy kis időt, hogy kitaláljuk,
mi folyik opcionális típusú, akkor mentse magát sok fejfájást
ahogy próbál írj egy app Swift.
>> Ez valójában egy nagyon erőteljes funkció.
És akkor csak meg kell Szavamat adom, hogy most.
De majd meglátjuk ez a konstrukció és mások tetszik
egyes, a másik forráskódot, hogy mi megmutatjuk, mindössze egy kicsit.
>> Vannak-e a kezdeti kérdéseket itt?
Tehát a fontos az, hogy egy elvihető opcionális típusú egyfajta metatype.
Ez akár egy értéket, és ha igen, akkor
talán van, hogy kapcsolódó értéket vele, vagy nincs érték nélkül,
és ez által képviselt nulla.
A többi ezt talán ahogy az elvárható.
>> Úgyhogy futtatják fel a nehézség ismét.
És ezúttal, vessünk egy pillantást néhány más adattípusok, hogy valóban léteznek.
Az egyik a szótárak, amely nagyon hasonlít a Python szótárak.
Ez némileg hasonlít a hash tábla C. Ez lényegében egy feltérképezése kulcsok
ahol a gombok lehet szálakat.
És ha megnézed azokat a kulcsokat, azok a gombok lesz értéke.
Tehát nem elég egy tömbben, hanem ahelyett, szorosabb kapcsolatba
hogy egy hash-térképet, vagy egy hash tábla.
>> Lássuk, hogyan kellene dolgozni, mielőtt ténylegesen
bemegy a forráskódot is.
Ha én csak futtatni ezt, semmi különös nem történik.
Azt mondja nekem, hogy várok néhány paraméter a következő típusú.
Így fogok nyújtani, hogy ez valami probléma beállított nevek,
így pset0, talán van 100.
És pset1, kaptam egy 5.
És akkor a vizsgán, én tette igazán jól, és van 30.
És hoppá, elütöttem egy helyet itt.
>> Mikor nyomja le az Entert, akkor láthatjuk, teljesít néhány számítást.
Azt mondja Gradebook három évfolyamon, pset1, pset0, vizsga.
És a Gradebook van Az egyedi átlag.
Tehát újra, dolgozunk ezzel Gradebook ötlet,
de megyünk tovább iterációjával összetettsége a funkciót.
>> Tehát ha kialakul, mi csak létre fog hozni egy olyan funkciót
felelős nyomtatás használatát.
És itt van ez a kilépési funkció, amely csak
erőszakkal kilép az alkalmazásból.
Ez nem olyan dolog, fogja használni iOS app.
Ez csak, ebben az esetben, egy parancssori argumentum.
Tovább fogjuk kezdeni felé halad Xcode.
De ez kifejezetten egy parancs vonal stílusa program Swift.
>> Vessünk egy pillantást néhány Az érdekes dolog van.
Lássuk, csak egy pár érdekes dolgokat is beszélve talán
az, hogy az én funkciója nyomtatás az évfolyamok száma,
talán felidézni, hogy volt, hogy a listát A items-- pset1, pset0, és vizsga.
Tudod valójában gyorsan és könnyen ezt
azáltal, hogy a Gradebook, amely egy Szótár amely kulcsokat és értékeket.
Keresse meg az összes kulcs segítségével A dot kulcsok módszer van,
majd ezt joinWithSeparator, ami majd elviszi az összes funkció
hogy mi már beírt, pset1-- vagy Sajnálom, pset0, pset1, és exam--
és összefűzni őket egy vessző és szóköz
hogy hozzon létre egy hosszú sora.
Ez csatlakozzon művelet csak tüneményes hasznos a különböző összefüggésekben.
És ez így van ez joinWithSeparator.
>> És ez az egyik dolog, ami változott Swift 1 Swift 2.
Ott szokott lenni Python style-- ha
ismerik Python-- Python stílus csatlakozni módszer húrok.
De ez már nem áll Az eset Swift 2.
Szeretné használni ezt, ha akarod összefűzni egy sor dolgot
együtt egy string.
>> Így talán majd mi tárgyalása előtt átlagosan,
ez teszi egy kicsit több értelme számunkra, hogy állítsa az átlagos funkció
hogy adott esetben kettős inkább mint egy explicit kettős.
Mert mi volt, hogy szokatlan állapot, amelyben,
mi van, ha tényleg Gradebook nincs belüli értékeket is?
Mit kell az átlagos hozam?
>> Nos, talán a C Önnek volna valamit
mint amennyiben egy őrszem érték, mint 0.0, vagy esetleg egy negatív szám,
vagy valami, csak ami a tényt, hogy volt néhány hiba történt
és akkor talán valójában nem is képes kiszámolni, hogy az átlagos.
Nos a szépség megadásával opcionális típusú lenne erre.
És én most azt mondja, ezeket a szavakat, de ez valójában nem használja OPCIÓK.
De majd meglátjuk, hogy csak perc, ahol tudunk állítani átlagos
hogy egy opcionális adatok típusát, hogy ha valóban visszatér egyes adatokat, akkor
térjünk vissza az adatokat.
Ellenkező esetben vissza fogunk térni nulla, mondván, hogy ez
nincs értelmes számítás.
>> Térjünk át valami másra.
Tehát itt, mi már néztem Mindezen példák a parancssorban.
De tényleg, mit fogsz hogy dolgunk Xcode.
És az egyik szép dolog Xcode van, és különösen a Swift,
hogy van ez a nevezett dolog egy játszótér.
És egy játszótér is Egyáltalán nem egy iOS app.
De ez lehetővé teszi, hogy a kísérlet A Swift egy nagyon egyszerű módja.
Akkor írja az összes kódot.
Ez szépen Syntax emeltük ki.
Amikor létrehoz egy új fájlt, akkor kérjen ha azt szeretnénk, hogy hozzon létre egy játszótér.
De a szép dolog a Playground az, hogy a jobb oldalon az ablak,
is jelent ez valójában megmutatja, kimenetét a kódot.
Szóval ha lépjünk le, láthatjuk, hogy mi A termelés különböző sornyi kódot
ténylegesen történetesen.
>> Tehát ebben az esetben, megyünk irányt változtatni csak egy kicsit
és beszélni valamit, ami igazán Fontos, hogy ez a magas szintű utat
hogy Swift működik, és ez Ez a gondolat a lezárások.
És akkor valószínűleg látta ezt egy kicsit a JavaScript.
Azoknak, hogy vannak CS50, bezárások
nagyon népszerű, nagyon jó módja a magas szintű dolgokat a modern nyelvek.
De ez is egyfajta nehéz tekerje a fejét először.
Tehát, ha nézi ezt először, hogy rendben.
Csak nézd meg a forráskódot, és látni ha lehet kitalálni otthon.
>> Tehát ebben az esetben, mondjuk, hogy mi szeretnénk létrehozni egy csomó hatványkitevők
néhány fix érték.
Tehát ebben az esetben tudok létrehozni egy funkciót.
Megyek nevezni ereje 2, melynek egyetlen célja az életben
az, hogy néhány bemeneti és kétágyas azt, és térjen vissza az értéket.
Figyeljük meg, hogy itt vagyok elfogadó egyik típusú adatok.
Ez lesz a változó nevű x.
Ez a típusú kétszemélyes.
És fogok visszatérni egy kétszemélyes itt.
És én csak csinálni nagyon, őszintén szólva, elég
naiv módon, hogy megduplázza ezt az értéket.
És én megmutatom, hogy ez miért Hasznos pillanatok alatt.
>> Figyeljük meg, hogy itt van ez a tartomány már megint. Valami 1, pont
dot dot, 2, ami azt jelenti, hogy Ez a hurok fog futni kétszer.
De ez azt jelenti, dummy változó.
Ez azt jelenti, én nem igazán fog használja a változó sehova
belül ez a hurok.
Csak azt akarom ezt a sort A kód futtatására kétszer,
anélkül, hogy tudni az értéke, hogy a tartományban.
>> Tehát ebben az esetben rohanok eredmény alkalommal kétszer ax, amely lényegében
azt jelenti, hogy én vagyok négyszögesítése ezt az értéket.
És ez történik dolgozni, mint várnánk.
Power of 2, átadva értéke 2.0 ad nekünk egy kimenet 4.
3.2 munkák 10.24.
>> Most nem tehetünk egy hasonló dolog ereje 3.
De most változás csak a tartományban.
Mert dummy változó 1 a 3, szaporodnak 3-szor,
és ugyanezt csinálja.
>> Tehát ez talán egy kicsit kiagyalt.
De van egy fontos dolog itt, amelyek
az, hogy nézi ezeket két funkció, van
csak egy dolog, hogy ez más, amely ezt az értéket a tartományban.
Minden mást a két funkciók, teljesítmény 3 és hatalma 2,
vannak, sőt, azonosak, mert működnek azonos módon.
>> Tehát ezen a ponton, egy kicsit vészcsengő kell megy le.
Remélhetőleg, amit mondasz, Tudod, ez úgy érzi, egy kicsit
mint a párhuzamos tevékenységeket.
Talán van rá mód, hogy én is hogy képes legyen beágyazására mindezt
és egy függvény vagy hozzon létre egy függvényt,
pontosan mit akarok, anélkül szoruló hogy írja ki kifejezetten.
És ez az, amit a hatalom A lezárás lehetővé teszi számunkra, hogy nem.
Szóval vessünk egy pillantást erre.
És én kiad egy pár percet ezen, mert ez a
nagyon fontos a Swift.
Látjuk ezt minden alkalommal.
Fogunk egy függvény definiálása.
Meg fog nevezni powerOf.
Meg fog elfogadni nevű paramétert y típusú Int.
De vessünk egy pillantást a visszatérési típus.
A visszatérési típus, a zárójelben, dupla nyíl Dupla.
Ami azt jelenti, hogy ezt a funkciót, Ez a funkció powerOf,
visszatér a funkciót.
Hogy elfogad egy kétszemélyes és a visszatérő egy duplát.
Tehát, hogy hangzik olyan őrült, de nézzük lépjünk le egy kicsit
és nézd meg, mi történik.
Bent vagyunk ennek a funkciónak powerOf.
Hozunk létre egy új funkció nevű exponentiator,
de ez nem számít, mi az.
>> Figyeljük meg, hogy ennek bemeneti értéke x.
És vesz egy kétszemélyes és a visszatérő egy duplát.
És ez ugyanaz a kód, amit látta fent, kivéve, hogy az értéke 2
vagy a értéke 3, hogy felső határértéket abban a tartományban,
váltotta fel ez az érték az y, amely
volt az első paraméter A mi powerOf funkciót.
És ezen a ponton, mi visszatér exponentiator.
Mi vissza a függvény.
>> Ez olyan, mint egy kis észbontó.
De képzeljük el, mi történik, amikor hívom ezt a funkciót powerOf
és add bele valamilyen érték, mint a 2.
Ez azt jelenti, hogy Én most már az értéke
2 y, ami azt jelenti, hogy ez az érték y e exponentiator funkció
lesz ez az érték 2.
De én ezt vissza exponentiator funkciót.
>> Tehát észre, mi Swift azt mondja, teremtettek ebben az esetben.
hadd tér fogalmának, ez egy függvény, amely elfogadja a Double
és vissza Double.
Létrehoztam egy funkciót hogy négyzetek valamit
Ezzel a mechanizmussal itt.
És tényleg az történik hogy visszatér ez a funkció
exponentiator, de ez az érték y csomagolva belsejébe.
És így most minden alkalommal, amikor használni ezt változó vagy ez az állandó nevezett
négyzet, akkor ez lesz viselkedjen függvényében.
És így tudok majd hívni, hogy a változó mint hívnám függvényében,
és add bele több, mint ebben az esetben 3.
És akkor tér ez az érték.
Tehát 3 a négyzeten majd válnak 9, mint látjuk itt.
>> Tényleg őrült, de ez most lehetővé teszi számomra a lehetőséget
létrehozni más powerOf funkciókat.
Mint azt tudom mondani, OK, nos most szeretnék hogy hozzon létre egy új funkció, powerOf (3),
és tárolja, hogy egy állandó nevű kocka.
És most kocka lesz külön funkció, amely akkor
hogy néhány érték a bemeneti és kocka, hogy értéket látjuk az alsó sorban
itt.
kocka 2 fog eredményezni 8.
>> Remélhetőleg elég ügyes dolgokat.
Még sosem láttam ilyet.
Azt javasoljuk, hogy nézzen a bezárások és vizsgálja meg ezt egy kicsit.
Ez tényleg nagy dolog azt látjuk, sok A JavaScript és néhány más nyelveken.
Ez valóban fontos megértése API-k is
hogy mi lesz pillanatok alatt.
Igen?
>> Közönség: Ha ezt powerOf (2), zárójelben, majd
Egy másik zárójelben, a másik input-- te alapvetően helyett a téren.
DAN AMRMENDARIZ: Így néz a legutolsó sort itt.
Ez valójában teljesen lehetséges Ehhez láncolt ahogy javasolta.
Tehát powerOf (5) azt jelenti, hogy megyünk hogy egy exponentiator 5 itt.
Tehát ez lényegében lesz a ugyanaz, mint 4 az ötödik erő,
mert már létrehozott egy hatványozása működni az ötödik erő,
és mi halad át hogy működik a 4-es érték.
És azt kapjuk, hogy értéket hogy mi várható, 1024.
Közönség: És ez nem egy Íme, így könnyebbé teszi
olvasni, a tér mindegy.
>> DAN AMRMENDARIZ: Jobb, pontosan.
Szóval mielőtt csak tedd egy állandó itt, így
hogy könnyen át lehetett használni ezt a nevet.
Igen?
>> Közönség: Ebben az összefüggésben powerOf, ez része
A programozási nyelv szemben, ahogy
gondolni powerOf az [hallhatatlan]?
DAN AMRMENDARIZ: Tehát Ebben az esetben, powerOf
egyszerűen a neve a funkciót, amit meghatározott ide.
Tehát ez nem jellemző hogy maga a nyelv,
hanem, hogy ez csak egy függvény, amely
ezt a nevet, mert adok neki ezt a nevet.
Más kérdés?
Minden rendben.
>> Most ez nagyszerű.
De nem fogod látni Sok lezárás funkciókat,
mint ez, ahol meghatározhatja, belül Egy funkció, egy másik funkció.
És meg tudod csinálni.
De ez a fajta nem valóban szükséges, nem igaz?
Mint miért határozza meg ezt nevezett funkció exponentiator
majd azonnal vissza.
Miért nem tudok csak közvetlenül vissza ezt a funkciót?
>> És valóban, ez pontosan Az ötlet mögött a koncepció nevezett
névtelen függvényt, ahol névtelen függvények valójában nem
Van egy nevet, mert Nem kell, hogy legyen.
És így ebben az esetben, a 7B, találunk pontosan ezt teszi.
Ez mind ugyanazt a kódot, pontosan ugyanaz a dolog,
de most már megváltozott kissé, így hogy ez a funkció azonnal powerOf
visszaad egy funkciót.
Figyeljük meg, hogy a visszatérés utáni, van egy nyitott zárójel.
Ez vár ez a bemenet Kétágyas.
Ez annak reményében, hogy kimeneti Kétágyas.
És akkor a kulcsszó a elválasztja a kódját.
Tehát ez egy névtelen függvényt.
Ez valójában nem egy név, mivel előtt hívták exponentiator.
De mint láttuk, csak nagyon nem utalt exponentiator
kívül, hogy a funkció.
Tehát ez nem számít.
Tehát ez a névtelen függvény úgynevezett, mert a névtelen,
De ez még mindig használják összefüggésben ezt a kódot.
>> A következő pár is vagyok folytatódni fog remélhetőleg
fúj az agyad egy kicsit.
Mi lehet egyszerűsíteni ez még.
Mert ahogy okosan korábban jelezte,
Talán, akikről tudjuk, a következtetnek arra, hogy ezt a kódot, hogy mit
A kimenő e-kód lesz.
És valóban, ebben a névtelen függvényt, mi is valójában következtetni a típusú adatok.
>> Tehát ebben az egy, már nem kell külön meghatározni
Az adatok típusa, amit most bemeneti és kimeneti ezt a funkciót
egy pár oka.
Az egyik az, hogy már meghatározott, akár a prototípus a befoglaló függvény,
milyen típusú adatot a névtelen funkciót bemeneti és kimeneti.
És a másik, mi arra lehet következtetni a kódot
idelent, hogy fogadunk bemeneti, hogy a típusa Kétágyas
és a visszatérő egy duplát.
>> Figyeljük meg, hogy itt mi nem kifejezetten meghatározta a nevét érvek
hogy ezt a funkciót elfogadja.
És így látjuk mi lehet hivatkozni E paraméterek segítségével $ 0, $ 1,
így tovább és így tovább, attól függően, száma, amely használt paraméter
ebben a funkcióban.
>> Ez olyan dolog, hogy fogsz hogy egy csomó ez nyitott zárójel
meghatározás követte $ 0, majd néhány műveletet,
majd zárt kapcsos zárójel.
Azaz egy névtelen függvényt végzi el ezt a műveletet.
Ennek ez a paraméter, ahol ez a típus kikövetkeztetett.
Ez az első paraméter 0 $.
És néhány művelet történik a $ 0.
>> Közönség: Tehát a dollár jel azt jelenti paraméter alapvetően,
0: az első?
DAN Armendariz: Így van.
Így a dollár jel lényegében azt jelenti, paraméter, és 0: az elsőt.
De működik kifejezetten Ebben az esetben, ha még nem elemzi
Az érvek az én névtelen függvényt.
>> Közönség: Vajon Perl vagy valami van ez a dollár jel, dollár 0 odabent?
DAN Armendariz: Vajon melyik, hogy sajnálom?
Közönség: Vajon Perl van ez a dollárral 0, dollár 1--
DAN Armendariz: Nem vagyok túlságosan is ismerős Perl,
de a PHP mi határozza meg a változók alapuló dollár jeleket.
És lehet, hogy néhány nyelv amelyek funkciók, mint ez.
Tény, Swift kölcsönzi csomó funkciók, mint ez
egy csomó más nyelveken.
Látjuk tippeket a Python benne.
Ez a meghatározás típusú Úgy tűnik, hogy jöjjön a OCaml.
És mi van, csak egy csomó cucc a sok különböző nyelven.
Ez az egyik a szép dolog Swift
hogy tart egy csomó a legjobb ötletek egy csomó nyelvet
és shoehorns őket együtt egyetlen szuper nyelven.
Sőt, ha megengedik, hogy továbbra is fúj a fejedben,
ezért csináltam ezt az egészet.
Mi talán leegyszerűsítik ezt egy kicsit bit felismerve, hogy, természetesen,
Swift egy hatványozása funkciót építettek be.
Ha importálni Darwin, amely csak a könyvtár, amely
funkciók Ezt a funkciót az úgynevezett puff, most Én egyszerűsítheti az erőmet funkció
hogy a következő.
Meg fog visszatérni ez a névtelen függvényt.
>> De nézd meg, milyen egyszerű ez most.
Ez egy névtelen függvény, amely fogad bizonyos típusú adat,
és ez lesz az egyik okfejtést, amely kifejezetten,
jelzőszáma $ 0, hogy a típusa Kétágyas.
Meg fog visszatérni típusú kétszemélyes.
De a return Most implicit.
>> És ez az a stílus, amely pontosan Nagyon, nagyon elterjedt a Swift,
mindenhol.
Fogunk látni ezt minden alkalommal a Swift.
Úgyhogy mutatja mindezt, hogy , mert ennek a szintaxis.
Ez nagyon gyakori látni, ami azt jelenti, hogy
egy névtelen függvényt hogy teljesít
Néhány művelet ezeket az érveket.
És van egy implicit vissza.
Tehát ez teljesen ugyanaz a dolog számunkra, hogy ezt mondom, itt van.
>> Mivel ez a göndör konzol egy olyan funkció,
mi vagyunk a művelet elvégzéséhez Az első érv.
Megyünk vissza, hogy.
De ez a külső visszatérés vissza, hogy az egész funkció,
hogy az egész névtelen függvényt hogy éppen most létrehozott.
Más kérdés?
Rendben, nem tudom, ha srácok készen áll erre,
de mehetünk még őrültebb Swift.
Készen állsz?
OK, ez nagyszerű.
>> Most valóban képesek hogy, a Swift, mert hogyan moduláris
és hogyan protokoll alapú azt jelenti, hogy definiálhatunk saját rohadt szereplők.
Mint ebben az esetben nem volt üzemeltető exponentiation-- is,
elvégzésére hatásköre valamit.
De tudom, a Swift, meg egy új üzemben, amely nem pontosan ezt teszi.
Tehát ebben az esetben van egy csomó szintaxis itt.
És én majd lehetővé teszi, hogy nézd meg otthon, amikor megnézi ezt.
De mi definiáljuk, hogy ez infix üzemeltetője, **, amely majd lehetővé teszi számunkra,
meghatározásával, hogy mi funkció ** ténylegesen
nak, hogy elfogadja a bal oldalon és a jobb oldalon,
majd vissza a kitevő, hogy bal oldali, hogy a jobb oldalon.
>> És így most hirtelen én létrehoztunk egy új számláló.
Tehát 2 ** 3 azt jelenti 2 a köbön.
[Észbontó SOUND] Ez az Maga kell, hogy úgy legyen, mint a,
OK, csavaros C. megyek Swift egészen.
Ez nagyszerű.
Ez elég fantasztikus.
>> Bár ez egy nagyszerű példa.
De egyszer sem kívül Ennek a példának a ténylegesen
meghatározott saját üzemben.
De mégis, ez azt mutatja, Sok a hatalom Swift
és miért ez valójában Tényleg nagyon klassz.
OK, igaz?
Közönség: Ha meghatározó a saját üzemben,
honnan tudod, hogy nem véletlenül próbálj létrehozni egy operátor, ami
A valahol C, mint rejtett valahol Swift,
mint egy homályos egyik, hogy Lehet, hogy nem látott.
>> DAN Armendariz: Szóval, ha akarsz hogy meghatározza a saját gazdasági,
fennáll a veszélye meghatározásának Egy több mint egy meglévő üzemeltető.
Hogy bemegy egy részletességgel, hogy Nem hiszem, hogy van ideje, hogy menjen át.
De ez egy kockázat.
És ez a tény az oka, amiért Én nem használja a kalap szimbólum, amely
amikor írsz a hatalmat, amit általában Használja 4 kis kalap 5 vagy valami
ilyesmi, éppen akkor, amikor mi vagyunk Gchatting bimbózó vagy bármi.
De ebben az esetben, hogy ténylegesen okozott volna az ütközés.
És így elkerülhető, hogy csak azért, mert Azt történt, hogy tudom, ebben az esetben
hogy hogy okozna, hogy az ütközések.
>> Minden rendben.
Most sajnos, az Az elmúlt hét perc,
Meg kell tartani fúj gondolataitokat egy kicsit.
Ezért engedje meg, hogy mutassa meg, néhány más dolgot is.
>> Megmutattuk akkor ez a gondolat a miután ezek a névtelen függvények,
ezek a bezárások, amelyek lehetővé teszik, hogy fajta át funkciók körül.
Akkor vissza őket.
Tudod manipulálni őket.
Meg tudod csinálni mindenféle marhaságot.
>> De egy másik dolog, hogy előfordul, hogy hasznos
az a képesség, hogy, szemben a visszatérő azok a funkciók
egy funkció, hogy adja át a funkciót mint paramétert másik funkció.
Lehet, hogy gondoltam is, hogy miért a Földön akarnék ilyesmit?
>> Nos, mondjuk, hogy szeretnék hogy ez a szolgáltató, hogy én
olyan keményen dolgozott, hogy hozzon létre és alkalmazzon hogy egy csomó különböző számok
egy tömbben.
Tehát ebben az esetben van egy sor integers-- 1, 4, 7, 2, 5, 10, 56.
És azt akarom, hogy megduplázza őket.
Az hogy mi lenne tipikusan csinálni, hogy csak írni
egy egyszerű hurok, hogy megismétli felett mindet
és végre valamiféle négyzet működését felettük,
bevitele ezeket az új értékeket egy új változó, vagy inkább egy új tömböt itt.
És az értéke a kimeneti eredmény akkor az összes ilyen tömbök,
vagy inkább az összes ilyen elemek most négyzeten.
>> És mi is ugyanígy dolog kocka meg,
de egy kicsit vészharangot mennem kell le
mondván, hogy talán van valamilyen módon, hogy mi lenne
képes, hogy egyszerűsítse ezt egy kicsit.
És valójában van.
Mi lenne, ha tudnánk létrehozni hogy a funkció lehetővé teszi számunkra,
elfogadni, mint egy ragadozó, egy funkció?
Tehát ebben az esetben, hogy egy nézd meg ezeket az érveket.
Megyünk, hogy elfogadja a fenti páros.
Aztán megyünk hogy elfogadja a funkciót
a változó nevű f hogy folyik hogy egy kétszemélyes és vissza egy duplát.
És az egész kimeneti A teljes funkció
nevű leképező fog tömböt ad vissza az úgynevezett kettős.
>> Mi ez, akkor engedje meg, hogy tennie, hogy végighaladni, hogy a listát
és nem ugyanaz a dolog, de most alkalmazni, hogy a funkció az egyes
Az egyes értékek ebben a listában.
Szóval nem igazán tudom, mi f.
Nem számít nekem.
De ameddig tart egy kétszemélyes, végez valamilyen műveletet rajta,
majd visszaadja Kétágyas, azt majd lesz
képes leképezni, hogy a funkció szerte minden egyes elemet a listában.
>> És ez a fajta programozás az úgynevezett magasabb rendű funkciókat,
ahol mi vagyunk halad funkciók körül, mint paraméterek
és a dolgokat a funkciókat.
Ez a fajta, mint hogy minden ilyen ötletek, hogy megtanultuk a CS50
és figyelembe őket egyfajta Az, hogy a következő szintre.
És ez mind CS51 stílusú dolgokat.
És így fogunk menni mélyreható Több osztályokban, mint ezt.
>> De ez is Fontos itt, mert
egy csomó funkciók , amelyek használják a Swift
hogy lényegében nem Ennek ahol van
Egyes számok, néhány tömb számokat.
Megyünk át, hogy tömböt a leképező.
És mi is lesz a átadni néhány funkció, amely
mi már definiált itt.
Ez lesz téren.
És mi lesz majd Szögletes Minden ezeket a számokat
és tárolja, hogy ebbe eredmény itt.
>> Tehát ebben az esetben mi már definiáltuk saját nevezett funkció leképező.
De ez a pontos dolog, sőt, beépített Swift.
Vannak különféle funkciókat úgynevezett térképet.
Van egy térkép funkció, van egy csökkentik funkciót,
és van egy szűrő funkció, amely lényegében alkalmazni funkciók
minden egyes eleme egy felsorolni módosítani őket valamilyen módon.
>> Közönség: Szóval mivel átalakítják Az adatok más formátumba
keresztül function--
DAN Armendariz: Így van.
Igen, így a funkció hogy mi elfogadó
átalakítja az adatokat valamilyen módon.
Ebben az esetben, voltunk akár négyszögesítése, vagy mi volt forgatáskor meg,
vagy tényleg, mi is végre Nincs művelet egyáltalán.
>> De hadd mutassam meg, akkor ez hogyan fog nézni a gyakorlatban.
És ismét, rohanok a kis időt. így nem vagyok
lesz képes, hogy menjen át minden A forráskód itt részletesen.
De azt javasoljuk, hogy ezt tegyük.
Tesszük közzé azt, amint követően a lehető ezt a beszédet.
>> De ha megnézzük ezt, fel, hogy van egy lista a számok,
egy sor számok ebben a változó hívott számokat.
Aztán szeretnénk elvégezni ezt Keresés a műveletet az említett számokat.
Tehát szűrő egy magasabb érdekében, hogy a funkció
elfogadja tömb és függvénye is.
És minden eleme, hogy tömbbel, e feladatot ellátja.
>> Ha ez a funkció visszatér Igaz, ez tartja azt az elemet.
Ha ez függvény false, eldobja azt az elemet.
És akkor ad egy listát hogy ezután épül fel minden
Ezen elemek, amelyeket leszűrjük.
>> Tehát egy másik szóval, ez ugyanezt a gondolatot, a Gradebook.
Lehet, hogy a különböző fokozatok ebbe az érték hívott számokat.
Lehet, hogy 100, illetve 70 és 40, így tovább és így tovább.
Mi ez a szűrő nem észrevennünk hogy ez az, hogy a szintaktikus cukor
Egy névtelen függvényt.
Ez egy névtelen függvényt mondván hogy a paraméter, hogy én elfogadva
lesz, ha nagyobb, mint 70,
akkor ez igaz értéket ad vissza, ami azt jelenti, hogy ez az elem fogja tartani ezt a szűrőt.
Úgyhogy egy kicsit konkrétabb erről.
Ha én ezt a tömböt a számok és ez áll a 100, 70, és 40,
Én végre ezt a szűrőt műveletet minden egyes ilyen.
Annak érdekében, hogy első ez az érték 100.
100-nél nagyobb vagy azzal egyenlő 70 Igaz, ami
azt jelenti, hogy a 100 őrzik Az új másolatot a tömb.
70 átadja.
De 40 nem.
Szóval mit ad vissza a passingCount a tömb elemeinek 100 és 70--
100, vessző, 70.
Ezek voltak az egyedüli két tárgyakat, tartották.
És így az ok, amiért gyorsan ment keresztül, egy csomó ilyen fajta magas érdekében
a dolgok, mert ez az, hogy a közös dolog, hogy látni fogja a Swift elég
Gyakran, valamilyen funkciót végez Ezzel a névtelen függvény szintaxisa.
>> Van néhány jó cucc.
A kapcsolók nagyon erős a Swift, Úgy értem, csak, mint egy őrült, őrült erős.
Használhatja kapcsolót, és akkor valóban alkalmazzák őket
a tartományok, ami elég őrült, és nem szép, ilyesmi.
>> De az elmúlt néhány percben, Azt akarom, hogy ugorjon elég messze
és mutassa meg egy konkrét példa arra, hogy mi is létrehozhatunk iOS app segítségével Swift.
Tehát ha csinálsz Ennek akkor van, hogy
egy pillantást at-- az Apple dokumentációban, ezeket
Van egy csomó igazán jó oktató létrehozására az első alkalmazás.
És azt javasoljuk, hogy ezt hogy azért, mert elviszi
az összes lépést, hogy pontosan mi az kattintson létrehozni egy iOS alkalmazás.
>> De itt van ez a iOS app.
És ez egy nagyon egyszerű alkalmazás igazán.
Ha futok ez, hadd mutassam Ön hogyan néz ki.
Minden lényegében nem az, hogy húzza az internetről a JSON fájlban
hogy én a szerveren tárolt.
És hogy JSON fájlok meghatározza a képeket, amelyek lehetővé teszik
nekem akkor lépkedni, az én app, képeket a webszerver.
>> Szóval van itt getNextImage.
Betölti a képet az interneten, majd megjeleníti a képernyőn.
>> Szóval ez elég egyszerű.
De a cél itt az, hogy megmutassa Ön hogyan tudjuk kombinálni a dolgokat
az utóbbi néhány hét CS50 a tényleges iOS alkalmazás.
Más szóval, talán az egyik dolog, amit meg szeretnék csinálni
az, hogy van egy iOS alkalmazás, amely lehet húzni az adatokat a Internet
és mutassuk meg a felhasználó bizonyos információkat.
Ez teljes mértékben a lényeg a forráskód itt.
>> Tehát van egy csomó kell mondani hogyan kell csinálni a tényleges iOS fejlesztés.
Van egy csomó őrült szintaxis hogy nem láttunk még elég
mint egy osztály, amit egy osztály valójában.
Mi lehet figyelmen kívül hagyni nagyrészt hogy egyelőre.
>> De észre, hogy már foglalt ezen belül a különböző dolgokat
hogy már láttuk, mint funkciók, amelyek konkrét neveket.
És amikor azt átadni ezeket funkcionál a helyes neveket
amelyek várhatóan iOS, sőt ez úgy érzi, egy kicsit varázslatos.
De amikor létrehoz egy iOS alkalmazás, ott
specifikus funkciót nevek hívja el magát a telefont
mivel az alkalmazás betöltése próbálni hogy megteremtse a folyamat, amely ténylegesen
fut az alkalmazás.
Tehát megint van egy csomó dolog, hogy én Van elkendőz ide, hogy a számunkra
erről beszélni konkrétan.
De azt javasoljuk, hogy nézd meg talán a másik iOS szeminárium, hanem néhány
Az oktatóanyagok online amely nem sokkal jobb munkát leírására
A konkrét információk.
>> De látjuk egy pár dolog, hogy Érdekes a kódot itt.
Figyeljük meg, hogy mi van, ha kimutatásokat.
Mellesleg, az egyik fontos dolog, ha nyilatkozatok
hogy zárójelbe kell tenni a Logikai kifejezést nem kötelező.
De a kapcsos zárójelek nem kötelező, nem számít, milyen kevés vagy sok sornyi kódot
Van egy if.
Nem lehet egy utasításból anélkül kapcsoszárójele a Swift.
>> És ez, nos, valami buta.
De van történelmi oka van.
Állítólag ez mentheti meg magát.
Ilyenek például, akkor nem megszünteti a kapcsos zárójelek körül, hogy
if.
Azok ugyanis szükség.
Így azt javasoljuk, hogy nézd meg ezt.
De van még egy megépíteni, hogy szeretnék
hogy mutassa meg arról, hogy a Swift az új Swift 2.0 képest
a régebbi verziójú Swift, amely a következő.
Lássuk, hol tettem itt?
>> Tehát ebben a nevezett funkció fetchJSON, ez a funkció
felelős húzás, hogy a JSON fájlt egy URL-t, ami csak azért történik,
hogy fut-e a CS50 IDE.
Én csak most kezdtem Apache, tette a JSON fájlban van,
és képes vagyok húzza, hogy adatokat az internet segítségével
Ezt a funkciót és ezt az URL, amely biztosítja a telefont.
Ez által nyújtott könyvtárat, amit használni
csinálsz néhány iOS app fejlődését.
>> Figyeljük meg, hogy itt van ez a szokatlan szintaktikai konstrukció nevű őr.
És tényleg ez mind a Swift egy módja annak ellenőrzése
hogy bizonyos dolgok teljesültek, mielőtt
folytassa a többi funkció.
Így tudtam volna, a ez opcionális típusú
Én találhatott volna az URL- fut ez NSURL funkció
és tárolása, hogy egy URL konstans, majd ellenőrzése
hogy ha URL nulla volt, mert fog visszatérni opcionális típusú.
És ha ez nulla volt, akkor azt nyomtassa ki a hibát, majd visszatér.
>> De ahelyett, hogy mi őr segítségével ránk az, hogy a dolog,
de annak biztosítása, hogy valójában a helyzet, hogy url
megfelelően lett beállítva a NSURL.
És ha ez, akkor átugorja ezt, és ez
lehetővé teszi, hogy folytassa url miután pontosan határozzák meg.
De ha ez a helyzet, hogy URL nem megfelelő meghatározása,
Ha a függvény hibát vagy más váratlan dolog
igaz, akkor ez az őr konstrukció lehetővé teszi számunkra, hogy majd a kimenetet, hogy hiba
és haladéktalanul térjen vissza.
Igen?
>> Közönség: Szóval ez a fajta A mint egy, ha majd mást?
DAN Armendariz: Elég mint egy, ha majd mást, igen,
kivéve, hogy ezen a cimen van, akkor meghatározott mindent ez alá.
Ha átmegy ez az őr, akkor majd ténylegesen tele adatok
és használható a fennmaradó forrás kódot a funkciót.
Szóval gyanítom, hogy meg fogsz kezdeni, hogy ez az őr is.
És tudatában kell lenniük, hogy.
>> Szóval csak néztem egy pár más dolgokat, ez itt a mi,
Mit gondol, csak az alapján, amit beszéltünk korábban?
>> Közönség: hiszem, hogy lesz futtatni a listán?
>> DAN Armendariz: Szóval ez közel.
Ez a funkció, hogy mi vagyunk meghatározó.
És mi megadásával, hogy a funkció érvként ezt a funkciót itt.
>> Közönség: [hallható], ha nem nulla.
Szóval ez a lista, ugye?
>> DAN Armendariz: Ha a hiba nem nulla, így is-- így kell görgetni.
Nos, lássuk, nem igazán tudok lapozzunk jobbra itt.
Hiba olyan érv, amely folyamatban van átadni ennek a névtelen függvényt.
Ez egy névtelen függvényt.
Nincs neve.
De fogadunk el ezt a három érvek, adatok, válasz, és a hiba.
És ez fog visszatérni nincsen, így ez nem fog visszatérni semmit.
És ez a tartalmát Az, hogy a funkció.
És akkor mi van belül, hogy hozzáférést függvény mindegyik érvet.
>> Szóval ez a forgószél túra a nyelvet.
De remélem, hogy ennek, remélhetőleg, ha megteszik
egy pillantást néhány tutorials jellemző iOS fejlesztés Swift,
különösen, ha elmész Apple fejlesztői web page--
van egy csomó nagyon jó oktatóanyagok a kezdéshez.
De remélhetőleg csak ebben az órájában beszél a szintaxis maga adta
ha elég az induláshoz ezzel.
>> Fogunk elküldeni mindezt forrás kódot a szeminárium honlapján
a lehető leghamarabb, és szintén a tárgylemezeket így van egy hivatkozást mindazoknak.
De sok sikert a projekteket.
És köszönöm mindenkinek szépen jön.
>> [TAPS]