Bu iki diziye sahibim: biri ajax isteğinden gelen bilgilerle dolu, diğeri kullanıcının tıkladığı düğmeleri saklıyor. Bu kodu kullanıyorum (örnek numaralarla doldurdum):

var array1 = [2, 4];
var array2 = [4, 2]; //It cames from the user button clicks, so it might be disordered.
array1.sort(); //Sorts both Ajax and user info.
array2.sort();
if (array1==array2) {
    doSomething();
}else{
    doAnotherThing();
}

Ancak false, iki dizi aynı olsa da, ancak farklı bir adla her zaman verir . (Bunu Chrome'un JS Konsolunda kontrol ettim). Öyleyse, bu iki dizinin aynı olup olmadığını bilmemin bir yolu var mı? Neden veriyor false? İlk dizideki hangi değerlerin ikinci dizide olmadığını nasıl bilebilirim?

function arraysEqual(_arr1, _arr2) {

    if (!Array.isArray(_arr1) || ! Array.isArray(_arr2) || _arr1.length !== _arr2.length)
      return false;

    var arr1 = _arr1.concat().sort();
    var arr2 = _arr2.concat().sort();

    for (var i = 0; i < arr1.length; i++) {

        if (arr1[i] !== arr2[i])
            return false;

    }

    return true;

}

Bunun, önceki yanıtın aksine orijinal dizileri değiştirmediğini unutmayın.

Dizi öğeleriniz nesne değilse - örneğin sayılar veya dizeler ise, herhangi bir sırayla aynı üyelere sahip olup olmadıklarını görmek için birleştirilmiş dizelerini karşılaştırabilirsiniz.

var array1= [10, 6, 19, 16, 14, 15, 2, 9, 5, 3, 4, 13, 8, 7, 1, 12, 18, 11, 20, 17];
var array2= [12, 18, 20, 11, 19, 14, 6, 7, 8, 16, 9, 3, 1, 13, 5, 4, 15, 10, 2, 17];

if(array1.sort().join(',')=== array2.sort().join(',')){
    alert('same members');
}
else alert('not a match');

Yalnızca iki dizinin aynı değerlere sahip olup olmadığını kontrol etmek istiyorsanız (her bir değerin oluşum sayısına ve sırasına bakılmaksızın), lodash kullanarak bunu yapabilirsiniz :

_.isEmpty(_.xor(array1, array2))

Kısa, basit ve güzel!

Array.prototype.compare = function(testArr) {
    if (this.length != testArr.length) return false;
    for (var i = 0; i < testArr.length; i++) {
        if (this[i].compare) { //To test values in nested arrays
            if (!this[i].compare(testArr[i])) return false;
        }
        else if (this[i] !== testArr[i]) return false;
    }
    return true;
}

var array1 = [2, 4];
var array2 = [4, 2];
if(array1.sort().compare(array2.sort())) {
    doSomething();
} else {
    doAnotherThing();
}

Olabilir?

Kodunuz neden çalışmadı

JavaScript, ilkel veri türlerine ve ilkel olmayan veri türlerine sahiptir.

İlkel veri tipleri için, ==ve ===kontrol çubukları her iki tarafta şeyler aynı değere sahip olup. Bu yüzden 1 === 1doğrudur.

Diziler gibi ilkel olmayan veri türleri için ==ve ===referans eşitliğini kontrol edin. Yani olup olmadığını kontrol olduğunu arr1ve arr2aynı nesne bulunmaktadır. Örneğinizde, iki dizi aynı sırayla aynı nesnelere sahiptir, ancak eşdeğer değildir.

Çözümler

İki diziler, arr1ve arr2aynı üyelerini ancak ve ancak vardır:

• İçindeki her şey arr2içindearr1

VE

• İçindeki her şey arr1içindearr2

Yani bu hile yapacak (ES2016):

const containsAll = (arr1, arr2) => 
                arr2.every(arr2Item => arr1.includes(arr2Item))

const sameMembers = (arr1, arr2) => 
                        containsAll(arr1, arr2) && containsAll(arr2, arr1);

sameMembers(arr1, arr2); // `true`

Alt Çizgi kullanan bu ikinci çözüm , yapmaya çalıştığınız şeye daha yakın:

arr1.sort();
arr2.sort();

_.isEqual(arr1, arr2); // `true`

İşe yarıyor çünkü isEqual"derin eşitliği" kontrol ediyor, yani sadece referans eşitlikten daha fazlasına bakıyor ve değerleri karşılaştırıyor.

Üçüncü sorunuza bir çözüm

Ayrıca hangi şeylerin içinde arr1olmadığını nasıl bulacağınızı sordunuz arr2.

Bunu yapacak (ES2015):

const arr1 = [1, 2, 3, 4];
const arr2 = [3, 2, 1];

arr1.filter(arr1Item => !arr2.includes(arr1Item)); // `[4]`

Ayrıca Alt Çizgi'nin difference: yöntemini de kullanabilirsiniz :

_.difference(arr1, arr2); // `[4]`

GÜNCELLEME

@ Redu'nun yorumuna bakın — benim çözümüm bunun içindir sameMembers, ancak aklınızdaki şeyler sameMembersInOrderde bilinir deepEquals.

GÜNCELLEME 2

Dizilerin üyelerinin sırasını önemsemiyorsanız, ES2015 + 'lardan Setdaha iyi bir veri yapısı olabilir Array. Tehlikeli maymun yamasının nasıl uygulanacağı isSupersetvedifference kullanılacağına ilişkin MDN notlarına bakın .

Nesne eşitliği kontrolü:JSON.stringify(array1.sort()) === JSON.stringify(array2.sort())

Yukarıdaki test aynı zamanda nesne dizileriyle de çalışır, bu durumda http://www.w3schools.com/jsref/jsref_sort.asp adresinde belgelendiği gibi bir sıralama işlevi kullanılır.

Düz JSON şemalarına sahip küçük diziler için yeterli olabilir.

Amacımız temelde 2 dizinin eşit küme olup olmadığını kontrol etmektir. küme , matematiksel olarak tanımlanmış kümedir . En hızlı sıralama asimptotik olarak O (nlog (n)) süresi alır. Yani bir diziyi sıralarsanız, en az O (nlog (n)) süre alacaktır . Ancak bu görevi daha hızlı yapabilirsiniz; bu , bir sözlük veri yapısıyla asimptotik olarak O (n) zaman alır (ortalama durum en kötü durum değil). JS'de sözlük, anahtarları ve değerleri olan bir nesnedir.

/** assumes array elements are primitive types
* check whether 2 arrays are equal sets.
* @param  {} a1 is an array
* @param  {} a2 is an array
*/
function areArraysEqualSets(a1, a2) {
  const superSet = {};
  for (const i of a1) {
    const e = i + typeof i;
    superSet[e] = 1;
  }

  for (const i of a2) {
    const e = i + typeof i;
    if (!superSet[e]) {
      return false;
    }
    superSet[e] = 2;
  }

  for (let e in superSet) {
    if (superSet[e] === 1) {
      return false;
    }
  }

  return true;
}

Bu fonksiyon ilkel türleri dizileri ile çalışır ve varsayar a1ve a2dizilerdir.

Peki buna ne dersin? ES 2017 sanırım:

const array1 = [1, 3, 5];
const array2 = [1, 5, 3];

const isEqual = (array1.length === array2.length) && (array1.every(val => array2.includes(val)));
console.log(isEqual);

1. koşul, her iki dizinin de aynı uzunluğa sahip olup olmadığını kontrol eder ve 2. koşul, 1. dizinin 2. dizinin bir alt kümesi olup olmadığını kontrol eder. Bu 2 koşulun birleştirilmesi, öğelerin sırasına bakılmaksızın 2 dizinin tüm öğelerinin karşılaştırılmasıyla sonuçlanmalıdır.

Yukarıdaki kod yalnızca her iki dizide de yinelenmeyen öğeler varsa çalışır.

Bu iki diziyi karşılaştırdığınızda, içerikleri değil dizileri temsil eden nesneleri karşılaştırırsınız.

İkisini karşılaştırmak için bir işlev kullanmanız gerekecek. Uzunlukların aynı olup olmadığını kontrol ettikten sonra, sadece bir döngü halinde olan ve onu diğeriyle karşılaştıran kendi yazınızı yazabilirsiniz.

ES6 kullanarak sığ eşitlik için basit çözüm:

const arr1test = arr1.slice().sort()
const arr2test = arr2.slice().sort()
const equal = !arr1test.some((val, idx) => val !== arr2test[idx])

Her dizinin sığ kopyalarını oluşturur ve sıralar. Daha sonra değerler some()arasında döngü yapmak için kullanır ve arr1testher bir değeri arr2testaynı indekse sahip değerle karşılaştırır . Tüm değerler eşitse, some()döner falseve sırayla olarak equaldeğerlendirilir true.

Ayrıca kullanılabilir every(), ancak bir truesonucu tatmin etmek için dizideki her öğe arasında geçiş yapmak zorunda kalacak , oysa some()eşit olmayan bir değer bulduğu anda kurtulacaktır:

const equal = arr1test.every((val, idx) => val === arr2test[idx])

Bir Oyun projesinde basit tamsayı değerlerim
vardı Her dizide daha az sayıda değere sahiptim, ayrıca orijinal diziye dokunulmadan ihtiyaç
duydum Yani, aşağıdakileri yaptım, iyi çalıştı. (Buraya yapıştırmak için kod düzenlendi)

var sourceArray = [1, 2, 3];
var targetArray = [3, 2, 1];

if (sourceArray.length !== targetArray.length) {
    // not equal
    // did something
    return false;
}

var newSortedSourceArray = sourceArray.slice().sort();
var newSortedTargetArray = targetArray.slice().sort();

if (newSortedSourceArray.toString() !== newSortedTargetArray.toString()) { // MAIN CHECK
    // not equal
    // did something
    return false;
}
else {
    // equal
    // did something
    // continued further below
}

// did some more work

return true;

Umarım yardımcı olur.

ES6 kullanma

Ramda'nın equalsişlevini kullanacağız , ancak bunun yerine Lodash veya Alt Çizgi'yi kullanabiliriz isEqual:

const R = require('ramda');

const arraysHaveSameValues = (arr1, arr2) => R.equals( [...arr1].sort(), [...arr2].sort() )

Yayılma karşıtlığını kullanarak, orijinal dizileri değiştirmekten kaçınıyoruz ve işlevimizi saf tutuyoruz.

reduceAkıllı görünmek için döngüler yerine kullanabilirsiniz , ancak geliştirici arkadaşlarınızın sizi bir zeki olarak düşünmesi riskiyle.

function isArrayContentSame(a, b) {
  if (Array.isArray(a) && Array.isArray(b) && a.length == b.length) {
    a = a.concat().sort()
    b = b.concat().sort()
    return a.reduce((acc,e,i) => acc && e === b[i], true)
  } else {
    return false;
  }
}

Diğer çözümlerin çoğu sıralama, O (n * log n) kullanır, kitaplıklar kullanır veya O (n ^ 2) karmaşıklığına sahiptir.

Doğrusal karmaşıklık O (n) olan saf bir Javascript çözümü:

/**
 * Check if two arrays of strings or numbers have the same values
 * @param {string[]|number[]} arr1
 * @param {string[]|number[]} arr2
 * @param {Object} [opts]
 * @param {boolean} [opts.enforceOrder] - By default (false), the order of the values in the arrays doesn't matter.
 * @return {boolean}
 */
function compareArrays(arr1, arr2, opts) {

  function vKey(i, v) {
    return (opts?.enforceOrder ? `${i}-` : '') + `${typeof v}-${v}`
  }

  if (arr1.length !== arr2.length) return false;

  const d1 = {};
  const d2 = {};  
  for (let i = arr1.length - 1; i >= 0; i--) {
    d1[vKey(i, arr1[i])] = true;
    d2[vKey(i, arr2[i])] = true;
  }
  
  for (let i = arr1.length - 1; i >= 0; i--) {
    const v = vKey(i, arr1[i]);
    if (d1[v] !== d2[v]) return false;
  }

  for (let i = arr2.length - 1; i >= 0; i--) {
    const v = vKey(i, arr2[i]);
    if (d1[v] !== d2[v]) return false;
  }

  return true
}

Testler:

arr1= [1, 2]
arr2= [1, 2]
compareArrays(arr1, arr2) => true
compareArrays(arr1, arr2, {enforceOrder: true}) => true
-------
arr1= [1, 2]
arr2= [2, 1]
compareArrays(arr1, arr2) => true
compareArrays(arr1, arr2, {enforceOrder: true}) => false
-------
arr1= [2, 1]
arr2= [1, 2]
compareArrays(arr1, arr2) => true
compareArrays(arr1, arr2, {enforceOrder: true}) => false
-------
arr1= [2, 2]
arr2= [1, 2]
compareArrays(arr1, arr2) => false
compareArrays(arr1, arr2, {enforceOrder: true}) => false
-------
arr1= [1, 2]
arr2= [1, 2, 3]
compareArrays(arr1, arr2) => false
compareArrays(arr1, arr2, {enforceOrder: true}) => false
-------
arr1= ["1"]
arr2= [1]
compareArrays(arr1, arr2) => false
compareArrays(arr1, arr2, {enforceOrder: true}) => false
-------
arr1= ["1", 2]
arr2= [2, "1"]
compareArrays(arr1, arr2) => true
compareArrays(arr1, arr2, {enforceOrder: true}) => false
-------
arr1= []
arr2= []
compareArrays(arr1, arr2) => true
compareArrays(arr1, arr2, {enforceOrder: true}) => true

Prototip Çerçevesini kullanıyorsanız, aynı olduklarını (sıraya bakılmaksızın) bulmak için bir dizinin intersect yöntemini kullanabilirsiniz :

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

if(array1.intersect(array2).length === array1.length) {
    alert("arrays are the same!");
}

lütfen bu cevabı kontrol edin

var arr1= [12,18];
var arr2= [12, 18, 20, 11, 19, 14, 6, 7, 8, 16, 9, 3, 1, 13, 5, 4, 15, 10, 2, 17];
for(i=0;i<arr1.length;i++)
{
var array1=arr1[i];
for(j=0;j<arr2.length;j++)
{
    var array2=arr2[j];
    if(array1==array2)
    {
return true;
    }
}
}

Uzun bir süre sonra cevap vermek, ancak bunun basit bir çözüm ve modern yeni başlayanlar arayan birine yardımcı olacağını umuyoruz.

Şimdi böyle bu kullanarak birden kütüphaneleri elde edebilirsiniz lodash, underscorevb (Bunlar yüzünden basitlik, çoklu özellikleri ve yüksek kullanım için günümüzde projenin bir parçası olur)

Lodash kütüphanesinden kesişimi kullanabilirsiniz.

_.intersection(['2-1', '1'], ['2-2', '3-1', '2-1']); 
// => ['2-1']

Bu, herhangi bir veri türü için çalışacaktır ..

İki diziyi karşılaştırmak ve her iki dizide de herhangi bir nesnenin aynı olup olmadığını kontrol etmek istiyorsanız, çalışacaktır. Misal :

Dizi1 = [a, b, c, d]
Dizi2 = [d, e, f, g]

Burada, 'd' her iki dizide de ortaktır, bu nedenle bu işlev gerçek değeri döndürür.

  cehckArray(array1, array2) {
    for (let i = 0; i < array1.length; i++) {
      for (let j = 0; j < array2.length; j++) {
        if (array1[i] === array2[j]) {
          return true;
        }
      }
    }
    // Return if no common element exist 
    return false;
  }

Bunu dene

function arraysEqual(arr1, arr2){
    if (!Array.isArray(arr1) || !Array.isArray(arr2) || arr1.length!=arr2.length)
        return false;

    return arr1.length==arr1.filter(word => arr2.includes(word)).length;
}

Kabul edilen cevaba göre başka bir yolum var.

function compareArrays(array1, array2) {

    if (
        !Array.isArray(array1)
        || !Array.isArray(array2)
        || array1.length !== array2.length
    ) return false;

    var first = array1.sort().map(value => (String(value))).join();
    var second = array2.sort().map(value => (String(value))).join();

    return first == second ? true : false;
}

Her ikisinin de aynı öğelere sahip olup olmadığını kontrol etmek için iki Diziyi Karşılaştırma işlevi. Düzensiz olsalar bile ...

Basit diziler için iyidir. [Dize, Sayı, Boolean, null, NaN].

.Sort () kullanmıyorum, orijinal diziyi değiştiriyor. Bazıları bunun kötü olduğunu söylüyor ...

Dikkat. Bu işlev sınırlıdır, "[], {}" Nesnelerini veya bu Dizilerdeki işlevleri karşılaştıramaz, kendi dizileri Nesnelerdir.

   let arraysHasSameElements = (arr1, arr2) => {
        let count =
            // returns counting of occurrences.
            (arr, val) => arr.reduce((count, curr) => (curr === val ? 1 : 0) + count, 0);

        /* this will return true if lengths of the arrays is equal.
           then compare them.*/
        return arr1.length === arr2.length

            // compare arr1 against arr2.
            && arr1.reduce((checks, val) =>

                /*  creating array of checking if a value has equal amount of occurrences
                    in both arrays, then adds true 'check'. */
                checks.concat(count(arr1, val) === count(arr2, val)), [])

                // checking if each check is equal to true, then .every() returns true.
                .every(check => check);
    }

    let arr1 = ['',-99,true,NaN,21,null,false,'help',-99,'help',NaN], 
        arr2 = [null,-99,'',NaN,NaN,false,true,-99,'help',21,'help'];
    arraysHasSameElements(arr1, arr2); //true

    let arr3 = [false,false,false,false,false,false], 
        arr4 = [false,false,false,false,false,false]
    arraysHasSameElements(arr3, arr4); //true


    // here we have uncommented version.
    let arraysHasSameElements = (arr1, arr2) => {
        let count = (arr, val) => arr.reduce((count, curr) => (curr === val ? 1:0) + count, 0);
        return arr1.length === arr2.length && arr1.reduce((checks, val) =>
            checks.concat(count(arr1, val) === count(arr2, val)), []).every(check => check);
    }

İki diziyi karşılaştırmak için Basit Çözüm:

var array1 = [2, 4];
var array2 = [4, 2];

array1.sort();
array2.sort();

if (array1[0] == array2[0]) {
    console.log("Success");
}else{
    console.log("Wrong");
}