《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;

}