Cette documentation est encore en cours de rédaction chez Apple et des corrections peuvent être apportées au cours des semaines à venir.

Swift possède un type de base, les Booléens, appelés Bool. Les valeurs booléennes sont définies comme logiques, parce-qu’elles ne peuvent qu’être vraies ou fausses. Swift possède deux valeurs booléennes constantes, true et false :

1 let orangeEstOrange = true
2 let navetEstDelicieux = false

Le type de orangeEstOrange et navetEstDelicieux a été définit comme Bool du fait que les deux contantes ont été initialisées avec un valeur littérale booléenne. Comme pour les Int et les Double que nous avons vu précédemment, vous n’avez pas besoin de déclarer vos variables ou vos constantes en tant que Bool si vous leur attribuez la valeur true ou false lors de leur création. La déduction de type de Swift vous aide à obtenir un code plus concis et lisible lorsque vous initialisez une constante ou une variable avec une valeur dont le type est déjà connu.

Les valeurs booléennes sont particulièrement utiles quand vous travaillez avec des conditions, comme c’est le cas par exemple avec if :

1 if navetEstDelicieux {
2     println("Mmmh ! Les navets gouteux !")
3 } else {
4     println("Beurk ! Les navets sont horribles !")
5 }
6 // Le programme affichera "Beurk ! Les navets sont horribles !"

Les conditions comme le if sont expliquées plus en détails dans la partie “Flux de contrôle”.

La sécurisation des types de Swift empêche les valeurs non-booléennes de se substituer au type Bool. L’exemple suivant provoque une erreur à la compilation :

1 let i = 1
2 if i {
3     // Cet exemple ne pourra pas être compilé !
4 }

Cependant l’exemple alternatif ci-dessous est valide :

1 let i = 1
2 if i == 1 {
3     // Cet exemple pourra être compilé !
4 }

Le résultat de i == 1 est une comparaison de type Bool, et dans ce second exemple, la vérification des types ne posera pas de problème. Pour plus de détails référez-vous à la partie “Opérateurs de base”.

Comme avec les autres exemples sur la sécurisation des types du langage Swift, cette approche permet d’éviter les erreurs accidentelles et assure que vos intentions sont toujours parfaitement retranscrites dans chaque section de votre code.

Les tuples

Les Tuples servent à regrouper de nombreuses valeurs en un seule valeur composée unique. Les valeurs d’un tuple peut être de n’importe quel type et n’ont pas forcement besoin d’être du même type les unes par rapport aux autres.

Dans cet exemple, (404, "Introuvable") est un tuple décrivant un code d’erreur HTTP. Ce code d’erreur HTTP est une valeur spéciale retournée par un serveur web lorsque vous souhaitez charger une page. Le code 404 Introuvable est retourné si la page web demandée n’existe pas.

1 let erreur404Http = (404, "Introuvable")
2 // le code d'erreur est du type (Int, String) et égale à (404, Introuvable)

Le tuple (404, "Introuvable") regroupe ensemble un entier et une chaine de caractères pour produire un code d’erreur HTTP composé de deux valeurs : un nombre pour la machine et une description compréhensible pour l’homme. On dit que le type du tuple est (Int, String).

Vous pouvez créer des tuples avec n’importe quelle combinaison de types, ils peuvent contenir beaucoup plus de deux valeurs et elles ne doivent pas nécessairement avoir le même type. Rien ne vous empêche cependant d’avoir un tuple du type (Int, Int, Int), ou (String, Bool). Toutes les combinaisons sont possibles.

Vous pouvez décomposer le contenu d’un tuple en plusieurs constantes ou variables séparées, auxquelles vous accédez comme d’habitude :

1 let (codeErreur, messageErreur) = erreur404Http
2 println("Le code d'erreur est \(codeErreur)")
3 // Affiche "Le code d'erreur est 404"
4 println("Le message d'erreur est \(messageErreur)")
5 // Affiche "Le message d'erreur est Introuvable"

Si vous avez juste besoin de récupérer une partie des valeurs d’un tuple, vous pouvez ignorer les autres parties en utilisant un underscore lors de la décomposition du tuple :

1 let (justeCodeErreur, _) = erreur404Http
2 println("Le code d'erreur est \(justeCodeErreur)")
3 // Affiche "Le code d'erreur est 404"

De façon alternative, vous pouvez accéder à la valeur d’un élément individuellement en utilisant son index (commençant à zéro) :

1 println("Le code d'erreur est \(erreur404Http.0)")
2 // Affiche "Le code d'erreur est 404"
3 println("Le message d'erreur est \(erreur404Http.1)")
4 // Affiche "Le message d'erreur est 404"

Vous pouvez nommer chacun des éléments d’un tuple de façon individuelle lorsque vous initialisez votre constante :

let erreur200Http = (codeErreur: 200, messageErreur: "OK")

Si vous nommez les éléments d’un tuple, vous pouvez utilisez le nom de ces éléments pour accéder à leur valeur respective :

1 println("Le code d'erreur est \(erreur200Http.codeErreur)")
2 // Affiche "Le code d'erreur est 200"
3 println("Le message d'erreur est \(erreur200Http.messageErreur)")
4 // Affiche "Le message d'erreur est OK"

Les tuples sont particulièrement utile pour retourner des valeurs de fonctions. Une fonction qui essaie de récupérer une page web pourrait retourner un tuple du type (Int, String) pour décrire si le chargement de la page a été couronné de succès ou non. En retournant un tuple avec deux valeurs distinctes, chacune d’un type différent, la fonction reçoit des informations beaucoup plus pertinente qu’elle n’aurait pas forcement pu traiter efficacement s’il avait s’agit uniquement de valeurs du type String. Pour plus d’informations, reportez-vous à la partie “Fonctions aux multiples valeurs”.

Note : Les tuples sont utiles pour stocker temporairement un groupe de valeurs. Elles ne sont pas là pour créer une structure de données complexes. Si la structure de vos données requiert un stockage sur la long terme, préférez une structure de vos données architecturées autour des classes, plutôt qu’autour des tuples. Pour plus d’informations, référez-vous à la partie “Classes et structures”.