Как удалить повторяющийся объект (строку) из массива в JavaScript

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

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.info(result); // ["three", "four"]

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

a1 и a2 - это 2-й массив

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

а1 = [1,4,5]; а = [0,1,0,0,1,1];

1 = верно как это

теперь мы проверяем 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;
}

Вы можете объединить массивы, а затем отфильтровать дубликаты, сравнивая 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.info(withoutDupes);

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

Вы можете сделать это вот так. Используйте 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.info(removeCommon(json1, json2));

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

It uses filter() and concat() methods defined on arrays.

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.info(result)

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

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

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

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 (), чтобы превратить наш набор в массив и вернуть его.

Это дает вам 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.info(uniq_n_shit(json1, json2, null)) // => [ 'one', 'two', 'three', 'four' ]
console.info(uniq_n_shit(json1, json2, 'uniq')) // => [ 'one', 'two', 'three', 'four' ]
console.info(uniq_n_shit(json1, json2, 'duplicate')) // => [ 'one', 'two' ]
console.info(uniq_n_shit(json1, json2, 'not_duplicate')) // => [ 'three', 'four' ]