Javascript的精華啊【如果以後我看到了或者想到了再繼續補吧】

我不過略有一些討人喜歡的地方而已，怎麼會有什麼迷人的魔力呢？

一.語法

JS只有一個數字類型，64位浮點數，所以1和1.0是相同的。為什麼這麼設計：防止短整型的溢出。

二.對象

1.通常將一個對象的值賦給另一個變數的賦值方法

if(car.name!=null){
    a=car.name;  
}else{
    a='unknown';
}

小技巧（給預設值）：

a=car.name||"unknown";

 2.嘗試從一個對象的屬性中取值

通常

if(car!=undefined){
   a=car.age;
} 
       

小技巧：

a=car&&car.age;

3.枚舉屬性

通常我們會簡單的使用for in

var name;
for(name in  car ){
   ...
}

這樣的後果就是遍歷出來的屬性你可能無法預知，會遍歷到原型上的屬性

小技巧：不適用for in，取而代之用for迴圈

var properties=[
     'name',
     'status',
      'useTime'
];

for(var i=0;i<properties.length;i++){
    car[properties[i]]  ...
}

4.刪除屬性

這個東西估計很少有人會使用到，但是存在既有道理，我就遇到過一個場景，在使用一個第三方的類庫的時候，類庫提供的方法創建的對象有我不需要的屬性，而我要將這個對象轉化為JSON格式的字元串，這個時候刪除屬性這個功能尤其的強大。

Delete car.name ;

三.函數

1.調用

JS中有4種調用方式

• 方法調用模式
• 函數調用模式
• 構造器調用模式
• apply調用模式

四種模式的差異在於 this指向

方法調用模式很好理解，我們寫C#定義一個類CAR，給CAR定義一個方法RUN，這個時候實例化一個對象 jeep ，那麼方法調用就是 jeep.RUN();

JS中同樣如此  

var jeep ={
    run:function(){
     ...
    }
};


jeep.run();

this的指向為調用的對象。

函數調用模式，如下add2函數被調用的方式，直接寫函數名

        function add(a, b) {
            return a + b;
        }
       var shuxue={};
       shuxue.calculate1 = function () {
            var add2 = function () {
                this.value=this.add(3, 3);
            }

           add2();//函數調用模式

        }
        shuxue.calculate1();//方法調用模式
        document.write(shuxue.value);//undefined

        shuxue.calculate2 = function () {
            var that=this;
            var add2 = function () {
                that.value=this.add(3, 3);
            }

            add2();//函數調用模式

        }
        shuxue.calculate2();//方法調用模式
        document.write(shuxue.value);//6

這裡的this指向有點問題，JS設計之初把它指向了全局，如果這樣就會導致上面代碼的異常，代碼定義了一個shuxue的對象，並給他定義了2個方法calculate1和calculate2，我們發現都同樣在函數內部調用了add2函數，add2函數內試圖給對象增加一個屬性

value，calculate1的方式失敗了，calculate2的方式成功了，區別在於後者把this（這時候的this是指向該函數的）給了函數的內部變數that，固定了下來，內嵌的函數使用外部函數的變數，也就是形成了閉包，前者this指向全局。

構造器調用模式

var Car=function(){};

var jeep=new Car();  //有個約定，如果函數是用來new的，那麼大寫開頭，以區別於一般的函數

this指向這個new的對象

apply調用模式

JS是一門函數式的面向對象編程語言，所以函數可以擁有方法

        function add(a, b) {
        return a + b;
        }

        var result=add.apply(null,[3,4]);
        document.write(result);// 7

        function getName(){
            return this.name;
        }

        var car={name:'jeep'};

        var name=getName.apply(car);//  car並沒有getName方法
        document.write(name); //  jeep

 　　this指向apply第一個參數

2.模塊

 我們知道JS很容易造成全局變數的濫用，所以JS提供了一個方法，利用閉包和和函數作用域（JS沒有塊級作用域）構造模塊

        var man=function(){
            var age=12;
            return {
                getYear:function(){
                    return age;
                },
                setYear:function(n){
                    age=n;
                }
            }
        }

        var peter=man();
        document.write(peter.getYear()); //12
        peter.setYear(20);
        document.write(peter.getYear());//20
        document.write(peter.age); //undefined 屬性私有隻能通過介面訪問

3.級聯

這個已經被廣大程式猿們所喜愛了

    var man=function(){
            var age=12;
            return {
                getYear:function(){
                   alert(age);
                    return this;
                },
                setYear:function(n){
                    age=n;
                    return this;
                }
            }
        }

        var peter=man();
        peter.getYear().setYear(20).getYear();  //級聯