getElementsByClassName的理想实现

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

　javascript通过className获取文件元素在 JavaScript 内建的核心中，document 物件及 Element 物件总共可以透过三个方式来获取其下的元素，分别是:

getElementById('id')
getElementsByName('name')
getElementsByTagName('tag')

这些方法就跟它们的名字一样，分别是依照 id, name, tag 来获取元素。

　　因在同一份文件中，id 是具有唯一性的，所以 getElementById(id) 的回传值是单一物件可以直接使用；而其他则会传回一个依照具有该属性的元素在文件中出现顺序排列的阵列，使用时必须指定阵列编号，如: array[0] 代表第一个元素。

　　可是在设计网页时，最常常需要使用到的 class 却没有相对应的方法可以去获取 className 相同的元素。

　　没有没关系，我们自己写一个，而且代码非常简短只有下面几句。

　　function getElementsByClassName(n) {
　　 var el = [],
　　 _el = document.getElementsByTagName('*');
　　 for (var i=0; i<_el.length; i++ ) {
　　 if (_el[i].className == n ) {
　　 el[el.length] = _el[i];
　　 }
　　 }
　　 return el;
　　}

上面这段代码将会传回一个元素阵列，这些元素的共通点就是它们的 class 名称都一样。

　　下面这段代码是 getElementsByClassName(’className’) 众多应用的其中一种，可以将文件中所有 className 为 ‘black’ 的元素的 className 改为 ‘red’。

　　var classBlack = getElementsByClassName('black');
　　for (var i=0; i<classBlack.length; i++) {
　　 classBlack[i].className = 'red';
　　}

Pure DOM

通常先使用getElementsByTagName("*")取出文档中所有元素，然后进行遍历，使用正则表达式找出匹配的元素放入一个数组返回。由于IE5不支持document.getElementsByTagName("*")，要使用分支document.all以防错误。

The Ultimate getElementsByClassName方案，作者为Robert Nyman，05年实现，可见老外许多东西在很早以前就走得很远了。

//三个参数都是必需的，查找一网页中5007个类名为“cell”的元素，IE8历时1828 ~ 1844毫秒，
//IE6为4610 ~ 6109毫秒，FF3.5为46 ~ 48毫秒，opera10为31 ~ 32毫秒，Chrome为23~ 26毫秒，
//safari4为19 ~ 20毫秒
function getElementsByClassName(oElm, strTagName, strClassName){
    var arrElements = (strTagName == "*" && oElm.all)? oElm.all :
        oElm.getElementsByTagName(strTagName);
    var arrReturnElements = new Array();
    strClassName = strClassName.replace(/\-/g, "\\-");
    var oRegExp = new RegExp("(^|\\s)" + strClassName + "(\\s|$)");
    var oElement;
    for(var i=0; i < arrElements.length; i++){
        oElement = arrElements[i];
        if(oRegExp.test(oElement.className)){
            arrReturnElements.push(oElement);
        }
    }
    return (arrReturnElements)
}

另一个实现，由Dustin Diaz（《JavaScript Design Patterns》的作者）提供，但兼容性不如上面的，不支持IE5。

//后两参数是可靠的，查找一网页中5007个类名为“cell”的元素，IE8历时78毫秒，IE6历时125~171毫秒
//FF3.5为42 ~ 48毫秒，opera10为31 毫秒，Chrome为22~ 25毫秒，safari4为18 ~ 19毫秒
var getElementsByClass = function(searchClass,node,tag) {
        var classElements = new Array();
        if ( node == null )
                node = document;
        if ( tag == null )
                tag = '*';
        var els = node.getElementsByTagName(tag);
        var elsLen = els.length;
        var pattern = new RegExp("(^|\\s)"+searchClass+"(\\s|$)");
        for (i = 0, j = 0; i < elsLen; i++) {
                if ( pattern.test(els[i].className) ) {
                        classElements[j] = els[i];
                        j++;
                }
        }
        return classElements;
}

还有个更古老级的，我从prototype.js1.01版本中找到的，它能支持多个类名的查找（上面两个不行）。它不支持IE5，效率一般般，但作为最早的框架之一，它已经做得很好，其他框架还没有想到这个呢！

//由于这是后期添加的，测试页面已被我删掉，没有做测试……
function getElementsByClassName(className, element) {
    var children = (element || document).getElementsByTagName('*');
    var elements = new Array();
 
    for (var i = 0; i < children.length; i++) {
        var child = children[i];
        var classNames = child.className.split(' ');
        for (var j = 0; j < classNames.length; j++) {
            if (classNames[j] == className) {
                elements.push(child);
                break;
            }
        }
    }
 
    return elements;
}

DOM Tree Walker

使用document.createTreeWalker，这是个比较不常用的二级DOM方法。可惜IE全系列歇菜。

//查找一网页中5007个类名为“cell”的元素，FF3.5为104 ~ 119毫秒，opera10为230 ~ 265毫秒，
//Chrome为119 ~ 128毫秒，safari为28 ~ 32毫秒
var getElementsByClassName = function(searchClass) {
    function acceptNode(node) {
        if (node.hasAttribute("class")) {
            var c = " " + node.className + " ";
            if (c.indexOf(" " + searchClass + " ") != -1)
                return NodeFilter.FILTER_ACCEPT;
        }
        return NodeFilter.FILTER_SKIP;
    }
    var treeWalker = document.createTreeWalker(document.documentElement,
        NodeFilter.SHOW_ELEMENT, acceptNode, true);
    var returnElements = [];
    if (treeWalker) {
        var node = treeWalker.nextNode();
        while (node) {
            returnElements.push(node);
            node = treeWalker.nextNode();
        }
    }
    return returnElements;
}

XPath

更加新式时髦的技术。

下面取自Prototype.js框架。

document.getElementsByClassName = function(className, parentElement) {
  if (Prototype.BrowserFeatures.XPath) {
    var q = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
    return document._getElementsByXPath(q, parentElement);
  } else {
    var children = ($(parentElement) || document.body).getElementsByTagName('*');
    var elements = [], child;
    for (var i = 0, length = children.length; i < length; i++) {
      child = children[i];
      if (Element.hasClassName(child, className))
        elements.push(Element.extend(child));
    }
    return elements;
  }
};

由于这个是不能运行的，我们修改如下：

//查找一网页中5007个类名为“cell”的元素，FF3.5为33 ~ 48毫秒，opera10为31 ~ 32毫秒，
//Chrome为104 ~ 107毫秒，safari为18 ~ 21毫秒
var getElementsByClassName = function(searchClass,node,tag) {
    node = node || document;
    tag = tag || '*';
    var classes = searchClass.split(" "),
    patterns = "",
    xhtmlNamespace = "http://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){
        patterns += "[contains(concat(' ', @class, ' '), ' " + classes[j] + " ')]";
    }
    try {
        elements = document.evaluate(".//" + tag + patterns, node, namespaceResolver, 0, null);
    }
    catch (e) {
        elements = document.evaluate(".//" + tag + patterns, node, null, 0, null);
    }
    while ((_node = elements.iterateNext()))  returnElements.push(_node);
    return returnElements;
}

当然如果游览器原生支持，就用原生的。

各主流游览器的支持情况
IE8	IE7	IE6	FF3	FF2	Saf3	Op9	Op10	Chrome
N	N	N	Y	N	Y	Y	Y	Y

速度比较一览

综合以上方案，我得出了一个最理想的实现——兼容IE5，让后面两个参数是可选的，能原生的原生，利用字面量与倒序循环提高效率……

//查找一网页中5007个类名为“cell”的元素，IE8历时1828 ~ 1844毫秒，
//IE6为125 ~ 172毫秒，IE8为93 ~ 94毫秒，FF3.5为0~1毫秒，opera10为0毫秒，Chrome为1毫秒，
//safari4为0毫秒
var getElementsByClassName = function(searchClass,node,tag) {
    if(document.getElementsByClassName){
        return  document.getElementsByClassName(searchClass)
    }else{    
        node = node || document;
        tag = tag || '*';
        var returnElements = []
        var els =  (tag === "*" && node.all)? node.all : node.getElementsByTagName(tag);
        var i = els.length;
        searchClass = searchClass.replace(/\-/g, "\\-");
        var pattern = new RegExp("(^|\\s)"+searchClass+"(\\s|$)");
        while(--i >= 0){
            if (pattern.test(els[i].className) ) {
                returnElements.push(els[i]);
            }
        }
        return returnElements;
    }
}

用法：

var collections = getElementsByClassName("red");

但它还是不如原生的getElementsByClassName，不能同时检索多个class

<h2 class="red cell title">安装支持</h2>
 
<span class="cell red  ">jjj</span>
 
<div class="filament_table  red cell">这是DIV</div>
 
#利用 var dd = getElementsByClassName("cell red") ，这三个元素都应该能被检索到！

因此，最最终的方案为：

var getElementsByClassName = function (searchClass, node,tag) {
  if(document.getElementsByClassName){
    var nodes =  (node || document).getElementsByClassName(searchClass),result = [];
      for(var i=0 ;node = nodes[i++];){
        if(tag !== "*" && node.tagName === tag.toUpperCase()){
          result.push(node)
        }else{
          result.push(node)
        }
      }
      return result
    }else{
      node = node || document;
      tag = tag || "*";
      var classes = searchClass.split(" "),
      elements = (tag === "*" && node.all)? node.all : node.getElementsByTagName(tag),
      patterns = [],
      current,
      match;
      var i = classes.length;
      while(--i >= 0){
        patterns.push(new RegExp("(^|\\s)" + classes[i] + "(\\s|$)"));
      }
      var j = elements.length;
      while(--j >= 0){
        current = elements[j];
        match = false;
        for(var k=0, kl=patterns.length; k<kl; k++){
          match = patterns[k].test(current.className);
          if (!match)  break;
        }
        if (match)  result.push(current);
      }
      return result;
    }
  }

posted @ 2012-05-31 12:00 赵小磊阅读(355) 评论(0) 编辑收藏举报