Get best of the week

Swift 5.3: O que há de novo?

Oi Habr! A linguagem de programação Swift é muito popular devido ao seu uso em aplicativos de escrita para iOS, portanto, seu desenvolvimento é do interesse de todos os envolvidos nessa área.

Vamos ver o que há de novo para os desenvolvedores do Swift versão 5.3.

Vários fechamentos à direita


A nova versão ( SE-0279 ) oferece uma nova sintaxe para fechamentos finitos que permite chamar vários fechamentos como parâmetros de função de maneira mais legível. Isso minimiza o uso de muitos parênteses na assinatura da função.

import Foundation

func load(url: String, success: (Data) -> Void, failure: (Error) -> Void) {
    
}

// old  version

load(url: "someURL", success: { data in }, failure: { error in })

// new multiple trailing closures

load(url: "someURL") { (data) in
    // do smth
} failure: { (error) in
    // do smth
}

No exemplo de duas opções de chamada, pode-se ver que visualmente a segunda parece um pouco melhor.

Cláusulas de captura de vários padrões


Atualmente, cada cláusula catch em uma instrução do-catch pode conter apenas um padrão. Para contornar esse problema, os desenvolvedores usarão os recursos das opções de opção para incluir a correspondência de padrões no corpo das instruções catch, aumentando assim o código aninhado e duplicado ( SE-0276 ).

Agora, os itens de captura permitem que o usuário especifique uma lista de modelos separados por vírgula com a capacidade de vincular variáveis ​​ao corpo da captura, como em uma opção.

enum NetworkError: Error {
    case failure, timeout
}

// old  version
func networkCall(){
  do{
    try someNetworkCall()
  } catch NetworkError.timeout{
    print("timeout")
  } catch NetworkError.failure{
    print("failure")
  }
}

// new multi-Pattern catch clauses
func networkCall(){
  do{
    try someNetworkCall()
  } catch NetworkError.failure, NetworkError.timeout {
    print("handle for both")
  }
}

Conformidade comparável sintetizada para enums


Até agora, comparar dois elementos de uma enumeração não era uma coisa "agradável". Era necessário conformar Comparable e escrever uma função estática <para determinar se o valor original é menor que outro.

Agora, o Swift ( SE-0266 ) permite que você não se preocupe com a implementação de todas essas coisas, e você não precisa implementar explicitamente o protocolo, desde que sua enumeração tenha os mesmos tipos. Se os valores correspondentes não forem especificados, as listagens serão comparadas na ordem semântica da declaração.

enum Brightness: Comparable {
    case low(Int)
    case medium
    case high
}

([.high, .low(1), .medium, .low(0)] as [Brightness]).sorted()
// [Brightness.low(0), Brightness.low(1), Brightness.medium, Brightness.high]

o número de selfs pode ser reduzido


A partir de agora, o self pode ser omitido nos locais onde não é mais necessário ( SE-0269 ). Anteriormente, era necessário usar o fechamento automático quando capturávamos valores do escopo externo.

struct OldView: View {

    var body: some View {
        Button(action: {
            self.sayHello()
        }) {
            Text("Press")
        }
    }
    
    func sayHello() {}
}

struct NewView: View {

    var body: some View {
        Button {
            sayHello()
        } label: {
            Text("Press")
        }
    }
    
    func sayHello(){}
}

Onde em genérico


Uma nova versão do idioma ( SE-0267 ) introduziu a capacidade de anexar funções onde a tipos e extensões genéricos.

struct Stack<Element> {
    private var array = [Element]()

    mutating func push(_ obj: Element) {
        array.append(obj)
    }

    mutating func pop(_ obj: Element) -> Element? {
        array.popLast()
    }
}

extension Stack {
    func sorted() -> [Element] where Element: Comparable {
        array.sorted()
    }
}

Você pode adicionar um novo método ordenado () à pilha, mas apenas para os casos em que os elementos dentro da pilha estiverem em Comparável.

Novo tipo Float16


Introduzido o ponto flutuante de meia precisão Float16 ( SE-0277 ). Com o advento do aprendizado de máquina em dispositivos móveis nos últimos anos, isso indica apenas as ambições da Apple de promover esse tópico. O Float 16 é comumente usado em GPUs móveis para computação e como um formato compactado para pesos em aplicativos ML.

let f16: Float16 = 7.29

O Swift 5.3 introduziu muitos aprimoramentos no Swift Package Manager (SPM). Considere-os.

  1. SE-0271 (Recursos do Gerenciador de Pacotes) permite que o SPM contenha recursos como imagens, áudio, JSON e muito mais.
  2. SE-0272 (Dependências binárias do Gerenciador de Pacotes) permite que o SPM use pacotes binários junto com o suporte ao pacote de origem existente. Isso significa que SDKs de código fechado e compartilhado, como o Firebase, agora podem ser integrados usando o SPM.
  3. SE-0273 (Dependências de Destino Condicionais do Gerenciador de Pacotes) permite configurar destinos para que eles tenham dependências apenas para plataformas e configurações específicas. Por exemplo, você pode designar estruturas adicionais especiais ao compilar para Linux.
  4. O SE-0278 permite adicionar recursos localizados.

Assim, pode-se afirmar que a versão 5.3 introduziu algumas boas inovações que serão captadas ao longo do tempo pelos desenvolvedores.

More articles:


All Articles