In order to access this site you need to enable JavaScript!

You are here: Reference > JavaScript > client-side > HTML DOM > properties > entities (doctype)

entities property (doctype)

Browser support:

Returns a collection of available entity nodes in the document.

Entity nodes identify name/value pairs. The entity name can be used in the document as a shorter format (&name;), instead of the entity value.
Declaring entities is only allowed in XML documents.

Syntax:

object.entities;

You can find the related objects in the Supported by objects section below.

This property is read-only.

Possible values:

Collection of entities.

Default: this property has no default value.

Example HTML code 1:

This example shows how to access the entities in an XML file:

Code

ajax.js

doctype_test.xml

<head>
    <script type="text/javascript" src="ajax.js"></script>
    
    <script type="text/javascript">
        var httpRequest = null;
        
        function SendRequest () {
            if (!httpRequest) {
                httpRequest = CreateHTTPRequestObject ();   // defined in ajax.js
            }
            if (httpRequest) {          
                var url = "doctype_test.xml";
                httpRequest.open ("GET", url, true);    // async
                httpRequest.onreadystatechange = OnStateChange;
                httpRequest.send (null);
            }
        }

        function OnStateChange () {
            if (httpRequest.readyState == 0 || httpRequest.readyState == 4) {
                if (IsRequestSuccessful (httpRequest)) {    // defined in ajax.js
                    Test_Entities ();
                }
                else {
                    alert ("Operation failed.");
                }
            }
        }

        function Test_Entities () {
            var xmlDoc = ParseHTTPResponse (httpRequest);   // defined in ajax.js
            if (!xmlDoc)
                return;
                
            var message = "";
            if (xmlDoc.doctype) {
                var entities = xmlDoc.doctype.entities;
                if (entities) {
                    message += entities.length + " entities found.<br />";
                    for (var i = 0; i < entities.length; i++) {
                        message += "name: <b>" + entities[i].nodeName + "</b> - ";
                        message += "value: <b>" + entities[i].firstChild.data + "</b>.<br />";
                    }
                }
                else {
                    message += "Your browser doesn't support the entities property!<br />";
                }

                var notations = xmlDoc.doctype.notations;
                if (notations) {
                    message += notations.length + " notations found.<br />";
                    for (var i = 0; i < notations.length; i++) {
                        message += "name: <b>" + notations[i].nodeName + "</b> - ";
                        message += "publicId: <b>" + notations[i].publicId + "</b>.<br />";
                    }
                }
                else {
                    message += "Your browser doesn't support the notations property!<br />";
                }

                if (xmlDoc.doctype.internalSubset) {
                    var repaired = xmlDoc.doctype.internalSubset;
                    repaired = repaired.replace (/\</g, "&lt;");
                    repaired = repaired.replace (/\x0a/g, "<br />");
                    message += "The entire content of the DTD: <b>" + repaired + "</b><br />";
                }
                else {
                    message += "Your browser doesn't support the internalSubset property!<br />";
                }
            }
            else {
                message += "Your browser doesn't support the doctype property!<br />";
            }
            
            var info = document.getElementById ("info");
            info.innerHTML = message;
        }
    </script>
</head>
<body onload="SendRequest ();">
    <div id="info" style="width:500px; height:300px; overflow:auto; background-color:#e0d0d0;"></div>
</body>


function CreateHTTPRequestObject () {
        // although IE supports the XMLHttpRequest object, but it does not work on local files.
    var forceActiveX = (window.ActiveXObject && location.protocol === "file:");
    if (window.XMLHttpRequest && !forceActiveX) {
        return new XMLHttpRequest();
    }
    else {
        try {
            return new ActiveXObject("Microsoft.XMLHTTP");
        } catch(e) {}
    }
    alert ("Your browser doesn't support XML handling!");
    return null;
}

function CreateMSXMLDocumentObject () {
    if (typeof (ActiveXObject) != "undefined") {
        var progIDs = [
                        "Msxml2.DOMDocument.6.0", 
                        "Msxml2.DOMDocument.5.0", 
                        "Msxml2.DOMDocument.4.0", 
                        "Msxml2.DOMDocument.3.0", 
                        "MSXML2.DOMDocument", 
                        "MSXML.DOMDocument"
                      ];
        for (var i = 0; i < progIDs.length; i++) {
            try { 
                return new ActiveXObject(progIDs[i]); 
            } catch(e) {};
        }
    }
    return null;
}

function CreateXMLDocumentObject (rootName) {
    if (!rootName) {
        rootName = "";
    }
    var xmlDoc = CreateMSXMLDocumentObject ();
    if (xmlDoc) {
        if (rootName) {
            var rootNode = xmlDoc.createElement (rootName);
            xmlDoc.appendChild (rootNode);
        }
    }
    else {
        if (document.implementation.createDocument) {
            xmlDoc = document.implementation.createDocument ("", rootName, null);
        }
    }
    
    return xmlDoc;
}

function ParseHTTPResponse (httpRequest) {
    var xmlDoc = httpRequest.responseXML;

            // if responseXML is not valid, try to create the XML document from the responseText property
    if (!xmlDoc || !xmlDoc.documentElement) {
        if (window.DOMParser) {
            var parser = new DOMParser();
            try {
                xmlDoc = parser.parseFromString (httpRequest.responseText, "text/xml");
            } catch (e) {
                alert ("XML parsing error");
                return null;
            };
        }
        else {
            xmlDoc = CreateMSXMLDocumentObject ();
            if (!xmlDoc) {
                return null;
            }
            xmlDoc.loadXML (httpRequest.responseText);

        }
    }

            // if there was an error while parsing the XML document
    var errorMsg = null;
    if (xmlDoc.parseError && xmlDoc.parseError.errorCode != 0) {
        errorMsg = "XML Parsing Error: " + xmlDoc.parseError.reason
                  + " at line " + xmlDoc.parseError.line
                  + " at position " + xmlDoc.parseError.linepos;
    }
    else {
        if (xmlDoc.documentElement) {
            if (xmlDoc.documentElement.nodeName == "parsererror") {
                errorMsg = xmlDoc.documentElement.childNodes[0].nodeValue;
            }
        }
    }
    if (errorMsg) {
        alert (errorMsg);
        return null;
    }

        // ok, the XML document is valid
    return xmlDoc;
}

    // returns whether the HTTP request was successful
function IsRequestSuccessful (httpRequest) {
        // IE: sometimes 1223 instead of 204
    var success = (httpRequest.status == 0 || 
        (httpRequest.status >= 200 && httpRequest.status < 300) || 
        httpRequest.status == 304 || httpRequest.status == 1223);
    
    return success;
}

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE sample [
    <!NOTATION vrml PUBLIC "VRML 1.0">
    <!ENTITY dotto "Dottoro"> 
    <!ENTITY dhf "Dottoro Help File"> 
]>
<root>
    <child>&dotto;</child>
</root>