Если вы возвращаете только фиксированные значения, лучше всего подходит словарь.
Изменить: быть красным ниндзя:
!!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
.
Простой. Создайте функцию и передайте параметр. В этой функции скопируйте первый индекс в новую переменную. Затем создайте цикл 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;
}
Да, вы можете проверить это также с помощью фильтра, как показано ниже, очень просто, проверяя, что все значения совпадают с первым:
//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
это может сработать, вы также можете использовать код комментария, который также хорошо справляется с данным scenerio.
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();
Ну, это действительно не очень сложно. У меня есть сильное подозрение, что вы даже не пытались. Что вы делаете, так это то, что вы выбираете первое значение, сохраняете его в переменной, а затем в цикле for
сравниваете все последующие значения с первым. Я намеренно не разделял никакого кода. Найдите, как for
используется и как сопоставляются переменные.
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);
}));
}
Простое однострочное решение, просто сравните его с массивом, заполненным первой записью.
if(arr.join('') === Array(arr.length).fill(arr[0]).join(''))
Другой способ с ограниченным размером и организованным списком:
array1 = [1,2,3]; array2 = [1,2,3];
function isEqual(){
return array1.toString()==array2.toString();
}
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 () проверяет, все ли элементы в массиве пройти тест, реализованный предоставленной функцией.
const everythings_equal = array => array.every(thing => thing === array[0]);
– K._
25 January 2018 в 12:24
Вы можете превратить массив в набор. Если размер Set равен 1, то все элементы массива равны.
function allEqual(arr) {
return new Set(arr).size == 1;
}
allEqual(['a', 'a', 'a', 'a']); // true
allEqual(['a', 'a', 'b', 'a']); // false
allEqual([NaN, NaN])
дает true
в этом случае.
– K._
25 January 2018 в 12:26
Что-то вокруг этого подхода должно работать.
a.join(',').split(a[0]).length === a.length + 1
В 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
Вот и все.
arr.length && arr.reduce(function(a, b){return (a === b)?a:false;}) === arr[0];
Функция _.isEqual(object, other)
подчеркивания отлично работает для массивов. Порядок элементов в массиве имеет значение, когда он проверяет равенство. См. http://underscorejs.org/#isEqual .
Обновить новое решение: проверить индекс
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));
}
Самый короткий ответ с использованием 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
изменить:
Или даже короче , вдохновленный ответом Тома:
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
И для сравнения производительности я также сделал бенчмарк:
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)
Так что, по-видимому, используя встроенный массив. some () - самый быстрый способ отобранных.
Array#some
будет иногда превосходить, заключается в том, что, как только функция обратного вызова вернет true, она прекратит итерацию. Итак, если все элементы фактически равны, производительность должна быть идентичной Array#every
. И относительная производительность, когда все элементы не равны, будет зависеть от индекса первого несогласованного элемента.
– danmactough
6 January 2015 в 13:09
В JavaScript 1.6 вы можете использовать Array.every
:
function AllTheSame(array) {
var first = array[0];
return array.every(function(element) {
return element === first;
});
}
Возможно, вам потребуются некоторые проверки на здравомыслие, например. когда массив не имеет элементов. (Кроме того, это не будет работать, если все элементы NaN
с NaN !== NaN
, но это не должно быть проблемой ... правильно?)
Вы можете использовать это:
function same(a) {
if (!a.length) return true;
return !a.filter(function (e) {
return e !== a[0];
}).length;
}
Функция сначала проверяет, пуст ли массив. Если это его значения равны. В противном случае он фильтрует массив и принимает все элементы, которые отличаются от первого. Если нет таких значений =>, массив содержит только равные элементы, иначе это не так.
Я думаю, что самый простой способ сделать это - создать цикл для сравнения каждого значения с другим. Пока есть разрыв в «цепочке», тогда он вернет false. Если первое равно второму, второе равно третьему и так далее, то мы можем заключить, что все элементы массива равны друг другу.
заданы данные массива [], затем вы можете использовать:
for(x=0;x<data.length - 1;x++){
if (data[x] != data[x+1]){
isEqual = false;
}
}
alert("All elements are equal is " + isEqual);
Вы можете получить этот однострочный лайнер, чтобы делать то, что хотите, используя функции Array.prototype.every , Object.is и ES6:
const all = arr => arr.every(x => Object.is(arr[0], x));
Это работает. Вы создаете метод в Array с помощью прототипа.
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
else
, потому что if
вернет значение из функции, прежде чем код ниже имеет шанс выполнить, если условие в if
равно true
, Если это false
, else
должен быть выполнен любым способом, нет необходимости обертывать его в дополнительные {}
– Cerbrus
12 February 2013 в 14:43
Array.prototype
только штрафа (даже IE6). Это только прототипы элементов DOM, которые некоторые более старые версии IE не поддерживают увеличение.
– T.J. Crowder
12 February 2013 в 15:00
allValuesSame
в цикле
– Olivier Pons
23 April 2016 в 09:14
Если вы уже используете 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;
}
false
. Хотя я думаю, что это должно быть true
. Однако переход на .length <= 1
будет достаточным.
– Kasztan
22 March 2017 в 12:43
Еще один интересный способ использования синтаксиса функции 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
И если вы не хотите повторно использовать переменную для массива (x):
!['a', 'a', 'a', 'a'].filter((e,i,a)=>e!==a[0])[0] // true
Предыдущий плакат IMO, который использовал массив. Каждый (...) имеет самое чистое решение.
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; }
}
}
Метод every () проверяет, проходят ли все элементы массива в тесте (предоставляемые как функция).
Метод every () выполняет функцию один раз для каждого элемента, присутствующего в массиве:
Примечание: 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>
Вы можете использовать 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;
Также работает.
equals = !array.some( (v,i,a) => v!==a[0] )
. В противном случае вы просто проверяете, что любое значение равно первому, что, конечно, всегда будет истинным :)
– Mark Kahn
30 July 2015 в 04:53
some
вместо every
, как я упомянул в первом абзаце. :) Спасибо за улов!
– ZER0
2 August 2015 в 15:39
false
s! например try [false, false, false] .reduce (function (a, b) {return (a === b)? a: false;}); – George Flourentzos 27 November 2014 в 20:21["false", ""]
возвращаетtrue
: / – dalgard 15 October 2015 в 16:55NaN
. Поскольку обаNaN === NaN
иNaN !== NaN
являются ложными, это гарантирует, что после того, какprev
будет установлен на NaN, тогда никакое значение не сможет его вынуть. Кроме того, добавление двойного отрицания преобразует результаты вtrue
иfalse
, так какNaN
является ложным. Финальная форма:!!array.reduce(function(a, b){ return (a === b) ? a : NaN; });
– Filipe Silva 19 January 2016 в 18:53