javascript学习系列（三）JS面向对象

1、JS面向对象名词解释

（1）属性：事物的特性；

方法：事物的功能；

对象：事物的一个实例；

原型：JS函数中由prototype属性引用了一个对象，即原型对象（原型）。

 2、闭包

3、对象声明

（1）JS字面式声明对象

 （2）new 操作符后跟Object构造函数

 

（3）JS中构造方法声明对象

this代表当前对象，函数内部只能用this访问属性和方法。

（4）工厂方式声明对象

构造方法和工厂模式不同:

a.构造方式不会显式创建对象将属性赋值给this，不需要return对象

b.工厂在方法内部创建object对象 返回object对象，属性和方法都是赋给object对象

（5）原型模式声明对象

（6）混合模式声明对象（构造+原型） 

function Blog(v1, v2,v3) {
    this.v1 = v1;
    this.v2 = v2;
    this.v3 = v3;
}
Blog. prototype.方法名称= function (){
   执行代码;
}
var obj = new Blog(v1,v2,v3) ;

4、对象属性和方法遍历

当作数组处理：for in方法便利

5、对象在内存中的分布  

（1）对象指向的都是地址；

（2）不同对象之间没有关联。

6、封装：把对象内部数据和操作细节进行隐藏

不同于C++等面向对象编程语言，JS没有提供封装方法，而是通过闭包实现相应功能。

几个特征：

（1）不能访问函数内部变量；

（2）公有与私有的区别是：能否在对象外部被访问；

7、原型和原型链

原型:是利用prototype添加属性和方法（对象）

原型链: JS在创建对象(不论是普通对象还是函数对象)的时候，都有一个叫做_ proto_ 的内置属性,用于指向创建它的函数对象

             原型对象prototype。

8、JS面向对象的关键词

instanceof：用于判断变量是否是对象的实例 

var arr = new Array();  console.log(arr instanceof Array);

delete：删除对象的属性 （对方法作用不大、删除不了变量，也不能删除原型链中的属性和变量）

 call、apply：

      call :   调用一个对象的一个方法,以另一个对象替换当前对象
      apply :应用某一对象的一个方法,用另一个对象替换当前对象
 

           如图所示输出结果均为8。

   封装调用：

callee：返回正在执行的function对象（function 内容，就是指代函数本身），是arguments的一个属性（不是方法），默认值为正在执行的function对象。

     如果没有限制条件“n≤1”的话会陷入死循环。

arguments：每个函数都有Arguments对象的实例arguments。引用函数的参数（实参）可以用数组下标方式引用arguments元素。arguments.length是参数个数，arguments.callee是引用函数本身。（arguments是参数时，可以遍历）

this： 当前函数的this是在函数被调用执行的时候才确定的。其使用主要在三方面

     （1）全局对象中的this。

     （2）函数中的this：在一个函数的执行上下文中，this由该函数的调用者提供，由调用函数的方式来决定其指向。

              如果调用者被一个对象所拥有，那么在函数内部使用严格函数时，内部的this指向该对象。如果调用者函数独立调用，那么该函数内部的this则指向undefined。非严格模式下，当this指向undefined时，它会自动指向全局变量

demo1：

var a =20;
var obj = { a = 40; };
function fn(){
    console.log('fn this:', this);
    console.log('fn this.a:', this.a);
    function foo(){
         console.log('foo this.a:', this.a);    
    }
    foo();
}

fn.call(obj); 
//输出结果为：
//fn this:Object{a:40}
//40
//20   
fn(); 
//输出结果为：
//fn this:Window{}
//20
//20       

该例中无论fn的调用方式在怎样变化，但是foo一直都是独立调用，因此foo内部的this都是指向undefined的，由于是非严格模式，因此自动指向window。

demo2：

'use strict'
var a=20;
function foo(){
    var a=1;
    var obj={
        a:10,
        c:this.a+20
    }
    return obj.c;
}
console.log(window.foo());    //40,window对象调用则this指向window的a
console.log(foo());           //Uncaught TypeError:....,独立调用this指向undefined

   对象字面量的写法不会产生自己的作用域，因此obj.c上的this属性并不会指向obj，而是与foo函数内部的this一样。

demo3：牢记调用者的独立调用与被某个对象所拥有的区别。

var a = 20;
var foo(){
    a:10,
    getA:function(){
        return this.a;   
    }
}
console.log(foo.getA());    //10  getA为调用者，被foo所拥有，getA执行时this指向foo

var test = foo.getA;
console.log(test());    //20    test为调用者，是独立调用，this指向undefined。

（3）call/apply/bind显示指定this。

call函数的第一个参数是为函数内部指定this指向，后续的参数则是函数执行时所需要的参数，一个个传递。apply第一个参数与call相同，为函数内部指定this指向，而函数的参数，则以数组的形式传递，作为apply的第二个参数。