Verifique se todos os valores da matriz são iguais

Eu preciso encontrar matrizes onde todos os valores são iguais. Qual é o caminho mais rápido para fazer isso? Devo percorrer 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 one-liner:

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

Array.prototype.every (do MDN): O método every () testa se todos os elementos no array passam no teste implementado pela function 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" 

Atenção:

 var array = [] => result: TypeError thrown 

Isso ocorre porque não passamos um initialValue . Então, você pode querer verificar array.length primeiro.

Isso funciona. Você cria um método no Array usando o protótipo.

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

Chame isso assim:

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

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

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

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

Você pode transformar o array 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 um 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]; }); } 

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, usando matriz builtin.some () é o método mais rápido dos amostrados.

Resposta mais curta usando sublinhado / 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 

editar:

Ou ainda mais curto, inspirado pela resposta 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 

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

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

_.uniq retorna uma versão livre da duplicata da matriz. Se todos os valores forem iguais, o comprimento será 1.

Como mencionado nos comentários, uma vez que você pode esperar que um array vazio retorne true , então você deve também verificar o caso:

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

Sim, você pode verificá-lo também usando o filtro como abaixo, muito simples, verificando todos os valores são os mesmos que o 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 methods da matriz:

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

e você pode verificar seus arrays como abaixo:

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

Ou você pode adicioná-lo às funcionalidades nativas do Array em JavaScript se você reutilizá-lo muito:

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

e você pode verificar seus arrays como abaixo:

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

Você pode usar Array.every se suportado:

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

Alternativas abordagem 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 são como a pergunta, algo sujo como:

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

Também funciona.

Você pode obter este 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)); 

Acho que a maneira mais simples de fazer isso é criar um loop para comparar o valor de cada um com o 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, então podemos concluir que todos os elementos do array são iguais entre si.

dado um array data [], então você pode usar:

 for(x=0;x 
 arr.length && arr.reduce(function(a, b){return (a === b)?a:false;}) === arr[0]; 

Você pode usar isto:

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

A function primeiro verifica se a matriz está vazia. Se for, os valores são iguais. Caso contrário, filtre a matriz e obtenha todos os elementos diferentes da primeira. Se não houver tais valores => o array contém apenas elementos iguais, caso contrário não.

Algo em torno desta abordagem deve funcionar.

 a.join(',').split(a[0]).length === a.length + 1 

Atualize a nova solução: verifique o í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 ES6: Use list.every é o caminho mais rápido:

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

A function _.isEqual(object, other) do sublinhado parece funcionar bem para matrizes. A ordem dos itens no array é importante quando ele verifica a igualdade. Veja http://underscorejs.org/#isEqual .

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

 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 function e passe um parâmetro. Nesta function, copie o primeiro índice para uma nova variável. Em seguida, crie um loop for e faça um loop pela matriz. Dentro de um loop, crie um loop while com uma condição verificando se a nova variável criada é igual a todos os elementos no loop. se seu retorno igual verdadeiro após o loop for concluir, retornará 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; } 

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

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

Outra maneira interessante de usar a syntax da function de seta do 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 quiser reutilizar a variável para array (x):

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

O pôster anterior da IMO que usava 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 detecta irregular, retorna "falso"
  • O primeiro loop é executado e, se retornar false, temos "false"
  • Quando não é return false, significa que haverá true, então fazemos o segundo loop. E, claro, teremos "true" do segundo loop (porque o primeiro loop encontrado não é falso)

Isso pode funcionar, você pode usar o código de comentários, bem como 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:

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

 function isEqual(){ return array1.toString()==array2.toString(); } 

O método every () verifica se todos os elementos em uma matriz passam por um teste (fornecido como uma function).

O método every () executa a function uma vez para cada elemento presente na matriz:

  • Se encontrar um elemento de matriz em que a function retorne um valor falso, every () retornará false (e não verificará os valores restantes)
  • Se não ocorrer falso, every () retorna true

Nota: every () não executa a function para elementos de matriz sem valores.

Nota: every () não altera o array original

 var ages = [32, 33, 16, 40]; function checkAdult(age) { return age == 1; } function myFunction() { alert(ages.every(checkAdult)); } 
 

Click the button to check if every element in the array is equal to one.

No PHP, existe uma solução muito simples, 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.