Mis à jour le lundi 30 octobre 2017
  • 30 heures
  • Facile

Ce cours est visible gratuitement en ligne.

Ce cours est en vidéo.

Vous pouvez obtenir un certificat de réussite à l'issue de ce cours.

J'ai tout compris !

Assimilez le concept de type

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

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 !

Investiguons !
Investiguons !

Le "type", kézako ?

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.

  1. 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.

  2. 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 exactement 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.

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 2 fois plus précisément que  Float .

C'est-à-dire ?

Vous êtes exigeant ! Prenons un exemple. Si je veux 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 2 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... :honte:

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.

N'utilisez donc les  Float que si Swift l'exige ou que vous avez un fort besoin de performance.

Déclarer une variable avec un type

Avec Swift, une variable a toujours un type. Swift est capable de déduire le type tout seul. Mais parfois, on va avoir envie de décider nous-mêmes du type. 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 :

  1. 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.

  2. La variablebest bien un  Float  puisqu'elle est tronquée à la moitié de la variableaqui est un  Double .

  3. Swift a bien déduit que la variablecétait un  Double  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.

Le type String

Non, on ne va pas parler slip...

Présentation

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.

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 :D ! 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 ! Essayez de faire écrire le message suivant à votre ordinateur : "Cher Joe, il te faudra économiser pendant X jours pour te payer ton voyage à X €". Évidemment, il vous faut remplacer les X par les bonnes valeurs. Je vous laisse essayer seul, ne trichez pas !

// Essayez par vous-même !



















































let message = "Cher Joe, il te faudra économiser pendant \(result) jours pour te payer ton voyage à \(price) €"

Vous avez trouvé ? Bravo !

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 qu'ils 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 signalant tout de suite aux développeurs 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 (faîtes 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

  • Il y a 3  façons de déclarer une variable

    var text: String 
    // Le type est annoté ce qui est nécessaire car la variable n'est pas initialisé avec une valeur
    var text = "Je suis un texte"
    // Le type est déduit à partir de la valeur de la variable
    var text: String = "Je suis un texte"
    // Le type est annoté, ce n'est pas nécessaire car il peut être déduit. Mais ce n'est pas interdit.
  • 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 

      • On peut concaténer les chaînes avec l'opérateur  + 

      • On peut insérer une variable d'un autre type avec  \(nomDeMaVariable) .

  • 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

 

Exemple de certificat de réussite
Exemple de certificat de réussite