node 求算法# Programming - 葵花宝典
s*r
1 楼
请问一下，如果可以看CNTV央视的话，理论上是不是CNTV其他的频道都可以看到呢？挺
想看看劲爆体育，上海体育等体育频道的，如果方便的话，天线宝宝能够加一下到列表
里面呢？如果是我太贪心的话，就忽略我吧
多谢天线宝宝造福大众！
想看看劲爆体育，上海体育等体育频道的，如果方便的话，天线宝宝能够加一下到列表
里面呢？如果是我太贪心的话，就忽略我吧
多谢天线宝宝造福大众！
b*u
2 楼
我把视频拷贝到iFile一个目录下，avi, mkv之类的电影。发现在iFile里打开，系统实
际上是把当前电影再次拷贝到Avplayer/oplayer安装目录下，如果一个视频有2G，则这
个拷贝过程相当漫长，且损磁盘。不知道IOS为什么要设计成这样？
这些个player难道不能直接读取iFile下的文件？
际上是把当前电影再次拷贝到Avplayer/oplayer安装目录下，如果一个视频有2G，则这
个拷贝过程相当漫长，且损磁盘。不知道IOS为什么要设计成这样？
这些个player难道不能直接读取iFile下的文件？
n*t
3 楼
有 mongodb collection 如下：{ id， parent }，现需将这个 array 变成 tree。表
比较大，读到内存再遍历太费内存、太慢，请大牛看看 async 怎么做。
500 伪币酬谢。
比较大，读到内存再遍历太费内存、太慢，请大牛看看 async 怎么做。
500 伪币酬谢。
t*b
4 楼
我周末查看了一下，您说的这两个频道只在pc上能看。移动客户端（iphone/ipad/
android）上没找到。机顶盒用的和移动客户端一个格式，也就是说iphone/ipad/
android上能看的机顶盒就可以，但pc上的是p2p的一个cntv私有格式，没有任何机顶盒
能支持。
android）上没找到。机顶盒用的和移动客户端一个格式，也就是说iphone/ipad/
android上能看的机顶盒就可以，但pc上的是p2p的一个cntv私有格式，没有任何机顶盒
能支持。
i*8
5 楼
不要用iFile
损磁盘?怎么个损法?
如果允许任意访问, 银行就不会有app了
【在 b**u 的大作中提到】
: 我把视频拷贝到iFile一个目录下，avi, mkv之类的电影。发现在iFile里打开，系统实
: 际上是把当前电影再次拷贝到Avplayer/oplayer安装目录下，如果一个视频有2G，则这
: 个拷贝过程相当漫长，且损磁盘。不知道IOS为什么要设计成这样？
: 这些个player难道不能直接读取iFile下的文件？
损磁盘?怎么个损法?
如果允许任意访问, 银行就不会有app了
【在 b**u 的大作中提到】
: 我把视频拷贝到iFile一个目录下，avi, mkv之类的电影。发现在iFile里打开，系统实
: 际上是把当前电影再次拷贝到Avplayer/oplayer安装目录下，如果一个视频有2G，则这
: 个拷贝过程相当漫长，且损磁盘。不知道IOS为什么要设计成这样？
: 这些个player难道不能直接读取iFile下的文件？
p*2
6 楼
没看明白。你这个在mongo中已经形成了一个tree了呀。你想做什么query呀。
r*r
7 楼
10mmons的安卓播放器（Amazon 上搜10mmons Android),刷回天敏电视大师5中文固件，
里面有CNTV认可的CNTV App，可以看CNTV频道，装其他直播App可以看其他台。
里面有CNTV认可的CNTV App，可以看CNTV频道，装其他直播App可以看其他台。
i*1
8 楼
我记得vlc是不用 copy的。
另外如果用oplayer放，直接把文件放oplayer 目录下不就行了？
【在 b**u 的大作中提到】
: 我把视频拷贝到iFile一个目录下，avi, mkv之类的电影。发现在iFile里打开，系统实
: 际上是把当前电影再次拷贝到Avplayer/oplayer安装目录下，如果一个视频有2G，则这
: 个拷贝过程相当漫长，且损磁盘。不知道IOS为什么要设计成这样？
: 这些个player难道不能直接读取iFile下的文件？
另外如果用oplayer放，直接把文件放oplayer 目录下不就行了？
【在 b**u 的大作中提到】
: 我把视频拷贝到iFile一个目录下，avi, mkv之类的电影。发现在iFile里打开，系统实
: 际上是把当前电影再次拷贝到Avplayer/oplayer安装目录下，如果一个视频有2G，则这
: 个拷贝过程相当漫长，且损磁盘。不知道IOS为什么要设计成这样？
: 这些个player难道不能直接读取iFile下的文件？
i*i
9 楼
哥，不能比这更简单了吧？
啥叫树？ 就是 {id, [child,...]}, 对吧？
你知道了吧。
啥叫树？ 就是 {id, [child,...]}, 对吧？
你知道了吧。
t*b
10 楼
我中午试试看。如果上面有'劲爆体育，上海体育'，就能加到其他机顶盒上。
【在 r******r 的大作中提到】
: 10mmons的安卓播放器（Amazon 上搜10mmons Android),刷回天敏电视大师5中文固件，
: 里面有CNTV认可的CNTV App，可以看CNTV频道，装其他直播App可以看其他台。
【在 r******r 的大作中提到】
: 10mmons的安卓播放器（Amazon 上搜10mmons Android),刷回天敏电视大师5中文固件，
: 里面有CNTV认可的CNTV App，可以看CNTV频道，装其他直播App可以看其他台。
S*M
11 楼
iOS每个App有自己的工作目录，不能打开别的目录下的文件，所以必须拷贝过去。
i*i
12 楼
500伪币拿来，一个子也不能少。
s*r
13 楼
非常感谢天线宝宝！bow
【在 t**b 的大作中提到】
: 我中午试试看。如果上面有'劲爆体育，上海体育'，就能加到其他机顶盒上。
【在 t**b 的大作中提到】
: 我中午试试看。如果上面有'劲爆体育，上海体育'，就能加到其他机顶盒上。
i*1
14 楼
是不是可以link?
【在 S****M 的大作中提到】
: iOS每个App有自己的工作目录，不能打开别的目录下的文件，所以必须拷贝过去。
【在 S****M 的大作中提到】
: iOS每个App有自己的工作目录，不能打开别的目录下的文件，所以必须拷贝过去。
n*t
15 楼
不是，mongo 里存的是 array
{ id: '子1', parent: '老王' }
{ id: '子2', parent: '老王' }
{ id: '孙1', parent: '子1' }
{ id: '孙2', parent: '子1' }
{ id: '孙3', parent: '子2' }
需要变成：
老王 : [
子1 : [ 孙1, 孙2 ],
子2 : [ 孙3 ]
]
【在 p*****2 的大作中提到】
: 没看明白。你这个在mongo中已经形成了一个tree了呀。你想做什么query呀。
{ id: '子1', parent: '老王' }
{ id: '子2', parent: '老王' }
{ id: '孙1', parent: '子1' }
{ id: '孙2', parent: '子1' }
{ id: '孙3', parent: '子2' }
需要变成：
老王 : [
子1 : [ 孙1, 孙2 ],
子2 : [ 孙3 ]
]
【在 p*****2 的大作中提到】
: 没看明白。你这个在mongo中已经形成了一个tree了呀。你想做什么query呀。
h*v
16 楼
use symbolic link
【在 i**8 的大作中提到】
: 不要用iFile
: 损磁盘?怎么个损法?
: 如果允许任意访问, 银行就不会有app了
【在 i**8 的大作中提到】
: 不要用iFile
: 损磁盘?怎么个损法?
: 如果允许任意访问, 银行就不会有app了
n*t
17 楼
书少别骗，请给出 async
【在 i**i 的大作中提到】
: 哥，不能比这更简单了吧？
: 啥叫树？ 就是 {id, [child,...]}, 对吧？
: 你知道了吧。
【在 i**i 的大作中提到】
: 哥，不能比这更简单了吧？
: 啥叫树？ 就是 {id, [child,...]}, 对吧？
: 你知道了吧。
i*i
18 楼
不给就算了。
【在 n*****t 的大作中提到】
: 不是，mongo 里存的是 array
: { id: '子1', parent: '老王' }
: { id: '子2', parent: '老王' }
: { id: '孙1', parent: '子1' }
: { id: '孙2', parent: '子1' }
: { id: '孙3', parent: '子2' }
: 需要变成：
: 老王 : [
: 子1 : [ 孙1, 孙2 ],
: 子2 : [ 孙3 ]
【在 n*****t 的大作中提到】
: 不是，mongo 里存的是 array
: { id: '子1', parent: '老王' }
: { id: '子2', parent: '老王' }
: { id: '孙1', parent: '子1' }
: { id: '孙2', parent: '子1' }
: { id: '孙3', parent: '子2' }
: 需要变成：
: 老王 : [
: 子1 : [ 孙1, 孙2 ],
: 子2 : [ 孙3 ]
p*2
19 楼
最后的tree存在mongo里 还是memory里
collection有多少records
【在 n*****t 的大作中提到】
: 不是，mongo 里存的是 array
: { id: '子1', parent: '老王' }
: { id: '子2', parent: '老王' }
: { id: '孙1', parent: '子1' }
: { id: '孙2', parent: '子1' }
: { id: '孙3', parent: '子2' }
: 需要变成：
: 老王 : [
: 子1 : [ 孙1, 孙2 ],
: 子2 : [ 孙3 ]
collection有多少records
【在 n*****t 的大作中提到】
: 不是，mongo 里存的是 array
: { id: '子1', parent: '老王' }
: { id: '子2', parent: '老王' }
: { id: '孙1', parent: '子1' }
: { id: '孙2', parent: '子1' }
: { id: '孙3', parent: '子2' }
: 需要变成：
: 老王 : [
: 子1 : [ 孙1, 孙2 ],
: 子2 : [ 孙3 ]
n*t
20 楼
存在 memory 里，records 现在有 1W 多吧，db find 肯定比在 memory 里快，因为可
以用到 index。其实问题找到了，肯定是 async 递归，忘记 find 结果要 copy 一下。
【在 p*****2 的大作中提到】
: 最后的tree存在mongo里 还是memory里
: collection有多少records
以用到 index。其实问题找到了，肯定是 async 递归，忘记 find 结果要 copy 一下。
【在 p*****2 的大作中提到】
: 最后的tree存在mongo里 还是memory里
: collection有多少records
p*2
21 楼
那就好 这个问题也是常见
下。
【在 n*****t 的大作中提到】
: 存在 memory 里，records 现在有 1W 多吧，db find 肯定比在 memory 里快，因为可
: 以用到 index。其实问题找到了，肯定是 async 递归，忘记 find 结果要 copy 一下。
下。
【在 n*****t 的大作中提到】
: 存在 memory 里，records 现在有 1W 多吧，db find 肯定比在 memory 里快，因为可
: 以用到 index。其实问题找到了，肯定是 async 递归，忘记 find 结果要 copy 一下。
c*y
22 楼
不了解mongodb，oracle的话就是用connected by（不加order by），结果本身顺序就
是按照depth first顺序展开的，遍历一边就行
【在 n*****t 的大作中提到】
: 有 mongodb collection 如下：{ id， parent }，现需将这个 array 变成 tree。表
: 比较大，读到内存再遍历太费内存、太慢，请大牛看看 async 怎么做。
: 500 伪币酬谢。
是按照depth first顺序展开的，遍历一边就行
【在 n*****t 的大作中提到】
: 有 mongodb collection 如下：{ id， parent }，现需将这个 array 变成 tree。表
: 比较大，读到内存再遍历太费内存、太慢，请大牛看看 async 怎么做。
: 500 伪币酬谢。
W*o
23 楼
以前写过一个类似的，就是先找儿子，再给每个儿子找儿子：
var async = require('async');
var parentLaoWang = "Lao Wang"
if (parentLaoWang) {
var laoWangFamily = {"laoWang": []};
var findKidByParent = function(parent, callback) {
//findKidsByParent is a custom function on Kids collection
Kids.findKidsByParent(parent, function (err, foundKids) {
//foundKids is Array
if (foundKids) {
var currParentAndKids = {"parent" : parent, "kids" :
foundKids};
laoWangFamily.laoWang.push(currParentAndKids);
}
callback();
});
}; //findKidByParent
var retKids = function(err) {
if (err) return sendErrorMsgCode(res, "error in assembling kids",
401);
return laoWangFamily;
}; //retTagNames
// 先找儿子辈
var laoWangsSons = [];
Kids.findKidsByParent(parentLaoWang, function(error, foundSons) {
laoWangsSons = foundSons;
//再给每个儿子找儿子辈的
async.eachSeries(laoWangsSons, findKidByParent, retKids);
});
}
【在 n*****t 的大作中提到】
: 有 mongodb collection 如下：{ id， parent }，现需将这个 array 变成 tree。表
: 比较大，读到内存再遍历太费内存、太慢，请大牛看看 async 怎么做。
: 500 伪币酬谢。
var async = require('async');
var parentLaoWang = "Lao Wang"
if (parentLaoWang) {
var laoWangFamily = {"laoWang": []};
var findKidByParent = function(parent, callback) {
//findKidsByParent is a custom function on Kids collection
Kids.findKidsByParent(parent, function (err, foundKids) {
//foundKids is Array
if (foundKids) {
var currParentAndKids = {"parent" : parent, "kids" :
foundKids};
laoWangFamily.laoWang.push(currParentAndKids);
}
callback();
});
}; //findKidByParent
var retKids = function(err) {
if (err) return sendErrorMsgCode(res, "error in assembling kids",
401);
return laoWangFamily;
}; //retTagNames
// 先找儿子辈
var laoWangsSons = [];
Kids.findKidsByParent(parentLaoWang, function(error, foundSons) {
laoWangsSons = foundSons;
//再给每个儿子找儿子辈的
async.eachSeries(laoWangsSons, findKidByParent, retKids);
});
}
【在 n*****t 的大作中提到】
: 有 mongodb collection 如下：{ id， parent }，现需将这个 array 变成 tree。表
: 比较大，读到内存再遍历太费内存、太慢，请大牛看看 async 怎么做。
: 500 伪币酬谢。
l*n
24 楼
这个非常简单。本质就是一async recursive query, 你可以用while loop, 也可以写
成递归。递归的话注意pass中间结果。我用bluebird写过。promise用过吧，当你得到
想要的结果，call resolve退出循环或递归
【在 n*****t 的大作中提到】
: 有 mongodb collection 如下：{ id， parent }，现需将这个 array 变成 tree。表
: 比较大，读到内存再遍历太费内存、太慢，请大牛看看 async 怎么做。
: 500 伪币酬谢。
成递归。递归的话注意pass中间结果。我用bluebird写过。promise用过吧，当你得到
想要的结果，call resolve退出循环或递归
【在 n*****t 的大作中提到】
: 有 mongodb collection 如下：{ id， parent }，现需将这个 array 变成 tree。表
: 比较大，读到内存再遍历太费内存、太慢，请大牛看看 async 怎么做。
: 500 伪币酬谢。
l*n
25 楼
google 'while loop with promise' at stackoverflow
【在 l**********n 的大作中提到】
: 这个非常简单。本质就是一async recursive query, 你可以用while loop, 也可以写
: 成递归。递归的话注意pass中间结果。我用bluebird写过。promise用过吧，当你得到
: 想要的结果，call resolve退出循环或递归
【在 l**********n 的大作中提到】
: 这个非常简单。本质就是一async recursive query, 你可以用while loop, 也可以写
: 成递归。递归的话注意pass中间结果。我用bluebird写过。promise用过吧，当你得到
: 想要的结果，call resolve退出循环或递归
n*t
26 楼
谢 code，这一行有问题的吧：
var currParentAndKids = {"parent" : parent, "kids" : foundKids};
foundKids 要 copy 一下，之前我就是忘记了。
【在 W***o 的大作中提到】
: 以前写过一个类似的，就是先找儿子，再给每个儿子找儿子：
: var async = require('async');
: var parentLaoWang = "Lao Wang"
: if (parentLaoWang) {
: var laoWangFamily = {"laoWang": []};
: var findKidByParent = function(parent, callback) {
: //findKidsByParent is a custom function on Kids collection
: Kids.findKidsByParent(parent, function (err, foundKids) {
: //foundKids is Array
: if (foundKids) {
var currParentAndKids = {"parent" : parent, "kids" : foundKids};
foundKids 要 copy 一下，之前我就是忘记了。
【在 W***o 的大作中提到】
: 以前写过一个类似的，就是先找儿子，再给每个儿子找儿子：
: var async = require('async');
: var parentLaoWang = "Lao Wang"
: if (parentLaoWang) {
: var laoWangFamily = {"laoWang": []};
: var findKidByParent = function(parent, callback) {
: //findKidsByParent is a custom function on Kids collection
: Kids.findKidsByParent(parent, function (err, foundKids) {
: //foundKids is Array
: if (foundKids) {
n*t
27 楼
一开始我是读到 memory 里再便历，比较耗资源、比较慢。然后递归查询，速度还好，
因为 find 可以用到 index。
现在想有没有更好的算法。
【在 l**********n 的大作中提到】
: 这个非常简单。本质就是一async recursive query, 你可以用while loop, 也可以写
: 成递归。递归的话注意pass中间结果。我用bluebird写过。promise用过吧，当你得到
: 想要的结果，call resolve退出循环或递归
因为 find 可以用到 index。
现在想有没有更好的算法。
【在 l**********n 的大作中提到】
: 这个非常简单。本质就是一async recursive query, 你可以用while loop, 也可以写
: 成递归。递归的话注意pass中间结果。我用bluebird写过。promise用过吧，当你得到
: 想要的结果，call resolve退出循环或递归
p*o
28 楼
你不是才1万多records吗？为啥读到memory里比较耗资源？
【在 n*****t 的大作中提到】
: 一开始我是读到 memory 里再便历，比较耗资源、比较慢。然后递归查询，速度还好，
: 因为 find 可以用到 index。
: 现在想有没有更好的算法。
【在 n*****t 的大作中提到】
: 一开始我是读到 memory 里再便历，比较耗资源、比较慢。然后递归查询，速度还好，
: 因为 find 可以用到 index。
: 现在想有没有更好的算法。
W*o
29 楼
我没有跑，只是早上改写了一下，mongodb 的find 是async 的，相当于promise, 只是
用async library 同时跑很多
【在 n*****t 的大作中提到】
: 谢 code，这一行有问题的吧：
: var currParentAndKids = {"parent" : parent, "kids" : foundKids};
: foundKids 要 copy 一下，之前我就是忘记了。
:
用async library 同时跑很多
【在 n*****t 的大作中提到】
: 谢 code，这一行有问题的吧：
: var currParentAndKids = {"parent" : parent, "kids" : foundKids};
: foundKids 要 copy 一下，之前我就是忘记了。
:
n*t
30 楼
贴一下最终实现
// model is the mongoose collection Model
function getTree(parent_cid, cb) {
var node = {};
model.find({
parent_cid : parent_cid || 0,
}).exec(function(err, results) {
if (err)
return cb(err);
async.each(results, function(x, next) {
getTree(x.cid, function(err, nodes) {
node[x.name] = nodes;
next(err);
});
}, function(err) {
cb(err, node);
});
});
}
// model is the mongoose collection Model
function getTree(parent_cid, cb) {
var node = {};
model.find({
parent_cid : parent_cid || 0,
}).exec(function(err, results) {
if (err)
return cb(err);
async.each(results, function(x, next) {
getTree(x.cid, function(err, nodes) {
node[x.name] = nodes;
next(err);
});
}, function(err) {
cb(err, node);
});
});
}
m*u
31 楼
谁帮忙转换成java程序吗？
i*i
32 楼
1 没必要用啥库了。
2 要判断tree遍历结束。
随便写了一个：
var treeBuilder = (function () {
var count = 0;
var tree = {};
return {
setRoot: function (root) {
tree[root] = {};
this.grow(tree[root], root);
return this;
},
onDone: function (cb) {
this._cb = cb;
return this;
},
grow: function (root, branch) {
console.log("add: " + branch);
var self = this;
count++;
findChildren(branch, function (children) {
children.forEach(function (c) {
root[c] = {};
self.grow(root[c], c);
});
count--;
if (count == 0) {
self._cb(tree);
}
});
}
};
})();
treeBuilder
.onDone(function (tree) {
console.dir(tree);
})
.setRoot(1);
【在 n*****t 的大作中提到】
: 贴一下最终实现
: // model is the mongoose collection Model
: function getTree(parent_cid, cb) {
: var node = {};
: model.find({
: parent_cid : parent_cid || 0,
: }).exec(function(err, results) {
: if (err)
: return cb(err);
: async.each(results, function(x, next) {
2 要判断tree遍历结束。
随便写了一个：
var treeBuilder = (function () {
var count = 0;
var tree = {};
return {
setRoot: function (root) {
tree[root] = {};
this.grow(tree[root], root);
return this;
},
onDone: function (cb) {
this._cb = cb;
return this;
},
grow: function (root, branch) {
console.log("add: " + branch);
var self = this;
count++;
findChildren(branch, function (children) {
children.forEach(function (c) {
root[c] = {};
self.grow(root[c], c);
});
count--;
if (count == 0) {
self._cb(tree);
}
});
}
};
})();
treeBuilder
.onDone(function (tree) {
console.dir(tree);
})
.setRoot(1);
【在 n*****t 的大作中提到】
: 贴一下最终实现
: // model is the mongoose collection Model
: function getTree(parent_cid, cb) {
: var node = {};
: model.find({
: parent_cid : parent_cid || 0,
: }).exec(function(err, results) {
: if (err)
: return cb(err);
: async.each(results, function(x, next) {
d*e
33 楼
你这设计就有问题
直接存成下面的什么都不用高了
你的设计还是SQL de关系
【在 n*****t 的大作中提到】
: 不是，mongo 里存的是 array
: { id: '子1', parent: '老王' }
: { id: '子2', parent: '老王' }
: { id: '孙1', parent: '子1' }
: { id: '孙2', parent: '子1' }
: { id: '孙3', parent: '子2' }
: 需要变成：
: 老王 : [
: 子1 : [ 孙1, 孙2 ],
: 子2 : [ 孙3 ]
直接存成下面的什么都不用高了
你的设计还是SQL de关系
【在 n*****t 的大作中提到】
: 不是，mongo 里存的是 array
: { id: '子1', parent: '老王' }
: { id: '子2', parent: '老王' }
: { id: '孙1', parent: '子1' }
: { id: '孙2', parent: '子1' }
: { id: '孙3', parent: '子2' }
: 需要变成：
: 老王 : [
: 子1 : [ 孙1, 孙2 ],
: 子2 : [ 孙3 ]
n*t
34 楼
async 更简洁吧，另外 findChildren 返回空就是结束了，不需要 count
【在 i**i 的大作中提到】
: 1 没必要用啥库了。
: 2 要判断tree遍历结束。
: 随便写了一个：
: var treeBuilder = (function () {
: var count = 0;
: var tree = {};
: return {
: setRoot: function (root) {
: tree[root] = {};
: this.grow(tree[root], root);
【在 i**i 的大作中提到】
: 1 没必要用啥库了。
: 2 要判断tree遍历结束。
: 随便写了一个：
: var treeBuilder = (function () {
: var count = 0;
: var tree = {};
: return {
: setRoot: function (root) {
: tree[root] = {};
: this.grow(tree[root], root);
n*t
35 楼
两码事好伐，树生成一次就可以了，还有其他操作。举个例子，给出 id 需要取出
name，当然是 indexed array 比你便历数快多了。
马工不能自己图方便就让客户改需求。
【在 d******e 的大作中提到】
: 你这设计就有问题
: 直接存成下面的什么都不用高了
: 你的设计还是SQL de关系
name，当然是 indexed array 比你便历数快多了。
马工不能自己图方便就让客户改需求。
【在 d******e 的大作中提到】
: 你这设计就有问题
: 直接存成下面的什么都不用高了
: 你的设计还是SQL de关系
i*i
36 楼
async去掉以后更简洁。findChildren是一个小twig结束了。你怎知隔壁老王有没有结
束？
需要判断整体结束。
老哥的基本功不咋地呀。
【在 n*****t 的大作中提到】
: async 更简洁吧，另外 findChildren 返回空就是结束了，不需要 count
束？
需要判断整体结束。
老哥的基本功不咋地呀。
【在 n*****t 的大作中提到】
: async 更简洁吧，另外 findChildren 返回空就是结束了，不需要 count
n*t
37 楼
我的代码是你的一半吧，而且你的 find 都没实际实现，err 也没处理。
隔壁老王结束没结束跟我啥关系啊？把 found 加到 children 里就行了啊，每个
found 都结束了就是 done，最后递归 callback。
感觉你是没理解 async 吧。
【在 i**i 的大作中提到】
: async去掉以后更简洁。findChildren是一个小twig结束了。你怎知隔壁老王有没有结
: 束？
: 需要判断整体结束。
: 老哥的基本功不咋地呀。
隔壁老王结束没结束跟我啥关系啊？把 found 加到 children 里就行了啊，每个
found 都结束了就是 done，最后递归 callback。
感觉你是没理解 async 吧。
【在 i**i 的大作中提到】
: async去掉以后更简洁。findChildren是一个小twig结束了。你怎知隔壁老王有没有结
: 束？
: 需要判断整体结束。
: 老哥的基本功不咋地呀。
i*i
38 楼
你牛，你随意。
对了。理解好了以后，再上来吱一声。谢谢。
【在 n*****t 的大作中提到】
: 我的代码是你的一半吧，而且你的 find 都没实际实现，err 也没处理。
: 隔壁老王结束没结束跟我啥关系啊？把 found 加到 children 里就行了啊，每个
: found 都结束了就是 done，最后递归 callback。
: 感觉你是没理解 async 吧。
对了。理解好了以后，再上来吱一声。谢谢。
【在 n*****t 的大作中提到】
: 我的代码是你的一半吧，而且你的 find 都没实际实现，err 也没处理。
: 隔壁老王结束没结束跟我啥关系啊？把 found 加到 children 里就行了啊，每个
: found 都结束了就是 done，最后递归 callback。
: 感觉你是没理解 async 吧。
n*t
39 楼
分特，本质是个递归，只不过用 async 写，你告诉我为什么要知道隔壁老王结束没结
束。
【在 i**i 的大作中提到】
: 你牛，你随意。
: 对了。理解好了以后，再上来吱一声。谢谢。
束。
【在 i**i 的大作中提到】
: 你牛，你随意。
: 对了。理解好了以后，再上来吱一声。谢谢。
i*i
40 楼
"你告诉我为什么要知道隔壁老王结束没结束。"
假定树是
1
/
2 3
| |
4 5
findChildren( ,2) 发出后2秒返回结果。
findChildren( ,3) 发出后3秒返回结果。
findChildren( ,2)结束后，需要不需要知道隔壁老王结束没有啊？
【在 n*****t 的大作中提到】
: 分特，本质是个递归，只不过用 async 写，你告诉我为什么要知道隔壁老王结束没结
: 束。
假定树是
1
/
2 3
| |
4 5
findChildren( ,2) 发出后2秒返回结果。
findChildren( ,3) 发出后3秒返回结果。
findChildren( ,2)结束后，需要不需要知道隔壁老王结束没有啊？
【在 n*****t 的大作中提到】
: 分特，本质是个递归，只不过用 async 写，你告诉我为什么要知道隔壁老王结束没结
: 束。
n*t
41 楼
所以我说你大概没理解 async，用法是这样的：
each(array, forEachChild, allDone)
这个库本身已经 take care 老王了，只有所有老王的儿子都找到了，才会执行
allDone
【在 i**i 的大作中提到】
: "你告诉我为什么要知道隔壁老王结束没结束。"
: 假定树是
: 1
: /
: 2 3
: | |
: 4 5
: findChildren( ,2) 发出后2秒返回结果。
: findChildren( ,3) 发出后3秒返回结果。
: findChildren( ,2)结束后，需要不需要知道隔壁老王结束没有啊？
each(array, forEachChild, allDone)
这个库本身已经 take care 老王了，只有所有老王的儿子都找到了，才会执行
allDone
【在 i**i 的大作中提到】
: "你告诉我为什么要知道隔壁老王结束没结束。"
: 假定树是
: 1
: /
: 2 3
: | |
: 4 5
: findChildren( ,2) 发出后2秒返回结果。
: findChildren( ,3) 发出后3秒返回结果。
: findChildren( ,2)结束后，需要不需要知道隔壁老王结束没有啊？
i*i
42 楼
不想讨论了。到此为止吧。
【在 n*****t 的大作中提到】
: 所以我说你大概没理解 async，用法是这样的：
: each(array, forEachChild, allDone)
: 这个库本身已经 take care 老王了，只有所有老王的儿子都找到了，才会执行
: allDone
【在 n*****t 的大作中提到】
: 所以我说你大概没理解 async，用法是这样的：
: each(array, forEachChild, allDone)
: 这个库本身已经 take care 老王了，只有所有老王的儿子都找到了，才会执行
: allDone
n*t
43 楼
你这个 counter 写得也有问题，假如老王只有 2 个儿子，grow 3 次，你自己心算一下
【在 i**i 的大作中提到】
: 不想讨论了。到此为止吧。
【在 i**i 的大作中提到】
: 不想讨论了。到此为止吧。
c*e
44 楼
同意。
【在 n*****t 的大作中提到】
: 所以我说你大概没理解 async，用法是这样的：
: each(array, forEachChild, allDone)
: 这个库本身已经 take care 老王了，只有所有老王的儿子都找到了，才会执行
: allDone
【在 n*****t 的大作中提到】
: 所以我说你大概没理解 async，用法是这样的：
: each(array, forEachChild, allDone)
: 这个库本身已经 take care 老王了，只有所有老王的儿子都找到了，才会执行
: allDone
c*e
45 楼
3个问题
1。 getTree function的 callback function cb怎么写的？
2。 nodes从哪来的，怎么赋值的？你的gettree() function里面并没有写nodes怎么赋
值啊。
3。 next(err);是async.each item执行后的call back,应该只需要call一次。你如果
放到递归recursion里，最后递归退出是通过
if (err)
return cb(err);
那 next(err)就没有被call到。
async.each(results, function(x, next) {
getTree(x.cid, function(err, nodes) {
node[x.name] = nodes;
next(err); //next(err);放这对吗？
});
//next(err); 要移到这吗？
}, function(err) {
cb(err, node);
})
// model is the mongoose collection Model
function getTree(parent_cid, cb) {
var node = {};
model.find({
parent_cid : parent_cid || 0,
}).exec(function(err, results) {
if (err)
return cb(err);
async.each(results, function(x, next) {
getTree(x.cid, function(err, nodes) {
node[x.name] = nodes;
next(err);
});
}, function(err) {
cb(err, node);
}); //end of async each
}); //end of exec
}
【在 n*****t 的大作中提到】
: 贴一下最终实现
: // model is the mongoose collection Model
: function getTree(parent_cid, cb) {
: var node = {};
: model.find({
: parent_cid : parent_cid || 0,
: }).exec(function(err, results) {
: if (err)
: return cb(err);
: async.each(results, function(x, next) {
1。 getTree function的 callback function cb怎么写的？
2。 nodes从哪来的，怎么赋值的？你的gettree() function里面并没有写nodes怎么赋
值啊。
3。 next(err);是async.each item执行后的call back,应该只需要call一次。你如果
放到递归recursion里，最后递归退出是通过
if (err)
return cb(err);
那 next(err)就没有被call到。
async.each(results, function(x, next) {
getTree(x.cid, function(err, nodes) {
node[x.name] = nodes;
next(err); //next(err);放这对吗？
});
//next(err); 要移到这吗？
}, function(err) {
cb(err, node);
})
// model is the mongoose collection Model
function getTree(parent_cid, cb) {
var node = {};
model.find({
parent_cid : parent_cid || 0,
}).exec(function(err, results) {
if (err)
return cb(err);
async.each(results, function(x, next) {
getTree(x.cid, function(err, nodes) {
node[x.name] = nodes;
next(err);
});
}, function(err) {
cb(err, node);
}); //end of async each
}); //end of exec
}
【在 n*****t 的大作中提到】
: 贴一下最终实现
: // model is the mongoose collection Model
: function getTree(parent_cid, cb) {
: var node = {};
: model.find({
: parent_cid : parent_cid || 0,
: }).exec(function(err, results) {
: if (err)
: return cb(err);
: async.each(results, function(x, next) {
i*i
46 楼
又读了一下你的代码，发现你的实现是对的。
我不用async。
【在 n*****t 的大作中提到】
: 所以我说你大概没理解 async，用法是这样的：
: each(array, forEachChild, allDone)
: 这个库本身已经 take care 老王了，只有所有老王的儿子都找到了，才会执行
: allDone
我不用async。
【在 n*****t 的大作中提到】
: 所以我说你大概没理解 async，用法是这样的：
: each(array, forEachChild, allDone)
: 这个库本身已经 take care 老王了，只有所有老王的儿子都找到了，才会执行
: allDone
d*e
47 楼
nosql不是这么玩的。
都是按照query来设计数据存储。如果你需要查id，在id上见index好了。
child 就放到sub-doc。数据冗余一些没关系
不过既然是客户这么设计的，那么你只好写query了。
【在 n*****t 的大作中提到】
: 两码事好伐，树生成一次就可以了，还有其他操作。举个例子，给出 id 需要取出
: name，当然是 indexed array 比你便历数快多了。
: 马工不能自己图方便就让客户改需求。
都是按照query来设计数据存储。如果你需要查id，在id上见index好了。
child 就放到sub-doc。数据冗余一些没关系
不过既然是客户这么设计的，那么你只好写query了。
【在 n*****t 的大作中提到】
: 两码事好伐，树生成一次就可以了，还有其他操作。举个例子，给出 id 需要取出
: name，当然是 indexed array 比你便历数快多了。
: 马工不能自己图方便就让客户改需求。
n*t
48 楼
设想一个 category tree，一方面我要构建 menu，另一方面给出 category id 迅速找
到 name，是把 sub category 放在 root 的 suc-doc 方便还是做成 array？
【在 d******e 的大作中提到】
: nosql不是这么玩的。
: 都是按照query来设计数据存储。如果你需要查id，在id上见index好了。
: child 就放到sub-doc。数据冗余一些没关系
: 不过既然是客户这么设计的，那么你只好写query了。
到 name，是把 sub category 放在 root 的 suc-doc 方便还是做成 array？
【在 d******e 的大作中提到】
: nosql不是这么玩的。
: 都是按照query来设计数据存储。如果你需要查id，在id上见index好了。
: child 就放到sub-doc。数据冗余一些没关系
: 不过既然是客户这么设计的，那么你只好写query了。
n*t
49 楼
1) function(err, node)
2) node 就是 getTree callback 得到的 sub tree
3) cb 有 2 个地方会 call，一个是 err，一个是 getTree 得到结果了
next 移到后面，get sub tree 没得到结果就返回了，肯定不对
【在 c*********e 的大作中提到】
: 3个问题
: 1。 getTree function的 callback function cb怎么写的？
: 2。 nodes从哪来的，怎么赋值的？你的gettree() function里面并没有写nodes怎么赋
: 值啊。
: 3。 next(err);是async.each item执行后的call back,应该只需要call一次。你如果
: 放到递归recursion里，最后递归退出是通过
: if (err)
: return cb(err);
: 那 next(err)就没有被call到。
: async.each(results, function(x, next) {
2) node 就是 getTree callback 得到的 sub tree
3) cb 有 2 个地方会 call，一个是 err，一个是 getTree 得到结果了
next 移到后面，get sub tree 没得到结果就返回了，肯定不对
【在 c*********e 的大作中提到】
: 3个问题
: 1。 getTree function的 callback function cb怎么写的？
: 2。 nodes从哪来的，怎么赋值的？你的gettree() function里面并没有写nodes怎么赋
: 值啊。
: 3。 next(err);是async.each item执行后的call back,应该只需要call一次。你如果
: 放到递归recursion里，最后递归退出是通过
: if (err)
: return cb(err);
: 那 next(err)就没有被call到。
: async.each(results, function(x, next) {
l*n
50 楼
array. you can load all menu items into memory, and then build the tree in
memory.
【在 n*****t 的大作中提到】
: 设想一个 category tree，一方面我要构建 menu，另一方面给出 category id 迅速找
: 到 name，是把 sub category 放在 root 的 suc-doc 方便还是做成 array？
memory.
【在 n*****t 的大作中提到】
: 设想一个 category tree，一方面我要构建 menu，另一方面给出 category id 迅速找
: 到 name，是把 sub category 放在 root 的 suc-doc 方便还是做成 array？
n*t
51 楼
现在就是这样实现，npm start 的时候 build tree，存到 json，ajax 到 client 由
angular render 成 menu
【在 l**********n 的大作中提到】
: array. you can load all menu items into memory, and then build the tree in
: memory.
angular render 成 menu
【在 l**********n 的大作中提到】
: array. you can load all menu items into memory, and then build the tree in
: memory.
z*e
52 楼
老姜，这种一般都直接写成properties
而非存到persistance里面去
xml用得比较多，多弄点app就知道了，基本上都是xml在搞
android，fxml，就只有ios是json
当然其他语言parse xml很弱，你做成json也是一种方式
但是基本都是properties，比较少做成persistance
还有就是，即便你要这样搞，这种接近metdata的数据
也是用db比较多，你用nosql算是各种奇芭
由
【在 n*****t 的大作中提到】
: 现在就是这样实现，npm start 的时候 build tree，存到 json，ajax 到 client 由
: angular render 成 menu
而非存到persistance里面去
xml用得比较多，多弄点app就知道了，基本上都是xml在搞
android，fxml，就只有ios是json
当然其他语言parse xml很弱，你做成json也是一种方式
但是基本都是properties，比较少做成persistance
还有就是，即便你要这样搞，这种接近metdata的数据
也是用db比较多，你用nosql算是各种奇芭
由
【在 n*****t 的大作中提到】
: 现在就是这样实现，npm start 的时候 build tree，存到 json，ajax 到 client 由
: angular render 成 menu
l*n
53 楼
yaml
【在 z****e 的大作中提到】
: 老姜，这种一般都直接写成properties
: 而非存到persistance里面去
: xml用得比较多，多弄点app就知道了，基本上都是xml在搞
: android，fxml，就只有ios是json
: 当然其他语言parse xml很弱，你做成json也是一种方式
: 但是基本都是properties，比较少做成persistance
: 还有就是，即便你要这样搞，这种接近metdata的数据
: 也是用db比较多，你用nosql算是各种奇芭
:
: 由
【在 z****e 的大作中提到】
: 老姜，这种一般都直接写成properties
: 而非存到persistance里面去
: xml用得比较多，多弄点app就知道了，基本上都是xml在搞
: android，fxml，就只有ios是json
: 当然其他语言parse xml很弱，你做成json也是一种方式
: 但是基本都是properties，比较少做成persistance
: 还有就是，即便你要这样搞，这种接近metdata的数据
: 也是用db比较多，你用nosql算是各种奇芭
:
: 由
n*t
54 楼
赵老师你也是一桶浆糊，前面不说了，每个 node 下面还有一堆 sub-doc，你不问需求
就在这夸夸其谈。还有，即使 db 和 nosql 都可以，选择 nosql 了怎么就各种奇葩，
您说来听听？
【在 z****e 的大作中提到】
: 老姜，这种一般都直接写成properties
: 而非存到persistance里面去
: xml用得比较多，多弄点app就知道了，基本上都是xml在搞
: android，fxml，就只有ios是json
: 当然其他语言parse xml很弱，你做成json也是一种方式
: 但是基本都是properties，比较少做成persistance
: 还有就是，即便你要这样搞，这种接近metdata的数据
: 也是用db比较多，你用nosql算是各种奇芭
:
: 由
就在这夸夸其谈。还有，即使 db 和 nosql 都可以，选择 nosql 了怎么就各种奇葩，
您说来听听？
【在 z****e 的大作中提到】
: 老姜，这种一般都直接写成properties
: 而非存到persistance里面去
: xml用得比较多，多弄点app就知道了，基本上都是xml在搞
: android，fxml，就只有ios是json
: 当然其他语言parse xml很弱，你做成json也是一种方式
: 但是基本都是properties，比较少做成persistance
: 还有就是，即便你要这样搞，这种接近metdata的数据
: 也是用db比较多，你用nosql算是各种奇芭
:
: 由
d*e
55 楼
要是我就考虑顶层category写成一个json.下面的都是它的sub-doc
sub category存成.
{_id:id, path: “top/child/child-2/child3}
要是找sub-doc就用json path.
【在 n*****t 的大作中提到】
: 设想一个 category tree，一方面我要构建 menu，另一方面给出 category id 迅速找
: 到 name，是把 sub category 放在 root 的 suc-doc 方便还是做成 array？
sub category存成.
{_id:id, path: “top/child/child-2/child3}
要是找sub-doc就用json path.
【在 n*****t 的大作中提到】
: 设想一个 category tree，一方面我要构建 menu，另一方面给出 category id 迅速找
: 到 name，是把 sub category 放在 root 的 suc-doc 方便还是做成 array？
a9
56 楼
你要找一个child(x) where name='老三'的话，你这个存法可是要难受死了
速找
【在 d******e 的大作中提到】
: 要是我就考虑顶层category写成一个json.下面的都是它的sub-doc
: sub category存成.
: {_id:id, path: “top/child/child-2/child3}
: 要是找sub-doc就用json path.
速找
【在 d******e 的大作中提到】
: 要是我就考虑顶层category写成一个json.下面的都是它的sub-doc
: sub category存成.
: {_id:id, path: “top/child/child-2/child3}
: 要是找sub-doc就用json path.
d*e
57 楼
那每个doc加上一个name,然后index一下好了。总之，围绕query设计schema.
其实如果只有1万的量，要我就直接都读进来，然后flatten.filter(_.name ="老三“）
【在 a9 的大作中提到】
: 你要找一个child(x) where name='老三'的话，你这个存法可是要难受死了
:
: 速找
其实如果只有1万的量，要我就直接都读进来，然后flatten.filter(_.name ="老三“）
【在 a9 的大作中提到】
: 你要找一个child(x) where name='老三'的话，你这个存法可是要难受死了
:
: 速找
n*t
58 楼
围绕 query 设计就是 array，树是准静态，find by name or id 频繁操作。
你的设计只有一棵大树，加 index 没用了。
【在 d******e 的大作中提到】
: 那每个doc加上一个name,然后index一下好了。总之，围绕query设计schema.
: 其实如果只有1万的量，要我就直接都读进来，然后flatten.filter(_.name ="老三“）
你的设计只有一棵大树，加 index 没用了。
【在 d******e 的大作中提到】
: 那每个doc加上一个name,然后index一下好了。总之，围绕query设计schema.
: 其实如果只有1万的量，要我就直接都读进来，然后flatten.filter(_.name ="老三“）
c*e
59 楼
你这个function的结果，node["老王"] 里面只会包含一个儿子： “子一”或者“子二
”,不可能同时包含2个或者多个儿子。
你运行了这个function吗？结果正确吗？
// model is the mongoose collection Model
function getTree(parent_cid, cb) {
var node = {};
model.find({
parent_cid : parent_cid || 0,
}).exec(function(err, results) {
if (err)
return cb(err);
async.each(results, function(x, next) {
getTree(x.cid, function(err, nodes) {
node[x.name] = nodes;
next(err);
});
}, function(err) {
cb(err, node);
}); //end of async each
}); //end of exec
}
【在 n*****t 的大作中提到】
: 1) function(err, node)
: 2) node 就是 getTree callback 得到的 sub tree
: 3) cb 有 2 个地方会 call，一个是 err，一个是 getTree 得到结果了
: next 移到后面，get sub tree 没得到结果就返回了，肯定不对
”,不可能同时包含2个或者多个儿子。
你运行了这个function吗？结果正确吗？
// model is the mongoose collection Model
function getTree(parent_cid, cb) {
var node = {};
model.find({
parent_cid : parent_cid || 0,
}).exec(function(err, results) {
if (err)
return cb(err);
async.each(results, function(x, next) {
getTree(x.cid, function(err, nodes) {
node[x.name] = nodes;
next(err);
});
}, function(err) {
cb(err, node);
}); //end of async each
}); //end of exec
}
【在 n*****t 的大作中提到】
: 1) function(err, node)
: 2) node 就是 getTree callback 得到的 sub tree
: 3) cb 有 2 个地方会 call，一个是 err，一个是 getTree 得到结果了
: next 移到后面，get sub tree 没得到结果就返回了，肯定不对
n*t
60 楼
当然运行了，肯定正常。
你还是没理解 async，next 要在对当前 element 操作结束后再 call，也就是要等异
步的结果出来。所有 next 都结束后才能去执行 done。
【在 c*********e 的大作中提到】
: 你这个function的结果，node["老王"] 里面只会包含一个儿子： “子一”或者“子二
: ”,不可能同时包含2个或者多个儿子。
: 你运行了这个function吗？结果正确吗？
:
: // model is the mongoose collection Model
: function getTree(parent_cid, cb) {
: var node = {};
: model.find({
: parent_cid : parent_cid || 0,
: }).exec(function(err, results) {
你还是没理解 async，next 要在对当前 element 操作结束后再 call，也就是要等异
步的结果出来。所有 next 都结束后才能去执行 done。
【在 c*********e 的大作中提到】
: 你这个function的结果，node["老王"] 里面只会包含一个儿子： “子一”或者“子二
: ”,不可能同时包含2个或者多个儿子。
: 你运行了这个function吗？结果正确吗？
:
: // model is the mongoose collection Model
: function getTree(parent_cid, cb) {
: var node = {};
: model.find({
: parent_cid : parent_cid || 0,
: }).exec(function(err, results) {
c*e
61 楼
看不懂你的逻辑，call function的时候的参数是什么，能给个例子吗？
结果正常就好。
【在 n*****t 的大作中提到】
: 当然运行了，肯定正常。
: 你还是没理解 async，next 要在对当前 element 操作结束后再 call，也就是要等异
: 步的结果出来。所有 next 都结束后才能去执行 done。
结果正常就好。
【在 n*****t 的大作中提到】
: 当然运行了，肯定正常。
: 你还是没理解 async，next 要在对当前 element 操作结束后再 call，也就是要等异
: 步的结果出来。所有 next 都结束后才能去执行 done。
n*t
62 楼
next 只有一个参数 err，就是告诉 async 子任务完成，有没有出错。
这么解释吧，一个组 20 个人分段挖路，每个人完成之后向组长报告。如果有人说我这
段挖不了有煤气管，组长就通知老板没法干活、咱收工了。如果所有人都报告完工，组
长给老板打电话、收队换下一波。
所以，任务分配之后，每个人要完成任务之后再向组长汇报，而不是刚接到任务就报告。
【在 c*********e 的大作中提到】
: 看不懂你的逻辑，call function的时候的参数是什么，能给个例子吗？
: 结果正常就好。
这么解释吧，一个组 20 个人分段挖路，每个人完成之后向组长报告。如果有人说我这
段挖不了有煤气管，组长就通知老板没法干活、咱收工了。如果所有人都报告完工，组
长给老板打电话、收队换下一波。
所以，任务分配之后，每个人要完成任务之后再向组长汇报，而不是刚接到任务就报告。
【在 c*********e 的大作中提到】
: 看不懂你的逻辑，call function的时候的参数是什么，能给个例子吗？
: 结果正常就好。
c*e
63 楼
next(err);其实也可以写成next();
你想async.each里每个item都执行，对吧，那这个next();和next(err);最后执行的结
果是一样的。如果each里有一个出错，就马上停止了，然后执行async.each的callback.
所以，next();其实就是放个空炮，不起任何实际作用。
告。
【在 n*****t 的大作中提到】
: next 只有一个参数 err，就是告诉 async 子任务完成，有没有出错。
: 这么解释吧，一个组 20 个人分段挖路，每个人完成之后向组长报告。如果有人说我这
: 段挖不了有煤气管，组长就通知老板没法干活、咱收工了。如果所有人都报告完工，组
: 长给老板打电话、收队换下一波。
: 所以，任务分配之后，每个人要完成任务之后再向组长汇报，而不是刚接到任务就报告。
你想async.each里每个item都执行，对吧，那这个next();和next(err);最后执行的结
果是一样的。如果each里有一个出错，就马上停止了，然后执行async.each的callback.
所以，next();其实就是放个空炮，不起任何实际作用。
告。
【在 n*****t 的大作中提到】
: next 只有一个参数 err，就是告诉 async 子任务完成，有没有出错。
: 这么解释吧，一个组 20 个人分段挖路，每个人完成之后向组长报告。如果有人说我这
: 段挖不了有煤气管，组长就通知老板没法干活、咱收工了。如果所有人都报告完工，组
: 长给老板打电话、收队换下一波。
: 所以，任务分配之后，每个人要完成任务之后再向组长汇报，而不是刚接到任务就报告。
n*t
64 楼
啥？当然不一样，next 不报错，最后 cb 就以为都成功了。就好比挖坑的必须告诉组
长结果如何，不能简单说我走了。
callback.
【在 c*********e 的大作中提到】
: next(err);其实也可以写成next();
: 你想async.each里每个item都执行，对吧，那这个next();和next(err);最后执行的结
: 果是一样的。如果each里有一个出错，就马上停止了，然后执行async.each的callback.
: 所以，next();其实就是放个空炮，不起任何实际作用。
:
: 告。
长结果如何，不能简单说我走了。
callback.
【在 c*********e 的大作中提到】
: next(err);其实也可以写成next();
: 你想async.each里每个item都执行，对吧，那这个next();和next(err);最后执行的结
: 果是一样的。如果each里有一个出错，就马上停止了，然后执行async.each的callback.
: 所以，next();其实就是放个空炮，不起任何实际作用。
:
: 告。
c*y
65 楼
mongo的recursive/connect by query能不能返回这种顺序的结果，本身就是depth
first search顺序的而且带level和leaf，生成树非常方便啊，oracle下做过
{ id: '老王', parent: null, level: 0, leaf: false }
{ id: '子1', parent: '老王', level: 1, leaf: false }
{ id: '孙1', parent: '子1', level: 2, leaf: true }
{ id: '孙2', parent: '子1', level: 2, leaf: true }
{ id: '子2', parent: '老王', level: 1, leaf: false }
{ id: '孙3', parent: '子2', level: 2, leaf: true}
【在 n*****t 的大作中提到】
: 不是，mongo 里存的是 array
: { id: '子1', parent: '老王' }
: { id: '子2', parent: '老王' }
: { id: '孙1', parent: '子1' }
: { id: '孙2', parent: '子1' }
: { id: '孙3', parent: '子2' }
: 需要变成：
: 老王 : [
: 子1 : [ 孙1, 孙2 ],
: 子2 : [ 孙3 ]
first search顺序的而且带level和leaf，生成树非常方便啊，oracle下做过
{ id: '老王', parent: null, level: 0, leaf: false }
{ id: '子1', parent: '老王', level: 1, leaf: false }
{ id: '孙1', parent: '子1', level: 2, leaf: true }
{ id: '孙2', parent: '子1', level: 2, leaf: true }
{ id: '子2', parent: '老王', level: 1, leaf: false }
{ id: '孙3', parent: '子2', level: 2, leaf: true}
【在 n*****t 的大作中提到】
: 不是，mongo 里存的是 array
: { id: '子1', parent: '老王' }
: { id: '子2', parent: '老王' }
: { id: '孙1', parent: '子1' }
: { id: '孙2', parent: '子1' }
: { id: '孙3', parent: '子2' }
: 需要变成：
: 老王 : [
: 子1 : [ 孙1, 孙2 ],
: 子2 : [ 孙3 ]
n*t
66 楼
有意思，回头研究一下。不过感觉效率是一样的吧，mango 做还是 app 做的区别，
query 之后还要手工拼。
【在 c******y 的大作中提到】
: mongo的recursive/connect by query能不能返回这种顺序的结果，本身就是depth
: first search顺序的而且带level和leaf，生成树非常方便啊，oracle下做过
: { id: '老王', parent: null, level: 0, leaf: false }
: { id: '子1', parent: '老王', level: 1, leaf: false }
: { id: '孙1', parent: '子1', level: 2, leaf: true }
: { id: '孙2', parent: '子1', level: 2, leaf: true }
: { id: '子2', parent: '老王', level: 1, leaf: false }
: { id: '孙3', parent: '子2', level: 2, leaf: true}
query 之后还要手工拼。
【在 c******y 的大作中提到】
: mongo的recursive/connect by query能不能返回这种顺序的结果，本身就是depth
: first search顺序的而且带level和leaf，生成树非常方便啊，oracle下做过
: { id: '老王', parent: null, level: 0, leaf: false }
: { id: '子1', parent: '老王', level: 1, leaf: false }
: { id: '孙1', parent: '子1', level: 2, leaf: true }
: { id: '孙2', parent: '子1', level: 2, leaf: true }
: { id: '子2', parent: '老王', level: 1, leaf: false }
: { id: '孙3', parent: '子2', level: 2, leaf: true}
n*t
67 楼
mongo 好像不支持这样的 query，关于 tree 的存储，他们是这样说的：
http://docs.mongodb.org/manual/tutorial/model-tree-structures/
基本上还是 array 存储 linked list
【在 c******y 的大作中提到】
: mongo的recursive/connect by query能不能返回这种顺序的结果，本身就是depth
: first search顺序的而且带level和leaf，生成树非常方便啊，oracle下做过
: { id: '老王', parent: null, level: 0, leaf: false }
: { id: '子1', parent: '老王', level: 1, leaf: false }
: { id: '孙1', parent: '子1', level: 2, leaf: true }
: { id: '孙2', parent: '子1', level: 2, leaf: true }
: { id: '子2', parent: '老王', level: 1, leaf: false }
: { id: '孙3', parent: '子2', level: 2, leaf: true}
http://docs.mongodb.org/manual/tutorial/model-tree-structures/
基本上还是 array 存储 linked list
【在 c******y 的大作中提到】
: mongo的recursive/connect by query能不能返回这种顺序的结果，本身就是depth
: first search顺序的而且带level和leaf，生成树非常方便啊，oracle下做过
: { id: '老王', parent: null, level: 0, leaf: false }
: { id: '子1', parent: '老王', level: 1, leaf: false }
: { id: '孙1', parent: '子1', level: 2, leaf: true }
: { id: '孙2', parent: '子1', level: 2, leaf: true }
: { id: '子2', parent: '老王', level: 1, leaf: false }
: { id: '孙3', parent: '子2', level: 2, leaf: true}
c*e
68 楼
next一旦报错，整个async.each(){}就马上中止，然后就callback了。你难道不想把
results的每一个成员都处理一次？
【在 n*****t 的大作中提到】
: 啥？当然不一样，next 不报错，最后 cb 就以为都成功了。就好比挖坑的必须告诉组
: 长结果如何，不能简单说我走了。
:
: callback.
results的每一个成员都处理一次？
【在 n*****t 的大作中提到】
: 啥？当然不一样，next 不报错，最后 cb 就以为都成功了。就好比挖坑的必须告诉组
: 长结果如何，不能简单说我走了。
:
: callback.
n*t
69 楼
如果需要这样，next 不要传递 err，每个 element 的结果存到一个 array
【在 c*********e 的大作中提到】
: next一旦报错，整个async.each(){}就马上中止，然后就callback了。你难道不想把
: results的每一个成员都处理一次？
【在 c*********e 的大作中提到】
: next一旦报错，整个async.each(){}就马上中止，然后就callback了。你难道不想把
: results的每一个成员都处理一次？
c*e
70 楼
对。
async的每个分支之间互相交流的方法有限，这方面还是multi-threading做得深入些。
【在 n*****t 的大作中提到】
: 如果需要这样，next 不要传递 err，每个 element 的结果存到一个 array
async的每个分支之间互相交流的方法有限，这方面还是multi-threading做得深入些。
【在 n*****t 的大作中提到】
: 如果需要这样，next 不要传递 err，每个 element 的结果存到一个 array
相关阅读
请教如何学java和找工作C++糟粕和需要避免的。Scala又被鄙视了前几天有人问rvalue reference的为何空格鄙视tab? 3空鄙视4空和8空？！NatureOK，你的菜来了c++ 这几天总是被黑，啥节奏c++的问题就是用*标识指针，和乘法混了，应该用@替代一群人天天聊fp, 说实话有几个精通java or c++ or python的？开了定时器，按钮如何保持流畅？请教C++class全tmd是技术红卫兵面试碰到J2EE系统安全性的问题应该怎么回答？c++ copy reference 还是deep copyPython machine learning library请教，call c++ shared lib in java via jniwhat is c++? and what can you expect大家的GitHub里都放点啥代码复用：复制粘贴是一个很好的办法，不亚于继承ETrade API