String.prototype.split()

separator

Das Muster, das beschreibt, wo jede Aufteilung erfolgen soll. Kann undefined, ein String oder ein Objekt mit einer Symbol.split-Methode sein — typischerweise ein regulärer Ausdruck. Das Auslassen von separator oder Übergeben von undefined führt dazu, dass split() ein Array mit dem aufrufenden String als einzigem Element zurückgibt. Alle Werte, die weder undefined noch Objekte mit einer [Symbol.split]()-Methode sind, werden zu Strings gezwungen.

limit Optional

Eine nicht-negative ganze Zahl, die eine Begrenzung der Anzahl der in das Array aufzunehmenden Teilstrings angibt. Ist dies angegeben, teilt es den String bei jedem Vorkommen des angegebenen separator, hört aber auf, wenn limit Einträge im Array platziert wurden. Jeglicher übrig gebliebene Text wird gar nicht in das Array aufgenommen.

• Das Array kann weniger Einträge als limit enthalten, wenn das Ende des Strings erreicht ist, bevor die Grenze erreicht wird.
• Wenn limit 0 ist, wird [] zurückgegeben.

Wenn separator ein String ist, wird ein Array von Strings zurückgegeben, das an jedem Punkt aufgeteilt wird, an dem der separator im gegebenen String auftritt.

Wenn separator ein regulärer Ausdruck ist, enthält das zurückgegebene Array ebenfalls die erfassten Gruppen für jedes Separator-Match; siehe unten für Details. Die erfassten Gruppen können nicht übereinstimmen, in welchem Fall sie undefined im Array sind.

Wenn separator eine benutzerdefinierte [Symbol.split]()-Methode hat, wird deren Rückgabewert direkt zurückgegeben.

Wenn separator ein nicht leerer String ist, wird der Zielstring durch alle Übereinstimmungen des separator geteilt, ohne separator in den Ergebnissen einzubeziehen. Zum Beispiel könnte ein String, der durch Tabs getrennte Werte (TSV) enthält, analysiert werden, indem ein Tabulatorzeichen als Trennzeichen übergeben wird, wie myString.split("\t"). Wenn separator mehrere Zeichen enthält, muss diese gesamte Zeichenfolge gefunden werden, um zu teilen. Wenn separator am Anfang (oder Ende) des Strings erscheint, hat es immer noch den Effekt des Teilens, wobei ein leerer (d.h. null Länge) String an der ersten (oder letzten) Position des zurückgegebenen Arrays erscheint. Wenn separator in str nicht auftritt, enthält das zurückgegebene Array ein Element, das aus dem gesamten String besteht.

Wenn separator ein leerer String ("") ist, wird str in ein Array von jeweils einem seiner UTF-16-"Zeichen" umgewandelt, ohne leere Strings an beiden Enden des resultierenden Strings.

Note: "".split("") ist daher der einzige Weg, um ein leeres Array zu erzeugen, wenn ein String als separator übergeben wird und limit nicht 0 ist.

Wenn separator ein regulärer Ausdruck ist, der leere Strings passt, hängt es davon ab, ob der reguläre Ausdruck Unicode-fähig ist, ob die Übereinstimmung durch UTF-16-Codeeinheiten oder Unicode-Codepunkte geteilt wird.

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

Wenn separator ein regulärer Ausdruck mit Erfassungsgruppen ist, werden jedes Mal, wenn separator übereinstimmt, die erfassten Gruppen (einschließlich aller undefined-Ergebnisse) in das Ausgabe-Array eingefügt. Dieses Verhalten wird durch die Symbol.split-Methode des regulären Ausdrucks spezifiziert.

Wenn separator ein Objekt mit einer Symbol.split-Methode ist, wird diese Methode mit dem Zielstring und limit als Argumenten aufgerufen und this auf das Objekt gesetzt. Dessen Rückgabewert wird zum Rückgabewert von split.

Alle anderen Werte werden zum String gezwungen, bevor sie als Trennzeichen verwendet werden.

Wenn der String leer ist und ein nicht-leerer Separator angegeben wird, gibt split() [""] zurück. Wenn sowohl der String als auch der Separator leere Strings sind, wird ein leeres Array zurückgegeben.

const emptyString = "";

// string is empty and separator is non-empty
console.log(emptyString.split("a"));
// [""]

// string and separator are both empty strings
console.log(emptyString.split(emptyString));
// []

Das folgende Beispiel definiert eine Funktion, die einen String in ein Array von Strings unter Verwendung von separator aufteilt. Nachdem der String aufgeteilt wurde, protokolliert die Funktion Nachrichten, die den ursprünglichen String (vor der Aufteilung), den verwendeten Separator, die Anzahl der Elemente im Array und die einzelnen Array-Elemente anzeigen.

function splitString(stringToSplit, separator) {
  const arrayOfStrings = stringToSplit.split(separator);

  console.log("The original string is:", stringToSplit);
  console.log("The separator is:", separator);
  console.log(
    "The array has",
    arrayOfStrings.length,
    "elements:",
    arrayOfStrings.join(" / "),
  );
}

const tempestString = "Oh brave new world that has such people in it.";
const monthString = "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec";

const space = " ";
const comma = ",";

splitString(tempestString, space);
splitString(tempestString);
splitString(monthString, comma);

Dieses Beispiel erzeugt die folgende Ausgabe:

The original string is: "Oh brave new world that has such people in it."
The separator is: " "
The array has 10 elements: Oh / brave / new / world / that / has / such / people / in / it.

The original string is: "Oh brave new world that has such people in it."
The separator is: "undefined"
The array has 1 elements: Oh brave new world that has such people in it.

The original string is: "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec"
The separator is: ","
The array has 12 elements: Jan / Feb / Mar / Apr / May / Jun / Jul / Aug / Sep / Oct / Nov / Dec

Im folgenden Beispiel sucht split() nach null oder mehr Leerzeichen, gefolgt von einem Semikolon, gefolgt von null oder mehr Leerzeichen, und entfernt dann die Leerzeichen und das Semikolon aus dem String. nameList ist das Array, das als Ergebnis von split() zurückgegeben wird.

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

console.log(names);

const re = /\s*(?:;|$)\s*/;
const nameList = names.split(re);

console.log(nameList);

Dies protokolliert zwei Zeilen; die erste Zeile protokolliert den ursprünglichen String, und die zweite Zeile protokolliert das resultierende Array.

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

Im folgenden Beispiel sucht split() nach Leerzeichen in einem String und gibt die ersten 3 Aufteilungen zurück, die es findet.

const myString = "Hello World. How are you doing?";
const splits = myString.split(" ", 3);

console.log(splits); // [ "Hello", "World.", "How" ]

Wenn separator ein regulärer Ausdruck ist, der erfasste Klammern ( ) enthält, werden die übereinstimmenden Ergebnisse in das Array aufgenommen.

const myString = "Hello 1 word. Sentence number 2.";
const splits = myString.split(/(\d)/);

console.log(splits);
// [ "Hello ", "1", " word. Sentence number ", "2", "." ]

Note: \d steht für die Zeichenklasse für Ziffern zwischen 0 und 9.

Ein Objekt mit einer Symbol.split-Methode kann als Splitter mit benutzerdefiniertem Verhalten verwendet werden.

Das folgende Beispiel teilt einen String unter Verwendung eines internen Zustands, der aus einer inkrementierenden Zahl besteht:

const splitByNumber = {
  [Symbol.split](str) {
    let num = 1;
    let pos = 0;
    const result = [];
    while (pos < str.length) {
      const matchPos = str.indexOf(num, pos);
      if (matchPos === -1) {
        result.push(str.substring(pos));
        break;
      }
      result.push(str.substring(pos, matchPos));
      pos = matchPos + String(num).length;
      num++;
    }
    return result;
  },
};

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

Das folgende Beispiel verwendet einen internen Zustand, um bestimmtes Verhalten zu erzwingen und sicherzustellen, dass ein "gültiges" Ergebnis erzeugt wird.

const DELIMITER = ";";

// Split the commands, but remove any invalid or unnecessary values.
const splitCommands = {
  [Symbol.split](str, lim) {
    const results = [];
    const state = {
      on: false,
      brightness: {
        current: 2,
        min: 1,
        max: 3,
      },
    };
    let pos = 0;
    let matchPos = str.indexOf(DELIMITER, pos);

    while (matchPos !== -1) {
      const subString = str.slice(pos, matchPos).trim();

      switch (subString) {
        case "light on":
          // If the `on` state is already true, do nothing.
          if (!state.on) {
            state.on = true;
            results.push(subString);
          }
          break;

        case "light off":
          // If the `on` state is already false, do nothing.
          if (state.on) {
            state.on = false;
            results.push(subString);
          }
          break;

        case "brightness up":
          // Enforce a brightness maximum.
          if (state.brightness.current < state.brightness.max) {
            state.brightness.current += 1;
            results.push(subString);
          }
          break;

        case "brightness down":
          // Enforce a brightness minimum.
          if (state.brightness.current > state.brightness.min) {
            state.brightness.current -= 1;
            results.push(subString);
          }
          break;
      }

      if (results.length === lim) {
        break;
      }

      pos = matchPos + DELIMITER.length;
      matchPos = str.indexOf(DELIMITER, pos);
    }

    // If we broke early due to reaching the split `lim`, don't add the remaining commands.
    if (results.length < lim) {
      results.push(str.slice(pos).trim());
    }

    return results;
  },
};

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

• Polyfill von String.prototype.split in core-js mit Fixes und Implementierung von modernem Verhalten wie Symbol.split-Unterstützung
• es-shims Polyfill von String.prototype.split
• Guide zu regulären Ausdrücken
• String.prototype.charAt()
• String.prototype.indexOf()
• String.prototype.lastIndexOf()
• Array.prototype.join()