javascript - What is the point of creating new DOMParser instances? - Stack Overflow

admin管理员组

文章数量:1341431

If you look at the example of DOMParser from MDN:

var parser = new DOMParser();
var doc = parser.parseFromString(stringContainingXMLSource, "application/xml");
// returns a Document, but not a SVGDocument nor a HTMLDocument

parser = new DOMParser();
doc = parser.parseFromString(stringContainingXMLSource, "image/svg+xml");
// returns a SVGDocument, which also is a Document.

parser = new DOMParser();
doc = parser.parseFromString(stringContainingHTMLSource, "text/html");
// returns a HTMLDocument, which also is a Document.

They keep creating new DOMParser instances. But why? Wouldn't one parser instance suffice? What about code that does a lot of parsing, is there a performance advantage in creating new instances?

EDIT: People are getting hung up on the example. To phrase my question better: why isn't DOMParser more like JSON and its parse method? Why isn't parseFromString a static method?

If you look at the example of DOMParser from MDN:

var parser = new DOMParser();
var doc = parser.parseFromString(stringContainingXMLSource, "application/xml");
// returns a Document, but not a SVGDocument nor a HTMLDocument

parser = new DOMParser();
doc = parser.parseFromString(stringContainingXMLSource, "image/svg+xml");
// returns a SVGDocument, which also is a Document.

parser = new DOMParser();
doc = parser.parseFromString(stringContainingHTMLSource, "text/html");
// returns a HTMLDocument, which also is a Document.

They keep creating new DOMParser instances. But why? Wouldn't one parser instance suffice? What about code that does a lot of parsing, is there a performance advantage in creating new instances?

EDIT: People are getting hung up on the example. To phrase my question better: why isn't DOMParser more like JSON and its parse method? Why isn't parseFromString a static method?

• javascript
• domparser

Share Improve this question Follow edited Nov 6, 2016 at 11:33 kasbah asked Oct 11, 2016 at 12:41 kasbahkasbah 94377 silver badges2424 bronze badges 5

• 9 I would interpret that as 3 'separate' examples, not as an encouragement to create a new parser for each parse operation. – Pieter Witvoet Commented Oct 11, 2016 at 12:49
• Maybe, but generally I see a lot of code around that does (new DOMParser).parseFromString. I guess that's for convenience, but why does it even have this interface, is any state kept in your DOMParser instance? I looked at the spec a bit but couldn't find a reason for it. – kasbah Commented Oct 11, 2016 at 13:05
• Currently both DOMParser and XMLSerializer Objects have only one method, but the use of a constructor enables to add more in the future if needed. – Kaiido Commented Oct 21, 2016 at 2:58
• Have you tried to ask the author of the page? – guest271314 Commented Oct 24, 2016 at 9:41
• @Kalido, I don't see why they can't add more methods later if it wasn't a class. It would make sense to me if it was more like JSON.parse. I thought there might be a reason for it but there doesn't seem to be. @guest271314 I am more interested in why DOMParser has this interface. – kasbah Commented Nov 6, 2016 at 11:09

Add a ment  | 

3 Answers 3

Sorted by: Reset to default 2 +25

The example you posted is just 3 different examples concatenated into 1, and they all declare a new DOMParser, so each is runnable on its own.

Maybe, but generally I see a lot of code around that does (new DOMParser).parseFromString.

If they use the (new DOMParser()).parseFromString that is because they only use it once, and they don't need it anywhere else, thus making a separate variable for it is redundant.

This code:

var
  proto = DOMParser.prototype
, nativeParse = proto.parseFromString
;

// Firefox/Opera/IE throw errors on unsupported types
try {
    // WebKit returns null on unsupported types
    if ((new DOMParser()).parseFromString("", "text/html")) {
        // text/html parsing is natively supported
        return;
    }
} catch (ex) {}

proto.parseFromString = function(markup, type) {
    if (/^\s*text\/html\s*(?:;|$)/i.test(type)) {
        var
          doc = document.implementation.createHTMLDocument("")
        ;
            if (markup.toLowerCase().indexOf('<!doctype') > -1) {
                doc.documentElement.innerHTML = markup;
            }
            else {
                doc.body.innerHTML = markup;
            }
        return doc;
    } else {
        return nativeParse.apply(this, arguments);
    }
};

This is pretty much a fail-safe if the browser doesn't support the DOMParser object.

There seem to be no significant difference between using one vs multiple instances. The spec says that the current API shape is due to historical reasons:

The design of DOMParser, as a class that needs to be constructed and then have its parseFromString() method called, is an unfortunate historical artifact. If we were designing this functionality today it would be a standalone function. For parsing HTML, the modern alternative is Document.parseHTMLUnsafe().

If the MIME type is text/xml, the resulting object will be an XMLDocument, if the MIME type is image/svg+xml, it will be an SVGDocument and if the MIME type is text/html, it will be an HTMLDocument.

So its not about one parser instance but its about what we required...

The example you posted is just 3 different examples concatenated into 1, and they all declare a new DOMParser.

You can do it by one parser instance also but you just have to change MIME type in parseFromString method according to your exact requirement. And if you required all of these then you have to call parseFromString mehod with different MIME type 3 times by same parser instance.Hope this will help you..

本文标签： javascriptWhat is the point of creating new DOMParser instancesStack Overflow