我需要找到所有值相等的数组。最快的方法是什么？我应该遍历它并只比较值吗？
['a', 'a', 'a', 'a'] // true
['a', 'a', 'b', 'a'] // false
答案 0 :(得分：159)
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()方法测试数组中的所有元素是否都通过了由提供的函数实现的测试。
答案 1 :(得分：109)
编辑：成为红色忍者：
!!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。
答案 2 :(得分：62)
这很有效。您可以使用原型在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
答案 3 :(得分：30)
在JavaScript 1.6中，您可以使用Array.every：
function AllTheSame(array) {
var first = array[0];
return array.every(function(element) {
return element === first;
});
}
您可能需要进行一些健全性检查，例如：当数组没有元素时。 （此外，自NaN后所有元素都为NaN !== NaN时，这不起作用，但这不应该是一个问题......对吗？）
答案 4 :(得分：22)
您可以将数组转换为Set。如果Set的大小等于1，则Array的所有元素都相等。
function allEqual(arr) {
return new Set(arr).size == 1;
}
allEqual(['a', 'a', 'a', 'a']); // true
allEqual(['a', 'a', 'b', 'a']); // false
答案 5 :(得分：10)
为了进行性能比较，我还做了一个基准测试：
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（）是采样的最快方法。
答案 6 :(得分：8)
使用下划线/ 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's different than above)
elementsEqual2([]) // true
elementsEqual2({}) // true
elementsEqual2([1]) // true
elementsEqual2([1,2]) // false
elementsEqual2(NaN) // true
答案 7 :(得分：6)
如果您已经在使用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;
}
答案 8 :(得分：6)
是的，你也可以使用过滤器检查它，非常简单，检查每个值是否与第一个相同：
//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
或者，如果您重复使用它，可以将其添加到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
答案 9 :(得分：5)
如果支持，您可以使用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;
也有效。
答案 10 :(得分：4)
您可以使用Array.prototype.every，Object.is和ES6箭头功能获得所需的一行：
const all = arr => arr.every(x => Object.is(arr[0], x));
答案 11 :(得分：3)
arr.length && arr.reduce(function(a, b){return (a === b)?a:false;}) === arr[0];
答案 12 :(得分：3)
我认为最简单的方法是创建一个循环来将每个值与下一个值进行比较。只要＆＃34;链条中断，就会出现问题。然后它会返回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 :(得分：2)
更新新解决方案：检查索引
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));
}
答案 14 :(得分：2)
您可以使用：
function same(a) {
if (!a.length) return true;
return !a.filter(function (e) {
return e !== a[0];
}).length;
}
该函数首先检查数组是否为空。如果是它的值是等于.. 否则，它会过滤数组并获取与第一个不同的所有元素。如果没有这样的值=＆gt;数组只包含相等的元素，否则不包含。
答案 15 :(得分：1)
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);
}));
}
答案 16 :(得分：1)
Underscore的_.isEqual(object, other)函数似乎适用于数组。数组中的项的顺序在检查相等性时很重要。请参阅http://underscorejs.org/#isEqual。
答案 17 :(得分：1)
简单。 创建一个函数并传递一个参数。 在该函数中，将第一个索引复制到一个新变量中。 然后创建一个for循环并循环遍历数组。 在循环内部创建一个while循环，其中一个条件检查新创建的变量是否等于循环中的所有元素。 如果在for循环完成后其等于返回true，则在while循环内返回false。
function isUniform(arra){
var k=arra[0];
for (var i = 0; i < arra.length; i++) {
while(k!==arra[i]){
return false;
}
}
return true;
}
答案 18 :(得分：1)
every（）函数检查数组的所有元素
const checkArr = a => a.every( val => val === a[0] )
checkArr(['a','a','a']) // true
答案 19 :(得分：1)
您可以使用for循环：
function isEqual(arr) {
var first = arr[0];
for (let i = 1; i < arr.length; i++) {
if (first !== arr[i]) {
return false;
}
}
return true;
}
答案 20 :(得分：1)
accepted answer很不错，但是我想补充一点。使用===对我来说是行不通的，因为我正在比较对象数组的数组，但是在我的整个应用程序中，我一直在使用强烈推荐的fast-deep-equal软件包。这样，我的代码如下：
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 :(得分：0)
您可以计算数组中不同值的数量，如果此值为 1，则所有条目都相同。
示例：
array = np.array([1, 2, 2, 3, 3])
set(array) # this gives the different values present in the array (1,2,3)
len(set(array)) # this returns 3, 3 different values in the array
答案 22 :(得分：0)
嗯，这真的不是很复杂。我怀疑你甚至没有尝试过。您所做的是选择第一个值，将其保存在变量中，然后在for循环内，将所有后续值与第一个值进行比较。
我故意不共享任何代码。了解如何使用for以及如何比较变量。
答案 23 :(得分：0)
**// Logical Solution:- Declare global array and one variable(To check the condition) whether all element of an array contains same value or not.**
var arr =[];
var isMatching = false;
for(var i=0;i<arr.length;i++){
if(String(arr[i]).toLowerCase()== "Your string to check"){
isMatching=true;
// Array has same value in all index of an array
}
else{
isMatching=false;
// Array Doesn't has same value in all index of an array
break;
}
}
// **Check isMatching variable is true or false**
if(isMatching){ // True
//If Array has same value in all index, then this block will get executed
}
else{ //False
//If Array doesn't has same value in all index, then this block will get executed
}
答案 24 :(得分：0)
您可以将数组转换为Set并检查其大小
如果是原始数组条目，即number，string：
const isArrayWithEqualEntries = array => new Set(array).size === 1
如果对象数组具有要测试其等效性的某个字段，请说id：
const mapper = ({id}) => id
const isArrayWithEqualEntries = array => new Set(array.map(mapper)).size === 1
答案 25 :(得分：0)
现在，您可以利用集合轻松做到这一点。
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);
答案 26 :(得分：0)
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']));
您完成了！
答案 27 :(得分：0)
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>
答案 28 :(得分：0)
另一种具有定界大小和组织列表的方式：
array1 = [1,2,3]; array2 = [1,2,3];
function isEqual(){
return array1.toString()==array2.toString();
}
答案 29 :(得分：0)
这可能会有效，您也可以使用注释代码，这也适用于给定的场景。
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();
答案 30 :(得分：0)
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; }
}
}
答案 31 :(得分：0)
使用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以前使用过array.every（...）的海报有最干净的解决方案。
答案 32 :(得分：0)
简单的一行解决方案，只需将其与填充第一个条目的数组进行比较。
if(arr.join('') === Array(arr.length).fill(arr[0]).join(''))
答案 33 :(得分：-4)
在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
这就是全部。