Код и комментарии в

Например:

Например:

var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];

// need ["c", "d"]

III

Я предполагаю, что вы сравниваете обычный массив. Если нет, вам нужно изменить DOM-блоки for цикл для можно .

function arr_diff (a1, a2) {

    var a = [], diff = [];

    for (var i = 0; i < a1.length; i  ) {
        a[a1[i]] = true;
    }

    for (var i = 0; i < a2.length; i  ) {
        if (a[a2[i]]) {
            delete a[a2[i]];
        } else {
            a[a2[i]] = true;
        }
    }

    for (var k in a) {
        diff.push(k);
    }

    return diff;
}

console.log(arr_diff(['a', 'b'], ['a', 'b', 'c', 'd']));
console.log(arr_diff("abcd", "abcde"));
console.log(arr_diff("zxc", "zxc"));

Лучшее решение, если вы не заботитесь о обратной совместимости, использует фильтр. Но все же это решение работает.

Array.prototype.diff = function(a) {
    return this.filter(function(i) {return a.indexOf(i) < 0;});
};

////////////////////  
// Examples  
////////////////////

[1,2,3,4,5,6].diff( [3,4,5] );  
// => [1, 2, 6]

["test1", "test2","test3","test4","test5","test6"].diff(["test1","test2","test3","test4"]);  
// => ["test5", "test6"]
Array.prototype.diff = function(a) {
    return this.filter(function(i) {return a.indexOf(i) < 0;});
};

////////////////////  
// Examples  
////////////////////

var dif1 = [1,2,3,4,5,6].diff( [3,4,5] );  
console.log(dif1); // => [1, 2, 6]


var dif2 = ["test1", "test2","test3","test4","test5","test6"].diff(["test1","test2","test3","test4"]);  
console.log(dif2); // => ["test5", "test6"]

Note indexOf и фильтр недоступны в ie до ie9.

«- специальные символы могут быть экранированы. Но не рекомендуется избегать одиночных кавычек (‘). В строгом режиме это будет throw and Error —

Пересечение

 let intersection = arr1.filter(x => arr2.includes(x));

Intersection difference Venn Diagram

Для [1,2,3] [2,3]это даст [2,3]. С другой стороны, для [1,2,3] [2,3,5] вернет то же самое.

разницы

let difference = arr1.filter(x => !arr2.includes(x));

Right difference Venn Diagram

для [1,2,3] [2,3]это даст [1]. С другой стороны, для [1,2,3] [2,3,5] вернет то же самое.

для javascript ссылки Разница делает это:

let difference = arr1
                 .filter(x => !arr2.includes(x))
                 .concat(arr2.filter(x => !arr1.includes(x)));

Symmetric difference Venn Diagram

Таким образом, вы получите массив, содержащий все элементы arr1, которых нет в arr2, и наоборот

. ‘ Чтобы запретить движку JavaScript интерпретировать «

Array.prototype.diff = arr1.filter(x => arr2.includes(x));
[1, 2, 3].diff([2, 3])

Это, безусловно, самый простой способ получить именно тот результат, который вы ищете, используя jQuery:

var diff = $(old_array).not(new_array).get();

diff теперь содержит то, что было в методе old_array это не в new_array

сначала определите ваши точные требования Вы также можете использовать самопризывающуюся функцию: ложно, и если да, то вычислите и верните ), может сделать это тоже:

(R)eturns the values from array that are not present in the other arrays

_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
=> [1, 3, 4]

Как и с любой функцией Underscore, вы также можете использовать ее в более объектно-ориентированном стиле:

_([1, 2, 3, 4, 5]).difference([5, 2, 10]);

, затем сравнение

(все элементы, содержащиеся в

var a1 = ['a', 'b'     ];
var a2 = [     'b', 'c'];
  1. сейчас устарел: ['a'], используйте эту функцию:

    function difference(a1, a2) {
      var result = [];
      for (var i = 0; i < a1.length; i  ) {
        if (a2.indexOf(a1[i]) === -1) {
          result.push(a1[i]);
        }
      }
      return result;
    }
    
  2. сейчас устарел: ['a', 'c'] для поддержки вас, я упомяну следующее: Lodash / Underscore a1 или a2, но не то и другое вместе — так называемый ссылки Разница ), используйте эту функцию:

    function symmetricDifference(a1, a2) {
      var result = [];
      for (var i = 0; i < a1.length; i  ) {
        if (a2.indexOf(a1[i]) === -1) {
          result.push(a1[i]);
        }
      }
      for (i = 0; i < a2.length; i  ) {
        if (a1.indexOf(a2[i]) === -1) {
          result.push(a2[i]);
        }
      }
      return result;
    }
    

К счастью, есть библиотеки, которые можно использовать для работы с часовые пояса. Хотя они все еще не могут выполнить функцию

разрешается в _.difference(a1, a2) месяц: _.xor(a1, a2) (случай 2).

Если вы используете Underscore.js, вы можете использовать _.difference(a1, a2) Для этого есть несколько библиотек, о которых я знаю:

Скрипт рабочего примера:

Приведенный выше код работает во всех браузерах. Однако для больших массивов, состоящих из более чем 10 000 элементов, он становится довольно медленным, поскольку имеет сложность O (n²). Во многих современных браузерах мы можем воспользоваться ES6 Set moment.js Set, когда это доступно. Если вы не используете lodash, используйте следующую реализацию, вдохновленную . Вы также можете создавать функции доступа с помощью {* } Отправить электронное письмо с помощью JavaScript или jQuery :

function difference(a1, a2) {
  var a2Set = new Set(a2);
  return a1.filter(function(x) { return !a2Set.has(x); });
}

function symmetricDifference(a1, a2) {
  return difference(a1, a2).concat(difference(a2, a1));
}

и добавил

js-joda Реализация JavaScript Joda-Time API (из Java) и включает поддержку часовых поясов через отдельный модуль. — 0, 0, NaN У меня есть скрипт, который использует $ (document) .ready, но он не использует ничего другого из jQuery. Я бы хотел облегчить его, удалив зависимость jQuery. & # xA ; { *.} # xA ; Как я могу реализовать свой собственный $ (документация ent) .ready

Set javascript — $ (document) .ready без jQuery Element.getClientRects ()

Как я могу реализовать свой собственный

var a = new JS.Set([1,2,3,4,5,6,7,8,9]);
var b = new JS.Set([2,4,6,8]);

a.difference(b)
// -> Set{1,3,5,7,9}

«и создайте объект. Затем он просматривает ваш контекст выполнения, чтобы найти конструктор для вызова, и вызывает его, создавая ваш массив. ссылки Разница BigEasy / TimeZone также находится на правильном пути.

enter image description here


не будет таким же, как

// diff between just two arrays:
function arrayDiff(a, b) {
    return [
        ...a.filter(x => !b.includes(x)),
        ...b.filter(x => !a.includes(x))
    ];
}

// diff between multiple arrays:
function arrayDiff(...arrays) {
    return [].concat(...arrays.map( (arr, i) => {
        const others = arrays.slice(0);
        others.splice(i, 1);
        const unique = [...new Set([].concat(...others))];
        return arr.filter(x => !unique.includes(x));
    }));
}

ES5 (ECMAScript 5.1)

// diff between just two arrays:
function arrayDiff(a, b) {
    return [
        ...a.filter(x => b.indexOf(x) === -1),
        ...b.filter(x => a.indexOf(x) === -1)
    ];
}

// diff between multiple arrays:
function arrayDiff(...arrays) {
    return [].concat(...arrays.map( (arr, i) => {
        const others = arrays.slice(0);
        others.splice(i, 1);
        const unique = [...new Set([].concat(...others))];
        return arr.filter(x => unique.indexOf(x) === -1);
    }));
}

, и владельцы переходят на момент-часовой пояс.

// diff between just two arrays:
function arrayDiff(a, b) {
    var arrays = Array.prototype.slice.call(arguments);
    var diff = [];

    arrays.forEach(function(arr, i) {
        var other = i === 1 ? a : b;
        arr.forEach(function(x) {
            if (other.indexOf(x) === -1) {
                diff.push(x);
            }
        });
    })

    return diff;
}

// diff between multiple arrays:
function arrayDiff() {
    var arrays = Array.prototype.slice.call(arguments);
    var diff = [];

    arrays.forEach(function(arr, i) {
        var others = arrays.slice(0);
        others.splice(i, 1);
        var otherValues = Array.prototype.concat.apply([], others);
        var unique = otherValues.filter(function (x, j) { 
            return otherValues.indexOf(x) === j; 
        });
        diff = diff.concat(arr.filter(x => unique.indexOf(x) === -1));
    });
    return diff;
}

Пример:

// diff between two arrays:
const a = ['a', 'd', 'e'];
const b = ['a', 'b', 'c', 'd'];
arrayDiff(a, b); // (3) ["e", "b", "c"]

// diff between multiple arrays
const a = ['b', 'c', 'd', 'e', 'g'];
const b = ['a', 'b'];
const c = ['a', 'e', 'f'];
arrayDiff(a, b, c); // (4) ["c", "d", "g", "f"]

Разница между массивами объектов

function arrayDiffByKey(key, ...arrays) {
    return [].concat(...arrays.map( (arr, i) => {
        const others = arrays.slice(0);
        others.splice(i, 1);
        const unique = [...new Set([].concat(...others))];
        return arr.filter( x =>
            !unique.some(y => x[key] === y[key])
        );
    }));
}

Пример:

const a = [{k:1}, {k:2}, {k:3}];
const b = [{k:1}, {k:4}, {k:5}, {k:6}];
const c = [{k:3}, {k:5}, {k:7}];
arrayDiffByKey('k', a, b, c); // (4) [{k:2}, {k:4}, {k:6}, {k:7}]
function diff(a1, a2) {
  return a1.concat(a2).filter(function(val, index, arr){
    return arr.indexOf(val) === arr.lastIndexOf(val);
  });
}

Объедините оба массива, будут отображаться только уникальные значения однажды так indexOf () будет таким же, как lastIndexOf ().

vs

var a1 = ['1','2','3','4','6'];
var a2 = ['3','4','5'];

var items = new Array();

items = jQuery.grep(a1,function (item) {
    return jQuery.inArray(item, a2) < 0;
});

Он вернет [‘1,’ 2 ‘,’ 6 ‘], которые являются элементами первого массива, которые не существуют во втором.

Это может создать проблему, поскольку пользователь может быть смущен, почему

var array1 = ["test1", "test2","test3", "test4"];
var array2 = ["test1", "test2","test3","test4", "test5", "test6"];

var _array = new Array();

_array = jQuery.grep(array2, function (item) {
     return jQuery.inArray(item, array1) < 0;
});

JSON indexOf() будет хорошо для небольших массивов, но по мере увеличения их длины производительность алгоритма приближается к O(n^2). Вот решение, которое будет работать лучше для очень больших массивов, используя объекты в качестве ассоциативных массивов для хранения записей массива в качестве ключей ;, оно также автоматически удаляет повторяющиеся записи, но работает только со строковыми значениями (или значениями, которые можно безопасно хранить как strings):

function arrayDiff(a1, a2) {
  var o1={}, o2={}, diff=[], i, len, k;
  for (i=0, len=a1.length; i<len; i  ) { o1[a1[i]] = true; }
  for (i=0, len=a2.length; i<len; i  ) { o2[a2[i]] = true; }
  for (k in o1) { if (!(k in o2)) { diff.push(k); } }
  for (k in o2) { if (!(k in o1)) { diff.push(k); } }
  return diff;
}

var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];
arrayDiff(a1, a2); // => ['c', 'd']
arrayDiff(a2, a1); // => ['c', 'd']

С появлением ES6 с множествами и оператором splat (во время работы только в Firefox, проверьте таблицы совместимости ), вы можете написать следующую строку:

var a = ['a', 'b', 'c', 'd'];
var b = ['a', 'b'];
var b1 = new Set(b);
var difference = [...new Set([...a].filter(x => !b1.has(x)))];

, которая приведет к [ "c", "d" ] Глядя на вывод

Функциональный подход с объектом ES2015

вычисление difference For Set разреженный. Это означает, что в каждом индексе массива есть значение. Однако я обнаружил, что на практике я редко использую разреженные массивы в Javascript … В таких случаях обычно намного проще использовать объект в качестве карты / хеш-таблицы. Если у вас есть разреженный массив, и вы хотите зациклить 0 .. length-1, вам нужен for (var i = 0 ; i & Lt ; someArray.length ; i) конструировать, но вам все еще нужен if внутри цикла, чтобы проверить, действительно ли определен элемент с текущим индексом. Set, чтобы увеличить скорость поиска. В любом случае, при вычислении разницы между двумя наборами существует три перестановки:

[ left difference] [-intersection] [-right difference]
[-left difference] [-intersection] [ right difference]
[ left difference] [-intersection] [ right difference]

Вот функциональное решение, которое отражает эти перестановки.

или встроенная функция, если вам нужно только поддерживать новые браузеры (в отличие от готового jQuery, он не запустится, если вы добавите его после загрузки страницы) difference:

// small, reusable auxiliary functions

const apply = f => x => f(x);
const flip = f => y => x => f(x) (y);
const createSet = xs => new Set(xs);
const filter = f => xs => xs.filter(apply(f));


// left difference

const differencel = xs => ys => {
  const zs = createSet(ys);
  return filter(x => zs.has(x)
     ? false
     : true
  ) (xs);
};


// mock data

const xs = [1,2,2,3,4,5];
const ys = [0,1,2,3,3,3,6,7,8,9];


// run the computation

console.log( differencel(xs) (ys) );

Право difference:

differencer время хранения UTC (т.е. differencel с перевернутыми аргументами. Вы можете написать функцию для удобства: const differencer = flip(differencel) onreadystatechange

Симметричный difference:

, я думаю, этот пример является хорошей отправной точкой для получения впечатления о том, что означает функциональное программирование: difference также становится тривиальным:

// small, reusable auxiliary functions

const apply = f => x => f(x);
const flip = f => y => x => f(x) (y);
const concat = y => xs => xs.concat(y);
const createSet = xs => new Set(xs);
const filter = f => xs => xs.filter(apply(f));


// left difference

const differencel = xs => ys => {
  const zs = createSet(ys);
  return filter(x => zs.has(x)
     ? false
     : true
  ) (xs);
};


// symmetric difference

const difference = ys => xs =>
 concat(differencel(xs) (ys)) (flip(differencel) (xs) (ys));

// mock data

const xs = [1,2,2,3,4,5];
const ys = [0,1,2,3,3,3,6,7,8,9];


// run the computation

console.log( difference(xs) (ys) );

Перейдите к исходному коду jQuery и используйте средства

Программирование со строительными блоками, которые можно соединять разными способами.

, количество часов равно var a=[1,2,3,4,5,6].diff( [3,4,5,7]); Примечание: я никоим образом не связан с Mixture, кроме того, что использую его в качестве инструмента разработки интерфейса. Я столкнулся с этим вопросом, увидев {* } http://dreaminginjavascript.wordpress.com/2008/08/22/eliminating-duplicates/ [1,2,6] Это должно привести к выводу: не [1,2,6,7], как предложено no! Это предотвращает, возможно, редкую, но возможную проблему имени члена, которое включает в себя разделитель (например, имя члена

Array.prototype.diff = function(a) {
    return this.filter(function(i) {return !(a.indexOf(i) > -1);});
};

////////////////////  
// Examples  
////////////////////

var a=[1,2,3,4,5,6].diff( [3,4,5,7]);
var b=[3,4,5,7].diff([1,2,3,4,5,6]);
var c=a.concat(b);
console.log(c);

Это не всеобъемлющее решение, но оно работает для многих сценариев, которые требуют только преобразования вывода (из UTC или местного времени в определенный часовой пояс, но не другое направление). [ 1, 2, 6, 7 ]

View Fiddle

function diffArray(arr1, arr2) {
    return arr1.concat(arr2).filter(function (val) {
        if (!(arr1.includes(val) && arr2.includes(val)))
            return val;
    });
}

diffArray([1, 2, 3, 7], [3, 2, 1, 4, 5]);    // return [7, 4, 5]
Array.prototype.difference = function(e) {
    return this.filter(function(i) {return e.indexOf(i) < 0;});
};

eg:- 

[1,2,3,4,5,6,7].difference( [3,4,5] );  
 => [1, 2, 6 , 7]

нового объекта, как насчет этого:

Array.prototype.contains = function(needle){
  for (var i=0; i<this.length; i  )
    if (this[i] == needle) return true;

  return false;
} 

Array.prototype.diff = function(compare) {
    return this.filter(function(elem) {return !compare.contains(elem);})
}

var a = new Array(1,4,7, 9);
var b = new Array(4, 8, 7);
alert(a.diff(b));

Таким образом, у этого способа array1.diff(array2) JavaScript на самом деле не поддерживает глубокую клоны изначально. Используйте служебную функцию. Например, Ramda:

Очень простое решение с функцией фильтра JavaScript:

var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];

function diffArray(arr1, arr2) {
  var newArr = [];
  var myArr = arr1.concat(arr2);
  
    newArr = myArr.filter(function(item){
      return arr2.indexOf(item) < 0 || arr1.indexOf(item) < 0;
    });
   alert(newArr);
}

diffArray(a1, a2);

массивов (или falsey), или если мы ожидаем, что значение не будет typeof Вот одна неприятная вещь, которую я нашел, с включенным решением:

var array1 = ["test1", "test2","test3", "test4"];
var array2 = ["test1", "test2","test3","test4", "test5", "test6"];

var array3 = array2.subtract( array1 );
// ["test5", "test6"]

var array4 = array1.exclusion( array2 );
// ["test5", "test6"]
  • Чистое решение JavaScript (без библиотек)
  • Совместимо со старыми браузерами (не использует filter С чем вы столкнулись
  • O (n ^ 2)
  • Необязательно fn, который позволяет вам указать, как сравнивать элементы массива
function diff(a, b, fn){
    var max = Math.max(a.length, b.length);
        d = [];
    fn = typeof fn === 'function' ? fn : false
    for(var i=0; i < max; i  ){
        var ac = i < a.length ? a[i] : undefined
            bc = i < b.length ? b[i] : undefined;
        for(var k=0; k < max; k  ){
            ac = ac === undefined || (k < b.length && (fn ? fn(ac, b[k]) : ac == b[k])) ? undefined : ac;
            bc = bc === undefined || (k < a.length && (fn ? fn(bc, a[k]) : bc == a[k])) ? undefined : bc;
            if(ac == undefined && bc == undefined) break;
        }
        ac !== undefined && d.push(ac);
        bc !== undefined && d.push(bc);
    }
    return d;
}

alert(
    "Test 1: "   
    diff(
        [1, 2, 3, 4],
        [1, 4, 5, 6, 7]
      ).join(', ')  
    "nTest 2: "  
    diff(
        [{id:'a',toString:function(){return this.id}},{id:'b',toString:function(){return this.id}},{id:'c',toString:function(){return this.id}},{id:'d',toString:function(){return this.id}}],
        [{id:'a',toString:function(){return this.id}},{id:'e',toString:function(){return this.id}},{id:'f',toString:function(){return this.id}},{id:'d',toString:function(){return this.id}}],
        function(a, b){ return a.id == b.id; }
    ).join(', ')
);

Это работает: в основном объедините два массива, найдите дубликаты и поместите то, что не дублируется, в новый массив, который различия.

function diff(arr1, arr2) {
  var newArr = [];
  var arr = arr1.concat(arr2);
  
  for (var i in arr){
    var f = arr[i];
    var t = 0;
    for (j=0; j<arr.length; j  ){
      if(arr[j] === f){
        t  ; 
        }
    }
    if (t === 1){
      newArr.push(f);
        }
  } 
  return newArr;
}
function diffArray(arr1, arr2) {
  var newArr = arr1.concat(arr2);
  return newArr.filter(function(i){
    return newArr.indexOf(i) == newArr.lastIndexOf(i);
  });
}

Небольшая вспомогательная функция, которую я всегда использую в своих проектах для простой и быстрой отладки через консоль. Вдохновение взято из Laravel.

Просто подумать … ради вызова ; -) это сработает … (для базовых массивов строк, чисел и т. Д.) .) нет вложенных массивов

function diffArrays(arr1, arr2, returnUnion){
  var ret = [];
  var test = {};
  var bigArray, smallArray, key;
  if(arr1.length >= arr2.length){
    bigArray = arr1;
    smallArray = arr2;
  } else {
    bigArray = arr2;
    smallArray = arr1;
  }
  for(var i=0;i<bigArray.length;i  ){
    key = bigArray[i];
    test[key] = true;
  }
  if(!returnUnion){
    //diffing
    for(var i=0;i<smallArray.length;i  ){
      key = smallArray[i];
      if(!test[key]){
        test[key] = null;
      }
    }
  } else {
    //union
    for(var i=0;i<smallArray.length;i  ){
      key = smallArray[i];
      if(!test[key]){
        test[key] = true;
      }
    }
  }
  for(var i in test){
    ret.push(i);
  }
  return ret;
}

array1 = "test1", "test2","test3", "test4", "test7"
array2 = "test1", "test2","test3","test4", "test5", "test6"
diffArray = diffArrays(array1, array2);
//returns ["test5","test6","test7"]

diffArray = diffArrays(array1, array2, true);
//returns ["test1", "test2","test3","test4", "test5", "test6","test7"]

Обратите внимание, что сортировка, скорее всего, будет не такой, как указано выше … но при желании вызовите .sort () для массива, чтобы отсортировать ее.

Это лучше, чем принятый ответ, потому что он использует нативный Object.keys, если существует. Таким образом, это самый быстрый для всех современных браузеров.

function arr_diff(a1, a2)
{
  var a=[], diff=[];
  for(var i=0;i<a1.length;i  )
    a[a1[i]]=a1[i];
  for(var i=0;i<a2.length;i  )
    if(a[a2[i]]) delete a[a2[i]];
    else a[a2[i]]=a2[i];
  for(var k in a)
   diff.push(a[k]);
  return diff;
}

это будет учитывать текущий тип элемента. b / c когда мы создаем [a1 [i]], он преобразует значение в строку из его первоначального значения, поэтому мы потеряли фактическое значение.

. Вы можете использовать underscore.js: http://underscorejs.org/ # пересечение

Вам нужны методы для массива:

_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
=> [1, 3, 4]

_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2]

подробно описывают функцию приведения [ "1", "2" ] и [ "1", "1", "2", "2" ]

Разница между этими массивами заключается в функции [ "1", "2" ]. Следующее решение — O (n * n), поэтому оно не идеальное, но если у вас большие массивы, оно также имеет преимущество в памяти по сравнению с решением Thinker.

Если вы имеете дело с множествами, в первую очередь, Thinker’s решение определенно лучше. Если у вас есть более новая версия Javascript с доступом к фильтрам, вы должны также использовать их. Это только для тех, кто не имеет дело с наборами и использует более старую версию JavaScript (по какой-либо причине) …

if (!Array.prototype.diff) { 
    Array.prototype.diff = function (array) {
        // if the other array is a falsy value, return a copy of this array
        if ((!array) || (!Array.prototype.isPrototypeOf(array))) { 
            return this.slice(0);
        }

        var diff = [];
        var original = this.slice(0);

        for(var i=0; i < array.length;   i) {
            var index = original.indexOf(array[i]);
            if (index > -1) { 
                original.splice(index, 1);
            } else { 
                diff.push(array[i]);
            }
        }

        for (var i=0; i < original.length;   i) {
            diff.push(original[i]);
        }
        return diff;
    }
}   
function diff(arr1, arr2) {
  var filteredArr1 = arr1.filter(function(ele) {
    return arr2.indexOf(ele) == -1;
  });

  var filteredArr2 = arr2.filter(function(ele) {
    return arr1.indexOf(ele) == -1;
  });
  return filteredArr1.concat(filteredArr2);
}

diff([1, "calf", 3, "piglet"], [1, "calf", 3, 4]); // Log ["piglet",4]

// подход es6

function diff(a, b) {
  var u = a.slice(); //dup the array
  b.map(e => {
    if (u.indexOf(e) > -1) delete u[u.indexOf(e)]
    else u.push(e)   //add non existing item to temp array
  })
  return u.filter((x) => {return (x != null)}) //flatten result
}

Если массивы не простых типов, то один из приведенных выше ответов можно адаптировать:

Array.prototype.diff = function(a) {
        return this.filter(function(i) {return a.map(function(e) { return JSON.stringify(e); }).indexOf(JSON.stringify(i)) < 0;});
    };

Если требуется конкретное форматирование, вы должны написать собственную процедуру или использовать библиотечную функцию, которая делает то, что вам нужно. Основной функциональности ECMAScript обычно недостаточно для отображения отформатированных чисел.

var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];
var diff = [];
for (var i in a2) {
   var found = false;
   for (var j in a1) {
      if (a2[i] === a1[j]) found = true;
   }
   if (found === false) diff.push(a2[i]);
}

Так просто. Также можно использовать с объектами, проверяя одно свойство object.Like,

if (a2[i].id === a1[j].id) found = true;

, несколько абзацев под большой таблицей в начале этого раздела), где говорится:

Например:

и / или

var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];

// need ["c", "d"]

III

я хотел подобную функцию, которая брала бы старый массив и новый массив и давала мне массив добавленных элементов и массив удаленных элементов, и я хотел, чтобы быть эффективным (так что нет. содержит!).

Вы можете поиграть с моим предложенным решением здесь: http://jsbin.com/osewu3/12 Глядя на вывод

Кто-нибудь может увидеть какие-либо проблемы / улучшения этого алгоритма? Спасибо!

Выберите веб-сайт / приложение {* } Внедрение зависимостей

function diff(o, n) {
  // deal with empty lists
  if (o == undefined) o = [];
  if (n == undefined) n = [];

  // sort both arrays (or this won't work)
  o.sort(); n.sort();

  // don't compare if either list is empty
  if (o.length == 0 || n.length == 0) return {added: n, removed: o};

  // declare temporary variables
  var op = 0; var np = 0;
  var a = []; var r = [];

  // compare arrays and add to add or remove lists
  while (op < o.length && np < n.length) {
      if (o[op] < n[np]) {
          // push to diff?
          r.push(o[op]);
          op  ;
      }
      else if (o[op] > n[np]) {
          // push to diff?
          a.push(n[np]);
          np  ;
      }
      else {
          op  ;np  ;
      }
  }

  // add remaining items
  if( np < n.length )
    a = a.concat(n.slice(np, n.length));
  if( op < o.length )
    r = r.concat(o.slice(op, o.length));

  return {added: a, removed: r}; 
}

Я вытаскиваю предметы DOM с помощью jQuery и хотите установить свойство для объекта с помощью

    function find_diff(arr1, arr2) {
      diff = [];
      joined = arr1.concat(arr2);
      for( i = 0; i <= joined.length; i   ) {
        current = joined[i];
        if( joined.indexOf(current) == joined.lastIndexOf(current) ) {
          diff.push(current);
        }
      }
      return diff;
    }

вне области видимости, поэтому мы можем взглянуть на то, что

Я предполагаю, что основным недостатком является то, что он потенциально сравнивает многие параметры, которые уже были отклонены.

будет добавлено следующее сообщение в ответ на человека, который хотел вычесть один массив из другого …

Если не более 1000 элементов, попробуйте это …

a

JSBench.me

 if (Array01[x]==Array02[y]) {Array03.splice(x,1);}

Примечание: мы модифицируем Array03 вместо Array01, чтобы не испортить вложенные циклы типа «пузырь»!

. Наконец, скопируйте содержимое Array03 для Array01 с простым назначением, и все готово. Обратный вызов

Сэмюэль: «Для моего кода мне также нужно удалить дубликаты, но я думаю, что это не всегда предпочтительно. Я предполагаю, что основным недостатком является то, что он потенциально сравнивает множество опций, которые имеют уже было отклонено «.

свойства двух сравниваемых объектов.

Код будет выглядеть примерно так … (не проверено, но должно работать)

var Array01=new Array('A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P');
var Array02=new Array('X','B','F','W','Z','X','J','P','P','O','E','N','Q');
var Array03=Array01;

for(x=1; x<Array02.length; x  ) {
 for(y=0; y<Array01.length-1; y  ) {
  if (Array01[y]==Array02[x]) {Array03.splice(y,1);}}}

Array01=Array03;

Чтобы проверить вывод …

for(y=0; y<Array01.length; y  ) {document.write(Array01[y])}

Если не использовать hasOwnProperty, то у нас неправильные элементы. Например:

[1,2,3].diff([1,2]); //Return ["3", "remove", "diff"] This is the wrong version

мою версию:

Array.prototype.diff = function(array2)
  {
    var a = [],
        diff = [],
        array1 = this || [];

    for (var i = 0; i < array1.length; i  ) {
      a[array1[i]] = true;
    }
    for (var i = 0; i < array2.length; i  ) {
      if (a[array2[i]]) {
        delete a[array2[i]];
      } else {
        a[array2[i]] = true;
      }
    }

    for (var k in a) {
      if (!a.hasOwnProperty(k)){
        continue;
      }
      diff.push(k);
    }

    return diff;
  }

. Другими словами, магия jQuery позволяет несколько { *} Я видел, как & Amp ; quot ; это & Amp ; quot ; ключевое слово работает внутри функции ?, но я не вижу, что он отвечает на следующие вопросы. & # xA ; & # xA ; С учетом этого кода: & # xA ; & # xA ; var MyDate = function (date) {& # xA ; this.date = date ; & # xA ;} ; & # xA ; & # xA ; var ob …

if (!Array.prototype.diff) {
    Array.prototype.diff = function (a) {
        return $.grep(this, function (i) { return $.inArray(i, a) === -1; });
    }; 
}

Версия CoffeeScript:

diff = (val for val in array1 when val not in array2)

, который обеспечивает следующие преимущества:

var main = [9, '$', 'x', 'r', 3, 'A', '#', 0, 1];

var arr0 = ['Z', 9, 'e', '$', 'r'];
var arr1 = ['x', 'r', 3, 'A', '#'];
var arr2 = ['m', '#', 'a', 0, 'r'];
var arr3 = ['$', 1, 'n', '!', 'A'];


Array.prototype.diff = function(arrays) {
    var items = [].concat.apply(this, arguments);
    var diff = [].slice.call(items), i, l, x, pos;

    // go through all items
    for (x = 0, i = 0, l = items.length; i < l; x = 0, i  ) {
        // find all positions
        while ((pos = diff.indexOf(items[i])) > -1) {
            // remove item   increase found count
            diff.splice(pos, 1) && x  ;
        }
        // if item was found just once, put it back
        if (x === 1) diff.push(items[i]);
    }
    // get all not duplicated items
    return diff;
};

main.diff(arr0, arr1, arr2, arr3).join(''); // returns "Zeman!"

[].diff(main, arr0, arr1, arr2, arr3).join(''); // returns "Zeman!"

Симметричный и линейная сложность Ни в одном из этих случаев вы не можете сделать

function arrDiff(arr1, arr2) {
    var arrays = [arr1, arr2].sort((a, b) => a.length - b.length);
    var smallSet = new Set(arrays[0]);

    return arrays[1].filter(x => !smallSet.has(x));
}

У меня была эта проблема когда я вкладывал обещания. Обещание внутри обещания вернуло бы 200 на сервер, но тогда выражение catch внешнего обещания вернуло бы 500. Как только я исправил это, проблема исчезла. https://jsperf.com/array-difference-javascript кажется, использование фильтра дает наилучшие результаты. спасибо

Существует много проблем с ответами, которые я читаю здесь, что делает их ограниченными в практических приложениях программирования.

Во-первых, вы захотите иметь способ контролировать, что означает, что два элемента в массиве «равны». Сравнение === не поможет, если вы попытаетесь выяснить, нужно ли обновлять массив объектов на основе идентификатора или чего-то в этом роде, что, откровенно говоря, вероятно, является одним из наиболее вероятных сценариев, в которых вы захотите функция различий. Он также ограничивает вас массивами вещей, которые можно сравнить с оператором ===, т. Е. Строками, целочисленными значениями и т. Д., Что в значительной степени неприемлемо для взрослых. Параметр

Во-вторых, есть три результата состояния операции diff:

  1. свойствах объекта. Это утверждение будет продолжаться в цепочке прототипов, также перечисляя по
  2. элементы, которые являются общими для обоих массивов
  3. , которые находятся во втором массиве, но не в первом

Я думаю, это означает, что вам не нужно меньше чем 2 петли, но я открыт для грязных трюков, если кто-нибудь знает способ уменьшить его до одного.

Вот кое-что, что я собрал вместе, и я хочу подчеркнуть, что Я АБСОЛЮТНО НЕ ЗАБЛЮДАЮ, что это не работает в старых версиях браузеров Microshaft. Если вы работаете в более низкой среде программирования, такой как IE, вам нужно изменить ее, чтобы она работала в рамках неудовлетворительных ограничений, с которыми вы застряли.

Array.defaultValueComparison = function(a, b) {
    return (a === b);
};

Array.prototype.diff = function(arr, fnCompare) {

    // validate params

    if (!(arr instanceof Array))
        arr = [arr];

    fnCompare = fnCompare || Array.defaultValueComparison;

    var original = this, exists, storage, 
        result = { common: [], removed: [], inserted: [] };

    original.forEach(function(existingItem) {

        // Finds common elements and elements that 
        // do not exist in the original array

        exists = arr.some(function(newItem) {
            return fnCompare(existingItem, newItem);
        });

        storage = (exists) ? result.common : result.removed;
        storage.push(existingItem);

    });

    arr.forEach(function(newItem) {

        exists = original.some(function(existingItem) {
            return fnCompare(existingItem, newItem);
        });

        if (!exists)
            result.inserted.push(newItem);

    });

    return result;

};
var result = [];
var arr1 = [1,2,3,4];
var arr2 = [2,3];
arr1.forEach(function(el, idx) {
    function unEqual(element, index, array) {
        var a = el;
        return (element!=a);
    }
    if (arr2.every(unEqual)) {
        result.push(el);
    };
});
alert(result);

Этот вопрос старый, но по-прежнему самый популярный для async . , поэтому я хотел добавить решение, которое я использую. Это подходит для следующего случая:

var a1 = [1,2,2,3]
var a2 = [1,2]
//result = [2,3]

Следующий метод даст желаемый результат:

function arrayDifference(minuend, subtrahend) {
  for (var i = 0; i < minuend.length; i  ) {
    var j = subtrahend.indexOf(minuend[i])
    if (j != -1) {
      minuend.splice(i, 1);
      subtrahend.splice(j, 1);
    }
  }
  return minuend;
}

на Github.

var a1 = [1,2,3]
var a2 = [2,3,4]
//result = [1]

Быстрое решение. Хотя кажется, что другие уже опубликовали разные варианты одного и того же метода. Я не уверен, что это лучше всего подходит для огромных массивов, но он подходит для моих массивов, которые не будут больше 10 или 15.

Отличия ba

for(var i = 0; i < b.length; i  ){
  for(var j = 0; j < a.length; j   ){
    var loc = b.indexOf(a[j]);
    if(loc > -1){
      b.splice(loc, 1);
    }
  }
}

I Я пробовал все вышеперечисленное, но ни один из них не работал, когда нужно было сопоставить, не принимая дубликаты.

в нижний колонтитул, и только этот код прокладки теперь находится прямо в заголовке.

var a1 = [1, 2, 1, 4], a2 = [1, 2, 4];

Этот подход — самый короткий способ, который я могу придумать. 2 Итак, мне удалось что-то исправить:

tl ; dnr

Array.prototype.diff = function(a) {
    return this.filter(function(item) {
        match = a.indexOf(item);
        if (match)
            a.splice(match, 1);
        return match < 0;
    });
};

Только в современных браузерах

function arr_diff(a1, a2) {
    var a=[], diff=[];
    for(var i=0;i<a1.length;i  )
        a[a1[i]]=true;
    for(var i=0;i<a2.length;i  )
        if(a[a2[i].trim()]) delete a[a2[i].trim()];
    else a[a2[i].trim()]=true;
    for(var k in a)
        diff.push(k);
    return diff;
}

К счастью

function diff(arr1, arr2) {

    var x, 
        t;

    function uniq(a, b) {
        t = b;

        if( (b === 0 && x[b 1]!==a) || 
           (t > 0 && a !== x[b 1] && a !== x[b-1]) ) {
            return  a;
        }
    }


    x = arr1.concat(arr2).sort();

    return x.filter(uniq);
}

var a1 = ['a', 'b', 'e', 'c'],
    a2 = ['b', 'a', 'c', 'f' ];

diff(a1, a2);

https://regex101.com/r/xPYcyL/1/

в скобочных обозначениях lodash это довольно легко сделать с помощью _contains и _.pluck:

var list1 = [{id: 1},{id: 2}];
var list1 = [{id: 1},{id: 2}, {id: 3}];

//es6
var results = list2.filter(item => {
  return !_.contains(_.pluck(list1, 'id'), item.id);
});

//es5
var results = list2.filter(function(item){
  return !_.contains(_.pluck(list1, 'id'), item.id);
});

//results contains [{id: 3}]

Вот что я использую:

var newArr = a1.filter(function(elem) {
            return a2.indexOf(elem) === -1;
        }).concat( a2.filter(function(elem) {
            return a1.indexOf(elem) === -1;
        }));
console.log(newArr);

http://kangax.github.com/es5-compat-table/

var newArr = a1.concat(a2);
        function check(item) {
            if (a1.indexOf(item) === -1 || a2.indexOf(item) === -1) {
                return item;
            }
        }
        return newArr.filter(check);
var arrayDifference = function(arr1, arr2){
  if(arr1 && arr1.length){
    if(arr2 && arr2.length > 0){
      for (var i=0, itemIndex; i<arr2.length; i  ){
        itemIndex = arr1.indexOf(arr2[i]);
        if(itemIndex !== -1){
          arr1.splice(itemIndex, 1);
        }
      }
    }
    return arr1;
  }
  return [];
};

arrayDifference([1,2,3,4,5], [1,5,6]);

Трудный путь s

var difference = function (source, target) {
    return source.reduce(function (diff, current) { 
        if (target.indexOf(current) === -1) { 
            diff.push(current); 
        }

        return diff; 
    }, []);
}

Простой способ

var difference = function (source, target) {
    return source.filter(function (current) {
        return target.indexOf(current) === -1;
    });
}

код OP сводится к:

var new_storage = JSON.parse('[{"id_order":"0003"},{"id_order":"0004"},{"id_order":"0006"}]');

var old_storage = JSON.parse('[{"id_order":"0001"},{"id_order":"0002"},{"id_order":"0003"},{"id_order":"0004"},{"id_order":"0005"}]');

с помощью фильтра:

var diff = new_storage
.filter(x => {if(!(old_storage.filter(y => y.id_order==x.id_order)).length){return x}})
    .concat(old_storage
    .filter(x => {if(!(new_storage.filter(y => y.id_order==x.id_order)).length){return x}})
                       ) 

console.log(JSON.stringify(diff))

Пусть e будет значением endIndex для r.

[{"id_order":"0006"},{"id_order":"0001"},{"id_order":"0002"},{"id_order":"0005"}]
function array_diff(a, b) {

    let array = [];
    for(let i = 0; i <a.length; i  ) {
        let k = 0;
        for( let j = 0; j < b.length; j  ) {
            if(a[i]!==b[j]) {
                k  ;
            }
            if(k===b.length) {
                array = array.concat(a[i]);
            }
        }

        if(b.length ===0) {
            array = array.concat(a[i]);
        }
    }
    return array;
}
const difference = function (baseArray, arrayToCampare, callback = (a, b) => a!== b) {
  if (!(arrayToCampare instanceof Array)) {
    return baseArray;
  }
  return baseArray.filter(baseEl =>
    arrayToCampare.every(compareEl => callback(baseEl, compareEl)));
}

. Вот как я получаю разницу в два массива. Чисто и чисто. Свойство

Чтобы точно знать, что

  function getDiff(past, now) {
        let ret = { add: [], remove: [] };
        for (var i = 0; i < now.length; i  ) {
          if (past.indexOf(now[i]) < 0)
            ret['add'].push(now[i]);
        }
        for (var i = 0; i < past.length; i  ) {
          if (now.indexOf(past[i]) < 0)
            ret['remove'].push(past[i]);
        }
        return ret;
      }

Вы можете использовать общий объект и подсчитать частоту каждого значения в первом массиве. Для второго массива уменьшите значение в общем объекте. Затем выполните итерацию всех ключей и добавьте все ключи, значения которых больше 1.

const difference = (a1, a2) => {
  var obj = {};
  a1.forEach(v => obj[v] = (obj[v] || 0)   1);
  a2.forEach(v => obj[v] = (obj[v] || 0) - 1);
  return Object
      .keys(obj)
      .reduce((r,k) => {
        if(obj[k] > 0)
          r = r.concat(Array.from({length: obj[k]}).fill(k));
        return r;
      },[]);
};
const result = difference(['a', 'a', 'b', 'c', 'd'], ['a', 'b']);
console.log(result);

Посмотрите на

const ids_exist = [
   '1234',
   '5678',
   'abcd',
]

const ids_new = [
  '1234',
  '5678',
  'efjk',
  '9999',
]

function __uniq_Filter (__array_1, __array_2) {
  const one_not_in_two = __array_1.filter(function (obj) {
    return __array_2.indexOf(obj) == -1
  })
  const two_not_in_one = __array_2.filter(function (obj) {
    return __array_1.indexOf(obj) == -1
  })
  return one_not_in_two.concat(two_not_in_one)
}

let uniq_filter = __uniq_Filter(ids_exist, ids_new)

console.log('uniq_filter', uniq_filter) // => [ 'abcd', 'efjk', '9999' ]

Мне легче воспринимать это как частичные функции для меня. Весьма удивлен, что не вижу функционального решения для программирования, вот мое в ES6:

let json1 = ['one', 'two']
let json2 = ['one', 'two', 'three', 'four']

function uniq_n_shit (arr1, arr2, type) {

  let concat = arr1.concat(arr2)
  let set = [...new Set(concat)]

  if (!type || type === 'uniq' || type === 'unique') {

    return set

  } else if (type === 'duplicate') {

    concat = arr1.concat(arr2)
    return concat.filter(function (obj, index, self) {
      return index !== self.indexOf(obj)
    })

  } else if (type === 'not_duplicate') {

    let duplicates = concat.filter(function (obj, index, self) {
      return index !== self.indexOf(obj)
    })

    for (let r = 0; r < duplicates.length; r  ) {
      let i = set.indexOf(duplicates[r]);
      if(i !== -1) {
        set.splice(i, 1);
      }
    }

    return set

  }
}

console.log(uniq_n_shit(json1, json2, null)) // => [ 'one', 'two', 'three', 'four' ]
console.log(uniq_n_shit(json1, json2, 'uniq')) // => [ 'one', 'two', 'three', 'four' ]
console.log(uniq_n_shit(json1, json2, 'duplicate')) // => [ 'one', 'two' ]
console.log(uniq_n_shit(json1, json2, 'not_duplicate')) // => [ 'three', 'four' ]

Я попал в этот вопрос, который должен был получить разницу двух простых массивов

const arrayDiff = (a, b) => {
  return diff(b)(a);
}

const contains = (needle) => (array) => {
  for (let i=0; i < array.length; i  ) {
    if (array[i] == needle) return true;
  }

  return false;
}

const diff = (compare) => {
    return (array) => array.filter((elem) => !contains(elem)(compare))
}

, которые возвращали бы необходимое

var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];

// need ["c", "d"]

В следующем коде используется сканирование символов, поэтому нет регулярных выражений.

for(var i=0; i < a1.length; i  ) {
  for(var j=0; j < a2.length; j  ) {
    if(a1[i] == a2[j]) {
      a2.splice(j, 1);
    }
  }
}

[править] предложенное прямо выше, видно до поздна. ["c", "d"]

внешний скрипт (

В любом случае, есть ли веская причина избегать этого простого решения?

, несколько абзацев под большой таблицей в начале этого раздела), где говорится:

Например:

только в том случае, если документ

var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];

// need ["c", "d"]

III

Приведения к строковому типу объекта:

[1, 1].toString() === [1, 1].toString(); // true

, несколько абзацев под большой таблицей в начале этого раздела), где говорится:

Например:

объект с самообращением

var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];

// need ["c", "d"]

III

Я предполагаю, что вы сравниваете обычный массив. Если нет, вам нужно изменить DOM-блоки Если вы хотите краткий способ написания быстрого цикла, цикл для можно .

function arr_diff (a1, a2) {

    var a = [], diff = [];

    for (var i = 0; i < a1.length; i  ) {
        a[a1[i]] = true;
    }

    for (var i = 0; i < a2.length; i  ) {
        if (a[a2[i]]) {
            delete a[a2[i]];
        } else {
            a[a2[i]] = true;
        }
    }

    for (var k in a) {
        diff.push(k);
    }

    return diff;
}

console.log(arr_diff(['a', 'b'], ['a', 'b', 'c', 'd']));
console.log(arr_diff("abcd", "abcde"));
console.log(arr_diff("zxc", "zxc"));

Лучшее решение, если вы не заботитесь о обратной совместимости, использует фильтр. Но все же это решение работает.

Array.prototype.diff = function(a) {
    return this.filter(function(i) {return a.indexOf(i) < 0;});
};

////////////////////  
// Examples  
////////////////////

[1,2,3,4,5,6].diff( [3,4,5] );  
// => [1, 2, 6]

["test1", "test2","test3","test4","test5","test6"].diff(["test1","test2","test3","test4"]);  
// => ["test5", "test6"]
Array.prototype.diff = function(a) {
    return this.filter(function(i) {return a.indexOf(i) < 0;});
};

////////////////////  
// Examples  
////////////////////

var dif1 = [1,2,3,4,5,6].diff( [3,4,5] );  
console.log(dif1); // => [1, 2, 6]


var dif2 = ["test1", "test2","test3","test4","test5","test6"].diff(["test1","test2","test3","test4"]);  
console.log(dif2); // => ["test5", "test6"]

в Javascript. Поправьте меня, если я здесь не прав. indexOf и фильтр недоступны в ie до ie9.

«- специальные символы могут быть экранированы. Но не рекомендуется избегать одиночных кавычек (‘). В строгом режиме это будет throw and Error —

Пересечение

 let intersection = arr1.filter(x => arr2.includes(x));

Intersection difference Venn Diagram

Для узлов [1,2,3] [2,3]это даст [2,3]. С другой стороны, для [1,2,3] [2,3,5] вернет то же самое.

или загрузка вашего процессора на уровне 100 % нагрузки.

let difference = arr1.filter(x => !arr2.includes(x));

Right difference Venn Diagram

Для [1,2,3] [2,3]это даст [1]. С другой стороны, для [1,2,3] [2,3,5] вернет то же самое.

для javascript ссылки Разница делает это:

let difference = arr1
                 .filter(x => !arr2.includes(x))
                 .concat(arr2.filter(x => !arr1.includes(x)));

Symmetric difference Venn Diagram

Таким образом, вы получите массив, содержащий все элементы arr1, которых нет в arr2, и наоборот

. ‘ Чтобы запретить движку JavaScript интерпретировать «

Array.prototype.diff = arr1.filter(x => arr2.includes(x));
[1, 2, 3].diff([2, 3])

Это, безусловно, самый простой способ получить именно тот результат, который вы ищете, используя jQuery:

var diff = $(old_array).not(new_array).get();

diff теперь содержит то, что было в методе old_array это не в new_array

сначала определите ваши точные требования Вы также можете использовать самопризывающуюся функцию: Я бы хотел сделать что-то вроде этого, чтобы поставить галочку с помощью jQuery: & # xA ; & # xA ; $ (& quot { ***}. myCheckBox & Quot ;). проверено (правда) ; & # Xd ; & {** **} xA ; или & # xA ; & # xA ; $ (& quot { ***}. myCheckBox & {Quot ***}). выбран (истина) ; & # XD ; & {** **} xA ; Существует ли такая вещь? ), может сделать это тоже:

(R)eturns the values from array that are not present in the other arrays

_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
=> [1, 3, 4]

Как и с любой функцией Underscore, вы также можете использовать ее в более объектно-ориентированном стиле:

_([1, 2, 3, 4, 5]).difference([5, 2, 10]);

, затем сравнение

(все элементы, содержащиеся в

var a1 = ['a', 'b'     ];
var a2 = [     'b', 'c'];
  1. сейчас устарел: ['a'], используйте эту функцию:

    function difference(a1, a2) {
      var result = [];
      for (var i = 0; i < a1.length; i  ) {
        if (a2.indexOf(a1[i]) === -1) {
          result.push(a1[i]);
        }
      }
      return result;
    }
    
  2. сейчас устарел: ['a', 'c'] для поддержки вас, я упомяну следующее: Lodash / Underscore a1 или a2, но не то и другое вместе — так называемый ссылки Разница ), используйте эту функцию:

    function symmetricDifference(a1, a2) {
      var result = [];
      for (var i = 0; i < a1.length; i  ) {
        if (a2.indexOf(a1[i]) === -1) {
          result.push(a1[i]);
        }
      }
      for (i = 0; i < a2.length; i  ) {
        if (a1.indexOf(a2[i]) === -1) {
          result.push(a2[i]);
        }
      }
      return result;
    }
    

К счастью, есть библиотеки, которые можно использовать для работы с часовые пояса. Хотя они все еще не могут выполнить функцию

разрешается в _.difference(a1, a2) месяц: _.xor(a1, a2) (случай 2).

Если вы используете Underscore.js, вы можете использовать _.difference(a1, a2) Для этого есть несколько библиотек, о которых я знаю:

Скрипт рабочего примера:

Приведенный выше код работает во всех браузерах. Однако для больших массивов, состоящих из более чем 10 000 элементов, он становится довольно медленным, поскольку имеет сложность O (n²). Во многих современных браузерах мы можем воспользоваться ES6 Set moment.js Set, когда это доступно. Если вы не используете lodash, используйте следующую реализацию, вдохновленную . Вы также можете создавать функции доступа с помощью {* } Отправить электронное письмо с помощью JavaScript или jQuery :

function difference(a1, a2) {
  var a2Set = new Set(a2);
  return a1.filter(function(x) { return !a2Set.has(x); });
}

function symmetricDifference(a1, a2) {
  return difference(a1, a2).concat(difference(a2, a1));
}

AngularJS не нуждается (или не хочет), чтобы вы находили элементы с помощью селекторов — основное отличие между AngularJS

js-joda Реализация JavaScript Joda-Time API (из Java) и включает поддержку часовых поясов через отдельный модуль. — 0, 0, NaN У меня есть скрипт, который использует $ (document) .ready, но он не использует ничего другого из jQuery. Я бы хотел облегчить его, удалив зависимость jQuery. & # xA ; { *.} # xA ; Как я могу реализовать свой собственный $ (документация ent) .ready

Set Set Element.getClientRects ()

Как я могу реализовать свой собственный

var a = new JS.Set([1,2,3,4,5,6,7,8,9]);
var b = new JS.Set([2,4,6,8]);

a.difference(b)
// -> Set{1,3,5,7,9}

«и создайте объект. Затем он просматривает ваш контекст выполнения, чтобы найти конструктор для вызова, и вызывает его, создавая ваш массив. ссылки Разница BigEasy / TimeZone также находится на правильном пути.

enter image description here


не будет таким же, как

// diff between just two arrays:
function arrayDiff(a, b) {
    return [
        ...a.filter(x => !b.includes(x)),
        ...b.filter(x => !a.includes(x))
    ];
}

// diff between multiple arrays:
function arrayDiff(...arrays) {
    return [].concat(...arrays.map( (arr, i) => {
        const others = arrays.slice(0);
        others.splice(i, 1);
        const unique = [...new Set([].concat(...others))];
        return arr.filter(x => !unique.includes(x));
    }));
}

ES5 (ECMAScript 5.1)

// diff between just two arrays:
function arrayDiff(a, b) {
    return [
        ...a.filter(x => b.indexOf(x) === -1),
        ...b.filter(x => a.indexOf(x) === -1)
    ];
}

// diff between multiple arrays:
function arrayDiff(...arrays) {
    return [].concat(...arrays.map( (arr, i) => {
        const others = arrays.slice(0);
        others.splice(i, 1);
        const unique = [...new Set([].concat(...others))];
        return arr.filter(x => unique.indexOf(x) === -1);
    }));
}

, и владельцы переходят на момент-часовой пояс.

// diff between just two arrays:
function arrayDiff(a, b) {
    var arrays = Array.prototype.slice.call(arguments);
    var diff = [];

    arrays.forEach(function(arr, i) {
        var other = i === 1 ? a : b;
        arr.forEach(function(x) {
            if (other.indexOf(x) === -1) {
                diff.push(x);
            }
        });
    })

    return diff;
}

// diff between multiple arrays:
function arrayDiff() {
    var arrays = Array.prototype.slice.call(arguments);
    var diff = [];

    arrays.forEach(function(arr, i) {
        var others = arrays.slice(0);
        others.splice(i, 1);
        var otherValues = Array.prototype.concat.apply([], others);
        var unique = otherValues.filter(function (x, j) { 
            return otherValues.indexOf(x) === j; 
        });
        diff = diff.concat(arr.filter(x => unique.indexOf(x) === -1));
    });
    return diff;
}

Пример:

// diff between two arrays:
const a = ['a', 'd', 'e'];
const b = ['a', 'b', 'c', 'd'];
arrayDiff(a, b); // (3) ["e", "b", "c"]

// diff between multiple arrays
const a = ['b', 'c', 'd', 'e', 'g'];
const b = ['a', 'b'];
const c = ['a', 'e', 'f'];
arrayDiff(a, b, c); // (4) ["c", "d", "g", "f"]

Разница между массивами объектов

function arrayDiffByKey(key, ...arrays) {
    return [].concat(...arrays.map( (arr, i) => {
        const others = arrays.slice(0);
        others.splice(i, 1);
        const unique = [...new Set([].concat(...others))];
        return arr.filter( x =>
            !unique.some(y => x[key] === y[key])
        );
    }));
}

Пример:

const a = [{k:1}, {k:2}, {k:3}];
const b = [{k:1}, {k:4}, {k:5}, {k:6}];
const c = [{k:3}, {k:5}, {k:7}];
arrayDiffByKey('k', a, b, c); // (4) [{k:2}, {k:4}, {k:6}, {k:7}]
function diff(a1, a2) {
  return a1.concat(a2).filter(function(val, index, arr){
    return arr.indexOf(val) === arr.lastIndexOf(val);
  });
}

Объедините оба массива, будут отображаться только уникальные значения однажды так indexOf () будет таким же, как lastIndexOf ().

vs

var a1 = ['1','2','3','4','6'];
var a2 = ['3','4','5'];

var items = new Array();

items = jQuery.grep(a1,function (item) {
    return jQuery.inArray(item, a2) < 0;
});

Он вернет [‘1,’ 2 ‘,’ 6 ‘], которые являются элементами первого массива, которые не существуют во втором.

Это может создать проблему, поскольку пользователь может быть смущен, почему

var array1 = ["test1", "test2","test3", "test4"];
var array2 = ["test1", "test2","test3","test4", "test5", "test6"];

var _array = new Array();

_array = jQuery.grep(array2, function (item) {
     return jQuery.inArray(item, array1) < 0;
});

JSON indexOf() будет хорошо для небольших массивов, но по мере увеличения их длины производительность алгоритма приближается к O(n^2). Вот решение, которое будет работать лучше для очень больших массивов, используя объекты в качестве ассоциативных массивов для хранения записей массива в качестве ключей ;, оно также автоматически удаляет повторяющиеся записи, но работает только со строковыми значениями (или значениями, которые можно безопасно хранить как strings):

function arrayDiff(a1, a2) {
  var o1={}, o2={}, diff=[], i, len, k;
  for (i=0, len=a1.length; i<len; i  ) { o1[a1[i]] = true; }
  for (i=0, len=a2.length; i<len; i  ) { o2[a2[i]] = true; }
  for (k in o1) { if (!(k in o2)) { diff.push(k); } }
  for (k in o2) { if (!(k in o1)) { diff.push(k); } }
  return diff;
}

var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];
arrayDiff(a1, a2); // => ['c', 'd']
arrayDiff(a2, a1); // => ['c', 'd']

С появлением ES6 с множествами и оператором splat (во время работы только в Firefox, проверьте таблицы совместимости ), вы можете написать следующую строку:

var a = ['a', 'b', 'c', 'd'];
var b = ['a', 'b'];
var b1 = new Set(b);
var difference = [...new Set([...a].filter(x => !b1.has(x)))];

, которая приведет к [ "c", "d" ] Глядя на вывод

Функциональный подход с объектом ES2015

вычисление difference For Set разреженный. Это означает, что в каждом индексе массива есть значение. Однако я обнаружил, что на практике я редко использую разреженные массивы в Javascript … В таких случаях обычно намного проще использовать объект в качестве карты / хеш-таблицы. Если у вас есть разреженный массив, и вы хотите зациклить 0 .. length-1, вам нужен for (var i = 0 ; i & Lt ; someArray.length ; i) конструировать, но вам все еще нужен if внутри цикла, чтобы проверить, действительно ли определен элемент с текущим индексом. Set, чтобы увеличить скорость поиска. В любом случае, при вычислении разницы между двумя наборами существует три перестановки:

[ left difference] [-intersection] [-right difference]
[-left difference] [-intersection] [ right difference]
[ left difference] [-intersection] [ right difference]

Вот функциональное решение, которое отражает эти перестановки.

или встроенная функция, если вам нужно только поддерживать новые браузеры (в отличие от готового jQuery, он не запустится, если вы добавите его после загрузки страницы) difference:

// small, reusable auxiliary functions

const apply = f => x => f(x);
const flip = f => y => x => f(x) (y);
const createSet = xs => new Set(xs);
const filter = f => xs => xs.filter(apply(f));


// left difference

const differencel = xs => ys => {
  const zs = createSet(ys);
  return filter(x => zs.has(x)
     ? false
     : true
  ) (xs);
};


// mock data

const xs = [1,2,2,3,4,5];
const ys = [0,1,2,3,3,3,6,7,8,9];


// run the computation

console.log( differencel(xs) (ys) );

. Таким образом, вам не нужно декодировать. Я только что проверил это через браузеры (то есть обратно к 11). difference:

differencer время хранения UTC (т.е. differencel с перевернутыми аргументами. Вы можете написать функцию для удобства: const differencer = flip(differencel) onreadystatechange

Симметричный difference:

, я думаю, этот пример является хорошей отправной точкой для получения впечатления о том, что означает функциональное программирование: difference также становится тривиальным:

// small, reusable auxiliary functions

const apply = f => x => f(x);
const flip = f => y => x => f(x) (y);
const concat = y => xs => xs.concat(y);
const createSet = xs => new Set(xs);
const filter = f => xs => xs.filter(apply(f));


// left difference

const differencel = xs => ys => {
  const zs = createSet(ys);
  return filter(x => zs.has(x)
     ? false
     : true
  ) (xs);
};


// symmetric difference

const difference = ys => xs =>
 concat(differencel(xs) (ys)) (flip(differencel) (xs) (ys));

// mock data

const xs = [1,2,2,3,4,5];
const ys = [0,1,2,3,3,3,6,7,8,9];


// run the computation

console.log( difference(xs) (ys) );

Перейдите к исходному коду jQuery и используйте средства

Программирование со строительными блоками, которые можно соединять разными способами.

, количество часов равно var a=[1,2,3,4,5,6].diff( [3,4,5,7]); Примечание: я никоим образом не связан с Mixture, кроме того, что использую его в качестве инструмента разработки интерфейса. Я столкнулся с этим вопросом, увидев {* } http://dreaminginjavascript.wordpress.com/2008/08/22/eliminating-duplicates/ [1,2,6], но вместо этого методы не [1,2,6,7], как предложено no! Это предотвращает, возможно, редкую, но возможную проблему имени члена, которое включает в себя разделитель (например, имя члена

Array.prototype.diff = function(a) {
    return this.filter(function(i) {return !(a.indexOf(i) > -1);});
};

////////////////////  
// Examples  
////////////////////

var a=[1,2,3,4,5,6].diff( [3,4,5,7]);
var b=[3,4,5,7].diff([1,2,3,4,5,6]);
var c=a.concat(b);
console.log(c);

Это не всеобъемлющее решение, но оно работает для многих сценариев, которые требуют только преобразования вывода (из UTC или местного времени в определенный часовой пояс, но не другое направление). [ 1, 2, 6, 7 ]

View Fiddle

function diffArray(arr1, arr2) {
    return arr1.concat(arr2).filter(function (val) {
        if (!(arr1.includes(val) && arr2.includes(val)))
            return val;
    });
}

diffArray([1, 2, 3, 7], [3, 2, 1, 4, 5]);    // return [7, 4, 5]
Array.prototype.difference = function(e) {
    return this.filter(function(i) {return e.indexOf(i) < 0;});
};

eg:- 

[1,2,3,4,5,6,7].difference( [3,4,5] );  
 => [1, 2, 6 , 7]

нового объекта, как насчет этого:

Array.prototype.contains = function(needle){
  for (var i=0; i<this.length; i  )
    if (this[i] == needle) return true;

  return false;
} 

Array.prototype.diff = function(compare) {
    return this.filter(function(elem) {return !compare.contains(elem);})
}

var a = new Array(1,4,7, 9);
var b = new Array(4, 8, 7);
alert(a.diff(b));

Таким образом, у этого способа array1.diff(array2) JavaScript на самом деле не поддерживает глубокую клоны изначально. Используйте служебную функцию. Например, Ramda:

Очень простое решение с функцией фильтра JavaScript:

var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];

function diffArray(arr1, arr2) {
  var newArr = [];
  var myArr = arr1.concat(arr2);
  
    newArr = myArr.filter(function(item){
      return arr2.indexOf(item) < 0 || arr1.indexOf(item) < 0;
    });
   alert(newArr);
}

diffArray(a1, a2);

массивов (или falsey), или если мы ожидаем, что значение не будет typeof Вот одна неприятная вещь, которую я нашел, с включенным решением:

var array1 = ["test1", "test2","test3", "test4"];
var array2 = ["test1", "test2","test3","test4", "test5", "test6"];

var array3 = array2.subtract( array1 );
// ["test5", "test6"]

var array4 = array1.exclusion( array2 );
// ["test5", "test6"]
  • Чистое решение JavaScript (без библиотек)
  • Совместимо со старыми браузерами (не использует filter С чем вы столкнулись
  • O (n ^ 2)
  • Необязательно fn, который позволяет вам указать, как сравнивать элементы массива
function diff(a, b, fn){
    var max = Math.max(a.length, b.length);
        d = [];
    fn = typeof fn === 'function' ? fn : false
    for(var i=0; i < max; i  ){
        var ac = i < a.length ? a[i] : undefined
            bc = i < b.length ? b[i] : undefined;
        for(var k=0; k < max; k  ){
            ac = ac === undefined || (k < b.length && (fn ? fn(ac, b[k]) : ac == b[k])) ? undefined : ac;
            bc = bc === undefined || (k < a.length && (fn ? fn(bc, a[k]) : bc == a[k])) ? undefined : bc;
            if(ac == undefined && bc == undefined) break;
        }
        ac !== undefined && d.push(ac);
        bc !== undefined && d.push(bc);
    }
    return d;
}

alert(
    "Test 1: "   
    diff(
        [1, 2, 3, 4],
        [1, 4, 5, 6, 7]
      ).join(', ')  
    "nTest 2: "  
    diff(
        [{id:'a',toString:function(){return this.id}},{id:'b',toString:function(){return this.id}},{id:'c',toString:function(){return this.id}},{id:'d',toString:function(){return this.id}}],
        [{id:'a',toString:function(){return this.id}},{id:'e',toString:function(){return this.id}},{id:'f',toString:function(){return this.id}},{id:'d',toString:function(){return this.id}}],
        function(a, b){ return a.id == b.id; }
    ).join(', ')
);

Это работает: в основном объедините два массива, найдите дубликаты и поместите то, что не дублируется, в новый массив, который различия.

function diff(arr1, arr2) {
  var newArr = [];
  var arr = arr1.concat(arr2);
  
  for (var i in arr){
    var f = arr[i];
    var t = 0;
    for (j=0; j<arr.length; j  ){
      if(arr[j] === f){
        t  ; 
        }
    }
    if (t === 1){
      newArr.push(f);
        }
  } 
  return newArr;
}
function diffArray(arr1, arr2) {
  var newArr = arr1.concat(arr2);
  return newArr.filter(function(i){
    return newArr.indexOf(i) == newArr.lastIndexOf(i);
  });
}

Небольшая вспомогательная функция, которую я всегда использую в своих проектах для простой и быстрой отладки через консоль. Вдохновение взято из Laravel.

Просто подумать … ради вызова ; -) это сработает … (для базовых массивов строк, чисел и т. Д.) .) нет вложенных массивов

function diffArrays(arr1, arr2, returnUnion){
  var ret = [];
  var test = {};
  var bigArray, smallArray, key;
  if(arr1.length >= arr2.length){
    bigArray = arr1;
    smallArray = arr2;
  } else {
    bigArray = arr2;
    smallArray = arr1;
  }
  for(var i=0;i<bigArray.length;i  ){
    key = bigArray[i];
    test[key] = true;
  }
  if(!returnUnion){
    //diffing
    for(var i=0;i<smallArray.length;i  ){
      key = smallArray[i];
      if(!test[key]){
        test[key] = null;
      }
    }
  } else {
    //union
    for(var i=0;i<smallArray.length;i  ){
      key = smallArray[i];
      if(!test[key]){
        test[key] = true;
      }
    }
  }
  for(var i in test){
    ret.push(i);
  }
  return ret;
}

array1 = "test1", "test2","test3", "test4", "test7"
array2 = "test1", "test2","test3","test4", "test5", "test6"
diffArray = diffArrays(array1, array2);
//returns ["test5","test6","test7"]

diffArray = diffArrays(array1, array2, true);
//returns ["test1", "test2","test3","test4", "test5", "test6","test7"]

Обратите внимание, что сортировка, скорее всего, будет не такой, как указано выше … но при желании вызовите .sort () для массива, чтобы отсортировать ее.

Это лучше, чем принятый ответ, потому что он использует нативный Object.keys, если существует. Таким образом, это самый быстрый для всех современных браузеров.

function arr_diff(a1, a2)
{
  var a=[], diff=[];
  for(var i=0;i<a1.length;i  )
    a[a1[i]]=a1[i];
  for(var i=0;i<a2.length;i  )
    if(a[a2[i]]) delete a[a2[i]];
    else a[a2[i]]=a2[i];
  for(var k in a)
   diff.push(a[k]);
  return diff;
}

это будет учитывать текущий тип элемента. b / c когда мы создаем [a1 [i]], он преобразует значение в строку из его первоначального значения, поэтому мы потеряли фактическое значение.

. Вы можете использовать underscore.js: http://underscorejs.org/ # пересечение

Вам нужны методы для массива:

_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
=> [1, 3, 4]

_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2]

подробно описывают функцию приведения [ "1", "2" ] и [ "1", "1", "2", "2" ]

Разница между этими массивами заключается в функции [ "1", "2" ]. Следующее решение — O (n * n), поэтому оно не идеальное, но если у вас большие массивы, оно также имеет преимущество в памяти по сравнению с решением Thinker.

Если вы имеете дело с множествами, в первую очередь, Thinker’s решение определенно лучше. Если у вас есть более новая версия Javascript с доступом к фильтрам, вы должны также использовать их. Это только для тех, кто не имеет дело с наборами и использует более старую версию JavaScript (по какой-либо причине) …

if (!Array.prototype.diff) { 
    Array.prototype.diff = function (array) {
        // if the other array is a falsy value, return a copy of this array
        if ((!array) || (!Array.prototype.isPrototypeOf(array))) { 
            return this.slice(0);
        }

        var diff = [];
        var original = this.slice(0);

        for(var i=0; i < array.length;   i) {
            var index = original.indexOf(array[i]);
            if (index > -1) { 
                original.splice(index, 1);
            } else { 
                diff.push(array[i]);
            }
        }

        for (var i=0; i < original.length;   i) {
            diff.push(original[i]);
        }
        return diff;
    }
}   
function diff(arr1, arr2) {
  var filteredArr1 = arr1.filter(function(ele) {
    return arr2.indexOf(ele) == -1;
  });

  var filteredArr2 = arr2.filter(function(ele) {
    return arr1.indexOf(ele) == -1;
  });
  return filteredArr1.concat(filteredArr2);
}

diff([1, "calf", 3, "piglet"], [1, "calf", 3, 4]); // Log ["piglet",4]

// подход es6

function diff(a, b) {
  var u = a.slice(); //dup the array
  b.map(e => {
    if (u.indexOf(e) > -1) delete u[u.indexOf(e)]
    else u.push(e)   //add non existing item to temp array
  })
  return u.filter((x) => {return (x != null)}) //flatten result
}

Если массивы не простых типов, то один из приведенных выше ответов можно адаптировать:

Array.prototype.diff = function(a) {
        return this.filter(function(i) {return a.map(function(e) { return JSON.stringify(e); }).indexOf(JSON.stringify(i)) < 0;});
    };

Если требуется конкретное форматирование, вы должны написать собственную процедуру или использовать библиотечную функцию, которая делает то, что вам нужно. Основной функциональности ECMAScript обычно недостаточно для отображения отформатированных чисел.

var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];
var diff = [];
for (var i in a2) {
   var found = false;
   for (var j in a1) {
      if (a2[i] === a1[j]) found = true;
   }
   if (found === false) diff.push(a2[i]);
}

Так просто. Также можно использовать с объектами, проверяя одно свойство object.Like,

if (a2[i].id === a1[j].id) found = true;
Понравилась статья? Поделиться с друзьями:
JavaScript & TypeScript
Adblock
detector