Les fonctions pures sont un concept fondamental de la programmation informatique qui sont utilisées pour écrire du code prévisible et maintenable.

Dans cet article, nous approfondirons le concept de fonctions pures et comment elles peuvent être utilisées pour écrire un meilleur code.

Qu'est-ce qu'une fonction pure ?

une fonction pure est une fonction qui a quelques caractéristiques clés :

1. Il renvoie toujours la même sortie pour un ensemble d'entrées donné ( prévisible ).
2. Il n'a pas d' effets secondaires , ce qui signifie qu'il ne modifie aucune variable en dehors de sa propre portée.
3. Il ne repose sur aucun état ou donnée externe.

Prévisible:

La fonction pure est considérée comme prévisible car elle renvoie toujours la même sortie pour un ensemble donné d'entrées.

Cela signifie que si vous appelez plusieurs fois une fonction pure avec le même ensemble d'entrées, elle renverra toujours le même résultat.

Par exemple, considérons la fonction pure suivante :

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

console.log(add(2, 3)); // 5
console.log(add(2, 3)); // 5
console.log(add(2, 3)); // 5

function add(x, y) {
  return x + y + Math.random() * 10;
}

Effets secondaires:

Les effets secondaires sont des modifications de l'état d'un programme ou d'un système provoquées par une fonction ou une opération.

Les effets secondaires incluent, mais ne sont pas limités à :

1. Modifier (muter) une variable globale :

let counter = 0;

function incrementCounter() {
  counter++;
}

const user = {
  name: 'Ali',
  age: 30
};

function setUserName(newName) {
  user.name = newName;
}

function saveDataToDatabase(data) {
//  db.save(data)
}

async function getDataFromAPI() {
  const response = await fetch('https://api.example.com/data');
  const data = await response.json();
  return data;
}

function toggleVisibility(elementId) {
  const element = document.getElementById(elementId);
  if (element.style.display === 'none') {
    element.style.display = 'block';
  } else {
    element.style.display = 'none';
  }
}

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

function divide(x, y) {
  if (y === 0) {
    throw new Error('Cannot divide by zero');
  }
  return x / y;
}

ne s'appuie sur aucun état ou donnée externe :

Dans cet exemple, la incrementCounterfonction incrémente une variable globale ( counter) et renvoie sa nouvelle valeur. Cette fonction est impure, car elle repose sur un état externe (la countervariable) et ne renvoie donc pas toujours la même sortie pour un ensemble d'entrées donné.

let counter = 0;

function incrementCounter() {
  counter++;
  return counter;
}

Les fonctions pures sont un principe clé de la programmation fonctionnelle et peuvent offrir un certain nombre d'avantages par rapport aux fonctions impures dans certaines situations. Voici quelques-uns des principaux avantages de l'utilisation de fonctions pures :

1. Prévisibilité et facilité de compréhension : cela facilite le raisonnement et le test du code, et vous permet également de réutiliser et de composer facilement des fonctions pures dans d'autres parties de votre programme.
2. Isolation et absence d'effets secondaires : les fonctions pures n'interagissent avec ni ne modifient aucun état ou donnée externe, et n'ont donc aucun effet secondaire. Cela les rend plus faciles à tester et à déboguer, car ils n'introduisent pas de dépendances ou de comportements involontaires .
3. Concurrence et évolutivité : les fonctions pures ne reposent pas sur un état ou des données externes, et peuvent donc être exécutées simultanément ou en parallèle sans se soucier des conditions de concurrence ou d'autres problèmes de concurrence. Cela facilite l'optimisation et la mise à l'échelle du code qui repose sur des fonctions pures.
4. Composabilité et programmation déclarative : Les fonctions pures sont un principe clé de la programmation fonctionnelle, qui est un paradigme de programmation qui se concentre sur l'immuabilité, les fonctions de première classe et la composition. L'utilisation de fonctions pures peut vous aider à écrire du code plus déclaratif et composable, et peut également faciliter le raisonnement et le débogage de votre code.

Redux est une bibliothèque de gestion d'état populaire pour les applications JavaScript.

Les fonctions pures sont particulièrement utiles car elles sont utilisées pour implémenter des réducteurs, qui sont chargés de mettre à jour l'état de l'application. En utilisant des fonctions pures pour mettre à jour l'état, Redux garantit que les mises à jour d'état sont prévisibles et faciles à comprendre, et active également des fonctionnalités puissantes telles que le débogage du voyage dans le temps et le rechargement à chaud.

Résumer: