20-4-2010 1

Ajax
Outlines:
 Basic objects necessary

 Setting up the XMLHttpRequest object

 Making the call

 How the server responds

 Using the reply

 XML basics
The usual way we operate in the Web
Typical browsing behaviour consists of loading a web page, then

selecting some action that we want to do, filling out a form,

submitting the information, etc...
We work in this sequential manner, requesting one page at a

time, and have to wait for the server to respond, loading a whole
new web page before we continue.
This is also one of the limitations of web pages, where

transmitting information between a client and server generally

requires a new page to be loaded.
20-4-2010 4
Java Script... But!!
 JavaScript is one way to cut down on (some of ) the client-server
response time, by using it to verify form (or other) information before
it’s submitted to a server.

 One of the limitations of JavaScript is (or used to be) that there was no
way to communicate directly with a web server.

 Another drawback to this usual sequential access method is that there

are many situations where you load a new page that shares lots of the
same parts as the old (consider the case where you have a “menu bar”
on the top or side of the page that doesn’t change from page to page).
Things changed…
Until recently, we didn’t have any alternative to this

load/wait/respond method of web browsing.

Ajax (sometimes written AJAX) is a means of using

JavaScript to communicate with a web server without

submitting a form or loading a new page.
Ajax makes use of a built-in object, XMLHttpRequest, to

perform this function.

Things changed (cont.)…
This object is not yet part of the DOM (Document Object

Model) standard, but is supported (in different fashions) by

Firefox, Internet Explorer, Safari, Opera, and other popular
browsers.
The term “Ajax” was coined in 2005, but the XMLHttpRequest

object was first supported by Internet Explorer several years

before this.
Ajax
 Ajax stands for “Asynchronous JavaScript and XML”.

 The word “asynchronous” means that the user isn’t left

waiting for the server the respond to a request, but can

continue using the web page.

 Ajax.. How it works
 The typical method for using Ajax is the following:
1) A JavaScript creates an XMLHttpRequest object, initializes it with
relevant information as necessary, and sends it to the server. The
script (or web page) can continue after sending it to the server.

2) The server responds by sending the contents of a file or the output of a

server side program (written, for example, in PHP).

3) When the response arrives from the server, a JavaScript function is

triggered to act on the data supplied by the server.

4) This JavaScript response function typically refreshes the display using

the DOM, avoiding the requirement to reload or refresh the entire
page.
20-4-2010 10
 Ajax Components
XHTML and CSS
Ajax applies these Web standards for styling the look and feel of a page and to markup
those areas on a page that will be targeted for data updates.

DOM (document object model)

Ajax uses the DOM to manipulate dynamic page views for data and to walkthrough
documents to “cherrypick” data. The DOM enables certain pieces of an Ajax page to be
transformed and updated with data.

XML, JSON (Javascript Object Notation), HTML, or plain text

Ajax can use any of these standards to provide structure to the data it passes to and from a
page.

XMLHttpRequest object
The heavy lifter for Ajax: It’s a javascript object embedded in most modern browsers that
sets up data request/response pipelines between client and server.

Javascript
Lightweight programming language that Ajax uses for instructions to bind all of the
components together.
How Ajax Works
Classic XHTML form: User submits entire form to server, which validates the data entered (if any).
Server responds indicating fields with invalid or missing data.
Ajax-enabled form shows errors asynchronously when user moves to another field.
Potential Problems
 Javascript MUST be enabled

 Back button doesn’t always work

 Pages can be difficult to bookmark

 Search engines may not be able to index all portions

of an Ajax site

 Cross browser differences in how XML is dealt with

Ajax Web Interaction
What you don’t see:

Data reload happens in the background

JavaScript queries the server to get the proper data

without you knowing it

Page updates without a screen “reload”
 The Back End
The part of the Ajax application that resides on the web server is

referred to as the “back end”.

This back end could be simply a file that the server passes back to the

client, which is then displayed for the user.

Alternatively, the back end could be a program, written in PHP, Perl,

Ruby, Python, C, or some other language that performs an operation

and sends results back to the client browser.

The Back End (Cont.)
An XMLHttpRequest object can send information using the GET

and POST methods to the server in the same way that an HTML
form sends information.
Recall from our previous discussions that the GET request

encodes the information inside of the URL, while a POST

request sends its data separately (and can contain more
information than a GET request can).
Writing an Ajax application
We have to write the “front end” of the application in JavaScript

to initiate the request.

The back end, as mentioned, processes the request and sends it’s

response back to the client. The back end is typically a short

program we write for performing some dedicated task. This
could be scripted in any language that is capable of sending back
communication to the browser, like PHP or Perl.
We also need to write the JavaScript response function for

processing the response and displaying any results (or alterations

to the web page).
Writing an Ajax application (Cont.)
The “x” in Ajax stands for XML, the extensible markup language.

XML looks like HTML, which is no mistake as the latest versions

of HTML are built upon XML. The back end could send data
back in XML format and the JavaScript response function can
process it using built-in functions for working with XML. The
back end could also send plain text, HTML, or even data in the
JavaScript format.
We will discuss some of these methods for sending data back to

the requesting client and how it can be processed.

The XMLHttpRequest object
The XMLHttpRequest object is the backbone of every Ajax
method. Each application requires the creation of one of these
objects. So how do we do it?
As with most things in web programming, this depends upon the
web browser that the client is using because of the different ways
in which the object has been implemented in the browsers.

Firefox, Safari, Opera, and some other browsers can create one of
these objects simply using the “new” keyword.
<script type=“text/javascript”>
ajaxRequest = new XMLHttpRequest();

</script>
 The XMLHttpRequest object (cont.)
Microsoft Internet Explorer implements this object using its
proprietary ActiveX technology. This requires a different syntax
for creating the object (and can also depend upon the particular
version of Internet Explorer being used).
To handle different types of browsers, we use the
try { . . . } catch (error) { . . . } format.
The “try” section attempts to execute some JavaScipt code. If an
error occurs, the “catch” section is used to intervene before the
error crashes the JavaScript (either to indicate an error has
happened, or to attempt something else).
To create one of these objects we can use a sequence of try. . . catch
blocks, attempting different ways to create an XMLHttpRequest
object.
function getXMLHttpRequest()
/* This function attempts to get an Ajax request object by trying
a few different methods for different browsers. */
{
var request, err;
try {
request = new XMLHttpRequest();// Firefox, Safari, Opera,etc.
}//try
catch(err) {// catch 1
try { // first attempt for Internet Explorer
request = new ActiveXObject("MSXML2.XMLHttp.6.0");
}//try
catch (err) {// catch 2
try { // second attempt for Internet Explorer
request = new ActiveXObject("MSXML2.XMLHttp.3.0");
}//try
catch (err) { // catch 3
request = false; // oops, can’t create one!
}// catch 3
} //catch 2
} //catch 1
return request;
}// function

If this function doesn’t return “false” then we were successful in creating an

XMLHttpRequest object.
The XMLHttpRequest object (cont.)
As with any object in JavaScript (and other programming
languages), the XMLHttpRequest object contains various properties
and methods.
We list the most important of these properties and methods on the
next slides.
The main idea is that the properties are set after the object is
created to specify information to be sent to the server, as well as
how to handle the response received from the server. Some
properties will be updated to hold status information about
whether the request finished successfully.
The methods are used to send the request to the server, and to
monitor the progress of the request as it is executed (and to
determine if it was completed successfully).
 XMLHttpRequest object properties
Property Description

 readyState An integer from 0. . .4.

(0 means the call is uninitialized, 4 means
that the call is complete.)
 onreadystatechange Determines the function called when the
objects readyState changes.
 responseText Data returned from the server as a text
string (read-only).
 responseXML Data returned from the server as an XML
document object (read-only).
 status HTTP status code returned by the server.
200 means successful. 404 means resource was not found
and 500 error while the server was processing the request.
 statusText HTTP status phrase returned by the server
We use the readyState to determine when the request has been completed,
and then check the status to see if it executed without an error.
 XMLHttpRequest object methods
Method Description
 open(‘method’,’URL’,asyn) Specifies the HTTP method to
be used (GET or POST as a
string, the target URL, and
whether or not the request
should be handled asynchronously
(asyn should be true or false,
if omitted, true is assumed).
 send(content) Sends the data for a POST
request and starts the request,
if GET is used you should call
send(null).
 setRequestHeader(‘x’,‘y’) Sets a parameter and value pair
x=y and assigns it to the header
to be sent with the request.
 getAllResponseHeaders() Returns all headers as a string.
 getResponseHeader(x) Returns header x as a string.
 abort() Stops the current operation.
The open object method is used to set up the request, and the send method starts
the request by sending it to the server (with data for the server if the POST
method is used).
A general skeleton for an Ajax application
<script type=“text/javascript”>
// include the getXMLHttpRequest function defined before
var ajaxRequest = getXMLHttpRequest();
if (ajaxRequest) { // if the object was created successfully
ajaxRequest.onreadystatechange = ajaxResponse;
ajaxRequest.open(“GET”, “search.php?query=Bob”);
ajaxRequest.send(null);
}//if
function ajaxResponse() //This gets called when the readyState changes.

{
if (ajaxRequest.readyState != 4) // check to see if we’re done
{ return; }//if
else {
if (ajaxRequest.status == 200) // check to see if successful
{ // process server data here. . . }//if
else {
alert(“Request failed: “ + ajaxRequest.statusText);
}//else
}//else
}//function
</script>
A first example
 The main idea is that we’re going to get the time on the server and

display it to the screen (and provide a button for a user to update this
time). The point I want to demonstrate here is how to use Ajax to do this
update without updating/refreshing the entire webpage.

 We use a (very) small PHP script to get the date from the server, and

return it as a string as a response to the request. Here is the script:

<?php
echo date('H:i:s');
?>

 I saved this as the file “telltime.php”.

 The HTML file and JavaScript code follows.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en"
lang="en">

<head>
<title>Ajax Demonstration</title>
<style>
body {
background-color: #CCCCCC;
text-align: center;
}
.displaybox {
margin: auto;
width: 150px;
background-color: #FFFFFF;
border: 2px solid #000000;
padding: 10px;
font: 1.5em normal verdana, helvetica, arial, sans-
serif;
}
</style>
<script type="text/javascript">
var ajaxRequest;

function getXMLHttpRequest()
/* This function attempts to get an Ajax request object by trying
a few different methods for different browsers. */
{
// same code as before. . .
}

function ajaxResponse()//This gets called when the readyState changes.

{
if (ajaxRequest.readyState != 4) // check to see if we're done
{ return; }
else {
if (ajaxRequest.status == 200) // check to see if successful
{
document.getElementById("showtime").innerHTML =

ajaxRequest.responseText; }
else {
alert("Request failed: " + ajaxRequest.statusText);
}
}
}
function getServerTime() // The main JavaScript for
calling the update.
{
ajaxRequest = getXMLHttpRequest();
if (!ajaxRequest) {
document.getElementById("showtime").innerHTML =
"Request error!";
return; }
var myURL = "telltime.php";
var myRand = parseInt(Math.random()*999999999999999);
myURL = myURL + "?rand=" + myRand;
ajaxRequest.onreadystatechange = ajaxResponse;
ajaxRequest.open("GET", myURL);
ajaxRequest.send(null);
}
</script>
</head>
<body onLoad="getServerTime();">
<h1>Ajax Demonstration</h1>
<h2>Getting the server time without refreshing the
page</h2>
<form>
<input type="button" value="Get Server Time"
onClick="getServerTime();" />
</form>
<div id="showtime" class="displaybox"></div>
</body>
</html>

• The main functionality is handled by the getServerTime()

function in setting up and sending the XMLHttpRequest
object, and the ajaxResponse() function to display the time.
 What’s this business with the random numbers?
Web browsers use caches to store copies of the web page. A
browser could use data from it’s cache instead of making a request
to the web server.
The whole point of Ajax is to make server requests and not to read
data from the cache.
To avoid this potential problem, we can add a parameter with a
random string to the URL so that the browser won’t be reading
data from its cache to satisfy the request (as then it looks like a
different request than previous ones).
This is only necessary if the request method is GET, as POST
requests don’t use the cache. (This also seems to be more of an
issue with Microsoft Internet Explorer than with other browsers.)
 XML: a (very) brief introduction
 XML, the eXtensible Markup Language, is used in many ways, the most

relevant to us being the transfer of structured information.

 XML and HTML look similar in many ways and this is because both are

based on SGML, the Standard Generalized Markup Language established

by the International Organization for Standards (ISO).

 Like HTML, XML uses tags to denote information but is not limited to the

types of tags that occur in HTML. Tags can be essentially anything a user

likes and are used to define the type of data present in the document.
 XML: a (very) brief intro (cont.)
Here’s an example:
<library>
<book>
<title>Programming PHP</title>
<author>Rasmus Lerdorf</author>
<author>Kevin Tatroe</author>
<author>Peter MacIntyre</author>
<chapter number=“1”>Introduction to PHP</chapter>
<chapter number=“2”>Language Basics</chapter>
. . .
<pages>521</pages>
</book>
. . .
</library>
Accessing an XML document in JavaScript
To use an XML document in JavaScript, you must create an
object to hold it. This can be done in the following fashion:
 Non-Microsoft browsers:

<script>
var myXMLDoc = document.implementation.createDocument(“”,””,null);
myXMLDoc.load(“mydoc.xml”);
// other code here
</script>
Accessing an XML document in JavaScript
 Internet Explorer:

<script>
var myXMLDoc = new ActiveXObject(“Microsoft.XMLDOM”);
myXMLDoc.async=“false”;
myXMLDoc.load(“mydoc.xml”);
// other code here
</script>

 Once we’ve created the object holding the XML document, we can then

use JavaScript methods to examine it, extract data from it, etc.
 The “time” example using XML
The first change is to make a new PHP script that returns an XML
document to the browser.
<?php
header('Content-Type: text/xml');
echo "<?xml version=\"1.0\" ?>\n”;
echo “<clock><timenow>" . date('H:i:s') ."</timenow>< /clock>";
?>
After that change (and inserting the new script name into the HTML code),
we need to alter the ajaxResponse function to parse the XML
document. That new JavaScript function is given on the next page.

Note that we need not explicitly create an object to hold the XML
document, but that responseXML (as a property of XMLHttpRequest) is
already such an object.
 The new Ajax response function
function ajaxResponse() //This gets called when the readyState
changes.
{ if (ajaxRequest.readyState != 4) // check to see if we're
done
{ return; }
else {
if (ajaxRequest.status == 200) // check to see if successful
{ var timeValue =
ajaxRequest.responseXML.getElementsByTagName("timenow")[0];
document.getElementById("showtime").innerHTML =
timeValue.childNodes[0].nodeValue; }
else {
alert("Request failed: " + ajaxRequest.statusText);
}
}
}
 This new response function uses a JavaScript method to access the XML DOM
and retrieve the time string before inserting it into the output display box.
 Some cautions
 As with any JavaScript element, you can’t (or shouldn’t) rely upon a user’s

browser being able to execute JavaScript (some people turn it off on their

browsers). (Of course, there are web pages that ignore this caution.)

 Debug carefully and on many different browsers. Ajax uses features that

might not be present in all browsers or they may not operate in the same

fashion.

 If you can, indicate to the user that “something is happening” or that

something has changed on the page, otherwise they may not notice it.
 Some cautions
Ajax can possibly introduce strange behavior, like the “Back”

button on the browser doesn’t act like it did before (as with any

dynamic website), or that if you use some “hidden” elements in

your page (generated by Ajax), then they will likely not show

up in a form that search engines will recognize.

Don’t let “flashy behavior” be a substitute for actual content, or

a well designed layout of your web pages.

 References
PH,.AJAX Rich Internet Applications and Web
Development for Programmers , Deitel: Chapter 13

The End
Thank you for patience!

26-4-2010 42