>> [RIPRODUZIONE DI BRANI MUSICALI]
>> DAN AMRMENDARIZ: Tutti, benvenuti al seminario CS50,
iOS App per lo sviluppo di Swift.
Sono Dan Armendariz, e io sono un maestro di informatica qui a Harvard.
>> E la prossima ora sarà un tour di più oggetti
su questo argomento, come possiamo andare bene.
Io posto tutto il codice sorgente di che vedrete oggi on-line.
Potremmo non essere in grado di effettivamente andare su tutto
che sono che sono mostrando in questo momento.
Ma almeno si spera attraverso i commenti del codice sorgente,
sarete in grado di cercare di capire che cosa sta succedendo esattamente per queste cose
che non abbiamo abbastanza raggiungere.
>> In generale, la struttura di il discorso di oggi sarà il seguente.
Inizieremo fuori facendo un po 'di base sintassi con la lingua Swift,
entrare in alcune delle più avanzate sintassi del linguaggio Swift.
Perché la lingua è davvero moderno e
ha un sacco di alto livello caratteristiche, cose che non abbiamo
visto in C tutto CS50, o anche alcune altre lingue
che abbiamo iniziato utilizzando in CS50 come PHP,
così ho intenzione di avere a cercare di introdurre anche alcuni argomenti che
sono legati a linguaggi di livello superiore che non si può vedere in modo approfondito nel CS50,
ma si vedrà più tardi corsi di informatica.
Quindi sarà un fitto ora.
E non esitate a lasciarmi sapere se avete domande.
Quindi, se siete interessati a fare lo sviluppo
con Swift, o realmente qualsiasi sviluppo iOS app,
ci sono un paio di requisiti.
Prima di tutto, si deve essere con un Mac, in esecuzione negli esempi
che ci accingiamo a utilizzare oggi, una relativamente nuova versione di OS
X. In questo caso, sto correndo X 10.5.
È possibile eseguire 10.11 se si vuole.
Ma tutto ciò che si sta andando a vedere sta coinvolgendo Xcode 7 e versioni successive,
che ha l'ultima versione di Swift, che è Swift 2.0.
Questo è in realtà una bella distinzione importante.
Un sacco di sintassi ha cambiata abbastanza significativamente
in alcuni casi da Swift 1.0, che è stato rilasciato lo scorso anno,
a Swift 2.0, che appena uscito questo autunno.
Così stiamo andando a mostrare Swift 2.0.
Un sacco di cose che si cerca on-line
quando si sta cercando di ottenere ulteriori informazioni su una varietà di cose,
si potrebbe voler esplicitamente cercare Swift 2
piuttosto che semplicemente vecchio Swift fare assicurarsi che si ottiene la sintassi corretta.
>> In realtà, questo è generalmente vero.
C'è un rapido quantità di sviluppo accade nella lingua Swift
da quando Apple ha rilasciato, credo che cosa, è stato un po 'più di un anno
adesso.
E le cose sono cambiate drammaticamente in quel momento.
E quindi non essere frustrato se, quando si sta guardando in giro
per argomenti su Swift o di come realizzare qualcosa usando qualche esempio di codice
o qualcosa che non fa effettivamente lavorare su Swift 2.0.
Assicurarsi che si sta cercando in particolare per quella versione
per cercare di ridurre al minimo gli effetti di diverso le versioni e questo genere di cose.
>> Cercherò di indicare solo alcune cose che sono diverse per le versioni precedenti.
Ma è qualcosa a cui prestare attenzione.
Questo è probabilmente sarà uno dei più grandi mal di testa
che si avrà con Swift è la ricerca esempio di codice che è più vecchio, anche solo
da alcuni mesi, cercando di utilizzare nel vostro progetto più moderno.
E semplicemente non funziona.
Stai diventando errori di compilazione, la sintassi errori, ogni sorta di cose folli.
Quindi, solo essere paziente con che, e si spera
avere una bella bella esperienza con generale Swift.
>> Ora si può effettivamente join-- e spero in realtà abbiamo ancora questo anno di successo questo
Di CS 50 Apple App team di sviluppo, che
vi permetterà di installare qualsiasi applicazione che si creano sui vostri dispositivi iOS.
Quindi dare un'occhiata a questo URL se siete interessati a farlo.
>> Quindi, solo un paio di cose su Swift stesso.
È un linguaggio compilato.
Ma vedrete che alcuni delle caratteristiche che usiamo
consentono di essere utilizzato anche in un po ' interpretato come un modo pure.
>> Un sacco di sintassi è preso in prestito da C. Si basa e scritto in C.
E così vedremo che ci sono un sacco di take away
dalla vostra conoscenza esistente da C che possiamo porto di Swift.
>> Ma ci sono cose che lo rendono molto diverso da C.
E 'molto fortemente tipizzato.
C'è gestione automatica della memoria.
Tu non stai andando ad avere per utilizzare malloc o dovunque gratuito.
È progettato per la generalità.
Quindi, in altre parole, è possibile utilizzarlo in tutti i tipi di contesti, da Apple Osservare
per iPhone tutta la strada fino a OS X, e persino alcuni server, anche alcuni script.
Ma vedremo che il supporto per lo scripting
non c'era ancora come è in altre lingue.
Quindi molto probabilmente sarete utilizzando questo esclusivamente per lo sviluppo
sul vostro Mac o il vostro iPhone.
>> E ha un sacco di funzioni moderne.
E molte di queste cose sono cose che stiamo andando a cercare di affrontare oggi,
ma anche i nostri argomenti che francamente, siamo in grado di dedicare interi corsi.
Infatti, CS 51, che è offerto semestre successivo,
si concentra molto su questi argomenti che sono descritte di seguito.
Così si può trascorrere un intero semestre capire queste cose.
Ma stiamo andando a provare per ottenere attraverso di loro
almeno abbastanza che può capire che cosa è
succede quando si guarda in un programma di Swift
ed essere in grado di incidere il vostro modo attraverso di essa per il progetto finale.
>> Ora, uno dei modi migliori che si può ottenere ulteriori informazioni su questo
è francamente solo attraverso Apple fornito una documentazione per Swift.
C'è un sacco di API che sono disponibili.
E questa è una buona base di partenza per voi cercare, cose specifiche che si
vogliono fare con un API che coinvolge iOS.
Se si desidera utilizzare la fotocamera per esempio, è possibile iniziare a cercare qui,
e anche l'uso di Google e Pila Overflow come si farebbe normalmente.
>> Tutte le domande su questo prima di saltare in pieno?
Tutto ok.
Andiamo avanti.
>> Quindi, prima, ho un numero di file di esempio.
E ho intenzione di provare a fare un passo attraverso di loro in tempi relativamente brevi.
Questo è il file Ciao Mondiale per Swift.
E 'molto semplice.
Non c'è modo più commenti che ci sono codice vero e proprio.
Si noti il ​​codice attuale è a il fondo sulla linea 14.
Dice di stampa.
E poi è una chiamata di funzione.
Stiamo passando in un stringa chiamato Ciao CS50.
Si noti che non ci sono punti e virgola.
Si noti che non c'è principale int.
C'è nessuno dei cruff che abbiamo avuto con C.
Quando stiamo usando Swift in questo modo, che è appena scritto in un file di testo
e memorizzati sul mio computer, quindi Posso compilarlo ed eseguirlo.
>> Si noti che qui io sono non usare l'IDE CS50.
Ciò presuppone che io sono in esecuzione e che sono su OS X,
e che ho già installato Xcode su questa macchina in modo che questo
in realtà la funzione.
Ma questo è solo un normale file di testo che possiamo quindi compilare e modificare.
Quindi cerchiamo di vedere come funziona realmente.
Che cosa devo fare per compilarlo?
1.Swift swiftc.
Dopo un momento o due, vedrà che abbiamo ora
compilato questo in un file chiamato 1.
E ora abbiamo stampato il nostro CS50, la nostra applicazione Ciao mondo piuttosto.
>> Notate un'altra cosa come bene è che di default,
Non abbiamo dovuto all'ingresso a / n per stampare una nuova riga.
Per impostazione predefinita, la funzione di stampa in Swift stamperà una nuova linea per voi.
È possibile passare un ulteriore optional parametro per dire che non farlo.
Ma Google per ulteriori informazioni su questo.
Per impostazione predefinita, lo farà la linea di stampa.
>> Va bene, quindi cerchiamo di andare avanti poi ad alcune altre cose.
Quindi, come possiamo davvero definire variabili?
Possiamo farlo sta usando uno dei due metodi.
E quello che voglio dirti su prima è questa definizione let.
E questo è importante perché effettivamente
quello che stiamo facendo è la definizione di una costante.
Stiamo per creare una variabile, o meglio una chiamata nome costante,
fornire ad essa alcuni data-- in questo caso, la stringa Dan.
Ma usando questo let parola chiave, stiamo dicendo
che questo variable-- o ancora constant-- chiamato
nome non è mai sta per essere cambiato.
Sta andando essere immutabile per tutto la durata del programma
o per tutta la durata del contesto
che tale variabile è disponibile.
>> Questo è molto importante che quando avete alcuni dati che non è
cambierà nel vostro programma, e vedrete una varietà di esempi
su quando vogliamo usare lasciare rispetto all'altro sintassi,
è importante che si utilizza lascia ove possibile, perché questa Notifica
la lingua che è non andare a modificare,
e può effettivamente svolgere un sacco di ottimizzazioni
per migliorare la velocità e la sicurezza del vostro programma.
E per la sicurezza, io non intendo lascio è scontro con errori pazzeschi
che potremmo essere abituato a vedere in C.
>> Poi possiamo usare l'interpolazione corda per incapsulare questo all'interno di una stringa.
Così possiamo vedere in questo linea di stampa, stampare ciao,
e quindi utilizzando backslash parentesi aperte, e poi il nome della mia variabile,
in questo caso costante, chiudere le parentesi.
Sono essenzialmente poi mettere il contenuti di questo nome variabile chiamata
all'interno della stringa e poi stampa del risultato lì.
>> C'è un altro cambiamento a questo file che è che ho, al top,
mettere in una shebang, che fondamentalmente specifica solo
che voglio usare il Interprete Swift, che
vuol dire che non ho più a compilare questo particolare programma.
Posso solo correre come una propria scrittura.
Ma questa è, in questo caso, dietro le scene fase di compilazione e quindi
in esecuzione.
E 'solo a noi invisibile.
>> Va bene, quindi cerchiamo di andare avanti.
Quindi c'è un po 'di inganno che appena successo prima.
Vi ho mostrato che io potrebbe definire una costante.
E potrei fornire alcuni dati per farlo.
Ma in questo caso, accorgo che non ho in realtà specificare il tipo di dati
è così.
E questo perché la compilatore, Swift può
dedurre il tipo di dati solo in base sui dati che ho messo in esso.
Perché sa che, valutando questo variabile proprio qui, questo diritto di dati
qui, si sa che è una stringa.
E così questo nome costante è quindi sarà una stringa come pure.
>> Ma possiamo anche essere espliciti circa il tipo che è
ci accingiamo a utilizzare per la costanti o variabili
utilizzando questa sintassi instead-- lasciate nome colon String uguale
Dan, che in questo caso significa che siamo andando a definire un nome chiamato costante.
Sta andando essere di tipo stringa.
E il valore sarà Dan.
Ora l'altro modo che possiamo creare variables--
e questi sono variabili mutabili, che significa che siamo, infatti, andando
a cambiare il loro contenuto a volte nella durata del contesto
che tale variabile è defined-- noi utilizzare la parola chiave var invece di lasciare.
Ma ancora una volta, per impostazione predefinita, se non si sa che è necessario manipolare i dati,
provare a utilizzare per lasciare miglioramenti delle prestazioni.
>> In questo caso, posso poi specificare il tipo di dati
che ci aspettiamo di essere all'interno di questa nuova variabile chiamata etichetta.
Sta andando essere una stringa.
E stiamo per poi concatenare due stringhe, la stringa ciao,
e la stringa rappresentata dal variabile, o meglio il nome della costante.
>> Quindi questo è bello perché questo è un po 'come in PHP che abbiamo
hanno molto semplice concatenazione di stringhe.
Non abbiamo automaticamente utilizzare qualsiasi tipo di gestione della memoria
per aumentare la dimensione e fare ogni sorta di cose divertenti lì.
Questo funziona come ci si aspetterebbe in realtà.
>> D'accordo, tutte le domande su questo?
>> Ora l'altro motivo che abbiamo bisogno di avere la possibilità
per poter definire tipo di variabili di dati sono
è perché a volte non lo facciamo vuole inizializzare le variabili
con alcuni dati al punto di definizione.
Quindi, in questo caso, diciamo che voglio iniziare inserendo
alcuni gradi in un libro di grado.
So bene che uno dei variabili che voglio essere
sta per essere un grado mutevole.
E sappiamo anche che ci vuole che sia un numero intero.
Ma forse non siamo ancora avere quella qualità disponibile.
>> In Swift, si deve definire il tipo di dati
che è associato con un variabile o una delusione costante
prima di poter effettivamente utilizzare tale variabile.
Perché è fortemente tipizzato, si deve associare un tipo di
con queste variabili.
>> Quindi, in questo caso, se non ho correttamente inizializzato il primo con un certo valore,
poi ho bisogno di raccontare quello che Swift Mi aspetto che il tipo di dati di essere.
E sta andando a rimanere lo stesso tipo di dati
tutta la storia di questo programma.
>> Ora si potrebbe essere tentati più presto Ho creato questa variabile grado
ea condizione che un intero di 100, se ora
vuole provare per concatenare una stringa che con intero,
potrebbe essere tentati di usare ancora tale operatore concatenazione di stringhe
come abbiamo fatto poche righe prima.
Ma sfortunatamente, questo in realtà non lo farà
lavorare, perché tu sei essenzialmente l'esecuzione
un'operazione su due tipi diversi.
>> Ora questo è molto diverso da altri linguaggi come PHP che sono davvero
goosey loosey con il loro tipo di tipi.
Sono proprio come, sì, qualsiasi altra cosa, non mi interessa.
Dammi solo un tipo, e forse farò la cosa giusta.
>> In questo caso, Swift è estremamente rigorosi sui tipi
che si sta trattando.
Questo operatore sommatoria o operatore di concatenazione
ha essenzialmente una coppia di diverse opzioni possibili.
Si può fare sommatoria con numeri interi, oppure si
può fare concatenazione di stringhe, e forse alcune altre cose.
Ma se tale operatore non riconosce ciò è su entrambi i lati di esso,
ovvero la combinazione di questi due tipi, non è quello che si aspetta,
poi sta andando a causare un guasto.
>> Quindi, in questo caso, che cosa vuol dire avere una stringa più un intero?
Ebbene nel contesto questo, probabilmente vogliamo
di eseguire un'operazione di concatenazione di stringhe.
Ma naturalmente computer non ha quel tipo di contesto.
E così abbiamo bisogno di fornire che ulteriori informazioni
per fargli sapere che cosa è che noi vogliamo fare.
>> In altre parole, il fatto che Swift è fortemente tipizzato
significa che devi fare un po 'di lavoro in più
per farlo funzionare la modo che si vorrebbe.
Ma come risultato, è più sicuro.
E una volta che hai prendere in considerazione quei tipi,
le cose cominciano francamente funzionare abbastanza bene.
>> Quindi, in questo caso, abbiamo poi sarebbe eseguire concatenazione di stringhe
lanciando esplicitamente il numero intero in una stringa
avvolgendolo in questo capitale funzione S String,
e quindi utilizzando la concatenazione di stringhe all'operatore di modificare la nostra variabile etichetta,
e poi stamparlo.
>> Fin qui tutto bene?
Va bene, andiamo avanti.
>> Ora ci sono una varietà di dati tipi che possiamo usare a Swift.
Come avete abituati, siamo in grado di creare un array mutevole.
E tale matrice solo è possibile contenere un solo tipo.
>> Quindi, in questo caso, stiamo andando a creare un mutevoli array di interi, che
noi chiamiamo gradi, e saremo in grado per memorizzare che in questa fascia di piazza
formato sei cresciuto abituati a in una varietà di altre lingue.
Ma notiamo che qui siamo la definizione di un paio di cose.
gradi è un variable-- mutabile Non usiamo la parola chiave let.
In modo che significa che possiamo quindi modificare il contenuto di questa matrice.
E 'di tipo Array Int, e possiamo dire che
sulla base di queste parentesi quadre qui.
>> Ora, una delle cose belle su questo è che ci
avere accesso ad un sacco di Informazioni aggiuntive
circa l'array usando solo qualche semplice notazione del punto.
Così, per esempio, grades.count fornisce a noi
il numero di elementi che esistono in quel array, che possiamo poi accedere abbastanza
facilmente semplicemente utilizzando tale notazione punto.
>> Se si desidera aggiungere ulteriori elementi a questa matrice,
non si può fare lo stile di PHP dove basta definire in modo esplicito,
in un determinato indice, qualche valore che si desidera inserire.
Utilizzare invece il append metodo nel tipo array
per aggiungere tale voce, 95, a questa lista.
>> Così ora questo array ha il seguente contents-- 100, 0, 90, 85.
E ora abbiamo allegati 95 a quello.
>> Ci sono altri modi siamo in grado di aggiungere le cose.
Si può effettivamente utilizzare un operatore di sommatoria,
che sarà interpretata come un'operazione di matrice accodamento.
E si può quindi aggiungere un altro matrice, i cui contenuti sono 70 e 80,
di tale matrice.
Così ora abbiamo la contenuti in questa variabile
grades-- 100, 0, 90, 85, 95, 70, e 80.
Questo è solo un bel po 'sintattica zucchero che Swift offre a noi.
>> Quindi, se vogliamo sommare il gradi, siamo forse
andando a voler iterare su ogni elemento in questo ciclo.
E noi abbiamo, a Swift, l'idea di un ciclo for come ci si aspetterebbe.
Ma il modo che indichiamo una gamma è leggermente diverso.
Quindi, in questo caso, per Insomma tutto, ce la faremo
andando a creare una temporanea chiamato somma variabile in modo per noi
per mantenere questo conteggio.
>> E notare la nostra per costruzione in bouclè qui.
Per l'indice a 0 .. <grade.count.
Quindi questa costruzione, 0 .. <grades.count è un'operazione gamma dove siamo
dicendo che stiamo per creare una serie di numeri interi da 0 fino
ad e ad esclusione grades.count.
Quindi questo sarà 0, 1, 2, 3, 4, 5, fino a quando però molti uno
prima grades.count.
>> Quindi questo è diverso da come noi sarebbe tipicamente utilizzato per cicli
dove si dovrebbe avere un po 'indice variabile, impostarlo a 0 all'inizio,
e quindi integrare che fino a qualche valore inferiore al numero di elementi
in tale matrice.
>> Quindi vi è una modifica per questo, in realtà,
che ci permette di molto facilmente impostare diversi tipi di intervallo.
Se si cambia questa gamma per tre punti, 0 ... grade.count,
questo rappresenta la gamma 0 a grades.count compreso,
il che significa che quel numero è anche poi inclusi in tale intervallo.
>> Ma questo è molto utile per queste cose esatte,
quando dobbiamo eseguire iterazioni oltre cappio
perché tali indici sono pari a zero indicizzati, come abbiamo visto in altre lingue
anche.
Tutte le domande su questo per ciclo?
>> Quindi c'è definizione implicita di questa variabile indice,
il cui valore inizia a 0, e continua ad ogni iterazione del ciclo
aumentare di 1 fino ad un punto che è uguale a grades.count,
a quel punto, il ciclo si interrompe.
>> Si noti che nella nostra stringa interpolazione qui,
possiamo effettivamente eseguire alcune semplici manipolazioni a tali valori.
Così indice più 1 sarà effettivamente eseguire una somma di tale valore
perché indice è, in questo caso, un numero intero.
E a quel punto, lo farà successivamente convertito in una stringa
e interpolato in questa stringa qui, e stampati come ci si aspetterebbe. .
>> E la cosa bella sulle matrici qui è
che anche noi siamo in grado di avere valori fetching e valori di impostazione
usando la notazione parentesi quadra come abbiamo visto in altre lingue.
>> Va bene, allora da qui, ora calcolare nostra somma di tutti i nostri gradi.
Ora, specie del prossimo passo logico sarebbe
di eseguire un'operazione di divisione per trovare la media di questi gradi.
Ma qualcosa di importante qui sta accadendo che
è che tale somma è forse un numero intero.
Ma abbiamo bisogno di eseguire alcune sorta di doppio divisione.
E questo sta per essere estremamente importante quando
vogliamo eseguire questa operazione, perché quello che stiamo dicendo
è che abbiamo bisogno di realtà eseguire la divisione in due doppie.
E ancora, perché Swift è molto fortemente tipizzato,
dobbiamo esplicitamente impostare tutte le elementi a doppio prima di poter effettivamente
eseguire tale operazione.
>> Così, in modo per noi di eseguire doppia divisione,
non è sufficiente che una sola di questi elementi di essere un doppio.
Entrambi hanno essere un doppio perché veloce
per essere sicuri che questo è quello che vogliamo fare.
Quindi dovremo quindi esplicitamente typecast la somma che abbiamo calcolato in precedenza
e il conteggio dei voti per raddoppia, e quindi eseguire tale operazione e memorizzare
che in questa nuova variabile, o meglio questa nuova costante chiamata media,
che avrà di che tipo, si immagina?
Doppio, sì.
Quindi, in questo caso, non c'è bisogno di specificarlo
perché si può dedurre dal operazione che tipo di media di dati
sarà.
E Swift è generalmente piuttosto buono di essere in grado di dedurre il tipo.
>> Vuoi vedere questo Corro, o posso andare avanti?
Voglio andare avanti.
Tutte le domande di nulla di tutto questo?
Grande.
>> Ora stiamo per iniziare a raggiungere le buone funzioni di definizione stuff--,
e un paio di altri tipi che sono unico a Swift che non hanno
visto in altre lingue fino a questo punto,
ma sono presenti in altri lingue che si potrebbe trovare in seguito.
Quindi, prima, se si desidera definire una funzione,
si definisce con la parola funky la funzione, e quindi il nome della funzione,
e poi tra parentesi, gli argomenti che si desidera che la funzione per accettare.
Gli argomenti devono anche specify-- generally--
deve anche specificare il tipo di dati che essi sono, a meno che non si può dedurre.
E vedremo che poco caveat in appena un po '.
>> Quindi, in questo caso abbiamo una funzione chiamata printGradeCount.
Stiamo per accettare un variable-- anzi in questo caso,
un constant-- chiamato registro di classe.
E sta per essere di tipo array di interi.
Ora c'è qualcosa che è molto importante qui
che voglio che tu capisca.
Che è che per default, questi argomenti che sono input per questa funzione sono
definito con una parola chiave let implicita, il che significa che non posso modificare questo
variabile registro di classe qui.
E che tipo di senso, perché si sta passando i dati in.
E forse non si vuole che di essere cambiato da sotto.
È possibile menzionare esplicitamente che questa è una variabile mettendo
la parola chiave var qui.
Ma questa è una Gotcha che abbiamo persone notato hanno fatto in passato
è che hanno supposto che sta andando essere una variabile quando, in realtà,
è una costante.
>> Va bene, ecco allora, in questo caso, non abbiamo specificato alcun tipo di ritorno.
Vi mostreremo come fare che in un momento.
Ma si noti che qui abbiamo solo una semplice se la condizione.
Se il registro di classe è vuoto, che in questo caso
è solo la proprietà di questo intero array, poi stampare qualcosa.
Altrimenti facciamo qualcos'altro.
>> Abbastanza semplice finora credo.
Ma mi fermarsi se avete domande.
>> Ora questa funzione, media, prende anche alcuni argomenti, o meglio un argomento,
che è il registro di classe, e questa volta sta per restituire un doppio tipo.
Perché è calcolando la media ed è
andando a tornare in realtà che medio calcolato per la linea chiamante.
>> In questo caso, si precisa la Tipo di tornare dopo una freccia.
E questo potrebbe sentire un po 'strano in un primo momento.
Sei cresciuto abituato all'impostazione del ritorno
digitare prima del nome della funzione.
Ma se si pensa a questo in termini di matematica,
come quando si ha la matematica che definiscono una funzione,
si dispone di una funzione con un po ' ingressi, e produce un'uscita.
E questo è esattamente ciò che questo dovrebbe imitare.
E ci sono un paio di altre lingue che hanno sintassi simile pure,
ma probabilmente nessuno che che hai visto in CS50.
Ma ancora non essere confuso da esso.
La freccia indica che cosa sta succedendo da restituire in questo caso.
OK, così come faremo per calcolare questa media?
Beh, se il registro di classe è vuoto, beh, allora siamo
andando a restituire 0, che forse un modo ragionevole per trattare questo.
Non lo so, veniamo indietro a quella in un po '.
Questo non può in realtà essere un modo ragionevole
per calcolare una media se abbiamo un registro di classe vuota.
>> Poi ci limiteremo a eseguiamo il nostro sommatoria.
Si noti che qui abbiamo effettivamente avere una versione alternativa di un
per il ciclo, che ci permette di iterare su ogni singolo elemento di un array
e porre ogni elemento nella sua variabile.
Specificando per grado in Registro di classe, quello che stiamo dicendo
è che stiamo andando a implicitamente creare una nuova costante chiamato
qualità che sta per rappresentare ogni oggetto unico nel registro di classe
ogni volta che il ciclo for.
Quindi la prima volta che è gestito, di grado sarà
essere il primo elemento della registro di classe.
La seconda volta sarà la secondo punto, così via e così via
fino a quando ha gradebook si esaurisce di elementi.
Allora saremo in grado di sommare che qualità nella nostra variabile sommatoria
e restituire il nostro media come abbiamo visto prima.
OK, tutte le domande?
Sì?
PUBBLICO: Ho due domande.
Numero uno, ipoteticamente, può si esegue intero su questo?
Non deve essere un doppio, è corretto?
DAN AMRMENDARIZ: Può voi ripetere questa domanda?
PUBBLICO: Posso fare intero come la media?
DAN AMRMENDARIZ: Può voi fare integer come media?
Così restituire un intero media invece di un doppio?
>> PUBBLICO: si Return-- avere che in questo momento al di sotto.
DAN AMRMENDARIZ: Proprio qui, tornare 0.0?
PUBBLICO: Sì, solo ritorno 0.
Così sarà sia 80 o 85, ma non 85.2.
>> DAN AMRMENDARIZ: Quindi, in questo caso, quindi c'è una paio di modi diversi
per rispondere a questa.
Lasciatemi rispondo in ordine.
Quindi, se ho solo fare questo ritorno 0, 0 è un valore intero.
E così che causerà una errore di tipo per questo caso
perché si aspetta un doppio ma viene poi restituisce un intero.
Se voglio tornare un intero, posso.
Posso impostare il tipo di ritorno a int, tornare qui 0,
e non eseguire la doppia divisione.
Ma allora saremmo facendo divisione intera.
E così abbiamo poi non avremmo avuto la media che avremmo forse aspettarci.
Ma sì possiamo modificare i tipi in questo modo.
>> PUBBLICO: E in secondo luogo, è avere una doppia in alto.
Ma in basso, quando si fare ritorno Double Double,
che è già automaticamente tornando formato doppio.
Perché è ancora necessario definirla con la freccia sulla parte superiore con un doppio?
>> DAN AMRMENDARIZ: So in caso, questo fa parte
di the-- così a ripetere la domanda, perché è implicita dal ritorno
tipi di qui, che tipo questo in realtà è, abbiamo bisogno di essere esplicito con Swift
su quello che vogliamo tornare da questa funzione
in modo che quando si esegue digitare il controllo, si può fare in modo
che ciò che abbiamo effettivamente scritto in basso in realtà conforme a quella.
Quindi è un po 'come un assegno con te stesso tipo di situazione.
Ma ci sono--
>> PUBBLICO: [incomprensibile] freccia?
>> DAN AMRMENDARIZ: Ci sono casi in cui possiamo specificare che possiamo implicitamente
impostare il tipo di ritorno.
Ma in questo caso, non mi pensare che avrebbe funzionato.
C'è qualche altra sintassi che vedremo in seguito.
>> Va bene, quindi questa fonte codice è un po 'diverso
perché questo analizza argomenti da la funzione che stiamo chiamando.
Mi permetta di mostrare come funziona prima di poter effettivamente passa
per alcune cose interessanti che sta succedendo a Swift.
>> Quindi, in questo caso, se ho appena eseguito questo codice, si noti che quello che sta facendo
mentre è--, che tipo di mi dà un errore di strano.
Ho bisogno di passare un paio di numeri interi come argomento della riga di comando.
Vediamo quindi, 150 e 80, e premi invio per scoprire cosa sta realmente facendo.
E 'accettando ciascuno di questi valori come numeri interi.
Li sta inserendo in un registro di classe.
E poi è l'esecuzione tale calcolo medio
e l'output che, come ci si aspetterebbe.
>> Ma ovviamente c'è qualcosa da fare con questo qualcosa rifiuto
qualcosa come un intero.
Come si può ricordare da quando eravamo si tratta di argomenti della riga di comando
in C e altre lingue, la prima 0-esimo elemento in tale argomento della riga di comando
lista è il nome del comando che abbiamo effettivamente eseguito.
Quindi, in questo caso, sto solo looping su tutti gli argomenti della riga di comando.
Ma io non sto facendo alcun tipo di fantasia controllare per saltare quel primo.
Sono solo in modo esplicito o che sono implicitamente controllare quali di questi tipi
sono interi prima che io in realtà eseguire questo calcolo.
>> E questo è essenzialmente cosa sta succedendo qui.
Per ogni argomento gli argomenti del processo,
Ho intenzione di eseguire alcune assegno.
E in questo caso, ho intenzione per cercare di primo convertito
tale argomento in un numero intero da l'esecuzione di un typecast esplicito,
perché è, in ingresso, una stringa e non in realtà un numero intero.
>> Ma questo è una specie di una sintassi strano, se di grado uguale lasciare Int (argomento).
Che cosa sta effettivamente accadendo qui è estremamente
importante per il vostro tramite Swift.
Questo sta usando ciò che è chiamato un tipo opzionale.
>> Quindi questa funzione, Int (argomento), restituisce non solo un intero, ma ritorna
quello che chiama un intero opzionale.
E così questo è una sorta di un tipo in cima a un tipo.
È possibile ordinare di immaginare come è tornando come un pacchetto.
E quando si apre che pacchetto, esso sia
ha un numero intero, che è il risultato, o non ha assolutamente nulla a affatto.
E questo è utile come controllo degli errori Meccanismo, perché in questo caso
possiamo scoprire, è stata questa tipo di conversione di successo?
Se fosse, allora è infatti andando ad avere un numero intero all'interno.
In caso contrario, sta andando ad avere un po ' valore che chiameremo trascurabili,
rappresentativa non integer affatto.
E 'davvero rappresentativo di nulla.
>> E così questo se la costruzione ci permette di scartare quel pacchetto,
che opzionale vincolante.
E se siamo in grado di scartare che pacchetto e trovare un intero all'interno,
allora quello che stiamo dicendo qui è che ci sarà poi
consentono tale valore da impostare in questa costante chiamato grado.
E questa porzione di if, la parte superiore del if
verrà eseguito, perché unwrap ha avuto successo.
>> Se si da il caso che c'è stato un errore forse
in questa conversione tipo esplicito da una stringa in un numero intero, forse
è il valore ABC per esempio.
E questo è in realtà non andare per convertire in un numero intero.
Poi tornerà a zero, che non è un numero intero.
E questa istruzione if bene quindi sicuro.
grade non esisterà perché esso non ha contenuto intero.
E sarà eseguire questo blocco else invece.
Sì?
>> PUBBLICO: Nil è la N-I-L?
DAN AMRMENDARIZ: nil è N-I-L, sì.
>> Quindi questo è forse uno dei più difficili cose su Swift,
soprattutto quando si è in le erbacce in un app iOS
e si sta effettivamente cercando per fare un po 'di sviluppo lì.
E sta per essere urlare a circa opzionale.
E sta per essere voi per chiedere interrogativi e punti esclamativi.
Ma una volta a capire se si fuori-- dedicare un po 'di tempo per capire
quello che sta succedendo con i tipi opzionali, potrai risparmiare un sacco di mal di testa
come si sta tentando di scrivere un'applicazione in Swift.
>> In realtà è una caratteristica molto potente.
E dovrete semplicemente per prendere la mia parola per ora.
Ma staremo a vedere questa costruzione e alcuni altri piace
in alcuni degli altri codice sorgente vi mostreremo in appena un po '.
>> Ci sono domande iniziali qui?
Così l'asporto importante è che un tipo facoltativo è una sorta di metatipo.
Si o ha un valore, e se lo fa, allora
sarà forse avere quel valore associato con esso, o esso ha alcun valore,
ed è rappresentato da zero.
Il resto di questo è forse come ci si aspetterebbe.
>> Quindi cerchiamo di rampa fino alla difficoltà ancora una volta.
E questa volta, diamo uno sguardo ad alcune altri tipi di dati che in realtà esistono.
Uno di questi è dizionari, che è molto simile ai dizionari Python.
E 'in qualche modo simile a una tabella hash C. Si tratta essenzialmente di una mappatura di tasti
dove le chiavi possono essere stringhe.
E quando si guarda quelle chiavi, tali tasti avranno un valore.
Quindi non è comunque una serie, ma invece, più strettamente associato
a una mappa hash o una tabella hash.
>> Vediamo come questo dovrebbe a lavorare prima di riuscire a
entrare nel codice sorgente stessa.
Se ho appena eseguito questo, non succede nulla davvero.
Mi sta dicendo che mi aspetto alcuni parametri del seguente tipo.
Quindi ho intenzione di fornire a essa alcuni nomi problema set,
così pset0, forse ho avuto 100.
E pset1, ho ottenuto un 5.
E poi l'esame, mi ha fatto molto bene e ha ottenuto 30.
E oops, mi ha colpito un spazio qui.
>> Quando mi ha colpito Invio, è possibile vedere esegue qualche calcolo.
Dice gradebook è di tre gradi, pset1, pset0, esame.
E il registro di classe ha questa specifica media.
Così ancora una volta, stiamo lavorando con questa idea Registro di classe,
ma abbiamo intenzione di continuare l'iterazione con la complessità della nostra funzione.
>> Così al momento della comparsa, siamo solo andando a creare una funzione che
è responsabile per la stampa dell'utilizzo.
E c'è questa uscita funzione che sarà solo
forzatamente chiudere l'applicazione.
Questo non è qualcosa che si utilizzerà in iOS.
Questo è solo, in questo caso, con un argomento da riga di comando.
Successivo inizieremo muoversi verso Xcode.
Ma questo è specifico per un comando programma di stile di linea a Swift.
>> Diamo uno sguardo ad alcune delle le cose interessanti qui.
Vediamo, solo un paio di cose interessanti da citare forse
è che nella mia funzione di stampare il numero di voti,
si potrebbe ricordare che ho avuto quella lista di pset1 items--, pset0, ed esame.
Si può effettivamente rapidamente e facilmente fare questo
prendendo il registro di classe, che è un dizionario che ha le chiavi e valori.
Trova tutti della chiave è attraverso il metodo chiavi a punti qui,
e quindi utilizzare questo joinWithSeparator, che poi prendere tutte le chiavi
che avevamo digitato, pset1-- o scusate, pset0, pset1, e exam--
e concatenare insieme utilizzando una virgola e uno spazio
per creare una stringa lungo.
Questa operazione è solo aderire fenomenale utile in una varietà di contesti.
E così è questo joinWithSeparator.
>> E questa è una cosa che è cambiato da Swift 1 a Swift 2.
Ci deve essere utilizzato un Python style-- se siete
familiarità con Python-- un Python stile metodo join sulle stringhe.
Ma che non è più il caso Swift 2.
Si desidera utilizzare questo se si vuole per concatenare una serie di cose
insieme con una stringa.
>> Quindi, forse, allora nella nostra discussione di media prima,
fa un po 'più senso per noi per impostare la funzione di media
per essere un doppio facoltativo piuttosto di un semplice doppio esplicito.
Perché abbiamo avuto che condizione insolita dove,
che cosa se realmente gradebook non ha valori all'interno di esso?
Quale dovrebbe essere il rendimento medio?
>> Beh, forse in C te avrebbe fatto qualcosa
come condizione un valore sentinel, come 0.0, o forse un numero negativo,
o qualcosa solo che rappresenta la realtà che ci fosse qualche condizione di errore
e forse in realtà non hanno la possibilità di calcolare tale media.
Beh, la bellezza di specificare un tipo opzionale sarebbe quello di farlo.
E ora sto dicendo che tutte queste parole, ma questo in realtà non fa uso di optional.
Ma vedremo che in appena minuti dove possiamo impostare media
essere un tipo di dati facoltativo affinché se effettivamente restituisce alcuni dati, poi
ritorneremo tali dati.
In caso contrario, ci ritorneremo nil, dicendo che questo
non ha il calcolo significativo.
>> Passiamo ad altro.
Quindi da qui, abbiamo cercato di tutti questi esempi nella linea di comando.
Ma in realtà quello che si sta andando a che fare con è Xcode.
E una delle cose belle di Xcode è, e in particolare in Swift,
è che abbiamo questa cosa chiamato un parco giochi.
E un parco giochi è non è affatto un app iOS.
Ma permette di sperimentare con Swift in un modo molto semplice.
È possibile digitare tutto il codice.
E 'ben sintassi evidenziata qui.
Quando si crea un nuovo file, verrà richiesto se si desidera creare un parco giochi.
Ma la cosa bella di Playground è che a destra della finestra,
fa realmente vi mostrerà Uscita dal codice.
Quindi, se ho scorrere verso il basso, si può vedere che cosa l'uscita di varie linee di codice
in realtà sembra essere.
>> Quindi, in questo caso, stiamo andando a cambiare direzione solo un po '
e parlare di qualcosa che è davvero importante in questo modo ad alto livello
Swift che opera, e è questa idea di chiusure.
E probabilmente avete visto questo un po 'in JavaScript.
Per quelli di voi che sono in CS50, chiusure
sono molto popolari, molto buon modo per farlo cose di alto livello in lingue moderne.
Ma è anche un po 'difficile da avvolgere la testa intorno la prima volta.
Quindi, se guardando questo prima volta, va bene così.
Basta guardare il codice sorgente e vedere se si può capire a casa.
>> Quindi, in questo caso, diciamo che noi vuole creare un sacco di esponenti
con un certo valore fisso.
Quindi, in questo caso posso creare una funzione.
Ho intenzione di chiamarlo potere di 2 il cui unico scopo nella vita
è quello di prendere un po 'di ingresso e doppio esso, e restituire tale valore.
Si noti che io sono qui accettare un tipo di dati.
Sta andando essere una variabile chiamata x.
E 'di tipo Double.
E ho intenzione di tornare un doppio qui.
E sto solo andando a fare molto, francamente, piuttosto
modo ingenuo di raddoppiare questo valore.
E ti mostrerò perché questo è utile in un secondo.
>> Si noti che qui abbiamo questa gamma ancora. qualcosa in 1, puntino
dot dot, 2, il che significa che questo ciclo verrà eseguito due volte.
Ma questo rappresenta una variabile dummy.
Significa che non ho davvero intenzione di stia usando la variabile ovunque
all'interno di tale ciclo.
Voglio solo che questa linea di codice da eseguire due volte,
senza dover conoscere il valore di tale intervallo.
>> Quindi, in questo caso sto risultato correndo volte x due volte, che in sostanza
significa che sto quadratura questo valore.
E questo succede a lavorare come ci aspetteremmo.
Potenza di 2, si passa il valore 2.0 ci dà una potenza di 4.
3.2 lavori per 10.24.
>> Ora possiamo fare un simile cosa per il potere di 3.
Ma ora cambia solo l'intervallo.
Per variabile dummy a 1 a 3, moltiplicare 3 volte,
e fare la stessa cosa.
>> Quindi questo potrebbe sentire un po 'forzato.
Ma c'è un importante cosa qui che
è che guardando queste due funzioni, c'è
solo una cosa che è diverso, che è questo valore nella gamma.
Tutto il resto di questi due funzioni, potenza di 3 e potenza di 2,
sono, infatti, identici perché funzionano allo stesso modo.
>> Quindi, a questo punto, un po ' campanello d'allarme dovrebbe andare via.
Speriamo che quello che stai dicendo, si sa, questo si sente un po '
come la duplicazione degli sforzi.
Forse c'è un modo che avrei essere in grado di incapsulare tutto questo
e fornire una funzione oppure creare una funzione che
fa esattamente quello che voglio senza la necessità di digitare esplicitamente.
E questo è ciò che il potere di una chiusura ci permette di fare.
Quindi, diamo uno sguardo a questo.
E io passerò una coppia minuti su questo, perché questo
è abbastanza importante per Swift.
Vediamo questo tutto il tempo.
Stiamo per definire una funzione.
Sta andando per essere chiamato powerof.
Sta andando a accettare un parametro chiamato y di tipo Int.
Ma date un'occhiata al tipo di ritorno.
Il tipo di ritorno è, in parentesi, Doppia freccia a due.
Il che significa che questa funzione, questa funzione powerof,
sta tornando una funzione.
Che sta accettando un doppio e restituire un doppio.
In modo che potrebbe suonare un po 'pazzo, ma cerchiamo di scorrere verso il basso un po '
e guardare per vedere cosa succede.
Siamo all'interno di questa funzione powerof.
Stiamo creando una nuova funzione chiamato exponentiator,
ma non importa quello che è.
>> Si noti che questo ha un valore di ingresso x.
E si sta prendendo in camera matrimoniale e restituire un doppio.
E questo è lo stesso codice che abbiamo visto sopra, tranne che il valore di 2
o il valore di 3, che limite superiore in tale intervallo,
è stato sostituito con questo valore di y, che
era il parametro iniziale della nostra funzione powerof.
E a questo punto, ci tornare exponentiator.
Stiamo restituendo la funzione.
>> E 'un po' come un piccolo soffia mente.
Ma immaginiamo cosa succede quando chiamo questa funzione powerof
e passare in esso un certo valore come 2.
Ciò significa che Ora ho il valore
2 per y, il che significa che questo valore y in questa funzione exponentiator
sarà quel valore 2.
Ma sto tornando questo Funzione exponentiator.
>> Allora notate cosa Swift dice che hanno creato in questo caso.
lasciò piazza è una definizione, è una funzione che accetta un doppio
e restituisce un Double.
Ho creato una funzione che qualcosa piazze
utilizzando questo meccanismo proprio qui.
E davvero quello che sta succedendo è che sta tornando questa funzione
exponentiator, ma questo valore y è avvolto all'interno di esso.
E così ora ogni volta che uso questo variabile o costante questa chiamata
piazza, si sta andando a comportarsi come una funzione.
E così posso quindi chiamare quella variabile come vorrei chiamare una funzione,
e passare in un certo numero, come in questo caso 3.
E io allora quadrato di questo valore.
Quindi 3 quadrato verrà poi diventano 9, come si può vedere qui.
>> Veramente pazzo, ma questo ora mi offre l'opportunità
per creare altre funzioni powerof.
Come posso dire, OK, bene ora voglio per creare una nuova funzione, powerof (3),
e memorizzare che in un costante chiamata cubo.
E ora il cubo sta per essere una funzione separata che sarà poi
prendere un certo valore come input e cubo che valore come si può vedere nella riga inferiore
Qui.
cubo 2 sta per tradursi in 8.
>> Roba Speriamo piuttosto pulito.
Non avete mai visto prima.
Vi incoraggio a guardare in chiusure e indagare su questo un po 'di più.
E 'roba davvero potente vediamo un sacco in JavaScript e alcune altre lingue.
E 'davvero fondamentale per capire API così
che ci arriveremo in un secondo.
Sì?
>> PUBBLICO: Quando si esegue powerof (2), parentesi, e poi
un'altra parentesi, un altro input-- sei fondamentalmente sostituire la piazza.
DAN AMRMENDARIZ: Così guardare all'ultimo riga qui.
In realtà è del tutto possibile farlo concatenamento come lei ha suggerito.
Così powerof (5) indica che stiamo andando per avere un exponentiator 5 quassù.
Quindi questo è essenzialmente sarà il stessa cosa 4 alla quinta potenza,
perché abbiamo creato un exponentiating funzionare alla quinta potenza,
e stiamo passando in che funzione il valore 4.
E si ottiene quel valore che ci aspettiamo, 1024.
PUBBLICO: E non è un nome, in modo che rende più facile
per leggere, la piazza qualunque.
>> DAN AMRMENDARIZ: Giusto, esattamente.
Quindi, prima ho appena messo in una costante qui così
che ha reso facile da usare quel nome.
Sì?
>> PUBBLICO: In questo contesto, powerof, è parte
del linguaggio di programmazione in contrasto con il modo in cui si
pensare powerof in [incomprensibile]?
DAN AMRMENDARIZ: So in questo caso, powerof
è semplicemente il nome del funzione che ho definito qui.
Quindi non è inerente al linguaggio stesso,
ma, invece, è solo una funzione che ha
quel nome perché gli ho dato quel nome.
Qualsiasi altra domanda?
Tutto ok.
>> Ora, questo è grande.
Ma tu non stai andando a vedere un molte funzioni di chiusura che
sono come questo, dove si definisce, dentro di una funzione, un'altra funzione.
E lo si può fare.
Ma non è di tipo davvero necessario, giusto?
Come faccio a definire il motivo per cui questo funzione chiamata exponentiator
e poi tornare immediatamente.
Perché non posso solo subito restituire questa funzione?
>> Ed infatti, è proprio L'idea alla base un concetto chiamato
funzioni anonime, dove funzioni anonime in realtà non
avere un nome, perché non c'è bisogno di avere uno.
E così in questo caso, in 7B, possiamo trovare esattamente quello.
E 'lo stesso codice, fa esattamente la stessa cosa,
ma ora abbiamo cambiato leggermente in modo che questa funzione powerof subito
restituisce una funzione.
Si noti che dopo il ritorno, c'è una parentesi graffa aperta.
Si aspetta questo ingresso doppio.
Si aspetta che l'uscita doppia.
E poi la parola chiave in separa il codice stesso.
Quindi questa è una funzione anonima.
In realtà non ha un nome, mentre prima si chiamava exponentiator.
Ma come abbiamo visto, solo veramente non faceva riferimento ai exponentiator
al di fuori di tale funzione.
Quindi non aveva importanza.
Quindi questa funzione anonima è cosiddetto perché è senza nome,
ma è ancora in uso nel contesto di questo codice.
>> I prossimi due quelli cui sono intenzione di continuare spera
soffia la vostra mente un po '.
Possiamo semplificare questo ancor più.
Perché, come è stato acutamente sottolineato in precedenza,
forse che sappiamo, da dedurre da questo codice, cosa
l'uscita di questo codice sta per essere.
Ed in effetti, in questa funzione anonima, infatti possiamo dedurre i tipi di dati.
>> Quindi, in questo, non abbiamo più necessità di definire in modo esplicito
il tipo di dati che si sta ingresso e uscita da questa funzione
per un paio di ragioni.
Uno è che abbiamo definito, fino al prototipo della funzione di inclusione,
il tipo di dati questo anonimi funzione dovrebbe ingresso e uscita.
E dall'altro, abbiamo può dedurre dal codice
qui che stiamo accettando input che è di tipo doppio
e restituire un doppio.
>> Si noti che qui non abbiamo esplicitamente definiti i nomi degli argomenti
che questa funzione è accettare.
E così vediamo che possiamo fare riferimento a i parametri che utilizzano $ 0, $ 1,
così via e così via, a seconda il numero di tale parametro utilizzato
in questa funzione.
>> Questo è qualcosa che si sta andando per vedere una partita è questa parentesi graffa aperta
Definizione seguita da una $ 0, e poi alcune operazioni,
e poi una parentesi graffa chiusa.
Questa è una funzione anonima che esegue questa operazione.
Ha questo parametro dove è tipo è dedotto.
Quel primo parametro è $ 0.
E alcuni operazione è accade su quel $ 0.
>> AUDIENCE: Così il segno del dollaro significa parametro fondamentalmente,
e 0 significa il primo?
DAN ARMENDARIZ: Esatto.
Così il segno del dollaro significa sostanzialmente parametro e 0 indica il primo.
Ma funziona in particolare in questo caso dove non ho nominato
gli argomenti a mia funzione anonima.
>> PUBBLICO: Fa Perl o qualcosa hanno questo simbolo del dollaro, dollaro 0 in là?
DAN ARMENDARIZ: fa che, mi dispiace?
PUBBLICO: Il Perl ha questo dollaro 0, dollaro 1--
DAN ARMENDARIZ: io non sono troppo familiare con il Perl,
ma quello che definisce le variabili di PHP sulla base di segni di dollaro.
E ci possono essere alcune lingue che hanno caratteristiche come questo.
Infatti, prende in prestito un Swift molte caratteristiche come questo
da un sacco di altre lingue.
Vediamo un accenno di Python in esso.
Questa definizione di tipo sembra provenire da OCaml.
E abbiamo solo un sacco di roba da un sacco di lingue diverse.
Questo è uno dei più bella cose su Swift
è che ci vuole un sacco dei migliori idee da un gruppo di lingue
e tutti insieme calzascarpe in una lingua eccellente.
In realtà, se mi permettete di continuare soffia la tua mente,
così faccio da noi tutto questo.
Forse possiamo semplificare questo un po ' bit realizzando che, naturalmente,
Swift ha un exponentiating funzione built in.
Se importare Darwin, che è proprio la libreria che
presenta questa funzione chiamata pow, ora Posso semplificare la mia potenza della funzione
essere il seguente.
E sta per essere di ritorno questa funzione anonima.
>> Ma guardate quanto semplice questo è ora.
Si tratta di una funzione anonima che è accettare un certo tipo di dati,
e che sta per essere uno argomento specificamente,
si fa riferimento a $ 0 cioè di tipo Double.
E 'intenzione di restituire un tipo Double.
Ma l'istruzione return è ora implicita.
>> Ed è questo stile esatto è molto, molto diffuso in Swift,
tutto il luogo.
Stiamo andando a vedere questo tutto il tempo a Swift.
Così sto mostrando tutto questo a voi a causa di questa sintassi.
Questo è molto comune per vedere, il che significa che
è una funzione anonima che esegue
alcune operazioni su questi argomenti.
E c'è un rendimento implicito.
Quindi è assolutamente la stessa cosa per noi di dire questo, proprio qui.
>> Perché questo riccio staffa è una funzione,
siamo eseguire questa operazione sul primo argomento.
Stiamo per tornare quello.
Ma questo ritorno esterno è ritorno che tutta la funzione,
che tutta la funzione anonima che abbiamo appena creato.
Qualsiasi altra domanda?
Va bene, non so se voi ragazzi siete pronti per questo,
ma possiamo andare ancora più pazzo di Swift.
Sei pronto?
OK, questo è grande.
>> Ora in realtà abbiamo la capacità a, in Swift, a causa di come modulare
e come base protocollo è, per definire i nostri operatori freaking.
Come in questo caso, non avevamo operatore per il exponentiation-- bene,
per l'esecuzione di poteri di qualcosa.
Ma posso, a Swift, definire un nuovo operatore che fa proprio questo.
Quindi in questo caso non c'è un po 'di sintassi qui.
E ti permetterò di vedere le cose a casa quando si guarda a questo.
Ma stiamo definendo questo infisso operatore **, che poi ci consentono,
definendo cosa che Funzione ** realtà
non, di accettare una mano sinistra lato e un lato destro,
e poi tornare l'esponente di tale lato sinistro al lato destro.
>> E così ora tutto ad un tratto mi hanno creato una nuova numeratore.
Quindi 2 ** 3 significa 2 alla terza potenza.
[Strabiliante SOUND] Questo per si dovrebbe ti fanno essere come,
OK, vite C. vado Swift tutta la strada.
Questo è grande.
Questo è abbastanza fantastico.
>> Anche se questo è un grande esempio.
Ma non ho mai una volta al di fuori di questo esempio effettivamente
definito il mio operatore.
Ma ancora, mostra un molta della potenza di Swift
e perché questo è in realtà davvero molto cool.
Ok si?
PUBBLICO: Se siete definire il proprio operatore,
come fai a sapere che non accidentalmente cercare di creare un operatore che è
da qualche parte in C, come nascosto da qualche parte a Swift,
come un quella oscura che si non può avere mai visto prima.
>> DAN ARMENDARIZ: Quindi, se si sta cercando di definire i propri operatori,
vi è il rischio di definire uno su un operatore esistente.
Che va in un livello di dettaglio che Non credo che abbiamo tempo di andare oltre.
Ma questo è un rischio.
E questo è in realtà il vero motivo per cui Non ho usato il simbolo di inserimento, che
quando stiamo digitando potere, di solito utilizzare 4 simbolo ^ 5 o qualcosa
così, proprio quando siamo Gchatting amici o qualsiasi altra cosa.
Ma in questo caso, che in realtà avrebbe provocato una collisione.
E così ho evitato solo perché Mi è capitato di conoscere in questo caso
che ciò avrebbe causato tale collisione.
>> Tutto ok.
Ora, purtroppo, per gli ultimi sette minuti,
Devo continuare a soffiaggio le vostre menti un po '.
Quindi, mi permetta di mostrarvi alcune altre cose.
>> Vi abbiamo mostrato questa idea di avere queste funzioni anonime,
queste chiusure che consentono di tipo di passare funzioni intorno.
Li può tornare.
Li può manipolare.
Si può fare ogni sorta di cose folli.
>> Ma un'altra cosa che sembra essere utile
è la capacità di, contrariamente di tornare quelle funzioni
in una funzione, per passare una funzione come parametro a un'altra funzione.
Si potrebbe pensare bene perché sulla Terra dovrei fare una cosa del genere?
>> Beh, diciamo che voglio di prendere questo operatore che mi
lavorato così duramente per creare e applicare ad un gruppo di numeri diversi
in un array.
Quindi, in questo caso ho una serie di integers-- 1, 4, 7, 2, 5, 10, 56.
E voglio raddoppiare tutti.
Il modo in cui avremmo tipicamente farlo è quello di scrivere semplicemente
un semplice ciclo for che itera su tutti
ed eseguire una sorta di operazione piazza su di loro,
inserendo i nuovi valori in una nuova variabili, o meglio, un nuovo array qui.
E il valore dell'uscita di risulta quindi tutte queste matrici,
ovvero tutti coloro Elementi ora al quadrato.
>> E potremmo fare lo stesso cosa per cubatura esso,
ma un po 'campanello d'allarme dovrebbe andare via
dicendo che forse c'è un modo che avremmo
essere in grado di semplificare questo un po '.
E in realtà non c'è.
Che cosa se potremmo creare una funzione che ci permette
di accettare, come un predatore, una funzione?
Quindi, in questo caso, prendere una guardare a questi argomenti.
Stiamo per accettare un elenco di doppio.
E poi stiamo andando per accettare una funzione
in una variabile chiamata f che sta succedendo di prendere un doppio e restituire un doppio.
E l'intera uscita di questa funzione intera
chiamato mapper sta per restituisce un array chiamato doppio.
>> Che cosa questo avrebbe poi mi permette di fare è di iterare quella lista
e fare la stessa cosa, ma ora applicare tale funzione su ciascun
dei valori individuali di quella lista.
Quindi non so davvero che cosa f è.
Non importa a me.
Ma finché ci vuole in camera matrimoniale, esegue alcune operazioni su di esso,
e quindi restituisce un Doppia, vorrei poi essere
in grado di mappare tale funzione attraverso ogni singolo elemento della lista.
>> E questo tipo di programmazione è chiamati funzioni di ordine superiore,
dove stiamo passando funzioni intorno come parametri
e fare le cose con le funzioni.
È un po 'come prendere tutti questi idee che abbiamo imparato a CS50
e prendendo le specie di al livello successivo.
E questa è tutta roba stile CS51.
E così noi andremo a fondo più in classi come quella.
>> Ma questo è anche importante qui perché siamo
vedere un sacco di funzioni che vengono utilizzati in Swift
fa che essenzialmente questo, dove abbiamo
alcuni numeri, alcune serie di numeri.
Stiamo andando a passare che array in nostro mapper.
E stiamo anche andando a passare qualche funzione che
abbiamo già definito qui.
Sta andando essere quadrata.
E stiamo per poi quadrare tutti quei numeri
e memorizzare che in questo risultato qui.
>> Quindi questo caso abbiamo definito il nostro propria funzione chiamata mapper.
Ma questa cosa esatta è, infatti, integrato in Swift.
Ci sono una varietà di funzioni chiamate mappa.
C'è una funzione di carta, c'è una funzione di ridurre,
e c'è una funzione di filtro, che sostanzialmente applicare funzioni
ad ogni singolo elemento in un un elenco di modificarli in qualche modo.
>> PUBBLICO: Quindi, dal momento che si sta trasformando i dati in un altro formato
attraverso un function--
DAN ARMENDARIZ: Giusto.
Sì, così la funzione che stiamo accettando
sta trasformando i dati in qualche modo.
In questo caso, eravamo o quadratura, o stavamo cubatura che,
o davvero, potremmo eseguire nessuna operazione su affatto.
>> Ma lasciate che vi mostri allora come questo sta andando a guardare nella pratica.
E di nuovo, sto correndo un po 'di tempo. quindi non sono
sarà in grado di andare oltre tutto del codice sorgente qui in dettaglio.
Ma vi incoraggio a farlo.
Postiamo il più presto possibile dopo questo discorso.
>> Ma se si dà un'occhiata a questo, supporre che abbiamo un elenco di numeri,
una matrice di numeri in questo variabili numeri chiamati.
Poi vogliamo eseguire questo funzionamento del filtro su quei numeri.
Quindi filtro è un elevato Funzione affinché
accetta un array e anche una funzione.
E su ogni elemento di quella array, svolgere tale funzione.
>> Se quella funzione ritorna vero, mantiene tale elemento.
Se tale funzione restituisce false, si butta via quella voce.
E poi restituisce un elenco che viene poi riempito tutto
di quegli elementi che sono stati filtrati.
>> Quindi, in altre parole, si tratta la stessa idea, il registro di classe.
Potremmo avere una varietà di gradi in questo valore numeri chiamati.
Potrebbe essere 100, e 70, e 40, così via e così via.
Che cosa questo filtro fa è comunicazione che questo è che lo zucchero sintattico
per una funzione anonima.
Si tratta di una funzione anonima dicendo che il parametro che sto accettando
sta per essere, se è maggiore di 70,
allora questa restituisce true, il che significa che tale elemento sarà tenuto in questo filtro.
Quindi cerchiamo di essere un po ' più concreta su questo.
Se ho questa serie di numeri e consiste di 100, 70, e 40,
Eseguo questo filtro operazione su ognuno di questi.
Sicché prima è il valore di 100.
100 maggiore o uguale a 70 è vero, che
significa che 100 è mantenuto in questa nuova copia di questo array.
70 passa anche.
Ma 40 non lo fa.
Che cosa viene restituito in passingCount è la matrice di elementi 100 e 70--
100, comma 70.
Quelli erano gli unici due elementi che sono stati mantenuti.
E così il motivo per cui è andato rapidamente attraverso un sacco di questo tipo di ordine elevato
le cose sono perché questo è quello comune cosa che si vedrà a Swift abbastanza
spesso, sta eseguendo alcune operazioni utilizzando questa sintassi funzione anonima.
>> Ci sono alcune cose interessanti.
Gli switch sono davvero potente in Swift, Voglio dire solo come un pazzo, pazzo potente.
È possibile utilizzare l'interruttore, e si può effettivamente applicarle
a intervalli, che è un po 'pazzo, e fare cose fantasiose come quella.
>> Ma negli ultimi minuti, Voglio saltare abbastanza lontano
e vi mostrerà un esempio specifico di come siamo in grado di creare in iOS utilizzando Swift.
Così, quando si sta facendo questo, dovrete prendere
uno sguardo at-- su Apple documentazione, essi
hanno un sacco di veramente buoni tutorial per creare la vostra prima applicazione.
E vi incoraggio a fare che perché ti portano
attraverso tutte le fasi di quello che esattamente a fare clic su per creare un'applicazione iOS.
>> Ma qui abbiamo questa app iOS.
Ed è una bella semplice applicazione davvero.
Se faccio funzionare questo, mi permetta di mostrare quello che sembra.
Tutto ciò che fa in sostanza è esso tira da internet un file JSON
che ho memorizzato su un server.
E quel file JSON definisce le immagini che permettono
me per poi passare, nel mio app, le immagini dal mio server web.
>> Così ho qui getNextImage.
Carica un'immagine da internet, e quindi visualizza sullo schermo.
>> Quindi è abbastanza semplice.
Ma l'obiettivo qui è quello di mostrare come possiamo combinare le cose
da queste ultime settimane di CS50 in un'applicazione reale iOS.
In altre parole, forse una delle cose che si vorranno fare
è quello di avere un'applicazione iOS che può tirare i dati da internet
e mostrare all'utente alcune informazioni.
Questo è del tutto il punto di questo codice sorgente qui.
>> Quindi c'è molto da dire su come fare vero sviluppo iOS.
Ci sono un sacco di sintassi pazzo che non abbiamo ancora visto tutto
come una classe, che una classe è in realtà.
Possiamo in gran parte ignorare che per il momento.
>> Ma notiamo che abbiamo contenuto in questo una varietà di cose
che abbiamo già visto come funzioni che hanno nomi specifici.
E quando diamo quelli funzioni i nomi corretti
che sono attesi da iOS, infatti questo si sente un po 'magico.
Ma quando si crea un applicazione iOS, ci
sono i nomi delle funzioni specifiche che sono chiamati dal telefono stesso
come l'applicazione sta caricando per provare per creare il processo che effettivamente
esegue l'applicazione.
Quindi, di nuovo, ci sono un sacco di cose che mi devono sorvolare qui in modo per noi
per parlare di questo in particolare.
Ma vi incoraggio a guardare forse l'altra seminario IOS, ma anche alcune
del tutorial online che fanno un lavoro molto migliore di descrivere
le informazioni specifiche.
>> Ma possiamo vedere un paio di cose che sono interessanti dal codice qui.
Si noti che abbiamo if.
Tra l'altro, un importante cosa if
è che le parentesi intorno al Espressione booleana sono opzionali.
Ma le parentesi graffe non sono opzionali, indipendentemente poche o molte linee di codice
avete in un'istruzione if.
Non si può avere un if senza parentesi graffe a Swift.
>> E questo è, beh, una sorta di sciocco.
Ma c'è ragioni storiche per questo.
Si suppone che salvarti da te stesso.
Così per esempio, non è possibile eliminare le parentesi graffe intorno a quella
if.
Coloro che sono in effetti obbligatori.
Quindi vi incoraggio a guarda questo.
Ma c'è un altro costruisco che voglio
per mostrarvi su Swift che è nuovo a Swift 2.0 rispetto
per le vecchie versioni di Swift, che è il seguente.
Vediamo dove ho messo qui?
>> Quindi, in questa funzione chiamato fetchJSON, questa funzione
è responsabile per la trazione che JSON file da un URL, che guarda caso
essere in esecuzione sul mio CS50 IDE.
Ho appena iniziato Apache, mettere il mio file JSON lì,
e sono in grado di tirare che poi i dati da Internet utilizzando
questa funzione e questo URL, che viene fornito dal telefono.
E 'fornito da un libreria che si usa quando
si sta facendo un po 'di sviluppo di applicazioni iOS.
>> Si noti qui che c'è questo insolito costrutto sintattico chiamato guardia.
E davvero tutto questo è in Swift è un modo di verificare
che alcune cose devono stati raggiunti prima
procedere con il resto della funzione.
Così ho potuto avere, utilizzando questo tipo facoltativo,
Ho potuto trovare l'URL esecuzione di questa funzione NSURL
e memorizzare che in un URL costante, e poi controllando
per vedere se l'URL è stato pari a zero, perché stava per restituire un tipo opzionale.
E se fosse pari a zero, allora vorrei stampare un errore e poi tornare.
>> Invece, ciò che permette di guardia noi facciamo è quella cosa molto,
ma assicurarsi che sia in realtà il caso che url
è stato correttamente impostato dal NSURL.
E se lo è, allora salta su questo, e
vi permetterà di procedere con url essendo stato correttamente definito.
Ma se è vero che url non è ben definito,
se questa funzione restituisce un errore o qualche altra cosa inaspettata
in realtà si verifica, questa guardia costrutto ci permette di poi uscita quell'errore
e tornare immediatamente.
Sì?
>> PUBBLICO: Quindi è una specie di come un se poi il resto?
DAN ARMENDARIZ: E 'una specie di come un altro se poi, sì,
salvo che questo url è quindi definito per tutto di sotto di questo.
Se passa questa guardia, allora sarà effettivamente riempito con dati
ed utilizzabili nei restanti il codice sorgente nella funzione.
Così ho il sospetto che si sta andando a iniziare a vedere questa guardia pure.
Ed essere consapevoli di questo.
>> Quindi, solo guardando un paio di altri le cose, questo qui è quello che,
pensi che, solo sulla base di quello che stavamo parlando prima?
>> PUBBLICO: Penso che sarà eseguito nella lista?
>> DAN ARMENDARIZ: Così che è vicino.
Si tratta di una funzione che stiamo definendo.
E stiamo inserendo tale funzione come argomento a questa funzione qui.
>> PUBBLICO: [incomprensibile], se non nullo.
Così è nella lista, giusto?
>> DAN ARMENDARIZ: Se l'errore non è pari a zero, in modo che è-- quindi devo scorrere.
Bene, vediamo, non posso davvero scorrere a destra qui.
l'errore è un argomento che si sta passata a questa funzione anonima.
Questa è una funzione anonima.
Non ha un nome.
Ma stiamo accettando questi tre argomenti, i dati, la risposta, e l'errore.
E sta per tornare vuoto, così non sta andando a restituire nulla.
E questo è il contenuto di tale funzione.
E poi noi abbiamo accesso all'interno che funzione a ciascuno di questi argomenti.
>> Quindi è un vortice Visita della lingua.
Ma spero con questo, si spera come si prende
uno sguardo ad alcuni dei tutorial specifico per lo sviluppo di iOS con Swift,
soprattutto se si va a Web developer page-- di Apple
hanno un sacco di veramente buono tutorial per iniziare.
Ma si spera proprio questa ora di parlare sulla sintassi stessa ha dato
abbastanza per iniziare con quello.
>> Noi pubblicheremo tutto di questa fonte codice sul sito seminario
il più presto possibile, e anche le diapositive in modo da avere un punto di riferimento per tutti coloro che.
Ma buona fortuna con i vostri progetti.
E grazie a tutti per essere venuti.
>> [APPLAUSI]