JS 基本数据类型

Undefined、Null、Boolean、String、Number

ES6 新增 Symbol，表示独一无二的值，凡是属性名属于 Symbol 类型，就都是独一无二的，可以保证不会与其他属性名产生冲突

Null 和 Undefined 的区别：

• null：表示一个对象是“没有值”的值，即值为“空”；typeof 为 object

• undefined：表示一个声明但没有初始化的变量；typeof 为 undefined

JS 的数据类型、及内存位置

栈：原始数据类型（Undefined、Null、Boolean、Number、String）

堆：引用数据类型（对象、数组、函数）

JS 内置对象

数据封装对象：Object、Array、Boolean、Number、String、Map、WeakMap、Set、WeakSet

其他对象：Function、Arguments、Math、Date、RegExp、Error

Object 是 JS 中所有对象的父对象

原型、原型链

每个对象都会在其内部初始化一个属性，就是 prototype (原型)

当我们访问一个对象的属性时， 如果这个对象内部不存在这个属性，那么他就会去 prototype 里找这个属性，这个prototype 又会有自己的 prototype , 于是就这样一直找下去，这样的一个链型结构就是原型链

let obj = Object.create(null)

这种方式创建的对象没有原型。使用的情景：

• 你需要一个非常干净且高度可定制的对象当作数据字典的时候；

• 想节省 hasOwnProperty 带来的一丢丢性能损失并且可以偷懒少些一点代码的时候

JS 创建对象的方式

工厂模式

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

var person = createPerson('OreChou', 23);

所创建的对象的原型都为 Object 。这种方式无法解决对象识别问题，即使用 instance 和 typeof 的时候，其值为 Object。

构造函数模式

// 此处的函数名首字母为大写，约定构造函数的首字母为大写
function Person(name, age) {
  this.name = name;
  this.age = age;
  // 方法会在每个实例上重新创建一遍
  this.sayName = function() {
    alert(this.name);
  }
  // 上面的代码与下面的等价
  // 相当于每次新建实例，都会创建一个函数，函数也是对象。所以有性能的开销
  this.sayAge = new Function("alert(this.age)");
}

var person = new Person('OreChou', 23);
person.constructor === Person // true
person instanceof Person // true

调用构造函数会经历以下步骤：

• 以该函数为原型创建一个新对象

• 将函数的 prototype 赋值给对象的 proto 属性

• 将函数的作用域赋给新对象（即 this 指向了该新对象），执行函数中的代码

• 若有 return（且不为基础类型）则返回 return 的内容，没有则返回新对象

缺点：

• 每个方法都会在实例上重新创建一遍（解决：把这种方法改成全局的，或者使用原型）

构造函数 + 原型模式

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

Person.prototype = {
  // 这里指定了构造函数为 Person
  // 若不指定，则 Person 的原型为 Object
  constructor: Person,
  sayName: function() {
    alert(this.name);
  }
}

Person.prototype.sayAge = function() {
  alert(this.age);
}

var person = new Person('OreChou', 23);

Person.prototype.isPrototypeOf(person) // true

每一个函数都有一个 prototype 属性，属性为一个指针，指向一个对象。该对象可以包含该特定类型的所有实例共享的属性与方法。

构造函数的 prototype 属性，实例的 [[prototype]] 属性（Chrome、Safari、Firefox中每个实例对象上的属性 proto ），都指向函数的原型对象。

使用 Class

class Person {
  // 等价于 Person 的构造函数
  // 除 constructor 外没有其他方法的保留名
    constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  // 等价于 Person.prototype.sayName
  // 类中所有方法都是不可枚举的
  sayName() {
        console.log(this.name);
  }
}

// 上面和下面两种方法等价

let Person = (function() {
  'use strict';
  const Person = function(name, age) {
    if (typeof new.target === 'undefined') {
      throw new Error('必须通过关键字 new 调用函数');
    }
    this.name = name;
    this.age = age;
  }
  Object.defineProperty(Person.prototype, 'sayName', {
    value: function() {
      if (typeof new.target !== 'undefined') {
        throw new Error('不可以使用关键字 new 调用该方法');
      }
            console.log(this.name);
    },
    // 当且仅当该属性的 enumerable 为 true 时，该属性才能够出现在对象的枚举属性中。默认为 false。
    enumerable: false,
    // 当且仅当该属性的 writable 为 true 时，value 才能被赋值运算符改变。默认为 false。
    writable: true,
    // 当且仅当该属性的 configurable 为 true 时，该属性描述符才能够被改变，同时该属性也能从对应的对象上被删除。默认为 false。
    configurable: true
  })
  return Person;
})

使用类的注意事项：

• 类声明与 let 类似，不能被提升

• 类中的所有代码自动运行在严格模式下

• 类中所有方法都是不可枚举的

• 类中有一个名为 constructor 的方法，且只能使用 new 调用，否则报错

• 类中其他的方法不能使用 new 调用，否则报错

JS 实现继承的方式

假设有如下的一个 Animal 类

function Animal() {
  this.species = '动物'
}

构造函数继承

function Person(name, age) {
  // 使用call或apply方法，将父对象的构造函数绑定在子对象上
  Animal.apply(this, arguments);
  this.name = name;
  this.age = age;
}

原型继承

function Person(name, age) {
  this.name = name;
  this.age = age;
}
// （1）
// 将 Person 的原型对象指向 Animal 的实例 （这种方式因为新增了 Animal 的一个实例，所以消耗了内存）
// 此时的 Person.prototype.constructor 指向了 Person
Person.prototype = new Animal();
// 这样导致了继承链混乱，所以将 constructor 改回 Person
Person.prototype.constructor = Person;

// (2)
// 这种方式不会新增内存，但是对 Person 原型的修改会反应到 Aniaml 的原型上
Person.prototype = Animal.prototype

// (3)
// 利用空对象作为中介。F 是空对象，几乎不占据内存，且修改 Person 的原型，不会反应到 Animal 的原型上
var nullObj = function() {};
F.prototype = Animal.prototype;
Person.prototype = new F();
Person.prototype.constructor = Person;

拷贝继承

实现一个拷贝函数，将父对象的所有属性方法拷贝到子对象

// 浅拷贝的实现
function shallowCopy(p) {
  var c = {};
  for (var i in p) {
    // js 的对象是一个指针，指向了该对象在内存中的地址
    // 所以这里如果属性是一个对象的话，其实只拷贝了该对象的地址
    // 那么拷贝后的对象对该属性的修改，会影响到原对象
    c[i] = p[i];
  }
  return c;
}

// 深拷贝的一个简单实现
function deepCopy(p) {
  // 确定 p 为对象还是数组
  var c = Array.isArray(p) ? [] : {};
  if (p && typeof p === 'object') {
    for (var i in p) {
      // 如果属性是对象，则递归拷贝
      if (p[i] && typeof p[i] === 'object') {
          c[i] = deepCopy(p[i]);
      } else {
        c[i] = p[i];
      }
    }
  }
  return c;
}