程式的本質,往往在於「順序」與「有序」這兩個概念,這在 JavaScript 中尤其明顯——畢竟它是一款單執行緒的引擎。
JavaScript 擁有函數式編程的特性,加上單執行緒的運行模型,我們撰寫的函數總是需要按部就班地執行。優秀的程式碼通常會把功能切割成各自獨立的模組,再在特定條件成立時觸發。既然這些函數是有序執行的,那麼我們為什麼不設計一個統一管理的物件,專門負責協調這些函數呢?於是,Callbacks(回調函數)應運而生。
JavaScript 的世界裡處處可見函數編程的身影。最簡單的例子莫過於 window.onload,它承接的就是一個函數。但惱人的是,直接賦值給 window.onload 只能掛上一個函數。如果有好幾個函數都想在頁面載入時執行,我們就得寫出這樣的程式碼:
程式碼如下:
function a(elem) {
elem.innerHTML = '我是函數a,我要改變Element的HTML結構';
};
function b(elem) {
elem.innerHTML = '我的函數b,我要改變Element的style';
}
window.onload = function () {
var elem = document.getElementById('test');
a(elem);
b(elem);
};
回調函數的初衷正是建立在這樣的基礎之上:不再讓函數四散在各處,而是把它們統一整理起來。可以看到,我們希望在 window.onload 裡針對同一個 Element 做兩件事——先改變 HTML 結構,再改變它的樣式。這兩個函數操作的都是同一個元素,而它們的執行順序是明確的。既然如此,我們何不設計一個物件來集中管理這些函數呢?
當然,這只是回調函數最基礎的存在意義。我們真正需要的,是一個更強大的回調機制。
Callbacks 的本質就是控制函數有序地執行。JavaScript 是單執行緒引擎,也就是說同一時間只會有一處程式碼在運行——即便是看似非同步的 Ajax 與 setTimeout 也不例外。瀏覽器在執行 JavaScript 時,會把這些程式碼有序地壓入一個佇列,再從佇列中逐一取出執行。Callbacks 正是順應了這種單執行緒引擎的運行特性。
在 jQuery 源碼中,Callbacks 提供了一組函數的基本管理能力,為 Deferred(非同步佇列)奠定了基礎,同時也服務於 Queue(同步佇列)。Deferred 用於抹平大量回調嵌套所產生的「金字塔式」程式碼;而 Queue 則驅動著 jQuery.animate 動畫引擎的運作。
Array(陣列):既然 Callbacks 要承接一系列函數,就必然需要一個容器。我們可以用一個陣列,把每個函數壓入其中,需要執行時再遍歷陣列逐一觸發。
工作模型:這個 Callbacks 需要足夠強大,而不只是「壓入函數、執行函數」這麼簡單,它應該具備良好的執行模型:
once:當前 Callbacks 物件中的所有函數只會執行一次,執行完畢後便會被釋放,確保函數不會重複觸發,讓流程更穩定可靠。
auto:自動執行模型,這是個相當有意思的設計。有些函數依賴上一層函數的結果,例如函數 b 的執行取決於函數 a。我們可以提供這樣的模型:第一次執行 Callbacks 之後,每當有新函數被加入,就自動執行過去已添加的函數,並把最後一次的參數傳遞給它們,從而抹平了依賴函數之間需要反覆觸發的關係。
once&auto:把兩者結合起來就更強大了——每次加入新函數時,過去的函數都會被執行,然後立即釋放;由於 once 模型的關係,下次再加入函數時,這些舊函數不會再被觸發。
add(function):添加一個或多個函數到 Callbacks 物件中。即使你沒有傳入函數,也不會拋出異常。
remove(function):從 Callbacks 中移除指定的函數,為操作提供反悔的餘地。
has(function):判斷 Callbacks 中是否包含某個函數。
empty():清空 Callbacks 中的所有函數,釋放記憶體。
disable():徹底廢棄這個 Callbacks 物件,使其不再可用。
disabled():判斷 Callbacks 是否已被廢棄。
lock(boolean):鎖定 Callbacks 物件,接收一個布林值決定是否鎖定;無參數時則用於查詢目前是否已鎖定。
fire(data):執行 Callbacks 中的函數,傳入的參數會成為這些函數的入參。
fireWith(context,data):執行函數並指定上下文(context)。fire() 中所有函數的上下文都是 Callbacks 物件本身,而 fireWith() 允許你自訂上下文,自由度更高。
fired():判斷 Callbacks 過去是否已經執行過。
我們先來打造一個最簡單的 Callbacks:
程式碼如下:
(function (window, undefined) {
var Callbacks = function () {
//通過閉包保護這些私有變量
var list = [],//回調函數列表
fired;//是否執行過
//返回一個閉包的Callbakcs對象
return {
add: function (fn) {
//當Callbacks廢棄掉的時候,list為undefined
if (list) {
//添加一個回調函數
list.push(fn);
//支持鏈式回調
}
return this;
},
fireWith: function (context, data) {
//觸發回調函數,並指定上下文
if (list) {
fired = true;
for (var i = 0, len = list.length; i < len; i++) {
//當Callbacks中某一個函數返回false的時候,停止Callbacks後續的執行
if (list[i].apply(context, data) === false)
break;
}
}
return this;
},
fire: function () {
//觸發回調函數
//調用fireWith並指定上下文
return this.fireWith(this, arguments);
},
empty: function () {
//清空list即可
if (list)//當這個Callbacks廢棄掉的時候,Callbacks不應該可以繼續使用
list = [];
return this;
},
disable: function () {
//廢棄這個Callbacks對象,後續的回調函數列表不再執行
list = undefined;
return this;
},
disabled: function () {//檢測這個Callbacks是否已經廢掉
//轉換為boolean返回
return !list;
},
fired: function () {//這個callbacks是否執行過
return !!fired;
}
};
};
//注冊到window下
window.Callbacks = Callbacks;
}(window));
接著我們來測試這個 Callbacks:
程式碼如下:
var test = new Callbacks();
test.add(function (value) {
console.log('函數1,value是:' + value);
});
test.add(function (value) {
console.log('函數2,value是:' + value);
});
test.fire('這是函數1和函數2的值');
console.log('查看函數是否執行過:' + test.fired());
test.disable();//廢棄這個Callbacks
console.log('查看函數是否被廢棄:' + test.disabled());
test.add(function () {
console.log('添加第三個函數,這個函數不應該被執行');
});
test.fire();
打開瀏覽器控制台,可以看到運行結果一切正常。
once:once 讓 Callbacks 中的函數執行一次後便不再運行。原理很簡單,我們用一個變數保存當前的執行模型,若是 once 模型,就在 fireWith() 裡讓 list 失效即可。
程式碼如下:
(function (window, undefined) {
var Callbacks = function (once) {
var list = [],
fired;
return {
fireWith: function (context, data) {
if (list) {
fired = true;
for (var i = 0, len = list.length; i < len; i++) {
if (list[i].apply(context, data) === false)
break;
}
}
if (once) list = undefined;
return this;
}
};
};
window.Callbacks = Callbacks;
}(window));
auto:auto(memory)模型在 jQuery 中以 memory 命名,最初這個命名讓不少人感到困惑,仔細研究用法後才確認它其實就是「自動執行」。它的作用是:第一次 fire() 之後,後續 add() 的函數會自動執行。當你已經添加了一組函數,臨時又想追加一個新函數時,這個新函數會立即被執行——為了使用上的便利,這個模式乍看之下確實有點難以理解。
實作關鍵在於:add() 時判斷是否為 auto 模型,若是則執行該函數。但要注意,只有在第一次 fire() 之後才會自動執行,且每次自動執行時都要把最後一次的參數傳遞過去。
jQuery 在這裡採用了一個相當巧妙的用法:讓 auto 變數不僅表示「當前是否為 auto 執行模式」,同時作為「最後一次參數的容器」。它既是 auto,也是 memory,一石二鳥。(以下程式碼依據 jQuery 思路改寫,非原始碼)
程式碼如下:
(function (window, undefined) {
var Callbacks = function (auto) {
var list = [],
fired,
memory,
coreFire = function (data) {
if (list) {
memory = auto && data;
fired = true;
for (var i = 0, len = list.length; i < len; i++) {
if (list[i].apply(data[0], data[1]) === false)
break;
}
}
};
return {
add: function (fn) {
if (list) {
list.push(fn);
if (memory) coreFire(auto);
}
return this;
},
fireWith: function (context, data) {
coreFire([context, data]);
return this;
}
};
};
window.Callbacks = Callbacks;
}(window));
在 jQuery 的設計中,它並不是在 add() 時給 auto(memory)賦值,而是選擇在 coreFire() 中賦值,這樣就能保證只有在第一次 fire() 之後才開啟自動執行。coreFire() 接收的參數是一個陣列,第一項是上下文,第二項是外部傳入的參數,並把整個陣列賦值給 auto,於是 auto 的定義就搖身一變成了 memory(記憶最後一次傳遞的參數)。這正是 auto 這個命名的鬼斧神工之處,值得我們仔細品味。
至於 once&auto 的組合,只需把兩段邏輯揉合在一起:在 coreFire() 裡判斷,如果是 auto 模式就把 list 重置為新陣列,否則直接設為 undefined 即可。
以下這份程式碼是對照 jQuery 手寫的版本,將一些 jQuery 公用函數也一併寫了進來,並非片段,因此可以直接引用運行。
程式碼如下:
(function (window, undefined) {
var isIndexOf = Array.prototype.indexOf,
toString = Object.prototype.toString,
toSlice = Array.prototype.slice,
isFunction = (function () {
return "object" === typeof document.getElementById ?
isFunction = function (fn) {
try {
return /^\s*\bfunction\b/.test("" + fn);
} catch (x) {
return false
}
} :
isFunction = function (fn) { return toString.call(fn) === '[object Function]'; };
})(),
each = function () {
if (arguments.length < 2 || !isFunction(arguments[1])) return;
var list = toSlice.call(arguments[0]),
fn = arguments[1],
item;
while ((item = list.shift())) {
fn.call(window, item);
}
},
inArray = function () {
return isIndexOf ? function (array, elem, i) {
if (array)
return isIndexOf.call(array, elem, i);
return -1;
} : function (elem, array, i) {
var len;
if (array) {
len = array.length;
i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
for (; i < len; i++) {
if (i in array && array[i] === elem) {
return i;
}
}
}
return -1;
}
}();
var Callbacks = function (option) {
option = toString.call(option) === '[object Object]' ? option : {};
var list = [],
_list = [],
fired,
firingStart,
firingLength,
auto,
stack = !option.once && [],
firing = false,
fire = function (data) {
auto = option.auto && data;
fired = true;
firingIndex = firingStart || 0;
firingStart = 0;
firingLength = list.length;
firing = true;
for (; firingIndex < firingLength; firingIndex++) {
if (list[firingIndex].apply(data[0], data[1]) === false) {
auto = false;
break;
}
firing = false;
if (stack) {
if (stack.length)
fire(stack.shift());
}
else if (auto)
list = [];
else
self.disable();
};
var self = {
add: function () {
if (list) {
var start = list.length;
(function addCallback(args) {
each(args, function (item) {
if (isFunction(item)) {
list.push(item);
} else if (toString.call(item) === '[object Array]') {
addCallback(item);
}
});
})(arguments);
}
if (firing)
firingLength = list.length;
else if (auto) {
firingStart = start;
fire(auto);
}
return this;
},
fire: function () {
self.fireWith(this, arguments);
return this;
},
fireWith: function (context, args) {
if (list && (!fired || stack)) {
args = [context,
args ?
args.slice && args.slice()
|| toSlice.call(args) :
[]
];
fire(args);
}
return this;
},
remove: function () {
if (list) {
each(arguments, function (item) {
var index;
while ((index = inArray(item, list, index)) > -1) {
list.splice(index, 1);
if (firing) {
if (index <= firingLength)
firingLength--;
if (index <= firingLength)
firingIndex--;
}
}
});
}
return this;
},
has: function (fn) {
return fn ? inArray(fn, list) > -1 : list && list.length;
},
empty: function () {
list = [];
firingLength = 0;
return this;
},
disable: function () {
list = stack = auto = undefined;
return this;
},
disabled: function () {
return !list;
},
lock: function (isLock) {
if (isLock == null) return !!_list;
if (isLock) {
_list = stack && list.concat(stack) || list;
list = undefined;
} else {
list = _list;
_list = undefined;
}
return this;
},
fired: function () {
return !!fired;
}
};
return self;
};
window.$ = window.$ || {};
window.$.Callbacks = window.Callbacks = Callbacks;
}(window));
Github:https://github.com/linkFly6/linkfly.so/blob/master/LinkFLy/jQuery/jQuery.LinkFLy/Callbacks.js
以上就是本文為大家分享的全部內容,希望對喜愛研究 jQuery 源碼的朋友有所幫助。