JS基礎(chǔ)之常用小技巧和知識總結(jié)(一)

dadong 發(fā)布于2019-08-20 18:33 / 882人閱讀

摘要：如果有一方是布爾值，則轉(zhuǎn)換為，轉(zhuǎn)換為，再進行判斷。等同運算符類型不同返回類型相同如果同為數(shù)字字符串則比較值如果同為布爾值，相同則為不同為如果兩個操作數(shù)同為引用類型，且引用的為同一個對象函數(shù)，數(shù)組，則相同。

本文主要記錄平時開發(fā)遇到的知識點和小技巧

相等判斷(==)

類型相同：判斷其值是否相同

類型不同：

 1. 如果數(shù)字和字符串比較， 則字符串會被隱式轉(zhuǎn)換為數(shù)字，在做判斷。
 2. 如果有一方是布爾值， 則true 轉(zhuǎn)換為 1， false 轉(zhuǎn)換為 0 ，再進行判斷。
 3. 如果其中有一個值為對象， 則對象會調(diào)取自身的valueOf 或者toString方法進行轉(zhuǎn)換，再做判斷。
 4.undefined 與 null 相等。

等同運算符（===）

類型不同： 返回false
類型相同： 

    1. 如果同為數(shù)字／字符串, 則比較值
    2. 如果同為布爾值， 相同則為true, 不同為false
    3.  如果兩個操作數(shù)同為引用類型，且引用的為同一個對象(函數(shù)，數(shù)組)，則相同。

所以使用 === 進行邏輯判斷的時候，自己就要很清楚兩邊的數(shù)據(jù)類型。比如調(diào)用函數(shù)得到的是字符串"1", 與數(shù)字 1 比較的時候，得到的false, 不要犯類似的低級錯誤。

this指針

javascript中， this表示當前上下文， 即調(diào)用者的引用。

        var tom = {
            sex: "M",
            age: 20
        }


        var jerry = {
            sex: "F",
            age: 18
        }

        function getAge() {
            return this.age;
        }

        console.log(getAge.call(tom)); // 20
        console.log(getAge.call(jerry)); // 18

        // 通過call 方法， 改變了getAge函數(shù)中this的指向， this不會指向getAge函數(shù)本身。
        


        var person = {
            first: "john",
            last: "tom",
            getFull: function () {
                console.log(this.first + " " + this.last);
            }
        }

        person.getFull(); // john tom 
        //this 指向person


        var firstName = "will";
        var lastName = "smith";

        function getFull() {
            console.log(this.firstName + " " + this.lastName);
        }

        getFull(); // will smith
        //調(diào)用者是window，所以 this 指向window。

        function a() {
            console.log(this);
        }
        a.call(null);

call 調(diào)用一個對象的一個方法，以另一個對象替換當前對象。 
格式如 call(thisObj, arg1,arg2...argN)；
在函數(shù)體外部調(diào)用call()方法,如果傳入null，則默認轉(zhuǎn)成window,如果不傳也是一樣,即函數(shù)中的this指向window。
console.log(this) // window;

        function a() {
            console.log(this === window);
        }

        console.log(this === window); // true

        a.call(); // true
        a.call(null); // true
        a.call(this); // true
        a.call(window); // true
        a(); // true

this 的值并非取決于如何被定義， 而是取決于調(diào)用方式。
更多有關(guān)函數(shù)調(diào)用的內(nèi)容請翻閱javascript語言精粹第四章的函數(shù)部分。
更多有關(guān)this的內(nèi)容可以翻閱《你不知道的javascript上卷》第二章。

變量聲明與函數(shù)聲明提升

JavaScript會將所有變量和函數(shù)聲明移動到它的作用域的最前面，這就是所謂的變量提升(Hoisting)。

也就是說，無論你在什么地方聲明變量和函數(shù)，解釋器都會將它們移動到作用域的最前面。因此我們可以先使用變量和函數(shù)，而后聲明它們.

但是，僅僅是變量聲明被提升了，而變量賦值不會被提升。

如果你不明白這一點，有時則會出錯：

console.log(a);  // 輸出undefined
a = 2; // 初始化y

// 上面的代碼等同于
var a;  // 聲明y
console.log(a);  // 輸出undefined
a = 2; // 初始化y

再看一個：

var a;

console.log(a);

a = 1;

function a() {
    // xxx
}

輸出:
/*

function a() {
    // xxx
}
1
*/

javascript永遠是先解析聲明函數(shù)，再解析變量。

執(zhí)行順序如下：
(1) 解析函數(shù)a;
(2) 聲明變量var a; 因為a此時并沒有被賦值，所以它為 undefined, 還是指向原來的值，即函數(shù) function a;
(3) console.log(a); // function a
(4) a = 1; // 重新賦值，輸出1

函數(shù)重載

javascript中是沒有函數(shù)重載的，但是javascript的函數(shù)沒有限制傳入的參數(shù)個數(shù)必須與函數(shù)接收參數(shù)的個數(shù)相同，所以我們可以利用這一特性來模擬函數(shù)重載。

舉個栗子：

        function add() {
            if (arguments.length < 2) {
                return arguments[0];
            } else {
                var _args = [].slice.call(arguments);
                return _args.reduce(function (a, b) {
                    return a + b;
                })
            }
        }

        add(1); // 1
        add(1, 2, 3, 4); // 10

舉個計算日期的栗子：

            // ..
        getFutureDate: function(startDate, afterYear, afterMonth, afterDay) {
            var futureDate, year, month, day;

            if (arguments.length === 3) {
                afterDay = arguments[2];
                afterMonth = arguments[1];
                afterYear = arguments[0];
                startDate = new Date(startDate);
            }

            if (arguments.length === 4 && Object.prototype.toString.call(startDate) !== "[object Date]") {
                startDate = new Date(startDate);
        getFutureDate: function (startDate, afterYear, afterMonth, afterDay) {
            var futureDate, year, month, day;

            if (arguments.length === 3) {
                afterDay = arguments[2];
                afterMonth = arguments[1];
                afterYear = arguments[0];
                startDate = new Date(startDate);
            }

            if (arguments.length === 4 && Object.prototype.toString.call(startDate) !== "[object Date]") {
                startDate = new Date(startDate);
            }

            //計算年
            futureDate = startDate.setFullYear(startDate.getFullYear() + parseInt(afterYear));
            futureDate = new Date(futureDate);
            // 計算月
            futureDate = futureDate.setMonth(futureDate.getMonth() + parseInt(afterMonth));
            futureDate = new Date(futureDate);
            // 計算日
            futureDate = futureDate.setDate(futureDate.getDate() + parseInt(afterDay));
            futureDate = (new Date(futureDate));

            year = futureDate.getFullYear();

            month = futureDate.getMonth() + 1;
            month = month < 10 ? "0" + month : month;

            day = futureDate.getDate();
            day = day < 10 ? "0" + day : day;

            futureDate = [year, month, day].join("-");

            return futureDate
        },
         initDateTime: function () {
            // ...
            var endTime = _that.getFutureDate(new Date(today.replace(/-/g, "/")).getTime(), 0, maxInsuranceMonth, maxInsuranceDay);   
            // ...
        }
        // ...

Map 函數(shù)

    var ary = [1, 2, 3, 4, 5];

    var res = ary.map(function (item, index, input) {
        return item * 10;
    });

    console.log(res); // [10, 20, 30, 40, 50]
    console.log(ary); // [1, 2, 3, 4, 5]

map 函數(shù)的實現(xiàn)：

Array.prototype.map = function (func /*, obj */) {
    var len = this.length;
    //check the argument
    if (typeof func != "function") {
        throw new Error("argument should be a function!");
    }
    var res = [];
    var obj = arguments[1];
    for (var i = 0; i < len; i++) {
        //func.call(), apply the func to this[i]
        res[i] = func.call(obj, this[i], i, this);
    }
    return res;
}

map:和forEach非常相似，都是用來遍歷數(shù)組中的每一項值的，用來遍歷數(shù)組中的每一項；
區(qū)別：map的回調(diào)函數(shù)中支持return返回值；return的是啥，相當于把數(shù)組中的這一項變?yōu)樯叮ú⒉挥绊懺瓉淼臄?shù)組，只是相當于把原數(shù)組克隆一份，把克隆的這一份的數(shù)組中的對應項改變了）；

前面已經(jīng)說過，this會指向調(diào)用者，所以this是指向需要用到map函數(shù)的數(shù)組的。
需要注意的是，map函數(shù)是接收2個參數(shù)的，第二個參數(shù)是第一個參數(shù)的函數(shù)this指向。

柯里化

柯里化就是預先將函數(shù)的某些參數(shù)傳入,得到一個簡單的函數(shù),但是預先傳入的參數(shù)被保存在閉包中,因此會有一些奇特的特性。

var adder = function(num) {
    return function(y) {
        return num + y;
    }
}
console.log(adder(1)(100)); // 101
console.log(adder(2)(100)); // 102

更多內(nèi)容請翻閱上一篇介紹《邂逅函數(shù)柯里化》

遞歸

遞歸在編程中會經(jīng)常使用，在某些時候，遞歸可以給我們減少很多代碼冗余。
比如我們的求階乘函數(shù):

function factorial(n) {
    if (n == 1) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

函數(shù)不停的調(diào)用自身，來達到不停的向下求值相乘，從而實現(xiàn)階乘求值。代碼邏輯也一目了然。

客戶端判斷

var UA = (function (userAgent) {
    var ISOldIOS     = /OS (d)_.* like Mac OS X/g.exec(userAgent),
        isOldAndroid = /Android (d.*?);/g.exec(userAgent) || /Android/(d.*?) /g.exec(userAgent);

    // 判斷設(shè)備是否是IOS7以下
    // 判斷設(shè)備是否是android4.5以下
    // 判斷是否iOS
    // 判斷是否android
    // 判斷是否QQ瀏覽器
    return {
        oldIOS    : ISOldIOS ? +ISOldIOS.pop() < 8 : false,
        oldAndroid: isOldAndroid ? +isOldAndroid.pop().substr(0, 3) < 4.5 : false,
        iOS       : /(i[^;]+;( U;)? CPU.+Mac OS X/.test(userAgent),
        android   : /Android/g.test(userAgent),
        mQQBrowser: /MQQBrowser/g.test(userAgent)
    }
})(navigator.userAgent);