我有两个数组： Question 和 UserProfile
userProfiles[] 数组包含{ id, name }对象questions[] 数组包含{ id, text, createdBy }对象问题中的createdBy整数始终是 中的 id 值之一userProfiles。
有没有一种方法可以“加入”数组，就像我使用数据库时加入两个 SQL 表一样。
我最终需要的是一个包含
{ id, text, name }
相应的 SQL 将是：
SELECT u.id, q.text, u.name
FROM userProfiles u
JOIN questions q ON q.createdBy=u.id
我认为你想要的是一个内部连接，它很简单，可以在 JavaScript 中实现：
const innerJoin = (xs, ys, sel) =>
xs.reduce((zs, x) =>
ys.reduce((zs, y) => // cartesian product - all combinations
zs.concat(sel(x, y) || []), // filter out the rows and columns you want
zs), []);
出于演示的目的，我们将使用以下数据集（谢谢@AshokDamani）：
const userProfiles = [
{id: 1, name: "Ashok"},
{id: 2, name: "Amit"},
{id: 3, name: "Rajeev"},
];
const questions = [
{id: 1, text: "text1", createdBy: 2},
{id: 2, text: "text2", createdBy: 2},
{id: 3, text: "text3", createdBy: 1},
{id: 4, text: "text4", createdBy: 2},
{id: 5, text: "text5", createdBy: 3},
{id: 6, text: "text6", createdBy: 3},
];
这是你将如何使用它：
const result = innerJoin(userProfiles, questions,
({id: uid, name}, {id, text, createdBy}) =>
createdBy === uid && {id, text, name});
在 SQL 术语中，这类似于：
SELECT questions.id, questions.text, userProfiles.name
FROM userProfiles INNER JOIN questions
ON questions.createdBy = userProfiles.id;
把它们放在一起：
const innerJoin = (xs, ys, sel) =>
xs.reduce((zs, x) =>
ys.reduce((zs, y) => // cartesian product - all combinations
zs.concat(sel(x, y) || []), // filter out the rows and columns you want
zs), []);
const userProfiles = [
{id: 1, name: "Ashok"},
{id: 2, name: "Amit"},
{id: 3, name: "Rajeev"},
];
const questions = [
{id: 1, text: "text1", createdBy: 2},
{id: 2, text: "text2", createdBy: 2},
{id: 3, text: "text3", createdBy: 1},
{id: 4, text: "text4", createdBy: 2},
{id: 5, text: "text5", createdBy: 3},
{id: 6, text: "text6", createdBy: 3},
];
const result = innerJoin(userProfiles, questions,
({id: uid, name}, {id, text, createdBy}) =>
createdBy === uid && {id, text, name});
console.log("Open your browser console to see the output.");
console.table(result);编辑：但这不是最好的解决方案。由于上述解决方案循环通过笛卡尔积，因此运行需要O(m × n)时间。稍作修改，我们就可以让它O(m + n)及时运行——@pebbl 首先找到了它：
const equijoin = (xs, ys, primary, foreign, sel) => {
const ix = xs.reduce((ix, row) => // loop through m items
ix.set(row[primary], row), // populate index for primary table
new Map); // create an index for primary table
return ys.map(row => // loop through n items
sel(ix.get(row[foreign]), // get corresponding row from primary
row)); // select only the columns you need
};
现在您可以按如下方式使用它：
const result = equijoin(userProfiles, questions, "id", "createdBy",
({name}, {id, text}) => ({id, text, name}));
把它们放在一起：
const equijoin = (xs, ys, primary, foreign, sel) => {
const ix = xs.reduce((ix, row) => ix.set(row[primary], row), new Map);
return ys.map(row => sel(ix.get(row[foreign]), row));
};
const userProfiles = [
{id: 1, name: "Ashok"},
{id: 2, name: "Amit"},
{id: 3, name: "Rajeev"},
];
const questions = [
{id: 1, text: "text1", createdBy: 2},
{id: 2, text: "text2", createdBy: 2},
{id: 3, text: "text3", createdBy: 1},
{id: 4, text: "text4", createdBy: 2},
{id: 5, text: "text5", createdBy: 3},
{id: 6, text: "text6", createdBy: 3},
];
const result = equijoin(userProfiles, questions, "id", "createdBy",
({name}, {id, text}) => ({id, text, name}));
console.log("Open your browser console to see the output.");
console.table(result);这似乎是一个重要的通用问题，虽然有很多答案，但有些具有边界行为，例如修改现有数据，解决与手头问题完全不同的问题，使用多达 93,057 字节的 JavaScript（更不用说产生错误的结果），产生过于复杂的数据结构的额外嵌套，每次调用都需要大量代码，最严重的是，它不是这个问题核心的重要更通用问题的独立解决方案。
因此，无论好坏，我编写了一个 shim，它使用一种方法扩展了 JavaScriptArray对象，该方法.joinWith旨在用于将this对象that数组与对象数组（by一个公共索引字段）连接起来。可以是select输出中所需的字段列表（适用于在只需要少数字段时合并具有许多字段的对象数组）或omit输出中的字段列表（适用于在需要大多数字段时合并对象数组但少数不是）。
shim 代码看起来并不漂亮，所以它会在最后，首先是如何将它用于 OP 的特定类型数据的示例：
/* this line will produce the array of objects as desired by the OP */
joined_objects_array = userProfiles.joinWith(questions, 'id', ['createdBy'], 'omit');
/* edit: I just want to make 100% sure that this solution works for you, i.e.,
* does exactly what you need. I haven't seen your actual data, so it's
* possible that your IDs are are not in common, (i.e., your createdBy
* is in common like you said, but not the IDs, and if so you could
* morph your data first like this:
* questions.map(function(x) { x.id = x.createdBy; });
* before joining the arrays of objects together.
*
*/
以下代码用于演示：
var array1 = [{ id: 3124, name: 'Mr. Smith' },
{ id: 710, name: 'Mrs. Jones' }];
var array2 = [{ id: 3124, text: 'wow', createdBy: 'Mr. Jones' },
{ id: 710, text: 'amazing' }];
var results_all = array1.joinWith(array2, 'id');
// [{id:3124, name:"Mr. Smith", text:"wow", createdBy:"Mr. Jones"},
// {id:710, name:"Mrs. Jones", text:"amazing"}]*
var results_selected = array1.joinWith(array2, 'id', ['id', 'text', 'name']);
// [{id:3124, name:"Mr. Smith", text:"wow"},
// {id:710, name:"Mrs. Jones", text:"amazing"}]*
/* or equivalently, */
var results_omitted = array1.joinWith(array2, 'id', ['createdBy'], 1);
// [{id:3124, name:"Mr. Smith", text:"wow"},
// {id:710, name:"Mrs. Jones", text:"amazing"}]*
这个解决方案还有其他一些好处（其中之一是保留通过索引键访问结果数据的能力，尽管返回一个数组）。
享受！
/* Array.joinWith - shim by Joseph Myers 7/6/2013 */
if (!Array.prototype.joinWith) {
+function () {
Array.prototype.joinWith = function(that, by, select, omit) {
var together = [], length = 0;
if (select) select.map(function(x){select[x] = 1;});
function fields(it) {
var f = {}, k;
for (k in it) {
if (!select) { f[k] = 1; continue; }
if (omit ? !select[k] : select[k]) f[k] = 1;
}
return f;
}
function add(it) {
var pkey = '.'+it[by], pobj = {};
if (!together[pkey]) together[pkey] = pobj,
together[length++] = pobj;
pobj = together[pkey];
for (var k in fields(it))
pobj[k] = it[k];
}
this.map(add);
that.map(add);
return together;
}
}();
}
文档：
/* this and that both refer to an array of objects, each containing
object[by] as one of their fields */
/*
N.B. It is the responsibility of the user of this method
to ensure that the contents of the [by] fields are
consistent with each other between the two arrays!
*/
/* select is an array of field names to be included in the resulting
objects--all other fields will be excluded, or, if the Boolean value
of omit evaluates to true, then select is an array of field names to
be excluded from the resulting objects--all others will be included.
*/
我几乎总是使用 underscore.js，因为它对数组和“map reduce”有很好的支持，可以解决这个问题。
这是一个解决您问题的方法（它假设每个用户只有一个问题，正如您原来的帖子所建议的那样）
（打开浏览器控制台查看输出）
var userProfiles = [{ id:'1', name:'john' }, { id:'2', name:'mary' }];
var questions =[ { id:'1', text:'question john', createdBy:'1' }, { id:'2', text:'question mary', createdBy:'2' }];
var rows = _.map(userProfiles, function(user){
var question = _.find(questions, function(q){ return q.createdBy == user.id });
user.text = question? question.text:'';
return user;
})
_.each(rows, function(row){ console.log(row) });
上面的答案假设您使用 id == createdBy 作为加入列。
如果是我，我会以下列方式处理这个问题：
设置：
var userProfiles = [], questions = [];
userProfiles.push( {id:1, name:'test'} );
userProfiles.push( {id:2, name:'abc'} );
userProfiles.push( {id:3, name:'def'} );
userProfiles.push( {id:4, name:'ghi'} );
questions.push( {id:1, text:'monkey', createdBy:1} );
questions.push( {id:2, text:'Monkey', createdBy:1} );
questions.push( {id:3, text:'big', createdBy:2} );
questions.push( {id:4, text:'string', createdBy:2} );
questions.push( {id:5, text:'monKey', createdBy:3} );
首先，将创建一个查找对象，其中链接 id 用作键
var createObjectLookup = function( arr, key ){
var i, l, obj, ret = {};
for ( i=0, l=arr.length; i<l; i++ ) {
obj = arr[i];
ret[obj[key]] = obj;
}
return ret;
};
var up = createObjectLookup(userProfiles, 'id');
现在您有了这个，应该很容易逐步解决问题，并找到要合并的用户对象：
var i, l, question, user, result = [];
for ( i=0, l=questions.length; i<l; i++ ) {
if ( (question = questions[i]) && (user = up[question.createdBy]) ) {
result.push({
id: question.id,
text: question.text,
name: user.name
});
}
}
您现在应该拥有所需的一切result
console.log(result);
这是我试图做出某种通用解决方案的尝试。我在这里使用Array.map和Array.index方法：
var arr1 = [
{id: 1, text:"hello", oid:2},
{id: 2, text:"juhu", oid:3},
{id: 3, text:"wohoo", oid:4},
{id: 4, text:"yeehaw", oid:1}
];
var arr2 = [
{id: 1, name:"yoda"},
{id: 2, name:"herbert"},
{id: 3, name:"john"},
{id: 4, name:"walter"},
{id: 5, name:"clint"}
];
function merge(arr1, arr2, prop1, prop2) {
return arr1.map(function(item){
var p = item[prop1];
el = arr2.filter(function(item) {
return item[prop2] === p;
});
if (el.length === 0) {
return null;
}
var res = {};
for (var i in item) {
if (i !== prop1) {
res[i] = item[i];
}
}
for (var i in el[0]) {
if (i !== prop2) {
res[i] = el[0][i];
}
}
return res;
}).filter(function(el){
return el !== null;
});
}
var res = merge(arr1, arr2, "oid", "id");
console.log(res);
所以基本上你可以为每个数组定义两个数组和一个属性，这样prop1将被array2中prop2等于prop1的项目的所有属性替换。
在这种情况下，结果将是：
var res = [
{id: 1, text:"hello", name:"herbert"},
{id: 2, text:"juhu", name:"john"},
{id: 3, text:"wohoo", name:"walter"},
{id: 4, text:"yeehaw", name:"yoda"}
];
请注意，如果有多个匹配项，则将使用第一项，如果没有匹配项，则将从结果数组中删除该对象。
你想要的只是ResultArray计算如下：
var userProfiles1= new Array(1, "ashok");
var userProfiles2= new Array(2, "amit");
var userProfiles3= new Array(3, "rajeev");
var UArray = new Array(userProfiles1, userProfiles2, userProfiles3);
var questions1= new Array(1, "text1", 2);
var questions2= new Array(2, "text2", 2);
var questions3= new Array(3, "text3", 1);
var questions4= new Array(4, "text4", 2);
var questions5= new Array(5, "text5", 3);
var questions6= new Array(6, "text6", 3);
var QArray = new Array(questions1, questions2, questions3, questions4, questions5, questions6);
var ResultArray = new Array();
for (var i=0; i<UArray.length; i++)
{
var uid = UArray[i][0];
var name = UArray[i][1];
for(var j=0; j<QArray.length; j++)
{
if(uid == QArray[j][2])
{
var qid = QArray[j][0]
var text = QArray[j][1];
ResultArray.push(qid +"," + text +","+ name)
}
}
}
for(var i=0; i<ResultArray.length; i++)
{
document.write(ResultArray[i] + "<br>")
}
演示：http: //jsfiddle.net/VqmVv/
在 JavaScript中进行SQL 连接的简单方法：
let userProfiles = [ { id: 3, name: "Paquito"}, { id: 2, name: "Jaime" } ];
let questions = [ { id: 22, text: "My question", createdBy: 3 }, { id: 44, text: "Other question", createdBy: 5 } ];
let left_join = questions
.map ( q => ({ ...userProfiles.find( u => q.createdBy === u.id ), ...q }) );
document.write("<p>Left join: <br>", JSON.stringify(left_join));
let right_join = userProfiles
.map ( u => ({ ...questions.find( q => q.createdBy === u.id ), ...u }) );;
document.write("</p><p>Right join: <br>", JSON.stringify(right_join));
let inner_join = questions
.filter( q => userProfiles.find( u => q.createdBy === u.id ) )
.map ( q => ({ ...userProfiles.find( u => q.createdBy === u.id ), ...q }) );
document.write("</p><p>Inner join: <br>", JSON.stringify(inner_join));只是想分享一些通用代码：
// Create a cartesian product of the arguments.
// product([1,2],['a','b'],['X']) => [[1,"a","X"],[1,"b","X"],[2,"a","X"],[2,"b","X"]]
// Accepts any number of arguments.
product = function() {
if(!arguments.length)
return [[]];
var p = product.apply(null, [].slice.call(arguments, 1));
return arguments[0].reduce(function(r, x) {
return p.reduce(function(r, y) {
return r.concat([[x].concat(y)]);
}, r);
}, []);
}
你的问题：
result = product(userProfiles, questions).filter(function(row) {
return row[0].id == row[1].createdBy;
}).map(function(row) {
return {
userName: row[0].name,
question: row[1].text
}
})
首先，创建一个从 ID 到名称的映射：
var id2name = userProfiles.reduce(function(id2name, profile){
id2name[profile.id] = profile.name;
return id2name;
}, {});
其次，创建一个新的问题数组，但使用创建问题的用户的名称代替他们的 ID：
var qs = questions.map(function(q){
q.createdByName = id2name[q.createdBy];
delete q.createdBy;
return q;
});
我不知道任何允许这样做的内置函数。
您可以编写自己的函数，类似于此 jsFiddle：
var userProfiles = [{id:1, name:'name1'},{id:2,name:'name2'}];
var questions = [
{id:1, text:'text1', createdBy:'foo'},
{id:1, text:'text2', createdBy:'bar'},
{id:2, text:'text3', createdBy:'foo'}];
merged = mergeMyArrays(userProfiles,questions);
console.log(merged);
/**
* This will give you an array like this:
* [{id:1, name:name1, text:text1}, {...]
* params : 2 arrays to merge by id
*/
function mergeMyArrays(u,q){
var ret = [];
for(var i = 0, l = u.length; i < l; i++){
var curU = u[i];
for(var j = 0, m = q.length; j<m; j++){
if(q[j].id == curU.id){
ret.push({
id: curU.id,
name: curU.name,
text: q[j].text
});
}
}
}
return ret;
}
或者，如果您想要更好的“加入”（SQL-y）：
var userProfiles = [{id:1, name:'name1'},{id:2,name:'name2'}];
var questions = [
{id:1, text:'text1', createdBy:'foo'},
{id:1, text:'text2', createdBy:'bar'},
{id:2, text:'text3', createdBy:'foo'}];
merged = mergeMyArrays(userProfiles,questions);
console.log(merged);
/**
* This will give you an array like this:
* [{id:1, name:name1, questions:[{...}]]
* params : 2 arrays to merge by id
*/
function mergeMyArrays(u,q){
var ret = [];
for(var i = 0, l = u.length; i < l; i++){
var curU = u[i],
curId = curU.id,
tmpObj = {id:curId, name:curU.name, questions:[]};
for(var j = 0, m = q.length; j<m; j++){
if(q[j].id == curId){
tmpObj.questions.push({
text: q[j].text,
createdBy: q[j].createdBy
});
}
}
ret.push(tmpObj);
}
return ret;
}
就像在这个 jsFiddle
使用StrelkiJS很容易做到这一点
var userProfiles = new StrelkiJS.IndexedArray();
userProfiles.loadArray([
{id: 1, name: "Ashok"},
{id: 2, name: "Amit"},
{id: 3, name: "Rajeev"}
]);
var questions = new StrelkiJS.IndexedArray();
questions.loadArray([
{id: 1, text: "text1", createdBy: 2},
{id: 2, text: "text2", createdBy: 2},
{id: 3, text: "text3", createdBy: 1},
{id: 4, text: "text4", createdBy: 2},
{id: 5, text: "text5", createdBy: 3},
{id: 6, text: "text6", createdBy: 3}
]);
var res=questions.query([{
from_col: "createdBy",
to_table: userProfiles,
to_col: "id",
type: "outer"
}]);
结果将是：
[
[
{"id":1,"text":"text1","createdBy":2},
{"id":2,"name":"Amit"}
],
[
{"id":2,"text":"text2","createdBy":2},
{"id":2,"name":"Amit"}
],
[
{"id":3,"text":"text3","createdBy":1},
{"id":1,"name":"Ashok"}
],
[
{"id":4,"text":"text4","createdBy":2},
{"id":2,"name":"Amit"}
],
[
{"id":5,"text":"text5","createdBy":3},
{"id":3,"name":"Rajeev"}
],
[
{"id":6,"text":"text6","createdBy":3},
{"id":3,"name":"Rajeev"}
]
]
Aadit 的第二个 O(m+n) 解决方案在我看来简洁、实用且高效。但是，当多个键匹配我的用例所需时，它没有实现记录的重复，所以我写了这个轻微的变化：
function equijoin(arrL,arrR,keyL,keyR=keyL){
const idx = arrL.reduce(
(idx, objL) =>
objL[keyL] === undefined
?idx
:idx.set(objL[keyL], [...(idx.get(objL[keyL])||[]), ...[objL]])
,new Map
)
const matches =
arrR
.map(objR =>
objR[keyR] === undefined
? []
: idx.get(objR[keyR])
.map(objL => ({l:objL, r:objR}))
.reduce((a,b)=>a.concat(b),[])
)
.reduce((a,b)=>a.concat(b),[])
return matches
}
（人为）示例：
var players =[
{id:"Alice", team:"Red"},
{id:"Bob", team:"Red"},
{id:"Clair", team:"Blue"},
{id:"Dave"},
{id:"Elliot"}
];
equijoin(players,players,"team")
[
{l:{id:"Alice",team:"Red"},r:{id:"Alice",team:"Red"}},
{l:{id:"Bob",team:"Red"},r:{id:"Alice",team:"Red"}},
{l:{id:"Alice",team:"Red"},r:{id:"Bob",team:"Red"}},
{l:{id:"Bob",team:"Red"},r:{id:"Bob",team:"Red"}},
{l:{id:"Clair",team:"Blue"},r:{id:"Clair",team:"Blue"}}
]
除了 Aadit M Shah 的等值连接之外，还有一个要求，它类似于左连接。但是由于该方法不是连接，而是直接的 1 到 1 等于，因此该方法不完全是左连接，如果不匹配，则更多的是具有默认值的 equijoin。然而，为了实现这一点并且阅读它是有意义的，我颠倒了这个方法，因为它实际上是反向加入的。
const equijoinWithDefault = (xs, ys, primary, foreign, sel, def) => {
const iy = ys.reduce((iy, row) => iy.set(row[foreign], row), new Map);
return xs.map(row => typeof iy.get(row[primary]) !== 'undefined' ? sel(row, iy.get(row[primary])): sel(row, def));
};
示例调用：
const userProfiles = [
{id: 1, name: "Ashok"},
{id: 2, name: "Amit"},
{id: 3, name: "Rajeev"},
];
const questions2 = [
{id: 1, text: "text1", createdBy: 2},
{id: 2, text: "text2", createdBy: 2},
{id: 3, text: "text3", createdBy: 1},
{id: 4, text: "text4", createdBy: 2},
{id: 5, text: "text5", createdBy: 3},
{id: 6, text: "text6", createdBy: 3},
{id: 7, text: "text7", createdBy: 4},
];
let result2 = equijoinWithDefault(questions2, userProfiles, "createdBy", "id", ({id, text}, {name}) => ({id, text, name}), {name:null});
Thats another way
var array1 = [{ id: 1, name: 'Khikmat'},
{ id: 2, name: 'User'}];
var array2 = [{ id: 1, text: 'hi test' },
{ id: 2, text: 'amazing test' }, { id: 2, text: 'test'}];
var result = array1.map((elem) => {
elem["complaints"] = array2.filter((val) => {
return val.id === elem.id;
});
return elem;
});
console.log(JSON.stringify(result))
您可以先使用 jQuery.merge() 然后使用 jQuery.unique() 来实现这一点。merge() 会将所有项目添加到一个数组中，而 unique() 将从该数组中删除重复项。