javascript 对象封装的常用方式

常规封装

function Person (name,age,sex){
    this.name = name;
    this.age = age;
    this.sex = sex;
}

Pserson.prototype = {
    constructor:Person,
    sayHello:function(){
        console.log(‘hello‘);
    }
}

这种方式是比较常见的方式,比较直观,但是Person() 的职责是构造对象,如果把初始化的事情也放在里面完成,代码就会显得繁琐,如果放在一个方法里初始化会不会好点呢?

升级版 (常见)

function Person (info){
    this._init_(info);
}

Pserson.prototype = {
    constructor : Person,
    _init_ : function(info) {
        this.name = info.name;
        this.age = info.age;
        this.sex = info.sex;
    }
    sayHello:function(){
        console.log(‘hello‘);
    }
}

可是,说到这里就发现,name,age,sex 并没有在Person里面申明,哪来的呢???

new 的执行原理

new 的执行过程可以用下面一个函数来代替

    var myNew = function(constructor, args) {
        var o = {};
        o.__proto__ = constructor.prototype;
        var res = constructor.apply(o, args);
        var type = typeof res;
        if ([‘string‘, ‘number‘, ‘boolean‘, ‘null‘, ‘undefined‘].indexOf(type) !== -1) {
            return o;
        }
        return res;
    }

解释:
首先通过 var o = {} 构造一个空对象.
然后将 构造函数的原型属性prototype赋值给o 的原型对象__proto__ 。这样,在执行 this.init(info); 这句话的时候,对象 o 就可以在其原型对象中查找_init_ 方法。(原型链)。
之后这句话 就是精髓了。

var res = constructor.apply(o,args);

以o为上下文调用函数,同时将参数作为数组传递。那么,

 this._init_(info);

这句话就会被 o 执行,
函数

    _init_ : function(info) {
        this.name = info.name;
        this.age = info.age;
        this.sex = info.sex;
    }

以 o 为上下文调用,o也将拥有自己的 name,age,sex 属性。

如果在构造函数中,return 复合类型,包括对象,函数,和正则表达式,那么就会直接返回这个对象,否则,返回 o 。

 var type = typeof res;
    if([‘string‘,‘number‘,‘boolean‘,‘null‘,‘undefined‘].indexOf(type) !== -1){
        return o;
    }
    return res;

测试一下


    function Person(name) {
        this.name = name;
    }
    Person.prototype.sayHello = function() {
        console.log(this.name);
    }
    var o1 = myNew(Person, [‘pawn‘]);
    console.log(o1);
    o1.sayHello();

OK 吧

类jQuery 封装

这种方式是我从 jQuery 那里学来的。

jQuery 对象具有很强的集成性,可以作为函数调用,也可以做为对象调用,当作为函数调用的时候,她可以无需 new 而返回它的一个实例,很方便。

先看代码

var Person = function(info){
    return new Person.prototype.init(info);
}

Person.prototype = {
    constructor: Person,
    init:function(){
        this.name = info.name.
    }
}
Person.prototype.init.prototype = Person.prototype;

这种封装方式非常巧妙。
将对象的构造操作放在函数的里面,而自己充当一个工厂。
不断调用 prototype 并不是一个直观的做法,于是

var Person = function(info){
    return new Person.fn.init(info);
}

Person.fn = Person.prototype = {
    constructor: Person,
    init:function(){
        this.name = info.name;
        this.sayHello = function(){
            this.makeArray();
        }
    }
    makeArray:function(){
        console.log(this.name);
    }
}
// 这句话的作用
// 虽然把makeArray 等常用方法挂载到 Person.prorotype 下面,但还是会被 init 这个实例使用.
Person.fn.init.prototype = Person.fn;

最后用 闭包 封装起来

    var Person = (function(window) {
        var Person = function(name) {
            return new Person.fn.init(name);
        }

        Person.fn = Person.prototype = {
            constructor: Person,
            init: function(name) {
                this.name = name;
                this.sayHello = function() {
                    this.makeArray();
                }
            },
            makeArray: function() {
                console.log(this.name);
            }
        }

        Person.fn.init.prototype = Person.fn;

        return Person;
    })();

测试一下

    var p = Person(‘pawn‘);
    console.log(p);
    p.sayHello();

object.create();

最后js也提供了一种构造对象的方式,object.create(); 可以传递一个对象Person,构造一个p,并且使p 继承Person.

    var Person = {
        name: ‘pawn‘,
        sayHello: function() {
            console.log(this.name);
        }
    }
    var p = Object.create(Person);
    console.log(p);
    p.sayHello();

结果

可以看到,对象Person的属性成为了p的原型属性,也就是说 p 原型继承自 Person !

我们可以实现一个 Object.create()


Object.create = function(prototype){
   function Func(){};
   Func.prototype = prototype;
   var o = new Func();
   return o;
}

在这里,我们将 Person 作为 构造函数的 原型属性,就可以构造出 以Person 为原型对象的对象.

测试一下

Object.create = function(prototype){

  function Func(){};

  Func.prototype = prototype;

  var o = new Func();

  return o;

}

在这里,我们将 Person 作为 构造函数的 原型属性,就可以构造出 以Person 为原型对象的对象.

测试一下

转发自: http://www.cnblogs.com/likeFlyingFish/p/6175734.html

时间: 2024-11-10 15:38:45

javascript 对象封装的常用方式的相关文章

javascript对象封装的常用方式

JS是门面向对象语言,其对象是用prototype属性来模拟的,下面例举下常用的封装方式. 常规封装 1 function Person(name, age, sex){ 2 this.name = name; 3 this.age = age; 4 this.sex = sex; 5 } 6 7 Person.prototype = { 8 constructor: Person, 9 sayHello: function(){ 10 console.log("hello"); 11

三种简单写法教你Javascript对象封装

这里的内容没有太多深入的东西,更多的内容请移步麦子学院. Javascript在HTML中变得越来越强大, HTML5中的WebGL等.但是我们书写Javascript的时候往往很随意,使用对象的封装是极好的.这里介绍Javascipt三种创建对象的方法.  使用关键字new创建对象 Js代码   1. 2.   function Person(name, age) { 3.     this.name = name; 4.     this.age = age; 5.   } 6.   var

Javascript——对象字面量常用写法以及规则

对象字面量 对象字面值是封闭在花括号对({})中的一个对象的零个或多个"属性名-值"对的(元素)列表.你不能在一条语句的开头就使用对象字面值,这将导致错误或产生超出预料的行为, 因为此时左花括号({)会被认为是一个语句块的起始符号. 以下是一个对象字面值的例子.对象car的第一个元素(译注:即一个属性/值对)定义了属性myCar:第二个元素,属性getCar,引用了一个函数(即CarTypes("Honda")):第三个元素,属性special,使用了一个已有的变量

创建javascript对象的几种方式

ECMAScript提供的对象有:String.Date.Array.Boolean.Math.Number.RegExp.Global 程序中需要用到很多自定义的js对象 1.直接创建 var obj = new Object(); obj.username = "jinxiao"; obj.age = 26; 可替代该方法的是:var obj = {username:"jinxiao",age:26}; 2.构造函数创建 function Obj(usernam

0145 JavaScript创建对象的三种方式 之 字面量:创建,访问对象的属性&方法,变量、属性、函数、方法总结

在 JavaScript 中,现阶段我们可以采用三种方式创建对象(object): 利用字面量创建对象 利用 new Object 创建对象 利用构造函数创建对象 5.2.1 利用字面量创建对象 5.2.1.1 创建 使用对象字面量创建对象:{ }. 就是花括号 { } 里面包含了表达这个具体事物(对象)的属性和方法: { } 里面采取键值对的形式表示 键:相当于属性名 值:相当于属性值,可以是任意类型的值(数字类型.字符串类型.布尔类型,函数类型等) 代码如下: var star = { na

JavaScript学习12 JS中定义对象的几种方式【转】

avaScript学习12 JS中定义对象的几种方式 转自:  http://www.cnblogs.com/mengdd/p/3697255.html JavaScript中没有类的概念,只有对象. 在JavaScript中定义对象可以采用以下几种方式: 1.基于已有对象扩充其属性和方法 2.工厂方式 3.构造函数方式 4.原型("prototype")方式 5.动态原型方式 一.基于已有对象扩充其属性和方法 <script type="text/javascript

javascript中对象两种创建方式

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Document</title> </head> <body> <script type="text/javascript"> // 创建对象的两种方式: // 1 对象字面量 // 2 new Obj

spring -mvc 将对象封装json返回时删除掉对象中的属性注解方式

spring -mvc 将对象封装json返回时删除掉对象中的属性注解方式 在类名,接口头上注解使用在 @JsonIgnoreProperties(value={"comid"}) //希望动态过滤掉的属性 例 @JsonIgnoreProperties(value={"comid"}) public interface 接口名称{ } @JsonIgnoreProperties(value={"comid"}) public class 类名{

JavaScript学习12 JS中定义对象的几种方式

JavaScript学习12 JS中定义对象的几种方式 JavaScript中没有类的概念,只有对象. 在JavaScript中定义对象可以采用以下几种方式: 1.基于已有对象扩充其属性和方法 2.工厂方式 3.构造函数方式 4.原型("prototype")方式 5.动态原型方式 一.基于已有对象扩充其属性和方法 <script type="text/javascript"> var object = new Object(); object.name