core.js种子模块
- 提供静态方法或属性，如$.extend（拷贝对象，首参true深拷贝）、$.each（遍历对象，返回首参对象）、$.map（遍历对象，创建新数组返回）、$.grep（过滤数组）、$.merge（拼接数组，返回首参对象）、$.proxy（改变函数执行的上下文）、$.makeArray（转变为数组）、$.inArray（返回元素在数组中的索引）、$.camelCase（转变为驼峰式书写）、$.nodeName（判断元素的nodeName是否和期望相同）、$.trim（移除字符串首尾空格）、$.globalEval（创建script节点执行代码）、$.type（类型判断）、$.isEmptyObject（是否空对象）、$.isPlainObject（是否普通对象）、$.isNumeric（是否数值或数值型字符串）、$.isWindow（是否window对象）、$.isArray（是否数组）、$.isFunction（是否函数）、$.noop（空函数）、$.error（创建错误对象）、$.now（当前时间）、$.support（浏览器能力检测）、$.guid（jquery内方法的guid，便于移除函数）、$.isReady（jquery加载完成）、$.expando（单次加载jquery的标识符）。
- 通过new jQuery.fn.init(selector,context)形式创建jquery对象，该jquery对象继承了$.fn中原型发放或属性，参见init.js。
- 为jquery对象提供原型方法或属性，如$.fn.toArray（将dom对象转化为数组）、$.fn.get（获取dom对象）、$.fn.pushStack（以堆栈形式保存本次获取的jquery对象，prevObject保存前次jquery对象）、$.fn.each（遍历dom对象）、$.fn.map（遍历dom对象）、$.fn.slice（获取dom对象的部分）、$.fn.first（获取首个jquery对象）、$.fn.last（获取末一个jquery对象）、$.fn.eq（获取index序号的jquery对象）、$.fn.end（以prevObject获取前一个jquery对象）、$.fn.push（数组push方法处理dom对象）、$.fn.sort（数组sort方法处理dom元素）、$.fn.splice（数组splice处理dom元素）、$.fn.constructor（返回$）、$.fn.jquery（返回版本号）、$.fn.length（dom对象的个数）。
define( [
"./var/arr",// [] 提供数组的一帮方法
"./var/document",// window.document
"./var/getProto",// Object.getPrototypeOf
"./var/slice",// arr.slice
"./var/concat",// arr.concat
"./var/push",// arr.push
"./var/indexOf",// arr.indexOf
"./var/class2type",// {} 以键值对类型存储toString方法的简单类型；并提供对象的一般方法
"./var/toString",// class2type.toString
"./var/hasOwn",// class2type.hasOwnProperty
"./var/fnToString",// hasOwn.toString
"./var/ObjectFunctionString",// fnToString.call( Object );
"./var/support",// {} 存储浏览器能力检测相关内容
"./core/DOMEval"// function(code,dom) 创建script节点插入dom，执行code后，删除该script节点
], function( arr, document, getProto, slice, concat, push, indexOf,
class2type, toString, hasOwn, fnToString, ObjectFunctionString,
support, DOMEval ) {
var
version = "@VERSION",
// 构建jquery对象
jQuery = function( selector, context ) {
return new jQuery.fn.init( selector, context );
},
// 去除s收尾两端的空格
rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
// 驼峰式转换需要
rmsPrefix=/^-ms-/,
rdashAlpha=/-([a-z])/g,
fcamelCase=function(all,letter){
return letter.toUpperCase();
};
// 公有方法
jQuery.fn = jQuery.prototype = {
jquery: version,// 版本
constructor: jQuery,// jquery对象的构造函数
length: 0,// jquery对象的默认值
// slice方法转化为数组
toArray: function() {
return slice.call( this );
},
// 获取Dom元素，负值反向获取，null数组输出
get: function( num ) {
return num != null ?
( num < 0 ? this[ num + this.length ] : this[ num ] ) :
slice.call( this );
},
// 创建jquery对象堆栈，压入ret中，ret.prevObject属性存储当前的dom元素
// $("#btns").eq(1)，eq方法中执行pushStack，ret变为[$,$("#btns")[1]]，prevObject存储$("#btns")
pushStack: function( elems ) {
var ret = jQuery.merge( this.constructor(), elems );// this.constructor()即$，长度为0
ret.prevObject = this;
return ret;
},
// 遍历dom对象，执行callback回调函数，
// jquery对象为类数组对象，$(".btns")[i]获取dom对象
each: function( callback ) {
return jQuery.each( this, callback );
},
// 遍历后选取部分jquery对象
map: function( callback ) {
return this.pushStack( jQuery.map( this, function( elem, i ) {
return callback.call( elem, i, elem );
} ) );
},
// 用slice方法截取jquery对象数组的部分
slice: function() {
return this.pushStack( slice.apply( this, arguments ) );
},
first: function() {
return this.eq( 0 );
},
last: function() {
return this.eq( -1 );
},
// 获取index=i的jquery对象
eq: function( i ) {
var len = this.length,
j = +i + ( i < 0 ? len : 0 );
return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
},
// 获取前一次jquery对象，或者返回jquery构造函数
end: function() {
return this.prevObject || this.constructor();
},
push: push,
sort: arr.sort,
splice: arr.splice
};
// 首参为布尔值时，是否深拷贝，将拷贝对象options内容复制给目标对象target，同时改变target
// target不存在，且options仅有一项时，将options内容拷贝给全局变量jQuery，用来制作插件等
jQuery.extend = jQuery.fn.extend = function() {
var options, name, src, copy, copyIsArray, clone,
target = arguments[ 0 ] || {},
i = 1,
length = arguments.length,
deep = false;
if ( typeof target === "boolean" ) {
deep = target;
target = arguments[ i ] || {};
i++;
}
// 非数组或非函数，目标对象target赋值为空对象
if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
target = {};
}
// 没有target，仅有一项options时，target赋值为jQuery全局变量，添加插件方法
if ( i === length ) {
target = this;
i--;
}
for ( ; i < length; i++ ) {
if ( ( options = arguments[ i ] ) != null ) {
for ( name in options ) {
src = target[ name ];
copy = options[ name ];
if ( target === copy ) {// 基本类型===成立
continue;
}
if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
( copyIsArray = jQuery.isArray( copy ) ) ) ) {
if ( copyIsArray ) {
copyIsArray = false;
clone = src && jQuery.isArray( src ) ? src : [];
} else {
clone = src && jQuery.isPlainObject( src ) ? src : {};
}
target[ name ] = jQuery.extend( deep, clone, copy );
} else if ( copy !== undefined ) {
target[ name ] = copy;
}
}
}
}
return target;
};
// 静态方法，jquery对象未继承
jQuery.extend( {
// 全局jquery的统一标识符，一次加载生成一个
expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
// jquery加载完成
isReady: true,
// 创建错误对象
error: function( msg ) {
throw new Error( msg );
},
// 空函数
noop: function() {},
// 是否函数
isFunction: function( obj ) {
return jQuery.type( obj ) === "function";
},
// 是否数组
isArray: Array.isArray,
// 是否window对象
isWindow: function( obj ) {
return obj != null && obj === obj.window;
},
// 是否数值或数值化字符串
isNumeric: function( obj ) {
var type = jQuery.type( obj );
return ( type === "number" || type === "string" ) &&
// parseFloat函数传参为NaN时，输出仍为NaN，其余数值化字符串转化为数值
!isNaN( obj - parseFloat( obj ) );
},
// 是否普通对象
isPlainObject: function( obj ) {
var proto, Ctor;
if ( !obj || toString.call( obj ) !== "[object Object]" ) {
return false;
}
proto = getProto( obj );// Object.getPrototypeOf获取原型obj.prototype
if ( !proto ) {
return true;
}
// {}.hasOwnProperty获取对象的自有属性
Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
},
// 是否空对象
isEmptyObject: function( obj ) {
var name;
for ( name in obj ) {
return false;
}
return true;
},
// 判断类型
type: function( obj ) {
if ( obj == null ) {
return obj + "";
}
return typeof obj === "object" || typeof obj === "function" ?
class2type[ toString.call( obj ) ] || "object" :
typeof obj;
},
// 插入script节点的方式执行一段code代码，code代码所用变量均为全局变量
globalEval: function( code ) {
DOMEval( code );
},
// "-"连接的字符串转换为驼峰式书写法，且"-ms-"开头的字符串转换为"ms-"开头
camelCase: function(string){
return string.replace(rmsPrefix,"ms-").replace(rdashAlpha,fcamelCase);
},
// 判断节点elem的nodeName与期望值name是否匹配
nodeName: function( elem, name ) {
return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
},
// 遍历对象或数组，执行callback(value,key)回调函数，callback返回否则遍历终止，上下文为value
// obj原路返回，除非callback中改变，否则不改变obj值
each: function( obj, callback ) {
var length, i = 0;
if ( isArrayLike( obj ) ) {
length = obj.length;
for ( ; i < length; i++ ) {
if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
break;
}
}
} else {
for ( i in obj ) {
if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
break;
}
}
}
return obj;
},
// 去掉字符串收尾两端的空格
trim: function( text ) {
return text == null ? "" : ( text + "" ).replace( rtrim, "" );
},
// 将arr转化为数组，拼接results后面，返回新的数组
makeArray: function( arr, results ) {
var ret = results || [];
if ( arr != null ) {
if ( isArrayLike( Object( arr ) ) ) {
jQuery.merge( ret, typeof arr === "string" ? [ arr ] : arr );
} else {
push.call( ret, arr );
}
}
return ret;
},
// 从i位置开始查询elem在arr数组中的位置
inArray: function( elem, arr, i ) {
return arr == null ? -1 : indexOf.call( arr, elem, i );
},
// 将第二个数组拼接到第一个数组后面，同时第一个数组被改变
merge: function( first, second ) {
var len = +second.length,
j = 0,
i = first.length;
for ( ; j < len; j++ ) {
first[ i++ ] = second[ j ];
}
first.length = i;
return first;
},
// 遍历执行callback回调过滤数组elems，真值时保留；ivert为否时，执行结果为否值时保留
grep: function( elems, callback, invert ) {
var callbackInverse,
matches = [],
i = 0,
length = elems.length,
callbackExpect = !invert;
for ( ; i < length; i++ ) {
callbackInverse = !callback( elems[ i ], i );
if ( callbackInverse !== callbackExpect ) {
matches.push( elems[ i ] );
}
}
return matches;
},
// 遍历数组或对象执行callback，返回非null时，压入新创建的ret数组中，以ret返回
map: function( elems, callback, arg ) {
var length, value,
i = 0,
ret = [];
if ( isArrayLike( elems ) ) {
length = elems.length;
for ( ; i < length; i++ ) {
value = callback( elems[ i ], i, arg );
if ( value != null ) {
ret.push( value );
}
}
} else {
for ( i in elems ) {
value = callback( elems[ i ], i, arg );
if ( value != null ) {
ret.push( value );
}
}
}
return concat.apply( [], ret );
},
// 供绑定事件函数使用的guid，标记函数，以便移除
guid: 1,
// 改变fn函数执行的上下文，并输出fn函数，绑定事件中使用可约定函数执行的上下文
// 解绑时通过guid查找回调函数fn，并从dataPriv中清除，并可向fn传递额外函数
proxy: function( fn, context ) {
var tmp, args, proxy;
// context为字符串，且fn为对象时，以fn作为上下文，fn[context]作为回调函数
if ( typeof context === "string" ) {
tmp = fn[ context ];
context = fn;
fn = tmp;
}
if ( !jQuery.isFunction( fn ) ) {
return undefined;
}
args = slice.call( arguments, 2 );
proxy = function() {
return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
};
// guid作为函数的标记，记录后，可以通过校验函数guid方式删除函数
proxy.guid = fn.guid = fn.guid || jQuery.guid++;
return proxy;
},
now: Date.now,// 当前时间
support: support// 浏览器能力检测
} );
// JSHint would error on this code due to the Symbol not being defined in ES5.
// Defining this global in .jshintrc would create a danger of using the global
// unguarded in another place, it seems safer to just disable JSHint for these
// three lines.
/* jshint ignore: start */
if ( typeof Symbol === "function" ) {
jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
}
// class2type以键值对类型存储toString方法的简单类型
jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
function( i, name ) {
class2type[ "[object " + name + "]" ] = name.toLowerCase();
} );
// 判断是否数组或伪数组
function isArrayLike( obj ) {
var length = !!obj && "length" in obj && obj.length,
type = jQuery.type( obj );
if ( type === "function" || jQuery.isWindow( obj ) ) {
return false;
}
return type === "array" || length === 0 ||
typeof length === "number" && length > 0 && ( length - 1 ) in obj;
}
return jQuery;
} );
init.js
- 创建jquery对象。
- 传参为$(slector,context)形式，在context元素或context对象或当前文档中获取slector，将dom对象包装为jquery对象，添加length、selector、context属性，index序号获取dom对象。
- 传参为$(html,ownerDocument)形式，在ownerDocument元素或当前文档中创建html元素，参见parseHTML。
- 传参为$(html,props)形式，在当前文档中创建html元素，props为向该html元素添加的属性，或者待执行的jquery方法。
- 传参为$(#id)形式，调用getElementById获取dom对象后，封装为jquery对象输出。
- 传参为$(tagName)，转化为$(slector,context)形式后处理。
- 传参为$(callback)，文档加载完成后执行callback回调函数，参见ready.js。
define( [
"../core",// 提供jquery全局变量
"../var/document",// window.document
"./var/rsingleTag",// ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i ) 匹配html标签名
"../traversing/findFilter"
], function( jQuery, document, rsingleTag ) {
var rootjQuery,
rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
init = jQuery.fn.init = function( selector, context, root ) {
var match, elem;
if ( !selector ) {
return this;
}
root = root || rootjQuery;// jQuery( document );
if ( typeof selector === "string" ) {
// 字符串以<、>闭合，跳过rquickExpr正则匹配
if ( selector[ 0 ] === "<" && selector[ selector.length - 1 ] === ">" &&
selector.length >= 3 ) {
match = [ null, selector, null ];
} else {
match = rquickExpr.exec( selector );
}
// 传参字符串匹配rquickExpr中html，或匹配rquickExpr中#id，且没有content
if ( match && ( match[ 1 ] || !context ) ) {
// 传参字符串匹配rquickExpr中html
// context为ownerDocument形式，意味创建DOM元素所在的文档
// context为props，用于执行jquery对象的方法或为dom元素修改属性、事件
if ( match[ 1 ] ) {
context = context instanceof jQuery ? context[ 0 ] : context;
// jQuery.parseHTML将html字符串转化成dom节点，尾参true时执行字符串中script脚本
jQuery.merge( this, jQuery.parseHTML(
match[ 1 ],
context && context.nodeType ? context.ownerDocument || context : document,
true
) );
// 传参context为创建节点的属性配置props
if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
for ( match in context ) {
// jquery对象拥有match方法时，context[match]作为参数执行该方法
// 或者修改dom节点的属性
if ( jQuery.isFunction( this[ match ] ) ) {
this[ match ]( context[ match ] );
} else {
this.attr( match, context[ match ] );
}
}
}
return this;
// 处理$(#id)情形，无content
} else {
elem = document.getElementById( match[ 2 ] );
if ( elem ) {
this[ 0 ] = elem;
this.length = 1;
}
return this;
}
// 选择器形式，没有指定context参数，在当前的HTML document中查找DOM元素
// 有指定context参数，在指定的DOM元素或jquery对象中查找
} else if ( !context || context.jquery ) {
return ( context || root ).find( selector );
} else {
return this.constructor( context ).find( selector );
}
// selector为dom元素，封装为jquery对象后返回
} else if ( selector.nodeType ) {
this[ 0 ] = selector;
this.length = 1;
return this;
// 文档载入完成后执行函数，或尚未载入，传参全局变量jquery
} else if ( jQuery.isFunction( selector ) ) {
return root.ready !== undefined ? root.ready( selector ) : selector( jQuery );
}
return jQuery.makeArray( selector, this );
};
// new运算符移到init方法中执行的目的，创建jquery实例的时候只需执行$()，不必调用new运算符
// 调用init方法前使用new运算符的必要，不使用时，init方法内部this关键字指向$实例，拥有$.fn的属性和方法
// 使用时，init方法称为构造器，内部使用this仅和init构造器相关
// init.prototype=jQuery.fn使init方法产生的实例，拥有$.fn的原型方法
init.prototype = jQuery.fn;
rootjQuery = jQuery( document );
return init;
} );
ready.js
- 文档加载成功时执行函数功能实现，提供$.fn.ready（向文档加载成功时触发的延迟对象添加回调函数；$(callback)调用，简化处理）、$.holdReady（暂停或恢复ready事件）、$.ready.then（用延迟对象的then方法添加成功时触发的回调函数）、$.readyWait（暂停ready事件，该属性归0时执行回调函数）。
define( [
"../core",
"../var/document",
"../deferred"
], function( jQuery, document ) {
var readyList = jQuery.Deferred();// 延迟对象
jQuery.fn.ready = function( fn ) {
readyList.then( fn );
return this;
};
jQuery.extend( {
isReady: false,
// 调用多次$(fn)，各回调函数fn推送到readyList，执行时机为最后一次执行$(fn)，适用于异步情况
readyWait: 1,
// 暂停或恢复ready事件
holdReady: function( hold ) {
if ( hold ) {
jQuery.readyWait++;
} else {
jQuery.ready( true );
}
},
ready: function( wait ) {
if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
return;
}
jQuery.isReady = true;
if ( wait !== true && --jQuery.readyWait > 0 ) {
return;
}
// 触发执行readyList中回调函数
readyList.resolveWith( document, [ jQuery ] );
}
} );
// 向外提供接口添加回调函数
jQuery.ready.then = readyList.then;
function completed() {
document.removeEventListener( "DOMContentLoaded", completed );
window.removeEventListener( "load", completed );
jQuery.ready();
}
// 文档已加载完成，直接执行jQuery.ready；否则绑定文档加载成功的事件执行jQuery.ready
if ( document.readyState === "complete" ||
( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
window.setTimeout( jQuery.ready );
} else {
document.addEventListener( "DOMContentLoaded", completed );
window.addEventListener( "load", completed );
}
} );
parseHTML.js
- 将html字符串转化为dom对象形式。尾参keepScripts为真时，执行html字符串中script脚本。
define( [
"../core",// 提供jquery全局变量
"../var/document",// window.document
"./var/rsingleTag",// ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i ) 匹配html标签名
"../manipulation/buildFragment",// 将html字符串转化为dom对象
"./support"
], function( jQuery, document, rsingleTag, buildFragment, support ) {
// data字符串html，context(可选)指定在哪个document创建元素，keepScripts为true时执行代码
jQuery.parseHTML = function( data, context, keepScripts ) {
if ( typeof data !== "string" ) {
return [];
}
if ( typeof context === "boolean" ) {
keepScripts = context;
context = false;
}
var base, parsed, scripts;
if ( !context ) {
// support.createHTMLDocument检测浏览器是否支持用document.implementation.createHTMLDocument
// 创建另一个document，被iframe包裹
if ( support.createHTMLDocument ) {
context = document.implementation.createHTMLDocument( "" );
base = context.createElement( "base" );
base.href = document.location.href;
context.head.appendChild( base );
} else {
context = document;
}
}
parsed = rsingleTag.exec( data );// data以<起始只提供创建元素的节点名
scripts = !keepScripts && [];
if ( parsed ) {
return [ context.createElement( parsed[ 1 ] ) ];
}
// html字符串中script脚本节点压入scripts中，keepScripts否值移除，不执行脚本，返回创建的dom元素
parsed = buildFragment( [ data ], context, scripts );
if ( scripts && scripts.length ) {
jQuery( scripts ).remove();
}
return jQuery.merge( [], parsed.childNodes );
};
return jQuery.parseHTML;
} );
附：buildFragment.js
define( [
"../core",
"./var/rtagName",// 匹配html节点标签名 ( /<([a-z][^\/\0>\x20\t\r\n\f]+)/i )
"./var/rscriptType",// ( /^$|\/(?:java|ecma)script/i )
"./wrapMap",// 获取option、tr、tbody包裹节点名称select、table/tbody、table
"./getAll",// getAll(context,tag) 获取context下所有tagName为tag的节点
"./setGlobalEval"// "globalEval"属性记录sctipt节点中的语法已执行
], function( jQuery, rtagName, rscriptType, wrapMap, getAll, setGlobalEval ) {
var rhtml = /<|&#?\w+;/;
function buildFragment( elems, context, scripts, selection, ignored ) {
var elem, tmp, tag, wrap, contains, j,
fragment = context.createDocumentFragment(),
nodes = [],
i = 0,
l = elems.length;
for ( ; i < l; i++ ) {
elem = elems[ i ];
if ( elem || elem === 0 ) {
// elem本身为dom对象
if ( jQuery.type( elem ) === "object" ) {
jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
} else if ( !rhtml.test( elem ) ) {
nodes.push( context.createTextNode( elem ) );
// 将html转化成dom对象，插入文档中，用dom方法获取
} else {
tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
// option、tr、tbody元素用select、table/tbody、table包裹
tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
wrap = wrapMap[ tag ] || wrapMap._default;
tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
// 用div、select等包裹后，lastChild获取实际添加的元素
j = wrap[ 0 ];
while ( j-- ) {
tmp = tmp.lastChild;
}
// html字符串转化为dom对象形式，存储到nodes中
jQuery.merge( nodes, tmp.childNodes );
tmp = fragment.firstChild;
tmp.textContent = "";
}
}
}
// 清除fragment中元素后，使用遍历方式将nodes中元素推送到fragment中
fragment.textContent = "";
i = 0;
while ( ( elem = nodes[ i++ ] ) ) {
// 传入的elems本就是dom节点对象的形式
if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
if ( ignored ) {
ignored.push( elem );
}
continue;
}
contains = jQuery.contains( elem.ownerDocument, elem );
// fragment中添加elem，tmp获取所有tmp节点
tmp = getAll( fragment.appendChild( elem ), "script" );
// 阻止script节点脚本执行
if ( contains ) {
setGlobalEval( tmp );
}
// script节点压入scripts数组中
if ( scripts ) {
j = 0;
while ( ( elem = tmp[ j++ ] ) ) {
if ( rscriptType.test( elem.type || "" ) ) {
scripts.push( elem );
}
}
}
}
return fragment;
}
return buildFragment;
} );
getAll.js
define([
"../core"
],function(jQuery){
// getAll为单参数时，数组形式返回context；
// 双参数，且tag匹配context的节点类型，获取context下同类子节点（包含context）
// 其余形式，如tag不是节点类型，返回context下tag节点
function getAll(context,tag){
// 不只文档document上挂载getElementsByTagName、querySelectorAll方法
// Dom元素上也会挂载getElementsByTagName、querySelectorAll方法
var ret = typeof context.getElementsByTagName!=="undefined" ?
context.getElementsByTagName(tag || "*") :
typeof context.querySelectorAll!=="undefined" ?
context.querySelectorAll(tag || "*") : [];
// jQuery.nodeName(elem,'TEXTAREA')判断elem节点的名称是否为'TEXTAREA'
// jQuery.merge合并两个数组到一个数组上，第一个数组后跟第二个数组的元素
// tag为空或为context元素的节点名时，获取context和context下同类子节点返回
// 否则返回context下tag节点
return tag===undefined || tag && jQuery.nodeName(context,tag) ?
jQuery.merge([context],ret) : ret;
}
return getAll;
});
setGlobalEval.js
define([
"../data/var/dataPriv"
],function(dataPriv){
// "globalEval"属性记录sctipt节点中的语法已执行
function setGlobalEval(elems,refElements){
var i=0,
l=elems.length;
for ( ; i<l; i++ ){
dataPriv.set(
elems[i], "globalEval",
!refElements || dataPriv.get(refElements[i],"globalEval")
);
}
}
return setGlobalEval;
});
wrapMap.js
define( function() {
var wrapMap = {
option: [ 1, "<select multiple='multiple'>", "</select>" ],
thead: [ 1, "<table>", "</table>" ],
col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
tr: [ 2, "<table><tbody>", "</tbody></table>" ],
td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
_default: [ 0, "", "" ]
};
wrapMap.optgroup = wrapMap.option;
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
wrapMap.th = wrapMap.td;
return wrapMap;
} );
access.js
- 内部模块使用，如css、attr等方法，对elems取值或赋值操作，或取出elem属性单纯执行回调。
define([
"../core"
],function(jQuery){
// 对elems取值或赋值操作，或取出elem属性单纯执行回调
var access=function(elems,fn,key,value,chainable,emptyGet,raw){
var i=0,
len=elems.length,
bulk=key==null;
if ( jQuery.type(key)==="object" ){
chainable=true;
for ( i in key ){
access(elems,fn,i,key[i],true,emptyGet,raw);
}
}else if( value!==undefined ){
chainable=true;
// value不是函数时，raw设置为真值
if ( !jQuery.isFunction(value) ){
raw=true;
}
// key为null，执行access参数fn，value或作为参数，或通过执行获取参数
if ( bulk ){
// key为null，value不是函数，fn以elems、value为参数执行
if ( raw ){
fn.call(elems,value);
fn=null;
// value为函数时，传参elem及i执行，作为access参数fn的参数，fn首参为$(elem)
}else{
bulk=fn;
fn=function(elem,key,value){
return bulk.call(jQuery(elem),value);
};
}
}
// key有值，value有值且非函数时，执行fn(elem,key,value)
// key有值，value为函数，执行fn(elem,key,value)，value作为回调
// key为null，value为函数，执行fn(elem,null,value.call(elem,i,fn(elem,key)))
if ( fn ){
for ( ;i<len;i++ ){
fn( elems[i], key, raw ? value : value.call(elems[i],i,fn(elems[i],key)) );
}
}
}
// value不等于undefined时，chainable恒为真；否则根据传参判断
// value等于undefined时，key为null，fn传参elems取值
// value等于undefined时，key不等于null，fn传参elems[0]、key取值，或用emptyGet取值
return chainable ?
elems :
// Gets
bulk ? fn.call(elems) : len ? fn(elems[0],key) : emptyGet;
};
return access;
} );