想成为JS大神必须会的东西

定制对象

var house = {
        rooms: 7,
        sharedEntrance: false,
        lock:function(){},
        unlock:function(){}
    };
    alert(house.rooms);
    alert(house.sharedEntrance);
    
    house.rooms = 8;
    alert(house.rooms);

类

function Accommodation(){};

    var house = new Accommodation();  //用new创建出来的对象都被称作是这个函数所示结构的对象实例
    var apartment = new Accommodation();  //创建对象的过程就叫做模板实例化的过程
    
    
    //找出对象的构造器
    alert(house.constructor === Accommodation);  //true
    //还可以用 instanceof 来完成
    alert(apartment instanceof Accommodation);

公有私有保护的属性和方法

var Accommodation = (function(){
        //定义“类”的构造函数，因为处在一个新的函数内，我们也切换到一个新的作用域中，所以可以使用与保存函数返回值得那个变量相同的名字
        function Accommodation(){};
        //此处定义的所有变量都是私有的，为了区分加了_,这些变量在当前作用域之外不能用。
        var _isLocked = false,
        _isAlarmed = false,
        _alarmMessage = "Alarm activated";
        
        //仅在当前作用域中定义的函数也都是私有的
        function _alarm(){
            _isAlarmed = true;
            alert(_alarmMessage);
        }
        
        function _disableAlarm(){
            _isAlarmed = false;
        }
        
        //所有定义在原型上的方法都是公有的，当我们在此处创建类在闭包结束处被返回后，就可以在当前作用域之外访问这些方法了
        Accommodation.prototype.lock = function(){
            _isLocked = true;
            _alarm();
        }
        
        Accommodation.prototype.unlock =  function(){
            _isLocked = true;
            _disableAlarm();
        }
        
        //定义一个getter函数来对私有变量_isLocked的值进行只读访问——相当于把该变量定义为“受保护的”
        Accommodation.prototype.getIsLocked = function(){
            return _isLocked;
        }
        
        //定义一个setter函数来对私有变量_alarmMessage进行只写访问——相当于将其定义为“受保护的”
        Accommodation.prototype.setAlarmMessage = function(message){
            _alarmMessage = message;
        };
        //返回在这个作用域中创建的“类”，使之在外层作用域中即后面代码的所有位置都可用。只有共有的属性和方法是可用的。
        return Accommodation;
    }());
    var house = new Accommodation();
    house.lock();
//  house._alarm(); //报错
    alert(house._isLocked);  //undefined
    console.log(house.getIsLocked());  //true
    house.setAlarmMessage("The alarm is now activated!");
    house.lock(); //"The alarm is now activated!"

一个用于简化其他“类”创建的基“类”

//定义一个名为Class的对象，该对象有一个create()方法用于创建新的“类”。我们用闭包来维护内部函数；
    //避免公开暴露这些函数
    var Class = (function(){
        //调用create()方法时，它将根据一个对象直接量来定义并且返回一个新的“类”，该对象直接量为这个“类”的原型提供了各种公有属性和方法。
        //一个名为initialize()的方法将被作为构造函数来执行。如果代表父“类”的可选参数paraentPrototype被传入，则新创建的“类”将成为该父“类”的子类
        function create(classDefinition,parentPrototype){
            //定义新“类”的构造函数，如果classDefinition对象直接量包含initialize()方法，则在构造函数中使用该方法
            var _NewClass() = function(){
                if(this.initialize && typeof this.initialize === 'function'){
                    this.initialize.apply(this,arguments);
                }
            },
            _name;
            //(在继承其他“类”时)如果传入一个parentPrototype对象
            //则子类将继承parentPrototypee的所有属性和方法
            if(parentPrototype){
                _NewClass.prototype = new parentPrototype.constructor();
                
                for (_name in parentPrototype) {
                    if (parentPrototype.hasOwnProperty(_name)) {
                        _NewClass.prototype[_name] = parentPrototype[_name];
                    }
                }
            }
            
            //通过定义一个函数来创建闭包，然后在闭包中返回另一个函数来替代传入的函数
            //将传入的函数包装起来，并为当前对象提供一个_parent()方法，
            //以支持父“类”中同名方法的访问，这样就实现了多态的支持
            
            function polymorph(thisFunction,parentFunction){
                return function(){
                    var output;
                     this._parent = parentFunction;
                     
                     output = thisFunction.apply(this,arguments);
                     
                     delete this._parent;
                     
                     return output;
                };
            }
            
            //将作为参数传入的“类”定义应用到新创建的“类”上，
            //覆盖所有parentPrototype中已存在的属性和方法
            for (_name in classDefinition) {
                if (classDefinition.hasOwnProperty(_name)) {
                    //如果正在利用多态，即创建和父“类”方法同名的新方法，
                    //我们希望提供一种在子“类”方法中调用父“类”同名方法的简单方式
                    if (parentPrototype && parentPrototype[_name] && typeof classDefinition[_name] === 'function') {
                        _NewClass.prototype[_name] = polymorph(classDefinition[_name],parentPrototype[_name]);
                    }else{
                        //如果不需要多态，则直接将calssDefinition对象直接量中的项映射到新“类”的原型即可
                        _NewClass.prototype[_name] = classDefinition[_name];
                    }
                }
            }
            
            //确保构造函数属性设置正确，不管是否继承
            //（以防classDefinition对象直接量包含名为constructor的属性方法）
            _NewClass.prototype.constructor = _NewClass;
            
            //为新创建的“类”自身定义一个extend()方法，指向私有的extend()函数，这个函数定义在下面，
            //我们通过此方法可以将当前“类”作为父“类”来创建一个新的子类
            _NewClass.extend = extend;
            return _NewClass;
        }
        
        //extend()与create()方法相同，不过隐含了一个额外的参数，即用来进行继承的父“类”的原型
        function extend(classDefinition){
            return create(classDefinition,this.prototype);
        }
        
        //用相同的名字将私有的create()方法暴露
        return {create: create};
    }());

对象方法

var personalDetails = {
        name:"Den Odell",
        email: 
    };
    
    console.log(Object.isExtensible(personalDetails));//true
    
    //阻止对personalDetails对象进行扩展
    Object.preventExtensions(personalDetails);
    
    console.log(Object.isExtensible(personalDetails));//false
    
    //尝试为personalDetails对象添加一个新属性
    personalDetails.age = 35;  //如果开启严格模式就会报错