jquery-1.2.6-vsdoc-cn.js

Jquery 1.2.6 最新版本的文档

		// Try to normalize/fix the name
		name = notxml && jQuery.props[ name ] || name;

		// Only do all the following if this is a node (faster for style)
		// IE elem.getAttribute passes even for style
		if ( elem.tagName ) {

			// These attributes require special treatment
			var special = /href|src|style/.test( name );

			// Safari mis-reports the default selected property of a hidden option
			// Accessing the parent's selectedIndex property fixes it
			if ( name == "selected" && jQuery.browser.safari )
				elem.parentNode.selectedIndex;

			// If applicable, access the attribute via the DOM 0 way
			if ( name in elem && notxml && !special ) {
				if ( set ){
					// We can't allow the type property to be changed (since it causes problems in IE)
					if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )
						throw "type property can't be changed";

					elem[ name ] = value;
				}

				// browsers index elements by id/name on forms, give priority to attributes.
				if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )
					return elem.getAttributeNode( name ).nodeValue;

				return elem[ name ];
			}

			if ( msie && notxml &&  name == "style" )
				return jQuery.attr( elem.style, "cssText", value );

			if ( set )
				// convert the value to a string (all browsers do this but IE) see #1070
				elem.setAttribute( name, "" + value );

			var attr = msie && notxml && special
					// Some attributes require a special call on IE
					? elem.getAttribute( name, 2 )
					: elem.getAttribute( name );

			// Non-existent attributes return null, we normalize to undefined
			return attr === null ? undefined : attr;
		}

		// elem is actually elem.style ... set the style

		// IE uses filters for opacity
		if ( msie && name == "opacity" ) {
			if ( set ) {
				// IE has trouble with opacity if it does not have layout
				// Force it by setting the zoom level
				elem.zoom = 1;

				// Set the alpha filter to set the opacity
				elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) +
					(parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
			}

			return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
				(parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '':
				"";
		}

		name = name.replace(/-([a-z])/ig, function(all, letter){
			return letter.toUpperCase();
		});

		if ( set )
			elem[ name ] = value;

		return elem[ name ];
	},

	trim: function( text ) {
		///	<summary>
	    ///		去掉字符串起始和结尾的空格。
		///		Part of JavaScript
		///	</summary>
		///	<returns type="String" />
		///	<param name="text" type="String">
		///		要去空格的字符串
		///	</param>

		return (text || "").replace( /^\s+|\s+$/g, "" );
	},

	makeArray: function( array ) {
		///	<summary>
	    ///		将类数组对象转换为数组对象。
	    ///     类数组对象有 length 属性，其成员索引为 0 至 length - 1。实际中此函数在 jQuery 中将自动使用而无需特意转换。
		///	</summary>
	    ///	<param name="array" type="Object">要转换为数组对象的类数组对象。</param>
		///	<returns type="Array" />
		///	<private />

		var ret = [];

		if( array != null ){
			var i = array.length;
			//the window, strings and functions also have 'length'
			if( i == null || array.split || array.setInterval || array.call )
				ret[0] = array;
			else
				while( i )
					ret[--i] = array[i];
		}

		return ret;
	},

	inArray: function( elem, array ) {
		///	<summary>
	    ///		确定第一个参数在数组中的位置(如果没有找到则返回 -1 )。
		///	</summary>
	    ///	<param name="elem">用于在数组中查找是否存在的值</param>
	    ///	<param name="array" type="Array">待处理数组。</param>
	///	<returns type="Number" integer="true">如果找到，则从0开始累计，没有找到则返回 -1</returns>

		for ( var i = 0, length = array.length; i < length; i++ )
		// Use === because on IE, window == document
			if ( array[ i ] === elem )
				return i;

		return -1;
	},

	merge: function( first, second ) {
		///	<summary>
	    ///		两个参数都是数组，排除第二个数组中与第一个相同的，再将两个数组合并
		///		Part of JavaScript
		///	</summary>
		///	<returns type="Array" />
		///	<param name="first" type="Array">
		///		 The first array to merge.
		///	</param>
		///	<param name="second" type="Array">
		///		 The second array to merge.
		///	</param>

		// We have to loop this way because IE & Opera overwrite the length
		// expando of getElementsByTagName
		var i = 0, elem, pos = first.length;
		// Also, we need to make sure that the correct elements are being returned
		// (IE returns comment nodes in a '*' query)
		if ( jQuery.browser.msie ) {
			while ( elem = second[ i++ ] )
				if ( elem.nodeType != 8 )
					first[ pos++ ] = elem;

		} else
			while ( elem = second[ i++ ] )
				first[ pos++ ] = elem;

		return first;
	},

	unique: function( array ) {
		///	<summary>
		///		删除元素数组中所有的重复元素。
		///	</summary>
		///	<param name="array" type="Array&lt;Element&gt;">要转换的数组</param>
		///	<returns type="Array&lt;Element&gt;">转换后的数组</returns>

		var ret = [], done = {};

		try {

			for ( var i = 0, length = array.length; i < length; i++ ) {
				var id = jQuery.data( array[ i ] );

				if ( !done[ id ] ) {
					done[ id ] = true;
					ret.push( array[ i ] );
				}
			}

		} catch( e ) {
			ret = array;
		}

		return ret;
	},

	grep: function( elems, callback, inv ) {
		///	<summary>
	    ///		使用过滤函数过滤数组元素。
	    ///		此函数至少传递两个参数：待过滤数组和过滤函数。
	    ///		过滤函数必须返回 true 以保留元素或 false 以删除元素。
		///		});
		///		Part of JavaScript
		///	</summary>
		///	<returns type="Array" />
		///	<param name="elems" type="Array">
	///		待过滤数组。
		///	</param>
		///	<param name="fn" type="Function">
	    ///		此函数将处理数组每个元素。第一个参数为当前元素，第二个参数而元素索引值。
	    ///     此函数应返回一个布尔值。另外，此函数可设置为一个字符串，当设置为字符串时，将视为“lambda-form”（缩写形式？），
	    ///     其中 a 代表数组元素，i 代表元素索引值。如“a > 0”代表“function(a){ return a > 0; }”。
		///	</param>
		///	<param name="inv" type="Boolean">
	    ///	    (可选) 如果 "invert" 为 false 或为设置，则函数返回数组中由过滤函数返回 true 的元素，
	    ///     当"invert" 为 true，则返回过滤函数中返回 false 的元素集。
		///	</param>
		
		var ret = [];

		// Go through the array, only saving the items
		// that pass the validator function
		for ( var i = 0, length = elems.length; i < length; i++ )
			if ( !inv != !callback( elems[ i ], i ) )
				ret.push( elems[ i ] );

		return ret;
	},

	map: function( elems, callback ) {
		///	<summary>
	    ///		将一个数组中的元素转换到另一个数组中。
	    ///		作为参数的转换函数会为每个数组元素调用，
	    ///		而且会给这个转换函数传递一个表示被转换的元素作为参数。
	    ///		转换函数可以返回转换后的值、null（删除数组中的项目）
	    ///		或一个包含值的数组，并扩展至原始数组中。
		///		Part of JavaScript
		///	</summary>
		///	<returns type="Array" />
		///	<param name="elems" type="Array">
	    ///		待转换数组。
		///	</param>
		///	<param name="fn" type="Function">
	    ///		为每个数组元素调用，而且会给这个转换函数传递一个表示被转换的元素作为参数。函数可返回任何值。
	    ///     另外，此函数可设置为一个字符串，当设置为字符串时，将视为“lambda-form”（缩写形式？）
	    ///     ，其中 a 代表数组元素。如“a * a”代表“function(a){ return a * a; }”。
		///	</param>
		
		var ret = [];

		// Go through the array, translating each of the items to their
		// new value (or values).
		for ( var i = 0, length = elems.length; i < length; i++ ) {
			var value = callback( elems[ i ], i );

			if ( value != null )
				ret[ ret.length ] = value;
		}

		return ret.concat.apply( [], ret );
	}
});

var userAgent = navigator.userAgent.toLowerCase();

// Figure out what browser is being used
jQuery.browser = {
	version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [])[1],
	safari: /webkit/.test( userAgent ),
	opera: /opera/.test( userAgent ),
	msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
	mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
};

var styleFloat = jQuery.browser.msie ?
	"styleFloat" :
	"cssFloat";

jQuery.extend({
	// Check to see if the W3C box model is being used
	boxModel: !jQuery.browser.msie || document.compatMode == "CSS1Compat",

	props: {
		"for": "htmlFor",
		"class": "className",
		"float": styleFloat,
		cssFloat: styleFloat,
		styleFloat: styleFloat,
		readonly: "readOnly",
		maxlength: "maxLength",
		cellspacing: "cellSpacing"
	}
});

jQuery.each({
	parent: function(elem){return elem.parentNode;}
}, function(name, fn){
	jQuery.fn[ name ] = function( selector ) {
		///	<summary>
	    ///		取得一个包含着所有匹配元素的唯一父元素的元素集合。
	    ///		你可以使用可选的表达式来筛选。
		///		Part of DOM/Traversing
		///	</summary>
		///	<param name="expr" type="String" optional="true">
    	///		 (可选)用来筛选的表达式
		///	</param>
		///	<returns type="jQuery" />   
		
		var ret = jQuery.map( this, fn );

		if ( selector && typeof selector == "string" )
			ret = jQuery.multiFilter( selector, ret );

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

jQuery.each({
	parents: function(elem){return jQuery.dir(elem,"parentNode");}
}, function(name, fn){
	jQuery.fn[ name ] = function( selector ) {
		///	<summary>
		///		取得一组包含唯一祖先元素的比配元素
		///		（除了根元素）
	    ///		你可以使用可选的表达式来筛选。
		///		Part of DOM/Traversing
		///	</summary>
		///	<param name="expr" type="String" optional="true">
	    ///		(可选) 用来筛选元素的表达式
		///	</param>
		///	<returns type="jQuery" />   
		
		var ret = jQuery.map( this, fn );

		if ( selector && typeof selector == "string" )
			ret = jQuery.multiFilter( selector, ret );

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

jQuery.each({
	next: function(elem){return jQuery.nth(elem,2,"nextSibling");}
}, function(name, fn){
	jQuery.fn[ name ] = function( selector ) {
		///	<summary>
	    ///		取得一组包含唯一后一个兄弟元素的比配元素
		///		它只能返回下一个子元素，而不是所有的子元素
    	///		你可以使用可选的表达式来筛选。
		///		Part of DOM/Traversing
		///	</summary>
		///	<param name="expr" type="String" optional="true">
	    ///		(可选) 用来筛选兄弟元素的表达式
		///	</param>
		///	<returns type="jQuery" />
		
		var ret = jQuery.map( this, fn );

		if ( selector && typeof selector == "string" )
			ret = jQuery.multiFilter( selector, ret );

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

jQuery.each({
	prev: function(elem){return jQuery.nth(elem,2,"previousSibling");}
}, function(name, fn){
	jQuery.fn[ name ] = function( selector ) {
		///	<summary>
	    ///		取得一组包含唯一前一个兄弟元素的比配元素
	    ///		它只能返回前一个子元素，而不是所有的子元素
	    ///		你可以使用可选的表达式来筛选。
		///		Part of DOM/Traversing
		///	</summary>
		///	<param name="expr" type="String" optional="true">
	    ///		(可选) 用来筛选兄弟元素的表达式
		///	</param>
		///	<returns type="jQuery" />
		
		var ret = jQuery.map( this, fn );

		if ( selector && typeof selector == "string" )
			ret = jQuery.multiFilter( selector, ret );

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

jQuery.each({
	nextAll: function(elem){return jQuery.dir(elem,"nextSibling");}
}, function(name, fn){
	jQuery.fn[name] = function(selector) {
		///	<summary>
		///		找出当前元素后的所有元素
    	///		你可以使用可选的表达式来筛选。
		///		Part of DOM/Traversing
		///	</summary>
		///	<param name="expr" type="String" optional="true">
	    ///		(可选) 用来筛选元素的表达式
		///	</param>
		///	<returns type="jQuery" />
		
		var ret = jQuery.map( this, fn );

		if ( selector && type