Come ottenere tag nella pagina HTML, se so che cosa contiene il tag di testo. Per esempio:
<a ...>SearchingText</a>
Come ottenere tag nella pagina HTML, se so che cosa contiene il tag di testo. Per esempio:
<a ...>SearchingText</a>
Risposte:
Dovrai attraversare a mano.
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`.
i < il
? Che cosa sta facendo?
È possibile utilizzare xpath per ottenere questo risultato
var xpath = "//a[text()='SearchingText']";
var matchingElement = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
Puoi anche cercare un elemento contenente del testo usando questo xpath:
var xpath = "//a[contains(text(),'Searching')]";
Document.evaluate()
non essere supposto nel browser IE
var xpath = "//a[text()='SearchingText']";
non funziona, ma var xpath = "//a[contains(text(),'Searching')]";
funziona. Fai attenzione al personaggio scappato, come \ '\'.
Utilizzando la sintassi più moderna disponibile al momento, si può fare in modo molto pulito in questo modo:
for (const a of document.querySelectorAll("a")) {
if (a.textContent.includes("your search term")) {
console.log(a.textContent)
}
}
O con un filtro separato:
[...document.querySelectorAll("a")]
.filter(a => a.textContent.includes("your search term"))
.forEach(a => console.log(a.textContent))
Naturalmente, i browser legacy non lo gestiranno, ma è possibile utilizzare un transpiler se è necessario il supporto legacy.
È possibile utilizzare jQuery : Includes () Selector
var element = $( "a:contains('SearchingText')" );
Error: <![EX[["Tried to get element with id of \"%s\" but it is not present on the page","a:contains('SearchingText')"]]]> TAAL[1]
anche se ho elementi con "SearchingText" in essi.
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>
Certo, un modo un po 'più semplice è ancora:
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>
Riferimenti:
Approccio funzionale. Restituisce la matrice di tutti gli elementi corrispondenti e ritaglia gli spazi durante il controllo.
function getElementsByText(str, tag = 'a') {
return Array.prototype.slice.call(document.getElementsByTagName(tag)).filter(el => el.textContent.trim() === str.trim());
}
uso
getElementsByText('Text here'); // second parameter is optional tag (default "a")
se stai osservando tag diversi, ad esempio span o pulsante
getElementsByText('Text here', 'span');
getElementsByText('Text here', 'button');
Il valore predefinito tag = 'a' avrà bisogno di Babel per i vecchi browser
a
conterrà il nodo figlio di str
- el
verrà incluso nel getElementsByText
risultato; che è sbagliato.
Basta passare la sottostringa nella seguente riga:
HTML esterno
document.documentElement.outerHTML.includes('substring')
HTML interno
document.documentElement.innerHTML.includes('substring')
Puoi usarli per cercare in tutto il documento e recuperare i tag che contengono il termine di ricerca:
function get_elements_by_inner(word) {
res = []
elems = [...document.getElementsByTagName('a')];
elems.forEach((elem) => {
if(elem.outerHTML.includes(word)) {
res.push(elem)
}
})
return(res)
}
Utilizzo :
Quante volte l'utente "T3rm1" è menzionato in questa pagina?
get_elements_by_inner("T3rm1").length
1
Quante volte viene menzionato jQuery?
get_elements_by_inner("jQuery").length
3
Ottieni tutti gli elementi contenenti la parola "Cibernetico":
get_elements_by_inner("Cybernetic")
Ho trovato l'uso della sintassi più recente un po 'più breve rispetto alla risposta degli altri. Quindi ecco la mia proposta:
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]
Per ottenere il metodo di filtro da user1106925 che funziona in <= IE11, se necessario
È possibile sostituire l'operatore di diffusione con:
[].slice.call(document.querySelectorAll("a"))
e include include con a.textContent.match("your search term")
che funziona abbastanza bene:
[].slice.call(document.querySelectorAll("a"))
.filter(a => a.textContent.match("your search term"))
.forEach(a => console.log(a.textContent))
Array.from
invece di [].slice.call
. Ad esempio: Array.from(document.querySelectorAll('a'))
Mentre è possibile ottenere dal testo interiore, penso che tu stia andando nella direzione sbagliata. Quella stringa interna è generata dinamicamente? In tal caso, puoi assegnare al tag una classe o - meglio ancora - ID quando il testo viene inserito. Se è statico, è ancora più semplice.
Puoi usare a TreeWalker
per andare oltre i nodi DOM, individuare tutti i nodi di testo che contengono il testo e restituire i loro genitori:
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>
Questo fa il lavoro.
Restituisce una matrice di nodi contenenti 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())
);
}
Penso che dovrai essere un po 'più specifico per noi per aiutarti.
Se il testo è univoco (o davvero, se non lo è, ma dovresti eseguire un array) potresti trovare un'espressione regolare per trovarlo. L'uso di preg_match () di PHP funzionerebbe per questo.
Se stai usando Javascript e puoi inserire un attributo ID, puoi usare getElementById ('id'). È quindi possibile accedere agli attributi dell'elemento restituito tramite il DOM: https://developer.mozilla.org/en/DOM/element.1 .
Ho solo bisogno di un modo per ottenere l'elemento che contiene un testo specifico e questo è quello che mi è venuto in mente.
Utilizzare document.getElementsByInnerText()
per ottenere più elementi (più elementi potrebbero avere lo stesso testo esatto) e utilizzare document.getElementByInnerText()
per ottenere un solo elemento (prima corrispondenza).
Inoltre, è possibile localizzare la ricerca utilizzando un elemento (ad esempio someElement.getElementByInnerText()
) anziché document
.
Potrebbe essere necessario modificarlo per renderlo cross-browser o soddisfare le tue esigenze.
Penso che il codice sia autoesplicativo, quindi lo lascerò così com'è.
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>