javascript_video_2

20、匿名函数的定义与调用

-------------

 - 匿名函数是指将函数的定义语句当做一个表达式来处理，既然是表达式，则可以直接赋值；

三种写法：

 -  (1)

      var fn  = function ( x , y ){return  x + y;} ;

     alert( fn(10 ,20) );

 -  (2)

 var fn  = ( function ( x , y ){return  x + y;} ) ( 10 ,20 ) ;

     alert( fn);

 -  (3)

var fn  = new  Function ( "x" ," y ","var sum = x + y; alert(sum) " ) ;

    fn(10 , 20);

  21、面向对象

-------------

【1】

function  Person(){} 

  第一种方式：Person( );把Person 当做一个普通函数来调用，对应的函数的命名规则可以使“小骆驼”写法

  第二种方式：var  p = newPerson( );把Person( )当做“类”来调用,创建一个Person类型的对象 p，此时Person() 叫做

  构造函数，对应的 构造函数的命名规则是“大骆驼”写法

 所谓构造函数，就是提供了一个生成对象的模板并描述对象的基本结构的函数。

 构造函数的特点：

               a：构造函数的函数名首字母必须大写。

　　　 　b：内部使用this对象，来指向将要生成的对象实例。

　　　　 c：使用new操作符来调用构造函数，并返回对象实例。

【2】有参数的构造函数

function Person(name,age){

this.name = name;

this.age = age;

this.say = function (){

alert("我是 "+this.name+“ ”+“我今年”+this.age+“岁啦！”);

     }

}

var p1 = new Person("小米","10");

p1.say(); // 调用函数中的匿名函数，而Person 并没有say（）这个属性，这个属性是，Person的实例才拥有的

p1.name; //同样通过 “ . ”的方式直接调用函数中的变量， 如果name 没有注册给 this ,则 p1 访问不到

p1(["name"]); //或者通过键值对访问

for (var key in p1) { // 对象也可以看做是键值对集合，所以对象可以进行遍历

   alert(key+" "+p1[key]); }

【3】 this

this 表示该类型的对象, this关键字总是指向正执行的作用域的所有者，指向生成对象的实例

【4】instanceof

判断对象的类型 ，验证原型对象与实例对象之间的关系:

alert(p1 instanceof Person); // true;

【5】对象字面量

通过对象字面量直接创建对象

var p2 = { name : "小";

                age : "10";

               say:function() {

              alert(this.name+this.age);

                           }

                }

                p2.say(); // 小10

【6】 prototype prototype 特点：

     a:   ptototype 用于解决构造函数的对象实例之间无法共享属性的特点。

    b:    js中每个数据类型都是对象（除了null和undefined），而每个对象都继承自另外一个对象，后者称为

       “原型”（prototype）对象，只有null没有自己的原型对象。

   c:　 prototype 上的所有属性和方法，都会被对象实例所共享。

   d:    构每个构造函数（函数对象）都有一个prototype属性，指向prototype对象，该对象除了有我们创建的 方法，还有一个 字段“__proto__”,指向它的原型对象，然后它的原型对象又指向它的原型对象，这样一层一层的往上；由于原型对象本身对于对象实例来说也是对象，它也有自己的原型，所以形成了一条原型链（prototype chain）

   e:    当创建构造函数的实例时，每个实例都会有这么一个字段“__proto__”,指向的是prototype原型对象，这样不同的实例就可以共用prototype中的属性和方法，优先在实例中找，如果实例中没,再找它的原型对象;

   f:      在原型对象中的属性和方法是只读的，不能改;

   

function Person(name,age){

     this.name = name;

       }

//在Person 原型对象中添加属性和方法

Person.ptototype.email = "dfadfa@qq.com";

Person.ptototype.say = function(){

      alert(this.name+this.email);

}

// 调用

var  p3 = new Person("啦啦");

p3.say();

var  p4 = new Person（"囖咯"）;

p4.say();

// 这里的修改，只会影响p4 ,不会改变p3 ,相当于在p4 实例下增加 email 属性，原型对象中email 并没有改变

p4.email = "jikjoihv。com"; 

【7】继承
    a:    在js 中并没有类的概念，继承是通过对象和对象来实现的
        function Student(c_name){
                    this.c_name = c_name;
             }
         var p5 = new Person()
 //学生有自己的属性，Person中的属性时人所共有的，学生应该继承Person,通过原型对象来继承

         Student.prototype = p5;

var s1 = new Student("6");

s1.name = "小王"；

// 继承的写法： super call
——1. js原型（prototype）实现继承

——2. 构造函数实现继承
function  Child(name,age,gender){ 
        this.tempMethod = Person; 
        this.tempMethod(name,age); 
        this.gender = gender; 
        this.sayChild=function(){ 
           alert("Child:"+this.name+"age:"+this.age+"gender:"+this.gender); 
        } 
    }
var p6 = new Person("江剑臣","10"); 
   p6.say(); //输出：“姓名:江剑臣” 
    var child=new Child("李鸣",24,"女");  
    child.sayChild(); // 输出，李鸣，24 女

——3. call , apply实现继承

  funtction Person(name,age){

        this.name = name;

        this.age = age;

        this.say = function  (){

        alert("name:"+this.name);   

        }

}

   //call方式 
    function student(name){        

             Person.call(this,name); 

    } 
    //apply方式 
    function teacher(name，age){ 
        Person.apply(this,[name,age]);       // Person.apply(this,arguments); //跟上句一样的效果，arguments 
    } 
    //call与aplly的异同： 
    //1. 第一个参数this都一样,指当前对象 
    //2. 第二个参数不一样：call的是一个个的参数列表；apply的是一个数组（arguments也可以）

var p7=new Person(" 楼",25 );
    p7.say();  // 输出：楼
    var stu=new student("曹玉");//输出：“曹玉” 
    stu.say(); 
    var tea=new teacher("秦杰",16);//输出：“秦杰” 
    tea.say()
22 、 闭包
【1】概念：闭包是将函数内部和函数外部连接起来的一座桥梁

  由于在Javascript语言中，只有函数内部的子函数才能读取局部变量，因此可以把闭包简单理解成

"定义在一个函数内部的函数"。

【2】实现："链式作用域" 结构（chain scope），子对象会一级一级地向上寻找所有父对象的变量。

所以，父对象的所有变量，对子对象都是可见的，反之则不成立。

【3】特点：

——1. 由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题，在IE中可能导致内存泄露。解决方法是，在退出函数之前，将不使用的局部变量全部删除。

——2. 闭包会在父函数外部，改变父函数内部变量的值。

——3. 父对象的所有变量，子对象都是可见的.

23、this

在一个函数内部，this 就表示的是哪一个对象，取决于当前函数是哪一个对象的函数；

每一个函数内部都有this, 函数的 this与 函数内部的 this 不一定相同；

var  name = "window 中的 ";

function Person(){

    this.name = "Person 中的";

    this.getName = function ( ){

       alert(this.name);   // 输出是 Person 中的, 因为这是取出 this中的 name，而this 注册给Person 对象

       return function (){  return this.name;   } ;  // 输出是 window 中的 ,因为该方法并没有注册给任何对象，默认是window

    // 要想使上面的输出也是Person ,可以 写成： var that = this;  return function (){  return that.name;   } ;

    }

}

  var p = new Person ();

 alert(p.getName()());