Vérifiez si toutes les valeurs du tableau sont égales

J'ai besoin de trouver des tableaux où toutes les valeurs sont égales. Quel est le moyen le plus rapide de faire cela? Dois-je le parcourir et comparer simplement 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 (de MDN): la every()méthode teste si tous les éléments du tableau passent le test implémenté 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" 

Avertissement:

var array = [] => result: TypeError thrown

C'est parce que nous ne transmettons pas une valeur initiale . Donc, vous voudrez peut-être vérifier d' array.lengthabord.

Cela marche. Vous créez une méthode sur Array à l'aide de prototype.

if (Array.prototype.allValuesSame === undefined) {
  Array.prototype.allValuesSame = function() {
    for (let i = 1; i < this.length; i++) {
      if (this[i] !== this[0]) {
        return false;
      }
    }
    return true;
  }
}

Appelez cela de cette façon:

let a = ['a', 'a', 'a'];
let b = a.allValuesSame(); // true
a = ['a', 'b', 'a'];
b = a.allValuesSame();     // false

Dans 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 quelques vérifications de cohérence, par exemple lorsque le tableau ne contient aucun élément. (De plus, cela ne fonctionnera pas lorsque tous les éléments sont NaNdepuis 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 fait 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, utiliser array.some () intégré est la méthode la plus rapide de 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

Éditer:

Ou encore plus court, inspiré de 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;
}

_.uniqrenvoie une version sans doublon 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, vous devriez également vérifier ce cas:

function allEqual(arr) {
    return arr.length === 0 || _.uniq(arr).length === 1;
}

Oui, vous pouvez le vérifier également en utilisant le filtre comme ci-dessous, très simple, en vérifiant que toutes les valeurs sont les mêmes que la première:

//ES6
function sameValues(arr) {
  return arr.filter((v,i,a)=>v===a[0]).length === arr.length;
} 

peut également être fait en utilisant toutes les méthodes 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 de Array en JavaScript si vous le réutilisez beaucoup:

//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.everysi pris en charge:

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;

Fonctionne aussi.

Vous pouvez obtenir ce one-liner pour faire ce que vous voulez en utilisant les fonctions fléchées 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 le faire est de créer une boucle pour comparer chaque valeur à la suivante. Tant qu'il y a une coupure dans la "chaîne", alors il retournera faux. Si le premier est égal au second, le second égal au troisième et ainsi de suite, alors nous pouvons conclure que tous les éléments du tableau sont égaux les uns aux autres.

é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;

Mise à jour avec ES6: l'utilisation list.everyest 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, ses valeurs sont égales. Sinon, il filtre le tableau et prend tous les éléments qui sont 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.

La _.isEqual(object, other)fonction de soulignement 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 .

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);
    }));
}

C'est simple. Créez une fonction et passez un paramètre. Dans cette fonction, copiez le premier index dans une nouvelle variable. Créez ensuite 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 retourne true après la fin de la boucle for else retourne 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 réponse acceptée fonctionnait très bien mais je voulais ajouter un tout petit peu. Cela n'a pas fonctionné pour moi ===parce que je comparais des tableaux de tableaux d'objets, mais tout au long de mon application, j'ai utilisé le package 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
    }
  ]
]

1. Créez une chaîne en joignant le tableau.
2. Créer une chaîne par répétition du premier caractère du tableau donné
3. correspond aux deux chaînes

	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 avez terminé!

Vous pouvez maintenant utiliser des ensembles pour le faire facilement.

let a= ['a', 'a', 'a', 'a']; // true
let b =['a', 'a', 'b', 'a'];// false

console.log(new Set(a).size === 1);
console.log(new Set(b).size === 1);

Vous pouvez utiliser une boucle for:

function isEqual(arr) {
  var first = arr[0];
  for (let i = 1; i < arr.length; i++) {
    if (first !== arr[i]) {
      return false;
    }
  }
  return true;
}

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 est de choisir la première valeur, de l'enregistrer dans la variable, puis, dans une forboucle, de comparer toutes les valeurs suivantes avec la première.
Je n'ai intentionnellement partagé aucun code. Trouvez comment forest utilisé et comment les variables sont comparées.

Solution simple d'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 façon intéressante d'utiliser 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

L'affiche précédente de l'OMI qui a utilisé array.every (...) a la solution la plus propre.

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 des irrégularités, renvoie "faux"
• La première boucle s'exécute, et si elle retourne false, nous avons "false"
• Quand ce n'est pas de retour faux, cela signifie qu'il y aura vrai, donc nous faisons la deuxième boucle. Et bien sûr, nous aurons "true" de la deuxième boucle (car la première boucle a trouvé que ce n'est PAS faux)

cela pourrait fonctionner, vous pouvez également utiliser le code de commentaire qui fonctionne également bien 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();

Une autre façon avec une taille délimitée et une liste organisée:

tableau1 = [1,2,3]; tableau2 = [1,2,3];

function isEqual(){

    return array1.toString()==array2.toString();
}

Vous pouvez convertir un tableau en un ensemble et vérifier sa taille

Dans le cas d'entrées de tableaux primitifs, c'est number-à- dire string:

const isArrayWithEqualEntries = array => new Set(array).size === 1

Dans le cas d'un tableau d'objets avec un champ à tester pour l'équivalence, dites id:

const mapper = ({id}) => id
const isArrayWithEqualEntries = array => new Set(array.map(mapper)).size === 1

En PHP, il existe une solution très simple, une méthode en une ligne:

(count (array_count_values ​​($ array)) == 1)

Par exemple :

$arr1 = ['a', 'a', 'a', 'a'];
$arr2 = ['a', 'a', 'b', 'a'];


print (count(array_count_values($arr1)) == 1 ? "identical" : "not identical"); // identical
print (count(array_count_values($arr2)) == 1 ? "identical" : "not identical"); // not identical

C'est tout.