jQuery技术内幕:深入解析jQuery架构设计与实现原理. 2.8 静态属性和方法-阿里云开发者社区

开发者社区> 华章出版社> 正文

jQuery技术内幕:深入解析jQuery架构设计与实现原理. 2.8 静态属性和方法

简介:

2.8 静态属性和方法

在构造jQuery对象模块中还定义了一些重要的静态属性和方法,它们是其他模块实现的基础。其整体源码结构如代码清单2-3所示。

代码清单2-3 静态属性和方法

388 jQuery.extend({

389     noConflict: function( deep ) {},

402     isReady: false,

406     readyWait: 1,

409     holdReady: function( hold ) {},

418     ready: function( wait ) {},

444     bindReady: function() {},

492     isFunction: function( obj ) {},

496     isArray: Array.isArray || function( obj ) {},

501     isWindow: function( obj ) {},

505     isNumeric: function( obj ) {},

509     type: function( obj ) {},

515     isPlainObject: function( obj ) {},

544     isEmptyObject: function( obj ) {},

551     error: function( msg ) {},

555     parseJSON: function( data ) {},

581     parseXML: function( data ) {},

601     noop: function() {},

606     globalEval: function( data ) {},

619     camelCase: function( string ) {},

623     nodeName: function( elem, name ) {},

628     each: function( object, callback, args ) {},

669     trim: trim ? function( text ) {} : function( text ) {},

684     makeArray: function( array, results ) {},

702     inArray: function( elem, array, i ) {},

724     merge: function( first, second ) {},

744     grep: function( elems, callback, inv ) {},

761     map: function( elems, callback, arg ) {},

794     guid: 1,

798     proxy: function( fn, context ) {},

825     access: function( elems, key, value, exec, fn, pass ) {},

852     now: function() {},

858     uaMatch: function( ua ) {},

870     sub: function() {},

891     browser: {}

892 });

jQuery.isReady、jQuery.readyWait、jQuery.holdReady()、jQuery.ready()、jQuery.bindReady()用于支持ready事件,将在9.11节对它们进行介绍和分析;jQuery.each()和jQuery.map()已经在2.7.3节和2.7.4节介绍和分析过了;jQuery.sub()在jQuery源码中没有用到,并且不推荐使用,这里不做分析;下面对其他的静态属性和方法逐一介绍和分析。

2.8.1 jQuery.noConflict( [removeAll] )

方法jQuery.noConflict( [removeAll] )用于释放jQuery对全局变量$的控制权,可选的参数removeAll指示是否释放对全局变量jQuery的控制权。$仅仅是jQuery的别名,所有的功能没有$也能使用。

很多JavaScript库使用美元符$作为函数名或变量名,在使用jQuery的同时,如果需要使用另一个JavaScript库,可以调用$.noConflict()返回$给其他库。如果有必要(例如,在一个页面中使用多个版本的jQuery库,但很少有这样的必要),也可以释放全局变量jQuery的控制权,只需要给这个方法传入参数true即可。

方法jQuery.noConflict( [removeAll] )相关代码如下所示:

  30     // Map over jQuery in case of overwrite

  31     _jQuery = window.jQuery,

  32

  33     // Map over the $ in case of overwrite

  34     _$ = window.$,

 

 388 jQuery.extend({

 389     noConflict: function( deep ) {

 390         if ( window.$ === jQuery ) {

 391             window.$ = _$;

 392         }

 393

 394         if ( deep && window.jQuery === jQuery ) {

 395             window.jQuery = _jQuery;

 396         }

 397

 398         return jQuery;

 399     },

 

9245 // Expose jQuery to the global object

9246 window.jQuery = window.$ = jQuery;

第30~34行:jQuery初始化时,把可能存在的window.jQuery和window.$备份到局部变量_jQuery和_$。

第390~392行:如果window.$ === jQuery,则设置window.$为初始化时备份的_$。也就是说,只有在当前jQuery库持有全局变量$的情况下,才会释放$的控制权给前一个JavaScript库。

从jQuery 1.6开始增加了对window.$ === jQuery的检测。如果不检测,则每次调用jQuery.noConflict()时都会释放$给前一个JavaScript库,当页面中有两个以上定义了$的 JavaScript库时,对$的管理将会变得混乱。

第394~396行:如果参数deep为true,并且window.jQuery === jQuery,则设置window.jQuery为初始化时备份的_jQuery。也就是说,如果参数deep为true,只有在当前jQuery库持有全局变量jQuery的情况下,才会释放jQuery的控制权给前一个JavaScript库。

从jQuery 1.6开始增加了对window.$ === jQuery的检测。如果不检测,则每次调用jQuery.noConflict( true )时都会释放jQuery给前一个JavaScript库,当页面中有两个以上定义了jQuery的JavaScript库时,对jQuery的管理将会变得混乱。

2.8.2 类型检测:jQuery.isFunction( obj )、jQuery.isArray( obj )、jQuery

   .isWindow( obj )、jQuery.isNumeric( value )、jQuery.type( obj )、

   jQuery.isPlainObject( object )、jQuery.isEmptyObject( object )

1.?jQuery.isFunction( obj )、jQuery.isArray( obj )

方法jQuery.isFunction( obj )用于判断传入的参数是否是函数;方法jQuery.isArray( obj )用于判断传入的参数是否是数组。这两个方法的实现依赖于方法jQuery.type( obj ),通过判断 jQuery.type( obj )返回值是否是“function”和“array”来实现。相关代码如下所示:

489     // See test/unit/core.js for details concerning isFunction.

490     // Since version 1.3, DOM methods and functions like alert

491     // aren't supported. They return false on IE (#2968).

492     isFunction: function( obj ) {

493        return jQuery.type(obj) === "function";

494     },

495

496     isArray: Array.isArray || function( obj ) {

497        return jQuery.type(obj) === "array";

498     },

499

2.?jQuery.type( obj )

方法jQuery.type( obj )用于判断参数的内建JavaScript类型。如果参数是undefined或null,返回“undefined”或“null”;如果参数是JavaScript内部对象,则返回对应的字符串名称;其他情况一律返回“object”。相关代码如下所示:

509     type: function( obj ) {

510         return obj == null ?

511            String( obj ) :

512            class2type[ toString.call(obj) ] || "object";

513     },

第510~511行:如果参数obj是undefined或null,通过String( obj )转换为对应的原始字符串“undefined”或“null”。

第512行:先借用Object的原型方法toString()获取obj的字符串表示,返回值的形式为[object class],其中的class是内部对象类,例如,Object.prototype.toString.call( true )会返回

[object Boolean];然后从对象class2type中取出[object class]对应的小写字符串并返回;如果未取到则一律返回“object”。原型方法toString()和对象class2type的定义和初始化源码如下所示:

 87    toString = Object.prototype.toString,

 

 94    // [[Class]] -> type pairs

 95    class2type = {};

 

894 // Ppulate the class2type map

895 jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {

896    class2type[ "[object " + name + "]" ] = name.toLowerCase();

897 });

对象class2type初始化后的结构为:

{

   "[object Array]": "array"

   "[object Boolean]": "boolean"

   "[object Date]": "date"

   "[object Function]": "function"

   "[object Number]": "number"

   "[object Object]": "object"

   "[object RegExp]": "regexp"

   "[object String]": "string"

}

3.?jQuery.isWindow( obj )

方法jQuery.isWindow( obj )用于判断传入的参数是否是window对象,通过检测是否存在特征属性setInterval来实现,相关代码如下所示:

500     // A crude way of determining if an object is a window

501     isWindow: function( obj ) {

502        return obj && typeof obj === "object" && "setInterval" in obj;

503     },

在本书写作时发布的jQuery 1.7.2中,该方法改为检测特征属性window,该属性是对窗口自身的引用,相关代码如下所示:

// 1.7.2

isWindow: function( obj ) {

   return obj != null && obj == obj.window;

},

4.?jQuery.isNumeric( value )

方法jQuery.isNumeric( value )用于判断传入的参数是否是数字,或者看起来是否像数字,相关代码如下所示:

505     isNumeric: function( obj ) {

506        return !isNaN( parseFloat(obj) ) && isFinite( obj );

507     },

第506行:先执行parseFloat( obj )尝试把参数obj解析为数字,然后用isNaN()判断解析结果是否是合法数字,并用isFinite()判断参数obj是否是有限的。如果parseFloat( obj )的解析结果是合法数字,并且参数obj是有限数字,则返回true;否则返回false。

方法parseFloat( string )用于对字符串参数进行解析,并返回字符串中的第一个数字。在解析过程中,如果遇到了不是有效数字的字符,解析就会停止并返回解析结果;如果字符串没有以一个有效的数字开头,则返回NaN;如果传入的参数是对象,则自动调用该对象的方法toString(),得到该对象的字符串表示,然后再执行解析过程。

方法isNaN( x )用于判断参数是否为非数字值,常用于检测方法parseFloat()和parseInt()的解析结果。

方法isFinite( number )用于判断一个数字是否是有限的。

5.?jQuery.isPlainObject( object )

方法jQuery.isPlainObject( object )用于判断传入的参数是否是“纯粹”的对象,即是否是用对象直接量{}或new Object()创建的对象。相关代码如下所示:

515     isPlainObject: function( obj ) {

516         // Must be an Object.

517         // Because of IE, we also have to check the presence of the constructor property.

518         // Make sure that DOM nodes and window objects don't pass through, as well

519         if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {

520             return false;

521         }

522

523         try {

524             // Not own constructor property must be Object

525             if ( obj.constructor &&

526                 !hasOwn.call(obj, "constructor") &&

527                 !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {

528                 return false;

529             }

530         } catch ( e ) {

531             // IE8,9 Will throw exceptions on certain host objects #9897

532             return false;

533         }

534

535         // Own properties are enumerated firstly, so to speed up,

536         // if last one is own, then all properties are own.

537

538         var key;

539         for ( key in obj ) {}

540

541         return key === undefined || hasOwn.call( obj, key );

542     },

第519~521行:如果参数obj满足以下条件之一,则返回false:

参数obj可以转换为false。

Object.prototype.toString.call( obj )返回的不是[object Object]。

参数obj是DOM元素。

参数obj是window对象。

如果参数obj不满足以上所有条件,则至少可以确定参数obj是对象。

第523~533行:检查对象obj是否由构造函数Object()创建。如果对象obj满足以下所有条件,则认为不是由构造函数Object()创建,而是由自定义构造函数创建,返回false:

对象obj含有属性constructor。由构造函数创建的对象都有一个constructor属性,默认引用了该对象的构造函数。如果对象obj没有属性constructor,则说明该对象必然是通过对象字面量{}创建的。

对象obj的属性constructor是非继承属性。默认情况下,属性constructor继承自构造函数的原型对象。如果属性constructor是非继承属性,说明该属性已经在自定义构造函数中被覆盖。

对象obj的原型对象中没有属性isPrototypeOf。属性isPrototypeOf是Object原型对象的特有属性,如果对象obj的原型对象中没有,说明不是由构造函数Object()创建,而是由自定义构造函数创建。

执行以上检测时抛出了异常。在IE 8/9中,在某些浏览器对象上执行以上检测时会抛出异常,也应该返回false。

函数hasOwn()指向Object.prototype.hasOwnProperty( property ),用于检查对象是否含有执行名称的非继承属性。

第539~541行:检查对象obj的属性是否都是非继承属性。如果没有属性,或者所有属性都是非继承属性,则返回true。如果含有继承属性,则返回false。

第539行:执行for-in循环时,JavaScript会先枚举非继承属性,再枚举从原型对象继承的属性。

第541行:如果对象obj的最后一个属性是非继承属性,则认为所有属性都是非继承属性,返回true;如果最后一个属性是继承属性,即含有继承属性,则返回false。

6.?jQuery.isEmptyObject( object )

方法jQuery.isEmptyObject( object )用于检测对象是否是空的(即不包含属性)。例如:

jQuery.isEmptyObject( {} )                           // true

jQuery.isEmptyObject( new Object() )               // true

jQuery.isEmptyObject( { foo: "bar" } )               // false

方法jQuery.isEmptyObject( object )的相关代码如下所示:

544     isEmptyObject: function( obj ) {

545         for ( var name in obj ) {

546             return false;

547         }

548         return true;

549     },

第545~548行:for-in循环会同时枚举非继承属性和从原型对象继承的属性,如果有,则立即返回false,否则默认返回true。

2.8.3 解析JSON和XML:jQuery.parseJSON( data )、jQuery.parseXML( data )

1.?jQuery.parseJSON( data )

方法jQuery.parseJSON( data )接受一个格式良好的JSON字符串,返回解析后的JavaScript对象。如果传入残缺的JSON字符串可能导致程序抛出异常;如果不传入参数,或者传入空字符串、null、undefined,则返回null。

如果浏览器提供了原生方法JSON.parse(),则使用该方法解析JSON字符串;否则使用

( new Function( "return"+ data ) )()解析JSON字符串。

方法jQuery.parseJSON( data )的相关代码如下所示:

555      parseJSON: function( data ) {

556         if ( typeof data !== "string" || !data ) {

557             return null;

558         }

559

560         // Make sure leading/trailing whitespace is removed (IE can't handle it)

561         data = jQuery.trim( data );

562

563         // Attempt to parse using the native JSON parser first

564         if ( window.JSON && window.JSON.parse ) {

565             return window.JSON.parse( data );

566         }

567

568         // Make sure the incoming data is actual JSON

569         // Logic borrowed from http:// json.org/json2.js

570         if ( rvalidchars.test( data.replace( rvalidescape, "@" )

571             .replace( rvalidtokens, "]" )

572             .replace( rvalidbraces, "")) ) {

573

574             return ( new Function( "return " + data ) )();

575

576         }

577         jQuery.error( "Invalid JSON: " + data );

578      },

第556~561行:对于非法参数一律返回null。如果参数data不是字符串,或者可以转换为false,则返回null。

第561行:移除开头和末尾的空白符。在IE 6/7中,如果不移除就不能正确的解析,例如:

typeof ( new Function( 'return ' + '\n{}' ) )();

// 返回"undefined"

第564~566行:尝试使用原生方法JSON.parse()解析JSON字符串,并返回。

JSON对象含有两个方法:JSON.parse()和JSON.stringify(),用于JSON字符串和JavaScript对象之间的相互转换。下面是它们的语法和使用示例。

JSON.parse()解析JSON字符串为 JSON对象,其语法如下:

JSON.parse(text[, reviver])

// text 待解析为 JSON 对象的字符串

// reviver 可选。在返回解析结果前,对解析结果中的属性值进行修改

JSON.parse()的使用示例如下所示:

JSON.parse( '{ "abc": 123 }' );

// {"abc": 123 }

 

JSON.parse( '{ "abc": 123 }', function( key, value ){

   if( key === '' ) return value;

   return value * 2;

} );

// {"abc": 246 }

JSON.stringify()转换JSON对象为JSON字符串,其语法如下:

JSON.stringify( value[, replacer [, space]] )

// value 待转换为 JSON 字符串的对象

// replacer 可选。如果 replacer 是函数,转换前先执行 replacer 改变属性值,如果函数 replacer 返回 undefined,则对应的属性不会出现在结果中;如果 replacer 是数组,指定最终字符串中包含的属性集合,不在数组 replacer 中的属性不会出现在结果中

// space 增加转换后的 JSON 字符串的可读性

JSON.stringify()的使用示例如下所示:

JSON.stringify( { a: 1, b: 2 } );

// '{"a":1,"b":2}'

 

JSON.stringify( { a: 1, b: 2 }, function( key, value ){

   if( key === '' ) return value;

   if( key === 'a' ) return value * 10;

   if( key === 'b' ) return undefined;

   return value;

} );

// '{"a":10}'

 

JSON.stringify( { a: 1, b: 2 }, ['b'] );

// '{"b":2}'

 

JSON.stringify( { a: 1, b: 2 }, null, 4 );

// '{\n    "a": 1,\n    "b": 2\n}'

JSON对象、JSON.parse()、JSON.stringify()在ECMAScript 5中被标准化,IE 8以下的浏览器不支持。关于JSON规范和浏览器实现的更多信息请访问以下地址:

http://json.org/json-zh.html

http://www.ecma-international.org/publications/standards/Ecma-262.htm(ECMAScript 5第15.12节)

https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/JSON

下面回到对方法jQuery.parseJSON()的分析中来。

第570~576行:在不支持JSON.parse()的浏览器中,先检查字符串是否合法,如何合法,才会执行( new Function("return"+ data) )()并返回执行结果。检查字符串是否合法的正则和逻辑来自开源JSON解析库json2.js(https://github.com/douglascrockford/JSON-js),检测过程分为4步,用到了4个正则表达式:rvalidchars、rvalidescape、rvalidtokens、rvalidbraces,相关代码如下:

 53     // JSON RegExp

 54     rvalidchars = /^[\],:{}\s]*$/,

 55     rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,

 56     rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,

 57     rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,

 

570         if ( rvalidchars.test( data.replace( rvalidescape, "@" )

571             .replace( rvalidtokens, "]" )

572             .replace( rvalidbraces, "")) ) {

第54~57行:正则rvalidescape用于匹配转义字符;正则rvalidtokens用于匹配有效值(字符串、true、false、null、数值);正则rvalidbraces用于匹配正确的左方括号“[”;正则rvalidchars用于检查字符串是否只含有指定的字符(“]”、“,”、“:”、“{”、“}”、“\s”)。

第570~572行:先利用正则rvalidescape把转义字符替换为“@”,为进行下一步替换做准备;再利用正则rvalidtokens把字符串、true、false、null、数值替换为“]”;然后利用rvalidbraces删除正确的左方括号;最后检查剩余字符是否只包含“]”、“,”、“:”、“{”、“}”、“\s”,如果只包含这些字符,那么认为JSON字符串是合法的。

第574行:通过构造函数Function()创建函数对象,然后执行。构造函数Function()的语法如下:

new Function( arguments_names..., body)

// 参见arguments_names...:任意多个字符串参数,每个字符串命名一个或多个要创建的 Function 对象的参数

// 参见body:一个字符串,指定函数的主体,可以含有任意多条 JavaScript 语句,这些语句之间用分号隔开,可以给该构造函数引用前面的参数设置的任何参数名

// 返回新创建的 Function 对象。调用该函数,将执行 body 指定的 JavaScript 代码

第577行:如果浏览器不支持JSON.parse(),并且JSON字符串不合法,则在最后抛出一个异常。

2.?jQuery.parseXML( data )

方法jQuery.parseXML( data )接受一个格式良好的XML字符串,返回解析后的XML文档。

方法jQuery.parseXML()使用浏览器原生的XML解析函数实现。在IE 9+和其他浏览器中,会使用DOMParser对象解析;在IE 9以下的浏览器中,则使用ActiveXObject对象解析。相关代码如下所示:

580     // Cross-browser xml parsing

581     parseXML: function( data ) {

582         var xml, tmp;

583         try {

584             if ( window.DOMParser ) { // Sandard

585                 tmp = new DOMParser();

586                 xml = tmp.parseFromString( data , "text/xml" );

587             } else { //IE

588                 xml = new ActiveXObject( "Microsoft.XMLDOM" );

589                 xml.async = "false";

590                 xml.loadXML( data );

591             }

592         } catch( e ) {

593             xml = undefined;

594         }

595         if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {

596             jQuery.error( "Invalid XML: " + data );

597         }

598         return xml;

599     },

第584~586行:尝试用标准解析器DOMParser解析。DOMParser在HTML5中标准化,可以将XML或HTML字符串解析为一个DOM文档。解析时,首先要创建一个DOMParser对象,然后使用它的方法parseFromString()来解析XML或HTML字符串。方法parseFromString()的语法如下:

DOMParser.parseFromString( DOMString str, SupportedType type )

// 参数str:待解析的 XML 或 HTML 字符串

// 参数type:支持的类型有"text/html"、"text/xml"、"application/xml"、"application/xhtml+xml"、"image/svg+xml"

// 返回一个解析后的新创建的文档对象

在IE以外的浏览器中,如果解析失败,方法parseFromString()不会抛出任何异常,只会返回一个包含了错误信息的文档对象,如下所示:

<parsererror xmlns="http:// www.mozilla.org/newlayout/xml/parsererror.xml">

   (error description)

   <sourcetext>(a snippet of the source XML)</sourcetext>

</parsererror>

因此,在第595行需要检查解析后的文档中是否包含<parsererror>节点,如果包含则表示解析失败,抛出一个更易读的异常。

在IE 9+中,如果解析失败,则会抛出异常。如果抛出异常,在catch块中设置xml为undefined,然后抛出一个更易读的异常。

可以运行下面的测试代码来验证上述内容:

new DOMParser().parseFromString("<a>hello" , "text/xml")

在Chrome中返回一个包含了错误信息的文档对象:

<a>

   <parsererror style="display: block; white-space: pre; border: 2px solid #c77;

   padding: 0 1em 0 1em; margin: 1em; background-color: #fdd; color: black">

       <h3>This page contains the following errors:</h3>

       <div style="font-family:monospace;font-size:12px">

           error on line 1 at column 9: Extra content at the end of the document

       </div>

       <h3>Below is a rendering of the page up to the first error.</h3>

   </parsererror>hello

</a>

在IE 9中则抛出异常:

"DOM Exception: SYNTAX_ERR (12)"

XML5602: 输入意外结束。

, 行1 字符9

下面回到对方法jQuery.parseXML()源码的分析中来。

第588~594行:IE 9以下的浏览器不支持DOMParser,需要使用微软的XML解析器Microsoft.XMLDOM解析。解析步骤依次为:创建一个空的XML文档对象,设该文档对象为同步加载,调用方法loadXML()解析XML字符串。

如果解析成功,方法loadXML()会返回true,解析结果存放在创建的XML文档对象中;如果解析失败,方法loadXML()会返回false(不会抛出异常),并设置文档根节点documentElement为null。

第595~597行:如果解析失败,则抛出一个更易读的异常。如果满足以下条件之一,则认为解析失败:

在IE 9+中,通过标准XML解析器DOMParser解析失败,此时!xml为true。

在IE 9以下的浏览器中,通过微软的XML解析器Microsoft.XMLDOM解析失败,此时!xml.documentElement为true。

在其他浏览器中,通过标准XML解析器DOMParser解析失败,此时xml.getElementsByTagName("parsererror").length可以转换为true。

第598行:如果解析成功,则返回解析结果。

下面是一些扩展阅读:

XML文档属性和方法:

http://msdn.microsoft.com/en-us/library/windows/desktop/ms763798(v=vs.85).aspx

http://msdn.microsoft.com/en-us/library/windows/desktop/ms757828(v=vs.85).aspx

解析XML文档:

http://www.w3schools.com/xml/xml_parser.asp

HTML5规范中的XML序列化:

http://html5.org/specs/dom-parsing.html#xmlserializer      

2.8.4 jQuery.globalEval( code )

方法jQuery.globalEval( code )用于在全局作用域中执行JavaScript代码。很多时候我们希望JavaScript代码是在全局作用域中执行,例如,当动态加载并执行JavaScript代码时。

在IE中,可以调用方法execScript()让JavaScript代码在全局作用域中执行;在其他浏览器中,则需要在一个自调用匿名函数中调用eval()执行JavaScript代码,自调用匿名函数确保了执行环境是全局作用域。相关代码如下所示:

603     // Evaluates a script in a global context

604     // Workarounds based on findings by Jim Driscoll

605     // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript- global-context

606     globalEval: function( data ) {

607         if ( data && rnotwhite.test( data ) ) {

608             // We use execScript on Internet Explorer

609             // We use an anonymous function so that context is window

610             // rather than jQuery in Firefox

611             ( window.execScript || function( data ) {

612               window[ "eval" ].call( window, data );

613             } )( data );

614         }

615     },

方法execScript()在全局作用域中按照指定的脚本语言执行脚本代码,默认语言是Jscript,没有返回值。该方法的语法如下:

execScript( code, language )

// 参数code:待执行的脚本代码

// 参数language:脚本语言,可选值有JavaScript、JavaScript1.1、JavaScript1.2、JavaScript1.3、

Jscript、VBS、VBScript,默认是 Jscript

Chrome的早期版本曾支持方法execScript(),现已不支持。

方法eval()在调用它的作用域中计算或执行JavaScript代码。如果JavaScript代码是一条表达式,则计算并返回计算结果;如果含有一条或多条JavaScript语句,则执行这些语句,如果最后一条语句有返回值,则返回这个值,否则返回undefined。该方法的语法如下:

eval( code )

// 参数code:待执行的 JavaScript 表达式或语句

第611~613行:如果支持方法execScript(),则执行execScript( data );否则创建一个自调用匿名函数,在函数内部执行“window[ "eval" ].call( window, data );”,读者可以访问源码注释第605行的网页地址查看如此书写的原因。

2.8.5 jQuery.camelCase( string )

方法jQuery.camelCase( string )转换连字符式的字符串为驼峰式,用于CSS模块和数据缓存模块。例如:

jQuery.camelCase( 'background-color' );

// "backgroundColor"

方法jQuery.camelCase( string )的相关代码如下所示:

 65     // Matches dashed string for camelizing

 66     rdashAlpha = /-([a-z]|[0-9])/ig,

 67     rmsPrefix = /^-ms-/,

 68

 69     // Used by jQuery.camelCase as callback to replace()

 70     fcamelCase = function( all, letter ) {

 71         return ( letter + "" ).toUpperCase();

 72     },

 

617     // Convert dashed to camelCase; used by the css and data modules

618     // Microsoft forgot to hump their vendor prefix (#9572)

619     camelCase: function( string ) {

620         return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );

621     },

第66行:正则rdashAlpha用于匹配字符串中连字符“-”和其后的第一个字母或数字。如果连字符“-”后是字母,则匹配部分会被替换为对应的大写字母;如果连字符“-”后是数字,则会删掉连字符“-”,保留数字。

第67行:正则rmsPrefix用于匹配字符串中前缀“-ms-”,匹配部分会被替换为“ms-”。这么做是因为在IE中,连字符式的样式名前缀“-ms-”对应小写的“ms”,而不是驼峰式的“Ms”。例如,“-ms-transform”对应“msTransform”而不是“MsTransform”。在IE以外的浏览器中,连字符式的样式名则可以正确地转换为驼峰式,例如,“-moz-transform”对应“MozTransform”。

第70~72行:函数fcamelCase()负责把连字符后的字母转换为大写并返回。

第619~621行:在方法jQuery.camelCase()中,先用正则rmsPrefix匹配前缀“-ms-”,如果有则修正为“ms-”;然后用正则rdashAlpha匹配连字符“-”和其后的第一个字母或数字,并用字符串方法replace()和函数fcamelCase()把匹配部分替换为对应的大写字母或数字。

2.8.6 jQuery.nodeName( elem, name )

方法jQuery.nodeName( elem, name )用于检查DOM元素的节点名称(即属性nodeName)与指定的值是否相等,检查时忽略大小写。

DOM元素的属性nodeName返回该元素的节点名称;对于HTML文档,始终返回其大写形式;对于XML文档,因为XML文档区分大小写,所以返回值与源代码中的形式一致。在方法jQuery.nodeName( elem, name )中会把属性nodeName和参数name转换为大写形式后再做比较,即忽略大小写。相关代码如下所示:

623     nodeName: function( elem, name ) {

624        return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpper

Case();

625     },

第624行:把属性elem.nodeName和参数name都转换为大写再做比较。在执行elem.nodeName.toUpperCase()前先检查elem.nodeName是否存在,可以有效地避免参数elem不是DOM元素,或者参数elem没有属性nodeName导致的错误。

2.8.7 jQuery.trim( str )

方法jQuery.trim( str )用于移除字符串开头和结尾的空白符。如果传入的参数是null或undefined,则返回空字符串;如果传入的参数是对象,则先获取对象的字符串表示,然后移除开头和结尾的空白符,并返回。相关代码如下所示:

 43     // Check if a string has a non-whitespace character in it

 44     rnotwhite = /\S/,

 45

 46     // Used for trimming whitespace

 47     trimLeft = /^\s+/,

 48     trimRight = /\s+$/,

 

 91     trim = String.prototype.trim,

 

910 // IE doesn't match non-breaking spaces with \s

911 if ( rnotwhite.test( "\xA0" ) ) {

912     trimLeft = /^[\s\xA0]+/;

913     trimRight = /[\s\xA0]+$/;

914 }

 

668     // Use native String.trim function wherever possible

669     trim: trim ?

670         function( text ) {

671             return text == null ?

672                 "" :

673                 trim.call( text );

674         } :

675

676         // Otherwise use our own trimming functionality

677         function( text ) {

678             return text == null ?

679                 "" :

680                 text.toString().replace( trimLeft, "" ).replace( trimRight, "" );

681         },

第47~48行:正则trimLeft用于匹配字符串开头的空白符;trimRight用于匹配字符串结尾的空白符。

第911~914行:在IE 9以下的浏览器中,\s不匹配不间断空格\xA0,需要为正则trimLeft和trimRight加上“\xA0”。

第669~681行:如果浏览器支持String.prototype.trim()则“借鸡生蛋”,String.prototype.

trim()是ECMAScript 5新增的String原型方法;如果不支持,则先调用方法toString()得到参数text的字符串表示,然后调用方法replace()把正则trimLeft和trimRight匹配到的空白符替换为空字符串。如果参数是null或undefined,则返回空字符串。

2.8.8 数组操作方法:jQuery.makeArray( obj )、jQuery.inArray( value,

   array [, fromIndex] )、jQuery.merge( first, second )、jQuery.

   grep( array, function(elementOfArray, indexInArray) [, invert] )

1.?jQuery.makeArray( obj )

方法jQuery.makeArray( obj )可以将一个类数组对象转换为真正的数组。

在jQuery内部,还可以为方法jQuery.makeArray()传入第二个参数,这样,第一个参数中的元素将被合并入第二个参数,最后会返回第二个参数,此时返回值的类型不一定是真正的数组。

方法jQuery.makeArray( obj )的源码如下:

 89     push = Array.prototype.push,

 

683     // results is for internal usage only

684     makeArray: function( array, results ) {

685        var ret = results || [];

686

687        if ( array != null ) {

688            // The window, strings (and functions) also have 'length'

689            // Theaked logic slightly to handle Blackberry 4.7 RegExp issues #6930

690            var type = jQuery.type( array );

691

692            if ( array.length == null

                     || type === "string"

                     || type === "function"

                     || type === "regexp"

                     || jQuery.isWindow( array ) ) {

693                push.call( ret, array );

694            } else {

695               jQuery.merge( ret, array );

696            }

697        }

698

699         return ret;

700     },

第684行:定义方法jQuery.makeArray( array, results ),它接受2个参数:

参数array:待转换对象,可以是任何类型。

参数results:仅在jQuery内部使用。如果传入参数results,则在该参数上添加元素。

第685行:定义返回值ret。如果传入了参数results则把该参数作为返回值,否则新建一个空数组作为返回值。

第687行:过滤参数array是null、undefined的情况。

第690~693行:如果参数array满足以下条件之一,则认为该参数不是数组,也不是类数组对象,调用数组方法push()把该参数插入返回值ret的末尾:

参数array没有属性length。

参数array是字符串,属性length返回字符串中的字符个数。

参数array是函数,属性length返回函数声明时的参数个数。

参数array是window对象,属性length返回窗口中的框架(frame、iframe)个数。

参数array是正则对象,在Blackberry(黑莓)4.7中,正则对象也有length属性。

注意,第693行插入元素时执行的是push.call( ret,array ),而不是ret.push( array ),这是因为返回值ret不一定是真正的数组。如果只传入参数array,则返回值ret是真正的数组;如果还传入了第二个参数result,则返回值ret的类型取决于该参数的类型。

第694~696行:否则认为参数array是数组或类数组对象,调用方法jQuery.merge()把该参数合并到返回值ret中。

第699行:最后返回ret。

2.?jQuery.inArray( value, array[, fromIndex] )

方法jQuery.inArray( value, array[, fromIndex] )在数组中查找指定的元素并返回其下标,未找到则返回-1。相关代码如下所示:

702     inArray: function( elem, array, i ) {

703         var len;

704

705         if ( array ) {

706             if ( indexOf ) {

707                 return indexOf.call( array, elem, i );

708             }

709

710             len = array.length;

711             i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;

712

713             for ( ; i < len; i++ ) {

714                 // Sip accessing in sparse arrays

715                 if ( i in array && array[ i ] === elem ) {

716                     return i;

717                 }

718             }

719         }

720

721         return -1;

722     },

第702行:定义方法jQuery.inArray( elem, array, i ),它接受3个参数:

参数elem:要查找的值。

参数array:数组,将遍历这个数组来查找参数value在其中的下标。

参数i:指定开始查找的位置,默认是0即查找整个数组。

第705行:过滤array可以转换为false的情况。

第706~708行:如果浏览器支持数组方法indexOf(),则调用它并返回下标。该方法在ECMAScript 5中被标准化。

第711行:修正参数i。如果未指定参数i,则初始化为0,表示默认从头开始遍历;如果i小于0,则加上数组长度len,即从数组末尾开始计算,例如,-1表示最后一个元素,-2表示倒数第二个元素,以此类推。注意,这里调用了Math.max()方法在0和len+i之间取最大值,即如果len+i依然小于0,则把i修正为0,仍然从头开始遍历。

第713~718行:从指定位置开始遍历数组,查找与指定值elem相等的元素,并返回其下标。先检测i in array,如果结果是false,说明数组array的下标是不连续的,也不需要与指定值elem比较;然后检测array[i]=== elem,如果结果是true,则返回当前下标。这里使用等同运算符( === )来避免类型转换。

第721行:如果没有找到与指定值相等的元素,则默认返回-1。从方法jQuery.inArray()的命名来看,这个方法应该返回true或false,而它实际上返回的却是下标,因此把方法名改为indexOf或许更合适些,但是这个方法从jQuery 1.2就一直存在,如果修改则会导致严重的向后兼容问题,所以返回值和方法名都不宜修改。

通常我们会比较jQuery.inArray()的返回值是否大于0,来判断某个指定的元素是否是数组中的元素,就像下面这样:

if( jQuery.inArray( elem, array ) > 0 ){

   // elem 是 array 中的元素

}

上面的写法比较繁琐,特别是当if语句检测的条件是复合布尔表达式时,可读性会很差;可以用按位非运算符(~)简化上面的代码:

if( ~jQuery.inArray( elem, array ) ){

   // elem 是 array 中的元素

}

按位非运算符(~)会将运算数的所有位取反,相当于改变它的符号并且减1,例如:

~-1 == 0; // true

~0 == -1; // true

~1 == -2; // true

~2 == -3; // true

更进一步,可以结合使用按位非运算符(~)和逻辑非运算符(!)把jQuery.inArray()的返回值转换为布尔型:

!!~jQuery.inArray( elem, array )

// 如果elem 可以匹配 array 中的某个元素,则该表达式的值为 true

// 如果elem 匹配不到 array 中的元素,则该表达式的值为 false

3.?jQuery.merge( first, second )

方法jQuery.merge( first, second )用于合并两个数组的元素到第一个数组中。事实上,第一个参数可以是数组或类数组对象,即必须含有整型(或可以转换为整型)属性length;第二个参数则可以是数组、类数组对象或任何含有连续整型属性的对象。

方法jQuery.merge()的合并行为是破坏性的,将第二个数组中的元素添加到第一个数组中后,第一个数组就被改变了。如果希望原来的第一个数组不被改变,可以在调用jQuery.merge()之前创建一份第一个数组的副本:

var newArray = $.merge([], oldArray);

方法jQuery.merge( first, second )的相关代码如下所示:

724     merge: function( first, second ) {

725         var i = first.length,

726             j = 0;

727

728         if ( typeof second.length === "number" ) {

729             for ( var l = second.length; j < l; j++ ) {

730                 first[ i++ ] = second[ j ];

731             }

732

733         } else {

734             while ( second[j] !== undefined ) {

735                 first[ i++ ] = second[ j++ ];

736             }

737         }

738

739         first.length = i;

740

741         return first;

742     },

第724行:定义方法jQuery.merge( first, second ),它接受2个参数:

参数first:数组或类数组对象,必须含有整型(或可以转换为整型)属性length,第二个数组second中的元素会被合并到该参数中。

参数second:数组、类数组对象或任何含有连续整型属性的对象,其中的元素会被合并到第一个参数first中。

第725行:初始化变量i为first.length,该变量指示了插入新元素时的下标。first.length必须是整型或可以转换为整型,否则后面执行i++时会返回NaN。

第728~731行:如果参数second的属性length是数值类型,则把该参数当作数组处理,把其中的所有元素都添加到参数first中。

第733~737行:如果参数second没有属性length,或者属性length不是数值类型,则把该参数当作含有连续整型(或可以转换为整型)属性的对象,例如,{ 0:'a', 1:'b'},把其中的非undefined元素逐个插入参数first中。

第739行:修正first.length。因为参数first可能不是真正的数组,所以需要手动维护属性length的值。

第741行:返回改变后的参数first。

4.?jQuery.grep( array, function( elementOfArray, indexInArray )[, invert] )

方法jQuery.grep( array, function( elementOfArray, indexInArray )[, invert] )用于查找数组中满足过滤函数的元素,原数组不会受影响。

如果参数invert未传入或是false,元素只有在过滤函数返回true,或者返回值可以转换为true时,才会被保存在最终的结果数组中,即返回一个满足回调函数的元素数组;如果参数invert是true,则情况正好相反,返回的是一个不满足回调函数的元素数组。

该方法的相关代码如下所示:

744     grep: function( elems, callback, inv ) {

745         var ret = [], retVal;

746         inv = !!inv;

747

748         // Go through the array, only saving the items

749         // that pass the validator function

750         for ( var i = 0, length = elems.length; i < length; i++ ) {

751             retVal = !!callback( elems[ i ], i );

752             if ( inv !== retVal ) {

753                 ret.push( elems[ i ] );

754             }

755         }

756

757         return ret;

758     },

第744行:定义方法jQuery.grep( elems, callback, inv ),它接受3个参数:

参数array:待遍历查找的数组。

参数callback:过滤每个元素的函数,执行时被传入两个参数:当前元素和它的下标。该函数应该返回一个布尔值。

参数inv:如果参数inv是false或未传入,方法jQuery.grep()会返回一个满足回调函数的元素数组;如果参数inv是true,则返回一个不满足回调函数的元素数组。

第746行:遍历数组elems,为每个元素执行过滤函数。如果参数inv为true,把执行结果为false的元素放入结果数组ret;如果inv为false,则把执行结果为true的元素放入结果数组ret。

第757行:最后返回结果数组ret。

2.8.9 jQuery.guid、jQuery.proxy( function, context )

1.?jQuery.guid

属性jQuery.guid是一个全局计数器,用于jQuery事件模块和缓存模块。在jQuery事件模块中,每个事件监听函数会被设置一个guid属性,用来唯一标识这个函数;在缓存模块中,通过在DOM元素上附加一个唯一标识,来关联该元素和该元素对应的缓存。属性jQuery.guid初始值为1,使用时自增1,相关代码如下所示:

793     // A global GUID counter for objects

794     guid: 1,

 

// jQuery.data( elem, name, data, pvt /* Internal Use Only */ )

1679                 elem[ internalKey ] = id = ++jQuery.uuid;

 

// jQuery.event.add: function( elem, types, handler, data, selector )

2861             handler.guid = jQuery.guid++;

2.?jQuery.proxy( function, context )

方法jQuery.proxy( function, context )接受一个函数,返回一个新函数,新函数总是持有特定的上下文。这个方法有两种用法:

(1)jQuery.proxy(  function, context )

参数function是将被改变上下文的函数,参数context是上下文。指定参数function的上下文始终为参数content。

(2)jQuery.proxy( context, name )

参数name是参数context的属性。指定参数name对应的函数的上下文始终为参数context。

该方法的相关代码如下所示:

796     // Bind a function to a context, optionally partially applying any

797     // aguments.

798     proxy: function( fn, context ) {

799         if ( typeof context === "string" ) {

800             var tmp = fn[ context ];

801             context = fn;

802             fn = tmp;

803         }

804

805         // Quick check to determine if target is callable, in the spec

806         // this throws a TypeError, but we will just return undefined.

807         if ( !jQuery.isFunction( fn ) ) {

808             return undefined;

809         }

810

811         // Simulated bind

812         var args = slice.call( arguments, 2 ),

813             proxy = function() {

814                 return fn.apply( context, args.concat( slice.call( arguments ) ) );

815             };

816

817         // Set the guid of unique handler to the same of original handler, so it can be removed

818         proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;

819

820         return proxy;

821     },

第798行:定义方法jQuery.proxy( fn, context ),参数有两种格式:

jQuery.proxy( fn, context )

jQuery.proxy( context, name )

第799行:修正参数fn和context。如果第二个参数是字符串,说明参数格式是jQuery.proxy( context, name ),修正为jQuery.proxy( fn, context )。

第807~809行:如果参数fn不是函数,则返回undefined。

第812行:收集多余参数。如果调用jQuery.proxy()时,除了传入参数fn、context之外,还传入了其他参数,那么在调用函数fn时,这些多余的参数将会优先传入。这里借用数组方法slice()来获取参数对象arguments中fn、context后的其他参数。下面的例子测试了传入多余参数的情况:

var proxied = $.proxy( function(){

   console.log( this );               // Object

   console.log( arguments ); // [1, 2, 3]

}, {}, 1, 2, 3 );

proxied(4, 5);

// 在控制台依次打印:

// Object

// [1, 2, 3, 4, 5]

第813~815行:创建一个代理函数,在代理函数中调用原始函数fn,调用时通过方法apply()指定上下文。代理函数通过闭包机制引用context、args、slice。

第818行:为代理函数设置与原始函数相同的唯一标识guid。如果原始函数没有,则重新分配一个。

相同的唯一标识将代理函数和原始函数关联了起来。例如,在jQuery事件系统中,如果为DOM元素绑定了事件监听函数的代理函数,当移除事件时,即使传入的是原始函数,jQuery也能通过唯一标识guid移除正确的函数。

第820行:最后返回创建的代理函数。

2.8.10 jQuery.access( elems, key, value, exec, fn( elem, key, value ), pass )

方法jQuery.access( elems, key, value, exec, fn( elem, key, value ), pass )可以为集合中的元素设置一个或多个属性值,或者读取第一个元素的属性值。如果设置的属性值是函数,并且参数exec是true时,还会执行函数并取其返回值作为属性值。

方法jQuery.access()为.attr()、.prop()、.css()提供支持,这三个方法在调用jQuery.access()时,参数exec为true,参数fn是同时支持读取和设置属性的函数(例jQuery.attr()、jQuery.prop()),相关代码如下所示:

// .attr()

2166     attr: function( name, value ) {

2167         return jQuery.access( this, name, value, true, jQuery.attr );

2168     },

 

// p.rop()

2176     prop: function( name, value ) {

2177         return jQuery.access( this, name, value, true, jQuery.prop );

2178     },

 

// c.ss()

6460 jQuery.fn.css = function( name, value ) {

6461     // ...

6466     return jQuery.access( this, name, value, true, function( elem, name, value ) {

6467         return value !== undefined ?

6468            jQuery.style( elem, name, value ) :

6469            jQuery.css( elem, name );

6470     });

6471 };

方法jQuery.access( elems, key, value, exec, fn, pass )的相关代码如下所示:

823     // Mutifunctional method to get and set values to a collection

824     // The value/s can optionally be executed if it's a function

825     access: function( elems, key, value, exec, fn, pass ) {

826         var length = elems.length;

827

828         // Setting many attributes

829         if ( typeof key === "object" ) {

830             for ( var k in key ) {

831                 jQuery.access( elems, k, key[k], exec, fn, value );

832             }

833             return elems;

834         }

835

836         // Setting one attribute

837         if ( value !== undefined ) {

838             // Optionally, function values get executed if exec is true

839             exec = !pass && exec && jQuery.isFunction(value);

840

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

842                 fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );

843             }

844

845             return elems;

846         }

847

848         // Getting an attribute

849         return length ? fn( elems[0], key ) : undefined;

850     },

第825行:定义方法jQuery.access( elems, key, value, exec, fn, pass ),它接受 6 个参数:

参数elems:元素集合,通常是jQuery对象。

参数key:属性名或含有键值对的对象。

参数value:属性值或函数。当参数key是对象时,该参数为undefined。

参数exec:布尔值,当属性值是函数时,该参数指示了是否执行函数。

参数fn:回调函数,同时支持读取和设置属性。

参数pass:布尔值,该参数在功能上与参数exec重叠,并且用法相当繁琐,可以忽略这个参数。

第829~834行:如果参数key是对象,表示要设置多个属性,则遍历参数key,为每个属性递归调用方法jQuery.access(),遍历完后返回元素集合elems。

第837~846行:如果参数value不是undefined,表示要设置单个属性,则遍历元素集合elems,为每个元素调用回调函数fn,遍历完后返回元素集合elems。如果参数exec为true,并且参数value是函数,则执行参数value,并取其返回值作为属性值。

第849行:读取一个属性。如果元素集合elems不为空,则为第一个元素调用回调函数fn,读取参数key对应的属性值;否则返回undefined。

2.8.11 jQuery.error( message )、jQuery.noop()、jQuery.now()

方法jQuery.error( message )接受一个字符串,抛出一个包含了该字符串的异常。开发插件时可以覆盖这个方法,用来显示更有用或更多的错误提示消息。

方法jQuery.noop()表示一个空函数。当希望传递一个什么也不做的函数时,可以使用这个空函数。开发插件时,这个方法可以作为可选回调函数的默认值,如果没有提供回调函数,则执行jQuery.noop()。

方法jQuery.now()返回当前时间的毫秒表示,是( newDate() ).getTime()的简写。

上面3个方法的相关代码如下所示:

551     error: function( msg ) {

552         throw new Error( msg );

553     },

 

601     noop: function() {},

 

852     now: function() {

853         return ( new Date() ).getTime();

854     },

2.8.12 浏览器嗅探:jQuery.uaMatch( ua )、jQuery.browser

属性jQuery.browser提供了访问当前页面的浏览器的信息,其中包含最流行的4种浏览器类型(IE、Mozilla、Webkit、Opera)和版本信息,属性值的结构如下:

// jQuery.browser

{

  webkit/opera/msie/mozilla: true,

  version: '版本号'

}

Chrome和Safari使用Webkit作为内核引擎,因此如果jQuery.browser.webkit为true则表示浏览器是Chrome或Safari;如果jQuery.browser.mozilla为true,则表示浏览器是Mozilla Firefox。

jQuery.browser通过解析navigator.userAgent来获取浏览器类型和版本号,这种技术也称为浏览器嗅探技术,用于解决浏览器不兼容问题;navigator是全局对象window的属性,指向一个Navigator对象,包含了正在使用的浏览器的信息;navigator.userAgent包含了浏览器用于HTTP请求的用户代理头(User-Agent)的值。

应该避免编写基于特定浏览器类型或版本号的代码,因为这会导致代码与特定的浏览器类型或版本紧密绑定在一起,另外,用户或浏览器也可以修改navigator.userAgent,欺骗脚本和服务器端;解决浏览器不兼容问题的更好做法是基于浏览器功能测试编写代码,具体请参阅第7章。

对navigator.userAgent的解析由方法jQuery.uaMatch( ua )实现,相关代码如下所示:

 59     // Useragent RegExp

 60     rwebkit = /(webkit)[ \/]([\w.]+)/,

 61     ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,

 62     rmsie = /(msie) ([\w.]+)/,

 63     rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,

 

 74     // Keep a UserAgent string for use with jQuery.browser

 75     userAgent = navigator.userAgent,

 

856     // Use of jQuery.browser is frowned upon.

857     // More details: http:// docs.jquery.com/Utilities/jQuery.browser

858     uaMatch: function( ua ) {

859         ua = ua.toLowerCase();

860

861         var match = rwebkit.exec( ua ) ||

862             ropera.exec( ua ) ||

863             rmsie.exec( ua ) ||

864             ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||

865             [];

866

867         return { browser: match[1] || "", version: match[2] || "0" };

868     },

 

891     browser: {}

892 });

 

899 browserMatch = jQuery.uaMatch( userAgent );

900 if ( browserMatch.browser ) {

901     jQuery.browser[ browserMatch.browser ] = true;

902     jQuery.browser.version = browserMatch.version;

903 }

904

905 // Dprecated, use jQuery.browser.webkit instead

906 if ( jQuery.browser.webkit ) {

907     jQuery.browser.safari = true;

908 }

第60~63行:定义用于解析用户代理navigator.userAgent的4个正则表达式:rwebkit、ropera、rmsie、rmozilla。每个正则包含两个分组:浏览器类型特征字符和浏览器版本特征字符。

第858~868行:定义方法jQuery.uaMatch( ua ),用于解析当前浏览器的类型和版本号。在方法jQuery.uaMatch( ua )中,依次尝试用4个正则表达式匹配用户代理navigator.userAgent,并返回一个包含了匹配结果的对象,对象的结构是:

{

   browser: 分组 1 或空字符串,

   version: 分组 2 或字符串"0"

}

第899~903行:调用方法jQuery.uaMatch( ua )解析用户代理navigator.userAgent,并把解析结果重新封装为jQuery.browser。

2.8.13 小结

构造jQuery对象模块的静态属性和方法总结如图2-9所示。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:

华章出版社

官方博客
官网链接