>> DANIEL ARMENDARIZ: Bonjour, tout le monde, accueillir au développement app iOS
avec SWIFT.
Je suis Dan Armendariz.
Je suis precepter de l'ordinateur la science ici à l'école
de génie et sciences appliquées.
Et rapide est en fait assez d'une langue vraiment bien.
Et je ai des plans pour aujourd'hui.
Donc, au cours de la prochaine heure ou nous allons regarder iOS app développement se
utilisant Xcode et effectivement la création de certains applications très simples, très simples.
Et en regardant la façon dont vous effectivement prendre ces applications,
et les construire, et effectivement les mettre sur un appareil iOS.
Certaines des choses qui nous ne allons pas à regarder
va inclure des choses comme prendre réellement une demande
et le mettre sur l'app store.
Il ya beaucoup de tutoriels en ligne qui vous aidera à cet aspect des choses.
Mais aussi parce que partie du CS50, vous obtenez
à rejoindre le développement d'Apple équipe, l'équipe de développement d'applications de CS50.
Si vous ne avez pas encore fait et vous êtes affilié CS50,
Je ne vous recommande faire parce que
comment vous êtes en mesure de créer certains programmes dans Xcode,
les construire, et effectivement mis eux sur certains de vos appareils iOS
si vous avez réellement un dispositif iOS physique.
Si vous ne avez pas un physique iOS dispositif qui est plus que bien.
Vous pouvez réellement développer pour iOS.
Et Xcode a une simulateur vous permet
pour voir votre application dans l'action sur votre ordinateur.
Mais ce genre de chose est un pur pour réellement jouer et interagir
avec votre demande sur un périphérique réel.
Donc, il ya un couple d'exigences à réellement faire tout ce développement.
L'un d'eux est que vous devez avoir un Mac.
Il doit être exécuté 10.9.4 ou version ultérieure afin de faire du développement avec SWIFT.
>> Vous pouvez utiliser une version antérieure Version d'élaborer
avec Objective C pour iOS et Mac.
Mais je recommande, et beaucoup de la exemples que nous allons voir aujourd'hui,
utiliser 10,10 Yosemite.
Donc, si vous ne avez pas encore mis à niveau, ce est une bonne excuse pour le faire.
Maintenant Xcode 6.1 est la dernière version de l'environnement de développement intégré
que Apple fournit gratuitement que vous pouvez télécharger hors l'app store.
Et je vous recommande également exécuter la dernière version.
>> Se il vous arrive de faire tourner une version antérieure Version, Xcode 5 et ci-dessous simplement
il suffit de ne pas soutenir que ce soit rapide.
Et les versions bêta de six, qui ont été libérés au cours de l'été,
faire soutenir rapide, mais il ya été un très grand nombre
des changements de la langue, assez de sorte que le code qui vous êtes
aller à regarder et que vous pourrait trouver sur internet
ne sera pas réellement compiler correctement dans ces versions précédentes de Xcode.
Encore une fois, si vous ne avez pas encore avoir un compte de développeur,
Je vous recommande d'aller à developer.apple.com.
Inscrivez-vous, créer un compte développeur, et rejoindre l'équipe CS50 de développement d'applications.
Cela va vous fournir une occasion pour compiler vos applications
et mettez-les sur votre appareil.
OK, alors nous allons commencer.
La première chose nous allons faire, ce est
pour réellement créer un très projet simple dans Xcode
cela vous permettra de faire une demande.
>> Donc, si vous ne avez pas encore Xcode ouvert, aller de l'avant et de l'ouvrir
et de créer un nouveau projet.
Un écran spécial de démarrage ouvrira et vous donnera
certaines options sur ce ce est que vous voulez faire.
Il suffit de dire que vous voulez créer un nouveau projet, une nouvelle application.
Cette fenêtre se ouvrira, en supposant que vous utilisez Xcode 6.1.
À l'heure actuelle, et pour la la durée de ce séminaire,
nous allons être en utilisant applications de vue unique, juste
une sorte de demande de base à se mouiller les pieds.
Et vous pouvez ramifier sur votre propre à partir de là.
>> Cliquez sur Suivant à ce stade.
Maintenant, voici il ya un certain nombre de choses que vous pouvez entrer.
Le nom du produit est le nom de votre projet.
Dans ce cas, je suis juste va appeler Seminar1
parce que ce est notre premier exemple.
Nom de l'organisation, dans ce cas est juste mon nom.
Vous pouvez bien sûr changer à votre propre nom, ou pour CS50.
identificateur de l'organisation, si vous arrive d'avoir un site web juste prendre
le nom de domaine en inverser, com.yourname.
puis le nom du produit devrait apparaître automatiquement
après que l'identificateur de paquet.
>> Évidemment, le langage que nous sommes allez utiliser pour aujourd'hui est rapide.
Vous pouvez, bien sûr, utiliser Objective C pour cela, mais aujourd'hui, sera rapide.
Et nous disons pour l'instant dispositifs universels, donc
qu'il fonctionne à la fois sur iPad et iPhone.
Et nous laisserons coeur des données non vérifiées de garder
le projet relativement simple pour le moment.
Donc, nous allons aller de l'avant et cliquez sur Suivant.
Et il va me demander où je veux l'enregistrer.
Je vais l'enregistrer sur mon bureau pour le moment.
>> Très bien, alors maintenant ce est ce qui se produire lorsque vous Xcode effectivement ouverte.
Et remarquez que le première chose que vous voyez
est ce point d'exclamation que dit pas d'identité de signature trouvé.
Je ai fait intentionnellement ce sur mon ordinateur et je suis
en espérant que je vais être en mesure de réellement régler le problème,
vous parce que je veux voir comment cela fonctionne réellement sur votre propre machine.
>> Allez-y et cliquez sur Correction d'un problème.
Il vous demandera si vous avez une compte développeur de pomme existant.
Ce est là que se joindre à la équipe de développement de l'application de CS50
est important afin que vous ne ont seulement un compte de l'application,
mais vous avez également la la capacité de signer les applications
et mettez-les sur votre appareil iOS.
Ce est en cliquant pas-- Correction d'un problème ne est pas nécessaire
si vous allez juste construire et développer localement,
entièrement dans le simulateur iOS.
>> Mais pour l'instant je vais à développer et à mettre
sur mon iPad, qui sera en mesure de diffuser ainsi.
Donc, je ne veux effectivement ajouter ceci.
Et ça va poser moi ma pomme ID.
Donc ça va être ça.
Et je dois chercher ma mot de passe, qui est ici.
Alors donnez-moi une seconde pour constater que, et à le copier et le coller ici.
>> Cliquez sur Ajouter.
Il va me demander quelle équipe je veux rejoindre.
Je vais faire école d'ingénieurs.
Cliquez sur Joindre.
Oups, ce est la mauvaise.
Faisons celui-ci.
Espérons que l'on va travailler.
Que l'on ne fonctionne toujours pas.
Nous manquons de bons ici.
OK, celui-ci devrait fonctionner.
Maintenant que fermer.
Maintenant, nous allons faire de l'école ingénierie, cliquez sur Choisir.
>> Et maintenant, je espère après une quelques secondes, vous can-- OK,
Je révoque et demande.
Oh man, ça va pas fonctionner.
OK, je vais essayer un autre.
Faisons celui-là.
Démonstrations en direct sont me parviennent.
Nous pourrions avoir à revenir à tout Immeuble entièrement localement,
mais ce serait OK dans ce cas.
>> Donc ici, tandis que ce est en fait travail, ce que nous allons faire est juste
créer une très simple Bonjour demande mondiale.
Donc, ce est Xcode.
Et si vous ne avez pas encore vu, il peut être un peu intimidant au début.
Il ya beaucoup de vitres, il ya une beaucoup de gadgets dans divers domaines.
Mais juste réaliser qu'il ya vraiment plusieurs composants principaux
à cet environnement de développement.
À l'extrême gauche sont tous les fichiers qui sont applicables à votre programme
ou à votre projet particulier.
Nous serons en cliquant autour certains d'entre eux et nous allons
signaler le plus ceux importantes au fil du temps.
À l'extrême droite, nous un ensemble d'attributs.
Et tous ces attributs, il sont différents volets pour les attributs.
Les vitres changeront en fonction de le contexte de la page principale, qui
se trouve être dans le milieu.
Maintenant, le milieu peut effectivement montrer vous une variété de choses, par exemple
votre code lui-même.
Ou vous pourriez réellement quand have-- vous cliquez sur le storyboard qui
est, soit dit en passant, juste un graphique représentation de votre utilisateur
interface pour votre Application-- alors les attributs volet
à l'extrême droite très va effectivement changer.
Maintenant, il ya un couple d'autres choses que je veux faire remarquer.
Vous pouvez sorte d'explorer autour dans l'environnement sur votre propre.
Mais l'une des choses qui a été très utile
est ce bouton ici, le en haut à droite de la fenêtre.
Il ya ce bouton ressemble à l'extrême
il a laissé un paragraphe suivie de deux cercles et tri
de deux flèches pointant l'un de l'autre.
Si vous basculez entre le éditeur standard, qui
est celle la plus à gauche, l'une Ce est sélectionnée par défaut,
et les deux cercles qui se chevauchent l'autre, ce que vous obtenez en fait
sont une vue à double vitrage.
>> Et ce est en fait va être utile pour nous
quand nous avons besoin de lier les articles dans l'interface utilisateur pour le code.
Et nous parlerons plus en détail que dans un instant.
Mais réalisez que si vous obtenez encore plus de panneaux de ce genre,
vous pouvez simplifier votre point de vue juste un peu en cliquant retour
sur votre éditeur unique.
Jusqu'ici, tout va bien.
Donc, fondamentalement, nous avons le code sur la gauche, les attributs sur la droite,
et quoi que ce soit nous travaillons ici dans le centre.
>> Donc ici, je ai cliqué sur le storyboard principale.
Et le storyboard, encore une fois, est une façon dans Xcode
que vous pouvez réellement créer votre utilisateur interface en utilisant simplement faire glisser et déposer
techniques.
Et donc pour notre très première application de cette
est précisément ce que nous allons faire.
Nous allons descendre à la partie très loin inférieur droit
de l'écran, qui contient une variété d'éléments d'utilisateurs
que vous pouvez alors cliquer et faire glisser pour créer votre interface utilisateur.
>> Maintenant tous ces éléments sont appelés vues
parce qu'ils fournissent une sorte de vue.
Il ya une vue de l'image, pour par exemple, pour montrer effectivement
une image sur l'interface utilisateur.
Il ya une vue de tableau à montrer effectivement une table.
Ainsi de suite et ainsi de suite.
Il existe une grande variété de vues que vous pouvez sélectionner ici.
Il suffit donc pour l'instant nous allons pour rechercher une étiquette.
Vous pouvez simplement faire défiler toutes les listes qui est là.
Mais il ya la recherche bar tout en bas
qui le rend plus facile à identifier vues spécifiques que vous avez réellement
vouloir glisser dans votre interface utilisateur.
>> Trouvé mon label.
Je vais glisser ici, directement sur mon exemple d'application.
Juste là au milieu semble bon.
Et je vais taper "Bonjour tout le monde!"
Appuyez sur Entrée.
Maintenant, je ai une étiquette.
Il ne semble pas que ce est centré à juste titre.
Donc, je peux essayer de le recentrer.
Heureusement, il offre à ces guide pour rendre les choses beaucoup plus facile.
Je vais essayer de le compiler.
Je espère que ce sera effectivement travailler ici.
Et si ce ne est pas, dans un instant il sera en effet apparaître sur mon iPad.
Ce est ici.
Il est là.
>> OK, donc ce est tout.
Nous avons terminé.
Nous avons créé notre très première application.
Maintenant, évidemment, cela ne fait rien.
Ce est juste une étiquette.
Il ya aucun lien entre l'interface utilisateur et le code.
Donc, si nous voulions vraiment pour créer cette connexion,
si nous voulions vraiment avoir une sorte de communication entre les éléments
qui existent sur la écran et le code qui
nous permet de contrôler ces éléments, puis
nous avons réellement besoin de regarder le code lui-même.
>> Donc, ce est ce qu'on appelle ViewController.swift.
Et pour, en particulier pour vos premiers programmes,
cela va être une sorte de la vrac du code que vous enter--
va être dans ce document ici.
Il ya beaucoup de choses ce est ici jusqu'à présent, non?
Il ya kit interface d'importation de classe, de la correction, [? funk,?] toutes ces différentes choses.
Et ce ne est pas tout à fait clair ce que ce est que tous ces moyens.
Alors prenons un peu de recul de suite à partir de Xcode pour un peu
et de regarder le langage lui-même, rapide.
>> Donc, avec rapide, ce était en la conception et le développement
chez Apple pendant environ quatre année à ma compréhension.
Et il ya un couple de fonctionnalités à ce sujet qui sont vraiment bien.
Tout d'abord, il est compilé la langue, tout comme C.
Donc, vous devez d'abord compiler et puis exécutez-le
Avant de pouvoir exécuter le code qui en résulte.
Mais il est, contrairement à C, un outil interactif invite que vous pouvez réellement fonctionner
et taper des commandes arbitraires en.
Et très bien comme une console JavaScript que vous connaissez peut-être maintenant,
il sera en fait ceux évaluer commandes et vous fournir la sortie.
Et ils ont même pris que à l'étape suivante
et ils ont créé quelque chose appelés terrains de jeux dans Xcode
qui vous permettra de travailler visuellement avec code.
Et nous allons réellement voir quelques exemples cela dans un tout petit peu.
Il est basé sur C. C est sous-jacente , parce que tous les compilateurs
créer un code de C et créer le code de l'objet de celle-ci.
Mais en réalité il part relativement peu de syntaxe.
Il se penchera assez différente.
Il y aura quelques similitudes.
Mais il va y avoir des un bon nombre de différences
par rapport à, disons, JavaScript ou PHP.
Et nous signalerons dans un instant.
>> Maintenant une des choses les plus importantes À propos de SWIFT ce est gentil
ce est que, surtout par rapport à C, il est destiné à être en sécurité.
Tout en elle est destinée à être très fortement typé dans.
En fait, il est presque gênant au début, lors de la première
commencer à travailler avec SWIFT, à quel autant il applique types partout.
Tout ce qui est une chaîne doit rester une chaîne.
Il est très difficile de trier de converti ou contraindre dans une autre forme.
>> Et encore une fois, nous montrons des exemples.
Mais finalement réaliser que cela est censé vous protéger,
et par vous je veux dire votre code, à partir de se écraser en quelque sorte horrible quand
vous avez une sorte de Type incompatibles.
Et encore, travailler avec elle.
Parce que ce sera frustrant au début que vous essayez de comprendre pourquoi exactement
vous obtenez cette inhabituelle traitement des erreurs types.
Mais il en vaut la peine à la fin.
>> Il ne traite avec automatique gestion de la mémoire,
donc ne vous faire avoir à traiter avec les choses
comme malloc et free et tout de ces sortes de choses.
Et il est également conçu pour des généralités.
Ainsi, alors que nous pouvons utiliser un Xcode à créer des applications iOS et les applications Mac,
nous pouvons aussi simplement l'utiliser comme un langage de script.
Et afin que nous puissions l'utiliser tri de la place de ou à la place PHP
de Python à fait analyser et de traiter rapidement
certaines données que nous avons sur notre ordinateur.
>> Il dispose d'une grande variété de moderne caractéristiques, optionnels, mutabilité,
génériques, les fermetures, et beaucoup de ce choses que vous pouvez ou ne pouvez pas reconnaître.
Et ce est juste une sorte de malheureux une partie de la langue que certains d'entre eux
sorte d'éléments modernes, futuristes sont contenus dans les éléments sont
si profondément enracinée que je ai effectivement volonté avoir à vous apprendre CS50.5 un peu.
>> Nous devons apprendre un peu plus à propos de certaines des caractéristiques afin
pour vraiment comprendre ce qui se passe suite et ainsi que vous pouvez regarder le code
et ne pas se sentir totalement perdu.
Et vous verrez ce que je veux dire par ce en seulement une minute.
OK, donc let's-- assez de cette genre de choses théorique.
Disons effectivement regardons notre tout premier programme rapide.
Ce est une ligne de code.
Ligne 14 ici, il dit l impression n bonjour CS50.
>> Il ya donc un certain nombre de choses qui est très différente sur ce rapport
à des choses que vous pourriez être utilisé à partir de C, par exemple.
L'un d'eux est qu'il n'y a pas intmain, il n'y a pas comprennent article,
il ya rien de tout cela trucs supplémentaires.
La comprennent, comme norme I / O, comme les bibliothèques
fournir le fait que caractéristiques standard de la langue,
sont automatiquement inclus en tant partie de la bibliothèque standard de SWIFT
et qui sont automatiquement importés.
Vous ne avez pas à faire que l'importation manuellement.
>> Intmain ne existe pas parce que le principal point d'entrée le code
est en fait à la début du code.
Donc, ne importe quel code que vous avez à partir du début
seront effectivement exécutés au début.
Donc, ce qui simplifie grandement vraiment.
Notez aussi qu'il n'y a aucune virgule.
Il n'y a pas des points-virgules dans cette langue.
Vous mettez une déclaration sur une ligne individuelle
puis la ligne suivante représente l'autre déclaration.
Si vous voulez mettre mulitiple déclarations en ligne,
alors vous devez séparer par des points-virgules.
Mais la plupart du temps, pour de bon style, nous sommes
jamais aller voir des points-virgules pour les fins des états de séparation
à Swift.
Alors, comment cela fonctionne?
Eh bien très bien comme nous C en fait avoir pour compiler ce.
Et afin que nous puissions le faire en utilisant c rapide et puis 1.swift.
Et puis après quelques Cela va compiler minutes
et puis je peux courir une article.
Et qu'il va juste dire "Bonjour CS50."
Impressionnant, alors là nous allons.
Il est notre premier programme bonjour de monde.
Passons au numéro deux.
>> Or, dans this-- cela a changé légèrement, parce que normalement vous
do-- en fait toujours que vous avez à compiler une application rapide avant
fait fonctionner une it-- des grandes caractéristiques
que je ai fait allusion étais avant cette SWIFT peut effectivement être utilisé dans une sorte
d'un mode de pseudo-interprétation, y est en fait comme un interprète.
Mais qu'est-ce que cela va faire est là est, en fait, une application rapide
que vous pouvez exécuter.
>> Ainsi, par exemple si vous tapez simplement rapide ici, ce qui va arriver
ce est que vous obtiendrez une invite.
Et vous pouvez taper votre rapide code, imprimer bonjour, et l'exécuter.
Et il sera effectivement print-- ainsi, il ne se imprime pas dans ce cas
parce qu'il imprime à centré out, ce qui ne est pas visible ici.
Mais il est en fait en mesure de fonctionner.
Et dans ce cas, je suis juste aller à l'utiliser comme un script.
Et je peux effectivement exécuter ce code là.
Ainsi, la manière que je dirige effectivement il sera légèrement différente,
mais vous verrez que dans un instant.
Maintenant, dans ce cas, ce que nous allons à faire est de définir d'abord une variable.
Donc, ce est la façon dont nous définissons une variable dans rapide,
ce est que nous utilisons le mot-clé let, suivi par le nom de la variable,
puis nous fournissons un certain initialisation des données éventuellement.
Donc ce cas, nous allons définir une constante appelée nom,
et nous allons utiliser que la sortie de notre ligne d'impression
tout en bas, bonjour nom.
>> Maintenant, remarquez que, plutôt que d'utiliser% s, nous pouvons encapsuler le nom de cette
variable / () et pouvoir concaténer dans le contenu de ce
chaîne dans cette chaîne.
Maintenant contrairement au C, est une chaîne réelle type réel à Swift.
Et il se trouve à côté ints et aux côtés
double très facilement et naturellement rapport
à une partie de l'autre langues que nous avons vu.
Donc, ce serait effectivement fonctionner tout comme on peut s'y attendre.
>> Je peux courir 2.swift.
Et nous voyons que mon nom est effectivement épissé dans «Bonjour Dan."
OK, impressionnant.
Passant à numéro trois.
Maintenant, ce était un peu d'un mensonge que je
dit que la façon dont nous déclarons les variables était d'utiliser le mot-clé let.
Autant de fois que vous le pouvez-vous faire vouloir utiliser laisser, parce ce que cela fait
est-il définit une constante.
Et que dit rapidement qu'il peut optimiser la vitesse de votre application
parce qu'il sait que ce variable est ne va pas changer.
>> Donc évaluer soigneusement quand vous allez utiliser
une variable pour le fins de le changer.
Et quand vous allez créer une variable simplement
de tenir certaines données et ce est pas réellement va changer.
Donc, cette notion d'immuabilité, ce ne est pas fait va changer,
est importante alors même que loin que la définition de variables.
Donc, ici, nous avons défini un nom, laissez nom, et dans ce cas
Ce est une constante, ce est de type chaîne, et il est égal à Dan.
>> Ainsi, alors que dans le précédant version, il infers-- et par «il»
Je veux dire rapide swift-- déduit le type de données
que nous sommes entrés dans la variable.
Dans ce cas, nous pouvons être explicite.
Alors laissez alors le nom de cette variable est le nom, puis un colon.
Et après les deux points-nous spécifier le type de données.
Donc, ce ne est plus int nom ou nom de chaîne ou quelque chose comme ça.
Mais au lieu laissez étiquette, nous sommes définir si oui ou non
il est constant ou variable, suivi du nom,
éventuellement suivie de la signalétique.
>> Donc dans ce cas nous définissons ce nom est une chaîne.
Nous disons, ce est Dan.
Et maintenant, je ai une autre variable, dans ce cas il est appelé étiquette.
Mais remarquez que ce est préfixé avec le mot-clé var.
Les moyens var mot-clé que cette variable peut
être changé à un point plus tard dans temps, quelque part dans le code
pouvons-nous réellement changer et il ne nous donnera aucune erreur particulière.
>> Nous pouvons faire concaténation norme opérateur ici en utilisant le symbole plus
pour réellement ajouter notre nom dans cette chaîne.
Et puis nous pouvons imprimer comme nous avons vu il ya quelques instants.
Maintenant, disons que vous vouloir créer une variable
mais vous ne voulez pas initialiser encore.
Vous ne voulez pas encore mettre toutes les données qu'il contient.
Eh bien vous avez à dire rapidement ce que le type de données
va être avant de pouvoir effectivement définir correctement.
>> Donc dans ce cas, quand nous avons défini une variable appelée année nous devons être
explicite sur son type, parce il ne peut pas déduire simplement à la recherche
au données initialisées que vous lui fournissez.
Il nous donnera une erreur si vous tapez simplement grade var, par exemple,
car il a donc aucun type.
Donc année = 100.
Alors que 100 est un nombre entier, il se adapte très bien dans cette.
Il continuera à fonctionner.
Nous pouvons voir comment nous peut concaténer ceci dans.
Maintenant, vous pourriez être tentés, si vous avez réellement
voulu concaténer la année dans une autre chaîne de texte,
dans une autre chaîne, que vous feriez tout utiliser le même opérateur de concaténation.
Et ce serait normalement être vrai.
Mais ne sera pas rapide vous permettra de implicitement changer le type de données.
Donc dans ce cas, ce ligne 25, va échouer
parce qualité est une entier et non une chaîne.
Et donc il ya une inadéquation ensemble de types.
Donc, vous devez être explicite lorsque vous souhaitez modifier ces données,
quand vous voulez pour contraindre ce données en un type différent
et dire, OK, je veux prendre ce niveau, ce qui est un nombre entier,
et le convertir en une chaîne.
>> Donc, je prends Chaîne de capital tous les types, vous remarquerez, sont capitalisés,
Int, Double, String, ainsi de suite et ainsi de suite.
Tout d'entre eux sont capitalisés juste pour rendre les choses plus faciles.
Et nous dirons capitaliser Chaîne passer dans ce grade.
Et il va créer un ficelle de cette entier.
Et puis nous pouvons concaténer les deux très bien.
Des questions sur ce genre de choses jusqu'à présent?
Très bien, nous allons charrue grâce à numéroter quatre.
>> Maintenant, nous allons parler un peu plus avancée structures, comme les tableaux et les boucles.
Et contrairement à C, les tableaux à Swift ne sont pas représentés par des pointeurs.
Pointeurs dans rapide, même si elles existent, appelé
comme des pointeurs dangereuses ou un certain type semblable comme ceci,
ils ne sont pas exposés à vous normalement.
Ainsi, il devient très difficile pour vous de manipuler
la mémoire directement de votre ordinateur.
>> Donc, les tableaux sont juste un type de données.
Et ils sont référencés en utilisant ce genre la notation de maintenant la norme de crochet
que vous avez vu avant.
Mais quand vous voulez réellement définir un type d'une variable
comme un tableau de certains type particulier, alors vous
mettre ce type entre crochets.
Donc ce que je dis ici est que Je crée une variable appelée
grades de type int tableau.
Et je suis la mise que l'égalité dans une certaine données initialisées, qui dans ce cas
est 100, 0, 90, 85, qui est juste un collection de qualités arbitraires ici.
Or, dans ce cas je le pouvais, rappelez-vous, supprimer le type,
et il serait en mesure de déduire qu'il sur la base des données initialisées.
Mais si je ai enlevé cela et Je avais besoin de mettre plus tard,
alors je aurais à assurer que je ai le type là.
Très bien, passons le long.
Donc, nous can-- tableaux nous fournir une variété
des méthodes à travers cette notation par point vous êtes probablement au désormais familier.
Donc grades.count, par exemple, nous dit précisément le nombre
des éléments qui sont contenues dans ce tableau.
>> Si je veux ajouter additional-- Maintenant, remarquez que ce est un var
pas-- et ce est une variable et un pas constant, ce qui
signifie que je peux changer le contenu de ce tableau, je peux y ajouter des objets.
Mais je ne peux pas juste dire grades et ensuite entre crochets
quatre, parce que ce sera un sur erreur de limites dans ce cas.
Si je veux vraiment changer la taille de ce tableau,
Je dois utiliser la méthode dot Ajout pour ajouter quelque chose à la fin de celui-ci.
Je peux cependant, le changement indices individuels.
>> Donc je pourrais utiliser grades et puis parenthèses carrés
zéro pour manipuler ce premier indice et ainsi de suite, comme vous le feriez normalement se attendre.
Et je peux faire la même chose pour réellement recevoir les données en provenance de ce même.
Maintenant, il ya aussi une sorte de méthode de fantaisie de le faire, ainsi que les grades égaux
puis un autre indice, qui append--
ou non une autre index-- mais une autre liste qui
ajoutera cette liste à l'arrière de notes.
Et les notes seront alors contenir tout ça.
Mais ce est une sorte de chose supplémentaire que je viens de vous montrer pour le plaisir.
>> Maintenant, il ya une boucle for.
Et ce est le début de l'endroit où les choses commencent à changer un peu.
Remarquez comment cette boucle est différent de boucles pour C.
Maintenant, je vais noter que pour les boucles à Swift peut
être fait pour ressembler à des boucles en C, mais il ya beaucoup de constructions plus utiles
qui éliminent essentiellement la nécessité avoir pour var i est égal à 0 virgule i
est inférieur à une certaine longueur, ainsi de suite et ainsi de suite, non?
Et cette construction est juste l'un d'eux.
>> Pour l'index, l'indice est nouveau variables, dans ce cas, dans la gamme.
Et ce que je dis, ce est qu'il ya une plage de 0 tout le chemin jusqu'à
mais ne comprenant pas grades.count.
Donc, ce point point de moins que le signe représente
une plage de valeurs à partir de zéro tout le chemin jusqu'à grades.count moins 1.
Il est séparé opérateur qui existe,
qui est dot dot dot, qui serait dire que je veux la fourchette de zéro
aux grades compter inclusivement.
>> Mais dans ce cas, parce que ces les tableaux sont l'indice zéro, nous avons bien sûr
ne veulent pas aller à la nombre maximum de notes.
Je peux résumer les qualités, comme vous le feriez se attendre, et la sortie tous ces trucs.
OK, passer.
Maintenant parlons de fonctions.
Afin de définir une fonction vous utilisez le mot-clé de funk.
Et encore, à Swift vous devez être très prudent avec les types.
Vous lui fournissez Paramètres en définissant, par exemple,
le nom du paramètre et puis en colin, le type de données
que vous attendez à ce que paramètre à accepter.
>> Donc dans ce cas nous avons une fonction appelée comptage de qualité d'impression.
Il accepte une variable appelée carnet de notes, ou plutôt un paramètre appelé carnet de notes.
Et nous nous attendons à ce que gradebook être un tableau d'entiers.
Si ce carnet de notes est vide, nous imprimons une chose.
Sinon, nous allons imprimer le nombre de nuances que cela a fait.
>> Maintenant, si nous voulons revenir une certaine valeur, alors la voie
que nous modifions cette définition est d'utiliser effectivement cette flèche mot-clé,
ou d'utiliser cette flèche signifiant.
Donc, nous allons définir ici une fonction appelée moyenne.
Nous allons accepter une liste de numéros.
Et nous allons revenir un double, qui, espérons-
à la moyenne de ce tableau.
Et pour ce faire, afin calculer réellement cette moyenne,
nous allons prendre une somme et nous allons de Bien sûr résumer tous les objets
dans ce tableau.
>> Notez qu'il ya une nouvelle style de boucle ici.
Nous ne avons pas à être explicite sur itération sur chaque élément,
mais nous pouvons dire à la place de grade et carnet de notes, sens
que pour chaque simple élément que nous avons dans ce domaine,
fournir cet élément dans ce variable appelée grade.
Et je veux faire quelque chose avec elle.
Donc, je vais résumer toutes ces données et effectivement retourner la double division.
>> Maintenant, remarquez ici encore il ya la concept de division entière à Swift.
Si vous voulez doubler division parce que vous voulez décimales,
alors vous devez être explicite, pas seulement sur un côté,
car il ne va pas vous permettre pour contraindre les données de chaque côté de cela,
vous avez à fait sûr les deux côtés dans doubles
de sorte que vous êtes très explicite à se assurer
que vous faites à double division.
>> Passons.
Donc, si je veux vraiment accept-- Donc, dans cet exemple particulier,
ce est encore une commande application de ligne.
Et nous commençons à voir quelques-uns des les limites de la jeune langue
en ce que nous pouvons bien accéder aux arguments en utilisant
ce process.arguments, ce est toujours pas nécessairement le plus propre
chose que nous ayons jamais vu.
Mais, fondamentalement, je vous encourage en quelque sorte de regarder ce code
et essayer de comprendre ce qui se passe exactement.
>> Essentiellement, ce qui se passe, ce est que nous prenons une liste d'arguments
et ont été les contraindre à entiers, puis nous sommes
aller à l'utiliser comme un moyen d'imprimer la moyenne de toutes nos qualités.
Passons.
Maintenant, il ya un autre type de data-- un autre type de données plutôt que de tableaux
appelés dictionnaires, qui sont très semblable aux différentes tables ou de cartes de hachage
et sont similaires aussi Tableaux associatifs de PHP.
Ils ont donc la notion des clés et des valeurs.
>> Et ils ont également défini avec cette notation de crochet,
mais la différence est que les dictionnaires ont
l'intérieur du support carré, un colon.
Et le côlon sépare les données saisissez qui est la clé et la valeur.
Donc dans ce cas, je vais créer un dictionnaire d'accepter certaines qualités.
Et il va être de type chaîne: int,
ce qui signifie que la totalité de la clés vont être des chaînes,
et toutes les valeurs de ceux clés vont être entiers.
>> Ce que cela signifie, ce est que je peux ensuite référencer les données spécifiques
que je veux utiliser ces touches plutôt à l'aide d'indices numériques comme je
aurait pour un tableau standard.
Voyons maintenant, il ya une chose importante
que je tiens également à mentionner au sujet de cette séquence de code particulier.
Et ce est qu'il ya un autre type de données,
ou plutôt il ya cette idée de données qui est
contenue dans Swift appelé optionnels.
>> Et ce est signifie optionnels qu'il reconnaît le fait
que, parfois, vous ne allez pas obtenir les données que vous attendez réellement.
Et donc ce que je veux dire par là, nous allons est-- jetez un oeil à cette séquence code
qui parcourt sur toute la arguments qui ont été adoptées à ce code
et tente de les convertir, essais à diviser en une série de cordes,
car il accepte une très type particulier d'argument.
Et puis, il va essayer de contraindre les chaînes qui représentent des nombres
en nombres entiers qui sont les grades, que je peux alors calculer.
>> Donc, fondamentalement, je vais utiliser cette fonction de scission qui
existe dans la Bibliothèque standard Swift.
Je vais passer en elle la chaîne que je veux partager.
Et puis dans l'utilisation de ce type de syntaxe génial, qui
Je ne sais pas si nous allons arrivons à, mais peut-être, nous
seront effectivement préciser le précise caractère que nous voulons couper à.
Alors qu'est-ce que cela ressemble?
Jetons un oeil à exécutant effectivement ce code.
>> Ainsi, par exemple, disons que je ai un quiz et je ai eu 50 à ce sujet.
Et je ai psets et Je ai eu une centaine à ce sujet.
Et je got-- il ya un autre quizz et je ai eu un 40 sur ce point.
Je ai frappé Entrez, et finalement ce qui va se passer, ce est que ce qu'il fait
est la prise de ces paramètres, le fractionnement les cordes à ces deux points,
reconnaissant qu'il ya deux éléments dans chacun,
et ce est essentiellement garder la trace de chaque.
>> Donc, je ai dans mon dictionnaire un quiz, dont le valeur est représentée par le nombre 50,
Je ai un PSET qui a une valeur de 100, et un autre quiz qui a une valeur de 40.
Puis, plus tard dans le code que je ai fait la moyenne de toutes ces valeurs
et la liste de toutes les touches de ce dictionnaire spécifique.
Mais ce est important de sorte que vous pouvez le constater
ce qui se passe, ce est que ce que nous vouloir faire est de prendre cette chaîne
et diviser à ce caractère, que nous pouvons faire à nouveau avec cette scission
fonction en utilisant ce genre de syntaxe intéressante qui existe ici.
>> Juste pour l'instant supposer que ce est OK.
Nous allons examiner plus à ce en seulement un peu de temps.
Mais maintenant il ya un intéressant aspect qui nous fait
essayer de convertir cette chaîne en un entier.
Mais dans d'autres langues ce qui pourrait arriver est
que nous essaierions probablement de le faire et soit revenir
une sorte de sentinelle comme valeur négative
ou peut-être une valeur nulle ou quelque chose comme ça.
Ou peut-être il serait tout simplement provoqué une erreur.
Et nous aurions à puis prendre cette erreur
puis essayer de faire quelque chose sur la base du fait
que cette conversion à un nombre entier échoué.
Ce est là que cette idée d'optionnels entre en jeu.
Vous pouvez effectivement créer un type de données qui est un int interrogation, par exemple.
Cela signifie que cet entier est, en fait, en option.
Et ce qui va arriver, ce est qu'il peut contenir un entier, ou il ne peut pas.
Il peut, en effet, être cette autre idée, appelée entièrement nulle.
Dans lequel cela signifie qu'il ya aucune valeur dans ce.
Il ne est même pas zéro, il ya juste aucune valeur.
Il n'y a absolument aucune valeur représentée.
>> Et ce est ce que cette ligne 71 est fait.
Est-ce que ce est dire que je essayer de définir une valeur,
une variable appelée classe, égale à la conversion de cette chaîne en un int.
Je ai donc pris cette chaîne, ces premiers éléments,
ou plutôt la seconde composants, parce que ce
est zéro indexés, de ce chaîne que je ai divisé.
Et je veux convertir que pour un nombre entier.
Mais il ne est pas toujours procéder normalement, imaginez parce
ce qui arriverait si, plutôt que par type un certain nombre, je tape bien sûr, comme asdf.
>> Il va à l'échec.
Ce ne est pas fait va être capable de convertir en un nombre entier
comme je m'y attendais.
Ainsi, plutôt que le coup d'envoi une sorte d'erreur,
nous avons cette idée d'une option.
Et cela signifie que l'utilisation cette interrogation que je peux dire,
OK, est-il possible que je peux prendre cela, converti en un int,
et le mettre dans une variable, qui sera également un int.
Si oui, alors que des moyens ce qui a réussi
et cette première partie de le bloc peut continuer.
>> Sinon, il a échoué.
Il n'y a aucune valeur dans grade-- ou plutôt il n'y a pas valeur existante,
et je ai fait pour essayer de gérer cette condition d'erreur.
Vous allez voir ce Aide à la recherche tout le temps
à Swift et exemple de code pour Swift.
Et en fait, l'opérateur Nill, ce genre point d'interrogation, la partie des optionnels,
va être probablement l'un des choses les plus difficiles
en quelque sorte d'envelopper votre tête autour que vous travaillez effectivement avec elle.
>> Il pourrait faire sens aujourd'hui.
Et en fait, quand je étais l'écriture de code de l'échantillon pour cette,
certainement je ai compris ce qui se passait,
mais toujours m'a pris par la surprise de temps en temps
quand je trouverais cela certaines données étaient effectivement
une version nul, une version optionnelle des données que je me attendais.
Il suffit donc de se rendre compte que si vous disposer d'une version en option
vous devez décompresser que les données de cette boîte.
>> Donc, ce est un peu comme si vous imaginer I-- avoir une boîte et il contient quelque chose.
Et ce que vous devez faire est de poser la question,
est-il possible que cette boîte fait contient les données que je suis à la recherche?
Si oui, puis tirez sur les données et mettre dans cette variable existante.
Si pas, alors je ai juste à ignorer le contenu de cette boîte
complètement, car il contient littéralement rien.
>> Vous avez des questions à ce sujet?
OK, nous allons sortir de cette genre de chose sur la base ligne de commande
et commencer à regarder une partie de la technologie
que Xcode fournit à nous sous la forme de terrains de jeux.
Donc, il ya beaucoup de capacité à Swift ici.
Et si vous ouvrez Xcode et il vous demande ce que vous voulez faire,
vous pouvez ouvrir l'aire de jeux et juste jouer
avec beaucoup de différentes structures et aspects de la langue
avant même de commencer toucher le SDK iOS ou Mac SDK.
>> Donc ce cas, disons que je have-- Je ai un exemple relativement artificiel
ici, mais garder avec moi que nous trions de travailler à travers cet exemple.
Disons que nous devons faire beaucoup d'exposants d'une valeur fixe,
comme nous savons que nous allons avoir besoin de faire beaucoup de pouvoirs carrés, par exemple.
Donc, nous allons prendre une certaine valeur x, nous allons au carré,
nous allons prendre une certaine valeur y et nous allons au carré.
Ainsi de suite et ainsi de suite.
>> Maintenant, nous pourrions en fait juste créer un puissance de 2 pour cette fonction, non?
Nous aimerions donc créons une puissance de 2 fonction.
Nous acceptons un double.
Nous allons output-- ou nous allons retourner un type double.
Nous allons prendre ce résultat puis deux fois
ce que nous prenons effectivement les résultats, qui a été initialisé à la valeur de l'un,
et le multiplier par x.
Donc, en substance nous avons x fois x ici.
>> Et alors je ai peut alors, comme nous pourrions attendre, prendre ce, pouvoir fonctionner de 2,
fournir à elle certaines données, je aime 2.0.
Et nous arrivons à voir les résultats ici 4.0.
Exécutez puissance de 2 sur 3.2 et nous la chance de voir nos résultats, 10,24.
Jusqu'ici tout va bien, non?
Nous sommes en train de penser, eh bien, OK.
Maintenant je ai besoin de faire beaucoup de pouvoirs de trois.
Donc, je vais copier coller tout ce code, changer le nom de la fonction à partir de
puissance de 2 à puissance de 3, et tout sera le même, sauf pour cette valeur
ici, cette gamme, 1 ... 2.
>> Ainsi, plutôt que de répéter cette boucle double,
Je tiens à répéter cette boucle trois fois.
Donc, je viens de changer cette valeur de 1 à 3-- ou plutôt entre 2 et 3.
Encore une fois, le même code, ce est le seul changement.
Maintenant cela fonctionne aussi.
Puissance de 3 fournis dans une certaine valeur de 2.
Nous obtenons 8.
Donc, deux cubes.
Et 3,2 cube est 32,768.
Et jusqu'ici tout va bien, non?
Mais je espère que ce est un peu peu d'un drapeau rouge pour vous
en ce que nous avons maintenant certains chevauchements code
sauf pour certains très mineur changer de l'un à l'autre.
Donc, il ya une certaine façon que nous pourrions être en mesure de simplifier
ce problème, où nous pouvons effectivement, au moment de l'exécution, comprendre certains,
nous fournir une fonction qui a précisément la puissance de ce que nous voulons.
>> Et il ya cette idée de fermetures, qui est vraiment, vraiment
importante dans le contexte de Swift, et dans de nombreux autres langues.
Mais sans doute vous verrez il a utilisé plus dans Swift
parce qu'il est intégré à l'intérieur de la langue
que vous voulez dans les autres aussi les langues modernes.
Donc, l'idée d'une fermeture est cela, ce est que nous
peut avoir une fonction qui est destiné à être une fonction générique, une puissance générique
de la fonction.
>> Et cette fonction va accepter cet exposant que nous fait
vouloir créer.
Ainsi, par exemple, la première exemple, nous voulions une puissance de 2.
Nous serions donc fournir de l'énergie de puis entre parenthèses 2.
Et maintenant remarquer ce cela renvoie effectivement.
Ceci prend une entrée d'une amorce appelé qui y est un nombre entier,
et il revient cette folle recherche chose entre parenthèses parentheses--
double puis double flèche.
>> Ce que cela signifie ce est que je suis va retourner une fonction.
Je ne suis pas de retour un autre type de données, je suis
en fait une fonction de retour qui présente ce paramètre, qui
accepte une double comme entrée et une double sorties comme une valeur de retour.
Et en conséquence, parce que maintenant je ai appelé puissance de, en passant une certaine valeur pour y,
et je crée cette autre function-- avis qu'il ya
une autre fonction qui est en cours de création intérieur de this-- ce que je fais
ce est que je peux alors changer de cette valeur, que l'on
la valeur que je avais changé 2-3, je fais maintenant, il y.
>> Et cela persiste.
Ainsi, chaque fois que je appelle le pouvoir de, ce qui se produit essentiellement
ce est que je me retournai une fonction.
Remarquez qu'ici je ai défini une nouvelle variable appelée carré.
Je l'ai établie égale à la puissance de, fourni cette valeur 2 à la puissance de.
Et ce que cela est retourné la fonction.
Donc carré, la variable carré, est maintenant de type fonction
qui a this-- oops, faites défiler jusqu'à une peu bit-- qui a cette signature,
accepter une double et une double sortie.
>> Alors maintenant, ce que je ai fait ce est que je ai essentiellement
créé un carré de fonction appelée que accepte toute valeur et seront au carré.
Nous pouvons voir ce qui se passe ici.
Place 3 par exemple, signifie que je vais de prendre la valeur 3 et carré il.
Alors, comment fait exactement ce travail?
Quand je passe puissance de 2-- quand je passer 2 dans ce pouvoir de la fonction,
cette variable y est peuplé avec cette valeur 2.
Et ce est une sorte de lieu de mémoire.
Ce est un peu comme lieu en Etat quelque part dans l'ordinateur,
nous ne nous soucions pas vraiment comment ou si à ce stade.
>> Mais je reviens cette fonction appelé exponentiate.
Et encore, il n'a pas vraiment d'importance ce cette fonction est appelée,
nous pouvons vraiment appeler ça, que accepte un double et retourne un double,
mais utilise cette valeur y l'intérieur de celui-ci.
Ainsi, même si ce est cette fonction, cette fonction de exponentiater ce est
été retourné à ma variable qui je ai appelé carré,
il est contenu dans ce cette notion de ce qui y était.
Et il se en souvient.
>> Ainsi, chaque fois que je appelle cette fonction que qui est maintenant appelé carré, il utilise cela.
Mais cela signifie aussi que je peux créer une autre variable à l'aide
une puissance différente de.
Donc, je peux créer une variable de cube, pour par exemple, fournir à ce pouvoir de trois.
Maintenant cube sera effectivement prendre un certain la valeur et cube et le retourner.
Donc, nous pouvons voir que je reçois une valeur 8 sur cela.
>> Mais cette valeur y n'a pas changé parce qu'ils sont
tenue dans une sorte de variables indépendantes.
Ils sont en quelque sorte des détenus dans espaces indépendants dans la mémoire.
Donc cube aura toujours x à la puissance trois.
Et carré aura toujours x à la puissance de deux, qui
signifie que la place sera toujours nombres carrés, que je attends.
Et cube sera toujours coupé en cubes numéros, comme je l'attendent.
Cela signifie aussi que, parfois, vous pouvez obtenir une sorte de syntaxe regardant génial
où vous avez le pouvoir d'au très bas de l'écran ici, puissance de 5.
Et vous passez dans le résultat.
Vous appelez cette fonction qui est été retourné avec le numéro 4.
Et qu'est-ce essentiellement ce 4 est le cinquième puissance,
nous pouvons voir les résultats là-bas.
Avec moi jusqu'ici?
>> Donc, cette idée se appelle une fermeture, parce que ce que nous sommes essentiellement faire
est que nous sommes encapsulation certaines données into-- tri
à enfermer ces données dans une fonction et nous sommes
pouvoir réutiliser cette fonction.
Maintenant cette syntaxe peut bien fait simplifier une grande quantité.
Et il ya beaucoup de possibilité à Swift pour cette simplification.
Et ce est ce genre de la les suivantes regardez vraiment.
Donc, en 7b par exemple, nous prendre ce même code.
>> Mais maintenant, plutôt que effectivement définir une fonction
l'intérieur de ce pouvoir de fonctionner et lui donner un nom,
puis retourner le nom de cette fonction, ce qui
puis est utilisé dans le cadre de cette fermeture, la place nous sommes
aller juste pour le simplifier.
Nous ne avons pas besoin de cette fonction pour être nommé.
Donc, ce est le concept d'un fonction anonyme où l'on peut ensuite
accepter comme entrée, entre parenthèses ici, la variable x qui est de type double.
>> Nous allons retourner la double type.
Et puis le mot-clé, n, est le début de cette fonction.
Donc remarquer que tout cela est entre accolades
et nous définissons une anonyme fonctionne ici.
Juste une façon plus simple de définir exactement la même chose.
D'ACCORD?
Mais attendez, Swift nous permet effectivement aller plus loin et de simplifier encore plus,
parce que vraiment nous ne avons pas soin que ce paramètre est
nommé quelque chose de particulier.
Il peut vraiment être appelé ne importe quoi et nous pouvons encore utiliser ce premier paramètre.
>> Donc, en fait, il ya cette spéciale type de données dans des fonctions anonymes,
il ya ce nom spécial de variables dans des fonctions anonymes
qui commencent avec le signe de dollar et représentent
les numéros de paramètres, zéro indexées, pour cette fonction.
Donc, il ya un couple de choses qui se passent.
Ici, je vais revenir, et puis un accolade représentant une fonction,
droit?
>> Remarquez que je ne ai pas défini la types paramètres ou le type de retour.
Il peut effectivement être déduite en raison de la signature
de cette fonction d'origine.
Donc, nous pouvons éliminer que comme une possibilité.
Mais aussi je peux utiliser le signe de dollar zéro à représenter ce premier paramètre qui est
passé dans cette fonction anonyme.
Simplifiant ainsi encore plus.
D'ACCORD?
Jusqu'ici, tout va bien?
>> Maintenant, ce est ce bien---vous rappelez-vous ce signe dollar zéro
que nous avons vu dans cette accolade que nous avons vu juste un peu de temps
Il ya dans ce six exemple Swift?
Ce est ici.
Notez que ce est exactement ce que nous cherchons à,
ce est que nous avons passé dans cette fonction rattrapante
une fonction anonyme qui vérifie le premier paramètre
pour voir se il est égal au symbole du côlon.
Et ce est exactement ce qui est passe, ce est que tous les
nous doing-- le retour mot-clé est implicite
dans ce case-- nous retour cette valeur lorsque nous comparons
le premier paramètre contre ce colon de caractère.
Et ce genre de démystifie cette.
Et vous allez voir cette construction beaucoup dans la syntaxe Swift, il ne faut garder que
à l'esprit lorsque vous êtes jeter un oeil à ce sujet.
Maintenant, nous pouvons descendre les rails un peu
et aller vraiment envie que les spectacles même un peu plus de la puissance de Swift.
Vous pourriez même voir de ceux-ci dans des exemples de codes.
Donc, ce est pourquoi je vais le montrer à vous.
>> Fondamentalement, ce que nous pouvons faire est que, premièrement de tous, il était un peu inutile pour moi
mettre en œuvre toute cette puissance de Code parce que si vous importez le Darwin
bibliothèque, il comprend en fait une fonction appelé pow qui fait cela pour vous.
Donc, nous pouvons simplifier encore plus et avoir notre fonction de puissance jusqu'à maintenant juste
être un merveilleux une chemise où nous venons de retourner cette fonction anonyme
accepte signe dollar 0 comme base et y comme exposant.
>> Mais nous pouvons être vraiment, vraiment envie quand nous
réaliser que Swift a un beaucoup de puissance sous le capot.
Un grand nombre des opérateurs nous avons eu affaire à,
ainsi que les signes et les symboles de la division et toutes ces choses que vous normalement
fonctionner avec des types de données dans un langage de programmation,
sont en fait extensible à Swift.
Donc ce que cela signifie que nous en peut définir nos propres opérateurs.
>> Alors maintenant, je suis fatigué de taper tout cela pow, puis un parenthèses puis
la base.
Je ne veux pas faire ça.
Je veux réellement avoir un opérateur qui me permet de faire cela.
Donc, je peux dire que je veux Swift pour créer un opérateur, étoile
star-- par la façon dont je ne peux pas utiliser le carat parce que le carat est un opérateur qui
fait tout autre chose.
Donc, je ne veux pas trier d'entrer en collision avec cela.
Et ce que vous voyez dans une variété des langues, y compris Python,
ce est comme opérateur de star pour représenter exposants.
>> Donc, ce est la seule raison pourquoi je ai fait cela.
Et il va être un opérateur de type infixe.
Et je dois fournir pour elle des informations
au sujet de la priorité de cette opérateur, il est si associative gauche.
Ce est comme relativement priorité élevée comparée
à la sommation ou la multiplication.
Ce est une priorité plus élevée que tous ceux.
Ainsi de suite et ainsi de suite.
Et puis je définis le fonction qui fait
dicte ce que cet opérateur fait.
Donc, en supposant que je ai une gauche côté et du côté droit,
qui serait peut-être un meilleur nom variable pour cela.
Côté gauche et côté droit.
Je peux alors prendre ce pouvoir de la gauche à la droite
et retourner cette valeur.
Alors maintenant, ce est super doux.
Tout ce que nous avons à faire est de 2 étoiles 3 étoiles et ce est 2 à la puissance trois,
et nous obtenons une valeur de 8.
Étoiles 2 étoiles 10 est 2 à la Puissance 10, nous obtenons 1024.
>> Alors maintenant, notre pouvoir de la fonction, qui encore une fois est différent,
parce que l'idée derrière cette ce est que nous avons une fonction qui
prend toujours une certaine valeur et it-- multiplie ou plutôt
prend l'exposant à la même puissance.
Alors maintenant, ce est encore plus simple.
Alors maintenant, ce est juste dollar signer étoiles 0 étoiles y.
Nous ne avons même pas plus d'utiliser pow.
>> OK, qui a perdu?
Faisons-nous OK?
Des questions sur ce genre de choses?
Ouais?
>> AUDIENCE: Lorsque vous-- [inaudible] la puissance de funk de y double.
Alors, quand vous êtes de retour d'une fonction.
DANIEL ARMENDARIZ: Funk puissance de y double.
Oh oui, je ne sais pas ce que les nombres y sont.
Désolé à ce sujet.
>> AUDIENCE: Pourquoi êtes-vous retournez une fonction [inaudible] enceinte.
Ne est pas zéro dollar étoiles étoiles y [inaudible]
cet opérateur à trouver que renvoyant un double [inaudible] doubler?
>> DANIEL ARMENDARIZ: Alors laissez- moi de répondre à votre question
ce que je comprends et vous pouvez me dire si je ne ai pas compris votre question.
Donc, cette construction, l'accolade signe de zéro dollar star y,
est une fonction.
Et il accepte un paramètre qui est représenté par ce signe de zéro dollar.
Le mot-clé return est implicite dans ce très court, anonyme syntaxe de la fonction.
>> Ce qui signifie que l'essentiel ce que cela veut dire
ce est que je suis la définition d'une function-- et puis je vais
simplement l'appeler quelque chose-- où je ai une certaine valeur y.
Je ai y, qui est double.
Et je retourne un double.
Et je ai dans ce retour y-- désolé, Je ne aurais pas appelé cette y-- x.
Oh, oh dear, oh dear.
Star y de X-.
>> Donc, ce est juste une version simplifiée de ce produit.
Et la raison pour laquelle je ai dollar signe nulle est que l'utilisation de cette enceinte
signifie que je ne ai plus taper pow, ou n'y répondent plus
Je dois faire quelque chose un 3 étoiles 2 étoiles.
Je peux juste avoir un seul fonction appelée carré
qui va toujours prendre une certaine valeur en tant qu'entrée
et effectivement retourner la place de cela.
>> Donc, tout le but de la fermeture est à juste une sorte de encapsuler le fait
que je veux toujours y utiliser chaque fois Je appelle cette fonction en tant que puissance
lors de la prise cet exposant.
Donc, retour donc une fonction qui accepte
un double, qui est la base, et retourner le résultat de cette exposant
est la clé ici.
Et ce est la principale différence.
Il y avait juste un peu de beauté.
>> Ce ne est pas différent par rapport aux exemples précédents,
mais ce était juste un peu de un que nous pouvons réellement se épanouir
créer un opérateur à Swift et à faire réellement ce avec elle,
qui est une sorte de quelque chose de cool.
Ai-je répondu à votre question?
Sweet.
Rien d'autre avant de passer?
D'ACCORD.
>> Maintenant ce genre de pose la question est that-- bien OK,
nous avons maintenant la possibilité pour les fonctions pour être retournés.
Pouvons-nous passer également des fonctions que les données ou en tant que paramètres à d'autres fonctions?
Et en fait, nous le pouvons.
Alors disons que nous avons toutes le même code.
Nous avons la variable carré qui se affronteront ce code.
Et nous avons la variable de cube qui sera cube certaines données.
Et nous voulons effectivement à appliquer à une large gamme de nombres.
>> Donc, ce que nous pourrions être tentés de le faire, bien sûr, ce qui est certainement valable,
est d'itérer sur cette liste de numéros et appliquer mes fonctions carré et le cube
et obtenir deux nouvelles listes que les résultats qui sont cette liste originale carré
et en cubes, respectivement.
Parfaitement acceptable.
Mais quelle est la chose qui nous voyons ici est que nous avons,
nouveau, la duplication de notre code.
Et il ya peut-être une occasion pour nous de simplifier un peu cette question.
Que faire si il y avait un moyen pour nous de fait toujours itérer sur une certaine liste
et il suffit de passer à cette magique fonctionner une variable qui
représente une fonction que nous voulons appliquer
à chaque article dans cette liste.
Ceci nous amène à la notion de ce sont appelées fonctions d'ordre supérieur.
Et ce est essentiellement ce que cette est, ce est que nous pouvons créer une fonction.
>> Et dans ce cas on appelle ça un mappeur, juste pour lui donner un nom, juste
cartographie sur chaque seul élément dans une liste.
Lorsque je prends une liste et je prends une fonction.
Et cette fonction, bien sûr, a une certaine signature.
Il accepte en tant que paramètre à double et il sera sortie est un double.
Et toute la suite de cette fonction va
être une nouvelle liste qui est de type double.
D'ACCORD?
>> Et ce que je vais faire est d'appliquer cette fonction f
à chaque élément dans ma liste.
Et reply-- et plutôt revenir cette nouvelle la liste à la suite, ce qui est vraiment cool.
Maintenant, je peux passer autour de fonctions.
Et cette idée d'ordre supérieur fonctions est vraiment important.
Et ce est vraiment juste mappeur la mise en œuvre du pauvre
d'une fonction qui est construit dans Swift appelée carte.
Et il le fait précisément cela, peut-être même un peu mieux.
>> Ce est juste une sorte de générique, version simplifiée que
nous permet de voir les concept qui se applique ici.
Maintenant, regardez la façon dont je peut réellement appliquer mon carré
et mes fonctions de cube à cette liste de numéros.
Je dirige ma mappeur.
Je fournis à elle ma liste de nombres.
Je fournis à elle la la fonction qui va
se appliquer à chacun de ces indices.
Et il va être sortie en conséquence.
Et je vais arriver à voir que je ai au carré et cubes mes numéros à la suite.
>> Et bien sûr le mappeur aura toute sorte de fonction anonyme.
Nous pouvons même voir que je ai créé une nouvelle fonction anonyme
prend juste un paramètre et divise par deux.
Et nous pouvons voir que je ai, en fait, divisé par deux ma liste à la place.
Cool?
Jusqu'ici, tout va bien?
Très bien, maintenant nous allons revenir à cette idée.
Implémentons ce retour dans le contexte d'un carnet de notes.
>> Et si je fais cela, nous pouvons voir que je peux appliquer une grande variété de ces dire les options
ou une grande variété de ceux-ci fonctions d'ordre supérieur
pour réellement simplifier ma capacité à faire variété de choses sur des listes de numéros.
Ainsi, par exemple, si je prendre une liste de numéros,
l'une des fonctions d'ordre supérieur qui existe est appelé réduire.
Que fait plutôt réduire à la carte, est réduite sera
prendre deux éléments dans la liste, aura une fonction qui
compare les deux éléments de la liste, et il sera alors
sorte de output-- la la sortie de cette fonction
sera un autre élément qui puis vous comparez à d'autres.
>> Donc, vous pouvez utiliser ceci pour effectivement somme des nombres dans votre liste.
Par exemple, si vous aviez une liste de 1, 2, 3, 4, 5,
vous prenez les premiers éléments, 1 et 2.
Vous pouvez demander à un ajout fonction qui prend ces deux éléments
et crache un de ces éléments, ce qui serait la valeur 3.
Puis nous prenons cette valeur 3 avec la prochaine élément de la liste, résumer ces deux,
puis continuer la liste.
>> Nous réduisons la la liste à une seule valeur.
Et il se trouve que le symbole plus
est un opérateur, tout comme nous venons de le voir.
Cet opérateur est une fonction qui fait
a précisément cette liste que nous voudrait plutôt ces propriétés
que nous voudrions.
Je vous encourage donc à jetez un oeil à ce.
Je tiens à trier de déménagement sur de certains de ce code
afin que nous puissions effectivement examiner certains réelle, vraie, vraie Swift dans Xcode,
dans le développement iOS.
Mais jetez un oeil à cela et voir si vous pouvez
analyser à travers ce qui se passe avec certains d'entre eux d'ordre supérieur
fonctions y compris le filtre, réduire, et vous aurez même
voir quelque part dans la liste des cartes ainsi.
Ce est ici.
Où il prendra une séquence des qualités et il sera fait
la carte à l'aide du concept de commutation, que vous pourriez reconnaître à partir de C,
mais en fait ce est beaucoup plus puissant que la construction de l'interrupteur
que nous avons en C.
>> Et nous allons l'appliquer à chaque élément de la liste
et assurer effectivement la lettre de chaque année
de ces grades en utilisant tous ces concepts que nous venons de parler avant.
Maintenant, nous allons contourner pour seulement minute et parler de structures.
Et structs sont une attente dans C que nous ont réussi à définir un nouveau type de données.
Structures existent dans Swift.
Et ainsi de faire beaucoup d'autres constructions appelés énumérations et les classes, qui a vraiment
prendre cette idée à un toute autre niveau.
>> Et au fond, ce est juste une façon de définition d'un nouveau type de données.
Donc, si vous get-- si vous venez dans la classe ou structs ou énumérations,
ne pas confondre par elle.
Ce est juste la façon de définir un nouveau type de données.
Et ce est vraiment important quand nous parlons de développement d'applications iOS
car tout ce qui existe au sein de l'app iOS
est essentiellement un objet quelconque.
Et un objet est essentiellement un classe ou d'une énumération ou une structure.
>> Donc, dans ce cas, je suis la définition d'un nouveau type de données
que je appelle l'évaluation ce est certaines propriétés, y compris
un nom et une séquence de notes.
Donc, un type d'évaluation que je pourrais avoir à l'esprit
serait quiz, par exemple.
Je voudrais avoir une évaluation qui était un quiz
et qui avaient une variété de qualités associée à ce que, pour une quizz,
quizz deux, ainsi de suite et ainsi de suite.
>> Ou je pourrais avoir un autre type de l'évaluation pour les ensembles de problèmes.
Et je peux faire des choses.
Je peux effectivement avoir fonctions au sein de ce type
des données, qui sont maintenant appelées méthodes.
Donc si jamais vous voyez la méthode de mot, ce est vraiment
est juste une fonction qui se applique à une classe très spécifique,
ou à un type très spécifique de données.
Il nous permet de modifier les données au sein.
>> Donc, en d'autres termes, si je veux ajouter une note à mon évaluation,
alors tout ce que je dois faire est de ajouter le score qui était entrée
à cette fonction à ma propriété interne.
Il ya une autre construction soignée ici à Swift, qui est cette dot dot dot
l'opérateur, ce qui signifie que les scores peuvent désormais accepter ne importe quel nombre d'entiers.
Et les scores seront une tableau d'entiers
ont été adoptées à ma fonction, qui signifie que je peux faire des trucs comme ça.
>> Je peux ajouter ne grades et juste offrir un nombre arbitraire de nombres entiers en elle
et fournir réellement un réseau de ces valeurs dans ma fonction
ou ma méthode, comme ce est le cas.
Maintenant, ce est important parce que tout dans Xcode, tout dans iOS,
est en fait un objet.
Donc, gardez cela à l'esprit lorsque nous buste Xcode ouverte
et passez au-delà iOS versions deux et trois
et effectivement passer à la version quatre.
>> Et encore une fois, tout cela sera être posté sur la page de séminaire.
iOS quatre est une sorte de Full Blown mise en œuvre d'une application très basique.
Et ce que cette application ne est-il charge une interface utilisateur, qui ressemble à ceci.
Encore une fois, si l'on clique sur le storyboard nous pouvons voir que ce est à quoi il ressemble.
Ce est l'interface utilisateur.
Il a un titre au sommet.
Je l'ai appelé galerie Web.
>> Au milieu, il ya un élément appelé la vue de l'image de l'interface utilisateur.
Et au fond il ya un barre d'outils avec un bouton unique qui
a espaces extensibles qu'il permettent de centre au milieu de cette barre d'outils.
Et ce qui se passe est que lorsque cette charges, il télécharge un fichier JSON qui est
contenue sur un serveur ailleurs, parse ce fichier JSON,
et le fichier JSON ressemble un peu à cela.
Le fichier JSON ressemble à ceci.
Il est là.
>> Il dispose d'un nom d'album et il dispose d'une panoplie de photos.
Chacun de ces photos avoir un nom et aussi
une URL qui représentent eux-mêmes la Version jpeg de cette photo individuelle.
Donc ce qui se passe, ce est que lorsque ce programme charges, il télécharge le fichier JSON,
il analyse, met tout cela en l'équivalent d'un tableau dans iOS
le développement de l'application, qui est un NSArray.
Et puis, je peux alors charger ces données dans une application
et le charger sur mon écran.
>> Il se agit d'une image qui a été chargé avec le bouton tout en bas.
Si je clique Obtenez Image suivante, il a ensuite tire cette image à partir d'Internet
et remplace cette image dans la vue de l'image de l'interface utilisateur.
Donc, vous pouvez télécharger ce fait et prendre un coup d'oeil sur votre ordinateur.
Et construire et effectivement compiler sur votre appareil.
Mais essentiellement le processus était cela, créer le storyboard--
ou plutôt pas create-- mais sélectionnez le storyboard.
Et we'll-- fait, si vous ne avez pas mind-- nous prenons juste un couple de secondes
vous montrer réellement comment cela a été fait.
>> Juste pour que la façon dont nous pouvons effectivement parvenir est faite un peu plus
apparente.
Une seule application de vue, je suis vais appeler ce séminaire
quatre représentant cette notamment nombre.
Enregistrez-le sur le bureau.
OK, allez cliquer sur le storyboard.
Et ce que je vais faire est de trouver mon image vue,
faites-le glisser sur mon utilisateur interface et le centrer.
Maintenant, il suffit centrant malheureusement ne va pas faire beaucoup,
sauf pour un écran ce est cette taille exacte.
>> Donc, nous pouvons nous en convaincre par cliquant sur ce double chose de cercle,
faire baisser cette fenêtre menu ici et changeant
prévisualiser, où nous allons effectivement obtenir une chance de prévisualiser
Ce sera effectivement chercher sur d'autres appareils.
Comme nous pouvons le voir, nous ne avons même pas voir sur ce cas particulier.
Donc, je vais fermer cette pour l'instant.
>> Et je vais sélectionner cette icône vers le bas à la très
partie inférieure de l'écran.
Il dit de résoudre les problèmes de mise en page de l'automobile.
Désolé, il est coupé en bas.
Mais si je clique sur ce que, ce que je se est cette pop up-- disparaître.
Qu'est-ce que je obtiens est ce pop up qui me permet d'ajouter des contraintes manquantes.
Et en faisant qu'il triera alors de verrouiller
dans la partie centrale de la écran comme je pourrait se attendre.
>> Or, pour obtenir ce bouton sur dessus d'elle, je ai besoin d'aller à l'éditeur.
Aller pour intégrer et cliquez sur Navigation Controller.
Qu'est-ce qui va faire, ce est ce que va ajouter ce tout autre composant à elle,
mais il fait le lien revenir à mon interface originale.
Et les détails, encore une fois, nous ne vraiment besoin de se soucier de ce moment.
Mais je ne veux avoir une barre d'outils en bas.
Donc, je vais vérifier Spectacles barre d'outils.
>> Et cela donne dans mon point de vue, qui est maintenant un autre endroit,
nous pouvons voir qu'il est lié ici.
Il prévoit désormais une barre d'outils au fond de mon interface.
Alors maintenant, plutôt que de choisir un vue de l'image, je peux trouver un label,
ou plutôt un toolbar-- Voyons, où est-ce?
Quel est son nom?
Un élément de button-- bar-- item-- sorry-- objet de barre de bouton.
Plop qu'il ya et appliquer un couple espaces flexibles de chaque côté
à centrer fait que.
Alors maintenant, je ai créé mon interface, essentiellement.
Et je peux lui donner un nom par double-cliquant au sommet
dire ici et galerie Web et ainsi de suite.
Maintenant encore, ce sont des éléments qui existent par eux-mêmes.
Et je dois vous connecter eux de mon code qui
Je peux le faire par à nouveau apporter jusqu'à ce double icône de cercle,
évolution de l'aperçu.
Qui, soit dit en passant, maintenant nous pouvons voir est bien centré et aura l'air bien
sur une variété de dispositifs.
>> Basculer vers automatique, qui sera faire apparaître le code ViewController.
Et maintenant, cette partie est importante.
Afin de vous connecter ci deux éléments, votre code à l'interface utilisateur,
vous sélectionnez l'élément vous voulez vous connecter.
Donc dans ce cas, nous voulez réellement encoder
changer l'image qui est contenue au sein de ce point de vue de l'image de l'interface utilisateur.
Donc, si vous contrôlez cliquez partir la vue de l'image et glisser,
vous remarquerez que vous obtenez un petit bar, lorsque vous lâchez tout ce que cette pop
jusqu'à se produira.
>> Et il est dit que nous allons créer une connexion.
Et d'ici, je veux lui donner un nom, quelque chose comme la galerie.
Appuyez sur Entrée.
Et cela donne effectivement une galerie de variable appelée
que je peux ensuite référencer dans mon code pour changer l'image, par exemple.
Alors, comment est-ce que le code fait regarder?
Bien plus, je ne veux pas passer trop de temps sur elle.
Et je vous encourage à télécharger et jeter un oeil.
Mais l'un des plus aspect important est le code
qui récupère effectivement une image.
>> Donc, dans ce cas, je veux pour obtenir au sein de mes photos
réseau, qui est contenue au sein de ma classe.
Je veux définir le nom et l'URL cela a été analysé hors de cette JSON.
En fait poser l'appareil pour obtenir le URL, pour aller chercher l'URL de cela,
puis récupérer les données à partir de le contenu de cette URL.
Puis de convertir ces données en une image en passant dans l'image de l'interface utilisateur.
Encore une fois, ce sont tous les différents types des objets, des différents types de classes.
>> Et puis, je peux alors placé mon gallery.image égale à celle des données.
Et ce est une sorte de la viande de celui-ci qui est en fait ensuite
capable de changer le changement de données l'image de l'un à l'autre.
Encore une fois, je espère maintenant un grand nombre de constructions
fera un peu plus de sens.
Notez qu'il ya une points d'exclamation ici.
Les points d'exclamation sont essentiellement liée aux optionnels.
>> Ce que je veux dire, ce est essentiellement que, sans même vérifier
pour voir se il ya des données au sein de cette option,
Je vais aller de l'avant et assumer qu'il ya et déballer.
Ne oubliez pas que nous avons utilisé l'analogie de une sorte de package pour les optionnels
et nous avons besoin de déballer le emballage et tirez sur les données.
Le point d'exclamation forces qui se produisent effectivement.
>> Mais je sais que ce est en sécurité parce que je ai vérifié
pour voir si les données d'image est égale à zéro, je ai fait vérifier
pour voir si cela option était, en fait, a échoué.
Si cela avait, en fait, déjà échoué.
Et donc je suis sûr qu'une fois que je reçois à ce point que je peux déballer que les données en toute sécurité.
Vous pouvez également voir dans la forme d'un point d'interrogation.
Donc, si nous faisons défiler à l'endroit où je ai doivent effectivement analyser les données.
>> Alors ne soyez pas rebutés par ce genre de longs noms.
Vous pouvez trouver dans l'Apple développeur emplacement beaucoup
des références à l'ensemble de la les objets et tous les procédés
qui fait que cela soit possible.
Mais remarquez que ce est essentiellement une fonction où je transmets des données.
Et je reviens une sorte de données.
Et je ai besoin de l'utiliser comme mot-clé pour convertir en ce NSDictionary?
Qui est encore, un NSDictionary facultatif.
Que je ai ensuite besoin de vérifier pour voir si elle existe.
>> Donc je ne peux utiliser que si laisser égaux réussies analysées,
alors je sais que ce option contient effectivement certaines données.
Ou ce que je ai fait ici était de simplement supposer que se il
avait pas d'erreurs que ce est en fait en toute sécurité.
Très bien, je tiens à remercier vous tous d'être venus.
Je sais que ce était beaucoup, mais ce est seulement une heure
pour parler de certains trucs assez avancé.
Et alors je espère que vous aurez un chance de télécharger la totalité du code
et de prendre une meilleure, plus regard approfondi sur elle.
Sorte de vous convaincre de tous des choses qui se passe.
Et je tiens à vous remercier tout, à nouveau, d'être venus.
Et bonne chance dans vos projets finaux.
Passez une bonne journée.