// add array redirectors

     forEach(["slice", "splice"], function(name){

         var f = ap[name];

         //Use a copy of the this array via this.slice() to allow .end() to work right in the splice case.

         // CANNOT apply ._stash()/end() to splice since it currently modifies

         // the existing this array -- it would break backward compatibility if we copy the array before

         // the splice so that we can use .end(). So only doing the stash option to this._wrap for slice.

         //类似于：this._wrap(this.slice(parameter), this);

         nlp[name] = function(){ return this._wrap(f.apply(this, arguments), name == "slice" ? this : null); };

     });

     // concat should be here but some browsers with native NodeList have problems with it

     // add array.js redirectors

     forEach(["indexOf", "lastIndexOf", "every", "some"], function(name){

         var f = array[name];

         //类似于：dojo.indexOf(this, parameter)

         nlp[name] = function(){ return f.apply(dojo, [this].concat(aps.call(arguments, 0))); };

     });

     lang.extend(NodeList, {//将属性扩展至原型链

         // copy the constructors

         constructor: nl,

         _NodeListCtor: nl,

         toString: function(){

             // Array.prototype.toString can't be applied to objects, so we use join

             return this.join(",");

         },

         _stash: function(parent){//保存parent，parent应当也是nl的一个实例

             // summary:

             //        private function to hold to a parent NodeList. end() to return the parent NodeList.

             //

             // example:

             //        How to make a `dojo/NodeList` method that only returns the third node in

             //        the dojo/NodeList but allows access to the original NodeList by using this._stash:

             //    |    require(["dojo/query", "dojo/_base/lang", "dojo/NodeList", "dojo/NodeList-dom"

             //    |    ], function(query, lang){

             //    |        lang.extend(NodeList, {

             //    |            third: function(){

             //    |                var newNodeList = NodeList(this[2]);

             //    |                return newNodeList._stash(this);

             //    |            }

             //    |        });

             //    |        // then see how _stash applies a sub-list, to be .end()'ed out of

             //    |        query(".foo")

             //    |            .third()

             //    |                .addClass("thirdFoo")

             //    |            .end()

             //    |            // access to the orig .foo list

             //    |            .removeClass("foo")

             //    |    });

             //

             this._parent = parent;

             return this; // dojo/NodeList

         },

         on: function(eventName, listener){//绑定事件

             // summary:

             //        Listen for events on the nodes in the NodeList. Basic usage is:

             //

             // example:

             //        |    require(["dojo/query"

             //        |    ], function(query){

             //        |        query(".my-class").on("click", listener);

             //            This supports event delegation by using selectors as the first argument with the event names as

             //            pseudo selectors. For example:

             //        |         query("#my-list").on("li:click", listener);

             //            This will listen for click events within `<li>` elements that are inside the `#my-list` element.

             //            Because on supports CSS selector syntax, we can use comma-delimited events as well:

             //        |         query("#my-list").on("li button:mouseover, li:click", listener);

             //        |    });

             var handles = this.map(function(node){

                 return on(node, eventName, listener); // TODO: apply to the NodeList so the same selector engine is used for matches

             });

             handles.remove = function(){

                 for(var i = 0; i < handles.length; i++){

                     handles[i].remove();

                 }

             };

             return handles;

         },

         end: function(){//由当前的nl返回父nl

             // summary:

             //        Ends use of the current `NodeList` by returning the previous NodeList

             //        that generated the current NodeList.

             // description:

             //        Returns the `NodeList` that generated the current `NodeList`. If there

             //        is no parent NodeList, an empty NodeList is returned.

             // example:

             //    |    require(["dojo/query", "dojo/NodeList-dom"

             //    |    ], function(query){

             //    |        query("a")

             //    |            .filter(".disabled")

             //    |                // operate on the anchors that only have a disabled class

             //    |                .style("color", "grey")

             //    |            .end()

             //    |            // jump back to the list of anchors

             //    |            .style(...)

             //    |    });

             //

             if(this._parent){

                 return this._parent;

             }else{

                 //Just return empty list.

                 return new this._NodeListCtor(0);

             }

         },

         concat: function(item){

             // summary:

             //        Returns a new NodeList comprised of items in this NodeList

             //        as well as items passed in as parameters

             // description:

             //        This method behaves exactly like the Array.concat method

             //        with the caveat that it returns a `NodeList` and not a

             //        raw Array. For more details, see the [Array.concat

             //        docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/concat)

             // item: Object?

             //        Any number of optional parameters may be passed in to be

             //        spliced into the NodeList

             //return this._wrap(apc.apply(this, arguments));

             // the line above won't work for the native NodeList, or for Dojo NodeLists either :-(

             // implementation notes:

             // Array.concat() doesn't recognize native NodeLists or Dojo NodeLists

             // as arrays, and so does not inline them into a unioned array, but

             // appends them as single entities. Both the original NodeList and the

             // items passed in as parameters must be converted to raw Arrays

             // and then the concatenation result may be re-_wrap()ed as a Dojo NodeList.

             var t = aps.call(this, 0),

                 m = array.map(arguments, function(a){//array.concat方法不会将原始的NodeList和dojo的NodeList作为数组来处理，所以在这之前将他们转化成普通的数组

                     return aps.call(a, 0);

                 });

             return this._wrap(apc.apply(t, m), this);    // dojo/NodeList

         },

         map: function(/*Function*/ func, /*Function?*/ obj){

             // summary:

             //        see `dojo/_base/array.map()`. The primary difference is that the acted-on

             //        array is implicitly this NodeList and the return is a

             //        NodeList (a subclass of Array)

             return this._wrap(array.map(this, func, obj), this); // dojo/NodeList

         },

         forEach: function(callback, thisObj){

             // summary:

             //        see `dojo/_base/array.forEach()`. The primary difference is that the acted-on

             //        array is implicitly this NodeList. If you want the option to break out

             //        of the forEach loop, use every() or some() instead.

             forEach(this, callback, thisObj);

             // non-standard return to allow easier chaining

             return this; // dojo/NodeList

         },

         filter: function(/*String|Function*/ filter){

             // summary:

             //        "masks" the built-in javascript filter() method (supported

             //        in Dojo via `dojo/_base/array.filter`) to support passing a simple

             //        string filter in addition to supporting filtering function

             //        objects.

             // filter:

             //        If a string, a CSS rule like ".thinger" or "div > span".

             // example:

             //        "regular" JS filter syntax as exposed in `dojo/_base/array.filter`:

             //        |    require(["dojo/query", "dojo/NodeList-dom"

             //        |    ], function(query){

             //        |        query("*").filter(function(item){

             //        |            // highlight every paragraph

             //        |            return (item.nodeName == "p");

             //        |        }).style("backgroundColor", "yellow");

             //        |    });

             // example:

             //        the same filtering using a CSS selector

             //        |    require(["dojo/query", "dojo/NodeList-dom"

             //        |    ], function(query){

             //        |        query("*").filter("p").styles("backgroundColor", "yellow");

             //        |    });

             var a = arguments, items = this, start = 0;

             if(typeof filter == "string"){ // inline'd type check

                 items = query._filterResult(this, a[0]);//如果filter是css选择器，调用query的filter方法从已有集合中选择合适的元素

                 if(a.length == 1){

                     // if we only got a string query, pass back the filtered results

                     return items._stash(this); // dojo/NodeList

                 }

                 // if we got a callback, run it over the filtered items

                 start = 1;

             }

             //如果filter是函数，那就调用array的filter先过滤在包装。

             return this._wrap(array.filter(items, a[start], a[start + 1]), this);    // dojo/NodeList

         },

         instantiate: function(/*String|Object*/ declaredClass, /*Object?*/ properties){

             // summary:

             //        Create a new instance of a specified class, using the

             //        specified properties and each node in the NodeList as a

             //        srcNodeRef.

             // example:

             //        Grabs all buttons in the page and converts them to dijit/form/Button's.

             //    |    var buttons = query("button").instantiate(Button, {showLabel: true});

             //这个方法主要用于将原生dom元素实例化成dojo的dijit

             var c = lang.isFunction(declaredClass) ? declaredClass : lang.getObject(declaredClass);

             properties = properties || {};

             return this.forEach(function(node){

                 new c(properties, node);

             });    // dojo/NodeList

         },

         at: function(/*===== index =====*/){

             // summary:

             //        Returns a new NodeList comprised of items in this NodeList

             //        at the given index or indices.

             //

             // index: Integer...

             //        One or more 0-based indices of items in the current

             //        NodeList. A negative index will start at the end of the

             //        list and go backwards.

             //

             // example:

             //    Shorten the list to the first, second, and third elements

             //    |    require(["dojo/query"

             //    |    ], function(query){

             //    |        query("a").at(0, 1, 2).forEach(fn);

             //    |    });

             //

             // example:

             //    Retrieve the first and last elements of a unordered list:

             //    |    require(["dojo/query"

             //    |    ], function(query){

             //    |        query("ul > li").at(0, -1).forEach(cb);

             //    |    });

             //

             // example:

             //    Do something for the first element only, but end() out back to

             //    the original list and continue chaining:

             //    |    require(["dojo/query"

             //    |    ], function(query){

             //    |        query("a").at(0).onclick(fn).end().forEach(function(n){

             //    |            console.log(n); // all anchors on the page.

             //    |    })

             //    |    });

             //与array中的位置选择器类似

             var t = new this._NodeListCtor(0);

             forEach(arguments, function(i){

                 if(i < 0){ i = this.length + i; }

                 if(this[i]){ t.push(this[i]); }

             }, this);

             return t._stash(this); // dojo/NodeList

         }

     });