Developer Notes for prototype.js

covers version 1.5.0

by
last update: August 18th 2007

Table of Contents

What is that?

In case you haven't already used it, prototype.js is a JavaScript library initially written by Sam Stephenson. This amazingly well thought and well written piece of standards-compliant code takes a lot of the burden associated with creating rich, highly interactive web pages that characterize the Web 2.0 off your back.

When I first started trying to use this library, a few years ago, I noticed that the documentation was definitely not one of its strongest points. As many other developers before me, I got my head around prototype.js by reading the source code and experimenting with it. I thought it would be nice to take notes while I learned and share with everybody else.

I'm also offering an un-official reference for the objects, classes, functions, and extensions provided by this library.

As you read the examples and the reference, developers familiar with the Ruby programming language will notice an intentional similarity between Ruby's built-in classes and many of the extensions implemented by this library. That's not surprising since prototype.js is a spinoff and is directly influenced by the requirements of the Ruby on Rails framework.

As far as browser support goes, prototype.js tries to support Internet Explorer (Windows) 6.0+, Mozilla Firefox 1.5+, Apple Safari 1.0+, and Opera 9+. Supporting these browsers also cause some other browsers that share their rendering engines to be supported as well, like Camino, Konqueror, IceWeasel, Netscape 6+, SeaMonkey, etc.

toc

Related article

Advanced JavaScript guide.

toc

The utility functions

The library comes with many predefined objects and utility functions. The obvious goal of these functions is to save you a lot of repeated typing and idioms.

toc

Using the $() function

The $() function is a handy shortcut to the all-too-frequent document.getElementById() function of the DOM. Like the DOM function, this one returns the element that has the id passed as an argument.

Unlike the DOM function, though, this one goes further. The returned element object will be augmented with some extra methods. These extra methods simplify many tasks, like hiding/showing the element, getting its size, scrolling to the element, etc. You can get a \list of the methods that are added to the returned element object in the reference for the Element.Methods object. Furthermore, if the element is a form it will also receive copies of the utility methods from Form.Methods and if the element is a form field (input, select, or textarea) it will additionally receive copies of the utility methods from Form.Element.Methods. 

<html>
<head>
<title> Test Page </title>
<script src="prototype.js"></script>

<script>
	function test(){
		var d = $('myDiv');
		alert(d.innerHTML);
		d.hide();
		d.show();
		d.addClassName('active');
	}
</script>
</head>

<body>
	<div id="myDiv">
		<p>This is a paragraph</p>
	</div>
	<div id="myOtherDiv">
		<p>This is another paragraph</p>
	</div>

	<input type="button" value="Test $()" onclick="test();"/><br/> 

</body>
</html>

Because many of the new methods added to the element return the element itself, you can chain the method calls to make more compact code: 


//change the text, the CSS class, and make the element visible			
$('messageDiv').update('Your order was accepted.').addClassName('operationOK').show();

Another nice thing about this function is that you can pass either the id string or the element object itself, which makes this function very useful when creating other functions that can also take either form of argument.

toc

Using the $$() function

The $$() function will help you a lot if you consistently separate CSS from the content wireframe. It parses one or more CSS filtering expressions, analogous to the ones used to define CSS rules, and returns the elements that match these filters.

It's so easy to use it's ridiculous. Check this out. 

<script>
function test$$(){
	/*
	  in case CSS is not your forte, the expression below says
	  'find all the INPUT elements that are inside 
	  elements with class=field that are inside a DIV
	  with id equal to loginForm.'
	*/
	var f = $$('div#loginForm .field input');
	var s = '';
	for(var i=0; i<f.length; i++){
		s += f[i].value + '/';
	}
	alert(s); // shows: "joedoe1/secret/"
	
	//now passing more than one expression
	f = $$('div#loginForm .field input', 'div#loginForm .fieldName');
	s = '';
	for(var i=0; i<f.length; i++){
		s += ( f[i].value ? f[i].value : f[i].innerHTML ) + '/';
	}
	alert(s); //shows: "joedoe1/secret/User name:/Password:/"
}


</script>

<div id='loginForm'>
	<div class='field'>
		<span class='fieldName'>User name:</span>
		<input type='text' id='txtName' value='joedoe1'/>
	</div>
	<div class='field'>
		<span class='fieldName'>Password:</span>
		<input type='password' id='txtPass' value='secret' />
	</div>
	<input type='submit' value='login' />
</div> 
<input type=button value='test $$()' onclick='test$$();' />

A quick note on performance. The current implementation of the $$() function in prototype.js is not regarded as particularly efficient. If you plan on traversing deep and complex HTML documents using this function frequently, you may want to consider other freely available implementations, possibly simply substituting the $$() function itself.

toc

Using the $F() function

The $F() function is another welcome shortcut. It returns the value of any field input control, like text boxes or drop-down lists. The function can take as argument either the element id or the element object itself. 

<script>
	function test3()
	{
		alert(  $F('userName')  );
	}
</script>

<input type="text" id="userName" value="Joe Doe"><br/> 
<input type="button" value="Test3" onclick="test3();"><br/>

toc

Using the $A() function

The $A() function converts the single argument it receives into an Array object.

This function, combined with the extensions for the Array class, makes it easier to convert or copy any enumerable list into an Array object. One suggested use is to convert DOM NodeLists into regular arrays, which can be traversed more efficiently. See example below. 

<script>

	function showOptions(){
		var someNodeList = $('lstEmployees').getElementsByTagName('option');
		var nodes = $A(someNodeList);

		nodes.each(function(node){
				alert(node.nodeName + ': ' + node.innerHTML);
			});
	}
</script>

<select id="lstEmployees" size="10" >
	<option value="5">Buchanan, Steven</option>
	<option value="8">Callahan, Laura</option>
	<option value="1">Davolio, Nancy</option>
</select>

<input type="button" value="Show the options" onclick="showOptions();" >

toc

Using the $H() function

The $H() function converts objects into enumerable Hash objects that resemble associative arrays. 

<script>
	function testHash()
	{
		//let's create the object
		var a = {
			first: 10,
			second: 20,
			third: 30
			};

		//now transform it into a hash
		var h = $H(a);
		alert(h.toQueryString()); //displays: first=10&second=20&third=30
	}

</script>

toc

Using the $R() function

The $R() function is simply a short hand to writing new ObjectRange(lowerBound, upperBound, excludeBounds).

Jump to the ObjectRange class documentation for a complete explanation of this class. In the meantime, let's take a look at a simple example that also shows the usage of iterators through the each method. More on that method will be found in the Enumerable object documentation. 

<script>
	function demoDollar_R(){
		var range = $R(10, 20, false);
		range.each(function(value, index){
			alert(value);
		});
	}

</script>

<input type="button" value="Sample Count" onclick="demoDollar_R();" />

toc

Using the Try.these() function

The Try.these() function makes it easy when you want to, ahem, try different function calls until one of them works. It takes a number of functions as arguments and calls them one by one, in sequence, until one of them works, returning the result of that successful function call.

In the example below, the function xmlNode.text works in some browsers, and xmlNode.textContent works in the other browsers. Using the Try.these() function we can return the one that works. 

<script>
function getXmlNodeValue(xmlNode){
	return Try.these(
		function() {return xmlNode.text;},
		function() {return xmlNode.textContent;}
		);
}
</script>

toc

Tricked out strings

Strings are powerful objects. Prototype.js takes that power and elevates it by another level of magnitude.

String substitutions

When it comes string substitutions JavaScript already has the methods like String.Replace, which even works with regular expressions, but it's still not as flexible as the alternative introduced by prototype.js.

Meet the new String.gsub method. With this method you can not only find and replace a fixed string or a regular expression pattern, but you also have much more control over the replacement process. You can, for example, use a string template to instruct the method on how you would like the found elements to be transformed (rather than simply replaced.)

The example below searches for words containing 't' and replaces the portion that comes after the 't' with 'tizzle', in a lame shot at being funny. In case the example is not very clear, the regular expression we chose has a capture group declaration: the \w+ enclosed in parenthesis. We can get the value captured by this group using #{1} in the replacement template string.

In our example we are capturing what comes before the 't' and appending 'tizzle' to it. If we had more capture groups in the regular expression, we would get the values with #{2}, #{3}, and so on. 

<script>
function talkLikeYouKnowSomething(){
	var s = 'prototype string extensions can help you';
	var snoopdogfy = /\b(\w+)t\w+\b/;
	var snooptalk = s.gsub(snoopdogfy, '#{1}tizzle' );
	alert(snooptalk); // shows: "prototizzle stizzle extizzle can help you"				
}
</script>

Let's not stop there. The substitution we have just made is not all that powerful because we are limited to pattern matching and substitutions. What if we could operate on the matches with custom logic to produce the desired substitution vaues? We can do that if we pass a function as the second argument to gsub. The function will receive an array with the matched text (index 0) and any capture group values (index 1 to N.) 

<script>
function scamCustomers(){
	var prices = 'book1 $12.5, magazine $5.50, pencil $1.20';
	var priceFinder = /\$([0-9\.]+)/;
	var r = prices.gsub(priceFinder, jackUp);
	alert(r);//shows: "book1 $13.75, magazine $6.05, pencil $1.32"
}
	
function jackUp(matches){
	//increases the prices by 10%
	var price = parseFloat(matches[1]);
   	return '$' + Math.round(110 * price)/100;
}
</script>

String templates

As you increase the amount of JavaScript code in your applications, increasingly you'll find yourself with collections of objects of the same type and that you need to list or present in a formatted way.

It's not rare to find code in your applications that loops through a list of objects, building a string based on the object properties and some fixed formatting elements. Prototype.js comes with the Template class, which aims at helping you with exactly this type of scenarios.

The example below shows how to format a list of items in a shopping cart in multiple HTML lines. 

<script>
function printCart(){
	//creating a sample cart
	var cart = new Object();
	cart.items = [ ];
	//putting some sample items in the cart
	cart.items.push({product: 'Book 123', price: 24.50, quantity: 1});
	cart.items.push({product: 'Set of Pens', price: 5.44, quantity: 3});
	cart.items.push({product: 'Gift Card', price: 10.00, quantity: 4});
	
	//here we create our template for formatting each item
	var itemFormat = new Template(
			'You are ordering #{quantity} units ' + 
			'of #{product} at $#{price} each'
			);
	var formatted = '';
	
	for(var i=0; i<cart.items.length; i++){
		var cartItem = cart.items[i];
		formatted += itemFormat.evaluate(cartItem) + '<br/>\n';
	}
	
	alert(formatted);
	/* SHOWS:
	You are ordering 1 units of Book 123 at $24.5 each<br/>
	You are ordering 3 units of Set of Pens at $5.44 each<br/>
	You are ordering 4 units of Gift Card at $10 each<br/>
	*/
}
</script>

For a more complete list of new methods, see the String extensions reference.

toc

The Ajax object

The utility functions mentioned above are nice but, let's face it, they are not the most advanced type of thing, now are they? You could probably have done it yourself and you may even have similar functions in your own scripts. But those functions are just the tip of the iceberg.

I'm sure that your interest in prototype.js is driven mostly by its AJAX capabilities. So let's explain how the library makes your life easier when you need to perform AJAX logic.

The Ajax object is a pre-defined object, created by the library to wrap and simplify the tricky code that is involved when writing AJAX functionality. This object contains a number of classes that provide encapsulated AJAX logic. Let's take a look at some of them.

toc

Using the Ajax.Request class

If you are not using any helper library, you are probably writing a whole lot of code to create a XMLHttpRequest object and then track its progress asynchronously, then extract the response and process it. And consider yourself lucky if you do not have to support more than one type of browser.

To assist with AJAX functionality, the library defines the Ajax.Request class.

Let's say you have an application that can communicate with the server via the url http://yourserver/app/get_sales?empID=1234&year=1998, which returns an XML response like the following. 

<?xml version="1.0" encoding="utf-8" ?> 
<ajax-response>
	<response type="object" id="productDetails">
		<monthly-sales>
			<employee-sales>
				<employee-id>1234</employee-id> 
				<year-month>1998-01</year-month> 
				<sales>$8,115.36</sales> 
			</employee-sales>
			<employee-sales>
				<employee-id>1234</employee-id> 
				<year-month>1998-02</year-month> 
				<sales>$11,147.51</sales> 
			</employee-sales>
		</monthly-sales>
	</response>
</ajax-response>

Talking to the server to retrieve this XML is pretty simple using an Ajax.Request object. The sample below shows how it can be done. 

<script>
	function searchSales()
	{
		var empID = $F('lstEmployees');
		var y = $F('lstYears');
		var url = 'http://yourserver/app/get_sales';
		var pars = 'empID=' + empID + '&year=' + y;
		
		var myAjax = new Ajax.Request(
			url, 
			{
				method: 'get', 
				parameters: pars, 
				onComplete: showResponse
			});
		
	}

	function showResponse(originalRequest)
	{
		//put returned XML in the textarea
		$('result').value = originalRequest.responseText;
	}
</script>

<select id="lstEmployees" size="10" onchange="searchSales()">
	<option value="5">Buchanan, Steven</option>
	<option value="8">Callahan, Laura</option>
	<option value="1">Davolio, Nancy</option>
</select>
<select id="lstYears" size="3" onchange="searchSales()">
	<option selected="selected" value="1996">1996</option>
	<option value="1997">1997</option>
	<option value="1998">1998</option>
</select>
<br/><textarea id="result" cols=60 rows=10 ></textarea>

Can you see the second parameter passed to the constructor of the Ajax.Request object? The parameter {method: 'get', parameters: pars, onComplete: showResponse} represents an anonymous object in literal notation (a.k.a. JSON). What it means is that we are passing an object that has a property named method that contains the string 'get', another property named parameters that contains the querystring of the HTTP request, and an onComplete property/method containing the function showResponse.

There are a few other properties that you can define and populate in this object, like asynchronous, which can be true or false and determines if the AJAX call to the server will be made asynchronously (the default value is true.)

This parameter defines the options for the AJAX call. In our sample, we are calling the url in the first argument via a HTTP GET command, passing the querystring contained in the variable pars, and the Ajax.Request object will call the showResponse function when it finishes retrieving the response.

As you may know, the XMLHttpRequest reports progress during the HTTP call. This progress can inform four different stages: Loading, Loaded, Interactive, or Complete. You can make the Ajax.Request object call a custom function in any of these stages, the Complete being the most common one. To inform the function to the object, simply provide property/methods named onXXXXX in the request options, just like the onComplete from our example. The function you pass in will be called by the object with two arguments, the first one will be the XMLHttpRequest (a.k.a. XHR) object itself and the second one will be the evaluated X-JSON response HTTP header (if one is present). You can then use the XHR to get the returned data and maybe check the status property, which will contain the HTTP result code of the call. The X-JSON header is useful if you want to return some script or JSON-formatted data.

Two other interesting options can be used to process the results. We can specify the onSuccess option as a function to be called when the AJAX call executes without errors and, conversely, the onFailure option can be a function to be called when a server error happens. Just like the onXXXXX option functions, these two will also be called passing the XHR that carried the AJAX call and the evaluated X-JSON header.

Our sample did not process the XML response in any interesting way. We just dumped the XML in the textarea. A typical usage of the response would probably find the desired information inside the XML and update some page elements, or maybe even some sort of XSLT transformation to produce HTML in the page.

There's also another form of event callback handling available. If you have code that should always be executed for a particular event, regardless of which AJAX call caused it to happen, then you can use the new Ajax.Responders object.

Let's suppose you want to show some visual indication that an AJAX call is in progress, like a spinning icon or something of that nature. You can use two global event handlers to help you, one to show the icon when the first call starts and another one to hide the icon when the last one finishes. See example below. 

<script>
	var myGlobalHandlers = {
		onCreate: function(){
			Element.show('systemWorking');
		},

		onComplete: function() {
			if(Ajax.activeRequestCount == 0){
				Element.hide('systemWorking');
			}
		}
	};

	Ajax.Responders.register(myGlobalHandlers);
</script>

<div id='systemWorking'><img src='spinner.gif'>Loading...</div>

For more complete explanations, see the Ajax.Request reference and the options reference.

toc

Using the Ajax.Updater class

If you have a server endpoint that can return information already formatted in HTML, the library makes life even easier for you with the Ajax.Updater class. With it you just inform which element should be filled with the HTML returned from the AJAX call. An example speaks better than I can write. 

<script>
	function getHTML()
	{
		var url = 'http://yourserver/app/getSomeHTML';
		var pars = 'someParameter=ABC';
		
		var myAjax = new Ajax.Updater(
			'placeholder', 
			url, 
			{
				method: 'get', 
				parameters: pars
			});
		
	}
</script>

<input type="button" value="GetHtml" onclick="getHTML()"/>
<div id="placeholder"></div>

As you can see, the code is very similar to the previous example, with the exclusion of the onComplete function and the element id being passed in the constructor. Let's change the code a little bit to illustrate how it is possible to handle server errors on the client.

We will add more options to the call, specifying a function to capture error conditions. This is done using the onFailure option. We will also specify that the placeholder only gets populated in case of a successful operation. To achieve this we will change the first parameter from a simple element id to an object with two properties, success (to be used when everything goes OK) and failure (to be used when things go bad.) We will not be using the failure property in our example, just the reportError function in the onFailure option. 

<script>
	function getHTML()
	{
		var url = 'http://yourserver/app/getSomeHTML';
		var pars = 'someParameter=ABC';
		
		var myAjax = new Ajax.Updater(
					{success: 'placeholder'}, 
					url, 
					{
						method: 'get', 
						parameters: pars, 
						onFailure: reportError
					});
		
	}

	function reportError(request)
	{
		alert('Sorry. There was an error.');
	}
</script>

<input type="button" value="GetHtml" onclick="getHTML()"/>
<div id="placeholder"></div>

If your server logic returns JavaScript code along with HTML markup, the Ajax.Updater object can evaluate that JavaScript code. To get the object to treat the response as JavaScript, you simply add evalScripts: true; to the list of properties in the last argument of the object constructor. But there's a caveat. Those script blocks will not be added to the page's script. As the option name evalScripts suggests, the scripts will be evaluated. What's the difference, you may ask? Lets assume the requested URL returns something like this: 

<script language="javascript" type="text/javascript">
	function sayHi(){
		alert('Hi');
	}
</script>

<input type="button" value="Click Me" onclick="sayHi()"/>

In case you've tried it before, you know it doesn't work. The reason is that the script block will be evaluated, and evaluating a script like the above will not create a function named sayHi. It will do nothing. To create this function we need to change our script to create the function. See below. 

<script language="javascript" type="text/javascript">
	sayHi = function(){
		alert('Hi');
	};
</script>

<input type="button" value="Click Me" onclick="sayHi()"/>

Note that in the previous example we did not use the var keyword to declare the variable. Doing so would have created a function object that would be local to the script block (at least in IE). Without the var keyword the function object is scoped to the window, which is our intent.

For more complete explanations, see the Ajax.Updater reference and the options reference.

toc

What are all those "?" and squares?

So you went and wrote some quick test scripts to update your pages using the Ajax.Updater object and it all worked fine. Life was good until you ran your scripts against real data. All of a sudden the updated text was displayed with question marks or unprintable character symbols where the non-English characters should be.

Your first suspect is prototype.js, Of course, it seemed too easy to be true. But don't blame the library just yet. Ask yourself how much you really understand character encoding, code pages, and how the browser deals with it. If you have a positive answer then I bet you are on your way to fix the problem. If you are among the other 80% (another useless, imprecise author's estimate) of web developers that take character encoding for granted, keep reading.

I won't pretend to be an authority on the topic, much less give you a complete explanation of how this is best handled. Instead you go straight to the solution that I use and provide hints on how this could be fixed in your own scenario.

Simply put, the solution revolves around the following statement: Serve what the browser is expecting you to serve. If we are going to update the page with text that contains Unicode/UTF-8 characters then we better make the browser aware of that.

Let's start with the simple case when you are just updating the page with text from a static HTML file that resides on your server. When you created that file, depending on which text editor you employed, it is very possible that the file was saved in ANSI (or better said, non-Unicode) format. This is the default for many text editors, especially source code editors, because the file size will be smaller and it's rather unusual to edit source code with Unicode characters in it.

Suppose you have the following file named static-content.html on your server. You saved this file saved in ANSI format. 

<div>
	Hi there, José. Yo no hablo español.
</div>

Your main page updates itself using something like the snippet below. 

<script>
	function updateWithFile(){
		var url = 'static-content.html';
		var pars = '';
		var myAjax = new Ajax.Updater(
				'placeholder', url, 
				{method: 'get', parameters: pars});
	}
</script>
<div id="placeholder">(this will be replaced)</div>
<input id="btn" value="Test With Static File" 
                 onclick="updateWithFile()" type="button"/>

When you click the button the static file is retrieved but the non-English characters are replaced by question marks or some other symbol. The displayed text will look similar to "Hi there, Jos?. Yo no hablo espa?ol." or "Hi there, Jos?Yo no hablo espa?", depending on your browser.

In this case, the solution is straightforward, simply save the static file in an appropriate format. Let's save it in UTF-8 and run the script again (any decent text editor will have an option in the Save As dialog.) You should now see the correct text (if not, your browser may have cached the old version, try using a different file name.)

If the HTML that you are serving is not static, if it is being dynamically generated by some application framework (like ASP.NET, PHP, or even Perl,) make sure the code that generates this HTML is producing the text in the appropriate encoding and code page, and include in the HTTP response headers one header that informs this. Each platform has a different way to achieve this, but they are very similar.

For example, in ASP.NET you can set this globally in your web.config file and the default configuration is good enough to avoid this problem in the first place. You should already have the following section in your web.config. 

<globalization requestEncoding="utf-8" responseEncoding="utf-8" />

In classic ASP 3.0 you can fix this problem using the following code. 

Response.CodePage = 65001
Response.CharSet = "utf-8"

In PHP the syntax to add the response header looks like this. 

<?php header('Content-Type: text/html; charset=utf-8'); ?>

In any case, your ultimate goal is to have the following HTTP header sent with your response. 

Content-Type: text/html; charset=utf-8

We used UTF-8 in our examples above, but if you need a different setting you can easily change.

Enumerating... Wow! Damn! Wahoo!

We are all familiar with for loops. You know, create yourself an array, populate it with elements of the same kind, create a loop control structure (for, foreach, while, repeat, etc,) access each element sequentially, by its numeric index, and do something with the element.

When you come to think about it, almost every time you have an array in your code it means that you'll be using that array in a loop sooner or later. Wouldn't it be nice if the array objects had more functionality to deal with these iterations? Yes, it would, and many programming languages provide such functionality in their arrays or equivalent structures (like collections and lists.)

Well, it turns out that prototype.js gives us the Enumerable object, which implements a plethora of tricks for us to use when dealing with iterable data. The prototype.js library goes one step further and extends the Array class with all the methods of Enumerable.

toc

Loops, Ruby-style

In standard javascript, if you wanted to sequentially display the elements of an array, you could very well write something like this. 

<script>
	function showList(){
		var simpsons = ['Homer', 'Marge', 'Lisa', 'Bart', 'Maggie'];
		for(i=0;i<simpsons.length;i++){
			alert(simpsons[i]);
		}
	}

</script>

<input type="button" value="Show List" onclick="showList();" />

With our new best friend, prototype.js, we can rewrite this loop like this. 


	function showList(){
		var simpsons = ['Homer', 'Marge', 'Lisa', 'Bart', 'Maggie'];
		simpsons.each( function(familyMember){
			alert(familyMember);
		});
	}

You are probably thinking "big freaking deal...just a weird syntax for the same old thing." Well, in the above example, yes, there's nothing too earth shattering going on. After all, there's not much to be changed in such a drop-dead-simple example. But keep reading, nonetheless.

Before we move on. Do you see this function that is being passed as an argument to the each method? Let's start referring to it as an iterator function.

toc

Your arrays on steroids

Like we mentioned above, it's very common for all the elements in your array to be of the same kind, with the same properties and methods. Let's see how we can take advantage of iterator functions with our new souped-up arrays.

Here's how to find an element according to criteria. 

<script>
	function findEmployeeById(emp_id){
		var listBox = $('lstEmployees')
		var options = listBox.getElementsByTagName('option');
		options = $A(options);
		var opt = options.find( function(employee){
			return (employee.value == emp_id);
		});
		alert(opt.innerHTML); //displays the employee name
	}
</script>

<select id="lstEmployees" size="10" >
	<option value="5">Buchanan, Steven</option>
	<option value="8">Callahan, Laura</option>
	<option value="1">Davolio, Nancy</option>
</select>

<input type="button" value="Find Laura" onclick="findEmployeeById(8);" />

Now let's kick it up another notch. See how we can filter out items in arrays, and then retrieve just a desired member from each element. 

<script>
	function showLocalLinks(paragraph){
		paragraph = $(paragraph);
		var links = $A(paragraph.getElementsByTagName('a'));
		//find links that do not start with 'http'
		var localLinks = links.findAll( function(link){
			//we'll just assume for now that external links
			// do not have a '#' in their url
			return link.href.indexOf('#') >= 0;
		});
		//now the link texts
		var texts = localLinks.pluck('innerHTML');
		//get them in a single string
		var result = texts.inspect();
		alert(result);
	}

</script>
<p id="someText">
	This <a href="http://othersite.com/page.html">text</a> has 
	a <a href="#localAnchor">lot</a> of 
	<a href="#otherAnchor">links</a>. Some are 
	<a href="http://wherever.com/page.html">external</a>
	and some are <a href="#someAnchor">local</a>
</p>
<input type="button" value="Find Local Links" onclick="showLocalLinks('someText')"/>

It takes just a little bit of practice to get completely addicted to this syntax. Take a look at the Enumerable and Array references for all the available functions.

toc

Books I strongly recommend

Some books are just too good not to pass the word forward. The following books have helped me a lot learning the new skills required to adequately create AJAX applications and also consolidate the skills I though I already mastered. I think a good book is money well-spent, that keep paying for itself for a long time.

toc

Reference for prototype.js

Extensions to the JavaScript classes

One of the ways the prototype.js library adds functionality is by extending the existing JavaScript classes.

toc

Extensions for the Object class

MethodKindArgumentsDescription
extend(destination, source)staticdestination: any object, source: any object Provides a way to implement inheritance by copying all properties and methods from source to destination.
inspect(targetObj)statictargetObj: any object Returns a human-readable string representation of targetObj. It defaults to the return value of toString if the given object does not define an inspect instance method.
keys(targetObj)statictargetObj: any object Returns an Array with the names of all the properties and methods of given object.
values(targetObj)statictargetObj: any object Returns a Array with the values of all the properties and methods of given object.
clone(targetObj)statictargetObj: any object Returns a shallow copy of targetObj.

toc

Extensions for the Number class

MethodKindArgumentsDescription
toColorPart()instance(none) Returns the hexadecimal representation of the number. Useful when converting the RGB components of a color into its HTML/CSS representation.
succ()instance(none) Returns the next number. This function is used in scenarios that involve iterations.
times(iterator)instanceiterator: a function object conforming to Function(index) Calls the iterator function repeatedly passing the current index in the index argument.

The following sample will display alert message boxes from 0 to 9. 

<script>
	function demoTimes(){
		var n = 10;
		n.times(function(index){
			alert(index);
		});
		/***************************
		 * you could have also used: 
		 *           (10).times( .... ); 
		 ***************************/
	}

</script>

<input type="button" value="Test Number.times()" onclick="demoTimes()"/>

toc

Extensions for the Function class

MethodKindArgumentsDescription
bind(object [, arg1 [, arg2 [...]]])instanceobject: the object that owns the method Returns an instance of the function pre-bound to the function(=method) owner object. The returned function will use the same arguments as the original one (arg1, arg2, ... etc).
bindAsEventListener(object [, arg1 [, arg2 [...]]]) instanceobject: the object that owns the method Returns an instance of the function pre-bound to the function(=method) owner object. The returned function will have the current event object as its first argument followed optionally any other arguments passed after the object argument.

Let's see one of these extensions in action. 

<input type="checkbox" id="myChk" value="1"/> Test?
<script>
	//declaring the class
	var CheckboxWatcher = Class.create();

	//defining the rest of the class implementation
	CheckboxWatcher.prototype = {

	   initialize: function(chkBox, message) {
			this.chkBox = $(chkBox);
			this.message = message;
			//assigning our method to the event
			
			this.chkBox.onclick = 
			   this.showMessage.bindAsEventListener(this, ' from checkbox');
			
	   },

	   showMessage: function(evt, extraInfo) {
		  alert(this.message + ' (' + evt.type + ')' + extraInfo);
	   }
	};


	var watcher = new CheckboxWatcher('myChk', 'Changed');
</script>

toc

Extensions for the String class

MethodKindArgumentsDescription
camelize()instance(none) Converts a hyphen-delimited-string into a camelCaseString. This function is useful when writing code that deals with style properties, for example.
capitalize()instance(none) Converts the first character to upper case.
dasherize()instance(none) Replaces underscores '_' with dashes '-'.
escapeHTML()instance(none) Returns the string with any HTML markup characters properly escaped
evalScripts()instance(none) Evaluates each <script /> block found in the string.
extractScripts()instance(none) Returns an Array object containing all the <script /> blocks found in the string.
gsub(pattern, replacement)instance pattern: string or regular expression being searched. replacement: simple string, template string, or Function(strings[]) to produce the replacements. Returns a string that results from finding (or matching) the pattern string (or regular expression) in the current string and replacing it with the replacement string or the result of calling the replacement function passing an array with the strings that matched the pattern, including eventual regular expression groupings. When the replacement is a string, it can contain special templating tokens like #{n}, where n is the index of a grouping in the regular expession. #{0} will be replaced by the entire match, #{1} the first grouping, #{2} the second, and so on.
parseQuery()instance(none) Same as toQueryParams().
scan(pattern, replacement)instance pattern: string or regular expression being searched. replacement: Function(strings[]) to iterate over the matches. Provides a way to iterate over matched patterns in the string and operate on them. The pattern argument can be a string or a RegExp but a RegExp is evidently more useful. Similarly, the replacement argument can be a string or a function but it probably only makes sense to pass in a function to be able to produce anything useful.
strip()instance(none) Returns the string without any leading or trailing white spaces.
stripScripts()instance(none) Returns the string with any <script /> blocks removed
stripTags()instance(none) Returns the string with any HTML or XML tags removed
sub(pattern, replacement [, count])instance pattern: string or regular expression being searched. replacement: string, or Function(strings[]) to produce the replacements. count: number or replacements to perform - defaults to 1. Very similar to gsub but only performs a limited number of replacements, specified by the count parameter.
toArray()instance(none) Splits the string into an Array of its characters.
toQueryParams()instance(none) Splits a querystring into an associative Array indexed by parameter name (more like a hash).
truncate(length [, truncation])instance length: maximum length of the resulting string. truncation: string used to replace the last characters of the resulting string - defaults to '...' Used to produce a string of a known maximum length. In case the string needs to be truncated to maintain the maximum length, the text given in the truncation argument is used to replace the last few characters. (e.g.: var s='123456790'; alert(s.truncate(5)); //displays '12...' )
underscore()instance(none) Converts a CamelizedStringValue into a uderscore_formatted_string. (e.g.: var s='Namespace::MyClass123'; alert(s.underscore()); //displays 'namespace/my_class123' ). This function seems to be directly target at supporting Ruby on Rails functionality.
unescapeHTML()instance(none) The reverse of escapeHTML()

toc

Extensions for the Array class

To start off, Array extends Enumerable, so all the handy methods defined in the Enumerable object are available. Besides that, the methods listed below are also implemented.

MethodKindArgumentsDescription
clear()instance(none) Empties the array and returns itself.
compact()instance(none) Returns the array without the elements that are null or undefined. This method does not change the array itself
first()instance(none) Returns the first element of the array.
flatten()instance(none) Returns a flat, one-dimensional version of the array. This flattening happens by finding each of the array's elements that are also arrays and including their elements in the returned array, recursively.
indexOf(value)instance value: what you are looking for. Returns the zero-based position of the given value if it is found in the array. Returns -1 if value is not found.
inspect()instance(none) Overridden to return a nicely formatted string representation of the array with its elements.
last()instance(none) Returns the last element of the array.
reverse([applyToSelf])instance applyToSelf: indicates if the array itself should also be reversed. Returns the array in reverse sequence. If no argument is given or if the argument is true the array itself will be changed. Otherwise it will remain unchanged.
shift()instance(none) Returns the first element and removes it from the array, reducing the array's length by 1.
without(value1 [, value2 [, .. valueN]])instance value1 ... valueN: values to be excluded if present in the array. Returns the array excluding the elements that are included in the list of arguments. This method does not change the array itself.

Let's see some of these methods in action. 

<script>
var A = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'];
alert(A.inspect()); // "['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']"
var B = A.without('e','f');
alert(B.inspect()); // "['a', 'b', 'c', 'd', 'g', 'h']"
alert(A.inspect()); // did not change A: "['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']"
A.push(null);
A.push('x');
A.push(null);
A.push('y');
alert(A.inspect()); // "['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', null, 'x', null, 'y']"
A = A.compact();
alert(A.inspect()); // "['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'x', 'y']"
var e = A.shift();
alert(e); // "a" 
alert(A.inspect()); // "['b', 'c', 'd', 'e', 'f', 'g', 'h', 'x', 'y']"
alert(A.indexOf('c')); // 1
alert(A.first()); // 'b'
alert(A.last()); // 'y'
A.clear();
alert(A.inspect()); // "[]"
A = ['a', 'b', 'c'];
B = A.reverse(false);
alert(B.inspect()); // "['c', 'b', 'a']"
alert(A.inspect()); // A left untouched: "['a', 'b', 'c']"
A.reverse(true);
alert(A.inspect()); // "['c', 'b', 'a']"	
A = ['a', 'b',  ['c1','c2','c3'] , 'd',  ['e1','e2']  ];
B = A.flatten();
alert(B.inspect()); // "['a','b','c1','c2','c3','d','e1','e2']"		
alert(A.inspect()); // unchanged: "['a','b',['c1','c2','c3'],'d',['e1','e2']]"		
</script>

toc

Extensions for the document DOM object

MethodKindArgumentsDescription
getElementsByClassName(className [, parentElement])instance className: name of a CSS class associated with the elements, parentElement: object or id of the element that contains the elements being retrieved. Returns all the elements that are associated with the given CSS class name. If no parentElement id given, the entire document body will be searched.

toc

Extensions for the Event object

PropertyTypeDescription
KEY_BACKSPACENumber 8: Constant. Code for the Backspace key.
KEY_TABNumber 9: Constant. Code for the Tab key.
KEY_RETURNNumber 13: Constant. Code for the Return key.
KEY_ESCNumber 27: Constant. Code for the Esc key.
KEY_LEFTNumber 37: Constant. Code for the Left arrow key.
KEY_UPNumber 38: Constant. Code for the Up arrow key.
KEY_RIGHTNumber 39: Constant. Code for the Right arrow key.
KEY_DOWNNumber 40: Constant. Code for the Down arrow key.
KEY_DELETENumber 46: Constant. Code for the Delete key.
observers:Array List of cached observers. Part of the internal implementation details of the object.
MethodKindArgumentsDescription
element(event)static event: an Event object Returns element that originated the event.
isLeftClick(event)static event: an Event object Returns true if the left mouse button was clicked.
pointerX(event)static event: an Event object Returns the x coordinate of the mouse pointer on the page.
pointerY(event)static event: an Event object Returns the y coordinate of the mouse pointer on the page.
stop(event)static event: an Event object Use this function to abort the default behavior of an event and to suspend its propagation.
findElement(event, tagName)static event: an Event object, tagName: name of the desired tag. Traverses the DOM tree upwards, searching for the first element with the given tag name, starting from the element that originated the event.
observe(element, name, observer, useCapture)static element: object or id, name: event name (like 'click', 'load', etc), observer: function(evt) to handle the event, useCapture: if true, handles the event in the capture phase and if false in the bubbling phase. Adds an event handler function to an event.
stopObserving(element, name, observer, useCapture)static element: object or id, name: event name (like 'click'), observer: function that is handling the event, useCapture: if true handles the event in the capture phase and if false in the bubbling phase. Removes an event handler from the event.
_observeAndCache(element, name, observer, useCapture)static   Private method, do not worry about it.
unloadCache()static (none) Private method, do not worry about it. Clears all cached observers from memory.

Let's see how to use this object to add an event handler to the load event of the window object. 

<script>
	Event.observe(window, 'load', page_loaded, false);

	function page_loaded(evt) {
	  Event.observe('parent_node', 'click', item_clicked, false);
	}
	
	function item_clicked(evt){
		var child = Event.element(evt);
		alert('The child node with id=' + child.id + ' was clicked');
		Event.stop(evt); //avoid another call related to 'parent_node' itself
	}
</script>	
...
<div id="parent_node">
	<div id="child1">First</div>
	<div id="child2">Second</div>
	<div id="child3">Third</div>
</div>

toc

New objects and classes defined by prototype.js

Another way the library helps you is by providing many objects that implement both support for object oriented designs and common functionality in general.

toc

The PeriodicalExecuter object

This object provides the logic for calling a given function repeatedly, at a given interval, using a timer.

MethodKindArgumentsDescription
[ctor](callback, interval) constructorcallback: a function that will be passed the PeriodcalExecuter object itself as the only argument, interval: number of seconds Creates one instance of this object that will call the function repeatedly.
registerCallback() instance(none) Resets the timer.
stop() instance(none) Cancels the timer, avoiding the execution of the callback.
onTimerEvent() instance(none) This method is what will be called by the timer. It, in turn, will invoke the callback method passing the object itself.
PropertyTypeDescription
callback Function(objExecuter)The function to be called. objExecuter: the PeriodcalExecuter making the call.
timerTimer A handle to the underlying timer object responsible for repeatedly invoking the callback method
frequencyNumber This is actually the interval in seconds
currentlyExecuting BooleanIndicates if the callback is underway.

toc

The Prototype object

The Prototype object does not have any important role, other than declaring the version of the library being used.

PropertyTypeDescription
VersionStringThe version of the library
emptyFunctionFunction()An empty function object
KFunction(obj) A function object that just echoes back the given parameter.
ScriptFragmentString A regular expression to identify scripts

toc

The Enumerable object

The Enumerable object allows one to write more elegant code to iterate items in a list-like structure.

Many other objects extend the Enumerable object to leverage its useful interface.

MethodKindArgumentsDescription
each(iterator)instance iterator: a function object conforming to Function(value, index) Calls the given iterator function passing each element in the list in the first argument and the index of the element in the second argument
all([iterator])instance iterator: a function object conforming to Function(value, index), optional. This function is a way to test the entire collection of values using a given function. all will return true only if the iterator function returns a value that resolves to true for all the elements. It will return false otherwise. If no iterator is given, then the test will be if the element itself resolves to true. You can simply read it as "check if all elements pass the test."
any([iterator])instance iterator: a function object conforming to Function(value, index), optional. This function is a way to test the entire collection of values using a given function. any will return true if the iterator function returns a value that resolves to true for at least one of the elements. It will return false otherwise. If no iterator is given, then the test will be if the element itself resolves to true. You can simply read it as "check if any element passes the test."
collect(iterator)instance iterator: a function object conforming to Function(value, index) Calls the iterator function for each element in the collection and returns each result in an Array, one result element for each element in the collection, in the same sequence.
detect(iterator)instance iterator: a function object conforming to Function(value, index) Calls the iterator function for each element in the collection and returns the first element that caused the iterator function to return true (or, more precisely, not-false.) If no element returns true, then detect returns null.
entries()instance (none) Same as toArray().
find(iterator)instance iterator: a function object conforming to Function(value, index) Same as detect().
findAll(iterator)instance iterator: a function object conforming to Function(value, index) Calls the iterator function for each element in the collection and returns an Array with all the elements that caused the iterator function to return a value that resolves to true. This function is the opposite of reject().
grep(pattern [, iterator])instance pattern: a RegExp object used to match the elements, iterator: a function object conforming to Function(value, index) Tests the string value of each element in the collection against the pattern regular expression . The function will return an Array containing all the elements that matched the regular expression. If the iterator function is given, then the Array will contain the result of calling the iterator with each element that was a match.
include(obj)instance obj: any object Tries to find the given object in the collection. Returns true if the object is found, false otherwise.
inGroupsOf(number, fillWith)instance number: number of items per group, fillWith: value used to fill empty spots Returns the collection broken in groups containing as many items as specified by the first argument. If the quantity of items in the initial collection is not divisible by the number in the first argument, the resulting empty items at the end of the last group will be filled with null or with the value of the second argument, if provided. Quick example: ['a','b','c','d'].inGroupsOf(3,'?') creates [ ['a','b','c'] , ['d','?','?'] ]
inject(initialValue, iterator)instance initialValue: any object to be used as the initial value, iterator: a function object conforming to Function(accumulator, value, index) Combines all the elements of the collection using the iterator function. The iterator is called passing the result of the previous iteration in the accumulator argument. The first iteration gets initialValue in the accumulator argument. The last result is the final return value.
invoke(methodName [, arg1 [, arg2 [...]]])instance methodName: name of the method that will be called in each element, arg1..argN: arguments that will be passed in the method invocation. Calls the method specified by methodName in each element of the collection, passing any given arguments (arg1 to argN), and returns the results in an Array object.
map(iterator)instance iterator: a function object conforming to Function(value, index) Same as collect().
max([iterator])instance iterator: a function object conforming to Function(value, index) Returns the element with the greatest value in the collection or the greatest result of calling the iterator for each element in the collection, if an iterator is given.
member(obj)instance obj: any object Same as include().
min([iterator])instance iterator: a function object conforming to Function(value, index) Returns the element with the lowest value in the collection or the lowest result of calling the iterator for each element in the collection, if an iterator is given.
partition([iterator])instance iterator: a function object conforming to Function(value, index) Returns an Array containing two other arrays. The first array will contain all the elements that caused the iterator function to return true and the second array will contain the remaining elements. If the iterator is not given, then the first array will contain the elements that resolve to true and the other array will contain the remaining elements.
pluck(propertyName)instance propertyName name of the property that will be read from each element. This can also contain the index of the element Retrieves the value to the property specified by propertyName in each element of the collection and returns the results in an Array object.
reject(iterator)instance iterator: a function object conforming to Function(value, index) Calls the iterator function for each element in the collection and returns an Array with all the elements that caused the iterator function to return a value that resolves to false. This function is the opposite of findAll().
select(iterator)instance iterator: a function object conforming to Function(value, index) Same as findAll().
sortBy(iterator)instance iterator: a function object conforming to Function(value, index) Returns an Array with all the elements sorted according to the result the iterator function call.
toArray()instance (none) Returns an Array with all the elements of the collection.
zip(collection1[, collection2 [, ... collectionN [,transform]]])instance collection1 .. collectionN: enumerations that will be merged, transform: a function object conforming to Function(value, index) Merges each given collection with the current collection. The merge operation returns a new array with the same number of elements as the current collection and each element is an array (let's call them sub-arrays) of the elements with the same index from each of the merged collections. If the transform function is given, then each sub-array will be transformed by this function before being returned. Quick example: [1,2,3].zip([4,5,6], [7,8,9]).inspect() returns "[ [1,4,7],[2,5,8],[3,6,9] ]"

toc

The Hash object

The Hash object implements a hash structure, i.e. a collection of Key:Value pairs.

Each item in a Hash object is an array with two elements: first the key then the value. Each item also has two properties: key and value, which are pretty self-explanatory.

MethodKindArgumentsDescription
keys()instance (none) Returns an Array with the keys of all items.
values()instance (none) Returns an Array with the values of all items.
merge(otherHash)instance otherHash: Hash object Combines the hash with the other hash passed in and returns the new resulting hash.
toQueryString()instance (none) Returns all the items of the hash in a string formatted like a query string, e.g. 'key1=value1&key2=value2&key3=value3'
inspect()instance(none) Overridden to return a nicely formatted string representation of the hash with its key:value pairs.

toc

The ObjectRange class

Inherits from Enumerable

Represents a range of values, with upper and lower bounds.

PropertyTypeKindDescription
start(any)instance The lower bound of the range
end(any)instance The upper bound of the range
exclusiveBooleaninstance Determines if the boundaries themselves are part of the range.
MethodKindArgumentsDescription
[ctor](start, end, exclusive)constructorstart: the lower bound, end: the upper bound, exclusive: include the bounds in the range? Creates one range object, spanning from start to end. It is important to note that start and end have to be objects of the same type and they must have a succ() method.
include(searchedValue)instance searchedValue: value that we are looking for Checks if the given value is part of the range. Returns true or false.

toc

The Class object

The Class object is used when declaring the other classes in the library. Using this object when declaring a class causes the to new class to support an initialize() method, which serves as the constructor.

See the sample below. 

//declaring the class
var MySampleClass = Class.create();

//defining the rest of the class implementation
MySampleClass.prototype = {

   initialize: function(message) {
		this.message = message;
   },

   showMessage: function(ajaxResponse) {
      alert(this.message);
   }
};	

//now, let's instantiate and use one object
var myTalker = new MySampleClass('hi there.');
myTalker.showMessage(); //displays alert
MethodKindArgumentsDescription
create(*)instance(any) Defines a constructor for a new class

toc

The Ajax object

This object serves as the root and namespace for many other classes that provide AJAX functionality.

PropertyTypeKindDescription
activeRequestCountNumberinstance The number of AJAX requests in progress.
MethodKindArgumentsDescription
getTransport()instance(none) Returns a new XMLHttpRequest object

toc

The Ajax.Responders object

Inherits from Enumerable

This object maintains a list of objects that will be called when Ajax-related events occur. You can use this object, for example, if you want to hook up a global exception handler for AJAX operations.

PropertyTypeKindDescription
respondersArrayinstance The list of objects registered for AJAX events notifications.
MethodKindArgumentsDescription
register(responderToAdd)instanceresponderToAdd: object with methods that will be called. The object passed in the responderToAdd argument should contain methods named like the AJAX events (e.g. onCreate, onComplete, onException, etc.) When the corresponding event occurs all the registered objects that contain a method with the appropriate name will have that method called.
unregister(responderToRemove)instanceresponderToRemove: object to be removed from the list. The object passed in the responderToRemove argument will be removed from the list of registered objects.
dispatch(callback, request, transport, json)instance callback: name of the AJAX event being reported, request: the Ajax.Request object responsible for the event, transport: the XMLHttpRequest object that carried (or is carrying) the AJAX call, json: the X-JSON header of the response (if present) Runs through the list of registered objects looking for the ones that have the method determined in the callback argument. Then each of these methods is called passing the other 3 arguments. If the AJAX response contains a X-JSON HTTP header with some JSON content, then it will be evaluated and passed in the json argument. If the event is onException, the transport argument will have the exception instead and json will not be passed.

toc

The Ajax.Base class

This class is used as the base class for most of the other classes defined in the Ajax object.

MethodKindArgumentsDescription
setOptions(options)instanceoptions: AJAX options Sets the desired options for the AJAX operation
responseIsSuccess()instance(none) Returns true if the AJAX operation succeeded, false otherwise
responseIsFailure()instance(none) The opposite of responseIsSuccess().

toc

The Ajax.Request class

Inherits from Ajax.Base

Encapsulates AJAX operations

PropertyTypeKindDescription
EventsArraystatic List of possible events/statuses reported during an AJAX operation. The list contains: 'Uninitialized', 'Loading', 'Loaded', 'Interactive', and 'Complete.'
transportXMLHttpRequestinstance The XMLHttpRequest object that carries the AJAX operation
urlStringinstance The URL targeted by the request.
MethodKindArgumentsDescription
[ctor](url, options)constructorurl: the url to be fetched, options: AJAX options Creates one instance of this object that will call the given url using the given options. The onCreate event will be raised during the constructor call. Important: It is worth noting that the chosen url is subject to the browser's security settings. In many cases the browser will not fetch the url if it is not from the same host (domain) as the current page. You should ideally use only local urls to avoid having to configure or restrict the user's browser. (Thanks Clay).
evalJSON()instance(none) This method is typically not called externally. It is called internally to evaluate the content of an eventual X-JSON HTTP header present in the AJAX response.
evalResponse()instance(none) This method is typically not called externally. If the AJAX response has a Content-type header of text/javascript then the response body will be evaluated and this method will be used.
header(name)instancename: HTTP header name Retrieves the contents of any HTTP header of the AJAX response. Call this only after the AJAX call is completed.
onStateChange()instance(none) This method is typically not called externally. It is called by the object itself when the AJAX call status changes.
request(url)instanceurl: url for the AJAX call This method is typically not called externally. It is already called during the constructor call.
respondToReadyState(readyState)instancereadyState: state number (1 to 4) This method is typically not called externally. It is called by the object itself when the AJAX call status changes.
setRequestHeaders()instance(none) This method is typically not called externally. It is called by the object itself to assemble the HTTP header that will be sent during the HTTP request.

toc

The options argument object

An important part of the AJAX operations is the options argument. There's no options class per se. Any object can be passed, as long as it has the expected properties. It is common to create anonymous objects just for the AJAX calls.

PropertyTypeDefaultDescription
methodString'post' Method of the HTTP request
parametersString or Object'' The url-formatted list of values passed to the request (for example 'employee=john&month=11') or a hash-like object that represents the parameters (for example {employee:'john', month:11}.)
asynchronousBooleantrue Indicates if the AJAX call will be made asynchronously
postBodyStringundefined Content passed to in the request's body in case of a HTTP POST
requestHeadersArrayundefined List of HTTP headers to be passed with the request. This list must have an even number of items, any odd item is the name of a custom header, and the following even item is the string value of that header. Example:['my-header1', 'this is the value', 'my-other-header', 'another value']
encodingString'UTF-8' The character encoding used in the body of a request (especially POST requests.) UTF-8 should be enough in most cases, but if you know what you're doing, you can use a different encoding.
contentTypeString'application/x-www-form-urlencoded' Sets the Content-Type HTTP header of the Ajax request.
onXXXXXXXXFunction(XMLHttpRequest, Object)undefined Custom function to be called when the respective event/status is reached during the AJAX call. There are several alternatives for the "XXXXXXXX" in this option, among the alternatives are the statuses in Ajax.Request.Events, and the HTTP status codes. Example var myOpts = {on403: notAllowed, onComplete: showResponse, onLoaded: registerLoaded};. The function used will receive one argument, containing the XMLHttpRequest object that is carrying the AJAX operation and another argument containing the evaluated X-JSON response HTTP header.
onSuccessFunction(XMLHttpRequest, Object)undefined Custom function to be called when the AJAX call completes successfully. The function used will receive one argument, containing the XMLHttpRequest object that is carrying the AJAX operation and another argument containing the evaluated X-JSON response HTTP header.
onFailureFunction(XMLHttpRequest, Object)undefined Custom function to be called when the AJAX call completes with error. The function used will receive one argument, containing the XMLHttpRequest object that is carrying the AJAX operation and another argument containing the evaluated X-JSON response HTTP header.
onExceptionFunction(Ajax.Request, exception)undefined Custom function to be called when an exceptional condition happens on the client side of the AJAX call, like an invalid response or invalid arguments. The function used will receive two arguments, containing the Ajax.Request object that wraps the AJAX operation and the exception object.
insertionan Insertion classundefined A class that will determine how the new content will be inserted. Applies only to Ajax.Updater objects and if nothing is specified, the new content will completely replace the existing content. If an Insertion-derived class is given, the content will be added to the existing content. It can be Insertion.Before, Insertion.Top, Insertion.Bottom, or Insertion.After.
evalScriptsBooleanundefined, false Determines if script blocks will be evaluated when the response arrives. Applies only to Ajax.Updater objects.
decayNumberundefined, 1 Determines the progressive slowdown in a Ajax.PeriodicalUpdater object refresh rate when the received response is the same as the last one. For example, if you use 2, after one of the refreshes produces the same result as the previous one, the object will wait twice as much time for the next refresh. If it repeats again, the object will wait four times as much, and so on. Leave it undefined or use 1 to avoid the slowdown.
frequencyNumberundefined, 2 Interval (not frequency) between refreshes, in seconds. Applies only to Ajax.PeriodicalUpdater objects.

toc

The Ajax.Updater class

Inherits from Ajax.Request

Used when the requested url returns HTML that you want to inject directly in a specific element of your page. You can also use this object when the url returns <script> blocks that will be evaluated upon arrival. Use the evalScripts option to work with scripts.

PropertyTypeKindDescription
containersObjectinstance This object contains two properties: containers.success will be used when the AJAX call succeeds, and containers.failure will be used otherwise.
MethodKindArgumentsDescription
[ctor](container, url, options)constructor container:this can be the id of an element, the element object itself, or an object with two properties - object.success element (or id) that will be used when the AJAX call succeeds, and object.failure element (or id) that will be used otherwise. url: the url to be fetched, options: AJAX options Creates one instance of this object that will call the given url using the given options.
updateContent()instance(none) This method is typically not called externally. It is called by the object itself when the response is received. It will update the appropriate element with the HTML or call the function passed in the insertion option. The function will be called with two arguments, the element to be updated and the response text.

toc

The Ajax.PeriodicalUpdater class

Inherits from Ajax.Base

This class repeatedly instantiates and uses an Ajax.Updater object to refresh an element on the page, or to perform any of the other tasks the Ajax.Updater can perform. Check the Ajax.Updater reference for more information.

PropertyTypeKindDescription
containerObjectinstance This value will be passed straight to the Ajax.Updater's constructor.
urlStringinstance This value will be passed straight to the Ajax.Updater's constructor.
frequencyNumberinstance Interval (not frequency) between refreshes, in seconds. Defaults to 2 seconds. This number will be multiplied by the current decay when invoking theAjax.Updater object
decayNumberinstance Keeps the current decay level applied when re-executing the task
updaterAjax.Updaterinstance The most recently used Ajax.Updater object
timerObjectinstance The handle to the timer being used to notify the object when it is time for the next refresh.
MethodKindArgumentsDescription
[ctor](container, url, options)constructor container:this can be the id of an element, the element object itself, or an object with two properties - object.success element (or id) that will be used when the AJAX call succeeds, and object.failure element (or id) that will be used otherwise. url: the url to be fetched, options: AJAX options Creates one instance of this object that will call the given url using the given options.
start()instance(none) This method is typically not called externally. It is called by the object itself to start performing its periodical tasks.
stop()instance(none) Causes the object to stop performing its periodical tasks. After stopping, the object will call the callback given in the onComplete option (if any.)
updateComplete()instance(none) This method is typically not called externally. It is called by the currently used Ajax.Updater after it completes the request. It is used to schedule the next refresh.
onTimerEvent()instance(none) This method is typically not called externally. It is called internally when it is time for the next update.

toc

The Element object

This object provides some utility functions for manipulating elements in the DOM.

toc

The Element.Methods object

This object provides some utility functions for manipulating elements in the DOM. You typically do not call these methods directly from the Element.Methods object, but rather from the Element object, which gets copies of all of them.

All the methods defined here are automatically added to any element accessed using the $() function. When they are added to the elements, the first argument (always element) is removed because it's always the current element itself. So, in short, writing Element.show('myDiv'); is the same as writing $('myDiv').show();

MethodKindArgumentsDescription
addClassName(element, className)instanceelement: element object or id, className: name of a CSS class Adds the given class name to the element's class names.
ancestors(element)instanceelement: element object or id Returns an Array with all the ancestors (parent nodes) of the element. The array will start at the first direct parent element and go all the way to the html element.
childOf(element, ancestor)instance element: element object or id, ancestor: ancestor candidate element or id Same as descendantOf.
classNames(element)instanceelement: element object or id Returns an Element.ClassNames object representing the CSS class names associated with the given element.
cleanWhitespace(element)instanceelement: element object or id Removes any white space text node children of the element
descendantOf(element, ancestor)instance element: element object or id, ancestor: ancestor candidate element or id Returns a Boolean value indicating if the element is a descendant (child, grandchild, etc) of the given ancestor.
descendants(element)instanceelement: element object or id Returns an Array with all the descendants (child nodes — children, grandchildren, etc) of the element.
down(element, expression, index)instance element: element object or id, expression: a CSS selection rule, index: index of the returned descendant Checks which of the element's descendants match the given rule and returns the first one or the nth one given by the zero-based index argument. Lower index values mean closer to the element.
empty(element)instanceelement: element object or id Returns a Boolean value indicating if the element tag is empty (or has only whitespaces)
getDimensions(element)instanceelement: element object or id Returns the dimensions of the element. The returned value is an object with two properties: height and width.
getElementsByClassName(element, className)instance element: element object or id, className: CSS class name Returns an Array of all the element's children that have the given CSS class name as one of their classes.
getElementsBySelector(element, expression1 [, expression2 [, expression3]])instance element: element object or id, expressionN: CSS selection rule Returns an Array of all the element's children that match one of the given CSS selectors.
getHeight(element)instanceelement: element object or id Returns the offsetHeight of the element
getStyle(element, cssProperty)instanceelement: element object or id, cssProperty name of a CSS property (either format 'prop-name' or 'propName' works). Returns the value of the CSS property in the given element or null if not present.
hasClassName(element, className)instanceelement: element object or id, className: name of a CSS class Returns true if the element has the given class name as one of its class names.
hide(element)instanceelement: element object or id Hides the element by setting its style.display to 'none'.
immediateDescendants(element)instanceelement: element object or id Returns an Array with all the direct descendants (1st degree child nodes only) of the element.
inspect(element)instanceelement: element object or id Returns a simplified string representation of the element's tag. It's useful for debugging and only contains the element's id and css class name, like <p id="result" class="hilite numeric">
makeClipping(element)instanceelement: element object or id
makePositioned(element)instanceelement: element object or id Changes the element's style.position to 'relative'
match(element, selector)instance element: element object or id, selector: string or Selector object of a CSS rule Verifies if the element is matched by the given CSS selector rule. For example, a paragraph element with an id of 'message' would be matched by the selector 'p#message'. This method returns true or false.
next(element, expression, index)instance element: element object or id, expression: a CSS selection rule, index: index of the returned sibilng Checks which of the element's posterior sibilings match the given rule and returns the first one or the nth one given by the zero-based index argument. Lower index values mean closer to the element.
nextSiblings(element)instanceelement: element object or id Returns an Array with all the siblings that come after the element. The list is built by recursively finding all the other elements via the nextSibling property.
observe(element, name, observer, useCapture)instance element: object or id, name: event name (like 'click', 'load', etc), observer: function(evt) to handle the event, useCapture: if true, handles the event in the capture phase and if false in the bubbling phase. Shortcut for Event.observe.
previous(element, expression, index)instance element: element object or id, expression: a CSS selection rule, index: index of the returned sibilng Checks which of the element's previous sibilings match the given rule and returns the first one or the nth one given by the zero-based index argument. Lower index values mean closer to the element.
previousSiblings(element)instanceelement: element object or id Returns an Array with all the siblings that come before the element. The list is built by recursively finding all the other elements via the previousSibling property.
remove(element)instanceelement: element object or id Removes the element from the document.
removeClassName(element, className)instanceelement: element object or id, className: name of a CSS class Removes the given class name from the element's class names.
replace(element, html)instanceelement: element object or id, html: html content Replaces the entire html of the element with the given html argument. If the given html contains <script> blocks they will not be included but they will be evaluated.
scrollTo(element)instanceelement: element object or id Scrolls the window to the element position.
setStyle(element, cssPropertyHash)instanceelement: element object or id, cssPropertyHash Hash object with the styles to be applied. Sets the value of the CSS properties in the given element, according to the values in the cssPropertyHash argument.
show(element)instanceelement: element object or id Shows the element by resetting its style.display to ''.
siblings(element)instanceelement: element object or id Returns an Array with all the siblings that come before and after the element.
stopObserving(element, name, observer, useCapture)instance element: object or id, name: event name (like 'click', 'load', etc), observer: function(evt) to handle the event, useCapture: if true, handles the event in the capture phase and if false in the bubbling phase. Shortcut for Event.stopObserving.
toggle(element)instanceelement: element object or id Toggles the visibility of the element.
toggleClassName(element, className)instance element: element object or id, className: CSS class Toggles the presence of the given CSS class name in the element.
undoClipping(element)instanceelement: element object or id
undoPositioned(element)instanceelement: element object or id Clears the element's style.position to ''
up(element, expression, index)instance element: element object or id, expression: a CSS selection rule, index: index of the returned ancestor Checks which of the element's ancestors match the given rule and returns the first one or the nth one given by the zero-based index argument. Lower index values mean closer to the element.
update(element, html)instanceelement: element object or id, html: html content Replaces the inner html of the element with the given html argument. If the given html contains <script> blocks they will not be included but they will be evaluated.
visible(element)instanceelement: element object or id Returns a Boolean value indicating if the element is visible.

toc

You can add your own methods to the Element.Methods object and they will also be copied to the elements automatically. You only need to ensure that your methods also take the element as the first argument and (if possible) returns the element object. Here's an example of how to do that. I'll add three new utility methods to the elements. 

//first a helper method
var $CE = function(tagName, attributes, styles){ //short for create element
      var el = document.createElement(tagName);
      if (attributes)
            $H(attributes).each(function(pair){
                  eval("el." + pair.key + "='" + pair.value + "'");
            });
      if (styles)
            $H(styles).each(function(pair){
                  el.style[pair.key] = pair.value;
            });

      return $(el);
};

//adding he new methods
Element.addMethods({
	//removes any child noes from the element
	//example: <div id="myDiv"><b>hello</b></div>
	//         $('myDiv').clearChildren();
	//     ==> <div id="myDiv"></div>
	clearChildren: function(element) {
		element = $(element);
		$A(element.childNodes).each(function(e){
			  e.parentNode.removeChild(e);
		});
		return element;
	},
	//method that creates a new element and appends to the current element
	// example: <div id="myDiv">Please</div>
	//          $('myDiv').append('A',{href:'otherpage.html', className:'red'}).update('Continue...');
	//     ==>  <div id="myDiv">Please<a href="otherpage.html" class="red">Continue...</a></div>
	append: function(element, tagName, attributes, styles) {
		element = $(element);
		var newEl = $CE(tagName, attributes, styles);
		element.appendChild(newEl);
		return newEl;//<-- this one returns the new element
	},
	//appends a text node to the element
	// example: <div id="myDiv"><b>hello</b></div>
	//          $('myDiv').appendText(', John');
	//      ==> <div id="myDiv"><b>hello</b>, John</div>
	appendText: function(element, text){
		element = $(element);
		var t = document.createTextNode(text);
		element.appendChild(t);
		return element;
	  }
});

toc

The Element.ClassNames class

Inherits from Enumerable

Represents the collection of CSS class names associated with an element.

MethodKindArgumentsDescription
[ctor](element)constructorelement: any DOM element object or id Creates an Element.ClassNames object representing the CSS class names of the given element.
add(className)instance className: a CSS class name Includes the given CSS class name in the list of class names associated with the element.
remove(className)instance className: a CSS class name Removes the given CSS class name from the list of class names associated with the element.
set(className)instance className: a CSS class name Associates the element with the given CSS class name, removing any other class names from the element.

toc

The Abstract object

This object serves as the root for other classes in the library. It does not have any properties or methods. The classes defined in this object are also treated as traditional abstract classes.

toc

The Abstract.Insertion class

This class is used as the base class for the other classes that will provide dynamic content insertion. This class is used like an abstract class.

MethodKindArgumentsDescription
[ctor](element, content)constructor element: element object or id, content: HTML to be inserted Creates an object that will help with dynamic content insertion.
contentFromAnonymousTable()instance (none)
PropertyTypeKindDescription
adjacencyStringstatic, parameter Parameter that specifies where the content will be placed relative to the given element. The possible values are: 'beforeBegin', 'afterBegin', 'beforeEnd', and 'afterEnd'.
elementObjectinstance The element object that the insertion will be made relative to.
contentStringinstance The HTML that will be inserted.

toc

The Insertion object

This object serves as the root for other classes in the library. It does not have any properties or methods. The classes defined in this object are also treated as traditional abstract classes.

toc

The Insertion.Before class

Inherits from Abstract.Insertion

Inserts HTML before an element.

MethodKindArgumentsDescription
[ctor](element, content)constructor element: element object or id, content: HTML to be inserted Inherited from Abstract.Insertion. Creates an object that will help with dynamic content insertion.

The following code 

<br/>Hello, <span id="person" style="color:red;">Wiggum. How's it going?</span>

<script> new Insertion.Before('person', 'Chief '); </script>

Will change the HTML to 


<br/>Hello, Chief <span id="person" style="color:red;">Wiggum. How's it going?</span>

toc

The Insertion.Top class

Inherits from Abstract.Insertion

Inserts HTML as the first child under an element. The content will be right after the opening tag of the element.

MethodKindArgumentsDescription
[ctor](element, content)constructor element: element object or id, content: HTML to be inserted Inherited from Abstract.Insertion. Creates an object that will help with dynamic content insertion.

The following code 

<br/>Hello, <span id="person" style="color:red;">Wiggum. How's it going?</span>

<script> new Insertion.Top('person', 'Mr. '); </script>

Will change the HTML to 

<br/>Hello, <span id="person" style="color:red;">Mr. Wiggum. How's it going?</span>

toc

The Insertion.Bottom class

Inherits from Abstract.Insertion

Inserts HTML as the last child under an element. The content will be right before the element's closing tag.

MethodKindArgumentsDescription
[ctor](element, content)constructor element: element object or id, content: HTML to be inserted Inherited from Abstract.Insertion. Creates an object that will help with dynamic content insertion.

The following code 

<br/>Hello, <span id="person" style="color:red;">Wiggum. How's it going?</span>

<script> new Insertion.Bottom('person', " What's up?"); </script>

Will change the HTML to 

<br/>Hello, <span id="person" style="color:red;">Wiggum. How's it going? What's up?</span>

toc

The Insertion.After class

Inherits from Abstract.Insertion

Inserts HTML right after the element's closing tag.

MethodKindArgumentsDescription
[ctor](element, content)constructor element: element object or id, content: HTML to be inserted Inherited from Abstract.Insertion. Creates an object that will help with dynamic content insertion.

The following code 

<br/>Hello, <span id="person" style="color:red;">Wiggum. How's it going?</span>

<script> new Insertion.After('person', ' Are you there?'); </script>

Will change the HTML to 

<br/>Hello, <span id="person" style="color:red;">Wiggum. How's it going?</span> Are you there?

toc

The Field object

This object provides some utility functions for working with input fields in forms. It's simply a shorthand to Form.Element.

toc

The Form object

This object provides some utility functions for working with data entry forms and their input fields.

MethodKindArgumentsDescription
serialize(form)instanceform: form element object or id Returns a url-formatted list of field names and their values, like 'field1=value1&field2=value2&field3=value3'
findFirstElement(form)instanceform: form element object or id Returns the first enabled field element in the form.
getElements(form)instanceform: form element object or id Returns an Array containing all the input fields in the form.
getInputs(form [, typeName [, name]])instance form: form element object or id, typeName: the type of the input element, name: the name of the input element. Returns an Array containing all the <input> elements in the form. Optionally, the list can be filtered by the type or name attributes of the elements.
disable(form)instanceform: form element object or id Disables all the input fields in the form.
enable(form)instanceform: form element object or id Enables all the input fields in the form.
focusFirstElement(form)instanceform: form element object or id Activates the first visible, enabled input field in the form.
reset(form)instanceform: form element object or id Resets the form. The same as calling the reset() method of the form object.

toc

The Form.Element object

This object provides some utility functions for working with form elements. These functions have native DOM equivalents, but those don't return the element as the result of the function call, preventing the chaining of method calls.

The methods below are not the only methods in this object at runtime. All the methods from Form.Element.Methods will also be added to this object.

MethodKindArgumentsDescription
focus(element)instanceelement: element object or id of a form field Moves the input focus to the field.
select(element)instanceelement: element object or id of a form field Selects the value entered in the element.

toc

The Form.Element.Methods object

This object provides some utility functions for working with form field elements, that will be copied over to any field element accessed via the functions $() and $$().

Similarly to the Element.Methods methods, when they are copied, the first argument is dropped and becomes the element itself. These methods are also copied to the Form.Element object so you don't typically use the methods from Form.Element.Methods directly, but rather via the Form.Element object for consistency.

MethodKindArgumentsDescription
activate(element)instanceelement: element object or id Moves the input focus to the field and selects its contents.
clear(element)instanceelement: element object or id Empties the field.
disable(element)instanceelement: element object or id Disables the field or button, so it cannot be changed or clicked.
enable(element)instanceelement: element object or id Enables the field of button for being changed or clicked.
getValue(element)instanceelement: element object or id Returns the value of the element.
present(element)instanceelement: element object or id Returns true if the field is not empty.
serialize(element)instanceelement: element object or id Returns the element's name=value pair, like 'elementName=elementValue'

toc

The Form.Element.Serializers object

This object provides some utility functions that are used internally in the library to assist extracting the current value of the form elements.

MethodKindArgumentsDescription
inputSelector(element)instanceelement: object or id of a form element that has the checked property, like a radio button or checkbox. Returns an Array with the element's name and value, like ['elementName', 'elementValue']
textarea(element)instanceelement: object or id of a form element that has the value property, like a textbox, button or password field. Returns an Array with the element's name and value, like ['elementName', 'elementValue']
select(element)instanceelement: object of a <select> element Returns an Array with the element's name and all selected options' values or texts, like ['elementName', 'selOpt1 selOpt4 selOpt9']

toc

The Abstract.TimedObserver class

This class is used as the base class for the other classes that will monitor one element until its value (or whatever property the derived class defines) changes. This class is used like an abstract class.

Subclasses can be created to monitor things like the input value of an element, or one of the style properties, or number of rows in a table, or whatever else you may be interested in tracking changes to.

MethodKindArgumentsDescription
[ctor](element, frequency, callback)constructor element: element object or id, frequency: interval in seconds, callback: function to be called when the element changes Creates an object that will monitor the element.
getValue()instance, abstract (none) Derived classes have to implement this method to determine what is the current value being monitored in the element.
registerCallback()instance(none) This method is typically not called externally. It is called by the object itself to start monitoring the element.
onTimerEvent()instance(none) This method is typically not called externally. It is called by the object itself periodically to check the element.
PropertyTypeDescription
elementObject The element object that is being monitored.
frequencyNumberThis is actually the interval in seconds between checks.
callbackFunction(Object, String)The function to be called whenever the element changes. It will receive the element object and the new value.
lastValueStringThe last value verified in the element.

toc

The Form.Element.Observer class

Inherits from Abstract.TimedObserver

Implementation of an Abstract.TimedObserver that monitors the value of form input elements. Use this class when you want to monitor an element that does not expose an event that reports the value changes. In that case you can use the Form.Element.EventObserver class instead.

MethodKindArgumentsDescription
[ctor](element, frequency, callback)constructor element: element object or id, frequency: interval in seconds, callback: function to be called when the element changes Inherited from Abstract.TimedObserver. Creates an object that will monitor the element's value property.
getValue()instance (none) Returns the element's value.

toc

The Form.Observer class

Inherits from Abstract.TimedObserver

Implementation of an Abstract.TimedObserver that monitors any changes to any data entry element's value in a form. Use this class when you want to monitor a form that contains a elements that do not expose an event that reports the value changes. In that case you can use the Form.EventObserver class instead.

MethodKindArgumentsDescription
[ctor](form, frequency, callback)constructor form: form object or id, frequency: interval in seconds, callback function to be called when any data entry element in the form changes Inherited from Abstract.TimedObserver. Creates an object that will monitor the form for changes.
getValue()instance (none) Returns the serialization of all form's data.

toc

The Abstract.EventObserver class

This class is used as the base class for the other classes that execute a callback function whenever a value-changing event happens for an element.

Multiple objects of type Abstract.EventObserver can be bound to the same element, without one wiping out the other. The callbacks will be executed in the order they are assigned to the element.

The triggering event is onclick for radio buttons and checkboxes, and onchange for textboxes in general and listboxes/dropdowns.

MethodKindArgumentsDescription
[ctor](element, callback)constructor element: element object or id, callback: function to be called when the event happens Creates an object that will monitor the element.
getValue()instance, abstract (none) Derived classes have to implement this method to determine what is the current value being monitored in the element.
registerCallback()instance(none) This method is typically not called externally. It is called by the object to bind itself to the element's event.
registerFormCallbacks()instance(none) This method is typically not called externally. It is called by the object to bind itself to the events of each data entry element in the form.
onElementEvent()instance(none) This method is typically not called externally. It will be bound to the element's event.
PropertyTypeDescription
elementObject The element object that is being monitored.
callbackFunction(Object, String)The function to be called whenever the element changes. It will receive the element object and the new value.
lastValueStringThe last value verified in the element.

toc

The Form.Element.EventObserver class

Inherits from Abstract.EventObserver

Implementation of an Abstract.EventObserver that executes a callback function to the appropriate event of the form data entry element to detect value changes in the element. If the element does not expose any event that reports changes, then you can use the Form.Element.Observer class instead.

MethodKindArgumentsDescription
[ctor](element, callback)constructor element: element object or id, callback: function to be called when the event happens Inherited from Abstract.EventObserver. Creates an object that will monitor the element's value property.
getValue()instance (none) Returns the element's value

toc

The Form.EventObserver class

Inherits from Abstract.EventObserver

Implementation of an Abstract.EventObserver that monitors any changes to any data entry element contained in a form, using the elements' events to detect when the value changes. If the form contains elements that do not expose any event that reports changes, then you can use the Form.Observer class instead.

MethodKindArgumentsDescription
[ctor](form, callback)constructor form: form object or id, callback: function to be called when any data entry element in the form changes Inherited from Abstract.EventObserver. Creates an object that will monitor the form for changes.
getValue()instance (none) Returns the serialization of all form's data.

toc

The Position object

This object provides a host of functions that help when working with element positioning.

MethodKindArgumentsDescription
absolutize(element)instanceelement: element object or id Changes the object postioning to absolute but takes care of not altering its current size and location on the page.
clone(source, target [, cloneOptions])instance source: element object or id, target: element object or id, cloneOptions: allow fine tuning of the operation Resizes and repositions the target element identically to the source element. Note that the target element will only be repositioned if it already has the position style attribute set to absolute , otherwise only the size will change. Check the cloneOptions reference below.
cumulativeOffset(element)instanceelement: object Returns an Array with the total offsets of the element, including any of the element's ancestors offsets. The resulting array is similar to [total_left_offset, total_top_offset]
offsetParent(element)instanceelement: object Returns the first non-statically-positioned ancestor of the element.
overlap(mode, element)instancemode: 'vertical' or 'horizontal', element: object within() needs to be called right before calling this method. This method will return a decimal number between 0.0 and 1.0 representing the fraction of the coordinate that overlaps on the element. As an example, if the element is a square DIV with a 100px side and positioned at (300, 300), then within(divSquare, 330, 330); overlap('vertical', divSquare); should return 0.70, meaning that the point is at the 70% (100px - 30px = 70px) mark from the bottom border of the DIV. The easiest way to understand it is to think of the given coordinate pair as the top-left corner of another rectangle, overlapping the first one. The number will be the percentage of the width or height that is overlapped (assuming that the second rectangle is large enough.)
page(element)instanceelement: object Returns an Array with the coordinates of the element relative to the page. The resulting array is similar to [left, top]
positionedOffset(element)instanceelement: object Returns an Array with the correct offsets of the element relative to its offset parent, in pixels. The resulting array is similar to [left_offset, top_offset]
prepare()instance(none) Adjusts the deltaX and deltaY properties to accommodate changes in the scroll position. Remember to call this method before any calls to withinIncludingScrolloffset after the page scrolls.
realOffset(element)instanceelement: object Returns an Array with the correct scroll offsets of the element, including any scroll offsets that affect the element. The resulting array is similar to [total_scroll_left, total_scroll_top]
relativize(element)instanceelement: element object or id Changes the object postioning to relative but takes care of not altering its current size and location on the page. Works best with elements that have been absolutized previously.
within(element, x, y)instanceelement: object, x and y: coordinates of a point Tests if the given point coordinates are inside the bounding rectangle of the given element
withinIncludingScrolloffsets(element, x, y)instanceelement: object, x and y: coordinates of a point  

toc

The cloneOptions argument object

The clone() method of the Position object takes an optional third argument, used to more detailedly control the cloning operation.

PropertyTypeDefaultDescription
offsetLeftNumber0 Number of pixels to offset the target element from the left of the source.
offsetTopNumber0 Number of pixels to offset the target element from the top of the source.
setHeightBooleantrue Causes the height of the source element to be copied over to the target element.
setLeftBooleantrue Causes the left position of the source element to be copied over to the target element.
setTopBooleantrue Causes the top position of the source element to be copied over to the target element.
setWidthBooleantrue Causes the width of the source element to be copied over to the target element.

toc

The documentation for v1.5.0 is still in progress. Stay tuned for updates in this document.
If you find errors, inaccurate or incomplete information, or flat-out nonsense, please and I'll try to fix it as soon as possible.