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

我需要找到所有值都相等的数组。最快的方法是什么？我是否应该循环使用它并只比较值

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

---

这很有效。您可以使用prototype在数组上创建一个方法

if（Array.prototype.allValuesSame==未定义）{
Array.prototype.AllValuesName=函数（）{
for（设i=1；i

请这样称呼：

设a=['a'，'a'，'a']；
设b=a.allvaluesName（）；//真的
a=['a'，'b'，'a']；
b=a.所有值名称（）；//假的

您可以使用以下功能：

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

函数首先检查数组是否为空。如果是，则其值相等。。

---

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

在JavaScript 1.6中，您可以使用：

---

您可能需要一些健全性检查，例如，当数组没有元素时。（另外，当所有元素都是

NaN

时，这将不起作用，因为

NaN！==NaN

，但这不应该是一个问题……对吗？

您可以使用

数组。如果支持，每个
：

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（对象，其他）
函数似乎对数组很有效。当数组检查是否相等时，数组中项的顺序很重要。请参阅。
编辑：成为一名红色忍者：

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

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)


警告:

var array = [] => result: TypeError thrown

这是因为我们不传递初始值。因此，您可能希望首先检查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];
    });
}

结果:

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" 

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（）是采样中最快的方法
 我认为最简单的方法是创建一个循环，将每个值与下一个值进行比较。只要“链”中有一个中断，它就会返回false。如果第一个等于第二个，第二个等于第三个，依此类推，那么我们可以得出结论，数组的所有元素都是相等的

给定数组数据[]，则可以使用：

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

for（x=0；x更新新解决方案：检查索引

 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更新：
使用
列表。每个
都是最快的方法：

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

使用下划线/lodash的最短答案

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

规格：

编辑：

甚至更短，受汤姆回答的启发：

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

如果您已经在使用，那么这里有另一个使用
\uq.uniq
的选项：

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

\uuq.uniq
返回数组的无重复版本。如果所有值都相同，则长度将为1

如注释中所述，鉴于您可能期望空数组返回
true
，那么您还应该检查这种情况：

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

您可以使用ES6 arrow函数使这一行程序执行您想要的操作：

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

或一个班轮：

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

（来自MDN）：
every（）
方法测试数组中的所有元素是否通过了所提供函数实现的测试。
简单的单行解决方案，只需将其与填充了第一个条目的数组进行比较即可

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

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

或者，如果大量重用，可以将其添加到JavaScript中的本机数组功能中：

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

您可以按如下方式检查阵列：

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

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

可以将数组转换为一个集合。如果集合的大小等于1，则数组的所有元素都相等

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

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

很简单。
创建一个函数并传递一个参数。
在该函数中，将第一个索引复制到一个新变量中。
然后创建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;
}

函数是统一的（arra）{
var k=arra[0]；
对于（变量i=0；i
使用ES6 arrow函数语法时的另一种有趣方式：

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）的变量时：

在我之前的海报中，谁使用了数组。每个（…）都有最干净的解决方案。
函数是统一的（数组）{
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; }
  }
}

对于（变量i=1；i


对于第一个循环；每当检测到不均匀时，返回“false”
第一个循环运行，如果返回false，则为“false”
当它不返回false时，这意味着将有true，所以我们进行第二个循环。当然，我们将从第二个循环得到“true”（因为第一个循环发现它不是false）
这可能会起作用，您也可以使用注释输出代码，该代码也适用于给定场景


函数是统一的（）{
var arrayToMatch=[1,1,1,1,1]；
变量温度=阵列匹配[0]；
控制台日志（temp）；
/*返回arrayToMatch.every（函数）（检查）{
返回检查==温度；
});*/
瓦尔布尔；
arrayToMatch.forEach（函数（检查）{
布尔=（检查==温度）；
})
控制台日志（bool）；
}
isUniform（）；
工作得很好，但我想添加一点。使用
==
对我来说不起作用，因为我在比较对象数组，但是在整个应用程序中，我一直在使用我极力推荐的包。因此，我的代码如下所示：

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

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

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

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

    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
        }

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