jQuery를 사용하여 두 배열의 Javascript 객체 비교

jQuery를 사용하여 두 배열의 Javascript 객체 비교

저는 자바스크립트 객체의 배열이 두 개 있는데, 이들이 동일한지 비교해 보고자 합니다.각 배열에서 개체의 순서가 같지 않을 수도 있고 그렇지 않을 수도 있습니다.각 배열에는 10개 이상의 개체가 없어야 합니다.저는 jQuery가 이 문제에 대한 우아한 해결책을 가지고 있을지도 모른다고 생각했지만, 저는 온라인에서 많은 것을 찾을 수 없었습니다.

짐승이 둥지를 튼 건$.each(array, function(){})솔루션은 효과가 있겠지만, 제가 모르는 내장된 기능이 있습니까?

감사해요.

쉬운 방법이 있습니다...

$(arr1).not(arr2).length === 0 && $(arr2).not(arr1).length === 0

위에서 true를 반환하면 요소의 순서가 달라도 두 배열은 동일합니다.

참고: JSON 개체를 사용하는 경우 jquery version < 3.0.0에서만 작동합니다.

오늘도 이것을 찾고 있었는데 http://www.breakingpar.com/bkp/home.nsf/0/87256B280015193F87256BFB0077DFFD 을 찾았습니다.

몇 가지 성능 고려 사항을 언급하고 있지만 좋은 솔루션인지는 알 수 없습니다.

저는 jQuery helper 방법이 마음에 듭니다.@David 당신의 비교 방법이 다음과 같이 작동하기를 바랍니다.

jQuery.compare(a, b)

제가 하는 게 말이 안 돼요.

$(a).compare(b)

a와 b가 배열된 곳입니다.일반적으로 $($something)할 때는 DOM 요소를 사용하기 위한 선택기 문자열을 전달합니다.

또한 정렬된 배열을 정렬하고 '캐싱'하는 것과 관련하여:

• 루프를 통해 매번 정렬하는 것이 아니라 방법을 시작할 때 한 번 정렬하는 것이 '캐싱'이라고 생각하지 않습니다.compare(b)를 호출할 때마다 정렬이 계속 수행됩니다.그건 의미론일 뿐이지만...
• (vari = 0; t[i]; i++) {...t 배열에 어딘가에 잘못된 값이 포함되어 있으면 이 루프가 일찍 끝나므로 $([1, 2, 3, 4]).damply([1, false, 2, 3])가 true를 반환합니다!
• 더 중요한 것은 배열 정렬 방법(array sort() 메서드)은 배열을 제자리에 정렬하므로 var b = t.sign ...을 수행하면 원래 배열의 정렬된 복사본을 만들지 않고 원래 배열을 정렬하고 b에서 참조를 할당합니다.저는 비교법이 부작용을 가져서는 안 된다고 생각합니다.

우리가 해야 할 일은 어레이를 작업하기 전에 복사하는 것입니다.jQuery 방식으로 그것을 수행하는 방법에 대해 제가 찾을 수 있는 가장 좋은 답은 다름아닌 여기 SO에 대한 John Resig입니다!자바스크립트에서 객체를 딥클론하는 가장 효율적인 방법은 무엇입니까?(개체 복제 레시피 배열 버전에 대한 답변 주석 참조)

이 경우 코드는 다음과 같습니다.

jQuery.extend({
    compare: function (arrayA, arrayB) {
        if (arrayA.length != arrayB.length) { return false; }
        // sort modifies original array
        // (which are passed by reference to our method!)
        // so clone the arrays before sorting
        var a = jQuery.extend(true, [], arrayA);
        var b = jQuery.extend(true, [], arrayB);
        a.sort(); 
        b.sort();
        for (var i = 0, l = a.length; i < l; i++) {
            if (a[i] !== b[i]) { 
                return false;
            }
        }
        return true;
    }
});

var a = [1, 2, 3];
var b = [2, 3, 4];
var c = [3, 4, 2];

jQuery.compare(a, b);
// false

jQuery.compare(b, c);
// true

// c is still unsorted [3, 4, 2]

JSON.stringify를 사용하여 두 컬렉션을 평준화하고 동일성을 확인하기 위해 일반 문자열을 사용했습니다.

예.

var arr1 = [
             {Col: 'a', Val: 1}, 
             {Col: 'b', Val: 2}, 
             {Col: 'c', Val: 3}
           ];

var arr2 = [
             {Col: 'x', Val: 24}, 
             {Col: 'y', Val: 25}, 
             {Col: 'z', Val: 26}
           ];

if(JSON.stringify(arr1) == JSON.stringify(arr2)){
    alert('Collections are equal');
}else{
    alert('Collections are not equal');
}

NB: 그의 방법은 두 컬렉션이 비슷한 방식으로 정렬되는 것을 전제로 하며, 그렇지 않다면 잘못된 결과를 제공할 것입니다!

두 배열을 모두 문자열로 변환하여 비교

if (JSON.stringify(array1) == JSON.stringify(array2))
{
    // your code here
}

어레이와 객체를 심층적으로 비교할 수 있는 방법이 필요했기 때문에 이 논의를 찾았습니다.여기에 있는 예제를 사용하여 다음과 같은 것을 생각해 냈습니다(명확성을 위해 세 가지 방법으로 구분).

jQuery.extend({
    compare : function (a,b) {
        var obj_str = '[object Object]',
            arr_str = '[object Array]',
            a_type  = Object.prototype.toString.apply(a),
            b_type  = Object.prototype.toString.apply(b);

            if ( a_type !== b_type) { return false; }
            else if (a_type === obj_str) {
                return $.compareObject(a,b);
            }
            else if (a_type === arr_str) {
                return $.compareArray(a,b);
            }
            return (a === b);
        }
});

jQuery.extend({
    compareArray: function (arrayA, arrayB) {
        var a,b,i,a_type,b_type;
        // References to each other?
        if (arrayA === arrayB) { return true;}

        if (arrayA.length != arrayB.length) { return false; }
        // sort modifies original array
        // (which are passed by reference to our method!)
        // so clone the arrays before sorting
        a = jQuery.extend(true, [], arrayA);
        b = jQuery.extend(true, [], arrayB);
        a.sort(); 
        b.sort();
        for (i = 0, l = a.length; i < l; i+=1) {
            a_type = Object.prototype.toString.apply(a[i]);
            b_type = Object.prototype.toString.apply(b[i]);

            if (a_type !== b_type) {
                return false;
            }

            if ($.compare(a[i],b[i]) === false) {
                return false;
            }
        }
        return true;
    }
});

jQuery.extend({
    compareObject : function(objA,objB) {

        var i,a_type,b_type;

        // Compare if they are references to each other 
        if (objA === objB) { return true;}

        if (Object.keys(objA).length !== Object.keys(objB).length) { return false;}
        for (i in objA) {
            if (objA.hasOwnProperty(i)) {
                if (typeof objB[i] === 'undefined') {
                    return false;
                }
                else {
                    a_type = Object.prototype.toString.apply(objA[i]);
                    b_type = Object.prototype.toString.apply(objB[i]);

                    if (a_type !== b_type) {
                        return false; 
                    }
                }
            }
            if ($.compare(objA[i],objB[i]) === false){
                return false;
            }
        }
        return true;
    }
});

테스트

var a={a : {a : 1, b: 2}},
    b={a : {a : 1, b: 2}},
    c={a : {a : 1, b: 3}},
    d=[1,2,3],
    e=[2,1,3];

console.debug('a and b = ' + $.compare(a,b)); // a and b = true
console.debug('b and b = ' + $.compare(b,b)); // b and b = true
console.debug('b and c = ' + $.compare(b,c)); // b and c = false
console.debug('c and d = ' + $.compare(c,d)); // c and d = false
console.debug('d and e = ' + $.compare(d,e)); // d and e = true

저의 경우 비교 배열은 숫자와 문자열만 포함합니다.이 솔루션은 제게 효과적이었습니다.

function are_arrs_equal(arr1, arr2){
    return arr1.sort().toString() === arr2.sort().toString()
}

테스트 해보겠습니다.

arr1 = [1, 2, 3, 'nik']
arr2 = ['nik', 3, 1, 2]
arr3 = [1, 2, 5]

console.log (are_arrs_equal(arr1, arr2)) //true
console.log (are_arrs_equal(arr1, arr3)) //false

이를 위한 "jQuery"의 좋은 방법은 없다고 생각합니다. 하지만 효율성이 필요하다면 어레이 중 하나를 특정 키(유일한 객체 필드 중 하나)로 매핑한 다음 다른 어레이를 반복적으로 탐색하여 맵 또는 연관 어레이와 비교하여 비교해 보십시오.

효율성이 문제가 되지 않는다면 A의 모든 객체와 B의 모든 객체를 비교하면 됩니다.|A|와 |B|가 작은 한, 당신은 괜찮을 겁니다.

어레이의 내용만 비교하고 싶다면 유용한 jQuery 함수 $.inArray()가 있습니다.

var arr = [11, "String #1", 14, "String #2"];
var arr_true = ["String #1", 14, "String #2", 11]; // contents are the same as arr
var arr_false = ["String #1", 14, "String #2", 16]; // contents differ

function test(arr_1, arr_2) {
    var equal = arr_1.length == arr_2.length; // if array sizes mismatches, then we assume, that they are not equal
    if (equal) {
        $.each(arr_1, function (foo, val) {
            if (!equal) return false;
            if ($.inArray(val, arr_2) == -1) {
                equal = false;
            } else {
                equal = true;
            }
        });
    }
    return equal;
}

alert('Array contents are the same? ' + test(arr, arr_true)); //- returns true
alert('Array contents are the same? ' + test(arr, arr_false)); //- returns false

배열을 문자열로 변경하여 비교

var arr = [1,2,3], 
arr2 = [1,2,3]; 
console.log(arr.toString() === arr2.toString());

jQuery global method로 Suddakar R의 멋진 라이너입니다.

/**
 * Compare two arrays if they are equal even if they have different order.
 *
 * @link https://stackoverflow.com/a/7726509
 */
jQuery.extend({
  /**
   * @param {array} a
   *   First array to compare.
   * @param {array} b
   *   Second array to compare.
   * @return {boolean}
   *   True if both arrays are equal, otherwise false.
   */
  arrayCompare: function (a, b) {
    return $(a).not(b).get().length === 0 && $(b).not(a).get().length === 0;
  }
});

저는 jQuery와 어레이 비교를 하려고 할 때도 이 점을 발견했습니다.제 경우에는 배열이라고 알고 있는 문자열을 가지고 있었습니다.

var needle = 'apple orange';
var haystack = 'kiwi orange banana apple plum';

하지만 나는 그것이 완전한 경기인지 아니면 부분적인 경기인지를 신경을 썼기 때문에 수다카르 R의 대답에 근거하여 다음과 같은 것을 사용했습니다.

function compareStrings( needle, haystack ){
  var needleArr = needle.split(" "),
    haystackArr = haystack.split(" "),
    compare = $(haystackArr).not(needleArr).get().length;

  if( compare == 0 ){
    return 'all';
  } else if ( compare == haystackArr.length  ) {
    return 'none';
  } else {
    return 'partial';
  }
}

가 가 가 가 등[1, 1, 2]는됨는과 같을 수 .[2, 1]하지만 동등해야 합니다.[1, 2, 1] 솔루션입니다 , 은 입니다 입니다

  const arrayContentsEqual = (arrayA, arrayB) => {
    if (arrayA.length !== arrayB.length) {
      return false}

    const refCount = (function() {
      const refCountMap = {};
      const refCountFn = (elt, count) => {
          refCountMap[elt] = (refCountMap[elt] || 0) + count}
      refCountFn.isZero = () => {
        for (let elt in refCountMap) {
          if (refCountMap[elt] !== 0) {
            return false}}
        return true}
      return refCountFn})()

    arrayB.map(eltB => refCount(eltB, 1));
    arrayA.map(eltA => refCount(eltA, -1));
    return refCount.isZero()}

여기 가지고 놀 수 있는 바이올린이 있습니다.

var arr1 = [
             {name: 'a', Val: 1}, 
             {name: 'b', Val: 2}, 
             {name: 'c', Val: 3}
           ];

var arr2 = [
             {name: 'c', Val: 3},
             {name: 'x', Val: 4}, 
             {name: 'y', Val: 5}, 
             {name: 'z', Val: 6}
           ];
var _isEqual = _.intersectionWith(arr1, arr2, _.isEqual);// common in both array
var _difference1 = _.differenceWith(arr1, arr2, _.isEqual);//difference from array1 
var _difference2 = _.differenceWith(arr2, arr1, _.isEqual);//difference from array2 
console.log(_isEqual);// common in both array
console.log(_difference1);//difference from array1 
console.log(_difference2);//difference from array2 

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.js"></script>

이거 먹어봐요.

function check(c,d){
  var a = c, b = d,flg = 0;
  if(a.length == b.length) 
  { 
     for(var i=0;i<a.length;i++) 
           a[i] != b[i] ? flg++ : 0; 
  } 
  else  
  { 
     flg = 1; 
  } 
  return flg = 0;
}

언급URL : https://stackoverflow.com/questions/1773069/using-jquery-to-compare-two-arrays-of-javascript-objects