Javascript 检查Ext.tree.AsyncTreeNode的所有子节点

如果选中，我将尝试检查节点的所有子节点

添加了一个侦听器

   tree.addListener('expandnode', this.onTreeNodeExpand, this);

作用

onTreeNodeExpand: function (node) {
       if (node.hasChildNodes()) {
            node.eachChild(function (n) {
                    var checked = n.parentNode.ui.isChecked();
                    if (checked != undefined && checked)
                    {
                            n.getUI().toggleCheck(checked);
                    }
            });
        }
    }

由于我有一个异步树节点，所有的子记录都将按需加载，当节点第一次被扩展时，我得到这个语句的false

if（node.hasChildNodes（））//返回false

它认为“expandnode”

事件在异步进行的同时被调用

如何捕获一个事件，在加载异步数据后，检查此节点是否已选中，并将所有子节点设置为已选中

环境：extjs3.4
因为在这个场景中，我在EXTJS文档上没有得到太多帮助，所以我按如下方式处理它

我对子记录的所有异步调用都将通过一个函数进行，在该ajax success函数中，数据加载后，我调用了另一个函数来设置基于父节点的复选框

 ajaxForLoading: function (node, deep, anim, isDirectList, childrenConfig) {
       Ext.Ajax.request({
                    url: url,
                    params: param,
                    method: 'POST',
                    success: function (response) {
                       this.loadRelationNodeChildren(node, json, deep, anim, childrenConfig);
                    }

 },
loadRelationNodeChildren: function (node, json, deep, anim, childrenConfig){
    // My other logic
    expandChildNodes(node, this);
 },

expandChildNodes: function(node, scope){
 var checked = node.ui.isChecked();
            node.eachChild(function (n) {
                if (checked != undefined) {
                    var tree = n.ownerTree;
                    if (n.isLeaf())
                        tree.suspendEvents();
                        n.getUI().toggleCheck(checked);
                    if (n.isLeaf())
                        tree.resumeEvents();
                }
            });

}

我使用“beforechildrenrendered”、“expand”、“checkchange”事件通过异步树切换检查节点

root: {nodeType: 'async',text: 'root', id:'-1'},
dataUrl: url,
listeners: {
    scope: this,
    'beforechildrenrendered': function(node) {
        node.eachChild(function(childNode) {
            childNode.on('checkchange', function(node, checked) {
                childNode.suspendEvents();//need suspend events first
                childNode.cascade(function(n) {
                    n.attributes.checked = checked;
                    n.getUI().toggleCheck(checked);
                });
                childNode.resumeEvents();//resume events

                if(!checked) {
                    return;
                }

                if(!node.isLeaf()) {
                    node.expand();
                }
            });
        },this);

        node.on('expand', function(node) {
            if(node.id == '-1') {//root
                return;
            }

            if(node.parentNode && node.parentNode.attributes.checked) {
                node.attributes.checked = true;
                node.getUI().toggleCheck(true);
            }

            if(node.attributes.checked) {
                for(var i = 0; i < node.childNodes.length; i++) {
                    node.childNodes[i].expand();
                }
            }
        });
    }
}

root:{nodeType:'async'，text:'root'，id:'-1'}，
dataUrl:url，
听众：{
范围:本,，
“beforechildrenrendered”：函数（节点）{
node.eachChild（函数（childNode）{
childNode.on（'checkchange'，函数（节点，选中）{
childNode.suspendEvents（）；//首先需要挂起事件
childNode.cascade（函数（n）{
n、 attributes.checked=已选中；
n、 getUI（）.toggleCheck（已选中）；
});
childNode.resumeEvents（）；//恢复事件
如果（！选中）{
返回；
}
如果（！node.isLeaf（））{
node.expand（）；
}
});
}，这个）；
node.on（'expand'，函数（node）{
如果（node.id='-1'）{//root
返回；
}
if（node.parentNode&&node.parentNode.attributes.checked）{
node.attributes.checked=true；
node.getUI（）.toggleCheck（true）；
}
if（node.attributes.checked）{
对于（var i=0；i