>> [Jouer de la musique]
>> DAN AMRMENDARIZ: Tout le monde, accueillir le séminaire de CS50,
iOS App développement avec Swift.
Je suis Dan Armendariz, et je suis un précepteur de l'informatique ici à Harvard.
>> Et la prochaine heure va être une visite éclair de autant trucs
sur ce sujet que nous pouvons adapter.
Je vais poster la totalité du code source que vous verrez aujourd'hui en ligne.
Nous pourrions ne pas être en mesure de effectivement aller sur tout
que je suis ce que je suis vous montrant en cette heure.
Mais au moins, je l'espère grâce les commentaires du code source,
vous serez en mesure d'essayer de comprendre ce qui qui se passe exactement pour ces choses
que nous ne recevons pas assez.
>> Dans l'ensemble, la structure de La discussion d'aujourd'hui sera comme suit.
Nous allons commencer à faire un peu de base syntaxe de la langue Swift,
entrer dans une partie de la plus avancée syntaxe du langage Swift.
Parce que la langue est très moderne et il
a beaucoup de haut niveau caractéristiques, choses que nous avons pas
vu en C tout au long de CS50, ou Même certains des autres langues
que nous avons commencé en utilisant dans CS50 comme PHP,
donc je vais devoir essayer de introduisent également certains sujets qui
sont liés à la hausse des langages de haut niveau que vous ne pouvez pas voir en profondeur dans CS50,
mais vous verrez plus tard cours d'informatique.
Donc, ça va être un serrés heures.
Et s'il vous plaît sentir libre de me laisser savoir si vous avez des questions.
Donc, si vous êtes intéressé à faire du développement
avec Swift, ou vraiment tout développement d'application iOS,
il ya un couple d'exigences.
Tout d'abord, vous devez être à l'aide un Mac, en cours d'exécution dans les exemples
que nous allons utiliser aujourd'hui, relativement nouvelle version de l'OS
X. Dans ce cas, je suis X 10.5 courir.
Vous pouvez exécuter 10.11 si vous voulez.
Mais tout ce que vous allez voir impliquant Xcode est 7 et plus tard,
qui présente la dernière version de Swift, qui est Swift 2.0.
Ceci est en fait une jolie distinction importante.
A beaucoup de la syntaxe a changé assez significativement
dans certains cas, de Swift 1.0, qui a été publié l'année dernière,
Swift à 2,0, ce qui vient de sortir cet automne.
Donc, nous allons montrer Swift 2.0.
Un grand nombre des choses qui vous recherchez en ligne
lorsque vous essayez d'obtenir supplémentaires informations sur une variété de choses,
vous pouvez explicitement rechercher Swift 2
plutôt que de tout simplement vieux Swift à faire assurer que vous obtenez la syntaxe correcte.
>> En fait, cela est généralement vrai.
Il ya une quantité de développement rapide passe dans la langue Swift
depuis Apple a publié, je pense ce qui, il a été un peu plus d'un an
en ce moment.
Et les choses ont changé de façon spectaculaire en ce moment.
Et il ne faut pas être frustré si, lorsque vous êtes à la recherche autour de
pour les sujets Swift ou la façon d'accomplir quelque chose en utilisant quelques exemples de code
ou quelque chose qu'il ne travailler réellement sur Swift 2.0.
Assurez-vous que vous êtes à la recherche spécifiquement pour cette version
pour essayer de minimiser les effets de différents versions et ces sortes de choses.
>> Je vais essayer de souligner juste quelques choses qui sont différents aux anciennes versions.
Mais il est quelque chose à surveiller.
Cela va probablement être un des plus grands maux de tête
que vous aurez avec SWIFT est de trouver exemple de code qui est plus âgé, même juste
de quelques mois, en essayant d'utiliser dans votre projet plus moderne.
Et ce tout simplement ne fonctionne pas.
Vous obtenez des erreurs de compilation, de la syntaxe les erreurs, toutes sortes de trucs dingues.
Il suffit donc d'être patient avec cela, et nous espérons,
avoir une assez bonne expérience avec l'ensemble Swift.
>> Maintenant, vous pouvez réellement join-- et je l'espère nous avons toujours cette réalité cette année--
CS 50 d'application d'Apple équipe de développement, qui
vous permettra d'installer des applications que vous créez sur vos appareils iOS.
Alors jetez un oeil à cette adresse URL si vous êtes intéressé à le faire.
>> Donc, juste un couple de choses à propos de lui-même. Swift
Il est un langage compilé.
Mais vous verrez que certains des caractéristiques que nous utilisons
lui permettent d'être utilisé aussi dans un peu interprété comme une façon aussi.
>> A beaucoup de la syntaxe est empruntée de C. Il est basé et écrit en C.
Et donc nous allons voir que il ya beaucoup de plats à emporter
à partir de vos connaissances de C que nous pouvons port à Swift.
>> Mais il ya des choses qui rendre très différente de C.
Il est très fortement typé.
Il ya la gestion automatique de la mémoire.
Tu ne vas pas avoir à utiliser malloc ou n'importe où gratuitement.
Il est conçu pour généralité.
Donc, en d'autres termes, vous pouvez l'utiliser dans toutes sortes de contextes, de Apple Suivre
à l'iPhone tout le chemin jusqu'à OS X, et même certains serveurs, même certains scripts.
Mais nous verrons que le support pour les scripts
est pas encore là que il est dans d'autres langues.
Donc plus probable que vous serez à l'aide ce exclusivement pour le développement
sur votre Mac ou votre iPhone.
>> Et il a beaucoup de caractéristiques modernes.
Et beaucoup de ces choses sont des choses qui nous allons essayer de répondre aujourd'hui,
mais aussi nos sujets que franchement, nous pouvons consacrer des cours entiers.
En fait, CS 51, qui est prochain semestre offert,
se concentre beaucoup sur ces sujets qui sont décrits ci-dessous.
Ainsi, vous pouvez passer un semestre entier comprendre ces choses.
Mais nous allons essayer pour obtenir à travers eux
au moins assez que vous peut comprendre ce qui est
passe quand vous regardez à un programme Swift
et être en mesure de pirater votre chemin à travers elle pour le projet final.
>> Maintenant, l'une des meilleures façons que vous pouvez obtenir des informations supplémentaires sur ce
est franchement juste par Apple fourni de la documentation de Swift.
Il ya beaucoup d'API qui sont disponibles.
Et cela est une bonne base de départ pour vous à chercher, des choses spécifiques que vous
voulez faire avec une API impliquant iOS.
Si vous voulez utiliser l'appareil photo pour exemple, vous pouvez commencer à chercher ici,
et également utiliser Google et Stack Débordement comme vous le feriez normalement.
>> Des questions sur cette avant de sauter à droite?
D'accord.
Passons.
>> Alors d'abord, je dois une nombre de fichiers d'exemple.
Et je vais essayer de l'étape à travers eux relativement rapidement.
Ceci est le fichier Bonjour tout le monde pour Swift.
C'est très simple.
Il ya beaucoup plus de commentaires qu'il ya de code réel.
Notez que le code réel est à en bas sur la ligne 14.
Il dit impression.
Et puis il est un appel de fonction.
Nous passons dans une chaîne appelée Bonjour CS50.
Notez qu'il n'y a pas de points-virgules.
Notez qu'il n'y a aucun principale int.
Il ya rien de la cochonneries que nous avons eu avec C.
Lorsque nous utilisons Swift de cette manière, qui est simplement écrit dans un fichier texte
et stockées sur mon ordinateur, puis Je peux le compiler et l'exécuter.
>> Remarquez que je suis ici ne pas utiliser l'IDE CS50.
Cela suppose que je suis la course et que je suis sur OS X,
et que je l'ai déjà installé Xcode sur cette machine pour que cette
en fait pour fonction.
Mais cela est juste un fichier texte normal que nous puissions ensuite compiler et modifier.
Donc, nous allons voir comment cela fonctionne réellement.
Que faire si je veux compiler?
1.swift swiftc.
Après une minute ou deux, il verra que nous avons maintenant
compilé ce dans un fichier appelé 1.
Et maintenant, nous avons imprimé notre CS50, notre application Bonjour tout le monde, plutôt.
>> Remarquez une autre chose que ainsi est que, par défaut,
nous ne devons entrée a / n pour imprimer une nouvelle ligne.
Par défaut, la fonction d'impression dans Swift va imprimer une nouvelle ligne pour vous.
Vous pouvez passer d'une option supplémentaire paramètre pour lui dire de ne pas le faire.
Mais Google pour plus d'informations à ce sujet.
Par défaut, il fera la ligne d'impression.
>> Très bien, alors passons puis à d'autres choses.
Alors, comment pouvons-nous définir des variables effectivement?
Nous pouvons le faire est à l'aide l'une des deux méthodes.
Et celui que je tiens à vous dire à propos de la première est cette définition let.
Et cela est important car effectivement
ce que nous faisons est de définir une constante.
Nous allons créer une variable, ou plutôt un appelé nom de la constante,
fournir à elle dans certaines data-- ce cas, la chaîne Dan.
Mais en utilisant cette let mot-clé, nous disons
que cette variable-- ou constant-- nouveau appelé
nom ne va jamais être changé.
Ça va être immuable tout au long la durée du programme
ou tout au long de la la durée de contexte
que cette variable est disponible.
>> Ceci est très important que lorsque vous avez des données qui ne sont pas
va changer dans votre programme, et vous verrez une variété d'exemples
quand nous voulons utiliser laissez contre l'autre syntaxe,
il est important que vous utiliser let chaque fois que possible, car cette notifie
la langue qu'il est ne va pas être changé,
et il peut effectivement effectuer beaucoup d'optimisations
pour améliorer la vitesse et la sécurité de votre programme.
Et par la sécurité, je veux dire pas laissé il accident avec des erreurs folles
que nous soyons habitué à voir en C.
>> Ensuite, nous pouvons utiliser interpolation de chaîne pour encapsuler ce dans une chaîne.
Donc, nous pouvons voir dans cette ligne d'impression, imprimer bonjour,
puis en utilisant des barres obliques inverses parens ouvertes, puis le nom de ma variable,
dans ce cas constante, fermer les parenthèses.
Je essentiellement en mettant ensuite le contenu de cette variable appelée name
l'intérieur de la chaîne, puis imprimer le résultat là-bas.
>> Il ya un autre changement à ce fichier qui est ce que je dois, tout en haut,
mettre dans une ligne de tralala, qui essentiellement spécifie simplement
que je veux utiliser le Swift interprète, qui
signifie que je ne dois plus compiler ce programme particulier.
Je peux juste courir comme son propre script.
Mais cela est, dans ce cas, derrière les scènes en cours de compilation, puis
en cours d'exécution.
Il est juste invisible pour nous.
>> Très bien, alors passons.
Donc, il ya un peu de tricherie qui vient de se passer avant.
Je vous ai montré que je pourrait définir une constante.
Et je pourrais fournir des données pour le faire.
Mais dans ce cas, remarque que je ne l'ai pas effectivement spécifier le type de données
c'est tout.
Et cela est parce que le compilateur, SWIFT peut
déduire le type de données juste, fondée sur les données que je mets dedans.
Parce qu'il sait que par l'évaluation de cette la variable ici, ce droit de données
ici, elle sait qu'elle est une chaîne.
Et si ce nom est donc constante va être une chaîne aussi.
>> Mais nous pouvons aussi être explicite sur le type qui est
nous allons utiliser pour constantes ou des variables
en utilisant cette syntaxe instead-- laissez nom colon chaîne est égale
Dan, qui dans ce cas signifie que nous sommes va définir un nom appelé constante.
Ça va être du type chaîne.
Et la valeur va être Dan.
Maintenant, l'autre manière que nous pouvons créer variables--
et ceux-ci sont des variables modifiables, qui signifie que nous sommes, en fait, allons
de changer leur contenu parfois dans le contexte de la durée
que cette variable est defined-- nous utiliser le mot-clé var au lieu de laisser faire.
Mais encore une fois, par défaut, sauf si vous savez que vous devez manipuler ces données,
essayer d'utiliser pour laisser des améliorations de performances.
>> Dans ce cas, je peux alors spécifier le type de données
que nous nous attendons à être à l'intérieur du cette nouvelle variable appelée étiquette.
Ça va être une chaîne.
Et nous allons ensuite concaténer deux chaînes ensemble, la chaîne bonjour,
et la chaîne représentée par le variables, ou plutôt le nom de la constante.
>> Donc, que ce soit agréable parce que ce est un peu comme dans PHP que nous
avoir très facile concaténation de chaîne.
Nous ne devons pas automatiquement utiliser toute sorte de gestion de la mémoire
d'augmenter la taille et à faire toute sorte de choses drôles là.
Cela fonctionne comme nous aurions fait attendre.
>> Tous les droits, toutes les questions à ce sujet?
>> Maintenant, l'autre raison que nous avons besoin de vous avez la possibilité
pour être en mesure de définir ce que type de variables de données sont
est parce que parfois nous ne faisons pas vouloir initialiser les variables
avec quelques données au point de définition.
Donc dans ce cas, disons que je veux commencer à entrer
certains grades dans un carnet de notes.
Eh bien, je sais que l'un des variables qui je veux être
va être un grade mutable.
Et nous savons aussi que nous veux que ce soit un entier.
Mais peut-être que nous ne le faisons pas encore avoir cette qualité disponible.
>> Dans Swift, vous devez définir le type de données
qui est associé à un variable ou une constante laisser
Avant de pouvoir utiliser cette variable.
Parce qu'il est fortement typé, vous devez associer un type
avec ces variables.
>> Donc dans ce cas, si je ne l'ai pas correctement initialisé le premier avec une certaine valeur,
alors je besoin de dire ce que Swift Je pense que le type de données soit.
Et il va rester ce même type de données
tout au long de l'histoire de ce programme.
>> Maintenant, vous pourriez être tenté dès que Je l'ai créé cette variable de qualité
et à condition qu'elle un entier de 100, maintenant, si je
vouloir essayer de concaténer une chaîne avec cet entier,
pourraient être tentés de continuer à utiliser cet opérateur de concaténation
comme nous l'avons fait à quelques lignes avant.
Mais malheureusement, Ce sera effectivement pas
travailler, parce que vous êtes essentiellement l'exécution
une opération sur deux types différents.
>> Maintenant, ce qui est très différent des autres langages comme PHP qui sont vraiment
goosey loosey avec leur genre de types.
Ils sont comme, ouais, que ce soit, je ne me soucie pas.
Donnez-moi juste un type, et peut-être que je vais faire la bonne chose.
>> Dans ce cas, Swift est très strict sur les types
que vous faites affaire avec.
Cet opérateur de sommation ou l'opérateur de concaténation
a essentiellement un couple de différentes options possibles.
Vous pouvez le faire sommation avec des nombres entiers, ou vous
peut faire la concaténation de chaîne, et peut-être quelques autres choses aussi.
Mais si cet opérateur ne reconnaît pas ce qui est de chaque côté de celui-ci,
ou plutôt la combinaison de ceux- deux types, ne sont pas ce qu'il attend,
alors il va provoquer une panne.
>> Donc dans ce cas, ça veut dire quoi d'avoir une chaîne plus un nombre entier?
Bien dans le contexte de cela, nous voulons probablement
à faire une opération de concaténation de chaîne.
Mais bien sûr l'ordinateur ne pas avoir ce genre de contexte.
Et donc nous avons besoin de fournir que des informations supplémentaires
afin qu'il sache ce qu'il est que nous voulons faire.
>> En d'autres termes, le fait que Swift est fortement typé
signifie que vous avez à faire un peu de travail supplémentaire
pour le faire fonctionner le manière que vous voulez.
Mais de ce fait, il est plus sûr.
Et une fois que vous avez prendre compte de ces types,
les choses commencent franchement fonctionner assez bien.
>> Donc dans ce cas, nous serions alors effectuer la concaténation
par coulée explicitement l'entier en chaîne
en l'enveloppant dans cette capitale fonction S String,
puis en utilisant la concaténation de chaîne opérateur de modifier notre variable de l'étiquette,
et puis l'imprimer.
>> Jusqu'ici, tout va bien?
Très bien, passons à autre chose.
>> Maintenant, il ya une variété de données types que nous pouvons utiliser à Swift.
Comme vous l'avez pris l'habitude de, nous pouvons créer un tableau modifiable.
Et ce tableau ne peut contenir un seul type.
>> Donc dans ce cas, nous allons créer un mutables tableaux de nombres entiers,
nous appelons les qualités, et nous serons en mesure de stocker que dans ce crochet
format que vous avez pris l'habitude à une variété d'autres langues.
Mais remarquons que nous sommes ici la définition d'un certain nombre de choses.
grades est un variable-- mutable nous pas utiliser le mot clé let.
Cela signifie donc que nous pouvons ensuite modifier le contenu de ce tableau.
Il est de type Array Int, et nous pouvons dire que
sur la base de ces crochets ici.
>> Or l'une des belles choses à ce sujet est que nous
avoir accès à un grand nombre de Information Supplémentaire
sur le réseau en utilisant simplement une notation simple point.
Ainsi, par exemple, grades.count nous fournit
le nombre d'éléments qui existent en ce que tableau, que nous pouvons alors accéder jolie
facilement en utilisant simplement que la notation de points.
>> Si vous souhaitez ajouter supplémentaire articles à ce tableau,
vous ne pouvez pas faire le style de PHP où vous venez de définir explicitement,
à un indice donné, une certaine valeur que vous souhaitez insérer.
Au lieu de cela, utilisez le append procédé dans le type de tableau
pour ajouter cet élément, 95, à cette liste.
>> Alors maintenant, ce tableau a la suivante contents-- 100, 0, 90, 85.
Et maintenant, nous avons apposé leurs 95 à cela aussi.
>> Il ya d'autres façons nous pouvons ajouter des choses.
Vous pouvez effectivement utiliser un opérateur de sommation,
qui sera interprété comme une opération réseau de append.
Et vous pouvez ajouter une autre, puis tableau, dont les contenus sont 70 et 80,
à ce tableau.
Alors maintenant, nous avons la le contenu de cette variable
grades-- 100, 0, 90, 85, 95, 70, et 80.
Ceci est juste un joli petit syntaxique Swift sucre qui nous fournit.
>> Donc, si nous voulons résumer le grades, nous sommes peut-être
allez vouloir itérer sur chaque article dans cette boucle.
Et nous avons, à Swift, la notion d'une boucle que vous attendez.
Mais la façon dont nous indiquons une gamme est légèrement différente.
Donc dans ce cas, à résumer tout, nous allons
va créer un temporaire variable appelée somme pour que nous
de maintenir ce nombre.
>> Et remarquez notre pour boucle construction ici.
Pour l'index de 0 .. <grade.count.
Donc, cette construction, 0 .. <grades.count est une opération de gamme où nous sommes
dire que nous allons créer une gamme de nombres entiers de 0
mais à l'exclusion grades.count.
Ce sera donc 0, 1, 2, 3, 4, 5, jusqu'à un mais beaucoup
avant grades.count.
>> Donc ce qui est différent de la façon dont nous serait typiquement utilisé pour les boucles
où vous auriez un indice variables, elle a mis égal à 0 au premier abord,
puis intégrer cette jusqu'à ce que certains valeur inférieure à la numération des articles
dans ce tableau.
>> Donc, il ya une modification pour cela, en fait,
ce qui nous permet de créer très facilement définir différents types de gammes.
Si vous changez cette gamme de trois points, 0 ... grade.count,
ce qui représente la gamme 0 à grades.count inclusif,
ce qui signifie que ce nombre est également puis inclus dans cette gamme.
>> Mais cela est très pratique pour ces choses exactes,
quand nous avons à effectuer itérations plus de boucle
parce que ces indices sont indexés zéro, comme nous l'avons vu dans d'autres langues
aussi.
Des questions sur cette boucle for?
>> Donc, il ya définition implicite de cette variable d'index,
dont la valeur commence à 0, et continue à chaque itération de la boucle
augmenter de 1 jusqu'à un point qui est égale à grades.count,
à quel point, la boucle est abandonnée.
>> Notez que dans notre chaîne l'interpolation ici,
nous pouvons effectuer quelques simples manipulations à ces valeurs.
Donc index plus 1 sera effectivement effectuer une sommation de cette valeur
parce que l'indice est, en ce cas, un nombre entier.
Et à ce moment, il sera ensuite être converti en une chaîne
et interpolée dans cette chaîne ici, et imprimé que nous pourrions nous attendre. .
>> Et la bonne chose sur les matrices est ici
que nous sommes également en mesure d'avoir Obtention des valeurs et des valeurs de réglage
en utilisant la notation de crochet que nous avons vu dans d'autres langues aussi.
>> Très bien, alors à partir d'ici, nous maintenant calculer notre somme de toutes nos qualités.
Maintenant sorte de la prochaine étape logique serait
à faire une opération de division pour trouver la moyenne de ces grades.
Mais quelque chose d'important ici qui se passe
est que cette somme est peut-être un nombre entier.
Mais nous avons besoin de pouvoir effectuer certains sorte de double division.
Et cela va être extrêmement important quand
nous voulons effectuer cette opération, parce que ce que nous disons
est que nous devons effectivement effectuer division sur deux doubles.
Et encore une fois, parce que Swift est très fortement typé,
nous devons définir explicitement l'ensemble des articles à double avant que nous
effectuer cette opération.
>> Donc, pour nous accomplir une double division,
il ne suffit pas pour une seule de ces éléments pour être un double.
Tous deux ont pour être un double dans l'ordre pour SWIFT
pour être sûr que ce est ce que nous voulons faire.
Donc, nous allons ensuite explicitement catalogué la somme que nous avons calculé ci-dessus
et le nombre de grades à doubles, et puis effectuer cette opération et magasin
que dans cette nouvelle variable, ou plutôt cette nouvelle constante appelée moyenne,
qui aura ce type, vous imaginez?
Double, ouais.
Donc dans ce cas, nous ne pas avoir à le spécifier
car il peut être déduit de la opération ce type de moyen de données
sera.
Et Swift est généralement assez bon d'être en mesure de déduire les types.
>> Voulez-vous voir cette cours, ou que je peux passer à autre chose?
Je veux continuer.
Vous avez des questions sur tout cela?
Formidable.
>> Maintenant, nous allons commencer à se rendre à les bonnes fonctions déterminantes stuff--,
et un couple d'autres types qui sont unique de Swift que vous ne l'avez pas
vu dans d'autres langues jusqu'à ce point,
mais ils sont présents dans les autres langues que vous pourriez trouver plus tard.
Alors d'abord si vous voulez à définir une fonction,
vous définissez avec le mot génial fonction, puis le nom de la fonction,
Et puis, dans les parenthèses, les arguments que vous voulez que la fonction d'accepter.
Les arguments doivent également specify-- generally--
doit également spécifier le type de données qui ils sont, à moins qu'ils ne puissent être déduits.
Et nous voyons que peu mise en garde dans un tout petit peu.
>> Donc dans ce cas, nous avons une fonction appelée printGradeCount.
Nous allons accepter une variable-- ou plutôt dans ce cas,
un constant-- appelé carnet de notes.
Et il va être de tapez tableau d'entiers.
Maintenant, il ya quelque chose qui est vraiment important ici
que je veux que vous compreniez.
Voilà que par défaut, ces arguments qui sont entrées à cette fonction sont
défini avec un mot-clé let implicite, ce qui signifie que je ne peux pas modifier cette
variable de carnet de notes ici.
Et ce genre de logique, parce que vous êtes de passage dans les données.
Et vous ne voulez peut-être pas d'être changé de sous vous.
Il est possible de mentionner explicitement ce qui est une variable en plaçant
le mot-clé var ici.
Mais cela est une chasse aux sorcières que nous avons les gens ont remarqué l'ont fait dans le passé
est qu'ils supposaient que ça va comme une variable, alors qu'en fait, il
est une constante.
>> Très bien, alors ici, alors, dans ce cas, nous ne spécifiant pas de type de retour.
Nous allons vous montrer comment faire que dans un instant.
Mais remarquez que nous avons ici juste un simple si la condition.
Si le carnet de notes est vide, ce qui dans ce cas
est tout simplement la propriété de cet entier tableau, alors nous imprimer quelque chose.
Sinon, nous faisons quelque chose d'autre.
>> Assez simple, jusqu'ici, je pense.
Mais arrêtez-moi si vous avez des questions.
>> Maintenant cette fonction, en moyenne, prend également certains arguments, ou plutôt un argument,
qui est le carnet de notes, et cette fois- va retourner un type double.
Parce qu'il est calcule la moyenne et il est
va revenir effectivement que moyenne calculée à la ligne d'appel.
>> Dans ce cas, nous spécifions le le type de retour après une flèche.
Et cela pourrait se sentir un peu bizarre au premier abord.
Vous avez pris l'habitude à la mise au retour
saisir avant le nom de la fonction.
Mais si vous pensez de cette en termes de mathématiques,
comme lorsque vous avez les mathématiques qui définissent une fonction,
vous avez une fonction avec une certaine entrées, et il produit une sortie.
Et qui est exactement ce que ce qui est censé imiter.
Et il ya une couple d'autres langues qui ont une syntaxe similaire ainsi,
mais sans doute aucun que vous avez vu dans CS50.
Mais encore ne pas être confondu par elle.
La flèche signifie ce qui se passe être renvoyé dans ce cas.
OK, alors comment allons-nous pour calculer cette moyenne?
Eh bien, si le carnet de notes est vide, eh bien nous sommes
va retourner 0, ce qui peut-être une façon raisonnable de traiter cette.
Je ne sais pas, nous allons venir revenir dans un peu.
Ce ne peut pas réellement une façon raisonnable
pour calculer une moyenne si nous avons un carnet de notes vide.
>> Ensuite, nous allons simplement effectuons notre sommation.
Notez que nous avons fait ici avoir une version alternative d'un
pour la boucle, ce qui nous permet d'itérer sur chaque article unique dans un tableau
et placer chaque élément dans son propre variable.
En spécifiant pour le grade en carnet de notes, ce que nous disons
est que nous allons implicitement créer une nouvelle constante appelée
qualité qui va représenter chaque élément unique dans le carnet de notes
chaque fois que la boucle for.
Donc, la première fois que il est géré, note sera
être le premier élément dans le carnet de notes.
La deuxième fois, ce sera la deuxième point, ainsi de suite et ainsi de suite
jusqu'à ce carnet de notes a est épuisée d'éléments.
Ensuite, nous serons en mesure de résumer ce que qualité dans notre variable de sommation
et retourner à notre moyenne que nous avons vu auparavant.
OK, des questions?
Oui?
AUDIENCE: Je voudrais poser deux questions.
Numéro un, hypothétiquement, peut vous exécutez entier sur celui-ci?
N'a pas d'être un double, est-ce exact?
DAN AMRMENDARIZ: Pouvez-vous répéter la question?
AUDIENCE: Puis-je faire entier comme la moyenne?
DAN AMRMENDARIZ: Pouvez-vous faire entier comme un moyen?
Donc retourner un entier moyen au lieu d'un double?
>> AUDIENCE: vous Return-- avoir ce droit maintenant ci-dessous.
DAN AMRMENDARIZ: Juste ici, retourner 0.0?
AUDIENCE: Ouais, il suffit de retourner 0.
Donc, ce sera soit 80 ou 85, mais pas 85,2.
>> DAN AMRMENDARIZ: Donc, dans ce cas, donc il ya un couple de différentes façons
pour répondre à cela.
Permettez-moi de leur répondre dans l'ordre.
Donc, si je viens de faire ce retour 0, a 0 est une valeur entière.
Et ce qui va provoquer une erreur de type pour ce cas
car il attend une double mais est ensuite retournant un entier.
Si je veux retourner un entier, je peux.
Je peux définir le type de retour int, 0 revenir ici,
et non pas accomplir une double division.
Mais alors nous serions faisant division entière.
Et donc nous serions alors pas obtenir le moyenne que nous aurions peut-être attendre.
Mais oui, nous pouvons modifier les types de cette façon.
>> Public: Et deuxièmement, vous avoir une double sur le dessus.
Mais en bas, lorsque vous faire revenir Double Double,
qui est déjà automatiquement retour en format double.
Pourquoi avez-vous toujours besoin de définir avec la flèche sur le dessus avec un double?
>> DAN AMRMENDARIZ: Donc, dans le cas, cela fait partie
de the-- afin de répéter la question, parce qu'il est implicite du retour
types ici, quel type de cette réalité est, nous avons besoin d'être explicite sur Swift
à propos de ce que nous voulons revenir sur cette fonction
de sorte que lorsqu'il effectue saisir le contrôle, il peut faire en sorte
que ce que nous avons effectivement écrit bas fait conforme à ce.
Donc, il est un peu comme un chèque avec vous-même genre de situation.
Mais il y a--
>> AUDIENCE: [inaudible] Arrow?
>> DAN AMRMENDARIZ: Il ya des cas où nous pouvons préciser que nous pouvons implicitement
définir le type de retour.
Mais dans ce cas, je ne sais pas pense que cela pourrait fonctionner.
Il ya une autre syntaxe que nous verrons plus tard.
>> Très bien, alors cette source code est un peu différent
parce que cette analyse des arguments de la fonction que nous appelons.
Permettez-moi de vous montrer comment cela fonctionne: avant de passer réellement sur
à des choses intéressantes ce qui se passe à Swift.
>> Donc dans ce cas, si je viens de lancer cette Code, vous remarquerez que ce qu'il fait
tandis est--, il sorte de me donne une erreur bizarre.
Je dois passer une couple de entiers comme un argument de ligne de commande.
Voyons donc, 150 et 80, et appuyez sur Entrée pour savoir ce qu'il est en train de faire.
Il est d'accepter chacun des ces valeurs comme des nombres entiers.
Il est de les entrer dans un carnet de notes.
Et puis il est l'exécution que calcul de la moyenne
et délivrer que nous pourrions nous attendre.
>> Mais évidemment, il ya quelque chose à faire avec quelque chose sur cette rejetant
quelque chose comme un entier.
Comme vous pouvez vous rappeler de quand nous étions traiter avec des arguments de ligne de commande
en C et d'autres langues, le premier 0-ème élément dans cet argument de ligne de commande
liste est le nom de la commande que nous effectivement exécutées.
Donc dans ce cas, je suis juste en boucle sur tous les arguments de ligne de commande.
Mais je ne fais pas toute sorte de fantaisie vérifiez que sauter premier.
Je suis juste explicitement ou implicitement je suis vérifier laquelle de ces types
sont des nombres entiers avant que je ne effectuer ce calcul.
>> Et qui est essentiellement Qu'est-ce qu'il se passe ici.
Pour chaque argument en les arguments de ce processus,
Je vais effectuer une vérification.
Et dans ce cas, je vais pour tenter de convertir d'abord
cet argument en un entier par effectuer une conversion de type explicite,
car il est, en entrée, une chaîne et, en fait, pas un entier.
>> Mais cela est une sorte de syntaxe bizarre, le grade équivaut à laisser Int (argument).
Qu'est-ce qui se passe réellement ici est extrêmement
important pour votre aide Swift.
Cela est d'utiliser ce qui est appelé un type optionnel.
>> Donc cette fonction, Int (argument), renvoie pas seulement un nombre entier, mais les retours
ce qu'on appelle un entier optionnel.
Et donc cela est une sorte de un type au-dessus d'un type.
Vous pouvez sorte de l'imaginer comme il est de retour comme un paquet.
Et quand vous ouvrez ce paquet, il soit
a un nombre entier, ce qui est le résultat, ou il n'a absolument rien du tout.
Et ce qui est utile en tant que vérification d'erreur mécanisme, car dans ce cas
nous pouvons trouver, était-ce conversion réussie de type?
Si cela était, il est en fait va avoir un nombre entier à l'intérieur.
Sinon, il va avoir une certaine valeur que nous appellerons nul, ce qui
est représentatif d'aucun entier du tout.
Il est vraiment représentatif de rien.
>> Et donc cela si la construction nous permet de déballer ce paquet,
que option de liaison.
Et si nous sommes en mesure de déballer ce que emballer et de trouver un nombre entier à l'intérieur,
alors ce que nous disons ici est que nous allons ensuite
permettre à cette valeur à être mis en cette constante appelé grade.
Et cette partie de l'instruction if, la partie supérieure de l'instruction if
se déroulera, parce que unwrap a réussi.
>> Si il se trouve que il y avait peut-être une erreur
Dans cette conversion de type explicite à partir d'une chaîne en entier, peut-être
il est l'ABC de valeur par exemple.
Et cela est en fait ne va pas de se convertir à un nombre entier.
Ensuite, il sera de retour à zéro, qui est un nombre entier non.
Et cette déclaration si bien alors sûr.
qualité ne sera pas exister parce que il n'a pas de teneur en entier.
Et elle se déroulera ce bloc d'autre à la place.
Oui?
>> AUDIENCE: Néant est N-I-L?
DAN AMRMENDARIZ: nil est N-I-L, oui.
>> Donc, cela est peut-être l'un des les plus difficiles de choses sur Swift,
surtout quand vous êtes dans les mauvaises herbes sur une application iOS
et vous êtes en train d'essayer faire un peu de développement là-bas.
Ça va être criant à vous au sujet optionnel.
Il va vous poser des points d'interrogation et points d'exclamation.
Mais une fois que vous avez compris si vous out-- consacrer du temps à déterminer
ce qui se passe avec les types en option, vous vous éviterez beaucoup de maux de tête
que vous essayez de écrire une application à Swift.
>> Il est en fait une fonctionnalité très puissante.
Et vous aurez juste à prendre mon mot pour lui pour l'instant.
Mais nous verrons cette construction et quelques autres aiment
dans une partie de l'autre code source qui nous allons vous montrer dans un tout petit peu.
>> Y at-il des questions initiales ici?
Donc, la livraison important est qu'un Type option est une sorte de métatype.
Il a soit une valeur, et dans l'affirmative, alors il
aura peut-être que la valeur associée avec elle, ou il n'a aucune valeur,
et il est représenté par zéro.
Le reste de cette est peut-être comme vous le souhaitiez.
>> Donc, nous allons la rampe difficulté encore une fois.
Et cette fois, nous allons jeter un oeil à certains d'autres types de données qui existent réellement.
L'un d'eux est dictionnaires, qui est très similaire à dictionnaires Python.
Il est quelque peu semblable à une table de hachage C. Il est essentiellement un mappage de touches
où les clés peuvent être des chaînes.
Et quand vous regardez ces touches, ces clés auront une valeur.
Donc, il est pas tout à fait un tableau, mais à la place, plus étroitement associés
à une carte de hachage ou une table de hachage.
>> Voyons comment cela est censé à travailler avant que nous
aller dans le code source lui-même.
Si je viens de courir ce, rien ne se passe vraiment.
Il me dit que je vais attendre certains paramètres du type suivant.
Donc, je vais fournir à il certains noms de problème posé,
afin pset0, peut-être je suis 100.
Et pset1, je suis arrivé à 5.
Et puis à l'examen, je a vraiment bien et a obtenu 30.
Et oups, je frappe un espace ici.
>> Lorsque je tape Entrée, vous pouvez voir il effectue quelques calculs.
Il dit carnet de notes est de trois grades, pset1, pset0, examen.
Et le carnet de notes a cette moyenne spécifique.
Encore une fois, nous travaillons avec cette idée du carnet de notes,
mais nous allons continuer itération à la complexité de notre fonction.
>> Donc, au début, nous sommes juste va créer une fonction qui
est responsable de l'impression de l'utilisation.
Et il ya cette sortie fonction qui sera juste
force de quitter l'application.
Cela ne veut pas quelque chose qui vous allez utiliser dans iOS.
Ceci est seulement, dans ce cas, avec un argument de ligne de commande.
Ensuite, nous allons commencer à se déplacer vers Xcode.
Mais ceci est spécifique à une commande programme de style de ligne à Swift.
>> Jetons un oeil à quelques-uns des les choses intéressantes ici.
Voyons, seulement un couple de choses intéressantes oublier peut-être
est que dans ma fonction de imprimer le nombre de grades,
vous pourriez rappeler que je devais cette liste de pset1 items--, pset0, et l'examen.
Vous pouvez effectivement rapidement et le faire facilement
en prenant le carnet de notes, ce qui est un dictionnaire qui a les clés et les valeurs.
Retrouvez l'ensemble de la clé est par la méthode des touches de points ici,
et ensuite utiliser cette joinWithSeparator, qui prendra alors toutes les clés
que nous avions tapé dans, ou pset1-- Désolé, pset0, pset1 et exam--
et concaténer ensemble en utilisant une virgule et un espace
pour créer une longue chaîne.
Cette opération est tout simplement phénoménal rejoindre utile dans une variété de contextes.
Et il est donc cette joinWithSeparator.
>> Et cela est une chose qui est changé par rapport à une Swift Swift 2.
Il y avait un Python style-- si vous êtes
familier avec Python-- un Python style de méthode de jointure sur les chaînes.
Mais cela est plus le cas à Swift 2.
Vous souhaitez utiliser cette option si vous voulez pour concaténer un tableau de trucs
ensemble avec une chaîne.
>> Donc, peut-être alors dans notre discussion de la moyenne avant,
il fait un peu plus de sens pour nous de mettre la fonction moyenne
être une option à double plutôt que juste un double-explicite.
Parce que nous avons eu cette condition inhabituelle où,
si effectivement gradebook n'a pas de valeurs à l'intérieur il?
Quel devrait être le rendement moyen?
>> Eh bien peut-être dans C vous aurait fait quelque chose
comme prévu une valeur sentinelle, comme 0.0, ou peut-être un nombre négatif,
ou quelque chose juste représentant le fait qu'il y avait une condition d'erreur
et vous peut-être ne pas réellement avez la capacité de calculer cette moyenne.
Eh bien la beauté de spécifier une Type option serait de le faire.
Et je suis en train de dire toutes ces paroles, mais cela ne fait pas utiliser optionnels.
Mais nous allons voir que dans un peu minutes où nous pouvons établir la moyenne
pour être un type de données optionnelle afin de si elle renvoie effectivement certaines données, puis
nous reviendrons ces données.
Sinon, nous reviendrons nil, en disant que cette
a aucun calcul significative.
>> Passons à autre chose.
Donc à partir de là, nous avons examiné tous ces exemples dans la ligne de commande.
Mais vraiment ce que vous allez à traiter avec Xcode est.
Et l'une des choses gentilles sur Xcode est, et plus précisément à Swift,
est que nous avons cette chose appelé un aire de jeux.
Et une aire de jeux est pas du tout une application iOS.
Mais il vous permet d'expérimenter Swift d'une manière très facile.
Vous pouvez taper tout votre code.
Il est très bien mis en évidence la syntaxe ici.
Lorsque vous créez un nouveau fichier, il vous sera demandé si vous voulez créer une aire de jeux.
Mais la bonne chose à propos du Playground est que sur la droite de votre fenêtre,
ça fait de vous montrer sortie de votre code.
Donc, si je fais défiler vers le bas, nous pouvons voir ce que la sortie de différentes lignes de code
qui se passe réellement être.
>> Donc dans ce cas, nous allons changer de direction un peu
et de parler de quelque chose qui est vraiment important de cette façon de haut niveau
Swift qui fonctionne, et il est cette idée de fermetures.
Et vous avez probablement déjà vu cette un peu en JavaScript.
Pour ceux d'entre vous qui sont en CS50, fermetures
sont très populaires très bonne façon de faire, les choses de haut niveau dans les langues modernes.
Mais il est aussi un peu difficile à envelopper autour de votre tête la première fois.
Donc, si vous cherchez à ce première fois, qui est OK.
Il suffit de regarder le code source et de voir si vous pouvez le découvrir à la maison.
>> Donc dans ce cas, disons que nous vouloir créer un grand nombre d'exposants
avec une certaine valeur fixe.
Donc, dans ce cas, je peux créer une fonction.
Je vais l'appeler puissance de 2 dont le seul but dans la vie
est de prendre un certain entrée et double , et retourner cette valeur.
Remarquez que je suis ici accepter un type de données.
Ça va être une variable appelée x.
Il est de type double.
Et je vais revenir un double ici.
Et je vais juste faire très franchement, assez
manière naïve de doubler cette valeur.
Et je vais vous dire pourquoi ce spectacle est utile dans une seconde.
>> Notez que nous avons ici cette gamme de nouveau. pour quelque chose dans 1, point
point point, deux, ce qui signifie que cette boucle se déroulera deux fois.
Mais cela représente une variable fictive.
Cela signifie que je ne vais pas vraiment à soit en utilisant cette variable n'importe où
à l'intérieur de cette boucle.
Je veux juste cette ligne du code à exécuter deux fois,
sans avoir à connaître la valeur de cet intervalle.
>> Donc, dans ce cas, je vais courir résultat fois deux fois sur x, qui, essentiellement,
veut dire que je suis la quadrature cette valeur.
Et cela se produit pour travailler comme nous pourrions nous attendre.
Puissance de 2, passant d'une valeur de 2.0 nous donne une sortie de 4.
3.2 travaux pour 10,24.
>> Maintenant, nous pouvons faire une similaire chose pour puissance de 3.
Mais maintenant changer seulement la gamme.
Pour variable fictive en 1 à 3, multipliez 3 fois,
et faire la même chose.
>> Donc, cela peut paraître un peu artificiel.
Mais il ya une importante chose ici qui
est que regarder ces deux fonctions, il ya
une seule chose qui est différent, qui est cette valeur dans la gamme.
Tout le reste de ces deux les fonctions de puissance, 3 et 2, de la puissance
sont, en fait, identique car ils fonctionnent de la même façon.
>> Donc, à ce stade, un peu sonnette d'alarme devrait être va off.
Espérons que ce que vous dites, vous le savez, cela se sent un peu
comme la duplication des efforts.
Peut-être il ya une manière que je le ferais être capable d'encapsuler tout cela
et fournir une fonction ou créer une fonction qui
fait exactement ce que je veux sans besoin de taper explicitement.
Et voici ce que la puissance d'une fermeture nous permet de faire.
Donc, nous allons jeter un oeil à ce.
Et je vais passer un couple minutes à ce sujet, parce que ce
est assez important pour Swift.
Nous voyons cela tout le temps.
Nous allons définir une fonction.
Ça va être appelé powerof.
Il va accepter un paramètre appelé y de type int.
Mais jetez un oeil à le type de retour.
Le type de retour est, dans parenthèses, Double double flèche.
Ce qui signifie que cette fonction, cette fonction powerof,
est de retour d'une fonction.
Qui accepte un double et en renvoyant un double.
Donc, ça peut paraître un peu fou, mais nous allons faire défiler vers le bas un peu
et de regarder pour voir ce qui se passe.
Nous sommes à l'intérieur de cette fonction powerof.
Nous créons une nouvelle fonction appelé exponentiateur,
mais il n'a pas d'importance ce qu'il est.
>> Notez que cela a une valeur d'entrée de x.
Et il prend dans un double et en renvoyant un double.
Et cela est le même code que nous vu ci-dessus, sauf que la valeur de 2
ou la valeur de 3, qui limite supérieure de cette fourchette,
a été remplacé par cette valeur de y, qui
était le paramètre initial de notre fonction de powerof.
Et à ce stade, nous retourner exponentiateur.
Nous sommes de retour de la fonction.
>> Il est un peu comme un peu de l'esprit souffle.
Mais imaginons ce qui se passe quand je l'appelle cette fonction powerof
et de passer en elle une certaine valeur comme 2.
Ce que cela signifie est que Je dois maintenant la valeur
2 pour y, ce qui signifie que cette valeur y dans cette fonction de exponentiateur
sera cette valeur 2.
Mais je suis de retour cette fonction exponentiateur.
>> Donc, notez ce que dit Swift I ont créé dans ce cas.
laisser place est une définition, il est une fonction qui accepte un double
et renvoie un Double.
Je l'ai créé une fonction que quelque chose de places
en utilisant ce mécanisme ici.
Et vraiment ce qui se passe est qu'il est de retour cette fonction
exponentiateur, mais cette valeur y est enveloppé à l'intérieur.
Et maintenant chaque fois que je l'utilise de cette cette variable ou constante appelée
carré, il ça va à se comporter comme une fonction.
Et donc je peux alors appeler cette variable comme je voudrais appeler une fonction,
et passer dans un certain nombre, comme dans ce cas 3.
Et je puis carré de cette valeur.
Donc 3 carré sera alors 9 devenu, comme on peut le voir ici.
>> Vraiment fou, mais cela maintenant me donne l'occasion
pour créer d'autres fonctions de powerof.
Comme je peux dire, OK, et bien maintenant je veux pour créer une nouvelle fonction, powerof (3),
et stocker que dans un constante appelée cube.
Et maintenant cube va être un fonction distincte qui sera ensuite
prendre une certaine valeur en entrée et cube valeur que nous pouvons voir dans la ligne de fond
ici.
cube de 2 va se traduire par huit.
>> Espérons que des trucs assez soignée.
Vous ne l'avez jamais vu cela auparavant.
Je vous encourage à regarder dans les fermetures et enquêter sur ce un peu plus.
Il ya des choses vraiment puissant, nous voyons beaucoup en JavaScript et quelques autres langues.
Il est vraiment essentiel pour comprendre API ainsi
que nous aurons à juste une seconde.
Oui?
>> PUBLIC: Quand vous faites powerof (2), entre parenthèses, puis
une autre parenthèse, un autre input-- vous êtes essentiellement le remplacement de la place.
DAN AMRMENDARIZ: Alors regardez à la dernière ligne ici.
Il est en fait tout à fait possible à faire chaînage comme vous le suggérez.
Donc powerof (5) signifie que nous allons d'avoir un exponentiateur 5 ici.
Donc, cela est essentiellement va être le même chose que 4 à la cinquième puissance,
parce que nous avons créé une exponentiation fonctionner à la cinquième puissance,
et nous allons passer dans Cette fonction de la valeur 4.
Et nous obtenons cette valeur que nous attendons, 1024.
Public: Et il est pas un nom, donc il est plus facile
à lire, quelle que soit la place.
>> DAN AMRMENDARIZ: Exactement.
Alors avant que je viens de le mettre dans une constante ici, donc
qu'il a fait, il est facile d'utiliser ce nom.
Oui?
>> AUDIENCE: Dans ce contexte, powerof, ça fait partie
du langage de programmation par opposition à la façon dont vous
penser powerof dans [inaudible]?
DAN AMRMENDARIZ: Donc, dans ce cas, powerof
est simplement le nom du fonction que je définis ici.
Donc, il est pas inhérent à la langue elle-même,
mais à la place, il est juste une fonction qui a
ce nom parce que je lui donne ce nom.
D'autres questions?
D'accord.
>> Maintenant, ce qui est excellent.
Mais vous n'êtes pas d'aller voir un beaucoup de fonctions de fermeture que
sont comme ça où vous définissez, à l'intérieur d'une fonction, une autre fonction.
Et vous pouvez le faire.
Mais il est une sorte de pas vraiment nécessaire, non?
Comme pourquoi je définis ce fonction appelée exponentiateur
puis revenir immédiatement.
Pourquoi ne puis-je immédiatement retourner cette fonction?
>> Et en fait, ce sont précisément l'idée derrière un concept appelé
fonctions anonymes, où fonctions anonymes ne sont pas effectivement
avoir un nom parce qu'ils n'a pas besoin d'en avoir un.
Et dans ce cas, dans 7B, nous pouvons trouver précisément cela.
Il est tout de même code, fait exactement la même chose,
mais maintenant nous avons changé légèrement pour que cette fonction de powerof immédiatement
retourne une fonction.
Notez qu'après le retour, il ya une accolade ouverte.
Il est attendant cette entrée Double.
Il est attendant que la production double.
Et puis le mot-clé dans sépare le code lui-même.
Donc, cela est une fonction anonyme.
Il ne possède en fait un nom, considérant que avant il a été appelé exponentiateur.
Mais comme nous l'avons vu, vraiment ne pas se référer à exponentiateur
en dehors de cette fonction.
Donc, il n'a pas d'importance.
Donc, cette fonction est anonyme soi-disant parce qu'il n'a pas de nom,
mais il est encore utilisé dans le contexte de cette position.
>> Les deux prochaines ceux que je suis va continuer espérons
souffler votre esprit un peu.
Nous pouvons simplifier cela encore plus.
Parce que, comme était astucieusement a souligné plus tôt,
peut-être en fait on sait, par déduire de ce code, ce qui
la sortie de ce code va être.
Et en effet, dans cette fonction anonyme, nous pouvons en effet déduire les types de données.
>> Ainsi, dans celui-ci, nous ne sommes plus besoin de définir explicitement
le type de données qui est en cours entrée et la sortie de cette fonction,
pour un couple de raisons.
La première est que nous avons défini, à la place prototype de la fonction d'enceinte,
quel type de données de cette anonymes fonction devrait entrée et de sortie.
Et de l'autre, nous peut déduire le code
ici-bas que nous acceptons entrée qui est du type double
et en renvoyant un double.
>> Notez que nous avons ici ne sont pas explicitement selon les noms des arguments
que cette fonction accepte.
Et ainsi, nous voyons que nous pouvons nous référer à ces paramètres à l'aide de 0 $, 1 $,
ainsi de suite et ainsi de suite, en fonction de le numéro de ce paramètre utilisé
dans cette fonction.
>> Ceci est quelque chose que vous allez pour voir un lot est cette accolade ouverte
définition suivie d'une 0 $, puis une opération,
puis une accolade fermée.
Voilà une fonction anonyme qui effectue cette opération.
Il a de ce paramètre où son type est inféré.
Ce premier paramètre est de 0 $.
Et une opération est passe sur que 0 $.
>> Auditoire: Alors le signe du dollar paramètre signifie essentiellement,
et 0 signifie que la première?
DAN ARMENDARIZ: Exactement.
Alors le signe du dollar signifie fondamentalement paramètre, et 0 signifie que la première.
Mais cela fonctionne précisément dans ce cas où je ne l'ai pas nommé
les arguments de ma fonction anonyme.
>> Public: Est-ce que Perl ou quelque chose ont ce signe de dollar, dollar 0 là-dedans?
DAN ARMENDARIZ: Est-ce que, je suis désolé?
PUBLIC: ce que Perl a ce dollar 0, dollar 1--
DAN ARMENDARIZ: Je ne suis pas trop familier avec Perl,
mais ce qui définit les variables PHP sur la base de signes de dollar.
Et il peut y avoir certaines langues qui ont des caractéristiques de ce genre.
En fait, Swift emprunte une beaucoup de fonctionnalités comme ce
de beaucoup d'autres langues.
Nous voyons des notes de Python en elle.
Cette définition de Type semble venir de OCaml.
Et nous avons juste un tas de des trucs de beaucoup de langues différentes.
Voilà l'une des belles choses à propos de Swift
est que cela prend beaucoup de la meilleure des idées à partir d'un tas de langues
et tous ensemble Chausse-pieds dans une langue superbe.
En fait, si vous me permettez de continuer à souffler votre esprit,
de sorte que nous avons fait tout cela.
Nous pouvons peut-être simplifier un peu peu à se rendre compte que, bien sûr,
Swift a une exponentiation fonction intégrée.
Si je importer Darwin, qui est tout simplement la bibliothèque
les caractéristiques de cette fonction appelée pow, maintenant Je peux simplifier mon pouvoir de la fonction
comme suit.
Il va être de retour cette fonction anonyme.
>> Mais regardez comment cela est simple maintenant.
Ceci est une fonction anonyme qui est d'accepter un certain type de données,
et il va être l'un argumentation spécifiquement,
référencé à 0 $ qui est de type Double.
Il va retourner un type Double.
Mais la déclaration de retour est maintenant implicite.
>> Et il est exact que ce style est très, très répandue dans Swift,
partout.
Nous allons voir cette tout le temps dans Swift.
Donc, je montre tout cela à vous à cause de cette syntaxe.
Ceci est très fréquent à voir, ce qui signifie qu'il
est une fonction anonyme qui exécute
certaines opérations sur ces arguments.
Et il ya un rendement implicite.
Il est donc absolument la même chose pour nous de dire cela, ici.
>> Parce que ce bouclés le support est une fonction,
nous sommes effectuer cette opération sur le premier argument.
Nous allons le retourner.
Mais ce retour est externe retour cette fonction ensemble,
que toute fonction anonyme que nous venons de créer.
D'autres questions?
Très bien, je ne sais pas si vous les gars êtes prêt pour cela,
mais nous pouvons aller encore plus fou avec Swift.
Tu es prêt?
OK, ce qui est excellent.
>> Maintenant, nous avons en fait la capacité à, à Swift, en raison de la façon modulaire
et comment il est basée sur un protocole, à définir nos propres opérateurs freaking.
Comme dans ce cas, nous avons eu pas opérateur pour exponentiation-- bien,
pour effectuer des pouvoirs de quelque chose.
Mais je ne peux, à Swift, définir une nouvelle opérateur qui fait précisément.
Donc dans ce cas il ya un tas de syntaxe ici.
Et je vais vous permettre de le regardez à la maison quand vous regardez cela.
Mais nous définissons ce infix opérateur, **, ce qui nous permettra ensuite,
en définissant ce que ** effectivement fonction
ne, à accepter une main gauche côté et un côté droit,
puis de retourner l'exposant de cette gauche à la droite.
>> Et maintenant tout d'un coup, je ont créé un nouveau numérateur.
Donc 2 ** 3 signifie 2 à la puissance trois.
[Esprit sain SOUFFLAGE] Ce par elle-même devrait être comme vous,
OK, vis C. Je vais Swift tout le chemin.
C'est bien.
Ceci est assez fantastique.
>> Bien que ce soit un bon exemple.
Mais je dois jamais une fois à l'extérieur cet exemple fait de
défini ma propre opérateur.
Mais encore, il montre une beaucoup de la puissance de Swift
et pourquoi cela est fait vraiment très cool.
OK oui?
Public: Si vous êtes définir votre propre opérateur,
comment savez-vous que vous ne le faites pas accidentellement essayer de créer un opérateur qui est
en quelque part dans C, comme caché quelque part dans Swift,
comme un obscur que vous peut ne pas avoir vu avant.
>> DAN ARMENDARIZ: Donc, si vous essayez de définir vos propres opérateurs,
il existe un risque de définir un sur un opérateur existant.
Cela va dans un niveau de détail Je ne pense pas que nous avons le temps d'aller sur.
Mais cela est un risque.
Et qui est en fait la raison pour laquelle Je ne l'ai pas utiliser le symbole caret, qui
lorsque nous taper pouvoir, nous avons l'habitude utiliser 4 peu caret 5 ou quelque chose
comme ça, juste au moment où nous sommes Gchatting copains ou que ce soit.
Mais dans ce cas, que fait aurait causé une collision.
Et donc je évité ce simplement parce que Je me trouvais à savoir dans ce cas
ce qui ferait que la collision.
>> D'accord.
Maintenant, malheureusement, pour les sept dernières minutes,
Je dois continuer à soufflage vos esprits un peu.
Alors, permettez-moi de vous montrer quelques autres choses aussi.
>> Nous vous avons montré cette idée de ayant ces fonctions anonymes,
ces fermetures qui vous permettent de sorte de passer autour de fonctions.
Vous pouvez les retourner.
Vous pouvez les manipuler.
Vous pouvez faire toutes sortes de trucs dingues.
>> Mais une autre chose qui arrive à être utile
est la capacité à, par opposition à retourner les fonctions
dans une fonction, pour passer d'une fonction en tant que paramètre à une autre fonction.
Vous pourriez être bien pensé pourquoi sur Terre ce que je voudrais faire quelque chose comme ça?
>> Eh bien, disons que je veux de prendre cet opérateur que je
travaillé si dur pour créer et appliquer à tout un tas de différents numéros
dans un tableau.
Donc, dans ce cas, je dois un tableau de integers-- 1, 4, 7, 2, 5, 10, 56.
Et je tiens à les doubler.
La façon dont nous le ferions normalement faire est de simplement écrire
d'une simple boucle for parcourt tous
et d'effectuer une sorte de opération carré sur eux,
entrer ces nouvelles valeurs dans une nouvelle variables, ou plutôt, un nouveau tableau ici.
Et la valeur de la sortie résultat est alors l'ensemble de ces tableaux,
ou plutôt tous ceux éléments maintenant au carré.
>> Et nous pourrions faire la même chose chose pour cubage il,
mais un peu sonnette d'alarme devrait aller au large
disant que peut-être il ya d'une certaine façon que nous le ferions
être en mesure de simplifier un peu cette question.
Et en fait il est.
Et si nous pouvions créer une fonction qui nous permet
à accepter, comme un prédateur, une fonction?
Donc dans ce cas, prendre un regarder ces arguments.
Nous allons accepter une liste de doubles.
Et puis nous allons d'accepter une fonction
dans une variable appelée f qui va de prendre un double et retourner un double.
Et toute sortie de cette fonction entière
appelé mappeur va retourner un tableau appelé double.
>> Qu'est-ce que ce serait alors me permettre de faire est de parcourir cette liste
et faire la même chose, mais maintenant appliquer cette fonction sur chaque
des valeurs individuelles dans cette liste.
Donc, je ne sais pas vraiment ce que f est.
Il n'a pas d'importance pour moi.
Mais tant qu'il prend dans un double, effectue une opération sur elle,
et renvoie alors une Double, je serais alors
capable de cartographier cette fonction à travers chaque élément dans la liste.
>> Et ce type de programmation est appelées fonctions d'ordre supérieur,
où nous sommes fonctions passant en tant que paramètres autour
et faire des choses avec des fonctions.
Il est un peu comme prendre tous ces idées que nous avons apprises dans CS50
et de les prendre tri d'au prochain niveau.
Et cela est tous les trucs de style CS51.
Et donc nous allons aller en profondeur plus dans les classes comme ça.
>> Mais cela est également importante ici parce que nous
voir beaucoup de fonctions qui sont utilisés dans Swift
est-ce que l'essentiel ci, où nous avons
quelques chiffres, une certaine tableau de nombres.
Nous allons passer cette tableau dans notre mappeur.
Et nous allons aussi passer quelque fonction, qui
nous avons déjà défini ici.
Ça va être carré.
Et nous allons ensuite quadrature tous ces numéros
et stocker que dans ce résultat ici.
>> Donc ce cas, nous avons défini notre propre fonction appelé mappeur.
Mais cette chose est exacte, en fait, intégré dans Swift.
Il existe une variété de fonctions appelées carte.
Il ya une fonction de carte, il ya une diminution de la fonction,
et il ya une fonction de filtre, qui applique essentiellement des fonctions
pour chaque élément dans un la liste de les modifier de quelque façon.
>> Auditoire: Alors, puisque vous transformez les données dans un autre format
à travers un function--
DAN ARMENDARIZ: Droit.
Ouais, donc la fonction que nous acceptons
est la transformation des données d'une certaine façon.
Dans ce cas, nous étions soit quadrature, ou nous étions cubage il,
ou vraiment, nous pourrions effectuer aucune opération sur du tout.
>> Mais laissez-moi vous montrer comment cette va chercher dans la pratique.
Et encore, je suis à court d'un peu de temps. donc je ne suis pas
va être en mesure d'aller sur l'ensemble du code source en détail ici.
Mais je vous encourage à le faire.
Nous publierons dès que possible après ce discours.
>> Mais si vous jetez un oeil à cela, supposons que nous avons une liste de numéros,
un tableau de nombres en ce variables numéros appelés.
Ensuite, nous voulons effectuer cette opération de filtrage sur ces chiffres.
Donc filtre est un plus la fonction de commande qui
accepte un tableau et également une fonction.
Et sur chaque élément de ce tableau, il exerce cette fonction.
>> Si cette fonction retourne vrai, il garde cet élément.
Si cette fonction retourne false, il jette ce point.
Et puis elle retourne une liste qui se compose alors tous
de ces éléments qui ont été filtrés.
>> Donc, en d'autres mots, cela est la même idée, le carnet de notes.
On peut avoir une variété de qualités dans ce numéros de valeur appelé.
Peut-être 100, et 70, et 40, ainsi de suite et ainsi de suite.
Qu'est-ce que ce filtre ne constitue un avis que ce soit que le sucre syntaxique
pour une fonction anonyme.
Ceci est une fonction anonyme disant que le paramètre que je suis d'accepter
va être, si elle est supérieur à 70,
alors ce sera return true, ce qui signifie que cet élément sera conservée dans ce filtre.
Alors, soyons un peu plus concrète à ce sujet.
Si je dois ce tableau de nombres et il se compose de 100, 70 et 40,
Je effectuer ce filtre une opération sur chacun de ceux-ci.
Alors que première est cette valeur de 100.
100 supérieur ou égal 70 est vrai, ce qui
signifie que 100 est maintenu en cette nouvelle copie de ce tableau.
70 passe aussi.
Mais 40 ne fait pas.
Donc ce qui est retourné dans passingCount est la matrice d'éléments 100 et 70--
100, virgule, 70.
Ce sont les deux seuls éléments qui ont été conservés.
Et si la raison je suis allé rapidement à travers beaucoup de ce genre de d'ordre élevé
les choses sont parce que ce qui est commun chose que vous verrez à Swift jolie
fréquemment, est d'effectuer une opération en utilisant la syntaxe de cette fonction anonyme.
>> Il ya des trucs cool.
Les commutateurs sont vraiment puissant à Swift, Je veux dire simplement comme un fou, fou puissant.
Vous pouvez utiliser le commutateur, et vous pouvez réellement les appliquer
à des plages, ce qui est un peu fou, et faire des trucs de fantaisie comme ça.
>> Mais dans les dernières minutes, Je veux pour avancer assez loin
et vous montrer un exemple concret de la façon dont nous pouvons créer dans iOS utilisant Swift.
Alors, quand vous faites cela, vous aurez à prendre
un regard at-- sur Apple la documentation, ils
avoir un grand nombre de très bons didacticiels pour la création de votre première application.
Et je vous encourage à faire que parce qu'ils vous prennent
à travers toutes les étapes de ce qu'est exactement à cliquez sur pour créer une application iOS.
>> Mais ici, nous avons cette app iOS.
Et il est une application assez simple en fait.
Si je lance ce, permettez-moi de montrer vous à quoi il ressemble.
Tout ce qu'il fait essentiellement est-il tire de l'Internet un fichier JSON
que je l'ai stocké sur un serveur.
Et ce fichier JSON définit images qui permettent
je puis parcourir, sur mon application, les images de mon serveur web.
>> Donc je dois ici getNextImage.
Il charge une image à partir d'Internet, puis affiche sur l'écran.
>> Donc, il est assez simple.
Mais le but ici est de montrer comment nous pouvons combiner les choses
des quelques dernières semaines de CS50 dans une application réelle iOS.
En d'autres termes, peut-être le choses que vous voulez faire
est d'avoir une application iOS que peuvent extraire des données à partir d'Internet
et montrer à l'utilisateur des informations.
Cela est tout à fait le point de ce code source ici.
>> Donc, il ya beaucoup à dire sur comment faire développement réel iOS.
Il ya beaucoup de syntaxe fou que nous avons pas tout à fait encore vu
comme une classe, ce qui est en fait une classe.
Nous pouvons largement ignorer que, pour le moment.
>> Mais remarquons que nous avons contenue dans ce une variété de choses
que nous avons déjà vu comme fonctions qui ont des noms spécifiques.
Et lorsque nous donnons ceux fonctions les noms corrects
qui sont attendus pour iOS, en fait, cela se sent un peu magique.
Mais lorsque vous créez un application iOS, il
sont des noms de fonctions spécifiques sont appelés par le téléphone lui-même
que l'application se charge d'essayer pour créer le processus qui fait
exécute votre application.
Encore une fois, il ya beaucoup de choses que je avoir à passer sous silence ici pour que nous
pour parler de ce particulier.
Mais je vous encourage à regarder peut-être l'autre séminaire iOS, mais aussi certains
de l'tutoriels en ligne qui ne un bien meilleur travail de décrire
les informations spécifiques.
>> Mais nous pouvons voir un couple de choses qui sont intéressants à partir du code ici.
Notez que nous avons si les états.
Soit dit en passant, une importante chose à propos de si les états
est que les parenthèses autour de la Expression booléenne sont facultatifs.
Mais les accolades ne sont pas facultatifs, quel que soit le ou peu nombreuses lignes de code
vous avez dans une instruction if.
Vous ne pouvez pas avoir un si les états sans accolades dans Swift.
>> Et cela est, bien, sorte de stupide.
Mais il ya des raisons historiques à cela.
Il est censé pour vous sauver de vous-même.
Vous aimez cette par exemple, vous ne pouvez pas éliminer les accolades autour de ce
if.
Ceux-ci sont en fait nécessaires.
Je vous encourage donc à regarde ça.
Mais il ya un plus construis que je veux
vous montrer à propos de Swift que est de nouveau à Swift 2.0 rapport
pour les anciennes versions de Swift, qui est le suivant.
Voyons où ai-je mis ici?
>> Donc, dans cette fonction appelée fetchJSON, cette fonction
est responsable de la traction que JSON déposer partir d'une URL, qui se trouve juste
être en cours d'exécution sur mon CS50 IDE.
Je viens de commencer Apache, mettre mon fichier JSON là,
et je suis en mesure de tirer alors que les données de l'Internet à l'aide
cette fonction et cette URL, qui est fourni par le téléphone.
Elle est fournie par un bibliothèque que vous utilisez lorsque
vous faites un certain développement de l'application iOS.
>> Notez ici qu'il ya cette inhabituelle construction syntaxique appelé garde.
Et vraiment tout cela est en Swift est un moyen de vérifier
que certaines choses ont été remplies avant
procéder avec le reste de la fonction.
Donc, je pouvais avoir, en utilisant ce type en option,
Je pourrais ai trouvé l'URL par l'exécution de cette fonction NSURL
et stocker que dans une URL constante, puis en vérifiant
pour voir si l'URL est nul, parce qu'il allait revenir un type optionnel.
Et si elle était nulle, alors je serais imprimer une erreur et revenir ensuite.
>> Mais à la place, ce qui permet de garde nous faisons est que chose de très,
mais assurez-vous qu'il est effectivement le cas que url
a été correctement fixé par NSURL.
Et si elle est, alors il saute sur cela, et il
vous permettra de procéder à URL ayant été correctement défini.
Mais si cela est le cas que URL ne sont pas correctement défini,
Si cette fonction renvoie une erreur ou quelque chose d'autre inattendue
se produit effectivement, ce garde construction nous permet de sortir ensuite via cette erreur
et de revenir immédiatement.
Oui?
>> AUDIENCE: Donc, il est genre des comme un if then else?
DAN ARMENDARIZ: Il est une sorte de comme un if then else, oui,
sauf que cette URL est alors défini ci-dessous pour tout cela.
Si elle passe cette garde, alors il seront effectivement rempli avec des données
et le restant utilisable dans code source dans votre fonction.
Donc, je pense que vous allez commencer à voir cette garde ainsi.
Et être conscient de cela.
>> Il suffit donc de regarder un couple d'autres les choses, ce droit est ici ce qui,
pensez-vous, juste, fondée sur ce que nous parlions avant?
>> AUDIENCE: Pense qu'il va courir dans la liste?
>> DAN ARMENDARIZ: Alors qui est proche.
Ceci est une fonction que nous définissons.
Et nous sommes Saisie cette fonction comme un argument à cette fonction ici.
>> AUDIENCE: [inaudible], voire nulle.
Donc, il est dans la liste, non?
>> DAN ARMENDARIZ: Si l'erreur est non nul, de sorte que est-- donc je dois faire défiler.
Eh bien, voyons, je ne peux pas vraiment défiler vers la droite ici.
erreur est un argument qui est en cours passé à cette fonction anonyme.
Ceci est une fonction anonyme.
Il n'a pas de nom.
Mais nous acceptons ces trois arguments, les données, réponse et les erreurs.
Et il va retourner void, alors il ne va rien retourner.
Et ceci est le contenu de cette fonction.
Et puis, nous avons accès à l'intérieur qui fonction pour chacun de ces arguments.
>> Donc, il est un tourbillon Visite de la langue.
Mais je l'espère avec cela, espérons que vous prenez
un regard sur certains des tutoriels spécifique au développement iOS avec Swift,
surtout si vous allez à Développeur web de page-- d'Apple
ils ont beaucoup de vraiment bon tutoriels pour vous aider à démarrer.
Mais espérons juste cette heure de parler sur la syntaxe elle-même a donné
vous assez pour commencer avec cela.
>> Nous afficherons tous de cette source code sur le site du séminaire
dès que possible, et aussi les diapositives si vous avez une référence pour tous ceux.
Mais bonne chance avec vos projets.
Et je vous remercie tous d'être venus.
>> [APPLAUDISSEMENTS]