var result = arrays.shift().filter(function(v) {
    return arrays.every(function(a) {
        return a.indexOf(v) !== -1;
    });
});

演示： http : //jsfiddle.net/nWjcp/2/

您可以先对外部 Array 进行排序以在开始时获得最短的 Array ......

arrays.sort(function(a, b) {
    return a.length - b.length;
});

为了完整起见，这里有一个处理数组中重复项的解决方案。它使用.reduce()代替.filter()...

var result = arrays.shift().reduce(function(res, v) {
    if (res.indexOf(v) === -1 && arrays.every(function(a) {
        return a.indexOf(v) !== -1;
    })) res.push(v);
    return res;
}, []);

演示： http : //jsfiddle.net/nWjcp/4/

假设有一个数组数组，我们想要找到它们的交集，一个最简单的单线性方法可能是

var arr = [[0,1,2,3,4,5,6,7,8,9],[0,2,4,6,8],[4,5,6,7]],
    int = arr.reduce((p,c) => p.filter(e => c.includes(e)));

document.write("<pre>" + JSON.stringify(int) + "</pre>");

现在，您已经向问题添加了不确定数量的数组，这是另一种方法，将每个项目的计数收集到一个对象中，然后整理具有最大计数的项目。

这种方法的优点：

1. 如果数组更大，则蛮力搜索选项（由其他答案使用）快 15 倍
2. 不需要 ES5 或 ES5 垫片（适用于所有浏览器）
3. 完全无损（根本不改变源数据）
4. 处理源数组中的重复项
5. 处理任意数量的输入数组

这是代码：

function containsAll(/* pass all arrays here */) {
    var output = [];
    var cntObj = {};
    var array, item, cnt;
    // for each array passed as an argument to the function
    for (var i = 0; i < arguments.length; i++) {
        array = arguments[i];
        // for each element in the array
        for (var j = 0; j < array.length; j++) {
            item = "-" + array[j];
            cnt = cntObj[item] || 0;
            // if cnt is exactly the number of previous arrays, 
            // then increment by one so we count only one per array
            if (cnt == i) {
                cntObj[item] = cnt + 1;
            }
        }
    }
    // now collect all results that are in all arrays
    for (item in cntObj) {
        if (cntObj.hasOwnProperty(item) && cntObj[item] === arguments.length) {
            output.push(item.substring(1));
        }
    }
    return(output);
}    

工作演示：http : //jsfiddle.net/jfriend00/52mAP/

仅供参考，这不需要 ES5，因此可以在没有垫片的所有浏览器中使用。

在对每 1000 个长度的 15 个数组进行的性能测试中，这比 am not i am 在这个 jsperf 中使用的搜索方法快 10 倍以上：http ://jsperf.com/in-all-arrays 。

这是一个使用 ES6Map并Set进行重复数据删除和跟踪计数的版本。这具有保留数据类型并且可以是任何类型的优点（它甚至不必进行自然的字符串转换，数据甚至可以是对象，尽管将对象比较为完全相同的对象，而不具有相同的对象）属性/值）。

var arrays = [
    ['valueOf', 'toString','apple', 'orange', 'banana', 'banana', 'pear', 'fish', 'pancake', 'taco', 'pizza', 1, 2, 999, 888],
    ['valueOf', 'toString','taco', 'fish', 'fish', 'apple', 'pizza', 1, 999, 777, 999, 1],
    ['valueOf', 'toString','banana', 'pizza', 'fish', 'apple', 'apple', 1, 2, 999, 666, 555]
    ];
    
// subclass for updating cnts    
class MapCnt extends Map {
    constructor(iterable) {
        super(iterable);
    }
    
    cnt(iterable) {
        // make sure items from the array are unique
        let set = new Set(iterable);
        // now update the cnt for each item in the set
        for (let item of set) {
            let cnt = this.get(item) || 0;
            ++cnt;
            this.set(item, cnt);
        }
    }
}


function containsAll(...allArrays) {
    let cntObj = new MapCnt();
    for (array of allArrays) {
        cntObj.cnt(array);
    }
    // now see how many items have the full cnt
    let output = [];
    for (var [item, cnt] of cntObj.entries()) {
        if (cnt === allArrays.length) {
            output.push(item);
        }
    }
    return(output);
}    

var result = containsAll.apply(this, arrays);

document.body.innerHTML = "<pre>[<br>    " + result.join(',<br>    ') + "<br>]</pre>";

一些想法 - 您可以只比较最短数组中的项目，并防止返回数组中的重复项。

function arraysInCommon(arrays){
    var i, common,
    L= arrays.length, min= Infinity;
    while(L){
        if(arrays[--L].length<min){
            min= arrays[L].length;
            i= L;
        }
    }
    common= arrays.splice(i, 1)[0];
    return common.filter(function(itm, indx){
        if(common.indexOf(itm)== indx){
            return arrays.every(function(arr){
                return arr.indexOf(itm)!= -1;
            });
        }
    });
}

var arr1= ['apple', 'orange', 'banana', 'pear', 'fish', 'pancake', 'taco', 'pizza'];
var arr2= ['taco', 'fish', 'apple', 'pizza', 'apple','apple'];
var arr3= ['banana', 'pizza', 'fish', 'apple','fish'];

var allArrays = [arr1,arr2,arr3];

arraysInCommon(allArrays).sort();

返回值： apple,fish,pizza

演示- http://jsfiddle.net/kMcud/

假设数组数组并检查所有数组：

演示：http : //jsfiddle.net/qUQHW/

var tmp = {};
for (i = 0; i < data.length; i++) {
    for (j = 0; j < data[i].length; j++) {
        if (!tmp[data[i][j]]) {
            tmp[data[i][j]] = 0;
        }
        tmp[data[i][j]]++;
    }
}

var results = $.map(tmp, function(val,key) {
    return val == data.length ? key :null;
})