JS学习2

JS面向对象
    constructor:对象的构造器(构造函数)
                // 使用 new 关键字创建
                var o = new Object();
                var a = new Array();
                var d = new Date();
            |         |
                object    constructor

               // 使用直接量创建
                var o = {name: 'Xinyang'};
                var a = [1, 2, 3];

    自定义构造器:
    function Person(name,age,birthdate){
        this.name = name;
        this.age = age;
        this.birthdate = birthdate;
        this.changeAge = function(newAge){
            this.age = newAge;
        }

    }

       //create object
        var q = new Person('q',12,new Date(2011,2,1))
        var p = new Person('p',34,new Date(2065,03,12))
                p.changeAge(12)


创建构造器的三种方法:
1.function  ClassName(){...}
2.var class = function(){...}
3.var class = new Function(){...}
并不是所有的函数都可以当成构造器.如var o = Math.min()
 通常自定义的函数都可以当成构造器使用.内置对象的构造器亦可当做构造器.


如果构造器有返回值,并且是对象类型,则对象将直接返回

                function Person(name,age,birthdate){
                    this.name = name;
                    this.age = age;
                    this.birthdate = birthdate;
                    this.changeAge = function(newAge){
                        this.age = newAge;
                    }

                    return {};
                }

                var X = new Person('a',22,new Date())
                X.name//undefined



        this关键字:
                this 在不同环境中指代的对象不同（this 指代的值可在函数运行过程中发生改变）。

                全局环境中:this指代全局对象window
                var val = 10
                alert(this.val)


        构造器中:this指代将被构造出来的对象
        函数中:指代函数的调用者
                NOTE: new Function('console.log(this)') 中的 this 均指代全局对象。
                eval('console.log(this) 则为调用上下文指代的 this。


        this实例:使用 apply 与 call。通过这两个方法来将一个对象中 this 指代的目标进行改变。
        function Point(x, y) {
            this.x = x;
            this.y = y;
            this.move = function(x, y) {
                this.x += x;
                this.y += y;
            }
        }

                var point = new Point(0, 0);
                point.move(1, 1);

                var circle = {x: 0, y: 1, r: 1};

// 改变 point 中 move 方法 this 指代的对象至 circle
                point.move.apply(circle, [1, 1]);
// 同样可以用类似的 call 方法，区别为参数需依次传入
                point.move.call(circle, 1, 1);




原型继承prototype
            function Boss() {
                this.age = 0;
                this.birthdate = null;
                this.name = '';
                this.tasks = [];
            }
                Boss.prototype = {
                    title: 'Boss',
                    gretting: function(){console.log('I am a Boss!');}
                }

                var X = new Boss();
                var Q = new Boss();

// X 与 Q 中具有完全一致（不必唯一的属性或方法）
// 并耗用内存的共享部分
// this.title 与 this.gretting

                var X = new Boss();
                var Q = new Boss();

        // X 与 Q 拥有相同的原型 Boss.prototype

                原型链

                使用原型继承的方法会产生原型链。JavaScript 中对于对象的查找、修改和删除都是通过原型链来完成的。
                判断属性是否为对象本身
                objectName.hasOwnProperty('propertyName');
        // 返回布尔值 true 或 false

                属性查找

                对象的属性查找会更随原型链依次查找，如果在当前环境中无法找到需要的属性则会继续向下一层原型中继续寻找。
                属性修改

                在 JavaScript 中对于对象属性的修改永远只修改对象自身的属性（不论是来源于对象本身还是对象的原型）。当创建当前对象不存在属性时（即便原型拥有此属性），也会为此对象增加改属性。
                修改原型上的属性
                修改原型属性会印象所有被创建出的对象现有的属性和方法。
                ClassName.prototype.propertyName = 'new value';
                ClassName.prototype.methodName = function(){...};

                属性删除

                delete objectName.propertyName 只可删除对象自身的属性，无法删除对象的原型属性。



Object.create(proto[, propertiesObject])
                其为ECMAScript 5 中提出的新建立对象的方式。在 X 中使用隐式的原型对象指向 boss 对象，并将其设为 X 对象的原型。

var boss = {
    title: 'Boss',
    gretting: function(){console.log('Hi, I am a Boss!');}
};

                var X = Object.create(boss);
                X.gretting(); // Hi, I am a Boss!



                低版本中实现 Object.create 功能
                此种方式仍需使用 ClassName.prototype 的方式来实现。


var clone = (function(){
    var F = function(){};
    return function(proto) {
        F.prototype = proto;
        return new F();
    }
})();



                面向对象的应用

                全局变量

                全局变量可在程序任意位置进行访问和修改的变量。滥用全局变量会导致，命名冲突，导致程序不稳定。
                全局标量的三种定义方法：
                var gloablVal = 'value'; 。
                window.gloablVal = 'value'; 附加于 window 对象上
                gloablVal = 'value'; 不使用 var 关键字，也附加于 windwo 对象
                NOTE：delete 无法删除在代码最顶端定义的全局标量 var globale
                封装

                信息隐藏可以保证程序的稳定，将内部信息进行隐藏。其他语言中可词用访问权限来实现封装的概念，像 private、public。
                    JavaScript 中的封装可使用函数的方法（闭包）。