>> DANIEL Armendariz: Hallo, iedereen, welkom op iOS app ontwikkeling
met swift.
Ik ben Dan Armendariz.
Ik ben precepter van computer wetenschap hier aan de School
of Engineering and Applied Sciences.
En snel is eigenlijk soort van een heel nette taal.
En ik heb een aantal plannen voor vandaag.
Dus de komende uur of zo wij gaan om te kijken naar iOS app ontwikkeling zelf
met behulp van Xcode en eigenlijk het creëren van een aantal erg basic, zeer eenvoudige toepassingen.
En kijken naar de manier waarop je die toepassingen daadwerkelijk nemen,
en bouwen ze, en eigenlijk leg ze op een iOS-apparaat.
Sommige van de dingen die we zijn niet van plan om naar te kijken
zullen dingen zoals onder andere het daadwerkelijk nemen van een aanvraag
en zetten het op de app store.
Er is een hoop tutorials online die zal u helpen met dat aspect ervan.
Maar ook omdat als deel van CS50, krijg je
naar de Apple ontwikkeling meedoen team, CS50's app development team.
Als u nog niet hebt gedaan en u bent aangesloten bij CS50,
Ik adviseer dat u dat, omdat dat te doen
is hoe je in staat om te creëren bent sommige programma's in Xcode,
bouwen ze, en eigenlijk zet hen op een aantal van uw iOS-apparaten
Als je eigenlijk een fysieke iOS-apparaat.
Als u niet beschikt over een fysiek iOS apparaat dat is meer dan prima.
Je kunt eigenlijk te ontwikkelen voor iOS.
En Xcode heeft een simulator waarmee je
om uw aanvraag te zien in acties op uw computer.
Maar het soort is een nette zaak om daadwerkelijk te spelen en interactie
met uw aanvraag op een daadwerkelijk apparaat.
Dus er is een paar eisen aan eigenlijk alles van deze ontwikkeling te doen.
Een daarvan is dat moet je een Mac hebt.
Het dient te lopen 10.9.4 of hoger met het oog op de ontwikkeling van doen met swift.
>> U kunt een eerdere gebruiken version ontwikkeling
met Objective C voor iOS en Mac.
Maar ik raad, en een groot deel van de voorbeelden die we vandaag zien,
Gebruik 10.10 Yosemite.
Dus als u nog geen gebruik maakt, het is een goed excuus om dat te doen.
Nu Xcode 6.1 is de nieuwste versie van de geïntegreerde ontwikkelomgeving
dat Apple biedt gratis dat U kunt de app store te downloaden.
En ik raden u aan Ook lopen de laatste versie.
>> Als je toevallig een eerder te draaien versie, Xcode 5 en lager net
gewoon niet ondersteunen dan ook snel.
En de bètaversies van zes, waarvan werden uitgebracht in de zomer,
ondersteunen wel snel, maar er is is een enorm aantal
veranderingen in de taal, voldoende zodat de code die je bent
gaan kijken en dat u zou kunnen vinden op het internet
zal niet echt goed te compileren in deze eerdere versies van Xcode.
Dus nogmaals, maar als je dat niet doet hebben een developer-account,
Ik raad je aan developer.apple.com.
Meld je aan, maak een developer-account, en lid van de CS50 app development team.
Dat zal een gelegenheid om u te voorzien om uw applicaties te compileren
en zet ze op uw apparaat.
OK, dus laten we beginnen.
Het allereerste wat we gaan doen is
om daadwerkelijk te creëren een zeer eenvoudig project in Xcode
dat zal u toestaan een aanvraag.
>> Dus als je nog niet over Xcode geopend, ga je gang en open het
en maak een nieuw project.
Een speciale splash screen zal openen en zal u geven
enkele opties over wat het is dat je wilt doen.
Gewoon zeggen dat je wilt maken een nieuw project, een nieuwe applicatie.
Deze pop-up venster, aangenomen dat je Xcode 6.1.
Nu, en voor de duur van dit seminar,
we gaan gebruiken enkele weergave toepassingen, net
soort van een basis applicatie om uw voeten nat worden.
En je kunt vertakken op uw eigen vanaf daar.
>> Klik op Volgende op dit punt.
Nu hier is er een paar dingen dat u zou willen voeren.
De naam van het product is de de naam van uw project.
In dit geval, ik ben gewoon gaan om het te noemen Seminar1
want het is onze eerste voorbeeld.
Naam van de organisatie, in dit geval is gewoon mijn naam.
U kunt natuurlijk ook veranderen om uw eigen naam, of om CS50.
Organisatie identifier, als je toevallig een website hebben gewoon
de domeinnaam in achteruit, com.yourname.
en dan de naam van het product zou automatisch moeten verschijnen
daarna de bundel identifier.
>> Uiteraard is de taal die we gaat worden met behulp van vandaag is vlug.
U kunt natuurlijk gebruik maken van Objective C voor dat, maar vandaag zal snel zijn.
En we zullen nu zeggen universele apparaten, zodat
dat het werkt op zowel de iPad en iPhone.
En we zullen kern vertrekken gegevens ongecontroleerd te houden
het project relatief eenvoudig voor het moment.
Dus laten we verder gaan en klik op Volgende.
En het gaat om me te vragen waar ik wil om het te redden.
Ik zal gewoon sla het op mijn desktop voor nu.
>> Oké, dus nu is dit wat zal gebeuren als je daadwerkelijk open Xcode.
En merk op dat de allereerste wat je ziet
is dit uitroepteken dat zegt dat er geen ondertekening identiteit gevonden.
Ik dit met opzet deed op mijn computer en ik ben
in de hoop dat ik ga in staat zijn om daadwerkelijk vast te stellen dat,
want ik wil dat je hoe dit te zien daadwerkelijk zal werken op uw eigen computer.
>> Ga je gang en klik op fix kwestie.
Het zal u vragen of u een bestaande Apple Developer-account.
Dit is waar de toetreding tot de CS50 app development team
is belangrijk, zodat je niet alleen een app-account,
maar je hebt ook de mogelijkheid om de apps te ondertekenen
en zet ze op je iOS-apparaat.
Dit is niet-- klikken fix probleem is niet nodig
als je gewoon gaat om bouwen en plaatselijk ontwikkelen,
geheel binnen de iOS-simulator.
>> Maar voor nu ga ik te ontwikkelen en zet ze
op mijn iPad, die zal worden kunnen eveneens uitzenden.
Dus ik wil dit ook daadwerkelijk toe te voegen.
En het gaat om te vragen me voor mijn Apple ID.
Dus het gaat om dit te zijn.
En ik moet mijn te halen wachtwoord, dat is meer dan hier.
Dus geef me maar een seconde te vinden dat, en kopieer die en plak het dan hier.
>> Klik op Toevoegen.
Het gaat om me te vragen welk team ik wil meedoen.
Ik ga naar school van de techniek te doen.
Klik op Deelnemen.
Oeps, dat is de verkeerde.
Laten we dit één.
Hopelijk zal dat ene werken.
Dat men nog steeds niet werkt.
We hebben bijna geen goeden hier.
OK, moet deze werken.
Sluit nu.
Nu gaan we de school van engineering, klikt u kiest.
>> En nu hopelijk na een paar seconden je OK can--,
Ik zal intrekken en aanvraag.
Oh man, dit gaat niet werken.
OK, zal ik een andere proberen.
Laten we dit doen hier.
Live-demo's er niet in slagen mij.
Misschien moeten we terugkeren naar gewoon gebouw volledig lokaal,
maar dat OK in dit geval.
>> Dus hier, terwijl dit eigenlijk werken, wat we gaan doen is gewoon
maakt een zeer eenvoudige Hello World-toepassing.
Dus dit is Xcode.
En als je het nog niet gezien, het kan een beetje intimiderend op het eerste.
Er is veel van ruiten, er is een veel hebbedingetjes op verschillende gebieden.
Maar gewoon beseffen dat er echt meerdere hoofdcomponenten
deze ontwikkelomgeving.
Op de uiterst links zijn alle bestanden die van toepassing zijn op uw programma
of om uw specifieke project.
We zullen rond te klikken op een aantal van hen en we zullen
wijzen op de meest belangrijkste zijn in de tijd.
Uiterst rechts, we hebben een set van attributen.
Al deze eigenschappen, daar verschillende panelen voor de attributen.
De ruiten zal veranderen afhankelijk van de de context van de belangrijkste inhoud, die
toevallig in het midden.
Nu de middelste daadwerkelijk aantonen u een verscheidenheid van dingen, bijvoorbeeld
uw code zelf.
Of je zou eigenlijk have-- wanneer U klikt op het storyboard waarop
is, door de manier, maar een grafische weergave van uw gebruiker
interface voor uw application-- vervolgens het deelvenster attributen
op het meest rechtse daadwerkelijk veranderen.
Nu is er een paar andere dingen die ik op wil wijzen.
U kunt soort verkennen rond in de omgeving op uw eigen.
Maar een van de dingen dat is zeer nuttig geweest
is deze knop hier, de rechtsboven in het venster.
Er is op deze knop dat lijkt op het ver
liet het een paragraaf gevolgd door twee cirkels en sorteren
twee pijlen afstand van elkaar.
Als u tussen de standaard editor die
is uiterst linker, de ene dat is standaard geselecteerd,
en de twee overlappende cirkels elkaar, wat krijg je eigenlijk
zijn een dubbele vensters.
>> En dit is eigenlijk gaat om bruikbaar voor ons te zijn
wanneer we nodig hebben om artikelen te koppelen in de gebruikersinterface om de code.
En we zullen meer over praten dat in slechts een moment.
Maar beseffen dat als je nog meer ruiten als dit,
u kunt uw uitzicht gewoon te vereenvoudigen een beetje van terug te klikken
op enkele editor.
Tot nu toe alles goed.
Dus eigenlijk hebben we de code op links, attributen aan de rechterkant,
en wat het ook is we werken hier in het centrum.
>> Dus hier heb ik klikte op de belangrijkste storyboard.
En het storyboard, nogmaals, is een manier om in Xcode
dat je daadwerkelijk kunt maken van uw gebruiker interface met behulp van gewoon slepen en neerzetten
technieken.
En dus voor ons erg eerste toepassing dit
is precies wat we gaan doen.
We gaan naar beneden te gaan naar de zeer veel lagere rechter gedeelte
van het scherm, die bevat een verscheidenheid van de gebruiker elementen
die u vervolgens kunt klikken en slepen om uw gebruikersinterface te creëren.
>> Nu al deze elementen worden genoemd bekeken
omdat zij leveren een soort van uitzicht.
Er is een beeld uitzicht, voor bijvoorbeeld daadwerkelijk tonen
een beeld op de gebruikersinterface.
Er is een tafel te eigenlijk tonen een tafel.
Enzovoort, enzovoort.
Er is een grote verscheidenheid van uitzichten die je hier kunt selecteren.
Dus gewoon voor nu gaan we te zoeken naar een label.
Je kunt gewoon bladeren door alle van de lijsten die er is.
Maar er is de zoektocht bar aan de onderkant
dat maakt het gemakkelijker identificeren specifieke uitzicht dat je eigenlijk
willen slepen in uw gebruikersinterface.
>> Vond mijn label.
Ik ga het slepen hier, direct op mijn voorbeeld applicatie.
Daar in het midden ziet er goed uit.
En ik ga het type "Hello World!"
Druk op Enter.
Nu heb ik een label.
Het maakt niet uit als het is gecentreerd terecht.
Dus ik kan proberen om opnieuw te centreren.
Gelukkig biedt deze begeleidt om dingen veel gemakkelijker.
Ik ga proberen om het te compileren.
Hopelijk zal het eigenlijk hier.
En als dat niet het geval, in slechts een moment het zal wel degelijk op mijn iPad.
Het is hier.
Daar is het.
>> OK, dus dat is het.
We zijn klaar.
We hebben ons zeer gecreëerd eerste aanvraag.
Nu is dit natuurlijk niet om het even wat doen.
Het is gewoon een label.
Er is geen verband tussen de user interface en de code.
Dus als we eigenlijk wilden om deze verbinding te maken,
als we wilde eigenlijk een soort hebben De communicatie tussen de elementen
die bestaan ​​op de scherm en de code die
laat ons toe om te controleren deze elementen, dan
we eigenlijk nodig hebben om kijken naar de code zelf.
>> Dus dit is wat heet ViewController.swift.
En, vooral uw eerste paar programma's,
dit gaat om een ​​soort van de te grootste deel van de code die u enter--
zal in dit document hier.
Er is een heleboel dingen dat is hier tot nu toe, toch?
Er is import UI kit klasse, overschrijven, [? funk,?] al deze verschillende dingen.
En het is niet helemaal duidelijk wat is dat al deze middelen.
Dus laten we eens een stap terug weg van Xcode voor een klein beetje
en kijk naar de taal zelf, swift.
>> Dus met swift, het was in ontwerp en ontwikkeling
bij Apple voor ongeveer vier jaren aan mijn begrip.
En er zijn een paar functies erover dat zijn echt netjes.
Allereerst, het is samengesteld taal, net als C.
Dus moet je eerst compileren en voer het uit
voordat je daadwerkelijk kan uitvoeren van de code die het gevolg is.
Maar, in tegenstelling tot C, een interactief vraagt ​​dat je eigenlijk kan draaien
en typ willekeurige commando's in.
En heel graag een JavaScript-console, die u nu vertrouwd met kan zijn,
het daadwerkelijk zal beoordelen die commando's en aan u de output.
En ze hebben zelfs genomen dat naar het volgende niveau
en ze hebben iets gecreëerd riep speeltuinen in Xcode
die u in staat om visueel werken met code.
En we eigenlijk zien een aantal voorbeelden van die in slechts een klein beetje.
Het is gebaseerd op C. C is de grond het, omdat alle van de samenstellers
creëren code uit C en maken de objectcode van.
Maar het is echt aandelen relatief weinig syntax.
Het ziet er nogal anders.
Er zullen een aantal gelijkenissen.
Maar er gaan worden nogal wat verschillen
in vergelijking met, zeg, JavaScript of PHP.
En we zullen deze wijzen in slechts een moment.
>> Nu een van de grootste dingen over swift dat is leuk
is dat, zeker in vergelijking tot C, het is bedoeld om veilig te zijn.
Alles in het bedoeld is worden zeer sterk ingetypt.
In feite is het bijna vervelend in het begin, toen je voor het eerst
begint te werken met snelle, hoe hoeveel het afdwingt types overal.
Iets dat is een string moet een snaar blijven.
Het is erg moeilijk om te sorteren van de bekeerling het of dwingen het in een andere vorm.
>> En nogmaals, we voorbeelden van deze show.
Maar uiteindelijk beseffen dat Dit is bedoeld om je te beschermen,
en door u bedoel ik de code, uit crashen in sommige afschuwelijke manier waarop
je hebt een soort van niet-passende type.
En nogmaals, werken.
Omdat het frustrerend zal eerst als je probeert te achterhalen waarom precies
je krijgt deze ongewone fout omgaan met types.
Maar het zal de moeite waard op het einde.
>> Het behandelt wel automatische geheugenbeheer,
je dus niet meer doen hebben te maken met dingen
zoals malloc en vrij en alle van dit soort dingen.
En het is ook ontworpen voor algemeenheden.
Dus terwijl we een Xcode te kunnen gebruiken maken iOS-apps en Mac-toepassingen,
we kunnen ook gewoon gebruiken als een scripttaal.
En zo kunnen we het soort gebruik van de plaats van PHP of plaats
van Python om daadwerkelijk snel ontleden en te verwerken
sommige gegevens die wij hebben op onze computer.
>> Het heeft een breed scala aan moderne functies, opties die, veranderlijkheid,
generieke geneesmiddelen, sluitingen, en veel van deze dingen die je wel of niet herkennen.
En het is gewoon een soort van een ongelukkige deel van de taal die sommige
soort van futuristische, moderne elementen die zijn opgenomen in de elementen
zo diep geworteld dat ik eigenlijk wil hebben om je te leren CS50.5 een beetje.
>> We moeten een beetje meer te leren over enkele functies in orde
om echt te begrijpen wat er gaande is op en zodat u kunt kijken naar code
en niet het gevoel totaal verloren.
En je zult zien wat ik bedoel door die in slechts een minuut.
OK, dus let's-- genoeg van dit soort theoretische spullen.
Laten we eigenlijk kijken naar onze allereerste snel programma.
Het is een regel code.
Lijn 14 hier, het zegt afdruk l n hallo CS50.
>> Dus er is een paar dingen dat is heel anders over vergeleken
om dingen die u misschien wel gebruikt vanaf, bijvoorbeeld.
Een daarvan is dat er geen intmain, er is geen omvatten sectie,
er is geen van deze extra dingen.
De omvatten, zoals standaard I / O, zoals bibliotheken
die daadwerkelijk zorgen voor de standaard functies van de taal,
worden automatisch opgenomen als onderdeel van de standaard bibliotheek swift's
en die worden automatisch geïmporteerd.
Je hoeft niet te doen dat import handmatig.
>> Intmain bestaat niet omdat de belangrijkste toegangspoort voor de code
is effectief ter begin van de code.
Dus elke code die je hebt vanaf het begin
daadwerkelijk zal worden uitgevoerd bij de start.
Dus dit is echt sterk vereenvoudigd.
Merk ook, dat er geen puntkomma.
Er is geen puntkomma's in deze taal.
Je zet een verklaring op een afzonderlijke regel
en dan de volgende regel vertegenwoordigt het andere verklaring.
Als u wilt zetten mulitiple verklaringen online,
dan heb je scheiden door een puntkomma.
Maar voor het grootste deel, voor goede stijl, we zijn
nooit te puntkomma zien het doel van het scheiden statements
in swift.
Dus hoe werkt dit eigenlijk?
Wel erg veel op C we eigenlijk een compilatie.
En zo kunnen we dat doen met behulp van swift c en dan 1.Swift.
En dan na een paar minuten zal dit compileren
en dan kan ik lopen punt één.
En dan zal het gewoon zeggen "Hallo CS50."
Geweldig, dus daar gaan we.
Daar is onze eerste Hello World programma.
Laten we verder gaan naar nummer twee.
>> Nu in dit-- dit is veranderd lichtjes, want terwijl je normaal
doen-- in feite altijd heb je te een snelle toepassing voordat je compileert
eigenlijk het-- één run van de grote kenmerken
dat ik zinspeelde eerder was dat swift daadwerkelijk kan worden gebruikt in een soort
van een pseudo-interpretatieve modus is er in feite als een interpreter.
Maar wat dit zal doen, is er is in feite een snelle applicatie
die u kunt uitvoeren.
>> Dus bijvoorbeeld als je typt gewoon swift hier, wat er zal gebeuren
is dat u een melding krijgt.
En u kunt uw snelle typen code, te printen hallo, en voer het uit.
En het zal eigenlijk print-- nou ja, het is niet afgedrukt in dit geval
omdat deze gemaakt gecentreerd uit, die niet hier zichtbaar.
Maar het is eigenlijk in staat om te functioneren.
En dus in dit geval, ik ben gewoon gaat dit als script.
En ik kan eigenlijk deze code er draaien.
Dus de manier waarop ik in feite lopen het iets anders zal zijn,
maar je zult zien dat in slechts een moment.
Nu, in dit geval wat we gaan te doen is om eerst een variabele definiëren.
Dus dit is hoe we definiëren een variabele in vlotte,
wordt gebruik gemaakt van de verhuurde trefwoord, gevolgd de naam van de variabele,
en dan bieden we een aantal initialiseren van gegevens optioneel.
Dus dit geval zijn we het definiëren een constante genaamd naam
en we gaan gebruiken, dat in de output van onze printlijn
helemaal onderaan, hello naam.
>> Nu merken dat in plaats van% s, kunnen we de naam van deze kapselen
variabele / () en kunnen samenvoegen in de inhoud van deze
string in deze string.
Nu tegenstelling C, koord is werkelijke echte typ snel.
En zo is het, naast zit ints en langs
verdubbelt heel gemakkelijk en natuurlijk vergeleken
Om enkele van de andere talen die we hebben gezien.
Dus dit zou eigenlijk functioneren net zoals je zou verwachten.
>> Ik kan 2.swift draaien.
En we zien dat mijn naam is eigenlijk gesplitst in, "Hallo Dan."
OK, geweldig.
Verhuizen naar nummer drie.
Nu was het een beetje van een leugentje om bestwil dat ik
zei dat de manier waarop we verklaren variabelen was om de verhuurde trefwoord te gebruiken.
Zo vaak als u eventueel kunt u doen wilt gebruiken te laten, want wat dat doet
is het definieert een constante.
En dat snel dat het kan vertelt optimaliseren van de snelheid van uw aanvraag
omdat hij weet dat variabele is niet van plan om te veranderen.
>> Zo zorgvuldig evalueren wanneer je gaat gebruiken
een variabele voor de oog veranderen.
En als je gaat maak een variabele net
om een ​​aantal gegevens te houden en dat is niet echt gaan veranderen.
Dus dit concept van de onveranderlijkheid, het is niet echt gaat veranderen,
is een belangrijk, zelfs als ver naar beneden als het definiëren van variabelen.
Dus hier hebben we een naam gedefinieerd, Laat naam, en in dit geval
het is een constante, die van het type snaar, en is gelijk aan Dan.
>> Dus terwijl in de voorafgaande versie, het infers-- en door "het"
Ik bedoel swift-- swift leidt het type gegevens
dat we in de variabele hebt ingevoerd.
In dit geval kunnen we expliciet zijn.
Dus laat vervolgens de naam van deze variabele naam, dan een dubbele punt.
En na de dubbele punt doen we specificeert het type gegevens.
Dus het is niet langer int naam of string naam of iets dergelijks.
Maar in plaats daarvan laat label, we zijn bepalen of
het is een constante of variabele, gevolgd door de naam,
gevolgd door het type naar keuze.
>> Dus in dit geval zijn we het definiëren deze naam is een string.
We zeggen is Dan.
En nu heb ik een andere variabele, in dit geval heet het label.
Maar merken dat het voorafgegaan door de var trefwoord.
De var keyword middelen dat deze variabele kan
op een later moment worden veranderd tijd, ergens in de code
kunnen we eigenlijk veranderen en het zal niet geven ons een bepaalde fout.
>> We kunnen standaard concatenating doen operator hier gebruik van het plusteken
om daadwerkelijk toe te voegen onze noemen in deze string.
En dan kunnen we uitprinten zoals we zagen slechts een moment geleden.
Laten we nu eens zeggen dat je een variabele wilt maken
maar u wilt niet het nog initialiseren.
Je nog niet wilt zet alle gegevens binnen het.
Nou moet je vertellen swift wat de aard van de gegevens
gaat worden voordat je kan eigenlijk correct definiëren.
>> Dus in dit geval, wanneer we hebben gedefinieerd een variabele genaamd graad we moeten
expliciet over zijn soort, omdat het kan niet afleiden gewoon op zoek
de geïnitialiseerde data die u aan het.
Het zal ons een fout als u gewoon het type var rang, bijvoorbeeld,
omdat het geen soort dan ook.
Dus graad = 100.
Zodat 100 een geheel getal is past heel mooi in dat.
Het zal blijven functioneren.
We kunnen zien hoe dan wij kunnen deze samenvoegen in.
Nu u misschien wel verleiding, als je werkelijk
wilde het aaneenschakelen leerjaar in een andere tekenreeks,
in andere string, dat je zou gewoon Gebruik diezelfde concatenating operator.
En dat zou normaal gesproken waar zijn.
Maar snel zal je niet laten impliciet veranderen de aard van de gegevens.
Dus in dit geval, dit lijn, 25, zal mislukken
omdat rang een integer en niet een string.
En dus is er een mismatch set van soorten.
Dus je moet expliciet te zijn wanneer wilt u deze gegevens te wijzigen,
wanneer u dit wilt dwingen gegevens in een ander type
en zeggen: OK, ik wil nemen deze kwaliteit, die een integer,
en te converteren naar een string.
>> Dus ik een hoofdletter s String nemen alle van de soorten, zult u merken, worden geactiveerd,
Int, Dubbele, String, enzovoort, enzovoort.
Allemaal zijn gekapitaliseerde alleen maar om dingen makkelijker te maken.
En we zullen zeggen kapitaliseren String overgaan in het leerjaar.
En het zal creëren touwtje uit dat integer.
En dan kunnen we samenvoegen de twee zeer mooi.
Heeft u vragen over dit soort dingen tot nu toe?
Oké, laten we ploegen door naar nummer vier.
>> Laten we nu praten over een aantal meer geavanceerde structuren, zoals arrays en loops.
En in tegenstelling tot C, arrays in swift worden niet vertegenwoordigd door pointers.
Wijzers in swift, hoewel ze bestaan, genaamd
als onveilig pointers of sommige gelijkaardig type als dit,
ze zijn niet normaal blootgesteld aan u.
Dus wordt het zeer moeilijk voor u om te manipuleren
het geheugen rechtstreeks van uw computer.
>> Dus arrays zijn slechts een type data.
En ze zijn verwezen met behulp van dit soort van nu standaard vierkante haakjesnotering
die u eerder hebt gezien.
Maar als je eigenlijk wilt definieert een type variabele
als een array van enkele bepaald type, dan moet je
zet dat soort vierkante haakjes.
Dus wat ik hier zeg is dat Ik ben het creëren van een variabele genaamd
kwaliteiten van het type int array.
En ik ben het opzetten dat gelijk is aan een aantal geïnitialiseerde gegevens, die in dit geval
is 100, 0, 90, 85, dat is gewoon een verzameling van willekeurige cijfers hier.
Nu in dit geval ik kon, vergeet niet, verwijder dan de soort,
en het zou in staat om het af te leiden zijn op basis van de gegevens geïnitialiseerd.
Maar als ik verwijderd dit en Ik nodig om het later te stellen,
dan zou ik moeten ervoor zorgen dat ik de soort daar.
Oké, laten we gaan samen.
Dus we can-- arrays aan ons een verscheidenheid
van methoden door die puntnotatie bij u waarschijnlijk nu vertrouwd met.
Dus grades.count bijvoorbeeld vertelt precies het aantal
elementen die op deze array.
>> Als ik wil additional-- toevoegen merk nu dat dit een var
en niet-- dit is een variabele en niet een constante, die
betekent dat ik de inhoud kan veranderen van deze array, kan ik objecten toe te voegen.
Maar ik kan niet zomaar kwaliteiten zeggen en dan tussen vierkante haakjes
vier, want dat zal zijn een out of bounds fout in dit geval.
Als ik wil eigenlijk verandering de grootte van deze matrix,
Ik moet de stip append methode gebruiken om iets toe te voegen aan het einde van het.
Ik kan echter verandering individuele indices.
>> Zo kon ik kwaliteiten gebruiken en dan vierkante haakjes
nul tot deze eerste index manipuleren en enzovoorts, zoals je normaal zou verwachten.
En ik kan het zelfde om daadwerkelijk te doen ontvangt de gegevens van dat ook.
Nu is er ook een soort van een fancy-methode om dit te doen, kwaliteiten plus gelijken
en dan nog een index, die append--
of niet een andere index-- maar een andere lijst die
zal die lijst toe te voegen aan de achterkant van rangen.
En de kwaliteiten zal bevat dan dat alles.
Maar dat is een soort van een extra ding dat ik ben gewoon te laten zien voor de lol.
>> Nu is er een lus.
Dit is het begin waar dingen beginnen om een ​​beetje te veranderen.
Merk op hoe deze lus is anders dan voor loops in C.
Nu zal ik er rekening mee dat voor lussen in Swift kan
worden gemaakt om te kijken als naar lussen in C, maar er is veel nuttiger constructies
die in wezen overbodig te hebben voor var i gelijk is aan 0 puntkomma i
minder dan uiteenzetten, zo voort en zo verder, toch?
En deze constructie is slechts een van hen.
>> Voor de index, index is nieuw variabele, in casu het bereik.
En wat ik zeg is dat er een bereik van 0 helemaal tot aan
maar niet met inbegrip van grades.count.
Dus dit punt minder dot dan teken vertegenwoordigt
een bereik van waarden vanaf nul helemaal tot aan grades.count minus 1.
Er is een aparte operator die er bestaat,
dat is dot dot dot, wat zou betekenen dat ik wil dat het bereik van nul
in klassen tellen inclusive.
>> Maar in dit geval, omdat deze arrays zijn nul-index, die we natuurlijk
willen niet naar de maximum aantal kwaliteiten.
Ik kan samenvatten van de kwaliteiten, zoals je misschien verwachten, en output allemaal van dit spul.
OK, bewegen op.
Laten we nu praten over de functies.
Teneinde een functie te definiëren u de funk trefwoord te gebruiken.
En nogmaals, in Swift moet je heel voorzichtig zijn met het typen.
Die u verstrekt aan deze parameters mee door het definiëren, bijvoorbeeld,
de naam van de parameter en Vervolgens Colin, het type gegevens
dat je verwacht dat parameter te accepteren.
>> Dus in dit geval hebben we een functie genaamd afdruk leerjaar tellen.
Het accepteert een variabele genaamd cijferlijst, of liever een parameter genaamd cijferlijst.
En wij verwachten dat cijferlijst een array van gehele getallen.
Als dat cijferlijst leeg is, zullen we een ding af te drukken.
Anders zullen we het aantal af te drukken cijferlijst dat dit eigenlijk.
>> Als we nu willen terugkeren bepaalde waarde, dan de manier
we passen deze definitie om daadwerkelijk gebruik maken van deze pijl trefwoord,
of om deze pijl betekenaar gebruiken.
We dus hier gaan om te definiëren een functie genaamd gemiddeld.
We gaan een lijst van nummers te accepteren.
En we gaan naar een terugkeer dubbel, die hopelijk
als gemiddelde van deze array.
En om dat te doen, teneinde om daadwerkelijk te berekenen dit gemiddelde,
zullen we een som te nemen en wij zullen van Natuurlijk vatten alle objecten
binnen deze array.
>> Merk op dat er een nieuwe stijl van de for-lus hier.
We hebben niet expliciet over te zijn itereren over elk afzonderlijk element,
maar we kunnen in plaats daarvan zeggen voor rang en cijferlijst, betekenis
dat voor elk item dat wij hebben in deze,
bepalen dat artikel in deze variabele genaamd leerjaar.
En ik wil er iets mee doen.
Dus ik ga al deze gegevens samen te vatten en eigenlijk terug de dubbele divisie.
>> Merk nu weer hier is er de concept van de integer deling in Swift.
Als u wilt divisie verdubbelen want je wilt decimalen,
dan moet je expliciet te zijn, niet alleen over de ene kant,
want het gaat niet om u te laten gegevens aan beide zijden van deze dwingen,
je moet eigenlijk natuurlijk beide zijden in dubbelspel
zodat je erg expliciet over het ervoor zorgen
dat je doet dubbele divisie.
>> Laten we verder gaan.
Dus als ik eigenlijk willen accept-- dus in dit voorbeeld,
dit is nog steeds een opdracht lijn-gebaseerde applicatie.
En we beginnen om een ​​aantal van zien de beperkingen van de jonge taal
dat hoewel we kunnen toegang krijgen tot de argumenten met behulp
dit process.arguments, het is nog niet noodzakelijkerwijs de schoonste
ding dat we ooit hebben gezien.
Maar in principe Ik moedig u naar soort van kijken naar deze code
en proberen te achterhalen wat er precies aan de hand is.
>> Wezen wat er gebeurt is dat we nemen een lijst van argumenten
en waren ze te dwingen tot gehele getallen, en dan zijn we
gaan gebruiken als een manier om afdrukken uit het gemiddelde van al onze kwaliteiten.
Verdergaan.
Nu is er een ander type data-- andere gegevens te typen in plaats van arrays
genaamd woordenboeken, die zeer zijn vergelijkbaar met tabellen of hash kaarten hash
en lijken ook Associatieve arrays PHP.
Zo hebben zij de notie van sleutels en waarden.
>> En ze zijn ook met gedefinieerde dit plein haakjesnotering,
maar het verschil dat woordenboeken
binnenzijde van de rechte haak een dubbele punt.
En het colon scheidt de gegevens typt dat is de sleutel en de waarde.
Dus in dit geval, ik ga maken een woordenboek om een ​​aantal kwaliteiten te accepteren.
En het gaat worden van het type string: int,
hetgeen betekent dat alle sleutels zullen strings,
en alle waarden van de sleutels zullen integers.
>> Wat dit betekent is dat ik kan referentie dan de specifieke data
dat wil ik met behulp van deze toetsen in plaats dan met behulp van numerieke indices zoals ik
zou een standaard array.
Laten we nu zien, is er een belangrijk ding
dat wil ik ook vermelden over dit specifieke volgorde van de code.
En dat is dat er Andere soorten gegevens,
of liever, er is dit idee van gegevens die
vervat in Swift genoemd optionals.
>> En wat opties die betekent is dat zij erkent het feit
dat je soms gaat niet krijgen de gegevens die je eigenlijk verwachten.
En dus wat ik bedoel met dat is-- laten neem een ​​kijkje op deze opeenvolging van code
die itereert over alle van de argumenten die werden doorgegeven aan deze code
en probeert om te zetten, probeert te splitsen in een aantal snaren,
omdat aanvaardt een bepaald type argument.
En dan is het gaan proberen te dwingen de snaren die getallen
in gehele getallen die zijn kwaliteiten, dat ik dan kan berekenen.
>> Dus eigenlijk ga ik Gebruik deze split functie die
bestaat binnen de Swift standaard bibliotheek.
Ik ga om te gaan in het de snaar die ik wil splitsen.
En het gebruik van deze soort van funky syntax, die
Ik weet niet of we zullen krijgen, maar misschien zijn we
daadwerkelijk zal specificeren de precieze karakter dat we willen splitsen op.
Dus wat heeft dit er eigenlijk uit?
Laten we eens een kijkje nemen op daadwerkelijk uitvoeren van deze code.
>> Dus bijvoorbeeld, laten we zeggen dat ik heb een quiz en ik kreeg 50 op dat.
En ik heb een PSETs en Ik kreeg een honderdtal op dat.
En ik got-- er is een andere quiz en ik kreeg een 40 op dat.
Ik druk op Enter, en uiteindelijk wat zal gebeuren is dat wat het doet
is het nemen van deze parameters, splitsen de snaren bij deze dubbele punten,
het besef dat er twee elementen in elk,
en het is in wezen bijhouden van elk.
>> Dus ik heb in mijn woordenboek een quiz, wiens waarde wordt vertegenwoordigd door het getal 50,
Ik heb een PSET die waarde van 100 heeft, en een quiz een die een waarde van 40 heeft.
Vervolgens later in de code die ik eigenlijk gemiddeld al deze waarden
en een lijst van alle van de sleutels van dat bepaalde woordenboek.
Maar dit is belangrijk zodat u kunt zien
wat er gebeurt, is dat wat we willen doen is om deze string te nemen
en splitsen het op dit karakter, die we weer kunnen doen met deze split
functie met behulp van dit soort interessante syntax die hier bestaat.
>> Net voor nu aannemen dat dat is OK.
We zullen meer op dit kijken in slechts een tijdje.
Maar nu is er een interessante aspect dat we eigenlijk
willen proberen dit om te zetten string in een integer.
Maar in andere talen wat er kan gebeuren is
dat we zouden waarschijnlijk proberen om het te doen en ofwel terug te krijgen
een soort van sentinel waarde als negatief
of misschien een nul of iets dergelijks.
Of misschien zou het gewoon een fout heeft veroorzaakt.
En we zouden moeten vang dan die fout
en dan proberen te doen iets gebaseerd op het feit
dat deze omzetting een integer mislukt.
Dat is waar dit idee van de opties die binnen komt.
Je kunt eigenlijk het creëren van een soort data dat is een int vraagteken, bijvoorbeeld.
Dat betekent dat deze integer is in feite optioneel.
En wat zal gebeuren is dat het kan bevat een geheel getal, of het kan niet.
Het kan in feite zijn dit andere idee, helemaal genaamd nill.
Waarin dat betekent dat er geen enkele waarde in deze.
Het is zelfs niet nul, er is gewoon geen waarde.
Er is absoluut geen waarde vertegenwoordigd.
>> En dat is wat deze lijn 71 aan het doen is.
Is dat het is te zeggen dat ik willen proberen om een ​​waarde in te stellen,
een variabele genaamd rang, gelijk aan de omzetting van deze string in een int.
Dus ik heb deze string genomen, deze eerste onderdelen,
of liever de tweede componenten, omdat
nul geïndexeerd, dit string die ik heb te splitsen.
En ik wil omzetten die naar een integer.
Maar het kan niet altijd doorgaan normaal, want stel
wat zou er gebeuren als, in plaats van het type een nummer, typ ik natuurlijk als asdf.
>> Het zal mislukken.
Het is niet echt gaat worden kunnen zetten die een integer
zoals ik zou verwachten.
Dus in plaats van de aftrap een soort van een fout,
hebben we dit idee van een optioneel.
En dat betekent dat het gebruik van Dit vraagteken wat ik kan zeggen,
OK, is het mogelijk dat ik kan nemen dit, omgebouwd tot een int,
en zet het in een variabele, die ook een int.
Zo ja, dan betekent dat dit gelukt is
en deze eerste portie het blok kan blijven.
>> Anders is het mislukt.
Er is geen waarde in grade-- of plaats is er geen waarde in de bestaande,
en ik heb eigenlijk proberen om behandelen deze fout staat.
Je gaat om dit te zien vraagteken hele tijd
in Swift en voorbeeldcode voor Swift.
En in feite de nill operator, dit soort van vraagteken, de opties die deel,
zal waarschijnlijk een van de moeilijkere dingen
naar soort wikkel je hoofd rond als je eigenlijk werken.
>> Het is misschien zinvol nu maken.
En in feite, toen ik het schrijven van voorbeeldcode voor deze,
zeker begreep ik wat er gaande was,
maar nog steeds gevangen me door verrassing om zo vaak
als ik zou vinden dat sommige gegevens was eigenlijk
een nul-versie, een optionele versie van de gegevens die ik verwachtte.
Dus gewoon beseffen dat als je hebben een optionele versie
je moet uitpakken dat gegevens uit dit vak.
>> Dus het is een beetje zoals Ik-- stel je voor als je een doos en het iets bevat.
En wat je moet doen is om de vraag te stellen,
is het mogelijk dat deze box eigenlijk bevat de gegevens die ik zoek?
Als dat zo is, trek dan de gegevens uit en zet het in deze variabele bestaande.
Zo niet, dan moet ik gewoon geen rekening met de inhoud van deze doos
helemaal omdat bevat letterlijk niets.
>> Heeft u vragen over dit?
OK, laten we af te stappen van deze soort command line gebaseerde ding
en gaan kijken naar sommige van de techniek
dat Xcode biedt aan ons in de vorm van speeltuinen.
Dus er is een heleboel mogelijkheid hier met Swift.
En als je het openstellen van Xcode en het vraagt ​​wat u wilt doen,
kunt u het openstellen van de speelplaats en gewoon spelen rond
met veel verschillende structuren en aspecten van de taal
voordat je zelfs beginnen te raken de iOS SDK of de Mac SDK.
>> Dus dit geval, laten we zeggen dat ik have-- Ik heb een vrij gekunsteld voorbeeld
hier, maar geduld met mij als we een soort van werken door middel van dit voorbeeld.
Laten we zeggen dat we moeten veel doen exponenten met een vaste waarde,
als we weten dat we gaan moeten doen veel vierkante bevoegdheden, bijvoorbeeld.
Dus we gaan naar een bepaalde waarde te nemen x, gaan we naar het plein,
we gaan om een ​​bepaalde waarde te nemen y en we gaan het plein.
Enzovoort, enzovoort.
>> Nu zouden we eigenlijk gewoon een macht van 2-functie voor deze, toch?
Dus zouden we een macht van 2-functie te creëren.
We zullen instemmen met een dubbele.
We zullen output-- of we terug van een dubbele type.
We zullen dit resultaat te nemen en dan twee keer
wat we eigenlijk de resultaten, neem die werd geïnitialiseerd op de waarde één,
en vermenigvuldigen met x.
Dus in wezen hebben we x keer x hier.
>> En dus dan kan ik dan, als we zouden kunnen verwachten, neem dit, lopen macht van 2,
bieden om het aantal gegevens, ik hou van 2,0.
En we krijgen om de resultaten hier 4.0 zien.
Run kracht van 2 op 3,2 en we krijgen op ons resultaat, 10.24 te zien.
So far so good, toch?
Nu we denken, nou ja, OK.
Nu heb ik eigenlijk nodig om doe heel veel van de bevoegdheden van de 3.
Dus zal ik kopieer en plak dit allemaal code, verander de naam van de functie van
vermogen van 2 tot de macht van 3, en alles Dezelfde behalve deze waarde
Hier, dit bereik, 1 ... 2.
>> Dus in plaats van het herhalen van deze lus twee keer,
Ik wil deze loop drie keer te herhalen.
Dus ik verander gewoon dat de waarde van 1 tot 3-- of liever 2-3.
Dus nogmaals, dezelfde code, dat is de enige verandering.
Nu werkt dit ook.
Power of 3 indien aanwezig waarde 2.
We krijgen 8.
Dus 2 in blokjes.
En 3.2 blokjes is 32,768.
En tot nu toe zo goed, toch?
Maar hopelijk is dit een beetje beetje een rode vlag voor u
in dat we nu hebben sommige duplicatie van code
behalve enkele zeer kleine van de ene naar de volgende.
Dus is er een manier we zouden kunnen vereenvoudigen
dit probleem, waar we kunnen eigenlijk, tijdens runtime, erachter te komen wat,
te verstrekken aan ons enkele functie die heeft juist de kracht van dat we willen.
>> En er is dit idee van sluitingen, die is echt, echt
belangrijk in de context van Swift, en in vele andere talen.
Maar waarschijnlijk zul je zien het vroeger meer in Swift
want het is ingebed binnen de taal
dan wel in andere Ook moderne talen.
Dus het idee van een sluiting Hierdoor, is dat we
een functie die bedoeld is om zijn een generieke functie, een generieke macht
van de functie.
>> En deze functie zal accepteren Deze exponent dat we eigenlijk
wilt maken.
Dus bijvoorbeeld, de eerste Zo wilden we een macht van 2.
Dus zouden we de macht van bieden en daarna tussen haakjes 2.
En let nu op wat dit ook daadwerkelijk terugkeert.
Dit neemt een ingang van een primer genaamd y dat een geheel getal,
en het terugkeert dit gek op zoek ding in parentheses-- haakjes
dubbele pijl en dubbelklik.
>> Wat dit betekent is dat ik ben naar een functie weer.
Ik ben niet terug een ander type van gegevens, ik ben
in feite een functie oplevert dat heeft deze parameter, dat
accepteert een dubbele als input en voert een dubbele als een terugkeer waarde.
En als gevolg daarvan, want nu heb ik geroepen macht van, passeren in een bepaalde waarde voor y,
en ik ben deze andere creëren function-- bericht dat er
een andere functie dat wordt gecreëerd binnenkant van dit-- wat ik doe
wordt kan ik dan veranderen die waarde, dat men
waarde dat ik veranderd was 2-3, I maken het nu y.
>> En dit aanhoudt.
Dus elke keer dat ik bel de macht van, in wezen wat er gebeurt
is dat ik terug een functie.
Merk op dat ik hier heb gedefinieerd een nieuwe variabele genaamd plein.
Ik heb ingesteld dat gelijk is aan de macht, mits deze waarde 2 tot de macht van.
En wat dit terug is de functie.
Dus plein, de variabele plein, is nu van het type functie
dat heeft dit-- oops, bladert u omhoog een weinig bit-- dat deze handtekening heeft,
instemmen met een tweepersoonsbed en de output van een dubbele.
>> Dus nu wat ik heb gedaan is ik heb in wezen
creëerde een functie genaamd plein dat aanvaardt geen enkele waarde en zal het plein.
We kunnen zien wat hier beneden gebeurt.
Vierkant 3 bijvoorbeeld, betekent dat ik ga om de waarde 3 te nemen en in het kwadraat het.
Dus hoe precies werkt dit?
Toen ik pas kracht van 2-- toen ik passeren 2 in deze macht van de functie,
deze variabele y bevolkt met die waarde 2.
En dat is een soort van in het geheugen bewaard.
Dat is een beetje zoals gehouden in staat ergens in de computer,
we niet echt schelen hoe of wanneer op dit punt.
>> Maar ik deze functie terug riep machtsverheffen.
En nogmaals, het maakt eigenlijk niet uit Wat deze functie wordt aangeroepen,
kunnen we echt noemen het iets, dat accepteert een tweepersoonsbed en geeft een dubbel,
maar gebruikt deze waarde y erin.
Dus ook al is deze functie, Dit exponentiater functie dat is
is terug terug naar mijn variabele die ik noemde plein,
het is opgenomen in het deze notie van wat y was.
En het herinnert zich dat.
>> Dus elke keer als ik bel die functie dat heet nu vierkant, het maakt gebruik van dat.
Maar dit betekent ook dat ik kan maakt u een andere variabele met behulp van
een andere kracht van.
Dus ik kan een kubus variabel te maken, voor Zo bieden om het vermogen van 3.
Nu kubus zal eigenlijk wel wat waarde en de kubus die en terug te sturen.
Dus we kunnen zien dat ik krijg een waarde 8 van dat.
>> Maar die waarde y niet veranderd omdat ze
gehouden soort onafhankelijke variabelen.
Ze zijn soort gehouden in onafhankelijke ruimtes in het geheugen.
Dus kubus zal altijd x tot de macht 3.
En plein zal altijd x tot de macht 2, waarbij
betekent dat plein zal altijd vierkant nummers, zoals ik verwacht.
En kubus zal altijd in blokjes gesneden getallen, zoals ik verwacht.
Dit betekent ook dat je soms kunt krijgen een soort van funky zoek syntaxis
waar heb je de macht van de zeer onderkant van het scherm hier, kracht 5.
En je overgaan in het resultaat.
Noem je dat de functie dat is is terug met het nummer 4.
En ja, wat in wezen dit 4 tot de vijfde macht,
we kunnen de resultaten daar te zien.
Met mij tot nu toe?
>> Dus dit idee wordt een sluiting, want wat we eigenlijk aan het doen zijn
is dat we het inkapselen sommige gegevens into-- soort
omsluiten deze gegevens in een functie en we zijn
kunnen deze functie opnieuw.
Nu is deze syntax al kan eigenlijk vereenvoudigd een grote hoeveelheid.
En er is veel mogelijk in Swift voor deze vereenvoudiging.
En dat is wat voor soort het daaropvolgende degenen eigenlijk naar te kijken.
Dus in 7b we bijvoorbeeld neem deze exact dezelfde code.
>> Maar nu plaats een functie in de praktijk te definiëren
binnenkant van deze kracht van functioneren en geef het een naam,
en dan terug de naam van die functie, hetgeen
vervolgens wordt gebruikt als onderdeel van deze sluiting, in plaats daarvan zijn we
gewoon gaan om het te vereenvoudigen.
We hoeven niet deze functie worden benoemd.
Dit is dus het begrip anonieme functie waar we kunnen dan
accepteren als invoer haakjes hier de variabele x die is van het type double.
>> We gaan naar het type double terugkeren.
En dan is het sleutelwoord, n, is het begin van deze functie.
Zo merken dat dit alles is binnen accolades
en we zijn het definiëren van een anoniem functioneren hier.
Gewoon een eenvoudigere manier van vaststellen van de precieze hetzelfde.
OK?
Maar wacht even, Swift laat ons eigenlijk om verder te gaan en nog meer te vereenvoudigen,
omdat we echt niet doen zorg dat deze parameter is
noemde een bepaalde zaak.
Het kan echt iets te noemen en kunnen we nog steeds gebruik maken van die eerste parameter.
>> Dus in feite is er deze speciale soort gegevens in anonieme functies,
er is deze bijzondere naam van variabelen in anonieme functies
die beginnen met de dollarteken en vertegenwoordigen
de parameter getallen nul geïndexeerd voor deze functie.
Dus er is een paar dingen aan de hand.
Hier ga ik om terug te keren, en dan een accolade die een functie,
toch?
>> Merk op dat ik niet hebt gedefinieerd de parameter types of de return type.
Het kan zelfs worden afgeleid vanwege de handtekening
van deze oorspronkelijke functie.
Dus we kunnen elimineren dat als mogelijkheid.
Maar ook kan ik dollarteken nul gebruiken om vertegenwoordigen deze eerste parameter dat is
overgegaan in deze anonieme functie.
Dus vereenvoudigen het nog meer.
OK?
Tot nu toe alles goed?
>> Nu is dit Motortype- doe je onthoud dit dollarteken nul
die we zagen in deze accolade dat zagen we gewoon een tijdje
geleden in deze Swift zes voorbeeld?
Het was hier.
Merk op dat is precies wat we kijken naar,
is dat wij overgegaan in deze split-functie
een anonieme functie die controleert de eerste parameter
om te zien of deze gelijk is aan de dubbele punt.
En dat is precies wat er gebeurt, is dat alle
we doing-- de terugkeer trefwoord wordt geïmpliceerd
in deze case-- we terugkeren deze waarde waar we het vergelijken
de eerste parameter tegen dit karakter dikke darm.
En dus dat soort demystifies dit.
En je gaat deze constructie zien veel in Swift syntax, dus doe houden dat
in gedachten wanneer u bent het nemen van een kijkje op deze.
Nu kunnen we uitstappen de rails een beetje
en ga echt zin dat shows nog wat meer van kracht Swift.
Je zou zelfs een aantal te zien van deze in de steekproef van codes.
Dus dat is de reden waarom ik ga om dit te laten zien.
>> Eigenlijk wat we kunnen doen is dat, ten eerste van alles, het was een soort van onnodig voor mij
om al die macht van de uit te voeren code want als je importeert de Darwin
bibliotheek, het eigenlijk een functie omvat riep pow dat dit voor je doet.
Zodat we het kunnen vereenvoudigen nog meer en hebben onze macht up functie nu net
zijn een prachtige one-liner waar we net terug deze anonieme functie die
aanvaardt dollarteken 0 als zijn base en y als exponent.
>> Maar we kunnen echt, echt zin als we
beseffen dat Swift heeft een veel kracht onder de motorkap.
Een groot deel van de exploitanten die we hebben te maken met,
plustekens en verdeeldheid symbolen al deze dingen die je normaal
werken met met datatypes in een programmeertaal,
zijn eigenlijk uitbreidbaar in Swift.
Dus wat dat betekent in dat wij kunnen onze eigen operatoren te definiëren.
>> Dus nu ben ik moe van het typen in dit alles pow en vervolgens een haakjes en dan
de basis.
Ik wil niet om dat te doen.
Ik eigenlijk wil een hebben operator die me in staat stelt om dat te doen.
Dus ik kan Swift vertellen dat ik wil aan een operator, ster creëren
star-- door de manier waarop ik kan de karaat niet gebruiken omdat de karaat is een operator die
doet iets heel anders.
Dus ik wil niet om te sorteren van botsen met die.
En dus wat je ziet in een verscheidenheid van talen, waaronder Python,
is als star star exploitant te exponenten vertegenwoordigen.
>> Dus dat is de enige reden waarom heb ik dat gedaan.
En het gaat worden een soort infix operator.
En ik moet bieden het enige informatie
over de voorrang van deze exploitant dus het is links associatief.
Het is als relatief hoge prioriteit in vergelijking
om optelling of vermenigvuldiging.
Het is een hogere prioriteit dan al die.
Enzovoort, enzovoort.
En dan heb ik bepalen de functie daadwerkelijk
dicteert wat deze operator doet.
Dus in de veronderstelling dat ik een linkse kant en de rechterkant,
hetgeen zou misschien betere variabele naam voor dit.
Linkerkant en rechterkant.
Ik kan dan deze bevoegdheid van de linkerkant naar de rechterkant
en terug te keren die waarde.
Dus nu is het super lief.
Het enige wat we moeten doen is 2 star star 3 en 2 tot de derde macht,
en krijgen we een waarde van 8.
2 star star 10 is 2 tot de 10e macht, krijgen we 1.024.
>> Dus nu onze macht van de functie, die opnieuw verschillend,
omdat het hele idee achter deze was dat we een functie die
duurt altijd even waarde en vermenigvuldigt het-- of liever
neemt de exponent op dezelfde stroombron.
Dus nu is het nog eenvoudiger.
Dus nu is het gewoon dollar aanmelden 0 star star y.
We hebben niet eens te pow meer gebruiken.
>> OK, wie heeft verloren?
Doen we OK?
Heeft u vragen over dit spul?
Yeah?
>> Publiek: Wanneer u krijge [onverstaanbaar] de funk macht y dubbel.
Dus als je een functie oplevert.
DANIEL Armendariz: Funk macht y dubbel.
Oh ja, ik weet het niet Wat de y getallen zijn.
Sorry daarvoor.
>> Publiek: Waarom bent u terug een functie [onverstaanbaar] behuizing.
Is niet dollar nul ster ster y [onverstaanbaar]
vinden dat operator met dat terugkerende dubbele [onverstaanbaar] verdubbelen?
>> DANIEL Armendáriz: Dus laten mij antwoord op uw vraag
hoe ik het begrijp en je kan mij vertellen als ik niet begrijp uw vraag.
Dus dit construct de accolade dollarteken nul star star y,
is een functie.
En een parameter die accepteert vertegenwoordigd door deze dollarteken nul.
De return sleutelwoord wordt geïmpliceerd in deze zeer korte, anonieme syntaxis van de functie.
>> Wat betekent dat in wezen wat dit zegt
is dat ik de definitie van een function-- en dan zal ik
noem het gewoon something-- waar heb ik enkele waarde y.
Ik heb y, wat het dubbele is.
En ik ben terug van een dubbele.
En ik heb in die terugkeer Y-- sorry, Ik zou niet dit Y-- x hebben genoemd.
Oh dear, oh dear, oh dear.
X-- nope-- star star y.
>> Dus dit is gewoon een vereenvoudigde versie van deze.
En dus is de reden dat ik heb dollar teken nul is dat het gebruik van deze behuizing
betekent dat ik niet meer naar pow te typen, of niet meer doen
Ik moet iets doen als 3-sterren ster 2.
Ik kan alleen maar een enkele functie genaamd vierkante
dat zal altijd enige waarde als input
en eigenlijk terug op het plein van dat.
>> Dus de hele doel van de sluiting om gewoon een soort van kapselen het feit
dat ik wil altijd y gebruiken wanneer Ik noem dat de functie als de kracht
bij het nemen van deze exponent.
Dus terug dan een functie die accepteert
een dubbele, die de basis en retourneren het resultaat van die exponent
is hier het sleutelwoord.
En dat is het grote verschil.
Er was gewoon een beetje een floreren.
>> Dit is niet anders vergeleken met de voorafgaande voorbeelden
maar het was gewoon een beetje een floreren we kunnen eigenlijk
zorgen voor een operator in Swift en werkelijk dingen mee doen,
dat is een soort van een cool ding.
Heb ik je vraag beantwoord?
Zoet.
Iets anders, voordat we verder gaan?
OK.
>> Nu dit soort smeekt de vraag is dat-- goed OK,
Nu hebben we de mogelijkheid voor functies worden geretourneerd.
Kunnen we ook functies als gegevens doorgeven of als parameters andere functies?
En in feite we kunnen.
Dus laten we zeggen dat we hebben allemaal van dezelfde code.
We hebben het plein variabele dat zal deze code vierkant.
En we hebben de kubus variabele dat zal een aantal gegevens kubus.
En we eigenlijk willen toepassen een breed bereik van getallen.
>> Dus wat we misschien geneigd te doen, natuurlijk wat zeker geldig
is te itereren over deze lijst van nummers en toe te passen mijn functies vierkant en kubus
en krijgt twee nieuwe lijsten als resultaat dat deze oorspronkelijke lijst kwadraat zijn
en in blokjes, respectievelijk.
Perfect aanvaardbaar.
Maar wat is de zaak die we hier zien is dat we hebben,
nogmaals, de verdubbeling van onze code.
En er is misschien een kans voor ons om dit een beetje te vereenvoudigen.
Wat als er een manier voor ons om eigenlijk altijd itereren over enkele lijst
en gewoon door te geven aan deze magische functie een variabele
is een functie die we willen toepassen
elke afzonderlijk product in deze lijst.
Dit brengt het concept van wat worden hogere orde functies genoemd.
En dat is in wezen wat dit is, is dat we een functie kunnen maken.
>> En in dit geval heet het een mapper, alleen maar om het een naam te geven, net
in kaart brengen over elk enkel item in een lijst.
Waar ik neem een ​​lijst en ik neem een ​​functie.
En die functie, natuurlijk heeft een bepaalde signatuur.
Het accepteert als parameter double en het zal de uitgang is een dubbele.
En het gehele resultaat van deze functie zal
om een ​​nieuwe lijst die is van het type double zijn.
OK?
>> En wat ik ga doen is deze functie f toegepast
om elk element in mijn lijst.
En reply-- en plaats deze nieuwe terugkeren lijst als resultaat, dat is echt cool.
Nu kan ik de functies rond passeren.
En dit idee van hogere orde functies is echt belangrijk.
En dit mapper is eigenlijk gewoon implementatie van de arme man
een functie die wordt gebouwd in Swift genoemd kaart.
En het doet precies dit, misschien zelfs een beetje beter.
>> Dit is gewoon een soort van een generiek, vereenvoudigde versie
laat ons toe om het te zien concept dat hier van toepassing.
Kijk nu eens naar de manier waarop ik daadwerkelijk kan toepassen mijn vierkante
en mijn kubus functies om deze lijst van nummers.
Ik run mijn mapper.
Ik geef het mijn lijst van nummers.
Ik geef om het de de functie dat gaat
om voor elk van deze indices.
En het gaat worden uitgang als resultaat.
En ik zal krijgen om te zien dat ik heb in het kwadraat en in blokjes mijn nummers als gevolg.
>> En natuurlijk de mapper zal nemen elke vorm van anonieme functie.
We kunnen zelfs zien dat ik heb gemaakt een nieuwe anonieme functie die
duurt slechts enkele parameter en deelt het door 2.
En we kunnen zien dat ik heb, in feite, verdeelde mijn lijst met 2 in plaats daarvan.
Cool?
Tot nu toe alles goed?
Oké, laten we nu terug te komen op dit idee.
Laten we voeren dit terug in de context van een cijferlijst.
>> En als ik dat doen, kunnen we zien dat ik kan een groot aantal van deze options-- toepassing
of een groot aantal van deze hogere orde functies
om mijn vermogen om een ​​doen eigenlijk te vereenvoudigen verscheidenheid van dingen op lijsten van getallen.
Dus bijvoorbeeld, als ik neem een ​​lijst van nummers,
een van de hogere orde functies dat bestaat heet verminderen.
Wat te verminderen doet nogal dan de kaart, wordt verminderd zal
neem twee elementen in de lijst, zal een functie te nemen dat
vergelijkt de twee elementen van de lijst en het zal dan
soort output-- de output van die functie
zal een element dat je dan vergelijken met anderen.
>> Dus je zou kunnen dit gebruiken om daadwerkelijk som van de getallen in de lijst.
Bijvoorbeeld, als je had Een lijst 1, 2, 3, 4, 5,
u de eerste elementen, 1 en 2 nemen.
U kunt toepassen om het een toevoeging functie dat deze twee elementen draait
en spuugt een van die elementen, wat zou de waarde 3 te zijn.
Dan nemen we die waarde 3 met de volgende element van de lijst, de som van deze twee,
en vervolgens door te gaan naar beneden in de lijst.
>> We zijn het verminderen van de lijst om een ​​enkele waarde.
En het gewoon zo gebeurt dat het plusteken
is een operator, net zoals we net zagen.
Deze operator is eigenlijk een functie die
heeft juist deze lijst die wij zou willen, in plaats van deze eigenschappen
dat we zouden willen.
Dus ik moedig u aan neem een ​​kijkje op deze.
Ik wil om te sorteren van de verhuizing op van een aantal van deze code
zodat we daadwerkelijk kunnen kijken naar een aantal werkelijke, echte, ware Swift in Xcode,
in iOS ontwikkeling.
Maar een kijkje nemen op dit en kijk of je kunt
ontleden door wat er aan de hand met sommige van deze hogere orde
functies, waaronder filter, te verminderen, en je zult zelfs
zie ergens hier in kaart ook.
Het is hier.
Waar het zal een opeenvolging te nemen kwaliteiten en het zal eigenlijk
in kaart te brengen met behulp van de schakelaar constructie, die u misschien herkennen uit C,
maar het is eigenlijk een veel meer krachtiger dan de switch constructie
dat we in C.
>> En we zullen toepassen op elk element in de lijst
en eigenlijk bieden de brief graad van elke
van deze cijfers met al deze concepten die we zojuist hebben gesproken over vroeger.
Laten we nu eens omzeilen voor slechts een minuut en praten over structuren.
En zo structuren zijn een wachttijd in C dat wij konden een nieuw type gegevens.
Structs bestaan ​​binnen Swift.
En dus doen veel andere constructies riep opsommingen en klassen, die echt
neem dit idee om een geheel ander niveau.
>> En eigenlijk is het gewoon een manier het definiëren van een nieuw type gegevens.
Dus als je get-- als je komt tegenover klasse of structuren of opsommingen,
niet in de war raken door het.
Het is gewoon de manier van het definiëren van nieuwe bepaald type gegevens.
En dit is echt belangrijk bij we praten over iOS app ontwikkeling
omdat alles wat bestaat binnen de iOS-app
is in wezen een object van een soort.
En een voorwerp is in feite een klasse of een enum of een structuur.
>> Dus in dit geval ben ik definiëren van een nieuw type gegevens
dat Ik bel beoordeling Dat is een aantal eigenschappen, waaronder
een naam en een opeenvolging van rangen.
Dus een soort van evaluatie dat ik zou kunnen hebben in het achterhoofd
quizzen, bijvoorbeeld zou zijn.
Ik zou willen een hebben beoordeling dat een quiz was
en dat een verscheidenheid aan kwaliteiten had verbonden dat voor een quiz,
quiz twee, enzovoort, enzovoort.
>> Of ik misschien een ander type hebben van de beoordeling voor probleem sets.
En ik kan dingen doen.
Ik kan eigenlijk functies binnen deze
gegevens, waarvan nu bekend methoden.
Dus als je ooit de woord methode, het is echt
is gewoon een functie die geldt een zeer specifieke klasse,
of een datatype.
Het stelt ons in staat om de gegevens binnen te wijzigen.
>> Dus met andere woorden, als ik wil toevoegen van een cijfer aan mijn beoordeling,
dan alles wat ik moet doen is om voeg de score die ingang was
deze functie mijn interne eigenschap.
Er is nog een nette constructie hier in Swift, dat is deze dot dot dot
operator, wat betekent dat scores kunnen Nu accepteren aantal gehele getallen.
En scores zullen een array van integers die
zijn doorgegeven aan mijn functie, die betekent dat ik dingen kan doen als dit.
>> Ik kan denk kwaliteiten toe te voegen en leveren alleen willekeurig aantal getallen erin
en eigenlijk worden een matrix van die waarden in mijn functie
of mijn methode, zoals het geval.
Nu is dit belangrijk, omdat alles in Xcode, alles in iOS,
is in feite een object.
Dus hou dat in gedachten toen we buste geopend Xcode
en ga je verder dan iOS versies van twee en drie
en eigenlijk gaan naar versie vier.
>> En nogmaals, dit alles zal worden geplaatst op de seminar pagina.
iOS vier is een soort van een full blown implementatie van een zeer eenvoudige app.
En wat deze app doet is het laadt een UI, die er als volgt uitziet.
Nogmaals, als we op storyboard we kunnen zien dat dit is wat het lijkt.
Dit is de gebruikersinterface.
Het heeft een titel aan de top.
Ik heb het zogenaamde web gallery.
>> In het midden is er een element riep de afbeelding UI uitzicht.
En aan de onderkant is er een werkbalk met een enkele knop die
heeft rekbare ruimtes die het mogelijk maken om centrum in het midden van deze werkbalk.
En wat er gebeurt is dat wanneer deze laadt het een JSON-bestand dat is gedownload
die op een server elders ontleedt dat JSON-bestand,
en de JSON-bestand ziet er een beetje als dit.
De JSON-bestand ziet er als volgt uit.
Daar is het.
>> Het heeft een albumnaam en heeft een reeks foto's.
Elk van die foto's een naam en ook
een URL zelf dat het vertegenwoordigen jpeg versie van die individuele foto.
Dus wat gebeurt is dat wanneer dit programma belastingen, het de JSON-bestand downloadt,
ontleedt het, zet dit alles in het equivalent van een array in iOS
app ontwikkeling, dat is een NSArray.
En dan kan ik laad deze gegevens in een toepassing
en laad het op mijn scherm.
>> Er is een beeld dat werd geladen met de knop helemaal onderaan.
Als ik klik op Get Next Image, het dan trekt die afbeelding van het internet
en vervangt die afbeelding in het beeld UI uitzicht.
Dus je kunt deze downloaden en eigenlijk een kijkje nemen op het op uw computer.
En bouwen en eigenlijk compileren naar uw apparaat.
Maar in wezen het proces was dit, maak het storyboard--
of liever niet create-- maar selecteer het storyboard.
En eigenlijk we'll-- als je niet mind-- we gewoon een paar seconden duren
om daadwerkelijk te laten zien hoe dit werd gedaan.
>> Gewoon zo dat hoe we kunnen eigenlijk dit te bereiken wordt gemaakt een beetje meer
duidelijk.
Enkele weergave toepassing, ik ben ga dit seminar te bellen
vier vertegenwoordigen deze bepaald getal.
Opslaan op het bureaublad.
OK, gaat klikken op het storyboard.
En wat ik ga doen is om mijn imago uitzicht te vinden,
sleep het naar mijn gebruiker interface en centreren.
Nu alleen gecentreerd helaas is niet van plan om een ​​heleboel te doen,
behalve een scherm dat is precies deze grootte.
>> Dus we kunnen onszelf overtuigen dat door klikken op deze dubbele cirkel ding,
het terugdringen van deze pop up menu hier en veranderende
om een ​​voorbeeld, waar we eigenlijk de kans krijgen om te bekijken hoe
dit ook daadwerkelijk kijk op andere apparaten.
Zoals we kunnen zien, we doen niet eens zie het op dit specifieke geval.
Dus ik ga dit afsluiten.
>> En ik ga om te selecteren dit pictogram neer op de zeer
onderste gedeelte van het scherm.
Het zegt Resolve Auto Layout Vraagstukken.
Sorry, het is afgesneden aan de onderkant.
Maar als ik op dat, wat ik krijgen wordt deze pop up-- weggaan.
Wat ik krijg is deze pop-up die kan ik ontbrekende beperkingen toe te voegen.
En door te doen dat het zal dan een soort van op slot
in het middengedeelte van de scherm zoals ik zou verwachten.
>> Nu in om deze knop op te krijgen top van het, ik moet gaan naar de editor.
Ga naar verankeren in en klik Navigation Controller.
Wat dat zal doen, is die zal toevoegen deze hele andere component aan,
maar het zal eigenlijk verbinden het terug naar mijn oorspronkelijke UI.
En de details, nogmaals, we doen niet echt zorgen te maken over nu.
Maar ik wil wel een hebben werkbalk helemaal onderaan.
Dus ik zal Shows Toolbar controleren.
>> En dit biedt binnen mijn inziens die nu elders,
we kunnen zien dat dat verband houdt hier.
Het biedt nu een werkbalk onderaan mijn UI.
Dus nu, in plaats van het selecteren van een image view, kan ik een label te vinden,
of liever een toolbar-- laten we eens kijken, waar is dat?
Hoe heet het?
Een button-- punt bar-- item-- sorry-- bar knop voorwerp.
Plop dat er en pas een paar flexibele spaties naast
om daadwerkelijk te centreren dat.
Zo nu heb ik mijn UI gemaakt, in principe.
En ik kan het een naam geven door dubbelklikken op de top
hier en zeggen webgalerie en ga zo maar door.
Nu weer, dit zijn elementen die bestaan ​​op zichzelf.
En ik moet verbinden ze naar mijn code die
Ik kan doen door nogmaals te brengen tot deze cirkel icon dubbele,
het veranderen van de preview.
Die, door de manier, nu kunnen we zien is mooi gecentreerd en zal er goed uitzien
op verschillende apparaten.
>> Schakelen naar de automatische, die zal brengen de ViewController code.
En nu dit deel is belangrijk.
Om voor u om deze te sluiten twee elementen, de code voor de UI,
u het item te selecteren dat u verbinding wilt maken.
Dus in dit geval, we eigenlijk willen coderen
verandert het beeld dat is opgenomen binnen deze afbeelding UI uitzicht.
Dus als je de controle op uit De beeldweergave en sleep,
je zult merken dat je een kleine bar te krijgen, wanneer je laat gaan van alles wat deze pop
up zal optreden.
>> En dat zullen we zegt een verbinding te maken.
En vanaf hier wil ik het geven een naam, zoiets als galerie.
Druk op Enter.
En dit ook daadwerkelijk biedt een galerie variabele genaamd
dat ik dan kan verwijzen in mijn code om het beeld te veranderen, bijvoorbeeld.
Dus hoe werkt die code er eigenlijk uit?
Nou nogmaals, ik wil niet besteden te veel tijd op.
En ik moedig u aan downloaden en een kijkje nemen.
Maar een van de meest belangrijk aspect is de code
die daadwerkelijk haalt een beeld.
>> Dus in dit geval wil ik binnen mijn foto's te krijgen
matrix, die is opgenomen in mijn klas.
Ik wil definiëren de naam en de URL die is ontleed uit deze JSON.
Eigenlijk is het apparaat vragen om de te krijgen URL om de URL te halen uit deze,
en dan halen de gegevens van de inhoud van die URL.
Zet deze gegevens vervolgens in een beeld door het passeren van het in beeld UI.
Dus nogmaals, het zijn allemaal verschillende types voorwerpen, verschillende klassen.
>> En dan kan ik vervolgens mijn gallery.image gelijk aan die gegevens.
En dat is een soort van het vlees ervan die eigenlijk dan
in staat om de gegevens van-- verandering veranderen het beeld van de ene naar de volgende.
Dus nogmaals, hopelijk nu veel van de constructen
zal een beetje meer zin te maken.
Merk op dat er een aantal uitroeptekens hier.
De uitroeptekens zijn voornamelijk met betrekking tot de optionals.
>> Wat ik eigenlijk te zeggen is dat zonder zelfs te controleren
om te zien of er gegevens binnen deze optionele,
Ik ga om te gaan en veronderstellen dat er op en ontrafel het.
Vergeet niet dat we de analogie van soort van een pakket voor de opties die
en we moeten het uitpakken verpakking en trek de gegevens uit.
Het uitroepteken krachten die daadwerkelijk gebeuren.
>> Maar ik weet dat dit is veilig omdat ik gecontroleerd
om te zien of beeldgegevens gelijk tot nihil, heb ik eigenlijk controleren
om te zien of dat optioneel was in feite mislukt.
Als dat had in feite niet reeds.
En dus ik weet zeker dat als ik eenmaal aan deze punt dat ik kan veilig uitpakken die gegevens.
Je zou het ook zien in de vorm van een vraagteken.
Dus als we naar beneden scrollen naar waar ik moeten eigenlijk ontleden gegevens.
>> Dus laat je niet afschrikken door worden gezet dit soort lange namen.
U kunt vinden in de Apple developer site veel
verwijzingen naar alle voorwerpen en alle processen
dat eigenlijk dit mogelijk te maken.
Maar merk op dat dit in wezen een functie waar ik geef het aantal gegevens.
En ik krijg weer een soort van data.
En ik nodig om dit te gebruiken als zoekwoord om omzetten in dit NSDictionary?
Die weer is, een optionele NSDictionary.
Die ik moet dan controleren om te zien of het bestaat.
>> Dus ik kan gebruiken dat als laat succesvolle gelijken ontleed,
dan weet ik dat dat optioneel eigenlijk bevat een aantal gegevens.
Of wat ik hier deed was om gewoon aannemen dat als er
geen fouten waren dat het inderdaad veilig.
Oké, ik wil bedanken u allen hartelijk voor uw komst.
Ik weet dat dit was een stuk, maar het was slechts een uur
om te praten over een aantal vrij geavanceerde spullen.
En dus hopelijk heb je een te krijgen kans om alle code te downloaden
en neem een ​​betere, meer grondig te kijken naar het.
Soort overtuig uzelf van alle van de dingen die gaande is.
En ik wil je bedanken alles, nogmaals, voor het komen.
En veel succes met je laatste projecten.
Heb een geweldige dag.