我需要找到所有值都相等的数组。最快的方法是什么？我应该遍历它并比较值吗？
['a', 'a', 'a', 'a'] // true
['a', 'a', 'b', 'a'] // false
问问题
377168 次
32 回答
453
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()方法测试数组中的所有元素是否通过提供的函数实现的测试。
于 2016-02-23T04:34:07.280 回答
111
编辑：成为红色忍者：
!!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。
于 2014-01-21T18:35:05.257 回答
63
这行得通。您可以使用原型在 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
于 2013-02-12T12:33:00.847 回答
53
您可以将 Array 变成 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
于 2017-08-01T10:31:52.740 回答
32
在 JavaScript 1.6 中，您可以使用Array.every：
function AllTheSame(array) {
var first = array[0];
return array.every(function(element) {
return element === first;
});
}
您可能需要进行一些完整性检查，例如当数组没有元素时。NaN（此外，当所有元素都是since时，这将不起作用NaN !== NaN，但这不应该是一个问题......对吗？）
于 2013-02-12T12:39:49.633 回答
16
为了进行性能比较，我还做了一个基准测试：
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() 是采样中最快的方法。
于 2014-01-21T19:10:33.717 回答
10
使用下划线/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
于 2015-06-22T09:08:23.253 回答
10
如果您已经在使用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;
}
于 2015-07-30T12:00:51.493 回答
7
every() 函数检查数组的所有元素
const checkArr = a => a.every( val => val === a[0] )
checkArr(['a','a','a']) // true
于 2020-09-08T06:05:44.453 回答
6
更新新解决方案：检查索引
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;
用 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));
}
于 2014-09-29T08:52:03.817 回答
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 中的原生 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
于 2017-05-13T02:59:59.113 回答
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;
也有效。
于 2013-02-12T13:04:11.487 回答
5
你可以使用Array.prototype.every、Object.is和 ES6 箭头函数让这个单线器做你想做的事情：
const all = arr => arr.every(x => Object.is(arr[0], x));
于 2015-12-29T10:07:43.780 回答
4
我认为最简单的方法是创建一个循环来将每个值与下一个值进行比较。只要“链”中有中断，它就会返回假。如果第一个等于第二个，第二个等于第三个，以此类推，那么我们可以得出结论，数组的所有元素彼此相等。
给定一个数组 data[]，那么你可以使用：
for(x=0;x<data.length - 1;x++){
if (data[x] != data[x+1]){
isEqual = false;
}
}
alert("All elements are equal is " + isEqual);
于 2014-09-29T07:13:56.010 回答
4
现在您可以使用集合轻松地做到这一点。
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);于 2019-10-22T14:35:17.060 回答
3
arr.length && arr.reduce(function(a, b){return (a === b)?a:false;}) === arr[0];
于 2015-02-09T23:27:24.617 回答
2
你可以使用这个：
function same(a) {
if (!a.length) return true;
return !a.filter(function (e) {
return e !== a[0];
}).length;
}
该函数首先检查数组是否为空。如果是，它的值是相等的。否则它过滤数组并获取与第一个不同的所有元素。如果没有这样的值 => 数组只包含相等的元素，否则它不包含。
于 2013-02-12T12:35:14.580 回答
2
这很简单。创建一个函数并传递一个参数。在该函数中，将第一个索引复制到一个新变量中。然后创建一个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;
}
于 2017-09-05T05:14:17.987 回答
2
接受的答案效果很好，但我想补充一点。它对我来说不起作用，===因为我正在比较对象数组的数组，但是在我的应用程序中，我一直在使用我强烈推荐的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
}
]
]
于 2019-05-16T18:30:25.873 回答
2
您可以将数组转换为 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
于 2020-03-21T00:13:22.670 回答
2
您可以使用 for 循环：
function isEqual(arr) {
var first = arr[0];
for (let i = 1; i < arr.length; i++) {
if (first !== arr[i]) {
return false;
}
}
return true;
}
于 2020-06-06T14:45:33.247 回答
1
Underscore 的_.isEqual(object, other)功能似乎适用于数组。在检查是否相等时，数组中项目的顺序很重要。请参阅http://underscorejs.org/#isEqual。
于 2013-07-10T22:42:33.890 回答
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);
}));
}
于 2015-05-04T10:38:27.430 回答
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; }
}
}
- 对于第一个循环；每当它检测到不均匀时，返回“false”
- 第一个循环运行，如果它返回假，我们有“假”
- 当它不返回 false 时，意味着会有 true，所以我们进行第二个循环。当然，我们将从第二个循环中获得“真”（因为第一个循环发现它不是假的）
于 2018-04-04T12:04:38.117 回答
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(...) 的海报有最干净的解决方案。
于 2018-04-03T15:04:58.433 回答
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();于 2018-04-13T12:02:29.717 回答
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']));你完成了！
于 2019-05-16T18:58:54.267 回答
0
我喜欢的另一个很酷的解决方案是使用 XOR 运算符：
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
于 2022-02-15T09:43:17.643 回答
-1
简单的单行解决方案，只需将其与填充第一个条目的数组进行比较。
if(arr.join('') === Array(arr.length).fill(arr[0]).join(''))
于 2016-07-29T13:27:32.430 回答
-1
**// 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
}
于 2021-04-11T06:29:24.343 回答
-1
您可以计算数组中不同值的数量，如果该值为 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
于 2021-04-25T13:31:47.573 回答
-5
在 PHP 中，有一个非常简单的解决方案，一行方法：
(计数(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
就这样。
于 2016-07-24T12:33:44.453 回答