Créer et utiliser des variables en Kotlin

1. Avant de commencer

Dans les applications de votre téléphone, vous remarquerez que certaines parties de l'appli restent les mêmes, tandis que d'autres changent (ou sont variables).

Par exemple, les noms des catégories dans l'application Paramètres restent les mêmes : "Réseau et Internet", "Appareils connectés", "Applications", etc.

En revanche, les articles changent souvent dans une application d'actualités. Le nom, la source, l'heure de publication et les images des articles changent.

Comment rédiger votre code pour que le contenu évolue au fil du temps ? Vous ne pouvez pas réécrire le code dans votre application chaque fois que de nouveaux articles sont publiés, chaque jour, chaque heure et chaque minute.

Dans cet atelier de programmation, vous allez apprendre à écrire du code qui utilise des variables afin que certaines parties de votre programme puissent être modifiées sans nécessiter un nouvel ensemble d'instructions. Vous utiliserez Kotlin Playground comme dans l'atelier précédent.

Objectifs de l'atelier

• Programmes courts en Kotlin qui utilisent des variables.

Points abordés

• Comment définir une variable et mettre à jour sa valeur
• Comment sélectionner un type de données approprié pour une variable parmi les types de données de base en Kotlin
• Comment ajouter des commentaires à votre code.

Ce dont vous aurez besoin

• Un ordinateur avec accès à Internet et un navigateur Web.

2. Variables et types de données

En programmation informatique, une variable est un conteneur qui ne contient qu'une seule donnée. Vous pouvez vous la représenter comme une boîte qui contiendrait une seule valeur. La boîte comporte un libellé qui correspond au nom de la variable. En faisant référence à la boîte en l'appelant par son nom, vous avez accès à la valeur qu'elle contient.

Pourquoi stocker la valeur dans une boîte et faire référence à la boîte avec son nom, au lieu de l'utiliser directement ? Un problème se pose : lorsque votre code utilise des valeurs directement dans toutes les instructions, votre programme ne fonctionne que pour ce cas spécifique.

Voici une analogie qui peut vous aider à comprendre plus facilement l'utilité des variables. Une personne que vous avez rencontrée récemment vous a envoyé la lettre ci-dessous.

Chère Lauren,

Ce fut un plaisir de vous voir aujourd'hui au bureau. J'ai hâte de vous voir vendredi.

Bonne journée !

Cette lettre est intéressante, mais elle ne peut s'appliquer que dans votre situation spécifique avec Lauren. Pourquoi ne pas écrire la même lettre plusieurs fois, avec de légères variations selon les personnes ? Il serait plus efficace de créer un modèle de lettre unique, en laissant les champs vides pour les parties susceptibles d'être modifiées.

Bonjour ____ ,

Ce fut un plaisir de vous voir aujourd'hui _________. J'ai hâte de vous voir ___________ .

Bonne journée !

Vous pouvez également spécifier le type d'informations qui figurent dans chaque espace. Ainsi, le modèle de lettre pourra s'adapter à chaque cas spécifique.

Bonjour { name } ,

Ce fut un plaisir de vous rencontrer aujourd'hui { location } (lieu). J'ai hâte de vous voir { date }.

Bonne journée !

Lors de la création d'une application, vous appliquez un concept similaire. Vous disposez d'espaces réservés pour certaines données, tandis que d'autres parties de l'application restent identiques.

Dans l'illustration ci-dessus, le texte "Welcome" (Bienvenue), le titre "Last News for You" (Dernières actualités pour vous) et le bouton "View more articles" (Afficher plus d'articles) dans une application News restent inchangés. À l'inverse, le nom d'utilisateur et le contenu de chaque article seront modifiés. C'est une excellente occasion d'utiliser des variables pour stocker chaque information.

Vous ne voudriez pas écrire un code (ou des instructions) dans votre application News qui ne fonctionnerait que pour un utilisateur nommé Alex, ou pour un article d'actualités qui aurait toujours le même titre et la même date de publication. Votre application doit être flexible : vous devez donc écrire votre code en faisant référence à des noms de variables tels que name, article1Name, article1Date, etc. Votre code englobe alors tous les cas d'utilisation, et adaptera le nom de l'utilisateur et les informations sur l'article selon les cas rencontrés.

Exemple d'application contenant des variables

Voyons un exemple d'application qui peut utiliser des variables.

Dans une application de type Maps, une fenêtre d'informations affiche des informations sur chaque établissement (p. ex. un restaurant ou une entreprise). La capture d'écran ci-dessus de l'application Google Maps affiche des informations sur le siège de l'entreprise de Google, le Googleplex. Selon vous, quelles données sont stockées en tant que variables dans l'application ?

• Nom du lieu
• Note du lieu
• Nombre d'avis sur le lieu
• Indique si l'utilisateur a enregistré ou ajouté ce lieu à ses favoris
• Adresse du lieu
• Description du lieu

Modifiez les données stockées dans ces variables. Votre application Google Maps est suffisamment flexible pour afficher des informations sur d'autres lieux.

Types de données

Lorsque vous choisissez où placer des variables dans votre application, vous devez spécifier le type de données pouvant être stockées dans ces variables. En langage Kotlin, certains types de données de base sont fréquemment utilisés. Le tableau ci-dessous, chaque ligne vous présente un type de données différent. Chaque type de données est associé à une description du type de données qu'il peut contenir et des exemples de valeurs.

Type de données Kotlin	Types de données qu'il peut contenir	Exemples de valeurs littérales
String	Texte	"Add contact" "Search" "Sign in"
Int	Nombre entier	32 1293490 -59281
Double	Nombre décimal	2.0 501.0292 -31723.99999
Float	Nombre décimal (moins précis qu'un Double), suivi de f ou F.	5.0f -1630.209f 1.2940278F
Boolean	true ou false. Utilisez ce type de données quand il n'y a que deux valeurs possibles. Notez que true et false sont des mots clés en Kotlin.	true false

Remarque : Pour connaître les plages valides pour les types de données numériques (Int, Double et Float), consultez Nombres. Pour en savoir plus sur la différence entre Double et Float, consultez ce tableau qui compare les deux types de données.

Vous connaissez maintenant certains types de données courants en langage Kotlin : quel type de données peut-on utiliser pour chacune des variables identifiées dans la page d'informations sur l'établissement vue précédemment ?

• Le nom du lieu est au format texte. Il peut donc être stocké dans une variable dont le type de données est String..
• La note du lieu correspond à un nombre décimal (p. ex. 4,2), et peut donc être stocké en tant que Double.
• Le nombre d'avis sur le lieu est un nombre entier. Vous devez donc le stocker en tant que Int.
• Si l'utilisateur a enregistré cet établissement, il n'a que deux valeurs possibles (enregistré ou non). Il est donc stocké comme une valeur Boolean, où true et false appliquent l'un ou l'autre état.
• L'adresse du lieu est un texte. Il s'agit donc d'une String.
• La description du lieu est également un texte. Il doit donc s'agir d'une String.

Entraînez-vous à l'aide des deux autres situations ci-dessous. Identifiez l'utilisation de variables et leurs types de données dans les applications suivantes.

1. Une application permettant de regarder des vidéos, comme l'application YouTube, comporte un écran affichant les informations de la vidéo. Où peut-on utiliser des variables ? À quel type de données correspondent ces variables ?

Il n'y a pas qu'une seule bonne réponse, mais dans une application de lecture de vidéos, vous pouvez notamment utiliser des variables pour les données suivantes :

• Nom de la vidéo (String)
• Nom de la chaîne (String)
• Nombre de vues de la vidéo (Int)
• Nombre de "J'aime" sur la vidéo (Int)
• Nombre de commentaires de la vidéo (Int)

2. Dans une application de messagerie comme Gmail, l'écran de la boîte de réception affiche les e-mails les plus récents. Où peut-on utiliser des variables ? À quel type de données correspondent ces variables ?

Encore une fois, il n'y a pas qu'une seule bonne réponse. Dans une application de messagerie, vous pouvez utiliser des variables pour les données suivantes :

• Nom de l'expéditeur (String)
• Objet de l'e-mail (String)
• Suivi de l'e-mail (Boolean)
• Nombre de nouveaux e-mails dans la boîte de réception (Int)

Essayer

1. Ouvrez votre application préférée sur votre téléphone.
2. Identifiez les emplacements où l'on utiliserait des variables dans l'application sur un écran spécifique.
3. Devinez à quel type de données correspondent ces variables.
4. Partagez vos réponses sur les réseaux sociaux avec une capture d'écran de l'application, une explication de l'utilisation des variables et le hashtag #AndroidBasics.

Bien joué ! Vous avez fait un excellent travail dans cet atelier de programmation. Passez à la section suivante pour en savoir plus sur l'utilisation des variables et des types de données à utiliser dans votre code.

3. Définir et utiliser des variables

Définir ou utiliser une variable

Vous devez définir une variable dans votre code avant de pouvoir l'utiliser. Vous avez déjà utilisé cette méthode lors du dernier atelier, qui vous a appris à définir les fonctions avant de les appeler.

Lorsque vous définissez une variable, vous lui attribuez un nom unique qui permettra de l'identifier. Vous pouvez également spécifier le type de données qu'il peut contenir. Enfin, vous pouvez fournir une valeur initiale qui sera stockée dans la variable, mais ce n'est pas obligatoire.

Remarque : Vous pourrez rencontrer l'expression alternative "déclarer une variable". Les mots "déclarer" et "définir" peuvent être utilisés de manière interchangeable et ont la même signification. Vous pouvez également entendre le terme "définition de la variable" ou "déclaration de la variable", qui renvoient au code qui définit une variable.

Une fois que vous avez défini une variable, vous pouvez l'utiliser dans votre programme. Pour utiliser une variable, saisissez son nom dans le code. Cette action indique au compilateur Kotlin que vous souhaitez utiliser la valeur de la variable à cet endroit du code.

Par exemple, définissez une variable pour le nombre de messages non lus dans la boîte de réception d'un utilisateur. Cette variable peut être nommée count. Stockez une valeur comme le nombre 2 dans la variable, qui signifient que la boîte de réception de l'utilisateur comporte 2 messages non lus. (Vous pouvez stocker un autre nombre dans la variable, mais pour cet exemple, vous utiliserez le nombre 2.)

Chaque fois que votre code doit accéder au nombre de messages non lus, saisissez count dans votre code. Lors de l'exécution de vos instructions, le compilateur Kotlin voit le nom de la variable dans votre code et utilise la valeur de la variable à la place.

Voici la terminologie technique plus précise pour décrire ce processus :

Une expression est une petite unité de code associée à une valeur. Une expression peut être composée de variables, d'appels de fonction, etc. Dans le cas ci-dessous, l'expression est constituée d'une variable : la variable count. La valeur de l'expression est 2.

Evaluate (to) signifie déterminer la valeur d'une expression. Dans ce cas, l'expression est 2. Le compilateur évalue les expressions dans le code et les utilise lorsque le programme exécute les instructions.

Pour observer ce comportement dans Kotlin Playground, exécutez le programme à la section suivante.

Exemple

1. Ouvrez Kotlin Playground dans un navigateur Web.
2. Remplacez le code existant dans Kotlin Playground par le programme suivant.

Ce programme crée une variable appelée count avec une valeur initiale de 2 et l'utilise en imprimant la valeur de la variable count dans la sortie. Ne vous inquiétez pas si vous ne maîtrisez pas encore tous les aspects de la syntaxe du code. Nous y reviendrons plus en détail dans les prochaines sections.

fun main() {
    val count: Int = 2
    println(count)
}

3. Exécutez le programme. La sortie doit se présenter comme suit :

2

Déclaration de variable

Dans le programme que vous avez exécuté, la deuxième ligne de code indique :

val count: Int = 2

Cette instruction crée une variable entière appelée count qui contient le nombre 2.

Il faut parfois un certain temps pour se familiariser avec la lecture de la syntaxe (ou du format) de déclaration de variable en langage Kotlin. Le schéma ci-dessous indique où se trouve chaque détail de la variable, ainsi que l'emplacement des espaces et des symboles.

Dans le contexte de la variable count, vous pouvez voir que la déclaration de variable commence par le mot val. Le nom de la variable est count. Le type de données est Int, et la valeur initiale est 2.

Chaque partie de la déclaration de variable est expliquée plus en détail ci-dessous.

Mot clé pour définir une nouvelle variable

Pour définir une nouvelle variable, commencez par le mot clé Kotlin val (signifiant "valeur"). Le compilateur Kotlin sait alors qu'une déclaration de variable figure dans cette instruction.

Nom de la variable

Vous attribuez un nom à une variable de la même façon que vous nommez une fonction. Dans la déclaration de variable, le nom de la variable suit le mot clé val.

Vous pouvez choisir le nom de votre choix. Toutefois, il est déconseillé d'utiliser des mots clés Kotlin en tant que nom de variable.

Il est préférable de choisir un nom qui décrit les données contenues dans la variable afin que votre code soit plus facile à lire.

Les noms de variables doivent respecter la convention Camel Case ("casse de chameau"), comme vous l'avez vu pour les noms de fonctions. Le premier mot du nom de la variable s'écrit en minuscules. S'il est composé de plusieurs mots, il ne doit pas y avoir d'espace entre eux, et tous les autres mots doivent commencer par une majuscule.

Exemples de noms de variables :

• numberOfEmails
• cityName
• bookPublicationDate

Pour l'exemple de code présenté précédemment, count est le nom de la variable.

val count: Int = 2

Type de données variable

Après le nom de la variable, vous devez ajouter le signe deux-points, une espace, puis le type de données de la variable. Comme indiqué précédemment, String, Int, Double, Float, et Boolean font partie des types de données de base en Kotlin. Vous découvrirez d'autres types de données dans la suite de ce cours. N'oubliez pas d'orthographier correctement les types de données et de les commencer par une lettre majuscule.

Pour l'exemple de variable count, Int correspond au type de données de la variable.

val count: Int = 2

Opérateur d'attribution

Dans la déclaration de variable, le signe égal (=) suit le type de données. Le signe égal est appelé opérateur d'attribution. L'opérateur d'attribution attribue une valeur à la variable. En d'autres termes, la valeur figurant à droite du signe égal est stockée dans la variable située à gauche du signe égal.

Valeur initiale variable

La valeur de la variable correspond aux données réellement stockées dans la variable.

Pour l'exemple de variable count, le nombre 2 correspond à la valeur initiale de la variable.

val count: Int = 2

Vous pouvez également entendre : "la variable count est initialisée sur 2". Cela signifie que 2 est la première valeur stockée dans la variable lorsque celle-ci est déclarée.

La valeur initiale varie en fonction du type de données déclaré pour la variable.

Reportez-vous au tableau ci-dessous, que vous avez peut-être déjà rencontré dans l'atelier de programmation. La troisième colonne contient des exemples de valeurs pouvant être stockées dans une variable de chaque type correspondant. Ces valeurs sont appelées des littéraux, car il s'agit de valeurs fixes ou constantes (la valeur est constamment identique). Par exemple, l'entier 32 aura toujours la valeur 32. En revanche, une variable n'est pas un littéral, car sa valeur peut changer. Ces valeurs littérales peuvent être mentionnées en fonction de leur type : littéral de chaîne, littéral d'entier, littéral booléen, etc.

Type de données Kotlin	Types de données qu'il peut contenir	Exemples de valeurs littérales
String	Texte	"Add contact" "Search" "Sign in"
Int	Nombre entier	32 1293490 -59281
Double	Nombre décimal	2.0 501.0292 -31723.99999
Float	Nombre décimal (moins précis qu'un Double), suivi de f ou F.	5.0f -1630.209f 1.2940278F
Boolean	true ou false. Utilisez ce type de données quand il n'y a que deux valeurs possibles. Notez que true et false sont des mots clés en Kotlin.	true false

Il est important d'indiquer une valeur appropriée et valide en fonction du type de données de la variable. Par exemple, vous ne pouvez pas stocker de littéral de chaîne comme "Hello" dans une variable de type Int, car le compilateur Kotlin génère une erreur.

Utiliser une variable

Vous trouverez ci-dessous le programme original que vous avez exécuté dans Kotlin Playground. Jusqu'à présent, vous avez appris que la deuxième ligne de code crée une variable entière appelée count, dont la valeur est 2.

fun main() {
    val count: Int = 2
    println(count)
}

Examinons à présent la troisième ligne de code. Vous imprimez la variable count dans la sortie :

println(count)

Notez qu'il n'y a pas de guillemets autour du mot count. Il s'agit d'un nom de variable, pas d'un littéral de chaîne. S'il s'agissait d'un littéral de chaîne, le mot pourrait être entouré par des guillemets. Lorsque vous exécutez le programme, le compilateur Kotlin évalue l'expression contenue entre parenthèses, à savoir count, pour l'instruction println(). Étant donné que l'expression renvoie 2, la méthode println() est appelée avec l'entrée 2  : println(2).

Par conséquent, la sortie du programme est :

2

Le nombre affiché dans la sortie n'est pas très utile. Il serait plus judicieux d'afficher un message plus détaillé dans la sortie pour expliquer ce que 2 représente.

Modèle de chaîne

Voici un exemple de message plus utile :

You have 2 unread messages.

Suivez les étapes ci-dessous pour afficher un message plus utile.

1. Mettez à jour votre programme dans Kotlin Playground avec le code ci-dessous. Pour l'appel println(), transmettez un littéral de chaîne contenant le nom de la variable count. N'oubliez pas d'entourer le texte de guillemets. Notez que vous n'obtiendrez pas les résultats attendus. Vous résoudrez le problème lors d'une prochaine étape.

fun main() {
    val count: Int = 2
    println("You have count unread messages.")
}

2. Exécutez le programme. La sortie doit se présenter comme suit :

You have count unread messages.

Cette phrase n'a aucun sens ! Vous souhaitez que la valeur de la variable count s'affiche dans le message, et non dans le nom de la variable.

3. Pour corriger votre programme, ajoutez le symbole dollar $ avant la variable count : "You have $count unread messages." Il s'agit d'un modèle de chaîne, car il contient une expression de modèle, qui est $count ici. Une expression de modèle est une expression qui prend une valeur, qui est ensuite remplacée dans la chaîne. Dans ce cas, l'expression de modèle $count prend la valeur 2, et 2 est remplacé dans la chaîne où se trouve l'expression.

fun main() {
    val count: Int = 2
    println("You have $count unread messages.")
}

4. Lorsque vous exécutez le programme, la sortie correspond à l'objectif souhaité :

You have 2 unread messages.

Cette phrase est beaucoup plus logique pour l'utilisateur !

5. Remplacez maintenant la valeur initiale de la variable count par un autre littéral entier. Par exemple, vous pouvez choisir le nombre 10. Ne modifiez pas le reste du code.

fun main() {
    val count: Int = 10
    println("You have $count unread messages.")
}

6. Exécutez le programme. Notez que le résultat change en conséquence et que vous n'avez même pas besoin de modifier l'instruction println() dans votre programme.

You have 10 unread messages.

Vous pouvez voir combien le modèle de chaîne peut se révéler utile. Vous n'avez écrit le modèle de chaîne qu'une seule fois dans votre code ("You have $count unread messages."). Si vous modifiez la valeur initiale de la variable count, l'instruction println() fonctionne toujours. Votre code est désormais plus flexible !

Pour illustrer ce point, comparez les deux programmes ci-dessous. Le premier programme ci-dessous utilise un littéral de chaîne : le nombre exact de messages non lus s'affiche directement dans la chaîne. Ce programme ne fonctionne que lorsque l'utilisateur a 10 messages non lus.

fun main() {
    println("You have 10 unread messages.")
}

Si vous utilisez une variable et un modèle de chaîne dans le deuxième programme ci-dessous, votre code couvrira un plus large éventail de cas. Ce deuxième programme est plus flexible !

fun main() {
    val count: Int = 10
    println("You have $count unread messages.")
}

Inférence de type

Voici une astuce qui vous permet d'écrire moins de code lorsque vous déclarez des variables.

On parle d'inférence de type lorsque le compilateur Kotlin peut déduire (ou déterminer) le type de données d'une variable, sans que le type ne soit écrit explicitement dans le code. Cela signifie que vous pouvez omettre le type de données dans une déclaration de variable si vous fournissez une valeur initiale pour cette variable. Le compilateur Kotlin examine le type de données de la valeur initiale et part du principe que vous souhaitez que la variable contienne les données de ce type.

La syntaxe d'une déclaration de variable suivante utilise l'inférence de type :

Revenons à l'exemple de "count" (nombre). Le programme contenait initialement cette ligne de code :

val count: Int = 2

Toutefois, cette ligne de code peut également être rédigée comme suit. Notez que les deux-points (:) et le type de données Int ne sont pas inclus. La syntaxe mise à jour nécessite moins de mots et permet d'obtenir le même résultat lorsque vous créez une variable Int appelée count avec la valeur 2.

val count = 2

Le compilateur Kotlin sait que vous souhaitez stocker 2 (un nombre entier) dans la variable count. Il peut donc déduire que la variable count est de type Int. Plutôt pratique. Il s'agit d'un exemple d'écriture plus concise en Kotlin.

Remarque : Si vous ne fournissez pas de valeur initiale lorsque vous déclarez une variable, vous devez spécifier le type.

Dans cette ligne de code, aucune valeur initiale n'est fournie. Vous devez donc spécifier le type de données :

val count: Int

Dans cette ligne de code, une valeur est fournie : vous pouvez donc omettre le type de données :

val count = 2

Bien que cet exemple ne concerne qu'une variable de type Int, le concept d'inférence de type s'applique à tous les types de données en langage Kotlin.

Opérations mathématiques de base avec nombres entiers

Quelle est la différence entre une variable Int avec la valeur 2 et une variable String avec la valeur "2" ? Lorsqu'elles sont toutes deux affichées dans la sortie, elles sont identiques.

Stocker des entiers en tant que Int (par rapport à String) présente un avantage : vous pouvez effectuer des opérations mathématiques avec des variables Int, telles que des additions, des soustractions, des divisions et des multiplications (voir les autres opérateurs). Par exemple, vous pouvez ajouter deux variables entières pour obtenir la somme des deux. Dans certains cas, il est judicieux de stocker des entiers en tant que chaînes, mais le but de cette section est de vous montrer ce que vous pouvez faire avec des variables Int.

1. Revenez à Kotlin Playground et supprimez tout le code dans l'éditeur de code.
2. Créez un programme dans lequel vous définissez une variable entière pour le nombre d'e-mails non lus dans une boîte de réception, puis initialisez-la avec une valeur comme 5. Vous pouvez choisir un autre nombre si vous le souhaitez. Définissez une deuxième variable entière pour le nombre d'e-mails lus dans une boîte de réception. Initialisez-la sur une valeur comme 100. Vous pouvez choisir un autre nombre si vous le souhaitez. Imprimez ensuite le nombre total de messages dans la boîte de réception en ajoutant les deux nombres entiers.

fun main() {
    val unreadCount = 5
    val readCount = 100
    println("You have ${unreadCount + readCount} total messages in your inbox.")
}

3. Exécutez le programme pour qu'il affiche le nombre total de messages dans la boîte de réception :

You have 105 total messages in your inbox.

Pour un modèle de chaîne, vous avez appris que vous pouvez placer le symbole $ devant un seul nom de variable. Cependant, si votre expression est plus complexe, vous devez placer l'expression entre accolades en faisant précéder celles-ci du symbole $ : ${unreadCount + readCount}. L'expression entre accolades unreadCount + readCount prend la valeur 105. La valeur 105 est ensuite remplacée dans le littéral de chaîne.

Avertissement : Si vous oubliez les accolades autour de l'expression du modèle, vous obtiendrez des résultats inattendus. Vous pouvez effectuer un test dans Kotlin Playground en définissant l'instruction println() sur println("You have $unreadCount + readCount total messages in your inbox.") et en observant le résultat.

4. Pour explorer ce sujet plus en détail, créez des variables avec des noms et des valeurs initiales différents, puis utilisez des expressions de modèle pour imprimer des messages dans la sortie.

Par exemple, modifiez votre programme pour imprimer ce qui suit :

100 photos
10 photos deleted
90 photos left

Voici une façon d'écrire votre programme, mais il existe d'autres méthodes tout aussi valables !

fun main() {
    val numberOfPhotos = 100
    val photosDeleted = 10
    println("$numberOfPhotos photos")
    println("$photosDeleted photos deleted")
    println("${numberOfPhotos - photosDeleted} photos left")
}

4. Mettre à jour les variables

Lorsqu'une application est en cours d'exécution, il peut être nécessaire de mettre à jour la valeur d'une variable. Par exemple, dans une application d'achat, lorsque l'utilisateur ajoute des articles au panier, le total du panier augmente.

Illustrons ce cas d'utilisation (les achats) en créant un programme simple. La logique ci-dessous emploie le langage humain, et non le langage Kotlin. Cette technique est appelée pseudocode, car elle décrit les points clés du code qui sera écrit, mais elle ne contient pas tous les détails du code.

Remarque : Le pseudo-code ne constitue pas un code opérationnel compilable, d'où son nom de pseudo-code.

Dans la fonction principale d'un programme :

• Créez une variable entière cartTotal qui commence à la valeur 0.
• L'utilisateur ajoute un pull à 20 $ à son panier.
• Définissez la variable cartTotal sur 20, qui correspond au coût actuel des articles dans le panier.
• Imprimez le coût total des articles dans le panier de l'utilisateur, qui est la variable cartTotal, en sortie.

Vous n'avez pas besoin d'écrire de code pour l'action d'ajout dans le panier effectuée par l'utilisateur. (Vous n'avez pas encore appris comment un programme peut répondre aux entrées de l'utilisateur. Nous verrons ce point dans un prochain module.) Concentrez-vous donc sur les parties dans lesquelles vous créez, modifiez et imprimez la variable cartTotal.

1. Remplacez le code existant dans Kotlin Playground par le programme ci-dessous. À la ligne 2 du programme, initialisez la variable cartTotal sur la valeur 0. Puisque vous fournissez une valeur initiale, il n'est pas nécessaire de spécifier le type de données Int en raison de l'inférence de type. À la ligne 3 du programme, vous tentez de remplacer la variable cartTotal par 20 avec l'opérateur d'attribution (=). À la ligne 4 du programme, vous imprimerez la variable cartTotal à l'aide d'un modèle de chaîne.

fun main() {
    val cartTotal = 0
    cartTotal = 20
    println("Total: $cartTotal")
}

2. Exécutez le programme. Une erreur de compilation s'affiche.
3. L'erreur indique que val ne peut pas être réattribué. L'erreur se situe à la troisième ligne du programme, qui tente de remplacer la valeur de la variable cartTotal par 20.. Il n'est pas possible de réattribuer à val cartTotal une autre valeur (20) une fois la valeur initiale (0) attribuée.

Val cannot be reassigned

Si vous devez mettre à jour la valeur d'une variable, déclarez-la avec le mot clé Kotlin var au lieu de val.

• Mot clé val : à utiliser lorsque vous estimez que la valeur de la variable ne changera pas.
• Mot clé var : à utiliser lorsque vous pensez que la valeur de la variable peut changer.

Avec val, la variable est en lecture seule, ce qui signifie que vous pouvez uniquement consulter ou accéder à la valeur de la variable. Une fois la valeur définie, vous ne pouvez plus la modifier. Avec var, la variable est modifiable, ce qui signifie qu'elle peut être modifiée. Il est possible de modifier la valeur.

Pour retenir la différence, voyez val comme une valeur fixe et var comme une variable. En Kotlin, il est recommandé d'utiliser le mot clé val plutôt que le mot clé var lorsque cela est possible.

4. Modifiez la déclaration de variable cartTotal pour la ligne 2 du programme afin d'utiliser var au lieu de val. Voici à quoi ressemble le code :

fun main() {
    var cartTotal = 0
    cartTotal = 20
    println("Total: $cartTotal")
}

5. Notez la syntaxe du code à la ligne 3 du programme qui met à jour la variable.

cartTotal = 20

Utilisez l'opérateur d'attribution (=) pour attribuer une nouvelle valeur (20) à la variable existante (cartTotal). Vous n'avez pas besoin d'utiliser le mot clé var, car la variable est déjà définie.

À l'aide de l'analogie de la boîte, imaginez la valeur 20 stockée dans la boîte libellée cartTotal.

Voici un schéma représentant la syntaxe générale d'une variable, déjà déclarée sur une ligne de code antérieure. Commencez l'instruction avec le nom de la variable que vous souhaitez mettre à jour. Ajoutez une espace, un signe égal, puis une autre espace. Écrivez ensuite la nouvelle valeur de la variable.

6. Exécutez votre programme. Le code devrait maintenant se compiler correctement. La sortie suivante doit s'afficher :

Total: 20

7. Pour voir comment la valeur de la variable change pendant l'exécution du programme, imprimez la variable cartTotal dans le résultat après la déclaration initiale de variable. Consultez les modifications de code ci-dessous. La ligne 3 comporte une nouvelle instruction println(). Une ligne vide est également ajoutée à la ligne 4 du code. Les lignes vides n'ont aucune incidence sur la façon dont le compilateur comprend le code. Ajoutez une ligne vide pour faciliter la lecture de votre code. Elle vous permettra de séparer vos blocs de code de façon claire.

fun main() {
    var cartTotal = 0
    println("Total: $cartTotal")

    cartTotal = 20
    println("Total: $cartTotal")
}

8. Exécutez le programme une nouvelle fois. La sortie doit se présenter comme suit :

Total: 0
Total: 20

Vous constatez qu'au départ, le panier total s'élève à 0. Sa valeur est ensuite remplacée par 20. La variable a été mise à jour avec succès, car vous avez remplacé cartTotal, partant d'une variable en lecture seule (avec val) pour obtenir une variable modifiable (avec var).

N'oubliez pas que vous ne devez utiliser var que pour déclarer une variable. Sinon, vous devez utiliser val par défaut pour déclarer une variable. Cette pratique vous permet de renforcer la sécurité de votre code. L'utilisation de val garantit que les variables ne seront pas mises à jour dans votre programme si vous ne souhaitez pas qu'elles le soient. Une fois qu'une valeur a été attribuée à val, cette valeur est toujours conservée.

Remarque : Si vous connaissez d'autres langages de programmation, déclarer une val revient à déclarer une valeur de la constante, car il s'agit d'une variable en lecture seule. D'autres conventions, plus avancées pour cet atelier, sont à prendre en compte pour déclarer des constantes en Kotlin. Vous les trouverez dans la section Constantes du guide de style.

Opérateurs d’incrémentation et de décrémentation

Vous savez maintenant qu'une variable doit être déclarée en tant que var pour mettre à jour sa valeur. Appliquez ces connaissances avec l'e-mail ci-dessous, qui devrait vous sembler familier.

1. Remplacez le code dans Kotlin Playground par ce programme :

fun main() {
    val count: Int = 10
    println("You have $count unread messages.")
}

2. Exécutez le programme. La sortie devrait afficher ce qui suit :

You have 10 unread messages.

3. Remplacez le mot clé val par le mot clé var pour transformer la variable count en une variable modifiable. La sortie ne devrait pas changer lorsque vous exécutez le programme.

fun main() {
    var count: Int = 10
    println("You have $count unread messages.")
}

4. Cependant, vous pouvez maintenant mettre à jour count avec une autre valeur. Par exemple, lorsqu'un nouvel e-mail arrive dans la boîte de réception de l'utilisateur, vous pouvez augmenter la valeur de count en lui ajoutant 1. Vous n'avez pas besoin d'écrire de code pour la réception d'un e-mail. Les données récupérées sur Internet constituent un sujet bien plus avancé qui fera l'objet d'un module à part entière. Pour l'instant, concentrons-nous sur la variable count qui augmente de 1 avec la ligne de code suivante :

count = count + 1

L'expression à droite du signe égal est count + 1 et renvoie 11. En effet, la valeur actuelle de count est 10 (à la ligne 2 du programme) et 10 + 1 est égal à 11. Avec l'opérateur d'attribution, la valeur 11 est attribuée ou stockée dans la variable count.

Ajoutez cette ligne de code à votre programme en bas de la fonction main(). Le code doit ressembler à l'extrait suivant :

fun main() {
    var count = 10
    println("You have $count unread messages.")
    count = count + 1
}

Si vous exécutez le programme maintenant, vous obtenez le même résultat qu'avant, car vous n'avez ajouté aucun code pour utiliser la variable count après sa mise à jour.

5. Ajoutez une autre instruction d'impression qui affiche le nombre de messages non lus après la mise à jour de la variable.

fun main() {
    var count = 10
    println("You have $count unread messages.")
    count = count + 1
    println("You have $count unread messages.")
}

6. Exécutez le programme. Le deuxième message devrait afficher le count mis à jour de 11 messages.

You have 10 unread messages.
You have 11 unread messages.

7. Pour faire court, si vous souhaitez augmenter une variable de 1, vous pouvez utiliser l'opérateur d'incrémentation (++), qui se compose de deux symboles "plus". En utilisant ces symboles directement après le nom d'une variable, vous indiquez au compilateur que vous souhaitez ajouter 1 à la valeur actuelle de la variable, puis vous stockez la nouvelle valeur dans la variable. Les deux lignes de code suivantes sont équivalentes, mais l'utilisation de l'opérateur d'incrémentation ++ nécessite moins de saisie.

count = count + 1

count++

Apportez cette modification à votre code, puis exécutez votre programme. Il ne doit pas y avoir d'espace entre le nom de la variable et l'opérateur d'incrémentation.

fun main() {
    var count = 10
    println("You have $count unread messages.")
    count++
    println("You have $count unread messages.")
}

8. Exécutez le programme. Le résultat est identique, mais vous avez maintenant un nouvel opérateur à votre arc !

You have 10 unread messages.
You have 11 unread messages.

9. Modifiez maintenant la ligne 4 de votre programme pour utiliser l'opérateur de diminution (--) après le nom de la variable count. L'opérateur de diminution est composé de deux symboles "moins". En plaçant l'opérateur de diminution après le nom de la variable, vous indiquez au compilateur que vous souhaitez réduire la valeur de la variable de 1 et stocker la nouvelle valeur dans la variable.

fun main() {
    var count = 10
    println("You have $count unread messages.")
    count--
    println("You have $count unread messages.")
}

10. Exécutez le programme. La sortie suivante doit s'afficher :

You have 10 unread messages.
You have 9 unread messages.

Dans cette section, vous avez appris à mettre à jour une variable modifiable à l'aide des opérateurs d'incrémentation (++) et de diminution (--). Ainsi, count++ est identique à count = count + 1 et count-- est identique à count = count - 1.

5. Explorer d'autres types de données

Plus tôt dans l'atelier de programmation, vous avez découvert certains types de données de base courants : String, Int, Double et Boolean. Vous venez d'utiliser le type de données Int. Vous allez maintenant explorer d'autres types de données.

Type de données Kotlin	Types de données qu'il peut contenir
String	Texte
Int	Nombre entier
Double	Nombre décimal
Boolean	true ou false (deux valeurs possibles seulement)

Essayez ces programmes dans Kotlin Playground pour découvrir la sortie.

Double

Lorsque vous avez besoin d'une variable avec une valeur décimale, utilisez une variable Double. Pour en savoir plus sur sa plage valide, consultez ce tableau, et examinez les chiffres décimaux qu'il peut stocker.

Remarque : Le nom du type de données Double provient du type de données ayant une double précision par rapport au type de données Float, qui ne possède qu'une seule précision. La précision désigne le nombre de chiffres décimaux qu'elle peut contenir. Par conséquent, une variable Double peut stocker une valeur plus précise. Si vous souhaitez en savoir plus, consultez ce tableau qui explique les différences entre les types Double et Float. Cette section de l'atelier de programmation porte sur l'utilisation de Double pour les nombres décimaux.

Imaginez que vous naviguez vers une destination et que votre itinéraire est divisé en trois parties distinctes, car vous devez faire des arrêts en cours de route. Ce programme indique la distance totale restante pour atteindre votre destination.

1. Saisissez ce code dans Kotlin Playground. Comprenez-vous ce qui se passe sur chaque ligne de code ?

fun main() {
    val trip1: Double = 3.20
    val trip2: Double = 4.10
    val trip3: Double = 1.72
    val totalTripLength: Double = 0.0
    println("$totalTripLength miles left to destination")
}

Trois variables appelées trip1, trip2 et trip3 sont déclarées pour représenter la distance entre chaque étape de l'itinéraire. Toutes ces variables sont des variables Double, car elles stockent des valeurs décimales. Utilisez val pour déclarer chaque variable, car leurs valeurs ne changent pas au cours du programme. Le programme crée également une quatrième variable appelée totalTripLength, qui est actuellement initialisée sur 0.0. La dernière ligne du programme affiche un message avec la valeur totalTripLength.

2. Corrigez le code afin que la variable totalTripLength corresponde à la somme des trois distances de trajet.

val totalTripLength: Double = trip1 + trip2 + trip3

L'expression à droite du signe égal correspond à 9.02, car 3.20 + 4.10 + 1.72 est égal à 9.02. La valeur de 9.02 est stockée dans la variable totalTripLength.

Votre programme doit se présenter comme suit :

fun main() {
    val trip1: Double = 3.20
    val trip2: Double = 4.10
    val trip3: Double = 1.72
    val totalTripLength: Double = trip1 + trip2 + trip3
    println("$totalTripLength miles left to destination")
}

3. Exécutez le programme. La sortie suivante doit s'afficher :

9.02 miles left to destination

4. Corrigez votre code pour supprimer le type de données Double inutile des déclarations de variable, en raison de l'inférence de type. Le compilateur Kotlin peut déduire que ces variables sont des types de données Double basés sur les nombres décimaux fournis en tant que valeurs initiales.

fun main() {
    val trip1 = 3.20
    val trip2 = 4.10
    val trip3 = 1.72
    val totalTripLength = trip1 + trip2 + trip3
    println("$totalTripLength miles left to destination")
}

5. Exécutez à nouveau votre code pour vous assurer qu'il est toujours compilé. Le résultat devrait être identique, mais votre code est désormais plus simple.

Chaîne

Lorsque vous avez besoin d'une variable pouvant stocker du texte, utilisez une variable String. N'oubliez pas d'utiliser des guillemets autour des valeurs littérales de chaîne, par exemple "Hello Kotlin". Les valeurs littérales Int et Double n'en ont pas besoin.

1. Copiez et collez ce programme dans Kotlin Playground.

fun main() {
    val nextMeeting = "Next meeting is:"
    val date = "January 1"
    val reminder = nextMeeting + date
    println(reminder)
}

Notez qu'il existe deux variables String déclarées : une variable nextMeeting et une variable date. Ensuite, une troisième variable String appelée reminder est déclarée. Elle est égale à la somme des variables nextMeeting et date.

Avec le symbole +, vous pouvez ajouter deux chaînes. C'est ce qu'on appelle la concaténation. Les deux chaînes sont combinées, l'une après l'autre. Le résultat de l'expression nextMeeting + date est "Next meeting is:January 1", comme illustré dans le schéma ci-dessous.

La valeur "Next meeting is:January 1" est ensuite stockée dans la variable reminder à l'aide de l'opérateur d'attribution à la ligne 4 du programme.

2. Exécutez votre programme. La sortie suivante doit s'afficher :

Next meeting is:January 1

Lorsque vous concaténez deux chaînes, aucune espace supplémentaire n'est ajoutée entre les chaînes. Pour ajouter une espace après les deux-points, vous devez ajouter l'espace à l'une des chaînes.

3. Mettez à jour la variable nextMeeting en ajoutant une espace supplémentaire à la fin de la chaîne avant le guillemet fermant. (Vous pouvez également ajouter une espace supplémentaire au début de la variable date.) Le programme doit ressembler à l'extrait suivant :

fun main() {
    val nextMeeting = "Next meeting is: "
    val date = "January 1"
    val reminder = nextMeeting + date
    println(reminder)
}

4. Exécutez de nouveau votre programme. La sortie doit contenir une espace après les deux-points.

Next meeting is: January 1

5. Modifiez le code pour concaténer (ou ajouter) un autre texte à l'expression stockée dans la variable reminder.

Utilisez le symbole + pour ajouter le littéral de chaîne "at work" à la fin de la chaîne reminder.

6. Exécutez le programme.

La sortie suivante doit s'afficher :

Next meeting is: January 1 at work

Le code ci-dessous vous montre une façon d'implémenter le comportement.

fun main() {
    val nextMeeting = "Next meeting is: "
    val date = "January 1"
    val reminder = nextMeeting + date + " at work"
    println(reminder)
}

Notez qu'il n'y a pas de guillemets autour de nextMeeting et date, car il s'agit de noms de variables de chaîne existantes (où leurs valeurs respectives sont au format texte et entourées par des guillemets). Inversement, le littéral "at work" n'est défini dans aucune variable. Vous devez donc utiliser des guillemets autour de ce texte pour que le compilateur comprenne qu'il s'agit d'une chaîne qui doit être concaténée sur les autres chaînes.

Vous pouvez obtenir le même résultat en déclarant une seule variable String avec le texte intégral au lieu d'utiliser des variables distinctes. Toutefois, l'objectif de cet exercice est de montrer comment déclarer et manipuler des variables String, en particulier comment concaténer des chaînes distinctes.

7. Lorsque vous lisez du code contenant des chaînes, vous pouvez rencontrer des séquences d'échappement. Les séquences d'échappement sont des caractères précédés d'une barre oblique inverse (\), également appelée barre oblique inverse d'échappement.

Par exemple, \" apparaît dans un littéral de chaîne, comme dans l'exemple ci-dessous. Copiez et collez ce code dans Kotlin Playground.

fun main() {
    println("Say \"hello\"")
}

Vous avez appris à utiliser des guillemets doubles autour d'un littéral de chaîne. Mais comment procéder si vous souhaitez utiliser le symbole " dans votre chaîne ? Vous devez ajouter la barre oblique inverse avant le guillemet \" dans votre chaîne. N'oubliez pas qu'il doit toujours être placé entre guillemets.

8. Exécutez le programme pour voir le résultat. Voici ce qui devrait s'afficher :

Say "hello"

Dans le résultat, des guillemets s'affichent autour de hello, car nous avons ajouté \" avant et après hello dans l'instruction println().

Pour les autres séquences d'échappement prises en charge en Kotlin, reportez-vous à la page de documentation sur les séquences d'échappement. Par exemple, si vous souhaitez ajouter une ligne dans votre chaîne, utilisez le symbole \ avant le caractère n, comme dans \n.

Vous savez maintenant concaténer des chaînes et échapper des séquences au sein des chaînes. Passez au dernier type de données abordé dans cet atelier de programmation.

Booléen

Le type de données Boolean est utile lorsque votre variable ne comporte que deux valeurs possibles, représentées par true ou false.

Par exemple, il s'agit d'une variable qui indique si le mode Avion d'un appareil est activé ou désactivé, ou si les notifications d'une application sont activées ou désactivées.

1. Saisissez ce code dans Kotlin Playground. À la ligne 2 de ce programme, vous déclarez une variable Boolean appelée notificationsEnabled et l'initialisez sur true. Vous pouvez omettre : Boolean dans la déclaration afin de le supprimer si vous le souhaitez. À la ligne 3 du programme, vous affichez la valeur de la variable notificationsEnabled.

fun main() {
    val notificationsEnabled: Boolean = true
    println(notificationsEnabled)
}

Exécutez le programme. Voici ce qui devrait s'afficher :

true

2. Remplacez la valeur initiale Boolean par "false" à la ligne 2 du programme.

fun main() {
    val notificationsEnabled: Boolean = false
    println(notificationsEnabled)
}

Exécutez le programme. Voici ce qui devrait s'afficher :

false

3. Les autres types de données peuvent être concaténés avec Strings. Par exemple, vous pouvez concaténer Booleans avec Strings. Utilisez le symbole + pour concaténer (ou ajouter) la valeur de la variable booléenne notificationsEnabled à la fin de la chaîne "Are notifications enabled? ".

fun main() {
    val notificationsEnabled: Boolean = false
    println("Are notifications enabled? " + notificationsEnabled)
}

Exécutez le programme pour voir le résultat de la concaténation. Le programme devrait afficher le résultat suivant :

Are notifications enabled? false

Vous pouvez constater qu'il est possible de définir la variable Boolean sur une valeur true ou false. Les variables Boolean vous permettent de coder des scénarios plus intéressants, dans lesquels vous exécutez des instructions lorsqu'une variable Boolean a une valeur true. Si la valeur de Boolean est "false", vous pouvez ignorer ces instructions. Vous en apprendrez plus sur les Booleans dans un prochain atelier de programmation.

6. Conventions de codage

Dans l'atelier de programmation précédent, vous avez découvert le guide de style Kotlin, suivi par d'autres développeurs professionnels, qui vous permet d'écrire un code cohérent sur Android et conforme aux recommandations de Google.

Voici quelques autres conventions de mise en forme et de codage à suivre en fonction des nouveaux thèmes que vous avez étudiés :

• Les noms des variables doivent être écrits en Camel Case ("casse de chameau") et commencer par une lettre minuscule.
• Dans une déclaration de variable, vous devez insérer une espace après les deux-points (:) lorsque vous spécifiez le type de données.

• Il doit y avoir une espace avant et après un opérateur comme l'attribution (=), l'addition (+), la soustraction (-), la multiplication (*), la division (/) et plus encore.

• Lorsque vous écrivez des programmes plus complexes, la limite est fixée à 100 caractères par ligne. De cette façon, vous pouvez lire facilement l'ensemble du code d'un programme sur l'écran de votre ordinateur, sans avoir à faire défiler la page horizontalement.

7. Commentaires dans votre code

Lorsque vous codez, une autre bonne pratique consiste à ajouter des commentaires décrivant le code. Les commentaires peuvent aider les personnes qui lisent votre code à le suivre plus facilement. Les deux barres obliques (//) indiquent que le texte situé après le reste de la ligne est un commentaire. Elles ne sont donc pas interprétées comme du code. Il est courant d'ajouter une espace après les deux symboles de barre oblique.

// This is a comment.

Il est également possible de commencer un commentaire au milieu d'une ligne de code. Dans cet exemple, height = 1 est une instruction de codage normale. Tout ce qui se trouve après // ou Assume the height is 1 to start with est interprété comme un commentaire et n'est pas traité comme un élément du code.

height = 1 // Assume the height is 1 to start with.

Si vous souhaitez décrire le code plus en détail et ajouter un commentaire dépassant 100 caractères sur une ligne, utilisez un commentaire multiligne. Le commentaire de plusieurs lignes doit commencer par une barre oblique (/) et un astérisque (*) sous la forme /*. Ajoutez un astérisque au début de chaque ligne du commentaire. Enfin, ajoutez un astérisque suivi d'une barre oblique (*/) au commentaire.

/*
 * This is a very long comment that can
 * take up multiple lines.
 */

Ce programme contient des commentaires sur une ou plusieurs lignes, décrivant ce qu'effectue le programme :

/**
 * This program displays the number of messages
 * in the user's inbox.
 */
fun main() {
    // Create a variable for the number of unread messages.
    var count = 10
    println("You have $count unread messages.")

    // Decrease the number of messages by 1.
    count--
    println("You have $count unread messages.")
}

Comme indiqué précédemment, vous pouvez ajouter des lignes vides à votre code pour regrouper les instructions connexes et faciliter la lecture du code.

1. Ajoutez des commentaires à un extrait de code que vous avez utilisé précédemment.
2. Exécutez le programme pour vous assurer que le comportement n'est pas altéré : les commentaires ne devraient pas affecter la sortie.

8. Conclusion

Très beau travail ! Vous avez découvert les variables en Kotlin, leur utilité en programmation, et comment les créer, les mettre à jour et les utiliser. Vous avez testé différents types de données de base en Kotlin, y compris les types de données Int, Double, String et Boolean. Vous avez également découvert la différence entre les mots clés val et var.

Tous ces concepts sont essentiels pour devenir développeur.

Rendez-vous pour notre prochain atelier de programmation !

Résumé

• Une variable est un conteneur qui ne contient qu'une seule donnée.
• Vous devez déclarer une variable avant de l'utiliser.
• Utilisez le mot clé val pour définir une variable en lecture seule dont la valeur ne peut pas être modifiée après avoir été attribuée.
• Utilisez le mot clé var pour définir une variable modifiable ou interchangeable.
• En Kotlin, il est préférable d'utiliser val plutôt que var lorsque cela est possible.
• Pour déclarer une variable, commencez par le mot clé val ou var. Indiquez ensuite le nom de la variable, le type de données et la valeur initiale. Exemple : val count: Int = 2.
• Avec l'inférence de type, omettez de mentionner le type de données dans la déclaration de variable si une valeur initiale est fournie.
• Voici les types de données Kotlin de base les plus courants : Int, String, Boolean, Float et Double.
• Utilisez l'opérateur d'attribution (=) pour attribuer une valeur à une variable lors de sa déclaration ou de sa mise à jour.
• Vous ne pouvez mettre à jour qu'une variable déclarée comme variable modifiable (avec var).
• Utilisez l'opérateur d'incrémentation (++) pour augmenter de 1 la valeur d'une variable d'entier, ou l'opérateur de diminution (--) pour la diminuer de 1.
• Utilisez le symbole + pour concaténer des chaînes. Vous pouvez également concaténer d'autres types de données comme Int et Boolean avec Strings.

En savoir plus

• Variables
• Types de base
• Modèles de chaîne
• Mots clés et opérateurs
• Syntaxe de base