Qual è il modo più veloce o più elegante per calcolare una differenza di set utilizzando gli array Javascript?

Siano Ae Bsiano due insiemi. Sto cercando modi molto veloci o eleganti per calcolare la differenza di set ( A - Bo A \B, a seconda delle preferenze) tra di loro. I due set vengono memorizzati e manipolati come array Javascript, come dice il titolo.

Appunti:

• I trucchi specifici del geco vanno bene
• Preferirei attenermi alle funzioni native (ma sono aperto a una libreria leggera se è molto più veloce)
• Ho visto, ma non testato, JS.Set (vedi punto precedente)

Modifica: ho notato un commento sui set contenenti elementi duplicati. Quando dico "set" mi riferisco alla definizione matematica, il che significa (tra le altre cose) che non contengono elementi duplicati.

se non so se è il più efficace, ma forse il più breve

A = [1, 2, 3, 4];
B = [1, 3, 4, 7];

diff = A.filter(function(x) { return B.indexOf(x) < 0 })

console.log(diff);

Aggiornato a ES6:

A = [1, 2, 3, 4];
B = [1, 3, 4, 7];

diff = A.filter(x => !B.includes(x) );

console.log(diff);

Bene, 7 anni dopo, con l' oggetto Set di ES6 è abbastanza facile (ma ancora non compatto come quello di Python A - B ) e, a quanto riferito, più veloce rispetto indexOfagli array di grandi dimensioni:

console.clear();
let a = new Set([1, 2, 3, 4]);
let b = new Set([5, 4, 3, 2]);


let a_minus_b = new Set([...a].filter(x => !b.has(x)));
let b_minus_a = new Set([...b].filter(x => !a.has(x)));
let a_intersect_b = new Set([...a].filter(x => b.has(x))); 

console.log([...a_minus_b]) // {1}
console.log([...b_minus_a]) // {5}
console.log([...a_intersect_b]) // {2,3,4}

È possibile utilizzare un oggetto come mappa per evitare la scansione lineare Bper ogni elemento Acome nella risposta di user187291 :

function setMinus(A, B) {
    var map = {}, C = [];

    for(var i = B.length; i--; )
        map[B[i].toSource()] = null; // any other value would do

    for(var i = A.length; i--; ) {
        if(!map.hasOwnProperty(A[i].toSource()))
            C.push(A[i]);
    }

    return C;
}

Il toSource()metodo non standard viene utilizzato per ottenere nomi di proprietà univoci; se tutti gli elementi hanno già rappresentazioni di stringa univoche (come nel caso dei numeri), è possibile accelerare il codice eliminando le toSource()chiamate.

Il più breve, utilizzando jQuery, è:

var A = [1, 2, 3, 4];
var B = [1, 3, 4, 7];

var diff = $(A).not(B);

console.log(diff.toArray());

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

Vorrei hash l'array B, quindi manterrei i valori dell'array A non presente in B:

function getHash(array){
  // Hash an array into a set of properties
  //
  // params:
  //   array - (array) (!nil) the array to hash
  //
  // return: (object)
  //   hash object with one property set to true for each value in the array

  var hash = {};
  for (var i=0; i<array.length; i++){
    hash[ array[i] ] = true;
  }
  return hash;
}

function getDifference(a, b){
  // compute the difference a\b
  //
  // params:
  //   a - (array) (!nil) first array as a set of values (no duplicates)
  //   b - (array) (!nil) second array as a set of values (no duplicates)
  //
  // return: (array)
  //   the set of values (no duplicates) in array a and not in b, 
  //   listed in the same order as in array a.

  var hash = getHash(b);
  var diff = [];
  for (var i=0; i<a.length; i++){
    var value = a[i];
    if ( !hash[value]){
      diff.push(value);
    }
  }
  return diff;
}

Incorporando l'idea di Christoph e assumendo un paio di metodi di iterazione non standard su array e oggetti / hash ( eache amici), possiamo ottenere la differenza di set, l'unione e l'intersezione in tempo lineare in circa 20 righe totali:

var setOPs = {
  minusAB : function (a, b) {
    var h = {};
    b.each(function (v) { h[v] = true; });
    return a.filter(function (v) { return !h.hasOwnProperty(v); });
  },
  unionAB : function (a, b) {
    var h = {}, f = function (v) { h[v] = true; };
    a.each(f);
    b.each(f);
    return myUtils.keys(h);
  },
  intersectAB : function (a, b) {
    var h = {};
    a.each(function (v) { h[v] = 1; });
    b.each(function (v) { h[v] = (h[v] || 0) + 1; });
    var fnSel = function (v, count) { return count > 1; };
    var fnVal = function (v, c) { return v; };
    return myUtils.select(h, fnSel, fnVal);
  }
};

Ciò presuppone che eachefilter siano definiti per gli array e che abbiamo due metodi di utilità:

• myUtils.keys(hash): restituisce un array con le chiavi dell'hash

• myUtils.select(hash, fnSelector, fnEvaluator): restituisce un array con i risultati della chiamata fnEvaluator sulle coppie chiave / valore per le quali fnSelectorrestituisce true.

Il select()è vagamente ispirato a Common Lisp, ed è semplicemente filter()e map()arrotolato in uno. (Sarebbe meglio averli definiti Object.prototype, ma così facendo si rovina il caos con jQuery, quindi ho optato per metodi di utilità statici.)

Prestazioni: test con

var a = [], b = [];
for (var i = 100000; i--; ) {
  if (i % 2 !== 0) a.push(i);
  if (i % 3 !== 0) b.push(i);
}

fornisce due set con 50.000 e 66.666 elementi. Con questi valori AB impiega circa 75 ms, mentre l'unione e l'intersezione sono circa 150 ms ciascuna. (Mac Safari 4.0, utilizzando Javascript Date per i tempi.)

Penso che sia un discreto guadagno per 20 righe di codice.

Utilizzo di Underscore.js (libreria per JS funzionale)

>>> var foo = [1,2,3]
>>> var bar = [1,2,4]
>>> _.difference(foo, bar);
[4]

Alcune semplici funzioni, prese in prestito dalla risposta di @ milan:

const setDifference = (a, b) => new Set([...a].filter(x => !b.has(x)));
const setIntersection = (a, b) => new Set([...a].filter(x => b.has(x)));
const setUnion = (a, b) => new Set([...a, ...b]);

Uso:

const a = new Set([1, 2]);
const b = new Set([2, 3]);

setDifference(a, b); // Set { 1 }
setIntersection(a, b); // Set { 2 }
setUnion(a, b); // Set { 1, 2, 3 }

Per quanto riguarda il modo a digiuno, questo non è così elegante ma ho eseguito alcuni test per essere sicuro. Il caricamento di un array come oggetto è molto più veloce da elaborare in grandi quantità:

var t, a, b, c, objA;

    // Fill some arrays to compare
a = Array(30000).fill(0).map(function(v,i) {
    return i.toFixed();
});
b = Array(20000).fill(0).map(function(v,i) {
    return (i*2).toFixed();
});

    // Simple indexOf inside filter
t = Date.now();
c = b.filter(function(v) { return a.indexOf(v) < 0; });
console.log('completed indexOf in %j ms with result %j length', Date.now() - t, c.length);

    // Load `a` as Object `A` first to avoid indexOf in filter
t = Date.now();
objA = {};
a.forEach(function(v) { objA[v] = true; });
c = b.filter(function(v) { return !objA[v]; });
console.log('completed Object in %j ms with result %j length', Date.now() - t, c.length);

risultati:

completed indexOf in 1219 ms with result 5000 length
completed Object in 8 ms with result 5000 length

Tuttavia, funziona solo con le stringhe . Se prevedi di confrontare set numerati, ti consigliamo di mappare i risultati con parseFloat .

Funziona, ma penso che un altro sia molto più corto e anche elegante

A = [1, 'a', 'b', 12];
B = ['a', 3, 4, 'b'];

diff_set = {
    ar : {},
    diff : Array(),
    remove_set : function(a) { ar = a; return this; },
    remove: function (el) {
        if(ar.indexOf(el)<0) this.diff.push(el);
    }
}

A.forEach(diff_set.remove_set(B).remove,diff_set);
C = diff_set.diff;