jquery原理解析,简述jquery的实现原理

请教一个jquery load函数的原理

1:表现形式:

创新互联-专业网站定制、快速模板网站建设、高性价比三亚网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式三亚网站制作公司更省心,省钱,快速模板网站建设找我们,业务覆盖三亚地区。费用合理售后完善,十多年实体公司更值得信赖。

传统的:

javascript的加载事件:

body onload = “函数()”

window.onload= function(){}

jquery :

① $(document).ready(function处理);

② $().ready(function处理);

③ $(function处理); 对第一种加载的封装而已

2:设置个数:

在同一个请求里边,jquery的可以设置多个,而传统方式只能设置一个

传统方式加载事件是给onload事件属性赋值,多次赋值,后者会覆盖前者。

jquery方式加载事件是把每个加载事件都存入一个数组里边,成为数组的元素,执行的时候就遍历该数组执行每个元素即可,因此其可以设置多个加载事件。:

3:执行时机:

传统方式加载事件,是全部内容(文字、图片、样式)在浏览器显示完毕再给执行加载事件。

jquery方式加载事件,只要全部内容(文字、图片、样式)在内存里边对应的DOM树结构绘制完毕就给执行,有可能对应的内容在浏览器里边还没有显示。

什么是jquery jquery的工作原理

jquery是javascript的一个类库,说到底jquery就是javascript jquery主要是用来简化javascript的各种操作以及解决各种浏览器之间的兼容性 用jquery能办到的用javascript都能办到。

jQuery 是如何判断HTML页面加载完毕的?它的原理是什么?

jquery是一个轻量级的JS框架,这点相信大部分人都听过,而jquery之所以有这样一个称呼,就是因为它悄悄披了一件外衣,将自己给隐藏了起来。

//以下截取自jquery源码片段(function( window, undefined ) {   /*    源码内容    */})( window );

上面这一小段代码来自于1.9.0当中jquery的源码,它是一个无污染的JS插件的标准写法,专业名词叫闭包。可以把它简单的看做是一个函数,与普通函数不同的是,这个函数没有名字,而且会立即执行,就像下面这样,会直接弹出字符串。

(function( window, undefined ) {

alert("Hello World!");

})( window );

可以看出来这样写的直接效果,就相当于我们直接弹出一个字符串。但是不同的是,我们将里面的变量变成了局域变量,这不仅可以提高运行速度,更重要的是我们在引用jquery的JS文件时,不会因为jquery当中的变量太多,而与其它的JS框架的变量命名产生冲突。对于这一点,我们拿以下这一小段代码来说明。

var temp = "Hello World!";

(function( window, undefined ) {       var temp = "ByeBye World!";

})( window );

alert(temp);

这段代码的运行结果是Hello而不是ByeBye,也就是说闭包中的变量声明没有污染到外面的全局变量,倘若我们去掉闭包,则最终的结果会是ByeBye,就像下面这样。

var temp = "Hello World!";//    (function( window, undefined ) {

var temp = "ByeBye World!";//    })( window );

alert(temp);

由此就可以看出来,jquery的外衣就是这一层闭包,它是很重要的一个内容,是编写JS框架必须知道的知识,它可以帮助我们隐藏我们的临时变量,降低污染。

jQuery选择器的工作原理和优化分析

每次申明一个jQuery对象的时候,返回的是jQuery.prototype.init

对象,很多人就会不明白,init明明是jQuery.fn的方法啊,实际上这里不是方法,而是init的构造函数,因为js的prototype对象可

以实现继承,加上js的对象只是引用不会是拷贝,new

jQuery,new

jQuery.fn和new

jQuery.fn.init的子对象是一样的,只是有没有执行到init的不同,这里就不讲原因了,等下一篇再讲为什么会是这样。

当我们使用选择器的时候$(selector,content),就会执行

init(selectot,content),我们看看inti中是怎样执行的:

复制代码

代码如下:

if

(

typeof

selector

==

"string"

)

{

//正则匹配,看是不是HTML代码或者是#id

var

match

=

quickExpr.exec(

selector

);

//没有作为待查找的

DOM

元素集、文档或

jQuery

对象。

//selector是#id的形式

if

(

match

(match[1]

||

!context)

)

{

//

HANDLE:

$(html)

-

$(array)

//HTML代码,调用clean补全HTML代码

if

(

match[1]

){

selector

=

jQuery.clean(

[

match[1]

],

context

);

}

//

是:

$("#id")

else

{

//判断id的Dom是不是加载完成

var

elem

=

document.getElementById(

match[3]

);

if

(

elem

){

if

(

elem.id

!=

match[3]

)

return

jQuery().find(

selector

);

return

jQuery(

elem

);//执行完毕return

}

selector

=

[];

}

//非id的形式.在context中或者是全文查找

}

else{

return

jQuery(

context

).find(

selector

);

}

}

这里就说明只有选择器写成$(‘#id')的时候最快,相当于执行了一次

getElementById,后边的程序就不用再执行了。当然往往我们需要的选择器并不是这么简单,比如我们需要id下的CSS为className,

有这样的写法$(‘#id.className')和$(‘#id').find(‘.className');这两种写法的执行结果都是一样的,比

如div

id=”id”span

class=”className”/span/div,返回的肯定都是span

class=”className”/span,但是执行的效率是完全不一样的。

在分析一下上边的代码,如果不是$(‘#id')这样的简单选择器的话,都会执行find函

数,那我们再看看find到底是做用的:

复制代码

代码如下:

find:

function(

selector

)

{

//在当前的对象中查找

var

elems

=

jQuery.map(this,

function(elem){

return

jQuery.find(

selector,

elem

);

});

//下边的代码可以忽略,只是做一些处理

//这里应用了js的正则对象的静态方法test

//indexOf("..")需要了解一下xpath的语法,就是判断selector中包含父节点的写法

//本意就是过滤数组的重复元素

return

this.pushStack(

/[^+]

[^+]/.test(

selector

)

||

selector.indexOf("..")

-1

?

jQuery.unique(

elems

)

:

elems

);

}

如果这样写$(‘#id

.className'),就会执行到扩展的find(‘#id

.className',document),因为当前的this是document的jQuery数组,那我们在看看扩展的find他的实现,代码比较

多,就不列出来,总之就是从第二个参数传递进行的dom第一个子节点开始找,遇见#比对id,遇见.比对ClassName,还有:+-等处理。

那我们要优化,是不是就要想办法让第二个参数context的范围最小,那样遍历是不是就很少了?

如果我们这样写$(‘#id').find(‘.className'),那程序只这样执行

的,第一次init的时候执行一步getElementById,就return了,接着执行

find(‘.className',divDocument),divDocument就是我们第一次选择的是div标签,如果document下有很

多dom对象的时候,这次只遍历divDocument是不是少了很多次,而且在第一次选择id的速度也要比遍历快的多。

现在大家应该是明白了吧。就是说第一层选择最好是ID,而是简单选择器,目的就是定义范围,

提高速度,这次就说这些,选择写法的优化,其他的优化,下次再说。

那些年一直用jQuery处理事件,这些年想了解下内部原理吗

说起jQuery的事件,不得不提一下Dean Edwards大神 addEvent库,很多流行的类库的基本思想从他那儿借来的

jQuery的事件处理机制吸取了JavaScript专家Dean Edwards编写的事件处理函数的精华,使得jQuery处理事件绑定的时候相当的可靠。

在预留退路(graceful degradation),循序渐进以及非入侵式编程思想方面,jQuery也做的非常不错

事件的流程图

总的来说对于JQuery的事件绑定

在绑定的时候做了包装处理

在执行的时候有过滤器处理

.on( events [, selector ] [, data ], handler(eventObject) )

events:事件名

selector : 一个选择器字符串,用于过滤出被选中的元素中能触发事件的后代元素

data :当一个事件被触发时,要传递给事件处理函数的

handler:事件被触发时,执行的函数

例如:

var body = $('body')

body.on('click','p',function(){

console.log(this)

})

用on方法给body上绑定一个click事件,冒泡到p元素的时候才出发回调函数

这里大家需要明确一点:每次在body上点击其实都会触发事件,但是只目标为p元素的情况下才会触发回调handler

通过源码不难发现,on方法实质只完成一些参数调整的工作,而实际负责事件绑定的是其内部jQuery.event.add方法

on: function( types, selector, data, fn, /*INTERNAL*/ one ) {

var origFn, type;

// Types can be a map of types/handlers

if ( typeof types === "object" ) {

// ( types-Object, selector, data )

if ( typeof selector !== "string" ) {

// ( types-Object, data )

data = data || selector;

selector = undefined;

}

for ( type in types ) {

this.on( type, selector, data, types[ type ], one );

}

return this;

}

if ( data == null fn == null ) {

// ( types, fn )

fn = selector;

data = selector = undefined;

} else if ( fn == null ) {

if ( typeof selector === "string" ) {

// ( types, selector, fn )

fn = data;

data = undefined;

} else {

// ( types, data, fn )

fn = data;

data = selector;

selector = undefined;

}

}

if ( fn === false ) {

fn = returnFalse;

} else if ( !fn ) {

return this;

}

if ( one === 1 ) {

origFn = fn;

fn = function( event ) {

// Can use an empty set, since event contains the info

jQuery().off( event );

return origFn.apply( this, arguments );

};

// Use same guid so caller can remove using origFn

fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );

}

return this.each( function() {

jQuery.event.add( this, types, fn, data, selector );

});

针对事件处理,我们可以拆分2部分:

一个事件预绑定期

一个事件执行期

本章着重讲解事件的预绑定的时候做了那些处理,为什么要这样处理?

事件底层的绑定接口无非就是用addEventListener处理的,所以我们直接定位到addEventListener下面

jQuery.event.add 中有

elem: 目标元素

type: 事件类型,如’click’

eventHandle: 事件句柄,也就是事件回调处理的内容了

false: 冒泡

现在我们把之前的案例给套一下看看

var body = document.getElementsByTagName('body')

var eventHandle = function(){

console.log(this)

}

body .addEventListener( 'click’, eventHandle, false );

明显有问题,每次在body上都触发了回调,少了个p元素的处理,当然这样的效果也无法处理

eventHandle源码

回到内部绑定的事件句柄eventHandle ,可想而知eventHandle不仅仅只是只是充当一个回调函数的角色,而是一个实现了EventListener接口的对象

if ( !(eventHandle = elemData.handle) ) {

eventHandle = elemData.handle = function( e ) {

// Discard the second event of a jQuery.event.trigger() and

// when an event is called after a page has unloaded

return typeof jQuery !== core_strundefined (!e || jQuery.event.triggered !== e.type) ?

jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :

undefined;

};

// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events

eventHandle.elem = elem;

}

可见在eventHandle中并没有直接处理回调函数,而是映射到jQuery.event.dispatch分派事件处理函数了

仅仅只是传入eventHandle.elem,arguments , 就是body元素 与事件对象

那么这里有个问题,事件回调的句柄并没有传递过去,后面的代码如何关联?

本章的一些地方可能要结合后面的dispatch处理才能理清,但是我们还是先看看做了那些处理

on内部的实现机制

我们开从头来理清下jQuery.event.add代码结构,适当的跳过这个环节中不能理解的代码,具体遇到在提出

之前就提到过jQuery从1.2.3版本引入数据缓存系统,贯穿内部,为整个体系服务,事件体系也引入了这个缓存机制

所以jQuery并没有将事件处理函数直接绑定到DOM元素上,而是通过$.data存储在缓存$.cahce上

第一步:获取数据缓存

//获取数据缓存

elemData = data_priv.get( elem );

在$.cahce缓存中获取存储的事件句柄对象,如果没就新建elemData

第二步:创建编号

if ( !handler.guid ) {

handler.guid = jQuery.guid++;

}

为每一个事件的句柄给一个标示,添加ID的目的是 用来寻找或者删除handler,因为这个东东是缓存在缓存对象上的,没有直接跟元素节点发生关联

第三步:分解事件名与句柄

if ( !(events = elemData.events) ) {

events = elemData.events= {};

}

if ( !(eventHandle = elemData.handle) ) {

eventHandle = elemData.handle = function( e ) {

// Discard the second event of a jQuery.event.trigger() and

// when an event is called after a page has unloaded

return typeof jQuery !== core_strundefined (!e || jQuery.event.triggered !== e.type) ?

jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :

undefined;

};

eventHandle.elem = elem;

}

events,eventHandle 都是elemData缓存对象内部的,可见

在elemData中有两个重要的属性,

一个是events,是jQuery内部维护的事件列队

一个是handle,是实际绑定到elem中的事件处理函数

之后的代码无非就是对这2个对象的筛选,分组,填充了

第四步: 填充事件名与事件句柄

// Handle multiple events separated by a space

// jQuery(...).bind("mouseover mouseout", fn);

// 事件可能是通过空格键分隔的字符串,所以将其变成字符串数组

// core_rnotwhite:/\S+/g

types = ( types || "" ).match( core_rnotwhite ) || [""];

// 例如:'.a .b .c'.match(/\S+/g) → [".a", ".b", ".c"]

// 事件的个数

t = types.length;

while ( t-- ) {

// 尝试取出事件的命名空间

// 如"mouseover.a.b" → ["mouseover.a.b", "mouseover", "a.b"]

tmp = rtypenamespace.exec( types[t] ) || [];

// 取出事件类型,如mouseover

type = origType = tmp[1];

// 取出事件命名空间,如a.b,并根据"."分隔成数组

namespaces = ( tmp[2] || "" ).split( "." ).sort();

// There *must* be a type, no attaching namespace-only handlers

if ( !type ) {

continue;

}

// If event changes its type, use the special event handlers for the changed type

// 事件是否会改变当前状态,如果会则使用特殊事件

special = jQuery.event.special[ type ] || {};

// If selector defined, determine special event api type, otherwise given type

// 根据是否已定义selector,决定使用哪个特殊事件api,如果没有非特殊事件,则用type

type = ( selector ? special.delegateType : special.bindType ) || type;

// Update special based on newly reset type

// type状态发生改变,重新定义特殊事件

special = jQuery.event.special[ type ] || {};

// handleObj is passed to all event handlers

// 这里把handleObj叫做事件处理对象,扩展一些来着handleObjIn的属性

handleObj = jQuery.extend({

type: type,

origType: origType,

data: data,

handler: handler,

guid: handler.guid,

selector: selector,

needsContext: selector jQuery.expr.match.needsContext.test( selector ),

namespace: namespaces.join(".")

}, handleObjIn );

// Init the event handler queue if we're the first

// 初始化事件处理列队,如果是第一次使用,将执行语句

if ( !(handlers = events[ type ]) ) {

handlers = events[ type ] = [];

handlers.delegateCount = 0;

// Only use addEventListener if the special events handler returns false

// 如果获取特殊事件监听方法失败,则使用addEventListener进行添加事件

if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {

if ( elem.addEventListener ) {

elem.addEventListener( type, eventHandle, false );

}

}

}

// 特殊事件使用add处理

if ( special.add ) {

special.add.call( elem, handleObj );

// 设置事件处理函数的ID

if ( !handleObj.handler.guid ) {

handleObj.handler.guid = handler.guid;

}

}

// Add to the element's handler list, delegates in front

// 将事件处理对象推入处理列表,姑且定义为事件处理对象包

if ( selector ) {

handlers.splice( handlers.delegateCount++, 0, handleObj );

} else {

handlers.push( handleObj );

}

// Keep track of which events have ever been used, for event optimization

// 表示事件曾经使用过,用于事件优化

jQuery.event.global[ type ] = true;

}

// Nullify elem to prevent memory leaks in IE

// 设置为null避免IE中循环引用导致的内存泄露

elem = null;

},

这段比较长了分解下,最终的目的就是为填充events,eventHandle


新闻标题:jquery原理解析,简述jquery的实现原理
文章网址:http://myzitong.com/article/dsceogo.html