jquery源码学习笔记（一）jQuery的无new构建

本人是一名.net程序员.....

你一个.net coder 看什么jQuery 源码啊？

原因吗，很简单。技多不压身吗(麻蛋，前端工作好高...羡慕)。

我一直都很喜欢JavaScript，废话不多说了，直接切入正题。

最近看了好几篇jQuery 源码的文章，对于jQuery的无new构建  很是不解.

查了很多资料，总算是搞明白了。

jQuery的无new构建

jQuery框架的核心就是从HTML文档中匹配元素并对其执行操作、

回想一下使用 jQuery 的时候，实例化一个 jQuery 对象的方法：

// 无 new 构造
$(‘#test‘).text(‘Test‘);

// 当然也可以使用 new
var test = new $(‘#test‘);
test.text(‘Test‘);

大部分人使用 jQuery 的时候都是使用第一种无 new 的构造方式，直接 $(‘‘) 进行构造，这也是 jQuery 十分便捷的一个地方。

当我们使用第一种无 new 构造方式的时候，其本质就是相当于 new jQuery()，那么在 jQuery 内部是如何实现的呢？看看：

(function(window, undefined) {
    var
    // ...
    jQuery = function(selector, context) {
        // The jQuery object is actually just the init constructor ‘enhanced‘
        return new jQuery.fn.init(selector, context, rootjQuery);
    },

    jQuery.fn = jQuery.prototype = {
        init: function(selector, context, rootjQuery) {
            // ...
        }
    }
    jQuery.fn.init.prototype = jQuery.fn;
})(window);

没看懂？没关系，我们一步一步分析。

函数表达式和函数声明

在ECMAScript中，创建函数的最常用的两个方法是函数表达式和函数声明，两者期间的区别是有点晕，因为ECMA规范只明确了一点：函数声明必须带有标示符（Identifier）（就是大家常说的函数名称），而函数表达式则可以省略这个标示符：

　

　   //函数声明:
　　function 函数名称 (参数：可选){ 函数体 }
　　//函数表达式：
　　function 函数名称（可选）(参数：可选){ 函数体 }

所以，可以看出，如果不声明函数名称，它肯定是表达式，可如果声明了函数名称的话，如何判断是函数声明还是函数表达式呢？

ECMAScript是通过上下文来区分的，如果function foo(){}是作为赋值表达式的一部分的话，那它就是一个函数表达式，

如果function foo(){}被包含在一个函数体内，或者位于程序的最顶部的话，那它就是一个函数声明。

  function foo(){} // 声明，因为它是程序的一部分
  var bar = function foo(){}; // 表达式，因为它是赋值表达式的一部分
  new function bar(){}; // 表达式，因为它是new表达式
  (function(){
    function bar(){} // 声明，因为它是函数体的一部分
  })();

还有一种函数表达式不太常见，就是被括号括住的(function foo(){})，他是表达式的原因是因为括号 ()是一个分组操作符，它的内部只能包含表达式

再来看jQuery源码：

(function(window, undefined) {
    /...
})(window)

可以将上面的代码结构分成两部分：(function(){window, undefined}) 和 (window) ,

第1个()是一个表达式，而这个表达式本身是一个匿名函数，

所以在这个表达式后面加(window)就表示执行这个匿名函数并传入参数window。

原型 prototype

认识一下什么是原型？

在JavaScript中，原型也是一个对象，通过原型可以实现对象的属性继承，JavaScript的对象中都包含了一个" [[Prototype]]"内部属性，这个属性所对应的就是该对象的原型。

对于"prototype"和"__proto__"这两个属性有的时候可能会弄混，"Person.prototype"和"Person.__proto__"是完全不同的。

在这里对"prototype"和"__proto__"进行简单的介绍：

  • 对于所有的对象，都有__proto__属性，这个属性对应该对象的原型
  • 对于函数对象，除了__proto__属性之外，还有prototype属性，当一个函数被用作构造函数来创建实例时，该函数的prototype属性值将被作为原型赋值给所有对象实例（也就是设置实例的__proto__属性）
function Person(name, age){
    this.name = name;
    this.age = age;
}
Person.prototype.getInfo = function(){
    console.log(this.name + " is " + this.age + " years old");
};
//调用
var will = new Person("Will", 28);
will.getInfo();//"Will is 28 years old"

闭包

闭包的定义：

当一个内部函数被其外部函数之外的变量引用时，就形成了一个闭包。

闭包的作用：

在了解闭包的作用之前，我们先了解一下 javascript中的GC机制:

在javascript中，如果一个对象不再被引用，那么这个对象就会被GC回收，否则这个对象一直会保存在内存中。

在上述例子中，B定义在A中，因此B依赖于A,而外部变量 c 又引用了B, 所以A间接的被 c 引用，

也就是说，A不会被GC回收，会一直保存在内存中。为了证明我们的推理，看如下例子：

function A(){
    var count = 0;
    function B(){
       count ++;
       console.log(count);
    }
    return B;
}
var c = A();
c();// 1
c();// 2
c();// 3

count是A中的一个变量，它的值在B中被改变，函数B每执行一次，count的值就在原来的基础上累加1。因此，A中的count一直保存在内存中。

这就是闭包的作用，有时候我们需要一个模块中定义这样一个变量：希望这个变量一直保存在内存中但又不会“污染”全局的变量，这个时候，我们就可以用闭包来定义这个模块

在看jQuery源码：

(function(window, undefined) {
    var
    // ...
　　jQuery = function(selector, context) {
        // The jQuery object is actually just the init constructor ‘enhanced‘
        return new jQuery.fn.init(selector, context, rootjQuery);
    },
    jQuery.fn = jQuery.prototype = {
        init: function(selector, context, rootjQuery) {
            // ...
        }
    }
    jQuery.fn.init.prototype = jQuery.fn;
})(window);

我们知道了 什么是闭包：当一个内部函数被其外部函数之外的变量引用时，就形成了一个闭包。

jQuery.fn的init 函数被jQuery 的构造函数调用了,这里形成了一个闭包。

构造函数及调用代码：

// ...
　　jQuery = function(selector, context) {
        // The jQuery object is actually just the init constructor ‘enhanced‘
        return new jQuery.fn.init(selector, context, rootjQuery);
    },

问题关键来了。

如何实现无new构建

JavaScript是函数式语言，函数可以实现类，类就是面向对象编程中最基本的概念

var aQuery = function(selector, context) {
        //构造函数
}
aQuery.prototype = {
    //原型
    name:function(){},
    age:function(){}
}
var a = new aQuery();
a.name();

这是常规的使用方法，显而易见jQuery不是这样玩的

要实现这样,那么jQuery就要看成一个类，那么$()应该是返回类的实例才对

按照jQuery的抒写方式

$().ready()
$().noConflict()

要实现这样,那么jQuery就要看成一个类，那么$()应该是返回类的实例才对

所以把代码改一下：

var aQuery = function(selector, context) {
       return new aQuery();
}
aQuery.prototype = {
    name:function(){},
    age:function(){}
}

通过new aQuery()，虽然返回的是一个实例，但是也能看出很明显的问题，死循环了！

那么如何返回一个正确的实例？

在javascript中实例this只跟原型有关系

那么可以把jQuery类当作一个工厂方法来创建实例，把这个方法放到aQuery.prototye原型中

var aQuery = function(selector, context) {
       return  aQuery.prototype.init(selector);
}
aQuery.prototype = {
    init:function(selector){
        return this;
    }
    name:function(){},
    age:function(){}
}

当执行aQuery() 返回的实例：

很明显aQuery()返回的是aQuery类的实例，那么在init中的this其实也是指向的aQuery类的实例

问题来了init的this指向的是aQuery类，如果把init函数也当作一个构造器，那么内部的this要如何处理？

var aQuery = function(selector, context) {
       return  aQuery.prototype.init(selector);
}
aQuery.prototype = {
    init: function(selector) {
        this.age = 18
        return this;
    },
    name: function() {},
    age: 20
}
aQuery().age  //18

因为this只是指向aQuery类的，所以aQuery的age属性是可以被修改的。

这样看似没有问题，其实问题很大的

为什么是new jQuery.fn.init？

看如下代码：

var aQuery = function(selector, context) {
       return  aQuery.prototype.init(selector);
}
aQuery.prototype = {
    init: function(selector) {
        if(selector=="a")
           this.age = 18
        return this;
    },
    name: function() {},
    age: 20
}
aQuery("a").age  //18
aQuery("b").age  //18

当我调用 传入"a"的时候，修改age=18，及aQuery("a").age 的值为18

但是当我  传入"b"的时候 并没又修改 age的值，我也希望得到默认age的值20，但是aQuery("b").age 的值为18.

因为在 调用aQuery("a").age 的时候age被修改了。

这样的情况下就出错了，所以需要设计出独立的作用域才行。

jQuery框架分隔作用域的处理

jQuery = function( selector, context ) {
        // The jQuery object is actually just the init constructor ‘enhanced‘
        return new jQuery.fn.init( selector, context, rootjQuery );
    },

很明显通过实例init函数，每次都构建新的init实例对象，来分隔this,避免交互混淆

我们修改一下代码：

var aQuery = function(selector, context) {
       return  new aQuery.prototype.init(selector);
}
aQuery.prototype = {
    init: function(selector) {
        if(selector=="a")
           this.age = 18
        return this;
    },
    name: function() {},
    age: 20
}
aQuery("a").age  //18
aQuery("b").age  //undefined
aQuery("a").name()  //Uncaught TypeError: Object [object Object] has no method ‘name‘

又出现一个新的问题,

age  ：undefined,

name() :抛出错误，无法找到这个方法，所以很明显new的init跟jquery类的this分离了

怎么访问jQuery类原型上的属性与方法？

做到既能隔离作用域还能使用jQuery原型对象的作用域呢，还能在返回实例中访问jQuery的原型对象?

实现的关键点

// Give the init function the jQuery prototype for later instantiation
jQuery.fn.init.prototype = jQuery.fn;

我们再改一下：

var aQuery = function(selector, context) {
       return  new aQuery.prototype.init(selector);
}
aQuery.prototype = {
    init: function(selector) {
        if(selector=="a")
           this.age = 18
        return this;
    },
    name: function() {
         return age;
    },
    age: 20
}
aQuery.prototype.init.prototype = aQuery.prototype;  

aQuery("a").age  //18
aQuery("b").age  //20
aQuery("a").name()   //20

最后在看一下jQuery源码：

(function(window, undefined) {
    var
    // ...
　　jQuery = function(selector, context) {
        // The jQuery object is actually just the init constructor ‘enhanced‘
        return new jQuery.fn.init(selector, context, rootjQuery);
    },
    jQuery.fn = jQuery.prototype = {
        init: function(selector, context, rootjQuery) {
            // ...
        }
    }
    jQuery.fn.init.prototype = jQuery.fn;
})(window);

是不是明白了？

哈哈哈~~~

在简单说两句：

大部分人初看 jQuery.fn.init.prototype = jQuery.fn 这一句都会被卡主，很是不解。但是这句真的算是 jQuery 的绝妙之处。理解这几句很重要，分点解析一下：

1）首先要明确，使用 $(‘xxx‘) 这种实例化方式，其内部调用的是 return new jQuery.fn.init(selector, context, rootjQuery) 这一句话，也就是构造实例是交给了 jQuery.fn.init() 方法取完成。

2）将 jQuery.fn.init 的 prototype 属性设置为 jQuery.fn，那么使用 new jQuery.fn.init() 生成的对象的原型对象就是 jQuery.fn ，所以挂载到 jQuery.fn 上面的函数就相当于挂载到 jQuery.fn.init() 生成的 jQuery 对象上，所有使用 new jQuery.fn.init() 生成的对象也能够访问到 jQuery.fn 上的所有原型方法。

3）也就是实例化方法存在这么一个关系链

  • jQuery.fn.init.prototype = jQuery.fn = jQuery.prototype ;
  • new jQuery.fn.init() 相当于 new jQuery() ;
  • jQuery() 返回的是 new jQuery.fn.init()，而 var obj = new jQuery()，所以这 2 者是相当的，所以我们可以无 new 实例化 jQuery 对象。
时间： 2024-10-24 00:57:37

jquery源码学习笔记（一）jQuery的无new构建的相关文章

菜鸟的jQuery源码学习笔记（二）

jQuery对象是使用构造函数和原型模式相结合的方式创建的.现在来看看jQuery的原型对象jQuery.prototype: 1 jQuery.fn = jQuery.prototype = { 2 //成员变量和方法 3 } 这里给原型对象起了一个别名叫做jQuery.fn.要注意的是这个jQuery.fn可不是jQuery对象的属性,而是jQuery构造方法本身的属性,它是不会传给它所创建的对象的.如果你在控制台敲$().fn的话输出的结果会是undefined.接下来看看原型对象里面有些

jQuery源码学习笔记：总体架构

1.1.自调用匿名函数: (function( window, undefined ) { // jquery code })(window); 这是一个自调用匿名函数,第一个括号内是一个匿名函数,第二个括号立即执行,传参是window. 1.为什么有自调用匿名函数? 通过定义匿名函数,创建了一个"私有"空间,jQuery必须保证创建的变量不能和导入它的程序发生冲突. 2.为什么传入window? 传入window使得window由全局变量变成局部变量,jQuery访问window时,

jQuery源码学习笔记：构造jQuery对象

3.1源码结构: (function( window, undefined ) { var jQuery = (function() { // 构建jQuery对象 var jQuery = function( selector, context ) { return new jQuery.fn.init( selector, context, rootjQuery ); } // jQuery对象原型 jQuery.fn = jQuery.prototype = { constructor:

jQuery源码学习笔记：扩展工具函数

// 扩展工具函数 jQuery.extend({ // http://www.w3school.com.cn/jquery/core_noconflict.asp // 释放$的 jQuery 控制权 // 许多 JavaScript 库使用 $ 作为函数或变量名,jQuery 也一样. // 在 jQuery 中,$ 仅仅是 jQuery 的别名,因此即使不使用 $ 也能保证所有功能性. // 假如我们需要使用 jQuery 之外的另一 JavaScript 库,我们可以通过调用 $.noC

jQuery源码学习笔记五 六 七 八 转

jQuery源码学习笔记五 六 七 八 转 Js代码   <p>在正式深入jQuery的核心功能选择器之前,还有一些方法,基本都是数组方法,用于遴选更具体的需求,如获得某个元素的所有祖选元素啦,等等.接着是其缓存机制data.</p> <pre class="brush:javascript;gutter:false;toolbar:false"> //@author  司徒正美|なさみ|cheng http://www.cnblogs.com/ru

jQuery源码学习笔记（1）

在慕课网上学习jQuery源码,做一些笔记小研究. 第1章 节点遍历 第2章 文档处理 第3章 元素操作 第4章 样式操作 第5章 事件体系 第6章 数据交互 第7章 动画引擎 首先瞅瞅目录,大概可以了解一下这个是怎么讲的QAQ. 今天学习的是节点遍历. 遍历的对象主要是:1 祖先 2 同胞兄弟 3 后代 4 过滤 我们先看祖先. .parent()方法允许我们能够在DOM树中搜索到这些元素的父级元素,从有序的向上匹配元素,并根据匹配的元素创建一个新的 jQuery 对象. .parents()

2016年11月2日——jQuery源码学习笔记

1.jQuery()函数,即$().有四种不同的调用方式. (1)传递CSS选择器(字符串)给$()方法,返回当前文档中匹配该选择器的元素集.可选第二个参数,一个元素或jQuery对象,定义元素查询的起始点,称为上下文(context),这时返回的是该特定元素或元素集的子元素中匹配选择器的部分. (2)传递一个Element.Document或Window对象给$()方法,$()将它们封装为jQuery对象并返回,这样就可以使用jQuery方法来操作这些元素而不用使用原生DOM方法 (3)传递H

菜鸟的jQuery源码学习笔记（三）

1 each: function(callback, args) { 2 return jQuery.each(this, callback, args); 3 }, each:这个调用了jQuery.each方法,来遍历当前集合.我们先来看看jQuery.each方法: //args是一个数组 each: function(obj, callback, args) { var value, i = 0, length = obj.length, isArray = isArraylike(ob

jquery源码学习

jQuery 源码学习是对js的能力提升很有帮助的一个方法,废话不说,我们来开始学习啦 我们学习的源码是jquery-2.0.3已经不支持IE6,7,8了,因为可以少学很多hack和兼容的方法. jquery-2.0.3的代码结构如下 首先最外层为一个闭包, 代码执行的最后一句为window.$ = window.jquery = jquery 让闭包中的变量暴露倒全局中. 传参传入window是为了便于压缩 传入undefined是为了undifined被修改,他是window的属性,可以被修