Get best of the week

Swift 5.3: Quoi de neuf?

Salut Habr! Le langage de programmation Swift est très populaire en raison de son utilisation dans l'écriture d'applications pour iOS, donc son développement intéresse toutes les personnes impliquées dans ce domaine.

Voyons les nouveautés pour les développeurs de Swift version 5.3.

Plusieurs fermetures arrière


La nouvelle version ( SE-0279 ) offre une nouvelle syntaxe pour les fermetures finies qui vous permet d'appeler plusieurs fermetures en tant que paramètres de fonction d'une manière plus lisible. Cela minimise l'utilisation de trop de parenthèses dans la signature de fonction.

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
}

Sur l'exemple de 2 options d'appel, on peut voir que visuellement la seconde semble un peu plus agréable.

Clauses de capture à motifs multiples


Actuellement, chaque clause catch dans une instruction do-catch ne peut contenir qu'un seul modèle. Pour contourner ce problème, les développeurs utiliseront les capacités des options de commutateur pour inclure la correspondance de modèles dans le corps des instructions catch, augmentant ainsi le code imbriqué et dupliqué ( SE-0276 ).

Les éléments de capture permettent désormais à l'utilisateur de spécifier une liste de modèles séparés par des virgules avec la possibilité de lier des variables au corps de capture, comme dans un commutateur.

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")
  }
}

Conformité comparable synthétisée pour les énumérations


Jusqu'à présent, comparer 2 éléments d'une énumération n'était pas une chose «agréable». Il était nécessaire de conformer Comparable et d'écrire une fonction statique <pour déterminer si la valeur d'origine est inférieure à une autre.

Maintenant, Swift ( SE-0266 ) vous permet de ne pas «transpirer» sur la mise en œuvre de toutes ces choses, et vous n'avez pas besoin d'implémenter explicitement le protocole tant que votre énumération a les mêmes types. Si les valeurs correspondantes ne sont pas spécifiées, les listes seront comparées dans l'ordre sémantique de la déclaration.

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]

le nombre de selfs peut être réduit


Désormais, le soi peut être omis dans les endroits où il n'est plus nécessaire ( SE-0269 ). Auparavant, l'utilisation de fermetures auto était nécessaire lorsque nous capturions des valeurs de la portée externe.

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(){}
}

Où en générique


Une nouvelle version du langage ( SE-0267 ) a introduit la possibilité d'attacher où aux fonctions à l'intérieur des types et extensions génériques.

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()
    }
}

Vous pouvez ajouter une nouvelle méthode sorted () à la pile, mais uniquement dans les cas où les éléments à l'intérieur de la pile sont conformes à Comparable.

Nouveau type Float16


Introduction de la virgule flottante Float16 demi-précision ( SE-0277 ). Avec l'avènement du machine learning sur les appareils mobiles ces dernières années, cela ne fait qu'indiquer les ambitions d'Apple de promouvoir ce sujet. Float 16 est couramment utilisé sur les GPU mobiles pour l'informatique et comme format compressé pour les échelles dans les applications ML.

let f16: Float16 = 7.29

Swift 5.3 a introduit de nombreuses améliorations au Swift Package Manager (SPM). Considérez-les.

  1. SE-0271 (Package Manager Resources) permet à SPM de contenir des ressources telles que des images, du son, du JSON, etc.
  2. SE-0272 (Package Manager Binary Dependencies) permet à SPM d'utiliser des packages binaires avec la prise en charge des packages source existants. Cela signifie que les SDK partagés et fermés tels que Firebase peuvent désormais être intégrés à l'aide de SPM.
  3. SE-0273 (Package Manager Depitional Target Dependencies) vous permet de configurer des cibles afin qu'elles n'aient des dépendances que pour des plates-formes et des configurations spécifiques. Par exemple, vous pouvez désigner des cadres supplémentaires spéciaux lors de la compilation pour Linux.
  4. SE-0278 vous permet d'ajouter des ressources localisées.

Ainsi, on peut affirmer que la version 5.3 a introduit de bonnes innovations qui seront reprises au fil du temps par les développeurs.

More articles:


All Articles