JS这门语言,曾被不少开发者视为玩乐的语言,没有厚度和技术含量的语言,但发展到现在,想必没有人敢再这么说,它能做的事越来越多,所以,这门语言看似知识结构简单,但却在代码的行与行之间藏着很多细节和玄机。

“对象”在JS中是个很有意思的东西,它随处可见,说简单可以很简单,但也可以复杂到让人头皮发麻。

简单

如何简单?

var person = new Object();

这样就可以创建一个名为“person”的对象。

但事实上,没有人会在意它的简单,因为简单的东西往往承担不了重任。

所以,我们可以从另一个角度去理解它的复杂,就是强大——每一种形式,每一个特性,都为了解决更多问题而生。

复杂

像上面那样,我们可以轻松创建一个对象,进一步,为其添加一些属性和方法:

person.name = "idea";
person.age = 18;
person.run = function(){
    alert("I can run!");
}

但其实这里我们就会发现需要写很多的“person”,代码不够简洁。

可以进行如下改进,也就是另外一种写法——“对象字面量”:

对象字面量

var person = {
    name : "idea";
    age : 18;
    run : function(){
        alert("I can run!");
    }
}

它有两个优点:简化代码、凸显封装性

如果你对js不熟,但对css预处理还算熟悉,这就像是less或者sass的嵌套。(后面更深入的东西我还会拿css类比,以帮助理解。

由此,我们可以像这样创建对象:

var person1 = {
    name : "tom";
    age : 18;
    run : function(){
        alert("I can run!");
    }
} 
var person2 = {
    name : "lili";
    age : 16;
    run : function(){
        alert("I can run!");
    }
} 
...

但其实我们好像又发现一点不那么好的地方,这样以来,我们每创建一个新的实例,都要写这么一大块的代码,显然是冗余的,于是,有人发动脑筋,想了一种办法——“工厂模式”。

工厂模式

对于工厂模式,可以这么理解,我们需要制作100个同类的产品,但不需要为每件产品都弄一个模子,而是一个模子可以反复用,生产很多很多产品。

代码就像这样:

function createPerson(name, age, job){
    var o = new object();
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName = function(){
        alert(this.name);
    }
    return o;
}

var person1 = createPerson("tom",18,"teacher");
var person2 = createPerson("lili",16,"doctor");

这段代码的亮点在最后,我们可以只用一行代码就创建一个对象,并赋予其属性值。

看起来很不错,但它存在一个难以觉察的不足——我们好像无法获知这个对象的类型。

这么说其实并不准确,每个对象都有其类型,大不了是Object,但这个结果给不了我们更有价值的东西。所以,要引荐出一个对象世界里的重要角色——“构造函数”。

构造函数

先看代码:

function Person(name, age, job){
this.name = name;
this.age = age;
this.job = job;
this.sayName = function(){
    alert(this.name);
    }
};

var person1 = new Person("tom",18,"teacher");
var person2 = new Person("lili",16,"doctor");

从面上看,这段代码跟上面那段有这么几点不同:

  • 没有显式创建对象
  • 属性和方法直接给了this
  • 没有返回
  • 创建新实例的时候,使用了“new”关键字
  • 名称首字母大写

为什么说它重要,上面我们只是创建了一个自定义的构造函数,其实js当中有很多内置的构造函数,我们会无数次地使用,比如Array、Date、String等等。

构造函数和普通函数有什么不同?好像只是首字母大写?

这么说也没错,它可以当做普通函数使用,就像这样:

Person(“tom”,18,“teacher”);

但当它被这样使用了之后,就是作为构造函数:

var person1 = new Person("tom",18,"teacher");

会经历完全不同的过程。

构造函数看起来很好用,但它还有需要改进的地方吗?往下看。

上面那段代码里,有这么一行:

this.sayName = function(){  
    alert(this.name);  
}

它会为新创建的实例新建一个sayName方法,别忘了,方法是赋予对象的函数,函数本身也是对象,所以,person1和person2是两个不同的对象实例,同样,它们的sayName方法也不同(虽然看起来是一个样子)。

这样以来,name、age和job都共用了,完成同样任务的方法却没有共用,每一个新的实例都会创建一次,显然,这不是最理想的,有办法解决吗?

我们可以做这样的尝试:

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

function sayName(){
    alert(this.name);
}

var person1 = new Person("tom",18,"teacher");
var person2 = new Person("lili",16,"doctor");

和之前的区别就在于,我们把sayName方法提到了函数体的外面,意味着,它是个全局的函数,而不属于某一个。

这个时候,你会发现一个有趣的现象,如果你写下这么一行代码:

alert(person1.sayName() == person2.sayName());

它会弹出三个值:”tom、lili、true”。

首先是里面两个分别执行,然后是外层,这说明,它们俩共用了同一个,不需要担心多余创建的那个函数实例。

终于皆大欢喜!

可是…慢着,好像哪里不对?

你可能记得,说对象字面量的时候,我们提到了封装性,你会发现,这里的sayName方法在函数体的外部,如果有很多个,就会有很多个方法散落在外部,这感觉很糟,这不是我们要的,so,必须找到一个办法解决它,就像上面做的那样。

原型模式

我们终于迎来了这个重磅的概念,关于这个概念,往往让人觉得是复杂的,抽象的,高深莫测的,其实并不,让我们来看看它具体的表现:

function Person(){

}
Person.prototype.name = "alien";
Person.prototype.age = "23";
Person.prototype.job = "teacher";
Person.prototype.sayName = function(){
    alert(this.name);
};

var person1 = new Person();

var person2 = new Person();

我们创建一个函数,但里面什么都没有。

接下来用到了“prototype”,其实每个函数都有一个prototype属性,这个属性是一个指针,所谓指针,就是建立A和B相关联的一个中介,prototype指向一个对象,这个对象,可以为我们提供所有同一类型实例能够共享的属性和方法,听起来是不是很熟悉?——它能为我们带来前面提到的所有。

但这么说似乎仍然不好理解,所以,你应该对CSS很熟悉,prototype,就相当于为所有可能的子元素,提供了一个父元素,这个父元素的所有属性,都能为子元素所共享,同时,它也不限制子元素的行为。

即,person1和person2具备Person.prototype所指对象的所有属性和方法,并且能够对其进行覆盖或者添加自身特有的新属性和方法。

看到这,我们是不是应该准备欢呼“大结局”了呢?的确,已经有不少内容了,可是,事情从来都不像我们想想的那么简单。

来思考一下,原型虽好,但它是否让我们走向了另一个极端?所有的属性和方法我们都需要共享吗?往往并不是,很多时候,对于某个属性,我们只需要私有即可,而不必共有,那么,什么样的属性私有更合适?既具备私有,又能共有的方案,存在吗?

想知道答案,且看下回分解~