我需要找到所有值都相等的数组。最快的方法是什么?我应该循环遍历它，然后比较值吗?
['a', 'a', 'a', 'a'] // true
['a', 'a', 'b', 'a'] // false
这个作品。通过使用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，但这应该不是问题……对吗?)
你可以使用数组。每个if支持:
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。所以，你可能希望检查数组。第一个长度。
为了进行性能比较，我还做了一个基准测试:
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;
在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));
}
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让这一行代码做你想做的事情。每一个对象。和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
它的简单。 创建一个函数并传递一个参数。 在该函数中，将第一个索引复制到一个新变量中。 然后创建一个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;
}
当你使用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"(因为第一个循环发现它不是假的)
这可能会起作用，你也可以使用注释代码，这也适用于给定的场景。
函数isUniform () { var arrayToMatch = [1,1,1,1,1]; var temp = arrayToMatch[0]; console.log(临时); /*返回arrayToMatch.every(函数(检查){ 返回检查== temp; }); * / var bool; arrayToMatch.forEach(函数(检查){ 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
}
]
]
通过加入数组创建一个字符串。 通过重复给定数组的第一个字符创建字符串 匹配两个字符串
函数checkArray(数组){ 返回array.join("") == array[0].repeat(array.length); ｝ console.log('数组:(,,,):”+ checkArray ([' a ', ' ', ' ', ' '))); console.log('数组:[a, a, b, a]: ' + checkArray ([' a ', ' ', ' b ', ' ')));
这样你就完成了!
现在您可以使用集合轻松地做到这一点。
Let a= ['a'， 'a'， 'a'， 'a'];/ /正确的 Let b =['a'， 'a'， 'b'， 'a'] console.log(新组(a)。Size === 1); console.log(新组(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
