Swift (linguagem de programação) - Swift (programming language)

Rápido

Logotipo
Paradigma	Multi-paradigma : orientada para o protocolo , orientada a objectos , funcional , imperativo , bloquear estruturado , declarativa
Projetado por	Chris Lattner , Doug Gregor, John McCall, Ted Kremenek, Joe Groff e Apple Inc.
Desenvolvedor	Apple Inc. e colaboradores de código aberto
Apareceu pela primeira vez	2 de junho de 2014 ; 7 anos atrás ( 02/06/2014 )
Versão estável	5.4.2  / 28 de junho de 2021 ; 3 meses atrás ( 28 de junho de 2021 )
Versão de visualização	5,5 filial
Disciplina de digitação	Estático , forte , inferido
SO	Sistemas operacionais da Apple ( Darwin , iOS , iPadOS , macOS , tvOS , watchOS ), Linux , Windows 10 , Android
Licença	Licença Apache 2.0 (Swift 2.2 e posterior) Proprietária (até Swift 2.2)
Extensões de nome de arquivo	.swift, .SWIFT
Local na rede Internet	swift .org
Influenciado por
Objective-C , Rust , Haskell , Ruby , Python , C # , CLU , D
Influenciado
Ferrugem

Swift é uma de uso geral , multi-paradigma , compilados linguagem de programação desenvolvida pela Apple Inc. e a comunidade open-source . Lançado pela primeira vez em 2014, o Swift foi desenvolvido como um substituto para a linguagem de programação anterior Objective-C da Apple , uma vez que Objective-C permaneceu praticamente inalterado desde o início dos anos 1980 e carecia de recursos de linguagem modernos. O Swift trabalha com os frameworks Cocoa e Cocoa Touch da Apple , e um aspecto chave do design do Swift foi a capacidade de interoperar com o enorme código Objective-C existente desenvolvido para produtos Apple nas décadas anteriores. Ele é construído com a estrutura do compilador LLVM de código aberto e foi incluído no Xcode desde a versão 6, lançada em 2014. Em plataformas Apple, ele usa a biblioteca de tempo de execução Objective-C , que permite que códigos C , Objective-C , C ++ e Swift executado dentro de um programa.

A Apple pretendia que o Swift suportasse muitos conceitos básicos associados ao Objective-C , notavelmente despacho dinâmico , ligação tardia generalizada , programação extensível e recursos semelhantes, mas de uma maneira "mais segura", tornando mais fácil detectar bugs de software ; O Swift tem recursos que tratam de alguns erros comuns de programação, como desreferenciamento de ponteiro nulo, e fornece açúcar sintático para ajudar a evitar a pirâmide da desgraça . O Swift suporta o conceito de extensibilidade de protocolo , um sistema de extensibilidade que pode ser aplicado a tipos, estruturas e classes , que a Apple promove como uma mudança real nos paradigmas de programação que eles chamam de "programação orientada a protocolo" (semelhante a traits ).

O Swift foi apresentado na Conferência Mundial de Desenvolvedores da Apple em 2014 (WWDC). Ele passou por uma atualização para a versão 1.2 durante 2014 e uma grande atualização para o Swift 2 na WWDC 2015. Inicialmente uma linguagem proprietária , a versão 2.2 tornou -se um software de código aberto sob a Licença Apache 2.0 em 3 de dezembro de 2015, para plataformas da Apple e Linux .

Através da versão 3.0, a sintaxe do Swift passou por uma evolução significativa, com a equipe central fazendo da estabilidade do código um foco nas versões posteriores. No primeiro trimestre de 2018, o Swift ultrapassou o Objective-C em popularidade medida.

O Swift 4.0, lançado em 2017, introduziu várias alterações em algumas classes e estruturas integradas. O código escrito com versões anteriores do Swift pode ser atualizado usando a funcionalidade de migração embutida no Xcode. O Swift 5, lançado em março de 2019, introduziu uma interface binária estável nas plataformas Apple, permitindo que o tempo de execução do Swift fosse incorporado aos sistemas operacionais da Apple. É fonte compatível com Swift 4.

O Swift 5.1 foi lançado oficialmente em setembro de 2019. O Swift 5.1 se baseia na versão anterior do Swift 5, estendendo os recursos estáveis ​​da linguagem para o tempo de compilação com a introdução da estabilidade do módulo. A introdução da estabilidade do módulo torna possível criar e compartilhar estruturas binárias que funcionarão com versões futuras do Swift.

O Swift 5.5, anunciado oficialmente pela Apple no WWDC de 2021 , expande significativamente o suporte de linguagem para simultaneidade e código assíncrono , notavelmente introduzindo uma versão exclusiva do modelo de ator .

História

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 pegou ideias de linguagem "de Objective-C , Rust , Haskell , Ruby , Python , C # , CLU e muitos outros para listar". Em 2 de junho de 2014, o aplicativo Apple Worldwide Developers Conference (WWDC) se tornou o primeiro aplicativo lançado publicamente escrito com Swift. Uma versão beta da linguagem de programação foi lançada para desenvolvedores registrados da Apple na conferência, mas a empresa não prometeu que a versão final do Swift seria o código-fonte compatível com a versão de teste. A Apple planejou disponibilizar conversores de código-fonte, se necessário, para o lançamento completo.

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

O Swift atingiu a marca 1.0 em 9 de setembro de 2014, com o Gold Master do Xcode 6.0 para iOS . O Swift 1.1 foi lançado em 22 de outubro de 2014, juntamente com o lançamento do Xcode 6.1. O Swift 1.2 foi lançado em 8 de abril de 2015, junto 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 4.0 foi lançado em 19 de setembro de 2017. Swift 4.1 foi lançado em 29 de março de 2018.

Swift ganhou o primeiro lugar na Linguagem de Programação Mais Amada no Stack Overflow Developer Survey 2015 e o segundo lugar em 2016.

Em 3 de dezembro de 2015, a linguagem Swift, as bibliotecas de suporte, o depurador e o gerenciador de pacotes tiveram o código-fonte aberto sob a licença Apache 2.0 com uma Runtime Library Exception, e o Swift.org foi criado para hospedar o projeto. O código-fonte está hospedado no GitHub , onde é fácil para qualquer pessoa obter o código, construí-lo por conta própria e até mesmo criar solicitações pull para contribuir com o código de volta para o projeto.

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

Durante a WWDC 2016 , a Apple anunciou um aplicativo exclusivo para iPad , chamado Swift Playgrounds , com o objetivo de ensinar as pessoas a programar em Swift. O aplicativo é apresentado em uma interface semelhante a um videogame 3D , que fornece feedback quando as 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 um novo cargo na Tesla Motors , com o papel de líder do projeto Swift indo para o veterano da equipe Ted Kremenek.

Durante a WWDC 2019, a Apple anunciou o SwiftUI com Xcode 11, que fornece uma estrutura para design de estrutura de IU declarativa em todas as plataformas da Apple.

Downloads oficiais para a distribuição Ubuntu do Linux estão disponíveis desde Swift 2.2, com mais distros adicionadas desde Swift 5.2.4, CentOS e Amazon Linux. Também existe um SDK não oficial e um pacote de conjunto de ferramentas nativo para Android.

Plataformas

As plataformas que o Swift suporta são os sistemas operacionais da Apple ( Darwin , iOS , iPadOS , macOS , tvOS , watchOS ), Linux , Windows e Android .

Histórico de versão

Recursos

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

Por padrão, o Swift não expõe ponteiros e outros acessadores inseguros , em contraste com Objective-C, que usa ponteiros amplamente para se referir a instâncias de objeto. Além disso, o uso de Objective-C de uma sintaxe semelhante a Smalltalk para fazer chamadas de método foi substituído por um estilo de notação de ponto e sistema de namespace mais familiar para programadores de outras linguagens orientadas a objetos (OO) comuns como Java ou C # . O Swift introduz parâmetros nomeados verdadeiros e retém os principais conceitos Objective-C, incluindo protocolos , encerramentos e categorias , muitas vezes substituindo a sintaxe anterior por versões mais limpas e permitindo que esses conceitos sejam aplicados a outras estruturas de linguagem, como tipos enumerados (enums).

Suporte de fechamento

O Swift oferece suporte a encerramentos (conhecidos como lambdas em outras linguagens). Fechamentos são blocos autocontidos de funcionalidade que podem ser transmitidos e usados ​​em seu código. Os fechamentos podem ser considerados uma função sem nome. Aqui está um exemplo:

// Closure type, defined by its input and output values, can be specified outside the closure:
let closure1: (Int, Int) -> Int = { arg1, arg2 in
    return arg1 + arg2
}

// …or inside it:
let closure2 = { (arg1: Int, arg2: Int) -> Int in
    return arg1 + arg2
}

// In most cases, closure’s return type can be inferred automatically by the compiler.
// However, this functionality may not work for too complex expressions.
let closure3 = { arg1: Int, arg2: Int in
    return arg1 + arg2
}

O Swift tem uma sintaxe de encerramento final como esta:

// This function takes a closure which receives no input parameters and returns an integer,
// evaluates it, and uses the closure’s return value (an Int) as the function’s return value.
func foo(closure bar: () -> Int) -> Int {
    return bar()
}

// Without trailing closure syntax:
foo(closure: { return 1 })

// With trailing closure syntax:
foo { return 1 }

A partir da versão 5.3, o Swift oferece suporte a vários fechamentos à direita:

// This function passes the return of the first closure as the parameter of the second,
// and returns the second closure’s result:
func foo(bar: () -> Int, baz: (Int) -> Int) -> Int {
    return baz(bar())
}

// With no trailing closures:
foo(bar: { return 1 }, baz: { x in return x + 1 })

// With 1 trailing closure:
a(bar: { return 1 }) { x in return x + 1 })

// With 2 trailing closures (note that only the first closure’s argument name is ommited):
a { return 1 } baz: { x in return x + 1 }

Aqui estão os critérios para a sintaxe de encerramento final:

• Se os últimos argumentos de uma função forem encerramentos, você poderá usar a sintaxe de encerramento final.
• O nome do parâmetro do primeiro fechamento à direita deve ser omitido.
• Os nomes dos parâmetros dos fechamentos à direita restantes não devem ser omitidos.
• Se todos os argumentos dados a uma função forem encerramentos finais, você pode omitir os parênteses após o nome da função.
• As chamadas para uma função com encerramentos finais devem ser colocadas entre parênteses se usadas em uma guardinstrução.

Suporte de corda

Nos ambientes Cocoa e Cocoa Touch , muitas classes comuns faziam parte da biblioteca do Foundation Kit . Isso incluiu a biblioteca de strings NSString (usando Unicode , UTF-8 em Swift 5, alterado de UTF-16 ), as classes de coleção NSArray e NSDictionary e outras. Objective-C forneceu vários bits de açúcar sintático para permitir que alguns desses objetos fossem criados em tempo real dentro da linguagem, mas uma vez criados, os objetos foram manipulados com chamadas de objeto. Por exemplo, em Objective-C, concatenar duas NSStrings exigia chamadas de método semelhantes a esta:

NSString *str = @"hello,";
str = [str stringByAppendingString:@" world"];

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

var str = "hello,"
str += " world"

Controle de acesso

Swift suporta cinco controle de acesso níveis de símbolos: open, public, internal, fileprivate, e private. Ao contrário de muitas linguagens orientadas a objetos, esses controles de acesso ignoram hierarquias de herança : privateindica que um símbolo está acessível apenas no escopo imediato , fileprivateindica que ele é acessível apenas de dentro do arquivo, internalindica que está acessível dentro do módulo que contém, publicindica que é acessível de qualquer módulo e open(apenas para classes e seus métodos) indica que a classe pode ser uma subclasse fora do módulo.

Opcionais e encadeamento

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 os tipos não opcionais não podem resultar em um erro de ponteiro nulo ; o compilador pode garantir que isso não seja possível.

Tipos opcionais são criados com o Optionalmecanismo - para tornar um Integer que pode ser anulado, deve-se usar uma declaração semelhante a var optionalInteger: Optional<Int>. Como em C #, o Swift também inclui açúcar sintático para isso, permitindo indicar que uma variável é opcional colocando um ponto de interrogação após o nome do tipo var optionalInteger: Int?,. As variáveis ​​ou constantes marcadas como opcionais têm um valor do tipo subjacente ou são nil. Os tipos opcionais envolvem o tipo base, resultando em uma instância diferente. Stringe String?são tipos fundamentalmente diferentes, o último tem mais em comum com do Int?que String.

Para acessar o valor interno, supondo que não seja nulo, ele deve ser desembrulhado para expor a instância interna. Isso é realizado com o !operador:

let myValue = anOptionalInstance!.someMethod()

Nesse caso, o !operador se desdobra anOptionalInstancepara expor a instância interna, permitindo que a chamada do método seja feita nela. Se anOptionalInstancefor nulo, ocorre um erro de ponteiro nulo. Isso pode ser irritante na prática, então o Swift também inclui o conceito de encadeamento opcional para testar se a instância é nula e depois desembrulhá-la se não for nula:

let myValue = anOptionalInstance?.someMethod()

Nesse caso, o tempo de execução chama someMethodapenas se 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 em que várias chamadas / getters de método são encadeados. Por exemplo:

let aTenant = aBuilding.tenantList[5]
let theirLease = aTenant.leaseDetails
let leaseStart = theirLease?.startDate

pode ser reduzido a:

let leaseStart = aBuilding.tenantList[5].leaseDetails?.startDate

A ?sintaxe contorna a pirâmide da desgraça .

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:

guard let leaseStart = aBuilding.TenantList[5]?.leaseDetails?.startDate else
{
    //handle the error case where anything in the chain is nil
    //else scope must exit the current method or loop
}
//continue, knowing that leaseStart is not nil

O uso guardtem três benefícios. Embora a sintaxe possa atuar como uma ifdeclaração, seu principal benefício é inferir a não nulidade. Quando uma ifdeclaração requer um caso, guardassume o caso com base na condição fornecida. Além disso, uma vez que guardnão contém escopo, com exceção do elsefechamento, leaseStarté apresentado como um opcional desembrulhado para o superescopo do guarda. Por último, se o guardteste da instrução falhar, o Swift requer que o elsepara sair do método ou loop atual, garantindo que leaseStartnunca seja acessado quando nil. Isso é realizado com as palavras-chave return, continue, break, ou throw, ou chamando uma função retornando um Never(por exemplo fatalError()).

Objective-C era mal tipado e permitia que qualquer método fosse chamado em qualquer objeto a qualquer momento. Se a chamada do método falhou, havia um manipulador padrão no tempo de execução que retornou nil. Isso significava que nenhum desempacotamento ou teste era necessário, a declaração equivalente em Objective-C:

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

Retornaria nulo e isso poderia ser testado. No entanto, isso também exigia que todas as chamadas de método fossem dinâmicas, o que introduz uma sobrecarga significativa. O uso de opcionais do Swift fornece um mecanismo semelhante para testar e lidar com nils, mas faz isso de uma forma que permite ao compilador usar o despacho estático porque a ação de desempacotamento é chamada em uma instância definida (o invólucro), em vez de ocorrer no despacho em tempo de execução sistema.

Tipos de valor

Em muitas linguagens orientadas a objetos, os objetos são representados internamente em duas partes. O objeto é armazenado como um bloco de dados colocado no heap , enquanto o nome (ou "identificador") desse 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, 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 esses dados são passados ​​diretamente para métodos por meio de cópia. Esses estilos de acesso são denominados passagem por referência no caso de objetos e passagem por valor para tipos básicos.

Ambos os conceitos têm 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 inteiros, têm o 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, a passagem por referência requer inerentemente uma operação de desreferenciamento, que pode produzir uma sobrecarga perceptível em algumas operações, normalmente aquelas usadas com esses tipos de valor básicos, como matemática.

Semelhante ao C # e em contraste com a maioria das outras linguagens OO, o Swift oferece suporte integrado para objetos usando semântica passagem por referência ou passagem por valor, o primeiro usando a classdeclaração e o último usando struct. As estruturas em Swift têm quase todos os mesmos recursos das classes: métodos, implementação de protocolos e uso de mecanismos de extensão. Por esse motivo, a Apple denomina todos os dados genericamente como instâncias , versus objetos ou valores. No entanto, as estruturas não oferecem suporte à herança.

O programador é livre para escolher qual semântica é mais apropriada para cada estrutura de dados na aplicação. Estruturas maiores, como janelas, seriam definidas como classes, permitindo que fossem passadas como ponteiros. Estruturas menores, como um ponto 2D, podem ser definidas como estruturas, que serão passadas por valor e permitirão acesso direto aos seus dados internos sem desreferenciamento. A melhoria de desempenho inerente ao conceito de passagem por valor é tal que o Swift usa esses tipos para quase todos os tipos de dados comuns, incluindo Inte Double, e tipos normalmente representados por objetos, como Stringe Array. O uso de tipos de valor também pode resultar em melhorias significativas de desempenho nos aplicativos do usuário.

Para garantir que mesmo os maiores structs não causem uma penalidade de desempenho quando são entregues, o Swift usa copiar na gravação para que os objetos sejam copiados apenas 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. Portanto, embora os dados sejam armazenados fisicamente como uma instância na memória, no nível do aplicativo, esses valores são separados e a separação física é aplicada por cópia na gravação apenas se necessário.

Programação orientada a protocolo

Um recurso chave do Objective-C é seu suporte para categorias , métodos que podem ser adicionados para estender classes em tempo de execução. As categorias permitem estender classes no local para adicionar novas funções sem a necessidade de criar subclasses ou mesmo ter acesso ao código-fonte original . Um exemplo pode ser adicionar suporte ao verificador ortográfico à NSStringclasse base , o que significa que todas as instâncias de NSString no aplicativo ganham verificação ortográfica. O sistema também é amplamente usado como uma técnica organizacional, permitindo que o código relacionado seja reunido em extensões semelhantes a bibliotecas. O Swift continua a apoiar esse conceito, embora agora sejam denominados extensões e declarados com a palavra-chave extension. Ao contrário de Objective-C, o Swift também pode adicionar novos acessadores de propriedades, tipos e enums às instâncias existentes.

Outra característica fundamental do Objective-C é o uso de protocolos , conhecidos na maioria das linguagens modernas como interfaces . Os protocolos prometem que uma classe específica 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 é frequentemente usado em linguagens OO modernas como um substituto para herança múltipla , embora os conjuntos de recursos não sejam inteiramente semelhantes. Um exemplo comum de protocolo no Cocoa é o NSCopyingprotocolo, que define um método,, copyWithZoneque implementa a cópia profunda em objetos.

Em Objective-C, e na maioria das outras linguagens que implementam o conceito de protocolo, é responsabilidade do programador garantir que os métodos requeridos sejam implementados em cada classe. O Swift adiciona a capacidade de adicionar esses métodos usando extensões e usar programação genérica (genéricos) para implementá-los. Combinados, eles permitem que os protocolos sejam escritos uma vez e oferecem suporte a uma ampla 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 protocolo pode ser declarado chamado StringConvertible, o que garante que as instâncias que estão em conformidade com o protocolo implementem um toStringmétodo que retorna a String. Em Swift, isso pode ser declarado com código como este:

protocol StringConvertible
{
    func toString() -> String
}

Este protocolo agora pode ser adicionado a String, sem acesso à fonte da classe base:

extension String: StringConvertible
{
    func toString() -> String
    {
        self
    }
}

Em Swift, como 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: StringConvertible
...
print(someSortOfPrintableObject.toString())

Não importa que tipo de instância someSortOfPrintableObjectseja, o compilador garantirá que ela esteja em conformidade com o protocolo e, portanto, este código é seguro. Essa sintaxe também significa que as coleções também podem ser baseadas em protocolos, como let printableArray = [StringConvertible].

Como o Swift trata structs e classes como conceitos semelhantes, as extensões e os protocolos são amplamente usados ​​no tempo de execução do Swift para fornecer uma API rica baseada em structs. Por exemplo, o Swift usa uma extensão para adicionar o Equatableprotocolo a muitos de seus tipos básicos, como Strings e Arrays, permitindo que sejam comparados com o ==operador. Um exemplo concreto de como todos esses recursos 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 em conformidade com Equatable, proporcionando um não é igual a função. Qualquer instância, classe ou estrutura, obtém automaticamente essa implementação simplesmente por se conformar com Equatable. Como muitas instâncias ganham Equatablepor meio de suas implementações básicas ou outras extensões genéricas, a maioria dos objetos básicos no ganho de tempo de execução é igual e não igual sem código.

Essa combinação de protocolos, padrões, herança de protocolo e extensões permite que muitas das funções normalmente associadas a classes e herança sejam implementadas em tipos de valor. Usado corretamente, isso pode levar a melhorias dramáticas de desempenho sem limites significativos na API. Esse conceito é tão amplamente usado no Swift que a Apple começou a chamá-lo de linguagem de programação orientada a protocolo . Eles sugerem abordar muitos dos domínios de problemas normalmente resolvidos por meio de classes e herança usando protocolos e estruturas.

Bibliotecas, tempo de execução e desenvolvimento

Em sistemas Apple, o Swift usa o mesmo tempo de execução do sistema Objective-C existente, mas requer iOS 7 ou macOS 10.9 ou superior. Também depende do Grand Central Dispatch . Os códigos Swift e Objective-C podem ser usados ​​em um programa e, por extensão, C e C ++ também. Em contraste com o C, o código C ++ não pode ser usado diretamente no Swift. Um wrapper Objective-C ou C deve ser criado entre Swift e C ++. No caso do Objective-C, o Swift tem acesso considerável ao modelo de objeto e pode ser usado para criar subclasses, estender e usar o código Objective-C para fornecer suporte ao protocolo. O inverso não é verdade: uma classe Swift não pode ser subclassificada em Objective-C.

Para ajudar no desenvolvimento de tais programas e na reutilização do código existente, o Xcode 6 e superior oferece um sistema semiautomático que constrói e mantém um cabeçalho de ponte para expor o código Objective-C ao Swift. Isso assume 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 para o código Swift do projeto. Nesse ponto, o Swift pode se referir aos tipos, funções e variáveis ​​declaradas nessas importações como se tivessem sido escritos no Swift. O código Objective-C também pode usar o código Swift diretamente, importando um arquivo de cabeçalho mantido automaticamente com 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 de não objetos, enums sofisticados ou mesmo identificadores Unicode, pode tornar um símbolo inacessível a partir do Objective-C.

O Swift também tem suporte limitado para atributos , metadados que são lidos pelo ambiente de desenvolvimento e não necessariamente fazem parte do código compilado. Como Objective-C, os atributos usam a @sintaxe, mas o conjunto disponível atualmente é pequeno. Um exemplo é o @IBOutletatributo, que marca um determinado 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.

Em sistemas não Apple, o Swift não depende de um runtime Objective-C ou de outras bibliotecas de sistema Apple; um conjunto de implementações Swift "Corelib" os substitui. Estes incluem um "swift-corelibs-foundation" para substituir o Foundation Kit , um "swift-corelibs-libdispatch" para substituir o Grand Central Dispatch e um "swift-corelibs-xctest" para substituir o XCTest APIs do Xcode .

A partir de 2019, com o Xcode 11, a Apple também adicionou um novo paradigma de IU chamado SwiftUI. O SwiftUI substitui o antigo paradigma do Interface Builder por um novo paradigma de desenvolvimento declarativo.

Gerenciamento de memória

Swift usa contagem automática de referência (ARC) para gerenciar a memória . A Apple costumava exigir gerenciamento manual de memória em Objective-C, mas introduziu o ARC em 2011 para permitir uma alocação e desalocação de memória mais fáceis. Um problema com ARC é a possibilidade de criar um ciclo de referência forte , onde os objetos referenciam uns aos outros de uma forma que você pode alcançar o objeto de onde começou seguindo as referências (por exemplo, referências A B, referências B A). Isso faz com que eles vazem para a memória, pois nunca são liberados. Swift fornece as palavras-chave weake unownedpara evitar fortes ciclos de referência. Normalmente, um relacionamento pai-filho usaria uma referência forte, enquanto um pai-filho usaria qualquer uma das weakreferências, em que pais e filhos podem não ter parentesco ou unownedquando um filho sempre tem um dos pais, mas os pais podem não ter um filho. As referências fracas devem ser variáveis ​​opcionais, pois podem mudar e se tornar nil.

Um encerramento dentro de uma classe também pode criar um ciclo de referência forte, capturando referências próprias. As referências próprias a serem tratadas como fracas ou sem dono podem ser indicadas usando uma lista de captura.

Depuração e outros elementos

Um elemento-chave do sistema Swift é sua capacidade de ser depurado de forma limpa e executado dentro do ambiente de desenvolvimento, usando um loop read – eval – print (REPL), dando a ele propriedades interativas mais em comum com as habilidades de script do Python do que a programação de sistema tradicional línguas. O REPL é ainda mais aprimorado com playgrounds , visualizações interativas em execução no ambiente Xcode que respondem a alterações de código ou depurador em tempo real. Playgrounds permitem que os programadores adicionem código Swift junto com a documentação do markdown. Se algum código mudar com o tempo ou em relação a algum outro valor de entrada de intervalo, a visualização pode ser usada com o Assistente de Linha de Tempo para demonstrar a saída de forma animada. Além disso, o Xcode possui recursos de depuração para desenvolvimento em Swift, incluindo pontos de interrupção, instruções passo a passo e passo a passo, bem como análises de posicionamento de elementos de IU para desenvolvedores de aplicativos.

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

atuação

Muitos dos recursos introduzidos com o Swift têm compensações bem conhecidas de desempenho e segurança. A Apple implementou otimizações que reduzem essa sobrecarga.

Comparações com outras línguas

Swift é considerada uma linguagem de programação da família C e é semelhante a C de várias maneiras:

• A maioria dos operadores C são usados ​​em Swift, mas existem alguns novos operadores, por exemplo, para suportar operações inteiras com estouro (consulte as diferenças).
• Os colchetes são usados ​​para agrupar declarações.
• As variáveis ​​são atribuídas usando um sinal de igual , mas comparadas usando dois sinais de igual consecutivos . Um novo operador de identidade, ===, é fornecido para verificar se dois elementos de dados se referem ao mesmo objeto .
• Instruções de controle while, ife switchsão semelhantes, mas têm funções prolongado, por exemplo, uma switchque leva casos não inteiros, whilee ifapoiando correspondência de padrões e condicionalmente desempacota opcionais, forutiliza a sintaxe.for i in 1...10
• Os colchetes são usados ​​com matrizes , tanto para declará-los quanto para obter um valor em um determinado índice em um deles.

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

• Tipos numéricos básicos ( Int, UInt, Float, Double)
• Os métodos de classe são herdados, como os métodos de instância; selfem métodos de classe é a classe em que o método foi chamado.
• Semelhante for... insintaxe de enumeração.

As diferenças de Objective-C incluem:

• As ;instruções não precisam terminar com ponto e vírgula ( ), embora devam ser usados ​​para permitir mais de uma instrução em uma linha.
• Nenhum arquivo de cabeçalho.
• Usa inferência de tipo .
• Programação genérica .
• 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 operadores ) e novos operadores podem ser definidos.
• Strings são totalmente compatíveis com Unicode . A maioria dos caracteres Unicode pode ser usada em identificadores ou operadores.
• Sem tratamento de exceção . O Swift 2 apresenta um modelo de tratamento de erros diferente e incompatível.
• Vários recursos das linguagens da família C anteriores que são fáceis de usar indevidamente foram removidos:
  • Os ponteiros não são expostos por padrão. Não é necessário que o programador acompanhe e marque nomes para referência ou desreferenciação.
  • As atribuições não retornam nenhum valor. Isso evita o erro comum de gravação em i = 0vez de i == 0lançar um erro de tempo de compilação.
  • Não há necessidade de usar breakinstruções em switchblocos. Os casos individuais não passam para o próximo caso, a menos que a fallthroughinstrução seja usada.
  • Variáveis ​​e constantes são sempre inicializadas e os limites do array são sempre verificados.
  • Estouros de inteiros , que resultam em comportamento indefinido para inteiros com sinal em C, são capturados como um erro de tempo de execução em Swift. Os programadores podem optar por permitir que transborda usando os operadores aritméticos especiais &+, &-, &*, &/e &%. As propriedades mine maxsão definidas em Swift para todos os tipos de inteiros e podem ser usadas para verificar com segurança possíveis estouros, em vez de depender de constantes definidas para cada tipo em bibliotecas externas.
  • A forma de declaração única de ife while, que permite a omissão de colchetes ao redor da declaração, não é suportada.
  • A enumeração de estilo C for (int i = 0; i < c; i++), que está sujeita a erros individuais , não é suportada (do Swift 3 em diante).
  • Os operadores pré e pós- incremento e decremento ( i++, --i...) não são suportados (do Swift 3 em diante), ainda mais porque as fordeclarações de estilo C também não são suportadas do Swift 3 em diante.

Desenvolvimento e outras implementações

Como a linguagem é de código aberto, há perspectivas de que ela seja portada para a web. Alguns frameworks web já foram desenvolvidos, como o Kitura , o Perfect e o Vapor da IBM .

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

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

Ao combinar conjuntos de ferramentas do LLVM e do Workshop do Programador do Macintosh , é possível executar um subconjunto muito pequeno da linguagem no Mac OS 9 .

Veja também

• Comparação de linguagens de programação
• Objective-C
• Kotlin (linguagem de programação)
• Python (linguagem de programação)
• Nim (linguagem de programação)

Referências

links externos

• Website oficial
• Swift na Apple Developer
• O código-fonte do Swift no GitHub
• Swift do lado do servidor
• Exemplo Rápido
• Swift do lado do servidor - The Vapor Framework