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

Question

У меня есть два массива json с одним и тем же объектом, я хочу получить json из этих двух json, который не содержит дублированного значения, например, это мои jsons:

json1=["one","two"];
json2=["one","two","three","four"];

результат должен быть:

result=["three","four"]

знаете ли вы, как это сделать, спасибо

Answer 1

Вот решение, если вы не знаете / не заботитесь, какой массив самый длинный.Не очень короткий, но легко читаемый и понятный.

function myFilter(arr1, arr2) {

const combined = [...arr1, ...arr2]

const seen = new Set()

combined.forEach(item => {
  if (seen.has(item)) {
    seen.delete(item)
  } else {
    seen.add(item)
  }
})

return Array.from(seen)

}

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

Затем мысоздайте новый набор , который будет похож на контейнер, в который мы подбрасываем наши значения.

Далее мы будем использовать forEach, чтобы перебрать объединенный массив и спросить: «Мы видели это значение раньше?Если это так, давайте удалим его, потому что это означает, что он не уникален, в противном случае давайте добавим его в набор. "

Наконец, мы используем Array.from () , чтобы превратить наш набор вмассив и вернуть его.

Answer 2

Это дает вам 3 результата, основанных на аргументе типа.

(1) «uniq»: нет дубликатов (2) «дубликат» (3) «not_duplicate»

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

function uniq_n_shit (arr1, arr2, type) {

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

    return [...new Set(arr1.concat(arr2))]

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

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

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

    let concat = arr1.concat(arr2)
    let set = [...new Set(concat)]
    let remove = concat.filter(function (obj, index, self) {
      return index !== self.indexOf(obj)
    })

    for (let r = 0; r < remove.length; r++) {
      let i = set.indexOf(remove[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' ]

Answer 3

@ Jan , попробуйте следующий код.

Используются filter () и concat () методы, определенные намассивы.

json1=["one","two"];
json2=["one","two","three","four"];

var arr1 = json1.filter((key) => {
       if(json2.indexOf(key) == -1) 
            return true
       else 
            return false
})

var arr2 = json2.filter((key) => {
       if(json1.indexOf(key) == -1) 
            return true
       else 
            return false
 })

result = arr1.concat(arr2)
console.log(result)

Answer 4

Вы можете просто использовать concat и фильтровать довольно просто.

function noDupes(arr1,arr2){
  return arr1.concat(arr2).filter((item,index,arr)=>{
    if(arr1.includes(item)&&arr2.includes(item))
        return false
    else
        return item
  })
}

Answer 5

Вы можете сделать это так.Используйте Array.prototype.reduce, чтобы выбрать все элементы, которые находятся в первом массиве, а не во втором.Затем используйте его таким же образом, чтобы выбрать все элементы, которые находятся во втором, а не в первом.И, наконец, объедините эти два результата.

const _removeCommon = (xs, ys) =>
  xs.reduce((acc, v) => ys.includes(v) ? acc : acc.concat(v), []);

const removeCommon = (xs, ys) =>
  [..._removeCommon(xs, ys), ..._removeCommon(ys, xs)];

const json1=["one","two"];
const json2=["one","two","three","four"];

console.log(removeCommon(json1, json2));

Answer 6

function myFilter(arraySmall, arrayBig){
  var result = [];

  for (var i = 0; i < arrayBig.length; i++) {
    if (arraySmall.indexOf(arrayBig[i]) === -1){ //ie. if item not exists in arraySmall
      result.push(arrayBig[i]);
    }
  }

  return result;
}

Вы можете просто позвонить myFilter(json1, json2);

Answer 7

Вы можете объединить массивы, а затем отфильтровать дубликаты, сравнив indexOf и lastIndexOf для каждого элемента:

const json1 = ["one", "two"];
const json2 = ["one", "two", "three", "four"];

const withoutDupes = [...json1, ...json2].filter((item, idx, array) => {
  if (array.indexOf(item) === array.lastIndexOf(item)) {
      return item;
  }
});

console.log(withoutDupes);

Answer 8

вот код, это функция, которая в основном вычитает массив 2 и возвращает результирующий массив

a1 и a2 - массив 2

a - пустой массив, который имеет истинное значениево всех a1 [index]

a1 = [1,4,5];a = [0,1,0,0,1,1];

1 = true, как это

теперь мы проверяем id на наличие любого a2 [index] в a

если a2 = [1,3];

, то a [a2 [atanyindex]] будет a = [0,1,0,0,1,1];

.......................................................... ^ 1 и, если это произойдет, удалите этот элемент

, добавьте оставшиеся элементы в массив diff, и массив diff вычитает 2 массива, то есть вам требуется ответ

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

Answer 9

Решение с использованием функции уменьшения и фильтрации:

const json1 = ["one","two"];
const json2 = ["one","two","three", "four"];

const result = json2
  .reduce((acc, cur) => acc.indexOf(cur) > -1 ? acc : acc.concat(cur), json1)
  .filter(item => json1.indexOf(item) === -1 || json2.indexOf(item) === -1);

console.log(result); // ["three", "four"]