Được TopGit lập chỉ mục từ metadata GitHub: fb55/htmlparser2 có 4.8k sao, viết chủ yếu bằng TypeScript. The fast & forgiving HTML and XML parser
Tóm tắt dựng từ metadata GitHub của chính dự án — chưa có bài review TopGit. Trang sẽ tự động cập nhật khi bài review đầy đủ được xuất bản.
VÌ SAO CHƯA CÓ REVIEW
TopGit viết bài đầy đủ cho repo có nhiều sao nhất và được yêu cầu nhiều nhất. Trang này là snapshot trong thời gian chờ — xem README gốc ở tab READ ME.
htmlparser2 is the fastest HTML parser, and takes some shortcuts to get there. If you need strict HTML spec compliance, have a look at parse5.
Installation
npm install htmlparser2
A live demo of htmlparser2 is available on AST Explorer.
Ecosystem
Name
Description
htmlparser2
Fast & forgiving HTML/XML parser
domhandler
Handler for htmlparser2 that turns documents into a DOM
domutils
Utilities for working with domhandler's DOM
css-select
CSS selector engine, compatible with domhandler's DOM
cheerio
The jQuery API for domhandler's DOM
dom-serializer
Serializer for domhandler's DOM
Usage
htmlparser2 itself provides a callback interface that allows consumption of documents with minimal allocations.
For a more ergonomic experience, read Getting a DOM below.
import * as htmlparser2 from "htmlparser2";
const parser = new htmlparser2.Parser({
onopentag(name, attributes) {
/*
* This fires when a new tag is opened.
*
* If you don't need an aggregated `attributes` object,
* have a look at the `onopentagname` and `onattribute` events.
*/
if (name === "script" && attributes.type === "text/javascript") {
console.log("JS! Hooray!");
}
},
ontext(text) {
/*
* Fires whenever a section of text was processed.
*
* Note that this can fire at any point within text and you might
* have to stitch together multiple pieces.
*/
console.log("-->", text);
},
onclosetag(tagname) {
/*
* Fires when a tag is closed.
*
* You can rely on this event only firing when you have received an
* equivalent opening tag before. Closing tags without corresponding
* opening tags will be ignored.
*/
if (tagname === "script") {
console.log("That's it?!");
}
},
});
parser.write(
"Xyz <script type='text/javascript'>const foo = '<<bar>>';</script>",
);
parser.end();
All callbacks are optional. The handler object you pass to Parser may implement any subset of these:
Event
Description
onopentag(name, attribs, isImplied)
Opening tag. attribs is an object mapping attribute names to values. isImplied is true when the tag was opened implicitly (HTML mode only).
onopentagname(name)
Emitted for the tag name as soon as it is available (before attributes are parsed).
onattribute(name, value, quote)
Attribute. quote is " / ' / null (unquoted) / undefined (no value, e.g. disabled).
onclosetag(name, isImplied)
Closing tag. isImplied is true when the tag was closed implicitly (HTML mode only).
ontext(data)
Text content. May fire multiple times for a single text node.
oncomment(data)
Comment (content between <!-- and -->).
oncdatastart()
Opening of a CDATA section (<![CDATA[).
oncdataend()
End of a CDATA section (]]>).
onprocessinginstruction(name, data)
Processing instruction (e.g. <?xml ...?>).
oncommentend()
Fires after a comment has ended.
onparserinit(parser)
Fires when the parser is initialized or reset.
onreset()
Fires when parser.reset() is called.
onend()
Fires when parsing is complete.
onerror(error)
Fires on error.
Parser options
Option
Type
Default
Description
xmlMode
boolean
false
Treat the document as XML. This affects entity decoding, self-closing tags, CDATA handling, and more. Set this to true for XML, RSS, Atom and RDF feeds.
decodeEntities
boolean
true
Decode HTML entities (e.g. & -> &).
lowerCaseTags
boolean
!xmlMode
Lowercase tag names.
lowerCaseAttributeNames
boolean
!xmlMode
Lowercase attribute names.
recognizeSelfClosing
boolean
xmlMode
Recognize self-closing tags (e.g. <br/>). Always enabled in xmlMode.
recognizeCDATA
boolean
xmlMode
Recognize CDATA sections as text. Always enabled in xmlMode.
Usage with streams
While the Parser interface closely resembles Node.js streams, it's not a 100% match.
Use the WritableStream interface to process a streaming input:
The parseDocument helper parses a string and returns a DOM tree (a Document node).
import * as htmlparser2 from "htmlparser2";
const dom = htmlparser2.parseDocument(
`<ul id="fruits">
<li class="apple">Apple</li>
<li class="orange">Orange</li>
</ul>`,
);
parseDocument accepts an optional second argument with both parser and DOM handler options:
const dom = htmlparser2.parseDocument(data, {
// Parser options
xmlMode: true,
// domhandler options
withStartIndices: true, // Add `startIndex` to each node
withEndIndices: true, // Add `endIndex` to each node
});
Searching the DOM
The DomUtils module (re-exported on the main htmlparser2 export) provides helpers for finding nodes:
import * as htmlparser2 from "htmlparser2";
const dom = htmlparser2.parseDocument(`<div><p id="greeting">Hello</p></div>`);
// Find elements by ID, tag name, or class
const greeting = htmlparser2.DomUtils.getElementById("greeting", dom);
const paragraphs = htmlparser2.DomUtils.getElementsByTagName("p", dom);
// Find elements with custom test functions
const all = htmlparser2.DomUtils.findAll(
(el) => el.attribs?.class === "active",
dom,
);
// Get text content
htmlparser2.DomUtils.textContent(greeting); // "Hello"
For CSS selector queries, use css-select:
import { selectAll, selectOne } from "css-select";
const results = selectAll("ul#fruits > li", dom);
const first = selectOne("li.apple", dom);
Or, if you'd prefer a jQuery-like API, use cheerio.
Modifying and serializing the DOM
Use DomUtils to modify the tree, and dom-serializer (also available as DomUtils.getOuterHTML) to serialize it back to HTML:
import * as htmlparser2 from "htmlparser2";
const dom = htmlparser2.parseDocument(
`<ul><li>Apple</li><li>Orange</li></ul>`,
);
// Remove the first <li>
const items = htmlparser2.DomUtils.getElementsByTagName("li", dom);
htmlparser2.DomUtils.removeElement(items[0]);
// Serialize back to HTML
const html = htmlparser2.DomUtils.getOuterHTML(dom);
// "<ul><li>Orange</li></ul>"
Other manipulation helpers include appendChild, prependChild, append, prepend, and replaceElement -- see the domutils docs for the full API.
Parsing feeds
htmlparser2 makes it easy to parse RSS, RDF and Atom feeds, by providing a parseFeed method:
const feed = htmlparser2.parseFeed(content);
This returns an object with type, title, link, description, updated, author, and items (an array of feed entries), or null if the document isn't a recognized feed format.
The xmlMode option is enabled by default for parseFeed. If you pass custom options, make sure to include xmlMode: true.
Performance
After having some artificial benchmarks for some time, @AndreasMadsen published his htmlparser-benchmark, which benchmarks HTML parses based on real-world websites.
At the time of writing, the latest versions of all supported parsers show the following performance characteristics on GitHub Actions (sourced from here):
fb55/htmlparser2 thuộc nhóm Frontend trên TopGit, cùng 7 topic GitHub. Trang Trending và Topics liệt kê các repo cùng số sao và cùng ngôn ngữ để so sánh.
Đọc thêm về fb55/htmlparser2 ở đâu?
Trang TopGit này là một snapshot — tab "Readme" hiển thị nguyên văn README của repo (đã bỏ link, giữ ảnh). Repo GitHub ở github.com/fb55/htmlparser2 là nguồn chính thức.
fb55/htmlparser2 có bao nhiêu sao?
fb55/htmlparser2 có 4.8k sao GitHub — tải lại trang để xem số mới nhất, hoặc xem trực tiếp github.com/fb55/htmlparser2. TopGit phản chiếu số sao của GitHub nhưng không cam kết đến từng phút.
fb55/htmlparser2 có phải mã nguồn mở không?
Có — fb55/htmlparser2 phát hành theo license MIT, nghĩa là mã nguồn mở để đọc, fork và (tùy license) tái sử dụng. Mã: github.com/fb55/htmlparser2.
fb55/htmlparser2 còn đang phát triển không?
Commit gần nhất trên fb55/htmlparser2 là 24 ngày trước (theo timestamp GitHub). Repo có 399 fork — một chỉ báo về mức độ quan tâm của cộng đồng.
fb55/htmlparser2 dùng license gì?
fb55/htmlparser2 phát hành theo license MIT. Nên mở file LICENSE trên GitHub để xác nhận — license metadata đôi khi lệch với thực tế dự án.
fb55/htmlparser2 là gì?
fb55/htmlparser2 (fb55/htmlparser2) là dự án TypeScript trên GitHub. Theo mô tả gốc: The fast & forgiving HTML and XML parser
fb55/htmlparser2 viết bằng ngôn ngữ gì?
fb55/htmlparser2 chủ yếu viết bằng TypeScript. Trường "language" của GitHub dựa trên phần lớn byte ở nhánh mặc định.
Đọc đầy đủ README ở tab phía trên.
Muốn nghe thêm một ý kiến về htmlparser2?
Hỏi một AI đọc được trang này — một cú bấm là có ngay nhận định về htmlparser2.