Apple publie Swift 6.2, la dernière version de son langage de programmation open source, avec une concurrence simplifiée, une sécurité améliorée, la prise en charge de WebAssembly et bien plus encoreApple a officiellement lancé Swift 6.2, la prochaine étape majeure dans l'évolution de son puissant langage de programmation. Cette version introduit de nouvelles fonctionnalités, améliore la gestion de la concurrence, renforce l'interopérabilité entre les langages et optimise les performances à grande échelle. Cette mise à jour apporte également des changements significatifs qui auront une incidence sur la manière dont les développeurs structureront et écriront leur code à l'avenir, qu'ils créent des applications dans l'écosystème Apple ou qu'ils intègrent Swift dans des environnements côté serveur et multiplateformes.
Swift est un langage de programmation compilé, polyvalent, multi-paradigme et de haut niveau, créé par Chris Lattner en 2010 pour Apple Inc. et maintenu par la communauté open source. Swift compile en code machine et utilise un compilateur basé sur LLVM. Le langage a été lancé pour la première fois en juin 2014 et la chaîne d'outils Swift est intégrée à Xcode depuis la version 6 de Xcode, sortie en septembre 2014.
Swift 6.2 introduit des mises à jour axées sur la programmation concurrente, les performances et l'amélioration des outils de développement. Cette version rend la programmation concurrente plus accessible en utilisant par défaut un fonctionnement à thread unique et en proposant des fonctions asynchrones intuitives, ce qui permet aux développeurs d'écrire du code concurrent sécurisé avec moins de code standard.
Parallèlement, Swift 6.2 optimise les performances sans sacrifier la sécurité, permettant ainsi un code de bas niveau avec une exécution prévisible et une surcharge minimale.
Suite à ces améliorations du langage, l'extension officielle Swift pour Visual Studio Code a été vérifiée et est désormais distribuée par Swift.org. Afin d'aider les équipes à effectuer les mises à niveau, de nouveaux outils de migration permettent aux projets d'adopter les fonctionnalités du langage à venir.
L'expérience des développeurs est encore améliorée grâce à des temps de compilation nettement plus rapides, en particulier pour les projets utilisant des API basées sur des macros. Les développeurs bénéficient d'un débogage amélioré du code concurrent dans LLDB et de nouvelles options pour gérer les avertissements du compilateur au niveau du groupe de diagnostic.
S'appuyant sur les améliorations apportées à l'écosystème, les mises à jour de la bibliothèque Swift 6.2 comprennent un nouveau package Subprocess, des améliorations de la bibliothèque Foundation et de nouvelles API destinées à prendre en charge des modèles de codage plus sûrs.
Enfin, Swift 6.2 ajoute également la prise en charge de WebAssembly, permettant aux applications Swift clientes et serveurs de cibler Wasm et de se déployer sur des navigateurs ou d'autres environnements compatibles.
Concurrence accessible
Swift 6.2 facilite la programmation concurrente grâce à une série de modifications visant à réduire les codes standard et à permettre d'écrire plus naturellement du code concurrent sécurisé :
- Monothread par défaut : les développeurs peuvent exécuter leur code sur le thread principal sans annotations @MainActor explicites à l'aide de la nouvelle option permettant d'isoler le code vers l'acteur principal par défaut. Cette option est idéale pour les scripts, le code d'interface utilisateur et d'autres cibles exécutables.
- Fonctions asynchrones intuitives : écrire du code asynchrone sans accès simultané à un état modifiable. Auparavant, les méthodes asynchrones non isolées basculaient toujours vers l'exécuteur global qui gère le pool de threads simultanés, ce qui rendait difficile l'écriture de méthodes asynchrones pour les types de classes sans erreurs de sécurité liées aux conflits de données. Dans Swift 6.2, il est possible de migrer vers une fonctionnalité à venir où les fonctions asynchrones s'exécutent dans le contexte d'exécution de l'appelant, même lorsqu'elles sont appelées sur l'acteur principal.
- Activer la concurrence avec @concurrent : introduire du code qui s'exécute simultanément à l'aide du nouvel attribut @concurrent. Cela permet de préciser clairement quand on souhaite que le code reste sérialisé sur l'acteur et quand il peut s'exécuter en parallèle.
| Code Swift : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | // In '-default-isolation MainActor' mode struct Image { // The image cache is safe because it's protected // by the main actor. static var cachedImage: [URL: Image] = [:] static func create(from url: URL) async throws -> Image { if let image = cachedImage[url] { return image } let image = try await fetchImage(at: url) cachedImage[url] = image return image } // Fetch the data from the given URL and decode it. // This is performed on the concurrent thread pool to // keep the main actor free while decoding large images. @concurrent static func fetchImage(at url: URL) async throws -> Image { let (data, _) = try await URLSession.shared.data(from: url) return await decode(data: data) } } |
Ensemble, ces améliorations permettent d'écrire du code sans conflit d'accès aux données avec moins de surcharge d'annotation, offrent un comportement plus prévisible pour le code asynchrone, tout en permettant d'introduire la concurrence lorsque cela est nécessaire.
Programmation de systèmes sécurisés
Swift 6.2 comprend des fonctionnalités conçues pour optimiser les performances sans compromettre la sécurité. Ces fonctionnalités aident à écrire du code sécurisé de bas niveau avec des performances prévisibles et une surcharge minimale.
InlineArray est un nouveau tableau de taille fixe avec stockage en ligne pour les éléments, qui peuvent être stockés dans la pile ou directement dans d'autres types sans allocation supplémentaire dans le tas. Le développeur peut introduire un tableau en ligne en écrivant la taille entre crochets avant l'élément, ou en utilisant la syntaxe abrégée :
| Code Swift : | Sélectionner tout |
1 2 3 4 5 6 7 8 | struct Game { // Shorthand for InlineArray<40, Sprite> var bricks: [40 of Sprite] init(_ brickSprite: Sprite) { bricks = .init(repeating: brickSprite) } } |
Le nouveau type Span offre un accès direct et sécurisé à la mémoire contiguë. Span garantit la sécurité de la mémoire en s'assurant que celle-ci reste valide pendant son utilisation. Ces garanties sont vérifiées lors de la compilation, sans surcoût d'exécution, et éliminent les problèmes de sécurité de la mémoire inhérents aux pointeurs, tels que les bogues de type « use-after-free ».
Swift 6.2 améliore ses capacités pour les projets de bas niveau et critiques en matière de sécurité au-delà des nouvelles API :
- Swift embarqué : Swift embarqué inclut désormais l'ensemble des API String de Swift, tous les types pour les protocoles contraints par classe, ainsi que les nouveaux types InlineArray et Span.
- Interopérabilité C++ sécurisée : les projets qui combinent Swift et C++ peuvent tirer parti des abstractions sécurisées de Swift, telles que Span pour les API C++, grâce à des annotations d'en-tête.
- Sécurité mémoire stricte en option : Swift assure la sécurité mémoire depuis sa création, tout en permettant l'utilisation de constructions non sécurisées telles que les pointeurs non sécurisés lorsque cela est nécessaire, par exemple lors de l'utilisation d'une API C qui accepte les pointeurs. Swift 6.2 introduit la sécurité mémoire stricte optionnelle, qui signale les utilisations de constructions non sécurisées afin que le développeur puisse les remplacer par des alternatives sécurisées ou les reconnaître explicitement dans le code source. Il s'agit d'une option facultative, car la majorité des projets n'ont pas besoin d'un tel niveau de sécurité. La sécurité mémoire stricte est réservée aux projets ayant les exigences de sécurité les plus élevées.
Workflows rationalisés
Au-delà des améliorations du langage, Swift 6.2 fluidifie le cycle quotidien d'itération consistant à éditer, compiler et déboguer le code.
Extension Swift pour VS Code
L'extension Swift pour VS Code est désormais officiellement vérifiée et distribuée par Swift.org. La dernière version de l'extension comprend :
- Indexation en arrière-plan par défaut : écrire du code grâce à des fonctionnalités d'édition rapides et toujours à jour, telles que le saut vers la définition et la complétion de code.
- Débogage LLDB intégré : parcourir le code Swift, définir des points d'arrêt et inspecter l'état à l'aide de LLDB directement dans VS Code.
- Panneau de projet Swift : naviguer parmi les cibles, les dépendances et les tâches d'un projet Swift dans la vue Explorateur.
- Aperçu DocC en live : prévisualiser la documentation rendue côte à côte avec le code, la mise à jour se fait en live pendant la saisie.
Ces améliorations apportées au flux de travail facilitent le travail sur les projets Swift dans l'environnement de votre choix grâce à des outils de premier ordre.
Contrôle précis des avertissements
Swift 6.2 améliore la gestion des avertissements du compilateur en permettant un contrôle au niveau des groupes de diagnostics. Un groupe de diagnostics est une catégorie d'avertissements identifiée par un nom. Il est possible de spécifier le comportement souhaité des avertissements dans un groupe de diagnostics dans un manifeste de package Swift à l'aide de la méthode treatWarning sur SwiftSetting, ou de promouvoir tous les avertissements en erreurs à l'aide de la méthode treatAllWarnings. Par exemple, il est possible de promouvoir tous les avertissements en erreurs, à l'exception des avertissements concernant l'utilisation d'API obsolètes :
| Code Swift : | Sélectionner tout |
1 2 3 4 5 6 7 | .target( name: "MyLibrary", swiftSettings: [ .treatAllWarnings(as: .error), .treatWarning("DeprecatedDeclaration", as: .warning), ] ) |
Performances de compilation des macros
Swift 6.2 améliore considérablement les temps de compilation des projets qui utilisent des API basées sur des macros. Auparavant, le système de compilation devait d'abord récupérer et compiler le paquet swift-syntax à partir du code source avant de compiler le projet macro, ce qui allongeait considérablement les temps de compilation, en particulier dans les environnements CI. SwiftPM prend désormais en charge les dépendances swift-syntax précompilées, éliminant ainsi complètement une étape de compilation coûteuse.
Débogage asynchrone amélioré
Swift 6.2 facilite considérablement le suivi de ce qui se passe dans le code concurrent lors du débogage avec LLDB : Exécution asynchrone robuste : exécution fiable des fonctions asynchrones dans LLDB, même lorsque l'appel asynchrone nécessite un changement de thread.
- Exécution de la commande « step-in » dans les fonctions asynchrones : exécution fiable de la commande « step-in » dans les fonctions asynchrones, même lorsque l'appel asynchrone nécessite un changement de thread.
- Affichage du contexte de la tâche : visualiser la tâche sur laquelle s'exécute un morceau de code lorsqu'il est arrêté à un point d'arrêt et lors de l'affichage de la trace de retour pour le thread actuel.
- Tâches nommées : attribution de noms lisibles par l'utilisateur lors de la création de tâches, qui apparaissent dans le contexte de la tâche dans les outils de débogage et de profilage.
Migration vers les fonctionnalités à venir
Swift 6.2 comprend des outils de migration pour permettre l'adoption des fonctionnalités à venir du langage :
- Identifier les incompatibilités de source : identifier les modèles de code qui ne compileront plus ou modifieront leur comportement lorsque la fonctionnalité à venir sera activée, grâce aux avertissements générés par les outils de migration.
- Automatiser les modifications de code : appliquer des correctifs pour mettre à jour le code afin de préserver son comportement existant.
Cela simplifie le processus d'activation des fonctionnalités à venir en éliminant la tâche fastidieuse des modifications manuelles du code.
Mises à jour des bibliothèques principales
Que vous gériez des processus externes, réagissiez à des changements d'état ou écriviez des suites de tests, les bibliothèques Swift 6.2 évoluent pour vous aider à écrire un code plus propre et plus sûr.
Sous-processus
Swift 6.2 introduit un nouveau package Subprocess qui offre une API simplifiée et adaptée à la concurrence pour lancer et gérer des processus externes. Cela inclut des API construites avec async/await, un contrôle précis de l'exécution des processus, une configuration spécifique à la plateforme, et plus encore — idéal pour les scripts, l'automatisation et les tâches côté serveur :
| Code Swift : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 | import Subprocess let swiftPath = FilePath("/usr/bin/swift") let result = try await run( .path(swiftPath), arguments: ["--version"] ) let swiftVersion = result.standardOutput |
Foundation
Dans Swift 6.2, la bibliothèque Foundation comprend une API NotificationCenter moderne qui utilise des types de notification concrets au lieu de s'appuyer sur des chaînes de caractères et des dictionnaires non typés pour les noms et les charges utiles des notifications. Cela signifie que vous pouvez définir une structure de notification avec des propriétés stockées, et que les observateurs peuvent utiliser le type sans indexation et conversion dynamique sujettes à des erreurs. Les types de notification spécifient également s'ils sont publiés de manière synchrone sur l'acteur principal ou de manière asynchrone via une conformité à MainActorMessage ou AsyncMessage, ce qui élimine les erreurs de concurrence lors de l'utilisation des notifications de l'acteur principal.
Observation
Swift 6.2 permet la diffusion en continu des changements d'état transactionnels des types observables à l'aide du nouveau type de séquence asynchrone Observations. Les mises à jour incluent tous les changements synchrones apportés aux propriétés observables, et la transaction se termine au prochain await qui suspend. Cela évite les mises à jour redondantes de l'interface utilisateur, améliore les performances et garantit que votre code réagit à un instantané cohérent de la valeur.
Tests Swift
Les tests Swift dans Swift 6.2 ajoutent de nouvelles API pour améliorer l'expressivité des tests et de leurs résultats :
- Les tests de sortie permettent de vérifier que le code se termine dans des conditions spécifiques, telles qu'une condition préalable non remplie. Les tests de sortie s'exécutent dans un nouveau processus et vérifient que le comportement de sortie correspond aux attentes du développeur, ce qui lui permet d'exercer des chemins d'échec critiques comme il le ferait dans n'importe quel autre test.
- Les pièces jointes permettent à un développeur d'inclure des informations supplémentaires dans les résultats des tests, notamment des chaînes de caractères, des images, des journaux et d'autres artefacts, qui apparaissent dans les rapports de test ou sont enregistrés sur le disque. Il est ainsi plus facile de diagnostiquer les défaillances à l'aide de preuves concrètes, qu'il s'agisse d'une capture d'écran de l'état de l'interface utilisateur, d'une charge utile JSON ou d'une trace des étapes ayant conduit au problème.
- Les noms d'affichage des identifiants bruts permettent de personnaliser les noms des fonctions de test et des types de suites avec moins de code :
| Code Swift : | Sélectionner tout |
1 2 3 4 5 | -@Test("square() returns x * x") -func squareIsXTimesX() { +@Test func `square() returns x * x`() { #expect(square(4) == 4 * 4) } |
Prise en charge de WebAssembly
Swift 6.2 prend désormais en charge WebAssembly, également connu sous le nom de Wasm. WebAssembly est une plateforme de machine virtuelle axée sur la portabilité, la sécurité et les performances élevées. Les développeurs peuvent désormais créer des applications client et serveur pour Wasm et les déployer sur le navigateur ou d'autres environnements d'exécution.
Source : Apple
Et vous ?
Que pensez-vous de cette version du langage de programmation Swift ? Trouvez-vous les améliorations apportées par cette version cohérentes et pertinentes ?Voir aussi :
Swift 6, la nouvelle version majeure du langage de programmation Swift, est disponible, avec une nouvelle bibliothèque Swift Testing et une prise en charge étendue de Linux et de Windows En route vers Swift 6 : l'équipe en charge du développement de Swift dévoile la nouvelle feuille de route du projet Apple recrute des développeurs de compilateurs pour améliorer l'interopérabilité entre Swift et C++
Vous avez lu gratuitement 14 238 articles depuis plus d'un an.
Soutenez le club developpez.com en souscrivant un abonnement pour que nous puissions continuer à vous proposer des publications.
Soutenez le club developpez.com en souscrivant un abonnement pour que nous puissions continuer à vous proposer des publications.