TRI DÉCROISSANT ET CROISSANT D'UN TABLEAU DYNAMIQUE REMPLIE PAR UN INTERNAUTE

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

														///////// partie triage des données ///////
														
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



var copieTableau = new Array(); // tableau javascript contenant les données de celui en HTML
var tableauLignesCasesVides = new Array(); // Sert à enregistrer les lignes contenant les cellules vides se trouvant dans la colonne à trier
function  sort_int(p1,p2) { return p1-p2; }			//fonction pour trier les nombres
function sort_char(p1,p2) { return ((p1>=p2)<<1)-1; }	//fonction pour trier les strings
	
	

function echange (p1, p2, nbLignes, nbColonnes) // une fois le tri d'un colonne effectué, il faut mettre à la bonne place les autres éléments du tableau, j'effectue donc ici un échange de 						 												//places entre deux lignes.
{
	for (var index1 = p1, index2 = p2; index1 <= (nbLignes * nbColonnes) - (nbLignes - p1); index1 = index1 + nbLignes, index2 = index2 + nbLignes)
	{
		var temp = copieTableau[index1];
		copieTableau[index1] = copieTableau[index2];
		copieTableau[index2] = temp;
	}
}


function verifCaseVide(ligne, index) // vérifie si la cellule en cours de la colonne à trier est vide ou non
{
	if (copieTableau[index + ligne] == "") // on se positionne sur la cellule correspondant à la colonne et à la ligne en cours de traitement
		return true; // si c'est vide
	else
		return false;
}

function enregistrementLignesCasesVides(ligne, nbLignes, nbColonnes, cpt) // si la cellule traitée est vide, on enregistre toute la ligne dans le tableau "tableauLignesCasesVides"
{
	for(var indice = ligne; indice <= (nbColonnes * nbLignes) - (nbLignes - ligne); indice += nbLignes) // déplacement colonne par colonne
	{	
		tableauLignesCasesVides[cpt] = indice; // on enregistre donc les indices des cellules appartennant à la ligne concernée
		cpt ++;
	}
	
	return cpt;
}

/* tri du tableau */

// triOrdre -> 1 pour décroissant, 0 pour croissant
// numeroColonne -< pour savoir où se trouve la colonne cliquée dans le tableau

function TableOrder(triOrdre, numeroColonne)
{
	var tableau = document.getElementById('tableau'); // on va enregistrer notre objet tableau
	var nbLignes = tableau.rows.length - 3; // on prend le nombre de lignes qui le compose (-3 viens du fait qu'il existe une première ligne cachée qui sert de modèle à dupliquer lors d'un    										//ajout de ligne)
	
	if (nbLignes > 1) // Sinon ça sert à rien de trier ...
	{
		var nbColonnes = tableau.rows[0].cells.length; // on enregistre le nombre de colonnes existantes.
		var FntSort = sort_int; // Cette variable enregistre le type de tri à effectuer, pourquoi on l'initialise avec un sort_int, nous le verrons par la suite.

		var index = nbLignes * (numeroColonne - 1); // Une fois que l'on a copié le tableau HTML dans le tableau javascript, il faut savoir où se trouve dans ce dernier les éléments à trier, 
													// index va contenir l'indice correspondant au numéro de la première cellule de la colonne à trier.

    	var tableauSort = new Array(); 				// ce tableau contient le contenu de la colonne à trier

		var cpt = 0;								// un compteur pour parcourir un tableau.

		var indice = 0;								// idem
	
		for (var colonne = 0; colonne < nbColonnes; colonne ++) // et c'est partie pour copier le tableau HTML dans le tableau javascript "copieTableau"
		{
			for (var ligne = colonne + nbColonnes; ligne <= (nbLignes * nbColonnes) + cpt; ligne = ligne + nbColonnes) // afin de retrouver facilement les données à trier, on va copier les  			 																														//données du tableau HTML colonne par colonne.
			{
				copieTableau[indice] = document.listing.champ[ligne].value; // Donc on aboutit à un tableau en une dimension contenant les données du tableau HTML colonne par colonne
				indice ++; // D'ou le besoin d'un autre indice de parcourt s'incrémentant différemment
			}
			
			cpt ++; // un compteur pour éviter de dépasser la taille du tableau HTML lors de sa copie
		}
	 
	 // après il va falloir définir si l'on tri des nombres ou des chaines de caractères.
	 
		cpt = index; // on va donc parcourir copieTableau à partir de l'indice correspondant au début de la colonne à trier.
		var verifInt = true; // on va vérifier si l'on a dans la colonne à trier QUE des nombres
	
		while (cpt < index + nbLignes && verifInt == true)
		{
			if (!copieTableau[cpt].match(/^[0-9£¤$\.\s-]+$/) && copieTableau[cpt] != "") // Si jamais on a rien qui est inscrit dans une cellule, on l'intèrprète comme un 0
			{
				FntSort=sort_char; // hop, on a trouvé une chaine de caractères.
				verifInt = false; // Bin voilà quoi, y a pas que des nombres finalement
			}
		
			cpt ++;
		}

		tableauSort = copieTableau.slice(index, index + nbLignes); // Et maintenant on copie les données de la colonne à copier dans le tableau servant au triage
	
		tableauSort.sort(FntSort); // on trie de façon croissante

		if (triOrdre == 1) // si on avait choisie de trier de façon décroissante
			tableauSort.reverse(); // on inverse les données dans le tableau de triage

		// Maintenant il va falloir faire correspondre les données triées avec le reste des champs du tableau copieTableau
		for (var indiceTabSort = 0, indiceCopieTab = index; indiceTabSort < tableauSort.length; indiceTabSort ++, indiceCopieTab ++)
		{
			if (tableauSort[indiceTabSort] != copieTableau[indiceCopieTab]) // on va alors comparer la place des données triées dans le tableau de triage avec celle qu'elles occupent dans le  																			//tableau copieTableau. La condition est vérifiée lorsque la place d'une donnée ne correspond pas d'un tableau à  														 																			// l'autre 	 									
			{
				var trouve = false;
				indice = indiceCopieTab + 1;
									
				while (!trouve && indice < numeroColonne * nbLignes) // On va devoir alors rechercher où se trouve la donnée triée dans le tableau copieTableau, pas besoin de rechercher sur    																// tout le tableau, on regarde juste dans l'intervalle de données correspondant à l'étendue de la colonne à trier.
				{
					if (tableauSort[indiceTabSort] == copieTableau[indice]) // Ah! On a trouvé l'indice de la valeur triée dans le tableau copieTableau ( c'est l'image du tableau HTML colonne   																		    // par colonne pour rappel)
					{
						indice = indice - ((numeroColonne-1) * nbLignes); // Comme copieTableau est une image du tableau HTML colonne par colonne, on peut dire ici que l'on calcule l'indice
																		// de la ligne à déplacer dans copieTableau
						echange (indiceTabSort, indice, nbLignes, nbColonnes); // On échange les deux lignes
						trouve = true;
					}
						
					indice ++;
				}
			}
		}
		
		indice = nbColonnes;
		cpt = 0;
		var indiceTabLCV = 0; // cette variable contient en fait la taille du tableau   "tableauLignesCasesVides"
		
		for (var ligne = 0; ligne < nbLignes; ligne ++) // Maintenant c'est comme au début, sauf que cette fois-ci on copie les données du tableau copieTableau dans celui en HTML
		{
                       if (verifCaseVide(ligne, index)) // on vérifie sur la ligne en cours si la cellule se trouvant dans la colonne à trier est vide ou non
				indiceTabLCV = enregistrementLignesCasesVides(ligne, nbLignes, nbColonnes, indiceTabLCV); // si c'est le cas on enregistre les indices des cellules de la ligne
			
			else // sinon on recopie la ligne dans le tableau HTML
			{
				for (var colonne = ligne; colonne <= (nbLignes * (nbColonnes - 1)) + cpt; colonne = colonne + nbLignes )
				{
						document.listing.champ[indice].value = copieTableau[colonne]; 
						indice ++; 
				}
			}
			
			cpt ++;
		}

                if (indiceTabLCV > 0) // si on a détecté une ou plusieurs cellules vides dans la colonne à trier, il faut alors rechercher les lignes enregistrées dans le tableau                              // "tableauLignesCasesVides" et les placer à la fin du tableau HTML
		{
			var taille = indiceTabLCV; // on enregistre la taille du tableau
			
			for (indiceTabLCV = 0; indiceTabLCV < taille; indiceTabLCV += nbColonnes) // comme on a enregistré des lignes entières dans ce tableau, on peut avancer qu'il est divisé en     	       																				// tranches dont l'étendue correspond au nombre de colonnes.
				for (cpt = indiceTabLCV; cpt < nbColonnes + indiceTabLCV; cpt ++) // on va donc parcourir chacune de ces divisions
				{
					document.listing.champ[indice].value = copieTableau[tableauLignesCasesVides[cpt]]; // pour les enregistrer l'une à la suite de l'autre dans le tableau HTML
					indice ++; // indice reprend là où il s'était arrêté lors de la copie des lignes contenant les cellules pleines de la colonne à trier
				}
		}
	}
}

// Bon bon j'espère que c'était assez clair, , n'hésitez pas à poser vos questions et vos solutions d'optimisations.