Vérifier l'égalité d'une variable par rapport à une liste de valeurs

Question

Je vérifie une variable, disons foo pour l'égalité à un certain nombre de valeurs. Par exemple,

if( foo == 1 || foo == 3 || foo == 12 ) {
    // ...
}

Le fait est qu'il s'agit d'un code assez volumineux pour une tâche aussi triviale. J'ai trouvé ce qui suit :

if( foo in {1: 1, 3: 1, 12: 1} ) {
    // ...
}

mais cela ne me plaît pas du tout, car je dois donner des valeurs redondantes aux éléments de l'objet.

Quelqu'un connaît-il un moyen décent de vérifier l'égalité de plusieurs valeurs ?

Answer 1

Pour une liste plus importante de valeurs que vous comparez souvent, il est probablement plus optimal de construire d'abord un fichier Set et utiliser Set#has pour un contrôle de temps constant plutôt que Array#includes qui s'exécute en temps linéaire.

const values = new Set([1, 2, 12]);
if(values.has(foo)){
   // do something
}

Answer 2

J'ai simplement utilisé jQuery inArray et un tableau de valeurs :

myArr = ["A", "B", "C", "C-"];

var test = $.inArray("C", myArr)  
// returns index of 2 returns -1 if not in array

if(test >= 0) // true

Answer 3

Il s'agit d'une petite fonction de flèche d'aide :

const letters = ['A', 'B', 'C', 'D'];

function checkInList(arr, val) {
  return arr.some(arrVal => val === arrVal);
}

checkInList(letters, 'E');   // false
checkInList(letters, 'A');   // true

Plus d'informations ici...

Answer 4

Il s'agit en fait d'un cas d'utilisation. Par exemple, si vous vous souciez uniquement de savoir si la variable a une valeur spécifique, l'utilisation de Array.some() serait la meilleure solution, car il fait essentiellement office de forEach sur n'importe quel type d'itérable et retourne vrai à la première valeur rencontrée par la condition. C'est donc l'un des moyens les plus rapides de savoir si une option remplit la condition. Voici un exemple de son utilisation.

const anyOfThese = [1, 2, 14];
const doesHave0 = 0;
const doesHave1 = 1;
const doesHave14 = 14;

// checks all
const found0 = anyOfThese.some(singleValue => singleValue === doesHave0));
console.log("found0", found0);
// -> false

// check anyOfThese[0] = (1) returns without checking the rest
const found1 = anyOfThese.some(singleValue => singleValue === doesHave1));
console.log("found1", found1);
// -> true

// checks anyOfThese[0...14] until it finds singleValue === 14
const found14 = anyOfThese.some(singleValue => singleValue === doesHave14));
console.log("found14", found14);
// -> true

Cependant, si vous stockez des valeurs dans un ensemble dont vous voulez suivre le résultat total et que vous n'ajoutez des éléments que si l'ensemble ne les contient pas déjà, par exemple. L'utilisation d'un Set serait préférable car les ensembles ne peuvent avoir qu'une entrée pour chaque valeur unique et il suffit de l'ajouter à l'ensemble comme tel.

const mSet = new Set();
mSet.add(2);
mSet.add(5);
mSet.add(2);
console.debug("mSet", mSet); // -> mSet Set {2, 5}

Et si vous avez besoin de savoir si la valeur a été ajoutée ou non, vous pouvez simplement comparer la taille de l'ensemble en ligne avec l'ajout, comme ceci

const mSet = new Set();
mSet.add(2);
const addedFive = mSet.size < mSet.add(5).size;
console.debug("addedFive", addedFive);  // -> true
const addedTwo = mSet.size < mSet.add(2).size;
console.debug("addedTwo", addedTwo);  // -> false
console.debug("mSet", mSet); // -> Set {2, 5}

Et cela < peut être n'importe quel contrôle logique, de sorte que l'on pourrait dire

const mSet = new Set([2]);
mSet.size === mSet.add(2); // -> returns true; didn't add 2
mSet.size !== mSet.add(2); // -> returns false; didn't add 2
mSet.size === mSet.add(5); // -> returns false; added 5
mSet.size !== mSet.add(6); // -> returns true; added 6

Vous pouvez également utiliser n'importe quelle fonction, ce qui signifie que vous pouvez également dire

const mSet = new Set([2]);
mSet.size === mSet.remove(2); // -> returns false; removed 2
mSet.size === mSet.remove(2); // -> returns true; didn't remove anything

En < y > Les opérateurs permettent de clarifier plus facilement ce que l'on vérifie, mais === y !== fournir un éventail plus large de possibilités dans les cas où le changement exact peut ne pas être important, mais plutôt si quelque chose a changé ou n'a pas changé.

N'oubliez pas, lorsque vous écrivez votre logique, que ces contrôles font muter vos valeurs, de sorte que le set aura réellement la valeur contrôlée ajoutée ou supprimée.

Answer 5

En utilisant la syntaxe ES6, vous pouvez faire :

Object.prototype.in = function (...args) {
  return args.includes(this.valueOf());
}

qui, incidemment, vérifie également l'égalité profonde. La méthode valueOf() est nécessaire car cette est un objet.