DIV CSS 佈局教程網

JavaScript 進階技巧筆記:高階函式、計時器、自訂事件與拖放
編輯:JavaScript基礎知識     

這是《JavaScript 高級程序設計》第十八章「高級技巧」的閱讀筆記,整理四個主題:高階函式、高階計時器、自訂事件,以及拖放實作。

一、高階函式

1. 作用域安全的建構函式

直接呼叫建構函式而不加 new 時,由於 this 的晚綁定,它會落到全域物件 window 上,導致屬性被錯誤地掛到 window:

function Person(name, age, job){
this.name = name;
this.age = age;
this.job = job;
}
var person = Person("Jay", 29, "singer"); // 屬性全跑到 window 上了

解法是在建構函式開頭做一次 instanceof 檢查:

function Person(name, age, job){
if(this instanceof Person){
this.name = name;
this.age = age;
}else{
return new Person(name, age);
}
}

要注意一個連帶風險:如果這個作用域安全建構函式被用於「建構函式竊取」式繼承,而沒有搭配原型鏈,繼承關係很可能被打斷。把建構函式竊取與原型鏈(或寄生組合式繼承)一起使用,就能解決:

function Polygon(sides){
if(this instanceof Polygon){
this.sides = sides;
this.getArea = function(){return 0;};}
else{
return new Polygon(sides);
}
}
function Rectangle(width, height){
Polygon.call(this, 2);
this.width = width;
this.height = height;
this.getArea = function(){
return this.width * this.height;
};
}
Rectangle.prototype = new Polygon();
var rect = new Rectangle(5, 10);
alert(rect.sides); // 2

2. 惰性載入函式

惰性載入的意思是:函式的條件判斷分支只會發生一次,也就是第一次呼叫時。在那次呼叫中,函式會把自己覆寫成另一個「直接走對應路徑」的版本,之後任何呼叫都不必再經過判斷。

好處有兩個:真正該執行的程式碼只在實際呼叫時才決定;雖然第一次呼叫因為多了一層函式呼叫而略慢,後續呼叫卻都很快,因為多重條件判斷被省下了。

典型的應用是建立跨瀏覽器的 XHR 物件:

function createXHR(){
if(typeof XMLHttpRequest != "undefined"){
createXHR = function(){
return new XMLHttpRequest();
};
}else if(typeof ActiveXObject != "undefined"){
createXHR = function(){
if(typeof arguments.callee.activeXString != "string"){
var versions = ["MSXML2.XMLHttp.6.0", "MSXML2.XMLHttp.3.0", "MSXML2.XMLHttp"];
for(var i = 0, len = versions.length; i < len; i++){
try{
var xhr = new ActiveXObject(versions[i]);
arguments.callee.activeXString = versions[i];
return xhr;
}catch(ex){
// 略過,試下一個
}
}
}
return new ActiveXObject(arguments.callee.activeXString);
};
}else{
createXHR = function(){
throw new Error("No XHR object available.");
};
}
return createXHR();
}

3. 函式綁定

函式綁定要建立的是一個新函式,它能在特定環境下、帶著指定參數去呼叫另一個函式。最簡陋的 bind() 收一個函式與一個環境,回傳一個在該環境中呼叫原函式、並把參數原封不動傳遞過去的新函式:

function bind(fn, context){
return function(){
return fn.apply(context, arguments);
};
}

代價要記清楚:被綁定的函式比一般函式開銷更大——需要更多記憶體,也因為多了一層函式呼叫而稍慢。所以只在必要時才用。

4. 函式柯里化

柯里化用於建立「已經預先設定好一個或多個參數」的函式。基本手法和函式綁定一樣——用閉包回傳一個函式;差別在於回傳的函式被呼叫時,還會把事先存好的參數併進去:

function bind(fn, context){
var args = Array.prototype.slice.call(arguments, 2);
return function(){
var innerArgs = Array.prototype.slice.call(arguments);
var finalArgs = args.concat(innerArgs);
return fn.apply(context, finalArgs);
};
}

二、高階計時器

JavaScript 是單執行緒語言,計時器的本質是「在間隔時間後把程式碼加入佇列」,而不是「到點立刻執行」。當目前這批程式碼跑完,JavaScript 執行緒會空出一小段時間,讓頁面其他處理得以進行。

1. 重複計時器的兩個毛病

setInterval() 只有在沒有其他該計時器的程式碼實例執行時,才會把計時器程式碼加入佇列。這帶來兩個缺點:某些間隔會被跳過;多個計時器程式碼之間的間隔可能比預期還小。

用鏈式 setTimeout() 可以避開這兩個問題:

setTimeout(function(){
// 處理
if(condition){
setTimeout(arguments.callee, interval);
}
}, interval);

2. 讓出執行權(Yielding)

瀏覽器有「長時間執行腳本」的機制:當程式碼執行超過特定時間或特定語句數量,就不讓它繼續跑。因此,任何預計耗時 200ms 以上的函式,最好切成一系列可用計時器排程的小任務。

陣列分塊技術就是這個思路:為待處理項目建一個佇列,用計時器取出下一項處理,處理完再排下一個計時器。

function chunk(array, process, context){
setTimeout(function(){
var item = array.shift();
process.call(context, item);
if(array.length > 0){
setTimeout(arguments.callee, 100);
}
}, 100);
}

3. 函式節流

DOM 操作比非 DOM 互動需要更多記憶體與 CPU 時間。連續嘗試過量的 DOM 相關操作,可能讓瀏覽器當住甚至崩潰。

節流的核心思想是:某些程式碼不可以在沒有間斷的情況下連續重複執行。做法是在每次呼叫時先清掉前一次排的計時器,重新排一個新的,於是只有「停止操作超過指定時間後」才會真正執行:

var processor = {
timeoutId : null,
// 真正做事的方法
performProcessing : function(){
// 實際執行的內容
},
// 對外呼叫的方法
process : function(){
clearTimeout(this.timeoutId);
var that = this;
this.timeoutId = setTimeout(function(){
that.performProcessing();
}, 100);
}
};
// 嘗試啟動
processor.process();

抽象成通用形式:

function throttle(method, context){
clearTimeout(method.tId);
method.tId = setTimeout(function(){
method.call(context);
}, 100);
}

三、自訂事件

事件其實就是觀察者模式的一種實作,這是一種打造鬆耦合程式碼的技術。

模式中有兩類角色:主體負責發布事件,觀察者則訂閱這些事件以便做出回應。關鍵在於,主體對觀察者的存在一無所知——即使沒有任何觀察者,它也能獨立運作。這種不互相依賴的特性,正是鬆耦合的價值。

自訂事件的實作,是建立一個管理事件的核心物件,讓其他物件可以在上面註冊監聽:

function EventTarget(){
this.handlers = {};
}
EventTarget.prototype = {
constructor : EventTarget,
addHandler : function(type, handler){
if(typeof this.handlers[type] == "undefined"){
this.handlers[type] = [];
}
this.handlers[type].push(handler);
},
fire : function(event){
if(!event.target){
event.target = this;
}
if(this.handlers[event.type] instanceof Array){
var handlers = this.handlers[event.type];
for(var i = 0, len = handlers.length; i < len; i++){
handlers[i](event);
}
}
},
removeHandler : function(type, handler){
if(this.handlers[type] instanceof Array){
var handlers = this.handlers[type];
for(var i = 0, len = handlers.length; i < len; i++){
if(handlers[i] === handler){
break;
}
}
handlers.splice(i, 1);
}
}
};

使用方式:

function handleMessage(event){
alert("message received: " + event.message);
}
// 建立一個新物件
var target = new EventTarget();
// 註冊事件處理器
target.addHandler("message", handleMessage);
// 觸發事件
target.fire({type:"message", message:"hello world!"});
// 移除事件處理器
target.removeHandler("message", handleMessage);

把它應用到自訂型別上更有意思:

function Person(name, age){
EventTarget.call(this);
this.name = name;
this.age = age;
}
inheritPrototype(Person, EventTarget);
Person.prototype.say = function(message){
this.fire({type:"message", message:message});
};

function handleMessage(event){
alert(event.target.name + " says: " + event.message);
}
// 建立一個新的 Person
var person = new Person("Nicholas", 29);
// 註冊事件處理器
target.addHandler("message", handleMessage);
// 呼叫方法,觸發訊息事件
person.say("Hi there");

四、拖放實作

把前面兩個技巧組合起來,就能做出一個帶自訂事件的拖放元件。它在 mousedown 時記錄被拖曳的元素與滑鼠位移,在 mousemove 時更新位置並廣播 drag 事件,在 mouseup 時收尾並廣播 dragend。

var DragDrop = function(){
var dragdrop = new EventTarget();
var dragging = null;
var diffX = 0;
var diffY = 0;

function handleEvent(event){
// 取得事件與目標元素
event = EventUtil.getEvent(event);
var target = EventUtil.getTarget(event);
// 依事件型別分派
switch(event.type){
case "mousedown":
if(target.className.indexOf("draggable") > -1){
dragging = target;
diffX = event.clientX - target.offsetLeft;
diffY = event.clientY - target.offsetTop;
dragdrop.fire({
type:"dragstart",
target: dragging,
x: event.clientX,
y: event.clientY
});
}
break;

case "mousemove":
if(dragging !== null){
event = EventUtil.getEvent(event);
// 指定新位置
dragging.style.left = (event.clientX - diffX) + "px";
dragging.style.top = (event.clientY - diffY) + "px";
dragdrop.fire({
type: "drag",
target: dragging,
x: event.clientX,
y: event.clientY
});
}
break;

case "mouseup":
dragdrop.fire({
type: "dragend",
target: dragging,
x: event.clientX,
y: event.clientY
});
dragging = null;
break;
}
}

// 對外介面
dragdrop.enable = function(){
EventUtil.addHandler(document, "mousedown", handleEvent);
EventUtil.addHandler(document, "mousemove", handleEvent);
EventUtil.addHandler(document, "mouseup", handleEvent);
};
dragdrop.disable = function(){
EventUtil.removeHandler(document, "mousedown", handleEvent);
EventUtil.removeHandler(document, "mousemove", handleEvent);
EventUtil.removeHandler(document, "mouseup", handleEvent);
};
return dragdrop;
}();

這個範例把整章的線索串了起來:閉包保留了內部狀態,EventTarget 提供事件通知,計時器概念則解釋了為什麼拖曳時必須小心 DOM 操作的頻率。四個技巧各自都不複雜,但組在一起就是一個可擴充的元件骨架。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved