Apprendre Kotlin #2: variables et types des données

Salut ! Nous continuons avec notre série d'articles sur le langage de programmation Kotlin, et dans cet article, nous allons parler des variables et type de données.

Nous allons écrire et exécuter notre premier code Kotlin directement dans notre navigateur, pour le faire, accédez à l'adresse https://play.kotlinlang.org/

Si c'est la première fois que vous accédez à ce site, vous trouverez un code qui ressemble à ça 👇🏾

/**
 * You can edit, run, and share this code.
 * play.kotlinlang.org
 */
fun main() {
    println("Hello World")
}

Vous n'avez pas besoin d'être un expert en Kotlin pour savoir que ce code affiche Hello World à l'écran, mais voici quand même une brève explication.

• Les mots qui sont entourés de /***/ sont des simples commentaires, ils ne sont pas pris en compte lors de l'exécution de notre programme, ils permettent juste de donner des informations au développeur qui lira le code afin qu'il sache en quoi ce dernier consiste.

• fun est un mot clé utilisé pour déclarer une fonction. Une fonction est un bloc de code conçu pour effectuer une tâche particulière. Dans l'exemple ci-dessus, il déclare la fonction main().

La fonction main() est le point d’entrée de tous les programmes Kotlin, elle est délimitée par des accolades {}.

À l'intérieur, on fait appel à la fonction println(), cette dernière est utilisée pour afficher un message texte, et dans notre exemple, elle affichera Hello World.

Bon à savoir : En Kotlin, les instructions de code ne doivent pas nécessairement se terminer par un point-virgule (;) (ce qui est souvent requis dans d'autres langages de programmation, tels que Java, C++, C#, etc.)

Essayons de compiler notre programme.

La déclaration des variables en Kotlin

En Kotlin, chaque variable doit être déclarée avant d'être utilisée. Sans déclaration d'une variable, une tentative d'utilisation de la variable donne une erreur de syntaxe. La déclaration du type de variable détermine également le type de données que vous êtes autorisé à stocker dans cette variable.

Il existe deux mots-clés pour déclarer une variable. Le premier qui est var, crée une variable muable, ce qui signifie que vous pouvez réaffecter une nouvelle valeur à cette variable autant de fois que vous le souhaitez, comme dans l'exemple suivant

var maPhrase : String // Declaration d'une variable muable de type String.
maPhrase = "Hello le monde" // affectation de la variable

Le mot-clé var est placé devant le nom de la variable, suivi de deux points :, du type de la variable (String dans notre cas) et de l'affectation.

On peut également déclarer un variable et l’affecter en une seule ligne comme suit :

var maPhrase : String = "Hello le monde" 

Vous apprendrez plus tard à écrire cela de manière plus concise en utilisant l'inférence de type.

Vous pouvez également déclarer des variables immuables, ceci est utile lorsque vous déclarer une variable qui ne sera pas modifiée plus tard. Par exemple, si vous voulez déclarer une variable pi = 3.14159265359

val pi : Double = 3.14159265359 // Declaration d'une variable immuable de type Double.
pi = 4.14159265359  // le programme de va pas compiler à cause de cette réaffectation.    

De cette façon, la variable ne peut pas être modifiée après sa déclaration, d'où l'erreur de compilation lorsqu'on essaie de réaffecter pi à une valeur différente.

Différents Types de donnes

Les types de données de base en Kotlin sont similaires à ceux d'autres langages. Ils ne sont pas considérés comme des types primitifs, car ils sont des objets au moment de l'exécution.

Il existe différents types de données en Kotlin :

• Les nombres entiers
• Les nombres à virgule flottante
• Le type Booléen
• Les types caractère et chaine des caractères

Voici une vue d'ensemble des types de base en Kotlin, de leur utilisation de la mémoire et de leur portée.

Les types entiers

Ces types de données contiennent des valeurs (nombres) entières.

Byte

Le type de données Byte peut stocker des nombres entiers de -128 à 127. Il peut être utilisé à la place de Int ou d'autres types d'entiers pour économiser de la mémoire lorsque vous êtes certain que la valeur sera comprise entre -128 et 127 :

val monNombre: Byte = 100
println(monNombre)  

Short Le type de données Short peut stocker des nombres entiers compris entre -32768 et 32767 :

val monNombre: Short = 5000 
println(monNombre)

Int Le type de données Int peut stocker des nombres entiers compris entre -2147483648 et 2147483647 :

val monNombre: Int = 900000
println(monNombre)

Long Le type de données Long peut stocker des nombres entiers compris entre -9223372036854775807 et 9223372036854775807. Il est utilisé lorsque Int n'est pas assez grand pour stocker la valeur. En optionnellement, vous pouvez terminer la valeur par un "L" :

val monNombre: Long = 2000000000L
println(monNombre)

Dans la plupart des cas, nous utiliserons Int pour déclarer tous les types entiers

Les nombres à virgule flottante (Decimal)

Ces types de données sont utilisés pour stocker une valeur décimale comme 0.5 ou une partie fractionnaire.

Les types Float et Double peuvent stocker des nombres fractionnaires

val monFloat: Float = 5.75F
println(monFloat)

val monDouble: Double = 5.75
println(monDouble)

La précision d'une valeur à virgule flottante indique le nombre de chiffres que la valeur peut avoir après la virgule. La précision de Float n'est que de six ou sept chiffres après la virgule, tandis qu’une variable de type Double a une précision d'environ 15 chiffres. Il est donc plus sûr d'utiliser Double pour la plupart des calculs. Notez également que vous devez terminer la valeur d'un type Float par un "F".

Le type booléen

Le type de données booléen est déclaré avec le mot clé Boolean et ne peut prendre que les valeurs true ou false (vrai ou faux) :

val jeSuisBeau : Boolean = true

Les types caractère et chaine des caractères

Le type de données caractères (Char) représente les lettres minuscules (a-z), les lettres majuscules (A-Z), les chiffres (0-9) et autres symboles.

Char

Le type de données Char est utilisé pour stocker un seul caractère. La valeur d'un caractère doit être entourée de guillemets simples, comme 'A' ou 'c' :

val monCaractere : Char = 'B'
println(monCaractere)

String

Le type de données String est utilisé pour stocker une séquence de caractères (texte). Les valeurs de type String doivent être entourées de guillemets doubles :

var monTexte : String = "Salut le monde"
println(monTexte)

Conclusion

Voilà ! Vous savez maintenant déclarer et initialiser des variables en Kotlin, dans le prochain article, nous allons essayer d'aller encore plus loin et effectuer certaines opérations sur ces derniers.

À bientôt !