manipulation.js

define([
	"./core",
	"./var/concat",
	"./var/push",
	"./core/access",
	"./manipulation/var/rcheckableType",
	"./manipulation/support",
	"./data/var/dataPriv",
	"./data/var/dataUser",

	"./core/init",
	"./data/accepts",
	"./traversing",
	"./selector",
	"./event"
], function( jQuery, concat, push, access, rcheckableType, support, dataPriv, dataUser ) {

var
	// (?!p) 反前向声明
	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,

	//  [A-Za-z0-9_:]
	// 匹配 <a  <div
	rtagName = /<([\w:]+)/,
	// <svg:svg>
	// 匹配 HTML标签或特殊符号
	// <
	// &
	// &#
	rhtml = /<|&#?\w+;/,
	// 匹配 <script 或  <style 或 <link
	rnoInnerhtml = /<(?:script|style|link)/i,
	// checked="checked" or checked
    // 匹配 checked="checked" 或者 checked
	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
    // 匹配script类型 "" 或者 /javascript 或者 /ecmascript
	rscriptType = /^$|\/(?:java|ecma)script/i,
    // 匹配 true/ 开头
	rscriptTypeMasked = /^true\/(.*)/,
    // 匹配任意空格开头(<![CDATA[或<!--) 或者 (]]> 或 -->)做空格结尾
	rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,

	// We have to close these tags to support XHTML (#13200)
    // 由于浏览器的实现情况不一样 为了保证兼容性，不得不关闭这些标签来支持xhtml
	wrapMap = {

		// Support: IE9
		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, "", "" ]
	};

// Support: IE9
wrapMap.optgroup = wrapMap.option;

wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
wrapMap.th = wrapMap.td;

// Support: 1.x compatibility
// Manipulating tables requires a tbody
function manipulationTarget( elem, content ) {
	return jQuery.nodeName( elem, "table" ) &&
		jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ?

		elem.getElementsByTagName("tbody")[0] ||
			elem.appendChild( elem.ownerDocument.createElement("tbody") ) :
		elem;
}

// Replace/restore the type attribute of script elements for safe DOM manipulation
function disableScript( elem ) {
	elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type;
	return elem;
}
function restoreScript( elem ) {
	var match = rscriptTypeMasked.exec( elem.type );

	if ( match ) {
		elem.type = match[ 1 ];
	} else {
		elem.removeAttribute("type");
	}

	return elem;
}

// Mark scripts as having already been evaluated
// 脚本标记为已经执行
function setGlobalEval( elems, refElements ) {
	var i = 0,
        // 获取元素集合的长度
		l = elems.length;

    // 遍历元素
	for ( ; i < l; i++ ) {
        // 为每个元素设置globalEval的data
		dataPriv.set(
            // 如果refElements取反为false，说明已经设置过了
            // 通过get获取
            // 否则设置为true
			elems[ i ], "globalEval", !refElements || dataPriv.get( refElements[ i ], "globalEval" )
		);
	}
}

function cloneCopyEvent( src, dest ) {
	var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;

	if ( dest.nodeType !== 1 ) {
		return;
	}

	// 1. Copy private data: events, handlers, etc.
	if ( dataPriv.hasData( src ) ) {
		pdataOld = dataPriv.access( src );
		pdataCur = dataPriv.set( dest, pdataOld );
		events = pdataOld.events;

		if ( events ) {
			delete pdataCur.handle;
			pdataCur.events = {};

			for ( type in events ) {
				for ( i = 0, l = events[ type ].length; i < l; i++ ) {
					jQuery.event.add( dest, type, events[ type ][ i ] );
				}
			}
		}
	}

	// 2. Copy user data
	if ( dataUser.hasData( src ) ) {
		udataOld = dataUser.access( src );
		udataCur = jQuery.extend( {}, udataOld );

		dataUser.set( dest, udataCur );
	}
}

function getAll( context, tag ) {
	// Support: IE9-11+
	// Use typeof to avoid zero-argument method invocation on host objects (#15151)

	// typeof context.getElementsByTagName 是否 undefined
	var ret = typeof context.getElementsByTagName !== "undefined" ?
		// 存在即用 getElementsByTagName 获取 context 下的 tag 或者 所有元素
		context.getElementsByTagName( tag || "*" ) :
		// 否则检测 context.querySelectorAll 是否为 undefined
			typeof context.querySelectorAll !== "undefined" ?
				// 存在即用 querySelectorAll 获取 context 下的 tag 或者 所有元素
				context.querySelectorAll( tag || "*" ) :
				// 否则为空数组[]
			[];

	// tag 不存在 返回 ret
	// tag 存在时 返回 ret
	// tag存在且 context.nodeName == tag 时
	// 返回合并后的结果(包括 context ret)
	return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
		jQuery.merge( [ context ], ret ) :
		ret;
}

// Fix IE bugs, see support tests
function fixInput( src, dest ) {
	var nodeName = dest.nodeName.toLowerCase();

	// Fails to persist the checked state of a cloned checkbox or radio button.
	if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
		dest.checked = src.checked;

	// Fails to return the selected option to the default selected state when cloning options
	} else if ( nodeName === "input" || nodeName === "textarea" ) {
		dest.defaultValue = src.defaultValue;
	}
}

jQuery.extend({
	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
		var i, l, srcElements, destElements,
			clone = elem.cloneNode( true ),
			inPage = jQuery.contains( elem.ownerDocument, elem );

		// Fix IE cloning issues
		if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
				!jQuery.isXMLDoc( elem ) ) {

			// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
			destElements = getAll( clone );
			srcElements = getAll( elem );

			for ( i = 0, l = srcElements.length; i < l; i++ ) {
				fixInput( srcElements[ i ], destElements[ i ] );
			}
		}

		// Copy the events from the original to the clone
		if ( dataAndEvents ) {
			if ( deepDataAndEvents ) {
				srcElements = srcElements || getAll( elem );
				destElements = destElements || getAll( clone );

				for ( i = 0, l = srcElements.length; i < l; i++ ) {
					cloneCopyEvent( srcElements[ i ], destElements[ i ] );
				}
			} else {
				cloneCopyEvent( elem, clone );
			}
		}

		// Preserve script evaluation history
		destElements = getAll( clone, "script" );
		if ( destElements.length > 0 ) {
			setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
		}

		// Return the cloned set
		return clone;
	},

	buildFragment: function( elems, context, scripts, selection ) {
		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 ) {

				// Add nodes directly
				// 如果 elem 是对象
				if ( jQuery.type( elem ) === "object" ) {
					// Support: QtWebKit, PhantomJS
					// push.apply(_, arraylike) throws on ancient WebKit
					// 元素 或者 元素集合  merge 到 nodes
					jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );

				// Convert non-html into a text node
				// 转换文本节点
				} else if ( !rhtml.test( elem ) ) {
					// 创建文本节点 push 到 nodes
					nodes.push( context.createTextNode( elem ) );

				// Convert html into DOM nodes
				// 将 html 转换为 dom 节点
				} else {
					// 如果 tmp 存在 就直接使用
					// 如果不存在 就 创建一个div 插入到 文档碎片上 并赋值给 tmp
					tmp = tmp || fragment.appendChild( context.createElement("div") );

					// Deserialize a standard representation
					// 反序列化

					// 正则 rtagName 匹配 elem 取得标签名
					// 如 匹配 "<tr><td></td></tr>"  得到 ["<tr","tr"]
					// 取得标签名 tr 转换为小写
					tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
					// 尝试 wrapMap 取得应数据 如果不存在 那么使用 默认数据
					// 如上逑 将 tr 代入
					// wrapMap['tr'] 得到  wrap = [ 2, "<table><tbody>", "</tbody></table>" ]
					// 如果 将 div 代入
					// wrapMap['div'] 得到 undefined
					// 将使用 wrap = [ 0, "", "" ]
					// 这么做的目的是为了某些浏览器下 如类似 tr 必须创建在 tbody 的下面，直接创建在 table 会失败
					// 为了修正操作
					wrap = wrapMap[ tag ] || wrapMap._default;

					// elem.replace( rxhtmlTag, "<$1></$2>" )
					// 用于匹配修正双标签类似"<div></div>"写成半标签的情况"<div />"

					// 整体修正情况类似如下
					// 当 "<tr><td></td></tr>" 情况时
					// 修复为 "<table><tbody><tr><td></td></tr></tbody></table>"
					// 而当 "<tr>" 时
					// 修复为 "<table><tbody><tr></tr></tbody></table>"
					// 将修复后的放入 tmp.innerHTML 快速创建成dom元素
					tmp.innerHTML = wrap[ 1 ] + elem.replace( rxhtmlTag, "<$1></$2>" ) + wrap[ 2 ];
					// http://www.cnblogs.com/nuysoft/archive/2012/01/11/2318651.html
					// http://www.cnblogs.com/aaronjs/p/3510768.html
					// Descend through wrappers to the right content

					// 如上述 wrap = [ 2, "<table><tbody>", "</tbody></table>" ]
					// wrap[ 0 ] =>  2  代表修正后相比原来元素来说嵌套层数
					j = wrap[ 0 ];
					// 遍历 j(层数) 取得   包含 parentNode 的 elem
					// tmp 为 "<div><table><tbody><tr><td></td></tr></tbody></table></div>" 的 dom
					// 取两层的 嵌套
					// tmp最终结果为
					// "<tbody><tr><td></td></tr></tbody>" 的 dom
					while ( j-- ) {
						tmp = tmp.lastChild;
					}

					// Support: QtWebKit, PhantomJS
					// push.apply(_, arraylike) throws on ancient WebKit
					// tmp.childNodes 也就是 elem 转成的 dom元素 合并到 nodes 上
					jQuery.merge( nodes, tmp.childNodes );

					// Remember the top-level container
					// 保存顶层容器
					// 也就是那个div
					tmp = fragment.firstChild;

					// Ensure the created nodes are orphaned (#12392)
					//
					tmp.textContent = "";
				}
			}
		}

		// Remove wrapper from fragment
		fragment.textContent = "";

		i = 0;
		while ( (elem = nodes[ i++ ]) ) {

			// #4087 - If origin and destination elements are the same, and this is
			// that element, do not do anything
			// 如果元素和目标元素相同
			if ( selection && jQuery.inArray( elem, selection ) !== -1 ) {
				// 跳出本次循环
				continue;
			}

			// 检测elem的根元素是否包含elem
			contains = jQuery.contains( elem.ownerDocument, elem );

			// Append to fragment
			// 获取所有的script标签
			tmp = getAll( fragment.appendChild( elem ), "script" );

			// Preserve script evaluation history
			if ( contains ) {
				setGlobalEval( tmp );
			}

			// Capture executables
			// 获取可执行的脚本
			if ( scripts ) {
				j = 0;
				// 遍历所有的script标签
				while ( (elem = tmp[ j++ ]) ) {
					// 检测 script 的 type 是否为 javascript 或 ecmascript 或者 没有type属性
					if ( rscriptType.test( elem.type || "" ) ) {
						// 推入 scripts 数组里面
						scripts.push( elem );
					}
				}
			}
		}

		return fragment;
	},

	cleanData: function( elems ) {
		var data, elem, type, key,
			special = jQuery.event.special,
			i = 0;

		for ( ; (elem = elems[ i ]) !== undefined; i++ ) {
			if ( jQuery.acceptData( elem ) ) {
				key = elem[ dataPriv.expando ];

				if ( key && (data = dataPriv.cache[ key ]) ) {
					if ( data.events ) {
						for ( type in data.events ) {
							if ( special[ type ] ) {
								jQuery.event.remove( elem, type );

							// This is a shortcut to avoid jQuery.event.remove's overhead
							} else {
								jQuery.removeEvent( elem, type, data.handle );
							}
						}
					}
					if ( dataPriv.cache[ key ] ) {
						// Discard any remaining `private` data
						delete dataPriv.cache[ key ];
					}
				}
			}
			// Discard any remaining `user` data
			delete dataUser.cache[ elem[ dataUser.expando ] ];
		}
	}
});

jQuery.fn.extend({
	text: function( value ) {
		return access( this, function( value ) {
			return value === undefined ?
				jQuery.text( this ) :
				this.empty().each(function() {
					if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
						this.textContent = value;
					}
				});
		}, null, value, arguments.length );
	},

	append: function() {
		return this.domManip( arguments, function( elem ) {
			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
				var target = manipulationTarget( this, elem );
				target.appendChild( elem );
			}
		});
	},

	prepend: function() {
		return this.domManip( arguments, function( elem ) {
			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
				var target = manipulationTarget( this, elem );
				target.insertBefore( elem, target.firstChild );
			}
		});
	},

	before: function() {
		return this.domManip( arguments, function( elem ) {
			if ( this.parentNode ) {
				this.parentNode.insertBefore( elem, this );
			}
		});
	},

	after: function() {
		return this.domManip( arguments, function( elem ) {
			if ( this.parentNode ) {
				this.parentNode.insertBefore( elem, this.nextSibling );
			}
		});
	},

	remove: function( selector, keepData /* Internal Use Only */ ) {
		var elem,
			elems = selector ? jQuery.filter( selector, this ) : this,
			i = 0;

		for ( ; (elem = elems[i]) != null; i++ ) {
			if ( !keepData && elem.nodeType === 1 ) {
				jQuery.cleanData( getAll( elem ) );
			}

			if ( elem.parentNode ) {
				if ( keepData && jQuery.contains( elem.ownerDocument, elem ) ) {
					setGlobalEval( getAll( elem, "script" ) );
				}
				elem.parentNode.removeChild( elem );
			}
		}

		return this;
	},

	empty: function() {
		var elem,
			i = 0;

		for ( ; (elem = this[i]) != null; i++ ) {
			if ( elem.nodeType === 1 ) {

				// Prevent memory leaks
				jQuery.cleanData( getAll( elem, false ) );

				// Remove any remaining nodes
				elem.textContent = "";
			}
		}

		return this;
	},

	clone: function( dataAndEvents, deepDataAndEvents ) {
		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;

		return this.map(function() {
			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
		});
	},

	html: function( value ) {
		return access( this, function( value ) {
			var elem = this[ 0 ] || {},
				i = 0,
				l = this.length;

			if ( value === undefined && elem.nodeType === 1 ) {
				return elem.innerHTML;
			}

			// See if we can take a shortcut and just use innerHTML
			if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
				!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {

				value = value.replace( rxhtmlTag, "<$1></$2>" );

				try {
					for ( ; i < l; i++ ) {
						elem = this[ i ] || {};

						// Remove element nodes and prevent memory leaks
						if ( elem.nodeType === 1 ) {
							jQuery.cleanData( getAll( elem, false ) );
							elem.innerHTML = value;
						}
					}

					elem = 0;

				// If using innerHTML throws an exception, use the fallback method
				} catch ( e ) {}
			}

			if ( elem ) {
				this.empty().append( value );
			}
		}, null, value, arguments.length );
	},

	replaceWith: function() {
		var arg = arguments[ 0 ];

		// Make the changes, replacing each context element with the new content
		this.domManip( arguments, function( elem ) {
			arg = this.parentNode;

			jQuery.cleanData( getAll( this ) );

			if ( arg ) {
				arg.replaceChild( elem, this );
			}
		});

		// Force removal if there was no new content (e.g., from empty arguments)
		return arg && (arg.length || arg.nodeType) ? this : this.remove();
	},

	detach: function( selector ) {
		return this.remove( selector, true );
	},

	domManip: function( args, callback ) {

		// Flatten any nested arrays
		args = concat.apply( [], args );

		var fragment, first, scripts, hasScripts, node, doc,
			i = 0,
			l = this.length,
			set = this,
			iNoClone = l - 1,
			value = args[ 0 ],
			isFunction = jQuery.isFunction( value );

		// We can't cloneNode fragments that contain checked, in WebKit
		if ( isFunction ||
				( l > 1 && typeof value === "string" &&
					!support.checkClone && rchecked.test( value ) ) ) {
			return this.each(function( index ) {
				var self = set.eq( index );
				if ( isFunction ) {
					args[ 0 ] = value.call( this, index, self.html() );
				}
				self.domManip( args, callback );
			});
		}

		if ( l ) {
			fragment = jQuery.buildFragment( args, this[ 0 ].ownerDocument, false, this );
			first = fragment.firstChild;

			if ( fragment.childNodes.length === 1 ) {
				fragment = first;
			}

			if ( first ) {
				scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
				hasScripts = scripts.length;

				// Use the original fragment for the last item
				// instead of the first because it can end up
				// being emptied incorrectly in certain situations (#8070).
				for ( ; i < l; i++ ) {
					node = fragment;

					if ( i !== iNoClone ) {
						node = jQuery.clone( node, true, true );

						// Keep references to cloned scripts for later restoration
						if ( hasScripts ) {
							// Support: QtWebKit
							// jQuery.merge because push.apply(_, arraylike) throws
							jQuery.merge( scripts, getAll( node, "script" ) );
						}
					}

					callback.call( this[ i ], node, i );
				}

				if ( hasScripts ) {
					doc = scripts[ scripts.length - 1 ].ownerDocument;

					// Reenable scripts
					jQuery.map( scripts, restoreScript );

					// Evaluate executable scripts on first document insertion
					for ( i = 0; i < hasScripts; i++ ) {
						node = scripts[ i ];
						if ( rscriptType.test( node.type || "" ) &&
							!dataPriv.access( node, "globalEval" ) &&
							jQuery.contains( doc, node ) ) {

							if ( node.src ) {
								// Optional AJAX dependency, but won't run scripts if not present
								if ( jQuery._evalUrl ) {
									jQuery._evalUrl( node.src );
								}
							} else {
								jQuery.globalEval( node.textContent.replace( rcleanScript, "" ) );
							}
						}
					}
				}
			}
		}

		return this;
	}
});

jQuery.each({
	appendTo: "append",
	prependTo: "prepend",
	insertBefore: "before",
	insertAfter: "after",
	replaceAll: "replaceWith"
}, function( name, original ) {
	jQuery.fn[ name ] = function( selector ) {
		var elems,
			ret = [],
			insert = jQuery( selector ),
			last = insert.length - 1,
			i = 0;

		for ( ; i <= last; i++ ) {
			elems = i === last ? this : this.clone( true );
			jQuery( insert[ i ] )[ original ]( elems );

			// Support: QtWebKit
			// .get() because push.apply(_, arraylike) throws
			push.apply( ret, elems.get() );
		}

		return this.pushStack( ret );
	};
});

return jQuery;
});