Aller au contenu | Aller au menu | Aller à la recherche

logo

Alt-I, des informations alternatives

Alt-I est un blog traitant d'informatique généraliste et de cultures alternatives.

lundi, 16 juillet 2007

Usez et abusez de JSON

Quand on fait de l'AJAX, plusieurs type de réponses peuvent être utilisées. Les puristes préconiseront l'XML, l'objet XML_HTTP_REQUEST étant au départ prévu pour faire transiter de l'XML. Les débutant utiliseront du texte plein ou du HTML.

Déjà, il faut éviter le HTML. Sauf pour le chargement de zones d'interfaces bien entendu. Le genre de cas fréquent à éviter est le suivant : une liste triable avec un événement AJAX lors du changement d'ordre. La requete envoit le nouvel ordre au serveur, qui renvoit, en html la liste entière dans le nouvel ordre. Puis sur le callback, on insére ce HTML à la place de la liste initiale. Faut pas faire ça… :/ Déjà, c'est crade, mais surtout, ça demande des ressources inutiles au serveur et un temps de chargement plus long.

Ensuite, XML peut être intéressant en théorie, mais en pratique, il est très lourd : le nombre de balises peut alourdir intensément la réponse, et surtout, il faut le parser à l'arrivée.

Heureusement, il y a JSON !

JSON (JavaScript Object Notation) est une façon d'écrire des objets en javascript très pratique qui permet de placer dans une seule variable, une infinité de données structurées. Sur une seule réponse Ajax, je peux donc avoir séparément le nouvel ordre des éléments de ma liste, un code erreur, un message de feedback, etc.

Sans aller jusqu'au débat à savoir quelle est la meilleure méthode à adopter, je vais simplement vous donner un exemple de fonctionnement de la réponse de type JSON.<
Nous allons prendre comme exemple un tableau de données à deux colonnes qui se rafraîchit toute les 30 secondes.

// Nous partons d'un array en PHP :
$datas = array(
	"fraise"	=> 2,
	"cerise"	=> 5,
	"bannane"	=> 1,
	"citron"	=> 10,
	"orange"	=> 15
);
// Nous le transformons en JSON grâce à la lib json
//(ou à la main avec un foreach mais, c'est con :/)
include_once("JSON.php");
$json = new JSON();
return $json->encode($datas);
// NB, on peut JSONner des tableau, mais aussi des objet, et même des objet d'objet dans des tableaux avec des tableaux dedans :p

Le résultat est envoyé en tant que text/plain à javascript :

// Voici ce que l'objet ajax reçoit :
// {"fraise" : 2, "cerise" : 5, "bannane" : 1, "citron" : 10, "orange" : 15}
// Ne reste qu'à l'exploiter
// Allons dans la fonction de callback success de notre objet Ajax :
// Je prends l'exemple de YAHOO UI car j'ai l'habitude de travailler avec ça
// Mais on peut faire pareil avec n'importe quelle lib et même sans
YAHOO.util.Connect.asyncRequest(
	"post",
	"traitement.php",
	{
		success: function(o)
		{
			// On commence par mettre notre JSON dans une variable.
			// Pour cela, on utilise la fonction eval()
			eval ("var result = " + o.responseText);
			// A partir de là, toute les données sont accessibles par la varibale result
			alert (result.citron); // Affichera 10
			alert(result['fraise']) // Affichera 2
			// Cette double notation nous permet d'accéder aux données même si on ne connait pas les clés
			// Nous allons créer un tableau qui affiche ces données
			var table = document.createElement("table");
			// Maintenant, on utilise un pseudo foreach pour parser l'objet result
			for (r in result)
			{
				var tr = document.createElement("tr");
				// r représente la clé ("fraise"),
				// result[r] représente sa valeur (2)
				var td1 = document.createElement("td");
				td1.innerHTML = r;
				var td2 = document.createElement("td");
				td2.innerHTML = result[r];
				tr.appendChild(td1);
				tr.appendChild(td2);
				table.appendChild(tr);
			}
			// On finit par afficher le tableau dans la page :
			document.getElementById("affichage").appendChild(
				table
			);
		}
	}
);

Dans cet exemple tout simple où on ne fait qu'afficher un tableau de données, on aurait pu simplement renvoyer le tableau mis en forme par php. Ainsi, coté Javascript, on se tape juste un document.getElementById('affichage').innerHTML o.responseText; et puis basta. Sauf que :

  • Il faut écrire le tableau coté php. Du travail supplémentaire pour le serveur, un template supplémentaire si on en utilise un, du code html dans du php en plus dans le cas contraire.
  • La réponse est bien plus lourde.
  • Coté Javascript, on est totalement limité. En fait, on ne peut rien faire à part afficher le tableau. Si finalement, on nous demande d'afficher une liste, ou d'ajouter une colonne avec le pourcentage, on est obligé d'aller taper coté PHP. Avec le JSON, je peux ajouter cette colonne en rajoutant ceci dans la boucle for :
    var td3 = document.createElement('td');
    td3.innerHTML = result[r] * total / 100; // total ayant été calculé auparavant

Ne retenez qu'une chose : dans le JSON tout est bon :D

dimanche, 15 juillet 2007

Héritage de classes Javascript

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

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.

mardi, 3 avril 2007

OverBlog est dans la place !

logoOverBlog V2 est de sortie !

Le grand jour est enfin arrivé après quelque léger retard. Nous avons donc le plaisir de vous présenter, mes collègues et moi même, la nouvelle version d'OverBlog !

Vous pourrez découvrir la splendide nouvelle charte graphique créée par un graphiste de talent, les nouvelles fonctionnalités Web2.0 telles que les communautés et les actualités, et surtout, l'interface d'administration toute en AJAX qui vous proposera un contrôle absolu de votre blog ! Vous aurez aussi droit à de nouveaux designs, d'un éditeur de css complet… et tellement de fonctionnalités à découvrir par vous même ;)

Je vous proposerais d'ici peu un screencast pour présenter l'admin d'OverBlog (mon œuvre :p) quand j'aurais trouvé où j'ai rangé Ellane. Me demande s'il elle est encore vivante la pauvre :o

mardi, 6 février 2007

Choisir son framework/API Javascript…

Chez les web dev, on assiste à une guerre de religion concernant les frameworks Javascript. De nombreuses bibliothèques existent, chacune ayant ses spécificités et sa syntaxe particulière. Chacune a sa communauté, ses défendeurs et détracteurs. Dans quel but ? Faire du Web 2.0… Car finalement, pas de Web 2.0 sans javascript.

Lire la suite...

- page 3 de 4 -