Traitement des chaînes & tableaux en JavaScript                » Tables & matrices , Constantes et fonctions mathématiques , JavaScript par des exemples

• Pour déclarer une chaîne, on la met entre guillemets : x = "chat" , z = "123", y="" (chaîne vide)
   

• toString() : convertit un nombre en chaîne : si y = 3.14, c = y.toString() retourne dans c la chaîne "3.14" constituée de 4 éléments.
   

• eval : convertit une chaîne en nombre, quitte à la calculer : x = eval(3/4) place 0.75 dans x.
   

• toLowerCase() et toUpperCase : convertit en minuscules et majuscules :
  x = "Ce chat s'appelle Matou".toLowerCase() identifiera x à la chaîne "ce chat s'appelle matou".
   

• length : calcule la longueur de la chaîne (nombre de caractères qu'elle contient) : lg = "Les 7 nains".length conduit à lg = 11.
  
   !   Si la longueur de la chaine x="123456789" est bien 9, JavaScript indexe cependant les éléments à partir de 0... (zéro) et non de 1, bizarrerie qui vous vaudra souvent des crises de nerfs, face à des résultats aberrants, quand vous l'oublierez... Ainsi, avec l'instruction suivante, demander d'afficher x.charAt(L) lorsque L = x.length provoque une erreur, il faut écrire : x.charAt(L - 1). Très énervant...
   

• charAt(n) : retourne le terme de rang n d'une chaîne : si x = "chat", c = x.charAt(2) fournira c = "a" (c est identifié à la lettre a) car JavaScript compte comme déjà dit à partir de 0...
   

• substr (en anglais substring = sous-chaîne) : x.substr(n,p) retourne la chaîne de longueur p extraite de x et commençant au rang n donc au (n+1)-ème caractère, le premier étant de rang 0.

• On peut aussi utiliser substring(n,p) : ici n et p sont les positions de début et de fin souhaitées. De plus, on commence en fait au rang n + 1 puisque JavaScript compte toujours à partir de 0 et non de 1 : "chaton".substring(2,5) fournira "ato".
   

• Concaténation : si x contient chat et y contient ton, alors z = x + y identifiera z à chaton.
  On peut aussi utiliser la méthode concat() : z = y.concat(x) a le même effet que z = x + y.

» Exemples : Un problème de 3 , casse-tête impair , palindrome

JavaScript gère également des listes (équivalentes à un n-uplet : donnée ordonnée de n éléments) grâce à de puissantes instructions.
Les tableaux à plusieurs dimensions sont aussi fort bien gérés au moyen d'une petite astuce... :

• a = new Array(n) : définit un vecteur a (n-uplet) dont les éléments sont notés a[0], a[1], a[2], ..., a[n]
  
  La déclaration de dimension n est optionnelle. Bien retenir que le compteur commence à 0 lors des opérations sur une liste.
  Dans une boucle, on peut indexer par un compteur i et écrire a[i].
   
• a[1] = new Array(n) : aura pour effet de déclarer un tableau (matrice) à une ligne et n colonnes.
  Ses éléments seront appelés par a[1][2], ..., a[1][n].
   
• a = new Array(2); for(i=1;i<=2;i++){a[i]=new Array()} : cette séquence définit une matrice carrée 2 × 2 d'éléments a[i][j].
  
  a = new Array(3); for(i=1;i<=5;i++){a[i]=new Array()} : cette séquence définit une matrice rectangulaire de 5 lignes
  et 3 colonnes.

   Un usage matriciel (méthode du pivot de Gauss) : »

• s = new Array(1,2,3,"Soleil") : définit un vecteur s dont les éléments sont s[0] = 1, s[1]=2, s[2]=3, ..., s[3]="Soleil".
  Pour i = 0, 1 et 2, s[i] est un nombre, s[3] est une chaîne.  » On pouvait tout aussi bien écrire s = [1,2,3,"soleil"].
   

• Si v = [1,2,3], alors  v.concat(4,5) : fournit le vecteur v = [1,2,3,4,5].
   ! [1,2,3] + [4,5] n'engendre pas d'erreur mais cela fournit [1,2,34,5] !!
  
  » Ce petit programme : M=new Array();
                                      for(i=1;i<=5;i++) { x=1+Math.floor(Math.random()*9);M=[x].concat(M) };
                                      alert("M="+M)
    affiche  une liste M de 5 éléments M[0], ...M[4]  (attention aux indices).
   
• L = new Array(1,2,3) ; alert (L) : affiche L sous forme de liste : 1,2,3.
   
• lg = L.length : retourne dans la variable lg le nombre d'éléments de la liste L. Si L = [élève,peut,mieux,faire], alors lg = 4.
   
• L.join("-") : joint les éléments d'une liste L en les séparant par le(s) caractère(s) placé(s), ici un tiret : 1-2-3 . Le résultat est une chaîne de caractères. L n'est pas modifié.
   
• L = chain_carac.split(car) : retourne dans L la liste des mots séparés par car (une virgule par exemple) dans la chaîne donnée chaine_carac. L = "vive les maths".split(" ") retourne L = [vive,les,maths] d'éléments L[0] = "vive", L[1] = "les", L[2] = "maths". Dans une affectation via l'instruction prompt de type L=prompt("Donnez votre liste :",L) , malgré toutes les déclarations préalables de type L = new Array() ou L = [ ] ou L = [1,2,3], etc., L sera convertie en une chaîne de caractères. Pour récupérer une liste, rajouter L=L.split(",") :

L=[100,7,20,3,1]
L=prompt("Donnez votre liste :",L)     // à la sortie du prompt, L est la chaîne 100,7,20,3,1
L=L.split(",")    // rétablit L comme liste de 5 éléments.

»  tri par insertion , tri à bulles , tri récursif

• L.reverse() : renverse l'ordre des éléments de L.  Si L = [1,2,3], alert(L.reverse()) affichera 3,2,1.
   

• L.sort() : trie les éléments de L dans l'ordre alphanumérique et lexicographique du code ASCII.
   !   Attention aux pièges : 100 sera placé avant 11 !!! (ordre lexicographique du dictionnaire : nombres transformés en chaînes). De plus, en ASCII les majuscules sont placées avant les minuscules et par suite le tri de ["Pierre",2,0,"pierre","java",100,"Java"] ne sera peut-être pas celui attendu.

function tri()
{
L=["Pierre",2,0,"pierre","java",100,"Java"]           
alert(L.join(" - ") ; alert(L.sort())
}

 ➔   Dans le cas d'un tableau numérique, imposez l'ordre usuel en indiquant à JavaScript votre façon de trier : l'instruction L.sort(diff) où diff est la fonction différence indique que nous trions par différence positive :

function tri2()
{
L=[17,2,0,-8,100,13]
alert("Liste L = "+L)
alert("Liste triée = "+L.sort(diff).join(" ; "))             
}
function diff(x,y)
{return x-y}

 Afin de trier dans l'ordre décroissant, on remplacerait x - y par y - x dans la fonction diff.

• M= L.slice(n) : retourne dans M la tranche (slice = tranche en anglais) de n premiers éléments de L. L n'est pas modifié.
   !   Attention, comme pour les chaînes de caractères, on commence au rang 0 : Si L = [0,1,2,3,4,5,6,7,8,9], M = L.slice(3) retournera
          [3,4,5,6, 7,8,9] dans M et l'instruction alert(L.slice(1)) affichera 1,2,3,4,5,6

• M = L.slice(n,p) : analogue à substr() : place dans M la sous-liste de L commençant au rang n et s'arrêtant au rang p  (n<=p). L n'est pas modifié.
   !  Mais, attention car on commence au rang 0 et non au rang 1. Avec la liste ci-dessous M = L.slice(3,7) retourne [3,4,5,6] dans M.
   
• L.slice(n,n+1) : extrait de la liste L le terme de rang n (donc en fait le n+1-ème élément).
  first = L.slice(0,1) retourne la tête de liste (1er élément) dans first et last=L.slice(L.length(),1) retourne le dernier dans last.

• L.splice(n,p) : ôte de la liste L p éléments consécutifs à partir du n-ème. Contrairement à slice, la liste L est ici modifiée : on recolle le début au reste (splice = collure en anglais comme pour un film cassé que l'on recolle).
   !   Là encore, on part du rang 0 : Avec la liste ci-dessous, L.splice(3,5) transforme L en [0,1,2,8,9] et l'instruction M= L.splice(3,5) retournera [3,4,5,6,7] dans M. Pour obtenir [1,2,3,...,9], il faut donner n = 0 (rang 0), p = 1.

• L.push(n) : ajoute n en fin de liste de L. Contrairement aux instructions précédentes, il s'agit d'une procédure et non d'une fonction retournant une liste : L est modifiée au profit de L.push(n).

function p()
{
n=10;
n=eval(prompt("n = ",n))
L=[0,1,2,3,4,5,6,7,8,9]
L.push(n);
alert(L.join(" - "))
}

• L.pop() : retire le dernier élément de la liste n en fin de liste de L. Comme push, il s'agit d'une procédure.
  
  » Noter que M = L.pop() retourne dans M l'élément retiré.