jsoup select 选择器

最新推荐文章于 2025-03-07 14:04:50 发布

ATCO

最新推荐文章于 2025-03-07 14:04:50 发布

阅读量8.2k

点赞数

分类专栏： JAVA 文章标签：正则表达式 regex dataset jquery div

JAVA 专栏收录该内容

94 篇文章

订阅专栏

问题

采用CSS或类似jquery 选择器（selector）语法来处理HTML文档中的数据。

方法

利用方法：Element.select(String selector)和Elements.select(String selector)。

File input = new File("/tmp/input.html");
Document doc = Jsoup.parse(input, "UTF-8", "http://example.com/");
Elements links = doc.select("a[href]"); // a with href
Elements pngs = doc.select("img[src$=.png]"); // img with src ending .png
Element masthead = doc.select("div.masthead").first();
// div with class=masthead
Elements resultLinks = doc.select("h3.r > a"); // direct a after h3

描述

Jsoup的元素支持类似CSS或（jquery）的选择器语法的查找匹配的元素，可实现功能强大且鲁棒性好的查询。

jsoup elements support a CSS(or jquery) like selector syntax to find matching elements, that allows very powerful and robust queries.

Select方法可作用于Document、Element或Elements，且是上下文相关的，因此可实现指定元素的过滤，或者链式选择访问。

The selectmethod is available in a Document, Element, or in Elements. It is contextual, so you can filter by selecting from a specific element, or by chaining select calls.

选择（操作）返回元素列表（Elements），并提供一组方法来提取或处理结果。

Select returns a list of Elements (as Elements), which provides a range of methods to extract and manipulate the results.

选择器概要（Selector overview）

Tagname：通过标签查找元素（例如：a）
ns|tag：通过标签在命名空间查找元素，例如：fb|name查找<fb:name>元素
#id：通过ID查找元素，例如#logo
.class：通过类型名称查找元素，例如.masthead
[attribute]：带有属性的元素，例如[href]
[^attr]：带有名称前缀的元素，例如[^data-]查找HTML5带有数据集（dataset）属性的元素
[attr=value]：带有属性值的元素，例如[width=500]
[attr^=value]，[attr$=value]，[attr*=value]：包含属性且其值以value开头、结尾或包含value的元素，例如[href*=/path/]
[attr~=regex]：属性值满足正则表达式的元素，例如img[src~=(?i)\.(png|jpe?g)]
*：所有元素，例如*

选择器组合方法

el#id:：带有ID的元素ID，例如div#logo
el.class：带类型的元素，例如. div.masthead
el[attr]：包含属性的元素，例如a[href]
任意组合：例如a[href].highlight
ancestor child：继承自某祖（父）元素的子元素，例如.body p查找“body”块下的p元素
parent > child：直接为父元素后代的子元素，例如: div.content > pf查找p元素，body > * 查找body元素的直系子元素
siblingA + siblingB：查找由同级元素A前导的同级元素，例如div.head + div
siblingA ~ siblingX：查找同级元素A前导的同级元素X例如h1 ~ p
el, el, el：多个选择器组合，查找匹配任一选择器的唯一元素，例如div.masthead, div.logo

伪选择器（Pseudo selectors）

:lt(n)：查找索引值（即DOM树中相对于其父元素的位置）小于n的同级元素，例如td:lt(3)
:gt(n)：查找查找索引值大于n的同级元素，例如div p:gt(2)
:eq(n) ：查找索引值等于n的同级元素，例如form input:eq(1)
:has(seletor)：查找匹配选择器包含元素的元素，例如div:has(p)
:not(selector)：查找不匹配选择器的元素，例如div:not(.logo)
:contains(text)：查找包含给定文本的元素，大小写铭感，例如p:contains(jsoup)
:containsOwn(text)：查找直接包含给定文本的元素
:matches(regex)：查找其文本匹配指定的正则表达式的元素，例如div:matches((?i)login)
:matchesOwn(regex)：查找其自身文本匹配指定的正则表达式的元素
注意：上述伪选择器是0-基数的，亦即第一个元素索引值为0，第二个元素index为1等

详见SelectorAPI 参考资料所列全部信息和细节。

【原文】http://jsoup.org/cookbook/extracting-data/selector-syntax

-------------------------------------------------------------------------------------------------------------------------------

CSS-like element selector, that finds elements matching a query.

Selector syntax

A selector is a chain of simple selectors, separated by combinators. Selectors are case insensitive (including against elements, attributes, and attribute values).

The universal selector (*) is implicit when no element selector is supplied (i.e. *.header and .header is equivalent).

Pattern	Matches	Example
`*`	any element	`*`
`tag`	elements with the given tag name	`div`
`ns\|E`	elements of type E in the namespace ns	`fb\|name` finds `<fb:name>` elements
`#id`	elements with attribute ID of "id"	`div#wrap`, `#logo`
`.class`	elements with a class name of "class"	`div.left`, `.result`
`[attr]`	elements with an attribute named "attr" (with any value)	`a[href]`, `[title]`
`[^attrPrefix]`	elements with an attribute name starting with "attrPrefix". Use to find elements with HTML5 datasets	`[^data-]`, `div[^data-]`
`[attr=val]`	elements with an attribute named "attr", and value equal to "val"	`img[width=500]`, `a[rel=nofollow]`
`[attr^=valPrefix]`	elements with an attribute named "attr", and value starting with "valPrefix"	`a[href^=http:]`
`[attr$=valSuffix]`	elements with an attribute named "attr", and value ending with "valSuffix"	`img[src$=.png]`
`[attr*=valContaining]`	elements with an attribute named "attr", and value containing "valContaining"	`a[href*=/search/]`
`[attr~=regex]`	elements with an attribute named "attr", and value matching the regular expression	`img[src~=(?i)\\.(png\|jpe?g)]`
	The above may be combined in any order	`div.header[title]`
	Combinators
`E F`	an F element descended from an E element	`div a`, `.logo h1`
`E > F`	an F direct child of E	`ol > li`
`E + F`	an F element immediately preceded by sibling E	`li + li`, `div.head + div`
`E ~ F`	an F element preceded by sibling E	`h1 ~ p`
`E, F, G`	all matching elements E, F, or G	`a[href], div, h3`
	Pseudo selectors
`:lt(n)`	elements whose sibling index is less than n	`td:lt(3)` finds the first 2 cells of each row
`:gt(n)`	elements whose sibling index is greater than n	`td:gt(1)` finds cells after skipping the first two
`:eq(n)`	elements whose sibling index is equal to n	`td:eq(0)` finds the first cell of each row
`:has(selector)`	elements that contains at least one element matching the selector	`div:has(p)` finds divs that contain p elements
`:not(selector)`	elements that do not match the selector. See also `Elements.not(String)`	`div:not(.logo)` finds all divs that do not have the "logo" class. `div:not(:has(div))` finds divs that do not contain divs.
`:contains(text)`	elements that contains the specified text. The search is case insensitive. The text may appear in the found element, or any of its descendants.	`p:contains(jsoup)` finds p elements containing the text "jsoup".
`:matches(regex)`	elements whose text matches the specified regular expression. The text may appear in the found element, or any of its descendants.	`td:matches(\\d+)` finds table cells containing digits. `div:matches((?i)login)` finds divs containing the text, case insensitively.
`:containsOwn(text)`	elements that directly contain the specified text. The search is case insensitive. The text must appear in the found element, not any of its descendants.	`p:containsOwn(jsoup)` finds p elements with own text "jsoup".
`:matchesOwn(regex)`	elements whose own text matches the specified regular expression. The text must appear in the found element, not any of its descendants.	`td:matchesOwn(\\d+)` finds table cells directly containing digits.`div:matchesOwn((?i)login)` finds divs containing the text, case insensitively.
	The above may be combined in any order and with other selectors	`.light:contains(name):eq(0)`
Structural pseudo selectors
`:root`	The element that is the root of the document. In HTML, this is the `html` element	`:root`
`:nth-child(an+b)`	elements that have `an+b-1` siblings before it in the document tree, for any positive integer or zero value of `n`, and has a parent element. For values of `a` and `b` greater than zero, this effectively divides the element's children into groups of a elements (the last group taking the remainder), and selecting the bth element of each group. For example, this allows the selectors to address every other row in a table, and could be used to alternate the color of paragraph text in a cycle of four. The `a` and `b` values must be integers (positive, negative, or zero). The index of the first child of an element is 1. In addition to this, `:nth-child()` can take `odd` and `even` as arguments instead. `odd` has the same signification as `2n+1`, and `even` has the same signification as `2n`.	`tr:nth-child(2n+1)` finds every odd row of a table. `:nth-child(10n-1)` the 9th, 19th, 29th, etc, element. `li:nth-child(5)` the 5h li
`:nth-last-child(an+b)`	elements that have `an+b-1` siblings after it in the document tree. Otherwise like `:nth-child()`	`tr:nth-last-child(-n+2)` the last two rows of a table
`:nth-of-type(an+b)`	pseudo-class notation represents an element that has `an+b-1` siblings with the same expanded element name before it in the document tree, for any zero or positive integer value of n, and has a parent element	`img:nth-of-type(2n+1)`
`:nth-last-of-type(an+b)`	pseudo-class notation represents an element that has `an+b-1` siblings with the same expanded element name after it in the document tree, for any zero or positive integer value of n, and has a parent element	`img:nth-last-of-type(2n+1)`
`:first-child`	elements that are the first child of some other element.	`div > p:first-child`
`:last-child`	elements that are the last child of some other element.	`ol > li:last-child`
`:first-of-type`	elements that are the first sibling of its type in the list of children of its parent element	`dl dt:first-of-type`
`:last-of-type`	elements that are the last sibling of its type in the list of children of its parent element	`tr > td:last-of-type`
`:only-child`	elements that have a parent element and whose parent element hasve no other element children
`:only-of-type`	an element that has a parent element and whose parent element has no other element children with the same expanded element name
`:empty`	elements that have no children at all