Javascript 基础理解

        /*【javascript核心对象包括】
        Array       表述数组。  
        Boolean     表述布尔值。  
        Date        表述日期。  
        Function    指定了一个可编译为函数的字符串 JavaScript 代码。  
        Math        提供了基本的数学常量和函数；如其 PI 属性包含了π的值。  
        Number      表述实数数值。  
        Object      包含了由所有 JavaScript 对象共享的基本功能。  
        RegExp      表述了一个正则表达式；同时包含了由所有正则表达式对象的共享的静态属性。  
        String      表述了一个 JavaScript 字符串。
        */
        
        /*【----理解apply call改变this----】
        //使用指定对象替换当前对象并调用函数
        var Henry = {
        name: 'Henry',
        age: '20'
        };
        function App() {
        this.Say = function () {
        alert('我的名字是'+this.name);
        }
        }
        App.apply(Henry);//理解：分两个步骤  ①改变this指向，并指向Henry；②执行App方法体，将App的属性、方法附加到Henry上（即Henry获得Say方法）
        Henry.Say();//Henry调用获得的Say方法
        */

        /*【----理解 new操作符----】        
        function Student(name, age) {
            this.Say = function () {
                alert("大家好，我是[" + name + "]，今年[" + age + "]岁");
            }
        }
        //第一种
        //这种方式要理解  this始终指向函数（方法）的所有者 
        //函数Student的所有者就是当前页面，即window对象，所以其中的this指向window
        Student("a", 1); //给window添加函数Say
        this.Say();      //通过this(即window)调用Say
        //第二种   改变this指向 将Student附加给
        var s2 = {};
        Student.call(s2, 'c', 3); //理解：将Student的属性、方法附加到s2上  让s2来调用  并将Student中this指到s2
        s2.Say();
        //第三种 使用new的实际过程就相当于第二种
        var s = new Student('b', 2);
        s.Say();*/

        /*【---理解prototype、constructor---】
        function Person(name) {
            this.name = name;
            this.showMe = function () {
                alert(this.name);
            }
        };
        Person.prototype.from = function () {
            alert('I come from prototype.');
        };

        var one = new Person('js');

        //prototype还有一个默认的属性：constructor，是用来表示创建对象的函数的(即我们OOP里说的构造函数)。
        //constructor属性是所有具有prototype属性的对象的成员。
        //它们包括除Global和Math对象以外的所有JScript内部对象。
        //constructor属性保存了对构造特定对象实例的函数的引用。 
        alert(one.constructor); //function Person(name) {...};
        alert(one.prototype)//undefined   
        alert(typeof Person.prototype);//object   
        alert(Person.prototype.constructor);//function Person(name) {...};  
        alert(Person.constructor);  //Function(){ [native code] }*/

        /*【---原型继承---】
        //prototype，是一个对象，因此可以给它添加属性。
        //给prototype添加的属性将会成为使用这个【构造函数创建的对象】的通用属性        
        function TestObjectA() {
            this.MethodA = function () {
                alert(TestObjectA.MethodA());
            }
        }
        function TestObjectB() {
            this.MethodB = function () {
                alert(TestObjectB.MethodB());
            }
        }
        //首先new TestObjectA() 获取所有TestObjectA的所有属性，然后添加到 TestObjectB的prototype属性上
        //这样 通过TestObjectB创建的对象 就包含TestObjectA和TestObjectB两者的所有的属性 即实现继承
        TestObjectB.prototype = new TestObjectA();


        //原型模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节，
        //工作原理是：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过
        //请求原型对象拷贝它们自己来实施创建。 

        //eg:
        function RP() {
            RP.PropertyA = 1;
            RP.MethodA = function () {
                alert("RP.MethodA ");
            };

            this.PropertyA = 100;
            this.MethodA = function () {
                alert("this.MethodA");
            };
        }

        RP.prototype.PropertyA = 10;
        RP.prototype.MethodA = function () {
            alert("RP.prototype.MethodA");
        };

        var rp = new RP();
        alert(rp.PropertyA);//100
        rp.MethodA(); //this.MethodA


        rp = new RP();
        alert(RP.PropertyA); 
        RP.MethodA();
        alert(rp.PropertyA);
        rp.MethodA(); 
        */

        /*【---继承---】        
        比较项                构造继承 原型继承 实例继承 拷贝继承 
        静态属性继承          N        Y        Y        Y
        内置（核心）对象继承  N        部分     Y        Y 
        多参多重继承          Y        N        Y        N 
        执行效率              高       高       高       低 
        多继承                Y        N        N        Y
        instanceof            false    true     false    false
         */

        /*1、构造继承法：在子类中执行父类的构造函数 
        //【构造继承法没有办法继承类型的静态方法】
        function dwn(s) {
            document.write(s + "<br/>");
        }
        function Collection(size) {     //公有方法，可以被继承
            this.size = function () { return size; }
        }
        function _Collection(_size) {
            this._size = function () { return _size; }
        }
        Collection.prototype.isEmpty = function () {    //静态方法，不能被继承
            return this.size() == 0;
        }

        function ArrayList() {
            var m_elements = [];
            m_elements = Array.apply(m_elements, arguments);//实现继承 利用构造函数
            this.base = Collection;
            this.base.call(this, m_elements.length);

            this.base = _Collection;        //可实现多态继承
            this.base.call(this, m_elements.length);

            this.add = function () {
                return m_elements.push.apply(m_elements, arguments);
            }

            this.toArray = function () {
                return m_elements;
            }
        }

        ArrayList.prototype.toString = function () {
            return this.toArray().toString();
        }
        function SortedList() {
            this.base = ArrayList;
            this.base.apply(this, arguments);
            this.sort = function () {
                var arr = this.toArray;
                arr.sort.apply(arr, arguments);
            }
        }

        //        var _arr = new Array(1, 2, 3);
        //        alert(_arr.length);

//        var a = new ArrayList(1, 2, 3);
//        dwn(a);         //1,2,3
//        dwn(a.size());  //3 a从Collection继承了size()方法
//        dwn(a.isEmpty); //undefined 但是a没有继承到isEmpty()方法  【构造继承法没有办法继承类型的静态方法】
//        dwn(a._size()); //3 可以实现多态继承

        //构造一个SortedList
        var b = new SortedList(3, 1, 2);
        dwn(b.toArray());
        b.add(4, 0);
        dwn(b.toArray());
        b.sort();
        dwn(b.toArray());
        dwn(b);
        dwn(b.size());
        */

        /*2、原型继承法  
        //给prototype添加的属性将会成为使用这个【构造函数创建的对象】的通用属性
        function SuperType(_age) {
            this.Name = "SuperType";
            this.Age = _age;
        }
        SuperType.prototype.Say = function () { //静态方法，可以被继承
            alert(this.Name + "_" + this.Age);
        }
        var s = new SuperType(2);
        s.Say();
        function SubType() {
            this.Age = "22";
        }
        SubType.prototype = new SuperType(2);//实现继承
//        SubType.prototype.Say = function () {
//            alert("Subtype:" + this.Name + "_" + this.Age);
//        }
        var sub = new SubType();
        sub.Say();

        alert(sub instanceof SubType);
        alert(sub instanceof SuperType);
        */

        /*3、实例继承法
        构造函数通常没有返回值，它们只是初始化由this值传递进来的对象，并且什么也不返回。
        【如果函数有返回值，被返回的对象就成了new表达式的值。】        
        function dwn(s) {
            document.write(s + "<br/>");
        }
        function MyDate() {
            var instance = new Date();
            instance.printDate = function () {
                dwn(instance.toLocaleString());
            }
            return instance; //【如果函数有返回值，被返回的对象就成了new表达式的值。】
        }
        var date = new MyDate();
        dwn(date.toLocaleString());
        dwn(date instanceof MyDate); //false
        dwn(date instanceof Date);   //true
        //对象的构造函数将会是实际构造的对象的构造函数（new Date()），
        //而不是类型本身的构造函数（new MyDate()）
        */

        /*4、拷贝继承法
        function Point(dimension) {
            this.dimension = dimension;
        }
        var Point2D = function (x, y) {
            this.x = x;
            this.y = y;
        }

        Point2D.extend = function () {
            var p = new Point(2);
            for (var each in p) {
                this.prototype[each] = p[each];
            }
        }
        Point2D.extend();
        //alert(Point2D.dimension);
        alert(Point2D.prototype.dimension);
        var p = new Point2D(1, 2);
        alert(p.dimension);
        */

        /*【---克隆---】
        浅复制(影子克隆):只复制对象的基本类型,对象类型,仍属于原来的引用.
        深复制(深度克隆):不紧复制对象的基本类,同时也复制原对象中的对象.就是说完全是新对象产生的
        
        var DeepExtend = function (destination, source) {
            for (var pro in source) {
                var copy = source[pro];
                if (destination === copy) continue;
                if (typeof copy === "object") {
                    destination[pro] = arguments.callee(destination[pro] || {}, copy);
                } else {
                    destination[pro] = copy;
                }
            }
            return destination;
        }
        */

        /*【---闭包---】
        当函数a的内部函数b被函数a外的一个变量引用的时候，就创建了一个闭包。
        function a() {
            var i = 0;
            function b() {
                alert(++i);
            }
            return b;
        }
        var c = a(); //当函数a的内部函数b被函数a外的一个变量引用的时候，就创建了一个闭包。
        c();
        c();
        
        function x() {
            var a = 0;
            this.b = function () {
                alert(++a);
            }
        }

        var _x = new x();
        _x.b();//1
        _x.b();//2
        var _x2 = new x();
        _x2.b(); //1
        */