Проверьте, равны ли все значения массива

Мне нужно найти массивы, где все значения равны. Какой самый быстрый способ сделать это? Должен ли я проходить через него и просто сравнивать значения?

['a', 'a', 'a', 'a'] // true
['a', 'a', 'b', 'a'] // false

ОТВЕТЫ

Ответ 1

const allEqual = arr => arr.every( v => v === arr[0] )
allEqual( [1,1,1,1] )  // true

Или однострочник:

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

Array.prototype.every (из MDN): метод every() проверяет, все ли элементы массива проходят тест, реализованный предоставленной функцией.

Ответ 2

Изменить: быть красным ниндзя:

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

Результаты:

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"

Внимание:

var array = [] => result: TypeError thrown

Это потому, что мы не передаем initialValue. Таким образом, вы можете сначала проверить array.length.

Ответ 3

Это работает. Вы создаете метод в массиве с использованием прототипа.

Array.prototype.allValuesSame = function() {

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

    return true;
}

Вызвать это следующим образом:

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

Ответ 4

В JavaScript 1.6 вы можете использовать Array.every:

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

Вам, вероятно, нужны некоторые проверки на здравомыслие, например. когда массив не имеет элементов. (Кроме того, это не будет работать, когда все элементы NaN с NaN !== NaN, но это не должно быть проблемой... правильно?)

Ответ 5

Вы можете превратить массив в набор. Если размер Set равен 1, то все элементы массива равны.

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

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

Ответ 6

И для сравнения производительности я также сделал тест:

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

Результаты:

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)

Таким образом, по-видимому, с помощью встроенного массива array.some() является самым быстрым методом выборки.

Ответ 7

Самый короткий ответ с использованием подчеркивания /lodash 

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

Спецификация:

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

изменить:

Или даже короче, вдохновленный Томом:

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

Спецификация:

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

Ответ 8

Если вы уже используете underscore.js, то здесь еще один вариант с использованием _.uniq:

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

_.uniq возвращает дублируемую версию массива. Если все значения совпадают, длина будет равна 1.

Как упоминалось в комментариях, учитывая, что вы можете ожидать, что пустой массив вернет true, вы также должны проверить этот случай:

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

Ответ 9

Да, вы можете проверить это также с помощью фильтра, как показано ниже, очень просто, проверяя, что все значения совпадают с первым:

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

также может быть сделано с использованием каждого метода в массиве:

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

и вы можете проверить свои массивы, как показано ниже:

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

Или вы можете добавить его к собственным функциям Array в JavaScript, если вы многократно его используете:

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

и вы можете проверить свои массивы, как показано ниже:

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

Ответ 10

Вы можете использовать Array.every, если поддерживается:

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

Альтернативный подход цикла может быть чем-то вроде sort

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

Или, если элементы похожи на вопрос, что-то грязное вроде:

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

Также работает.

Ответ 11

Вы можете получить этот однострочный файл, чтобы сделать то, что вы хотите, используя Array.prototype.every, Object.is и функции ES6 arrow:

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

Ответ 12

Я думаю, что самый простой способ сделать это - создать цикл для сравнения каждого значения с другим. Пока есть разрыв в "цепочке", тогда он вернет false. Если первое равно второму, второе равно третьему и так далее, то мы можем заключить, что все элементы массива равны друг другу.

с данными массива [], вы можете использовать:

for(x=0;x<data.length - 1;x++){
    if (data[x] != data[x+1]){
        isEqual = false;            
    }
}
alert("All elements are equal is " + isEqual);

Ответ 13

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

Ответ 14

Вы можете использовать это:

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

Функция сначала проверяет, пуст ли массив. Если это, то значения равны. В противном случае он фильтрует массив и принимает все элементы, которые отличаются от первого. Если таких значений нет, то массив содержит только равные элементы, иначе это не так.

Ответ 15

Что-то вокруг этого подхода должно работать.

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

Ответ 16

Обновить новое решение: проверить индекс

 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;

Обновлено с ES6: Использовать list.every является самым быстрым способом:

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

старая версия:

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

Ответ 17

Функция подчеркивания _.isEqual(object, other), похоже, хорошо работает для массивов. Порядок элементов в массиве имеет значение, когда он проверяет равенство. См. http://underscorejs.org/#isEqual.

Ответ 18

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

Ответ 19

Простой. Создайте функцию и передайте параметр. В этой функции скопируйте первый индекс в новую переменную. Затем создайте цикл for и цикл через массив. Внутри цикла создайте цикл while с условием, проверяющим, равна ли новая созданная переменная всем элементам цикла. если его равное значение true после завершения цикла for else возвращает false внутри цикла while.

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

Ответ 20

Принятый ответ работал отлично, но я хотел бы добавить немного. Мне не === использовать === потому что я сравнивал массивы массивов объектов, однако в моем приложении я использовал пакет fast-deep-равенства, который я настоятельно рекомендую. С этим мой код выглядит так:

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

и мои данные выглядят так:

[  
  [
    {
      "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
    }
  ]
]

Ответ 21

Ну, это действительно не очень сложно. У меня есть сильное подозрение, что вы даже не пытались. Что вы делаете, так это то, что вы выбираете первое значение, сохраняете его в переменной, а затем в цикле for сравниваете все последующие значения с первым.
Я не намерен делиться никаким кодом. Найти, как for используется и как сопоставляются переменные.

Ответ 22

Простое однострочное решение, просто сравните его с массивом, заполненным первой записью.

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

Ответ 23

Еще один интересный способ, когда вы используете синтаксис функции стрелки 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

И когда вы не хотите повторно использовать переменную для array (x):

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

Предыдущий постер ИМО, который использовал array.every(...), имеет самое чистое решение.

Ответ 24

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; }
  }
}
  • Для первого цикла; всякий раз, когда он обнаруживает неровности, возвращает "ложь"
  • Первый цикл запускается, и если он возвращает ложь, мы имеем "ложь"
  • Когда он не возвращает false, это означает, что будет true, поэтому мы делаем второй цикл. И, конечно, у нас будет "true" из второго цикла (потому что первый цикл нашел его НЕ ложным)

Ответ 25

это может сработать, вы также можете использовать код комментария, который также хорошо работает с заданным сценарием.

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

Ответ 26

Другой способ с ограниченным размером и упорядоченным списком:

массив1 = [1,2,3]; массив2 = [1,2,3];

function isEqual(){

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

Ответ 27

Метод every() проверяет, все ли элементы массива проходят тест (предоставляется как функция).

Метод every() выполняет функцию один раз для каждого элемента в массиве:

  • Если он находит элемент массива, в котором функция возвращает ложное значение, every() возвращает ложное значение (и не проверяет оставшиеся значения)
  • Если ложь не возникает, each() возвращает true

Примечание: every() не выполняет функцию для элементов массива без значений.

Примечание: every() не меняет исходный массив

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>

Ответ 28

  1. Создайте строку, присоединившись к массиву.
  2. Создать строку путем повторения первого символа данного массива
  3. сопоставить обе строки

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

Ответ 29

В PHP есть решение очень простое, однострочное:

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

Например:

$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

Что все.