检查数组的所有值是否相等

这个作品。通过使用prototype在Array上创建一个方法。

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

这样调用它:

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

你可以用这个:

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

函数首先检查数组是否为空。如果是的话，它的值是相等的。 否则，它会过滤数组并获取与第一个不同的所有元素。如果没有这样的值=>，则数组只包含相等的元素，否则不包含

在JavaScript 1.6中，你可以使用Array.every:

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

你可能需要一些完整性检查，例如当数组没有元素时。(此外，当所有元素都是NaN时，这将不起作用，因为NaN !== NaN，但这应该不是一个问题…对吗?)

如果支持，可以使用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;

同样适用。

下划线的_.isEqual(object, other)函数似乎适用于数组。当它检查是否相等时，数组中项目的顺序很重要。看到http://underscorejs.org/#isEqual。

编辑:做一个红色忍者:

!!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。

为了进行性能比较，我还做了一个基准测试:

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()是采样中最快的方法。

我认为最简单的方法是创建一个循环来比较每个值和下一个值。只要“链”中有断点，它就会返回false。如果第一个元素等于第二个元素，第二个元素等于第三个元素，以此类推，那么我们可以得出这样的结论:数组中的所有元素彼此相等。

给定一个数组data[]，那么你可以使用:

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

更新2022版本:使用Set()

     let a = ['a', 'a', 'b', 'a'];
let b = ['a', 'a', 'a', 'a'];
const check = (list) => {
const setItem = new Set(list);
return setItem.size <= 1;
}


const checkShort = (list) => (new Set(list)).size <= 1
     

check(a); // false;
check(b); // true;
checkShort(a); // false
checkShort(b); // true

更新新的解决方案:检查索引

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

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

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

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

使用下划线/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

如果你已经在使用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;
}

你可以使用Array.prototype.every， Object.is和ES6箭头函数让这个一行程序做你想做的事情:

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

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 (from MDN): every()方法测试数组中的所有元素是否都通过了所提供函数实现的测试

在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

这是所有。

简单的一行解决方案，只需将其与充满第一个条目的数组进行比较。

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

是的,你也可以使用过滤器检查它，如下所示，非常简单，检查每个值都与第一个相同:

//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

您可以将Array转换为Set。如果Set的大小等于1，则数组中的所有元素都相等。

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


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

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

当你使用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(…)的海报有最干净的解决方案。

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"
• 第一个循环运行，如果返回false，就有"false"
• 当它不返回false时，它意味着将会有true，所以我们做第二个循环。当然，在第二个循环中我们会得到"true"(因为第一个循环发现它不是假的)

这可能会起作用，你也可以使用注释代码，这也适用于给定的场景。

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

接受的答案工作得很好，但我想添加一点。对于我来说，使用===并没有起作用，因为我正在比较对象数组的数组，然而在整个应用程序中，我一直在使用我强烈推荐的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
}
]
]

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

这样你就完成了!

现在您可以使用集合轻松地做到这一点。

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

您可以将数组转换为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

你可以使用for循环:

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

each()函数检查数组中的所有元素

    const checkArr = a => a.every( val => val === a[0] )
checkArr(['a','a','a'])  // true
     

**// 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
}

你可以计算数组中不同值的数量，如果这个值是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

我喜欢的另一个很酷的解决方案是使用异或运算符:

console.log([5,5,5,5].reduce((a,b)=>a^b) == 0)
>> true
console.log([5,5,5,4].reduce((a,b)=>a^b) == 0)
>> false