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对象可以作为一个公共容器，供所有实例访问
抽象重复
我们刚才的问题可以通过这个手段解决
所有实例都会通过原型链引用到类型的
prototypeprototype相当于特定类型所有实例都可以访问到的一个公共容器重复的东西移动到公共容器里放一份就可以了
看下代码
function Person(nick, age){
this.nick = nick;
this.age = age;
}
Person.prototype.sayName = function(){
console.log(this.nick);
}
var p1 = new Person();
p1.sayName();
慢慢的这就是一个靠谱的构建对象的方式了
