Alt-I, des informations alternatives - Informatique, Cultures alternatives et Geekeries saupoudrées d'Ajax. - web

Acid test 3

Hadrien — Thu, 14 Feb 2008 10:51:00 +0100

On va encore se marrer. L'Acid test version 3 a été testé sur tout les navigateurs du marché. Voici ce qui devrait s'afficher sur un navigateur respectant les standards à 100% :

Malheureusement, on est loin du compte. Seule la dernière nightbuild de WebKit atteind un score respectable de 82% :

Et marrons nous devant IE6 et IE7 :

Voilà, avec 70% de navigateurs qui n'arrive même pas à 15% d'un test de standards, le web est mal barré…

Un site web magnifique

Hadrien — Tue, 18 Dec 2007 10:31:00 +0100

Pour qui aime les css et le png :

http://www.webleeddesign.com/

Ajax, navigation et accessibilité… Exemple pratique

Hadrien — Sat, 08 Sep 2007 23:42:00 +0200

J'ai codé à l'arrache un exemple pratique pour illustrer mon astuce concernant la navigation en Ajax accessible. Bon, c'est pas encore top au point, mais ça fonctionne nickel sous Firefox. Sous Safari 2, l'historique n'est pas modifié donc, pas de précédent ou suivant. Seul le rechargement de page fonctionne. Opera 9.5, seul le bouton Suivant ne fonctionne étrangement pas. Et IE, j'ai pas testé : j'ai pas envie de lancer VMWare : j'attends vos retours en commentaires.

Donc, de quoi s'agit il ? Nous avons une liste paginée. Sont affichés la liste des articles de ce blog par lot de 10 éléments. Une pagination en dessous permet d'afficher les 10 éléments suivants grâce à Ajax. Vous constaterez que lors d'un clic sur un numéro de page, une ancre s'ajoute à l'url. Mais aucun rechargement de page ne s'effectue.

Faîtes donc le test suivant : naviguez de page en page, puis rechargez la page. Vous vous retrouverez à la même pagination où vous étiez \o/ Attention, ce n'est pas fini. Cliquez sur le bouton précédent de votre navigateur… Pas de rechargement ni de changement de page, mais vous voilà quand même à la pagination précédente, toujours en ajax :o Revenez donc en arrière deux ou trois fois, puis repartez en avant. Même principe. Tout se charge par Ajax.

Voilà une application Ajax totalement accessible et qui reste utilisable comme tout site traditionnel.

Ah oui, ça se passe ici :

Exemple pratique pour rendre Ajax accessible

La prochaine étape sera d'écrire un module pour YUI afin de faciliter l'implémentation de cette méthode.

Héritage de classes Javascript

Hadrien — Sun, 15 Jul 2007 14:38:00 +0200

Il est possible aussi de faire hériter une classe d'une autre. Voici comment j'écris monAutreClasse héritée de maClasse :

/**
 * monAutreClasse
 * @extends maClasse
 * @constructor
 */
monProjet.monAutreClasse = function(arg) {
	// Ces deux lignes permettent de récupérer le constructeur de la classe parente
	this.superclass = monProjet.maClasse;
	this.superclass(arg);
	
	// On peut ensuite ajouter de nouvelles variables :
	this.autreVar = "autre chose";
	// A noter que si on veut qu'elles soient disponible dans le init, il faut les placer avant
	// le this.superclass
};
// Ici, on clone le prototype (les méthodes) de la classe parente à la classe enfant
monProjet.monAutreClasse.prototype = new superclass();

// Méthodes publiques
/**
 * Une nouvelle méthode disponible seulement dans monAutreClasse
 */
monProjet.monAutreClasse.prototype.displayAutreVar = function() {
	alert(this.autreVar);
};
/**
 * On redéfinie la méthode toString()
 */
monProjet.monAutreClasse.prototype.toString = function() {
	return "monAutreClasse object";
};


// On peut ensuite apeller les même méthodes que la classe parente
var unSecondObjet = new monProjet.monAutreClasse("kikoo");
monProjet.maClasse.getByVar1("kikoo"); // retourne l'objet "unObjet"
monProjet.maClasse.getByVar1("kikoo").autreMethode(); // Crée une alerte
// mais aussi celles propres à elle même :
unSecondObjet.displayAutreVar();
// Et les méthodes redéfinies :
unSecondObjet.toString(); // retourne "monAutreClasse Object"

Alors ce qui est embêtant, c'est qu'on ne peut pas définir de nouvelles méthodes de prototype directement comme dans l'écriture d'une classe simple. Si j'écrivais monProjet.monAutreClasse.prototype = {…}, toute les méthodes de la classe parente seraient écrasées. Je suis obligé de les nommer les unes après les autres.

À noter aussi que le tableau contenant tout les objets créé n'est pas necessaire. Par contre, on aurait pu avoir un tableau séparé pour cette classe enfante mais il aurait fallu modifier le construteur.

Coder proprement ses classes Javascript

Hadrien — Sun, 15 Jul 2007 01:30:00 +0200

Il existe de nombreuses façons de coder en Javascript. La plus fréquente est malheureusement la plus crade : lister ses fonctions les une après les autres…
Voici comment je code mes classes JS. Il existe peut être de meilleures méthodes mais je trouve celle-ci très propre et très lisible :

var monProjet = {}; // On crée une variable globale du nom du projet
// Ce tableau permettra de stocker et récupérer facilement les objets créés.
//Je lui donne le nom de la classe avec un 's' marquant le pluriel :
monProjet.maClasses = new Array();
/**
 * Classe maClasse : fait des choses.
 */
monProjet.maClasse = function(attr)
{
	// Variable
	this.variable1 = attr;
	
	monProjet.maClasses.push(this);
	this.init();
};
// Méthodes publiques de maClasse
monProjet.maClasse.prototype =
{
	/**
	 * Initialisation, méthode apellée à l'instanciation de l'objet
	 */
	init: function()
	{
		this.variable2 = this.variable1 + 10;
	},
	/**
	 * Autre méthode qui va afficher variable2 dans une alerte
	 */
	autreMethode: function()
	{
		alert(this.variable2);
	},
	/**
	 * Retourne une valeur de l'objet sous forme de chaine
	 */
	toString: function()
	{
		return "maClasse Object";
	}
};
// Méthodes Statiques
/**
 * Une methode statique qui retourne 'yo'
 */
monProjet.maClasse.uneMethodeStatique = function()
{
	return "yo";
};
/**
 * Le genre de méthode statique où on se rends compte de l'utilité du tableau d'objets vu plus haut
 */
monProjet.maClasse.getByVar1 = function(var1)
{
	for (var i = 0; monProjet.maClasses[i]; i++)
	{
		if (monProjet.maClasses[i].variable1 == var1)
		{
			return monProjet.maClasses[i];
		}
	}
	return false;
};

//On peut ensuite créer un objet maClasse et apeller ses méthodes publiques et statiques :

var unObjet = new monProjet.maClasse("youpi");
unObjet.toString(); // retourne "maClasse Object"
monProjet.maClasse.getByVar1("youpi"); // retourne l'objet "unObjet"
monProjet.maClasse.getByVar1("youpi").autreMethode(); // Crée une alerte
…

Nous avons ainsi des classes bien structurées et aucune variable globales (à part la première bien sur) qui pourrait se retrouver écraser par d'autres scripts.