Précision du formatage des chaînes en Swift : secrets et exemples

Spécificateur de format de précision de chaîne en Swift : comment contrôler la précision d'affichage des nombres

Bonjour, collègue ! Si tu as déjà eu besoin d'afficher un nombre avec un certain nombre de décimales en Swift, tu as sûrement remarqué que le classique String(format:) ne se comporte pas toujours de manière évidente. Surtout si tu viens du monde du C ou de l'Objective-C, où printf est une vache sacrée. Dans cet article, nous allons comprendre comment fonctionne le spécificateur de format de précision de chaîne en Swift, pourquoi il « plante » parfois et comment l'utiliser correctement. C'est parti !

Qu'est-ce que le spécificateur de précision et à quoi sert-il ?

Le spécificateur de précision est une partie de la chaîne de format qui détermine combien de décimales (ou le nombre total de chiffres) doivent être affichées. En Swift, comme en C, il s'écrit après le point à l'intérieur du spécificateur de format. Par exemple, %.2f signifie « afficher un nombre à virgule flottante avec deux décimales ».

Mais il y a un détail : Swift utilise Core Foundation pour le formatage des chaînes, et son comportement peut différer de ce à quoi tu es habitué en C. Cela concerne particulièrement le travail avec Double et Float.

Regardons tout de suite un exemple simple, souvent rencontré dans les questions sur Stack Overflow :

let pi = Double.pilet formatted = String(format: "%.2f", pi)print(formatted) // Affiche : "3.14"

Tout fonctionne comme sur des roulettes. Mais dès que nous commençons à expérimenter avec des formats plus complexes, les surprises commencent.

Les principaux types de spécificateurs de précision en Swift

En Swift, les spécificateurs suivants sont pris en charge et affectent la précision :

• %f — nombre à virgule flottante. La précision indique le nombre de décimales.
• %e — notation exponentielle. La précision est le nombre de chiffres après la virgule.
• %g — choisit entre %f et %e en fonction de la valeur. La précision est le nombre total de chiffres significatifs.
• %d / %i — nombres entiers. La précision est le nombre minimal de chiffres (complété par des zéros à gauche).
• %s — chaînes de caractères. La précision est le nombre maximal de caractères affichés.

Mais le plus intéressant commence lorsque nous essayons d'appliquer la précision à Double ou Float via String(format:).

Problème courant : « Pourquoi la précision ne fonctionne-t-elle pas ? »

L'une des plaintes les plus fréquentes sur Stack Overflow : « J'écris String(format: "%.2f", myDouble), mais j'obtiens un résultat inattendu ». Analysons un scénario typique :

let value: Float = 1.23456789let result = String(format: "%.4f", value)print(result) // Peut afficher "1.2346" ou "1.2345" selon la compilation

Pourquoi ? Parce que Float a une précision d'environ 6 à 7 chiffres significatifs. Si tu passes 1.23456789, il est arrondi à 1.234568 (ou à peu près) avant même d'atteindre le format. Et la précision dans %.4f est ensuite appliquée à cette valeur arrondie.

Pour éviter toute confusion, utilise toujours Double pour les nombres à virgule flottante si une haute précision est nécessaire :

let value: Double = 1.23456789let result = String(format: "%.4f", value)print(result) // Affiche de manière fiable "1.2346"

Exemples avancés : comment contrôler la précision dynamiquement

Parfois, la précision doit être définie non pas de manière fixe, mais via une variable. Swift permet de le faire de deux manières :

Méthode 1 : via * (astérisque)

Dans le spécificateur de format, on peut utiliser * à la place d'un nombre, et la précision sera alors extraite de l'argument suivant