Comment connaître le type d'une variable en Swift : guide complet avec exemples de code

Introduction : pourquoi connaître le type d'une variable en Swift ?

Avez-vous déjà écrit du code en Swift et soudainement pensé : « Quel est le type de cette variable ? » Surtout lorsque vous travaillez avec Any, les génériques ou des héritages complexes. C'est comme essayer de deviner ce qu'il y a à l'intérieur d'une boîte sans l'ouvrir. Mais Swift dispose d'outils puissants qui vous permettent de regarder à l'intérieur et de déterminer précisément le type ou la classe d'une variable.

Dans cet article, nous allons voir comment afficher le type d'une variable en Swift, en utilisant type(of:), Mirror, String(describing:) et même le bon vieux dynamicType (oui, il est toujours présent dans le code legacy). Vous apprendrez non seulement à imprimer le type, mais aussi à l'utiliser dans des projets réels : pour le débogage, la journalisation, la vérification des types à l'exécution et le travail avec les protocoles.

Cet article est rédigé pour le site éducatif pythonlib.ru et adapté aux développeurs débutants et expérimentés. C'est parti !

1. La méthode la plus simple : type(of:)

La façon la plus courante et correcte de connaître le type d'une variable en Swift est d'utiliser la fonction globale type(of:). Elle renvoie le métatype (MetaType) de la valeur passée.

Exemple :

let name = "Anna"\nlet age = 25\nlet price: Double = 99.99\nlet isActive = true\n\nprint(type(of: name))   // String\nprint(type(of: age))    // Int\nprint(type(of: price))  // Double\nprint(type(of: isActive)) // Bool\n

Notez que type(of:) fonctionne avec tous les types : structures, classes, énumérations, closures. Même avec les valeurs optionnelles :

var optionalValue: String? = "Hello"\nprint(type(of: optionalValue)) // Optional<String>\n

Pourquoi type(of:) est-il le meilleur choix ?

\n
• Fonctionne avec les value types (structures, énumérations) et les reference types (classes).
\n
• Prend en charge les protocoles et les génériques.
\n
• Ne nécessite pas de spécification explicite du type dans le code.
\n
• Renvoie le type dynamique exact (prend en compte l'héritage).
\n

2. La méthode classique : String(describing:)

Parfois, vous n'avez pas seulement besoin de connaître le type, mais de le convertir en chaîne de caractères pour l'afficher dans un journal ou une interface. String(describing:) fait parfaitement l'affaire :

let value: Any = 42\nprint(String(describing: type(of: value))) // Int\n

Vous pouvez le combiner avec type(of:) pour une journalisation élégante :

func logType(_ value: Any) {\n    let typeName = String(describing: type(of: value))\n    print("[LOG] Type : \\(typeName), valeur : \\(value)")\n}\nlogType(3.14)  // [LOG] Type : Double, valeur : 3.14\n

3. Travail avec les classes : dynamicType et Mirror

Avant Swift 3, on utilisait la propriété dynamicType. Elle est toujours disponible pour la rétrocompatibilité, mais officiellement dépréciée. Cependant, vous pouvez la rencontrer dans d'anciens projets :

class Animal {}\nclass Dog: Animal {}\n\nlet pet: Animal = Dog()\nprint(pet.dynamicType) // Dog (syntaxe obsolète)\n

Le remplacement moderne est type(of:) :

print(type(of: pet)) // Dog\n

Mirror : regarder plus en profondeur

Si vous avez besoin de connaître non seulement le type, mais aussi la structure de l'objet (par exemple, les noms des propriétés), utilisez Mirror :

struct User {\n    let name: String\n    let age: Int\n}\n\nlet user = User(name: "Ivan", age: 30)\nlet mirror = Mirror(reflecting: user)\nprint(mirror.subjectType) // User\nfor child in mirror.children {\n    print("\\(child.label ?? "") : \\(child.value) (\\(type(of: child.value)))")\n}\n// Affichage :\n// name : Ivan (String)\n// age : 30 (Int)\n

C'est particulièrement utile pour déboguer des hiérarchies complexes ou travailler avec la réflexion.

4. Détermination de la classe pour Any et AnyObject

En Swift, le type Any est courant : il peut stocker une valeur de n'importe quel type. Pour connaître le type spécifique