[Ajax] onreadystatechange wechseln?

function curry(fn) {
 var slice = Array.prototype.slice,
 args = slice.call(arguments, 1);
 
 return function() {
 args = args.concat(slice.call(arguments));
 return fn.apply(fn, args);
 };
}

function request(url, fn) {
 var xhr = new XMLHttpRequest;
 xhr.open('GET', url, true);
 xhr.onreadystatechange = curry(fn, xhr);
 xhr.send();
}

request('dieses.php', function(req) {
 if (req.readyState === 4) {
 // mach was...
 }
}); 

request('jenes.php', function(req) {
 if (req.readyState === 4) {
 // mach was anderes
 }
});

/**
 * diese funktion erzeugt eine neue funktion
 * die die übergebenen parameter an die übergebene funktion
 * bindet.
 *
 * diese art von closure-generator nennt man "curring"
 * 
 * @param Function fn die funktion
 * @param Object ... weitere parameter die an die funktion gebunden werden
 * @return Function die erstellte funktion
 */
function curry(fn) {
 var slice = Array.prototype.slice, // referenz auf die array.slice methode
 args = slice.call(arguments, 1); // alle angebenen parameter bis auf den ersten
 
 // Array.prototype.slice schneidet einen array an
 // der angegebenen stelle ab und gibt den rest zurück.
 
 // in `args` befinden sich nun alle parameter bis auf den ersten
 // der hier ja benannt wurde mit `fn` (den brauchen wir nicht zweimal)
 
 // dazu verwenden wir das objekt `arguments`
 // in welchem sich alle parameter befinden, egal ob die
 // funktion sie erwarten (wie z.b. `fn`) oder eben nicht.
 
 // hier erzeugen wir eine NEUE funktion,
 // welche beim aufruf die übergebene funktion `fn`
 // ausführt.
 return function() {
 // selbes spiel wie zu anfang.
 // achtung: `arguments` wird nun von DIESER funktion erzeugt!
 
 // wir kombinieren nun die parameter der funktion `curry`
 // und die parameter dieser funktion zu einem array
 // und übergeben dieses an unsere funktion `fn`
 args = args.concat(slice.call(arguments));
 
 // wir rufen die function mittels .apply auf um
 // unsere eigens erstellten parameter als array
 // zu übergeben
 return fn.apply(fn, args);
 };
}

/**
 * xml-http-request
 *
 * @param String url wohin die anfrage soll
 * @param Function fn eine funktion die als `onreadystatechange` callback dienen soll
 */
function request(url, fn) {
 // instanz erzeugen
 var xhr = new XMLHttpRequest;
 
 // öffnen als GET und async
 xhr.open('GET', url, true);
 
 // hier der wichtige teil!
 // wir binden das objekt `xhr` an die funktion `fn`
 // d.h. wenn die funktion nun aufgerufen wird ist das objekt `xhr`
 // IMMER der erste parameter, egal ob weitere parameter an die funktion
 // übergeben werden -> `xhr` ist immer an erster stelle!
 xhr.onreadystatechange = curry(fn, xhr);
 
 // anfrage absenden
 xhr.send();
}

// und hier die beispiele.

// wie du sehen kannst ist das objekt `req`
// angegeben, was dem `xhr` objekt in der funktion `request`
// entspricht.
request('dieses.php', function(req) {
 if (req.readyState === 4) {
 // mach was...
 }
}); 

// vielleicht macht es so mehr sinn:

request('dieses.php', function(xhr) {
 if (xhr.readyState === 4) {
 // mach was...
 }
}); 

function show(val) {
 alert(val);
} 

var hello = curry(show, "hello");
hello(); // gibt "hello" aus

var world = curry(show, "world");
world(); // gibt "world" aus

function loadContent()
{ 
 var crawl=encodeURIComponent(document.getElementById("crawly").value);
 request('crawl.php?crawl=' + crawl, handleContent); 
 return false;
} 

function handleContent(xhr)
{
 if (xhr.readyState == 1)
 {
 document.getElementById('Content').innerHTML = '<img src="ajax-loader.gif" alt="loading" />';
 }

 if (xhr.readyState == 3)
 {
 document.getElementById('Content').innerHTML = xmlHttpObject.responseText + '<div class="Loading"><img src="ajax-loader.gif" alt="loading" /></div>';
 }
 
 if (xhr.readyState == 4)
 {
 document.getElementById('Content').innerHTML = xmlHttpObject.responseText;
 }
}