BlogJava-J2EE社区-随笔分类-JavaScript高级程序设计(第2版)

第18章高级技巧

xcp — Thu, 28 Jul 2011 16:41:00 GMT

1.高级函数
    1.1 作用域安全的构造函数
         >例：function Person(name,age,job){
                    this.name=name;
                    this.age=age;
                    this.job=job;
                }
                var person = new Person("xcp",23,"program er");
               alert(person.name);//xcp
                alert(window.name);//undefined

                但如果我这样生成对象呢？
                var person = Person("xcp",23,"programer");
                alert(window.name);/xcp

                这是为什么呢？
                问题出现在当没有使用new操作符来调用构造函数的情况，由于该this对象是在运行时绑定的，所以直接调用Person(),this会映射到window上

                解决办法呢？
                function Person(name,age,job){
                    if(this instanceof Person){
                        this.name=name;
                        this.age = age;
                        this.job = job;
                    }else{
                        return new Person(name,age,job);
                    }
                }

    1.2 函数绑定
        函数绑定要创建一个函数，可以在特定中指定参数调用另外一个函数。该技巧常常和回调函数与事件处理程序一起使用，以便在见函数作为变量传递的时候保留代码执行环境。
        例如：var handler ={
                    message :"Event handled",
                    handleClick:function(event){
                            alert(this.message);
                    }
                }
                var btn = document.getElementById("sub");
                EventUtil.addHandler(btn,"click",bind(handler.handleClick,handler));

2.高级定时器
    2.1 setTimeout clearTimeout
    2.2 setIntelval clearInterval

3.拖放
    3.1 常用写法
        EventUtil.addHander(document,"mousemove",function(event){
            var myDiv = document.getElementById("myDiv");
            myDiv.style.left = event.clientX+"px";
            myDiv..style.top = event.clientY+"px";
        })

xcp 2011-07-29 00:41 发表评论

第8章 BOM

xcp — Tue, 26 Jul 2011 17:06:00 GMT

1.window作为globar对象
2.window文档结构树
3.延迟加载和间歇加载
setTimeout(function,time) clearTimeout(obj);
setInterval(function,time) clearInterval(obj);

xcp 2011-07-27 01:06 发表评论

第7章 javascript匿名函数和闭包

xcp — Tue, 26 Jul 2011 17:00:00 GMT

    匿名函数主要在声明对象的时候，不用写明方法。这跟标准函数的区别是什么？

    标准函数是可以在作用域里面加载的时候创建内存空间，分配指针地址。
    匿名函数只要在执行的这条语句的时候才会创建空间，分配指针地址。

    闭包：就相当于JAVA里面的内部类一样

xcp 2011-07-27 01:00 发表评论

第6章面向对象程序设计

xcp — Wed, 20 Jul 2011 03:46:00 GMT

1、自定义对象
a. 工厂模式

function Person(name,age){
    var person = new Object();
    person.name = name;
    person.age=age;
    person.say=function(){
        alert(person.name+" "+person.age);
    }
   return person;
}

var person1 = Person("xcp",23);
var person2 = Person("lxm",24);
person1.say();
person2.say();
//没有解决对象识别的问题（即怎么知道对象的类型）

b. 构造函数模式

function Person(name,age){
    this.name = name;
    this.age = age;
    this.say = function(){
         alert(this.name+" "+this.age);
    }
}
var person1 = new Person("xcp",23);
var person2 = new Person("lxm",24);
person1.say();
person2.say();
//直接将属性附值于this；并且没有显示的创建和返回对象；必须用new来创建对象
alert(person1 constructor Person);//true
alert(person1 instanceof Person);  //true

    ->创建对象经历以下步骤：
       >创建一个新对象
       >将构造函数的作用赋予新对象(因此this就指向了新对象)
       >执行构造函数里面的代码（添加属性）
       >返回新对象
    ->构造函数的问题
       >使用构造函数的主要问题，就是每个方法都要在每个实例上重新创建一遍。例如我们上面的alert(person1.say==person2.say) //false
         创建两个同样功能的Function()是完全没有必要的；况且有this对象在，根本不用在执行代码前就把函数绑定到特定对象上面。因些，大可以像以下面的代码，通过把函数定义转移到构造函数外部解决这个问题：
        function Person(name,age){
            this.name = name;
            this.age = age;
            this.say    = sayFunction(this.name,this.age);
        }
        function sayFunction(name,age){
            alert(name+" "+age);
        }
        //这样sayFunction就只会创建一次了 //即：alert(person1.say==person2.say) //true;
       但问题也来了，如果有很多个方法，就要创建很多方法，这样无论可读性，适用性都不是很好

    c. 原型模式
        >理解：我们创建的每一个对象，都有一个prototype属性，这个属性是一个对象，那么这个对象的作用是什么呢？所有prototype属性都会自动获得一个constructor(构造函数)，这个属性民包含一个指向prototype属性在所函数的指针。Person.prototype.constructor指向Person。而通过这个构造函数，我们还可以继承为原型添加其他属性和方法。如图：

            .Person对象的prototype属性指向Person原理对象
            .Person原理对象的构造方法指向Person对象
            .Person实例调用属性和方法的顺序：先查找Person对象是否具有此属性和方法，如果Person对象具有则返回，如果没有则先查询Person的原型对像。推出：如果对象本身和原型对象同时具有某个函数和方法，以对象本身的属性和方法为准。从这个可以体现出多个对象共享原型所保存的属性和方法，以降低内存开消。但有的时候我们需要用原理对象的属性属性和方法去覆盖原有对象的属性的方法，这时我们采用删除原有对象的属性和方法：delete Person.name(删除原有对象的name属性).可以使用hasOwnProperty()和isPrototypeof();



        >原型与in操作符
            .有两种可能使用in操作：单独使用("name" in person1)和在for..in里面。单独使用in的时候对象能够返回给定属性时返回true(实例和原型)

        >更加简单的原型语法
            function Person(){}
            Person.prototype={
                name:'age',
                age:'23',
                say:function(){
                        alert(this.name+" "+this.age);
                }
            }
        //这样写下来就相当于重写了对象的prototype对象，那原型对象里面的constructor属性就没有了.但如果我要得到constructor属性怎么办呢？
            Person.prototype={
                constructor:Person,//constructor=this,
                name:'age',
                age:'23',
                say:function(){
                        alert(this.name+" "+this.age);
                }
            }

        >原型中的动态性
　　　　.由于原型中查找植的过程是一次性的，因此我们对原型对象所做的操作会立刻反映出来，如
            function Person(){
            }
            Person p = new Person();
            Person.prototype.say=function(){
                alert("hi");
            }
            p.say(); //hi;这样就可以立刻体现出来

            //再看看下面的例子
            function Person(){}
            Person p = new Person();
            Person.prototype={
                say:function(){
                    alert("hi");
                }
            }
            p.say(); //error;
            //这里为什么就出错了呢，上一个例子不是好好的吗？因为第一个例子，只是在prototype原型对象里面添加了一个属性，我们在调用say的时候他会查找对象本身和原型对象并且是一次查询（所以的代码运行完毕），所以可以正常的到原型对象里面取出来；可是后面一个方法呢，声明对象p他的时候他会找到_proto_指针指向原型对象；而我用Person.prototype也重构这个原型对象，就相当于切断了constructor与是初始原型之间的连接关系，所有p的任何非本身属性都会出错！

        >原生态对象模型
            .原型类型不仅体现在自定义对象模型，包括原生的引用类型都是采用的这种模式，所以我们可以修改引用类型提供的方法和属性。
            String.prototype.trim=function(text){...} //我们将跟String对象添加了一个trim()方法；

        >原型对象的问题
            .原型对象省略了为构造函数传低参数这一细节，结果所以的实例对象取得的实例值都是一样的，所以原型对象最大问题就是由本享本质导成的。
            function Person(){}
            Person p = new Person();
            Person.prototype={
                say:function(){
                    alert("hi");
                }
            }
            p.say();

            Person p1 = new Person();
            Person p2 = new Person();
            alert(p1.say==p2.say);//true
            //所以接下来我们就是来 解决怎么合理共享,即合理使用prototype？

        >组合使用构造函数模式和原型模型(最常见的方法)
            .构造函数模式用于定义：实例属性(可以传递多个参数以确保必要性)
             原型模式用于定义：共享的属性和方法(这样即保证了安全，也保证了最大的节约内存)

             例：function Person(name,age){
                       this.name=name;
                       this.age = age;
                       this.friend=["zhangsan","lisi","wangmazi"];
                   }
                   Person.prototype={
                        constructor:Person,
                        say:function(){
                                alert(this.name+" "+this.age);
                        }
                    }
                    Person p1 = new Person("xcp","23");
                    Person p2 = new Person("lxm","25");
                    alert(p1.friends==p2.friends);//false;
                    alert(p1.say==p2.say);//true;

            .动态原型模型
                   function Person(name,age){
                       this.name=name;
                       this.age = age;
                       this.friend=["zhangsan","lisi","wangmazi"];
                        if(typeof this.say !="function"){
                             Person.prototype.say:function(){
                                 alert(this.name+" "+this.age);
                             }
                            //再一次强调这不能写成
                                Person.prototype={...}
                            }
                  }

        >寄生构造函数模型
            .在工厂模式上加上参数
             function Person(name,age){
                var o = new Object();
                o.name=name;
                o.age = age;
                o.say=function(){
                    alert(this.name+" "+this.age);
                }
                return o;
            }

2.继承
    一般所有的OO都支持接口继承和实现继承，而ECMAScript函数没有签明的说话（空函数标志或者说接口的声明方法），所以只有实现继承，而实现继承主要是通过原型对象来实现了。
    >原型链(重要思想)
        . 简单回顾一下构造函数，原型和实例的关系
            构造函数的prototype属性(指针)　->　原型地址
            原型的construtcotr属性(指针)     ->   构造函数地址
            实例的_proto_属性(内部指针)           ->   原型对象
        .原型链的思想
            我们将一个原型对象的指针指向另一个构造函数。如此层层递进，就实现了实例和原型的链条
            function SuperType(){
                    this.property = true;
            }
            SuperType.prototype.getSuperValue=function(){
                    return this.property;
            }
            function Subtype(){
                    this.subproperty = false;
            }
            SubType.prototype = new SuperType(); //子类的原型对象指向　生成的超类的子类（所以有一个_proto_指针指向超类的面型对象）
            SubType.prototype.getSubValue=function(){
                    return this.subproperty;
            }
            Subtype instance = new Subtype();
            instance.getSuperValue();
             分析：


            .如果我们调用subType.getSuperValue()经过的步骤有：1）搜索实例本身 2）搜索SubType.prototype 3)搜索SuperType.prototype 4)所有的类都是实现Object，所以如果前面没有找到的话，就还要搜索Object.prototype;所以真正的原型链应该是：

            //再到这来这来强调一下，不是原型对象的constructor被重写了，而且_proto_指针被重写了。

           . 两种方法来确定实现跟原理之间的关系
                //是否是指定类型的实现
                 alert(instance instanceof Object)//true;
                alert(instance instanceof SuperType);//true;
                alert(instance instanceof SubType);//true;
                alert(instance instanceof Data); //false;

                //指定类型的原型对象是否派生了此实例
                alert(Object.prototype.isPrototype(instance));//true;
                alert(SuperType.prototype.isPrototype(instance));//true;
                alert(SubType.prototype.isProtoType(instance));//true

            .重写超类方法
                在SubType.prototype = new SuperType(); 后面添加如下：
                //重写超类方法
                SubType.prototype.getSuperValue=function(){
                    return false;
                }

                //不能写成这样
                SubType.prototype=new Supertype();
                SubType.prototype={
                     getSuperValue=function(){
                        return false;
                    }
                } //当一使用这一句话时，上一句话就立刻实效了，为什么呢？前面已经说过一这样就切断了SubType与SuperType.prototype的链条

            .原型链的问题
                最主要的问题就是包含引用类型类型的值,换一句就是访问安全性问题；怎么说来着？前面介绍包含引用类型值的原型属性民会被所有实例共享；而这也正是为什么要在构造函数中，而不是在原型对象中定义属性的原因。但我们通过原型来实现继承时，原型实际上会变成另一个类型的实例，于是，原先的实例属性和原型对象里面所有的属性和方法顺利成章地变成了现在的原型属性了，从而可以将属性工享这就破坏了原有的安全性了。

        >借用构造函数（也叫伪造对象和经典继承->常用方式）
            .无参数版
                function SuperType(){
                    colors:["red","blue","green"];
                }
                function SubType(){
                    //实现继承SuperType,为什么呢，因为在子类构造函数调用父类构造函数里面的call方法
                    SuperType.call(this);
                }
                var instance1 = new SubType();
                instance1.colors.push("block");
                alert(instance1.colors); //"red","blue","green","block";

                var instance2 = new SubType();
                alert(instance2.colors);   //"red","blue","green"

            .有参数版
                function SuperType(name){
                        this.name = name;
                }
                function SubType(){
                    //继承了SuperType,同时传递了参数
                    SuperType.call(this,"xcp");
                    //实例属性
                    this.age = 23;
                }
                var instance = new SubType();
                alert(instance.name); //xcp
                alert(instance.age); //23

            .借用构造函数的问题
                如果仅仅是借用构造函数，那么也将无法避免构造函数模式存在的问题－方法都在构造函数中定义，这样些函数复用就无从谈起了。

        >组合继承(也称伪经典继承),指的是将原型链和借用构造函数的技术结合在一起来，从而发挥者这宅的一种继承模式
            .实例(精典实例)
                function SuperType(name){
                    this.name = name;
                    this.colors = ["red","blue","green"];
                }
                SuperType.prototype.sayName=function(){
                    alret(this.name);
                }
                function SubType(name,age){
                    //继承属性
                    SuperType.call(this,name);

                    //添加新属性
                    this.age = age;
                }

                //继承原型里面的属性和方法
                SubType.prototype = new SuperType();
                //添加新方法
                SubType.prototype.sayAge = function(){
                        alert(this.age);
                }

                var instance1 = new SubType("xcp",23);
                instance1.colors.push("black");
                alert(instance1.colors); //red,blue,green,black
                instance1.sayName();//xcp;
                instance1.sayAge();//23;

                var instance2 = new SubType("lxm",25);
                alert(instance2.colors); //red,blue,green
                instance2.sayName();//lxm
                instance2.sayAge(); //25

                //组合继承就避免了前面的原型链（父类所有的属性和方法均作用子类的原型对象的属性和方法，所以就存在数据安全问题了）和借用构造函数的缺陷（无共享属性和方法机制）；成为Javascript中最常用的继承模式。而且，instanceof和isPrototypeOf()也能够用于识别基于组合继承创建的对象。

         >当然还包括：原型式继承、寄生式继承等

3.总结
    >创建javascript对象的方式
        .方法：
            构造方法式<接收参数传值实例属性>+原型式<抽取公共共享的方式>
        .实例：
            function Person(name,age){
                this.name=name;
                this.age = age;
                this.friend=["zhangsan","lisi","wangmazi"];
            }
            Person.prototype={ //使用最简对象完成
                 constructor:Person,
                 say:function(){
                     alert(this.name+" "+this.age);
                 }
            }
            Person p1 = new Person("xcp","23");
            Person p2 = new Person("lxm","25");
            alert(p1.friends==p2.friends);//false;
            alert(p1.say==p2.say);//true;

    >继承超类的方法
        .方法
            借用构造函数式<复用超类的实例变量，表示不同实例得到不变量不同>+原型链<复用超类的原型对象，意思就是子类的_proto_指针指同超类的原型对象>
        .实例
            function SuperType(name){
                    this.name = name;
                    this.colors = ["red","blue","green"];
                }
                SuperType.prototype.sayName=function(){
                    alret(this.name);
                }
                function SubType(name,age){
                    //继承属性
                    SuperType.call(this,name);

                    //添加新属性
                    this.age = age;
                }

                //继承原型里面的属性和方法
                SubType.prototype = new SuperType();
                //添加新方法
                SubType.prototype.sayAge = function(){
                        alert(this.age);
                }

                var instance1 = new SubType("xcp",23);
                instance1.colors.push("black");
                alert(instance1.colors); //red,blue,green,black
                instance1.sayName();//xcp;
                instance1.sayAge();//23;

                var instance2 = new SubType("lxm",25);
                alert(instance2.colors); //red,blue,green
                instance2.sayName();//lxm
                instance2.sayAge(); //25

xcp 2011-07-20 11:46 发表评论

第5章引用类型

xcp — Tue, 19 Jul 2011 07:07:00 GMT

1.引用类型是一种数据结构，从技术上讲是一门面向对象的语言，通常称为类。从技术角度来说是一门面向对象的语言，但它不具备传统面向对象语言所支持的类和接口等基本结构。
2.创建Object实例的方式有两种:
    a. 用new操作符后跟Object构造函数
        var person = new Object();
        person.name = "xcp";
        person.age = 23;
    b. 另一种方式是使用对象字面量表示法
        var person = {
            name:'xcp';
            age:23;
        }
        或者
        var person={}
        person.namge="xcp";
        person.age=23;
3.创建Array数组有两种方法：
    a. 使用Array的构造函数
        var colors = new Array();
        var colors = new Array(20);
        var colors = {"red","blue","green"}
        //每一个数组元素的初始值都是undefined;
    b. 使用数组字面量方法
        var colors = Array(20);
        var colors = ["red","blue","green"];
4.使用Array的常用方法：
    a. 栈操作方法(后进先出)：push 推入,pop 弹出
        var colors=["red","blue"];
        colors.push("green"); //推入一项
        colors[4]="block";
        alert(colors.length); //4
        var temp = colors.pop();
        alert(temp); //block
        alert(colors.length);//3

     b. 对列方法(先进先出)：push推入，shift取出, unshift塞入
        var colors=["red","blue"];
        colors.push("green"); //推入一项
        colors[4]="block";
        alert(colors.length); //4
        var temp = colors.shift();
        alert(temp); //red
        alert(colors.length);//3

        unshift和shift的功能刚好相反：他是在第一位添加数据项

        var colors = new Array();
        var count = colors.unshift("red","green");
        alert(count); //2
        colors.unshift("block");
        var item = colors.pop();
        alert(item); //green
        alert(colors.length);

    c. 重排序方法:reverse()和sort()
        var values=[1,2,3,4,5,6];
        values.reverse();
        alert(values); //6,5,4,3,2,1

        //注意sort方法会调用每个数组的toString()转型方法，然后得到字符串，然后再排序，就会出现以下情况：
        var values = [0,15,1,10,5];
        values.sort();
        alert(values); //0,1,10,15,5
        //不用说这种sort方法肯定不是最佳的方式。因此sort方法可以接收一个比较函数作为参数，和java的Comparable一样的作用.
        function compare(value1,valu2){
            if(value1 < value2){
                return -1;
            }else if(value > value2){
                 return 1;
            }else{
                  return 0;
            }
        }
        values.sort(compare);
        alert(values); //0,1,5,10,15

    d. 常用方法
        concat:两个或更多数组组合而成的
        join:返回字符串值，其中包含了连接到一起的数组的所有元素    values.join(",")    0,1,5,10,15
        slice:返回一个数组的一段   values.slice(0,2);
        splice:从一个数组中移除一个或多个元素   values.splice(0,2);
        valueOf:返回指定对象的原始值

5.使用Data类型
    a. 创建日期对象
        var now = new Date();
        var someData = new Date(Data.parse("May 25,2005"));
        var someData = new Date("May 25,2005");
6.使用RegExp对象
    a. 创建RegExp对象(字面量方式创建)
        var expression = /pattern/flags;
        这里面的pattern 就是就行匹配的正则表达示
        这时面的flags包括以下几种：g,i,m
            g：表示全局模式(global)，则将模式应用于所有字符串，而并非发现第一个匹配项就立刻停止。
            i：表示不区分大小写（case-insensitive),
            m：表示多行模式(mutiline)，即达到一行末尾时还会继续查找下一行是否存在匹配项
            例：var at = /at/g;    匹配at
                  var at2 = /[bc]at/gi; 匹配bat,cat。。。。并且不区分大小写
                  var at3 = /.at/gi;   分有以at结尾的3个字母的字符串
                  注：
                      以下是javascript里面的转义字符：(){}[]\|/^$.?*+ 转义方法：加\ 。如\\ \$
                  var at4 = /\.at/gi; 所有.at,不区分大小写
    b. 使用RegExp构造函数创建
        它接受两个参数：一个是要匹配的字符串模式，可选的标志字符串。
        var at5 = new RegExp("[bc]at","i");
        由于RegExp函数模式的参数是字符串，所以在某些情况下要对字符串进行双重转义，如：

    c. RegExp的属性
        >global：返回true/false,返回是否设置了g标志
        >ignonecase：返回true/false，返回是否设置了i标志
        >mutiline：返回true/false,返回是否设置了m标志
        >lastIndex：开始搜索下一个匹配的位置，从0开始
        >source：返回正则表达示
    d. RegExp的方法
        >exec方法
        var text = "mom and dad and bady";
        var p = /mon( and dad( and bady)?)?/gi;
        var m = p.exec(text); //返回匹配器
        alert(m.index); //0
        alert(m.input);//mom and dad and bady
        alert(m[0]);//mom and dad and bady 相当于group(0)
        alert(m[1]);// and dad and bady 相当于group(1)
        alert(m[2]);// and bady 相当于group(2)

       >test方法
        通常用于if语句，如果匹配返回true,否则返回false
        var test="000-00-0000";
        var p = /\d{3}-\d{2}-\d{4}/;
        if(p.test(test)){alert("dd");}

    f. Function类型
        a.函数的声明
            function test(index){}
            var test = function(index){}
            var test = new Function(index){} //不推荐
            注：
                >函数没有重载功能，如果两个函数一样，他会直接将前面的方法
        b. 函数内部属性this和arguments
        c. 每个函数都包括length和prototype属性
            length：接受参数的个数
            prototype：原型对象，很重要
        d. 每个函数都有两个非继承的方法：apply()和call()方法
            >这两个方法的用途都是在特定的作用域中调用函数，实际上等于设置函数体内this对象的值。
            >首先,apply方法接受两个参数：一个是在其中运行函数的作用域，另一个是参数数据（可以是Array实例，也可以是arguments对象）
                function sum(num1,num2){
                    return num1+num2;
                }
                function callsum1(num1,num2){
                    return sum.apply(this,arguments); //传入arguments对象
                }
                function callsum2(num1,num2){
                    return sum.apply(this,[num1,num2]); //传入数组
                }
                alert(callSum1(10,10)); //20
                alert(callSum2(10,10)); //20
            >call()方法与apply()方法的作用相同，它们的区别仅在于接收参数的方式不同。对于call()方法来言，第一个参数是作用域没有变量，变化的只是其余参数都是直接传递跟函数的。
                function callSum3(num1,num2){
                    return sum.call(this,num1,num2);
                }
                alert(callSum3(10,10));//20

                //所以apply()和call()使用就看怎么使用方便来用了，如我们传入的参数就是要传调用的函数的参数，就可以直接作用apply(this,arguments);

            >真正强大的地方是能够扩充函数赖以运行的作用域<就是在后面运行的函数的作用域就是我传进的作用域>
                window.color = "red";
                var o={color:"blue"}
                function getColor(){
                    alert(this.color);
                }

                getColor();                //red
                getColor.call(this);     //red
                getColor.call(widow); //red;
                getColor.call(0);         //blue;

    g.Boolean类型
        a. 声明
            var b = true;
            var b = new Boolean(true);
            alert(b instanceof Boolean); //true

    h.Number类型
        a. 声明
            var b1 = 2;
            var b2 = new Number(2);
            var b3 = (Number)"2";

    i.String类型
        a. 声明
            var s1 = "dd";
            var s2 = new String("dd');
        b. 常用方法
            charAt,concat, substring,indexOf,toLowerCase,toUpperCase等

    j.常用内置对象
        a. URI编码方法：encodeURI()和encodeURIComponent(常用)
            比较：encodeURI()用于整个URL;encodeURIComponent用于URL中的某段进行编码
                     encodeURI不会对本身的URL特殊字符进行编码，例如冒号，正斜杠，问号和#号;而encodeURIComponent对所有非标准字符都要进行编码

        b. URL解码方法：decodeURI()和decodeURIComponent,基本操作同上
        c.  isNan(), parseInt(), parseFloat()
        d. eval()---功能最强大的一个方法
            ECMAScript内部解析器一样
        e. Window对象
        f. Math类
            min,max, ceil,floor,round,random

xcp 2011-07-19 15:07 发表评论

第4章　变量、作用域和内存位置

xcp — Sat, 16 Jul 2011 09:26:00 GMT

1.ECMAScript变量可能包含两种不同的数据类型：基本数据类型和引用数据类型
基本数据类型：是指的那些保存在栈内存中的简单数据段，即这种值完全保存在内存中的一个位置
　　引用类型：是指那些保存在堆内在中的对象，意思是变量中保存的实际上只是一个指针，这个指针指向内存中的中车个位置，该位置保存对象
　　　
2.有两种参数传递方式：传值和传址

xcp 2011-07-16 17:26 发表评论

第1章、javascript简介和基础

xcp — Sat, 16 Jul 2011 03:09:00 GMT

一、简介
1.javascript实现由三部分组成：ECMAScript,DOM,BOM
2.ECMAScrip:Javascript ActionScript ScriptEase
3.defer="defer"延迟加载

二、基础
(一)、语法
       1.区分大小写（变量，函数名，操作符都区分大小写）
       2.标识符
          2.1 第一个字母必须是：字母、_、$
          2.2 其它的允许字母、_、$、和数字
      3.注释
          3.1 单行 //
          3.2 多行 /***/
      4.关键字
           this,break,continue,if,else,switch,default,for,do,while,with,new,typeof,instanceof,try,catch,finally,throw,return等等
(二)、数据类型
      1、基本数据类型(可以保用typeof来取得以下)
          1.1 undefined --- 如果这个值未定义
          1.2 boolean    --- 如果这个值是布尔型
          1.3 string       --- 如果这个值是字符串
          1.4 number    --- 如果这个值是数字型
          1.5 object      --- 如果这个值是对象或null
          1.6 function   --- 如果这个值是函数
　　2、基本数据类
        Undefined,Boolean,String,Number,Object,Null,Function
     3、Null与Undefined的区别
          Null是指对象定义了，只不过指定他为空或者没有赋值；而Undefined是对象肯定没有定义
(三)、操作符
      1、一元操作符
           1.1 递增，递减 ++ --
      2、位操作符
           2.1 Not,And,Or,左移,有符号右移,无符号右移
      3、关系。
      4、各数据类型之间的操作
(四)、语句
      1、if...endif...else
      2、switch() case... break;default;
      3、do...whie()
      4、while(); break;continue;
      5、for(var i=0;i<*;i++)
      6、for(var i in *)
4.内置功能（系统类）
　　1、Function   可以传递参数，用arguments得到所以传递参数集合

xcp 2011-07-16 11:09 发表评论

第二十一章、javascript未来API

xcp — Sun, 10 Jul 2011 15:22:00 GMT

xcp 2011-07-10 23:22 发表评论

BlogJava-J2EE社区-随笔分类-JavaScript高级程序设计(第2版)

第18章 高级技巧