如何通过innerText获取元素

Question

如果我知道文本标签包含哪些内容，如何获取 html 页面中的标签。例如。：

<a ...>SearchingText</a>

Answer 1

您必须手动遍历。

var aTags = document.getElementsByTagName("a");
var searchText = "SearchingText";
var found;

for (var i = 0; i < aTags.length; i++) {
  if (aTags[i].textContent == searchText) {
    found = aTags[i];
    break;
  }
}

// Use `found`.

Answer 2

您可以使用XPath完成这个

var xpath = "//a[text()='SearchingText']";
var matchingElement = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;

您也可以搜索使用此XPath含一些文本的元素：

var xpath = "//a[contains(text(),'Searching')]";

Answer 3

可以使用jQuery ：含有（）选择器

var element = $( "a:contains('SearchingText')" );

Answer 4

使用可此刻最现代化的语法，可以很清晰地做过这样的：

for (const a of document.querySelectorAll("a")) {
  if (a.textContent.includes("your search term")) {
    console.log(a.textContent)
  }
}

或者用一个单独的过滤器：

[...document.querySelectorAll("a")]
   .filter(a => a.textContent.includes("your search term"))
   .forEach(a => console.log(a.textContent))

当然，传统的浏览器将无法处理这个问题，但你可以用一个transpiler如果需要传统支持。

Answer 5

虽然已经过去很长一段时间了，而且您已经（很久以前）接受了答案，但我想我会提供一种更新的方法：

function findByTextContent(needle, haystack, precise) {
  // needle: String, the string to be found within the elements.
  // haystack: String, a selector to be passed to document.querySelectorAll(),
  //           NodeList, Array - to be iterated over within the function:
  // precise: Boolean, true - searches for that precise string, surrounded by
  //                          word-breaks,
  //                   false - searches for the string occurring anywhere
  var elems;

  // no haystack we quit here, to avoid having to search
  // the entire document:
  if (!haystack) {
    return false;
  }
  // if haystack is a string, we pass it to document.querySelectorAll(),
  // and turn the results into an Array:
  else if ('string' == typeof haystack) {
    elems = [].slice.call(document.querySelectorAll(haystack), 0);
  }
  // if haystack has a length property, we convert it to an Array
  // (if it's already an array, this is pointless, but not harmful):
  else if (haystack.length) {
    elems = [].slice.call(haystack, 0);
  }

  // work out whether we're looking at innerText (IE), or textContent 
  // (in most other browsers)
  var textProp = 'textContent' in document ? 'textContent' : 'innerText',
    // creating a regex depending on whether we want a precise match, or not:
    reg = precise === true ? new RegExp('\\b' + needle + '\\b') : new RegExp(needle),
    // iterating over the elems array:
    found = elems.filter(function(el) {
      // returning the elements in which the text is, or includes,
      // the needle to be found:
      return reg.test(el[textProp]);
    });
  return found.length ? found : false;;
}


findByTextContent('link', document.querySelectorAll('li'), false).forEach(function(elem) {
  elem.style.fontSize = '2em';
});

findByTextContent('link3', 'a').forEach(function(elem) {
  elem.style.color = '#f90';
});

<ul>
  <li><a href="#">link1</a>
  </li>
  <li><a href="#">link2</a>
  </li>
  <li><a href="#">link3</a>
  </li>
  <li><a href="#">link4</a>
  </li>
  <li><a href="#">link5</a>
  </li>
</ul>

当然，更简单一些的方法还是：

var textProp = 'textContent' in document ? 'textContent' : 'innerText';

// directly converting the found 'a' elements into an Array,
// then iterating over that array with Array.prototype.forEach():
[].slice.call(document.querySelectorAll('a'), 0).forEach(function(aEl) {
  // if the text of the aEl Node contains the text 'link1':
  if (aEl[textProp].indexOf('link1') > -1) {
    // we update its style:
    aEl.style.fontSize = '2em';
    aEl.style.color = '#f90';
  }
});

<ul>
  <li><a href="#">link1</a>
  </li>
  <li><a href="#">link2</a>
  </li>
  <li><a href="#">link3</a>
  </li>
  <li><a href="#">link4</a>
  </li>
  <li><a href="#">link5</a>
  </li>
</ul>

参考：

• Array.prototype.filter().
• Array.prototype.forEach().
• Array.prototype.slice().
• 条件（'三元'， assessment ? ifTrue : ifFalse） 操作员.
• Function.prototype.call().
• typeof 操作员.

Answer 6

功能的方法。所有匹配的元素和饰件空间的返回阵列周围而检查。

function getElementsByText(str, tag = 'a') {
  return Array.prototype.slice.call(document.getElementsByTagName(tag)).filter(el => el.textContent.trim() === str.trim());
}

用法

getElementsByText('Text here'); // second parameter is optional tag (default "a")

如果你正在寻找通过不同的标签，即跨度或按钮

getElementsByText('Text here', 'span');
getElementsByText('Text here', 'button');

的缺省值标签=“A”将需要巴贝尔为旧的浏览器

Answer 7

我发现用比别人的答案较新的语法有点短。因此，这里是我的建议：

const callback = element => element.innerHTML == 'My research'

const elements = Array.from(document.getElementsByTagName('a'))
// [a, a, a, ...]

const result = elements.filter(callback)

console.log(result)
// [a]

JSfiddle.net

Answer 8

简单地通过您的子成以下行：

<强>外HTML

document.documentElement.outerHTML.includes('substring')

<强>内在HTML

document.documentElement.innerHTML.includes('substring')

Answer 9

虽然它可以通过内部文本来获得，我认为你正朝着错误的方式。是内部串动态生成的？当文云在那里ID - 如果是这样，你可以给标签类或 - 更好的。如果它是静态的，那么它更容易。

Answer 10

我认为您需要更具体一些，我们才能帮助您。

1. 你怎么找到这个？JavaScript？PHP？珀尔？
2. 您可以将 ID 属性应用于标签吗？

如果文本是唯一的（或者实际上，如果不是，但您必须运行一个数组），您可以运行正则表达式来查找它。使用 PHP 的 preg_match() 可以解决这个问题。

如果您使用的是 Javascript 并且可以插入 ID 属性，则可以使用 getElementById('id')。然后您可以通过 DOM 访问返回元素的属性： https://developer.mozilla.org/en/DOM/element.1.

Answer 11

我只是需要一种方式来获得包含特定文本的元素，这就是我想出了。

使用document.getElementsByInnerText()得到多个元件（多个元件可能具有相同的确切文本），并使用document.getElementByInnerText()得到仅一个元件（第一匹配）。

另外，还可以通过使用的元件（例如someElement.getElementByInnerText()）代替document本地化搜索。

您可能需要调整它，以使其跨浏览器或满足您的需求。

我认为代码是不言自明的，因此我将离开，因为它是

HTMLElement.prototype.getElementsByInnerText = function (text, escape) {
    var nodes  = this.querySelectorAll("*");
    var matches = [];
    for (var i = 0; i < nodes.length; i++) {
        if (nodes[i].innerText == text) {
            matches.push(nodes[i]);
        }
    }
    if (escape) {
        return matches;
    }
    var result = [];
    for (var i = 0; i < matches.length; i++) {
        var filter = matches[i].getElementsByInnerText(text, true);
        if (filter.length == 0) {
            result.push(matches[i]);
        }
    }
    return result;
};
document.getElementsByInnerText = HTMLElement.prototype.getElementsByInnerText;

HTMLElement.prototype.getElementByInnerText = function (text) {
    var result = this.getElementsByInnerText(text);
    if (result.length == 0) return null;
    return result[0];
}
document.getElementByInnerText = HTMLElement.prototype.getElementByInnerText;

console.log(document.getElementsByInnerText("Text1"));
console.log(document.getElementsByInnerText("Text2"));
console.log(document.getElementsByInnerText("Text4"));
console.log(document.getElementsByInnerText("Text6"));

console.log(document.getElementByInnerText("Text1"));
console.log(document.getElementByInnerText("Text2"));
console.log(document.getElementByInnerText("Text4"));
console.log(document.getElementByInnerText("Text6"));

<table>
    <tr>
        <td>Text1</td>
    </tr>
    <tr>
        <td>Text2</td>
    </tr>
    <tr>
        <td>
            <a href="#">Text2</a>
        </td>
    </tr>
    <tr>
        <td>
            <a href="#"><span>Text3</span></a>
        </td>
    </tr>
    <tr>
        <td>
            <a href="#">Special <span>Text4</span></a>
        </td>
    </tr>
    <tr>
        <td>
            Text5
            <a href="#">Text6</a>
            Text7
        </td>
    </tr>
</table>