Fonction personnalisée JavaScript à accumuler

JavaScript est un langage de programmation de haut niveau utilisé pour écrire des applications Web. Ses puissantes capacités et son large éventail d'utilisations en ont fait l'un des outils incontournables du développement Web. En JavaScript, les fonctions personnalisées sont une technologie très importante qui nous permet d'écrire et d'appeler des fonctions selon nos propres besoins. Dans cet article, nous présenterons comment utiliser une fonction personnalisée JavaScript pour accumuler.

Qu'est-ce que l'accumulation ?

L'addition consiste à additionner tous les nombres d'une séquence de nombres. Par exemple, si nous avons la séquence de nombres 1, 2, 3, 4, 5, alors le résultat cumulé est 15 (c'est-à-dire 1 + 2 + 3 + 4 + 5).

Comment utiliser les fonctions personnalisées JavaScript pour accumuler ?

Pour utiliser les fonctions personnalisées JavaScript pour accumuler, nous devons utiliser des variables, des boucles et des instructions conditionnelles.

Voici un programme d'accumulation le plus simple :

function sum(arr) {
  var s = 0;
  for (var i = 0; i < arr.length; i++) {
    s += arr[i];
  }
  return s;
}

var arr = [1, 2, 3, 4, 5];
console.log(sum(arr)); // 15

Décomposons ce programme étape par étape :

1. Tout d'abord, nous définissons une fonction appelée sum qui prend un paramètre arr. Cette fonction renverra un nombre, qui est la somme de la séquence de nombres.
2. Nous utilisons une variable s pour stocker le résultat accumulé et l'initialiser à 0. Ici, nous utilisons le mot-clé var pour déclarer des variables. Le mot-clé var indique que s est une variable locale accessible et utilisée uniquement dans la fonction actuelle. Si nous définissons une variable en dehors d'une fonction, elle devient une variable globale et peut être utilisée n'importe où dans le programme.
3. Ensuite, nous utilisons une boucle pour parcourir chaque élément de la séquence de nombres. La variable de boucle i est initialisée à 0 et augmente de 1 à chaque fois jusqu'à ce que i soit égal à arr.length.
4. Dans la boucle, nous utilisons s += arr[i] pour ajouter la valeur de l'élément actuel au résultat accumulé. Il s'agit d'une abréviation simple équivalente à s = ​​s + arr[i].
5. Enfin, nous utilisons l'instruction return pour renvoyer le résultat accumulé.

Nous pouvons le tester en appelant la fonction somme et en transmettant une séquence de nombres. Dans cet exemple, nous définissons une séquence de nombres arr = [1, 2, 3, 4, 5] et utilisons la fonction console.log pour afficher son résultat cumulé.

Le programme ci-dessus est la forme la plus basique de fonction personnalisée JavaScript pour l'accumulation. Cependant, cela laisse beaucoup à désirer.

Gestion des erreurs

Le programme précédent suppose que les données d'entrée sont correctes et valides et effectue les calculs directement. Cependant, dans les applications réelles, nous sommes susceptibles de rencontrer des données d'entrée incorrectes ou d'autres erreurs.

Pour écrire un programme plus robuste, nous devons ajouter un mécanisme de gestion des erreurs. Voici un programme d'accumulation amélioré :

function sum(arr) {
  if (!Array.isArray(arr)) {
    throw new TypeError('sum() expects an array as parameter.');
  }
  var s = 0;
  for (var i = 0; i < arr.length; i++) {
    if (typeof arr[i] !== 'number') {
      throw new TypeError('sum() expects an array of numbers.');
    }
    s += arr[i];
  }
  return s;
}

var arr = [1, 2, 3, 4, 5];
console.log(sum(arr)); // 15
console.log(sum('12345')); // TypeError: sum() expects an array as parameter.
console.log(sum([1, '2', 3, 4])); // TypeError: sum() expects an array of numbers.

Dans cette version, nous avons ajouté deux conditions de gestion des erreurs :

1. Si le paramètre transmis n'est pas un tableau, nous lancerons une TypeError (TypeError).
2. Nous générerons également une erreur de type s'il y a des éléments dans le tableau qui ne sont pas des nombres.

La gestion des erreurs peut considérablement améliorer la robustesse et la fiabilité du programme, garantissant que nos fonctions peuvent s'exécuter correctement dans des circonstances inattendues.

Signature de fonction

En programmation, la signature de fonction fait référence au nom, aux paramètres et au type de valeur de retour de la fonction. Déterminer les signatures de fonctions peut nous aider à comprendre et à utiliser les fonctions plus facilement.

La signature de la fonction doit contenir les éléments suivants :

1. Nom de la fonction : il doit s'agir d'une chaîne de texte décrivant le comportement de la fonction. Par exemple, le nom de fonction sum ci-dessus décrit très bien son comportement.
2. Paramètre : il doit s'agir d'une chaîne de texte décrivant l'entrée dans la fonction. Pour la fonction d'accumulation, nous n'avons besoin que d'un seul paramètre de tableau arr.
3. Type de valeur de retour : il doit s'agir d'une chaîne de texte décrivant le type de valeur de retour de la fonction. Pour la fonction d'accumulation, nous nous attendons à ce qu'elle renvoie un nombre.

Pour la fonction d'accumulation, on peut signer sa fonction comme suit :

sum(arr: Array) => Number

Cela indique que la fonction somme nécessite un tableau comme paramètre et renvoie un nombre comme résultat.

Fonctions d'ordre supérieur

En JavaScript, une fonction d'ordre supérieur est une fonction qui accepte une fonction en entrée ou renvoie une fonction en sortie. Nous pouvons utiliser des fonctions d'ordre supérieur pour encapsuler des opérations courantes et les appliquer à différents types ou conditions de données.

Par exemple, nous pouvons écrire une fonction de carte générale qui peut appliquer une opération à chaque élément de n'importe quel tableau. Voyons comment écrire cette fonction :

function map(arr, f) {
  if (!Array.isArray(arr)) {
    throw new TypeError('map() expects an array as parameter.');
  }
  if (typeof f !== 'function') {
    throw new TypeError('map() expects a function as second parameter.');
  }
  var result = [];
  for (var i = 0; i < arr.length; i++) {
    result.push(f(arr[i]));
  }
  return result;
}

var arr = [1, 2, 3, 4, 5];
console.log(map(arr, x => 2 * x)); // [2, 4, 6, 8, 10]

var words = ['JavaScript', 'is', 'awesome'];
console.log(map(words, w => w.toUpperCase())); // ['JAVASCRIPT', 'IS', 'AWESOME']

Cette fonction prend deux paramètres : un tableau arr et une fonction f. La fonction f sera appliquée à chaque élément du tableau et renverra le résultat calculé.

Nous pouvons utiliser la fonction map pour appliquer différentes opérations telles que la multiplication sur chaque élément du tableau de nombres et la conversion en majuscules sur chaque élément du tableau de chaînes. Puisque la fonction map est une opération générale, nous n’avons besoin de la définir qu’une seule fois et de l’utiliser dans plusieurs scénarios.

Résumé :

Grâce à l'introduction de cet article, nous avons appris à utiliser les fonctions personnalisées JavaScript pour accumuler. Nous avons appris à gérer les erreurs, à définir des signatures de fonctions et à utiliser des fonctions d'ordre supérieur. Les fonctions personnalisées JavaScript sont très flexibles et puissantes, nous permettant d'écrire et d'appeler des fonctions en fonction de nos propres besoins, améliorant ainsi la répétabilité et la maintenabilité du code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!