méthodes génériques javascript

Javascript est un langage dynamique. Sa flexibilité et son évolutivité sont assez élevées, ce qui facilite la mise en œuvre de fonctions difficiles à réaliser dans de nombreux langages. Par exemple, dans certains langages, pour implémenter une méthode générique, vous devez utiliser des modèles ou une syntaxe générique. Mais en Javascript, nous pouvons implémenter une telle méthode grâce à la fonctionnalité de type dynamique.

Que sont les méthodes génériques ?

Une méthode générique fait référence à une méthode qui peut accepter plusieurs types de paramètres différents. Nous utilisons généralement des méthodes génériques pour déclarer des structures de données telles que des tableaux, des collections et des files d'attente, et leurs types peuvent être automatiquement déduits selon les besoins. En Javascript, les méthodes génériques peuvent facilement gérer différents types de données, améliorant ainsi la réutilisation et la flexibilité du code.

Comment mettre en œuvre des méthodes génériques ?

Lors de l'implémentation de méthodes génériques en Javascript, nous pouvons utiliser les caractéristiques du typage dynamique pour traiter différents types de données via des paramètres de fonction. Examinons quelques méthodes d'implémentation spécifiques :

1. Utilisation des fonctions fléchées ES6

const reverse = (input) => {
  const array = input instanceof Array ? input : input.split('');
  return array.reverse().join('');
};

console.log(reverse('hello')); // 'olleh'
console.log(reverse([1, 2, 3])); // [3, 2, 1]

Dans cet exemple, nous utilisons la fonction flèche ES6 et traitons différents types de données en déterminant si l'entrée est un tableau. Cette méthode peut accepter des paramètres tels que des chaînes ou des tableaux et renvoie une valeur inversée.

2. Utilisation de n'importe quel type

function identity<T>(arg: T): T {
  return arg;
}

console.log(identity(5));
console.log(identity('hello'));

Dans cet exemple, nous définissons une identité de fonction générique qui accepte les paramètres et renvoie des valeurs de tout type et fait correspondre son type avec le type de sortie.

3. Utilisation de plusieurs paramètres de type

function merge<T, U>(first: T, second: U): T & U {
  return Object.assign(first, second);
}

const result = merge({ name: 'Alice' }, { age: 25 });
console.log(result); // { name: 'Alice', age: 25 }

Dans cet exemple, nous utilisons plusieurs paramètres de type pour implémenter une méthode générique. La fonction de fusion accepte deux paramètres de types différents, les fusionne et renvoie un nouvel objet.

4. Utilisation de classes et d'interfaces

interface Lengthwise {
  length: number;
}

function loggingIdentity<T extends Lengthwise>(arg: T): T {
  console.log(arg.length);
  return arg;
}

console.log(loggingIdentity([1, 2, 3])); // [1, 2, 3]
console.log(loggingIdentity('hello')); // 'hello'

Dans cet exemple, nous utilisons des interfaces et des classes pour implémenter des méthodes génériques. La fonction loggingIdentity accepte un objet qui implémente l'interface lengthwise, imprime sa propriété length et renvoie l'objet.

Résumé

En Javascript, l'utilisation de méthodes génériques peut améliorer la réutilisation et la flexibilité du code. Nous pouvons mettre en œuvre des méthodes de traitement de différents types de données grâce aux caractéristiques des types dynamiques. Selon différents besoins, nous pouvons également utiliser différentes méthodes d'implémentation, telles que les fonctions fléchées ES6, tout type, plusieurs paramètres de type, classes, interfaces, etc. Quelle que soit la méthode d’implémentation, les méthodes génériques sont un bon exemple d’utilisation des fonctionnalités flexibles de Javascript.

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!