Verifique se todos os valores da matriz são iguais

Eu preciso encontrar matrizes onde todos os valores são iguais. Qual é a maneira mais rápida de fazer isso? Devo percorrê-lo e apenas comparar valores?

['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 uma linha:

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

Array.prototype.every (from MDN): O every()método testa se todos os elementos da matriz são aprovados no teste implementado pela função fornecida.

Edit: Seja um ninja vermelho:

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

Resultados:

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" 

Aviso:

var array = [] => result: TypeError thrown

Isso ocorre porque não passamos um valor inicial . Portanto, você pode verificar array.lengthprimeiro.

Isso funciona. Você cria um método na matriz usando o protótipo.

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

Chame assim:

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

No JavaScript 1.6, você pode usar Array.every:

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

Você provavelmente precisará de algumas verificações de integridade, por exemplo, quando o array não possui elementos. (Além disso, isso não funcionará quando todos os elementos forem NaNdesde então NaN !== NaN, mas isso não deve ser um problema ... certo?)

Você pode transformar a matriz em um conjunto. Se o tamanho do conjunto for igual a 1, todos os elementos da matriz serão iguais.

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

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

E para comparação de desempenho, também fiz uma referência:

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

Resultados:

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)

Então, aparentemente, o uso do array.some () interno é o método mais rápido dos exemplos.

Resposta mais curta usando sublinhado / lodash

function elementsEqual(arr) {
    return !_.without(arr, arr[0]).length
}

especificação:

elementsEqual(null) // throws error
elementsEqual([]) // true
elementsEqual({}) // true
elementsEqual([1]) // true
elementsEqual([1,2]) // false
elementsEqual(NaN) // true

editar:

Ou ainda mais, inspirado na resposta de Tom:

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

especificação:

elementsEqual2(null) // true (beware, it's different than above)
elementsEqual2([]) // true
elementsEqual2({}) // true
elementsEqual2([1]) // true
elementsEqual2([1,2]) // false
elementsEqual2(NaN) // true

Se você já está usando underscore.js , aqui está outra opção usando _.uniq:

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

_.uniqretorna uma versão sem duplicado da matriz. Se todos os valores forem iguais, o comprimento será 1.

Conforme mencionado nos comentários, como você pode esperar que uma matriz vazia retorne true, verifique também o caso:

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

Sim, você também pode verificá-lo usando o filtro abaixo, muito simples, verificando todos os valores iguais aos do primeiro:

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

Também pode ser feito usando todos os métodos na matriz:

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

e você pode verificar suas matrizes como abaixo:

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

Ou você pode adicioná-lo às funcionalidades nativas de Array em JavaScript, se você o reutilizar muito:

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

e você pode verificar suas matrizes como abaixo:

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

Você pode usar Array.everyse suportado:

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

A abordagem alternativa de um loop pode ser algo como sort

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

Ou, se os itens forem como a pergunta, algo sujo como:

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

Também funciona.

Você pode obter esse one-liner para fazer o que quiser usando as funções de seta Array.prototype.every , Object.is e ES6:

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

Eu acho que a maneira mais simples de fazer isso é criar um loop para comparar cada valor ao próximo. Enquanto houver uma quebra na "cadeia", ela retornará falsa. Se o primeiro é igual ao segundo, o segundo é igual ao terceiro e assim por diante, podemos concluir que todos os elementos da matriz são iguais entre si.

dado um dado de matriz [], você pode usar:

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

Atualizar nova solução: verificar índice

 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;

Atualizado com o ES6: o uso list.everyé a maneira mais rápida:

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

versão antiga:

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

Você pode usar isto:

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

A função primeiro verifica se a matriz está vazia. Se for, seus valores são iguais. Caso contrário, ele filtra a matriz e pega todos os elementos diferentes do primeiro. Se não houver tais valores => a matriz contém apenas elementos iguais, caso contrário não.

A _.isEqual(object, other)função de sublinhado parece funcionar bem para matrizes. A ordem dos itens na matriz importa quando verifica a igualdade. Veja 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);
    }));
}

É simples. Crie uma função e passe um parâmetro. Nessa função, copie o primeiro índice para uma nova variável. Em seguida, crie um loop for e faça um loop na matriz. Dentro de um loop, crie um loop while com uma condição que verifique se a nova variável criada é igual a todos os elementos no loop. se seu retorno igual true após o loop for concluído, retorne false dentro do loop while.

function isUniform(arra){
    var k=arra[0];
    for (var i = 0; i < arra.length; i++) {
        while(k!==arra[i]){
            return false;
        }
    }
    return true;
}

A resposta aceita funcionou muito bem, mas eu queria acrescentar um pouquinho. Não funcionou para mim usar ===porque estava comparando matrizes de matrizes de objetos; no entanto, em todo o meu aplicativo, usei o pacote de igualdade profunda rápida que recomendo vivamente. Com isso, meu código fica assim:

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

e meus dados ficam assim:

[  
  [
    {
      "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. Crie uma sequência juntando-se à matriz.
2. Crie string repetindo o primeiro caractere da matriz especificada
3. combinar as duas cordas

	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 você está FEITO!

Agora você pode usar conjuntos para fazer isso 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);

Você pode usar um loop for:

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

Bem, isso realmente não é muito complicado. Eu tenho uma forte suspeita de que você nem tentou. O que você faz é escolher o primeiro valor, salvá-lo na variável e, em um forloop, comparar todos os valores subsequentes com o primeiro.
Eu intencionalmente não compartilhei nenhum código. Descubra como foré usado e como as variáveis ​​são comparadas.

Solução simples de uma linha, basta compará-la com uma matriz preenchida com a primeira entrada.

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

Outra maneira interessante quando você usa a sintaxe da função de seta 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 você não deseja reutilizar a variável para o array (x):

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

O pôster anterior da OMI que usou array.every (...) tem a solução mais limpa.

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

• Para o primeiro loop; sempre que detectar irregular, retorna "false"
• O primeiro loop é executado e, se retornar falso, temos "false"
• Quando não retorna false, significa que haverá true, então fazemos o segundo loop. E é claro que teremos "true" no segundo loop (porque o primeiro loop descobriu que NÃO é falso)

isso pode funcionar, você também pode usar o código de comentário que também funciona bem com o cenário fornecido.

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

Outra maneira com tamanho delimitado e lista organizada:

matriz1 = [1,2,3]; matriz2 = [1,2,3];

function isEqual(){

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

Você pode converter a matriz em um conjunto e verificar seu tamanho

No caso de entradas de matriz primitivo, isto é number, string:

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

No caso de matriz de objetos com algum campo a ser testado para equivalência, diga id:

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

No PHP, existe uma solução muito simples, com um método de linha:

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

Por exemplo :

$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

Isso é tudo.