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

You are here: Reference > JavaScript > client-side > xml handling > properties > nodeTypeString (attribute, Element, ...)

nodeTypeString property (attribute, Element, ...)

Browser support:

Returns the type of the current node as a string.

This property is not supported in HTML documents, only in XML documents.
The nodeType property is similar to the nodeTypeString property, but it returns an integer that represents the type of a node. The nodeType property is supported by the all commonly used browsers in HTML and XML documents also, use it instead.

Syntax:

object.nodeTypeString;

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

This property is read-only.

Possible values:

String that retrieves the type.

One of the following values:

element

The nodeType is ELEMENT_NODE (1)

attribute

The nodeType is ATTRIBUTE_NODE (2)

text

The nodeType is TEXT_NODE (3)

cdatasection

The nodeType is CDATA_SECTION_NODE (4)

entityreference

The nodeType is ENTITY_REFERENCE_NODE (5)

entity

The nodeType is ENTITY_NODE (6)

processinginstruction

The nodeType is PROCESSING_INSTRUCTION_NODE (7)

comment

The nodeType is COMMENT_NODE (8)

document

The nodeType is DOCUMENT_NODE (9)

documenttype

The nodeType is DOCUMENT_TYPE_NODE (10)

documentfragment

The nodeType is DOCUMENT_FRAGMENT_NODE (11)

notation

The nodeType is NOTATION_NODE (12)

Default: this property has no default value.

Example HTML code 1:

This example illustrates the use of the nodeTypeString property:

Code

ajax.js

<head>
    <script type="text/javascript" src="ajax.js"></script>
    
    <script type="text/javascript">
        function GetNodeTypes () {
                // create an XML document
            var xmlDoc = CreateXMLDocumentObject ("root");  // defined in ajax.js
            if (!xmlDoc) {
                return null;
            }

            alert ("The type of the document: " + xmlDoc.nodeTypeString);
            alert ("The type of the root node: " + root.nodeTypeString);
        }
    </script>
</head>
<body>
    <button onclick="GetNodeTypes ();">Get different node types!</button>
</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;
}