object

JS 中的对象

JS 中的对象是一系列无序key: value的集合

example：

var obj = { a: 1, b: 2}

var person = {
    name: 'kevin',
    sayName: function(){
        console.log('My name is kevin')
    }
}

对象的使用：

我们可以通过对象.属性的方式来获取属性的值
可以用for(var aa in person){ console.log(aa) }来获取对象的属性

但假设我们定义一个函数

function sum(a, b){
    return a + b
}

console.log(sum.name)   // => sum
console.log(sum.length)  //2

会发现，函数sum也有很多属性，从这个角度看，函数也是 js 对象的一种

OOP (Object-oriented programming，面向对象编程)

面向对象的思路来源于生活，这里就以开车为例，开车时司机拧钥匙、挂挡、踩油门，车开始启动

面向过程的写法：

拧钥匙()
联通电路()
火花塞点火()
活塞运动()
内燃机启动()
司机挂挡()
变速箱工作()
踩油门()
活塞运动加快()
刹车解除()
连杆传输动力到轮子()
轮子运转()

面向对象的思路：一次性实现所有的流程
面向过程的写法：

Car.拧钥匙()
Car.挂挡()
Car.踩油门()

面向对象的思路：把某个功能看成一个整体（对象），通过调用对象的某个方法来启动功能。在用的时候不去考虑这个对象内部的实现细节，在去实现这个对象细节的时候不用管谁在调用

面向对象的写法不仅更简洁，而且更可控。假设有两个车要启动，用面向过程的写法代码无法维护，而面向对象只需要

Car1.拧钥匙()
Car1.挂挡()
Car1.踩油门() 
Car2.拧钥匙()
Car2.挂挡()
Car2.踩油门()

构造对象

我们可以抛开类，使用字面量来构造一个对象

var obj1 = {
    nick: 'Byron',
    age: 20,
    printName: function(){
        console.log(obj1.nick)
    }
}
var obj2 = {
    nick: 'Casper',
    age: 25,
    printName: function(){
        console.log(obj2.nick)
    }
}

这样构造的问题：

两个对象相似，每次构建一个对象都要复制一遍代码
如果想个性化，只能通过手工赋值，使用者必需了解对象详细

所以这就是我们不能抛开类的重要原因，也是类的作用

使用函数做自动化

function createObj(nick, age){
  var obj = {
      nick: nick,
      age: age,
      printName: function(){
            console.log(this.nick)
        }
  }
  return obj
}

var obj3 = createObj('Byron', 30)
obj3.printName()

我们可以通过创建一个函数来实现自动创建对象的过程，至于个性化通过参数实现，使用者不必关注细节，只需要传入指定参数即可

问题：

这种方法解决了构造过程复杂，需要了解细节的问题，但是构造出来的对象类型都是Object，没有识别度

new

new 运算符接收一个函数 F 及其参数：new F(arguments...)。这一过程分为三步

创建类的实例。这步是把一个空的对象的proto属性设置为F.prototype
初始化实例。函数 F 被传入参数并调用，关键字this被设定为该实例
返回实例

function Person(name, age) {
    this.name = name
    this.age = age
    this.sayName = function() {
        console.log(this.name)
    }
}
var p = new Person('hunger', 3)
p.sayName()

以上代码的执行过程如下：

执行 new Person
i. 创建一个空对象{}，假设名字是 tmpObj
ii. 执行 Person 函数，执行过程中对 this 操作就是对 tmpObj 进行操作
iii. 函数执行完后返回刚刚创建的 tmpObj
把 tmpObj 赋值给 p (p也指向同一个对象)

另一种理解方式：

function Person(name, age) {
    // var this = {}
    this.name = name
    this.age = age
    this.sayName = function() {
        console.log(this.name)
    }
    // return this
}
var p = new Person('hunger', 3)
p.sayName()

注意：这里不需要return，否则可能影响传出对象的值（假设你return {a: 1, b: 2}，则对象p就是return的东西）

instanceof

instanceof是一个操作符，可以判断对象是否为某个类型的实例

p1 instanceof Person  // true
p1 instanceof Object  // true

instanceof判断的是对象

1 instanceof Number  // false

问题：
构造函数在解决了上面所有问题，同时为实例带来了类型，但可以注意到每个实例printName方法实际上作用一样，但是每个实例要重复一遍，大量对象存在的时候是浪费内存

ptototype

类的prototype对象可以作为一个公共容器，供所有实例访问

记住原型图 课件（构造对象）

function Person(name, age) {
    this.name = name
    this.age = age
    this.sayName = function() {
        console.log(this.name)
    }
    
}
var p1 = new Person('hello', 3)
var p2 = new Person('world', 5)

Person.prototype.sayAge = function(){
  console.log('say age...')
}
console.log(Person.prototype.sayAge())

console.log(p1)
//console.log(p1.__proto__.sayAge())
console.log(p1.sayAge())
console.log(p2)
//console.log(p2.__proto__.sayAge())
console.log(p2.sayAge())
// __proto__ 可以省略，默认会从这里面去找

构造函数

任何函数使用new表达式就是构造函数
每个函数都自动添加一个名称为prototype属性，这是一个对象
每个对象都有一个内部属性 __proto__(规范中没有指定这个名称，但是浏览器都这么实现的) 指向其类型的prototype属性，类的实例也是对象，其__proto__属性指向“类”的prototype

prototype

通过图示我们可以看出一些端倪，实例可以通过__prop__访问到其类型的prototype属性，这就意味着类的prototype对象可以作为一个公共容器，供所有实例访问

抽象重复

我们刚才的问题可以通过这个手段解决

所有实例都会通过原型链引用到类型的prototype
prototype相当于特定类型所有实例都可以访问到的一个公共容器
重复的东西移动到公共容器里放一份就可以了

看下代码

function Person(nick, age){
    this.nick = nick;
    this.age = age;
}
Person.prototype.sayName = function(){
    console.log(this.nick);
}

var p1 = new Person();
p1.sayName();

慢慢的这就是一个靠谱的构建对象的方式了

参考链接

wiki-Object-oriented programming