Vérifier si toutes les valeurs du tableau sont égales
Je dois trouver des tableaux où toutes les valeurs sont égales. Quel est le moyen le plus rapide de faire cela? Devrais-je parcourir et comparer les valeurs?
['a', 'a', 'a', 'a'] // true
['a', 'a', 'b', 'a'] // false
const allEqual = arr => arr.every( v => v === arr[0] )
allEqual( [1,1,1,1] ) // true
Ou one-liner:
[1,1,1,1].every( (val, i, arr) => val === arr[0] ) // true
Array.prototype.every (à partir de MDN): La méthode every() teste si tous les éléments du tableau réussissent le test mis en œuvre par la fonction fournie.
Edit: Soyez un ninja rouge:
!!array.reduce(function(a, b){ return (a === b) ? a : NaN; });
Résultats:
var array = ["a", "a", "a"] => result: "true"
var array = ["a", "b", "a"] => result: "false"
var array = ["false", ""] => result: "false"
var array = ["false", false] => result: "false"
var array = ["false", "false"] => result: "true"
var array = [NaN, NaN] => result: "false"
Attention:
var array = [] => result: TypeError thrown
En effet, nous ne transmettons pas un initialValue . Donc, vous voudrez peut-être vérifier array.length en premier.
Cela marche. Vous créez une méthode sur Array en utilisant prototype.
Array.prototype.allValuesSame = function() {
for(var i = 1; i < this.length; i++)
{
if(this[i] !== this[0])
return false;
}
return true;
}
Appelez ça de cette façon:
var a = ['a', 'a', 'a'];
var b = a.allValuesSame(); //true
a = ['a', 'b', 'a'];
b = a.allValuesSame(); //false
En JavaScript 1.6, vous pouvez utiliser Array.every :
function AllTheSame(array) {
var first = array[0];
return array.every(function(element) {
return element === first;
});
}
Vous avez probablement besoin de contrôles de cohérence, par exemple quand le tableau n'a pas d'éléments. (En outre, cela ne fonctionnera pas si tous les éléments sont NaN depuis NaN !== NaN, mais cela ne devrait pas être un problème… non?
Vous pouvez transformer le tableau en un ensemble. Si la taille de l'ensemble est égale à 1, tous les éléments du tableau sont égaux.
function allEqual(arr) {
return new Set(arr).size == 1;
}
allEqual(['a', 'a', 'a', 'a']); // true
allEqual(['a', 'a', 'b', 'a']); // false
Et pour la comparaison des performances, j'ai également réalisé un benchmark:
function allAreEqual(array){
if(!array.length) return true;
// I also made sure it works with [false, false] array
return array.reduce(function(a, b){return (a === b)?a:(!b);}) === array[0];
}
function same(a) {
if (!a.length) return true;
return !a.filter(function (e) {
return e !== a[0];
}).length;
}
function allTheSame(array) {
var first = array[0];
return array.every(function(element) {
return element === first;
});
}
function useSome(array){
return !array.some(function(value, index, array){
return value !== array[0];
});
}
Résultats:
allAreEqual x 47,565 ops/sec ±0.16% (100 runs sampled)
same x 42,529 ops/sec ±1.74% (92 runs sampled)
allTheSame x 66,437 ops/sec ±0.45% (102 runs sampled)
useSome x 70,102 ops/sec ±0.27% (100 runs sampled)
Donc, apparemment, l'utilisation de array.some () est la méthode la plus rapide parmi celles échantillonnées.
Réponse la plus courte en utilisant un trait de soulignement/lodash
function elementsEqual(arr) {
return !_.without(arr, arr[0]).length
}
spec:
elementsEqual(null) // throws error
elementsEqual([]) // true
elementsEqual({}) // true
elementsEqual([1]) // true
elementsEqual([1,2]) // false
elementsEqual(NaN) // true
modifier:
Ou même plus court, inspiré par la réponse de Tom:
function elementsEqual2(arr) {
return _.uniq(arr).length <= 1;
}
spec:
elementsEqual2(null) // true (beware, it's different than above)
elementsEqual2([]) // true
elementsEqual2({}) // true
elementsEqual2([1]) // true
elementsEqual2([1,2]) // false
elementsEqual2(NaN) // true
Si vous utilisez déjà underscore.js , voici une autre option utilisant _.uniq:
function allEqual(arr) {
return _.uniq(arr).length === 1;
}
_.uniq renvoie une version sans doublons du tableau. Si toutes les valeurs sont identiques, la longueur sera 1.
Comme mentionné dans les commentaires, étant donné que vous pouvez vous attendre à ce qu'un tableau vide retourne true, alors vous devriez également vérifier ce cas
function allEqual(arr) {
return arr.length === 0 || _.uniq(arr).length === 1;
}
Oui, vous pouvez aussi le vérifier en utilisant un filtre comme ci-dessous, très simple, en vérifiant que toutes les valeurs sont identiques
//ES6
function sameValues(arr) {
return arr.filter((v,i,a)=>v===a[0]).length === arr.length;
}
peut aussi être fait en utilisant chaque méthode du tableau:
//ES6
function sameValues(arr) {
return arr.every((v,i,a)=>v===a[0]);
}
et vous pouvez vérifier vos tableaux comme ci-dessous:
sameValues(['a', 'a', 'a', 'a']); // true
sameValues(['a', 'a', 'b', 'a']); // false
Ou vous pouvez l'ajouter aux fonctionnalités natives d'Array en JavaScript si vous le réutilisez souvent:
//ES6
Array.prototype.sameValues = Array.prototype.sameValues || function(){
this.every((v,i,a)=>v===a[0]);
}
et vous pouvez vérifier vos tableaux comme ci-dessous:
['a', 'a', 'a', 'a'].sameValues(); // true
['a', 'a', 'b', 'a'].sameValues(); // false
Vous pouvez utiliser Array.every si supporté:
var equals = array.every(function(value, index, array){
return value === array[0];
});
L’approche alternative d’une boucle pourrait être quelque chose comme sort
var temp = array.slice(0).sort();
var equals = temp[0] === temp[temp.length - 1];
Ou, si les éléments sont comme la question, quelque chose de sale comme:
var equals = array.join('').split(array[0]).join('').length === 0;
Travaille également.
Vous pouvez obtenir cette ligne unique de faire ce que vous voulez en utilisant Array.prototype.every , Object.is et ES6:
const all = arr => arr.every(x => Object.is(arr[0], x));
Je pense que le moyen le plus simple de faire est de créer une boucle pour comparer chaque valeur à la suivante. Tant qu'il y a une rupture dans la "chaîne", alors cela retourne faux. Si le premier est égal au second, le second au troisième et ainsi de suite, nous pouvons en conclure que tous les éléments du tableau sont égaux.
étant donné un tableau de données [], alors vous pouvez utiliser:
for(x=0;x<data.length - 1;x++){
if (data[x] != data[x+1]){
isEqual = false;
}
}
alert("All elements are equal is " + isEqual);
arr.length && arr.reduce(function(a, b){return (a === b)?a:false;}) === arr[0];
Mettre à jour une nouvelle solution: vérifier l'index
let a = ['a', 'a', 'b', 'a'];
let a = ['a', 'a', 'a', 'a'];
let check = (list) => list.every(item => list.indexOf(item) === 0);
check(a); // false;
check(b); // true;
Mis à jour avec ES6: Utiliser list.every est le moyen le plus rapide:
let a = ['a', 'a', 'b', 'a'];
let check = (list) => list.every(item => item === list[0]);
ancienne version:
var listTrue = ['a', 'a', 'a', 'a'];
var listFalse = ['a', 'a', 'a', 'ab'];
function areWeTheSame(list) {
var sample = list[0];
return (list.every((item) => item === sample));
}
Vous pouvez utiliser ceci:
function same(a) {
if (!a.length) return true;
return !a.filter(function (e) {
return e !== a[0];
}).length;
}
La fonction vérifie d'abord si le tableau est vide. Si c'est le cas, les valeurs sont égales à ...__ sinon, il filtre le tableau et prend tous les éléments différents du premier S'il n'y a pas de telles valeurs => le tableau ne contient que des éléments égaux, sinon ce n'est pas le cas.
var listTrue = ['a', 'a', 'a', 'a'];
var listFalse = ['a', 'a', 'a', 'ab'];
function areWeTheSame(list) {
var sample = list[0];
return !(list.some(function(item) {
return !(item == sample);
}));
}
Eh bien, ce n'est vraiment pas très compliqué. Je soupçonne fortement que vous n'avez même pas essayé. Ce que vous faites, c'est que vous choisissez la première valeur, l'enregistrez dans la variable, puis, au sein d'une boucle for, comparez toutes les valeurs suivantes avec la première.
Je n'ai intentionnellement partagé aucun code. Trouvez comment for est utilisé et comment les variables sont comparées.
Le la réponse acceptée a bien fonctionné, mais je voulais ajouter un tout petit peu. Cela n'a pas fonctionné pour moi d'utiliser === car je comparais des tableaux de tableaux d'objets. Cependant, tout au long de mon application, j'ai utilisé le paquet fast-deep-equal que je recommande vivement. Avec cela, mon code ressemble à ceci:
let areAllEqual = arrs.every((val, i, arr) => equal(val, arr[0]) );
et mes données ressemblent à ceci:
[
[
{
"ID": 28,
"AuthorID": 121,
"VisitTypeID": 2
},
{
"ID": 115,
"AuthorID": 121,
"VisitTypeID": 1
},
{
"ID": 121,
"AuthorID": 121,
"VisitTypeID": 1
}
],
[
{
"ID": 121,
"AuthorID": 121,
"VisitTypeID": 1
}
],
[
{
"ID": 5,
"AuthorID": 121,
"VisitTypeID": 1
},
{
"ID": 121,
"AuthorID": 121,
"VisitTypeID": 1
}
]
]
La fonction _.isEqual(object, other) de Underscore semble bien fonctionner pour les tableaux. L'ordre des éléments dans le tableau est important lorsqu'il vérifie l'égalité. Voir http://underscorejs.org/#isEqual .
C'est simple . Créez une fonction et passez un paramètre . Dans cette fonction, copiez le premier index dans une nouvelle variable . Ensuite, créez une boucle for et parcourez le tableau . À l'intérieur d'une boucle, créez une boucle while avec une condition vérifiant si la nouvelle variable créée est égale à tous les éléments de la boucle . si son égal renvoie true après la fin de la boucle for sinon renvoie false dans la boucle while.
function isUniform(arra){
var k=arra[0];
for (var i = 0; i < arra.length; i++) {
while(k!==arra[i]){
return false;
}
}
return true;
}
La méthode every () vérifie si tous les éléments d'un tableau passent un test (fourni en tant que fonction).
La méthode every () exécute la fonction une fois pour chaque élément présent dans le tableau:
- S'il trouve un élément de tableau dans lequel la fonction retourne une valeur False, every () renvoie false (et ne vérifie pas les valeurs Restantes).
- Si aucun false ne se produit, every () renvoie true
Remarque: every () n'exécute pas la fonction pour les éléments de tableau sans valeurs.
Remarque: every () ne modifie pas le tableau d'origine
var ages = [32, 33, 16, 40];
function checkAdult(age) {
return age == 1;
}
function myFunction() {
alert(ages.every(checkAdult));
}<p>Click the button to check if every element in the array is equal to one.</p>
<button onclick="myFunction()">Try it</button>Solution simple à une ligne, comparez-la simplement à un tableau rempli avec la première entrée.
if(arr.join('') === Array(arr.length).fill(arr[0]).join(''))
Une autre méthode intéressante lorsque vous utilisez la syntaxe de la fonction de flèche ES6:
x = ['a', 'a', 'a', 'a']
!x.filter(e=>e!==x[0])[0] // true
x = ['a', 'a', 'b', 'a']
!x.filter(e=>e!==x[0])[0] // false
x = []
!x.filter(e=>e!==x[0])[0] // true
Et quand vous ne voulez pas réutiliser la variable pour array (x):
!['a', 'a', 'a', 'a'].filter((e,i,a)=>e!==a[0])[0] // true
La précédente affiche de l'OMI qui a utilisé array.every (...) a la solution la plus propre.
Une autre façon avec une taille délimitée et une liste organisée:
array1 = [1,2,3]; array2 = [1,2,3];
function isEqual(){
return array1.toString()==array2.toString();
}
function isUniform(array) {
for (var i=1; i< array.length; i++) {
if (array[i] !== array[0]) { return false; }
}
for (var i=1; i< array.length; i++) {
if (array[i] === array[0]) { return true; }
}
}
- Pour la première boucle; chaque fois qu'il détecte une inégalité, renvoie "faux"
- La première boucle s'exécute, et si elle renvoie false, nous avons "false"
- Quand il ne retourne pas false, cela signifie qu'il y aura du vrai, alors nous faisons la deuxième boucle. Et bien sûr, nous aurons "true" à partir de la deuxième boucle (car la première boucle trouvée n'est pas fausse)
- Créez une chaîne en rejoignant le tableau.
- Créer une chaîne en répétant le premier caractère du tableau donné
- faire correspondre les deux cordes
function checkArray(array){
return array.join("") == array[0].repeat(array.length);
}
console.log('array: [a,a,a,a]: ' + checkArray(['a', 'a', 'a', 'a']));
console.log('array: [a,a,b,a]: ' + checkArray(['a', 'a', 'b', 'a']));Et vous en avez fini!
const allEqual = arr => arr.every( v => v === **arr[0]** )
allEqual( [1,1,1,1] ) // true
Ou one-liner:
[1,1,1,1].every( (val, i, arr) => val === **arr[0]** ) // true
// Ce code ne fonctionnera que pour les tableaux tels que [1,1,1,1], [2,2,2,2], même élément tableau . ]
Ici, ça devrait être arr [i], pas arr [0]
cela pourrait fonctionner, vous pouvez également utiliser le code de commentaire qui fonctionne également avec le scénario donné.
function isUniform(){
var arrayToMatch = [1,1,1,1,1];
var temp = arrayToMatch[0];
console.log(temp);
/* return arrayToMatch.every(function(check){
return check == temp;
});*/
var bool;
arrayToMatch.forEach(function(check){
bool=(check == temp);
})
console.log(bool);
}
isUniform();