Les variables en JavaScript

Les types de variables en Javascript

Les variables sont un concept fondamental en programmation. Elles permettent de stocker des informations dans la mémoire de l’ordinateur pour pouvoir les réutiliser plus tard dans un programme. En JavaScript, il existe plusieurs manières de déclarer des variables, chacune ayant des spécificités.

const : Utilisé pour déclarer une variable dont la valeur ne changera pas.
let : Utilisé pour déclarer une variable dont la valeur peut changer.
var : Une manière plus ancienne de déclarer des variables, qui a des particularités concernant sa portée, et qu’il vaut mieux éviter aujourd’hui.

Exemple de déclaration d’une variable :

				
					const pi = 3.14;  // Une constante, sa valeur ne changera jamais
let age = 25;     // Une variable dont la valeur pourra changer plus tard
var name = "Alice";  // Déclaration avec var (obsolète)

Les différences entre const, let et var

const est utilisé pour déclarer des constantes. Une fois qu’une valeur est attribuée à une variable avec const, elle ne peut plus être modifiée.

				
					const pi = 3.14;
// pi = 3.15;  // Erreur, la valeur de pi ne peut pas être modifiée

let est utilisé pour déclarer des variables dont la valeur peut changer au cours du programme.

				
					let age = 25;
age = 31;  // La valeur de age peut être modifiée

var est une m éthode plus ancienne pour déclarer des variables. Elle a un comportement différent concernant la portée des variables, c’est pourquoi il est recommandé d’utiliser let ou const à la place.

Créer un environnement de travail simple

Pour tester du JavaScript, nous allons utiliser le navigateur web et créer une page HTML simple. JavaScript est souvent intégré dans une page HTML via des balises <script>.

Vous pouvez tester ce code directement dans un éditeur de texte comme Visual Studio Code, puis ouvrir le fichier dans votre navigateur pour voir le résultat dans la console du navigateur.

				
					<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Exemple de variables</title>
</head>
<body>
    <h1>Test de variables en JavaScript</h1>
    <script>
        let a = 5;  // Déclaration d'une variable
        console.log(a);  // Affiche 5 dans la console
    </script>
</body>
</html>

Les types de données en JavaScript

Les variables peuvent contenir différents types de valeurs. Voici les principaux types de données en JavaScript :

Les nombres

Valeurs numériques entières ou à virgule flottante.

				
					let nombre = 42;
let prix = 19.99;

Les chaînes de caractères :

Texte entouré de guillemets simples, doubles ou de backticks.

				
					let message = "Bonjour tout le monde";
let autreMessage = `Le prix est ${prix}`;

Les booléens :

true ou false, représentant une valeur vraie ou fausse.

				
					let isMajor = true;

Null :

Représente une absence de valeur.

				
					let vide = null;

Undefined :

Indique qu’une variable a été déclarée mais n’a pas encore reçu de valeur.

				
					let inconnue;
console.log(inconnue);  // Affiche undefined

Chaînes de caractères et concaténation

En JavaScript, il est possible d’additionner des chaînes de caractères pour les concaténer. Les backticks permettent d’insérer directement des variables dans une chaîne.

Exemple de concaténation :

				
					let nom = "Alice";
let message = "Bonjour, " + nom + " !";
console.log(message);  // Affiche "Bonjour, Alice !"

let messageTemplate = `Bonjour, ${nom} !`;
console.log(messageTemplate);  // Affiche également "Bonjour, Alice !"

Les tableaux et les objets en Javascript

Les tableaux sont utilisés pour stocker plusieurs valeurs dans une seule variable. Un tableau est déclaré avec des crochets [].

Exemple :

				
					let notes = [12, 15, 18, 20];
console.log(notes[0]);  // Affiche 12 (première note)

Ils peuvent aussi contenir des chaînes de caractères, des booléens, ou même d’autres tableaux.

Un objet permet de regrouper des données sous forme de paires clé-valeur.

Exemple :

				
					let personne = {
    prenom: "Alice",
    age: 30,
    metier: "Développeur"
};
console.log(personne.prenom);  // Affiche "Alice"

Les objets peuvent contenir des tableaux ou même d’autres objets.

La portée des variables en Javascript

En JavaScript, la portée détermine où dans le code une variable peut être accédée ou modifiée. La portée permet de s’assurer que certaines variables sont accessibles uniquement dans certaines parties du programme, garantissant ainsi une meilleure organisation et évitant les conflits entre variables.

Il existe plusieurs types de portée en JavaScript :

Portée globale : La variable est accessible partout dans le programme.
Portée de bloc : La variable n’est accessible que dans un bloc spécifique (entre {}).
Portée de fonction : La variable est uniquement accessible à l’intérieur d’une fonction.

Les variables déclarées avec let et const

Les variables déclarées avec let ou const en JavaScript ont une portée de bloc. Cela signifie qu’elles ne sont accessibles qu’à l’intérieur du bloc de code où elles sont déclarées.

Exemple ci-dessous avec let : ici la variable message n’est accessible qu’à l’intérieur du bloc if. Si vous essayez d’y accéder en dehors du bloc, une erreur sera générée.

				
					let age = 20;

if (age >= 18) {
    let message = "Vous êtes majeur";
    console.log(message);  // Fonctionne ici, dans le bloc
}

console.log(message);  // Erreur : message n'est pas défini en dehors du bloc

Les variables déclarées avec var

Avant l’introduction de let et const, on utilisait var pour déclarer des variables. Cependant, les variables var ont une portée plus large, souvent globale ou limitée à une fonction. Cela pouvait entraîner des comportements inattendus et des bugs.

Avec var, la variable message reste accessible même en dehors du bloc if. C’est pour cette raison que let et const sont préférés aujourd’hui, car ils limitent la portée au bloc où la variable est définie.

				
					var age = 20;

if (age >= 18) {
    var message = "Vous êtes majeur";
    console.log(message);  // Fonctionne ici
}

console.log(message);  // Fonctionne aussi ici avec `var`

Les variables imbriquées

Il est possible de déclarer des variables ayant le même nom dans différents blocs ou fonctions. La portée de la variable la plus locale (la plus proche) est prioritaire.

Dans cet exemple, la variable message à l’intérieur du bloc if est différente de la variable message déclarée à l’extérieur du bloc. Chacune a sa propre portée.

				
					let message = "Global";

if (true) {
    let message = "Local";
    console.log(message);  // Affiche "Local"
}

console.log(message);  // Affiche "Global"