DIV CSS 佈局教程網

原生 JavaScript 實現 DIV 拖曳並即時計算重疊面積
編輯:關於JavaScript     

拖曳方塊本身不難,難的是拖曳過程中的「碰撞偵測」:兩個方塊有沒有重疊?重疊了多少?這份範例用九個絕對定位的 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。

Drag:把拖曳封成一個共用模組

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 掛上去。這樣的切分讓同一份拖曳邏輯可以套到任何需要拖曳的場景。

overlap:判斷相交並算出面積

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 軸區間排除大部分元素),再對候選者做精細判斷。

整體來說,這份範例的價值在於把「拖曳」與「碰撞計算」乾淨地分開,並用四角座標把矩形相交判斷寫得直白易懂。理解這個骨架之後,要換成方圓相交、要加上吸附效果、要算覆蓋百分比,都只是在同一個框架上加方法而已。

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