拖曳方塊本身不難,難的是拖曳過程中的「碰撞偵測」:兩個方塊有沒有重疊?重疊了多少?這份範例用九個絕對定位的 div 做實驗,拖動時會即時標出與它相交的方塊,並把重疊面積寫進方塊裡。全部用原生 JavaScript,沒有任何相依套件。
拖曳的部分是標準三步曲:在元素上監聽 mousedown 記錄起始位置與游標偏移,接著在 document 上監聽 mousemove 更新 left/top,最後在 mouseup 移除監聽並收尾。這裡額外做了兩件事:每次按下都遞增 zIndex,讓被拖的方塊永遠在最上層;並扣除 marginLeft/marginTop,避免有邊距時方塊會跳一下。
幾何計算的部分則先取得每個方塊的四個角點座標,再判斷是否相交。核心觀念很樸素:矩形相交就是「彼此的投影區間同時重疊」,只要有一個方向沒有重疊,兩個矩形就一定分離。
現代瀏覽器可以直接用 getBoundingClientRect(),舊版 IE8 則退回逐一累加 offsetLeft/offsetTop 的老方法:
window.objPos = function(elem){
var left = 0, top = 0, right = 0, bottom = 0,
doc = elem ? elem.ownerDocument : document;
if(!elem.getBoundingClientRect || window.Sys.ie8){
var n = elem;
while(n){ left += n.offsetLeft; top += n.offsetTop; n = n.offsetParent; }
right = left + elem.offsetWidth;
bottom = top + elem.offsetHeight;
}else{
var rect = elem.getBoundingClientRect();
left = right = doc.documentElement.scrollLeft || doc.body.scrollLeft;
top = bottom = doc.documentElement.scrollTop || doc.body.scrollTop;
left += rect.left; right += rect.right;
top += rect.top; bottom += rect.bottom;
}
return { "left":left, "top":top, "right":right, "bottom":bottom };
};
順帶一提,原始碼在標準分支裡把 top/bottom 的捲動量誤取成了 scrollLeft。在沒有垂直捲動的頁面上看不出差別,一旦頁面拉長就會產生偏移,實作時記得改成 scrollTop。
var Drag = {
elem : null,
zindex : 0,
options: {},
init : function(){
each(arguments, function(i, elem, oThis){
addListener(elem, 'mousedown', BindAsEventListener(oThis, oThis.start, elem));
}, this);
},
start : function(e, elem){
this.elem = elem;
elem.style.zIndex = ++this.zindex;
this.x = e.clientX - elem.offsetLeft;
this.y = e.clientY - elem.offsetTop;
this.marginLeft = parseInt(currentStyle(elem).marginLeft) || 0;
this.marginTop = parseInt(currentStyle(elem).marginTop) || 0;
Sys.ie ? elem.setCapture() : e.preventDefault();
addListener(document, "mousemove", BindAsEventListener(this, this.move));
addListener(document, "mouseup", Bind(this, this.up));
this.options.callbackmove && this.options.callbackmove(this.elem);
},
move : function(e){
window.getSelection ? window.getSelection().removeAllRanges() : document.selection.empty();
var iLeft = e.clientX - this.x,
iTop = e.clientY - this.y,
obj = this.elem;
obj.style.left = iLeft - this.marginLeft + "px";
obj.style.top = iTop - this.marginTop + "px";
this.options.callbackmove && this.options.callbackmove(this.elem);
},
up : function(){
removeListener(document, 'mousemove');
removeListener(document, 'mouseup');
Sys.ie && this.elem.releaseCapture();
this.options.callbackup && this.options.callbackup(this.elem);
}
};
兩個 callback 是整個設計的關鍵。Drag 只負責移動,不知道也不關心「重疊」這件事;碰撞偵測由外部透過 callbackmove 掛上去。這樣的切分讓同一份拖曳邏輯可以套到任何需要拖曳的場景。
hostel 存放所有參與計算的元素及其四角座標,overlapList 記錄目前處於重疊狀態的元素(供 mouseup 時清除高亮)。每次移動前先用 setElem 更新被拖元素的座標,再呼叫 isOverlap 逐一比對。
var overlap = {
hostel : {}, // 所有需要計算的元素
overlapList : {}, // 已經重合的元素
init : function(elems){
each(elems, function(i, elem, oThis){
elem.setAttribute('overlap', i);
oThis.setElem(elem);
}, this);
},
setElem : function(elem){
if(!elem) return;
var ret = objPos(elem), l = ret.left, t = ret.top, b = ret.bottom, r = ret.right;
this.hostel[elem.getAttribute('overlap')] = {
elem: elem,
leftTopDot : { x:l, y:t },
leftBottomDot : { x:l, y:b },
rightTopDot : { x:r, y:t },
rightBottomDot: { x:r, y:b }
};
},
isOverlap : function(my){
var obj = {}, my = this.hostel[my.getAttribute('overlap')];
each(this.hostel, function(key, config, oThis){
if(config.elem === my.elem) return; // 是自己就跳過
// 任一方向沒有交集即判定為分離
if(my.leftBottomDot.y <= config.leftTopDot.y ||
my.leftTopDot.y >= config.leftBottomDot.y ||
my.rightTopDot.x <= config.leftTopDot.x ||
my.leftTopDot.x >= config.rightTopDot.x) return;
obj[config.elem.getAttribute('overlap')] =
[config.elem, oThis.howOverlap(my, config)];
}, this);
return obj;
},
howOverlap : function(my, other){
var l = other.leftBottomDot.x, r = other.rightTopDot.x,
t = other.leftTopDot.y, b = other.leftBottomDot.y,
arr = [],
lt = this.include(my.leftTopDot, l, r, t, b, 'leftTopDot-rightBottomDot'),
lb = this.include(my.leftBottomDot, l, r, t, b, 'leftBottomDot-rightTopDot'),
rt = this.include(my.rightTopDot, l, r, t, b, 'rightTopDot-leftBottomDot'),
rb = this.include(my.rightBottomDot, l, r, t, b, 'rightBottomDot-leftTopDot');
lt && arr.push(lt) || lb && arr.push(lb) || rt && arr.push(rt) || rb && arr.push(rb);
if(!arr[0]) return 0;
// 一個角或兩個角落在內部,算法相同
if(arr.length === 1 || arr.length === 2){
var key = arr[0].split('-'),
x1 = my[key[0]].x, y1 = my[key[0]].y,
x2 = other[key[1]].x, y2 = other[key[1]].y;
return Math.abs((x1 - x2) * (y1 - y2));
}
// 四角全在內部代表完全覆蓋
if(arr.length === 4) return my.elem.offsetWidth * my.elem.offsetHeight;
},
include : function(dot, l, r, t, b, key){
return (dot.x >= l && dot.x <= r && dot.y >= t && dot.y <= b) ? key : false;
}
};
面積的算法值得說明:判斷被拖元素的四個角,哪些落在目標矩形內。若只有一個角落入,或以對角線方式有兩個角落入,重疊區就是由該角到目標對應邊所圍成的矩形,面積用兩軸差值的絕對值相乘即可。原始碼把「完全覆蓋」的面積寫成 162×162 的定值,那只對應範例裡固定的方塊尺寸;實務上改成 offsetWidth * offsetHeight 才能通用。
window.onload = function(){
extend(Drag.options, { callbackmove: move, callbackup: up });
function up(elem){
for(var n in overlap.overlapList)
removeClass(overlap.overlapList[n][0], 'focus');
overlap.overlapList = {};
Drag.elem.innerHTML = Drag.elem.id; // 還原文字
}
function move(elem){
overlap.setElem(elem); // 先更新自己的座標
var obj = overlap.isOverlap(elem),
name,
p = function(o){
for(name in o) return false; // 有屬性代表有交集
return true;
}(obj);
if(p){ up(); return; } // 沒有任何重疊,直接收尾
var str = '';
overlap.overlapList = obj;
each(overlap.hostel, function(key, config){
if(obj[key]){
addClass(obj[key][0], 'focus');
str = str + '與' + obj[key][0].id + '重合的面積為:' + obj[key][1] + '</br>';
}else{
removeClass(config.elem, 'focus');
}
});
Drag.elem.innerHTML = str;
}
var elems = [];
for(var i = 1; i <= 9; i++) elems.push($('demo' + i));
Drag.init.apply(null, elems);
overlap.init(elems);
};
對應的樣式很單純,九個方塊都是 160×160 的絕對定位元素,重疊時加上 .focus 改變背景色:
.div { height:160px; width:160px; position:absolute; text-align:center; }
.demo1 { border:1px solid #96C2F1; background-color:#EFF7FF; left:150px; top:20px; }
.demo2 { border:1px solid #9BDF70; background-color:#F0FBEB; left:450px; top:20px; }
.focus { background-color:#990000; color:#fff; }
原始作者也提到「感覺效率有點低」,這個觀察是準確的。程式的瓶頸在於每一次 mousemove 都會觸發 objPos(觸發 reflow)、對全部元素做一次線性比對,然後又用 innerHTML 重寫整段字串。幾個方向可以明顯改善:
用 requestAnimationFrame 包住 move 的計算,把每幀多次的滑鼠事件合併成一次更新。
拖曳開始時就快取所有靜止元素的座標,拖曳期間只更新被拖元素,不必每次都重算全部。
把 innerHTML = 改成 textContent,並只在內容真的變動時才寫入,避免每移動一像素就重建 DOM。
若元素數量多,可先做一層粗篩(例如只用 x 軸區間排除大部分元素),再對候選者做精細判斷。
整體來說,這份範例的價值在於把「拖曳」與「碰撞計算」乾淨地分開,並用四角座標把矩形相交判斷寫得直白易懂。理解這個骨架之後,要換成方圓相交、要加上吸附效果、要算覆蓋百分比,都只是在同一個框架上加方法而已。