Codice più semplice per l'intersezione di array in javascript

Qual è il codice più semplice e privo di librerie per l'implementazione di intersezioni di array in JavaScript? Voglio scrivere

intersection([1,2,3], [2,3,4,5])

e prendi

[2, 3]

Utilizzare una combinazione di Array.prototype.filtere Array.prototype.indexOf:

array1.filter(value => -1 !== array2.indexOf(value))

O come ha suggerito vrugtehagel nei commenti, è possibile utilizzare il più recente Array.prototype.includesper un codice ancora più semplice:

array1.filter(value => array2.includes(value))

Per i browser più vecchi:

array1.filter(function(n) {
    return array2.indexOf(n) !== -1;
});

Il distruttivo sembra più semplice, specialmente se possiamo supporre che l'input sia ordinato:

/* destructively finds the intersection of 
 * two arrays in a simple fashion.  
 *
 * PARAMS
 *  a - first array, must already be sorted
 *  b - second array, must already be sorted
 *
 * NOTES
 *  State of input arrays is undefined when
 *  the function returns.  They should be 
 *  (prolly) be dumped.
 *
 *  Should have O(n) operations, where n is 
 *    n = MIN(a.length, b.length)
 */
function intersection_destructive(a, b)
{
  var result = [];
  while( a.length > 0 && b.length > 0 )
  {  
     if      (a[0] < b[0] ){ a.shift(); }
     else if (a[0] > b[0] ){ b.shift(); }
     else /* they're equal */
     {
       result.push(a.shift());
       b.shift();
     }
  }

  return result;
}

Non distruttivo deve essere un pelo più complicato, dal momento che dobbiamo tenere traccia degli indici:

/* finds the intersection of 
 * two arrays in a simple fashion.  
 *
 * PARAMS
 *  a - first array, must already be sorted
 *  b - second array, must already be sorted
 *
 * NOTES
 *
 *  Should have O(n) operations, where n is 
 *    n = MIN(a.length(), b.length())
 */
function intersect_safe(a, b)
{
  var ai=0, bi=0;
  var result = [];

  while( ai < a.length && bi < b.length )
  {
     if      (a[ai] < b[bi] ){ ai++; }
     else if (a[ai] > b[bi] ){ bi++; }
     else /* they're equal */
     {
       result.push(a[ai]);
       ai++;
       bi++;
     }
  }

  return result;
}

Se il tuo ambiente supporta ECMAScript 6 Set , un modo semplice e presumibilmente efficace (vedi collegamento alle specifiche):

function intersect(a, b) {
  var setA = new Set(a);
  var setB = new Set(b);
  var intersection = new Set([...setA].filter(x => setB.has(x)));
  return Array.from(intersection);
}

Più breve, ma meno leggibile (anche senza creare l'intersezione aggiuntiva Set):

function intersect(a, b) {
      return [...new Set(a)].filter(x => new Set(b).has(x));
}

Evitare una nuova Setda bogni volta:

function intersect(a, b) {
      var setB = new Set(b);
      return [...new Set(a)].filter(x => setB.has(x));
}

Nota che quando usi i set otterrai solo valori distinti, quindi new Set[1,2,3,3].sizevaluta 3.

Utilizzo di Underscore.js o lodash.js

_.intersection( [0,345,324] , [1,0,324] )  // gives [0,324]

Il mio contributo in termini di ES6. In generale trova l'intersezione di una matrice con un numero indefinito di matrici fornite come argomenti.

Array.prototype.intersect = function(...a) {
  return [this,...a].reduce((p,c) => p.filter(e => c.includes(e)));
}
var arrs = [[0,2,4,6,8],[4,5,6,7],[4,6]],
     arr = [0,1,2,3,4,5,6,7,8,9];

document.write("<pre>" + JSON.stringify(arr.intersect(...arrs)) + "</pre>");

// Return elements of array a that are also in b in linear time:
function intersect(a, b) {
  return a.filter(Set.prototype.has, new Set(b));
}

// Example:
console.log(intersect([1,2,3], [2,3,4,5]));

Raccomando una soluzione succinta che supera le altre implementazioni su input di grandi dimensioni. Se le prestazioni su piccoli ingressi sono importanti, controllare le alternative seguenti.

Alternative e confronto delle prestazioni:

Vedere il frammento seguente per implementazioni alternative e controllare https://jsperf.com/array-intersection-comparison per i confronti delle prestazioni.

function intersect_for(a, b) {
  const result = [];
  const alen = a.length;
  const blen = b.length;
  for (let i = 0; i < alen; ++i) {
    const ai = a[i];
    for (let j = 0; j < blen; ++j) {
      if (ai === b[j]) {
        result.push(ai);
        break;
      }
    }
  } 
  return result;
}

function intersect_filter_indexOf(a, b) {
  return a.filter(el => b.indexOf(el) !== -1);
}

function intersect_filter_in(a, b) {
  const map = b.reduce((map, el) => {map[el] = true; return map}, {});
  return a.filter(el => el in map);
}

function intersect_for_in(a, b) {
  const result = [];
  const map = {};
  for (let i = 0, length = b.length; i < length; ++i) {
    map[b[i]] = true;
  }
  for (let i = 0, length = a.length; i < length; ++i) {
    if (a[i] in map) result.push(a[i]);
  }
  return result;
}

function intersect_filter_includes(a, b) {
  return a.filter(el => b.includes(el));
}

function intersect_filter_has_this(a, b) {
  return a.filter(Set.prototype.has, new Set(b));
}

function intersect_filter_has_arrow(a, b) {
  const set = new Set(b);
  return a.filter(el => set.has(el));
}

function intersect_for_has(a, b) {
  const result = [];
  const set = new Set(b);
  for (let i = 0, length = a.length; i < length; ++i) {
    if (set.has(a[i])) result.push(a[i]);
  }
  return result;
}

Risultati in Firefox 53:

• Ops / sec su array di grandi dimensioni (10.000 elementi):

  filter + has (this)               523 (this answer)
  for + has                         482
  for-loop + in                     279
  filter + in                       242
  for-loops                          24
  filter + includes                  14
  filter + indexOf                   10

• Ops / sec su array di piccole dimensioni (100 elementi):

  for-loop + in                 384,426
  filter + in                   192,066
  for-loops                     159,137
  filter + includes             104,068
  filter + indexOf               71,598
  filter + has (this)            43,531 (this answer)
  filter + has (arrow function)  35,588

Che ne dici di usare solo array associativi?

function intersect(a, b) {
    var d1 = {};
    var d2 = {};
    var results = [];
    for (var i = 0; i < a.length; i++) {
        d1[a[i]] = true;
    }
    for (var j = 0; j < b.length; j++) {
        d2[b[j]] = true;
    }
    for (var k in d1) {
        if (d2[k]) 
            results.push(k);
    }
    return results;
}

modificare:

// new version
function intersect(a, b) {
    var d = {};
    var results = [];
    for (var i = 0; i < b.length; i++) {
        d[b[i]] = true;
    }
    for (var j = 0; j < a.length; j++) {
        if (d[a[j]]) 
            results.push(a[j]);
    }
    return results;
}

1. Ordina
2. controlla uno per uno dall'indice 0, crea un nuovo array da quello.

Qualcosa del genere, non testato bene però.

function intersection(x,y){
 x.sort();y.sort();
 var i=j=0;ret=[];
 while(i<x.length && j<y.length){
  if(x[i]<y[j])i++;
  else if(y[j]<x[i])j++;
  else {
   ret.push(x[i]);
   i++,j++;
  }
 }
 return ret;
}

alert(intersection([1,2,3], [2,3,4,5]));

PS: l'algoritmo previsto solo per Numbers e String normali, l'intersezione di matrici di oggetti arbitrari potrebbe non funzionare.

Le prestazioni dell'implementazione di @ atk per le matrici ordinate di primitive possono essere migliorate usando .pop anziché .shift.

function intersect(array1, array2) {
   var result = [];
   // Don't destroy the original arrays
   var a = array1.slice(0);
   var b = array2.slice(0);
   var aLast = a.length - 1;
   var bLast = b.length - 1;
   while (aLast >= 0 && bLast >= 0) {
      if (a[aLast] > b[bLast] ) {
         a.pop();
         aLast--;
      } else if (a[aLast] < b[bLast] ){
         b.pop();
         bLast--;
      } else /* they're equal */ {
         result.push(a.pop());
         b.pop();
         aLast--;
         bLast--;
      }
   }
   return result;
}

Ho creato un benchmark usando jsPerf: http://bit.ly/P9FrZK . È circa tre volte più veloce usare .pop.

Utilizzando jQuery :

var a = [1,2,3];
var b = [2,3,4,5];
var c = $(b).not($(b).not(a));
alert(c);

Per le matrici che contengono solo stringhe o numeri puoi fare qualcosa con l'ordinamento, come per alcune delle altre risposte. Nel caso generale di matrici di oggetti arbitrari, non penso che tu possa evitare di farlo a lungo. Quanto segue fornirà l'intersezione di qualsiasi numero di matrici fornite come parametri per arrayIntersection:

var arrayContains = Array.prototype.indexOf ?
    function(arr, val) {
        return arr.indexOf(val) > -1;
    } :
    function(arr, val) {
        var i = arr.length;
        while (i--) {
            if (arr[i] === val) {
                return true;
            }
        }
        return false;
    };

function arrayIntersection() {
    var val, arrayCount, firstArray, i, j, intersection = [], missing;
    var arrays = Array.prototype.slice.call(arguments); // Convert arguments into a real array

    // Search for common values
    firstArray = arrays.pop();
    if (firstArray) {
        j = firstArray.length;
        arrayCount = arrays.length;
        while (j--) {
            val = firstArray[j];
            missing = false;

            // Check val is present in each remaining array 
            i = arrayCount;
            while (!missing && i--) {
                if ( !arrayContains(arrays[i], val) ) {
                    missing = true;
                }
            }
            if (!missing) {
                intersection.push(val);
            }
        }
    }
    return intersection;
}

arrayIntersection( [1, 2, 3, "a"], [1, "a", 2], ["a", 1] ); // Gives [1, "a"]; 

È piuttosto breve con ES2015 e set. Accetta valori simili a array come una stringa e rimuove i duplicati.

let intersection = function(a, b) {
  a = new Set(a), b = new Set(b);
  return [...a].filter(v => b.has(v));
};

console.log(intersection([1,2,1,2,3], [2,3,5,4,5,3]));

console.log(intersection('ccaabbab', 'addb').join(''));

È possibile utilizzare un Setas thisArgof Array#filtere prendere Set#hascome callback.

function intersection(a, b) {
    return a.filter(Set.prototype.has, new Set(b));
}

console.log(intersection([1, 2, 3], [2, 3, 4, 5]));

Una piccola modifica alla più piccola qui (la soluzione filter / indexOf ), ovvero la creazione di un indice dei valori in una delle matrici utilizzando un oggetto JavaScript, lo ridurrà da O (N * M) a tempo "probabilmente" lineare. source1 source2

function intersect(a, b) {
  var aa = {};
  a.forEach(function(v) { aa[v]=1; });
  return b.filter(function(v) { return v in aa; });
}

Questa non è la soluzione più semplice (è più codice del filtro + indexOf ), né è la più veloce (probabilmente più lenta di un fattore costante di intersect_safe () ), ma sembra un equilibrio piuttosto buono. È molto semplice, pur offrendo buone prestazioni e non richiede input pre-ordinati.

Un altro approccio indicizzato in grado di elaborare un numero qualsiasi di matrici contemporaneamente:

// Calculate intersection of multiple array or object values.
function intersect (arrList) {
    var arrLength = Object.keys(arrList).length;
        // (Also accepts regular objects as input)
    var index = {};
    for (var i in arrList) {
        for (var j in arrList[i]) {
            var v = arrList[i][j];
            if (index[v] === undefined) index[v] = 0;
            index[v]++;
        };
    };
    var retv = [];
    for (var i in index) {
        if (index[i] == arrLength) retv.push(i);
    };
    return retv;
};

Funziona solo per valori che possono essere valutati come stringhe e dovresti passarli come array come:

intersect ([arr1, arr2, arr3...]);

... ma accetta in modo trasparente oggetti come parametro o come uno qualsiasi degli elementi da intersecare (restituendo sempre array di valori comuni). Esempi:

intersect ({foo: [1, 2, 3, 4], bar: {a: 2, j:4}}); // [2, 4]
intersect ([{x: "hello", y: "world"}, ["hello", "user"]]); // ["hello"]

EDIT: Ho appena notato che questo è, in un certo senso, leggermente difettoso.

Cioè: l'ho codificato pensando che le matrici di input non possano contenere di per sé ripetizioni (come nell'esempio fornito non).

Ma se le matrici di input contengono ripetizioni, ciò produrrebbe risultati errati. Esempio (utilizzando l'implementazione di seguito):

intersect ([[1, 3, 4, 6, 3], [1, 8, 99]]);
// Expected: [ '1' ]
// Actual: [ '1', '3' ]

Fortunatamente questo è facile da risolvere semplicemente aggiungendo l'indicizzazione di secondo livello. Questo è:

Modificare:

        if (index[v] === undefined) index[v] = 0;
        index[v]++;

di:

        if (index[v] === undefined) index[v] = {};
        index[v][i] = true; // Mark as present in i input.

...e:

         if (index[i] == arrLength) retv.push(i);

di:

         if (Object.keys(index[i]).length == arrLength) retv.push(i);

Esempio completo:

// Calculate intersection of multiple array or object values.
function intersect (arrList) {
    var arrLength = Object.keys(arrList).length;
        // (Also accepts regular objects as input)
    var index = {};
    for (var i in arrList) {
        for (var j in arrList[i]) {
            var v = arrList[i][j];
            if (index[v] === undefined) index[v] = {};
            index[v][i] = true; // Mark as present in i input.
        };
    };
    var retv = [];
    for (var i in index) {
        if (Object.keys(index[i]).length == arrLength) retv.push(i);
    };
    return retv;
};

intersect ([[1, 3, 4, 6, 3], [1, 8, 99]]); // [ '1' ]

Puoi usare (per tutti i browser tranne IE):

const intersection = array1.filter(element => array2.includes(element));

o per IE:

const intersection = array1.filter(element => array2.indexOf(element) !== -1);

function intersection(A,B){
var result = new Array();
for (i=0; i<A.length; i++) {
    for (j=0; j<B.length; j++) {
        if (A[i] == B[j] && $.inArray(A[i],result) == -1) {
            result.push(A[i]);
        }
    }
}
return result;
}

Con alcune restrizioni sui tuoi dati, puoi farlo in modo lineare tempo !

Per numeri interi positivi : utilizzare un array che associa i valori a un valore booleano "visto / non visto".

function intersectIntegers(array1,array2) { 
   var seen=[],
       result=[];
   for (var i = 0; i < array1.length; i++) {
     seen[array1[i]] = true;
   }
   for (var i = 0; i < array2.length; i++) {
     if ( seen[array2[i]])
        result.push(array2[i]);
   }
   return result;
}

Esiste una tecnica simile per gli oggetti : prendi una chiave fittizia, impostala su "true" per ogni elemento in array1, quindi cerca questa chiave in elementi di array2. Pulisci quando hai finito.

function intersectObjects(array1,array2) { 
   var result=[];
   var key="tmpKey_intersect"
   for (var i = 0; i < array1.length; i++) {
     array1[i][key] = true;
   }
   for (var i = 0; i < array2.length; i++) {
     if (array2[i][key])
        result.push(array2[i]);
   }
   for (var i = 0; i < array1.length; i++) {
     delete array1[i][key];
   }
   return result;
}

Ovviamente devi assicurarti che la chiave non sia stata visualizzata prima, altrimenti distruggerai i tuoi dati ...

Contribuirò con ciò che ha funzionato meglio per me:

if (!Array.prototype.intersect){
Array.prototype.intersect = function (arr1) {

    var r = [], o = {}, l = this.length, i, v;
    for (i = 0; i < l; i++) {
        o[this[i]] = true;
    }
    l = arr1.length;
    for (i = 0; i < l; i++) {
        v = arr1[i];
        if (v in o) {
            r.push(v);
        }
    }
    return r;
};
}

"indexOf" per IE 9.0, chrome, firefox, opera,

    function intersection(a,b){
     var rs = [], x = a.length;
     while (x--) b.indexOf(a[x])!=-1 && rs.push(a[x]);
     return rs.sort();
    }

intersection([1,2,3], [2,3,4,5]);
//Result:  [2,3]

Un approccio funzionale con ES2015

Un approccio funzionale deve considerare l'utilizzo di funzioni pure senza effetti collaterali, ognuno dei quali riguarda solo un singolo lavoro.

Queste restrizioni migliorano la componibilità e la riusabilità delle funzioni coinvolte.

// small, reusable auxiliary functions

const createSet = xs => new Set(xs);
const filter = f => xs => xs.filter(apply(f));
const apply = f => x => f(x);


// intersection

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


// mock data

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


// run it

console.log( intersect(xs) (ys) );

Si noti che Setviene utilizzato il tipo nativo , che presenta prestazioni di ricerca vantaggiose.

Evita i duplicati

Ovviamente gli oggetti che si verificano ripetutamente dal primo Arrayvengono conservati, mentre il secondo Arrayviene de-duplicato. Questo può essere o non essere il comportamento desiderato. Se hai bisogno di un risultato univoco basta applicare dedupeal primo argomento:

// auxiliary functions

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


// intersection

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


// de-duplication

const dedupe = comp(afrom) (createSet);


// mock data

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


// unique result

console.log( intersect(dedupe(xs)) (ys) );

Calcola l'intersezione di un numero qualsiasi di Arrays

Se si vuole calcolare l'intersezione di un numero arbitrario di Arrays appena comporre intersectcon foldl. Ecco una funzione di convenienza:

// auxiliary functions

const apply = f => x => f(x);
const uncurry = f => (x, y) => f(x) (y);
const createSet = xs => new Set(xs);
const filter = f => xs => xs.filter(apply(f));
const foldl = f => acc => xs => xs.reduce(uncurry(f), acc);


// intersection

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


// intersection of an arbitrarily number of Arrays

const intersectn = (head, ...tail) => foldl(intersect) (head) (tail);


// mock data

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


// run

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

Per semplicità:

// Usage
const intersection = allLists
  .reduce(intersect, allValues)
  .reduce(removeDuplicates, []);


// Implementation
const intersect = (intersection, list) =>
  intersection.filter(item =>
    list.some(x => x === item));

const removeDuplicates = (uniques, item) =>
  uniques.includes(item) ? uniques : uniques.concat(item);


// Example Data
const somePeople = [bob, doug, jill];
const otherPeople = [sarah, bob, jill];
const morePeople = [jack, jill];

const allPeople = [...somePeople, ...otherPeople, ...morePeople];
const allGroups = [somePeople, otherPeople, morePeople];

// Example Usage
const intersection = allGroups
  .reduce(intersect, allPeople)
  .reduce(removeDuplicates, []);

intersection; // [jill]

Benefici:

• sporco semplice
• data-centric
• funziona per un numero arbitrario di liste
• funziona per lunghezze arbitrarie di liste
• funziona per tipi di valori arbitrari
• funziona per un ordinamento arbitrario
• mantiene la forma (ordine di prima apparizione in qualsiasi array)
• esce presto dove possibile
• memoria sicura, senza manomissioni con i prototipi Function / Array

svantaggi:

• maggiore utilizzo della memoria
• maggiore utilizzo della CPU
• richiede una comprensione di ridurre
• richiede comprensione del flusso di dati

Non vorresti usarlo per il motore 3D o il lavoro del kernel, ma se hai problemi a farlo funzionare in un'app basata su eventi, il tuo design ha problemi più grandi.

.reduceper costruire una mappa e .filtertrovare l'intersezione. deleteall'interno di .filterci permette di trattare il secondo array come se fosse un set unico.

function intersection (a, b) {
  var seen = a.reduce(function (h, k) {
    h[k] = true;
    return h;
  }, {});

  return b.filter(function (k) {
    var exists = seen[k];
    delete seen[k];
    return exists;
  });
}

Trovo questo approccio abbastanza facile da ragionare. Si esibisce in tempo costante.

Questo è probabilmente il più semplice, oltre a list1.filter (n => list2.includes (n))

var list1 = ['bread', 'ice cream', 'cereals', 'strawberry', 'chocolate']
var list2 = ['bread', 'cherry', 'ice cream', 'oats']

function check_common(list1, list2){
	
	list3 = []
	for (let i=0; i<list1.length; i++){
		
		for (let j=0; j<list2.length; j++){	
			if (list1[i] === list2[j]){
				list3.push(list1[i]);				
			}		
		}
		
	}
	return list3
	
}

check_common(list1, list2) // ["bread", "ice cream"]

Se è necessario che lo gestisca intersecando più array:

const intersect = (a, b, ...rest) => {
  if (rest.length === 0) return [...new Set(a)].filter(x => new Set(b).has(x));
  return intersect(a, intersect(b, ...rest));
};

console.log(intersect([1,2,3,4,5], [1,2], [1, 2, 3,4,5], [2, 10, 1])) // [1,2]

Modo semplice stile ES6.

const intersection = (a, b) => {
  const s = new Set(b);
  return a.filter(x => s.has(x));
};

Esempio:

intersection([1, 2, 3], [4, 3, 2]); // [2, 3]

Ho scritto una funzione di intesection che può persino rilevare l'intersezione di array di oggetti in base alla particolare proprietà di quegli oggetti.

Per esempio,

if arr1 = [{id: 10}, {id: 20}]
and arr2 =  [{id: 20}, {id: 25}]

e vogliamo intersezione in base alla idproprietà, quindi l'output dovrebbe essere:

[{id: 20}]

Pertanto, la funzione per lo stesso (nota: codice ES6) è:

const intersect = (arr1, arr2, accessors = [v => v, v => v]) => {
    const [fn1, fn2] = accessors;
    const set = new Set(arr2.map(v => fn2(v)));
    return arr1.filter(value => set.has(fn1(value)));
};

e puoi chiamare la funzione come:

intersect(arr1, arr2, [elem => elem.id, elem => elem.id])

Nota anche: questa funzione trova l'intersezione considerando che il primo array è l'array primario e quindi il risultato dell'intersezione sarà quello dell'array primario.

Pensa che questo sarà più veloce con O (array1 + array2) assumendo che map.has () sia ~ O (1). Correggimi se sbagli.

const intersection = (a1, a2) => {
  let map = new Map();
  let result = []
  for (let i of a1) {
    if (!map.has(i)) map.set(i, true);
  }
  for (let i of a2) {
    if (map.has(i)) result.push(i)
  }
  return result;
}

Ecco l' implementazione underscore.js :

_.intersection = function(array) {
  if (array == null) return [];
  var result = [];
  var argsLength = arguments.length;
  for (var i = 0, length = array.length; i < length; i++) {
    var item = array[i];
    if (_.contains(result, item)) continue;
    for (var j = 1; j < argsLength; j++) {
      if (!_.contains(arguments[j], item)) break;
    }
    if (j === argsLength) result.push(item);
  }
  return result;
};

Fonte: http://underscorejs.org/docs/underscore.html#section-62