Rappels essentiels : variables, types de données, opérateurs

Les briques élémentaires : Variables

Au coeur de tout programme se trouve la manipulation de données. En JavaScript, comme dans la plupart des langages, nous utilisons des variables pour stocker et nommer ces données afin de pouvoir les référencer et les modifier facilement. Une variable est essentiellement une étiquette associée à un emplacement en mémoire où une valeur est stockée.

Historiquement, le mot-clé `var` était la seule façon de déclarer une variable. Cependant, `var` présente des particularités qui peuvent prêter à confusion, notamment sa portée de fonction (function scope) et le phénomène de remontée (hoisting). Une variable déclarée avec `var` est accessible partout dans la fonction où elle est déclarée, même avant sa ligne de déclaration (sa valeur sera alors `undefined`). Cela peut entraîner des comportements inattendus.

function exempleVar() {
  console.log(maVariable); // Affiche undefined (hoisting), pas d'erreur
  if (true) {
    var maVariable = "Je suis définie ici";
  }
  console.log(maVariable); // Affiche "Je suis définie ici" (portée de fonction)
}
exempleVar();

En raison de ces comportements, l'utilisation de `var` est fortement déconseillée dans le code JavaScript moderne.

ECMAScript 2015 (ES6) a introduit deux nouveaux mots-clés pour déclarer des variables, qui résolvent les problèmes de `var` : `let` et `const`.

• `let` : Déclare une variable dont la portée est limitée au bloc (block scope) dans lequel elle est définie (un bloc est délimité par des accolades `{}`). Les variables `let` ne sont pas "remontées" de la même manière que `var` ; tenter d'y accéder avant leur déclaration lève une erreur (`ReferenceError`). C'est le choix idéal lorsque vous savez que la valeur de la variable devra être réassignée plus tard.

function exempleLet() {
  // console.log(maVariableLet); // ReferenceError: Cannot access 'maVariableLet' before initialization
  let a = 10;
  if (true) {
    let maVariableLet = "Je suis définie ici";
    console.log(maVariableLet); // Affiche "Je suis définie ici"
    a = 20; // OK, réassignation possible
  }
  // console.log(maVariableLet); // ReferenceError: maVariableLet is not defined (portée de bloc)
  console.log(a); // Affiche 20
}
exempleLet();

• `const` : Déclare également une variable avec une portée de bloc. La différence majeure est qu'une variable `const` doit être initialisée lors de sa déclaration et ne peut pas être réassignée par la suite. Attention, cela ne signifie pas que la valeur elle-même est immuable. Si une `const` référence un objet ou un tableau, le contenu de cet objet ou tableau peut toujours être modifié, mais la variable ne pourra pas être réassignée pour pointer vers un autre objet ou tableau. Utilisez `const` par défaut pour toutes vos variables, et ne passez à `let` que si vous savez explicitement que vous aurez besoin de réassigner la variable.

const tauxTVA = 0.20;
// tauxTVA = 0.21; // TypeError: Assignment to constant variable.

const utilisateur = {
  nom: "Alice",
  age: 30
};

utilisateur.age = 31; // OK, on modifie une propriété de l'objet
console.log(utilisateur); // { nom: 'Alice', age: 31 }

// utilisateur = { nom: "Bob" }; // TypeError: Assignment to constant variable.

Règle générale pour Node.js (et JS moderne) : Utilisez `const` par défaut, et `let` uniquement lorsque la réassignation est nécessaire. Evitez `var`.

Les formes de données : Types

JavaScript est un langage à typage dynamique. Cela signifie que vous n'avez pas besoin de déclarer explicitement le type d'une variable lors de sa création ; le type est déterminé automatiquement lors de l'assignation d'une valeur, et il peut changer si vous réassignez une valeur d'un type différent à la même variable (bien que ce soit souvent une mauvaise pratique).

JavaScript possède plusieurs types de données primitifs :

• `string` : Représente une séquence de caractères, utilisée pour le texte. Déclarée avec des guillemets simples (`'...'`), doubles (`"..."`) ou obliques (backticks `` `...` ``). Les backticks permettent les littéraux de gabarits (template literals) qui facilitent l'interpolation de variables :

  const nom = "Monde";
  const message = `Hello, ${nom}!`; // message vaut "Hello, Monde!"

• `number` : Représente les nombres, qu'ils soient entiers ou à virgule flottante. Inclut des valeurs spéciales comme `Infinity`, `-Infinity` et `NaN` (Not a Number), qui résulte souvent d'opérations mathématiques invalides (ex: `0 / 0`).
• `boolean` : Représente une valeur logique, soit `true` (vrai), soit `false` (faux). Essentiel pour les structures de contrôle.
• `null` : Représente l'absence intentionnelle de toute valeur ou objet. C'est une valeur assignée explicitement par le développeur.
• `undefined` : Représente une variable qui a été déclarée mais n'a pas encore reçu de valeur, ou une propriété d'objet qui n'existe pas.
• `symbol` (ES6) : Représente un identifiant unique et immuable. Principalement utilisé comme clé de propriété d'objet pour éviter les collisions de noms.
• `bigint` (ES2020) : Représente des nombres entiers de taille arbitraire, dépassant la limite de `Number.MAX_SAFE_INTEGER`. Créé en ajoutant `n` à la fin d'un entier (ex: `123n`).

En plus des types primitifs, JavaScript a un type complexe principal :

• `object` : Représente une collection de paires clé-valeur (les clés sont généralement des chaînes de caractères ou des Symboles, les valeurs peuvent être de n'importe quel type). Les objets sont utilisés pour structurer des données plus complexes. Les tableaux (Arrays) et les fonctions (Functions) sont également des types d'objets spécialisés en JavaScript.

const personne = {
  nom: "Dupont",
  prenom: "Jean",
  age: 42,
  estActif: true,
  adresse: {
    rue: "1 rue de la Paix",
    ville: "Paris"
  }
};

L'opérateur `typeof` permet d'obtenir une chaîne de caractères représentant le type d'une variable ou d'une valeur. Attention à ses particularités : `typeof null` renvoie `'object'` (un bug historique) et `typeof` une fonction renvoie `'function'`.

console.log(typeof "hello");   // "string"
console.log(typeof 123);      // "number"
console.log(typeof true);     // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof null);     // "object" (quirk!)
console.log(typeof {a: 1}); // "object"
console.log(typeof [1, 2]); // "object"
console.log(typeof function(){}); // "function"

Agir sur les données : Opérateurs

Les opérateurs sont des symboles spéciaux qui effectuent des opérations sur des valeurs (appelées opérandes). JavaScript fournit une large gamme d'opérateurs.

Opérateurs d'affectation :

• `=`: Affectation simple (ex: `let x = 10;`).
• `+=`, `-=`, `*=`, `/=`, `%=`, `**=`: Opérateurs d'affectation composés (ex: `x += 5;` équivaut à `x = x + 5;`).

Opérateurs arithmétiques :

• `+`: Addition (ou concaténation de chaînes).
• `-`: Soustraction.
• `*`: Multiplication.
• `/`: Division.
• `%`: Modulo (reste de la division entière).
• `**`: Exponentiation (ES7) (ex: `2 ** 3` vaut 8).
• `++`: Incrémentation (pré ou post-fixée, ex: `++x` ou `x++`).
• `--`: Décrémentation (pré ou post-fixée, ex: `--x` ou `x--`).

Opérateurs de comparaison : Très importants pour les conditions.

• `==`: Egalité faible (avec conversion de type - à éviter !).
• `!=`: Inégalité faible (avec conversion de type).
• `===`: Egalité stricte (sans conversion de type - recommandé !).
• `!==`: Inégalité stricte (sans conversion de type - recommandé !).
• `>`: Supérieur à.
• `<`: Inférieur à.
• `>=`: Supérieur ou égal à.
• `<=`: Inférieur ou égal à.

console.log(5 == "5");    // true (conversion de type)
console.log(5 === "5");   // false (pas de conversion, types différents)
console.log(null == undefined); // true
console.log(null === undefined); // false

Opérateurs logiques : Utilisés pour combiner des expressions booléennes.

• `&&`: ET logique (renvoie la première valeur "falsy" ou la dernière valeur "truthy").
• `||`: OU logique (renvoie la première valeur "truthy" ou la dernière valeur "falsy").
• `!`: NON logique (inverse une valeur booléenne).

Ils utilisent l'évaluation court-circuit (short-circuiting) : si le résultat peut être déterminé après avoir évalué le premier opérande, le second n'est pas évalué.

let utilisateurConnecte = null;
let nomUtilisateur = utilisateurConnecte && utilisateurConnecte.nom; // nomUtilisateur vaut null (court-circuit)

let port = process.env.PORT || 3000; // Si process.env.PORT est défini et truthy, utilise sa valeur, sinon 3000

Opérateur conditionnel (ternaire) : Un raccourci pour une instruction `if...else` simple.

const age = 25;
const statut = age >= 18 ? "Majeur" : "Mineur"; // statut vaut "Majeur"

Autres opérateurs utiles : `typeof` (vu précédemment), `instanceof` (vérifie si un objet est une instance d'une classe ou d'un constructeur), `delete` (supprime une propriété d'objet), `in` (vérifie si une propriété existe dans un objet), `new` (crée une instance d'objet).

Comprendre et utiliser correctement ces variables, types et opérateurs est la première étape indispensable pour écrire du code JavaScript fonctionnel et logique, que ce soit dans Node.js ou dans tout autre environnement JavaScript.