javascript高级程序设计

第一章

1.注意标签中的

function sayScript(){
    alert('<\/script>');//  如果這樣寫會報錯“alert('</script>')”
}

第三章

3.12 标识符

所谓标识符，就是指变量、函数、属性的名字，或者函数的参数。标识符可以是按照下列格式规则组合起来的一个或多个字符：

（1）每一个字符必须是字母、下划线（_）或者一个美元符号（$）;
（2）其他字符可以是字母、下划线、美元符号或数字。
标识符中的字母也可以包含扩展的ASCII或Unicode字母字符（如さ和し），但我们不推荐这样做。
ECMAScript标识符采用驼峰大小写格式，也就是第一个字母小写，剩下的每个有意义的单词的首字母大写，

    eg:
    firsetSecond、myCar、doSomethingImportant

3.4 数据类型

基本数据类型：Undefined、Null、Boolean、Number和String

3.4.3 null 类型

alert(null == undefined); //true

3.4.4Boolean类型

数据类型	转换为true的值	转换为false的值
Boolean	true	false
String	任何非空字符串	“”（空字符串）
Number	任何非零数字值（包括无穷大）	0和NaN
Object	任何对象	null
Undefined	n/a	Undefined

3.45 Number类型

1.浮点数数值

var floatNum = 3.125e7//等于31250000
var floatNum = 3e-7//等于0.0000003

浮点数的计算要注意：0.1+0.2的结果不是0.3
所以不要做这样的测试
if(a + b == 0.3){
    alert(You got 0.3);
}

2.数值范围
最小值：Number.MIN_VALUE（在大多数浏览器中，这个值是5e-324）
最大值：Number.MAX_VALUE（在大多数浏览器中，这个值是1.7976931348623157e+308）
如果某次计算的结果超过这个最大值，或者低于这个最小值，那么这个值是正数，则会转正Infinity（正无穷），如果这个值是负数，则会转正-Infinity（负无穷）
如果想确定这个值是不是有穷的，则可以使用isFinite()函数。这个函数在参数位于最小与最大值之前时会返回true，如下面的例子：

    var result = Number.MAX_VALUE+ Number.MAX_VALUE;
    alert(isFinite(result)); //false

特殊：访问Number.NEGATIVE_INFINITY和Number.POSITIVE_INFINITY也可以得到负和正的Infinity的值。可以想见，这两个属性中分别保存着-Infinity和Infinity。

4.数值转换
有3个函数可以把非数值转换为数值：Number()、parseInt()、parseFloat()。
Number()函数的转换规则如下。
∏如果是Boolean值，true和false将分别被转换为1和0。
∏如果是数字值，只是简单的传入和返回。
∏如果是null值，返回0。
∏如果是undefined，返回NaN。
∏如果是字符串，遵循下列规则：
∏如果是字符串，遵循下列规则：
▆如果字符串中数字（包括前面带正号或负号的情况），则将其转换为十进制数值，即“1”会变成1，“123”会变成123，而“011”会变成11（注意：前导的零被忽略了）;
▆如果字符串中包含有效的浮点格式，如“1.1”，则将其转换为对应的浮点数值（同样，也会忽略前导零）;
▆如果字符串中包含有效的十六进制格式，例如“0xf”，则将其转换为相同大小的十进制整数值;
▆如果字符串是空的（不包含任何字符），则将其转换为0;
▆如果字符串中包含除上述格式之外的字符，则将其转换为NaN。
∏如果是对象，则调用对象的valueOf()方法，然后依照前面的规则转换返回的值。如果转换的结果是NaN，则调用对象的toString()方法，然后再次依照前面的规则转换返回的字符串值。

    eg:
        var num1 = Number("Hello world!"); //NaN
        var num2 = Number("");             //0
        var num3 = Number("000011");       //11
        var num4 = Number(true);           //1

parseInt()：在转换字符串时，更多的是看其是否符合数值模式。它会忽略字符串前面的空格，直至找到一个非空格字符。如果第一个字符不是数字字符或者负号，parseInt()会返回NaN;也就是说，parseInt()转换空字符串会返回NaN，而用Number()对空字符串返回0.如果第一个字符是数字字符，parseInt()会继续解析第二个字符，直到解析完所有的字符或者遇到了一个非数字字符。例如，”1234blue”会被转换为1234，因为“blue”会被完全忽略，类似的，“22.5”会被转换为22，因为小数点并不是有效的数字字符。
如果字符串中的第一个字符是数字字符，parseInt()也能识别各种整数格式（即十进制、八进制和十六进制数）。也就是说，如果字符串以“0x”开头且后面跟数字字符，就会将其作一个十六进制数;如果字符串以“0”开头且后面跟数字字符，则会将其当作一个八进制数来解析。

    eg:
        var num1 = parseInt("1234blue");       //1234
        var num2 = parseInt("");               //NaN
        var num3 = parseInt("0xA");            //10(十六进制数)
        var num4 = parseInt(22.5);             //22
        var num5 = parseInt("070");            //56(八进制数)最好不要用这个，因为在ECMAScript3中认为是56（八进制），而在ECMAScript5中认为是0（十进制）
        var num7 = parseInt("0xf");            //15(十六进制数)

为了消除在使用parseInt()函数时可能导致的上述困惑，可以为这个函数提供第二个参数：转换时使用的基数（即多少进制）。如果知道要解析的值是十六进制格式的字符串，那么指定基数16作为第二个参数，可以保证得到正确的结果，

    eg:
        var num = parseInt("0xAF", 16);   //175
        实际上，如果指定了16作为第二个参数，字符串可以不加前面的“0x”，如下例子：
        var num1 = parseInt("AF", 16);    //175
        var num2 = parseInt("AF");        //NaN
    指定基数会影响到转换的输出结果。
    eg:
        var num1 = parseInt("10", 2);          //2（按二进制解析）
        var num2 = parseInt("10", 8);          //8（按八进制解析）
        var num3 = parseInt("10", 10);         //10（按十进制解析）
        var num4 = parseInt("10", 16);         //16（按十六进制解析）

parseFloat()与parseInt()函数类似，parseFloat()也是从第一个字符（位置为0）开始解析每个字符。而且也是一走解析到字符串尾，或者解析到遇到一个无效的浮点数数字字符为止。也就是说，字符串中的第一个小数点是有效的，而第二个小数点就是无效的了，因此它后面的字符串将被忽略。举例来说，“22.34.5”将会转换为22.34。
除了第一个小数点有效外，parseFloat()与parseInt()的第二个区别在于它始终都会忽略前导零。parseFloat()可以识别前面讨论过的所有浮点数格式，也包括十进制整数格式。但十六进制格式的字符串则始终会转换成0。由于parseFloat()只解析十进制值，因为它没有用到第二个参数指定基数的用法。最后一点要注意：如果字符串包含的是一个可解析为整数的数（没有小数点，或者小数点后都是零），parseFloat()会返回整数。以下是使用parseFloat()转换数值的几个典型示例。

    eg:
        var num1 = parseFloat("1234blue");      //1234(整数)
        var num2 = parseFloat("0xA");           //0
        var num3 = parseFloat("22.5");          //22.5
        var num4 = parseFloat("22.34.5");       //22.34
        var num5 = parseFloat("0908.5");        //908.5
        var num6 = parseFloat("3.125e7");       //31250000

3.46 String类型
String类型用于由零或多个16位Unicode字符组成的字符序列，即字符串。

字面量	含义
\n	换行
\t	制表
\b	空格
\r	回车
\|斜杠
\’	单引号(‘)，在用单引号表示的字符串中使用。例如：\’hey.\’
\”	双引号(“)，在用双引号表示的字符串中使用。例如：He said,\”hey.\”
\xnn	以十六进制代码nn表示的一个字符（其中n为0~F）。例如，\x41表示“A”
\unnn	以十六进制代码nnnn表示的一个Unicode字符（其中n为0~F）。例如，\u03a3表示希腊字符Σ

3.转换为字符串

 eg:
    var age = 11;
    var ageAsString = age.toString();              //字符串“11”
    var found = true;     
    var foundAsString = found.toString();          //字符串“true”

数值、布尔值、对象和字符串值都有toString()方法，但是null和undefined值没有这个方法。

    eg:
        var num = 10;
        alert(num.toString());               //“10”
        alert(num.toString(2));              //“1010”
        alert(num.toString(8));              //“12”
        alert(num.toString(10));             //“10”
        alert(num.toString(16));             //“a”

在不知道要转换的值是不是null或undefined的情况下，还可以使用转型函数String(),这个函数能将任何类型的值转换为字符串。String()函数遵循下列转换原则：
∏如果值有toString()方法，则调用该方法（没有参数）并返回相应的结果;
∏如果值是null,则返回“null”;
∏如果值是undefined,则返回“undefined”

    eg:
        var value1 = 10;
        var value2 = true;
        var value3 = null;
        var value4;

        alert(String(value1));       //“10”
        alert(String(value2));       //“true”
        alert(String(value3));       //“null”
        alert(String(value4));       //“undefined”

3.5.1一元操作符

    eg:
        var num1 = 2;
        var num2 = 20;
        var num3 = num1-- + num2;    //等于22
        var num4 = num1 + num2;      //等于21

    eg:
        var s1 = "2";
        var s2 = "z";
        var b = false;
        var f = 1.1;
        var o = {
            valueOf:function(){
                return -1;
            }
        };

        s1++;                    //值变成数值3
        s2++;                    //值变成NaN
        b++;                     //值变成数值1
        f--;                     //值变成0.10000000000000009(由于浮点传入错误所致)
        o--;                     //值变成数值-2

for对应while

for(;;){//无限循环
    doSomething();
}

//只给出控制表达式实际上就把for循环转换成了while循环
var count = 10;
var i = 0;
for(; i<count; ){
    alert(i);
    i++;
}

正则表达式

var mathces = pattern2.exec(text);
console.log("matches.index:" + matches.index);
console.log("matches[0]:" + matches[0]);
console.log("patter2.lastIndex:" + pattern2.lastIndex);

var person = {};
Object.defineProperty(person, "name", {
    writable: false,
    value: "Nicholas"
});

alert("person.name:" + person.name);
person.name = "Greg";
alert(person.name);
//输出结果为：
//"Nicholas"
//"Nicholas"

判断函数对象是否处于原型中

function Person(){
}

Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function(){
    alert(this.name);
}

var person1 = new Person();
var person2 = new Person();

person1.name = "Greg";
alert(hasPrototypeProperty(person1, "name"));//false
alert(hasPrototypeProperty(person2, "name"));//true

function hasPrototypeProperty(object, name){
    return !object.hasOwnProperty(name) && (name in object);
}

不使用for in遍历函数对象

function Person(){
}

Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function(){
    alert(this.name);
}

var keys = Object.keys(Person.prototype);
alert("keys:" + keys);//"keys:name,age,job,sayName"

var p1 = new Person();
p1.name = "Rob";
p1.age = 31;
var p1keys = Object.keys(p1);
alert(p1keys);//"name,age"

var book = {
    _year: 2004,
    edition: 1
};

Object.defineProperty(book, "year", {
    get: function(){
        return this._year;
    },
    set: function(newValue){
        if(newValue > 2004){
            this._year = newValue;
            this.edition += newValue - 2004;
        }
    }
});

book.year = 2005;
alert(book.edition);
//输出结果 2

===============================================================

var book = {};

Object.defineProperties(book, {
    _year: {
        value: 2004
    },

    edition: {
        value: 1
    },

    year: {
        get: function(){
            return this._year;
        },
        set: function(newValue){
            if(newValue > 2004){
                this._year = newValue;
                this.edition += newValue - 2004;
            }
        }
    }
});

var descriptor = Object.getOwnPropertyDescriptor(book, "_year");
alert(descriptor.value);//2004
alert(descriptor.configurable);//false
alert(typeof descriptor.get);//"undefined"
alert(descriptor.value);//2004
alert(descriptor.enumerable);//false
alert(typeof descriptor.get);"undefined"

==============================================================

function createPerson(name, age, job){
    var o = new Object();
        o.name = name;
        o.age = age;
        o.job = job;
        return o;
}

var person1 = createPerson("Nicholas", 29, "Software Engineer");
var person2 = createPerson("Greg", 27, "Doctor");
console.log("person1:" + JSON.stringify(person1));//person1:{"name":"Nicholas","age":29,"job":"Software Engineer"}
console.log("person2:" + JSON.stringify(person2));//person2:{"name":"Greg","age":27,"job":"Doctor"}

==============================================================

function Person(name, age, job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = function(){
        alert(this.name);
    }
}
var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");
alert(person1.constructor == Person);//true
alert(person2.constructor == Person);//true

==============================================================

function Person(name, age, job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = function(){
        alert(this.name);
    }
}
var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");
alert(person1 instanceof Object);//true
alert(person1 instanceof Person);//true
alert(person2 instanceof Object);//true
alert(person2 instanceof Person);//true

==============================================================

function Person(name, age, job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = function(){
        alert(this.name);
    }
}
var person = new Person("Nicholas", 29, "Software Engineer");
    person.sayName();//Nicholas

Person("Greg", 27, "Doctor");
window.sayName();//Greg

var o = new Object();
    Person.call(o, "Kristen", 25, "Nurse");
    o.sayName();//Kristen

==============================================================

function Person(name, age, job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = function(){
        alert(this.name);
    }
}
var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");
alert(person1 == person2);//false
==============================================================

function Person(name, age, job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = new Function(alert(this.name));
}

function sayName(){
    alert(this.name);
}
var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");
alert(person1.sayName == person2.sayName);//true