DIV CSS 佈局教程網

自己寫一個 DOM 選擇器:解釋器模式與開放封閉原則的實踐
編輯:關於JavaScript     

設計思路

解釋器模式(Interpreter)定義一套語法格式,透過程式解釋執行它並完成任務。CSS 選擇器正是這樣的語言,我們完全可以寫一個自己的解釋器來解析它、找出對應的 DOM 元素。

開放封閉原則要求類別或模組「對擴展開放、對修改封閉」。在這個實作中,id 選擇器、元素選擇器、類選擇器各自封裝為獨立建構函式;日後若要支援屬性選擇器,只需新增一個 AttributeSelector 並在簡單工廠中加一個分支,既有的程式碼不必更動。

匹配方向。瀏覽器匹配 CSS 選擇器時是從右到左的,自製選擇器也應該遵循同樣的行為,才能與原生結果一致。

完整程式碼

(function (ns) {
  /*
  // 支援的語法
  dom.get("p");                    // 元素選擇器
  dom.get("#div");                 // id 選擇器
  dom.get(".span", document.body); // 類選擇器,可指定 context
  dom.get("div.span");             // tag.class
  dom.get("#div .span");           // 後代組合
  dom.get(".ul .li-test");
  */

  var doc = document;
  var simple = /^(?:#|\.)?([\w-_]+)/;

  function api(query, context) {
    context = context || doc;
    // 複雜選擇器優先交給原生 querySelectorAll
    if (!simple.test(query) && context.querySelectorAll) {
      return context.querySelectorAll(query);
    } else {
      return interpret(query, context);
    }
  }

  // 解釋執行選擇符
  function interpret(query, context) {
    var parts = query.replace(/\s+/, " ").split(" ");
    var part = parts.pop();
    var selector = Factory.create(part);
    var ret = selector.find(context);
    return (parts[0] && ret[0]) ? filter(parts, ret) : ret;
  }

  // ID 選擇器
  function IDSelector(id) {
    this.id = id.substring(1);
  }
  IDSelector.prototype = {
    find: function (context) {
      return document.getElementById(this.id);
    },
    match: function (element) {
      return element.id == this.id;
    }
  };
  IDSelector.test = function (selector) {
    return /^#([\w\-_]+)/.test(selector);
  };

  // 元素選擇器
  function TagSelector(tagName) {
    this.tagName = tagName.toUpperCase();
  }
  TagSelector.prototype = {
    find: function (context) {
      return context.getElementsByTagName(this.tagName);
    },
    match: function (element) {
      return this.tagName == element.tagName.toUpperCase() || this.tagName === "*";
    }
  };
  TagSelector.test = function (selector) {
    return /^([\w\*\-_]+)/.test(selector);
  };

  // 類選擇器
  function ClassSelector(className) {
    var splits = className.split('.');
    this.tagName = splits[0] || undefined;
    this.className = splits[1];
  }
  ClassSelector.prototype = {
    find: function (context) {
      var elements, ret = [];
      var tagName = this.tagName;
      var className = this.className;
      var selector = new TagSelector((tagName || "*"));

      if (context.getElementsByClassName) {
        elements = context.getElementsByClassName(className);
        if (!tagName) return elements;
        for (var i = 0, n = elements.length; i < n; i++) {
          if (selector.match(elements[i])) ret.push(elements[i]);
        }
      } else {
        elements = selector.find(context);
        for (var i = 0, n = elements.length; i < n; i++) {
          if (this.match(elements[i])) ret.push(elements[i]);
        }
      }
      return ret;
    },
    match: function (element) {
      var regex = new RegExp("(^|\\s)" + this.className + "($|\\s)");
      return regex.test(element.className);
    }
  };
  ClassSelector.test = function (selector) {
    return /^([\w\-_]+)?\.([\w\-_]+)/.test(selector);
  };

  // TODO: 屬性選擇器
  function AttributeSelector(attr) {
    this.find = function (context) {};
    this.match = function (element) {};
  }
  AttributeSelector.test = function (selector) {
    return /\[([\w\-_]+)(?:=([\w\-_]+))?\]/.test(selector);
  };

  // 依父級元素過濾(由右至左)
  function filter(parts, nodeList) {
    var part = parts.pop();
    var selector = Factory.create(part);
    var ret = [];
    var parent;
    for (var i = 0, n = nodeList.length; i < n; i++) {
      parent = nodeList[i].parentNode;
      while (parent && parent !== doc) {
        if (selector.match(parent)) { ret.push(nodeList[i]); break; }
        parent = parent.parentNode;
      }
    }
    return parts[0] && ret[0] ? filter(parts, ret) : ret;
  }

  // 簡單工廠:依選擇符字串建立對應的選擇器物件
  var Factory = {
    create: function (query) {
      if (IDSelector.test(query)) {
        return new IDSelector(query);
      } else if (ClassSelector.test(query)) {
        return new ClassSelector(query);
      } else {
        return new TagSelector(query);
      }
    }
  };

  ns.dom || (ns.dom = {});
  ns.dom.get = api;
}(this));

這個實作的架構價值

api 是入口,負責判斷「能不能交給原生處理」。能就交出去,不能才走 interpret。interpret 把選擇器拆成若干段,從最右段開始建立選擇器物件並求值,剩下的段落交給 filter 逐層往上比對父元素,形成递归。

Factory 是擴充點。要新增屬性選擇器,只需實作 AttributeSelector 的 find 與 match,再把它加進 Factory 的分支判斷即可,其他部分完全不用動——這就是開放封閉原則的具體體現。

為什麼今天不該真的這樣寫

這個練習的價值在於理解選擇器解析與設計模式,但實際專案中,querySelectorAll 已經原生支援完整的 CSS 選取器語法,效能由瀏覽器以 C++ 實作,任何 JavaScript 版本都無法比擬。

此外,這份程式碼有幾個實際的缺口:simple 這個 regex 判斷過於粗糙,遇到 a > b、[href^="http"] 等語法會誤判;ClassSelector 的 match 用 regex 比對 className,對 SVG 元素會失效;filter 只處理後代關係,不支援 >、+、~ 等 combinator;回傳值型別在「單一元素」與「NodeList」之間搖擺,呼叫端無從預期。

若你真的需要自製選擇器(例如實作一個受限的查詢 DSL),請改用 Tokenizer 加 Pratt parser 的正規做法,把語法定義清楚、錯誤訊息做完整,並補上完整的測試。以 regex 逐段切分的策略在語法一複雜化之後就會迅速失控。

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