Fonctions Node.js

Une fonction est un bloc de code réutilisable utilisé pour effectuer une tâche spécifique.

Dans Node.js, les fonctions sont l'un des composants essentiels de JavaScript et constituent les blocs de construction de base des applications.

Node.js hérite de toutes les fonctionnalités de fonction de JavaScript, et elles jouent un rôle important dans son modèle de programmation asynchrone.

En JavaScript, une fonction peut être utilisée comme argument d'une autre fonction. Nous pouvons d'abord définir une fonction puis la passer, ou définir la fonction directement là où l'argument est passé.

Importance des fonctions

  • Réutilisation du code: Éviter de réécrire la même logique de façon répétée
  • Modularité: Décomposer les problèmes complexes en petites fonctions
  • Maintenabilité: Facilite le débogage et la modification d'unités fonctionnelles indépendantes

Déclaration de fonction

Utilisez lefunctionmot-clé pour déclarer une fonction.

function greet(name) {
    console.log(`Hello, ${name}!`);
}

Expression de fonction

Affectez une fonction à une variable.

const greet = function(name) {
    console.log(`Hello, ${name}!`);
};

Fonctions fléchées

Expressions de fonction concises introduites par ES6.

const greet = (name) => {
    console.log(`Hello, ${name}!`);
};

// 单行箭头函数
const greet = name => console.log(`Hello, ${name}!`);

Types de fonctions

1. Fonctions régulières

La forme de fonction la plus courante, qui peut avoir des paramètres et des valeurs de retour.

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

2. Fonctions anonymes

Fonctions sans nom, généralement passées comme arguments à d'autres fonctions.

setTimeout(function() {
    console.log('This is an anonymous function.');
}, 1000);

3. Fonctions de rappel

Passée comme argument à une autre fonction et appelée une fois qu'une certaine opération est terminée.

function fetchData(callback) {
    setTimeout(() => {
        const data = 'Some data';
        callback(data);
    }, 1000);
}

fetchData((data) => {
    console.log(data);
});

Fonctions asynchrones

Des callbacks aux promesses.

Exemple

function readFilePromise(path) {
  return new Promise((resolve, reject) => {
    fs.readFile(path, 'utf8', (err, data) => {
      if (err) reject(err);
      else resolve(data);
    });
  });
}

Utilisez les mots-clés async et await pour gérer les opérations asynchrones.

Exemple

async function fetchUser(id) {
    try {
        const response = await fetch(`https://api.example.com/users/${id}`);
        const user = await response.json();
        return user;
    } catch (error) {
        console.error('Erreur lors de la récupération de l'utilisateur :', error);
    }
}

fetchUser(1).then(user => console.log(user));

Comparaison des méthodes d'appel

Méthode d'appel Exemple Caractéristiques
Appel direct greet('Alice') La façon la plus courante
Appel en tant que méthode obj.method() this pointe vers l'objet appelant
Appel de constructeur new Constructor() Crée une nouvelle instance
Appel indirect greet.call(null, 'Bob') Peut changer la liaison de this

Utilisation avancée

1. Fermetures

Une fermeture est une fonction qui peut se souvenir de sa portée lexicale et y accéder même lorsqu'elle est exécutée en dehors de cette portée lexicale.

Exemple

function createCounter() {
    let count = 0;
    return function() {
        count++;
        return count;
    };
}

const counter = createCounter();
console.log(counter()); // 1
console.log(counter()); // 2

2. Fonctions d'ordre supérieur

Fonctions qui acceptent des fonctions comme arguments ou renvoient des fonctions.

Exemple

function applyOperation(a, b, operation) {
    return operation(a, b);
}

const sum = applyOperation(5, 3, (x, y) => x + y);
const product = applyOperation(5, 3, (x, y) => x * y);

console.log(sum); // 8
console.log(product); // 15

Gestion des paramètres de fonction

Paramètres par défaut

Fournir des valeurs par défaut pour les paramètres au moment de la déclaration de la fonction.

function greet(name = 'Guest') {
    console.log(`Hello, ${name}!`);
}

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

Paramètres du reste

Permet de représenter un nombre indéfini d'arguments sous forme de tableau.

Exemple

function sum(...numbers) {
    return numbers.reduce((acc, num) => acc + num, 0);
}

console.log(sum(1, 2, 3, 4)); // 10

Paramètres déstructurés

Extraire des données d'objets ou de tableaux et les affecter à des variables.

Exemple

function getUserInfo({ name, age }) {
    console.log(`Name: ${name}, Age: ${age}`);
}

const user = { name: 'Alice', age: 30 };
getUserInfo(user); // Nom : Alice, Âge : 30

Exemple

Responsabilité unique des fonctions :Chaque fonction ne devrait faire qu'une seule chose, ce qui facilite les tests et la maintenance.

Exemple

function calculateArea(width, height) {
    return width * height;
}

Éviter les variables globales :Minimisez l'utilisation des variables globales ; utilisez plutôt des variables locales et des paramètres de fonction.

Exemple

function calculateTotal(items) {
    let total = 0;
    for (const item of items) {
        total += item.price * item.quantity;
    }
    return total;
}

Utilisez les fonctions fléchées :Les fonctions fléchées sont concises et claires, en particulier lorsqu'il s'agit de fonctions de rappel.

Exemple

const users = [
    { id: 1, name: 'Alice' },
    { id: 2, name: 'Bob' }
];

const names = users.map(user => user.name);
console.log(names); // ['Alice', 'Bob']

Gestion des erreurs :Utilisez les instructions try...catch pour gérer les erreurs qui peuvent être levées.

Exemple

async function fetchUser(id) {
    try {
        const response = await fetch(`https://api.example.com/users/${id}`);
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        const user = await response.json();
        return user;
    } catch (error) {
        console.error('Erreur lors de la récupération de l'utilisateur :', error);
    }
}

Fonctions comme paramètres :Utilisez une fonction comme argument.

Exemple

function say(word) {
  console.log(word);
}

function execute(someFunction, value) {
  someFunction(value);
}

execute(say, "Hello");

Dans le code ci-dessus, nous passons la fonction say comme premier argument de la fonction execute. Ce qui est passé ici n'est pas la valeur de retour de say, mais say elle-même !

Par conséquent, say devient la variable locale someFunction à l'intérieur de execute, et execute peut utiliser la fonction say en appelant someFunction() (avec des parenthèses).

Bien sûr, comme say a un paramètre, execute peut passer un tel argument lors de l'appel à someFunction.

Fonctions anonymes :Nous pouvons passer une fonction comme une variable. Mais nous ne sommes pas obligés de passer par la boucle « définir d'abord, puis passer » ; nous pouvons définir et passer la fonction directement entre les parenthèses d'une autre fonction :

Exemple

function execute(someFunction, value) {
  someFunction(value);
}

execute(function(word){ console.log(word) }, "Hello");

Nous définissons la fonction que nous avons l'intention de passer à execute directement là où execute accepte son premier argument.

De cette façon, nous n'avons même pas besoin de donner un nom à la fonction, c'est pourquoi on l'appelle une fonction anonyme.

Comment le passage de fonctions fait fonctionner le serveur HTTP

Avec ces connaissances, jetons un autre coup d'œil à notre serveur HTTP simple mais pas si simple que ça :

Exemple

var http = require("http");

http.createServer(function(request, response) {
  response.writeHead(200, {"Content-Type": "text/plain"});
  response.write("Hello World");
  response.end();
}).listen(8888);

Maintenant, cela devrait être beaucoup plus clair : nous passons une fonction anonyme à la fonction createServer.

Le même objectif peut être atteint avec un code comme celui-ci :

Exemple

var http = require("http");

function onRequest(request, response) {
  response.writeHead(200, {"Content-Type": "text/plain"});
  response.write("Hello World");
  response.end();
}

http.createServer(onRequest).listen(8888);

Bonnes pratiques des fonctions

Principes de conception des fonctions

  1. Responsabilité unique: une fonction ne fait qu'une seule chose
  2. Nommage raisonnable: Utiliser la forme verbe + nom (par ex.getUserInfo）
  3. Contrôler la longueur: Il est recommandé de ne pas dépasser 20 lignes de code
  4. Éviter les effets de bord: Les fonctions pures sont plus faciles à tester et à maintenir

Conseils d'optimisation des performances

Exemple

// Utiliser une fermeture pour mettre en cache les résultats
function memoize(fn) {
  const cache = new Map();
  return (...args) => {
    const key = JSON.stringify(args);
    if (cache.has(key)) return cache.get(key);
    const result = fn(...args);
    cache.set(key, result);
    return result;
  };
}

Travaux pratiques

Exercice 1 : Créer une fonction de conversion de température

Exemple

/**
* Convertir entre Celsius et Fahrenheit
* @param {number} temp - Valeur de température
* @param {string} unit - Unité d'origine ('C' ou 'F')
* @returns {number} Température convertie
 */
function convertTemperature(temp, unit) {
  // Votre code...
}

Exercice 2 : Implémenter un émetteur d'événements simple

Exemple

class EventEmitter {
  constructor() {
    this.événements = {};
  }
 
  // Implémenter les méthodes on/emit/off
}
Autres extensions