亚洲av午夜精品一区二区三区,亚洲日本va中文字幕久久,红杏亚洲影院一区二区三区

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

1.高��函数
    1.1 作用域安全的构造函�?br />         >例：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

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

                �q�是��Z��么呢�Q?br />                问题出现在当没有使用new操作�W�来调用构造函数的情况�Q�由于该this对象是在�q�行时绑定的�Q�所以直接调用Person(),this会映��到window�?br />
                解决办法呢？
                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 函数�l�定
        函数�l�定要创��Z��个函敎ͼ�可以在特定中指定参数调用另外一个函数。该技巧常常和回调函数与事件处理程序一起��用，以便在见函数作�ؓ变量传递的时候保留代码执行环境�?br />        例如�Q�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.高��定时�?br />    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 发表评论

�W?�?BOM

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

1.window作�ؓglobar对象
2.window文档�l�构�?br />3.延迟加蝲和间歇加�?br /> setTimeout(function,time) clearTimeout(obj);
setInterval(function,time) clearInterval(obj);

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

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

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

    标准函数是可以在作用域里面加载的时候创建内存空��_��分配指针地址�?nbsp;
    匿名函数只要在执行的�q�条语句的时候才会创建空��_��分配指针地址�?br />

    闭包�Q�就相当于JAVA里面的内部类一�?br />

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

�W?�?面向对象�E�序设计

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();
//没有解决对象识别的问题（��x��么知道对象的类型）

b. 构造函数模�?/p>

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();
//直接��属性附��g��this�Q��ƈ且没有显�C�的创徏和返回对象；必须用new来创建对�?br />alert(person1 constructor Person);//true
alert(person1 instanceof Person);  //true

    ->创徏对象�l�历以下步骤�Q?br />       >创徏一个新对象
       >��构造函数的作用赋予新对�?因此this��指向了新对�?
       >执行构造函数里面的代码�Q�添加属性）
       >�q�回新对�?br />    ->构造函数的问题
       >使用构造函数的主要问题�Q�就是每个方法都要在每个实例上重�?/strong>创徏一遍。例如我们上面的alert(person1.say==person2.say) //false
         创徏两个同样功能的Function()是完全没有必要的�Q�况且有this对象在，�Ҏ��不用在执行代码前��把函数�l�定到特定对象上面。因些，大可以像以下面的代码�Q�通过把函数定义�{�U�d��构造函数外部解册��个问题：
        function Person(name,age){
            this.name = name;
            this.age = age;
            this.say    = sayFunction(this.name,this.age);
        }
        function sayFunction(name,age){
            alert(name+" "+age);
        }
        //�q�样sayFunction��只会创��Z��ơ了 //卻I��alert(person1.say==person2.say) //true;
       但问题也来了�Q�如果有很多个方法，��p��创徏很多�Ҏ��Q�这��h��论可��L��，适用性都不是很好

    c. 原型模式
        >理解�Q�我们创建的每一个对象，都有一个prototype属性，�q�个属性是一个对象，那么�q�个对象的作用是什么呢�Q�所有prototype属性都会自动获得一个constructor(构造函�?�Q�这个属性民包含一个指向prototype属性在所函数的指针。Person.prototype.constructor指向Person。而通过�q�个构造函敎ͼ�我们�q�可以��承�ؓ原型��d��其他属性和�Ҏ��。如图：


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



        >原型与in操作�W?br />            .有两�U�可能��用in操作�Q�单独��?"name" in person1)和在for..in里面。单独��用in的时候对象能够返回给定属性时�q�回true(实例和原�?

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

        >原型中的动态�?nbsp;
　　　　.�׃��原型中查找植的过�E�是一�ơ性的�Q�因此我们对原型对象所做的操作会立��d��映出来，�?br />            function Person(){
            }
            Person p = new Person();
            Person.prototype.say=function(){
                alert("hi");
            }
            p.say(); //hi;�q�样��可以立��M��现出�?br />
            //再看看下面的例子
            function Person(){}
            Person p = new Person();
            Person.prototype={
                say:function(){
                    alert("hi");
                }
            }
            p.say(); //error;
            //�q�里��Z��么就出错了呢�Q�上一个例子不是好好的�?/strong>�Q�因为第一个例子，只是在prototype原型对象里面��d��了一个属性，我们在调用say的时候他会查扑֯�象本�w�和原型对象�q�且是一�ơ查询（所以的代码�q�行完毕�Q�，所以可以正常的到原型对象里面取出来�Q�可是后面一个方法呢�Q�声明对象p他的时候他会找到_proto_指针指向原型对象�Q�而我用Person.prototype也重构这个原型对象，��q��当于切断了constructor与是初始原型之间的连接关�p�，所有p的�Q何非本��n属性都会出错！

        >原生态对象模�?/span>
            .原型�c�d��不仅体现在自定义对象模型�Q�包括原生的引用�c�d��都是采用的这�U�模式，所以我们可以修改引用类型提供的�Ҏ��和属性�?/span>
            String.prototype.trim=function(text){...} //我们��跟String对象��d��了一个trim()�Ҏ��Q?/span>

        >原型对象的问�?/span>
            .原型对象省略了�ؓ构造函��C��低参数这一�l�节�Q�结果所以的实例对象取得的实例值都是一��L��Q�所�?/span>原型对象最大问题就是由本��n本质导成�?/strong>�?/span>
            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
            //所以接下来我们��是�?/span> 解决怎么合理�׃�n,卛_��理��用prototype�Q?/span>

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

             例：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;

            .动态原型模�?br />                   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={...}
                            }
                  }

        >寄生构造函数模�?br />            .在工厂模式上加上参数
             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.�l�承
    一般所有的OO都支持接口��承和实现�l�承�Q�而ECMAScript�?span style="color: #000000">数没�?/span>�{�明的说话（�I�函数标志或者说接口的声明方法）�Q�所以只有实现��承，而实现��承主要是通过原型对象来实��C��?nbsp;
    >原型�?/strong>(重要思想)
        . ��单回��一下构造函敎ͼ�原型和实例的关系
            构造函数的prototype属�?指针)　->　原型地址
            原型的construtcotr属�?指针)     ->   构造函数地址
            实例的_proto_属�?内部指针)           ->   原型对象
        .原型铄��思想
            我们��一个原型对象的指针指向另一个构造函数。如此层层递进�Q�就实现了实例和原型的链�?br />            function SuperType(){
                    this.property = true;
            }
            SuperType.prototype.getSuperValue=function(){
                    return this.property;
            }
            function Subtype(){
                    this.subproperty = false;
            }
            SubType.prototype = new SuperType(); //子类的原型对象指向　生成的超�cȝ��子类�Q�所以有一个_proto_指针指向��类的面型对象）
            SubType.prototype.getSubValue=function(){
                    return this.subproperty;
            }
            Subtype instance = new Subtype();
            instance.getSuperValue();
             分析�Q?br />

            .如果我们调用subType.getSuperValue()�l�过的步骤有�Q?�Q�搜索实例本�w?2�Q�搜索SubType.prototype 3)搜烦SuperType.prototype 4)所有的�c�都是实现Object�Q�所以如果前面没有找到的话，��p��要搜索Object.prototype;所以真正的原型铑ֺ�该是�Q?br />
            //再到�q�来�q�来��一下，不是原型对象的constructor被重写了�Q�而且_proto_指针被重写了�?br />
           . 两种�Ҏ��来确定实现跟原理之间的关�p?br />                //是否是指定类型的实现
                 alert(instance instanceof Object)//true;
                alert(instance instanceof SuperType);//true;
                alert(instance instanceof SubType);//true;
                alert(instance instanceof Data); //false;

                //指定�c�d��的原型对象是否派生了此实�?br />                alert(Object.prototype.isPrototype(instance));//true;
                alert(SuperType.prototype.isPrototype(instance));//true;
                alert(SubType.prototype.isProtoType(instance));//true

            .重写��类�Ҏ��
                在SubType.prototype = new SuperType(); 后面��d��如下�Q?br />                //重写��类�Ҏ��
                SubType.prototype.getSuperValue=function(){
                    return false;
                }

                //不能写成�q�样
                SubType.prototype=new Supertype();
                SubType.prototype={
                     getSuperValue=function(){
                        return false;
                    }
                } //当一使用�q�一句话�Ӟ��上一句话��q��d��效了�Q��ؓ什么呢�Q�前面已�l�说�q�一�q�样��切断了SubType与SuperType.prototype的链�?br />
            .原型铄��问题
                最主要的问题就是包含引用类型类型的�?换一句就�?strong style="color: red">讉K��安全性问�?/strong>�Q�怎么说来着�Q�前面介�l�包含引用类型值的原型属性民会被所有实例共享；而这也正是�ؓ什么要在构造函��C��Q�而不是在原型对象中定义属性的原因。但我们通过原型来实现��承时�Q�原型实际上会变成另一个类型的实例�Q�于是，原先的实例属性和原型对象里面所有的属性和�Ҏ��利成章地变成了现在的原型属性了�Q�从而可以将属性工享这��q��坏了原有的安全性了�?br />

        >借用构造函�?/strong>�Q�也叫伪造对象和�l�典�l�承->常用方式�Q?br />            .无参数版
                function SuperType(){
                    colors:["red","blue","green"];
                }
                function SubType(){
                    //实现�l�承SuperType,��Z��么呢�Q�因为在子类构造函数调用父�c�L��造函数里面的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(){
                    //�l�承了SuperType,同时传递了参数
                    SuperType.call(this,"xcp");
                    //实例属�?br />                    this.age = 23;
                }
                var instance = new SubType();
                alert(instance.name); //xcp
                alert(instance.age); //23

            .借用构造函数的问题
                如果仅仅是借用构造函敎ͼ�那么也将无法避免构造函数模式存在的问题�Q�方法都在构造函��C��定义�Q�这样些函数复用��无从谈起了�?br />
        >�l�合�l�承(也称伪经典��?,指的是将原型铑֒�借用构造函数的技术结合在一��h��Q�从而发挥者这宅的一�U��承模�?br />            .实例(�_�օ�实例)
                function SuperType(name){
                    this.name = name;
                    this.colors = ["red","blue","green"];
                }
                SuperType.prototype.sayName=function(){
                    alret(this.name);
                }
                function SubType(name,age){
                    //�l�承属�?br />                    SuperType.call(this,name);

                    //��d��新属�?br />                    this.age = age;
                }

                //�l�承原型里面的属性和�Ҏ��
                SubType.prototype = new SuperType();
                //��d��新方�?br />                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

                //�l�合�l�承��避免了前面的原型链�Q�父�c�L��有的属性和�Ҏ��均作用子�cȝ��原型对象的属性和�Ҏ��Q�所以就存在数据安全问题了）和借用构造函数的�~�陷�Q�无�׃�n属性和�Ҏ��机制�Q�；成�ؓJavascript中最常用的��承模式。而且�Q�instanceof和isPrototypeOf()也能够用于识别基于组合��承创建的对象�?br />
         >当然�q�包括：原型式��ѝ��寄生式�l�承�{?br />

3.�ȝ��
    >创徏javascript对象的方�?br />        .�Ҏ��Q?br />            构造方法式<接收参数传值实例属�?gt;+原型�?lt;抽取公共�׃�n的方�?gt;
        .实例�Q?br />            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;

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

                    //��d��新属�?br />                    this.age = age;
                }

                //�l�承原型里面的属性和�Ҏ��
                SubType.prototype = new SuperType();
                //��d��新方�?br />                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 发表评论

�W?�?引用�c�d��

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

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

     b. 对列�Ҏ��(先进先出)�Q�push推入�Q�shift取出, unshift塞入
        var colors=["red","blue"];
        colors.push("green"); //推入一��?br />        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�Ҏ��会调�?strong>每个数组的toString()转型�Ҏ��Q�然后得到字�W�串�Q�然后再排序�Q�就会出��C��下情况：
        var values = [0,15,1,10,5];
        values.sort();
        alert(values); //0,1,10,15,5
        //不用说这�U�sort�Ҏ��肯定不是最佳的方式。因此sort�Ҏ��可以接收一个比较函��C��为参敎ͼ�和java的Comparable一��L��作用.
        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:两个或更多数�l�组合而成�?br />        join:�q�回字符串��|��其中包含了连接到一��L��数组的所有元�?nbsp;   values.join(",")    0,1,5,10,15
        slice:�q�回一个数�l�的一�D?nbsp; values.slice(0,2);
        splice:从一个数�l�中�U�除一个或多个元素   values.splice(0,2);
        valueOf:�q�回指定对象的原始�?br />
5.使用Data�c�d��
    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对象(字面量方式创�?/strong>)
        var expression = /pattern/flags;
        �q�里面的pattern ��是��p��匚w��的正则表辄��
        �q�时面的flags包括以下几种�Q?strong>g,i,m
            g�Q�表�C�全局模式(global)�Q�则��模式应用于所有字�W�串�Q�而�ƈ非发现第一个匹配项��q��d��止�?br />            i�Q�表�C�Z��区分大小写（case-insensitive),
            m�Q�表�C�多行模�?mutiline)�Q�即辑ֈ�一行末��时�q�会�l�箋查找下一行是否存在匹配项
            例：var at = /at/g;    匚w��at
                  var at2 = /[bc]at/gi; 匚w��bat,cat。。。。�ƈ且不区分大小�?br />                  var at3 = /.at/gi;   分有以at�l�尾�?个字母的字符�?br />                  注：
                      以下是javascript里面的�{义字�W�：(){}[]\|/^$.?*+ 转义�Ҏ��Q�加\ 。如\\ \$
                  var at4 = /\.at/gi; 所�?at,不区分大��写
    b. 使用RegExp构造函数创�?br />        它接受两个参敎ͼ�一个是要匹配的字符串模式，可选的标志字符丌Ӏ?br />        var at5 = new RegExp("[bc]at","i");
        �׃��RegExp函数模式的参数是字符�Ԍ��所以在某些情况下要对字�W�串�q�行双重转义�Q�如�Q?br />
    c. RegExp的属�?br />        >global�Q�返回true/false,�q�回是否讄��了g标志
        >ignonecase�Q�返回true/false�Q�返回是否设�|�了i标志
        >mutiline�Q�返回true/false,�q�回是否讄��了m标志
        >lastIndex�Q�开始搜索下一个匹配的位置�Q�从0开�?br />        >source�Q�返回正则表辄��
    d. RegExp的方�?br />        >exec�Ҏ��
        var text = "mom and dad and bady";
        var p = /mon( and dad( and bady)?)?/gi;
        var m = p.exec(text); //�q�回匚w��?br />        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语句�Q�如果匹配返回true,否则�q�回false
        var test="000-00-0000";
        var p = /\d{3}-\d{2}-\d{4}/;
        if(p.test(test)){alert("dd");}

    f. Function�c�d��
        a.函数的声�?br />            function test(index){}
            var test = function(index){}
            var test = new Function(index){} //不推�?br />            注：
                >函数没有重蝲功能�Q�如果两个函��C��P��他会直接��前面的�Ҏ��
        b. 函数内部属�?strong>this和arguments
        c. 每个函数都包�?strong>length和prototype属�?br />            length�Q�接受参数的个数
            prototype�Q�原型对象，很重�?br />        d. 每个函数都有两个非��承的�Ҏ��Q?strong>apply()和call()�Ҏ��
            >�q�两个方法的用途都是在特定的作用域中调用函敎ͼ�实际上等于设�|�函��C��内this对象的倹{�?br />            >首先,apply�Ҏ��接受两个参数�Q�一个是在其中运行函数的作用域，另一个是参数数据�Q�可以是Array实例�Q�也可以是arguments对象�Q?br />                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()�Ҏ��来言�Q�第一个参数是作用域没有变�?�Q�变化的只是其余参数都是直接传递跟函数的�?br />                function callSum3(num1,num2){
                    return sum.call(this,num1,num2);
                }
                alert(callSum3(10,10));//20

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

            >真正强大的地�Ҏ��能够扩充函数赖以�q�行的作用域<��是在后面运行的函数的作用域��是我传�q�的作用�?gt;
                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�c�d��
        a. 声明
            var b = true;
            var b = new Boolean(true);
            alert(b instanceof Boolean); //true

    h.Number�c�d��
        a. 声明
            var b1 = 2;
            var b2 = new Number(2);
            var b3 = (Number)"2";

    i.String�c�d��
        a. 声明
            var s1 = "dd";
            var s2 = new String("dd');
        b. 常用�Ҏ��
            charAt,concat, substring,indexOf,toLowerCase,toUpperCase�{?br />
    j.常用内置对象
        a. URI�~�码�Ҏ��Q�encodeURI()和encodeURIComponent(常用)
            比较�Q�encodeURI()用于整个URL;encodeURIComponent用于URL中的某段�q�行�~�码
                     encodeURI不会�Ҏ��w�的URL�Ҏ��字符�q�行�~�码�Q�例如冒��P��正斜杠，问号�?�?而encodeURIComponent�Ҏ��有非标准字符都要�q�行�~�码

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

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

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

1.ECMAScript变量可能包含两种不同的数据类型：基本数据�c�d��和引用数据类�?br />     基本数据�c�d��Q�是指的那些保存�?strong>�?/strong>内存中的��单数据段�Q�即�q�种值完全保存在内存中的一个位�|?br />　　引用�c�d��Q�是指那些保存在�?/strong>内在中的对象�Q�意思是变量中保存的实际上只是一个指针，�q�个指针指向内存中的中�R个位�|�，该位�|�保存对�?br />　　　
2.有两�U�参��C��递方式：传值和传址

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

�W?章、javascript��介和基础

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

一、简�?br />1.javascript实现�׃��部分�l�成�Q�ECMAScript,DOM,BOM
2.ECMAScrip:Javascript ActionScript ScriptEase
3.defer="defer"延迟加蝲

二、基��
(一)、语�?br />       1.区分大小写（变量�Q�函数名�Q�操作符都区分大��写�Q?br />       2.标识�W?br />          2.1 �W�一个字母必��L��Q�字母、_�?
          2.2 其它的允许字母、_�?、和数字
      3.注释
          3.1 单行 //
          3.2 多行 /***/
      4.关键�?br />           this,break,continue,if,else,switch,default,for,do,while,with,new,typeof,instanceof,try,catch,finally,throw,return�{�等
(�?、数据类�?br />      1、基本数据类�?可以保用typeof来取得以�?
          1.1 undefined --- 如果�q�个值未定义
          1.2 boolean    --- 如果�q�个值是布尔�?nbsp;
          1.3 string       --- 如果�q�个值是字符�?br />          1.4 number    --- 如果�q�个值是数字�?br />          1.5 object      --- 如果�q�个值是对象或null
          1.6 function   --- 如果�q�个值是函数
　　2、基本数据类
        Undefined,Boolean,String,Number,Object,Null,Function
     3�?strong>Null与Undefined的区�?br />          Null是指对象定义了，只不�q�指定他为空或者没有赋��|��而Undefined是对象肯定没有定�?br />(�?、操作符
      1、一元操作符
           1.1 递增�Q�递减 ++ --
      2、位操作�W?br />           2.1 Not,And,Or,左移,有符号右�U?无符号右�U?br />      3、关�p�R�?br />      4�?strong>各数据类型之间的操作
(�?、语�?br />      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.内置功能�Q�系�l�类�Q?br />　　1、Function   可以传递参敎ͼ��?strong>arguments得到所以传递参数集�?/div>

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

�W�二十一章、javascript未来API

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

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

亚洲av午夜精品一区二区三区,亚洲日本va中文字幕久久,红杏亚洲影院一区二区三区

�W?�?BOM

�W?�?面向对象�E�序设计

�W?�?引用�c�d��

�W?章、javascript���介和基础

�W�二十一章、javascript未来API

�W?章、javascript��介和基础