DIV CSS 佈局教程網

跨瀏覽器取得頁面中相同 class 節點的兩種方案
編輯:關於JavaScript     

在網頁開發中,我們經常需要一次操作多個 class 相同的元素。筆試時就常出現這道題:如何取得頁面中所有 class 為 test 的節點。本文整理兩套思路:一套來自經典書籍的相容性寫法,另一套是兼顧效能與多 class 查詢的完整實作。

原生 getElementsByClassName 的用法

HTML5 的 DOM 新增了 getElementsByClassName,可以透過 class 屬性中的類名直接存取元素。由於這個方法出現得比較晚,早期瀏覽器的 DOM 實作並沒有它,使用前需要先做特性偵測。

它與 getElementsByTagName 類似,只接受一個參數,回傳值也是一個集合:

getElementsByClassName(class)

以下程式碼回傳所有 class 為 sale 的元素:

document.getElementsByClassName("sale")

要查詢同時帶有多個 class 的元素,只要在字串參數中以空格分隔即可:

alert(document.getElementsByClassName("sale important").length);

完整示範頁面

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>Shopping List</title>
</head>
<body>
    <h1>What to buy</h1>
    <p title="a gentle reminder">Don't forget to buy this stuff.</p>
    <ul id="purchase">
        <li>A tin of beans</li>
        <li class="sale">Cheese</li>
        <li class="sale important">Milk</li>
    </ul>
    <script>
        alert(document.getElementsByClassName("sale important").length);
    </script>
</body>
</html>

提示框會顯示 1,因為只有一個元素同時帶有 important 與 sale。值得留意的是,元素上 class 的實際撰寫順序不影響比對結果,即使寫成 sale important 而查詢時寫成 important sale 也一樣會命中;元素就算還帶有其他 class 也不受影響。

跟 getElementsByTagName 一樣,它可以與 getElementById 串接使用,先定位容器再縮小範圍:

var shopping = document.getElementById("purchase");
var sales = shopping.getElementsByClassName("sale");
alert(sales.length); // 2

這樣 sales 裡就只包含 purchase 清單中帶有該 class 的元素。

方案一:Jeremy Keith 的相容性寫法

Jeremy Keith 在《JavaScript DOM 編程藝術》(第 2 版)第三章中介紹了自建 getElementsByClassName 的思路,並特別處理了不支援該方法的老舊 IE。核心做法是:有原生方法就用原生的,沒有就遍歷所有標籤逐一比對 className:

function getElementsByClassName(node, classname) {
    if (node.getElementsByClassName) {
        return node.getElementsByClassName(classname);
    } else {
        var results = [];
        var elems = node.getElementsByTagName("*");
        for (var i = 0; i < elems.length; i++) {
             if (elems[i].className.indexOf(classname) != -1) {
                 results[results.length] = elems[i];
             }
        }
        return results;
    }
}

這個函式接受兩個參數:node 是搜尋起點,classname 是要找的類名。若傳入的節點本身已有原生方法,就直接回傳結果;否則遍歷所有標籤比對。

它的缺點有兩個:不支援多 class 查詢,而且用 indexOf 比對會把 sales 誤判為包含 sale。套用到購物清單的例子:

var shopping = document.getElementById("purchase");
var sales = getElementsByClassName(shopping, "test");
console.log(sales);

因此,回答開頭那道面試題的完整程式碼如下:

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>Shopping List</title>
</head>
<body>
    <h1>What to buy</h1>
    <ul id="purchase">
        <li>A tin of beans</li>
        <li class="sale">Cheese</li>
        <li class="sale important">Milk</li>
    </ul>
    <script>
        function getElementsByClassName(node, classname) {
            if (node.getElementsByClassName) {
                return node.getElementsByClassName(classname);
            } else {
                var results = [];
                var elems = node.getElementsByTagName("*");
                for (var i = 0; i < elems.length; i++) {
                      if (elems[i].className.indexOf(classname) != -1) {
                          results[results.length] = elems[i];
                         }
                   }
                return results;
            }
        }
        var body = document.getElementsByTagName("body")[0];
        console.log(getElementsByClassName(body, "sales"));
    </script>
</body>
</html>

方案二:Robert Nyman 的完整實作

能用的寫法很多,但真正高效的並不多。2008 年 Robert Nyman 在《The Ultimate GetElementsByClassName, Anno 2008》一文中提出了改良版本(他早在 2005 年就給出过初版)。相比 Jeremy Keith 的寫法,這個版本補上了幾個關鍵能力:

1. 瀏覽器若支援原生 getElementsByClassName,直接呼叫;
2. 若不支援但有 document.evaluate,改用 XPath 定位,速度遠優於遍歷;
3. 支援多 class 查詢,且不計類名先後順序;
4. 回傳真正的陣列,而不是類陣列的 NodeList。

第 4 點值得多說一句。原生的 getElementsByClassName 回傳的是 NodeList,它有 length 與數字索引,但沒有 push、pop 這些陣列方法。若要在其上使用陣列操作,可以先轉型:

myList = Array.prototype.slice.call(myNodeList);

下面是 Robert 的完整實作:

/*
Developed by Robert Nyman, https://www.robertnyman.com
Code/licensing: https://code.google.com/p/getelementsbyclassname/
*/
var getElementsByClassName = function (className, tag, elm) {
    if (document.getElementsByClassName) {
        // 有原生方法:呼叫後再用正則過濾標籤名
        getElementsByClassName = function (className, tag, elm) {
            elm = elm || document;
            var elements = elm.getElementsByClassName(className),
                 nodeName = (tag) ? new RegExp("\\b" + tag + "\\b", "i") : null,
                 returnElements = [],
                 current;
            for (var i = 0, il = elements.length; i < il; i += 1) {
                 current = elements[i];
                 if (!nodeName || nodeName.test(current.nodeName)) {
                     returnElements.push(current);
                 }
            }
            return returnElements;
        };
    }
    else if (document.evaluate) {
        // 有 XPath:用 contains 組出多 class 條件
        getElementsByClassName = function (className, tag, elm) {
            tag = tag || "*";
            elm = elm || document;
            var classes = className.split(" "),
                 classesToCheck = "",
                 xhtmlNamespace = "https://www.w3.org/1999/xhtml",
                 namespaceResolver = (document.documentElement.namespaceURI === xhtmlNamespace) ? xhtmlNamespace : null,
                 returnElements = [],
                 elements,
                 node;
            for (var j = 0, jl = classes.length; j < jl; j += 1) {
                 classesToCheck += "[contains(concat(' ', @class, ' '), ' " + classes[j] + " ')]";
            }
            try {
                 elements = document.evaluate(".//" + tag + classesToCheck, elm, namespaceResolver, 0, null);
            } catch (e) {
                 elements = document.evaluate(".//" + tag + classesToCheck, elm, null, 0, null);
            }
            while ((node = elements.iterateNext())) {
                 returnElements.push(node);
            }
            return returnElements;
        };
    }
    else {
        // 兩者皆無:遍歷標籤,用邊界正則比對 class
        getElementsByClassName = function (className, tag, elm) {
            tag = tag || "*";
            elm = elm || document;
            var classes = className.split(" "),
                 classesToCheck = [],
                 elements = (tag === "*" && elm.all) ? elm.all : elm.getElementsByTagName(tag),
                 current,
                 returnElements = [],
                 match;
            for (var k = 0, kl = classes.length; k < kl; k += 1) {
                 classesToCheck.push(new RegExp("(^|\\s)" + classes[k] + "(\\s|$)"));
            }
            for (var l = 0, ll = elements.length; l < ll; l += 1) {
                 current = elements[l];
                 match = false;
                 for (var m = 0, ml = classesToCheck.length; m < ml; m += 1) {
                     match = classesToCheck[m].test(current.className);
                     if (!match) { break; }
                 }
                 if (match) { returnElements.push(current); }
            }
            return returnElements;
        };
    }
    return getElementsByClassName(className, tag, elm);
};

這段程式碼有個值得學習的技巧:外層函式只在第一次呼叫時執行,判斷完環境後直接把 getElementsByClassName 指向對應的實作,之後的呼叫就跳過偵測。這在效能敏感的場景下很常見。

現代寫法建議

今天的專案幾乎不必再手寫這些相容性程式碼。直接查詢 DOM 時優先使用 document.querySelectorAll('.sale'),它原生支援多 class 與複合條件、回傳 NodeList 且具備現代瀏覽器共識。若需要陣列方法,用 Array.from() 或展開運算子轉型即可。上面兩套方案的價值在於理解瀏覽器底層的比對邏輯,以及正則邊界 (^|\s)...(\s|$) 為什麼比 indexOf 更準確。

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