>> [Música tocando]
>> DAN AMRMENDARIZ: Todos, bem-vindo para o seminário CS50,
iOS App Desenvolvimento com Swift.
Eu sou Dan Armendariz, e eu sou um preceptor de ciência da computação aqui em Harvard.
>> E a próxima hora vai ser um rápido tour de tanta coisa
sobre este tópico como podemos encaixar.
Vou postar todo o código fonte que você vai ver hoje online.
Podemos não ser capazes de na verdade, passar por cima de tudo
que eu sou que eu sou mostrando a você nesta hora.
Mas, pelo menos, espero que através os comentários do código fonte,
você vai ser capaz de tentar descobrir o que exatamente está acontecendo para essas coisas
que nós não muito chegar.
>> Em geral, a estrutura de A palestra de hoje será a seguinte.
Nós vamos começar a fazer alguns básico sintaxe com a linguagem Swift,
indo em algumas das mais avançado sintaxe da linguagem Swift.
Porque o idioma é realmente moderno e
tem um monte de alto nível recursos, coisas que não têm
visto em C ao longo de CS50, ou Mesmo alguns dos outros idiomas
que nós começamos usando em CS50 como PHP,
então eu vou ter que tentar apresentar também alguns temas que
estão relacionados com linguagens de alto nível que você não pode ver em profundidade no CS50,
mas você vai ver mais tarde aulas de informática.
Por isso, vai ser um hermeticamente embalados hora.
E sinta-se livre para me deixar saber se você tem alguma dúvida.
Então, se você estiver interessado em fazer desenvolvimento
com Swift, ou realmente qualquer desenvolvimento de aplicativos iOS,
há um par de requisitos.
Primeiro de tudo, você tem que estar usando um Mac, correndo nos exemplos
que vamos estar usando hoje, relativamente nova versão do OS
X. Neste caso, eu estou correndo X 10.5.
Você pode estar executando 10.11, se quiser.
Mas tudo o que você vai ver se envolvendo Xcode 7 e posterior,
que tem a versão mais recente de Swift, que é Swift 2.0.
Esta é realmente uma bonita distinção importante.
Um monte de a sintaxe tem mudou muito significativamente
em alguns casos a partir de 1,0 Swift, que foi lançado no ano passado,
Swift para 2,0, o que só saiu neste outono.
Então, nós estamos indo para mostrar Swift 2.0.
Um monte de coisas que você procurar on-line
quando você está tentando obter adicional informações sobre uma variedade de coisas,
você pode querer explicitamente procurar Swift 2
ao invés de simplesmente velho Swift para fazer Certifique-se de que você começa a sintaxe correta.
>> Na verdade, este é geralmente verdade.
Há uma quantidade acelerado de desenvolvimento acontecendo na língua Swift
desde que a Apple lançou isso, eu acho o que, tem sido um pouco mais de um ano
agora.
E as coisas mudaram dramaticamente durante esse tempo.
E por isso não se frustrado se, quando você está olhando ao redor
para tópicos sobre Swift ou como realizar algo usando algum código de exemplo
ou algo que não faz realmente trabalhar em Swift 2.0.
Certifique-se de que você está procurando especificamente para essa versão
para tentar minimizar os efeitos de diferentes versões e esses tipos de coisas.
>> Vou tentar destacar apenas algumas coisas que são diferentes para versões mais antigas.
Mas é algo que atente para.
Isso provavelmente vai ser uma das maiores dores de cabeça
que você vai ter com Swift é encontrar exemplo de código que é mais velho, mesmo apenas
por alguns meses, tentando usar lo em seu projeto mais moderno.
E isso simplesmente não funciona.
Você está recebendo erros do compilador, sintaxe erros, todos os tipos de coisas loucas.
Então, basta ser paciente com que, e você venha a
ter uma experiência bastante agradável com total Swift.
>> Agora você pode realmente join-- e espero nós realmente ainda tem esse este ano--
A Apple app do CS 50 equipe de desenvolvimento, que
vai permitir a instalação de qualquer aplicativo que você cria em seus dispositivos iOS.
Então dê uma olhada neste URL se você está interessado em fazer isso.
>> Então, basta um par de coisas sobre si Swift.
É uma linguagem compilada.
Mas você vai ver que alguns os recursos que usamos
permitem que ele seja usado também em um pouco interpretado como uma maneira também.
>> Uma boa parte da sintaxe é emprestada de C. É baseado e escrito em C.
E por isso vamos ver que há um grande número de takeaways
a partir de seu conhecimento existente de C que pode porta para Swift.
>> Mas há coisas que torná-lo muito diferente de C.
É muito fortemente tipado.
Há gerenciamento automático de memória.
Você não vai ter que usar malloc ou em qualquer lugar gratuitamente.
Ele foi projetado para a generalidade.
Portanto, em outras palavras, você pode usá-lo em todos os tipos de contextos, da Apple Assista
para iPhone todo o caminho até OS X, e até mesmo alguns servidores, mesmo alguns scripts.
Mas vamos ver o que suporte para scripting
não é completamente lá ainda como é em outros idiomas.
Então, provavelmente você estará usando este exclusivamente para o desenvolvimento
no seu Mac ou um iPhone.
>> E tem um monte de características modernas.
E muitas dessas coisas são coisas que vamos tentar resolver hoje,
mas também os nossos temas que, francamente, podemos dedicar cursos inteiros.
Na verdade, CS 51, que é próximo semestre oferecido,
centra-se muito sobre esses tópicos que são descritos abaixo.
Assim, você pode passar um semestre inteiro compreender estas coisas.
Mas nós vamos tentar para passar por eles
pelo menos o suficiente para que você pode entender o que é
acontecendo quando você olha a um programa Swift
e ser capaz de cortar o seu caminho através dele para o projeto final.
>> Agora, uma das melhores maneiras que você pode obter informações adicionais sobre este
é francamente apenas através da Apple fornecida documentação para Swift.
Há um monte de APIs que estão disponíveis.
E esta é uma boa base para você a olhar para coisas específicas que você
querem fazer com uma API envolvendo iOS.
Se você quiser usar a câmera para exemplo, você pode começar a olhar aqui,
e também usar o Google e Stack Overflow como você faria normalmente.
>> Quaisquer perguntas sobre essa antes de saltar para a direita?
Tudo certo.
Vamos continuar.
>> Então, primeiro, eu tenho um número de arquivos de exemplo.
E eu estou indo tentar a etapa através deles de forma relativamente rápida.
Este é o arquivo Olá Mundo para Swift.
É muito simples.
Não há maneira mais comentários que existem código real.
Observe o código real está em parte inferior na linha 14.
Diz impressão.
E então é uma chamada de função.
Estamos passando para uma string chamada Olá CS50.
Observe que não há nenhum ponto e vírgula.
Observe que não há nenhuma int main.
Há nenhum dos cruft que tivemos com C.
Quando estamos usando Swift, desta forma, que é apenas escrito em um arquivo de texto
e armazenados no meu computador, em seguida, I pode compilá-lo e executá-lo.
>> Repare que aqui eu sou não usando o IDE CS50.
Isso pressupõe que eu sou execução e que eu estou no OS X,
e que eu Xcode já instalado nesta máquina para que este
para realmente função.
Mas este é apenas um arquivo de texto normal que pode então compilar e editar.
Então, vamos ver como isso realmente funciona.
E se eu quiser compilá-lo?
1.swift swiftc.
Depois de um momento ou dois, vai ver que temos agora
compilado isso em um arquivo chamado 1.
E agora nós imprimimos nosso CS50, nossa aplicação Olá Mundo em vez.
>> Observe uma outra coisa como bem é que, por padrão,
nós não temos a entrada A / N para imprimir uma nova linha.
Por padrão, a função de impressão em Swift irá imprimir uma nova linha para você.
Você pode passar um adicional opcional parâmetro para dizer que não fazê-lo.
Mas o Google para obter mais informações sobre isso.
Por padrão, ele vai fazer a linha de impressão.
>> Tudo bem, então vamos seguir em frente em seguida, para algumas outras coisas.
Então, como podemos realmente definir variáveis?
Nós podemos fazer isso é usando um dos dois métodos.
E o que eu quero dizer a você sobre a primeira é esta definição let.
E isso é importante porque efectivamente
o que estamos fazendo é definir uma constante.
Nós vamos criar uma variável, ou melhor, um chamado nome de constante,
fornecer-lhe algumas data-- em Neste caso, a seqüência de Dan.
Mas usando este let palavra-chave, estamos dizendo
que esta ou variable-- constant-- chamado novamente
nome nunca vai ser alterado.
Vai ser imutável ao longo a duração deste programa
ou em todo o duração do contexto
que esta variável é disponível.
>> Isso é realmente importante que, quando você tem alguns dados que não é
vai mudar em seu programa, e você verá uma variedade de exemplos
sobre quando nós queremos usar deixe versus a outra sintaxe,
é importante que você use deixá sempre que possível, porque esta notifica
o idioma que é não vai ser alterado,
e ele pode realmente executar um monte de otimizações
para melhorar a velocidade e a segurança de seu programa.
E por segurança, eu não significa deixá- ele falha com erros de loucos
para que sejamos acostumados a ver em C.
>> Então, podemos usar interpolação de string para encapsular isso dentro de uma string.
Assim, podemos ver neste linha de impressão, imprima Olá,
e em seguida, usando barra invertida parênteses abertas, e, em seguida, o nome do meu variável,
neste caso constante, fechar os parênteses.
Estou essencialmente, em seguida, colocar o conteúdo deste nome variável chamada
dentro da corda e, em seguida, imprimir o resultado lá.
>> Há uma outra alteração a este arquivo o que é que eu tenho, no topo,
colocar em uma linha shebang, que basicamente apenas especifica
que eu quero usar o Intérprete Swift, que
significa que eu não tenho mais para compilar este programa particular.
Eu posso apenas executá-lo como seu próprio script.
Mas esta é, neste caso, por trás as cenas sendo compilados e, em seguida,
sendo executado.
É apenas invisível para nós.
>> Tudo bem, então vamos seguir em frente.
Portanto, há um pouco de malandragem que apenas aconteceu antes.
Mostrei-lhe que eu Pode definir uma constante.
E eu poderia fornecer alguns dados para fazê-lo.
Mas, neste caso, repare que eu não fiz na verdade, especificam o tipo de dados
é isso.
E isso é porque o compilador, pode Swift
inferir o tipo de dados apenas com base sobre os dados que eu colocar nele.
Porque ele sabe que por avaliar este variável aqui mesmo, esse direito de dados
aqui, ele sabe que é uma string.
E assim este nome constante é, portanto, vai ser uma string assim.
>> Mas também pode ser explícita sobre o tipo que é
vamos usar para constantes ou variáveis
usando esta sintaxe instead-- deixe de Cordas nome cólon igual
Dan, que neste caso significa que estamos vai definir um nome chamado constante.
Vai ser do tipo String.
E o valor vai ser Dan.
Agora outra forma que podemos criar variables--
e estes são variáveis ​​mutáveis, que significa que estamos, de fato, vai
para mudar seu conteúdo em algum momento da duração do contexto
que essa variável é defined-- nós usar a palavra-chave var, em vez de deixar.
Mas, novamente, por padrão, se você não sabe que você precisa para manipular esses dados,
tente usar para deixar melhorias de desempenho.
>> Neste caso, posso, então, especificar o tipo de dados
que esperamos estar dentro de esta nova variável chamada etiqueta.
Vai ser uma string.
E nós estamos indo, em seguida, concatenar duas cordas em conjunto, a cadeia Olá,
ea cadeia representada pela variável, ou melhor, o nome constante.
>> Então, isso é bom porque esta está um tanto como o PHP em que nós
tem muito fácil concatenação.
Não temos para automaticamente usar qualquer tipo de gerenciamento de memória
para aumentar o tamanho e fazer qualquer tipo de coisas engraçadas lá.
Isso funciona como seria de esperar, na verdade.
>> Tudo bem, qualquer dúvida sobre este?
>> Agora, a outra razão que precisamos de você ter a capacidade
para ser capaz de definir o que tipo de variáveis ​​de dados são
é porque às vezes não o fazemos quer inicializar variáveis
com alguns dados no ponto de definição.
Portanto, neste caso, digamos que eu quero começar a introduzir
algumas notas em um livro de notas.
Bem, eu sei que um dos variáveis ​​que eu quero ser
vai ser uma classe mutável.
E também sabemos que nós quero que seja um inteiro.
Mas talvez nós não fazemos ainda tem esse grau disponível.
>> Em Swift, você tem que definir o tipo de dados
que está associada com um variável ou uma constante deixá
antes que você possa realmente usar essa variável.
Porque ele é fortemente tipado, você tem que associar um tipo de
com estas variáveis.
>> Portanto, neste caso, se eu não tenho propriamente inicializado o primeiro com algum valor,
então eu preciso dizer que Swift Espero que o tipo de dados a ser.
E vai permanecer que mesmo tipo de dados
ao longo da história deste programa.
>> Agora você pode ser tentado assim que Eu criei esta variável grau
e desde que um número inteiro de 100, agora se eu
quero tentar concatenar uma cadeia com esse inteiro,
pode ser tentado a usar ainda esse operador de concatenação de strings
como fizemos apenas algumas linhas antes.
Mas infelizmente, isso realmente não vai
trabalhar, porque você é essencialmente executando
uma operação em dois tipos diferentes.
>> Agora isso é muito diferente de outros linguagens como PHP que são realmente
goosey loosey com o seu tipo de tipos.
Eles estão apenas gosta, sim, qualquer que seja, eu não me importo.
Apenas me dê um tipo, e talvez eu vou fazer a coisa certa.
>> Neste caso, é Swift extremamente rigoroso sobre os tipos
que você está lidando.
Este operador somatório ou operador de concatenação
tem essencialmente um par de diferentes opções possíveis.
Você pode fazer somatório com números inteiros, ou você
pode fazer concatenação de strings, e talvez algumas outras coisas também.
Mas se esse operador não reconhece o que é em ambos os lados do mesmo,
ou melhor, a combinação daqueles dois tipos, não é o que está esperando,
em seguida, ele vai causar uma falha.
>> Portanto, neste caso, o que significa para ter uma corda mais um número inteiro?
Bem no contexto de isso, nós provavelmente quer
a fazer uma operação de concatenação de strings.
Mas é claro que o computador não tem esse tipo de contexto.
E por isso precisamos fornecer que as informações adicionais
para deixá-lo saber o que é que nós queremos fazer.
>> Assim, em outras palavras, o facto que Swift é fortemente tipado
significa que você tem que fazer um pouco de trabalho adicional
para obtê-lo para operar o maneira que você gostaria.
Porém, como resultado, é mais seguro.
E uma vez que você tem tomar em conta os tipos,
coisas apenas francamente começar funcionar muito bem.
>> Portanto, neste caso, nós, em seguida, iria executar concatenação de strings
por vazamento explicitamente o inteiro para uma string
por envolvê-lo neste capital de função S String,
e em seguida, usando a concatenação operador para modificar nossa variável etiqueta,
e, em seguida, imprimi-lo.
>> Por enquanto, tudo bem?
Tudo bem, vamos seguir em frente.
>> Agora, há uma variedade de dados tipos que podemos usar em Swift.
Como você se acostumaram a, nós podemos criar uma matriz mutável.
E essa matriz só pode conter um único tipo.
>> Portanto, neste caso, nós estamos indo para criar um mutáveis ​​matrizes de inteiros, o que
vamos chamar graus, e seremos capazes para armazenar que neste colchete
formato que você cresceu acostumado a em uma variedade de outras linguagens.
Mas note que aqui estamos definindo um par de coisas.
graus é um variable-- mutável nós não utilizar a palavra-chave let.
Então isso significa que nós podemos então modificar o conteúdo desta matriz.
É do tipo Array Int, e podemos dizer que
com base nesses colchetes aqui.
>> Agora, uma das coisas agradáveis sobre isso é que nós
têm acesso a uma grande quantidade de informação adicional
sobre a matriz usando apenas alguns notação de ponto simples.
Assim, por exemplo, grades.count fornece para nós
o número de itens que existe nesse array, que pode, então, acessar bonita
facilmente usando simplesmente que a notação de ponto.
>> Se você quiser adicionar adicional itens para essa matriz,
você não pode fazer o estilo PHP onde você acabou de definir explicitamente,
a um dado índice, algum valor que você deseja inserir.
Em vez disso, use o acréscimo método no tipo de matriz
para acrescentar esse item, 95, a esta lista.
>> Então agora essa matriz tem a seguinte contents-- 100, 0, 90, 85.
E agora temos acrescentado 95 para que, como bem.
>> Há outras maneiras Podemos acrescentar coisas.
Você pode realmente usar um operador de soma,
que será interpretada como uma operação de matriz de acréscimo.
E você pode em seguida, acrescentar um outro array, cujo conteúdo é de 70 e 80,
para essa matriz.
Portanto, agora temos o conteúdo deste variável
grades-- 100, 0, 90, 85, 95, 70, e 80.
Este é apenas um pouco agradável sintática açúcar que Swift fornece para nós.
>> Portanto, se queremos somar o graus, estamos talvez
vai querer fazer uma iteração sobre cada item neste loop.
E nós temos, no Swift, a noção de um loop for como seria de esperar.
Mas o caminho que nós indicamos um intervalo é um pouco diferente.
Portanto, neste caso, a Resumindo tudo, vamos
vai criar um temporário chamado soma variável para que nós
para manter esta contagem.
>> E note nosso para construção de loop aqui.
Para o índice em 0 .. <grade.count.
Portanto, esta construção, 0 .. <grades.count é uma operação de alcance onde estamos
dizendo que nós vamos criar uma gama de números inteiros de 0 até
até, mas excluindo grades.count.
Portanto, este será de 0, 1, 2, 3, 4, 5, até porém muitos um
antes grades.count.
>> Portanto, esta é diferente de como nós normalmente usado para loops
onde você teria algum índice variável, defina-igual a 0 no primeiro,
e então integrá que até alguns valor menor que a contagem de itens
nesse array.
>> Portanto, há uma modificação para isto, na verdade,
o que nos permite muito facilmente definir diferentes tipos de intervalos.
Se você alterar este intervalo para três pontos, 0 ... grade.count,
esta representa a gama 0 para grades.count inclusiva,
o que significa que esse número é também então incluídos nesse intervalo.
>> Mas isso é muito útil para estas coisas exatas,
quando temos que executar iterações mais de laço
porque esses índices são indexados zero, como vimos em outros idiomas
também.
Quaisquer perguntas sobre essa para loop?
>> Portanto, não há definição implícita desta variável índice,
cujo valor começa em 0 e continua a cada iteração do loop
a um aumento de 1 até um ponto que é igual a grades.count,
ponto no qual, o loop aborta.
>> Observe que, em nossa cadeia interpolação aqui,
nós podemos realmente executar algumas simples manipulações a esses valores.
Assim índice mais 1 vai realmente executar uma soma desse valor
porque o índice é, em Neste caso, um número inteiro.
E nesse ponto, ele vai em seguida, ser convertido em uma cadeia
e interpolados para essa sequência aqui, e impresso como seria de esperar. .
>> E a coisa agradável sobre as matrizes aqui é
que também somos capazes de ter valores buscar e valores de ajuste
usando a notação colchete como temos visto em outros idiomas também.
>> Tudo bem, então a partir daqui, podemos agora calcular a soma de todos os tipos.
Agora tipo do próximo passo lógico seria
para fazer uma operação de divisão para encontrar a média dessas notas.
Mas algo importante aqui que está a acontecer
é que este montante é, talvez, um número inteiro.
Mas precisamos realizar alguma espécie de divisão de casal.
E isso vai ser extremamente importante quando
queremos realizar esta operação, porque o que estamos dizendo
é que nós precisamos, na verdade, realizar a divisão em duas duplas.
E, novamente, porque Swift é fortemente digitado,
temos de definir explicitamente toda a itens para duplas antes que efectivamente
realizar essa operação.
>> Então, para nós realizar a divisão de casal,
não é suficiente para apenas um desses itens a ser um casal.
Ambas as partes têm de ser um duplo, a fim de swift
para ter certeza de que este é o que nós queremos fazer.
Então, vamos, então, explicitamente typecast a soma que temos calculado acima
ea contagem de notas para duplas, e em seguida, executar essa operação e armazenamento
que para esta nova variável, ou melhor, esta nova constante chamada média,
que terá que tipo, você imagina?
Duplo, sim.
Portanto, neste caso, nós não tem que especificá-lo
porque pode ser inferida a partir da operação que tipo de dados média
será.
E Swift é geralmente muito bom sobre ser capaz de inferir os tipos.
>> Você quer ver este executar, ou posso seguir em frente?
Eu quero continuar.
Quaisquer perguntas sobre nada disso?
Ótimo.
>> Agora vamos começar a chegar a as boas funções definidoras stuff--,
e um par de outros tipos que são Swift exclusivo para que você não tem
visto em outros idiomas até este ponto,
mas que estão presentes em outros línguas que você pode encontrar mais tarde.
Então, primeiro, se você quiser para definir uma função,
você defini-lo com a palavra funk função e, em seguida, o nome da função,
e, em seguida, entre parênteses, os argumentos que você deseja que a função de aceitar.
Os argumentos devem também specify-- generally--
também deve especificar o tipo de dados que eles são, a menos que possam ser inferida.
E veremos que pouco ressalva em apenas um pouco.
>> Portanto, neste caso, temos um função chamada printGradeCount.
Nós estamos indo para aceitar uma variable-- ou melhor, neste caso,
um constant-- chamado gradebook.
E isso vai ser de escreva array de inteiros.
Agora há algo que é realmente importante aqui
que eu quero que você entenda.
Isso é que, por padrão, esses argumentos que são entradas para esta função são
definido com uma palavra-chave let implícita, o que significa que eu não posso modificar este
variável gradebook aqui.
E que espécie de faz sentido, porque você está passando dados in.
E você talvez não quer que ele a ser alterado a partir de debaixo de você.
É possível mencionar explicitamente que esta é uma variável, colocando
a palavra-chave aqui var.
Mas isso é uma pegadinha que nós temos As pessoas notaram ter feito no passado
é que eles assumiram que ele vai para ser uma variável quando, na verdade,
é uma constante.
>> Tudo bem, então aqui, então, neste caso, não estamos especificando qualquer tipo de retorno.
Vamos mostrar-lhe como fazê- que em apenas um momento.
Mas note que temos aqui apenas um simples caso condição.
Se o livro de notas é vazia, que neste caso
é apenas a propriedade desta inteiro array, então nós imprimir algo.
Caso contrário, fazer outra coisa.
>> Bastante simples, até agora eu acho.
Mas me parar se você tiver quaisquer perguntas.
>> Agora esta função, médio, também leva alguns argumentos, ou melhor, um argumento,
que é o livro de notas, e desta vez vai retornar um tipo de casal.
Porque ele está computando a média e é
vai voltar, na verdade, que média calculada para a linha de chamada.
>> Neste caso, especificamos o tipo de retorno após uma seta.
E isso pode se sentir uma espécie de estranho no início.
Você cresceu acostumado para definir o retorno
escreva antes do nome da função.
Mas se você acha deste em termos de matemática,
como quando você tem a matemática que definem uma função,
você tem uma função com alguns insumos, e produz uma saída.
E isso é exatamente o que isto é suposto imitar.
E há um par de outras línguas que tem uma sintaxe semelhante, bem como,
mas provavelmente ninguém que você já viu em CS50.
Mas ainda não ser confundido por ele.
A seta significa que está acontecendo a ser devolvido neste caso.
OK, então como é que vamos para calcular essa média?
Bem, se o livro de notas está vazio, bem, então estamos
vai retornar 0, o que talvez uma forma razoável de tratá-lo.
Eu não sei, vamos chegar de volta para que, em um pouco.
Isto não pode, na verdade, ser uma maneira razoável
para calcular uma média se temos um livro de notas vazio.
>> Então vamos realizar nosso somatório.
Repare que aqui estamos, na verdade, tem uma versão alternativa de um
loop for, o que nos permite fazer uma iteração sobre cada item em uma matriz
e colocar cada elemento em sua própria variável.
Ao especificar para o grau em gradebook, o que estamos dizendo
é que nós vamos implicitamente criar uma nova constante chamada
grau que vai representar cada item único no gradebook
cada vez que o laço for.
Assim, a primeira vez que ele é executado, o grau será
ser o primeiro item no Boletim.
A segunda vez que vai ser a segundo item, assim por diante e assim por diante
até gradebook tem se exauriu de elementos.
Então, vamos ser capazes de resumir que grau em nossa variável somatório
e voltar a nossa média como vimos antes.
OK, todas as perguntas?
Sim?
AUDIÊNCIA: Eu tenho duas perguntas.
Número um, hipoteticamente, pode você corre inteiro em um presente?
Não tem de ser um casal, que é correto?
DAN AMRMENDARIZ: Você pode repetir essa pergunta?
AUDIÊNCIA: Posso fazer inteiro como a média?
DAN AMRMENDARIZ: Você pode fazer inteiro como uma média?
Então retornar um inteiro média em vez de um casal?
>> AUDIÊNCIA: Return-- você têm esse direito agora abaixo.
DAN AMRMENDARIZ: Bem aqui, voltar 0.0?
AUDIÊNCIA: É, basta retornar 0.
Por isso, será tanto 80 ou 85, mas não 85,2.
>> DAN AMRMENDARIZ: Então, nesse caso, por isso há um par de maneiras diferentes
para responder a isso.
Deixe-me responder-los em ordem.
Então, se eu apenas fazer este retorno 0, um 0 é um valor inteiro.
E assim que irá causar um Tipo de erro para este caso
porque ele está esperando um casal mas é, então, retornando um inteiro.
Se eu quiser retornar um inteiro, eu posso.
Eu posso definir o tipo de retorno para int, retornar 0 aqui,
e não executar a divisão de casal.
Mas então estaríamos fazendo a divisão inteira.
E por isso, então não iria receber o média que possivelmente iria esperar.
Mas sim, nós podemos modificar os tipos dessa forma.
>> AUDIÊNCIA: E em segundo lugar, você tem um duplo na parte superior.
Mas lá embaixo, quando você fazer retornar Duplo,
que já está automaticamente retornando formato duplo.
Por que você ainda precisa defini-lo com a seta na parte superior com um duplo?
>> DAN AMRMENDARIZ: Então, no caso, isso é parte
as-- de modo a repetir a pergunta, porque é implícita a partir do retorno
tipos aqui, que tipo isso realmente é, precisamos ser explícito com Swift
sobre o que queremos voltar para fora desta função
de modo que, quando se realiza tipo a verificação, ele pode ter certeza
que o que realmente escrito abaixo, na verdade, está de acordo com isso.
Então, é como uma espécie de cheque consigo mesmo tipo de situação.
Mas há--
>> AUDIÊNCIA: [inaudível] flecha?
>> DAN AMRMENDARIZ: há casos em que podemos especificar que podemos implicitamente
definir o tipo de retorno.
Mas, neste caso, eu não acho que iria funcionar.
Há alguma outra sintaxe que vamos ver mais tarde.
>> Tudo bem, então esta fonte código é um pouco diferente
porque este analisa argumentos de a função que nós estamos chamando.
Deixe-me mostrar-lhe como ele funciona antes de realmente seguir em frente
para algumas coisas interessantes que está acontecendo na Swift.
>> Portanto, neste caso, se eu executar este código, observe que o que está fazendo
enquanto é--, que tipo de me dá um erro estranho.
Eu preciso passar um par de inteiros como um argumento de linha de comando.
Então vamos ver, 150 e 80, e pressione Enter para descobrir o que ele está realmente fazendo.
É aceitar cada um dos estes valores como inteiros.
É de inseri-las em um livro de notas.
E então ele está executando que o cálculo da média
e saída que como seria de esperar.
>> Mas, obviamente, há algo acontecendo com esse rejeitar algo
algo como um inteiro.
Como você pode se lembrar de quando éramos lidar com argumentos de linha de comando
em C e outras linguagens, a primeira 0-th artigo em que o argumento de linha de comando
lista é o nome do comando que nós realmente executado.
Portanto, neste caso, só estou looping sobre todos os argumentos de linha de comando.
Mas eu não estou fazendo qualquer tipo de fantasia vá para saltar sobre aquele primeiro.
Eu sou apenas explicita ou implicitamente que eu sou verificar que um destes tipos
são inteiros antes de eu realmente efectuar este cálculo.
>> E isso é essencialmente O que está acontecendo aqui.
Para cada argumento em os argumentos do processo,
Eu estou indo para realizar alguma verificação.
E, neste caso, eu vou para tentar primeiro convertido
esse argumento em um número inteiro por executar uma conversão de tipo explícito,
porque ele é, na entrada, uma cadeia de caracteres e não no fato de um número inteiro.
>> Mas este é um tipo de sintaxe estranho, se deixar de grau é igual a Int (argumento).
O que está realmente acontecendo aqui é extremamente
importante para o seu uso Swift.
Isso é usar o que é chamado de tipo opcional.
>> Então esta função, Int (argumento), não apenas retorna um inteiro, mas retorna
o que é chamado um inteiro opcional.
E assim esta é uma espécie de um tipo em cima de um tipo.
Você pode imaginar que tipo de como ele está retornando como um pacote.
E quando você abrir esse pacote, ele quer
tem um número inteiro, o que é o resultado, ou não tem absolutamente nada nele em tudo.
E isso é útil como uma verificação de erros mecanismo, porque neste caso
podemos descobrir, foi esta conversão de tipo bem-sucedido?
Se foi, em seguida, ele é de facto vai ter um número inteiro dentro.
Caso contrário, ele vai ter algum valor que vamos chamar nulo, ou seja
é representativo de qualquer número inteiro de todo.
É realmente representativo de nada.
>> E assim esta construção se permite-nos a desembrulhar esse pacote,
que de ligação opcional.
E se somos capazes de desembrulhar que empacotar e encontrar um número inteiro dentro,
então o que estamos dizendo aqui é que vamos, então,
permitir que o valor a ser definido em esta constante chamado grau.
E esta parte do if, a parte superior da instrução if
será executado, porque isso desembrulhar foi bem sucedida.
>> Se isso só acontece que houve um erro, talvez,
neste tipo de conversão explícita a partir de uma seqüência de caracteres para um número inteiro, talvez
é o valor ABC por exemplo.
E isso é realmente não vai para converter em um inteiro.
Em seguida, ele retornará nil, que não é um número inteiro.
E esta declaração se bem, então falhar.
grau não existirá porque ele não tem nenhum conteúdo inteiro.
E ele será executado este bloco outra vez.
Sim?
>> AUDIÊNCIA: Nil é N-I-L?
DAN AMRMENDARIZ: nil é N-I-L, sim.
>> Portanto, este é talvez um dos coisas mais difíceis de Swift,
especialmente quando você está em as ervas daninhas em um aplicativo iOS
e você está realmente tentando para fazer algum desenvolvimento lá.
Vai estar gritando em você sobre opcionais.
Vai ser perguntando para você pontos de interrogação e pontos de exclamação.
Mas uma vez que você descobrir se você out-- dedicar algum tempo para descobrir
o que está acontecendo com os tipos de opcionais, você vai salvar um monte de dor de cabeça
como você está tentando escrever um aplicativo em Swift.
>> Na verdade, é um recurso muito poderoso.
E você vai ter que tomar minha palavra para ela por enquanto.
Mas vamos ver essa construção e alguns outros como ele
em algumas das outras código-fonte que vamos mostrar-lhe em apenas um pouco.
>> Existem dúvidas iniciais aqui?
Assim, o importante é que estaladiça um Tipo opcional é uma espécie de metatype.
Ou ela tem um valor, e se isso acontecer, então ele
talvez tenha que valor associado com ele, ou ela não tem valor algum,
e é representado por nulo.
O resto esta é talvez como seria de esperar.
>> Então, vamos rampa até o dificuldade mais uma vez.
E desta vez, vamos dar uma olhada em algumas outros tipos de dados que realmente existem.
Um deles é dicionários, que é muito semelhante ao dicionários Python.
É um pouco semelhante a uma tabela hash C. É, essencialmente, um mapeamento de teclas
onde as chaves podem ser strings.
E quando você olha para cima essas chaves, aquelas chaves terão um valor.
Portanto, não é uma real ordem, mas em vez disso, mais estreitamente associados
a um mapa de hash ou uma tabela hash.
>> Vamos ver como isto é suposto para trabalhar antes que efectivamente
ir para o próprio código fonte.
Se eu executar este, nada realmente acontece.
Está me dizendo que eu estou esperando alguns parâmetros do tipo seguinte.
Então, eu estou indo para fornecer a que alguns nomes conjunto de problemas,
pset0 assim, talvez eu tenho 100.
E pset1, eu tenho a 5.
E então no exame, eu fez muito bem e conseguiu 30.
E oops, eu bati um espaço aqui.
>> Quando eu pressionar Enter, você pode ver ele realiza alguma computação.
Diz gradebook é de três notas, pset1, pset0, exame.
E o livro de notas tem esta média específica.
Então, novamente, estamos trabalhando com esta ideia gradebook,
mas vamos continuar a iteração com a complexidade da nossa função.
>> Então, no início, nós somos apenas vai criar uma função que
é responsável por imprimir o uso.
E há essa saída função que será apenas
forçosamente sair da aplicação.
Isso não é algo que você vai usar em iOS app.
Esta é apenas, neste caso, com um argumento de linha de comando.
Em seguida, vamos começar a se mover em direção Xcode.
Mas esta é específica para um comando programa de estilo de linha em Swift.
>> Vamos dar uma olhada em algumas das as coisas interessantes aqui.
Vamos ver, apenas um par de coisas interessantes para falar, talvez,
é que na minha função de imprimir o número de graus,
você deve se lembrar que eu tinha que lista de pset1 itens--, pset0, e exame.
Você pode realmente rapidamente e fazer isso facilmente
tomando o livro de notas, que é um dicionário que tem chaves e valores.
Encontre todas a chave é através o método de pontos chaves aqui,
e, em seguida, usar esse joinWithSeparator, que, então, tomar todas as chaves
que tínhamos digitada, ou pset1-- desculpe, pset0, pset1, e exam--
e concatenar-los juntos usando uma vírgula e um espaço
para criar uma cadeia longa.
Esta operação de junção é apenas fenomenal úteis numa variedade de contextos.
E assim é esta joinWithSeparator.
>> E isso é uma coisa que é Swift alterado de 1 a 2 SWIFT.
Costumava haver um Style-- Python se você for
familiarizado com Python-- um Python estilo juntar método em strings.
Mas isso não é mais o caso em Swift 2.
Você quer usar isso se você quiser para concatenar uma série de coisas
juntamente com uma corda.
>> Por isso, talvez, em seguida, em nossa discussão de médio antes,
ele faz um pouco mais de sentido para nós para definir a função média
para ser uma dupla opcional em vez que apenas um casal explícito.
Porque nós tivemos que condição incomum, onde,
o que na verdade se gradebook não tem valores dentro dele?
Qual deve ser o retorno médio?
>> Bem, talvez em C você teria feito algo
como forneceu um valor de sentinela, como 0,0, ou talvez um número negativo,
ou apenas algo que representa o fato de que havia alguma condição de erro
e você talvez não têm efectivamente a capacidade de calcular essa média.
Bem, a beleza de especificar um opcional tipo seria fazer isso.
E eu estou dizendo agora todas estas palavras, mas isso realmente não usa opcionais.
Mas vamos ver isso em apenas minutos onde podemos definir média
ser um tipo de dados de modo que opcional se ele realmente retorna alguns dados, em seguida,
vamos retornar esses dados.
Caso contrário, vamos voltar nil, dizendo que este
não tem computação significativa.
>> Vamos passar para outra coisa.
Assim, a partir daqui, nós estive olhando todos estes exemplos na linha de comando.
Mas realmente o que você está indo estar lidando com é Xcode.
E uma das coisas agradáveis ​​sobre Xcode é, e especificamente em Swift,
é que temos esta coisa chamada um parque infantil.
E um parque infantil é não é de todo um aplicativo iOS.
Mas ele permite que você a experimentar com Swift de uma forma muito fácil.
Você pode digitar todo o seu código.
É bem sintaxe destaque aqui.
Quando você cria um novo arquivo, ele irá pedir se você quer criar um campo de jogos.
Mas a coisa agradável sobre o campo de jogos é que no lado direito da sua janela,
ele realmente mostrar-lhe saída do seu código.
Então, se eu rolar para baixo, podemos ver o que a saída de várias linhas de código
na verdade passa a ser.
>> Portanto, neste caso, nós vamos mudar de direção apenas um pouco
e falar sobre algo que é realmente importante desta forma nível elevado
Swift que opera, e é essa idéia de encerramentos.
E você provavelmente já viu este um pouco em JavaScript.
Para aqueles de vocês que estão em CS50, encerramentos
são muito populares maneira muito boa de fazer, coisas de alto nível em línguas modernas.
Mas é também uma espécie de difícil quebrar a cabeça em torno do primeiro tempo.
Então, se você olhar para este primeira vez, isso é OK.
Basta olhar para o código-fonte e veja se você pode descobrir isso em casa.
>> Portanto, neste caso, vamos dizer que nós quer criar um monte de expoentes
com algum valor fixo.
Portanto, neste caso, posso criar uma função.
Eu vou chamá-lo de poder de 2 propósito cujo único na vida
é tomar alguma entrada e dupla dele, e retornar esse valor.
Repare que aqui estou eu aceitar um tipo de dados.
Vai ser uma variável chamada x.
É do tipo Double.
E eu estou indo para retornar um casal aqui.
E eu estou indo só para fazer muito, francamente, muito
maneira ingênua de duplicar este valor.
E eu vou te mostrar por que isso é útil em apenas um segundo.
>> Note que aqui nós temos essa gama mais uma vez. para algo em 1, ponto
ponto a ponto, 2, o que significa que este laço será executado duas vezes.
Mas isso representa uma variável dummy.
Isso significa que eu não estou indo realmente para estar usando essa variável em qualquer lugar
no interior deste circuito.
Eu só quero que esta linha de código para ser executado duas vezes,
sem precisar saber o valor do referido intervalo.
>> Portanto, neste caso eu estou correndo resultado vezes x duas vezes e que, essencialmente,
significa que eu estou em quadratura com este valor.
E isso acontece com trabalhar como seria de esperar.
Potência de 2, passando um valor de 2.0 nos dá uma saída de 4.
3.2 obras para 10,24.
>> Agora podemos fazer um semelhante coisa de poder, de 3.
Mas agora alterar apenas o intervalo.
Para dummy em 1 a 3, multiplicar 3 vezes,
e fazer a mesma coisa.
>> Portanto, este pode se sentir um pouco artificial.
Mas há uma importante coisa aqui que
é que olhando para estes duas funções, há
apenas uma coisa que é diferente, que é este valor no intervalo.
Tudo mais sobre estes dois funções, potência de 3 e potência de 2,
são, de facto, idênticas porque elas funcionam da mesma maneira.
>> Então, neste momento, um pouco sino de alarme deve ser a sair.
Esperemos que o que você está dizendo, você sabe, este se sente um pouco
como a duplicação de esforços.
Talvez haja uma maneira que eu faria ser capaz de encapsular tudo isto
e proporcionar uma função ou criar uma função que
faz exatamente o que eu quero, sem a necessidade de digitá-la explicitamente.
E é isso que o poder de um encerramento nos permite fazer.
Então, vamos dar uma olhada nisso.
E eu vou passar um par minutos a esta, porque esta
é muito importante para a Swift.
Vemos isso o tempo todo.
Vamos definir uma função.
Vai ser chamado powerof.
Vai aceitar um parâmetro chamado y do tipo Int.
Mas dê uma olhada no tipo de retorno.
O tipo de retorno é, na parênteses, Double seta dupla.
O que significa que esta função, powerof esta função,
está retornando uma função.
Isso está aceitando um casal e retornando um duplo.
De modo que pode parecer meio louco, mas vamos rolar para baixo um pouco
e olhar para ver o que acontece.
Estamos dentro dessa função powerof.
Estamos criando uma nova função chamado exponentiator,
mas não importa o que é.
>> Observe que este tem um valor de entrada de x.
E ele está levando em uma de casal e retornando um duplo.
E isto é o mesmo código que nós viu acima, excepto que o valor de 2
ou o valor de 3, de que limite superior desse intervalo,
foi substituído com este valor de y, que
foi o parâmetro inicial da nossa função powerof.
E, neste ponto, nós retornar exponentiator.
Estamos voltando a função.
>> É como uma espécie de pequena mente blowing.
Mas vamos imaginar o que acontece quando eu chamar essa função powerof
e passar para ele algum valor como 2.
O que isto significa é que Agora tenho o valor
2 para y, o que significa que este valor y nesta função exponentiator
será que o valor 2.
Mas eu estou voltando este exponentiator função.
>> Então, observe o que Swift diz que eu criaram neste caso.
deixe praça é uma definição, é uma função que aceita um duplo
e retorna um duplo.
Eu criei uma função que algo quadrados
utilizando este mecanismo aqui.
E realmente o que está acontecendo é que ele está retornando esta função
exponentiator, mas este valor y está envolvido dentro dele.
E então agora cada vez que eu usar este esta variável ou constante chamada
praça, ele vai a comportar-se como uma função.
E para que eu possa, em seguida, chamar essa variável como eu chamaria de uma função,
e passá-la para um número, como neste caso 3.
E eu, então, conciliar esse valor.
Então, em seguida, 3 ao quadrado tornar-se 9, como podemos ver aqui.
>> Realmente louco, mas isso agora me permite a oportunidade
para criar outras funções powerof.
Como eu posso dizer, OK, bem, agora eu quero para criar uma nova função, powerof (3),
e armazenar isso em um chamado cubo constante.
E agora cubo vai ser um função separada que irá, em seguida,
levar algum valor como entrada e cubo que valor, como podemos ver na linha de fundo
Aqui.
cubo de 2 vai resultar em 8.
>> Esperemos que coisas muito arrumado.
Você nunca viu isso antes.
Encorajo-vos a olhar para encerramentos e investigar isso um pouco mais.
É uma coisa realmente poderosa vemos um monte em JavaScript e outras linguagens.
É realmente vital para APIs compreender bem
que nós vamos chegar a em apenas um segundo.
Sim?
>> AUDIÊNCIA: Quando você faz powerof (2), parêntesis, e, em seguida
outro parêntese, outro input-- basicamente você está substituindo a praça.
DAN AMRMENDARIZ: Então olhe na última linha aqui.
Na verdade, é totalmente possível fazer isso encadeamento como você sugeriu.
Então powerof (5) significa que nós estamos indo ter um exponentiator de 5 até aqui.
Portanto, este é essencialmente vai ser o mesma coisa que 4 para o quinto poder,
porque nós criamos um exponencializando funcionar ao quinto poder,
e nós estamos passando para que funcionar o valor 4.
E nós temos esse valor que esperamos, 1024.
AUDIÊNCIA: E não é um nomear, por isso torna mais fácil
a ler, a praça que seja.
>> DAN AMRMENDARIZ: Certo, exatamente.
Então, antes de colocá-la em uma constante aqui de modo
que tornou fácil de usar esse nome.
Sim?
>> AUDIÊNCIA: Neste contexto powerof, é parte
da linguagem de programação em oposição à maneira como você
pensar em powerof em [inaudível]?
DAN AMRMENDARIZ: Então, Neste caso, powerof
é simplesmente o nome do função que eu definido aqui em cima.
Portanto, não é inerente para a própria linguagem,
mas em vez disso, é só uma função que possui
esse nome porque eu dar-lhe esse nome.
Alguma outra pergunta?
Tudo certo.
>> Agora, isso é ótimo.
Mas você não vai ver um série de funções de fecho que
são como este onde você define, dentro de uma função, uma outra função.
E você pode fazê-lo.
Mas não é o tipo de realmente necessário, certo?
Como por que eu definir esta função chamada exponentiator
e, em seguida, devolvê-lo imediatamente.
Por que não posso apenas imediatamente retornar essa função?
>> E, de fato, este é precisamente a idéia por trás de um conceito chamado
funções anônimas, onde funções anônimas na verdade não
tem um nome, porque eles Não é necessário ter um.
E assim, neste caso, em 7B, podemos encontrar exatamente o que.
É tudo o mesmo código, faz exatamente a mesma coisa,
mas agora nós mudamos-lo um pouco para que esta função powerof imediatamente
retorna uma função.
Observe que após o regresso, há um colchete aberto.
Ele está esperando esta entrada dobro.
Ele está esperando que a saída de casal.
E, em seguida, a palavra-chave separa o código em si.
Portanto, esta é uma função anônima.
Na verdade, não tem um nome, enquanto antes de ter sido chamado exponentiator.
Mas, como vimos, apenas realmente não se referia a exponentiator
fora dessa função.
Por isso, não importa.
Portanto, esta função anônima é assim chamado porque é sem nome,
mas ele ainda está sendo usado no contexto deste código.
>> O casal próximo que eu sou vai continuar esperançosamente
soprando sua mente um pouco.
Podemos simplificar ainda mais.
Porque, como foi astutamente apontado anteriormente,
talvez nós realmente sabe, por inferindo a partir deste código, o que
a saída deste código vai ser.
E, de fato, nesta função anônima, que pode, de facto, inferir os tipos de dados.
>> Então, em um presente, já não precisa definir explicitamente
o tipo de dados que está sendo entrada e saída desta função
para um par de razões.
Uma delas é que nós definimos, até ao protótipo da função delimitador,
que tipo de dados que este anônimos função deve entrada e saída.
E do outro, nós pode-se inferir a partir do código
aqui que estamos aceitando entrada que é do tipo Double
e retornando um duplo.
>> Note que aqui nós não tem explicitamente definido os nomes dos argumentos
que esta função está aceitando.
E assim vemos que pode se referir a esses parâmetros usando US $ 0, $ 1,
assim por diante e assim por diante, dependendo que o número de parâmetro usados
nesta função.
>> Isso é algo que você está indo para ver um monte é este colchete aberto
seguido por uma definição R $ 0, e depois alguma operação,
e, em seguida, um colchete fechado.
Essa é uma função anônima que executa esta operação.
Ele tem esse parâmetro onde é tipo é inferido.
Esse primeiro parâmetro é $ 0.
E alguma operação é acontecendo naquele $ 0.
>> AUDIÊNCIA: Então o cifrão parâmetro significa, basicamente,
e 0 significa o primeiro?
DAN ARMENDARIZ: Isso está correto.
Assim, o sinal de dólar significa, basicamente, parâmetro, e 0 significa que a primeira.
Mas ele funciona especificamente em Neste caso onde eu não tenha nomeado
os argumentos a minha função anônima.
>> AUDIÊNCIA: Será que Perl ou algo tem este sinal de dólar, dólar 0 lá?
DAN ARMENDARIZ: Será que, me desculpe?
AUDIÊNCIA: Será que Perl tem esta dólar 0, dólar 1--
DAN ARMENDARIZ: Eu não sou muito familiarizado com Perl,
PHP mas o que define variáveis com base em sinais de dólar.
E pode haver alguns idiomas que têm características como esta.
Na verdade, Swift pede uma monte de recursos como este
a partir de um monte de outras línguas.
Vemos indícios de Python na mesma.
Esta definição de tipo parece vir do OCaml.
E nós temos apenas um monte de material de lotes de diferentes línguas.
Esse é um dos agradável coisas sobre Swift
é que ele tem um monte de o melhor idéias de um grupo de idiomas
e shoehorns-los todos juntos em uma linguagem super.
Na verdade, se você me permitir a continuar soprando sua mente,
por isso temos vindo a fazer tudo isso.
Podemos talvez simplificar isso um pouco bit por perceber que, é claro,
Swift tem uma exponencializando função incorporada.
Se eu importar Darwin, que é apenas que a biblioteca
apresenta esta função chamada prisioneiro de guerra, agora Eu posso simplificar o meu poder de função
para ser o seguinte.
Ele vai voltar esta função anônima.
>> Mas olhe o quão simples isso é agora.
Esta é uma função anônima que está a aceitar dados de algum tipo,
e ele vai ser um argumento especificamente,
referenciada em $ 0 que é do tipo Double.
Ele vai retornar um tipo duplo.
Mas a instrução de retorno agora é implícito.
>> E é este estilo exato que é muito, muito prevalente na Swift,
por todo o lugar.
Nós vamos ver isso todo o tempo em Swift.
Então, eu estou mostrando tudo isso para você por causa dessa sintaxe.
Isto é muito comum para ver, o que significa que
é uma função anônima que está a efectuar
alguma operação sobre esses argumentos.
E há um retorno implícito.
Por isso, é absolutamente a mesma coisa para nos dizer isto, aqui mesmo.
>> Porque este encaracolado suporte é uma função,
estamos executar esta operação no primeiro argumento.
Nós vamos voltar isso.
Mas esse retorno exterior é voltando toda essa função,
Toda essa função anônima que acabou de criar.
Alguma outra pergunta?
Tudo bem, eu não sei se vocês estão prontos para isso,
mas podemos ir ainda mais louco com Swift.
Esta pronto?
OK, isso é ótimo.
>> Agora nós realmente ter a capacidade para, em Swift, devido à forma como modular
e como protocolo baseado é, a definir nossos próprios operadores que freaking.
Como neste caso, não tínhamos operador para exponentiation-- bem,
para a realização de poderes de alguma coisa.
Mas eu posso, na Swift, definir um novo operador que faz precisamente isso.
Portanto, neste caso há um bando de sintaxe aqui.
E eu vou permitir que você olhar para ele em casa quando você olha para isto.
Mas estamos definindo este infix operador, **, que irá permitir-nos,
definindo o que isso ** função realmente
que, para aceitar uma mão esquerda lado e um lado direito,
e, em seguida, voltar para o expoente dessa lado esquerdo para o lado direito.
>> E agora, de repente eu criaram um novo numerador.
Então, 2 ** 3 significa 2 para a terceira potência.
[MENTE SÃ SOPRO] Este por em si deve fazer você ser como,
OK, parafuso C. Vou Swift todo o caminho.
Isso é ótimo.
Isso é muito fantástico.
>> Embora este é um grande exemplo.
Mas eu nunca tenho uma vez fora deste exemplo realmente
definida meu próprio operador.
Mas ainda assim, ele mostra uma Muito do poder do Swift
e por que isso é, na verdade, realmente muito legal.
OK, sim?
Audiência: Se você é definir o seu próprio operador,
como você sabe que você não acidentalmente tentar criar um operador que é
em algum lugar em C, como escondido em algum lugar Swift,
como uma obscura, que pode não ter visto antes.
>> DAN ARMENDARIZ: Então, se você está tentando para definir os seus próprios operadores,
existe o risco de que define um sobre um operador existente.
Que entra em um nível de detalhe que Eu não acho que temos tempo para passar por cima.
Mas isso é um risco.
E isso é de fato a razão pela qual Eu não utilizar o símbolo de acento circunflexo, que
quando estamos digitando o poder, nós normalmente usar pouco acento circunflexo 4 5 ou algo
assim, apenas quando estamos Gchatting amigos ou qualquer outra coisa.
Mas, nesse caso, que na verdade teria provocado uma colisão.
E assim eu evitava-lo apenas porque Aconteceu de eu saber, neste caso,
que que causaria que a colisão.
>> Tudo certo.
Agora, infelizmente, para os últimos sete minutos,
Eu tenho que manter sopro suas mentes um pouco.
Então, permita-me mostrar-lhe algumas outras coisas também.
>> Nós mostramos-lhe esta ideia de tendo estas funções anônimas,
estes encerramentos que permitem que você tipo de passar funções ao redor.
Você pode devolvê-los.
Você pode manipulá-los.
Você pode fazer todos os tipos de coisas loucas.
>> Mas uma outra coisa que passa a ser útil
é a capacidade de, ao contrário para devolver essas funções
em uma função, para passar uma função como um parâmetro para outra função.
Você pode estar pensando bem por que na Terra que eu iria querer fazer algo assim?
>> Bem, digamos que eu quero a tomar este operador que eu
trabalhou tão duro para criar e aplicar -lo para um monte de números diferentes
em uma matriz.
Portanto, neste caso eu tenho uma matriz de integers-- 1, 4, 7, 2, 5, 10, 56.
E eu quero dobrar todos eles.
A maneira que nós faria normalmente fazê-lo é apenas escrever
um loop for simples que itera sobre todos eles
e realizar algum tipo de operação quadrado sobre eles,
introduzir os novos valores em uma nova variável, ou melhor, uma nova matriz aqui.
E o valor da saída de resultado é, em seguida, todas essas matrizes,
ou em vez de todos aqueles elementos agora ao quadrado.
>> E nós poderíamos fazer o mesmo cubing coisa para ele,
mas um pequeno sino de alarme deve ir off
dizendo que talvez haja alguma maneira que faríamos
ser capaz de simplificar isso um pouco.
E na verdade não existe.
E se pudéssemos criar uma função que nos permite
a aceitar, como um predador, uma função?
Portanto, neste caso, tomar uma olhar para estes argumentos.
Nós estamos indo para aceitar uma lista de duplas.
E então nós vamos a aceitar uma função
em uma variável chamada F que vai para tomar um casal e retornar um duplo.
E toda a produção desta função inteira
chamado de mapeador vai retornar um array chamado duplo.
>> O que isto seria, então permita-me fazer é iterar sobre essa lista
e fazer a mesma coisa, mas agora aplicar essa função em cada
dos valores individuais na lista.
Então, eu realmente não sei o que é f.
Não importa para mim.
Mas desde que leva em um casal, realizar alguma operação sobre ele,
e, em seguida, retorna uma Duplo, eu seria, então,
capaz de mapear essa função através cada elemento na lista.
>> E esse tipo de programação é chamadas funções de ordem superior,
onde estamos passando funções em torno de como parâmetros
e fazer as coisas com funções.
É uma espécie de como tomar todos estes idéias que aprendemos em CS50
e levá-los espécie do para o nível seguinte.
E isso é tudo coisa estilo CS51.
E assim vamos em profundidade mais nas aulas como essa.
>> Mas esta é também importante aqui, porque nós
ver um monte de funções que são utilizados em Swift
que faz essencialmente este, onde temos
alguns números, alguns matriz de números.
Nós vamos passar isso matriz em nosso mapeador.
E nós também vamos passar alguma função, que
nós já definido aqui em cima.
Vai ser quadrado.
E nós estamos indo, em seguida, quadratura todos esses números
e armazenar isso em este resultado aqui.
>> Então, neste caso, nós definimos nossa própria função chamada mapeador.
Mas essa coisa exata é, Na verdade, construído em Swift.
Há uma variedade de funções chamado mapa.
Há uma função de mapa, há uma função de reduzir,
e há uma função de filtro, que se aplicam essencialmente funções
para cada elemento em um lista para modificá-los de alguma forma.
>> AUDIÊNCIA: Então, já que você está transformando os dados para outro formato
através de um function--
DAN ARMENDARIZ: Certo.
É, portanto, a função que nós estamos aceitando
está transformando os dados de alguma forma.
Neste caso, ambos os nós quadratura-lo, ou que foram cubing-lo,
ou realmente, poderíamos realizar nenhuma operação sobre ele em tudo.
>> Mas deixe-me mostrar-lhe então como este vai olhar na prática.
E novamente, eu estou correndo um pouco de tempo. então eu não tenho
vai ser capaz de passar por cima de tudo do código-fonte aqui em detalhe.
Mas eu encorajá-lo a fazer isso.
Vamos publicá-la o mais rapidamente possível após essa conversa.
>> Mas se você der uma olhada nisso, assumir que temos uma lista de números,
uma matriz de números nesta números chamados variáveis.
Então eu quero executar este operação do filtro sobre esses números.
Assim, é um filtro maior função a fim de que
aceita uma matriz e também uma função.
E em que cada elemento array, ele executa essa função.
>> Se essa função retorna verdade, ele mantém esse item.
Se essa função retorna falso, ele joga fora esse item.
E, em seguida, ele retorna uma lista que é então constituída por todos
desses itens que foram filtradas.
>> Portanto, em outras palavras, este é a mesma idéia, o livro de notas.
Podemos ter uma variedade de classes a este valor os números de chamada.
Poderia ser 100, e 70, e 40, assim por diante e assim por diante.
O que este filtro faz é aviso que este é que o açúcar sintático
para uma função anônima.
Esta é uma função anônima dizendo que o parâmetro que eu estou aceitando
vai ser, se é superior a 70,
então isso irá retornar true, o que significa que produto que vai ser mantido neste filtro.
Então, vamos ser um pouco mais concreto sobre isso.
Se eu tenho essa matriz de números e consiste em 100, 70 e 40,
Eu executar este filtro operação em cada um desses.
Assim que este é um primeiro valor de 100.
100 maior ou igual 70 é verdade, que
significa que 100 é mantido em esta nova cópia desta matriz.
70 também passa.
Mas 40 não.
Então, o que é devolvido em passingCount é a matriz de elementos 100 e 70--
100, vírgula, 70.
Aqueles foram os dois únicos itens que foram mantidos.
E assim a razão de eu rapidamente passou por um monte de este tipo de ordem alta
as coisas são, porque isso é tão comum coisa que você vai ver em Swift bonita
com freqüência, está realizando alguma operação usando esta sintaxe função anônima.
>> Há algumas coisas interessantes.
Os switches são realmente poderoso em Swift, Quero dizer apenas como um louco, louco poderoso.
Você pode usar o interruptor, e você pode realmente aplicá-las
a intervalos, o que é meio louco, e fazer coisas extravagantes como isso.
>> Mas, nos últimos minutos, Eu quero pular muito longe
e mostrar-lhe um exemplo concreto de como podemos criar em iOS app usando Swift.
Então, quando você está fazendo isso, você vai ter que tomar
um olhar sobre at-- Apple documentação, eles
tem um monte de realmente bons tutoriais para criar a sua primeira aplicação.
E eu encorajo você a fazer isso porque eles levá-lo
através de todos os passos do que exactamente à clique em criar um aplicativo iOS.
>> Mas aqui nós temos este app iOS.
E é um app realmente muito simples.
Se eu executar isso, deixe-me mostrar você é o que parece.
Tudo o que essencialmente faz é puxa a partir da Internet um arquivo JSON
que eu tenha armazenado em um servidor.
E esse arquivo JSON define imagens que permitem
me para então percorrer, em minha app, imagens do meu servidor web.
>> Então, eu tenho aqui getNextImage.
Ele carrega uma imagem a partir da Internet, e depois o exibe na tela.
>> Por isso é muito simples.
Mas o objetivo aqui é mostrar como podemos combinar as coisas
Deste último semanas de CS50 em uma aplicação real iOS.
Em outras palavras, talvez um dos coisas que você vai querer fazer
é ter um aplicativo iOS que pode extrair dados a partir da Internet
e mostrar ao utilizador uma informação.
Isto é inteiramente o ponto deste código-fonte aqui.
>> Portanto, há muito a ser dito sobre como fazer desenvolvimento real iOS.
Há um monte de sintaxe louco que não temos visto muito ainda
como uma classe, uma classe que realmente é.
Podemos ignorar em grande parte que, por enquanto.
>> Mas note que tenham contido dentro desta uma variedade de coisas
que já vimos como funções que têm nomes específicos.
E quando damos àqueles Funciona os nomes corretos
que são esperados pelo iOS, de fato isto parece um pouco mágico.
Mas quando você cria um aplicativo iOS, há
são os nomes das funções específicas que são chamados pelo próprio telefone
como o aplicativo está carregando para tentar para criar o processo que efectivamente
executa o aplicativo.
Então, novamente, há um monte de coisas que eu tem que passar por cima aqui para que nós
para falar sobre isso especificamente.
Mas eu encorajo-vos a olhar para talvez outro seminário iOS, mas também alguns
do tutoriais on-line que fazer um trabalho muito melhor de descrever
a informação específica.
>> Mas podemos ver um par de coisas que são interessantes a partir do código aqui.
Observe que temos se declarações.
By the way, um importante coisa sobre se as declarações
é que os parênteses em torno da Expressão booleana são opcionais.
Mas as chaves não são opcionais, não importa o quão poucas ou muitas linhas de código
você tem em uma instrução if.
Você não pode ter um if sem chaves em Swift.
>> E este é, assim, uma espécie de bobo.
Mas há razões históricas para isso.
É suposto salvá-lo de si mesmo.
Gosta dessa por exemplo, você não pode eliminar as chaves em torno de que
if.
Aqueles são na verdade necessária.
Então, eu encorajá-lo a dê uma olhada neste.
Mas há mais uma construir o que eu quero
para mostrar-lhe que sobre Swift é nova para Swift 2.0 comparação
para versões mais antigas do Swift, que é o seguinte.
Vamos ver onde é que eu colocá-lo aqui?
>> Portanto, nesta função chamada fetchJSON, esta função
é responsável por puxar que JSON arquivo de uma URL, o que só acontece
estar em execução no meu CS50 IDE.
Eu só comecei a Apache, colocar meu arquivo JSON lá,
e eu sou capaz de puxe que dados da internet usando
esta função e este URL, que é fornecido pelo telefone.
É fornecido por um biblioteca que você usa quando
você está fazendo algum desenvolvimento app iOS.
>> Note aqui que há esta incomum construção sintática chamado guarda.
E realmente tudo isso está em Swift é uma maneira de verificar
que algumas coisas têm foram atendidos antes que você
prosseguir com o resto da função.
Então, eu poderia ter, usando este tipo opcional,
Eu poderia ter encontrado o URL por de executar esta função NSURL
e armazenar isso em uma URL constante, e, em seguida, verificar
URL para ver se era nula, porque estava indo para retornar um tipo opcional.
E se fosse nula, então eu iria imprimir um erro e depois voltar.
>> Mas em vez disso, o que permite que guarda nós fazemos é que muito coisa,
mas garantir que ele é realmente o caso que url
foi devidamente definido pelo NSURL.
E se for, então salta sobre isso, e ele
irá permitir-lhe avançar com url tendo sido adequadamente definidas.
Mas, se for o caso de que url não está devidamente definido,
se esta função retorna um erro ou alguma outra coisa inesperada
na verdade, ocorre, este construto guarda permite-nos então a saída que o erro
e retornar imediatamente.
Sim?
>> AUDIÊNCIA: Então é tipo de como um se então mais?
DAN ARMENDARIZ: É uma espécie de como um se então mais, sim,
exceto que esta url é, então, definido para tudo isso abaixo.
Se ele passar pela guarda, então ele será efectivamente preenchido com dados
e utilizáveis ​​nos restantes código fonte em sua função.
Então, eu suspeito que você vai começar a ver este guarda também.
E estar atento a isso.
>> Então, basta olhar para um par de outro coisas, isso aqui é o que,
você acha que, apenas com base no que nós estávamos falando antes?
>> AUDIÊNCIA: Acho que vai correr na lista?
>> DAN ARMENDARIZ: Assim que é perto.
Esta é uma função que estamos definindo.
E nós estamos introduzindo essa função como um argumento para esta função aqui.
>> AUDIÊNCIA: [inaudível], se não nulo.
Portanto, é na lista, certo?
>> DAN ARMENDARIZ: Se o erro não é nulo, de modo que é-- então eu tenho que percorrer.
Bem, vamos ver, eu realmente não posso rolar para a direita aqui.
erro é um argumento que está sendo passado para esta função anônima.
Esta é uma função anônima.
Não tem nome.
Mas estamos aceitando estes três argumentos, dados, resposta, e erro.
E ele está indo para retornar void, então ele não vai retornar nada.
E este é o conteúdo dessa função.
E então nós temos acesso ao interior que função para cada um desses argumentos.
>> Portanto, é um turbilhão excursão da língua.
Mas eu espero que com isso, espero que você tomar
uma olhada em alguns dos tutoriais específico para o desenvolvimento iOS com Swift,
especialmente se você vai para Desenvolvedor web página-- da Apple
eles têm um monte de realmente bom tutoriais para você começar.
Mas espero que apenas nesta hora de falar sobre a sintaxe em si tem dado
você o suficiente para começar com isso.
>> Vamos postar tudo isso fonte código no site do seminário
logo que possível, e também as lâminas então você tem uma referência para todos aqueles.
Mas boa sorte com seus projetos.
E obrigado a todos muito por ter vindo.
>> [Aplausos]