如何通过innerText获取元素

小开

最佳答案

你必须徒手穿越。

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`.

小开

虽然有可能读懂里面的文字，但我认为你走错了方向。内部字符串是动态生成的吗?如果是这样，您可以在文本进入时为标记提供一个类或更好的ID。如果它是静态的，那就更容易了。

小开

我想你需要说得更具体一点，我们才能帮到你。

你是怎么发现的?Javascript ?PHP吗?Perl吗?
您可以将ID属性应用于标记吗?

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

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

小开

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>

引用:

小开

您可以使用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')]";

小开

你可以使用jQuery :包含()选择器

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

小开

使用目前最现代的语法，它可以像这样非常干净地完成:

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))

当然，遗留浏览器不能处理这个，但是如果需要遗留支持，可以使用转译器。

小开

我发现，与其他答案相比，新语法的使用略短。所以我的建议是:

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

小开

功能的方法。返回所有匹配元素的数组，并在检查时修整周围的空格。

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")

如果你在查看不同的标签，比如span或button

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

默认值标签= 'a'将需要Babel旧浏览器

小开

我只是需要一种方法来获取包含特定文本的元素，这就是我想到的。

使用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>

小开

简单地将你的子字符串传递到下面一行:

外的HTML

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

内心的HTML

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

你可以使用这些来搜索整个文档并检索包含搜索词的标签:

function get_elements_by_inner(word) {
res = []
elems = [...document.getElementsByTagName('a')];
elems.forEach((elem) => {
if(elem.outerHTML.includes(word)) {
res.push(elem)
}
})
return(res)
}

使用:

用户“T3rm1”在本页上被提到了多少次?

get_elements_by_inner("T3rm1").length

1

jQuery被提到了多少次?

get_elements_by_inner("jQuery").length

3.

获取所有包含“Cybernetic”的元素:

get_elements_by_inner("Cybernetic")

小开

你可以使用TreeWalker遍历DOM节点，并找到所有包含文本的文本节点，并返回它们的父节点:

const findNodeByContent = (text, root = document.body) => {
const treeWalker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);


const nodeList = [];


while (treeWalker.nextNode()) {
const node = treeWalker.currentNode;


if (node.nodeType === Node.TEXT_NODE && node.textContent.includes(text)) {
nodeList.push(node.parentNode);
}
};


return nodeList;
}


const result = findNodeByContent('SearchingText');


console.log(result);

<a ...>SearchingText</a>

小开

这就是工作返回包含text的节点数组

function get_nodes_containing_text(selector, text) {
const elements = [...document.querySelectorAll(selector)];


return elements.filter(
(element) =>
element.childNodes[0]
&& element.childNodes[0].nodeValue
&& RegExp(text, "u").test(element.childNodes[0].nodeValue.trim())
);
}

小开

如果需要，在<=IE11中从user1106925中获取过滤器方法

你可以将展开运算符替换为:

[].slice.call(document.querySelectorAll("a"))

和包含调用a.textContent.match("your search term")

这很简单:

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

小开

你可以这样做，不确定这是否被推荐，但对我来说很有效。

[... document.querySelectorAll('a')].filter(el => el.textContent.includes('sometext'));

小开

document.querySelectorAll('a').forEach(function (item) {
if (item.innerText == 'SearchingText') {
console.dir(item);
}
});

小开

在脚本中使用名为getElementInnerText的属性，它将获取该标记的内部内容。

document.getElementInnerText('a');

小开

const el = Array.from(document.body.querySelectorAll('a')).find(elm => elm.textContent.toLowerCase().includes('searching text'));
const el2 = document.evaluate('//a[contains(text(), "text5")]', document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
console.log(el, el2);

<a href="#">text1</a>
<a href="#">text2</a>
<a href="#">Searching Text</a>
<a href="#">text3</a>
<a href="#">text4</a>
<a href="#">text5</a>