getElementsByTagName() 相当于 textNodes

Question

有没有办法获取文档中所有 textNode 对象的集合？

getElementsByTagName() 对于元素来说效果很好，但 textNode 不是元素。

更新：我意识到这可以通过遍历 DOM 来完成 - 正如下面许多人建议的那样。我知道如何编写一个 DOM-walker 函数来查看文档中的每个节点。我希望有一些浏览器原生的方法来做到这一点。毕竟，我可以通过一个内置调用获取所有 ，但不是所有 textNode，这有点奇怪。

Answer 1

下面是最快的 TreeWalker 方法的现代 Iterator 版本：

function getTextNodesIterator(el) { // Returns an iterable TreeWalker
    const walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT);
    walker[Symbol.iterator] = () => ({
        next() {
            const value = walker.nextNode();
            return {value, done: !value};
        }
    });
    return walker;
}

用法：

for (const textNode of getTextNodesIterator(document.body)) {
    console.log(textNode)
}

更安全的版本

如果在循环时移动节点，直接使用迭代器可能会被卡住。这样更安全，它返回一个数组：

function getTextNodes(el) { // Returns an array of Text nodes
    const walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT);
    const nodes = [];
    while (walker.nextNode()) {
        nodes.push(walker.currentNode);
    }
    return nodes;
}

Answer 2

我知道您特别要求一个集合，但如果您只是非正式地表示这一点并且不关心它们是否全部连接在一起形成一个大字符串，您可以使用：

var allTextAsString = document.documentElement.textContent || document.documentElement.innerText;

...第一项是 DOM3 标准方法。但请注意，innerText 似乎在支持它的实现中排除脚本或样式标记内容（至少 IE 和 Chrome），而 textContent 则包含它们（在 Firefox 和 Chrome 中）。

Answer 3

这是一个更惯用且（希望）更容易理解的替代方案。

function getText(node) {
    // recurse into each child node
    if (node.hasChildNodes()) {
        node.childNodes.forEach(getText);
    }
    // get content of each non-empty text node
    else if (node.nodeType === Node.TEXT_NODE) {
        const text = node.textContent.trim();
        if (text) {
            console.log(text); // do something
        }
    }
}

Answer 4

在 createTreeWalker 被弃用后，您可以使用

  /**
   * Get all text nodes under an element
   * @param {!Element} el
   * @return {Array<!Node>}
   */
  function getTextNodes(el) {
    const iterator = document.createNodeIterator(el, NodeFilter.SHOW_TEXT);
    const textNodes = [];
    let currentTextNode;
    while ((currentTextNode = iterator.nextNode())) {
      textNodes.push(currentTextNode);
    }
    return textNodes;
  }

Answer 5

 document.deepText= function(hoo, fun){
        var A= [], tem;
        if(hoo){
            hoo= hoo.firstChild;
            while(hoo!= null){
                if(hoo.nodeType== 3){
                    if(typeof fun== 'function'){
                        tem= fun(hoo);
                        if(tem!= undefined) A[A.length]= tem;
                    }
                    else A[A.length]= hoo;
                }
                else A= A.concat(document.deepText(hoo, fun));
                hoo= hoo.nextSibling;
            }
        }
        return A;
    }

/*
您可以返回某个父元素的所有后代文本节点的数组，
或者你可以传递一些函数并做一些事情（查找或替换或其他）
到适当的文本。

此示例返回正文中非空白文本节点的文本：

var A= document.deepText(document.body, function(t){
    var tem= t.data;
    return /\S/.test(tem)? tem: undefined;
});
alert(A.join('\n'))

*/

方便搜索和替换、突出显示等

Answer 6

var el1 = document.childNodes[0]
function get(node,ob)
{
        ob = ob || {};

        if(node.childElementCount)
        {

            ob[node.nodeName] = {}
            ob[node.nodeName]["text"] = [];
            for(var x = 0; x < node.childNodes.length;x++)
            {   
                if(node.childNodes[x].nodeType == 3)
                {
                    var txt = node.childNodes[x].nodeValue;


                    ob[node.nodeName]["text"].push(txt)
                    continue
                }
                get(node.childNodes[x],ob[node.nodeName])       
            };  
        }
        else
        {
            ob[node.nodeName]   = (node.childNodes[0] == undefined ? null :node.childNodes[0].nodeValue )
        }
        return ob
}



var o = get(el1)
console.log(o)

Answer 7

更新：

我概述了这 6 种方法中每种方法超过 1000 次运行的一些基本性能测试。 getElementsByTagName 是最快的，但它做得半途而废，因为它不选择所有元素，而只选择一种特定类型的标签（我认为 p）并盲目地假设它的第一个子元素是一个文本元素。它可能有一点缺陷，但它是为了演示目的并将其性能与 TreeWalker 进行比较。 在 jsfiddle 上自行运行测试以查看结果。

1. 使用 TreeWalker
2. 自定义迭代遍历
3. 自定义递归遍历
4. Xpath 查询
5. querySelectorAll
6. getElementsByTagName

让我们暂时假设有一种方法允许您以本机方式获取所有 Text 节点。您仍然需要遍历每个结果文本节点并调用 node.nodeValue 来获取实际文本，就像处理任何 DOM 节点一样。因此，性能问题不在于迭代文本节点，而在于迭代所有非文本节点并检查它们的类型。我认为（根据结果）TreeWalker 的执行速度与 getElementsByTagName 一样快，甚至更快（即使 getElementsByTagName 玩残疾人）。

Ran each test 1000 times.

Method                  Total ms        Average ms
--------------------------------------------------
document.TreeWalker          301            0.301
Iterative Traverser          769            0.769
Recursive Traverser         7352            7.352
XPath query                 1849            1.849
querySelectorAll            1725            1.725
getElementsByTagName         212            0.212

---

每种方法的来源：

TreeWalker

function nativeTreeWalker() {
    var walker = document.createTreeWalker(
        document.body, 
        NodeFilter.SHOW_TEXT, 
        null, 
        false
    );

    var node;
    var textNodes = [];

    while(node = walker.nextNode()) {
        textNodes.push(node.nodeValue);
    }
}

递归树遍历

function customRecursiveTreeWalker() {
    var result = [];

    (function findTextNodes(current) {
        for(var i = 0; i < current.childNodes.length; i++) {
            var child = current.childNodes[i];
            if(child.nodeType == 3) {
                result.push(child.nodeValue);
            }
            else {
                findTextNodes(child);
            }
        }
    })(document.body);
}

迭代树遍历

function customIterativeTreeWalker() {
    var result = [];
    var root = document.body;

    var node = root.childNodes[0];
    while(node != null) {
        if(node.nodeType == 3) { /* Fixed a bug here. Thanks @theazureshadow */
            result.push(node.nodeValue);
        }

        if(node.hasChildNodes()) {
            node = node.firstChild;
        }
        else {
            while(node.nextSibling == null && node != root) {
                node = node.parentNode;
            }
            node = node.nextSibling;
        }
    }
}

querySelectorAll

function nativeSelector() {
    var elements = document.querySelectorAll("body, body *"); /* Fixed a bug here. Thanks @theazureshadow */
    var results = [];
    var child;
    for(var i = 0; i < elements.length; i++) {
        child = elements[i].childNodes[0];
        if(elements[i].hasChildNodes() && child.nodeType == 3) {
            results.push(child.nodeValue);
        }
    }
}

getElementsByTagName ( handicap)

function getElementsByTagName() {
    var elements = document.getElementsByTagName("p");
    var results = [];
    for(var i = 0; i < elements.length; i++) {
        results.push(elements[i].childNodes[0].nodeValue);
    }
}

XPath

function xpathSelector() {
    var xpathResult = document.evaluate(
        "//*/text()", 
        document, 
        null, 
        XPathResult.ORDERED_NODE_ITERATOR_TYPE, 
        null
    );

    var results = [], res;
    while(res = xpathResult.iterateNext()) {
        results.push(res.nodeValue);  /* Fixed a bug here. Thanks @theazureshadow */
    }
}

此外，您可能会发现此讨论很有帮助 - http://bytes.com/topic/javascript/answers/153239-how-do-i-get-elements-text-node