Function模式使用技巧彙總

作者 | 湯姆大叔

介紹

今天這篇文章，主要跟大家分享Function模式方面的一些使用技巧，利用Function特性可以編寫出很多非常有意思的代碼，包括：回調模式、配置對象、傳回函數、分布程式、柯裡化（Currying）。

其次就是一些初始化模式和性能模式，主要是用在初始化以及提高性能方面。

回調函數

在JavaScript中，當一個函數A作為另外一個函數B的其中一個參數時，則函數A稱為回調函數，即A可以在函數B的周期内執行（開始、中間、結束時均可）。

舉例來說，有一個函數用于生成node。

var complexComputation = function () { /* 内部處理，并傳回一個node*/};

有一個findNodes函數聲明用于查找所有的節點，然後通過callback回調進行執行代碼。

var findNodes = function (callback) {
var nodes = [];


var node = complexComputation();


// 如果回調函數可用，則執行它
if (typeof callback === "function") {
callback(node);
}


nodes.push(node);
return nodes;
};

關于callback的定義，我們可以事先定義好來用：

// 定義callback
var hide = function (node) {
node.style.display = "none";
};


// 查找node，然後隐藏所有的node
var hiddenNodes = findNodes(hide);

也可以直接在調用的時候使用匿名定義，如下：

// 使用匿名函數定義callback
var blockNodes = findNodes(function (node) {
node.style.display = 'block';
});

我們平時用的最多的，估計就數jQuery的ajax方法的調用了，通過在done/faild上定義callback，以便在ajax調用成功或者失敗的時候做進一步處理，代碼如下(本代碼基于jquery1.8版)：

var menuId = $("ul.nav").first().attr("id");
var request = $.ajax({
  url: "script.php",
  type: "POST",
  data: {id : menuId},
  dataType: "html"
});


//調用成功時的回調處理
request.done(function(msg) {
  $("#log").html( msg );
});


//調用失敗時的回調處理
request.fail(function(jqXHR, textStatus) {
  alert( "Request failed: " + textStatus );
});

配置對象

如果一個函數（或方法）的參數隻有一個參數，并且參數為對象字面量，我們則稱這種模式為配置對象模式。例如，如下代碼：

var conf = {
    username:"shichuan",
    first:"Chuan",
    last:"Shi"
};
addPerson(conf);

則在addPerson内部，就可以随意使用conf的值了，一般用于初始化工作，例如jquery裡的ajaxSetup也就是這種方式來實作的：

// 事先設定好初始值
$.ajaxSetup({
   url: "/xmlhttp/",
   global: false,
   type: "POST"


 });


// 然後再調用
 $.ajax({ data: myData });

另外，很多jquery的插件也有這種形式的傳參，隻不過也可以不傳，不傳的時候則就使用預設值了。

傳回函數

傳回函數，則是指在一個函數的傳回值為另外一個函數，或者根據特定的條件靈活建立的新函數，示例代碼如下：

var setup = function () {
    console.log(1);
    return function () {
        console.log(2);
    };
};


// 調用setup 函數
var my = setup(); // 輸出 1
my(); // 輸出 2
// 或者直接調用也可
setup()();

或者你可以利用閉包的特性，在setup函數裡記錄一個私有的計數器數字，通過每次調用來增加計數器，代碼如下：

var setup = function () {
    var count = 0;
    return function () {
        return ++count;
    };
};


// 用法
var next = setup();
next(); // 傳回 1
next(); // 傳回 2
next(); // 傳回 3

偏應用

這裡的偏應用，其實是将參數的傳入工作分開進行，在有的時候一系列的操作可能會有某一個或幾個參數始終完全一樣，那麼我們就可以先定義一個偏函數，然後再去執行這個函數（執行時傳入剩餘的不同參數）。

舉個例子，代碼如下：

var partialAny = (function (aps) {


    // 該函數是你們自執行函數表達式的結果，并且指派給了partialAny變量
 function func(fn) {
        var argsOrig = aps.call(arguments, 1);
        return function () {
            var args = [],
                argsPartial = aps.call(arguments),
                i = 0;


            // 變量所有的原始參數集， // 如果參數是partialAny._ 占位符，則使用下一個函數參數對應的值 // 否則使用原始參數裡的值
            for (; i < argsOrig.length; i++) {
                args[i] = argsOrig[i] === func._
                            ? argsPartial.shift()
                            : argsOrig[i];
            }


            // 如果有任何多餘的參數，則添加到尾部
            return fn.apply(this, args.concat(argsPartial));
        };
    }


    // 用于占位符設定
    func._ = {};


    return func;
})(Array.prototype.slice);

使用方式如下：

// 定義處理函數
function hex(r, g, b) {
    return '#' + r + g + b;
}


//定義偏函數, 将hex的第一個參數r作為不變的參數值ff
var redMax = partialAny(hex, 'ff', partialAny._, partialAny._);


// 新函數redMax的調用方式如下，隻需要傳入2個參數了：
console.log(redMax('11', '22')); // "#ff1122"

如果覺得partialAny._太長，可以用__代替哦。

var __ = partialAny._;


var greenMax = partialAny(hex, __, 'ff');
console.log(greenMax('33', '44'));


var blueMax = partialAny(hex, __, __, 'ff');
console.log(blueMax('55', '66'));


var magentaMax = partialAny(hex, 'ff', __, 'ff');
console.log(magentaMax('77'));

這樣使用，就簡潔多了吧。

Currying

Currying是函數式程式設計的一個特性，将多個參數的處理轉化成單個參數的處理，類似鍊式調用。

舉一個簡單的add函數的例子：

function add(x, y) {
    var oldx = x, oldy = y;
    if (typeof oldy === "undefined") { // partial
        return function (newy) {
            return oldx + newy;
        }
    }
    return x + y;
}

這樣調用方式就可以有多種了，比如：

// 測試
typeof add(5); // "function"
add(3)(4); // 7


// 也可以這樣調用
var add2000 = add(2000);
add2000(10); // 2010

接下來，我們來定義一個比較通用的currying函數：

// 第一個參數為要應用的function，第二個參數是需要傳入的最少參數個數
function curry(func, minArgs) {
    if (minArgs == undefined) {
        minArgs = 1;
    }


    function funcWithArgsFrozen(frozenargs) {
        return function () {
            // 優化處理，如果調用時沒有參數，傳回該函數本身
            var args = Array.prototype.slice.call(arguments);
            var newArgs = frozenargs.concat(args);
            if (newArgs.length >= minArgs) {
                return func.apply(this, newArgs);
            } else {
                return funcWithArgsFrozen(newArgs);
            }
        };
    }


    return funcWithArgsFrozen([]);
}

這樣，我們就可以随意定義我們的業務行為了，比如定義加法：

var plus = curry(function () {
    var result = 0;
    for (var i = 0; i < arguments.length; ++i) {
        result += arguments[i];
    }
    return result;
}, 2);

使用方式，真實多種多樣哇。

plus(3, 2) // 正常調用
plus(3) // 偏應用，傳回一個函數（傳回值為3+參數值）
plus(3)(2) // 完整應用（傳回5）
plus()(3)()()(2) // 傳回 5
plus(3, 2, 4, 5) // 可以接收多個參數
plus(3)(2, 3, 5) // 同理

如下是減法的例子。

var minus = curry(function (x) {
    var result = x;
    for (var i = 1; i < arguments.length; ++i) {
        result -= arguments[i];
    }
    return result;
}, 2);

或者如果你想交換參數的順序，你可以這樣定義

var flip = curry(function (func) {
    return curry(function (a, b) {
        return func(b, a);
    }, 2);
});

立即執行的函數

關于這個内容，你可以看看前面的《深入了解JavaScript之立即調用的函數表達式》中，我們已經對類似的函數進行過詳細的描述，這裡我們隻是再舉兩個簡單的例子做一下總結。

// 聲明完函數以後，立即執行該函數
(function () {
    console.log('watch out!');
} ());


//這種方式聲明的函數，也可以立即執行
!function () {
    console.log('watch out!');
} ();


// 如下方式也都可以哦
~function () { /* code */ } ();
-function () { /* code */ } ();
+function () { /* code */ } ();

立即執行的對象初始化

該模式的意思是指在聲明一個對象（而非函數）的時候，立即執行對象裡的某一個方法來進行初始化工作，通常該模式可以用在一次性執行的代碼上。

({
    // 這裡你可以定義常量，設定其它值
    maxwidth: 600,
    maxheight: 400,


    // 當然也可以定義utility方法
    gimmeMax: function () {
        return this.maxwidth + "x" + this.maxheight;
    },


    // 初始化
    init: function () {
        console.log(this.gimmeMax());
        // 更多代碼...
    }
}).init();  // 這樣就開始初始化咯

分支初始化

分支初始化是指在初始化的時候，根據不同的條件（場景）初始化不同的代碼，也就是所謂的條件語句指派。之前我們在做事件處理的時候，通常使用類似下面的代碼：

var utils = {
    addListener: function (el, type, fn) {
        if (typeof window.addEventListener === 'function') {
            el.addEventListener(type, fn, false);
        } else if (typeof document.attachEvent !== 'undefined') {
            el.attachEvent('on' + type, fn);
        } else {
            el['on' + type] = fn;
        }
    },
    removeListener: function (el, type, fn) {
    }
};

我們來改進一下，首先我們要定義兩個接口，一個用來add事件句柄，一個用來remove事件句柄，代碼如下：

var utils = {
    addListener: null,
    removeListener: null
};

實作代碼如下：

if (typeof window.addEventListener === 'function') {
    utils.addListener = function (el, type, fn) {
        el.addEventListener(type, fn, false);
    };
} else if (typeof document.attachEvent !== 'undefined') { // IE
    utils.addListener = function (el, type, fn) {
        el.attachEvent('on' + type, fn);
    };
    utils.removeListener = function (el, type, fn) {
        el.detachEvent('on' + type, fn);
    };
} else { // 其它舊浏覽器
    utils.addListener = function (el, type, fn) {
        el['on' + type] = fn;
    };
    utils.removeListener = function (el, type, fn) {
        el['on' + type] = null;
    };
}

用起來，是不是就很友善了？代碼也優雅多了。

自聲明函數

一般是在函數内部，重寫同名函數代碼，比如：

var scareMe = function () {
    alert("Boo!");
    scareMe = function () {
        alert("Double boo!");
    };
};

這種代碼，非常容易使人迷惑，我們先來看看例子的執行結果：

// 1\. 添加新屬性
scareMe.property = "properly";
// 2\. scareMe賦與一個新值
var prank = scareMe;
// 3\. 作為一個方法調用
var spooky = {
    boo: scareMe
};
// 使用新變量名稱進行調用
prank(); // "Boo!"
prank(); // "Boo!"
console.log(prank.property); // "properly" // 使用方法進行調用
spooky.boo(); // "Boo!"
spooky.boo(); // "Boo!"
console.log(spooky.boo.property); // "properly"

通過執行結果，可以發現，将定于的函數指派與新變量（或内部方法），代碼并不執行重載的scareMe代碼，而如下例子則正好相反：

// 使用自聲明函數
scareMe(); // Double boo!
scareMe(); // Double boo!
console.log(scareMe.property); // undefined

大家使用這種模式時，一定要非常小心才行，否則實際結果很可能和你期望的結果不一樣，當然你也可以利用這個特殊做一些特殊的操作。

記憶體優化

該模式主要是利用函數的屬性特性來避免大量的重複計算。通常代碼形式如下：

var myFunc = function (param) {
    if (!myFunc.cache[param]) {
        var result = {};
        // ... 複雜操作 ...
        myFunc.cache[param] = result;
    }
    return myFunc.cache[param];
};


// cache 存儲
myFunc.cache = {};

但是上述代碼有個問題，如果傳入的參數是toString或者其它類似Object擁有的一些公用方法的話，就會出現問題，這時候就需要使用傳說中的hasOwnProperty方法了，代碼如下：

var myFunc = function (param) {
    if (!myFunc.cache.hasOwnProperty(param)) {
        var result = {};
        // ... 複雜操作 ...
        myFunc.cache[param] = result;
    }
    return myFunc.cache[param];
};


// cache 存儲
myFunc.cache = {};

或者如果你傳入的參數是多個的話，可以将這些參數通過JSON的stringify方法生産一個cachekey值進行存儲，代碼如下：

var myFunc = function () {
    var cachekey = JSON.stringify(Array.prototype.slice.call(arguments)),
        result;
    if (!myFunc.cache[cachekey]) {
        result = {};
        // ... 複雜操作 ...
        myFunc.cache[cachekey] = result;
    }
    return myFunc.cache[cachekey];
};


// cache 存儲
myFunc.cache = {};

或者多個參數的話，也可以利用arguments.callee特性：

var myFunc = function (param) {
    var f = arguments.callee,
        result;
    if (!f.cache[param]) {
        result = {};
        // ... 複雜操作 ...
        f.cache[param] = result;
    }
    return f.cache[param];
};


// cache 存儲
myFunc.cache = {};

Function模式使用技巧彙總

介紹

回調函數

配置對象

傳回函數

偏應用

Currying

立即執行的函數

立即執行的對象初始化

分支初始化

自聲明函數

記憶體優化

總結

繼續閱讀

主流浏覽器四大綜合性能測試

JavaScript自學筆記【4】函數的聲明與調用目錄二、函數的聲明三、函數的調用

請求逾時VUE axios重新再次請求

nodejs微信開發---授權登入+擷取使用者資訊微信網頁授權

debian9更新4.9.0核心到4.19.2核心過程

Javascript建構Bingo卡片遊戲

JavaScript的那些坑之事件代理事件代理事件階段

javascript的for (var i in data)慎用javascript中的for (var i in data)謹慎用

tab滑鼠經過菜單切換

vue （vue2.0）使用總結(從大體結構總結)

vue搭建過程及出現問題

/\B(?=(?:\d{3})+$)/g 一條令人費解的正規表達式

适用于JavaScript的ECMAScript 2020規範向前發展

JS生成uuid的四種方法

layui多任務上傳添加進度條