CSSE 290 Web Programming

Lecture 22: Ajax examples

Reading: 12.2

Except where otherwise noted, the contents of this document are Copyright 2012 Marty Stepp, Jessica Miller, and Victoria Kirst. All rights reserved. Any redistribution, reproduction, transmission, or storage of part or all of the contents in any form is prohibited without the author's expressed written permission.

Otherwise note: Claude Anderson was given permission to modify the slides for CSSE 290 at Rose-Hulman by author Jessica Miller. The authors' original slides, based on Web Programming Step by Step, can be seen at http://webstepbook.com.

Some of the examples in some days' slides are from David Fisher at Rose-Hulman, who was kind enough to allow me to use them. My intention is to mark these examples with [DSF].

Recap: Asynchronous web communication

• asynchronous: user keeps interacting with page while new data loads
  • communication pattern made possible by Ajax

Recap: A typical Ajax request

1. user clicks, invoking an event handler
2. handler's code creates an XMLHttpRequest object
3. XMLHttpRequest object requests info from server
4. server retrieves appropriate data, sends it back
5. XMLHttpRequest fires an event when data arrives
   • we attach a handler function to this event (callback)
6. callback event handler processes the data and displays it

Recap: Prototype's Ajax model

new Ajax.Request("url", {
	option : value,
	option : value,
	...
	option : value
});

• construct a Prototype Ajax.Request object to request a page from a server using Ajax
• constructor accepts 2 parameters:
  1. the URL to fetch, as a String,
  2. a set of options, as a set of key : value pairs in {} braces
     (an anonymous JavaScript object)
• hides messy details of the raw XMLHttpRequest; works well in all browsers

Recap: Prototype Ajax options

Prototype Ajax example

	new Ajax.Request("foo/bar/mydata.txt", {
		method: "get",
		onSuccess: myAjaxSuccessFunction
	});
	...

function myAjaxSuccessFunction(ajax) {
	do something with ajax.responseText;
}

• attach an event handler function to the request's onSuccess event
• the handler takes an Ajax response object as a parameter, which we'll name ajax

Ajax response object's properties

function myAjaxSuccessFunction(ajax) {
	alert(ajax.responseText);
}

• most commonly used property is responseText, to access the fetched text content

Handling Ajax errors

	new Ajax.Request("url", {
		method: "get",
		onSuccess: functionName,
		onFailure: ajaxFailure,
		onException: ajaxFailure
	});
	...
function ajaxFailure(ajax, exception) {
  alert("Error making Ajax request:" + 
	"\n\nServer status:\n" + ajax.status + 
    " " + ajax.statusText + 
	"\n\nServer response text:\n" + ajax.responseText);
  if (exception) {
	throw exception;
	}
}

• for user's (and developer's) benefit, show an error message if a request fails

Debugging Ajax code

• Firebug Net tab (or Chrome's Network tab) shows each request, parameters, response, errors
• expand a request with + and look at Response tab to see Ajax result
• check Console tab for any errors that are thrown by requests

Passing query parameters to a request

new Ajax.Request("lookup_account.php", {
	method: "get",
	parameters: {name: "Ed Smith", age: 29, password: "abcdef"},
	onFailure: ajaxFailure,
	onException: ajaxFailure
});
...

• don't concatenate the parameters onto the URL yourself with "?" + ...
  • won't properly URL-encode the parameters
  • won't work for POST requests
• query parameters are passed as a parameters object, {} braces with name : value pairs
  • (the above is equivalent to: "name=Ed+Smith&age=29&password=abcdef")

Creating a POST request

new Ajax.Request("url", {
	method: "post",
	parameters: {name: value, name: value, ..., name: value},
	onSuccess: functionName,
	onFailure: functionName,
	onException: functionName
});

• method should be changed to "post" (or omitted; post is default)

XMLHttpRequest security restrictions

• Ajax must be run on a web page stored on a web server
• Ajax can only fetch files from the same server that the page is on
  • http://www.foo.com/a/b/c.html can only fetch from www.foo.com

Prototype's Ajax Updater

new Ajax.Updater("id", "url", {
	method: "get"
});

• Ajax.Updater fetches a file and injects its content into an element as innerHTML
  • this is a common Ajax use case: "go fetch this page/file, and put its contents into an element on the page"
  • could do this with Ajax.Request, but Ajax.Updater saves you some typing and work
• additional (1st) parameter specifies the id of element to inject into
• onSuccess handler not needed (but onFailure, onException handlers may still be useful)

Ajax.Updater options

new Ajax.Updater({success: "id", failure: "id"}, "url", {
	method: "get",
	insertion: "top"
});

• instead of passing a single id, you can pass an object with a success and/or failure id
  • the success element will be filled if the request succeeds
  • the failure element (if provided) will be filled if the request fails
• insertion parameter specifies where in the element to insert the text (top, bottom, before, after)

PeriodicalUpdater

new Ajax.PeriodicalUpdater("id", "url", {
	frequency: seconds,
	name: value, ...
});

• Ajax.PeriodicalUpdater repeatedly fetches a file at a given interval and injects its content into an element as innerHTML
• onSuccess handler not needed (but onFailure, onException handlers may still be useful)
• same options as in Ajax.Updater can be passed

Ajax.Responders

Ajax.Responders.register({
	onEvent: functionName,
	onEvent: functionName,
	...
});

• sets up a default handler for a given kind of event for all Ajax requests
• can be useful for attaching a common failure/exception handler to all requests in one place