Manipuler des chaînes

Objectifs

À la fin de cette leçon, vous saurez :

• parcourir une chaîne caractère par caractère ;
• inverser une chaîne en construisant le résultat pas à pas ;
• tester si un mot est un palindrome ;
• compter des caractères selon un critère.

🔗 Pour vous rafraîchir la mémoire : parcourir, sommer, compter

Une chaîne, une suite de caractères

Une chaîne se comporte comme une suite ordonnée de caractères :

const mot = "cours";

console.log(mot[0]);        // "c"
console.log(mot.length);    // 5
console.log(mot[mot.length - 1]);   // "s" : dernier caractère

Et elle se parcourt avec for...of comme un tableau :

for (const lettre of mot) {
  console.log(lettre);
}

Rappel du chapitre mémoire : les chaînes sont immuables. On ne modifie jamais une lettre en place ; on construit de nouvelles chaînes.

Construire une chaîne par accumulation

L'accumulateur fonctionne aussi pour les chaînes — la valeur initiale devient "" :

function inverser(texte) {
  let resultat = "";
  for (const lettre of texte) {
    resultat = lettre + resultat;   // chaque lettre se place DEVANT l'accumulation
  }
  return resultat;
}

console.log(inverser("cours"));   // "sruoc"

Tracez l'exécution sur "abc" pour comprendre la construction :

départ      : ""
après 'a'   : "a"
après 'b'   : "ba"
après 'c'   : "cba"

Chaque nouvelle lettre prend la tête : le résultat final est l'inverse.

Palindrome

Un palindrome se lit identiquement dans les deux sens : « kayak », « radar », « ressasser ».

function estPalindrome(texte) {
  return texte === inverser(texte);
}

console.log(estPalindrome("kayak"));   // true
console.log(estPalindrome("cours"));   // false

Version sans fonction auxiliaire, en comparant les extrémités deux à deux :

function estPalindromeBis(texte) {
  let gauche = 0;
  let droite = texte.length - 1;
  while (gauche < droite) {
    if (texte[gauche] !== texte[droite]) {
      return false;          // divergence trouvée : inutile de continuer
    }
    gauche += 1;
    droite -= 1;
  }
  return true;               // toutes les paires concordent
}

Cette version s'arrête dès la première divergence et ne compare que la moitié des positions.

Normaliser avant de comparer

« Kayak » avec majuscule, ou des espaces internes, cassent la comparaison naïve. La pratique courante : normaliser d'abord.

function normaliser(texte) {
  return texte.toLowerCase().replaceAll(" ", "");
}

estPalindrome(normaliser("Kay ak"));   // true

Décidez toujours explicitement ce que votre fonction accepte : casse, espaces, accents (les accents demandent plus qu'un toLowerCase — hors périmètre ici).

Compter des caractères

function compterVoyelles(texte) {
  const voyelles = "aeiouy";
  let compteur = 0;
  for (const lettre of texte.toLowerCase()) {
    if (voyelles.includes(lettre)) {
      compteur += 1;
    }
  }
  return compteur;
}

console.log(compterVoyelles("algorithmique"));   // 6

includes sur une chaîne teste la présence d'un sous-texte : parfait pour un critère d'appartenance simple.

Exercice

1. inverser(texte) — refaites-la sans regarder.
2. compterConsonnes(texte) — consonnes = lettres alphabétiques non voyelles ; décidez du traitement des espaces et chiffres.
3. premiereVoyelle(texte) — renvoie la première voyelle rencontrée, ou null.
4. contientMot(phrase, mot) — vrai si mot apparaît dans phrase (une ligne suffit).
5. estPalindromeNormalise(texte) — palindrome insensible à la casse et aux espaces.
6. Testez vos fonctions sur : "" (chaîne vide), "a" (un seul caractère), "Esope reste ici et se repose".

Résumé

• Une chaîne se parcourt comme un tableau ; ses éléments sont immuables.
• Accumuler une chaîne : partir de "" et reconstruire à chaque tour.
• Palindrome : comparaison à l'inverse, ou balayage des extrémités vers le centre.
• Normalisez (casse, espaces) avant toute comparaison littérale.

function inverser(texte) {
  let resultat = "";
  for (const lettre of texte) {
    resultat = lettre + resultat;
  }
  return resultat;
}

function compterConsonnes(texte) {
  const voyelles = "aeiouy";
  let compteur = 0;
  for (const lettre of texte.toLowerCase()) {
    if (lettre >= "a" && lettre <= "z" && !voyelles.includes(lettre)) {
      compteur += 1;
    }
  }
  return compteur;
}
// Les espaces et chiffres échouent au test a..z : ignorés, décision assumée.

function premiereVoyelle(texte) {
  const voyelles = "aeiouy";
  for (const lettre of texte.toLowerCase()) {
    if (voyelles.includes(lettre)) {
      return lettre;         // sortie anticipée dès la première trouvée
    }
  }
  return null;
}

function contientMot(phrase, mot) {
  return phrase.includes(mot);
}

function estPalindromeNormalise(texte) {
  const propre = texte.toLowerCase().replaceAll(" ", "");
  return propre === inverser(propre);
}