Fonctions et portée des variables

Les blocs de construction réutilisables : Fonctions

Les fonctions sont l'un des piliers fondamentaux de JavaScript. Elles représentent des blocs de code autonomes et réutilisables conçus pour effectuer une tâche spécifique. L'utilisation de fonctions permet d'organiser le code, de le rendre plus modulaire, plus facile à lire, à tester et à maintenir. Dans Node.js, les fonctions sont omniprésentes, que ce soit pour définir la logique métier, gérer des requêtes serveur, ou fournir des callbacks pour des opérations asynchrones.

Une fonction encapsule un ensemble d'instructions. Elle peut accepter des données en entrée (via des paramètres) et peut renvoyer une valeur en sortie (via l'instruction `return`). Comprendre comment définir, appeler et utiliser efficacement les fonctions est essentiel.

Intimement lié aux fonctions est le concept de portée (scope). La portée détermine où, dans votre code, les variables et les fonctions sont accessibles. Une mauvaise compréhension de la portée peut entraîner des erreurs difficiles à déboguer, comme des variables non définies ou des écrasements involontaires de valeurs. Nous allons explorer les différents types de fonctions et les règles de portée en JavaScript.

Définir et appeler des fonctions

Il existe plusieurs façons de définir une fonction en JavaScript :

1. Déclaration de fonction (Function Declaration) : C'est la manière la plus classique. Elles sont "remontées" (hoisted), ce qui signifie que vous pouvez les appeler avant leur déclaration dans le code.

function additionner(a, b) {
  return a + b;
}

let resultat = additionner(5, 3); // Appel de la fonction
console.log(resultat); // Affiche 8

2. Expression de fonction (Function Expression) : Une fonction est assignée à une variable. L'expression de fonction elle-même n'est pas remontée (seule la déclaration de la variable l'est, si elle utilise `var`). Elles peuvent être anonymes (sans nom après `function`).

const multiplier = function(a, b) {
  return a * b;
};

let produit = multiplier(4, 6); // Appel via la variable
console.log(produit); // Affiche 24

3. Fonctions fléchées (Arrow Functions - ES6) : Une syntaxe plus concise pour écrire des expressions de fonction. Elles ont une particularité importante : elles n'ont pas leur propre contexte `this` ; elles héritent le `this` de leur portée environnante (lexical `this`). C'est particulièrement utile pour les callbacks.

// Syntaxe complète
const soustraire = (a, b) => {
  return a - b;
};

// Si un seul paramètre, parenthèses optionnelles
const carre = x => {
  return x * x;
};

// Si le corps contient une seule expression de retour, accolades et 'return' implicites
const saluer = nom => `Bonjour, ${nom}!`;

console.log(soustraire(10, 4)); // 6
console.log(carre(5));         // 25
console.log(saluer("Alice"));  // Bonjour, Alice!

Paramètres et Arguments : Les paramètres sont les variables listées dans la définition de la fonction. Les arguments sont les valeurs réelles passées à la fonction lors de son appel.

• Paramètres par défaut (ES6) : Vous pouvez assigner des valeurs par défaut aux paramètres, utilisées si aucun argument n'est fourni.

function connecter(host = "localhost", port = 8080) {
  console.log(`Connexion à ${host}:${port}`);
}
connecter(); // Connexion à localhost:8080
connecter("example.com"); // Connexion à example.com:8080
connecter(undefined, 9000); // Connexion à localhost:9000

• Paramètres du reste (Rest Parameters - ES6) : Permet de regrouper un nombre indéfini d'arguments restants dans un tableau.

function somme(...nombres) { // ...nombres est un tableau
  let total = 0;
  for (const nb of nombres) {
    total += nb;
  }
  return total;
}
console.log(somme(1, 2, 3)); // 6
console.log(somme(10, 20, 30, 40)); // 100

Valeur de retour : Une fonction peut renvoyer une valeur en utilisant le mot-clé `return`. Si `return` est omis ou s'il n'est suivi d'aucune valeur, la fonction renvoie implicitement `undefined`.

Comprendre la portée des variables (Scope)

La portée définit l'accessibilité des variables. JavaScript a principalement trois types de portée :

1. Portée Globale (Global Scope) : Les variables déclarées en dehors de toute fonction ou bloc ont une portée globale. Dans un navigateur, elles deviennent des propriétés de l'objet `window`. En Node.js, la situation est légèrement différente : chaque fichier (module) a sa propre portée de module. Une variable déclarée au niveau supérieur d'un fichier Node.js n'est pas automatiquement globale à toute l'application, mais locale à ce module (sauf si explicitement attachée à l'objet `global`, ce qui est fortement déconseillé).

// Dans un fichier Node.js (module_a.js)
const variableModule = "Je suis dans le module A";
global.variableGlobaleApp = "Accessible partout (mauvaise pratique!)";

// Dans un autre fichier (module_b.js)
// console.log(variableModule); // ReferenceError: variableModule is not defined
console.log(global.variableGlobaleApp); // Affiche "Accessible partout (mauvaise pratique!)"

Evitez autant que possible les variables globales pour prévenir les conflits de noms et améliorer la modularité.

2. Portée de Fonction (Function Scope) : Les variables déclarées avec `var` à l'intérieur d'une fonction ne sont accessibles qu'à l'intérieur de cette fonction (et des fonctions imbriquées).

function exemplePorteeFonction() {
  var message = "Visible ici";
  console.log(message); // "Visible ici"
}
// console.log(message); // ReferenceError: message is not defined

3. Portée de Bloc (Block Scope - ES6) : Les variables déclarées avec `let` et `const` à l'intérieur d'un bloc (`{...}`), que ce soit une structure `if`, une boucle `for`, `while`, ou simplement un bloc isolé, ne sont accessibles qu'à l'intérieur de ce bloc.

if (true) {
  let secret = "Ceci est un secret";
  const aussiSecret = "Un autre secret";
  console.log(secret); // "Ceci est un secret"
}
// console.log(secret); // ReferenceError: secret is not defined
// console.log(aussiSecret); // ReferenceError: aussiSecret is not defined

for (let i = 0; i < 3; i++) {
  console.log(i); // 0, 1, 2
}
// console.log(i); // ReferenceError: i is not defined (car déclaré avec let dans la boucle)

La portée de bloc est plus prévisible et aide à éviter les erreurs liées à la réutilisation involontaire de variables. C'est pourquoi `let` et `const` sont préférés à `var`.

Le phénomène de remontée (Hoisting)

Le Hoisting est un mécanisme de JavaScript où les déclarations de variables (avec `var`) et de fonctions (déclarations, pas expressions) sont déplacées conceptuellement en haut de leur portée (globale ou de fonction) lors de la phase de compilation, avant l'exécution du code.

• Déclarations de `var` : Seule la déclaration est remontée, pas l'initialisation. La variable existe donc dès le début de sa portée, mais sa valeur est `undefined` jusqu'à la ligne où elle est initialisée.
• Déclarations de fonction : La déclaration complète (nom et corps) est remontée. Vous pouvez donc appeler une fonction déclarée de cette manière avant sa définition dans le code.
• `let` et `const` : Elles sont aussi techniquement remontées, mais elles ne sont pas initialisées. Tenter d'y accéder avant leur déclaration lève une `ReferenceError`. Cette période entre le début de la portée et la déclaration est appelée la Zone Morte Temporelle (Temporal Dead Zone - TDZ).

console.log(maVar); // undefined (hoisting de var)
var maVar = 5;

maFonctionDeclaree(); // "Je suis déclarée" (hoisting de fonction)
function maFonctionDeclaree() {
  console.log("Je suis déclarée");
}

// maFonctionExpression(); // TypeError: maFonctionExpression is not a function (var est hoisté, mais la fonction n'est pas encore assignée)
var maFonctionExpression = function() {
  console.log("Je suis une expression");
};

// console.log(maLet); // ReferenceError (TDZ pour let)
let maLet = 10;

Comprendre le hoisting aide à interpréter certains comportements, mais l'utilisation de `let` et `const` et le fait de déclarer les fonctions avant de les utiliser rendent généralement le code plus clair et moins sujet aux erreurs liées au hoisting.

Les fermetures (Closures) : Mémoire et portée

Une fermeture (closure) est l'une des caractéristiques les plus puissantes et parfois déroutantes de JavaScript. Une fermeture se produit lorsqu'une fonction "se souvient" et continue d'avoir accès aux variables de sa portée de définition (sa portée lexicale parente), même après que cette portée parente a terminé son exécution.

En termes simples, une fonction interne a toujours accès aux variables et paramètres de sa fonction externe, même après le retour de la fonction externe.

function creerCompteur() {
  let compte = 0; // Variable dans la portée de creerCompteur

  // La fonction interne 'incrementer' forme une closure
  function incrementer() {
    compte++; // Accède et modifie la variable 'compte' de la portée externe
    console.log(compte);
  }

  return incrementer; // Retourne la fonction interne
}

const compteur1 = creerCompteur(); // 'compte' est initialisé à 0
const compteur2 = creerCompteur(); // 'compte' est initialisé à 0 (nouvelle portée)

compteur1(); // Affiche 1 (la closure se souvient de son 'compte')
compteur1(); // Affiche 2

compteur2(); // Affiche 1 (la closure de compteur2 a son propre 'compte')

// La variable 'compte' n'est pas accessible directement de l'extérieur
// console.log(compte); // ReferenceError

Les closures sont fondamentales pour de nombreux motifs de conception en JavaScript et Node.js :

• Encapsulation et Confidentialité des données : Comme dans l'exemple `creerCompteur`, la variable `compte` n'est pas accessible de l'extérieur, créant une sorte de variable "privée".
• Fonctions de rappel (Callbacks) et Programmation Asynchrone : Les callbacks utilisés dans Node.js (par exemple, pour gérer la fin d'une lecture de fichier ou d'une requête réseau) sont souvent des closures. Ils ont besoin de se souvenir du contexte (variables, paramètres) dans lequel ils ont été créés pour pouvoir effectuer leur travail lorsque l'opération asynchrone se termine.
• Currying et Application partielle : Techniques de programmation fonctionnelle où une fonction retourne une autre fonction qui a déjà certains paramètres pré-remplis.

Une bonne compréhension des fonctions, de la portée des variables (`let`/`const` et portée de bloc étant la norme moderne) et des closures est absolument essentielle pour écrire du code Node.js robuste, modulaire et correct, en particulier lors de la gestion d'opérations asynchrones.