How to get the difference between two arrays in JavaScript

Question

Is there a way to return the difference between two arrays in JavaScript   For example   var a1     a    b    var a2     a    b    c    d        need   c    d

User · Answer

I was looking for a simple answer that didn't involve using different libraries, and I came up with my own that I don't think has been mentioned here. I don't know how efficient it is or anything but it works;

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

For my code I need duplicates taken out as well, but I guess that isn't always preferred.

I guess the main downside is it's potentially comparing many options that have already been rejected.

User · Answer

yet another answer  but seems nobody mentioned jsperf where they compare several algorithms and technology support  https   jsperf com array-difference-javascript  seems using filter gets the best results  thanks

User · Answer

A cleaner approach in ES6 is the following solution   var a1     a    b    var a2     a    b    c    d      Difference  a2 filter d   gt   a1 includes d      gives   c    d     Intersection  a2 filter d   gt  a1 includes d      gives   a    b     Disjunctive Union  Symmetric Difference        a2 filter d   gt   a1 includes d         a1 filter d   gt   a2 includes d

User · Answer

You can use a common object and count the frequency of each value in the first array  For the second array  decrement the value in the common object  Then iterate through all keys and add all the keys whose values is more than 1    x000D   x000D  const difference    a1  a2    gt    x000D    var obj       x000D    a1 forEach v   gt  obj v     obj v     0    1   x000D    a2 forEach v   gt  obj v     obj v     0  - 1   x000D    return Object x000D         keys obj  x000D         reduce  r k    gt    x000D          if obj k   gt  0  x000D            r   r concat Array from  length  obj k    fill k    x000D          return r  x000D               x000D     x000D  const result   difference   a    a    b    c    d      a    b     x000D  console log result   x000D   x000D   x000D

User · Answer

function diffArray arr1  arr2      var newArr   arr1 concat arr2     return newArr filter function i       return newArr indexOf i     newArr lastIndexOf i             this is works for me

User · Answer

It feels easier to process this as partial functions to me  Quite surprised not to see a functional programming solution  here is mine in ES6   const arrayDiff    a  b    gt      return diff b  a      const contains    needle    gt   array    gt      for  let i 0  i  lt  array length  i          if  array i     needle  return true         return false     const diff    compare    gt        return  array    gt  array filter  elem    gt   contains elem  compare

User · Answer

The above answer by Joshaven Potter is great  But it returns elements in array B that are not in array C  but not the other way around  For example  if var a  1 2 3 4 5 6  diff   3 4 5 7    then it will output       1 2 6   but not  1 2 6 7   which is the actual difference between the two  You can still use Potter s code above but simply redo the comparison once backwards too   Array prototype diff   function a        return this filter function i   return   a indexOf i   gt  -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     This should output    1  2  6  7

User · Answer

This question is old but is still the top hit for javascript array subtraction so I wanted to add the solution I am using  This fits for the following case   var a1    1 2 2 3  var a2    1 2    result    2 3    The following method will produced the desired result   function arrayDifference minuend  subtrahend      for  var i   0  i  lt  minuend length  i          var j   subtrahend indexOf minuend i       if  j    -1          minuend splice i  1         subtrahend splice j  1               return minuend      It should be noted that the function does not include values from the subtrahend that are not present in the minuend   var a1    1 2 3  var a2    2 3 4    result    1

User · Answer

Here is what I use   var newArr   a1 filter function elem                return a2 indexOf elem      -1             concat  a2 filter function elem                return a1 indexOf elem      -1               console log newArr     or this one  var newArr   a1 concat a2           function check item                if  a1 indexOf item      -1    a2 indexOf item      -1                    return item                                  return newArr filter check

User · Answer

Using http   phrogz net JS ArraySetMath js you can   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

User · Answer

CoffeeScript version   diff    val for val in array1 when val not in array2

User · Answer

This is by far the easiest way to get exactly the result you are looking for  using jQuery   var diff     old array  not new array  get      diff now contains what was in old array that is not in new array

User · Answer

Here is a slightly modified version that uses an Object to store the hashes can handle numbers as well as strings in arrays  function arrDiff a  b      const hash         a forEach n   gt    hash n    n        b forEach n   gt        if  hash n           delete hash n         else         hash n    n                return Object values hash

User · Answer

This is working  basically merge the two arrays  look for the duplicates and push what is not duplicated into a new array which is the difference    x000D   x000D  function diff arr1  arr2    x000D    var newArr       x000D    var arr   arr1 concat arr2   x000D     x000D    for  var i in arr   x000D      var f   arr i   x000D      var t   0  x000D      for  j 0  j lt arr length  j     x000D        if arr j      f   x000D          t     x000D            x000D        x000D      if  t     1   x000D        newArr push f   x000D            x000D       x000D    return newArr  x000D    x000D   x000D   x000D

User · Answer

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        That simple  Could use with objects also  checking one property of object  Like   if  a2 i  id     a1 j  id  found   true

User · Answer

x000D   x000D  Array prototype diff   function a        return this filter function i   return a indexOf i   lt  0                           Examples                    const dif1    1 2 3 4 5 6  diff   3 4 5       console log dif1        gt   1  2  6    const dif2     test1    test2   test3   test4   test5   test6   diff   test1   test2   test3   test4       console log dif2        gt    test5    test6   x000D   x000D   x000D   Note  indexOf   and  filter   are not available before IE9

User · Answer

With the arrival of ES6 with sets and splat operator  at the time of being works only in Firefox  check compatibility table   you can write the following one liner  var a     a    b    c    d    var b     a    b    var b1   new Set b   var difference       new Set a filter x   gt   b1 has x       which will result in    quot c quot    quot d quot

User · Answer

var arrayDifference   function arr1  arr2     if arr1  amp  amp  arr1 length       if arr2  amp  amp  arr2 length  gt  0         for  var i 0  itemIndex  i lt 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

User · Answer

Simply compares all values and returns array with the values that do not repeat   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  lt  l  x   0  i                 find all positions         while   pos   diff indexOf items i     gt  -1                   remove item   increase found count             diff splice pos  1   amp  amp  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

User · Answer

const difference   function  baseArray  arrayToCampare  callback    a  b    gt  a    b      if    arrayToCampare instanceof Array         return baseArray        return baseArray filter baseEl   gt      arrayToCampare every compareEl   gt  callback baseEl  compareEl

User · Answer

If the arrays are not of simple types  then one of the above answers can be adapted   Array prototype diff   function a            return this filter function i   return a map function e    return JSON stringify e      indexOf JSON stringify i    lt  0              This method works on arrays of complex objects

User · Answer

I assume you are comparing a normal array  If not  you need to change the for loop to a for    in loop    x000D   x000D  function arr diff  a1  a2    x000D   x000D      var a       diff       x000D   x000D      for  var i   0  i  lt  a1 length  i      x000D          a a1 i     true  x000D        x000D   x000D      for  var i   0  i  lt  a2 length  i      x000D          if  a a2 i      x000D              delete a a2 i    x000D            else   x000D              a a2 i     true  x000D            x000D        x000D   x000D      for  var k in a    x000D          diff push k   x000D        x000D   x000D      return diff  x000D    x000D   x000D  console log arr diff   a    b      a    b    c    d      x000D  console log arr diff  abcd    abcde     x000D  console log arr diff  zxc    zxc     x000D   x000D   x000D    A better solution  if you don t care about backward compatibility  is using filter  But still  this solution works

User · Answer

A solution using indexOf   will be ok for small arrays but as they grow in length the performance of the algorithm approaches O n 2    Here s a solution that will perform better for very large arrays by using objects as associative arrays to store the array entries as keys  it also eliminates duplicate entries automatically but only works with string values  or values which can be safely stored as strings    function arrayDiff a1  a2      var o1     o2     diff     i  len  k    for  i 0  len a1 length  i lt len  i      o1 a1 i     true      for  i 0  len a2 length  i lt 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        gt    c    d   arrayDiff a2  a1        gt    c    d

User · Answer

You could use a Set in this case  It is optimized for this kind of operation  union  intersection  difference    Make sure it applies to your case  once it allows no duplicates   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     - gt  Set 1 3 5 7 9

User · Answer

If not use hasOwnProperty then we have incorrect elements  For example     1 2 3  diff  1 2      Return   3    remove    diff   This is the wrong version   My version   Array prototype diff   function array2          var a               diff               array1   this             for  var i   0  i  lt  array1 length  i            a array1 i     true            for  var i   0  i  lt  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

User · Answer

Cast to string object type     1  1  toString        1  1  toString       true

User · Answer

Based on Thinker s answer  but allows duplicates   The map increments map values as they appear  and decrements them if they are in the other array   Any leftover will be included in the difference    x000D   x000D  function diff curr  prev    x000D    let a   curr split     sort    b   prev split     sort    c   arrDiff a  b   x000D    console log JSON stringify a    -   JSON stringify b        JSON stringify c    x000D    return c  x000D    x000D   x000D  function arrDiff larger  smaller    x000D    var entries       x000D    for  var i   0  i  lt  larger length  i      x000D      entries larger i      entries larger i      0    1  x000D      x000D    for  var i   0  i  lt  smaller length  i      x000D      if  entries smaller i      x000D        entries smaller i   -  1  x000D        else   x000D        entries smaller i      entries smaller i      0    1  x000D        x000D      x000D    return Object keys entries  sort   reduce  diff  key    gt    x000D      if  entries key   gt  0    x000D        for  var i   0  i  lt  entries key   i      x000D          diff push key   x000D          x000D        x000D      return diff  x000D            x000D    x000D   x000D     Smaller is a subset of Larger x000D  console log  Result    JSON stringify diff  ENLIGHTEN    LENGTHEN           I   x000D  console log  Result    JSON stringify diff  STRENGTH    TENTHS              G  R   x000D   x000D     Both have a unique value x000D  console log  Result    JSON stringify diff  BUBBLE    RUBBLE                B  R   x000D   as-console-wrapper   top  0  max-height  100   important    x000D   x000D   x000D

User · Answer

The difference method in Underscore  or its drop-in replacement  Lo-Dash  can do this too    R eturns the values from array that are not present in the other arrays    difference  1  2  3  4  5    5  2  10      gt   1  3  4    As with any Underscore function  you could also use it in a more object-oriented style      1  2  3  4  5   difference  5  2  10

User · Answer

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

User · Answer

If you re array contains objects it becomes a bit more difficult if you want to compare an attribute   Luckily lodash makes this pretty easy using  contains and   pluck   var list1     id  1   id  2    var list1     id  1   id  2    id  3       es6 var results   list2 filter item   gt      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

User · Answer

function diff a1  a2      return a1 concat a2  filter function val  index  arr       return arr indexOf val      arr lastIndexOf val             Merge both the arrays  unique values will appear only once so indexOf   will be the same as lastIndexOf

User · Answer

Quick solution  Although it seems that others have already posted different variations of the same method  I am not sure this is the best for huge arrays  but it works for my arrays which won t be larger than 10 or 15   Difference b - a  for var i   0  i  lt  b length  i       for var j   0  j  lt  a length  j          var loc   b indexOf a j        if loc  gt  -1         b splice loc  1

User · Answer

Just thinking    for the sake of a challenge  -  would this work     for basic arrays of strings  numbers  etc   no nested arrays  function diffArrays arr1  arr2  returnUnion     var ret         var test         var bigArray  smallArray  key    if arr1 length  gt   arr2 length       bigArray   arr1      smallArray   arr2      else       bigArray   arr2      smallArray   arr1        for var i 0 i lt bigArray length i         key   bigArray i       test key    true        if  returnUnion         diffing     for var i 0 i lt smallArray length i           key   smallArray i         if  test key            test key    null                    else         union     for var i 0 i lt 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     Note the sorting will likely not be as noted above    but if desired  call  sort   on the array to sort it

User · Answer

I wanted a similar function which took in an old array and a new array and gave me an array of added items and an array of removed items  and I wanted it to be efficient  so no  contains     You can play with my proposed solution here  http   jsbin com osewu3 12   Can anyone see any problems improvements to that algorithm  Thanks   Code listing   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  lt  o length  amp  amp  np  lt  n length          if  o op   lt  n np                  push to diff            r push o op              op                  else if  o op   gt  n np                  push to diff            a push n np              np                  else             op   np                      add remaining items   if  np  lt  n length       a   a concat n slice np  n length      if  op  lt  o length       r   r concat o slice op  o length       return  added  a  removed  r

User · Answer

littlebit fix for the best answer  function arr diff a1  a2      var a     diff       for var i 0 i lt a1 length i        a a1 i   a1 i     for var i 0 i lt 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      this will take current type of element in consideration  b c when we make a a1 i   it converts a value to string from its oroginal value  so we lost actual value

User · Answer

Plain JavaScript  There are two possible intepretations for  difference   I ll let you choose which one you want  Say you have   var a1     a    b         var a2          b    c       If you want to get   a    use this function   function difference a1  a2      var result         for  var i   0  i  lt  a1 length  i          if  a2 indexOf a1 i       -1          result push a1 i                return result     If you want to get   a    c    all elements contained in either a1 or a2  but not both -- the so-called symmetric difference   use this function   function symmetricDifference a1  a2      var result         for  var i   0  i  lt  a1 length  i          if  a2 indexOf a1 i       -1          result push a1 i                for  i   0  i  lt  a2 length  i          if  a1 indexOf a2 i       -1          result push a2 i                return result       Lodash   Underscore  If you are using lodash  you can use   difference a1  a2   case 1 above  or   xor a1  a2   case 2    If you are using Underscore js  you can use the   difference a1  a2  function for case 1   ES6 Set  for very large arrays  The code above works on all browsers  However  for large arrays of more than about 10 000 items  it becomes quite slow  because it has O n    complexity  On many modern browsers  we can take advantage of the ES6 Set object to speed things up  Lodash automatically uses Set when it s available  If you are not using lodash  use the following implementation  inspired by Axel Rauschmayer s blog post   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        Notes  The behavior for all examples may be surprising or non-obvious if you care about -0   0  NaN or sparse arrays   For most uses  this doesn t matter

User · Answer

The hard way  in case you would like to do something more fancy than  indexOf   var difference   function  source  target        return source reduce function  diff  current             if  target indexOf current      -1                 diff push current                       return diff                   The easy way  var difference   function  source  target        return source filter function  current            return target indexOf current      -1

User · Answer

Array prototype difference   function e        return this filter function i   return e indexOf i   lt  0         eg -    1 2 3 4 5 6 7  difference   3 4 5          gt   1  2  6   7

User · Answer

var compare   array1 length  gt  array2 length   array1   array2  var compareWith   array1 length  gt  array2 length   array2   array1  var uniqueValues   compareWith filter function value                       if compare indexOf vakye     -1                         return true                          This will both check which one is the larger one among the arrays and then will do the comparison

User · Answer

Contributing with a jQuery solution that I m currently using   if   Array prototype diff        Array prototype diff   function  a            return   grep this  function  i    return   inArray i  a      -1

User · Answer

here s the function I use to get the difference between 2 arrays - It s good for numerical  string  mixed num string arrays  not object literal within arrays   multidimentional arrays  function diff arr1  arr2         var x           t       function uniq a  b            t   b           if   b     0  amp  amp  x b 1    a                  t  gt  0  amp  amp  a     x b 1   amp  amp  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

User · Answer

function diffArray newArr  oldArr        var newSet   new Set newArr      var diff          oldArr forEach  a    gt            if  newSet delete a  diff push a             return diff concat Array from newSet

User · Answer

Very Simple Solution with the filter function of JavaScript    x000D   x000D  var a1     a    b    x000D  var a2     a    b    c    d    x000D   x000D  function diffArray arr1  arr2    x000D    var newArr       x000D    var myArr   arr1 concat arr2   x000D     x000D      newArr   myArr filter function item   x000D        return arr2 indexOf item   lt  0    arr1 indexOf item   lt  0  x000D          x000D     alert newArr   x000D    x000D   x000D  diffArray a1  a2   x000D   x000D   x000D

User · Answer

Here is how I get two arrays difference  Pure and clean   It will return a object that contain  add list  and  remove list      function getDiff past  now            let ret     add      remove                for  var i   0  i  lt  now length  i                if  past indexOf now i    lt  0              ret  add   push now i                      for  var i   0  i  lt  past length  i                if  now indexOf past i    lt  0              ret  remove   push past i                      return ret

User · Answer

To get the symmetric difference you need to compare the arrays in both ways  or in all the ways in case of multiple arrays       ES7  ECMAScript 2016      diff between just two arrays  function arrayDiff a  b        return              a filter x   gt   b includes x               b filter x   gt   a includes x                diff between multiple arrays  function arrayDiff    arrays        return    concat    arrays map   arr  i    gt            const others   arrays slice 0           others splice i  1           const unique       new Set    concat    others             return arr filter x   gt   unique includes x                   ES6  ECMAScript 2015      diff between just two arrays  function arrayDiff a  b        return              a filter x   gt  b indexOf x      -1              b filter x   gt  a indexOf x      -1               diff between multiple arrays  function arrayDiff    arrays        return    concat    arrays map   arr  i    gt            const others   arrays slice 0           others splice i  1           const unique       new Set    concat    others             return arr filter x   gt  unique indexOf x      -1                  ES5  ECMAScript 5 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   gt  unique indexOf x      -1                return diff      Example      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       Difference between Arrays of Objects  function arrayDiffByKey key     arrays        return    concat    arrays map   arr  i    gt            const others   arrays slice 0           others splice i  1           const unique       new Set    concat    others             return arr filter  x   gt               unique some y   gt  x key      y key                           Example   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

User · Answer

This returns an array of unique values  or an array of duplicates  or an array of non-duplicates  difference  for any 2 arrays based on the  type  argument           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  lt  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        gt     one    two    three    four    console log uniq n shit json1  json2   uniq         gt     one    two    three    four    console log uniq n shit json1  json2   duplicate         gt     one    two    console log uniq n shit json1  json2   not duplicate         gt     three    four

User · Answer

I fall into this question  which was to get the difference of two simple arrays  var a1     a    b    var a2     a    b    c    d        need   c    d     and I don t see why not go with the basic for loops    for var i 0  i  lt  a1 length  i        for var j 0  j  lt  a2 length  j          if a1 i     a2 j           a2 splice j  1                 which would return the needed   c    d     edit  proposed right above  seen to late   Anyway  any good reason to avoid this simple solution

User · Answer

to subtract one array from another  simply use the snippet below   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   lt  0        It will returns   1  2   6   that are items of first array which don t exist in the second   Therefore  according to your problem sample  following code is the exact solution   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   lt  0

User · Answer

I ve tried all of these above but none worked when you needed to match without accepting duplicates   For example   var a1    1  2  1  4   a2    1  2  4     Would return an empty diff array because 2 would be found once in the second array  even though we need it to match twice   So I ve managed to fix something up   Array prototype diff   function a        return this filter function item            match   a indexOf item           if  match              a splice match  1           return match  lt  0

User · Answer

function arrayDiff a  b          return a concat b  filter val   gt    b includes val              or  return a concat b  filter val   gt    a includes val   amp  amp  b includes val

User · Answer

if you don t care about original arrays and have no problem to edit them then this is quicker algorithm   let iterator   arrayA values   let result      for  entryA of iterator        if   arrayB includes entryA             result push entryA        else           arrayB splice arrayB indexOf entryA   1            result push    arrayB  return result

User · Answer

Based on previous answers    depends if you want an efficient or  quot nice oneliner quot  solution  There are 3 approaches in general      quot manual iterative quot   using indexOf  - naive with O n2  complexity  slow  var array diff naive   function a b     var i  la   a length  lb   b length  res         if   la  return b  else if   lb  return a   for  i   0  i  lt  la  i           if  b indexOf a i       -1  res push a i        for  i   0  i  lt  lb  i           if  a indexOf b i       -1  res push b i        return res       quot abstract iterative quot   using filter and concat library methods  - syntactic sugar for manual iterative  looks nicer  still sucks  var array diff modern   function a1 a2      return a1 filter function v    return   a2 includes v             concat a2 filter function v    return  a1 includes v            quot using hashtable quot   using object keys  - much more efficient - only O n   but has slightly limited range of input array values  var array diff hash   function a1 a2     var a       diff         for  var i   0  i  lt  a1 length  i           a a1 i     true       for  var i   0  i  lt  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       See this on jsperf https   jsperf com array-diff-algo

User · Answer

To find the difference of 2 arrays without duplicates  function difference arr1  arr2      let setA   new Set arr1     let differenceSet   new Set arr2 filter ele   gt   setA has ele       return     differenceSet        1 difference  2 2 3 4   2 3 3 4   will return    2 difference  1 2 3   4 5 6   will return  4 5 6  3 difference  1 2 3 4   1 2   will return    4 difference  1 2   1 2 3 4   will return  3 4  Note  The above solution requires that you always send the larger array as the second parameter  To find the absolute difference  you will need to first find the larger array of the two and then work on them  To find the absolute difference of 2 arrays without duplicates  function absDifference arr1  arr2      const  larger  smaller    arr1 length  gt  arr2 length       larger  arr1  smaller  arr2     larger  arr2  smaller  arr1       let setA   new Set smaller     let absDifferenceSet   new Set larger filter ele   gt   setA has ele       return     absDifferenceSet        1 absDifference  2 2 3 4   2 3 3 4   will return    2 absDifference  1 2 3   4 5 6   will return  4 5 6  3 absDifference  1 2 3 4   1 2   will return  3 4  4 absDifference  1 2   1 2 3 4   will return  3 4  Note the example 3 from both the solutions

User · Answer

There is a better way using ES7     Intersection   let intersection   arr1 filter x   gt  arr2 includes x        For  1 2 3   2 3  it will yield  2 3   On the other hand  for  1 2 3   2 3 5  will return the same thing     Difference  let difference   arr1 filter x   gt   arr2 includes x        For  1 2 3   2 3  it will yield  1   On the other hand  for  1 2 3   2 3 5  will return the same thing     For a symmetric difference  you can do   let difference   arr1                   filter x   gt   arr2 includes x                     concat arr2 filter x   gt   arr1 includes x         This way  you will get an array containing all the elements of arr1 that are not in arr2 and vice-versa  As  Joshaven Potter pointed out on his answer  you can add this to Array prototype so it can be used like this   Array prototype diff   function arr2    return this filter x   gt   arr2 includes x       1  2  3  diff  2  3

User · Answer

function array diff a  b         let array           for let i   0  i  lt a length  i              let k   0          for  let j   0  j  lt  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

User · Answer

You can use underscore js   http   underscorejs org  intersection  You have needed methods for array       difference  1  2  3  4  5    5  2  10      gt   1  3  4     intersection  1  2  3    101  2  1  10    2  1      gt   1  2

User · Answer

This was inspired by the accepted answer by Thinker  but Thinker s answer seems to assume the arrays are sets   It falls apart if the arrays are    1    2    and    1    1    2    2     The difference between those arrays is    1    2      The following solution is O n n   so not ideal  but if you have big arrays  it has memory advantages over Thinker s solution as well    If you re dealing with sets in the first place  Thinker s solution is definitely better   If you have a newer version of Javascript with access to filters  you should use those as well   This is only for those who aren t dealing with sets and are using an older version of JavaScript  for whatever reason      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  lt  array length    i                var index   original indexOf array i                if  index  gt  -1                     original splice index  1                 else                    diff push array i                                     for  var i 0  i  lt  original length    i                diff push original i                      return diff

User · Answer

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

User · Answer

There s a lot of problems with the answers I m reading here that make them of limited value in practical programming applications   First and foremost  you re going to want to have a way to control what it means for two items in the array to be  equal   The     comparison is not going to cut it if you re trying to figure out whether to update an array of objects based on an ID or something like that  which frankly is probably one of the most likely scenarios in which you will want a diff function  It also limits you to arrays of things that can be compared with the     operator  i e  strings  ints  etc  and that s pretty much unacceptable for grown-ups   Secondly  there are three state outcomes of a diff operation    elements that are in the first array but not in the second elements that are common to both arrays elements that are in the second array but not in the first   I think this means you need no less than 2 loops  but am open to dirty tricks if anybody knows a way to reduce it to one   Here s something I cobbled together  and I want to stress that I ABSOLUTELY DO NOT CARE that it doesn t work in old versions of Microshaft browsers  If you work in an inferior coding environment like IE  it s up to you to modify it to work within the unsatisfactory limitations you re stuck with   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

User · Answer

Similar to Ian Grainger s solution  but in typescript    function findDiffs arrayOne  string    arrayTwo  string           let onlyInArrayOne          let onlyInArrayTwo          let share          let  arrayOneCopy  arrayTwoCopy         arrayOne       arrayTwo        arrayOneCopy sort    arrayTwoCopy sort        while  arrayOneCopy length     0  amp  amp  arrayTwoCopy length     0            if  arrayOneCopy 0     arrayTwoCopy 0                 share push arrayOneCopy 0               arrayOneCopy splice 0  1              arrayTwoCopy splice 0  1                    if  arrayOneCopy 0   lt  arrayTwoCopy 0                 onlyInArrayOne push arrayOneCopy 0               arrayOneCopy splice 0  1                    if  arrayOneCopy 0   gt  arrayTwoCopy 0                 onlyInArrayTwo push arrayTwoCopy 0               arrayTwoCopy splice 0  1                      onlyInArrayTwo   onlyInArrayTwo concat arrayTwoCopy      onlyInArrayOne   onlyInArrayOne concat arrayOneCopy       return           onlyInArrayOne          onlyInArrayTwo          share          diff  onlyInArrayOne concat onlyInArrayTwo              arrayOne     a    b    c    m    y        arrayTwo     c    b    f    h          Results               onlyInArrayOne     a    m    y           onlyInArrayTwo     f    h           share     b    c           diff     a    m    y    f    h

User · Answer

Data   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         using filter   var diff   new storage  filter x   gt   if   old storage filter y   gt  y id order  x id order   length  return x         concat old storage      filter x   gt   if   new storage filter y   gt  y id order  x id order   length  return x                               console log JSON stringify diff     result difference in two arrays     id order   0006     id order   0001     id order   0002     id order   0005

User · Answer

How about this   Array prototype contains   function needle     for  var i 0  i lt 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      So this way you can do array1 diff array2  to get their difference  Horrible time complexity for the algorithm though - O array1 length x array2 length  I believe

User · Answer

In response to the person who wanted to subtract one array from another     If no more than say 1000 elements try this     Setup a new variable to duplicate Array01 and call it Array03   Now  use the bubble sort algorithm to compare the elements of Array01 with Array02 and whenever you find a match do the following to Array03      if  Array01 x   Array02 y    Array03 splice x 1      NB  We are modifying Array03 instead of Array01 so as not to screw up the nested loops of the bubble sort   Finally  copy the contents of Array03 to Array01 with a simple assignment  and you re done

User · Answer

es6 approach     function diff a  b      var u   a slice      dup the array   b map e   gt        if  u indexOf e   gt  -1  delete u u indexOf e       else u push e      add non existing item to temp array        return u filter  x    gt   return  x    null      flatten result

User · Answer

just trimming the string to ensure     spaces wont affect the diff  function arr diff a1  a2        var a     diff         for var i 0 i lt a1 length i            a a1 i   true      for var i 0 i lt 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

User · Answer

Samuel   For my code I need duplicates taken out as well  but I guess that isn t always preferred  I guess the main downside is it s potentially comparing many options that have already been rejected    When comparing TWO lists  Arrays  etc  and the elements are less than 1000  the industry standard in the 3GL world is to use the bubble sort which avoids dupes    The code would look something like this     untested but it should work   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 lt Array02 length  x       for y 0  y lt Array01 length-1  y        if  Array01 y   Array02 x    Array03 splice y 1       Array01 Array03    To test the output     for y 0  y lt Array01 length  y     document write Array01 y

User · Answer

Pure JavaScript solution  no libraries  Compatible with older browsers  doesn t use filter  O n 2  Optional fn callback parameter that lets you specify how to compare array items    x000D   x000D  function diff a  b  fn   x000D      var max   Math max a length  b length   x000D          d       x000D      fn   typeof fn      function    fn   false x000D      for var i 0  i  lt  max  i     x000D          var ac   i  lt  a length   a i    undefined x000D              bc   i  lt  b length   b i    undefined  x000D          for var k 0  k  lt  max  k     x000D              ac   ac     undefined     k  lt  b length     fn   fn ac  b k     ac    b k      undefined   ac  x000D              bc   bc     undefined     k  lt  a length     fn   fn bc  a k     bc    a k      undefined   bc  x000D              if ac    undefined    bc    undefined  break  x000D            x000D          ac     undefined    d push ac   x000D          bc     undefined    d push bc   x000D        x000D      return d  x000D    x000D   x000D  alert  x000D       Test 1       x000D      diff  x000D           1  2  3  4   x000D           1  4  5  6  7  x000D          join         x000D        nTest 2      x000D      diff  x000D            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     x000D            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     x000D          function a  b   return a id    b id    x000D        join       x000D     x000D   x000D   x000D

User · Answer

Use extra memory to do this  That way you can solve it with less time complexity  O n  instead of o n n    function getDiff arr1 arr2   let k       let diff      arr1 map i  gt       if   k hasOwnProperty i             k i    1           arr2 map j  gt       if   k hasOwnProperty j             k j    1        else           k j    2            for  var i in k        if  k i      1          diff push  i    return diff   getDiff  4  3  52  3  5  67  9  3   4  5  6  75  3  334  5  5  6

User · Answer

Functional approach with ES2015  Computing the difference between two arrays is one of the Set operations  The term already indicates that the native Set type should be used  in order to increase the lookup speed  Anyway  there are three permutations when you compute the difference between two sets     left difference   -intersection   -right difference   -left difference   -intersection    right difference    left difference   -intersection    right difference    Here is a functional solution that reflects these permutations   Left difference    x000D   x000D     small  reusable auxiliary functions x000D   x000D  const apply   f   gt  x   gt  f x   x000D  const flip   f   gt  y   gt  x   gt  f x   y   x000D  const createSet   xs   gt  new Set xs   x000D  const filter   f   gt  xs   gt  xs filter apply f    x000D   x000D   x000D     left difference x000D   x000D  const differencel   xs   gt  ys   gt    x000D    const zs   createSet ys   x000D    return filter x   gt  zs has x  x000D         false x000D         true x000D       xs   x000D     x000D   x000D   x000D     mock data x000D   x000D  const xs    1 2 2 3 4 5   x000D  const ys    0 1 2 3 3 3 6 7 8 9   x000D   x000D   x000D     run the computation x000D   x000D  console log  differencel xs   ys     x000D   x000D   x000D    Right difference   differencer is trivial  It is just differencel with flipped arguments  You can write a function for convenience  const differencer   flip differencel   That s all   Symmetric difference   Now that we have the left and right one  implementing the symmetric difference gets trivial as well    x000D   x000D     small  reusable auxiliary functions x000D   x000D  const apply   f   gt  x   gt  f x   x000D  const flip   f   gt  y   gt  x   gt  f x   y   x000D  const concat   y   gt  xs   gt  xs concat y   x000D  const createSet   xs   gt  new Set xs   x000D  const filter   f   gt  xs   gt  xs filter apply f    x000D   x000D   x000D     left difference x000D   x000D  const differencel   xs   gt  ys   gt    x000D    const zs   createSet ys   x000D    return filter x   gt  zs has x  x000D         false x000D         true x000D       xs   x000D     x000D   x000D   x000D     symmetric difference x000D   x000D  const difference   ys   gt  xs   gt  x000D   concat differencel xs   ys    flip differencel   xs   ys    x000D   x000D     mock data x000D   x000D  const xs    1 2 2 3 4 5   x000D  const ys    0 1 2 3 3 3 6 7 8 9   x000D   x000D   x000D     run the computation x000D   x000D  console log  difference xs   ys     x000D   x000D   x000D    I guess this example is a good starting point to obtain an impression what functional programming means   Programming with building blocks that can be plugged together in many different ways

User · Answer

Another way to solve the problem function diffArray arr1  arr2        return arr1 concat arr2  filter function  val            if    arr1 includes val   amp  amp  arr2 includes val                return val             diffArray  1  2  3  7    3  2  1  4  5          return  7  4  5   Also  you can use arrow function syntax  const diffArray    arr1  arr2    gt  arr1 concat arr2       filter val   gt    arr1 includes val   amp  amp  arr2 includes val      diffArray  1  2  3  7    3  2  1  4  5          return  7  4  5

User · Answer

The selected answer is only half right   You must compare the arrays both ways to get a complete answer       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       gt     abcd    efjk    9999

User · Answer

I agree with the solution of  luis-sieira  I created bit self explanatory function for beginners to understand easily step by step   function difference oneArr  twoArr     var newArr         newArr   oneArr filter  item   gt         return  twoArr includes item          console log newArr      let arr   twoArr filter  item   gt           return  oneArr includes item               newArr    newArr concat arr     console log newArr    difference  1  2  3  5    1  2  3  4  5

User · Answer

Symmetric and linear complexity  Requires ES6     function arrDiff arr1  arr2        var arrays    arr1  arr2  sort  a  b    gt  a length - b length       var smallSet   new Set arrays 0         return arrays 1  filter x   gt   smallSet has x

[javascript] How to get the difference between two arrays in JavaScript?

Examples related to javascript

Examples related to arrays

Examples related to array-difference