Как объединить два массива в JavaScript и удалить дубликаты элементов

У меня есть два массива JavaScript:

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];

Я хочу, чтобы вывод был:

var array3 = ["Vijendra","Singh","Shakya"];

В выходном массиве удалить повторяющиеся слова.

Как объединить два массива в JavaScript, чтобы я получал только уникальные элементы из каждого массива в том же порядке, в котором они были вставлены в оригинальные массивы?

Чтобы просто объединить массивы (без удаления дубликатов)

Версия ES5 использует элемент Array.concat:

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];

var array3 = array1.concat(array2); // Merges both arrays
// [ 'Vijendra', 'Singh', 'Singh', 'Shakya' ]
const array1 = ["Vijendra","Singh"];
const array2 = ["Singh", "Shakya"];
const array3 = [...array1, ...array2];

Поскольку не существует встроенного способа удаления дубликатов (на самом деле ECMA-262 имеет Array.forEach, что было бы неплохо для этого), мы должны сделать это вручную:

Array.prototype.unique = function() {
    var a = this.concat();
    for(var i=0; i<a.length;   i) {
        for(var j=i 1; j<a.length;   j) {
            if(a[i] === a[j])
                a.splice(j--, 1);
        }
    }

    return a;
};

Затем, чтобы использовать его:

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];
// Merges both arrays and gets unique items
var array3 = array1.concat(array2).unique(); 

Это также сохранит порядок массивов (т. Е. Сортировка не требуется).

Так как многих раздражает увеличение прототипа Array.prototype и for in Этот метод предназначен для

function arrayUnique(array) {
    var a = array.concat();
    for(var i=0; i<a.length;   i) {
        for(var j=i 1; j<a.length;   j) {
            if(a[i] === a[j])
                a.splice(j--, 1);
        }
    }

    return a;
}

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];
    // Merges both arrays and gets unique items
var array3 = arrayUnique(array1.concat(array2));

Для тех, кому посчастливилось работать с браузерами, в которых доступен ES5, вы можете использовать Object.definePropertyнапример:

Object.defineProperty(Array.prototype, 'unique', {
    enumerable: false,
    configurable: false,
    writable: false,
    value: function() {
        var a = this.concat();
        for(var i=0; i<a.length;   i) {
            for(var j=i 1; j<a.length;   j) {
                if(a[i] === a[j])
                    a.splice(j--, 1);
            }
        }

        return a;
    }
});

Вот решение, вдохновленное

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

Смотрите также

http://lodash.com/docs # union

Сначала объедините два массива, а затем — фильтр выходят только уникальные предметы.

var a = [1, 2, 3], b = [101, 2, 1, 10];
var c = a.concat(b);
var d = c.filter(function (item, pos) {return c.indexOf(item) == pos});

// d is [1,2,3,101,10]

. Я не уверен, что это все еще актуально сегодня, но при работе со старыми стандартами браузеров / JavaScript (ecmascript 5, javascript & Lt ; 1.8.5 ~ firefox 4), переменная global-scope {* } Хост-объекты могут реализовывать эти внутренние методы любым способом, если не указано иное, например, ;, одна из возможностей —

Редактировать

Как предложено @Dmitry (см. Второй комментарий ниже), более разумным решением было бы отфильтровать уникальные элементы в b перед конкатенацией с a

var a = [1, 2, 3], b = [101, 2, 1, 10];
var c = a.concat(b.filter(function (item) {
    return a.indexOf(item) < 0;
}));

// d is [1,2,3,101,10]

. Это решение ECMAScript 6, использующее оператором распространения и универсальные шаблоны.

В настоящее время он работает только с Firefox и, возможно, с Internet Explorer Technical Preview.

В зависимости от типа (ов) возвращаемых значений, ошибки часто можно легко различить (например, используйте Babel , ты можешь получить это сейчас.

// Input: [ [1, 2, 3], [101, 2, 1, 10], [2, 1] ]
// Output: [1, 2, 3, 101, 10]
function mergeDedupe(arr)
{
  return [...new Set([].concat(...arr))];
}
array1.push(...array2) // => don't remove duplication 

или

[...array1,...array2] //   =>  don't remove duplication 

или

[...new Set([...array1 ,...array2])]; //   => remove duplication

Использование Установить (ECMAScript 2015), это будет так просто:

const array1 = ["Vijendra", "Singh"];
const array2 = ["Singh", "Shakya"];
const array3 = Array.from(new Set(array1.concat(array2)));

Вот немного другой взгляд на петлю. С некоторыми из оптимизаций в последней версии Chrome, это самый быстрый метод для разрешения объединения двух массивов (Chrome 38.0.2111).

что также решает эту проблему.

var array1 = ["Vijendra", "Singh"];
var array2 = ["Singh", "Shakya"];
var array3 = [];

var arr = array1.concat(array2),
  len = arr.length;

while (len--) {
  var itm = arr[len];
  if (array3.indexOf(itm) === -1) {
    array3.unshift(itm);
  }
}

. Однако, если вы хотите использовать синтаксис, в котором код «разделен на середину» объектом
Я удивлен, что никто еще не предложил это: { *} Во всех примерах в W3Schools открываются файлы XML, расположенные в домене W3Schools.
lodash: 308k ops / s
для циклов: 225k ops / s

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

http://jsperf.com/merge-two-arrays-keeping-only-unique-values/52

let whileLoopAlt = function (array1, array2) {
    const array3 = array1.slice(0);
    let len1 = array1.length;
    let len2 = array2.length;
    const assoc = {};

    while (len1--) {
        assoc[array1[len1]] = null;
    }

    while (len2--) {
        let itm = array2[len2];

        if (assoc[itm] === undefined) { // Eliminate the indexOf call
            array3.push(itm);
            assoc[itm] = null;
        }
    }

    return array3;
};

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

Главный ответ здесь с двойным циклом для каждого значения (i-1): все еще значительно медленнее. У lodash все еще хорошо, и я бы порекомендовал его всем, кто не против добавить библиотеку в свой проект. Для тех, кто не хочет этого, мой цикл while все еще является хорошим ответом, и ответ фильтра очень ярко демонстрирует здесь, опередив все мои тесты последней версией Canary Chrome (44.0.2360) на момент написания этой статьи.

Ознакомьтесь с Ответ Майка и Ответ Дана Стокера Следовательно, лучшее решение — это включить

Вы можете сделать это просто с помощью ECMAScript 6,

var array1 = ["Vijendra", "Singh"];
var array2 = ["Singh", "Shakya"];
var array3 = [...new Set([...array1 ,...array2])];
console.log(array3); // ["Vijendra", "Singh", "Shakya"];
  • Используйте оператор распространения для объединения массива.
  • Использование Установить для создания отдельного набора элементов.
  • Снова используйте оператор распространения, чтобы преобразовать множество в массив.

объединить два массива и удалить дубликат в es6

let arr1 = [3, 5, 2, 2, 5, 5];
let arr2 = [2, 1, 66, 5];
let unique = [...new Set([...arr1,...arr2])];
console.log(unique);
// [ 3, 5, 2, 1, 66 ]
Array.prototype.merge = function(/* variable number of arrays */){
    for(var i = 0; i < arguments.length; i  ){
        var array = arguments[i];
        for(var j = 0; j < array.length; j  ){
            if(this.indexOf(array[j]) === -1) {
                this.push(array[j]);
            }
        }
    }
    return this;
};

Гораздо лучшая функция слияния массивов.

Просто держитесь подальше от вложенных циклов (O (n ^ 2)) и .indexOf() (O (n)).

function merge(a, b) {
    var hash = {}, i;
    for (i=0; i<a.length; i  ) {
        hash[a[i]]=true;
    } 
    for (i=0; i<b.length; i  ) {
        hash[b[i]]=true;
    } 
    return Object.keys(hash);
}

Просто добавляю мои два цента.

function mergeStringArrays(a, b){
    var hash = {};
    var ret = [];

    for(var i=0; i < a.length; i  ){
        var e = a[i];
        if (!hash[e]){
            hash[e] = true;
            ret.push(e);
        }
    }

    for(var i=0; i < b.length; i  ){
        var e = b[i];
        if (!hash[e]){
            hash[e] = true;
            ret.push(e);
        }
    }

    return ret;
}

Этот метод я часто использую, он использует объект в качестве таблицы hashlookup для проверки дубликатов. Если предположить, что хеш равен O (1), то он выполняется в O (n), где n — длина, длина. Честно говоря, я понятия не имею, как браузер выполняет хэширование, но он хорошо работает на многих тысячах точек данных.

Почему вы не используете объект? Похоже, вы пытаетесь смоделировать набор. Однако это не сохранит порядок.

var set1 = {"Vijendra":true, "Singh":true}
var set2 = {"Singh":true,  "Shakya":true}

// Merge second object into first
function merge(set1, set2){
  for (var key in set2){
    if (set2.hasOwnProperty(key))
      set1[key] = set2[key]
  }
  return set1
}

merge(set1, set2)

// Create set from array
function setify(array){
  var result = {}
  for (var item in array){
    if (array.hasOwnProperty(item))
      result[array[item]] = true
  }
  return result
}

решения для объединения на основе ES6

let arr1 = [1,2,3,4,5];
let arr2 = [3,4,5,6];
let result = [...new Set([...arr1, ...arr2])];
console.log(result);

Моя полторы копейки:

Array.prototype.concat_n_dedupe = function(other_array) {
  return this
    .concat(other_array) // add second
    .reduce(function(uniques, item) { // dedupe all
      if (uniques.indexOf(item) == -1) {
        uniques.push(item);
      }
      return uniques;
    }, []);
};

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];

var result = array1.concat_n_dedupe(array2);

console.log(result);

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

function mergeUnique(arr1, arr2){
    return arr1.concat(arr2.filter(function (item) {
        return arr1.indexOf(item) === -1;
    }));
}

Лучшее решение .. .

Вы можете проверить прямо в консоли браузера, нажав …

Без дублированного разрешения

a = [1, 2, 3];
b = [3, 2, 1, "prince"];

a.concat(b.filter(function(el) {
    return a.indexOf(el) === -1;
}));

С дублирующим

["prince", "asish", 5].concat(["ravi", 4])

JavaScript: кодом крика Глядя на вывод

[1, 2, 3].concat([3, 2, 1, "prince"].filter(function(el) {
    return [1, 2, 3].indexOf(el) === -1;
}));

javascript — Почему RegExp с глобальным флагом дает неверные результаты?

 f12 > console

Короче говоря, это

["prince", "asish", 5, "ravi", 4]

[1, 2, 3, "prince"]

Единственный недостаток: удаление HREF удаляет tabindex. Чтобы преодолеть это, вы можете использовать кнопку, которая стилизована как ссылка или добавить атрибут tabindex, используя JS. uniq :

array3 = _.uniq(array1.concat(array2))

console.log(array3)

It будет печатать [«Vijendra», «Singh», «Shakya»] Глядя на вывод

//Array.indexOf was introduced in javascript 1.6 (ECMA-262) 
//We need to implement it explicitly for other browsers, 
if (!Array.prototype.indexOf)
{
  Array.prototype.indexOf = function(elt, from)
  {
    var len = this.length >>> 0;

    for (; from < len; from  )
    {
      if (from in this &&
          this[from] === elt)
        return from;
    }
    return -1;
  };
}
//now, on to the problem

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];

var merged = array1.concat(array2);
var t;
for(i = 0; i < merged.length; i  )
  if((t = merged.indexOf(i   1, merged[i])) != -1)
  {
    merged.splice(t, 1);
    i--;//in case of multiple occurrences
  }

Реализация indexOf метод для других браузеров взят из Только база данных может надежно проверять данные, которые зависят от связанных данных.

Если данные JSON

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];

var array3 = array1.concat(array2);
var tempSet = new Set(array3);
array3 = Array.from(tempSet);

//show output
document.body.querySelector("div").innerHTML = JSON.stringify(array3);
<div style="width:100%;height:4rem;line-height:4rem;background-color:steelblue;color:#DDD;text-align:center;font-family:Calibri" > 
  temp text 
</div>

Новое решение (которое использует Array.prototype.indexOf и Array.prototype.concat):

Array.prototype.uniqueMerge = function( a ) {
    for ( var nonDuplicates = [], i = 0, l = a.length; i<l;   i ) {
        if ( this.indexOf( a[i] ) === -1 ) {
            nonDuplicates.push( a[i] );
        }
    }
    return this.concat( nonDuplicates )
};

Использование:

>>> ['Vijendra', 'Singh'].uniqueMerge(['Singh', 'Shakya'])
["Vijendra", "Singh", "Shakya"]

Array.prototype.indexOf (для интернет-обозревателя):

Array.prototype.indexOf = Array.prototype.indexOf || function(elt)
  {
    var len = this.length >>> 0;

    var from = Number(arguments[1]) || 0;
    from = (from < 0) ? Math.ceil(from): Math.floor(from); 
    if (from < 0)from  = len;

    for (; from < len; from  )
    {
      if (from in this && this[from] === elt)return from;
    }
    return -1;
  };
Array.prototype.add = function(b){
    var a = this.concat();                // clone current object
    if(!b.push || !b.length) return a;    // if b is not an array, or empty, then return a unchanged
    if(!a.length) return b.concat();      // if original is empty, return b

    // go through all the elements of b
    for(var i = 0; i < b.length; i  ){
        // if b's value is not in a, then add it
        if(a.indexOf(b[i]) == -1) a.push(b[i]);
    }
    return a;
}

// Example:
console.log([1,2,3].add([3, 4, 5])); // will output [1, 2, 3, 4, 5]
array1.concat(array2).filter((value, pos, arr)=>arr.indexOf(value)===pos)

Хорошая вещь об этом производительность и то, что вы вообще, при работе с массивами, используете методы цепочки, такие как filter, map и т. д., так что вы можете добавить эту строку, и она будет объединять и дедуплицировать array2 с array1 без необходимости ссылаться на более позднюю (когда вы используете методы chaining у вас нет), пример:

someSource()
.reduce(...)
.filter(...)
.map(...) 
// and now you want to concat array2 and deduplicate:
.concat(array2).filter((value, pos, arr)=>arr.indexOf(value)===pos)
// and keep chaining stuff
.map(...)
.find(...)
// etc

(я не люблю загрязнять Array.prototype, и это был бы единственный способ уважать цепочку — определение новой функции порвет ее — так что я думаю кое-что как будто это единственный способ сделать это)

Для ES6 только одна строка:

a = [1, 2, 3, 4]
b = [4, 5]
[...new Set(a.concat(b))]  // [1, 2, 3, 4, 5]
  • Современный способ достичь этого — просто использовать оператор распространения Глядя на вывод
  • Как мне преобразовать строку в целое число в JavaScript? Sets ; Наборы не допускают дублирования по умолчанию Глядя на вывод
  • . Рассматривая преимущества и недостатки обоих, мы можем сделать расчетное предположение относительно того, что подходит для данной ситуации. Это два основных подхода к выполнению обещаний. У обоих есть свои плюсы и минусы Array.from ()

Итак, вот демонстрация для вашего сценария —

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];
var resArr = Array.from(new Set([...array1, ...array2]));
console.log(resArr);

ради этого … вот решение одной строкой:

const x = [...new Set([['C', 'B'],['B', 'A']].reduce( (a, e) => a.concat(e), []))].sort()
// ['A', 'B', 'C']

Не особенно читабельно, но это может кому-то помочь:

  1. На мой взгляд, лучший способ — использовать функцию Array.forEach. Если вы не можете использовать это, я бы Предлагаем получить полифилл из MDN, чтобы сделать его доступным, это, безусловно, самый безопасный способ перебора массива в JavaScript.
  2. Функция Reduce использует concat для добавления каждого подмассива в массив аккумулятора.
  3. Результат этого передается как параметр конструктора для создания нового Set Глядя на вывод
  4. , которое скрывает / скрывает родительское свойство области с тем же именем. Это, вероятно, не то, что вы хотите / ожидаете. Set в массив.
  5. Переменная sort() функция применяется к новому массиву.
var arr1 = [1, 3, 5, 6];
var arr2 = [3, 6, 10, 11, 12];
arr1.concat(arr2.filter(ele => !arr1.includes(ele)));
console.log(arr1);

output :- [1, 3, 5, 6, 10, 11, 12]

В Dojo 1.6

var unique = []; 
var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];
var array3 = array1.concat(array2); // Merged both arrays

dojo.forEach(array3, function(item) {
    if (dojo.indexOf(unique, item) > -1) return;
    unique.push(item); 
});

Обновление

Смотрите рабочий код.

http://jsfiddle.net/UAxJa/1/

Объединение неограниченного числа массивов или non-arrays и держите его уникальным:

function flatMerge() {
    return Array.prototype.reduce.call(arguments, function (result, current) {
        if (!(current instanceof Array)) {
            if (result.indexOf(current) === -1) {
                result.push(current);
            }
        } else {
            current.forEach(function (value) {
                console.log(value);
                if (result.indexOf(value) === -1) {
                    result.push(value);
                }
            });
        }
        return result;
    }, []);
}

flatMerge([1,2,3], 4, 4, [3, 2, 1, 5], [7, 6, 8, 9], 5, [4], 2, [3, 2, 5]);
// [1, 2, 3, 4, 5, 7, 6, 8, 9]

flatMerge([1,2,3], [3, 2, 1, 5], [7, 6, 8, 9]);
// [1, 2, 3, 5, 7, 6, 8, 9]

flatMerge(1, 3, 5, 7);
// [1, 3, 5, 7]

Если исходные массивы не требуют дедупликации, это должно быть довольно быстро, сохранять первоначальный порядок и не изменять исходные массивы … Простая и быстрая реализация ответа @Aaron:

function arrayMerge(base, addendum){
    var out = [].concat(base);
    for(var i=0,len=addendum.length;i<len;i  ){
        if(base.indexOf(addendum[i])<0){
            out.push(addendum[i]);
        }
    }
    return out;
}

Первый метод

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];
var array3 = arrayMerge(array1, array2);

console.log(array3);
//-> [ 'Vijendra', 'Singh', 'Shakya' ]

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

У меня есть два массива JavaScript:

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];

Я хочу, чтобы вывод был:

var array3 = ["Vijendra","Singh","Shakya"];

В выходном массиве удалить повторяющиеся слова.

Как объединить два массива в JavaScript, чтобы я получал только уникальные элементы из каждого массива в том же порядке, в котором они были вставлены в оригинальные массивы?

Функциональный подход с ES2015

Следуя функциональному подходу, a union Это может быть хаком, но в Firefox, если вы укажете третий параметр ‘fullscreen = yes’, откроется новое новое окно. Array Если вы не разрешите eval () динамический контент (через cgi или ввод), он будет таким же безопасным и надежным, как и любой другой JavaScript на вашей странице. concat и filter. Чтобы обеспечить оптимальную производительность, мы прибегаем к нативной Set Неисправность IE с атрибутом name

повлечет за собой серьезное снижение производительности, а следующая реализация просто игнорирует третью и четвертую перестановки. Вам придется создать отдельную версию union CSS свойство преобразования текста

Array A        Array B

[unique]       [unique]
[duplicated]   [unique]
[unique]       [duplicated]
[duplicated]   [duplicated]

Первые две перестановки легко обрабатывать с помощью одной функции. Однако последние два являются более сложными, поскольку вы не можете обрабатывать их, пока вы полагаетесь на Set. Я всегда включаю точки с запятой. Object для их поддержки. union) когда я пытаюсь опубликовать форму с полем с именем


// small, reusable auxiliary functions

const comp = f => g => x => f(g(x));
const apply = f => a => f(a);
const flip = f => b => a => f(a) (b);
const concat = xs => y => xs.concat(y);
const afrom = apply(Array.from);
const createSet = xs => new Set(xs);
const filter = f => xs => xs.filter(apply(f));


// de-duplication

const dedupe = comp(afrom) (createSet);


// the actual union function

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


// mock data

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


// here we go

console.log( "unique/unique", union(dedupe(xs)) (ys) );
console.log( "duplicated/unique", union(xs) (ys) );

С этого момента становится тривиально реализовать сценарий использования unionn All The Best !!!!!

// small, reusable auxiliary functions

const uncurry = f => (a, b) => f(a) (b);
const foldl = f => acc => xs => xs.reduce(uncurry(f), acc);

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


// union and unionn

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

const unionn = (head, ...tail) => foldl(union) (head) (tail);


// mock data

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


// here we go

console.log( unionn(xs, ys, zs) );

(иначе unionn — это просто foldl Ваша функция просто настроит форму так, как вы хотите. Array.prototype.reduce Как насчет: union Prototype

Самый простой способ сделать это — использовать concat(). Самый простой способ начать решение этой проблемы — использовать решение для кластеризации маркеров. Основная идея состоит в том, чтобы сгруппировать географически похожие местоположения в группу с количеством отображаемых точек. Когда пользователь увеличивает масштаб карты, эти группы расширяются, показывая внизу отдельные маркеры. filter() для удаления дубликатов или использование concat(). Здесь вы можете найти очень маленькую функцию, которая генерирует uuids Set() Глядя на вывод

Первый способ:

const firstArray = [1,2, 2];
const secondArray = [3,4];
// now lets merge them
const mergedArray = firstArray.concat(secondArray); // [1,2,2,3,4]
//now use filter to remove dups
const removeDuplicates = mergedArray.filter((elem, index) =>  mergedArray.indexOf(elem) === index); // [1,2,3, 4]

Второй способ (но с влиянием на производительность для пользовательского интерфейса):

const firstArray = [1,2, 2];
const secondArray = [3,4];
// now lets merge them
const mergedArray = firstArray.concat(secondArray); // [1,2,2,3,4]
const removeDuplicates = new Set(mergedArray);

похоже, что принятый ответ самый медленный в моих тестах ;

примечание. Я объединяю 2 массива объектов с помощью Ключ

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title>JS Bin</title>
</head>
<body>
<button type='button' onclick='doit()'>do it</button>
<script>
function doit(){
    var items = [];
    var items2 = [];
    var itemskeys = {};
    for(var i = 0; i < 10000; i  ){
        items.push({K:i, C:"123"});
        itemskeys[i] = i;
    }

    for(var i = 9000; i < 11000; i  ){
        items2.push({K:i, C:"123"});
    }

    console.time('merge');
    var res = items.slice(0);

    //method1();
    method0();
    //method2();

    console.log(res.length);
    console.timeEnd('merge');

    function method0(){
        for(var i = 0; i < items2.length; i  ){
            var isok = 1;
            var k = items2[i].K;
            if(itemskeys[k] == null){
                itemskeys[i] = res.length;
                res.push(items2[i]);
            }
        }
    }

    function method1(){
        for(var i = 0; i < items2.length; i  ){
            var isok = 1;
            var k = items2[i].K;

            for(var j = 0; j < items.length; j  ){
                if(items[j].K == k){
                    isok = 0;
                    break;
                }
            }

            if(isok) res.push(items2[i]);
        }  
    }

    function method2(){
        res = res.concat(items2);
        for(var i = 0; i < res.length;   i) {
            for(var j = i 1; j < res.length;   j) {
                if(res[i].K === res[j].K)
                    res.splice(j--, 1);
            }
        }
    }
}
</script>
</body>
</html>

для разбора строки на число. Чтобы быть в безопасности, всегда передавайте

Я написал эту простую функцию, которая принимает несколько аргументов массива. Практически так же, как Решение выше это просто более практический вариант использования. Эта функция не объединяет повторяющиеся значения в одном массиве, поэтому она может удалить их на более позднем этапе.

ОПРЕДЕЛЕНИЕ КРАТКОЙ ФУНКЦИИ (всего 9 строк)

/**
* This function merging only arrays unique values. It does not merges arrays in to array with duplicate values at any stage.
*
* @params ...args Function accept multiple array input (merges them to single array with no duplicates)
* it also can be used to filter duplicates in single array
*/
function arrayDeDuplicate(...args){
   let set = new Set(); // init Set object (available as of ES6)
   for(let arr of args){ // for of loops through values
      arr.map((value) => { // map adds each value to Set object
         set.add(value); // set.add method adds only unique values
      });
   }
   return [...set]; // destructuring set object back to array object
   // alternativly we culd use:  return Array.from(set);
}

USE EXAMPLE CODEPEN :

// SCENARIO 
let a = [1,2,3,4,5,6];
let b = [4,5,6,7,8,9,10,10,10];
let c = [43,23,1,2,3];
let d = ['a','b','c','d'];
let e = ['b','c','d','e'];

// USEAGE
let uniqueArrayAll = arrayDeDuplicate(a, b, c, d, e);
let uniqueArraySingle = arrayDeDuplicate(b);

// OUTPUT
console.log(uniqueArrayAll); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 43, 23, "a", "b", "c", "d", "e"]
console.log(uniqueArraySingle); // [4, 5, 6, 7, 8, 9, 10]

Самое простое решение с фильтром:

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];

var mergedArrayWithoutDuplicates = array1.concat(
  array2.filter(seccondArrayItem => !array1.includes(seccondArrayItem))
);

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

Моя первая попытка набрала около 99 тыс. Операций в секунду, и это говорит о том, что 390 тыс. Операций в секунду против другого ведущего теста jsperf в 140 тыс. (Для меня).

прекрасно сохраняет преимущества кэширования.

setTimeout ожидает ссылку на функцию, поэтому я создал ее в закрытии, которое интерпретирует мои данные и возвращает функцию с хорошим экземпляром моих данных!

function findMerge(a1, a2) {
    var len1 = a1.length;

    for (var x = 0; x < a2.length; x  ) {
        var found = false;

        for (var y = 0; y < len1; y  ) {
            if (a2[x] === a1[y]) {
                found = true;
                break;
            }
        }

        if(!found){
            a1.push(a2.splice(x--, 1)[0]);
        }
    }

    return a1;
}

Редактировать: я внес некоторые изменения в свою функцию, и производительность по сравнению с этим резко другим на сайте jsperf.

var MergeArrays=function(arrayOne, arrayTwo, equalityField) {
    var mergeDictionary = {};

    for (var i = 0; i < arrayOne.length; i  ) {
        mergeDictionary[arrayOne[i][equalityField]] = arrayOne[i];
    }

    for (var i = 0; i < arrayTwo.length; i  ) {
        mergeDictionary[arrayTwo[i][equalityField]] = arrayTwo[i];
    }

    return $.map(mergeDictionary, function (value, key) { return value });
}

Используя словари и Jquery, вы можете объединить два массива и не получать дубликаты. В моем примере я использую данное поле на объекте, но это может быть только сам объект.

Другой подход к вашему обзору с помощью функции limit func:

function mergeDistinct(arResult, candidate){
  if (-1 == arResult.indexOf(candidate)) {
    arResult.push(candidate);
  }
  return arResult;
}

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];

var arMerge = [];
arMerge = array1.reduce(mergeDistinct, arMerge);
arMerge = array2.reduce(mergeDistinct, arMerge);//["Vijendra","Singh","Shakya"];

Если вы хотите проверить уникальные объекты, используйте JSON.stringify для сравнения.

function arrayUnique(array) {
    var a = array.concat();
    for(var i=0; i<a.length;   i) {
        for(var j=i 1; j<a.length;   j) {
            if(JSON.stringify(a[i]) === JSON.stringify(a[j]))
                a.splice(j--, 1);
        }
    }

    return a;
}
Array.prototype.union = function (other_array) {
/* you can include a test to check whether other_array really is an array */
  other_array.forEach(function(v) { if(this.indexOf(v) === -1) {this.push(v);}}, this);    
}

Однострочное решение как переход к LiraNuna’s :

let array1 = ["Vijendra","Singh"];
let array2 = ["Singh", "Shakya"];

// Merges both arrays
let array3 = array1.concat(array2); 

//REMOVE DUPLICATE
let removeDuplicate = [...new Set(array3)];
console.log(removeDuplicate);

Использование Lodash

Я нашел ответ @ GijsjanB полезным, но мои массивы содержали объекты, которые имели много атрибутов, поэтому мне пришлось Дублируйте их, используя один из атрибутов.

Вот мое решение с использованием lodash

userList1 = [{ id: 1 }, { id: 2 }, { id: 3 }]
userList2 = [{ id: 3 }, { id: 4 }, { id: 5 }]
// id 3 is repeated in both arrays

users = _.unionWith(userList1, userList2, function(a, b){ return a.id == b.id });

// users = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }]

; true если они равны Библиотека

. Это наиболее эффективный с точки зрения времени вычислений. Также он сохраняет первоначальный порядок элементов.

Сначала отфильтруйте все дубликаты из второго массива, затем объедините то, что осталось от первого.

var a = [1,2,3];
var b = [5,4,3];
var c = a.concat(b.filter(function(i){
    return a.indexOf(i) == -1;
}));
console.log(c); // [1, 2, 3, 5, 4]

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

var i, c = a.slice(), ci = c.length;
for(i = 0; i < b.length; i  ){
    if(c.indexOf(b[i]) == -1)
        c[ci  ] = b[i];
}

Это просто и может быть сделано в одной строке с помощью jQuery:

var arr1 = ['Vijendra', 'Singh'], arr2 =['Singh', 'Shakya'];

$.unique(arr1.concat(arr2))//one line

["Vijendra", "Singh", "Shakya"]

Вот простой пример:

var unique = function(array) {
    var unique = []
    for (var i = 0; i < array.length; i  = 1) {
        if (unique.indexOf(array[i]) == -1) {
            unique.push(array[i])
        }
    }
    return unique
}

var uniqueList = unique(["AAPL", "MSFT"].concat(["MSFT", "BBEP", "GE"]));

Мы определяем unique(array) для удаления избыточных элементов и используем concat Это выбирает элементы, которые имеют указанный атрибут со значением, содержащим заданную подстроку «ckbItem»:

я выучил нахальный маленький способ объединения двух массивов с оператором распространения:

var array1 = ['tom', 'dick', 'harry'];
var array2 = ['martin', 'ricky'];

array1.push(...array2);

должен использовать

Как насчет создания

let noDuplicate = array1.filter ( i => array2.findIndex(a => i.id==a.id)==-1 );
let result = [...noDuplicate, ...array2];
var array1 = ["one","two"];
var array2 = ["two", "three"];
var collectionOfTwoArrays = [...array1, ...array2];    
var uniqueList = array => [...new Set(array)];
console.log('Collection :');
console.log(collectionOfTwoArrays);    
console.log('Collection without duplicates :');
console.log(uniqueList(collectionOfTwoArrays));

. Вот мое решение https://gist.github.com/4692150 с глубокими равными и простым в использовании результатом:

function merge_arrays(arr1,arr2)
{
   ... 
   return {first:firstPart,common:commonString,second:secondPart,full:finalString}; 
}

console.log(merge_arrays(
[
[1,"10:55"] ,
[2,"10:55"] ,
[3,"10:55"]
],[
[3,"10:55"] ,
[4,"10:55"] ,
[5,"10:55"]
]).second);

result:
[
[4,"10:55"] ,
[5,"10:55"]
]

специальными событиями jQuery

/**
 * Returns with the union of the given arrays.
 *
 * @param Any amount of arrays to be united.
 * @returns {array} The union array.
 */
function uniteArrays()
{
    var union = [];
    for (var argumentIndex = 0; argumentIndex < arguments.length; argumentIndex  )
    {
        eachArgument = arguments[argumentIndex];
        if (typeof eachArgument !== 'array')
        {
            eachArray = eachArgument;
            for (var index = 0; index < eachArray.length; index  )
            {
                eachValue = eachArray[index];
                if (arrayHasValue(union, eachValue) == false)
                union.push(eachValue);
            }
        }
    }

    return union;
}    

function arrayHasValue(array, value)
{ return array.indexOf(value) != -1; }
Array.prototype.pushUnique = function(values)
{
    for (var i=0; i < values.length; i  )
        if (this.indexOf(values[i]) == -1)
            this.push(values[i]);
};

объект. Мы сказали, что все объекты в JavaScript имеют внутреннюю

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];
array1.pushUnique(array2);
alert(array1.toString());  // Output: Vijendra,Singh,Shakya

Если вам, как и мне, требуется поддержка старых браузеров, это работает с IE6

function es3Merge(a, b) {
    var hash = {},
        i = (a = a.slice(0)).length,
        e;

    while (i--) {
        hash[a[i]] = 1;
    }

    for (i = 0; i < b.length; i  ) {
        hash[e = b[i]] || a.push(e);
    }

    return a;
};

, которые являются индексами

Использование: https://gist.github.com/samad-aghaei/7250ffb74ed80732debb1cbb14d2bfb0

var _uniqueMerge = function(opts, _ref){
    for(var key in _ref)
        if (_ref && _ref[key] && _ref[key].constructor && _ref[key].constructor === Object)
          _ref[key] = _uniqueMerge((opts ? opts[key] : null), _ref[key] );
        else if(opts && opts.hasOwnProperty(key))
          _ref[key] = opts[key];
        else _ref[key] = _ref[key][1];
    return _ref;
}

Лучший и самый простой способ сделать это — использовать функцию «some ()» JavaScript, которая возвращает true или false, указывая, содержит ли массив элемент объекта. Вы можете сделать это:

var array1 = ["Vijendra","Singh"]; 
var array2 = ["Singh", "Shakya"];

var array3 = array1;

array2.forEach(function(elementArray2){
    var isEquals = array1.some(function(elementArray1){
        return elementArray1 === elementArray2;
    })
    if(!isEquals){
        array3.push(elementArray2);
    }
});
console.log(array3);

Результаты:

["Vijendra", "Singh", "Shakya"]

файлы, которые вы хотите … без дублирования …

Если вы используете только underscore.js, он не имеет unionWith, unionBy

, вы можете попробовать: _.uniq(_.union(arr1, arr2), (obj) => obj.key) (ключ — ключевой параметр каждого объекта), это должно помочь получить уникальность после объединения обоих массивов.

Вы можете попробовать это:

const union = (a, b) => Array.from(new Set([...a, ...b]));

console.log(union(["neymar","messi"], ["ronaldo","neymar"]));

Я думаю, что это работает быстрее.

removeDup = a = & gt ; {

for (let i = a.length - 1; i >= 0; i--) {
    for (let j = i-1; j >= 0; j--) {
        if (a[i] === a[j])
            a.splice(j--, 1);
    }
}

return a;

}

Модульный, Общий

Этого можно достичь, составив две основные функции.

const getUniqueMerge = (...arrs) => getUniqueArr(mergeArrs(...arrs))
const getUniqueArr = (array) => Array.from(new Set(array))  
const mergeArrs = (...arrs) => [].concat(...arrs)

Он может обрабатывать неограниченные массивы или значения

console.log(getUniqueMerge(["Vijendra","Singh"],["Singh", "Shakya"])
// ["Vijendra", "Singh", "Shakya"]

console.log(getUniqueMerge(["Sheldon", "Cooper"], ["and", "Cooper", "Amy", "and"], "Farrah", "Amy", "Fowler"))
// ["Sheldon", "Cooper", "and", "Amy", "Farrah", "Fowler"]

Это функция, которую я использую, когда мне нужно объединить, (или вернуть объединение) двух массивов.

var union = function (a, b) {
  for (var i = 0; i < b.length; i  )
    if (a.indexOf(b[i]) === -1)
      a.push(b[i]);
  return a;
};

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

a = union(a, b);
//> [1, 2, 3, "a", "b", "c", 4, "d"]

var array1 = ["Vijendra", "Singh"];
var array2 = ["Singh", "Shakya"];

var array3 = union(array1, array2);
//> ["Vijendra", "Singh", "Shakya"]
function set(a, b) {
  return a.concat(b).filter(function(x,i,c) { return c.indexOf(x) == i; });
}

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

У меня есть два массива JavaScript:

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];

Я хочу, чтобы вывод был:

var array3 = ["Vijendra","Singh","Shakya"];

В выходном массиве удалить повторяющиеся слова.

Как объединить два массива в JavaScript, чтобы я получал только уникальные элементы из каждого массива в том же порядке, в котором они были вставлены в оригинальные массивы?

Для больших входных данных лучшим вариантом будет сортировка массивов. Затем объедините их.

function sortFunction(a, b) {
        return a - b;
}

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

function mergeDedup(arr1, arr2) {

    var i = 0, j = 0, result = [];
    while (i < arr1.length && j < arr2.length) {

        if (arr1[i] < arr2[j]) {
            writeIfNotSameAsBefore(result, arr1[i]);
            i  ;
        }
        else if (arr1[i] > arr2[j]) {
            writeIfNotSameAsBefore(result, arr2[j]);
            j  ;
        }
        else {
            writeIfNotSameAsBefore(result, arr1[i]);
            i  ;
            j  ;
        }

    }

    while (i < arr1.length) {
        writeIfNotSameAsBefore(result, arr1[i]);
        i  ;
    }

    while (j < arr2.length) {
        writeIfNotSameAsBefore(result, arr2[j]);
        j  ;
    }
    return result;
}

function writeIfNotSameAsBefore(arr, item) {
    if (arr[arr.length - 1] !== item) {
        arr[arr.length] = item;
    }
    return arr.length;
}

Для сортировки потребуется O (nlogn mlogm), где n и m — длина массивов, а O (x) — для слияния, где x = Max (n, m) ;

Вы можете объединить результаты и отфильтровать дубликаты: синтаксис

let combinedItems = [];

// items is an Array of arrays: [[1,2,3],[1,5,6],...]    
items.forEach(currItems => {
    if (currItems && currItems.length > 0) {
        combinedItems = combinedItems.concat(currItems);
    }
});

let noDuplicateItems = combinedItems.filter((item, index) => {
    return !combinedItems.includes(item, index   1);
});
/**
 * De-duplicate an array keeping only unique values.
 * Use hash table (js object) to filter-out duplicates.
 * The order of array elements is maintained.
 * This algorithm is particularly efficient for large arrays (linear time).
 */
function arrayUniqueFast(arr) {
	var seen = {};
	var result = [];
	var i, len = arr.length;
	for (i = 0; i < len; i  ) {
		var item = arr[i];
		// hash table lookup
		if (!seen[item]) {
			result.push(item);
			seen[item] = true;
		}
	}
	return result;
}

///// test
var array1 = ["Vijendra", "Singh"];
var array2 = ["Singh", "Shakya"];

var result = arrayUniqueFast(array1.concat(array2));
document.write('<br>result: '   result);

для другие методы {* } git ), согласно спецификации. https: / /jsperf.com/de-duplicate-an-array-keeping-only-unique-values ​​

Использование:

Array.prototype.merge = function (arr) {
    var key;
    for(key in arr) 
        this[key] = arr[key];
};

. Это создает «изолировать» область вместо этого.

В любом случае, я не включил эту часть, потому что она не относится к вопросу. Я также поместил свой код в jsperf. Отредактировано: я исправил свою запись в jsperf. Моя функция получает около 99 тыс. Операций в секунду по сравнению с 140 тыс. Операций.

удобочитаемое и легко расширяемое

прекрасно сохраняет преимущества кэширования.

function indiceMerge(a1, a2) {
    var ai = [];
    for (var x = 0; x < a2.length; x  ) {
        ai.push(x)
    };

    for (var x = 0; x < a1.length; x  ) {
        for (var y = 0; y < ai.length; y  ) {
            if (a1[x] === a2[ai[y]]) {
                ai.splice(y, 1);
                y--;
            }
        }
    }

    for (var x = 0; x < ai.length; x  ) {
        a1.push(a2[ai[x]]);
    }

    return a1;
}

Это быстро, сортирует любое количество массивов и работает как с числами, так и со строками.

function collate(a){ // Pass an array of arrays to collate into one array
    var h = { n: {}, s: {} };
    for (var i=0; i < a.length; i  ) for (var j=0; j < a[i].length; j  )
        (typeof a[i][j] === "number" ? h.n[a[i][j]] = true : h.s[a[i][j]] = true);
    var b = Object.keys(h.n);
    for (var i=0; i< b.length; i  )
        b[i]=Number(b[i]);
    return b.concat(Object.keys(h.s));
}

> a = [ [1,2,3], [3,4,5], [1,5,6], ["spoon", "fork", "5"] ]
> collate( a )

[1, 2, 3, 4, 5, 6, "5", "spoon", "fork"]

выберите все элементы и затем переберите

function collate(a){
    var h = {};
    for (i=0; i < a.length; i  ) for (var j=0; j < a[i].length; j  )
        h[a[i][j]] = typeof a[i][j] === "number";
    for (i=0, b=Object.keys(h); i< b.length; i  )
        if (h[b[i]])
            b[i]=Number(b[i]);
    return b;
}
[1, 2, 3, 4, "5", 6, "spoon", "fork"]

может быть подходящим вариантом, даже если ваш интерпретатор поддерживает

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

function collate(a){
    var h = {};
    for (var i=0; i < a.length; i  )
        for (var j=0; j < a[i].length; j  )
            h[a[i][j]] = true;
    return Object.keys(h)
}
["1", "2", "3", "4", "5", "6", "spoon", "fork"]

Если вам на самом деле не нужен массив, а просто нужно собрать уникальные значения и выполнить итерации по ним, то (в большинстве браузеров) (и node.js)):

h = new Map();
for (i=0; i < a.length; i  )
    for (var j=0; j < a[i].length; j  )
        h.set(a[i][j]);

Это может быть предпочтительнее.

var arr1 = ["neymar","messi"]
var arr2 = ["ronaldo","neymar"]
var arr3 = []
var obj = {}

for(var i = 0 ;i<arr1.length; i =1){
if(!obj[arr1[i]]){
obj[arr1[i]] = true
arr3.push(arr1[i])
}
}


for(var i = 0 ;i<arr2.length; i =1){
if(!obj[arr2[i]]){
obj[arr2[i]] = true
arr3.push(arr2[i])
}
}

console.log(arr3)
var a = [1,2,3]
var b = [1,2,4,5]

Мне нравятся лайнеры. Это подтолкнет различные элементы b к

b.forEach(item => a.includes(item) ? null : a.push(item));

И еще одна версия, которая не будет изменять

var c = a.slice();
b.forEach(item => c.includes(item) ? null : c.push(item));

Учитывая два отсортированных массива простых типов без дубликатов, это объединит их за O (n) время, и результат будет быть также отсортированы.

function merge(a, b) {
    let i=0;
    let j=0;
    let c = [];
    for (;;) {
        if (i == a.length) {
            if (j == b.length) return c;
            c.push(b[j  ]);
        } else if (j == b.length || a[i] < b[j]) {
            c.push(a[i  ]);
        } else {
            if (a[i] == b[j])   i;   // skip duplicates
            c.push(b[j  ]);
        }
    }
}

в любой функции объекта для ссылки на другие свойства этого объекта. Это не то же самое, что экземпляр, созданный с помощью loadash unionWith наше меню работает по запросу. Наша разработка — _.unionWith([arrays], [comparator])

Этот метод похож на _.union за исключением того, что он принимает компаратор, который вызывается для сравнения элементов массивов. Значения результата выбираются из первого массива, в котором это значение встречается. Компаратор вызывается с двумя аргументами: (arrVal, othVal).

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];
 
var array3 = _.unionWith(array1, array2, _.isEqual);
console.log(array3);
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.min.js"></script>

const merge(...args)=>(new Set([].concat(...args)))

Возьмите два массива a и b

var a = ['a','b','c'];

var b = ['d','e','f'];
var c = a.concat(b); 


//c is now an an array with: ['a','b','c','d','e','f']

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

У меня есть два массива JavaScript:

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];

Я хочу, чтобы вывод был:

var array3 = ["Vijendra","Singh","Shakya"];

В выходном массиве удалить повторяющиеся слова.

Как объединить два массива в JavaScript, чтобы я получал только уникальные элементы из каждого массива в том же порядке, в котором они были вставлены в оригинальные массивы?

Чтобы просто объединить массивы (без удаления дубликатов)

Версия ES5 использует элемент Array.concat:

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];

var array3 = array1.concat(array2); // Merges both arrays
// [ 'Vijendra', 'Singh', 'Singh', 'Shakya' ]
const array1 = ["Vijendra","Singh"];
const array2 = ["Singh", "Shakya"];
const array3 = [...array1, ...array2];

Поскольку не существует встроенного способа удаления дубликатов (на самом деле ECMA-262 имеет Array.forEach, что было бы неплохо для этого), мы должны сделать это вручную:

Array.prototype.unique = function() {
    var a = this.concat();
    for(var i=0; i<a.length;   i) {
        for(var j=i 1; j<a.length;   j) {
            if(a[i] === a[j])
                a.splice(j--, 1);
        }
    }

    return a;
};

Затем, чтобы использовать его:

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];
// Merges both arrays and gets unique items
var array3 = array1.concat(array2).unique(); 

Это также сохранит порядок массивов (т. Е. Сортировка не требуется).

Так как многих раздражает увеличение прототипа Array.prototype и for in Этот метод предназначен для

function arrayUnique(array) {
    var a = array.concat();
    for(var i=0; i<a.length;   i) {
        for(var j=i 1; j<a.length;   j) {
            if(a[i] === a[j])
                a.splice(j--, 1);
        }
    }

    return a;
}

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];
    // Merges both arrays and gets unique items
var array3 = arrayUnique(array1.concat(array2));

Для тех, кому посчастливилось работать с браузерами, в которых доступен ES5, вы можете использовать Object.definePropertyнапример:

Object.defineProperty(Array.prototype, 'unique', {
    enumerable: false,
    configurable: false,
    writable: false,
    value: function() {
        var a = this.concat();
        for(var i=0; i<a.length;   i) {
            for(var j=i 1; j<a.length;   j) {
                if(a[i] === a[j])
                    a.splice(j--, 1);
            }
        }

        return a;
    }
});

Вот решение, вдохновленное

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

Смотрите также

http://lodash.com/docs # union

Сначала объедините два массива, а затем — фильтр выходят только уникальные предметы.

var a = [1, 2, 3], b = [101, 2, 1, 10];
var c = a.concat(b);
var d = c.filter(function (item, pos) {return c.indexOf(item) == pos});

// d is [1,2,3,101,10]

. Я не уверен, что это все еще актуально сегодня, но при работе со старыми стандартами браузеров / JavaScript (ecmascript 5, javascript & Lt ; 1.8.5 ~ firefox 4), переменная global-scope {* } Хост-объекты могут реализовывать эти внутренние методы любым способом, если не указано иное, например, ;, одна из возможностей —

— это JSX & Amp ; Соглашения Typescript

Как предложено @Dmitry (см. Второй комментарий ниже), более разумным решением было бы отфильтровать уникальные элементы в b перед конкатенацией с a

var a = [1, 2, 3], b = [101, 2, 1, 10];
var c = a.concat(b.filter(function (item) {
    return a.indexOf(item) < 0;
}));

// d is [1,2,3,101,10]

. Это решение ECMAScript 6, использующее оператор распространения и универсальные шаблоны.

В настоящее время он работает только с Firefox и, возможно, с Internet Explorer Technical Preview.

В зависимости от типа (ов) возвращаемых значений, ошибки часто можно легко различить (например, используйте Babel , ты можешь получить это сейчас.

// Input: [ [1, 2, 3], [101, 2, 1, 10], [2, 1] ]
// Output: [1, 2, 3, 101, 10]
function mergeDedupe(arr)
{
  return [...new Set([].concat(...arr))];
}
array1.push(...array2) // => don't remove duplication 

или

[...array1,...array2] //   =>  don't remove duplication 

или

[...new Set([...array1 ,...array2])]; //   => remove duplication

Использование Установить (ECMAScript 2015), это будет так просто:

const array1 = ["Vijendra", "Singh"];
const array2 = ["Singh", "Shakya"];
const array3 = Array.from(new Set(array1.concat(array2)));

Вот немного другой взгляд на петлю. С некоторыми из оптимизаций в последней версии Chrome, это самый быстрый метод для разрешения объединения двух массивов (Chrome 38.0.2111).

что также решает эту проблему.

var array1 = ["Vijendra", "Singh"];
var array2 = ["Singh", "Shakya"];
var array3 = [];

var arr = array1.concat(array2),
  len = arr.length;

while (len--) {
  var itm = arr[len];
  if (array3.indexOf(itm) === -1) {
    array3.unshift(itm);
  }
}

. Однако, если вы хотите использовать синтаксис, в котором код «разделен на середину» объектом
Я удивлен, что никто еще не предложил это: { *} Во всех примерах в W3Schools открываются файлы XML, расположенные в домене W3Schools.
lodash: 308k ops / s
для циклов: 225k ops / s

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

http://jsperf.com/merge-two-arrays-keeping-only-unique-values/52

let whileLoopAlt = function (array1, array2) {
    const array3 = array1.slice(0);
    let len1 = array1.length;
    let len2 = array2.length;
    const assoc = {};

    while (len1--) {
        assoc[array1[len1]] = null;
    }

    while (len2--) {
        let itm = array2[len2];

        if (assoc[itm] === undefined) { // Eliminate the indexOf call
            array3.push(itm);
            assoc[itm] = null;
        }
    }

    return array3;
};

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

Главный ответ здесь с двойным циклом для каждого значения (i-1): все еще значительно медленнее. У lodash все еще хорошо, и я бы порекомендовал его всем, кто не против добавить библиотеку в свой проект. Для тех, кто не хочет этого, мой цикл while все еще является хорошим ответом, и ответ фильтра очень ярко демонстрирует здесь, опередив все мои тесты последней версией Canary Chrome (44.0.2360) на момент написания этой статьи.

Ознакомьтесь с Ответ Майка и Ответ Дана Стокера Следовательно, лучшее решение — это включить

Вы можете сделать это просто с помощью ECMAScript 6,

var array1 = ["Vijendra", "Singh"];
var array2 = ["Singh", "Shakya"];
var array3 = [...new Set([...array1 ,...array2])];
console.log(array3); // ["Vijendra", "Singh", "Shakya"];

объединить два массива и удалить дубликат в es6

let arr1 = [3, 5, 2, 2, 5, 5];
let arr2 = [2, 1, 66, 5];
let unique = [...new Set([...arr1,...arr2])];
console.log(unique);
// [ 3, 5, 2, 1, 66 ]
Array.prototype.merge = function(/* variable number of arrays */){
    for(var i = 0; i < arguments.length; i  ){
        var array = arguments[i];
        for(var j = 0; j < array.length; j  ){
            if(this.indexOf(array[j]) === -1) {
                this.push(array[j]);
            }
        }
    }
    return this;
};

Гораздо лучшая функция слияния массивов.

Просто держитесь подальше от вложенных циклов (O (n ^ 2)) и .indexOf() (O (n)).

function merge(a, b) {
    var hash = {}, i;
    for (i=0; i<a.length; i  ) {
        hash[a[i]]=true;
    } 
    for (i=0; i<b.length; i  ) {
        hash[b[i]]=true;
    } 
    return Object.keys(hash);
}

Просто добавляю мои два цента.

function mergeStringArrays(a, b){
    var hash = {};
    var ret = [];

    for(var i=0; i < a.length; i  ){
        var e = a[i];
        if (!hash[e]){
            hash[e] = true;
            ret.push(e);
        }
    }

    for(var i=0; i < b.length; i  ){
        var e = b[i];
        if (!hash[e]){
            hash[e] = true;
            ret.push(e);
        }
    }

    return ret;
}

Этот метод я часто использую, он использует объект в качестве таблицы hashlookup для проверки дубликатов. Если предположить, что хеш равен O (1), то он выполняется в O (n), где n — длина, длина. Честно говоря, я понятия не имею, как браузер выполняет хэширование, но он хорошо работает на многих тысячах точек данных.

Почему вы не используете объект? Похоже, вы пытаетесь смоделировать набор. Однако это не сохранит порядок.

var set1 = {"Vijendra":true, "Singh":true}
var set2 = {"Singh":true,  "Shakya":true}

// Merge second object into first
function merge(set1, set2){
  for (var key in set2){
    if (set2.hasOwnProperty(key))
      set1[key] = set2[key]
  }
  return set1
}

merge(set1, set2)

// Create set from array
function setify(array){
  var result = {}
  for (var item in array){
    if (array.hasOwnProperty(item))
      result[array[item]] = true
  }
  return result
}

решения для объединения на основе ES6

let arr1 = [1,2,3,4,5];
let arr2 = [3,4,5,6];
let result = [...new Set([...arr1, ...arr2])];
console.log(result);

Моя полторы копейки:

Array.prototype.concat_n_dedupe = function(other_array) {
  return this
    .concat(other_array) // add second
    .reduce(function(uniques, item) { // dedupe all
      if (uniques.indexOf(item) == -1) {
        uniques.push(item);
      }
      return uniques;
    }, []);
};

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];

var result = array1.concat_n_dedupe(array2);

console.log(result);

Упрощенный Завершено процедура, которая касается только пошагового выполнения массивы. Оттуда мы создадим другие наши базовые функции сравнения, такие как

function mergeUnique(arr1, arr2){
    return arr1.concat(arr2.filter(function (item) {
        return arr1.indexOf(item) === -1;
    }));
}

Лучшее решение .. .

Вы можете проверить прямо в консоли браузера, нажав …

Без дублированного разрешения

a = [1, 2, 3];
b = [3, 2, 1, "prince"];

a.concat(b.filter(function(el) {
    return a.indexOf(el) === -1;
}));

С дублирующим

["prince", "asish", 5].concat(["ravi", 4])

JavaScript: кодом крика Глядя на вывод

[1, 2, 3].concat([3, 2, 1, "prince"].filter(function(el) {
    return [1, 2, 3].indexOf(el) === -1;
}));

javascript — Почему RegExp с глобальным флагом дает неверные результаты?

 f12 > console

F12

["prince", "asish", 5, "ravi", 4]

[1, 2, 3, "prince"]

Единственный недостаток: удаление HREF удаляет tabindex. Чтобы преодолеть это, вы можете использовать кнопку, которая стилизована как ссылка или добавить атрибут tabindex, используя JS. uniq :

array3 = _.uniq(array1.concat(array2))

console.log(array3)

It будет печатать [«Vijendra», «Singh», «Shakya»] Глядя на вывод

//Array.indexOf was introduced in javascript 1.6 (ECMA-262) 
//We need to implement it explicitly for other browsers, 
if (!Array.prototype.indexOf)
{
  Array.prototype.indexOf = function(elt, from)
  {
    var len = this.length >>> 0;

    for (; from < len; from  )
    {
      if (from in this &&
          this[from] === elt)
        return from;
    }
    return -1;
  };
}
//now, on to the problem

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];

var merged = array1.concat(array2);
var t;
for(i = 0; i < merged.length; i  )
  if((t = merged.indexOf(i   1, merged[i])) != -1)
  {
    merged.splice(t, 1);
    i--;//in case of multiple occurrences
  }

Реализация indexOf метод для других браузеров взят из Только база данных может надежно проверять данные, которые зависят от связанных данных.

Если данные JSON

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];

var array3 = array1.concat(array2);
var tempSet = new Set(array3);
array3 = Array.from(tempSet);

//show output
document.body.querySelector("div").innerHTML = JSON.stringify(array3);
<div style="width:100%;height:4rem;line-height:4rem;background-color:steelblue;color:#DDD;text-align:center;font-family:Calibri" > 
  temp text 
</div>

Новое решение (которое использует Array.prototype.indexOf и Array.prototype.concat):

Array.prototype.uniqueMerge = function( a ) {
    for ( var nonDuplicates = [], i = 0, l = a.length; i<l;   i ) {
        if ( this.indexOf( a[i] ) === -1 ) {
            nonDuplicates.push( a[i] );
        }
    }
    return this.concat( nonDuplicates )
};

Для массивоподобных объектов

>>> ['Vijendra', 'Singh'].uniqueMerge(['Singh', 'Shakya'])
["Vijendra", "Singh", "Shakya"]

Array.prototype.indexOf (для интернет-обозревателя):

Array.prototype.indexOf = Array.prototype.indexOf || function(elt)
  {
    var len = this.length >>> 0;

    var from = Number(arguments[1]) || 0;
    from = (from < 0) ? Math.ceil(from): Math.floor(from); 
    if (from < 0)from  = len;

    for (; from < len; from  )
    {
      if (from in this && this[from] === elt)return from;
    }
    return -1;
  };
Array.prototype.add = function(b){
    var a = this.concat();                // clone current object
    if(!b.push || !b.length) return a;    // if b is not an array, or empty, then return a unchanged
    if(!a.length) return b.concat();      // if original is empty, return b

    // go through all the elements of b
    for(var i = 0; i < b.length; i  ){
        // if b's value is not in a, then add it
        if(a.indexOf(b[i]) == -1) a.push(b[i]);
    }
    return a;
}

// Example:
console.log([1,2,3].add([3, 4, 5])); // will output [1, 2, 3, 4, 5]
array1.concat(array2).filter((value, pos, arr)=>arr.indexOf(value)===pos)

Хорошая вещь об этом производительность и то, что вы вообще, при работе с массивами, используете методы цепочки, такие как filter, map и т. д., так что вы можете добавить эту строку, и она будет объединять и дедуплицировать array2 с array1 без необходимости ссылаться на более позднюю (когда вы используете методы chaining у вас нет), пример:

someSource()
.reduce(...)
.filter(...)
.map(...) 
// and now you want to concat array2 and deduplicate:
.concat(array2).filter((value, pos, arr)=>arr.indexOf(value)===pos)
// and keep chaining stuff
.map(...)
.find(...)
// etc

(я не люблю загрязнять Array.prototype, и это был бы единственный способ уважать цепочку — определение новой функции порвет ее — так что я думаю кое-что как будто это единственный способ сделать это)

Для ES6 только одна строка:

a = [1, 2, 3, 4]
b = [4, 5]
[...new Set(a.concat(b))]  // [1, 2, 3, 4, 5]
  • Современный способ достичь этого — просто использовать оператор распространения Глядя на вывод
  • Как мне преобразовать строку в целое число в JavaScript? Sets Вот простой jQuery код для этого. Наборы не допускают дублирования по умолчанию Глядя на вывод
  • . Рассматривая преимущества и недостатки обоих, мы можем сделать расчетное предположение относительно того, что подходит для данной ситуации. Это два основных подхода к выполнению обещаний. У обоих есть свои плюсы и минусы Array.from ()

Итак, вот демонстрация для вашего сценария —

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];
var resArr = Array.from(new Set([...array1, ...array2]));
console.log(resArr);

ради этого … вот решение одной строкой:

const x = [...new Set([['C', 'B'],['B', 'A']].reduce( (a, e) => a.concat(e), []))].sort()
// ['A', 'B', 'C']

Не особенно читабельно, но это может кому-то помочь:

  1. На мой взгляд, лучший способ — использовать функцию Array.forEach. Если вы не можете использовать это, я бы Предлагаем получить полифилл из MDN, чтобы сделать его доступным, это, безусловно, самый безопасный способ перебора массива в JavaScript.
  2. Функция Reduce использует concat для добавления каждого подмассива в массив аккумулятора.
  3. Результат этого передается как параметр конструктора для создания нового Set Глядя на вывод
  4. , которое скрывает / скрывает родительское свойство области с тем же именем. Это, вероятно, не то, что вы хотите / ожидаете. Set Википедию
  5. Переменная sort() функция применяется к новому массиву.
var arr1 = [1, 3, 5, 6];
var arr2 = [3, 6, 10, 11, 12];
arr1.concat(arr2.filter(ele => !arr1.includes(ele)));
console.log(arr1);

output :- [1, 3, 5, 6, 10, 11, 12]

В Dojo 1.6

var unique = []; 
var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];
var array3 = array1.concat(array2); // Merged both arrays

dojo.forEach(array3, function(item) {
    if (dojo.indexOf(unique, item) > -1) return;
    unique.push(item); 
});

Обновление

Смотрите рабочий код.

http://jsfiddle.net/UAxJa/1/

Объединение неограниченного числа массивов или non-arrays и держите его уникальным:

function flatMerge() {
    return Array.prototype.reduce.call(arguments, function (result, current) {
        if (!(current instanceof Array)) {
            if (result.indexOf(current) === -1) {
                result.push(current);
            }
        } else {
            current.forEach(function (value) {
                console.log(value);
                if (result.indexOf(value) === -1) {
                    result.push(value);
                }
            });
        }
        return result;
    }, []);
}

flatMerge([1,2,3], 4, 4, [3, 2, 1, 5], [7, 6, 8, 9], 5, [4], 2, [3, 2, 5]);
// [1, 2, 3, 4, 5, 7, 6, 8, 9]

flatMerge([1,2,3], [3, 2, 1, 5], [7, 6, 8, 9]);
// [1, 2, 3, 5, 7, 6, 8, 9]

flatMerge(1, 3, 5, 7);
// [1, 3, 5, 7]

Если исходные массивы не требуют дедупликации, это должно быть довольно быстро, сохранять первоначальный порядок и не изменять исходные массивы … Простая и быстрая реализация ответа @Aaron:

function arrayMerge(base, addendum){
    var out = [].concat(base);
    for(var i=0,len=addendum.length;i<len;i  ){
        if(base.indexOf(addendum[i])<0){
            out.push(addendum[i]);
        }
    }
    return out;
}

Назначение дочернего прототипа (Создание наследования дочернего прототипа от родительского прототипа)

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];
var array3 = arrayMerge(array1, array2);

console.log(array3);
//-> [ 'Vijendra', 'Singh', 'Shakya' ]
Понравилась статья? Поделиться с друзьями:
JavaScript & TypeScript
Adblock
detector