dojo.query、JSON树（结构）、dojo读取json（转）

老外这么说：
dojo.query() is the swiss army knife of DOM node manipulation in Dojo. Much like Prototype’s “$$” (bling-bling) function or JQuery’s “$” function, dojo.query provides robust, high-performance CSS-based node selector support with the option of scoping searches to a particular sub-tree of a document
简单点说，就是dojo.query()是可以按样式、标签名、字符等等，来查询文档中的某个元素。
关键是怎么使用，国外的网上说的很清楚，其实你要是能耐住性子把DOJO BOOK里面的都认认真真看一边，就不用看我下面写的这点东西。
我也是惊叹dojo.query 中文资料的匮乏，才把自己看的英文资料和自己的实践做个小结，利人利己。
这个是老外的例子：
Example 1
search the entire document for elements with the class “foo”:

dojo.query(".foo");

these elements will match:

Example 2
search the entire document for elements with the classes “foo” and “bar”:

dojo.query(".foo.bar");
these elements will match:

while these will not:

Example 3
find “ elements which are descendants of paragraphs and which have a “highlighted” class:

dojo.query("p span.highlighted");
the innermost span in this fragment matches:

...
        ...
Example 4
set an “odd” class on all odd table rows inside of the table

#tabular_data
, using the
>
(direct child) selector to avoid affecting any nested tables:
dojo.query("#tabular_data > tbody > tr:nth-child(odd)").addClass("odd");
Example 5
remove all elements with the class “error” from the document and store them in a list:

var errors = dojo.query(".error").orphan();
Example 6
add an onclick handler to every submit button in the document which causes the form to be sent via Ajax instead:

dojo.query("input[type='submit']").onclick(function(e){
    dojo.stopEvent(e); // prevent sending the form
    var btn = e.target;
    dojo.xhrPost({
        form: btn.form,
        load: function(data){
            // replace the form with the response
            var div = dojo.doc.createElement("div");
            dojo.place(div, btn.form, "after");
            div.innerHTML = data;
            dojo.style(btn.form, "display", "none");
        }
    });
});

上面这些例子主要是为了大家能了解query，怎么用！
下面是我自己的例子：
结合JSON查询。
这个是个JSON集合，比较好的用法是你把这个代码放在一个filename.json的文件里。
我放在D:\WK50\tems114\test.json
Js代码

1. { identifier: 'name',   
2.      label: 'name',   
3.      items: [   
4.        { name:'Africa', type:'continent',   
5.            children:[{_reference:'Egypt'}, {_reference:'Sudan'}] },   
6.        { name:'Egypt', type:'country' },   
7.        { name:'Kenya', type:'country' },   
8.        { name:'Sudan', type:'country' }   
9.   ]}  

对于这个JSON的结构有几句话：
JSON的结构，就是 键：值
identifier中文意思：标识符；identifier: 'name' 的意思就是指定后面items里面的name键为标识符。老外说标识符就是唯一识别元组，不会重复的那个东西。
label 中文意思：标签；我的理解就是一个说明吧，这个就好像是你有名字，又有身份证编号一样。这个label就是你的名字，那个identifier就是你的身份证编号。
items 中文意思：元素集合 ，就表示是一个数组，jsonAarry
上面说这些，是为了说明下面这个：
如果你要获取一个元素的label 需要用store.getLabel(item)  这下问题来了：
store是什么？item是什么？先解释一下store就是数据源，dojo里面有个方法可以把json读取后存储为一个数据源，这里的item和上面说的items是有关系的，item就是items中的元素，具体的要看下面的代码。这个也是老外的例子，指不过我略微修改和加了点注释。如果要运行改代码，有个必要条件就是你在引入dojo.js的时候，djConfig里面的isDebug: true  我是jsp的页面，里面引用如下：
Js代码

1. <script type="text/javascript"    
2.    src="<html:rewrite page='/dojoroot/dojo/dojo.js'/>"     
3.    djConfig="parseOnLoad: true, isDebug: true,usePlainJson:true "></script>          

这个例子看似复杂，明白了每句话的意思之后，才觉得，真是简单啊！
Js代码

1. function test()   
2. {//读取json   
3. var store = new dojo.data.ItemFileReadStore({url: "<html:rewrite page="/test.json"/>"});   
4. //下面这个是函数申明，其实就是function gotContinents (items, request);   
5. //这个函数是为了处理后面query: {type: "continent"}返回的结果。具体看   
6. //store.fetch({query: {type: "continent"}, onComplete: gotContinents});  的注解。   
7. // items 是一个数组，查询返回的结果集，request就是请求。至于这个request怎么   
8. //用，我也不清楚，看了很多也没发现这个东西有什么用！   
9. //里面的console.log 其实就是 console.debug() 就是向dojo调试控制台输出。很多   
10. ///用alert()返回是object的东西，通过这2个函数，可以输出具体值，比如本例中的   
11. //console.log("item'lable:["+store.getLabel(item)+"]    
12. //attributes.length="+attributes.length);   
13. //你alert(attributes.length)返回值就是object    
14. //你如果用console.log(attributes.length)控制台输出就是3   
15.   
16.     var gotContinents = function(items, request){      
17.                         //Cycle over all the matches.      
18.                         for(var i = 0; i < items.length; i++){      
19.                             var item = items[i];      
20.                          
21.                             //Cycle over all the attributes.      
22.                             var attributes = store.getAttributes(item);      
23.                             console.log("item'lable:["+store.getLabel(item)+"] attributes.length="+attributes.length);   
24.                             for (var j = 0; j < attributes.length; j++){      
25.                                 //Assume all attributes are multi-valued and loop over the values ...      
26.                                 var values = store.getValues(item, attributes[j]);                     
27.                                 console.log("item'lable:["+store.getLabel(item)+"] values.length="+values.length);   
28.                                 for(var k = 0; k < values.length; k++){      
29.                                     var value = values[k];      
30.                                           
31.                                     if(store.isItem(value)){      
32.                                         //Test to see if the items data is fully loaded or needs to be demand-loaded in (the item in question is just a stub).      
33.                                         if(store.isItemLoaded(value)){      
34.                                             console.log("Located a child item with label: [" + store.getLabel(value) + "]");      
35.                                         }else{      
36.                                             //Asynchronously load in the child item using the stub data to get the real data.      
37.                                             var lazyLoadComplete = function(item){      
38.                                                 console.log("Lazy-Load of item complete.  Located child item with label: [" + store.getLabel(item) + "]");      
39.                                             }      
40.                                             store.loadItem({item: value, onItem: lazyLoadComplete});      
41.                                         }      
42.                                     }else{      
43.                                         console.log("Attribute: [" + attributes[j] + "] has value: [" + value + "]");      
44.                                     }      
45.                                 }                 
46.                             }      
47.                         }      
48.                     }      
49.                          
50.                     //Call the fetch of the toplevel continent items.      
51.                     store.fetch({query: {type: "continent"}, onComplete: gotContinents});     
52. //这个函数很神奇，有3个需要说明：   
53. //query: {type: "continent"} 意思就是在test.json中获取所有type: "continent"的items 显//然只有一条记录： { name:'Africa', type:'continent',   
54. //           children:[{_reference:'Egypt'}, {_reference:'Sudan'}] }   
55. //onComplete: gotContinents  这个onComplete 是fetch的一个参数，意识就是当   
56. //前面这个query查询完成后调用gotContinents  函数   
57. //store.fetch() 简单的说，就是当你需要查询json的时候，把查询语句，和一个处理函   
58. //数放里面;值得说明的是，这个函数是异步调用的，也就是说，可能在一些情况下并不是每   
59. //个元素都被加载完了，这也是为什么上面gotContinents函数里面会有   
60. //if(store.isItemLoaded(value)){} 的原因   
61. }  

运行结果：
Js代码

1. item'lable:[Africa] attributes.length=3   
2. item'lable:[Africa] values.length=1   
3. Attribute: [name] has value: [Africa]   
4. item'lable:[Africa] values.length=1   
5. Attribute: [type] has value: [continent]   
6. item'lable:[Africa] values.length=2   
7. Located a child item with label: [Egypt]   
8. Located a child item with label: [Sudan]  

最后一点说明：json文件中：
children:[{_reference:'Egypt'}, {_reference:'Sudan'}]

中_reference，这个东西找了很多地方，就只在DOJO的例子看见过，没在其他地方见过，在这里就是说，引用了name:'Egypt'元素。尚不清楚是不是标准JSON里面的结构，或者就是dojo自己定义的结构，清楚的人劳烦解释一下。

转载自：http://www.cnblogs.com/mylem/archive/2009/11/15/1603251.html