Manipulating XML Data with JavaScript - 21.4.2 Evaluating XPath Expressions
(Page 5 of 5 )
Example 21-10 shows an XML.XPathExpression class that works in IE and in standards-compliant browsers such as Firefox.
Example 21-10. Evaluating XPath expressions
/**
* XML.XPathExpression is a class that encapsulates an XPath query and its
* associated namespace prefix-to-URL mapping. Once an XML.XPathExpression
* object has been created, it can be evaluated one or more times (in on e
* or more contexts) using the getNode() or getNodes() methods.
*
* The first argument to this constructor is the text of the XPath expression.
*
* If the expression includes any XML namespaces, the second argument must
* be a JavaScript object that maps namespace prefixes to the URLs that define
* those namespaces. The properties of this object are the prefixes, and
* the values of those properties are the URLs.
*/
XML.XPathExpression = function(xpathText, namespaces) {
this.xpathText = xpathText; // Save the text of the expression
this.namespaces = namespaces; // And the namespace mapping
if (document.createExpression) {
// If we're in a W3C-compliant browser, use the W3C API
// to compile the text of the XPath query
this.xpathExpr =
document.createExpression(xpathText,
// This function is passed a
// namespace prefix and returns the URL.
function(prefix) {
return namespaces[prefix];
});
}
else {
// Otherwise, we assume for now that we're in IE and convert the
// namespaces object into the textual form that IE requires.
this.namespaceString = "";
if (namespaces != null) {
for(var prefix in namespaces) {
// Add a space if there is already something there
if (this.namespaceString) this.namespaceString += ' ';
// And add the namespace
this.namespaceString += 'xmlns:' + prefix + '="' +
namespaces[prefix] + '"';
}
}
}
};
/**
* This is the getNodes() method of XML.XPathExpression. It evaluates the
* XPath expression in the specified context. The context argument should
* be a Document or Element object. The return value is an array
* or array-like object containing the nodes that match the expression.
*/
XML.XPathExpression.prototype.getNodes = function(context) {
if (this.xpathExpr) {
// If we are in a W3C-compliant browser, we compiled the
// expression in the constructor. We now evaluate that compiled
// expression in the specified context.
var result =
this.xpathExpr.evaluate(context,
// This is the result type we want
XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,
null);
// Copy the results we get into an array.
var a = new Array(result.snapshotLength);
for(var i = 0; i < result.snapshotLength; i++) {
a[i] = result.snapshotItem(i);
}
return a;
}
else {
// If we are not in a W3C-compliant browser, attempt to evaluate
// the expression using the IE API.
try {
// We need the Document object to specify namespaces
var doc = context.ownerDocument;
// If the context doesn't have ownerDocument, it is the Document
if (doc == null) doc = context;
// This is IE-specific magic to specify prefix-to-URL mapping
doc.setProperty("SelectionLanguage", "XPath");
doc.setProperty("SelectionNamespaces", this.namespaceString);
// In IE, the context must be an Element not a Document,
// so if context is a document, use documentElement instead
if (context == doc) context = doc.documentElement;
// Now use the IE method selectNodes() to evaluate the expression
return context.selectNodes(this.xpathText);
}
catch(e) {
// If the IE API doesn't work, we just give up
throw "XPath not supported by this browser.";
}
}
}
/**
* This is the getNode() method of XML.XPathExpression. It evaluates the
* XPath expression in the specified context and returns a single matching
* node (or null if no node matches). If more than one node matches,
* this method returns the first one in the document.
* The implementation differs from getNodes() only in the return type.
*/
XML.XPathExpression.prototype.getNode = function(context) {
if (this.xpathExpr) {
var result =
this.xpathExpr.evaluate(context,
// We just want the first match
XPathResult.FIRST_ORDERED_NODE_TYPE,
null);
return result.singleNodeValue;
}
else {
try {
var doc = context.ownerDocument;
if (doc == null) doc = context;
doc.setProperty("SelectionLanguage", "XPath");
doc.setProperty("SelectionNamespaces", this.namespaceString);
if (context == doc) context = doc.documentElement;
// In IE call selectSingleNode instead of selectNodes
return context.selectSingleNode(this.xpathText);
}
catch(e) {
throw "XPath not supported by this browser.";
}
}
};
// A utility to create an XML.XPathExpression and call getNodes() on it
XML.getNodes = function(context, xpathExpr, namespaces) {
return (new XML.XPathExpression(xpathExpr, namespaces)).getNodes(context);
};
// A utility to create an XML.XPathExpression and call getNode() on it XML.getNode = function(context, xpathExpr, namespaces) {
return (new XML.XPathExpression(xpathExpr, namespaces)).getNode(context);
};
21.4.3 More on the W3C XPath API
Because of the limitations in the IE XPath API, the code in Example 21-10 handles only queries that evaluate to a document node or set of nodes. It is not possible in IE to evaluate an XPath expression that returns a string of text or a number. This is possible with the W3C standard API, however, using code that looks like this:
// How many <p> tags in the document ?
var n = document.evaluate("count(//p)", document, null,
XPathResult.NUMBER_TYPE, null).numberValue;
// What is the text of the 2nd paragraph?
var text = document.evaluate("//p[2]/text()", document, null,
XPathResult.STRING_TYPE, null).stringValue;
There are two things to note about these simple examples. First, they use the document.evaluate() method to evaluate an XPath expression directly without com piling it first. The code in Example 21-10 instead used document.createExpression() to compile an XPath expression into a form that could be reused. Second, notice that these examples are working with HTML <p> tags in the document object. In Firefox, XPath queries can be used on HTML documents as well as XML documents.
See Document, XPathExpression, and XPathResult in Part IV for complete details on the W3C XPath API.
Please check back next week for the conclusion to this article.
| DISCLAIMER: The content provided in this article is not warranted or guaranteed by Developer Shed, Inc. The content provided is intended for entertainment and/or educational purposes in order to introduce to the reader key ideas, concepts, and/or product reviews. As such it is incumbent upon the reader to employ real-world tactics for security and implementation of best practices. We are not liable for any negative consequences that may result from implementing any information covered in our articles or tutorials. If this is a hardware review, it is not recommended to open and/or modify your hardware. |
|
 This article is excerpted from chapter 21 of JavaScript: The Definitive Guide, Fifth Edition, written by David Flanagan (O'Reilly; ISBN: 0596101996). Check it out today at your favorite bookstore. Buy this book now.
|
|
/ 5 
