Controlla se tutti i valori dell'array sono uguali

Devo trovare array in cui tutti i valori siano uguali. Qual è il modo più veloce per farlo? Dovrei scorrere attraverso di esso e solo confrontare i valori?

['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

O one-liner:

[1,1,1,1].every( (val, i, arr) => val === arr[0] )   // true

Array.prototype.every (da MDN): il every()metodo verifica se tutti gli elementi dell'array superano il test implementato dalla funzione fornita.

Modifica: Be a ninja rosso:

!!array.reduce(function(a, b){ return (a === b) ? a : NaN; });

risultati:

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" 

Avvertimento:

var array = [] => result: TypeError thrown

Questo perché non passiamo un valore iniziale . Quindi, potresti voler controllare array.lengthprima.

Questo funziona Si crea un metodo sull'array utilizzando il prototipo.

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

Chiamalo in questo modo:

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

In JavaScript 1.6, puoi utilizzare Array.every:

function AllTheSame(array) {
    var first = array[0];
    return array.every(function(element) {
        return element === first;
    });
}

Probabilmente avrai bisogno di alcuni controlli di integrità, ad esempio quando l'array non ha elementi. (Inoltre, questo non funzionerà quando tutti gli elementi sono NaNfiniti NaN !== NaN, ma questo non dovrebbe essere un problema ... giusto?)

È possibile trasformare l'array in un set. Se la dimensione del set è uguale a 1, tutti gli elementi dell'array sono uguali.

function allEqual(arr) {
  return new Set(arr).size == 1;
}

allEqual(['a', 'a', 'a', 'a']); // true
allEqual(['a', 'a', 'b', 'a']); // false

E per il confronto delle prestazioni ho anche fatto 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];
    });
}

risultati:

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)

Quindi apparentemente l'utilizzo di array.some () è il metodo più veloce di quelli campionati.

Risposta più breve usando underscore / 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

modificare:

O ancora più breve, ispirato alla risposta di 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

Se stai già utilizzando underscore.js , ecco un'altra opzione che utilizza _.uniq:

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

_.uniqrestituisce una versione dell'array senza duplicati. Se tutti i valori sono uguali, la lunghezza sarà 1.

Come menzionato nei commenti, dato che potresti aspettarti un array vuoto da restituire true, allora dovresti anche verificare quel caso:

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

Sì, puoi controllarlo anche usando il filtro come di seguito, molto semplice, controllando che tutti i valori siano gli stessi del primo:

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

inoltre può essere eseguito usando tutti i metodi dell'array:

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

e puoi controllare le tue matrici come di seguito:

sameValues(['a', 'a', 'a', 'a']); // true
sameValues(['a', 'a', 'b', 'a']); // false

Oppure puoi aggiungerlo alle funzionalità dell'array nativo in JavaScript se lo riutilizzi molto:

//ES6
Array.prototype.sameValues = Array.prototype.sameValues || function(){
 this.every((v,i,a)=>v===a[0]);
}

e puoi controllare le tue matrici come di seguito:

['a', 'a', 'a', 'a'].sameValues(); // true
['a', 'a', 'b', 'a'].sameValues(); // false

Puoi usare Array.everyse supportato:

var equals = array.every(function(value, index, array){
    return value === array[0];
});

L'approccio alternativo di un ciclo potrebbe essere qualcosa di simile sort

var temp = array.slice(0).sort();
var equals = temp[0] === temp[temp.length - 1];

Oppure, se gli articoli sono come la domanda, qualcosa di sporco come:

var equals = array.join('').split(array[0]).join('').length === 0;

Funziona anche.

È possibile ottenere questo one-liner per fare ciò che si desidera utilizzando le funzioni freccia Array.prototype.every , Object.is ed ES6:

const all = arr => arr.every(x => Object.is(arr[0], x));

Penso che il modo più semplice per farlo sia quello di creare un ciclo per confrontare ciascun valore con il successivo. Finché si verifica un'interruzione nella "catena", restituisce false. Se il primo è uguale al secondo, il secondo è uguale al terzo e così via, allora possiamo concludere che tutti gli elementi dell'array sono uguali tra loro.

dati un array di dati [], quindi è possibile utilizzare:

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

Aggiorna nuova soluzione: controlla indice

 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;

Aggiornato con ES6: l'uso list.everyè il modo più veloce:

 let a = ['a', 'a', 'b', 'a'];
 let check = (list) => list.every(item => item === list[0]);

vecchia versione:

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

Puoi usare questo:

function same(a) {
    if (!a.length) return true;
    return !a.filter(function (e) {
        return e !== a[0];
    }).length;
}

La funzione controlla innanzitutto se l'array è vuoto. Se è i suoi valori sono uguali .. Altrimenti filtra l'array e accetta tutti gli elementi che sono diversi dal primo. Se non ci sono tali valori => l'array contiene solo elementi uguali, altrimenti non lo è.

La _.isEqual(object, other)funzione di Underscore sembra funzionare bene per le matrici. L'ordine degli elementi nell'array è importante quando verifica l'uguaglianza. Vedi 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);
    }));
}

È semplice. Crea una funzione e passa un parametro. In quella funzione copia il primo indice in una nuova variabile. Quindi creare un ciclo for e passare in rassegna l'array. All'interno di un ciclo crea un ciclo while con una condizione che controlla se la nuova variabile creata è uguale a tutti gli elementi nel ciclo. se il suo uguale ritorno è vero dopo che il ciclo for è completo, altrimenti restituisce false nel ciclo 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 risposta accettata ha funzionato alla grande ma volevo aggiungere un pochino. Non ha funzionato per me ===perché stavo confrontando le matrici di matrici di oggetti, tuttavia in tutta la mia app ho usato il pacchetto fast-deep-equal che consiglio vivamente. Detto questo, il mio codice è simile al seguente:

let areAllEqual = arrs.every((val, i, arr) => equal(val, arr[0]) );

e i miei dati si presentano così:

[  
  [
    {
      "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. Crea una stringa unendo l'array.
2. Crea una stringa ripetendo il primo carattere dell'array specificato
3. abbina entrambe le stringhe

	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']));

E sei fatto!

Ora puoi usare i set per farlo facilmente.

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

È possibile utilizzare un ciclo for:

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

Bene, questo non è davvero molto complicato. Ho un forte sospetto che tu non abbia nemmeno provato. Quello che fai è scegliere il primo valore, salvarlo nella variabile e quindi, all'interno di un forciclo, confrontare tutti i valori successivi con il primo.
Non ho intenzionalmente condiviso alcun codice. Scopri come forviene utilizzato e come vengono confrontate le variabili.

Semplice soluzione a una riga, basta confrontarla con un array riempito con la prima voce.

if(arr.join('') === Array(arr.length).fill(arr[0]).join(''))

Un altro modo interessante quando si utilizza la sintassi della funzione freccia 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

E quando non vuoi riutilizzare la variabile per array (x):

!['a', 'a', 'a', 'a'].filter((e,i,a)=>e!==a[0])[0]    // true

Poster precedente dell'IMO che utilizzava array.every (...) ha la soluzione più pulita.

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

• Per il primo ciclo; ogni volta che rileva irregolarità, restituisce "false"
• Il primo ciclo viene eseguito e se restituisce false, abbiamo "false"
• Quando non restituisce false, significa che ci sarà true, quindi facciamo il secondo loop. E ovviamente avremo "true" dal secondo loop (perché il primo loop ha riscontrato che NON è falso)

questo potrebbe funzionare, puoi usare anche il codice di commento che si sveglia bene anche con lo scenario dato.

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

Un altro modo con dimensioni delimitate ed elenco organizzato:

array1 = [1,2,3]; array2 = [1,2,3];

function isEqual(){

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

È possibile convertire l'array in un set e verificarne le dimensioni

Nel caso di elementi dell'array primitivi, cioè number, string:

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

In caso di array di oggetti con qualche campo da verificare per l'equivalenza, dire id:

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

In PHP esiste una soluzione molto semplice, un metodo a una riga:

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

Per esempio :

$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

È tutto.