javescript 的 对象

一，定义：
对象是JavaScript的一个基本数据类型，是一种复合值，它将很多值（原始值或者其他对象）聚合在一起，可通过名字(name/作为属性名)访问这些值。即属性的无序集合。

关键是name属性名可以是什么类型，以下是一些测试（不完整）：

 二，创建对象的方法

1.在{}内直接创建键值对，如上测试示例

2.使用实例化类的方法：new + Object()

let car = new Object(); //实际上，car.type的写法最终在后台自动转为car['type']执行的
car.type = 'Honda'; //等同于car['type'] = 'Honda'
car.color = 'white'; //等同于 car['color'] = 'white'
cat.seat = 5;    //等同于 cat['seat'] = 5
car.sayColor = function(){alert(this.color)} 

由于1，2两种方法在使用同一接口创建多个对象时，会产生大量的重复代码，为此，有了工厂模式

3.工厂模式--函数返回的形式

function creaeCar(type,color,seat){
  let obj = new Object();
  obj.type = type;
  obj.color = color;
  obj.seat = seat;
  obj.sayColor = function(){alert(this.color)}
  return obj;
}

let car01 = createCar('Honda','white',5);//instanceof 无法判断它是谁的实例，只能判断是对象 person1 instanceof Object //true

由于工厂模式没有解决对象的识别问题，检测到的都是object类型，不像是具体的Array,Date等类型，因此又出现了构造函数模式的创建方法。

4.构造函数模式

function Car(type,color,seat){
    this.type = type;
    this.color = color;
    this.seat = seat;
      this.sayColor = function(){alert(this.color)}
}

let car01 = Car('Honda','white',5); //此时car01 instanceof Car //true
console.log(Car.constructor);//返回创建此对象的数组，函数的引用

有上例可以看出工厂模式和构造函数模式的不同之处：

（1)没有显式地创建对象；（2）直接将属性和方法赋给了this对象；（3）没有return语句

实际上，调用构造函数的过程如下：

创建一个新对象==》将构造函数的作用域赋给新对象，即是将this指向这个新对象==》执行构造函数，为新对象添加属性==》自动返回新对象

不过构造函数也是有缺陷的，每个实例都包含不同的function实例，构造函数内的方法在做同一件事，但是实例化后却产生了不同的对象（方法sayColor是函数，函数也是对象）。

因此又产生了原型模式。

5.原型模式

function Car(){}

Car.prototype.type = 'Honda';  //相当于python中公共的类变量
Car.prototype.color = 'white';
Car.prototype.seat = 5;
Car.prototype.sayColor = function(){aleart(this.color)};

console.log(Car.prototype);//Object {type:'Honda',color:'white',seat:5}

let car01 = new Car();
console.log(car01.type);//Honda
let car02 = new Car();
car02.color = 'red';
console.log(car02);//Car {color:'red'}
console.log(car02.prototype.color); //报错的
console.log(car02.type); // 显示的将会是原型默认的‘Honda'

 原型模式的好处是所有实例共享它的属性和方法，即公共属性，可以设置私有属性值，如car02.color='red'，只是针对实例car02，将覆盖原型对象上的同名属性（方法）。

6.混合模式（构造函数+原型模式）

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

function Car(type,color,seat){
    this.type = type;
    this.color = color;
    this.seat = seat;
}

Car.prototype = {
    constructor: Car,  //每个函数都有prototype属性，指向该函数原型对象，原型对象都有constructor属性，这是一个指向prototype属性所在函数的指针
    sayColor: function(){
        alert(this.color);
    }
}

let car01 = new Car("Honda",'white',5);
console.log(car01);
let car02 = new Car("BMW",'blue',2);
console.log(car02);

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

https://www.cnblogs.com/libin-1/p/5911190.html

https://www.cnblogs.com/juggdxy/p/8245491.html