Master les opérations de jeu JavaScript avancé

Apprenez à tirer parti de l’ensemble de JavaScript avec des exemples pratiques. Ce guide complet couvre l’union, la différence, la différence symétrique, l’intersection et plus encore.

Les ensembles sont des collections en JavaScript qui stockent des valeurs uniques. Contrairement aux tableaux, les ensembles gèrent automatiquement les doublons et fournissent des opérations puissantes pour travailler avec des données uniques. Alors que Tableaux sont idéaux pour les collections ordonnées où les doublons sont autorisés, les ensembles excellent dans la gestion des éléments uniques et l’exécution des opérations d’ensemble mathématique.

La structure des données définies a été introduite dans ES6, mais les ajouts récents ont apporté plus de méthodes qui rendent les ensembles encore plus utiles pour le développement moderne. Explorons ces nouvelles opérations et voyons comment ils peuvent résoudre des défis de programmation courants.

Opération syndicale

Le union() La méthode combine deux ensembles dans un nouvel ensemble contenant tous les éléments uniques des deux ensembles. Considérez-le comme fusionnant deux collections tout en supprimant automatiquement les doublons.

Exemple: gérer les rôles utilisateur

Regardons un exemple où nous avons divers rôles pour différentes catégories d’utilisateurs, appelez-les basic et admin. Nous pouvons obtenir tous les rôles dans le système tout en évitant les doublons en utilisant le union Méthode comme suit:

const basicRoles = new Set(['user', 'viewer', 'commenter']);
const adminRoles = new Set(['admin', 'moderator', 'user']);


const allRoles = basicRoles.union(adminRoles);

console.log(allRoles); 

Cette méthode est utile lorsque vous devez combiner des autorisations, des fonctionnalités ou toute collection où les doublons ne sont pas nécessaires.

Opération de différence

Le difference() La méthode crée un nouvel ensemble contenant des éléments qui existent dans le premier ensemble mais pas dans le second. C’est comme demander: « Qu’est-ce que je n’ai pas? »

Exemple: trouver des articles uniques dans les paniers d’achat

Cette méthode est utile lors du travail analytique. Imaginez un scénario où vous avez deux utilisateurs qui ont acheté des articles similaires, mais vous voulez savoir ce qui est unique à l’un d’eux. Voici comment vous feriez cela avec le difference() méthode.

const cart1 = new Set(['book', 'laptop', 'headphones', 'mouse']);
const cart2 = new Set(['book', 'laptop', 'keyboard']);


const uniqueToCart1 = cart1.difference(cart2);

console.log(uniqueToCart1); 

Noter que keyboardqui est unique à cart2n’est pas inclus parce que nous ne regardons que ce qui est unique cart1. Cette méthode est précieuse lorsque vous avez besoin de trouver des éléments qui existent exclusivement dans une collection mais pas dans une autre.

Opération de différence symétrique

Le symmetricDifference() La méthode renvoie des éléments qui sont dans l’un ou l’autre ensemble, mais pas dans les deux. Il est utile pour trouver des éléments uniques à chaque ensemble.

Exemple: comparaison des drapeaux de fonctionnalité

Notre prochain exemple concerne les drapeaux de fonctionnalité. Les indicateurs de fonctionnalité sont un concept de développement de logiciels qui vous permet d’activer ou de désactiver une fonctionnalité sans modifier le code source ni nécessiter un redéploy. Étant donné deux environnements distincts, production et développementVoyons comment nous pouvons trouver les fonctionnalités différentes dans ces environnements:

const prodFeatures = new Set(['dark-mode', 'search', 'notifications']);
const devFeatures = new Set(['dark-mode', 'search', 'debug-panel']);


const diffFeatures = prodFeatures.symmetricDifference(devFeatures);

console.log([...diffFeatures]); 

Le symmetricDifference() La méthode aide à comparer deux versions ou états pour trouver des différences, quel que soit leur côté.

Opération d’intersection

Le intersection() La méthode crée un nouvel ensemble contenant uniquement les éléments présents dans les deux ensembles. Il est parfait pour trouver des éléments communs entre deux ensembles.

Exemple: trouver des intérêts communs / passe-temps

Regardons un exemple où nous voulons trouver des passe-temps communs entre deux utilisateurs:

const user1Interests = new Set(['coding', 'music', 'hiking', 'photography']);
const user2Interests = new Set(['gaming', 'music', 'photography', 'cooking']);


const commonInterests = user1Interests.intersection(user2Interests);

console.log(commonInterests); 

Seulement music et photography sont présents dans les deux ensembles, donc ils forment l’intersection. Intérêts uniques tels que coding, hiking, gaming et cooking sont exclus. Essentiellement, utilisez le intersection() Méthode pour identifier les points communs entre deux collections, ce qui peut être particulièrement utile pour les systèmes de recommandation ou les algorithmes de correspondance.

Opération IsdisjointFrom

Le isDisjointFrom() La méthode vérifie si deux ensembles n’ont pas d’éléments en commun. Il renvoie True si les ensembles sont complètement différents.

Exemple: vérifier les conflits du calendrier

Imaginez si vous construisez la prochaine application de calendrier ou une application de calendrier où vous souhaitez vérifier si la réunion sur le point d’être programmée est en conflit avec une réunion existante. Tu peux faire ça avec isDisjointedFrom(). Voici comment:

const meeting1Times = new Set([9, 10, 11]);
const meeting2Times = new Set([14, 15, 16]);


const noConflict = meeting1Times.isDisjointFrom(meeting2Times);

console.log(noConflict); 

Cette opération d’ensemble est idéale pour vérifier si deux collections sont distinctes, ce qui est utile dans les scénarios de planification, d’allocation des ressources ou de détection de conflits.

Opération issubsetof

Le isSubsetOf() La méthode vérifie si tous les éléments du premier ensemble existent dans le second.

Exemple: valider les compétences requises

Examinons un exemple pour vérifier qu’un candidat à l’emploi répond aux exigences minimales.

const requiredSkills = new Set(['typescript', 'react']);
const candidateSkills = new Set(['typescript', 'react', 'node', 'python']);


const hasRequiredSkills = requiredSkills.isSubsetOf(candidateSkills);

console.log(hasRequiredSkills); 

Compte tenu d’une collection de compétences requises et de compétences d’un candidat, nous pouvons déterminer si le candidat répond aux critères en utilisant le isSubsetOf() méthode.

Opération Issupersetof

Ce isSupersetOf() La méthode vérifie si le premier ensemble contient tous les éléments de la seconde.

Exemple: vérification de l’implémentation des fonctionnalités

const requiredFeatures = new Set(['login', 'signup']);
const implementedFeatures = new Set(['login', 'signup', 'logout', 'profile']);


const allFeaturesImplemented = implementedFeatures.isSupersetOf(requiredFeatures);

console.log(allFeaturesImplemented); 

Cet exemple vérifie si nous avons implémenté toutes les fonctionnalités requises. Ceci est beaucoup plus simple que d’écrire des boucles et des instructions conditionnelles pour obtenir le même résultat.

C’est un enveloppe

Avant ES6, JavaScript n’avait pas de structure de données pour les ensembles. JavaScript a maintenant un Set Structure de données qui peut contenir des valeurs arbitraires et effectue rapidement des vérifications d’adhésion. Nous avons exploré le nouveau Set opérations ajoutées après ES6. Voici ce que nous avons appris:

• Utiliser union, difference et intersection Pour combiner / filtrage des ensembles de données.
• Appliquer symmetricDifference pour trouver des entrées uniques.
• Effet de levier isSubsetOf/ /isSupersetOf pour les contrôles de confinement.
• Utiliser isDisjointFrom pour la vérification de l’exclusivité.

Ces opérations font des ensembles un outil inestimable pour gérer des collections uniques, en comparant les données et en résolvant des défis de programmation courants. En maîtrisant ces opérations, vous rédigerez un code plus expressif lorsque vous travaillez avec des collections, des autorisations utilisateur à la gestion des stocks. N’oubliez pas que toutes les méthodes sans mutation renvoient de nouveaux ensembles, ce qui les rend sûrs pour les modèles de programmation fonctionnelle.

Les exemples fournis montrent des applications pratiques, mais il existe de nombreuses autres possibilités. Lorsque vous travaillez avec des ensembles, vous découvrirez qu’ils peuvent simplifier de nombreuses tâches de programmation courantes et rendre votre code plus expressif.