Quoi de neuf avec Swift 4

Depuis le dernier article publié sur ce blog, Swift 4 est sortie avec son lot de nouveautés. Nous allons donc faire un résumé des gros changements / nouveautés de cette nouvelle version de notre langage préféré.

Changements

Dans cette section nous allons d’abord lister les changements principaux apportés à cette nouvelle monture du langage.

Les chaines de caratères

La proposition SE-0163 permet d’itérer directement sur une chaine de caractère sans passer par la propriété characters.

let swifttuto = "Swift tuto"

for char in swifttuto {
  print(char)
}

Cette modification permet également de manipuler un String comme une liste de caractère :

swifttuto.isEmpty // false
swifttuto.count // 10
String(swifttuto.reversed()) // "otut tfiwS"

Une autre nouveauté est la possibilité d’écrire des litéraux de chaines de caractère multi-ligne est mettant son texte entre 3 guillemets « » » :

let monTexteMultiLigne = """
Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
Ut enim ad minim veniam,
quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
"""

Contrôleurs d’accès

En swift il y a 4 contrôleurs d’accès aux variables, classes, structures, enum, etc. : private, fileprivate, internal, public. La proposition SE-0169 modifie la portée du contrôleur d’accès private.

Maintenant le private permet à une variable déclaré dans une classe / structure / enum avec ce modifieur d’être accessible dans toutes les extensions présente dans le même fichier. Pour illustrer l’amélioration voici un petit exemple :

struct Montre {
  private let marque: String
  
  init(marque: String) {
    self.marque = marque
  }
}

extension Montre {
  func nomDeLaMarque() -> String {
    return marque
  }
}

let montre = Montre(marque: "Apple Watch")
//montre.marque // error: 'marque' is inaccessible due to 'private' protection level
montre.nomDeLaMarque() // "Apple Watch"

Composition de classe et de protocole

Swift 4 ajoute la possibilité de définir une déclaration en tant que composition de type, classe et protocole. Un petit exemple :

protocol Animal {
  var espèce: String { get }
}

protocol Domestiqué {}

struct Chat: Animal, Domestiqué {
  let espèce = "chat"
}

struct Chien: Animal, Domestiqué {
  let espèce = "chien"
}

struct Serpent: Animal {
  let espèce = "serpent"
}

Ici nous avons définis 2 protocoles, Animal et Domestiqué, et 3 structures implémentant ces protocoles : Chat, Chien, Serpent. Maintenant utilisons notre composition de protocole en tant que type :

let chien = Chien()
let chat = Chat()
let serpent = Serpent()
var animauxDomestiqué: [Animal & Domestiqué] = []
animauxDomestiqué.append(chat)
animauxDomestiqué.append(chien)
animauxDomestiqué.append(serpent) // erreur: Argument type 'Serpent' does not conform to expected type 'Animal & Domestiqué'

Ici grâce aux crochets et au & nous pouvons associés différents protocoles (ou classes, structures) afin de former un type supérieur. C’est une fonctionnalité avancé, mais qui peux s’avérer très utiles dans certaines situations.

Nouvelles fonctionnalités

Encodage et décodage du JSON

De nouvelles APIs de décodage et d’encodage ont fait leur apparition grâce aux propositions SE-0166 et SE-0167. Elles définissent des protocoles permettant de sérialiser et désérialiser du JSON directement dans des objets Swift.

Ces deux protocoles sont Encodable et Decodable, et les objets JSONEncodeJSONDecode permettent de serialiser / désérialiser du JSON à partir d’objects conformes aux protocoles cité avant.

Voici un exemple pour encoder un objet en JSON :

struct Ordinateur: Encodable {
  let marque: String
  let modèle: String
  let année: Int
}

let ordinateur = Ordinateur(marque: "Apple", modèle: "MacBook", année: 2017)
let json = try? JSONEncoder().encode(ordinateur)

print(String(data: json!, encoding: .utf8)) // Optional("{"modèle": "MacBook", "année": 2017, "marque": "Apple"}")

Et la même chose pour décoder un JSON en objet :

struct Ordinateur: Decodable {
  let marque: String
  let modèle: String
  let année: Int
}

let json = """
{"modèle": "MacBook", "année": 2017, "marque": "Apple"}
"""

let ordinateur = try? JSONDecoder().decode(Ordinateur.self, from: json.data(using: .utf8)!)

print(ordinateur) // Ordinateur(marque: "Apple", modèle: "MacBook", année: 2017)

Simple non ?

Chemins Clés

Les chemins clés ont été ajoutés dans Swift 3 mais uniquement pour manipuler les propriétés des NSObject en utilisant des chaines de caractère, ce qui était propice aux erreurs. Avec la proposition SE-0161, les chemins clés ont été étendu aux structures en utilisant une syntaxe particulière qui permet au compilateur de vérifier la validité du chemin et donc d’éviter certains bugs.

Pour utiliser cette nouvelle syntaxe un anti-slash suffit :

struct Conf {
  let nom: String
  let ville: String
}

let keyPath = \Conf.nom
let wwdc = Conf(nom: "WWDC", ville: "San Jose")
wwdc[keyPath: keyPath] // "WWDC"

Intervalle unilatéral

La proposition SE-0172 introduit la notion d’intervalle unilatéral en swift. Pour faire simple, cela supprime la nécessité d’utiliser le startIndex et le endIndex sur des intervalles concernant les collections. Voici un exemple :

let numbers = [-2, -1, 0, 1, 2]

let positifs = numbers[2...] // [0, 1, 2]
let negatifs = numbers[...1] // [-2, -1]

La même syntaxe peut également être utilisée dans les cas d’un bloque switch.

Conclusion

Chaque nouvelle version apporte son lot de nouveauté, et Swift 4 n’y déroge pas. Dans cette version Apple commence à stabiliser ses APIs pour l’arriver de l’ABI (Abstract Binary Interface) dans Swift 5, donc l’avantage c’est qu’à partir de maintenant le langage ne devrait plus avoir de changement majeur et donc cela permet enfin de stabiliser notre base de code.

À l’année prochaine pour la nouvelle version du langage.