Chapitre 5 : Fonctions

1. Qu'est-ce qu'une fonction ?

Une fonction est un bloc de code réutilisable qui effectue une tâche spécifique. Elle permet d'organiser le code et d'éviter les répétitions.

2. Déclaration de fonction

Syntaxe de base

function direBonjour() {
    console.log("Bonjour !");
}

// Appel de la fonction
direBonjour(); // Affiche: Bonjour !

Fonction avec paramètres

function saluer(nom) {
    console.log("Bonjour " + nom + " !");
}

saluer("Alice"); // Bonjour Alice !
saluer("Bob");   // Bonjour Bob !

Plusieurs paramètres

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

let resultat = additionner(5, 3);
console.log(resultat); // 8

3. Le mot-clé return

Permet de renvoyer une valeur depuis une fonction :

function multiplier(x, y) {
    return x * y;
}

let produit = multiplier(4, 5);
console.log(produit); // 20

// Sans return, la fonction renvoie undefined
function afficher(message) {
    console.log(message);
    // Pas de return
}

let resultat = afficher("Hello"); // Affiche "Hello"
console.log(resultat); // undefined

4. Paramètres par défaut

function saluer(nom = "Invité") {
    console.log("Bonjour " + nom);
}

saluer("Marie"); // Bonjour Marie
saluer();        // Bonjour Invité

5. Fonctions fléchées (Arrow Functions)

Syntaxe plus courte introduite en ES6 :

Syntaxe de base

// Fonction classique
function carre(x) {
    return x * x;
}

// Fonction fléchée
const carre2 = (x) => {
    return x * x;
};

// Version ultra-courte (return implicite)
const carre3 = x => x * x;

console.log(carre3(5)); // 25

Avec plusieurs paramètres

const additionner = (a, b) => a + b;
console.log(additionner(10, 5)); // 15

// Avec un bloc de code
const calculer = (a, b) => {
    let somme = a + b;
    let produit = a * b;
    return { somme, produit };
};

let resultat = calculer(3, 4);
console.log(resultat); // { somme: 7, produit: 12 }

6. Fonctions anonymes

Fonctions sans nom, souvent utilisées comme callbacks :

// Fonction anonyme stockée dans une variable
const saluer = function(nom) {
    console.log("Salut " + nom);
};

saluer("Alice");

// Utilisée comme callback
setTimeout(function() {
    console.log("3 secondes écoulées");
}, 3000);

7. Fonctions callback

Une fonction passée en paramètre à une autre fonction :

function traiterNombres(a, b, callback) {
    let resultat = callback(a, b);
    console.log("Résultat:", resultat);
}

function additionner(x, y) {
    return x + y;
}

function multiplier(x, y) {
    return x * y;
}

traiterNombres(5, 3, additionner);  // Résultat: 8
traiterNombres(5, 3, multiplier);   // Résultat: 15

8. Portée des variables (Scope)

Variables locales

function test() {
    let x = 10; // Variable locale
    console.log(x);
}

test(); // 10
// console.log(x); // Erreur ! x n'existe pas ici

Variables globales

let y = 20; // Variable globale

function afficher() {
    console.log(y); // Accessible
}

afficher(); // 20

9. Fonctions récursives

Une fonction qui s'appelle elle-même :

function factorielle(n) {
    if (n === 0 || n === 1) {
        return 1;
    }
    return n * factorielle(n - 1);
}

console.log(factorielle(5)); // 120 (5 * 4 * 3 * 2 * 1)

10. Exercice pratique

Créez les fonctions suivantes :

// 1. Fonction qui vérifie si un nombre est pair
function estPair(nombre) {
    return nombre % 2 === 0;
}

console.log(estPair(4));  // true
console.log(estPair(7));  // false

// 2. Fonction qui trouve le maximum de deux nombres
const max = (a, b) => a > b ? a : b;

console.log(max(10, 5)); // 10

// 3. Fonction qui calcule la moyenne d'un tableau
function moyenne(tableau) {
    let somme = 0;
    for (let nombre of tableau) {
        somme += nombre;
    }
    return somme / tableau.length;
}

console.log(moyenne([10, 20, 30])); // 20

// 4. Fonction qui inverse une chaîne
const inverser = chaine => chaine.split('').reverse().join('');

console.log(inverser("Bonjour")); // "ruojnoB"