引入
我们在编写和维护复杂或庞大的代码时,必须使用模块化策略。目前,业界的主流做法就是采用"面向对象编程"。我们把模块中的属性及方法封装起来,日后使用将非常方便,也可以避免繁琐重复的工作。
然而,Javascript与其他语言(如 java)不同,它不支持"类"(class),导致传统的面向对象编程方法无法直接使用。本文总结了Javascript中实现面向对象类的4种方式以及它们的使用方法,供大家学习参考。
1. 传统面向对象
在 ES6中,class
(类) 作为对象的模板被引入,可以通过 class
关键字定义类。它可以被看作一个语法糖,让对象原型的写法更加清晰、更像面向对象编程的语法。而其本质就是一个函数,就是由ES5里面的语法封装的。
类中所有函数均不需要写function,且多个函数方法之间不需要添加符号分隔;
class Person {
constructor(name, sex, age) {
this.name = name;
this.sex = sex;
this.age = age;
}
// 类中添加方法
Say() {
console.log('我叫' + this.name, '性别' + this.sex, '今年' + this.age);
}
}
// 创建实例对象
var xm = new Person('小明', '男', 19);
// 通过实例调用方法
xm.Say(); // 我叫小明 性别男 今年19
继承:
class Student extends Person {
// 子类继承父类
}
2. 构造函数和原型式面向对象
这是js中经典的方法。它用构造函数模拟"类",在其内部用this关键字指代实例对象。
先编写一个构造函数
function Cat(name, color) {
// 添加属性
this.name = name;
this.color= color;
}
增加类的方法,通常在构造函数的prototype
对象之上。所有对象的实例可以共享这些方法,相比直接在构造函数上增加方法,在原型prototype
上增加方法可以减少内存空间的使用。
Cat.prototype.sayHi = function() {
console.log('Hi,我是'+this.name);
}
使用new关键字,生成实例对象。
var miao=new Cat('小猫','白色');
console.log(miao.color); //白色
miao.sayHi(); //Hi,我是小猫
因为JS中没有class,所有在这个方法中,我们用到的构造函数是一种特殊的函数,主要用于初始化对象,即为对象成员变量赋初始值,它总与new一起使用,他们可把对象中一些公共的属性和方法抽取出来,然后封装到这个函数里面;
另外,注意上面代码的this
,被作为类使用的函数里面的this
总是指向实例化对象,这里也就是miao
。
在JS中,使用构造函数时要注意以下两点:
- 构造函数用于创建某一类对象,其首字母要大写;
- 构造函数要和new一起使用才有意义
new 在执行时会做四件事情:
- 在内存中创建一个新的空对象;
- 让this指向这个新的对象;
- 执行构造函数里面的代码,给这个新对象添加属性和方法;
- 返回这个新对象(所以构造函数里面不需要return)
下面来介绍一些这些对象的属性和方法
2.1 prototype
JavaScript 中的对象有一个特殊的 Prototype
内置属性,其实就是对于其他对象的引用。
当我们通过 new
来生成一个类的对象时,prototype对象的属性就会成为实例化对象的属性。
在上面的代码中,我们在
cat.prototype
上挂载了一个sayHi()
方法,在实例化的时候该方法会给到实例对象,也就是它的所有实例共享方法。
2.2__proto__
对象都会有一个属性__proto__
指向构造函数的prototype
原型对象,之所以我们对象可使用构造函数prototype
原型对象的属性和方法,就是因为对象有__proto__
原型的存在。
__proto__
对象原型和原型对象prototype
是等价的__proto__
对象原型的意义就在于为对象的查找机制提供一个方向,或者说一条路线,但是它是一个非标准属性,因此实际开发中,不可以使用这个属性,它只是内部指向原型对象prototype
当我们查找一个对象的属性或方法的时候,比如miao.sayHi()
,而这个对象中没有定义这个属性或方法,那么对象就会到__proto__上查找,即构造函数的prototype
上查找,因为我们把该方法定义在了Cat.prototype
上,因次就在这找到了这个方法。
那么如果在构造函数上的prototype
中也找不到这个属性或方法呢?这里对象会继续往Cat.prototype.__proto__
上找,这时候就找到了Object.prototype
了,而Object.prototype
再往上找就没有了,也就是null,这其实就是原型链。
2.3 constructor
对象原型 __proto__
和构造函数 prototype
原型对象里面都有一个属性 constructor
属性,constructor我们称为构造函数,因为它指回构造函数本身。他主要用于记录该对象引用于哪个构造函数。
如上面的miao
对象的constructor
指向它的构造函数Cat
。不过constructor
并不是实例对象本身的属性,这个属性是在原型链上找到的。
3. Object.create()式面向对象
前一种方法使用起来相对比较麻烦,为了更方便地生成对象,Javascript的国际标准ECMAScript第五版(目前通行的是第三版),提出了一个新的方法Object.create()。
用这个方法,"类"就是一个对象,不是函数。
var Cat = {
name :'miao',
makeSound:function(){
console.log('喵喵喵');
}
}
这里,直接用Object.create()生成实例,不需要用到new。
var tom = Object.create(Cat);
console.log(tom.name); // miao
tom.makeSound(); // 喵喵喵
目前,各大浏览器的最新版本(包括IE9)都部署了这个方法。如果遇到老式浏览器,可以用下面的代码自行部署。
if (!Object.create) {
Object.create = function (o) {
function F() {}
F.prototype = o;
return new F();
};
}
这种方法比上一种方法简单,但是不能实现私有属性和私有方法,实例对象之间也不能共享数据,类之间的关系不明显,对"类"的模拟也不够全面。
4. 极简面向对象方式
极简面向对象方式是荷兰程序员 Gabor de Mooij 提出的,它是一种比Object.create()更好的新方法,他称这种方法为"极简主义法"(minimalist approach)。
4.1 封装
这种方法不使用this
和prototype
,代码部署起来非常简单,这大概也是它被叫做"极简主义法"的原因。
首先,它也是用一个对象模拟"类"。在这个类里面,定义一个构造函数 createNew()
,用来生成实例。
var Cat = {
createNew: function(){
// some code here
}
};
然后,在createNew()里面,定义一个实例对象,把这个实例对象作为返回值。
var Cat = {
createNew: function(){
var cat = {};
cat.name = "大毛";
cat.makeSound = function(){ alert("喵喵喵"); };
return cat;
}
};
创建实例对象的时候,我们就可以调用它的createNew()方法,就可以得到实例对象。
var cat1 = Cat.createNew();
cat1.makeSound(); // 喵喵喵
这种方法的好处是,容易理解,结构清晰优雅,符合传统的"面向对象编程"的构造,因此可以方便地部署下面的特性。
4.2 继承
让一个类继承另一个类,实现起来很方便。只要在前者的createNew()方法中,调用后者的createNew()方法即可。
先定义一个Animal类。
var Animal = {
createNew: function(){
var animal = {};
animal.sleep = function(){ alert("睡懒觉"); };
return animal;
}
};
然后,在Cat的createNew()方法中,调用Animal的createNew()方法。
var Cat = {
createNew: function(){
var cat = Animal.createNew();
cat.name = "大毛";
cat.makeSound = function(){ alert("喵喵喵"); };
return cat;
}
};
这样得到的Cat实例,就会同时继承Cat类和Animal类。
var cat1 = Cat.createNew();
cat1.makeSound() // 喵喵喵
cat1.sleep(); // 睡懒觉
4.3 私有属性和私有方法
在createNew()方法中,只要不是定义在cat对象上的方法和属性,都是私有的。
var Cat = {
createNew: function(){
var cat = {};
var sound = "喵喵喵";
cat.makeSound = function(){ alert(sound); };
return cat;
}
};
上例的内部变量sound,外部无法读取,只有通过cat的公有方法makeSound()来读取。
var cat1 = Cat.createNew();
alert(cat1.sound); // undefined
4.4 数据共享
有时候,我们需要所有实例对象,能够读写同一项内部数据。这个时候,只要把这个内部数据,封装在类对象的里面、createNew()方法的外面即可。
var Cat = {
sound : "喵喵喵",
createNew: function(){
var cat = {};
cat.makeSound = function(){ alert(Cat.sound); };
cat.changeSound = function(x){ Cat.sound = x; };
return cat;
}
};
然后,生成两个实例对象:
var cat1 = Cat.createNew();
var cat2 = Cat.createNew();
cat1.makeSound(); // 喵喵喵
这时,如果有一个实例对象,修改了共享的数据,另一个实例对象也会受到影响。
cat2.changeSound("啦啦啦");
cat1.makeSound(); // 啦啦啦
5. 个人总结
- 在上面四种实现类(class)的方法中,最后一种极简主义方法比较容易理解且好使用,是比较推荐的。
- 在ES6中类没有变量提升,所以必须要先定义类,才能通过类实例化对象;
- 类声明不可以重复。
- 继承是指若子类有属性和方法,则用子类的属性和方法,若无,则继承父类方法;
- 类里面共有的属性和方法一定要加this使用;构造函数中的this 指向的是创建的实例对象;谁调用类中的方法,this就指向谁;