Swift (linguagem de programação)

Rápido
Logotipo
ParadigmaMultiparadigma : orientado a protocolo , orientado a objetos , funcional , imperativo , estruturado em bloco , declarativo , simultâneo
Projetado porChris Lattner , Doug Gregor, John McCall, Ted Kremenek, Joe Groff e Apple Inc.
DesenvolvedorApple Inc. e colaboradores de código aberto
Apareceu pela primeira vez2 de junho de 2014 ; 9 anos atrás [2] ( 02/06/2014 )
Versão estável
5.9.2 [3]  / 11 de dezembro de 2023 ; 2 meses atrás ( 11 de dezembro de 2023 )
Versão prévia
5.9
Disciplina de digitaçãoEstático , forte , inferido
Gerenciamento de memóriaContagem automática de referência
SOSistemas operacionais da Apple ( Darwin , iOS , iPadOS , macOS , tvOS , watchOS ), Linux , Windows , Android
LicençaLicença Apache 2.0 (Swift 2.2 e posterior)
Proprietária (até Swift 2.2) [4] [5]
Extensões de nome de arquivo.rápido, .SWIFT
Local na rede Internet
  • www.swift.org
  • desenvolvedor.apple.com/swift/
Influenciado por
Objective-C , [6] Ferrugem , Haskell , Ruby , Python , C# , CLU , [7] D [8]
Influenciado
Ferrugem , [9] V (Vlang) [10]

Swift é uma linguagem de programação compilada de alto nível , de propósito geral e multiparadigma , desenvolvida pela Apple Inc. Swift compila para código de máquina, pois é um compilador baseado em LLVM . Swift foi lançado pela primeira vez em junho de 2014, [11] e o conjunto de ferramentas Swift foi enviado no Xcode desde a versão 6, lançada em 2014.

A Apple pretendia que o Swift suportasse muitos conceitos básicos associados ao Objective-C , notadamente despacho dinâmico , ligação tardia generalizada , programação extensível e recursos semelhantes, mas de uma forma "mais segura", tornando mais fácil detectar bugs de software ; Swift possui recursos que abordam alguns erros comuns de programação , como desreferenciação de ponteiro nulo , e fornece açúcar sintático para ajudar a evitar a pirâmide da destruiçã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" [12] (semelhante a traits e classes de tipo ). [13]

O Swift foi apresentado na Worldwide Developers Conference (WWDC) de 2014 da Apple. [14] Ela passou por uma atualização para a versão 1.2 durante 2014 e uma grande atualização para Swift 2 na WWDC 2015. Inicialmente uma linguagem proprietária , a versão 2.2 foi tornada software de código aberto sob a Licença Apache 2.0 em 3 de dezembro de 2015, para plataformas da Apple. e Linux . [15] [16]

Através da versão 3.0, a sintaxe do Swift passou por uma evolução significativa, com a equipe principal tornando a estabilidade da fonte um foco em versões posteriores. [17] [18] No primeiro trimestre de 2018, o Swift ultrapassou o Objective-C em popularidade medida. [19]

O Swift 4.0, lançado em 2017, introduziu diversas 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 integrada ao 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 Swift fosse incorporado aos sistemas operacionais Apple. É fonte compatível com Swift 4. [20]

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. [21]

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

A versão atual, Swift 5.9, foi lançada em setembro de 2023 e inclui um sistema macro, pacotes de parâmetros genéricos e recursos de propriedade como o novo consumeoperador. [23]

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 foi motivado pela necessidade de substituir a linguagem de programação anterior da Apple, Objective-C , que permaneceu praticamente inalterada desde o início dos anos 1980 e carecia de recursos de linguagem modernos. Swift pegou ideias de linguagem "de Objective-C , Rust , Haskell , Ruby , Python , C# , CLU e muitas outras para listar". [7] Em 2 de junho de 2014, o aplicativo Apple Worldwide Developers Conference (WWDC) se tornou o primeiro aplicativo lançado publicamente escrito com Swift. [24] 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 teria 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. [24]

A Linguagem de Programação Swift , 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. [25]

Swift atingiu a marca 1.0 em 9 de setembro de 2014, com o Gold Master do Xcode 6.0 para iOS . [26] Swift 1.1 foi lançado em 22 de outubro de 2014, juntamente com o lançamento do Xcode 6.1. [27] Swift 1.2 foi lançado em 8 de abril de 2015, junto com o Xcode 6.3. [28] O Swift 2.0 foi anunciado na WWDC 2015 e disponibilizado para publicação de aplicativos na App Store em 21 de setembro de 2015. [29] O Swift 3.0 foi lançado em 13 de setembro de 2016. [30] O Swift 4.0 foi lançado em setembro. 19 de março de 2017. [31] Swift 4.1 foi lançado em 29 de março de 2018. [32]

Swift ganhou o primeiro lugar como linguagem de programação mais amada na Stack Overflow Developer Survey 2015 [33] e o segundo lugar em 2016. [34]

Em 3 de dezembro de 2015, a linguagem Swift, bibliotecas de suporte, depurador e gerenciador de pacotes foram de código aberto sob a licença Apache 2.0 com uma exceção de biblioteca de tempo de execução, [35] e 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 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. [36] [37] [38] O Swift Sandbox foi descontinuado em janeiro de 2018. [39]

Durante a WWDC 2016 , a Apple anunciou um aplicativo exclusivo para iPad , chamado Swift Playgrounds , destinado a ensinar as pessoas a codificar em Swift. O aplicativo é apresentado em uma interface 3D semelhante a um videogame que fornece feedback quando as linhas de código são colocadas em uma determinada ordem e executadas. [40] [41] [42]

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. [43] [44]

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

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

Plataformas

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

Um aspecto fundamental do design do Swift é sua capacidade de interoperar com o enorme corpo de código Objective-C existente desenvolvido para produtos Apple nas décadas anteriores, como Cocoa e as estruturas Cocoa Touch . Nas plataformas Apple, [51] ele se vincula à biblioteca de tempo de execução Objective-C , que permite que códigos C , Objective-C , C++ e Swift sejam executados dentro de um programa. [52]

Histórico de versões

Versão Data de lançamento Mac OS Linux janelas
Rápido 1.0 9 de setembro de 2014 Sim Não Não
Rápido 1.1 22 de outubro de 2014 Sim Não Não
Rápido 1.2 8 de abril de 2015 Sim Não Não
Rápido 2.0 21 de setembro de 2015 Sim Não Não
Rápido 2.1 20 de outubro de 2015 Sim Não Não
Rápido 2.2 21 de março de 2016 Sim Sim Não
Rápido 2.2.1 3 de maio de 2016 Sim Sim Não
Rápido 3.0 13 de setembro de 2016 Sim Sim Não
Rápido 3.0.1 28 de outubro de 2016 Sim Sim Não
Rápido 3.0.2 13 de dezembro de 2016 Sim Sim Não
Rápido 3.1 27 de março de 2017 Sim Sim Não
Rápido 3.1.1 21 de abril de 2017 Sim Sim Não
Rápido 4.0 19 de setembro de 2017 Sim Sim Não
Rápido 4.0.2 1º de novembro de 2017 Sim Sim Não
Rápido 4.0.3 5 de dezembro de 2017 Sim Sim Não
Rápido 4.1 29 de março de 2018 Sim Sim Não
Rápido 4.1.1 4 de maio de 2018 Não Sim Não
Rápido 4.1.2 31 de maio de 2018 Sim Sim Não
Rápido 4.1.3 27 de julho de 2018 Não Sim Não
Rápido 4.2 17 de setembro de 2018 Sim Sim Não
Rápido 4.2.1 30 de outubro de 2018 Sim Sim Não
Rápido 4.2.2 4 de fevereiro de 2019 Não Sim Não
Rápido 4.2.3 28 de fevereiro de 2019 Não Sim Não
Rápido 4.2.4 29 de março de 2019 Não Sim Não
Rápido 5.0 [53] 25 de março de 2019 Sim Sim Não
Rápido 5.0.1 18 de abril de 2019 Sim Sim Não
Rápido 5.0.2 15 de julho de 2019 Não Sim Não
Rápido 5.0.3 30 de agosto de 2019 Não Sim Não
Rápido 5.1 10 de setembro de 2019 Sim Sim Não
Rápido 5.1.1 11 de outubro de 2019 Não Sim Não
Rápido 5.1.2 7 de novembro de 2019 Sim Sim Não
Rápido 5.1.3 13 de dezembro de 2019 Sim Sim Não
Rápido 5.1.4 31 de janeiro de 2020 Não Sim Não
Rápido 5.1.5 9 de março de 2020 Não Sim Não
Rápido 5.2 24 de março de 2020 Sim Sim Não
Rápido 5.2.1 30 de março de 2020 Não Sim Não
Rápido 5.2.2 15 de abril de 2020 Sim Sim Não
Rápido 5.2.3 29 de abril de 2020 Não Sim Não
Rápido 5.2.4 20 de maio de 2020 Sim Sim Não
Rápido 5.2.5 5 de agosto de 2020 Não Sim Não
Rápido 5.3 16 de setembro de 2020 Sim Sim Sim [54]
Rápido 5.3.1 13 de novembro de 2020 Sim Sim Sim
Rápido 5.3.2 15 de dezembro de 2020 Sim Sim Sim
Rápido 5.3.3 25 de janeiro de 2021 Não Sim Sim
Rápido 5.4 [55] 26 de abril de 2021 Sim Sim Sim
Rápido 5.4.1 25 de maio de 2021 Não Sim Sim
Rápido 5.4.2 28 de junho de 2021 Sim Sim Sim
Rápido 5.4.3 9 de setembro de 2021 Não Sim Sim
Rápido 5.5 20 de setembro de 2021 Sim Sim Sim
Rápido 5.5.1 27 de outubro de 2021 Sim Sim Sim
Rápido 5.5.2 14 de dezembro de 2021 Sim Sim Sim
Rápido 5.5.3 9 de fevereiro de 2022 Não Sim Sim
Rápido 5.6 [56] 14 de março de 2022 Sim Sim Sim
Rápido 5.6.1 [57] 9 de abril de 2022 Não Sim Sim
Rápido 5.6.2 [58] 15 de junho de 2022 Não Sim Sim
Rápido 5.6.3 [59] 2 de setembro de 2022 Não Sim Sim
Rápido 5.7 [60] 12 de setembro de 2022 Sim Sim Sim
Rápido 5.7.1 [61] 1º de novembro de 2022 Sim Sim Sim
Rápido 5.8 [62] 30 de março de 2023 Sim Sim Sim
Rápido 5.8.1 [63] 1º de junho de 2023 Sim Sim Sim
Rápido 5.9 [64] 18 de setembro de 2023 Sim Sim Sim
Rápido 5.9.1 [65] 19 de outubro de 2023 Sim Sim Sim
Rápido 5.9.2 [66] 11 de dezembro de 2023 Sim Sim Sim

Características

Swift é uma linguagem de programação de uso geral que emprega conceitos modernos da teoria da linguagem de programação e se esforça para apresentar uma sintaxe simples, mas poderosa. Swift incorpora inovações e convenções de várias linguagens de programação, com notável inspiração em Objective-C, que substituiu como principal linguagem de desenvolvimento nas plataformas Apple.

O Swift foi projetado para ser seguro e amigável para novos programadores, sem sacrificar a velocidade. Por padrão, o Swift gerencia toda a memória automaticamente e garante que as variáveis ​​sejam sempre inicializadas antes do uso. Os acessos ao array são verificados quanto a erros fora dos limites e as operações inteiras são verificadas quanto a estouro. Os nomes dos parâmetros permitem a criação de APIs claras. Os protocolos definem interfaces que os tipos podem adotar, enquanto as extensões permitem que os desenvolvedores adicionem mais funções aos tipos existentes. Swift permite programação orientada a objetos com suporte para classes , subtipos e substituição de métodos . Os opcionais permitem que valores nulos sejam tratados de forma explícita e segura. Programas simultâneos podem ser escritos usando sintaxe assíncrona/aguardada e os atores isolam o estado mutável compartilhado para eliminar corridas de dados. [67] [68]

Sintaxe básica

A sintaxe do Swift é semelhante às linguagens do estilo C. O código começa a ser executado no escopo global por padrão. [69] Alternativamente, o atributo pode ser aplicado a uma estrutura, classe ou declaração de enumeração para indicar que contém o ponto de entrada do programa. [70]@main

" Olá , mundo!" programa é:

print ( "Olá, mundo!" )

A função aqui utilizada está incluída na biblioteca padrão do Swift, que está disponível para todos os programas sem a necessidade de importar módulos externos. As instruções em Swift não precisam terminar com ponto e vírgula, no entanto, o ponto e vírgula é necessário para separar várias instruções escritas na mesma linha. Os comentários de linha única começam e continuam até o final da linha atual. Comentários multilinhas são contidos por caracteres e . As constantes são declaradas com a palavra-chave e as variáveis ​​com a palavra-chave. Os valores devem ser inicializados antes de serem lidos. Os valores podem inferir seu tipo com base no tipo do valor inicial fornecido. Se o valor inicial for definido após a declaração do valor, um tipo deverá ser declarado explicitamente. [69]print(_:separator:terminator:)///**/letvar

let  highScoreThreshold  =  1000  // Uma constante com tipo Int. O tipo foi inferido com base no valor fornecido.

var  currentScore  =  980  // Uma variável com tipo Int.
currentScore  =  1200  // O valor das variáveis ​​pode mudar com o tempo.

let  playerMessage :  String  // Uma constante com tipo explícito String.
if  PontuaçãoAtual  >  highScoreThreshold  {
    playerMessage  =  "Você é um jogador top!"
}  outro  {
    playerMessage  =  "Melhor sorte da próxima vez."
}

print ( playerMessage )  // Imprime "Você é um jogador top!"

O fluxo de controle no Swift é gerenciado com instruções if-else , guard e switch , juntamente com loops while e for-in . As instruções If recebem um parâmetro booleano e executam o corpo da instrução if se a condição for verdadeira, caso contrário, executa o elsecorpo opcional. a sintaxe fornece açúcar sintático para verificar a existência de um valor opcional e desembrulhá-lo ao mesmo tempo.if-let

deixe  algumNúmero  =  42
if  someNumber  %  2  ==  0  {  // Use o operador de resto para encontrar o resto de someNumber dividido por 2.
    print ( " \( someNumber ) é par." )
}  outro {
   print ( " \( someNumber ) é ímpar." )
}

// Imprime "42 é par."

As funções são definidas com a funcpalavra-chave. Os parâmetros de função podem ter nomes que permitem que as chamadas de função sejam lidas como frases. Um sublinhado antes do nome do parâmetro permite que o rótulo do argumento seja omitido do site de chamada. Tuplas podem ser usadas por funções para retornar vários dados de uma vez.

func  constructGreeting ( para  nome :  String )  ->  String  {
    retorne  "Olá \( nome ) !"
}

deixe  saudação  =  constructGreeting ( para :  "Craig" )

print ( saudação )  // Imprime "Olá Craig!"

Funções e funções anônimas conhecidas como encerramentos podem ser atribuídas a propriedades e passadas pelo programa como qualquer outro valor.

func  divideByTwo ( _aNum  : Int ) - > Int {    
    retornar  umNum  /  2
}

func  multiplicarByTwo ( _aNum  : Int ) - > Int {    
    retornar  umNum  *  2
}

deixe  mathOperation  =  multiplicarByTwo

print ( mathOperation ( 21 ))  // Imprime "42"

guardas instruções exigem que a condição fornecida seja verdadeira antes de continuar após a guardinstrução, caso contrário, o corpo da elsecláusula fornecida será executado. A elsecláusula deve sair do controle do bloco de código no qual a guardinstrução aparece. guarddeclarações são úteis para garantir que certos requisitos sejam atendidos antes de continuar com a execução do programa. Em particular, eles podem ser usados ​​para criar uma versão desembrulhada de um valor opcional que é garantido como não nulo para o restante do escopo envolvente.

func  divide ( numerador :  Int ?,  byDenominator  denominador :  Int )  ->  Int ?  {
     denominador  de guarda ! =  0  else  {
        print ( "Não é possível dividir por 0." )
        retorno  nulo
    }
    
    guarda  deixe  o numerador  else  {
        print ( "O numerador fornecido é nulo." )
        retorno  nulo
    }
    
    retornar  numerador  /  denominador
}

deixe  resultado  =  dividir ( numerador :  3 ,  porDenominador :  0 )
print ( "O resultado da divisão é: \( resultado ) " )

// Impressões:
// "Não é possível dividir por 0."
// "O resultado da divisão é: nulo."

switchinstruções comparam um valor com vários valores potenciais e, em seguida, executam um bloco de código associado. switchas instruções devem ser exaustivas, incluindo casos para todos os valores possíveis ou incluindo um defaultcaso que é executado quando o valor fornecido não corresponde a nenhum dos outros casos. switchos casos não falham implicitamente, embora possam fazê-lo explicitamente com a fallthroughpalavra-chave. A correspondência de padrões pode ser usada de várias maneiras dentro de switchinstruções. Aqui está um exemplo de um número inteiro sendo comparado com vários intervalos potenciais:

deixe  algumNúmero  =  42

mudar  algum número  {
caso  ..< 0 : 
    print ( " \( algumNúmero ) negativo." )
caso  0 : 
    print ( " \( algumNúmero ) é 0." )
caso  1. .. 9 :
    print ( " \( someNumber ) maior que 0, mas menor que 10." )
padrão : 
    print ( " \( algumNumber ) é maior que 9." )
}

// Imprime "42 é maior que 9."

for-inloops iteram sobre uma sequência de valores:

deixe  nomes  =  [ "Will" ,  "Anna" ,  "Bart" ]
para  nome  em  nomes  {
    imprimir ( nome )
}
// Impressões:
// Vai
//Ana
// Barto

whileos loops iteram enquanto a condição booleana fornecida for avaliada como true:

// Some todos os números de 1 a 5.
var  eu  =  1
var  resultado  =  0

while  i  <=  5  {  // O loop executa seu corpo enquanto i for menor ou igual a 5.  
    result  +=  i  // Adiciona i ao resultado atual.
    i  +=  1  // Incrementa i em 1.
}

print ( resultado )  // Imprime "15"

Suporte de fechamento

Swift suporta encerramentos , que são blocos independentes de funcionalidade que podem ser transmitidos e usados ​​em código, [71] e também podem ser usados ​​como funções anônimas . aqui estão alguns exemplos:

// O tipo de encerramento, definido pelos seus valores de entrada e saída, pode ser especificado fora do encerramento:
deixe  encerramento1 :  ( Int ,  Int )  ->  Int  =  {  arg1 ,  arg2  em
    retornar  arg1  +  arg2
}

// …ou dentro dele:
deixe  encerramento2  =  {  ( arg1 :  Int ,  arg2 :  Int )  ->  Int  in
    retornar  arg1  +  arg2
}

// Na maioria dos casos, o tipo de retorno do encerramento pode ser inferido automaticamente pelo compilador.
deixe  encerramento3  =  {  arg1 :  Int ,  arg2 :  Int  em
    retornar  arg1  +  arg2
}

Os encerramentos podem ser atribuídos a variáveis ​​e constantes e podem ser passados ​​para outras funções ou encerramentos como parâmetros. Os fechamentos de expressão única podem eliminar a returnpalavra-chave.

Swift também possui uma sintaxe de encerramento final, que permite que o encerramento seja escrito após o final da chamada de função, em vez de dentro da lista de parâmetros da função. Os parênteses podem ser totalmente omitidos se o fechamento for o único parâmetro da função:

// Esta função recebe um encerramento que não recebe parâmetros de entrada e retorna um número inteiro,
// avalia e usa o valor de retorno do encerramento (um Int) como valor de retorno da função.
func  foo ( barra de fechamento  : () -> Int ) -> Int {      
     barra de retorno ()
}

// Sem sintaxe de encerramento final:
foo ( fechamento :  {  retornar  1  })

// Com sintaxe de encerramento final e retorno implícito:
foo  {1}  _  _

A partir da versão 5.3, o Swift suporta vários fechamentos finais: [72]

// Esta função passa o retorno do primeiro encerramento como parâmetro do segundo, 
// e retorna o resultado do segundo encerramento: 
func  foo ( bar :  ()  ->  Int ,  baz :  ( Int )  ->  Int )  ->  Int  { 
    retornar  baz ( barra ()) 
}

// Sem fechamentos finais: 
foo ( bar :  {  return  1  },  baz :  {  x  in  return  x  +  1  })

// Com 1 encerramento final: 
foo ( bar :  {  return  1  })  {  x  in  return  x  +  1  }

// Com 2 encerramentos finais (apenas o nome do argumento do primeiro encerramento é omitido): 
foo  {  return  1  }  baz :  {  x  in  return  x  +  1  }

O Swift fornecerá nomes abreviados de argumentos para fechamentos in-line, eliminando a necessidade de nomear explicitamente todos os parâmetros de fechamentos. [73] Os argumentos podem ser referidos com os nomes $0, $1, $2 e assim por diante:

deixe  nomes  =  [ "Josephine" ,  "Steve" ,  "Chris" ,  "Barbara" ]

// filter chama o encerramento fornecido para cada valor em nomes. 
// Valores com contagem de caracteres menor que 6 são mantidos, os demais são eliminados. 
deixe  shortNames  =  nomes . filtro  {  $0 . contagem  <  6  }

print ( shortNames )  // Imprime "["Steve", "Chris"]"

Os fechamentos podem capturar valores do escopo circundante. O fechamento se referirá a este valor capturado enquanto existir o fechamento:

func  makeMultiplier ( withMultiple  multiple :  Int )  ->  ( Int )  ->  ( Int )  { 
    // Cria e retorna um encerramento que recebe um Int e retorna a entrada multiplicada pelo valor de multiple. 
    return  { 
        $0  *  múltiplo 
    } 
}

let  multiplicador  =  makeMultiplier ( withMultiple :  3 ) 
print ( multiplier ( 3 ))  // Imprime "9" 
print ( multiplier ( 10 ))  // Imprime "30"

Suporte de corda

StringA biblioteca padrão Swift inclui tipos e compatíveis com Unicode Character. Os valores de string podem ser inicializados com um literal String, uma sequência de caracteres entre aspas duplas. Strings podem ser concatenadas com o +operador:

var  someString  =  "Olá," 
someString  +=  "mundo!"

A interpolação de strings permite a criação de uma nova string a partir de outros valores e expressões. Valores escritos entre parênteses precedidos por a \serão inseridos na string literal anexa: [74]

var  currentScore  =  980 
print ( "Sua pontuação é \( currentScore ) . ." )

// Imprime "Sua pontuação é 980."

Um loop for-in pode ser usado para iterar sobre os caracteres contidos em uma string:

para  caractere  em  "Swift"  { 
    print ( character ) 
} 
// S 
// w 
// i 
// f 
// t

Quando a estrutura Foundation é importada, o Swift faz uma ponte invisível entre o tipo String e NSString, a classe String comumente usada em Objective-C.

Objetos chamáveis

Em Swift, objetos que podem ser chamados são definidos usando callAsFunction. [75]

struct  CallableStruct  { 
    var  valor :  Int 
    func  callAsFunction ( _número  : Int , escala : Int ) { print ( escala * ( número + valor ) ) } } let callable = CallableStruct ( valor : 100 ) chamável ( 4 , escala : 2 ) chamável . callAsFunction ( 4 , escala : 2 ) // Ambas as chamadas de função imprimem 208.    
            
    

    
  
  

Controle de acesso

Swift suporta cinco níveis de controle de acesso para símbolos: open, public, internal, fileprivatee private. Ao contrário de muitas linguagens orientadas a objetos, esses controles de acesso ignoram hierarquias de herança : privateindica que um símbolo é acessível apenas no escopo imediato , fileprivateindica que é acessível apenas de dentro do arquivo, internalindica que é acessível dentro do módulo que o 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 subclassificada fora do módulo. [76]

Opcionais e encadeamento

Um recurso importante em Swift são os tipos de opções , 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 específico ou a nenhum valor. Isso implica que tipos não opcionais não podem resultar em erro de ponteiro nulo ; o compilador pode garantir que isso não seja possível.

Tipos opcionais são criados com o Optionalenum. Para criar um número inteiro anulável, seria usada uma declaração semelhante a var optionalInteger: Optional<Int>. Assim como em C#, [77] 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?. [78] Variáveis ​​ou constantes marcadas como opcionais possuem 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 primeiro é do tipo String, enquanto o último é um tipo Optionalque pode ter algum Stringvalor.

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:

deixe  meuValor  =  anOptionalInstance !. algum método ()

Nesse caso, o !operador desembrulha 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, encerrando o programa. Isso é conhecido como desembrulhamento forçado. Os opcionais podem ser desembrulhados com segurança usando o encadeamento opcional que primeiro testa se a instância é nula e, em seguida, desembrulha-a se não for nula:

deixe  meuValor  =  anOptionalInstance ?. algum método ()

Neste caso o tempo de execução chama someMethodapenas se anOptionalInstancenão for nulo, suprimindo o erro. A ?deve ser colocado após cada propriedade opcional. Se alguma dessas propriedades for nula, toda a expressão será avaliada como nula. A origem do termo encadeamento vem do caso mais comum em que várias chamadas/getters de método são encadeadas. Por exemplo:

deixe  aTenant  =  aBuilding . inquilinoList [ 5 ] 
deixe  seuLease  =  aTenant . leaseDetails 
letleaseStart  = theirLease ?. _  data de início 

pode ser reduzido a:

deixe  arrendamentoStart  =  aBuilding . lista de inquilinos [ 5 ]. detalhes do arrendamento ?. data de início

O uso de opcionais pelo Swift permite que o compilador use o despacho estático porque a ação de desempacotamento é chamada em uma instância definida (o wrapper), em vez de ocorrer em um sistema de despacho em tempo de execução.

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 que tenha uma cópia. Por outro lado, tipos básicos como números inteiros e valores de ponto flutuante são representados diretamente; o identificador contém os dados, não um ponteiro para eles, e esses dados são passados ​​diretamente para os 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 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. Nestes 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, têm o mesmo tamanho dos ponteiros (normalmente, ambos são uma palavra ), portanto, não há vantagem em passar um ponteiro em vez de passar o valor.

Swift oferece suporte integrado para objetos usando semântica de 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. As estruturas não suportam herança, entretanto. [79]

O programador é livre para escolher qual semântica é mais apropriada para cada estrutura de dados da aplicação. Estruturas maiores, como janelas, seriam definidas como classes, permitindo que fossem transmitidas 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 indireção ou contagem de referência. 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. [79] O uso de tipos de valor também pode resultar em melhorias significativas de desempenho em aplicativos de usuário. [80]

Array, Dictionarye Settodos utilizam cópia na gravação para que seus dados sejam copiados somente se e quando o programa tentar alterar um valor neles. Isso significa que os vários acessadores possuem 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 é imposta pela cópia na gravação somente se necessário. [81]

Extensões

As extensões adicionam novas funcionalidades a um tipo existente, sem a necessidade de subclassificar ou mesmo ter acesso ao código-fonte original. As extensões podem adicionar novos métodos, inicializadores, propriedades computadas, subscritos e conformidades de protocolo. [82] Um exemplo pode ser adicionar um corretor ortográfico ao Stringtipo base, o que significa que todas as instâncias do Stringprograma ganham a capacidade de verificação ortográfica. O sistema também é amplamente utilizado como técnica organizacional, permitindo que códigos relacionados sejam reunidos em extensões semelhantes a bibliotecas.

As extensões são declaradas com a extensionpalavra-chave.

estrutura  retângulo  {
    deixe  largura :  Duplo
    deixe  altura :  Duplo
}

extensão  Retângulo  {
     área var :  Duplo  {
         altura  de retorno *  largura
    }
}

Programação orientada a protocolo

Os protocolos prometem que um tipo específico implementa um conjunto de métodos ou propriedades, o que significa que outras instâncias no sistema podem chamar esses métodos em qualquer instância que implemente esse protocolo. Isso é frequentemente usado em linguagens modernas orientadas a objetos como um substituto para herança múltipla , embora os conjuntos de recursos não sejam totalmente semelhantes.

No Objective-C, 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. [83] Swift adiciona a capacidade de adicionar esses métodos usando extensões e de usar programação genérica (genéricos) para implementá-los. Combinados, eles permitem que os protocolos sejam escritos uma vez e suportam 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. [84]

Por exemplo, um protocolo pode ser declarado chamado Printable, o que garante que as instâncias em conformidade com o protocolo implementem uma descriptionpropriedade e um printDetails()requisito de método:

// Defina um protocolo chamado Printable 
protocol  Printable  { 
    var  description :  String  {  get  }  // Um ​​requisito de propriedade somente leitura 
    func  printDetails ()  // Um ​​requisito de método 
}

Este protocolo agora pode ser adotado por outros tipos:

// Adote o protocolo Printable em uma classe 
class  MyClass :  Printable  { 
    var  description :  String  { 
        return  "An instance of MyClass" 
    }

    func  printDetails ()  { 
        imprimir ( descrição ) 
    } 
}

Extensões podem ser usadas para adicionar conformidade de protocolo aos tipos. Os próprios protocolos também podem ser estendidos para fornecer implementações padrão de seus requisitos. Os adotantes podem definir suas próprias implementações ou podem usar a implementação padrão:

extension  Printable  {  // Todas as instâncias Printable receberão esta implementação ou poderão definir a sua própria. 
    func  printDetails ()  { 
        imprimir ( descrição ) 
    } 
}

// Bool agora está em conformidade com Printable e herda a implementação printDetails() acima. 
extensão  Bool :  Imprimível  { 
    var  descrição :  String  { 
        return  "Uma instância de Bool com valor: \( 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:

func  getSomethingPrintable ()  ->  qualquer  imprimível  { 
    return  true 
}

var  someSortOfPrintableInstance  =  getSomethingPrintable () 
imprimir ( someSortOfPrintableInstance . descrição )

// Imprime "Uma instância de Bool com valor: true"

Não importa o tipo concreto someSortOfPrintableInstance, o compilador garantirá que ele esteja em conformidade com o protocolo e, portanto, esse código seja seguro. Essa sintaxe também significa que as coleções também podem ser baseadas em protocolos, como let printableArray = [any Printable].

Tanto as extensões quanto os protocolos são amplamente usados ​​na biblioteca padrão do Swift; no Swift 5.9, aproximadamente 1,2% de todos os símbolos da biblioteca padrão eram protocolos e outros 12,3% eram requisitos de protocolo ou implementações padrão. [85] Por exemplo, Swift usa extensões para adicionar o Equatableprotocolo a muitos de seus tipos básicos, como Strings e Arrays, permitindo que sejam comparados com o ==operador. O Equatableprotocolo também define esta implementação padrão:

func  !=< T  :  Equatável >( lhs :  T ,  rhs :  T )  ->  Bool

Esta função define um método que funciona em qualquer instância em conformidade com Equatable, fornecendo um operador diferente . Qualquer instância, classe ou estrutura, ganha automaticamente essa implementação simplesmente por estar em conformidade com Equatable. [86]

Protocolos, extensões e genéricos podem ser combinados para criar APIs sofisticadas. Por exemplo, as restrições permitem que os tipos adotem protocolos ou métodos condicionalmente com base nas características do tipo que os adota. Um caso de uso comum pode ser adicionar um método aos tipos de coleção somente quando os elementos contidos na coleção são Equatable:

extensão  Array  onde  Elemento :  Equatável  {

    // allEqual estará disponível apenas em instâncias de Array que contenham elementos Equatable. 
    func  allEqual ()  ->  Bool  { 
        para  elemento  em  self  { 
            if  element  !=  self . primeiro  { 
                retornar  falso 
            } 
        } 
        retornar  verdadeiro 
    } 
}

Simultaneidade

O Swift 5.5 introduziu simultaneidade estruturada na linguagem. [87] A simultaneidade estruturada usa sintaxe Async/await semelhante a Kotlin, JavaScript e Rust. Uma função assíncrona é definida com a asyncpalavra-chave após a lista de parâmetros. Ao chamar uma função assíncrona, a awaitpalavra-chave deve ser escrita antes da função para indicar que a execução será potencialmente suspensa durante a chamada da função. Enquanto uma função está suspensa, o programa pode executar alguma outra função simultânea no mesmo programa. Essa sintaxe permite que os programas identifiquem claramente possíveis pontos de suspensão e evitem uma versão da Pirâmide da Perdição (programação) causada pelo uso anteriormente difundido de retornos de chamada de fechamento. [88]

func  downloadText ( nome :  String )  async  ->  String  { 
    let  result  =  // ... algum código de download assíncrono ... 
    return  result 
}

deixe  texto  =  aguarde  downloadText ( "text1" )

A async letsintaxe permite que várias funções sejam executadas em paralelo. awaité novamente usado para marcar o ponto em que o programa será suspenso para aguardar a conclusão das asyncfunções chamadas anteriormente.

// Cada uma dessas chamadas para downloadText será executada em paralelo. 
assíncrono  let  text1  =  downloadText ( nome :  "text1" ) 
async  let  text2  =  downloadText ( nome :  "text2" ) 
assíncrono  let  text3  =  downloadText ( nome :  "text3" )

let  textToPrint  =  await  [ text1 ,  text2 ,  text3 ]  // Suspende até que todas as três chamadas downloadText tenham retornado. 
imprimir ( textToPrint )

Tarefas e TaskGroups podem ser criados explicitamente para criar um número dinâmico de tarefas filhas durante o tempo de execução:

deixe  taskHandle  =  Tarefa  { 
    aguarde  downloadText ( nome :  "someText" ) 
}

deixe  resultado  =  aguarde  taskHandle . valor

Swift usa o modelo Actor para isolar o estado mutável, permitindo que diferentes tarefas alterem o estado compartilhado de maneira segura. Os atores são declarados com a actorpalavra-chave e são tipos de referência, como classes. Apenas uma tarefa pode acessar o estado mutável de um ator ao mesmo tempo. Os atores podem acessar e alterar livremente seu próprio estado interno, mas o código executado em tarefas separadas deve marcar cada acesso com a awaitpalavra-chave para indicar que o código pode ser suspenso até que outras tarefas terminem de acessar o estado do ator.

 diretório  do ator { 
    var  nomes :  [ String ]  =  []
    
    func  add ( nome :  String )  { 
        nomes . acrescentar ( nome ) 
    } 
}

deixe  diretório  =  Diretório ()

// O código é suspenso até que outras tarefas terminem de acessar o ator. 
aguardar  diretório . add ( nome :  "Tucker" ) 
imprimir ( aguardar  diretório . nomes )

Bibliotecas, tempo de execução, desenvolvimento

Nos 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 . [89] Código Swift e Objective-C podem ser usados ​​em um programa e, por extensão, C e C++ também. A partir do Swift 5.9, o código C++ pode ser usado diretamente do código Swift. [90] No caso do Objective-C, Swift tem acesso considerável ao modelo de objeto e pode ser usado para subclassificar, estender e usar o código Objective-C para fornecer suporte ao protocolo. [91] O inverso não é verdadeiro: uma classe Swift não pode ser subclassificada em Objective-C. [92]

Para auxiliar no desenvolvimento de tais programas e na reutilização do código existente, o Xcode 6 e superior oferece um sistema semiautomático que cria 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 necessários ao 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 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 declarações Objective-C dos símbolos Swift do projeto. Por exemplo, um arquivo Objective-C em um projeto misto chamado "MyApp" poderia 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 através deste mecanismo - o uso de recursos específicos do Swift, como tipos genéricos, tipos opcionais não-objeto, enumerações sofisticadas ou até mesmo identificadores Unicode podem tornar um símbolo inacessível a partir do Objective-C. [93]

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

Em sistemas que não são da Apple, o Swift não depende de um tempo de execução Objective-C ou de outras bibliotecas de sistema da Apple; um conjunto de implementações Swift "Corelib" os substitui. Isso inclui 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 . [94]

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

Gerenciamento de memória

Swift usa Contagem Automática de Referência (ARC) para gerenciar memória . Cada instância de uma classe ou encerramento mantém uma contagem de referências que mantém um registro contínuo do número de referências que o programa está mantendo. Quando essa contagem chega a 0, a instância é desalocada. Essa desalocação automática elimina a necessidade de um coletor de lixo, pois as instâncias são desalocadas assim que não são mais necessárias.

Um ciclo de referência forte pode ocorrer se duas instâncias fizerem referência mútua forte (por exemplo, A faz referência a B, B faz referência a A). Como nenhuma contagem de referência de instâncias pode chegar a zero, nenhuma delas é desalocada, resultando em vazamento de memória . Swift fornece as palavras-chave weake unownedevita ciclos de referência fortes. Essas palavras-chave permitem que uma instância seja referenciada sem aumentar sua contagem de referências. weakas referências devem ser variáveis ​​​​opcionais, pois podem mudar e se tornar nil. [96] A tentativa de acessar um unownedvalor que já foi desalocado resulta em um erro de tempo de execução.

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

classe  Pessoa  {
    deixe  o nome :  String
    fraco  var  home :  Home ?  // Definido como uma referência fraca para quebrar o ciclo de referência. referências fracas não aumentam a contagem de referências da instância à qual se referem.
    
    init ( nome :  String )  {
        auto . nome  =  nome
    }
    
    deinit  {  print ( "Desinicializado \( nome ) " )  }
}

classe  Início  {
    deixe  o endereço :  String
    var  proprietário :  Pessoa ?
    
    init ( endereço :  String ,  proprietário :  Pessoa ?)  {
        auto . endereço  =  endereço
        auto . proprietário  =  proprietário
    }
    
    deinit  {  print ( "Desinicializado \( endereço ) " )  }
}

var  stacy :  Pessoa ?  =  Pessoa ( nome :  "Stacy" )
var  house21b :  Casa ?  =  Residência ( endereço :  "21b Baker Street" ,  proprietária :  stacy )

stacy ?. home  =  house21b  // stacy e house42b agora se referem um ao outro.

stacy  =  nil  // A contagem de referência para stacy agora é 1, porque house21b ainda mantém uma referência para ela.
house21b  =  nil  // a contagem de referência de house21b cai para 0, o que por sua vez reduz a contagem de stacy para 0 porque house21b foi a última instância com uma referência forte a stacy.

// Impressões:
// 21b Baker Street desinicializado
// Stacy desinicializada

Depuração

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-lhe propriedades interativas mais em comum com as habilidades de script do Python do que com a programação do sistema tradicional. línguas. O REPL é aprimorado ainda mais com playgrounds , visualizações interativas executadas no ambiente Xcode ou aplicativo Playgrounds que respondem a alterações de código ou depurador dinamicamente. [97] Playgrounds permitem que os programadores adicionem código Swift junto com documentação de markdown. Os programadores podem percorrer o código e adicionar pontos de interrupção usando LLDB em um console ou em um IDE como o Xcode.

Comparações com outras línguas

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

  • A maioria dos operadores em C também aparece em Swift, embora alguns operadores como +tenham comportamento ligeiramente diferente. Por exemplo, em Swift, +intercepta no overflow, enquanto &+é usado para denotar o comportamento semelhante ao C de encapsulamento no overflow.
  • Chaves são usadas para agrupar instruçõ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 .
  • As instruções de controle while, ife switchsão semelhantes, mas possuem funções estendidas, por exemplo, a switchque aceita casos não inteiros whilee ifsuporta correspondência de padrões e desembrulhamento condicional de opcionais, forusa a sintaxe.for i in 1...10
  • Colchetes são usados ​​com arrays , tanto para declará-los quanto para obter um valor em um determinado índice em um deles.

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 métodos de instância; selfem métodos de classe é a classe na qual o método foi chamado.
  • Semelhante for... insintaxe de enumeração.

As diferenças do Objective-C incluem:

  • As instruções não precisam terminar com ponto e vírgula ( ;), embora estes 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 suportam totalmente Unicode . A maioria dos caracteres Unicode pode ser usada em identificadores ou operadores.
  • Sem tratamento de exceções . Swift 2 introduz um modelo de tratamento de erros diferente e incompatível. [98]
  • Vários recursos de linguagens anteriores da família C que são fáceis de usar indevidamente foram removidos:
    • Os ponteiros não são expostos por padrão. Não há necessidade de o programador acompanhar e marcar nomes para referência ou desreferência.
    • As atribuições não retornam nenhum valor. Isso evita o erro comum de gravação i = 0em vez de i == 0gerar um erro em tempo de compilação.
    • Não há necessidade de usar breakinstruções em switchblocos. Os casos individuais não passam para o caso seguinte, a menos que a fallthroughdeclaraçã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 assinados em C, são capturados como um erro de tempo de execução em Swift. Os programadores podem optar por permitir overflows usando os operadores aritméticos especiais &+, &-, e . As propriedades e são definidas em Swift para todos os tipos inteiros e podem ser usadas para verificar com segurança possíveis overflows, em vez de depender de constantes definidas para cada tipo em bibliotecas externas.&*&/&%minmax
    • A forma de instrução única ife while, que permite a omissão de colchetes ao redor da instrução, não é suportada.
    • A enumeração no estilo C for (int i = 0; i < c; i++), que é propensa a erros off-by-one , não é suportada (do Swift 3 em diante). [99]
    • Os operadores de pré e pós-incremento e decremento ( i++, --i...) não são suportados (do Swift 3 em diante), ainda mais porque foras instruções no estilo C também não são suportadas do Swift 3 em diante. [100]

Desenvolvimento e outras implementações

Como o Swift pode ser executado no Linux, às vezes também é usado como linguagem do lado do servidor. [101] Algumas estruturas web já foram desenvolvidas, como Kitura da IBM (agora descontinuado), Perfect e Vapor .

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

Uma segunda implementação gratuita do Swift voltada para Cocoa , a Common Language Infrastructure da Microsoft ( .NET Framework , agora .NET ) e as plataformas Java e Android existe como parte do Elements Compiler da RemObjects Software . [104]

Subconjuntos do Swift foram portados para plataformas adicionais, como Arduino [105] e Mac OS 9 . [106]

Veja também

Referências

  1. ^ Patente dos EUA no. 9329844
  2. ^ "Swift atingiu 1,0" . Maçã. 9 de setembro de 2014 . Recuperado em 8 de março de 2015 .
  3. ^ "Lançamento 5.9.2" . 11 de dezembro de 2023 . Recuperado em 19 de dezembro de 2023 .
  4. ^ "Rápido, objetivamente" . Swift é proprietário e fechado: é totalmente controlado pela Apple e não há implementação de código aberto.
  5. ^ Lattner, Chris (11 de junho de 2014). "Re: [LLVMdev] [cfe-dev] [Anúncio] vagas abertas na equipe de compiladores Swift da Apple" . Arquivado do original em 14 de julho de 2014 . Recuperado em 12 de junho de 2014 . Você pode imaginar que muitos de nós queremos que ele seja de código aberto e faça parte do LLVM, mas a discussão ainda não aconteceu e não acontecerá por algum tempo.
  6. ^ "Página inicial de Chris Lattner" . Chris Lattner. 3 de junho de 2014 . Recuperado em 3 de junho de 2014 . A linguagem Swift é o produto do esforço incansável de uma equipe de especialistas em linguagem, gurus de documentação, ninjas de otimização de compiladores e um grupo interno incrivelmente importante de dogfooding que forneceu feedback para ajudar a refinar e testar ideias. Claro, ele também se beneficiou muito das experiências duramente conquistadas por muitas outras linguagens da área, extraindo ideias de Objective-C, Rust, Haskell, Ruby, Python, C#, CLU e muitas outras para listar.
  7. ^ ab Lattner, Chris (3 de junho de 2014). "Página inicial de Chris Lattner" . Chris Lattner . Recuperado em 3 de junho de 2014 . Comecei a trabalhar na linguagem de programação Swift em julho de 2010. Implementei grande parte da estrutura básica da linguagem, com apenas algumas pessoas sabendo de sua existência. Algumas outras pessoas (incríveis) começaram a contribuir seriamente no final de 2011, e isso se tornou um foco importante para o grupo Apple Developer Tools em julho de 2013 [...] extraindo ideias de Objective-C , Rust, Haskell, Ruby, Python, C#, CLU e muitos outros para listar.
  8. ^ "Construindo assert() em Swift, Parte 2: __FILE__ e __LINE__" . Recuperado em 25 de setembro de 2014 .
  9. ^ "Influências - A Referência da Ferrugem" . doc.rust-lang.org . Recuperado em 2 de maio de 2020 .
  10. ^ "influenciado pela documentação - V" . github. com . Recuperado em 3 de novembro de 2023 .
  11. ^ Lardinois, Frederic (2 de junho de 2014). "Apple lança Swift, uma nova linguagem de programação para escrever aplicativos iOS e OS X" . TechCrunch . Recuperado em 7 de setembro de 2022 .
  12. ^ Programação orientada a protocolo em Swift. Apple Inc. YouTube .
  13. ^ "Os conceitos são semelhantes aos Rust Traits" .
  14. ^ Williams, Owen (2 de junho de 2014). "No sexagésimo aniversário de Tim Berners-Lee, a Apple anuncia Swift, uma nova linguagem de programação para iOS" . A próxima web . Recuperado em 2 de junho de 2014 .
  15. ^ "A nova linguagem de programação da Apple, Swift, agora é open source" . A beira . 3 de dezembro de 2015 . Recuperado em 5 de dezembro de 2015 .
  16. ^ "Apple Open Sources Swift na última proposta para a empresa" . Jornal do CIO. Os blogs do Wall Street Journal . 3 de dezembro de 2015 . Recuperado em 5 de dezembro de 2015 .
  17. ^ "Olhando para trás, para o Swift 3 e adiante para o Swift 4" . Fóruns rápidos . 29 de julho de 2016 . Recuperado em 19 de novembro de 2018 .
  18. ^ "Evolução rápida" . Evolução Rápida . Recuperado em 19 de novembro de 2018 .
  19. ^ "The RedMonk Programming Language Rankings: Janeiro de 2018 - tecossistemas" . redmonk. com . 7 de março de 2018 . Recuperado em 20 de novembro de 2018 .
  20. ^ Kremenek, Ted (25 de março de 2019). "Swift 5 lançado!"
  21. ^ Kremenek, Ted (20 de setembro de 2019). "Lançado Swift 5.1!". Arquivado do original em 26 de fevereiro de 2022 . Recuperado em 28 de outubro de 2019 .
  22. ^ Hudson, Paul (6 de junho de 2021). "O que há de novo no Swift 5.5?" HackingWithSwift. com . Hackeando com Swift . Recuperado em 8 de junho de 2021 .
  23. ^ "Swift 5.9 lançado" . Swift.org . 18 de setembro de 2023 . Recuperado em 9 de outubro de 2023 .
  24. ^ ab Platforms State of the Union, Sessão 102, Apple Worldwide Developers Conference , 2 de junho de 2014
  25. ^ A linguagem de programação Swift. Maçã . 2 de junho de 2014 . Recuperado em 2 de junho de 2014 .
    • "Documentação". Rápido .
  26. ^ "Swift atingiu 1,0" . 9 de setembro de 2014 . Recuperado em 10 de setembro de 2014 .
  27. ^ "Notas de versão do Xcode 6.1" . 22 de outubro de 2014 . Recuperado em 23 de janeiro de 2015 .
  28. ^ "Notas de versão do Xcode 6.3" . 8 de abril de 2015 . Recuperado em 8 de abril de 2015 .
  29. ^ "Aplicativos Swift 2 na App Store" . Blog Rápido . Recuperado em 13 de março de 2016 .
  30. ^ "Swift 3.0 lançado!" Swift.org . 13 de setembro de 2016. Arquivado do original em 14 de outubro de 2016 . Recuperado em 26 de outubro de 2016 .
  31. ^ "Swift 4.0 lançado!" Swift.org . 17 de setembro de 2017. Arquivado do original em 28 de março de 2019 . Recuperado em 1º de março de 2018 .
  32. ^ "Swift 4.1 lançado!" Swift.org . 29 de março de 2018. Arquivado do original em 25 de abril de 2019 . Recuperado em 30 de março de 2018 .
  33. ^ "Resultados da pesquisa do desenvolvedor Stack Overflow 2015" .
  34. ^ "Resultados da pesquisa do desenvolvedor Stack Overflow 2016" .
  35. ^ "Swift.org e código aberto" . Swift.org . Apple Inc. Recuperado em 25 de fevereiro de 2019 .
  36. ^ "Apresentando o IBM Swift Sandbox - Swift" . Rápido . Recuperado em 5 de dezembro de 2015 .
  37. ^ Mayo, Benjamin (4 de dezembro de 2015). "Escreva código Swift em um navegador da web com o IBM Swift Sandbox" . 9to5Mac . Recuperado em 5 de dezembro de 2015 .
  38. ^ "Depois que a Apple abriu o código, a IBM colocou a programação Swift na nuvem | ZDNet" . ZDNet . Recuperado em 5 de dezembro de 2015 .
  39. ^ "Catálogo de pacotes Swift e descontinuação do Swift Sandbox" . Recuperado em 9 de novembro de 2018 .
  40. ^ "Parques Rápidos" . Desenvolvedor Apple . Recuperado em 19 de junho de 2016 .
  41. ^ "Swift Playgrounds - Visualização" . Maçã . Recuperado em 19 de junho de 2016 .
  42. ^ Mayo, Benjamin (13 de junho de 2016). "Apple anuncia Swift Playgrounds para iPad na WWDC, lançamento público no outono" . 9to5Mac . Recuperado em 19 de junho de 2016 .
  43. ^ Cunningham, Andrew (10 de janeiro de 2017). "Programador de longa data da Apple e criador do Swift troca a Apple pela Tesla" . Ars Técnica.
  44. ^ Wuerthele, Mike (13 de janeiro de 2017). "O novo chefe do projeto Swift, Ted Kremenek, disse que estará comandando o show nos bastidores por algum tempo" . AppleInsider.
  45. ^ Daniel Eran Dilger. "WWDC19: SwiftUI foi a estrela mais brilhante em uma galáxia de novas ideias" . AppleInsider . Recuperado em 19 de julho de 2019 .
  46. ^ "Swift.org - Baixe Swift" . Recuperado em 21 de junho de 2020 .
  47. ^ "SDKs Android para Swift" . Github . Recuperado em 10 de setembro de 2021 .
  48. ^ "versões do pacote swift-lang" . Recuperado em 10 de setembro de 2021 .
  49. ^ Readdle (15 de janeiro de 2020). "Swift para Android: nossa experiência e ferramentas" . Médio . Recuperado em 20 de agosto de 2020 .
  50. ^ Anderson, Tim (30 de março de 2020). "Suporte oficial personalizado para Swift para Windows prometido em 5.3: Swift em mais plataformas - desde que você não precise de uma GUI" . O registro . Recuperado em 18 de setembro de 2020 .
  51. ^ "A porta Swift Linux" . Swift.org . 3 de dezembro de 2015 . Recuperado em 3 de agosto de 2016 .
  52. ^ Timmer, John (5 de junho de 2014). “Uma rápida olhada no Swift, a nova linguagem de programação da Apple” . Ars Técnica . Condé Nast . Recuperado em 6 de junho de 2014 .
  53. ^ Kremenek, Ted (25 de março de 2019). "Swift 5 lançado!" Swift.org . Recuperado em 28 de março de 2019 .
  54. ^ "Baixar Swift" . Swift.org . Maçã . Recuperado em 15 de dezembro de 2020 .
  55. ^ Kremenek, Ted (26 de abril de 2021). "Lançado Swift 5.4!". Swift.org . Maçã. Arquivado do original em 26 de abril de 2021 . Recuperado em 26 de abril de 2021 .
  56. ^ Kremenek, Ted (14 de março de 2022). "Lançado Swift 5.6!". Swift.org . Maçã . Recuperado em 14 de março de 2022 .
  57. ^ "Lançamento Swift 5.6.1 versão · maçã/Swift" . Github .
  58. ^ "Lançamento Swift 5.6.2 versão · maçã/Swift" . Github .
  59. ^ "Lançamento do Swift 5.6.3 · maçã/Swift" . Github .
  60. ^ Borla, azevinho (12 de setembro de 2022). "Lançado Swift 5.7!". Swift.org . Maçã . Recuperado em 23 de setembro de 2022 .
  61. ^ "Lançamento do Swift 5.7.1 · maçã/Swift" . Github .
  62. ^ "Lançamento do Swift 5.8 · maçã/Swift" . Github .
  63. ^ "Lançamento Swift 5.8.1 versão · apple/swift" . Github . Recuperado em 14 de junho de 2023 .
  64. ^ "Lançamento do Swift 5.9 · apple/swift" . Github . Recuperado em 18 de setembro de 2023 .
  65. ^ "Lançamento Swift 5.9.1 versão · apple/swift" . Github . Recuperado em 19 de outubro de 2023 .
  66. ^ "Lançamento Swift 5.9.2 versão · apple/swift" . Github . Recuperado em 11 de dezembro de 2023 .
  67. ^ "Documentação" . docs.swift.org . Recuperado em 17 de novembro de 2023 .
  68. ^ "Elimine corridas de dados usando Swift Concurrency - WWDC22 - Vídeos" . Apple Inc. Recuperado em 17 de novembro de 2023 .
  69. ^ ab "Documentação". docs.swift.org . Recuperado em 15 de outubro de 2023 .
  70. ^ "Documentação" . docs.swift.org . Recuperado em 15 de outubro de 2023 .
  71. ^ "Encerramentos - A linguagem de programação Swift (Swift 5.5)" . docs.swift.org . Recuperado em 31 de agosto de 2021 .
  72. ^ Macomber, Kyle; Yaskevich, Yavel; Gregor, Douglas; McCALL, John. "Vários fechamentos finais" . Github . Recuperado em 19 de outubro de 2020 .
  73. ^ "Documentação" . docs.swift.org . Recuperado em 16 de outubro de 2023 .
  74. ^ "Cordas e caracteres" . docs.swift.org . Recuperado em 16 de outubro de 2023 .
  75. ^ "Declarações - A linguagem de programação Swift (Swift 5.6)" . docs.swift.org . Recuperado em 28 de fevereiro de 2022 .
  76. ^ “Controle de acesso” . desenvolvedor.apple.com . Recuperado em 25 de outubro de 2016 .
  77. ^ "Tipos anuláveis", Guia de programação C#, Microsoft.
  78. ^ "Tipos". desenvolvedor.apple.com . Recuperado em 16 de julho de 2014 .
  79. ^ ab “Classes e Estruturas” . Apple. com .
  80. ^ Guhit, Fiel (14 de fevereiro de 2015). "Estudo de caso de desempenho em Swift 1.1, Swift 1.2 e Objective-C" .
  81. ^ Construindo aplicativos melhores com tipos de valor. Maçã.
  82. ^ "Documentação" . docs.swift.org . Recuperado em 28 de novembro de 2023 .
  83. ^ “Trabalhando com Protocolos” . Maçã .
  84. ^ "Referência do protocolo NSCopying" . Maçã .
  85. ^ "Estatísticas da biblioteca padrão Swift" . swiftinit.org . Swiftinit . Recuperado em 2 de outubro de 2023 .
  86. ^ Thompson, Mattt (2 de setembro de 2014). "Implementações do protocolo padrão Swift" . NShipster .
  87. ^ "swift-evolution/proposals/0304-structured-concurrency.md em principal · apple/swift-evolution" . Github . Recuperado em 16 de outubro de 2023 .
  88. ^ "swift-evolution/proposals/0296-async-await.md em principal · apple/swift-evolution" . Github . Recuperado em 16 de outubro de 2023 .
  89. ^ "Os aplicativos baseados em Swift funcionam no macOS 10.9/iOS 7 e inferior?", StackOverflow
  90. ^ Inc, Apple (18 de setembro de 2023). "Lançado Swift 5.9" . Swift.org . Recuperado em 9 de outubro de 2023 . {{cite web}}: |last=tem nome genérico ( ajuda )
  91. ^ "Escrevendo aulas Swift com comportamento Objective-C", Apple Inc.
  92. ^ "Migrando seu código Objective-C para Swift" .
  93. ^ "Swift e Objective-C no mesmo projeto", Apple Inc.
  94. ^ "Apple: pesquise" corelib"". Github .
  95. ^ "Xcode - SwiftUI- Desenvolvedor Apple" . desenvolvedor.apple.com . Recuperado em 1º de fevereiro de 2021 .
  96. ^ Lanier, Brian; Groff, Joe. "Rápido Intermediário". Maçã . Recuperado em 3 de julho de 2014 .
  97. ^ Metz, Cade. "Por que os programadores estão enlouquecendo com a nova linguagem de programação da Apple" . Com fio . Recuperado em 16 de julho de 2014 .
  98. ^ "Tratamento de erros em linguagem Swift" . stackoverflow. com .
  99. ^ "maçã/evolução rápida" . Github . Recuperado em 4 de abril de 2016 .
  100. ^ "maçã/evolução rápida" . Github . Recuperado em 4 de abril de 2016 .
  101. ^ Barbosa, Greg (22 de fevereiro de 2016). “IBM traz Swift para a nuvem, lança framework web Kitura escrito na linguagem de programação da Apple” . 9to5Mac . Recuperado em 16 de maio de 2016 .
  102. ^ "Grupo de trabalho de APIs de servidor" . Swift.org . 25 de outubro de 2016 . Recuperado em 28 de outubro de 2016 .
  103. ^ "Swift.org" . Swift.org . Arquivado do original em 10 de maio de 2021 . Recuperado em 28 de outubro de 2016 .
  104. ^ "Compilador de elementos RemObjects" . Recuperado em 17 de janeiro de 2016 .
  105. ^ "Rápido para Arduino" .
  106. ^ Rose, Jordânia (1º de abril de 2020). "Rápido no Mac OS 9". -dealloc .

links externos

  • Website oficial
  • Swift na Apple Developer
  • Código fonte do Swift no GitHub
  • Exemplo rápido
  • Swift do lado do servidor - The Vapor Framework
Obtido em "https://en.wikipedia.org/w/index.php?title=Swift_(programming_linguagem)&oldid=1207803205"