Nous avons compris ce qu'étaient les variables dans le chapitre précédent. Elles permettent d'associer un nom à une valeur. Nous avons pu jouer un peu avec ces variables et les opérateurs pour faire des opérations simples. Mais tout ne s'est pas passé sans encombre. Vous vous souvenez de ceci :
3/2 // Le résultat est 1
3/2.0 // Le résultat est 1.5
Ça n'a quand même pas l'air très logique ; alors investiguons !
Découvrez les types
La raison principale, c'est que je ne vous ai pas tout dit sur les variables ! Elles contiennent en fait trois informations :
un nom ;
une valeur ;
... et un type !
Euh... C'est quoi le type ?
C'est tout simplement le type d'information que l'on va stocker dans la variable. Il y en a une infinité, et vous allez même apprendre à en créer. Mais pour vous donner quelques exemples, un type peut être :
un nombre entier ;
un nombre décimal ;
une chaîne de caractères ;
etc.
Quel est l'intérêt de ces types ?
Il y en a 2.
Lorsque l'on va utiliser une variable, puisqu'elle a un type, l'ordinateur va savoir de quoi il s'agit. Il va donc pouvoir nous suggérer des méthodes logiques. Par exemple : si c'est une chaîne de caractères, il nous proposera une méthode pour tout mettre en majuscules.
Surtout, cela permet de stocker la variable correctement en mémoire. Un nombre entier et un nombre décimal ne prennent pas la même place en mémoire. Donc en sachant à l'avance de quel type il va s'agir, l'ordinateur va pouvoir allouer directement la place nécessaire en reconnaissant le type. C'est plus optimisé comme ceci.
Rentrons tout de suite dans le vif du sujet avec les types numériques.
Appréhendez les types numériques
Pour déclarer un nombre avec Swift, il existe trois types :
Int
pour déclarer un nombre entier ;Float
pour déclarer un nombre décimal ;Double
pour déclarer un nombre décimal.
Euh... Tu te répètes...
Oui, bien vu ! Il y a 2 types différents pour déclarer un nombre décimal : Float
et Double
. Pourquoi ? Comme son nom l'indique, Double
est un type deux fois plus gros que Float
.
C'est-à-dire ?
Cela veut dire qu'une variable de type Double
peut stocker des nombres deux fois plus précisément que Float
.
C'est-à-dire ?
Vous êtes exigeant ! Prenons un exemple. Admettons que je veuille créer une variable qui contient la valeur 1876.79797657
. C'est une valeur sacrément précise ! Elle contient 12 chiffres ! Un Double
pourra la stocker en mémoire, car ce type prévoit suffisamment de place pour 12 chiffres.
Mais un Float
ne pourra stocker que les 6 premiers chiffres, car il a deux fois moins de place que le Double
. Il stockera donc 1876.79
.
C'est-à-dire ?
Bien essayé, mais je ne peux pas plus détailler. J'ai fait de mon mieux...
Du coup, j'utilise quoi si je veux un nombre décimal ?
Cela dépend de la précision que vous souhaitez obtenir. En pratique, si les deux solutions peuvent convenir, Apple recommande l'utilisation de Double
. Un nombre à virgule est d'ailleurs évalué comme un Double
par défaut par Swift. Cela vous permettra d'être large dans la précision, et Swift est suffisamment optimisé pour vous permettre cette concession.
Par exemple, il est déconseillé d’utiliser un Float
pour une opération arithmétique telle qu’une simple soustraction, par exemple.
Ah oui ? Mais pourquoi ?
Vous allez finir par me faire cracher le morceau !
Allez, je vous montre un exemple. Dans le Playground, lorsque je fais :
var cinqMillions: Float = 5000000.0
var moins: Float = 1149.8
var reste: Float = cinqMillions - moins
On obtient 4998850
et non 4998850.2
:
Il faut donc toujours garder en tête qu’en utilisant un Float
, on peut avoir une perte de précision sur des opérations, de par sa nature même et sa conception dans un compilateur. N'utilisez donc les Float
que si Swift l'exige, ou que vous avez un fort besoin de performance.
Déclarez une variable avec un type
Avec Swift, une variable a toujours un type. Swift est capable de déduire le type tout seul. Mais comme on vous l’a dit, il est toujours préférable de donner un type à ses variables. Question de bonne pratique !
Pour cela, on utilise la syntaxe suivante :
var nom: Type = valeur
Par exemple :
var taille: Float = 180.5
Je déclare le nom de ma variable, taille
puis son type, Float
, puis je lui assigne une valeur, 180.5
.
Pour bien comprendre cela, je vous propose le petit exercice suivant. Copiez ceci dans votre Playground :
var a:Double = 1876.79797657765609870978709780987
var b:Float = 1876.79797657765609870978709780987
var c = 1876.79797657765609870978709780987
On déclare a
comme étant un Double
, b
est un Float
, et on laisse Swift deviner le type de c
. Voici ce que Swift vous propose sur la droite :
On peut constater plusieurs choses :
Le nombre est trop grand pour être stocké en entier même pour un type
Double
. Il est donc tronqué après le 16e chiffre.La variable
b
est bien unFloat
puisqu'elle est tronquée à la moitié de la variablea
qui est unDouble
.Swift a bien déduit que la variable
c
était unDouble
en reconnaissant un chiffre à virgule.Double
est bien le type par défaut des nombres décimaux.
Reprenons maintenant notre code :
// Le prix du voyage aux Caraïbes de Joe
var price = 1499
// Le bénéfice quotidien de Joe avec sa ferme
var dailyBenefit = 10
// Le nombre de jours pendant lesquelles Joe doit économiser
var result = price / dailyBenefit
La variable result
est un entier, donc de type Int
. Or, on prévoit que le résultat de 1499/10
ne sera pas un nombre entier. On va donc modifier nos déclarations pour obtenir un résultat non entier.
var price: Double = 1499 // ou alternativement => var price = 1499.0
Avec cette modification, le Playground vous présente une erreur. En effet, la variable price
est maintenant un Double
, mais la variable dailyBenefit
est toujours un entier.
Pour corriger ça, c'est évidemment très simple. Il suffit de déclarer dailyBenefit
de type Double
. Je vous laisse le faire et constater que maintenant la variable result
contient un nombre décimal.
Découvrez le type String
Non, on ne va pas parler slip...
Le type String
, c'est simplement le type des chaînes de caractères, plus simplement des mots et des lettres.
Pour que l'ordinateur puisse faire la différence entre le code et une chaîne de caractères, on déclare une chaîne de caractères entre guillemets "
comme ceci :
"Je suis une chaîne de caractères"
Évidemment, on peut déclarer une variable qui contient une chaîne de caractères. Dans ce cas, Swift devine son type : String
.
var text = "Je suis un texte" // Swift déduit que la variable text est du type String
On peut également indiquer le type de façon explicite comme pour les types numériques :
var explicitText: String = "Je suis à coup sûr un texte"
En pratique, vous n'aurez pas à le faire, car Swift le déduit seul.
Et comment faire si je veux écrire plusieurs lignes dans une seule et même variable ?
Comme vous le savez maintenant : les chaînes de caractères utilisent des guillemets doubles !
En revanche, ces dernières ne permettent pas d’y inclure aussi des sauts de lignes. Donc sachez que pour faire cela, on utilise les chaînes de caractères multilignes.
Pour ce faire, vous avez besoin d’une syntaxe légèrement différente : commencez et finissez par trois guillemets doubles, comme ceci :
var multilineText = """
Je suis
à coup
sûr
un texte
"""
Lorsque votre code source inclut un saut de ligne à l'intérieur d'une chaîne de caractères multiligne, ce saut de ligne apparaît également dans la valeur de la chaîne. Ce qui nous donne "Je suis\nà coup\nsûr\nun texte"
.
Si vous souhaitez utiliser des sauts de ligne pour faciliter la lecture de votre code, mais que vous ne voulez pas que les sauts de ligne fassent partie de la valeur de la chaîne comme dans l’exemple ci-dessus, écrivez tout simplement un antislash ( \
) à la fin de ces lignes :
var multilineText2 = """
Je suis \
à coup \
sûr \
un texte
"""
Voici le résultat : "Je suis à coup sûr un texte"
.
Les méthodes
Comme pour les types numériques, on va pouvoir utiliser des opérateurs pour les strings, et leur affecter des modifications. La première façon de les modifier, c'est la concaténation.
La contanétaki ?
La concaténation ! C'est le fait d'assembler deux chaînes de caractères l'une à la suite de l'autre. On fait cela en utilisant l'opérateur +
. Par exemple :
var phrase = "Je suis le début de la phrase... " + "Et moi la fin !"
// Le playground affiche : "Je suis le début de la phrase... Et moi la fin !"
Simple, non ?
Allez, on grimpe un peu en difficulté. Essayons d’inclure un nombre dans une phrase. Par exemple la variable suivante :
var age = 24
Avec cette information, je pourrais construire la phrase :
"Vous avez 24 ans !"
Pour cela, on remplace 24 par la syntaxe suivante :
"Vous avez \(age) ans !" // Le playground lit : "Vous avez 24 ans !"
On place entre parenthèses la variable age
, et l’on ajoute l'antislash devant.
Faisons un petit exercice pour vérifier que vous m'avez bien suivi ! Le contenu de l’exercice se trouve dans le dossier Github P1C4.
Ouvrez un nouveau Playground Xcode.
Copiez le contenu du fichier “main.swift” dans votre Playground.
Suivez les instructions.
Avec cette nouvelle technique, nous allons pouvoir générer notre réponse à Joe directement depuis le Playground !
Un peu de philosophie
Avant de clore ce chapitre, je vous propose un petit peu de philosophie... N'ayez crainte, rien de grave !
Ce qui différencie les langages de programmation, au-delà de leur syntaxe, c'est surtout l'approche avec laquelle ils ont été conçus.
Swift a été conçu pour être particulièrement protégé. C'est la philosophie de ceux qui l'ont conçu. Cela signifie que, contrairement à d'autres langages, Swift est très très structuré. Cela permet d'éviter aux développeurs quelques bêtises, en leur signalant tout de suite qu'ils s'apprêtent à faire quelque chose de dangereux.
Cela est particulièrement vrai pour les types. C'est la raison pour laquelle je vous en parle maintenant !
Contrairement à d'autres langages, Swift est très strict sur les variables qui doivent obéir à 2 règles.
1. Une variable ne peut pas changer de type.
Essayons (faites-le avec moi !) de transgresser cette règle :
var text = "Je suis un texte" // La variable est de type String
text = 2 // Pour contenir ce nombre, la variable doit devenir de type Int
Swift présente une erreur : Cannot assign value of type 'Int' to type 'String'. En français : "Je ne peux assigner une valeur de type Int
à une variable de type String
" .
2. Une variable a toujours un type
Autrement dit, une variable sans type n'existe pas. On ne peut donc pas écrire le code suivant :
var chose
Swift déclare : Type annotation missing in pattern. En français : le type n'est pas indiqué.
On peut en revanche déclarer une variable sans valeur. Comme ceci :
var chose: String
La variable a un type. Swift est content ! C'est tout ce qu'il lui faut. Il accepte qu'on lui donne la valeur plus tard.
En résumé
Une variable a trois informations :
une valeur ;
un nom ;
un type.
Vous connaissez désormais 4 types :
3 types numériques :
Int
pour les nombres entiers ;Float
pour les nombres décimaux ;Double
pour les nombres décimaux avec 2 fois plus de précisions.
1 type pour les chaînes de caractères :
String
.
Swift est un langage strict. On ne peut pas faire n'importe quoi ! Notamment :
Une variable a toujours un type.
Une variable ne peut pas changer de type.
Nous y voilà ! Comme promis, les variables n’ont dorénavant plus de secret pour vous. Et si maintenant, si on retournait voir Joe pour lui annoncer la bonne nouvelle ? N’oubliez pas de valider vos acquis avec le quiz !