Dizinin tüm değerlerinin eşit olup olmadığını kontrol edin

Tüm değerlerin eşit olduğu diziler bulmam gerekiyor. Bunu yapmanın en hızlı yolu nedir? Ben döngü ve sadece değerleri karşılaştırmak gerekir?

['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

Veya tek astarlı:

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

Array.prototype.every (MDN'den): every()Yöntem, dizideki tüm öğelerin sağlanan işlev tarafından uygulanan testi geçip geçmediğini test eder.

Düzenleme: Kırmızı ninja olun:

!!array.reduce(function(a, b){ return (a === b) ? a : NaN; });

Sonuçlar:

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" 

Uyarı:

var array = [] => result: TypeError thrown

Bunun nedeni bir başlangıçDeğerini geçmiyoruz . Yani, array.lengthönce kontrol etmek isteyebilirsiniz .

Bu çalışıyor. Prototip kullanarak Dizi üzerinde bir yöntem oluşturursunuz.

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

Buna şu şekilde seslenin:

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

JavaScript 1.6'da şunları kullanabilirsiniz Array.every:

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

Muhtemelen bazı akıl sağlığı kontrollerine ihtiyacınız vardır, örneğin dizinin hiçbir elemanı olmadığında. (Ayrıca, tüm öğeler o NaNzamandan beri işe yaramaz NaN !== NaN, ancak bu bir sorun olmamalı ... değil mi?)

Diziyi bir Kümeye dönüştürebilirsiniz. Kümenin boyutu 1'e eşitse, Dizinin tüm öğeleri eşit olur.

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

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

Performans karşılaştırması için de bir kıyaslama yaptım:

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

Sonuçlar:

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)

Görünüşe göre builtin array.some () kullanmak, örneklenenlerin en hızlı yöntemidir.

Alt çizgi / lodash kullanarak en kısa cevap

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

spec:

elementsEqual(null) // throws error
elementsEqual([]) // true
elementsEqual({}) // true
elementsEqual([1]) // true
elementsEqual([1,2]) // false
elementsEqual(NaN) // true

Düzenle:

Ya da daha kısa, Tom'un cevabından esinlenerek:

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

spec:

elementsEqual2(null) // true (beware, it's different than above)
elementsEqual2([]) // true
elementsEqual2({}) // true
elementsEqual2([1]) // true
elementsEqual2([1,2]) // false
elementsEqual2(NaN) // true

Zaten underscore.js kullanıyorsanız , burada başka bir seçenek daha bulunmaktadır _.uniq:

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

_.uniqdizinin yinelenen bir sürümünü döndürür. Tüm değerler aynı ise, uzunluk 1 olacaktır.

Yorumlarda belirtildiği gibi, boş bir dizinin dönmesini beklediğiniz göz önüne alındığında, truebu durumu da kontrol etmelisiniz:

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

Evet, aşağıdaki filtreyi kullanarak da kontrol edebilirsiniz, çok basit, her değerin birinciyle aynı olduğunu kontrol edin:

//ES6
function sameValues(arr) {
  return arr.filter((v,i,a)=>v===a[0]).length === arr.length;
} 

dizideki her yöntem kullanılarak da yapılabilir:

//ES6
function sameValues(arr) {
  return arr.every((v,i,a)=>v===a[0]);
} 

ve dizilerinizi aşağıdaki gibi kontrol edebilirsiniz:

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

Ya da çok kullanıyorsanız, JavaScript'teki yerel Dizi işlevlerine ekleyebilirsiniz:

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

ve dizilerinizi aşağıdaki gibi kontrol edebilirsiniz:

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

Array.everyDestekleniyorsa kullanabilirsiniz :

var equals = array.every(function(value, index, array){
    return value === array[0];
});

Bir döngünün alternatif yaklaşımı şöyle olabilir: sort

var temp = array.slice(0).sort();
var equals = temp[0] === temp[temp.length - 1];

Veya, öğeler soru gibi ise, kirli bir şey gibi:

var equals = array.join('').split(array[0]).join('').length === 0;

Ayrıca çalışır.

Array.prototype.every , Object.is ve ES6 ok işlevlerini kullanarak bu tek astarı istediğinizi yapabilirsiniz :

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

Bunu yapmak için en basit yolu her değeri sonraki ile karşılaştırmak için bir döngü oluşturmak olduğunu düşünüyorum. "Zincir" de bir kırılma olduğu sürece yanlış dönecektir. Birincisi ikinciye, ikincisi üçüncüye eşitse, dizinin tüm öğelerinin birbirine eşit olduğu sonucuna varabiliriz.

bir dizi verisi [] verildiğinde şunu kullanabilirsiniz:

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

Yeni çözümü güncelle: dizini kontrol et

 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 ile güncellendi: Kullanım list.everyen hızlı yoldur:

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

eski versiyon:

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

Bunu kullanabilirsiniz:

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

İşlev önce dizinin boş olup olmadığını kontrol eder. Değerleri eşitse .. Aksi takdirde diziyi filtreler ve ilkinden farklı olan tüm öğeleri alır. Böyle bir değer yoksa => dizi sadece eşit elemanlar içerir, aksi takdirde dizide yoktur.

Alt çizginin _.isEqual(object, other)işlevi diziler için iyi çalışıyor gibi görünüyor. Eşitliği kontrol ettiğinde dizideki öğelerin sırası önemlidir. Bkz. 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);
    }));
}

Basit. Bir işlev oluşturun ve bir parametre iletin. Bu işlevde ilk dizini yeni bir değişkene kopyalayın. Sonra for for döngüsü oluşturun ve dizi boyunca döngü yapın. Bir döngü içinde, yeni oluşturulan değişkenin döngüdeki tüm öğelere eşit olup olmadığını kontrol eden bir koşula sahip bir while döngüsü oluşturun. for döngüsü tamamlandıktan sonra eşit dönüşü true ise while döngüsü içinde false döndürür.

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

Kabul edilen cevap harika çalıştı ama biraz eklemek istedim. Kullanmak benim için işe yaramadı ===çünkü nesnelerin dizilerini karşılaştırıyordum, ancak uygulamam boyunca şiddetle tavsiye ettiğim hızlı-derin eşit paketi kullanıyordum . Bununla, kodum şöyle görünür:

let areAllEqual = arrs.every((val, i, arr) => equal(val, arr[0]) );

ve verilerim şöyle görünüyor:

[  
  [
    {
      "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. Diziye katılarak bir dize oluşturun.
2. Verilen dizinin ilk karakterini tekrarlayarak dize oluşturma
3. her iki dizeyle eşleş

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

Ve BİTTİ!

Artık bunu kolayca yapmak için setlerden faydalanabilirsiniz.

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 döngüsü kullanabilirsiniz:

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

Bu gerçekten çok karmaşık değil. Denemediğinizden bile şüpheleniyorum. Yaptığınız şey, ilk değeri seçmeniz, değişkene kaydetmeniz ve ardından bir fordöngü içinde sonraki tüm değerleri ilk değerle karşılaştırmanızdır.
Kasıtlı olarak herhangi bir kod paylaşmadım. Nasıl forkullanıldığını ve değişkenlerin nasıl karşılaştırıldığını bulun .

Basit bir satır çözümü, sadece ilk girişle dolu bir dizi ile karşılaştırın.

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

ES6 ok işlevi sözdizimini kullandığınızda başka ilginç bir yol:

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

Ve değişkeni dizi (x) için yeniden kullanmak istemediğinizde:

!['a', 'a', 'a', 'a'].filter((e,i,a)=>e!==a[0])[0]    // true

Array.every (...) kullanan önceki IMO en temiz çözüme sahiptir.

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

• İlk döngü için; düzensiz algıladığında "false" döndürür
• İlk döngü çalışır ve false değerini döndürürse, "false"
• Yanlış döndürülmediği zaman, doğru olacağı anlamına gelir, bu yüzden ikinci döngüyü yaparız. Ve tabii ki ikinci döngüden "true" değerine sahip olacağız (çünkü ilk döngü yanlış DEĞİL buldu)

Bu işe yarayabilir, aynı zamanda verilen senaryo ile de uyanır yorum kodunu kullanabilirsiniz.

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

Sınırlı boyut ve organize listeyle başka bir yol:

dizi1 = [1,2,3]; dizi2 = [1,2,3];

function isEqual(){

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

Diziyi bir Kümeye dönüştürebilir ve boyutunu kontrol edebilirsiniz

İlkel dizi girişleri durumunda, yani number, string:

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

Eşdeğerlik açısından test edilecek bir alana sahip nesnelerin dizisi durumunda, şunları söyleyin id:

const mapper = ({id}) => id
const isArrayWithEqualEntries = array => new Set(array.map(mapper)).size === 1

PHP'de çok basit, tek satırlık bir çözüm var:

(sayı (dizi_sayısı_değerler ($ dizi)) == 1)

Örneğin :

$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

Bu kadar.