解釋器模式(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 逐段切分的策略在語法一複雜化之後就會迅速失控。