Swift (linguagem de programação)

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Swift
Swift logo.svg
Paradigma Multiparadigma (Orientação a objetos, funcional, imperativa, estruturada)
Última versão 3.1 (27 de março de 2017; há 0 dias)
Criado por Chris Lattner and Apple Inc.
Estilo de tipagem: estática, forte, inferência
Influenciada por Objective-C, Rust, Haskell, Ruby, Python, Scala, C#, CLU, D
Influenciou Rust
Licença: Software proprietário (até a versão 2.2)

Licença Apache 2.0 (versão 2.2 e acima)

Página oficial swift.org

Swift é uma linguagem de programação multiparadigma criada pela Apple para desenvolvimento de programas para iOS e OS X. Apresentada na Apple's 2014 Worldwide Developers Conference, Swift foi projetada para trabalhar com os frameworks da Apple, Cocoa e Cocoa Touch, e com códigos em Objective-C.

História[editar | editar código-fonte]

Swift é uma linguagem de programação de uso geralmulti-paradigmática e compilada desenvolvida pela Apple Inc.para iOSMacOSwatchOStvOS e Linux . A linguagem Swift foi projetada para trabalhar com as frameworks Cocoa e Cocoa Touch da Apple e o grande corpo do código Objective-C (ObjC) existente para os produtos Apple. Ele é construído com o open source LLVM compilador quadro e foi incluído no Xcode desde a versão 6. Em diferentes plataformas Linux,  ele usa a biblioteca de tempo de execução do Objective-C que permite que o C , o Objective-C, o C ++ eo código Swift sejam executados dentro de um programa. 

Swift destina-se a ser mais resiliente ao código errado ("mais seguro") do que Objective-C, e mais conciso. No entanto, ele suporta muitos conceitos básicos que estão associados com Objective-C; nomeadamente expedição dinâmica , difundida ligação tardia , programação extensível e características semelhantes. Por segurança, Swift ajuda a corrigir erros comuns de programação como ponteiros nulos e fornece açúcar sintático para evitar a pirâmide de desgraça que de outra forma pode resultar. Mais fundamentalmente, Swift acrescenta o conceito de protocoloextensibilidade, um sistema de extensibilidade que pode ser aplicado a tipos, estruturas e aulas . A Apple promove isso como uma mudança real nos paradigmas de programação que eles denominam "programação orientada ao protocolo". 

A Swift foi introduzida na Conferência Mundial de Desenvolvedores 2014 da Apple (WWDC).  Submetido a uma atualização para a versão 1.2 durante 2014 e uma atualização mais importante para Swift 2 na WWDC 2015. Inicialmente uma linguagem proprietária , a versão 2.2 foi feita software de código aberto sob a Licença Apache 2.0 em 3 de dezembro de 2015, para a Apple Plataformas e Linux . 

Em março de 2017, menos de três anos após sua estréia oficial, a Swift alcançou o top 10 no ranking mensal do índice TIOBE de linguagens de programação populares. 

História [editar | editar código-fonte]

O desenvolvimento do Swift começou em julho de 2010 por Chris Lattner , com a eventual colaboração de muitos outros programadores da Apple . Swift tomou idéias de linguagem "de Objective-C , Rust , Haskell , Ruby , Python , C # , CLU , e muitos demais para listar".  Em 2 de junho de 2014, a Apple Worldwide Developers Conference (WWDC) aplicação tornou-se o primeiro aplicativo lançado publicamente escrito em Swift.  Uma versão beta da linguagem de programação foi lançado para desenvolvedores registrados Apple na conferência, Mas a empresa não prometeu que a versão final do Swift seria código-fonte compatível com a versão de teste. A Apple planejou disponibilizar conversores de código fonte se necessário para a versão completa. 

A Swift Programming Language , um manual gratuito de 500 páginas, também foi lançado na WWDC, e está disponível na loja iBooks e no site oficial. 

Swift atingiu o marco 1.0 em 9 de setembro de 2014, com o Gold Master do Xcode 6.0 para iOS .  Swift 1.1 foi lançado em 22 de outubro de 2014, juntamente com o lançamento do Xcode 6.1.  Swift 1.2 foi lançado em 8 de abril de 2015, juntamente com o Xcode 6.3.  Swift 2.0 foi anunciado na WWDC 2015, e foi disponibilizado para publicação de aplicativos na App Store em 21 de setembro de 2015.  Swift 3.0 foi lançado em 13 de setembro de 2016. 

Swift ganhou o primeiro lugar para a linguagem de programação mais amada no Stack Overflow Developer Survey 2015  eo segundo lugar em 2016. 

Em dezembro de 2015, a IBM anunciou seu site Swift Sandbox, que permite aos desenvolvedores escrever código Swift em um painel e exibir saída em outro. 

Durante a WWDC 2016 , a Apple anunciou um iPad exclusivo aplicativo , chamado Swift Playgrounds, destinado a ensinar as pessoas como codificar em Swift. O aplicativo é apresentado em uma interface de jogo de vídeo 3D, que fornece feedback quando linhas de código são colocadas em uma determinada ordem e executadas. 

Em janeiro de 2017, Chris Lattner anunciou sua saída da Apple para uma nova posição com a Tesla Motors , com o papel de líder do projeto Swift indo para o veterano Ted Kremenek. 

Recursos[editar | editar código-fonte]

Swift é uma alternativa à linguagem Objective-C que emprega conceitos modernos de teoria da linguagem de programação e se esforça para apresentar uma sintaxe mais simples. Durante a sua introdução, foi descrito simplesmente como "Objetivo-C sem o C". 

Por padrão, Swift não expõe ponteiros e outros inseguras assessores , em contraste com Objective-C, que utiliza ponteiros pervasively para se referir a instâncias de objeto. Além disso, o uso de uma sintaxe similar a Smalltalk para fazer chamadas de método foi substituído por um estilo de notação de ponto e um sistema de namespace mais familiar para programadores de outras linguagens orientadas a objetos comuns (OO) como Java ou C # . Swift apresenta verdadeiros parâmetros nomeados e mantém conceitos Objective-C-chave, incluindo protocolosfechamentos e categorias.

Açúcar sintático[editar | editar código-fonte]

Sob os ambientes Cocoa e Cocoa Touch , muitas classes comuns faziam parte da biblioteca Foundation Kit . Isso incluiu a biblioteca de seqüências NSString (usando Unicode ), as classes de coleção NSArray e NSDictionary e outras. Objective-C forneceu vários pedaços de açúcar sintáctico para permitir que alguns desses objetos fossem criados on-the-fly no idioma, mas uma vez criados, os objetos foram manipulados com chamadas de objetos. Por exemplo, em Objective-C concatenando duas chamadas de método NSStrings necessário semelhante a este:

NSString  * str  =  @ "Olá," ;
Str  =  [ str  stringByAppendingString : @ "mundo" ];

Em Swift, muitos desses tipos básicos foram promovidos ao núcleo da linguagem, e podem ser manipulados diretamente. Por exemplo, as strings são invisivelmente conectadas a NSString (quando a Foundation é importada) e agora podem ser concatenadas com o +operador, permitindo simplificar a sintaxe; O exemplo anterior tornando-se: 

Var  str  =  "hello,"
str  + =  "mundo"

Tratamento de arquivos [editar | editar código-fonte]

Swift suporta cinco controle de acesso níveis de símbolos: openpublicinternalfileprivate, e private. Ao contrário de muitas linguagens orientadas a objetos, esses controles de acesso ignoram as hierarquias de herança: privateindica que um símbolo é acessível apenas no escopo fileprivateimediato , indica que é acessível somente a partir do arquivo, internalindica que está acessível dentro do módulo publiccontendo, Qualquer módulo e open(apenas para classes e seus métodos) indica que a classe pode ser subclassed fora do módulo. 

Opcionais e encadeamento [editar | editar código-fonte]

Um novo recurso importante no Swift são os tipos de opção , que permitem que referências ou valores operem de maneira semelhante ao padrão comum em C , onde um ponteiro pode se referir a um valor ou pode ser nulo. Isso implica que tipos não-opcionais não podem resultar em um erro de ponteiro nulo ; O compilador pode garantir isso não é possível.

Tipos Optionalopcionais são criados com o mecanismo - para fazer um Integer que é anulável, um usaria uma declaração semelhante a var optionalInteger: Optional<Int>. Como em C #,  Swift também inclui açúcar sintático para este, permitindo um para indicar uma variável é opcional, colocando um ponto de interrogação depois de o nome do tipo, var optionalInteger: Int?.  variáveis ​​ou constantes marcadas como opcionais têm um valor do tipo subjacente ou são nil. Tipos opcionais envolvem o tipo de base, resultando em uma instância diferente. StringString?são fundamentalmente diferentes tipos, o último tem mais em comum com Int?que String.

Para acessar o valor dentro, assumindo que ele não é nil, ele deve ser desempacotado para expor a instância dentro. Isso é realizado com o !operador:

    Deixe  myValue  =  anOptionalInstance ! SomeMethod ()

Neste caso, o !operador desenrola anOptionalInstancepara expor a instância dentro, permitindo que a chamada de método seja feita nele. Se anOptionalInstancefor nulo, ocorre um erro de ponteiro nulo. Isso pode ser irritante na prática, então Swift também inclui o conceito de encadeamento opcional para testar se a instância é nula e, em seguida, desenrolá-lo se não for nulo:

    Deixe  myValue  =  anOptionalInstance ?. SomeMethod ()

Neste caso, o tempo de execução apenas chama someMethodse anOptionalInstancenão for nulo, suprimindo o erro. Normalmente isso requer que o programador teste se myValueé nulo antes de prosseguir. A origem do termo encadeamento vem do caso mais comum onde várias chamadas de método / getters são encadeadas junto. Por exemplo:

    Deixe  aTenant  =  aBuilding . TenantList [ 5 ]
    deixe sua  Lease  =  aTenant . LeaseDetails
    let  leaseStart  =  yourLease ? data de início

Pode ser reduzida para:

   Let  leaseStart  =  aBuilding . TenantList [ 5 ]. LeaseDetails ?. data de início

?sintaxe permite que a pirâmide do destino seja evitada.

O Swift 2 introduziu a nova palavra-chave guardpara casos em que o código deve parar de ser executado se alguma condição não for atendida:

    Guarda  let  leaseStart  =  aBuilding . TenantList [ 5 ] ?. LeaseDetails ?. StartDate  else  {
        // lida com o caso de erro onde qualquer coisa na cadeia é nil
        // else scope deve sair do método atual ou loop
    }
    // continuar, sabendo que leaseStart não é nil

Usando guardtem três benefícios. Enquanto a sintaxe pode atuar como uma ifinstrução, seu principal benefício é inferir não-nulidade. Quando uma ifdeclaração requer um caso, guardassume o caso com base na condição fornecida. Além disso, uma vez guardque não contém escopo, com exceção do fechamento elseleaseStarté apresentado como um opcional não enrolado para o super-escopo do guarda. Por fim, se o guardteste da instrução falhar, Swift requer a elsesaída do método ou loop atual , garantindo que leaseStartnunca seja acessado quando nil. Isso é realizado com as palavras-chave returncontinuebreak, ou throw.

ObjC foi fracamente digitado, e permitiu que qualquer método seja chamado em qualquer objeto a qualquer momento. Se a chamada de método falhou, houve um manipulador padrão no tempo de execução que retornou nil. Isso significava que não era necessário desempacotar ou testar, a declaração equivalente em ObjC:

    LeaseStart  =  [[[ aBuilding  tenantList : 5 ]  leaseDetails ]  startDate ]

Retornaria nil e isso poderia ser testado. No entanto, isso também exigiu que todas as chamadas de método ser dinâmico, que introduz uma sobrecarga significativa. O uso de Swift de opcionais fornece um mecanismo semelhante para testar e lidar com nils, mas faz isso de uma forma que permite que o compilador para usar o despacho estático porque a ação de desembrulhar é chamado em uma instância definida (o wrapper), versus ocorrendo na expedição de tempo de execução sistema.

Tipos de valor [editar | editar código-fonte]

Em muitas linguagens orientadas a objetos, objetos são representados internamente em duas partes. O objeto é armazenado como um bloco de dados colocado no heap , enquanto o nome (ou "handle") para esse objeto é representado por um ponteiro . Os objetos são passados ​​entre métodos copiando o valor do ponteiro, permitindo que os mesmos dados subjacentes no heap sejam acessados ​​por qualquer pessoa com uma cópia. Em contraste, os tipos básicos como inteiros e valores de ponto flutuante são representados diretamente; O identificador contém os dados, não um ponteiro para ele, e que os dados são passados ​​diretamente para métodos por cópia. Esses estilos de acesso são denominados pass-by-reference no caso de objetos e pass-by-value para tipos básicos.

Ambos os conceitos têm suas vantagens e desvantagens. Os objetos são úteis quando os dados são grandes, como a descrição de uma janela ou o conteúdo de um documento. Nesses casos, o acesso a esses dados é fornecido copiando um valor de 32 ou 64 bits, em vez de copiar uma estrutura de dados inteira. No entanto, valores menores como números inteiros são do mesmo tamanho que ponteiros (normalmente ambos são uma palavra ), portanto, não há vantagem em passar um ponteiro, em vez de passar o valor. Além disso, pass-by-reference requer inerentemente uma operação de desreferenciamento, que pode produzir sobrecarga notável em algumas operações, tipicamente aquelas usadas com esses tipos de valores básicos, como a matemática.

Similarmente ao C # e em contraste com a maioria das outras linguagens OO, Swift oferece suporte interno para objetos usando uma semântica pass-by-reference ou pass-by-value, a primeira usando a classdeclaração e a última usando struct. Estruturas em Swift têm quase todas as mesmas características como classes: métodos, implementação de protocolos, e usando os mecanismos de extensão. Por esta razão, a Apple define todos os dados genericamente como instâncias , versus objetos ou valores. Estruturas não suportam herança, no entanto. 

O programador é livre para escolher quais semânticas são mais apropriadas para cada estrutura de dados na aplicação. Estruturas maiores como janelas seriam definidas como classes, permitindo que fossem passadas ao redor como ponteiros. Estruturas menores, como um ponto 2D, podem ser definidas como estruturas, que serão pass-by-value e permitem acesso direto aos dados internos sem desreferência. A melhoria de desempenho inerente ao conceito de passagem por valor é tal que Swift usa esses tipos para quase todos os tipos de dados comuns, incluindo IntDouble, e tipos normalmente representados por objetos, como StringArray.  Usar tipos de valores pode resultar em melhorias significativas de desempenho em aplicativos de usuário também. 

Para garantir que mesmo as estruturas maiores não causam uma penalidade de desempenho quando são entregues, o Swift usa a cópia em gravação para que os objetos sejam copiados somente se e quando o programa tentar alterar um valor neles. Isso significa que os vários acessadores têm o que é, na verdade, um ponteiro para o mesmo armazenamento de dados, mas isso ocorre muito abaixo do nível do idioma, na unidade de gerenciamento de memória do computador (MMU). Portanto, enquanto os dados são armazenados fisicamente como uma instância na memória, no nível da aplicação, esses valores são separados e a separação física é aplicada por cópia em gravação somente se necessário. 

Programação orientada a protocolo [editar | editar código-fonte]

Uma característica fundamental do ObjC é o suporte a categorias , métodos que podem ser adicionados para estender classes em tempo de execução. As categorias permitem a extensão de classes no local para adicionar novas funções sem necessidade de subclasse ou mesmo ter acesso ao código-fonte original . Um exemplo pode ser para adicionar corretor ortográfico apoio à base de NSStringclasse, o que significa que todas as instâncias do NSString na verificação ortográfica ganho de aplicação. O sistema também é amplamente utilizado como uma técnica organizacional, permitindo que o código relacionado seja reunido em extensões semelhantes a bibliotecas. Swift continua a apoiar este conceito, embora eles agora são chamados de extensões , e declarado com a palavra-chave extension. Ao contrário do ObjC, o Swift também pode adicionar novos acessores de propriedades, tipos e enums a instâncias existentes.

Outra característica fundamental do ObjC é o uso de protocolos , conhecidos na maioria das linguagens modernas como interfaces . Os protocolos prometem que uma classe particular implementa um conjunto de métodos, o que significa que outros objetos no sistema podem chamar esses métodos em qualquer objeto que suporte esse protocolo. Isso é freqüentemente usado em linguagens OO modernas como um substituto para herança múltipla , embora os conjuntos de recursos não sejam totalmente semelhantes . Um exemplo comum de um protocolo em Cocoa é o protocolo NSCopying, que define um método copyWithZone, que implementa a cópia profunda em objetos. 

No ObjC e na maioria das outras linguagens que implementam o conceito de protocolo, cabe ao programador garantir que os métodos necessários sejam implementados em cada classe.  Swift adiciona a capacidade de adicionar esses métodos usando extensões e usar programação genérica ( genéricos ) para implementá-los. Combinados, estes permitem que os protocolos sejam escritos uma vez e suportem uma grande variedade de instâncias. Além disso, o mecanismo de extensão pode ser usado para adicionar conformidade de protocolo a um objeto que não lista esse protocolo em sua definição. 

Por exemplo, um SupportsToStringprotocolo pode ser declarado chamado , o que garante que as instâncias que estão em conformidade com o protocolo implementar um toStringmétodo que retorna a String. Em Swift, isso pode ser declarado com um código como este:

protocolo  SupportsToString  {
    func  toString ()  ->  string
}

Este protocolo agora pode ser adicionado ao String, sem acesso à origem da classe base:

Extensão  String :  SupportsToString  {
    func  toString ()  ->  String  {
        return  self
    }
}

Em Swift, como em muitas linguagens modernas que suportam interfaces, os protocolos podem ser usados ​​como tipos, o que significa que variáveis ​​e métodos podem ser definidos por protocolo em vez de seu tipo específico:

var  someSortOfPrintableObject :  SupportsToString
...
print ( someSortOfPrintableObject . toString ())

Não importa qual o tipo de instância someSortOfPrintableObjecté, o compilador irá garantir que ele está em conformidade com o protocolo e, portanto, este código é seguro. Esta sintaxe também significa que as coleções podem ser baseadas em protocolos também, como let printableArray = [SupportsToString].

À medida que Swift trata estruturas e classes como conceitos semelhantes, extensões e protocolos são amplamente utilizados no tempo de execução do Swift para fornecer uma API rica baseada em estruturas. Por exemplo, Swift usa uma extensão para adicionar o protocolo a Equatablemuitos dos seus tipos básicos, como Strings e Arrays, permitindo que eles sejam comparados com o ==operador. Um exemplo concreto de como todas essas características interagem pode ser visto no conceito de implementações de protocolo padrão :

Func  ! = < T  :  Equatable > ( lhs :  T ,  rhs :  T )  ->  Bool

Esta função define um método que funciona em qualquer instância conforme Equatable, fornecendo uma função não igual . Qualquer instância, classe ou estrutura, automaticamente ganha essa implementação simplesmente por estar em conformidade com Equatable. À medida que muitas instâncias ganham Equatableatravés de suas implementações base ou outras extensões genéricas, a maioria dos objetos básicos no ganho de tempo de execução é igual e não é igual a nenhum código. 

Essa combinação de protocolos, padrões, herança de protocolo e extensões permite que muitas das funções normalmente associadas com classes e herança sejam implementadas em tipos de valores.  Adequadamente utilizado, isso pode levar a melhorias dramáticas de desempenho sem limites significativos na API. Este conceito é tão amplamente utilizado dentro Swift, que a Apple começou a chamá-lo de uma linguagem de programação orientada a protocolo . Eles sugerem abordar muitos dos domínios de problema normalmente resolvidos através de classes e herança usando protocolos e estruturas em vez disso.

Bibliotecas, tempo de execução e desenvolvimento [editar | editar código-fonte]

O Swift usa o mesmo tempo de execução que o sistema Objective-C existente, mas requer o iOS 7 ou o macOS 10.9 ou superior.  código Swift e Objective-C pode ser usado em um programa e, por extensão, C e C ++ também. Em contraste com C, código C ++ não pode ser usado diretamente do Swift. Um wrapper Objective-C ou C deve ser criado entre Swift e C ++.  No caso de Objective-C, Swift tem acesso considerável ao modelo de objeto, e pode ser usado para subclasse, estender e usar o código Objective-C para fornecer suporte de protocolo.  O inverso não é verdadeiro: uma classe Swift não pode ser subclassificada em Objective-C. 

Para auxiliar o desenvolvimento de tais programas, e a re-utilização do código existente, Xcode 6 oferece um sistema semi-automatizado que acumula e mantém um cabeçalho de ponte para expor o código Objective-C para Swift. Isso toma a forma de um arquivo de cabeçalho adicional que simplesmente define ou importa todos os símbolos Objective-C que são necessários pelo código Swift do projeto. Nesse ponto, Swift pode se referir aos tipos, funções e variáveis ​​declaradas nessas importações como se estivessem escritas em Swift. O código Objective-C também pode usar o código Swift diretamente, importando um arquivo de cabeçalho mantido automaticamente com as declarações Objective-C dos símbolos Swift do projeto. Por exemplo, um arquivo Objective-C em um projeto misto chamado "MyApp" pode acessar classes ou funções Swift com o código #import "MyApp-Swift.h". No entanto, nem todos os símbolos estão disponíveis por meio desse mecanismo. O uso de recursos específicos do Swift, como tipos genéricos, tipos opcionais não-objeto, enums sofisticados ou mesmo identificadores Unicode pode tornar um símbolo inacessível a partir do Objective-C. 

A Swift também tem suporte limitado para atributos , metadados que são lidos pelo ambiente de desenvolvimento e não é necessariamente parte do código compilado. Como o Objective-C, os atributos usam a @sintaxe, mas o conjunto atualmente disponível é pequeno. Um exemplo é o @IBOutletatributo, que marca um dado valor no código como uma saída , disponível para uso no Interface Builder (IB). Uma saída é um dispositivo que vincula o valor da exibição na tela a um objeto no código.

Gerenciamento de memória [editar | editar código-fonte]

Swift usa Automatic Reference Counting (ARC) para gerenciar memória . A Apple costumava exigir gerenciamento de memória manual no Objective-C, mas introduziu o ARC em 2011 para permitir uma alocação de memória mais fácil e desalocação.  Um problema com ARC é a possibilidade de criar um ciclo de referência forte , onde instâncias de duas classes diferentes cada uma incluem uma referência ao outro, fazendo com que eles se vazem para a memória como eles nunca são liberados. A Swift fornece as palavras-chave weakunownedevita ciclos de referência fortes. Tipicamente, uma relação pai-filho usaria uma referência forte enquanto uma criança-pai usaria qualquer weakreferência, onde pais e filhos podem não estar relacionados ou unownedonde uma criança sempre tem um pai, Mas o pai não pode ter um filho. nilReferências fracas devem ser variáveis ​​opcionais, já que elas podem mudar e se tornar . 

Um encerramento dentro de uma classe também pode criar um forte ciclo de referência, capturando auto referências. As auto-referências a serem tratadas como fracas ou sem proprietário podem ser indicadas usando uma lista de captura.

Depuração e outros elementos [editar | editar código-fonte]

Um elemento-chave do sistema Swift é a sua capacidade de ser limpa debugging e executar dentro do ambiente de desenvolvimento, usando um loop de leitura-eval-print (REPL), dando-lhe propriedades interativas mais em comum com as habilidades de script do Python do que a programação do sistema tradicional línguas. A REPL é reforçada com o novo conceito playgrounds . Estas são exibições interativas em execução no ambiente Xcode que respondem a alterações de código ou depurador on-the-fly.  Se algumas mudanças de código ao longo do tempo ou com relação a algum outro valor de entrada variado, a visualização pode ser usada com o Assistente de linha de tempo para demonstrar a saída de uma maneira animada.

A Apple afirma que a Swift "é a primeira linguagem de programação de sistemas de qualidade industrial que é tão expressiva e agradável como uma linguagem de script". 

Desempenho[editar | editar código-fonte]

Muitas das características introduzidas com Swift também têm o desempenho well-known e os trade-offs da segurança. A Apple investiu um esforço considerável na otimização agressiva que pode nivelar as chamadas de método e acessadores para eliminar essa sobrecarga.

Comparações com outras línguas [editar | editar código-fonte]

Swift é semelhante a C de várias maneiras:

  • A maioria dos operadores C são usados ​​no Swift, mas existem alguns operadores novos.
  • As chaves são usadas para agrupar declarações.
  • As variáveis ​​são atribuídas usando um sinal de igual , mas comparadas usando dois sinais iguais consecutivos . Um novo operador de identidade, ===, é fornecido para verificar se dois elementos de dados se referem ao mesmo objeto .
  • As declarações de controle,, e são semelhantes while, mas têm funções estendidas, por exemplo, a que toma casos não-inteiros, e compatível com a correspondência de padrões e desdobramento opcional de opcionais, etc.ifswitchswitchwhileif

Ele também tem semelhanças com o Objective-C:

  • Tipos numéricos básicos ( Int, UInt, Float, Double)
  • Colchetes são usados ​​com arrays , tanto para declará-los e para obter um valor em um determinado índice em um deles.
  • Os métodos de classe são herdados, como métodos de instância; selfEm métodos de classe é a classe em que o método foi chamado.
  • Semelhante for... inenumeração sintaxe.

Diferenças de Objective-C incluem:

  • As declarações não precisam de terminar com ponto-e-vírgula ( ;), embora elas devem ser usadas para permitir mais de uma instrução em uma linha.
  • Sem arquivos de cabeçalho.
  • Utiliza a inferência do tipo .
  • Programação genérica .
  • As funções são objetos de primeira classe .
  • Os casos de enumeração podem ter dados associados ( tipos de dados algébricos ).
  • Os operadores podem ser redefinidos para classes ( sobrecarga de operador ), e novos operadores podem ser definidos.
  • As strings suportam totalmente Unicode . A maioria dos caracteres Unicode podem ser usados ​​em identificadores ou operadores.
  • Sem manipulação de exceção . O Swift 2 introduz um modelo de manipulação de erros diferente e incompatível. 
  • Vários comportamentos notoriamente propensos a erros de línguas anteriores da família C foram alterados :
    • Os ponteiros não são expostos por padrão. Não é necessário que o programador acompanhe e marque nomes para referenciar ou desreferenciar.
    • As atribuições não retornam nenhum valor. Isso evita o erro comum de gravação i = 0em vez de i == 0lançando um erro de compilação.
    • Não há breaknecessidade de usar declarações em switchblocos. Os casos individuais não se encaixam no próximo caso, a menos que a fallthroughdeclaração seja usada.
    • As variáveis ​​e constantes sempre são inicializadas e os limites da matriz sempre são verificados.
    • Inteiros overflows , que resultam em comportamento indefinido para inteiros assinados em C, são presos como um erro em tempo de execução no Swift. Os programadores podem optar por permitir que transborda usando os operadores aritméticos especiais &+&-&*&/&%. As propriedades minmaxsão definidas no Swift para todos os tipos inteiros e podem ser usadas para verificar com segurança os potenciais transbordos, versus depender das constantes definidas para cada tipo em bibliotecas externas.
    • O formulário de uma declaração de ifwhile, que permite a omissão de chaves ao redor da instrução, não é suportado.
    • C-estilo de enumeração for (int i = 0; i < c; i++), que é propenso a off-by-one erros , é sem suporte (a partir de Swift 3 em diante). 
    • Os operadores pré e pós- incremento e decremento ( i++--i...) não são suportados (a partir do Swift 3 em diante), mais ainda, uma vez que as forinstruções de estilo C também não são suportadas a partir do Swift 3 em diante. 

Desenvolvimento e outras implementações [editar | editar código-fonte]

Uma vez que a linguagem é de código aberto, há perspectivas de ser portado para a web.  Alguns frameworks web já foram desenvolvidas, tais como IBM 's Kitura , Perfeito e vapor.

Um grupo de trabalho oficial de "APIs de servidor" também foi iniciado pela Apple,  com membros da comunidade de desenvolvedores Swift desempenhando um papel central. 

Uma segunda implementação livre do Swift que tem como alvo Cacau , Microsoft 's Common Language Infrastructure ( .NET ), eo Java e Android plataforma existe como parte da Elements Compiler de RemObjects Software . 

Referências [editar | editar código-fonte]

  1. https://swift.org/download
  2.  https://swift.org/download/#previews
  3.  http://www.cultofmac.com/471301/swift-is-already-of-the-worlds-most-popular-programming-languages/
  4. Plataformas Estado da União, Sessão 102, Apple Worldwide Developers Conference , 2 de junho de 2014
  5.  http://arstechnica.com/apple/2017/01/longtime-apple-programmer-and-swift-creator-leaves-apple-for-tesla/
  6.  http://appleinsider.com/articles/17/01/13/new-swift-project-head-ted-kremenek-said-to-be-running-the-show-behind-the-scenes-for -às vezes
  7.  "Nullable Tipos", C # Guia de Programação, Microsoft.
  8.  "Os aplicativos baseados em Swift funcionam no MacOS 10.9 / iOS 7 e inferior?" , StackOverflow
  9. Escrevendo Swift Classes Com Comportamento Objective-C", a Apple Inc.
  10.  "Swift e Objective-C no mesmo projeto", Apple Inc.
  11. "Automatic Reference Counting", Apple Inc.
  12.  Sobre a Swift, a Apple Inc.
  13. "RemObjects Elements Compiler" . Recuperado 2016-01-17 .
  14. https://en.wikipedia.org/wiki/Swift_(programming_language)

References[editar | editar código-fonte]

copiado do Wikipedia em inglês

  1. https://en.wikipedia.org/wiki/Swift_(programming_language)

Ver também[editar | editar código-fonte]