对象
创建对象
- 方式1-字面量表示，推荐使用
var a = {};
- 方式2-调用构造函数,不推荐使用
var obj = new Object();
//Object是所有对象的基础
- 方式3 ，自定义方法,形式和函数一样，为了区分，构造函数命名严格按照大驼峰形式（所有单词首字母大写）
function Person(){}
var person = new Person();
Object的所有实例都有下列属性和方法,因此所有的对象都有这些属性和方法
- constructor
- hasOwnProperty(propertyName)
--->propertyName必须为字符串类型 - propertyIsEnunerable(propertyName)
--->propertyName必须为字符串类型 - isPrototypeOf(object)
- toString()
- valueOf()
- toLocaleString()
使用构造函数创建对象模式
function Person(name,age,job){
this.name=name;
this.age=age;
this.job=job;
this.sayName=function(){
console.log(this.name);
};
}
var person1 = new Person('xiaoli',29,'doctor');
var person1 = new Person('xiaozhang',38,'teacher');
console.log(person1.constructor ==Person);//true
console.log(person2.constructor ==Person);//true
构造函数原理
构造函数和普通函数的唯一区别就是名字要首字母大写和要用new实例化
要创建Person的实例，必须使用new，以这种方式调用构造函数实际上会经历4个阶段
- 创建一个新对象
- 新对象名字叫this（构造函数的作用域赋予新对象）
- 执行构造函数中的代码（为这个新对象添加属性）
this.xxx=xxx; - 返回新对象
return this
构造函数的注意点
- 不同实例的同名函数是不相等的。
- 所以创建两个完成同样任务的Function实例没有必要,况且由this对象在，根本不用再执行代码前就把函数绑定在特定对象上
- 把函数定义转移到构造函数外部来解决这个问题
function Person(name,age,job){
this.name=name;
this.age=age;
this.job=job;
this.sayName=sayName;
}
function sayName(){
console.log(this.name);
}
var person1 = new Person('xiaoli',29,'doctor');
var person1 = new Person('xiaozhang',38,'teacher');
但是这样又有新的问题。
- 在全局作用域中定义的sayName只能被某个函数调用，
- 如果需要定义很多方法，那就要定义很多全局函数，没有封装性
- 通过原型模式来解决
原型模式
我们创建的每一个函数都有prototype属性，prototype也是对象，是构造函数制造出来的对象的公共祖先，创造出来的原型可以继承原型里面的属性和方法
- JavaScript 的所有对象中都包含了一个
__proto__内部属性，这个属性所对应的就是该对象的原型 - JavaScript 的函数对象，除了原型
__proto__之外，还预置了 prototype 属性 - 当函数对象作为构造函数创建实例时，该 prototype 属性值将被作为实例对象的原型
__proto__。
- prototype是通过调用构造函数而创建的那个对象实例，的原型对象
不必再构造函数中定义对象实例的信息，而是将信息直接添加到原型对象中
function Person(){}
Person.prototype.name="lia";
Person.prototype.age=19;
Person.prototype.sayName=function(){
console.log(this.name);
};
var person1 = new Person();
var person2 = new Person();
person1.sayName();
person2.sayName();
理解原型对象
- 无论什么时候，只要创建了一个新函数，就会为该函数创建一个prototype属性。这个属性指向函数的原型对象
- 在默认情况下，所有原型对象都会自动获得一个constructor(构造函数)属性，这个属性是一个指向prototype属性所在函数的指针，
Person.prototype.constructor指向Person
- 创建一个自定义的构造函数后，其原型对象只会默认取得constructor属性，至于其他方法，都是从Object继承来的
- 构造函数初始化时，新建的this空对象其实不是空的，里面自带一条
__proto__:Person.prototype,用来指引实例函数寻找他的原型 - 在调用构造函数创建一个新实例后，该实例的内部将包含一个指针，指向该构造函数的原型对象。es5管这个指针叫[[prototype]]
- 脚本中没有标准的方法访问[[prototype]]，但Firefox,safari和chrome在每个对象上都支持一个属性proto,而在其他实现中，这个属性对脚本则是完全不可见的。
- 这个链接存在于 实例函数 和 构造函数的原型对象 之间，而不是存在于实例和构造函数之间
- 函数才有prototype，实例对象只有有proto， 而函数有的proto是因为函数是Function的实例对象
以以上 Person构造函数为例
- Person.prototype指向了原型对象，而Person.prototype.cunstructor又指向了Person,
其他注意点
- 当为对象实例添加一个属性是，这个属性会 <em>屏蔽</em> 原型对象中保存的同名属性。（添加这个同名属性只会阻止我们访问原型对象中的那个属性，而不会修改那个属性。）。即使这个属性为null
- 但是，使用delete操作符可以完全删除实例属性，从而可以可以重新访问原型中的属性
原型链-使用proto连接
任意一个函数（包括构造函数）都有一个prototype属性，指向该函数的原型对象，同样任意一个构造函数实例化的对象，都有一个proto属性
Grande.prototype.lastname="你爷爷";
function Grande(){}
var grande = new Grande();
Father.prototype=grande;
function Father (){}
var father = new Father();
Son.prototype=father;
function Son (){}
var son = new Son();
console.log(son.lastname);//你爷爷
Grande.prototype.proto--->Object.prototype
- 绝大多数对象的最终，都会继承自Object.protype
var obj = Object.create(null)
这样就没有原型了，因为null和undefined没有toString方法
- 重写toString方法
Number.prototype.toString=function(){
return "你要返回的东西";
}
方法
isPrototypeOf()
console.log(Person.prototype.isPrototypeOf(person1));//true
console.log(Person.prototype.isPrototypeOf(person2));//true
//因为Person1和Person2内部都有一个指向Person的指针，所以返回true
Object.getPrototypeOf
返回这个对象的原型
hasOwnPrototype()
一个属性是存在实例中，而不是存在于原型对象中，返回ture，继承自Object
使用for-in循环是，会循环实例和原型对象里面的属性，
确认属性是原型中的属性
function hasPrototypeProperty(object,name){
return (name in object) && !object.hasOwnPrototype(name);
}
//左边的卡确认是实例或者原型的属性，左边返回ture后，右边的如果是原型里面的属性，则整体返回true
proto和prototype的联系和区别
function a() {
//console.log("I'am a function.");
}
//b是实例化对象，a是构造函数
var b = new a();
console.log(b.__proto__ == a.prototype); //true
//一个对象的隐式原型指向构造该对象的构造函数的原型，这也保证了实例能够访问在构造函数原型中定义的属性和方法。
console.log(Object.getPrototypeOf(b) == a.prototype); //true
区别：
- 区别：prototype是构造函数访问原型对象，proto是对象实例访问原型对象。
- proto是每个对象都有的一个属性，而prototype是函数才会有的属性!!!
- 使用Object.getPrototypeOf()代替proto
注意： 函数才有prototype，实例对象只有有proto， 而函数有的proto是因为函数是Function的实例对象
继承
借用构造函数法
在构造函数中 使用Parent.call(this)的方法继承父类属性。
原理： 将子类的this使用父类的构造函数跑一遍
缺点： Parent原型链上的属性和方法并不会被子类继承
function Parent() {
this.name = 'parent'
}
function Child() {
Parent.call(this);
this.type = 'child'
}
原型链实现继承
原理：把子类的prototype（原型对象）直接设置为父类的实例
Son.prototype=new Father();
缺点：当子类对象上进行值修改时，如果是修改的原始类型的值，那么会在实例上新建这样一个值；
但如果是引用类型的话，他就会去修改子类上唯一一个父类实例里面的这个引用类型，这会影响所有子类实例
继承圣杯模式
* 继承圣杯模式
var inherit =(function(){
var F = function(){};//利用闭包，实现变量私有化
return function(Target,Origin){
F.prototype = Origin.prototype;
Target.prototype= new F();
//通过原型链连接
Targer.prototype.constructor = Target;
Target.prototype.uber = Origin.prototype;
}
}());
对象的遍历
for in
var obj= {
name:123,
age:33，
__proto__:{
lastName:deng;
}
}
for(bar i in obj){
//为了不访问到原型里面的方法
if(obj.hasOwnProperty(i)){
console,log(i+":"+obj[i]);
}
}
//i是一个字符串，如果写成obj.i,系统会转换成obj['i']，就成属性读取，，所以必须要写方括号，
//如果是系统自带的原型，没程序员设置，他就不会打印出来，。要程序员自己设置的原型，才会被打印出来
object.name与object["name"]
- 使用方括号读取对象属性（替代点方式）-比较灵活
var obj = {
name:"xiaoli"
}
obj.name;//用这种方式访问，会在后台转换成方括号模式
obj['name'];
//这两种方式，本质来说是一样的，方括号比较灵活
- 应用
var deng = {
wife1:{name:"1111"},
wife2:{name:"22222"},
wife3:{name:"3333"},
wife4:{name:"4444"},
sayWife:function(num){
console.log(deng['wife'+num]);
}
}
模拟Jquery实现链式编程
var deng = {
smoke : function(){
console.log("smoking...");
return this
},
sayHi:function(){
console.log("hello");
return this;
}
}
deng.smoke().sayHi();
