Fonctions

Une fonction est un bloc de code réutilisable conçu pour accomplir une tâche particulière. Tu la définis une fois et tu peux l'appeler autant de fois que nécessaire.

La manière la plus courante de créer une fonction est avec une déclaration de fonction :

function greet(name) {
  console.log('Hello, ' + name + '!');
}

greet('Alice'); // Hello, Alice!
greet('Bob');   // Hello, Bob!

Voici les éléments clés :

• Mot-clé function — indique à JavaScript que tu définis une fonction.
• Nom — suit les mêmes règles que les noms de variables. Par convention, les noms de fonction utilisent le camelCase : calculateTotal, getUserName, isValid.
• Paramètres — les variables listées à l'intérieur des parenthèses. Ils agissent comme des espaces réservés pour les valeurs que tu passeras lors de l'appel de la fonction. Tu peux avoir zéro, un ou plusieurs paramètres séparés par des virgules.
• Arguments — les valeurs réelles que tu passes lors de l'appel de la fonction. Dans greet('Alice'), la chaîne de caractères 'Alice' est l'argument qui est assigné au paramètre name.
• Corps de la fonction — le code à l'intérieur des accolades {} qui s'exécute à chaque fois que la fonction est appelée.

Une caractéristique importante des déclarations de fonction est le hoisting. JavaScript déplace les déclarations de fonction en haut de leur portée avant d'exécuter le code. Cela signifie que tu peux appeler une fonction avant qu'elle n'apparaisse dans ton code source :

sayHello(); // Ça fonctionne !

function sayHello() {
  console.log('Hello!');
}

Tu peux définir des fonctions avec plusieurs paramètres :

function add(a, b) {
  console.log(a + b);
}

add(3, 5); // 8

Si tu appelles une fonction avec moins d'arguments que de paramètres, ceux qui manquent seront undefined. Tu peux aussi définir des valeurs de paramètres par défaut :

function greet(name = 'World') {
  console.log('Hello, ' + name + '!');
}

greet();        // Hello, World!
greet('Alice'); // Hello, Alice!

Les fonctions peuvent renvoyer une valeur au code qui les a appelées en utilisant l'instruction return :

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

const sum = add(3, 5);
console.log(sum); // 8

L'instruction return fait deux choses :

1. Renvoie une valeur à l'endroit où la fonction a été appelée.
2. Arrête la fonction immédiatement. Tout code après return dans le même bloc ne sera pas exécuté.

function checkAge(age) {
  if (age < 0) {
    return 'Invalid age'; // Retour anticipé — sort ici
  }
  return 'Age is ' + age;
}

Ce modèle de retours anticipés est très courant. Il te permet de gérer les cas particuliers en haut d'une fonction et de garder la logique principale non indentée.

Si une fonction n'a pas d'instruction return, ou utilise return sans valeur, elle renvoie undefined :

function sayHi() {
  console.log('Hi!');
  // pas d'instruction return
}

const result = sayHi(); // affiche 'Hi!'
console.log(result);    // undefined

Comme les fonctions renvoient des valeurs, tu peux les utiliser directement dans des expressions :

function double(n) {
  return n * 2;
}

const total = double(5) + double(10); // 10 + 20 = 30
console.log(double(double(3)));       // double(6) = 12

Cette composabilité est l'un des aspects les plus puissants des fonctions — tu peux les combiner, les imbriquer et construire une logique complexe à partir de blocs simples.

Au lieu d'utiliser une déclaration de fonction, tu peux créer une fonction et l'assigner à une variable. C'est ce qu'on appelle une expression de fonction :

const greet = function(name) {
  return 'Hello, ' + name + '!';
};

console.log(greet('Alice')); // Hello, Alice!

La fonction du côté droit du = est appelée une fonction anonyme car elle n'a pas de nom. La variable greet contient une référence à la fonction, et tu l'appelles en utilisant le nom de la variable.

Tu peux aussi donner un nom aux expressions de fonction, créant une expression de fonction nommée :

const factorial = function fact(n) {
  if (n <= 1) return 1;
  return n * fact(n - 1); // le nom 'fact' est accessible à l'intérieur
};

Le nom fact n'est accessible qu'à l'intérieur de la fonction elle-même, ce qui est utile pour la récursion et le débogage (le nom apparaît dans les traces de pile).

Différence clé avec les déclarations : les expressions de fonction ne sont pas hoistées. Tu ne peux pas les appeler avant la ligne où elles sont définies :

greet('Alice'); // Erreur ! greet n'est pas encore défini

const greet = function(name) {
  return 'Hello, ' + name;
};

Quand utiliser chacune :

• Utilise les déclarations de fonction pour les fonctions de haut niveau qui forment la structure principale de ton code. Le hoisting les rend disponibles partout dans la portée, ce qui peut améliorer la lisibilité.
• Utilise les expressions de fonction quand tu as besoin de passer une fonction comme valeur — par exemple, comme callback à une autre fonction, ou quand tu veux assigner conditionnellement différentes fonctions à la même variable.

Les deux approches sont valides et largement utilisées. En progressant, tu apprendras aussi les fonctions fléchées (=>), qui sont une syntaxe plus concise pour les expressions de fonction.