《JavaScript高级程序设计》读书笔记 14章

第一章：JavaScript是什么

 

1.起源：做一些输入有效性的验证，减轻浏览器负担

2.ECMAScript：JavaScript实现的基础，是标准，但不是javascript唯一的部分。

3.javascript组成：核心（ECMAScript）,DOM(doucument object model),BOM(brower object model)

4.ECMAScript：ECMAScript仅仅是一个描述，定义了脚本语言的所有属性，方法和对象。其他语言可以实现ECMAScript来作为功能的基准，如JavaScript

5.DOM:DOM是HTML和XML的应用程序接口(API)。通过创建树来表示文档。DOM其实不是javascript专有的，只是浏览器内部已经通过ESMAScript实现了DOM，成为了javascript的重要组成部分

6.BOM：可以对浏览器窗口进行访问和操作。

 

第二章：ESMAScript基础

1.语法

    区分大小写，变量都是弱类型（var），建议每行结尾有分号。//单行注释  多行注释。括号标明代码块

2.变量

3.关键字

4.ECMAScript原始类型: Null  Undefine  string  Boolean Number

5.typeof运算符  

   undefined    undefined 类型

   boolean      boolean类型

   number      number类型

   string         string  类型

   object         如果变量是一种引用类型或null类型   现在认为null是对象对的占位符

6.Undefined类型

   Undefined类型只有一个值，

   当声明的变量未赋值时，默认是undefined

   当函数无明确返回值时，返回值也是undefined

   typeof （temp） ==undefined   为true

7.Null类型

   只有一个专用值null。值undefined实际上是从值null派生来的，因为ECMAScript认为他俩相等

   尽管这两个值相等，但含义不同。null用于表示尚未存在的对象。将变量设为null意味着允许回收

8.Boolean类型

    非0即true

9.Number类型

    直接输入的(而不是从另一个变量访问的)任何数字都被看做是Number类型

10.string类型

11.转换

    ① 转换成string

        boolean  string  number都有tostring()方法。值得一提的是，number的tostring()方法有两种方式，第一种是普通的，第二种是tostring(num)，可以转换成num进制

    ②转换成number

        ParseInt()   ParseFloat()方法，若转换不成，则返回NaN

        ParseInt(‘1234ABC’)  将返回1234

    ③强制转换类型

           Boolean（value） 当转换的值至少有一个字符的字符串，非0数字或对象时，返回true

           Number（value） 转换传入的整个值，‘22.21.3’不能被转换，和ParseInt不一样

           String（value）  与tostring'()方法不同之处在于，强制转换null和undefined时不会报错

12.引用类型

     对象是由new运算符加上要实例化的类的名字创建的

    var o=new object();//这段代码创建了object类的实例

13.instanceof运算符

      类似typeof运算符，typeof运算返回对应的引用类型。instanceof返回boolean类型

      var s="asd";

      if（s instanceof string）

14.运算符

         ①一元运算符

             1.delete   删除开发者对以前定义的对象属性或方法的引用

             2.void  该运算符对任何值都返回undefined。该运算符通常用于避免输出不应该输出的值。例如，从元素调用javascript时，函数不能有返回有效值，否则浏览器将清空页面，显示函数结果。最经典的使用就是

             3.++  --

             4.=+  =-

          ②位运算符

              1.~   按位非

              2.&   按位与

              3.|    按位或

              4.^    按位异或

              5.<<  左位移符

              6.>>  右移位符

          ③在加法中，如果计算字符串+数字，则数字转换成字符串，俩字符串拼接

              在减法，乘法，除法中，均是字符串转换成数字做计算

             在比较中，字符串转换成数字

           ④等号和非等号

              为确定两个运算数是否相等，这两个运算符都会进行类型转换

              1.boolean类型先转换为数字  

              2.若运算符一个是字符串，一个是数字，则字符串通过强制转换为数字。如（'1234abc'==1234）返回false

              3.若一个运算数是字符串，另一个是对象，调用对象tostring()方法

              4.null值与undefined相等

              5.NaN!=NaN

              6.若两个运算数都是对象，则比较两个运算数的引用值

15.函数

     1.函数不用专门声明返回值。不管拥有有返回值

     2.函数不能重载，如果在同一作用域中定义两个名字相同的函数，则实际调用的是后一个

         使用arguments避免这种情况

     3.ECMAScript最令人感兴趣的是函数实际上是一个功能完整的对象

          用function类直接创建方法：

         var fun=new function(args1,agrs2.....functionbody);

         函数类也有toString()方法，返回函数体

     4.函数闭包

         简而言之，就是可以访问函数外定义的变量

         简而言之，闭包的作用就是在a执行完并返回后，闭包使得Javascript的垃圾回收机制GC不会收回a所占用的资源，因为a的内部函数b的执行需要依赖a中的变量

         闭包只是在形式和表现上像函数，但实际上不是函数。函数是一些可执行的代码，这些代码在函数被定义后就确定了，不会在执行时发生变化，所以一个函数只有一个实例。闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例

         闭包可以用在许多地方。它的最大用处有两个，一个是前面提到的可以读取函数内部的变量，另一个就是让这些变量的值始终保持在内存中

第三章 对象基础

      1.ECMAScript有无用存储单元收集程序，意味着不比专门销毁对象来释放内存

      2.当再没有对对象的引用时，称该对象被废除了。

      3.每当函数执行完，无用存储单元收集程序变会运行。当然，还有一些不可预知的情况下，该程序也会运行

      4.将对象的所有引用设置为null，可以强制性的废除对象

    

      5.早绑定与晚绑定

           所谓绑定，是把对象的接口（我理解为定义）与对象实例结合在一起的方法 

           早绑定，是指在实例化对象之前定义它的特性和方法，java，VB中就是这样

           晚绑定，是指在编译器或解释程序在运行前，不知道对象的类型

      6.本地对象

          

       7.Array类

               var aValues=new Array();

               var aValues=new Array(20);

               var aValues=new Array("a","b","c");

               var aValues=["a","b","c"];

 

               aValues[0]="a";

               aValues[1]="b"

               长度可以动态增长

 

               aValues.toString()和aValues.valueOf()均返回数组中的值

               aValues.join(char)   类似C# string.join

                

               数组提供操作最后一项的push()  和  pop()   两个方法

                                  第一项的方法   shift() 和unshift() 方法

 

         
       8.内置对象

         1.由ECMAScript实现提供的，独立于宿主环境的所有对象，在ECMAScript程序开始执行时出现。即不必明确实例化内置对象，它已经被实例化了

         2.ECMAScript中不存在独立的函数，所有函数必须是某个对象的方法。

               isNaN(),isFinite(),parseInt(),parseFloat()均为Global对象的方法

               encodeURI()和encodeURIComponent()方法用于编码传递给浏览器的URI

               encodeURI()用于处理完整的URI，不对特殊符号编码

               encodeURIComponent()用于处理片段，对所有特殊符号编码

               decodeURI(),decodeURIComponent()

         3.eval_r()  号称最为强大的方法，就像整个ECMAScript的解释程序，接受一个参数。在运行时，将参数解释为真正的语句，然后插入该函数所在的位置

            eval_r()在处理用户传递输入的数据时，容易造成代码注入

         4.另一个内置对象是Math

               min()                                    pow()

               max()                                    log()

               abs()                                     sqrt()          random()   0-1   配合floor使用              

               ceil()  向上舍入函数               acos()           tan()

               floor()  向下舍入函数              asin()           sin()

               round()   标准的舍入函数        atan()           cos()

      9.宿主对象

               BOM  DOM

      10.作用域

               1.公用，受保护和私有作用域

                    ECMAScript作用域只有一种公共作用域，所有对象的所有属性和方法都是公用的。

                    约定 _变量名   为私有成员

               2.this关键字

                    this关键字总是指向调用该方法的对象

       11.定义类或对象

               1.工厂方式

                    function createCar(){

                         var oTempCar=new object;

                         oTemoCar.color="color";

                         oTemoCar.doors=4;

                         oTemoCar.showColor=function(){

                                   alert(this.color);
                         }

                         return oTempCar

                    }

                    var car1=createCar();

                    var car2=createCar();

                    如此创建了两个car类，但会造成函数代码重复的弊端

                2.构造函数方式

                    function Car(sColor,iDoors,iMpg){
                         this.color=sColor;

                         this.doors=iDoors;

                         this.mpg=iMpg;

                         this.showColor=function(){

                              alert(this.color);
                         };

                    }

                     var oCar1=new Car("red",4,23);

                    var oCar2=new Car("blue",3,24);

                     如此创建了两个car类，但也会造成函数代码重复的弊端

                    注意：new运算符调用函数式，在执行第一行代码前先创建一个对象，只有this能访问这个对象，并且在函数结尾自动return

                3.原型方式

                    function Car(){
                    }

                    Car.prototype.color="red";

                    Car.prototype.doors=4;

                    Car.prototype.showColor=function(){
                                alert(this.color);

                    }

                    注意：在new Car()时，原型的所有索性都被立即赋予要创建的对象，意味着所有Car实例都是保存着指向showColor函数的指针

                 4.完美方案  混合的构造函数/原型方式

                    function Car(sColor,iDoors){

                              this.sColor=sColor;

                              this.iDoors=iDoors;

                    }

                    Car.prototype.sayHi=function(){
                              alert(this.color)

                    }

               5.实例

                    最常见的一个问题是字符串连接的性能。ECMASript的字符串长度不变，所以字符串连接非常耗资源

                    解决办法   Array.join();

               6.修改方法

                    使用对象的prototype属性可以很容易的修改对象的方法，即使是内置对象也是如此

                    注意：使用时一定要用prototype.a=function(){}这种方式去添加新方法，如果是

                    prototype=function(){}  则会覆盖掉之前的函数

                    

第四章  继承

               1.继承机制的实现。

                    从基类入手，所有开发者定义的类都可作为基类。处于安全原因，本地类和宿主类不能作为基类，防止公用访问编译过的浏览器级代码，避免被用作恶意攻击。

                    子类将可以访问基类所有的属性和方法，也可以覆盖超类中的属性和方法

               2.继承的方式 

                    1.经典的对象冒充方式

                //混合构造函数\原型方法创建类方法

        function ClassA(name, age) {

            this.name = name;

            this.age = age;

            this.sayHi = function () {//注意，这里不能使用原型方法创造基类的函数

                alert( "ClassA");

            }

        }

 

        function ClassB(name,age,color) {

            this.ClassA = ClassA;

            this.ClassA(name, age);

            delete this .ClassA; //因为是用在ClassA中时用this赋值，所以在ClassB中调用ClassA时，实际上时ClassB.name=name。然后删除ClassA

 

            this.color = color;

        }

        var testB = new ClassB("heh",18, "red");

        alert(testB.age);

        testB.sayHi();

          2.混合方式

        function ClassA(color) {

            this.color = color;

        }

        ClassA.prototype.sayHi = function () {

            alert( this.color);

        }

 

        function ClassB(name,color) {

            ClassA.call( this, color);

            this.name = name;

        }

        ClassB.prototype = new ClassA();

 

        var testB = new ClassB("color", "red");

        testB.sayHi();

             3.call() 和 apply() 函数

          call()方法是最相似于对象冒充方法，它的第一个参数是用作this的对象，其他函数参数都直接传递给函数自身

      var a = "aa" ;

        var classA = function () {

            this.a = "red" ;

        }

        var testA = new classA();

        //alert(testA.a);

 

        function sayColor() {

            alert( this.a);

        }

        sayColor();

        sayColor.call(); //若call函数不传值，则不改变this

        sayColor.call(testA);

       由此，继承可以写成

      function ClassB(name,age,color) {

           // this .ClassA = ClassA;

            //this .ClassA(name, age);

            //delete this .ClassA; //因为是用在ClassA中时用this赋值，所以在ClassB中调用ClassA时，实际上时ClassB.name=name。然后删除ClassA

          ClassA.call(this,name,age);

 

            this .color = color;

        }