面向对象的js学习（一）对象的创建

2024-02-01 17:52:04

一、new 操作符 + Object 创建对象

1 var person = new Object();
2     person.name = "lisi";
3     person.age = 21;
4     person.family = ["lida","lier","wangwu"];
5     person.say = function(){
6         alert(this.name);
7     }

二、字面式创建对象

1 var person ={
2         name: "lisi",
3         age: 21,
4         family: ["lida","lier","wangwu"],
5         say: function(){
6             alert(this.name);
7         }
8     };

以上两种方法在使用同一接口创建多个对象时，会产生大量重复代码，为了解决此问题，工厂模式被开发。

三、工厂模式

function createPerson(name,age,family) {
    var o = new Object();
    o.name = name;
    o.age = age;
    o.family = family;
    o.say = function(){
        alert(this.name);
    }
    return o;
}

var person1 =  createPerson("lisi",21,["lida","lier","wangwu"]);   //instanceof无法判断它是谁的实例，只能判断他是对象，构造函数都可以判断出
var person2 =  createPerson("wangwu",18,["lida","lier","lisi"]);
console.log(person1 instanceof Object);                           //true

工厂模式解决了重复实例化多个对象的问题，但没有解决对象识别的问题（但是工厂模式却无从识别对象的类型，因为全部都是Object，不像Date、Array等，本例中，得到的都是o对象，对象的类型都是Object，因此出现了构造函数模式）。

四、构造函数模式

function Person(name,age,family) {
    this.name = name;
    this.age = age;
    this.family = family;
    this.say = function(){
        alert(this.name);
    }
}
var person1 = new Person("lisi",21,["lida","lier","wangwu"]);
var person2 = new Person("lisi",21,["lida","lier","lisi"]);
console.log(person1 instanceof Object); //true
console.log(person1 instanceof Person); //true
console.log(person2 instanceof Object); //true
console.log(person2 instanceof Person); //true
console.log(person1.constructor);      //constructor 属性返回对创建此对象的数组、函数的引用

构造函数就是一个普通的函数，创建方式和普通函数没有区别，不同的是构造函数习惯上首字母大写。

另外就是调用方式的不同，普通函数是直接调用，而构造函数需要使用new关键字来调用。以这种方式调用构造函数实际上会经历以下 4 个步骤：

(1) 创建一个新对象；

(2) 将构造函数的作用域赋给新对象（因此 this 就指向了这个新对象）；

(3) 执行构造函数中的代码（为这个新对象添加属性）；

(4) 返回新对象。

对比工厂模式有以下不同之处：

1、没有显式地创建对象

2、直接将属性和方法赋给了 this 对象

3、没有 return 语句

这种方法虽然好用，但也不是没有问题。例如当你需要创建100个Person,这100个对象都是单独的个体，它们之间的私有属性是不相等的，当创建100个这样的对象时，加入一个对象中有一个方法，那创建100个对象就要创建100个方法，但是这些方法都是一样的功能，就没有这个必要去浪费内存空间，于是我们这个自定义的引用类型就丝毫没有封装性可言了，因此产生了原型模式。

五、原型模式

 1 function Person() {
 2 }
 3 
 4 Person.prototype.name = "lisi";
 5 Person.prototype.age = 21;
 6 Person.prototype.family = ["lida","lier","wangwu"];
 7 Person.prototype.say = function(){
 8     alert(this.name);
 9 };
10 console.log(Person.prototype);   //Object{name: 'lisi', age: 21, family: Array[3]}
11 
12 var person1 = new Person();        //创建一个实例person1
13 console.log(person1.name);        //lisi
14 
15 var person2 = new Person();        //创建实例person2
16 person2.name = "wangwu";
17 person2.family = ["lida","lier","lisi"];
18 console.log(person2);            //Person {name: "wangwu", family: Array[3]}
19 // console.log(person2.prototype.name);         //报错
20 console.log(person2.age);              //21

原型模式的好处是所有对象实例共享它的属性和方法（即所谓的共有属性），此外还可以如代码第16,17行那样设置实例自己的属性（方法）（即所谓的私有属性），可以覆盖原型对象上的同名属性（方法）。

六、混合模式（构造函数模式+原型模式）

构造函数模式用于定义实例属性，原型模式用于定义方法和共享的属性

 1 function Person(name,age,family){
 2     this.name = name;
 3     this.age = age;
 4     this.family = family;
 5 }
 6 
 7 Person.prototype = {
 8     constructor: Person,  //每个函数都有prototype属性，指向该函数原型对象，原型对象都有constructor属性，这是一个指向prototype属性所在函数的指针
 9     say: function(){
10         alert(this.name);
11     }
12 }
13 
14 var person1 = new Person("lisi",21,["lida","lier","wangwu"]);
15 console.log(person1);
16 var person2 = new Person("wangwu",21,["lida","lier","lisi"]);
17 console.log(person2);

可以看出，混合模式共享着对相同方法的引用，又保证了每个实例有自己的私有属性。最大限度的节省了内存

码农公寓