>> [Muziek]
>> DAN AMRMENDARIZ: Iedereen, van harte welkom om de CS50 seminar,
iOS App Development met Swift.
Ik ben Dan Armendariz, en ik ben een leermeester informatica hier op Harvard.
>> En het volgende uur gaat worden een wervelwind tour van zoveel spullen
over dit onderwerp als we kunnen passen.
Ik zal alle van de broncode dat je vandaag zult zien online.
We zouden niet in staat zijn om daadwerkelijk te gaan over alles
dat ben ik, dat ik ben toont u in dit uur.
Maar minstens hopelijk door middel van het commentaar van de broncode,
zul je in staat om te proberen te achterhalen wat precies gebeurt voor die dingen
dat we niet helemaal krijgen.
>> Kortom, de structuur van talk van vandaag ziet er als volgt.
We zullen beginnen te doen een aantal fundamentele syntax met de Swift taal,
gaan in enkele van de meer geavanceerde syntaxis van de Swift taal.
Omdat de taal is echt modern en het
heeft veel hoog niveau kenmerken, dingen die we niet hebben
gezien in C heel CS50, of zelfs een aantal van de andere talen
dat we begonnen met behulp van in CS50 zoals PHP,
dus ik ga moeten proberen om introduceren ook een aantal onderwerpen die
zijn aan hogere programmeertalen dat je niet kunt zien in de diepte in CS50,
maar je zal later zien in informatica klassen.
Dus het gaat om een ​​te zijn opeengepakte uur.
En aarzel niet om me te laten weten als je vragen hebt.
Dus als je geïnteresseerd bent in het doen van de ontwikkeling
met Swift, of eigenlijk elke iOS app ontwikkeling,
er zijn een paar eisen.
Allereerst moet je gebruiken MAC, die in de voorbeelden
dat we gaan worden met behulp van vandaag, een relatief nieuwe versie van OS
X. In dit geval ga ik hardlopen X 10.5.
Je kan worden uitgevoerd 10,11 als je wilt.
Maar alles wat je gaat zie betrekt Xcode 7 en later,
die heeft de nieuwste versie van Swift, dat is Swift 2.0.
Dit is eigenlijk een vrij belangrijk onderscheid.
Een groot deel van de syntaxis vrij sterk veranderd
in sommige gevallen uit Swift 1,0, die vorig jaar werd uitgebracht,
Swift 2,0, waarbij kwam net uit dit najaar.
Dus we gaan Swift 2.0 laten zien.
Veel van de dingen die u zoeken naar online
wanneer je probeert om extra krijgen informatie over een verscheidenheid van dingen,
wilt u misschien expliciet zoeken naar Swift 2
in plaats van gewoon oud Swift te maken ervoor dat je de juiste syntax.
>> In feite is dit algemeen waar.
Er is een snelle hoeveelheid ontwikkeling gebeurt in de Swift taal
Sinds Apple vrijgegeven, denk ik wat, het is een beetje meer dan een jaar
nu.
En dingen zijn veranderd dramatisch in die tijd.
En dus niet worden gefrustreerd of, wanneer u op zoek bent rond
voor onderwerpen op Swift of hoe te bereiken iets met behulp van enkele voorbeeldcode
of iets dat niet eigenlijk werken aan Swift 2.0.
Zorg ervoor dat u op zoek bent specifiek voor die versie
om te proberen om de effecten van de verschillende te minimaliseren versies en dat soort dingen.
>> Ik zal proberen te wijzen op slechts enkele dingen die verschillende oudere versies.
Maar het is iets om op te letten.
Dat is waarschijnlijk gaat worden een van de grootste kopzorgen
dat je zal hebben met de Swift is het vinden Bijvoorbeeld code die ouder is, zelfs alleen
met een paar maanden, probeert te gebruiken het in uw moderne project.
En het gewoon gewoon niet werkt.
Je krijgt compiler fouten, syntax fouten, allerlei gekke dingen.
Dus gewoon geduldig met zijn dat, en je zal hopelijk
hebben een aardige ervaring met Swift algemeen.
>> Nu kun je eigenlijk join-- en ik hoop we eigenlijk nog steeds van dit jaar--
CS 50 Apple app development team, dat
kunt u geen apps installeren die u op uw iOS-apparaten.
Dus neem een ​​kijkje op deze URL als u geïnteresseerd in dat te doen zijn.
>> Dus gewoon een paar dingen over Swift zelf.
Het is een gecompileerde taal.
Maar je zult zien dat sommige van de functies die we gebruiken
Laat het ook gebruikt worden in een beetje geïnterpreteerd als een manier zo goed.
>> Een groot deel van de syntax is geleend van C. Het is gebaseerd en geschreven in C.
En dus zullen we zien dat er zijn een heleboel afhaalrestaurants
vanuit uw bestaande kennis van C dat we kunnen poort Swift.
>> Maar er zijn dingen die maken het zeer verschillend van C.
Het is zeer sterk getypt.
Er is automatisch geheugenbeheer.
Je bent niet van plan te hebben om gebruik malloc of vrij overal.
Het is ontworpen voor algemeenheid.
Dus met andere woorden, kunt u deze gebruiken in allerlei contexten van Apple Watch
iPhone helemaal naar OS X, en zelfs sommige servers, zelfs een aantal scripts.
Maar we zullen zien dat de ondersteuning voor scripting
is er nog niet helemaal als het is in andere talen.
Dus de meeste kans dat u zult gebruiken dit exclusief voor ontwikkeling
op je Mac of iPhone.
>> En het heeft veel moderne elementen.
En veel van deze dingen zijn dingen die we zullen proberen om vandaag aan te pakken,
maar ook onze onderwerpen die eerlijk gezegd, kunnen we volledige cursussen besteden.
In feite, CS 51, die aangeboden volgende semester,
richt zich veel over deze onderwerpen die hieronder worden beschreven.
Dus je kunt een hele semester doorbrengen het begrijpen van deze dingen.
Maar we gaan proberen door hen te krijgen
in ieder geval genoeg dat je kan begrijpen wat
er aan de hand als je kijkt bij een Swift-programma
en in staat zijn om je weg te hacken door middel van het voor het uiteindelijke project.
>> Nu een van de beste manieren waarop u kunt krijgen meer informatie over dit
is eerlijk gezegd alleen door Apple verschaft documentatie voor Swift.
Er is veel van API's die beschikbaar zijn.
En dit is een goede thuisbasis voor u om te zoeken naar specifieke dingen die je
wilt doen met een API met iOS.
Als u de camera wilt gebruiken voor Zo kunt u bijvoorbeeld op zoek gaan naar hier,
en ook gebruik maken van Google en Stack Overloop zoals u gewend bent.
>> Heeft u vragen over dit voordat we springen in?
Prima.
Laten we verder gaan.
>> Dus eerst, ik heb een aantal voorbeeld bestanden.
En ik ga proberen te stappen doorheen relatief snel.
Dit is het bestand Hello World voor Swift.
Het is heel simpel.
Er is veel meer reacties dan zijn eigenlijke code.
Let op de werkelijke code is op de bodem op lijn 14.
Het zegt afdrukken.
En dan is het een functie aan te roepen.
We passeren erin een snaar genoemd Hallo CS50.
Merk op dat er geen puntkomma's.
Merk op dat er geen int main.
Er is geen van de cruft dat we hadden met C.
Als we gebruiken Swift op deze wijze die net in een tekstbestand geschreven
en opgeslagen op mijn computer, dan Ik kan het compileren en voer het uit.
>> Merk op dat ik hier ben niet met behulp van de CS50 IDE.
Dit veronderstelt dat ik hardlopen en dat ik ben op OS X,
en dat heb ik Xcode al geïnstalleerd op deze machine, zodat deze
daadwerkelijk functioneren.
Maar dit is gewoon een normaal tekstbestand dat we dan kunnen samenstellen en bewerken.
Dus laten we zien hoe dit werkt.
Wat als ik wil om het te compileren?
swiftc 1.Swift.
Na een moment of twee, is het zal zien dat we nu hebben
Dit gecompileerd in een bestand genaamd 1.
En nu hebben we onze CS50 gedrukt, onze Hello World applicatie plaats.
>> Merkt een ander ding als goed is dat standaard,
we niet hoefden te voeren a / n om een ​​nieuwe lijn te drukken.
Standaard wordt de printfunctie in Swift zal een nieuwe lijn af te drukken voor u.
U kunt een optionele extra passeren parameter om het te vertellen dat niet te doen.
Maar Google voor meer informatie over dat.
Standaard zal het afdrukken lijn te doen.
>> Oké, dus laten we verder gaan dan sommige andere dingen.
Dus hoe kunnen we eigenlijk variabelen definiëren?
We kunnen dat doen is met behulp van een van twee methoden.
En degene die ik wil je vertellen over eerste is dit laten definitie.
En dit is belangrijk omdat effectief
wat we doen is het definiëren van een constante.
We gaan naar een variabel te maken, of liever een constante genaamd naam
bieden om het aantal data-- in casu de string Dan.
Maar door het gebruik van deze verhuurde trefwoord, zeggen wij
dat deze variable-- of weer constant-- genoemd
naam nooit worden veranderd.
Het gaat om het hele onveranderlijk zijn de duur van dit programma
of gehele duur van de context
dat die variabele beschikbaar is.
>> Dit is echt belangrijk dat wanneer heb je een aantal gegevens die niet
zal veranderen in uw programma, en je zult een aantal voorbeelden te zien
over wanneer we willen gebruiken laat ten opzichte van de andere syntaxis,
het is belangrijk dat u gebruik te laten waar mogelijk, omdat dit Waarschuwt
de taal die het niet zal worden gewijzigd,
en het kan daadwerkelijk uit te voeren veel optimalisaties
de snelheid verbeteren de veiligheid van uw programma.
En door veiligheid, bedoel ik niet laten Het ongeluk met gekke fouten
dat we misschien gewend aan het zien in C.
>> Vervolgens kunnen we snaar interpolatie dit kapselen binnen een tekenreeks.
Dus we kunnen zien in deze afdrukken lijn, print hello,
en vervolgens met behulp backslash geopend Parens, en dan de naam van mijn variabele
in dit geval constant, sluit de haakjes.
Ik ben in wezen dan zetten de De inhoud van deze naam variabele genaamd
binnenzijde van de snaar en afdrukken van het resultaat daar.
>> Er is nog een andere wijziging in dit bestand en dat is dat ik heb, aan de top,
in een keet lijn, die eigenlijk gewoon specificeert
dat ik wil het gebruiken Swift tolk, die
betekent dat ik niet meer dit specifieke programma samen te stellen.
Ik kan alleen nog maar het als zijn eigen script.
Maar dat is in dit geval achter de schermen wordt samengesteld en vervolgens
wordt uitgevoerd.
Het is gewoon voor ons onzichtbaar.
>> Oké, dus laten we verder gaan.
Dus er is een beetje van bedrog die net eerder gebeurd.
Ik liet zien dat ik kan een constante definiëren.
En ik kon een aantal gegevens om het te doen te bieden.
Maar in dit geval, merken dat ik niet eigenlijk geeft u het type gegevens
dat is het.
En dat komt omdat de compiler, Swift kan
afleiden van het type gegevens alleen gebaseerd op de gegevens die ik in het zet.
Omdat het weet dat deze evaluatie variabele hier, deze gegevens te rechts
Hier, het weet dat het een tekenreeks.
En dus is deze constante naam is daarom gaan naar een string te zijn ook.
>> Maar we kunnen ook expliciet zijn van het type dat is
gaan we gebruiken voor constanten of variabelen
door het gebruik van deze syntaxis instead-- Laat naam colon String gelijk
Dan, wat in dit geval betekent dat we gaat om een ​​constante genaamd naam definiëren.
Het gaat van het type String zijn.
En de waarde gaat Dan zijn.
Nu andersom die we kunnen variables-- creëren
en deze zijn veranderlijke variabelen, die betekent dat we in feite gaan
om hun inhoud ergens veranderen de duur van de context
dat die variabele wordt defined-- we gebruik maken van de var trefwoord in plaats van te laten.
Maar nogmaals, standaard, tenzij je weet die je nodig hebt om die gegevens te manipuleren,
probeert te gebruiken verhuurd voor prestatieverbeteringen.
>> In dit geval, kan ik dan specificeert het type gegevens
dat we verwachten dat de binnenkant van deze nieuwe variabele genaamd label.
Het gaat om een ​​string te zijn.
En we gaan dan aaneenschakelen twee strings samen, de string hello,
en de tekenreeks voorgesteld door de variabele, of liever de constantenaam.
>> Dus dit is mooi omdat dit is enigszins PHP als in dat we
hebben zeer gemakkelijk tekenreekssamenvoegingsoperator.
We hebben niet automatisch te Gebruik een soort van memory management
het vergroten en doe een soort van grappige dingen daar.
Dit werkt zoals we eigenlijk zou verwachten.
>> Oké, vragen over dit?
>> Nu de andere reden moeten we u de mogelijkheid
om te kunnen bepalen welke datatype variabelen
is want soms doen we niet willen variabelen initialiseren
enkele data in de punt van de definitie.
Dus in dit geval, laten we zeggen dat wil ik beginnen met het invoeren
sommige kwaliteiten in een klas boek.
Nou ik weet dat een van de variabelen die ik wil zijn
gaat een veranderlijk kwaliteit zijn.
En we weten ook dat we wil dat het een integer zijn.
Maar toch misschien doen we niet hebben die rang beschikbaar.
>> In Swift, moet je definieert het type gegevens
die is gekoppeld aan een variabele of een laat constante
voordat je kan eigenlijk gebruiken variabele.
Omdat het sterk getypt, je moet een soort associëren
deze variabelen.
>> Dus in dit geval, als ik heb niet goed geïnitialiseerd de eerste met een bepaalde waarde,
dan moet ik zeggen wat Swift Ik verwacht dat de data type te zijn.
En het gaat om te blijven hetzelfde gegevenstype
in de geschiedenis van dit programma.
>> Nu zou je zo snel in de verleiding Ik heb dit cijfer variabele gecreëerd
en op voorwaarde dat het een geheel getal van 100, nu als ik
willen proberen om aaneenschakelen een string met die integer,
misschien geneigd om nog te gebruiken die string samenvoegingsoperator
alsof we slechts een paar regels voor.
Maar helaas, zal dit eigenlijk niet
werken, want je bent wezen uitvoeren
een bewerking van twee verschillende types.
>> Nu is deze zeer verschillend van andere talen zoals PHP, die zijn echt
loosey goosey met hun soort types.
Ze zijn net als, ja, wat dan ook, kan me niet schelen.
Geef me een type, en misschien zal ik het juiste te doen.
>> In dit geval is Swift zeer streng over de soorten
dat u te maken met.
Deze sommatie exploitant of samenvoegingsoperator
in wezen een paar verschillende mogelijke opties.
U kunt sommatie doen met getallen, of u
kan tekenreekssamenvoegingsoperator doen, en misschien een aantal andere dingen.
Maar als dat de exploitant niet herkent wat op weerszijden daarvan,
of liever de combinatie van deze twee soorten, is niet wat het verwacht,
dan dat het gaat om een ​​storing veroorzaken.
>> Dus in dit geval, wat betekent het om een ​​string plus een integer hebben?
Welnu, in het kader van deze, waarschijnlijk willen we
een tekenreekssamenvoegingsoperator operatie te doen.
Maar natuurlijk de computer niet hebben dat soort van context.
En dus moeten we bieden dat aanvullende informatie
te laten weten wat het is dat we willen doen.
>> Met andere woorden, het feit dat Swift sterk getypt
betekent dat je moet een doen beetje extra werk
om het te krijgen om de werken manier die je zou willen.
Maar als gevolg, is het veiliger.
En als je eenmaal te nemen houdend met die types,
dingen gewoon eerlijk beginnen vrij goed te werken.
>> Dus in dit geval, dan zouden we voeren tekenreekssamenvoegingsoperator
door expliciet gieten de integer naar een string
door verpakken in deze hoofdletter S String functie,
en vervolgens met behulp van de tekenreekssamenvoegingsoperator operator om ons label variabele wijzigen,
en print het uit.
>> Tot dusver, zo goed?
Oké, laten we verder gaan.
>> Nu zijn er diverse data soorten die we kunnen gebruiken in Swift.
Zoals jullie gewend zijn geraakt aan, kunnen we een veranderlijk array te maken.
En die array kan alleen bevat een enkel type.
>> Dus in dit geval, gaan we creëren een veranderlijk arrays van integers, die
we zullen kwaliteiten noemen, en we in staat zullen zijn op te slaan die in dit plein beugel
formaat als u gewend geraakt De in diverse andere talen.
Maar merken dat we hier zijn definiëren van een paar dingen.
rangen is een veranderlijk variable-- we geen gebruik van de laat trefwoord.
Dus dat betekent dat we dan kunnen wijzigen de inhoud van deze array.
Het is van het type Array Int, en we kunnen vertellen dat
op basis van deze vierkante haken here.
>> Nu is een van de leuke dingen hiervan is dat we
hebben toegang tot een veel Extra informatie
over de array alleen met behulp enkele eenvoudige puntnotatie.
Dus bijvoorbeeld, grades.count biedt ons
het aantal items die bestaan ​​in dat array, die we vervolgens toegang vrij
eenvoudig eenvoudig met behulp van die puntnotatie.
>> Als u meer wilt toevoegen items op deze array,
kunt u de PHP-stijl niet waar je gewoon expliciet te definiëren,
bij een bepaalde index, wat waarde dat u wilt invoegen.
Gebruik in plaats daarvan de append werkwijze het matrixtype
op die post, 95 toevoegen, aan deze lijst.
>> Dus nu deze array heeft de volgende contents-- 100, 0, 90, 85.
En nu hebben we toegevoegd 95 dat ook.
>> Er zijn andere manieren kunnen we de dingen toevoegen.
Je kunt eigenlijk gebruiken een sommatie-operator,
die zal worden geïnterpreteerd als een scala append operatie.
En u kunt dan nog toevoegen matrix, waarvan de inhoud 70 en 80,
die matrix.
Dus nu hebben we de inhoud van deze variabele
grades-- 100, 0, 90, 85, 95, 70, en 80.
Dit is gewoon een leuke kleine syntactische suiker die Swift biedt voor ons.
>> Dus als we willen de som kwaliteiten, we zijn misschien
gaat te willen herhalen op elk punt in deze lus.
En we hebben, in Swift, de notie van een lus zoals je zou verwachten.
Maar de manier waarop we aanduiden een bereik is iets anders.
Dus in dit geval, Kortom alles, zullen we
gaat om een ​​tijdelijke maken variabele genoemd bedrag in orde voor ons
deze telling handhaven.
>> En let ons voor lus constructie hier.
Voor index 0 .. <grade.count.
Dus deze constructie, 0 .. <grades.count is een range bedrijf waar we zijn
zeggen dat we gaan creëren een bereik van gehele getallen van 0 tot
om maar exclusief grades.count.
Zo zal dit 0, 1, 2, 3, 4, 5, tot maar velen
voordat grades.count.
>> Dit is dus anders dan hoe we zou doorgaans voor loops
waar u enkele index zou hebben variabele, stel deze gelijk is aan 0 op het eerste,
en integreren dan is dat tot enkele waarde lager dan het aantal items
in die array.
>> Dus er is een modificatie dit eigenlijk
die ons in staat stelt om heel gemakkelijk set verschillende reeksen.
Als je dit bereik te veranderen drie puntjes, 0 ... grade.count,
Dit vertegenwoordigt het bereik van 0 om grades.count inclusive,
betekent dat dat nummer ook vervolgens opgenomen in dat bereik.
>> Maar dit is erg handig deze exacte dingen,
wanneer we moeten presteren iteraties dan loop
omdat die indexen nul geïndexeerd, zoals we hebben gezien in andere talen
ook.
Voor vragen over deze lus?
>> Dus er is impliciete definitie deze index variabele
waarvan de waarde begint bij 0 en blijft bij elke lus iteratie
te verhogen met 1 tot op een punt dat is gelijk aan grades.count,
op welk punt, de lus afgebroken.
>> Merk op dat in onze reeks interpolatie hier,
kunnen we eigenlijk voeren enkele eenvoudige manipulaties die waarden.
Dus index plus 1 ook daadwerkelijk het uitvoeren van een optelling van die waarde
omdat index naar dit geval een geheel getal.
En op dat moment, het zal vervolgens worden omgezet in een string
en geïnterpoleerd in deze string hier, en afgedrukt als we zouden verwachten. .
>> En het leuke de arrays hier
dat wij ook in staat om ophalen waarden en instelwaarden
met behulp van het plein haakjesnotering als we hebben gezien in andere talen.
>> Oké, zo van hier, nu zijn we berekenen onze som van al onze kwaliteiten.
Nu soort van de volgende logische stap zou zijn
om een ​​deling te doen om uit te vinden het gemiddelde van deze cijfers.
Maar iets belangrijks hier gebeurt die
dat dit bedrag misschien een integer.
Maar we moeten een aantal uit te voeren soort van dubbele divisie.
En dit gaat worden uiterst belangrijk wanneer
we willen deze operatie uit te voeren, want wat we zeggen
is dat we nodig hebben om daadwerkelijk voeren divisie op twee doubles.
En nogmaals, omdat Swift is sterk getypt,
We moeten expliciet alle vastgestelde items om doubles voordat we eigenlijk
voeren die operatie.
>> Dus om voor ons te voeren dubbele divisie,
het is niet voldoende voor slechts een van deze items zijn een double.
Beiden hebben een te zijn dubbele opdat swift
om zeker te zijn dat dit is wat we willen doen.
Dus we zullen dan expliciet typecast de som die we hierboven hebben berekend
en de telling van de rangen te dubbelen, en voer dat de werking en op te slaan
dat in deze nieuwe variabele, of liever Deze nieuwe constante genaamd gemiddeld
die zullen moeten wat voor soort, je je voorstellen?
Dubbel, ja.
Dus in dit geval, we niet hoeft te specificeren
omdat het kan worden afgeleid uit de bediening wat voor soort data gemiddelde
zal zijn.
En Swift is over het algemeen vrij goed over de mogelijkheid om de types afleiden.
>> Wilt u dit te zien lopen, of kan ik verder gaan?
Ik wil om door te gaan.
Heeft u vragen over een van deze?
Grote.
>> Nu gaan we om te beginnen te bereiken de goede stuff-- definiëren functies,
en een paar andere soorten die zijn uniek voor Swift dat u niet
gezien in andere talen tot op dit punt,
maar zij aanwezig zijn in andere talen die je later zou kunnen vinden.
Dus eerst als je wilt definiëren van een functie,
definieer je het met het funky woord functie, en dan de naam van de functie,
en daarna tussen haakjes, de argumenten dat u wilt dat de functie te aanvaarden.
De argumenten moeten ook specify-- generally--
moet het type gegevens aangeven dat zij zijn, tenzij ze kunnen worden afgeleid.
En we zullen dat er weinig te zien waarschuwing in slechts een klein beetje.
>> Dus in dit geval hebben we een functie genaamd printGradeCount.
We gaan naar een accepteren variable-- of liever in casu
een constant-- genaamd cijferlijst.
En het gaat te zijn typt array van integers.
Nu is er iets dat is echt belangrijk hier
dat ik wil dat je begrijpt.
Dat is dat de standaard, deze argumenten dat zijn input voor deze functie worden
gedefinieerd met een impliciete laat trefwoord, wat betekent dat ik dit niet kan wijzigen
cijferlijst variabele hier.
En dat soort zinvol, omdat je het passeren van gegevens in.
En je misschien niet wilt te worden veranderd onder je.
Het is mogelijk om expliciet te vermelden dat dit een variabel door de invoering
de var trefwoord hier.
Maar dat is een gotcha dat we hebben merkten mensen hebben gedaan in het verleden
is dat ze aangenomen dat het gaat een variabele wanneer, in feite
een constante is.
>> Oké, dus even dan, in dit geval, we zijn niet het opgeven van elk type return.
Wij laten u zien hoe dat te doen dat in slechts een moment.
Maar merken dat we hier hebben gewoon een simpele als voorwaarde.
Als de cijferlijst is lege, die in dit geval
is slechts het bezit van deze integer array, dan printen we iets.
Anders iets anders doen we.
>> Vrij eenvoudig tot nu toe denk ik.
Maar stop me als je vragen hebt.
>> Nu deze functie, gemiddelde, neemt ook sommige argumenten, of liever één argument,
dat is de cijferlijst, en deze keer gaat om een ​​dubbele soort terugkeren.
Omdat het berekenen het gemiddelde en het
gaat eigenlijk terug dat berekende gemiddelde van de oproepende lijn.
>> In dit geval geven wij de terug soort na een pijl.
En dit zou voelen beetje vreemd op het eerste.
Je hebt gewend gegroeid het instellen van de terugkeer
Typ voor de naam van de functie.
Maar als je van deze op het gebied van wiskunde,
zoals wanneer je wiskunde die een functie definieert,
u een functie met een aantal hebben inputs en produceert een output.
En dat is precies wat Dit wordt verondersteld te bootsen.
En er zijn een paar andere talen die hebben soortgelijke syntax als goed,
maar waarschijnlijk niemand die je hebt gezien in de CS50.
Maar nog steeds niet worden verward door het.
De pijl geeft aan wat er gaande is te worden geretourneerd in dit geval.
OK, dus hoe gaan we om dit gemiddelde te berekenen?
Nou, als de cijferlijst leeg is, nou dan zijn we
gaat die misschien terug 0, een redelijke manier om dit te behandelen.
Ik weet het niet, laten we komen terug naar die in een klein beetje.
Dit is misschien niet echt zijn een redelijke manier
gemiddeld indien berekenen we hebben een lege cijferlijst.
>> Dan zullen we alleen het uitvoeren van onze sommatie.
Merk op dat we hier eigenlijk een alternatieve versie van een
lus, waardoor we herhalen over elke enkel item in een array
en leg elk element tot zijn variabel.
Onder vermelding van rang cijferlijst, wat we zeggen
is dat we gaan impliciet maak een nieuwe constante genaamd
kwaliteit dat gaat vertegenwoordigen elk uniek punt in de cijferlijst
elke keer dat de lus herhaalt.
Dus de eerste keer dat Het wordt gerund, rang zal
zijn het eerste item in de cijferlijst.
De tweede keer dat het zal de tweede punt, enzovoort, enzovoort
tot cijferlijst heeft zelf uitgeput van elementen.
Dan zullen we in staat zijn om dat te vatten graad in onze sommatie variabele
en terug te keren onze gemiddelde zoals we eerder hebben gezien.
OK, nog vragen?
Ja?
Publiek: Ik heb twee vragen.
Nummer één, hypothetisch, kan je integer draaien op deze?
Hoeft niet te zijn een dubbel, is dat juist?
DAN AMRMENDARIZ: Kunt u herhalen die vraag?
Publiek: Kan ik integer als het gemiddelde?
DAN AMRMENDARIZ: Kunt u doen integer als een gemiddelde?
Dus terug een integer gemiddelde in plaats van een dubbele?
>> Publiek: Return-- u dat recht nu hieronder.
DAN AMRMENDARIZ: Right here, terug 0.0?
Publiek: Ja, gewoon terug 0.
Zo zal ofwel 80 of 85, maar 85,2.
>> DAN AMRMENDARIZ: Dus in dat geval, dus er is een paar verschillende manieren
te beantwoorden.
Laat me ze te beantwoorden in orde.
Dus als ik alleen deze terugkeer 0, een 0 is een geheel getal.
En dus dat zal leiden tot een het type fout in dit geval
omdat het verwacht een double maar dan terug een integer.
Als ik wil een integer terug, dat kan ik.
Ik kan het type return instellen naar int, hier terugkeren 0,
en niet uit te voeren dubbele divisie.
Maar dan zouden we zijn doet integer divisie.
En zo zouden we dan niet de gemiddelde dat we misschien zou verwachten.
Maar ja we kunnen wijzigen de soorten op die manier.
>> Publiek: En ten tweede, je hebben een dubbel aan de bovenkant.
Maar beneden, als je doen terugkeren Double Double,
dat is al automatisch terugkerende Double-formaat.
Waarom heb je nog nodig hebt om het te definiëren met pijl op de top met een dubbele?
>> DAN AMRMENDARIZ: So in geval dit onderdeel
van the-- dus om de vraag te herhalen, omdat het impliciete van de terugkeer
types hier, wat voor soort dit eigenlijk is, moeten we expliciet met Swift te zijn
over wat we willen terug uit deze functie
zodat wanneer voert typen controleren, kan het ervoor zorgen dat
dat wat we eigenlijk hebben geschreven beneden daadwerkelijk voldoet aan die.
Dus het is een beetje als een cheque met jezelf soort situaties.
Maar daar zijn--
>> PUBLIEK: [onverstaanbaar] arrow?
>> DAN AMRMENDARIZ: Er zijn gevallen waarin kunnen we aangeven dat we kunnen impliciet
stelt u het rendement.
Maar in dit geval, ik niet dat zou werken.
Er is een aantal andere syntax dat zullen we later zien.
>> Oké, dus deze bron code is een beetje anders
want dit ontleedt argumenten uit de functie die we bellen.
Laat me zien hoe het werkt voordat we daadwerkelijk gaan
een aantal interessante dingen dat gebeurt in Swift.
>> Dus in dit geval, als ik dit run gewoon code, merken dat wat het doet
is-- terwijl het soort geeft me een rare fout.
Ik moet het langs een paar integers als een command line argument.
Dus laten we zien, 150 en 80, en druk op enter om uit te vinden wat het eigenlijk doet.
Het accepteren van elk deze waarden integers.
Het invoeren van hen in een cijferlijst.
En dan is het uitvoeren van dat de gemiddelde berekening
en het uitvoeren van dat als we zouden verwachten.
>> Maar natuurlijk is er iets aan de hand Op deze verwerpen iets
iets een integer.
Zoals je misschien herinneren van toen we waren omgaan met command line argumenten
in C en andere talen, de allereerste 0-ste artikel op dat opdrachtregelargument
lijst is de naam van het commando dat wij daadwerkelijk zijn uitgevoerd.
Dus in dit geval, ik ben gewoon looping alle command line argumenten van.
Maar ik ben niet te doen een soort van buitensporige controleer dan slaan dat eerste.
Ik ben gewoon expliciet of impliciet ik ben controleren welke van deze types
zijn gehele getallen voordat ik eigenlijk het uitvoeren van deze berekening.
>> En dat is in wezen wat er gebeurt hier.
Voor elk argument in de argumenten van het proces,
Ik ga wat controle uit te voeren.
En in dit geval, ga ik om te proberen om de eerste bekeerling
dat argument in een integer door het uitvoeren van een expliciete typecast,
omdat het van inputs, een string en in feite een geheel getal.
>> Maar dit is een soort van een rare syntax, Als laten cijfer gelijk Int (argument).
Wat er daadwerkelijk gebeurt Hier is uiterst
belangrijk om je met behulp van Swift.
Deze wordt gebruikt om het riep een optionele type.
>> Dus deze functie Int (argument), keert niet alleen een integer, maar keert terug
wat heet een optionele integer.
En dus dit is een soort van een soort bovenop een soort.
U kunt soort voorstellen als het is terug te keren als een pakket.
En als je die open pakket, het ofwel
heeft een integer, welke het gevolg is, of het heeft absoluut niets in het helemaal.
Dit is bruikbaar als een foutcontrole mechanisme, omdat in dit geval
we kunnen vinden, dit was conversie succesvol?
Zo ja, dan is het in feite naar een geheel getal binnen.
Anders gaat om sommige hebben waarde die we nihil, zullen noemen die
representeert geen integer helemaal.
Het is echt vertegenwoordiger van niets.
>> En dus dit als de bouw laat ons toe om dat pakket uitpakken,
dat optionele binding.
En als we in staat zijn om uit te pakken, dat verpakken en vind een integer binnen,
dan wat we zeggen hier is dat we zullen dan
toestaan ​​dat de in te stellen waarde in deze constante genaamd leerjaar.
En dit gedeelte van de if-statement, het bovenste gedeelte van de if
zal lopen, omdat dat uitpakken was succesvol.
>> Als het gewoon zo gebeurt het dat Er is een fout opgetreden misschien
in deze expliciete conversie een string naar een integer, misschien
Het is de waarde ABC bijvoorbeeld.
En dat is eigenlijk niet van plan converteren naar een integer.
Dan zal het nihil terug, die geen geheel getal.
En dit als statement goed dan mislukken.
graad zal niet bestaan, want het geen integer inhoud.
En het zal dit anders blok in plaats lopen.
Ja?
>> Publiek: Nil is N-I-L?
DAN AMRMENDARIZ: nihil is N-I-L, ja.
>> Dus dit is misschien een van de moeilijkste dingen over Swift,
vooral als je in het onkruid op een iOS-app
en je bent eigenlijk probeert wat de ontwikkeling is er te doen.
Het gaat te schreeuwen naar je over optionele.
Het zal moeten vragen u voor vraagtekens en uitroeptekens.
Maar zodra je erachter out-- als je wijden enige tijd uitzoeken
Wat is er aan de hand met optionele types, je bespaart jezelf een hoop hoofdpijn
als je probeert te schrijf een app in Swift.
>> Het is eigenlijk een zeer krachtige functie.
En je moet gewoon neem mijn woord voor het voor nu.
Maar we zullen zien deze constructie en enkele anderen het leuk vinden
in andere broncode die laten wij u zien in slechts een klein beetje.
>> Zijn er aanvankelijk vragen hier?
Dus de belangrijkste afhaalrestaurant is dat een optionele type is een soort van metatype.
Het ofwel heeft een waarde, en zo ja, dan
zullen misschien hebben die waarde geassocieerd met het, of het heeft geen enkele waarde,
en wordt vertegenwoordigd door nul.
De rest van dit misschien wel zoals je zou verwachten.
>> Dus laten we het opvoeren van de moeilijkheidsgraad nog maar eens.
En deze keer, laten we eens een kijkje bij enkele andere soorten gegevens die werkelijk bestaan.
Een daarvan is woordenboeken, wat zeer vergelijkbaar met Python woordenboeken.
Het is enigszins vergelijkbaar met een hashtabel in C. Het is in wezen een mapping sleutels
waar de sleutels kunnen worden strings.
En als je omhoog kijkt die sleutels, deze toetsen zal een waarde hebben.
Dus het is niet echt een array, maar in plaats daarvan, nauwer verbonden
een hash kaart of een hash tabel.
>> Laten we eens kijken hoe dit wordt verondersteld om daadwerkelijk te werken voordat we
gaan in de broncode zelf.
Als ik dit run gewoon, niets gebeurt echt.
Het is me te vertellen dat ik verwacht enkele parameters van het volgende type.
Dus ik ga om te voorzien het enige probleem set namen,
zo pset0, misschien heb ik 100.
En pset1, ik heb een 5.
En dan op het examen, ik deed echt goed en kreeg 30.
En oei, ik raakte een ruimte hier.
>> Als ik druk op Enter, kunt u zien Het voert enkele berekening.
Het zegt cijferlijst is drie rangen, pset1, pset0, examen.
En de cijferlijst heeft Deze specifieke gemiddelde.
Dus nogmaals, we werken met deze cijferlijst idee,
maar we gaan verder itereren de complexiteit van onze functie.
>> Dus bij het begin, we zijn gewoon gaan naar een functie te creëren die
is verantwoordelijk voor het drukken van het gebruik.
En er is deze afrit functie die zal gewoon
geforceerd stoppen de applicatie.
Dit is niet iets dat je zal gebruiken in iOS app.
Dit is enkel, in casu met een command line argument.
Volgende we beginnen te bewegen in de richting van Xcode.
Maar dit is specifiek voor een opdracht lijnstijl programma in Swift.
>> Laten we eens een kijkje bij enkele van interessante dingen hier.
Laten we eens kijken, maar een paar interessante dingen te misschien noemen
dat in mijn functie van afdrukken van het aantal rangen,
je zou kunnen herinneren dat ik had die lijst van items-- pset1, pset0 en examen.
Je kunt eigenlijk snel en dit gemakkelijk doen
Door de puntenboek, die een woordenboek die sleutels en waarden heeft.
Zoek alle van de belangrijkste is via de stip sleutels methode hier,
en gebruik dan deze joinWithSeparator, die vervolgens nemen van de sleutels
dat we hadden ingetypt, pset1-- of sorry, pset0, pset1 en exam--
en aaneenschakelen ze samen met behulp van een komma en een spatie
een lange reeks maken.
Deze join operatie is gewoon fenomenaal bruikbaar in verschillende contexten.
En zo is dit joinWithSeparator.
>> En dit is een ding dat is veranderd van Swift 1 tot Swift 2.
Vroeger was er een te zijn Python style-- als je
vertrouwd met Python-- een Python stijl join methode op strings.
Maar dat is niet meer Voor in Swift 2.
Je wilt om dit te gebruiken als je wilt om een ​​array van dingen samenvoegen
samen met een koord.
>> Dus misschien dan in onze bespreking gemiddelde vóór,
maakt het een beetje meer zin voor ons om de gemiddelde functie in te stellen
eerder een optionele dubbele zijn dan alleen een expliciete dubbele.
Omdat we dat ongewone aandoening waarbij,
wat als cijferlijst eigenlijk geen waarden binnen het?
Wat moet de gemiddelde rendement?
>> Nou misschien in C u zou iets hebben gedaan
als voorwaarde een sentinel waarde, zoals 0.0, of misschien een negatief getal,
of iets gewoon vertegenwoordigt het feit dat er een fout
en je misschien niet eigenlijk de mogelijkheid om dit gemiddelde te berekenen.
Nou, de schoonheid van het opgeven van een optionele soort zou zijn om dat te doen.
En ik ben nu zeg al deze woorden, maar dit eigenlijk niet optionals gebruiken.
Maar we zullen zien dat in slechts minuten waar we gemiddeld kunt instellen
een optionele soort gegevens, zodat zijn als het daadwerkelijk terugkeert sommige gegevens, dan
zullen we die gegevens terug.
Anders zullen we terugkeren nihil, zegt dat dit
geen logische berekening.
>> Laten we gaan naar iets anders.
Dus vanaf hier, hebben we gekeken naar al deze voorbeelden in de opdrachtregel.
Maar echt wat je gaat te behandelen is Xcode.
En een van de leuke dingen over Xcode is, en in het bijzonder in Swift,
is dat we dit ding heet een speeltuin.
En een speeltuin is helemaal niet een iOS-app.
Maar het laat je om te experimenteren met Swift in een zeer eenvoudige manier.
U kunt al uw code in te typen.
Het is mooi hier syntax gemarkeerd.
Wanneer u een nieuw bestand te maken, zal het vragen als je wilt een speeltuin maken.
Maar het leuke van de Playground is dat aan de rechterkant van uw raam,
doet het eigenlijk laten zien output van de code.
Dus als ik naar beneden scrollen, kunnen we wat zien de productie van verschillende regels code
eigenlijk gebeurt te zijn.
>> Dus in dit geval, gaan we richting veranderen gewoon een beetje
en praten over iets dat echt belangrijk om dit hoge niveau manier
dat Swift opereert, en het is dit idee van sluitingen.
En je hebt waarschijnlijk dit gezien een beetje in JavaScript.
Voor degenen onder u die zijn in CS50, sluitingen
zijn erg populair, zeer goede manier van doen hoog niveau zaken in de moderne talen.
Maar het is ook een soort van moeilijk te wikkel je hoofd rond de eerste keer.
Dus als u op zoek naar dit eerste keer, dat is OK.
Kijk maar naar de broncode en zien als je kan het uitzoeken thuis.
>> Dus in dit geval, laten we zeggen dat we willen veel exponenten creëren
met enige vaste waarde.
Dus in dit geval kan ik een functie te creëren.
Ik ga noemen macht van 2 wiens enige doel in het leven
is om wat input en dubbele nemen het, en terug te keren die waarde.
Merk op dat hier ben ik aanvaarden één type data.
Het gaat om een ​​variabele genaamd x zijn.
Het is van het type Double.
En ik ga een dubbele hier terugkeren.
En ik ga gewoon doen een zeer, eerlijk gezegd, vrij
naïeve manier van een verdubbeling van deze waarde.
En ik zal je laten zien waarom dit is nuttig in slechts een seconde.
>> Merk op dat hier hebben we dit gamma weer. iets in 1, punt
dot dot, 2, waardoor deze lus zal twee keer draaien.
Maar dit is een dummy variabele.
Het betekent dat ik ben niet echt van plan om gebruiken die variabele overal
binnenkant van deze lus.
Ik wil deze lijn code twee keer draaien,
zonder te weten de waarde van dat bereik.
>> Dus in dit geval ben ik rennen resultaat x keer tweemaal, die in wezen
betekent dat ik de kwadratuur van deze waarde.
En dit gebeurt werken als we zouden verwachten.
Power of 2, passeren de waarde 2,0 geeft ons een vermogen van 4.
3,2 werken voor 10,24.
>> Nu kunnen we een soortgelijke doen ding voor de macht van 3.
Maar nu verandert alleen het bereik.
Voor dummy variabele 1 tot 3, vermenigvuldig 3 keer,
en doe hetzelfde.
>> Dus dit misschien het gevoel een beetje gekunsteld.
Maar er is een belangrijke ding hier die
dat kijken naar deze twee functies, is er
maar één ding is dat anders, dat deze waarde in het gebied.
Alles over deze twee functies vermogen van 3 en macht van 2,
in feite identiek omdat zij werken op dezelfde wijze.
>> Dus op dit punt, een beetje alarmbel moeten afgaan.
Hopelijk wat je zegt, je weet wel, dit voelt een beetje
zoals dubbel werk.
Misschien is er een manier die ik zou doen in staat zijn om dit alles te kapselen
en een functie of maak een functie die
doet precies wat ik wil, zonder hoeven te typen expliciet.
En dit is wat de kracht van een sluiting stelt ons in staat te doen.
Dus laten we eens een kijkje op deze.
En ik zal een paar te besteden minuten op deze, omdat deze
is erg belangrijk voor Swift.
We zien dit de hele tijd.
We gaan naar een functie te definiëren.
Het zal worden genoemd powerof.
Het gaat om een ​​accepteren parameter genaamd y van het type Int.
Maar een kijkje nemen op de return type.
De return type is, in haakjes, dubbele pijl Double.
Wat betekent dat deze functie, deze functie powerof,
terugkeert van een functie.
Dat is het aanvaarden van een tweepersoonskamer en het terugsturen van een dubbel.
Dus dat klinkt misschien soort gek, maar laten we naar beneden scrollen een beetje
en kijken om te zien wat er gebeurt.
We zijn in deze functie powerof.
We zijn het creëren van een nieuwe functie genaamd exponentiator,
maar het maakt niet uit wat het is.
>> Merk op dat dit een invoerwaarde van x.
En het neemt in een tweepersoonskamer en het terugsturen van een dubbel.
Dit is dezelfde code die we zagen hierboven, behalve dat de waarde van 2
of de waarde van 3, die bovengrens in dat gebied,
is vervangen door deze waarde van y, waarbij
was de eerste parameter onze powerof functie.
En op dit punt, we terug exponentiator.
We zijn terug van de functie.
>> Het is net zoiets als een kleine geest waait.
Maar laten we eens voorstellen wat er gebeurt als ik bel deze functie powerof
en overgaan in het wat waarde als 2.
Wat dit betekent is dat Ik heb nu de waarde
2 for y, hetgeen betekent dat deze waarde y in deze functie exponentiator
zal die waarde 2 zijn.
Maar ik ben terug dit exponentiator functie.
>> Dus let op wat Swift zegt dat ik gecreëerd in dit geval.
Laat plein is een definitie, het is een functie die een dubbele aanvaardt
en geeft een dubbel.
Ik heb een functie gecreëerd dat pleinen iets
met behulp van dit mechanisme hier.
En echt wat er gebeurt is dat terugkeert functie
exponentiator, maar deze waarde y is verpakt erin.
En dus nu elke keer als ik dit gebruiken variabele of deze constante genoemd
vierkant, het gaat het te gedragen als een functie.
En zo kan ik dan bellen die variabele als ik zou een functie aan te roepen,
en overgaan in het een nummer, zoals in dit geval 3.
En ik zal dan vierkant deze waarde.
Dus 3 kwadraat Vervolgens 9 geworden, zoals we hier kunnen zien.
>> Echt gek, maar dit nu laat me de kans
andere powerof functies te creëren.
Zoals ik kan zeggen, OK, en nu wil ik een nieuwe functie maakt, powerof (3),
en opslaan die in een constante genoemd kubus.
En nu kubus gaat om een ​​te zijn aparte functie die zal dan
neem wat waarde als input en kubus die waarde zoals we kunnen zien in de onderste regel
hier.
blokje 2 zal leiden tot 8.
>> Hopelijk mooie leuke dingen.
Je hebt nog nooit eerder gezien.
Ik moedig u te kijken naar sluitingen en onderzoeken dit een beetje meer.
Het is echt krachtig spul zien we veel in JavaScript en enkele andere talen.
Het is echt belangrijk om het begrijpen van API's en
dat we zullen krijgen in slechts een seconde.
Ja?
>> Publiek: Als je dat doet powerof (2), haakjes, en dan
een haakje, een andere input-- u bent in principe vervangen van het plein.
DAN AMRMENDARIZ: Dus kijk op het allerlaatste lijn hier.
Het is eigenlijk volledig mogelijk dat doen chaining als u voorgesteld.
Dus powerof (5) betekent dat we gaan een exponentiator van 5 hebben hier.
Dus dit is in wezen gaat het worden 4 hetzelfde als de vijfde macht,
want we hebben een exponentiating gemaakt functie om de vijfde macht,
en we passeren in die functie de waarde 4.
En krijgen we die waarde dat wij verwachten, 1024.
Publiek: En het is niet een te noemen, dus het maakt het makkelijker
om te lezen, het plein wat dan ook.
>> DAN AMRMENDARIZ: Juist, precies.
Dus voordat ik het net in een constante hier dus
dat maakte het gemakkelijk om die naam te gebruiken.
Ja?
>> PUBLIEK: In deze context powerof, het is een deel
van de programmeertaal in tegenstelling tot de manier waarop u
denk aan powerof in [onverstaanbaar]?
DAN AMRMENDARIZ: So in dit geval powerof
eenvoudigweg de naam van de functie die ik gedefinieerd hier.
Dus het is niet inherent de taal zelf,
maar in plaats daarvan, het is gewoon een functie heeft
die naam omdat ik geef het die naam.
Een andere vragen?
Prima.
>> Nu is dit geweldig.
Maar je bent niet van plan om een ​​te zien Veel sluiting functies
zijn als dit waar u definieert, binnen van één functie, andere functie.
En je kunt het doen.
Maar het is een soort van niet echt nodig, toch?
Net waarom heb ik dit te definiëren functie genaamd exponentiator
en dan onmiddellijk terug.
Waarom niet meteen kan ik gewoon deze functie terug te keren?
>> En in feite is dit precies het idee achter een concept genaamd
anonieme functies, waarbij anonieme functies niet echt
een naam, omdat ze niet nodig om een ​​te hebben.
Dus in dit geval, 7B, kunnen we precies dat te vinden.
Het is allemaal dezelfde code, doet precies hetzelfde,
maar nu hebben we het veranderd een beetje, zodat dat deze powerof functie onmiddellijk
retourneert een functie.
Merk op dat na terugkeer, er is een open accolade.
Het wordt verwacht dat deze ingang Double.
Het wordt verwacht dat de output Double.
En dan de in trefwoord scheidt de code zelf.
Dus dit is een anonieme functie.
Het heeft niet echt een naam, terwijl voordat het exponentiator werd genoemd.
Maar zoals we zagen, gewoon echt niet verwijzen naar exponentiator
buiten die functie.
Dus het deed er niet toe.
Dus deze anonieme functie is zo genoemd omdat het is naamloos,
maar het is nog steeds gebruikt In het kader van deze code.
>> De komende paar die ik ben zal hopelijk blijven
blazen je geest een beetje.
We kunnen dit nog eenvoudiger.
Want als scherpzinnig was wees eerder,
misschien zijn we eigenlijk weten, door afleiden van deze code, wat
de output van deze code gaat worden.
En inderdaad, in deze anonieme functie, We kunnen in feite afleiden van de soorten gegevens.
>> Dus in dit ene, we niet langer moeten expliciet te definiëren
het soort gegevens dat wordt input en output van deze functie
voor een paar redenen.
Een daarvan is dat we hebben gedefinieerd, op naar de prototype van de omhullende functie,
wat voor soort data deze anonieme functie moet input en output.
En de andere, we kan afleiden uit de code
hier beneden dat we het accepteren input die is van het type Double
en het terugsturen van een dubbel.
>> Merk op dat hier hebben we niet expliciet gedefinieerd de namen van de argumenten
dat deze functie accepteert.
En zo zien we dat we kunnen verwijzen naar die parameters met behulp van $ 0, $ 1,
enzovoort, enzovoort, naargelang het aantal van die parameter gebruikt
in deze functie.
>> Dit is iets dat je gaat te zien van een kavel is deze open accolade
definition gevolgd door een $ 0, en vervolgens een bepaalde handeling,
en dan een gesloten accolade.
Dat is een anonieme functie dat voert deze bewerking.
Het heeft deze parameter waar de het type is afgeleid.
Die eerste parameter is $ 0.
En enkele operatie is gebeurt op dat $ 0.
>> Publiek: Dus het dollarteken betekent parameter principe,
en 0 betekent de eerste?
DAN Armendáriz: Dat is juist.
Dus de dollar teken betekent in feite parameter en 0: de eerste.
Maar het werkt specifiek dit geval heb ik niet genoemd
de argumenten in mijn anonieme functie.
>> PUBLIEK: Heeft Perl of iets hebben Dit dollar teken, dollar 0 daar?
DAN Armendáriz: Doet die, het spijt me?
PUBLIEK: Heeft Perl hebben Dit dollar 0, dollar 1--
DAN Armendáriz: Ik ben niet te vertrouwd met Perl,
maar PHP wat definieert variabelen gebaseerd op dollar tekens.
En er kunnen sommige talen dat functies als deze.
In feite, Swift leent een Veel functies, zoals deze
van een heleboel andere talen.
We zien hints van Python in.
Deze definitie van het type lijkt te komen uit OCaml.
En we hebben net een hele hoop spullen uit veel verschillende talen.
Dat is een van de leuke dingen over Swift
is dat het een groot deel van de beste ideeën van een bos van talen
en schoenlepels ze allemaal samen in een super taal.
In feite, als je me laten blijven blazen je geest,
dus we hebben dit allemaal te doen.
We kunnen misschien is dit een beetje te vereenvoudigen bits door te beseffen dat, uiteraard,
Swift heeft een exponentiating functie ingebouwd.
Als ik importeer Darwin, die is gewoon de bibliotheek
beschikt over deze functie genaamd pow, nu Ik kan mijn macht van functie te vereenvoudigen
de volgende zijn.
Het gaat om terug te keren Deze anonieme functie.
>> Maar kijk eens hoe eenvoudig dit is nu.
Dit is een anonieme functie accepteert een soort van data,
en het gaat om één te zijn argument in het bijzonder,
verwezen naar $ 0, dat is van het type Double.
Het gaat om een ​​soort dubbel terug.
Maar de return statement is nu impliciet.
>> En het is precies deze stijl die is zeer, zeer overwegend in Swift,
overal.
We gaan om dit te zien de hele tijd in Swift.
Dus ik ben met alle van dit u als gevolg van deze syntaxis.
Dit is heel gebruikelijk te zien, hetgeen betekent
is een anonieme functie die presteert
enkele operatie op deze argumenten.
En er is een impliciete rendement.
Dus het is absoluut hetzelfde voor ons om dit te zeggen, hier.
>> Omdat deze curly bracket is een functie,
we zijn het uitvoeren van deze operatie Op het eerste argument.
We gaan terug te keren dat.
Maar deze uiterlijke terugkeer is terugkeren dat hele functie,
dat hele anonieme functie dat we net hebben gemaakt.
Een andere vragen?
Oké, ik weet niet of jullie zijn er klaar voor,
maar we kunnen nog gekker gaan met Swift.
Ben je klaar?
OK, dit is geweldig.
>> Nu hebben we eigenlijk de mogelijkheid tot in Swift, want hoe modulaire
en hoe het protocol gebaseerd is, om definiëren onze eigen freaking operators.
Zoals in dit geval, hadden we geen operator voor goed exponentiation--,
voor het uitvoeren van bevoegdheden van iets.
Maar ik kan, in Swift, definieert u een nieuwe operator die precies dat doet.
Dus in dit geval is er een stelletje syntax hier.
En ik zal u toestaan ​​om naar te kijken thuis als je kijkt naar dit.
Maar we zijn het definiëren van deze infix exploitant, **, die dan ons toelaten,
door te definiëren wat dat functie ** eigenlijk
doet, om een ​​linkerhand accepteren zijde en een rechterhand,
en vervolgens de exponent van die terugkeer linkerkant naar de rechterkant.
>> En nu ineens I een nieuwe teller hebt gemaakt.
So 2 ** 3 betekent 2 met de derde macht.
[Geest waait SOUND] Dit door zelf moet je zijn als,
OK, schroef C. Ik ga Swift helemaal.
Dit is geweldig.
Dit is vrij fantastisch.
>> Maar dit is een goed voorbeeld.
Maar ik heb nooit een keer buiten van dit voorbeeld eigenlijk
gedefinieerd mijn eigen operator.
Maar toch, het toont een Veel van de macht van de Swift
en waarom dit is eigenlijk echt heel cool.
Oké, ja?
Publiek: Als je definiëren van uw eigen operator,
hoe weet je dat je per ongeluk niet proberen en te zorgen voor een operator die is
ergens in C, zoals ergens verborgen in Swift,
als een obscure die u misschien niet eerder hebben gezien.
>> DAN Armendáriz: Dus als je probeert om uw eigen exploitanten te definiëren,
is er het risico definiëren één over een bestaande operator.
Dat gaat in een mate van detail die Ik denk niet dat we de tijd hebben om over te gaan.
Dat gevaar.
En dat is in feite de reden waarom Ik heb het dakje symbool, niet gebruiken die
als we het typen van de macht, we meestal Gebruik 4 kleine dakje 5 ofzo
als dat, net als we Gchatting vrienden of wat dan ook.
Maar in dat geval, dat eigenlijk zou een aanrijding hebben veroorzaakt.
En zo vermeed ik het alleen maar omdat Ik toevallig te weten in dit geval
dat zou veroorzaken dat de botsing.
>> Prima.
Nu helaas voor de laatste zeven minuten,
Ik moet blazen houden je geest een beetje.
Dus staat u mij om te laten zien een aantal andere dingen ook.
>> We hebben u zien dit idee van het hebben van deze anonieme functies,
deze sluitingen die u in staat te stellen soort passeren functies rond.
Je kunt ze terugkeren.
Je kunt ze manipuleren.
U kunt allerlei gekke dingen te doen.
>> Maar een ander ding dat toevallig nuttig
is de mogelijkheid om, in tegenstelling om terug te keren die functies
in een functie, een functie doorgeven als een parameter aan een andere functie.
Je zou ook kunnen denken waarom op aarde zou ik zoiets doen?
>> Nou, laten we zeggen dat ik wil om deze operator te nemen dat ik
werkte zo hard te maken en toe te passen het aan een heleboel verschillende nummers
in een matrix.
Dus in dit geval heb ik een array van integers-- 1, 4, 7, 2, 5, 10, 56.
En ik wil ze allemaal te verdubbelen.
De manier waarop we zouden in het algemeen doen is om gewoon te schrijven
een eenvoudige lus die doorloopt ze allemaal
en het uitvoeren van een soort van vierkante werking over hen,
invoeren die nieuwe waarden in een nieuw variabele of eerder een nieuwe array here.
En de waarde van de uitgang van Hierdoor is dan al deze arrays,
of liever al die elementen nu kwadraat.
>> En we konden het zelfde doen ding voor cubing het,
maar een beetje alarmbel zou moeten gaan off
zeggen dat er misschien een manier die we zouden
in staat zijn om dit te vereenvoudigen een beetje.
En in feite is er.
Wat als we konden creëren een functie die ons in staat stelt
te accepteren, als een roofdier, een functie?
Dus in dit geval, neem een kijken naar deze argumenten.
We gaan een lijst van dubbelspel te accepteren.
En dan gaan we een functie accepteren
in een variabele met de naam f dat gaat een dubbele nemen en terug te keren een Double.
En de volledige output van deze gehele functie
genaamd Mapper gaat terug een array genaamd dubbel.
>> Wat dit dan zou mij toe doen is om te herhalen over die lijst
en doe hetzelfde, maar nu die functie toe te passen op elke
van de individuele waarden in die lijst.
Dus ik weet niet echt wat f.
Het maakt niet uit voor mij.
Maar zolang het duurt in een dubbel, voert enkele operatie op het,
en dan geeft een Dubbele, zou ik dan
in staat om die functie in kaart over elk element van de lijst.
>> En dit soort programmering riep hogere orde functies,
waar we passeren functies rond als parameters
en dingen te doen met de functies.
Het is een beetje zoals het nemen van al deze ideeën die we hebben geleerd in CS50
en hen sorteren van naar het volgende niveau.
En dit is allemaal CS51 stijl spullen.
En dus gaan we in de diepte meer in klassen als dat.
>> Maar dit is ook belangrijk hier omdat we
zie veel functies die worden gebruikt in Swift
die in wezen doet dit, waar we
sommige nummers, sommige matrix van getallen.
We gaan voorbij dat serie in onze mapper.
En we gaan ook passeren een functie die
we hebben hier al gedefinieerd up.
Het gaat om vierkant te zijn.
En we gaan dan vierkant al die nummers
en slaan die op dit resultaat here.
>> Dus dit geval hebben we ons gedefinieerd eigen functie genaamd mapper.
Maar precies dit ding is, in feite ingebouwd in Swift.
Er zijn diverse functies genaamd kaart.
Er is een kaart functie, er is een vermindering van de functie,
en er is een filter-functie, die in wezen gelden functies
aan elk element in een lijst om ze aan te passen op een bepaalde manier.
>> Publiek: Dus omdat je transformeren Gegevens in een ander formaat
door middel van een function--
DAN Armendáriz: Recht.
Ja, dus de functie dat we het accepteren
is het transformeren van de gegevens op een bepaalde manier.
In dit geval waren we ofwel kwadratuur, of we waren cubing het,
of eigenlijk, kunnen we uit te voeren geen bediening op het helemaal.
>> Maar laat me je dan laten zien hoe deze eruit komt te zien in de praktijk.
En nogmaals, ik ben het draaien van een beetje tijd. dus ik ben niet
zal zijn om over te gaan allemaal in staat van de broncode hier in detail.
Maar ik moedig u aan om dat te doen.
We zullen het zo snel plaatsen mogelijk na dit gesprek.
>> Maar als je een kijkje nemen op deze, veronderstellen dat we een lijst van nummers,
blok getallen in deze variabele gebelde nummers.
Dan willen we dit uit te voeren filter operatie op die nummers.
Dus filter een hogere Om functie die
accepteert een matrix en een functie.
En elk element, dat array, zij die hoedanigheid.
>> Als die functie terugkeert waar is, houdt dat punt.
Als die functie geeft false, werpt dat punt weg.
En dan is een lijst terug dat wordt dan al
van die items die zijn gefilterd.
>> Dus andere woorden, dit hetzelfde idee, de cijferlijst.
We kunnen verschillende soorten hebben op deze nummers waarde genoemd.
Zou kunnen zijn 100 en 70, en 40, enzovoort, enzovoort.
Wat dit filter doet is kennisgeving dat dit dat syntactische suiker
voor een anonieme functie.
Dit is een anonieme functie te zeggen dat de parameter die ik keur
gaat worden, als het groter dan 70,
dan is dit waar terug, waardoor dat punt zal in dit filter worden gehouden.
Dus laten we een beetje concreter over.
Als ik deze reeks getallen en bestaat uit 100, 70 en 40,
Ik dit filter uit te voeren operatie op elk van deze.
Zodat eerste is deze waarde van 100.
100 groter of gelijk 70 geldt dat
betekent dat 100 wordt bewaard in dit nieuwe exemplaar van deze array.
70 gaat ook.
Maar 40 niet.
Dus wat is teruggekeerd in passingCount is de matrix van elementen 100 en 70--
100, komma, 70.
Dat waren de enige twee items werden gehouden.
En dus is de reden dat ik ging snel door veel van dit soort hoge orde
dingen zijn want dit is dat de gemeenschappelijke ding dat je mooi in Swift zullen zien
vaak is het uitvoeren van een operatie Met deze anonieme functie syntax.
>> Er is een aantal leuke dingen.
Switches zijn echt krachtig in Swift, Ik bedoel, net als een gek, gek krachtig.
U kunt gebruik maken van switch, en je kunt ze eigenlijk van toepassing
te bereiken, dat is een soort van gek, en doe chique dat soort dingen.
>> Maar in de laatste paar minuten, Ik wil vooruit overslaan heel ver
en laten u een specifiek voorbeeld van hoe we kunnen creëren in iOS app met Swift.
Dus als je aan het doen bent deze, moet je nemen
een blik at-- op Apple's documentatie, zij
hebben veel echt goede tutorials voor het maken van uw eerste aanvraag.
En ik moedig u te doen dat, omdat ze je mee
alle stappen van wat precies Klik op een iOS-applicatie te maken.
>> Maar hier hebben we deze iOS-app.
En het is een vrij eenvoudige applicatie echt.
Als ik dit run, laat me zien je hoe het eruit ziet.
Alles wat het wezen doet is het trekt van het internet een JSON-bestand
die ik heb opgeslagen op een server.
En dat JSON bestand definieert beelden die het mogelijk maken
ik vervolgens doorlopen, op mijn app, beelden van mijn web-server.
>> Dus ik heb hier getNextImage.
Het laadt een afbeelding van het internet, en toont vervolgens op het scherm.
>> Dus het is vrij eenvoudig.
Maar het doel is hier om te laten zien hoe kunnen we de dingen combineren
van de laatste paar weken van de CS50 in een werkelijke iOS-applicatie.
Met andere woorden, misschien één van de dingen die je wilt doen
is om een ​​iOS-applicatie die kan gegevens te trekken van het internet
en wat informatie geven de gebruiker.
Dat volledig het punt van deze broncode hier.
>> Dus er is veel te zeggen over hoe werkelijke iOS ontwikkeling doen.
Er is een heleboel gekke syntaxis dat we nog niet helemaal hebben gezien
als een klasse, wat een klasse eigenlijk is.
We kunnen grotendeels negeren dat voor het moment.
>> Maar merken dat we hebben bevat binnen die een aantal dingen
dat we al hebben gezien, zoals functies die specifieke namen te hebben.
En als we geven die functioneert de juiste namen
die naar verwachting door de iOS, in feite Dit voelt een beetje magisch.
Maar als je een te maken iOS-applicatie, is er
zijn specifieke functie namen die worden opgeroepen door de telefoon zelf
als de toepassing wordt geladen om te proberen het proces daadwerkelijk creëren
loopt uw ​​aanvraag.
Dus nogmaals, er is een heleboel dingen die ik hier hebben dan te verdoezelen om ons
specifiek over praten.
Maar ik moedig u te kijken naar misschien de andere iOS seminar, maar ook een aantal
van de tutorials online die wel een veel betere baan beschrijven
de specifieke informatie.
>> Maar we kunnen een paar dingen zien dat zijn interessant uit de code hier.
Merk op dat we hebben als statements.
By the way, een belangrijke ding over if-statements
dat de haakjes rond Boolean expressie zijn optioneel.
Maar de accolades zijn niet optioneel, maakt niet uit hoe veel of weinig regels code
je hebt in een if-statement.
Je kunt niet een if statements hebben zonder accolades in Swift.
>> En dit is, nou ja, soort dom.
Maar er is historische redenen voor.
Het is de bedoeling om je te redden van jezelf.
Als dit bijvoorbeeld, kun je niet elimineren de accolades rond die
als statement.
Deze zijn in feite vereist.
Dus ik moedig u aan neem een ​​kijkje op deze.
Maar er is nog een construeren die ik wil
om te laten zien dat over Swift is nieuw voor Swift 2.0 vergelijking
oudere versies van Swift, die de volgende is.
Laten we eens kijken waar heb ik het hier?
>> Dus in deze functie genaamd fetchJSON, deze functie
is verantwoordelijk voor het trekken van dat JSON bestand van een URL, die net zo gebeurt
te draaien op mijn CS50 IDE.
Ik ben begonnen met Apache, zet mijn JSON bestand daar,
en ik ben in staat om trek dat gegevens van het internet met behulp van
deze functie en deze URL, die door de telefoon.
Het is voorzien van een bibliotheek die u gebruikt wanneer
je doet een aantal iOS app ontwikkeling.
>> Merkt hier dat er deze ongewone syntactische constructie genaamd bewaker.
En echt alles is in Swift is een manier om na te gaan
dat sommige dingen hebben is voldaan voordat u
verder met de rest van de functie.
Dus ik zou kunnen hebben, met behulp van deze optionele soort,
Ik kon de URL door hebben gevonden het uitvoeren van deze functie NSURL
en opslaan die in een URL constant, en vervolgens controleren
om te zien of de URL was nihil, omdat het ging om een ​​optionele soort terugkeren.
En als het was nihil, dan zou ik afdrukken van een fout en dan terug.
>> Maar in plaats daarvan, wat guard laat wij doen, is dat zeer ding,
maar zorg ervoor dat het is inderdaad zo dat URL
correct is door NSURL ingesteld.
En zo ja, dan slaat dan dit, en het
zal u toelaten om verder te gaan met url te zijn correct gedefinieerd zijn.
Maar als het zo dat url is niet goed gedefinieerd,
Als deze functie geeft een fout of een andere onverwachte dingen
eigenlijk gebeurt, deze bewaker construct laat ons toe om vervolgens output die fout
en onmiddellijk terug te keren.
Ja?
>> Publiek: Dus het is een soort van als een als dan anders?
DAN Armendáriz: Het is een soort van als een als dan anders, ja,
behalve dat deze URL wordt vervolgens gedefinieerd voor alle onder deze.
Als het passeert deze bewaker, dan is het daadwerkelijk gevuld met data
en geschikt voor gebruik in de overblijvende broncode in uw functie.
Dus ik vermoed dat je gaat beginnen om deze bewaker te zien ook.
En wees zuinig op.
>> Dus gewoon kijken naar een paar andere dingen, dit recht hier is wat,
denk je, maar op basis van wat we hadden het over vroeger?
>> PUBLIEK: Denk dat het zal draaien in de lijst?
>> DAN Armendáriz: Dus dat is dichtbij.
Dit is een functie die we definiëren.
En we zijn het invoeren van die functie als argument om deze functie hier.
>> PUBLIEK: [onverstaanbaar], zo niet nihil.
Dus het is in de lijst, toch?
>> DAN Armendáriz: Als de fout is niet nul, zodat is-- dus ik moet scrollen.
Nou, laten we eens kijken, ik kan niet echt Blader naar rechts hier.
fout is een argument dat wordt doorgegeven aan deze anonieme functie.
Dit is een anonieme functie.
Het heeft geen naam.
Maar we accepteren deze drie argumenten, gegevens, reactie, en opstaan.
En het gaat leegte terug te keren, zodat het is niet van plan om iets terug te keren.
En dit is de inhoud van die functie.
En dan hebben we toegang binnen dat kan aan elk van deze argumenten.
>> Dus het is een wervelwind tour van de taal.
Maar ik hoop dat met deze, hopelijk als u
een kijkje bij enkele van de tutorials specifiek voor iOS ontwikkeling met Swift,
vooral als je naar Apple's developer web page--
ze hebben een veel echt goede tutorials om mee te beginnen.
Maar hopelijk net dit uur praten over de syntax zichzelf gegeven heeft
je genoeg aan de slag met dat.
>> Wij zullen alle van deze bron te posten code op het seminar website
zo snel mogelijk, en ook de slides dus je hebt een referentie voor al die.
Maar veel succes met uw projecten.
En dank u allen hartelijk voor uw komst.
>> [APPLAUS]