String : méthode split()

Exemple interactif

const str = "Le renard brun rapide saute par-dessus le chien paresseux.";

const words = str.split(" ");
console.log(words[3]);
// Résultat attendu : "renard"

const chars = str.split("");
console.log(chars[8]);
// Résultat attendu : "d"

const strCopy = str.split();
console.log(strCopy);
// Résultat attendu : Array ["Le renard brun rapide saute par-dessus le chien paresseux."]

Syntaxe

split(separator)
split(separator, limit)

Paramètres

separator

Le motif décrivant où chaque découpe doit se produire. Peut être undefined, une chaîne de caractères, ou un objet avec une méthode Symbol.split — l'exemple typique étant une expression rationnelle. Omettre separator ou passer undefined fait que split() retourne un tableau avec la chaîne de caractères appelante comme unique élément. Toutes les valeurs qui ne sont pas undefined ou des objets avec une méthode [Symbol.split]() sont converties en chaînes de caractères.

limit Facultatif

Un entier non négatif définissant une limite sur le nombre de sous-chaînes de caractères à inclure dans le tableau. Si fourni, divise la chaîne de caractères à chaque occurrence du separator défini, mais s'arrête lorsque limit entrées ont été placées dans le tableau. Tout texte restant n'est pas inclus dans le tableau.

• Le tableau peut contenir moins d'entrées que limit si la fin de la chaîne de caractères est atteinte avant d'atteindre la limite.
• Si limit est 0, [] est retourné.

Valeur de retour

Si separator est une chaîne de caractères, un tableau (Array) de chaînes de caractères est retourné, découpé à chaque point où le separator apparaît dans la chaîne de caractères donnée.

Si separator est une expression rationnelle, le tableau retourné (Array) contient également les groupes capturés pour chaque correspondance du séparateur ; voir ci-dessous pour plus de détails. Les groupes capturés peuvent ne pas correspondre, auquel cas ils sont undefined dans le tableau.

Si separator a une méthode personnalisée [Symbol.split](), sa valeur de retour est directement retournée.

Description

Si separator est une chaîne de caractères non vide, la chaîne de caractères cible est découpée à chaque occurrence de separator, sans inclure separator dans les résultats. Par exemple, une chaîne de caractères contenant des valeurs séparées par des tabulations (TSV) peut être analysée en passant un caractère de tabulation comme séparateur, par exemple avec myString.split("\t"). Si separator contient plusieurs caractères, toute cette séquence de caractères doit être présente pour effectuer le découpage. Si separator apparaît au début ou à la fin de la chaîne de caractères, il provoque tout de même un découpage, ce qui fait apparaître une chaîne de caractères vide (c'est-à-dire de longueur nulle) à la première ou à la dernière position du tableau retourné. Si separator n'apparaît pas dans str, le tableau retourné contient un seul élément constitué de la chaîne de caractères entière.

Si separator est une chaîne de caractères vide (""), str est convertie en un tableau contenant chacun de ses « caractères » UTF-16, sans chaîne de caractères vide à l'une ou l'autre extrémité de la chaîne de caractères obtenue.

Si separator est une expression rationnelle qui correspond à des chaînes de caractères vides, le fait que la correspondance soit découpée en unités de code UTF-16 ou en points de code Unicode dépend de la sensibilité à l'Unicode par l'expression rationnelle.

"😄😄".split(/(?:)/); // [ "\ud83d", "\ude04", "\ud83d", "\ude04" ]
"😄😄".split(/(?:)/u); // [ "😄", "😄" ]

Si separator est une expression rationnelle avec des groupes de capture, chaque correspondance de separator insère les groupes capturés (y compris les éventuels résultats undefined) dans le tableau de sortie. Ce comportement est défini par la méthode Symbol.split de l'expression rationnelle.

Si separator est un objet doté d'une méthode Symbol.split, cette méthode est appelée avec la chaîne de caractères cible et limit comme arguments, et avec this défini sur l'objet. Sa valeur de retour devient celle de split.

Toute autre valeur est contrainte en chaîne de caractères avant de servir de séparateur.

Exemples

Utiliser la méthode split()

Lorsque la chaîne de caractères est vide et qu'un séparateur non vide est défini, split() retourne [""]. Si la chaîne de caractères et le séparateur sont tous deux des chaînes de caractères vides, un tableau vide est retourné.

const chaineDeCaracteresVide = "";

// la chaîne de caractères est vide et le séparateur n'est pas vide
console.log(chaineDeCaracteresVide.split("a"));
// [""]

// la chaîne de caractères et la séparateur sont tous deux des chaînes de caractères vides
console.log(chaineDeCaracteresVide.split(chaineDeCaracteresVide));
// []

L'exemple suivant définit une fonction qui divise une chaîne de caractères en un tableau de chaînes de caractères en utilisant separator. Après avoir divisé la chaîne de caractères, la fonction affiche des messages indiquant la chaîne de caractères d'origine (avant la division), le séparateur utilisé, le nombre d'éléments dans le tableau et les éléments individuels du tableau.

function diviserChaineDeCaracteres(stringToSplit, separator) {
  const tableauDeChainesCaracteres = stringToSplit.split(separator);

  console.log(`La chaîne de caractères d'origine est : ${stringToSplit}`);
  console.log(`Le délimiteur est : ${separator}`);
  console.log(
    `Le tableau comporte ${tableauDeChainesCaracteres.length} éléments : `,
    tableauDeChainesCaracteres.join(" / "),
  );
}

const chaineDeCaracteresTempest =
  "Ô merveilleux nouveau monde qui abrite de telles personnes.";
const chaineDeCaracteresMois =
  "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec";

const espace = " ";
const virgule = ",";

diviserChaineDeCaracteres(chaineDeCaracteresTempest, espace);
diviserChaineDeCaracteres(chaineDeCaracteresTempest);
diviserChaineDeCaracteres(chaineDeCaracteresMois, virgule);

Cet exemple produit la sortie suivante :

La chaîne de caractères d'origine est : "Ô merveilleux nouveau monde qui abrite de telles personnes."
Le délimiteur est : " "
Le tableau comporte 9 elements : Ô / merveilleux / nouveau / monde / qui / abrite / de / telles / personnes. /

La chaîne de caractères d'origine est : "Ô merveilleux nouveau monde qui abrite de telles personnes."
Le délimiteur est : "undefined"
Le tableau comporte 1 elements : Ô merveilleux nouveau monde qui abrite de telles personnes. /

La chaîne de caractères d'origine est : "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec"
Le délimiteur est : ","
Le tableau comporte 12 elements : Jan / Feb / Mar / Apr / May / Jun / Jul / Aug / Sep / Oct / Nov / Dec /

Supprimer les espaces d'une chaîne de caractères

Dans l'exemple suivant, la fonction split() recherche zéro ou plusieurs espaces, suivis d'un point-virgule, puis de zéro ou plusieurs espaces — et, lorsqu'elle les trouve, elle supprime les espaces et le point-virgule de la chaîne de caractères. listeNom est le tableau retourné par la fonction split().

const noms = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand ";

console.log(noms);

const re = /\s*(;|$)\s*/;
const listeNom = noms.split(re);

console.log(listeNom);

Cela génère deux lignes ; la première ligne affiche la chaîne de caractères d'origine, et la seconde ligne affiche le tableau obtenu.

Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand
["Harry Trump","Fred Barney","Helen Rigby","Bill Abel","Chris Hand"]

Retourner un nombre limité de sous-chaînes de caractères

Dans l'exemple suivant, split() recherche des espaces dans une chaîne de caractères et retourne les 3 premières sous-chaînes de caractères qui correspondent.

const maChaineDeCaracteres = "Bonjour le monde. Comment allez-vous ?";
const separations = maChaineDeCaracteres.split(" ", 3);

console.log(separations); // [ "Bonjour", "le "monde." ]

Séparer avec une RegExp pour inclure des parties du séparateur dans le résultat

Si separator est une expression rationnelle qui contient des parenthèses de capture ( ), les résultats correspondants sont inclus dans le tableau.

const maChaineDeCaracteres = "Bonjour 1 le monde. Séquence numéro 2.";
const separations = maChaineDeCaracteres.split(/(\d)/);

console.log(separations);
// [ "Bonjour ", "1", " le monde. Séquence numéro ", "2", "." ]

Utiliser un séparateur personnalisé

L'exemple suivant divise une chaîne de caractères en utilisant un état interne constitué d'un nombre croissant :

L'exemple suivant divise une chaîne de caractères en utilisant un état interne constitué d'un nombre croissant :

const separerParNombre = {
  [Symbol.split](chaine) {
    let nombre = 1;
    let pos = 0;
    const resultat = [];
    while (pos < chaine.length) {
      const positionCorrespondante = chaine.indexOf(nombre, pos);
      if (positionCorrespondante === -1) {
        resultat.push(chaine.substring(pos));
        break;
      }
      resultat.push(chaine.substring(pos, positionCorrespondante));
      pos = positionCorrespondante + String(nombre).length;
      nombre++;
    }
    return resultat;
  },
};

const maChaineDeCaracteres = "a1bc2c5d3e4f";
console.log(maChaineDeCaracteres.split(separerParNombre)); // [ "a", "bc", "c5d", "e", "f" ]

L'exemple suivant utilise un état interne pour appliquer un certain comportement et pour s'assurer qu'un résultat « valide » est produit.

const DELIMITATION = ";";

// Sépare les commandes, mais supprime toutes les valeurs invalides ou inutiles.
const separerCommandes = {
  [Symbol.split](chaine, limite) {
    const resultats = [];
    const etat = {
      on: false,
      brightness: {
        current: 2,
        min: 1,
        max: 3,
      },
    };
    let pos = 0;
    let positionCorrespondante = chaine.indexOf(DELIMITATION, pos);

    while (positionCorrespondante !== -1) {
      const sousChaineDeCaracteres = chaine
        .slice(pos, positionCorrespondante)
        .trim();

      switch (sousChaineDeCaracteres) {
        case "light on":
          // Si l'état `on` est déjà vrai, ne rien faire.
          if (!etat.on) {
            etat.on = true;
            resultats.push(sousChaineDeCaracteres);
          }
          break;

        case "light off":
          // Si l'état `on` est déjà faux, ne rien faire.
          if (etat.on) {
            etat.on = false;
            resultats.push(sousChaineDeCaracteres);
          }
          break;

        case "brightness up":
          // Applique un maximum de luminosité.
          if (etat.brightness.current < etat.brightness.max) {
            etat.brightness.current += 1;
            resultats.push(sousChaineDeCaracteres);
          }
          break;

        case "brightness down":
          // Applique un minimum de luminosité.
          if (etat.brightness.current > etat.brightness.min) {
            etat.brightness.current -= 1;
            resultats.push(sousChaineDeCaracteres);
          }
          break;
      }

      if (resultats.length === limite) {
        break;
      }

      pos = positionCorrespondante + DELIMITATION.length;
      positionCorrespondante = chaine.indexOf(DELIMITATION, pos);
    }

    // Si nous avons interrompu l'exécution prématurément parce que la limite `lim` a été atteinte, ne pas ajouter les commandes restantes.
    if (resultats.length < limite) {
      resultats.push(chaine.slice(pos).trim());
    }

    return resultats;
  },
};

const commandes =
  "light on; brightness up; brightness up; brightness up; light on; brightness down; brightness down; light off";
console.log(commandes.split(separerCommandes, 3)); // ["light on", "brightness up", "brightness down"]

Spécifications

Compatibilité des navigateurs

Voir aussi

• La prothèse d'émulation (polyfill en anglais) de String.prototype.split dans core-js avec des corrections et l'implémentation du comportement moderne comme la prise en charge de Symbol.split ^(angl.)
• La prothèse d'émulation (polyfill en anglais) es-shims de String.prototype.split ^(angl.)
• Le guide des expressions rationnelles
• La méthode String.prototype.charAt()
• La méthode String.prototype.indexOf()
• La méthode String.prototype.lastIndexOf()
• La méthode Array.prototype.join()