htmlparser2

The fast & forgiving HTML and XML parser

HTML & text parsing
fb55/htmlparser2feedic.com/htmlparser2htmlparser2

README

htmlparser2

NPM version Downloads Build Status Coverage

The fast & forgiving HTML/XML parser.

_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 here.

Ecosystem


NameDescription
--------------------------------------------------------------------------------------------------------------------
[htmlparser2](https://github.com/fb55/htmlparser2)Fast
[domhandler](https://github.com/fb55/domhandler)Handler
[domutils](https://github.com/fb55/domutils)Utilities
[css-select](https://github.com/fb55/css-select)CSS
[cheerio](https://github.com/cheeriojs/cheerio)The
[dom-serializer](https://github.com/cheeriojs/dom-serializer)Serializer

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.

  1. ``` js
  2. import * as htmlparser2 from "htmlparser2";

  4. const parser = new htmlparser2.Parser({
  5.     onopentag(name, attributes) {
  6.         /*
  7.          * This fires when a new tag is opened.
  8.          *
  9.          * If you don't need an aggregated `attributes` object,
  10.          * have a look at the `onopentagname` and `onattribute` events.
  11.          */
  12.         if (name === "script" && attributes.type === "text/javascript") {
  13.             console.log("JS! Hooray!");
  14.         }
  15.     },
  16.     ontext(text) {
  17.         /*
  18.          * Fires whenever a section of text was processed.
  19.          *
  20.          * Note that this can fire at any point within text and you might
  21.          * have to stitch together multiple pieces.
  22.          */
  23.         console.log("-->", text);
  24.     },
  25.     onclosetag(tagname) {
  26.         /*
  27.          * Fires when a tag is closed.
  28.          *
  29.          * You can rely on this event only firing when you have received an
  30.          * equivalent opening tag before. Closing tags without corresponding
  31.          * opening tags will be ignored.
  32.          */
  33.         if (tagname === "script") {
  34.             console.log("That's it?!");
  35.         }
  36.     },
  37. });
  38. parser.write(
  39.     "Xyz <script type='text/javascript'>const foo = '<<bar>>';</script>"
  40. );
  41. parser.end();
  42. ```

Output (with multiple text events combined):

  1. ```
  2. --> Xyz
  3. JS! Hooray!
  4. --> const foo = '<<bar>>';
  5. That's it?!
  6. ```

This example only shows three of the possible events.
Read more about the parser, its events and options in the wiki.

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:

  1. ``` js
  2. import { WritableStream } from "htmlparser2/lib/WritableStream";

  4. const parserStream = new WritableStream({
  5.     ontext(text) {
  6.         console.log("Streaming:", text);
  7.     },
  8. });

  10. const htmlStream = fs.createReadStream("./my-file.html");
  11. htmlStream.pipe(parserStream).on("finish", () => console.log("done"));
  12. ```

Getting a DOM


The DomHandler produces a DOM (document object model) that can be manipulated using the [DomUtils](https://github.com/fb55/DomUtils) helper.

  1. ``` js
  2. import * as htmlparser2 from "htmlparser2";

  4. const dom = htmlparser2.parseDocument(htmlString);
  5. ```

The DomHandler, while still bundled with this module, was moved to its own module.
Have a look at that for further information.

Parsing RSS/RDF/Atom Feeds


  1. ``` js
  2. const feed = htmlparser2.parseFeed(content, options);
  3. ```

Note: While the provided feed handler works for most feeds,
you might want to use danmactough/node-feedparser, which is much better tested and actively maintained.

Performance


After having some artificial benchmarks for some time, @AndreasMadsen published his [htmlparser-benchmark](https://github.com/AndreasMadsen/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):

  1. ```
  2. htmlparser2        : 2.17215 ms/file ± 3.81587
  3. node-html-parser   : 2.35983 ms/file ± 1.54487
  4. html5parser        : 2.43468 ms/file ± 2.81501
  5. neutron-html5parser: 2.61356 ms/file ± 1.70324
  6. htmlparser2-dom    : 3.09034 ms/file ± 4.77033
  7. html-dom-parser    : 3.56804 ms/file ± 5.15621
  8. libxmljs           : 4.07490 ms/file ± 2.99869
  9. htmljs-parser      : 6.15812 ms/file ± 7.52497
  10. parse5             : 9.70406 ms/file ± 6.74872
  11. htmlparser         : 15.0596 ms/file ± 89.0826
  12. html-parser        : 28.6282 ms/file ± 22.6652
  13. saxes              : 45.7921 ms/file ± 128.691
  14. html5              : 120.844 ms/file ± 153.944
  15. ```

How does this module differ from node-htmlparser?


In 2011, this module started as a fork of the htmlparser module.
htmlparser2 was rewritten multiple times and, while it maintains an API that's mostly compatible with htmlparser in most cases, the projects don't share any code anymore.

The parser now provides a callback interface inspired by sax.js (originally targeted at readabilitySAX).
As a result, old handlers won't work anymore.

The DefaultHandler and the RssHandler were renamed to clarify their purpose (to DomHandler and FeedHandler). The old names are still available when requiring htmlparser2, your code should work as expected.

Security contact information


To report a security vulnerability, please use the Tidelift security contact.
Tidelift will coordinate the fix and disclosure.

htmlparser2 for enterprise


Available as part of the Tidelift Subscription.

The maintainers of htmlparser2 and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. Learn more.