Types de données

Il existe de nombreux types de données, et Swift les traite tous de manière individuelle. Vous avez déjà vu l'un des types les plus importants lorsque vous avez assigné du texte à une variable. En Swift, cela s'appelle une String, littéralement une chaîne de caractères.

Les chaînes de caractères peuvent être longues (par exemple un million de lettres ou plus), courtes (par exemple 10 lettres) ou même vides (sans lettre). Peu importe, ce sont toutes des chaînes de caractères aux yeux de Swift, et toutes fonctionnent de la même façon. Swift sait que name doit contenir une chaîne de caractères parce que nous lui en avons attribué une lorsque nous l'avons créée : "Tim McGraw". Si nous réécrivions notre code comme ceci, il cesserait de fonctionner :

var name
name = "Tim McGraw"

En efet, Xcode vous donne un message d'erreur qui n'a pas beaucoup de sens pour le moment : "Type annotation missing in pattern". Ce qui signifie "Je n'arrive pas à savoir quel type de données a name parce que vous ne m'avez pas donné assez d'informations".

À ce stade, nous avons deux options : soit créer notre variable et lui donner une valeur initiale sur une ligne de code, soit utiliser ce qu'on appelle type annotation (annotation du type), où nous disons à Swift quel type de données la variable contiendra plus tard, même si nous ne lui donnons pas de valeur pour le moment.

Nous avons déjà vu à quoi ressemble la première option, maintenant regardons la seconde. Nous savons que name sera une chaîne de caractères, donc nous pouvons le dire à Swift en écrivant deux points puis String, comme ceci :

var name: String
name = "Tim McGraw"

Dans les projets d'applications réelles - contrairement aux playgrounds - cela fonctionne très bien, parce que Swift sait quel type de données name aura dans l'avenir. Les playgrounds étant un cas un peu particulier, nous obtiendrons quand même une erreur.

Remarque : certaines personnes aiment mettre un espace avant et après les deux-points, en écrivant var name : String, mais ils ont tort et vous devriez essayer de ne pas prendre cette mauvaise habitude.

Ce qu'il faut retenir ici c'est que Swift veut toujours savoir quel type de données chaque variable ou constante contiendra. Toujours. Vous ne pouvez pas y échapper, et c'est une bonne chose parce que Swift est doté d'un mécanisme qu'on appelle type safety - si vous dites "ceci contiendra une chaîne de caractères" puis essayez plus tard d'y mettre un lapin, Swift n'acceptera pas.

Essayons cela en introduisant un autre type de données important, appelé Int, qui est l'abréviation de "integer" (nombre entier). Les nombres entiers sont des nombres ronds comme 3, 30, 300 ou -16777216. Par exemple :

var name: String
name = "Tim McGraw"

var age: Int
age = 25

Ce code déclare qu'une variable est une chaîne de caractères et qu'une autre est un entier. Notez que String et Int commencent par une majuscule, alors que name et age commencent par une lettre minuscule : c'est la convention standard lorsque l'on programme en Swift. Une convention en programmation est quelque chose qui n'a pas d'importance pour Swift (vous pouvez écrire vos noms comme vous voulez !) mais qui en a pour les autres développeurs. Dans ce cas, les types de données commencent par une majuscule, mais pas les variables ni les constantes.

Maintenant que nous avons des variables de deux types différents, nous pouvons voir type safety en action. Écrivons ceci :

nom = 25
age = "Tim McGraw"

Dans ce code, nous essayons de mettre un entier dans une variable de type String, et une chaîne de caractères dans une variable de type Int, et heureusement, Xcode génère des erreurs. Vous pourriez penser que c'est du pinaillage, mais c'est en fait très utile : vous faites la promesse qu'une variable contiendra un type particulier de données, et Xcode vous l'imposera tout au long de votre travail.

Avant de continuer, effacez les deux lignes de code à l'origine de l'erreur, sinon plus rien dans votre playground ne fonctionnera !

Float et Double

Examinons deux autres types de données, appelés Float et Double. Ils correspondent à la façon dont Swift stocke les nombres avec une virgule, tels que 3.1 ou 3.141 ou bien encore 3.1415926 et -16777216.5. Il y a deux types de données pour cela parce que vous pouvez choisir la précision que vous voulez, mais la plupart du temps, cela n'a pas d'importance. D'ailleurs la recommandation officielle d'Apple est d'utiliser par défaut Double car avec ce type de données la précision est plus élevée.

Saisissons ces quelques lignes de code dans notre playground :

var latitude: Double
latitude = 36.166667

var longitude: Float
longitude = -86.78333333

Attention, lorsqu'on écrit un nombre, nos virgules françaises sont des points en anglais.

Vous pouvez voir les deux nombres apparaître à droite, mais regardez attentivement car il y a une petite différence. Nous avons dit que la longitude devait être égale à -86.783333, mais dans le panneau des résultats nous lisons -86.78333 - il manque le dernier 3 à la fin. Alors, vous pourriez bien dire, "entre nous, qu'est-ce que 0,000003 ?", mais cela démontre bien ce que je disais au sujet de la précision.

Parce que les playgrounds se mettent à jour au fur et à mesure que vous tapez, changez le code comme suit pour que vous puissiez voir exactement en quoi Float et Double diffèrent.

var longitude: Float
longitude = -86.783333
longitude = -186.783333
longitude = -1286.783333
longitude = -12386.783333
longitude = -123486.783333
longitude = -1234586.783333

Nous ajoutons de plus en plus de chiffres avant la virgule, tout en gardant le même nombre après. Mais si vous regardez dans le panneau des résultats, vous remarquez qu'en ajoutant plus de chiffres avant le point, Swift supprime les chiffres qui sont après. C'est parce qu'il a un espace limité pour stocker votre nombre, donc il stocke d'abord la partie la plus importante - 1 000 000 est bien plus important que 0,000003.

Essayons maintenant de changer le Float en Double. Nous voyons que Swift indique le bon nombre à chaque fois :

var longitude: Double

C'est parce que, encore une fois, Double est deux fois plus précis que Float, Swift n'a donc pas besoin de tronquer notre nombre pour l'adapter. Cependant, les Double ont encore des limites - si vous essayez avec un très grand nombre comme 123456789.123456789 vous constaterez que le résultat est réduit à 123456789.12345679.

Booléen

Swift a un type de données intégré qui peut stocker si une valeur est vraie ou fausse, appelé un Bool, abréviation de booléen. Les booléens n'ont pas de place pour le doute, les "peut-être", mais uniquement pour les valeurs "true" (vrai) ou "false" (faux). Par exemple :

var stayOutTooLate: Bool
stayOutTooLate = true

var nothingInBrain: Bool
nothingInBrain = true

var missABeat: Bool
missABeat = false

Utiliser judicieusement la syntaxe

Comme vous l'avez appris, il y a deux façons de dire à Swift quel est le type de données d'une variable : assigner une valeur lorsque vous créez la variable, ou utiliser type annotation. Si vous avez le choix, la première est toujours préférable car elle est plus claire. Par exemple :

var name = "Tim McGraw"

... est préféré à :

var name: String
name = "Tim McGraw"

Ceci s'applique à tous les types de données. Par exemple :

var age = 25
var longitude = -86.783333
var nothingInBrain = true

Cette technique est appelée type inference (déduction du type), parce que Swift peut déduire quel type de données doit être utilisé pour une variable en regardant la valeur de la donnée que vous lui avez assigné. Quand il s'agit de nombres comme -86.783333, Swift déduira toujours un Double plutôt qu'un Float.

Pour être vraiment complet sur le sujet, je dois ajouter qu'il est possible de spécifier un type de données et de fournir une valeur en même temps, comme ceci :

var name: String = "Tim McGraw"

Sponsor Hacking with Swift and reach the world's largest Swift community!