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

2020/10/16 20:41 · javascript ·  · 0评论

我需要找到所有值都相等的数组。最快的方法是什么?我应该遍历它而只是比较值吗?

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

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

编辑:是红色忍者:

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

这可行。您通过使用原型在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

您可以将数组变成集合。如果Set的大小等于1,则Array的所有元素均相等。

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

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

在JavaScript 1.6中,您可以使用Array.every

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

您可能需要进行完整性检查,例如,当数组中没有元素时。(另外,这是不行的,当所有的元素都是NaN因为NaN !== NaN,但这不应该是一个问题,对吧?)

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

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

使用下划线/破折号的最短答案

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

是的,您还可以使用以下过滤器对其进行检查,非常简单,检查每个值是否与第一个相同:

//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中的本机Array功能中:

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

也可以。

您可以使用Array.prototype.everyObject.is和ES6箭头函数来获得以下内容:

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

我认为最简单的方法是创建一个循环,将每个值与下一个值进行比较。只要“链”中存在中断,它就会返回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);
arr.length && arr.reduce(function(a, b){return (a === b)?a:false;}) === arr[0];

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

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

您可以使用此:

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

该函数首先检查数组是否为空。如果是,则它们的值是相等的。否则,它将对数组进行过滤,并接受与第一个元素不同的所有元素。如果没有这样的值=>数组仅包含相等的元素,否则不包含。

接受的答案真是棒极了,但我想补充一点点。它对我来说并不起作用,===因为我正在比较对象数组的数组,但是在我的整个应用程序中,我一直在使用我强烈推荐快速深相等包。这样,我的代码如下所示:

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

Underscore的_.isEqual(object, other)功能似乎适用于数组。数组中项目的顺序在检查是否相等时很重要。请参阅http://underscorejs.org/#isEqual

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

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

您可以使用for循环:

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

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

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

好吧,这确实不是很复杂。我非常怀疑您没有尝试。您要做的是选择第一个值,将其保存在变量中,然后在for循环内,将所有后续值与第一个值进行比较。
我故意不共享任何代码。查找如何for使用以及如何比较变量。

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

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

使用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”(因为第一个循环发现它不是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();

分隔大小和组织列表的另一种方法:

array1 = [1,2,3]; array2 = [1,2,3];

function isEqual(){

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

您可以将数组转换为Set并检查其大小

在原始阵列条目的情况下,即numberstring

const isArrayWithEqualEntries = array => new Set(array).size === 1

对于具有某个要进行等效性测试的对象的数组,请说id

const mapper = ({id}) => id
const isArrayWithEqualEntries = array => new Set(array.map(mapper)).size === 1
本文地址:http://javascript.askforanswer.com/jianchashuzudesuoyouzhishifouxiangdeng.html
文章标签: ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!