Saiten

In JavaScript werden die Textdaten als Zeichenfolgen gespeichert. Es gibt keinen separaten Typ für ein einzelnes Zeichen.

Das interne Format für Strings ist immer UTF-16, es ist nicht an die Seitenkodierung gebunden.

Zitate

Erinnern wir uns an die Arten von Zitaten.

Zeichenfolgen können entweder in einfache Anführungszeichen, doppelte Anführungszeichen oder Backticks eingeschlossen werden:

 let single = 'single-quoted';
let double = "doppelte Anführungszeichen";

let backticks = `backticks`;

Einfache und doppelte Anführungszeichen sind im Wesentlichen gleich. Backticks ermöglichen es uns jedoch, jeden Ausdruck in den String einzubetten, indem wir ihn in ${…} einschließen:

 Funktion sum(a, b) {
  gib a + b zurück;
}

alarm(`1 + 2 = ${sum(1, 2)}.`); // 1 + 2 = 3.

Ein weiterer Vorteil der Verwendung von Backticks besteht darin, dass sie es ermöglichen, dass sich eine Zeichenfolge über mehrere Zeilen erstreckt:

 let GuestList = `Gäste:
 * John
 * Pete
 * Maria
`;

alarm(guestList); // eine Gästeliste, mehrere Zeilen

Sieht natürlich aus, oder? Aber einfache oder doppelte Anführungszeichen funktionieren auf diese Weise nicht.

Wenn wir sie verwenden und versuchen, mehrere Zeilen zu verwenden, wird ein Fehler angezeigt:

 let GuestList = „Gäste: // Fehler: Unerwartetes Token ILLEGAL
  * John“;

Einfache und doppelte Anführungszeichen stammen aus alten Zeiten der Sprachschöpfung, als die Notwendigkeit mehrzeiliger Zeichenfolgen noch nicht berücksichtigt wurde. Backticks erschienen viel später und sind daher vielseitiger.

Backticks ermöglichen es uns auch, vor dem ersten Backtick eine „Vorlagenfunktion“ anzugeben. Die Syntax lautet: func`string` . Die Funktion func wird automatisch aufgerufen, empfängt den String und eingebettete Ausdrücke und kann diese verarbeiten. Diese Funktion wird als „getaggte Vorlagen“ bezeichnet und ist selten zu sehen, aber Sie können sie im MDN: Vorlagenliterale nachlesen.

Sonderzeichen

Es ist weiterhin möglich, mehrzeilige Zeichenfolgen mit einfachen und doppelten Anführungszeichen zu erstellen, indem Sie ein sogenanntes „Newline-Zeichen“ verwenden, das als n geschrieben wird und einen Zeilenumbruch bezeichnet:

 let GuestList = "Gäste:n * Johnn * Peten * Mary";

alarm(guestList); // eine mehrzeilige Gästeliste, wie oben

Als einfacheres Beispiel sind diese beiden Zeilen gleich, nur unterschiedlich geschrieben:

 let str1 = "HellonWorld"; // zwei Zeilen mit einem „Newline-Symbol“

// zwei Zeilen mit einem normalen Zeilenumbruch und Backticks
let str2 = `Hallo
Welt`;

alarm(str1 == str2); // WAHR

Es gibt weitere, weniger verbreitete Sonderzeichen:

Wie Sie sehen, beginnen alle Sonderzeichen mit einem Backslash-Zeichen . Es wird auch „Fluchtzeichen“ genannt.

Weil es so besonders ist, müssen wir ihn verdoppeln, wenn wir einen tatsächlichen Backslash innerhalb der Zeichenfolge anzeigen müssen:

 Alert( `Der Backslash: \` ); // Der Backslash: 

Sogenannte „escaped“-Anführungszeichen ' , " , ` werden verwendet, um ein Anführungszeichen in die gleichnamige Zeichenfolge einzufügen.

Zum Beispiel:

 alarm( 'Ich bin das Walross!' ); // Ich bin das Walross!

Wie Sie sehen, müssen wir dem inneren Anführungszeichen den Backslash ' voranstellen, da es sonst das Ende der Zeichenfolge anzeigen würde.

Natürlich müssen nur die Anführungszeichen maskiert werden, die mit den einschließenden identisch sind. Als elegantere Lösung könnten wir stattdessen auf doppelte Anführungszeichen oder Backticks umsteigen:

 alarm( "Ich bin das Walross!" ); // Ich bin das Walross!

Neben diesen Sonderzeichen gibt es auch eine spezielle Notation für Unicode-Codes u… , die selten verwendet wird und im optionalen Kapitel über Unicode behandelt wird.

Saitenlänge

Die length hat die Stringlänge:

 alarm( `Myn`.length ); // 3

Beachten Sie, dass n ein einzelnes „Sonderzeichen“ ist, die Länge also tatsächlich 3 beträgt.

length ist eine Eigenschaft

Leute mit einem Hintergrund in einigen anderen Sprachen vertippen sich manchmal, indem sie str.length() statt nur str.length aufrufen. Das funktioniert nicht.

Bitte beachten Sie, dass str.length eine numerische Eigenschaft und keine Funktion ist. Es ist nicht erforderlich, danach eine Klammer einzufügen. Nicht .length() , sondern .length .

Auf Charaktere zugreifen

Um ein Zeichen an der Position pos zu erhalten, verwenden Sie eckige Klammern [pos] oder rufen Sie die Methode str.at(pos) auf. Das erste Zeichen beginnt an der Nullposition:

 let str = `Hallo`;

// das erste Zeichen
alarm( str[0] ); // H
alarm( str.at(0) ); // H

// das letzte Zeichen
alarm( str[str.length - 1] ); // o
alarm( str.at(-1) );

Wie Sie sehen können, hat die Methode .at(pos) den Vorteil, dass sie eine negative Position zulässt. Wenn pos negativ ist, wird ab dem Ende der Zeichenfolge gezählt.

.at(-1) bedeutet also das letzte Zeichen und .at(-2) ist das davor usw.

Die eckigen Klammern geben bei negativen Indizes immer undefined zurück, zum Beispiel:

 let str = `Hallo`;

alarm( str[-2] ); // undefiniert
alarm( str.at(-2) ); // l

Wir können auch über Zeichen iterieren, indem wir for..of verwenden:

 for (lassen Sie char von „Hallo“) {
  alarm(char); // H,e,l,l,o (char wird zu „H“, dann zu „e“, dann zu „l“ usw.)
}

Zeichenfolgen sind unveränderlich

Zeichenfolgen können in JavaScript nicht geändert werden. Es ist unmöglich, einen Charakter zu ändern.

Probieren wir es aus, um zu zeigen, dass es nicht funktioniert:

 let str = 'Hallo';

str[0] = 'h'; // Fehler
alarm( str[0] ); // funktioniert nicht

Die übliche Problemumgehung besteht darin, eine ganz neue Zeichenfolge zu erstellen und diese anstelle der alten str zuzuweisen.

Zum Beispiel:

 let str = 'Hallo';

str = 'h' + str[1]; // Ersetze die Zeichenfolge

alarm( str ); // Hi

In den folgenden Abschnitten sehen wir weitere Beispiele hierfür.

Den Fall ändern

Die Methoden toLowerCase() und toUpperCase() ändern die Groß-/Kleinschreibung:

 alarm( 'Interface'.toUpperCase() ); // SCHNITTSTELLE
alarm( 'Interface'.toLowerCase() ); // Schnittstelle

Oder, wenn wir ein einzelnes Zeichen in Kleinbuchstaben wollen:

 alarm( 'Interface'[0].toLowerCase() ); // 'ich'

Suche nach einem Teilstring

Es gibt mehrere Möglichkeiten, innerhalb einer Zeichenfolge nach einer Teilzeichenfolge zu suchen.

str.indexOf

Die erste Methode ist str.indexOf(substr, pos).

Es sucht nach dem substr in str , beginnend an der angegebenen Position pos , und gibt die Position zurück, an der die Übereinstimmung gefunden wurde, oder -1 wenn nichts gefunden werden kann.

Zum Beispiel:

 let str = 'Widget mit ID';

alarm( str.indexOf('Widget') ); // 0, da 'Widget' am Anfang steht
alarm( str.indexOf('widget') ); // -1, nicht gefunden, die Suche unterscheidet zwischen Groß- und Kleinschreibung

alarm( str.indexOf("id") ); // 1, „id“ wird an Position 1 gefunden (..idget mit id)

Der optionale zweite Parameter ermöglicht es uns, die Suche von einer bestimmten Position aus zu starten.

Das erste Vorkommen von "id" ist beispielsweise an Position 1 . Um nach dem nächsten Vorkommen zu suchen, beginnen wir die Suche ab Position 2 :

 let str = 'Widget mit ID';

alarm( str.indexOf('id', 2) ) // 12

Wenn wir an allen Vorkommen interessiert sind, können wir indexOf in einer Schleife ausführen. Jeder neue Anruf erfolgt mit der Position nach dem vorherigen Spiel:

 let str = 'So schlau wie ein Fuchs, so stark wie ein Ochse';

let target = 'as'; // Lasst uns danach suchen

sei pos = 0;
while (wahr) {
  let FoundPos = str.indexOf(target, pos);
  if (foundPos == -1) break;

  alarm( `Gefunden bei ${foundPos}` );
  pos = gefundenPos + 1; // Fortsetzung der Suche ab der nächsten Position
}

Der gleiche Algorithmus kann kürzer dargestellt werden:

 let str = „So schlau wie ein Fuchs, so stark wie ein Ochse“;
let target = „as“;

sei pos = -1;
while ((pos = str.indexOf(target, pos + 1)) != -1) {
  alarm( pos );
}

str.lastIndexOf(substr, position)

Es gibt auch eine ähnliche Methode str.lastIndexOf(substr, position), die vom Ende einer Zeichenfolge bis zu ihrem Anfang sucht.

Es würde die Vorkommnisse in umgekehrter Reihenfolge auflisten.

Es gibt eine leichte Unannehmlichkeit mit indexOf im if Test. Wir können es nicht so in das if einfügen:

 let str = "Widget mit ID";

if (str.indexOf("Widget")) {
    alarm("Wir haben es gefunden"); // funktioniert nicht!
}

Die alert im obigen Beispiel wird nicht angezeigt, da str.indexOf("Widget") 0 zurückgibt (was bedeutet, dass die Übereinstimmung an der Startposition gefunden wurde). Richtig, aber if man 0 für false hält.

Wir sollten also tatsächlich nach -1 suchen, etwa so:

 let str = "Widget mit ID";

if (str.indexOf("Widget") != -1) {
    alarm("Wir haben es gefunden"); // Funktioniert jetzt!
}

beinhaltet, beginnt mit, endet mit

Die modernere Methode str.includes(substr, pos) gibt true/false zurück, je nachdem, ob str substr enthält.

Es ist die richtige Wahl, wenn wir die Übereinstimmung testen müssen, aber ihre Position nicht benötigen:

 Alert( "Widget mit ID".includes("Widget") ); // WAHR

alarm( "Hallo".includes("Bye") ); // FALSCH

Das optionale zweite Argument von str.includes ist die Position, von der aus mit der Suche begonnen werden soll:

 alarm( "Widget".includes("id") ); // WAHR
alarm( "Widget".includes("id", 3) ); // false, ab Position 3 gibt es kein „id“

Die Methoden str.startsWith und str.endsWith machen genau das, was sie sagen:

 alarm( "Widget".startsWith("Wid") ); // true, „Widget“ beginnt mit „Wid“
alarm( "Widget".endsWith("get") ); // true, „Widget“ endet mit „get“

Einen Teilstring abrufen

In JavaScript gibt es drei Methoden, um einen Teilstring abzurufen: substring , substr und slice .

• str.slice(start [, end])

• Gibt den Teil der Zeichenfolge von start bis (aber nicht einschließlich) end zurück.

  Zum Beispiel:

   let str = "stringify";
  alarm( str.slice(0, 5) ); // 'strin', der Teilstring von 0 bis 5 (ohne 5)
  alarm( str.slice(0, 1) ); // 's', von 0 bis 1, aber ohne 1, also nur Zeichen bei 0

  Wenn es kein zweites Argument gibt, geht slice bis zum Ende der Zeichenfolge:

   let str = "stringify";
  alarm( str.slice(2) ); // 'ringify', von der 2. Position bis zum Ende

  Auch negative Werte für start/end sind möglich. Sie bedeuten, dass die Position vom Ende der Zeichenfolge aus gezählt wird:

   let str = "stringify";
  
  // Beginnen Sie an der 4. Position von rechts und enden Sie an der 1. von rechts
  alarm( str.slice(-4, -1) ); // 'gif'

• str.substring(start [, end])

• Gibt den Teil der Zeichenfolge zwischen start und end zurück (ohne end ).

  Dies ist fast dasselbe wie slice , erlaubt jedoch, dass start größer als end ist (in diesem Fall werden einfach start und end vertauscht).

  Zum Beispiel:

   let str = "stringify";
  
  // Diese gelten auch für Teilzeichenfolgen
  alarm( str.substring(2, 6) ); // "Ring"
  alarm( str.substring(6, 2) ); // "Ring"
  
  // ...aber nicht für Slice:
  alarm( str.slice(2, 6) ); // „klingeln“ (dasselbe)
  alarm( str.slice(6, 2) ); // "" (eine leere Zeichenfolge)

  Negative Argumente werden (im Gegensatz zu Slice) nicht unterstützt, sie werden als 0 behandelt.

• str.substr(start [, length])

• Gibt den Teil der Zeichenfolge ab start mit der angegebenen length zurück.

  Im Gegensatz zu den vorherigen Methoden können wir bei dieser Methode die length anstelle der Endposition angeben:

   let str = "stringify";
  alarm( str.substr(2, 4) ); // 'ring', ab der 2. Position 4 Zeichen erhalten

  Das erste Argument kann negativ sein, vom Ende an gezählt:

   let str = "stringify";
  alarm( str.substr(-4, 2) ); // 'gi', ab der 4. Position 2 Zeichen erhalten

  Diese Methode befindet sich im Anhang B der Sprachspezifikation. Das bedeutet, dass nur vom Browser gehostete Javascript-Engines es unterstützen sollten und es nicht empfohlen wird, es zu verwenden. In der Praxis wird es überall unterstützt.

Lassen Sie uns diese Methoden noch einmal zusammenfassen, um Verwirrung zu vermeiden:

Welches soll ich wählen?

Alle können den Job machen. Formal hat substr einen kleinen Nachteil: Es wird nicht in der JavaScript-Kernspezifikation beschrieben, sondern in Anhang B, der nur Browserfunktionen abdeckt, die hauptsächlich aus historischen Gründen existieren. Daher kann es sein, dass Nicht-Browser-Umgebungen dies nicht unterstützen. Aber in der Praxis funktioniert es überall.

Von den beiden anderen Varianten ist slice etwas flexibler, erlaubt negative Argumente und ist kürzer zu schreiben.

Für den praktischen Gebrauch reicht es also aus, sich nur slice zu erinnern.

Strings vergleichen

Wie wir aus dem Kapitel Vergleiche wissen, werden Zeichenfolgen Zeichen für Zeichen in alphabetischer Reihenfolge verglichen.

Allerdings gibt es einige Kuriositäten.

1. Ein Kleinbuchstabe ist immer größer als ein Großbuchstabe:

    alarm( 'a' > 'Z' ); // WAHR

2. Buchstaben mit diakritischen Zeichen sind „nicht in der richtigen Reihenfolge“:

    Alert( 'Österreich' > 'Seeland' ); // WAHR

   Dies kann zu seltsamen Ergebnissen führen, wenn wir diese Ländernamen sortieren. Normalerweise würden die Leute erwarten, dass Zealand in der Liste nach Österreich kommt.

Um zu verstehen, was passiert, sollten wir uns darüber im Klaren sein, dass Zeichenfolgen in Javascript mit UTF-16 codiert werden. Das heißt: Jedes Zeichen hat einen entsprechenden Zahlencode.

Es gibt spezielle Methoden, die es ermöglichen, das Zeichen für den Code und zurück zu erhalten:

• str.codePointAt(pos)

• Gibt eine Dezimalzahl zurück, die den Code für das Zeichen an Position pos darstellt:

   // Unterschiedliche Groß-/Kleinschreibung hat unterschiedliche Codes
  alarm( "Z".codePointAt(0) ); // 90
  alarm( "z".codePointAt(0) ); // 122
  alarm( "z".codePointAt(0).toString(16) ); // 7a (wenn wir einen Hexadezimalwert benötigen)

• String.fromCodePoint(code)

• Erstellt ein Zeichen anhand seines numerischen code

   alarm( String.fromCodePoint(90) ); // Z
  alarm( String.fromCodePoint(0x5a) ); // Z (wir können auch einen Hex-Wert als Argument verwenden)

Sehen wir uns nun die Zeichen mit den Codes 65..220 (das lateinische Alphabet und etwas mehr) an, indem wir daraus eine Zeichenfolge erstellen:

 let str = '';

for (let i = 65; i <= 220; i++) {
  str += String.fromCodePoint(i);
}
alarm( str );
// Ausgabe:
// ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~ € ‚ƒ„
// ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜ

Sehen? Zuerst kommen Großbuchstaben, dann einige Sonderzeichen, dann Kleinbuchstaben und am Ende der Ausgabe Ö .

Jetzt wird klar, warum a > Z .

Die Zeichen werden anhand ihres Zahlencodes verglichen. Der größere Code bedeutet, dass das Zeichen größer ist. Der Code für a (97) ist größer als der Code für Z (90).

• Alle Kleinbuchstaben stehen nach Großbuchstaben, da ihre Codes größer sind.

• Einige Buchstaben wie Ö heben sich vom Hauptalphabet ab. Hier ist sein Code größer als alles von a bis z .

Richtige Vergleiche

Der „richtige“ Algorithmus zum Durchführen von Zeichenfolgenvergleichen ist komplexer als es scheint, da die Alphabete für verschiedene Sprachen unterschiedlich sind.

Daher muss der Browser die zu vergleichende Sprache kennen.

Glücklicherweise unterstützen moderne Browser den Internationalisierungsstandard ECMA-402.

Es bietet eine spezielle Methode zum Vergleichen von Zeichenfolgen in verschiedenen Sprachen und folgt deren Regeln.

Der Aufruf str.localeCompare(str2) gibt eine Ganzzahl zurück, die angibt, ob str gemäß den Sprachregeln kleiner, gleich oder größer als str2 ist:

• Gibt eine negative Zahl zurück, wenn str kleiner als str2 ist.

• Gibt eine positive Zahl zurück, wenn str größer als str2 ist.

• Gibt 0 zurück, wenn sie gleichwertig sind.

Zum Beispiel:

 Alert( 'Österreich'.localeCompare('Zealand') ); // -1

Diese Methode verfügt tatsächlich über zwei zusätzliche Argumente, die in der Dokumentation angegeben sind, wodurch sie die Sprache angeben kann (standardmäßig aus der Umgebung übernommen, die Reihenfolge der Buchstaben hängt von der Sprache ab) und zusätzliche Regeln wie die Berücksichtigung der Groß-/Kleinschreibung oder "a" und "á" einrichten kann. gleich behandelt werden usw.

Zusammenfassung

• Es gibt 3 Arten von Zitaten. Backticks ermöglichen es einer Zeichenfolge, sich über mehrere Zeilen zu erstrecken und Ausdrücke einzubetten ${…} .

• Wir können Sonderzeichen wie einen Zeilenumbruch n verwenden.

• Um ein Zeichen zu erhalten, verwenden Sie: [] oder at -Methode.

• Um einen Teilstring zu erhalten, verwenden Sie: slice oder substring .

• Um eine Zeichenfolge in Klein-/Großbuchstaben zu schreiben, verwenden Sie: toLowerCase/toUpperCase .

• Um nach einer Teilzeichenfolge zu suchen, verwenden Sie: indexOf oder includes/startsWith/endsWith für einfache Überprüfungen.

• Um Zeichenfolgen entsprechend der Sprache zu vergleichen, verwenden Sie: localeCompare , andernfalls werden sie anhand von Zeichencodes verglichen.

Es gibt mehrere andere hilfreiche Methoden in Strings:

• str.trim() – entfernt („trimmt“) Leerzeichen vom Anfang und Ende der Zeichenfolge.

• str.repeat(n) – wiederholt die Zeichenfolge n -mal.

• …und mehr finden Sie im Handbuch.

Strings verfügen auch über Methoden zum Suchen/Ersetzen mit regulären Ausdrücken. Aber das ist ein großes Thema, deshalb wird es in einem separaten Tutorial-Abschnitt „Reguläre Ausdrücke“ erklärt.

Außerdem ist es ab sofort wichtig zu wissen, dass Zeichenfolgen auf der Unicode-Kodierung basieren und es daher Probleme bei Vergleichen gibt. Mehr über Unicode erfahren Sie im Kapitel Unicode, String-Interna.

Aufgaben

Das erste Zeichen in Großbuchstaben schreiben

Wichtigkeit: 5

Schreiben Sie eine Funktion ucFirst(str) die die Zeichenfolge str mit dem ersten Zeichen in Großbuchstaben zurückgibt, zum Beispiel:

 ucFirst("john") == "John";

Öffnen Sie eine Sandbox mit Tests.

Lösung

Wir können das erste Zeichen nicht „ersetzen“, da Zeichenfolgen in JavaScript unveränderlich sind.

Aber wir können eine neue Zeichenfolge basierend auf der vorhandenen erstellen, wobei das erste Zeichen in Großbuchstaben geschrieben wird:

 let newStr = str[0].toUpperCase() + str.slice(1);

Es gibt jedoch ein kleines Problem. Wenn str leer ist, ist str[0] undefined , und da undefined nicht über die Methode toUpperCase() verfügt, erhalten wir eine Fehlermeldung.

Der einfachste Ausweg besteht darin, einen Test für eine leere Zeichenfolge hinzuzufügen, etwa so:

 Funktion ucFirst(str) {
  if (!str) return str;

  return str[0].toUpperCase() + str.slice(1);
}

alarm( ucFirst("john") ); // John

Öffnen Sie die Lösung mit Tests in einer Sandbox.

Auf Spam prüfen

Wichtigkeit: 5

Schreiben Sie eine Funktion checkSpam(str) , die true zurückgibt, wenn str „viagra“ oder „XXX“ enthält, andernfalls false .

Bei der Funktion muss die Groß-/Kleinschreibung nicht beachtet werden:

 checkSpam('ViAgRA jetzt kaufen') == true
checkSpam('free xxxxx') == true
checkSpam("innocent Rabbit") == false

Öffnen Sie eine Sandbox mit Tests.

Lösung

Um die Suche unabhängig von der Groß-/Kleinschreibung zu machen, wandeln wir die Zeichenfolge in Kleinbuchstaben um und suchen dann:

 Funktion checkSpam(str) {
  let LowerStr = str.toLowerCase();

  return LowerStr.includes('viagra') || LowerStr.includes('xxx');
}

Alert( checkSpam('ViAgRA jetzt kaufen') );
alarm( checkSpam('free xxxxx') );
alarm( checkSpam("unschuldiges Kaninchen") );

Öffnen Sie die Lösung mit Tests in einer Sandbox.

Kürzen Sie den Text

Wichtigkeit: 5

Erstellen Sie eine Funktion truncate(str, maxlength) , die die Länge von str überprüft und, wenn sie maxlength überschreitet, das Ende von str durch das Auslassungszeichen "…" ersetzt, um seine Länge gleich maxlength zu machen.

Das Ergebnis der Funktion sollte die (falls erforderlich) gekürzte Zeichenfolge sein.

Zum Beispiel:

 truncate("Was ich zu diesem Thema sagen möchte, ist:", 20) == "Was ich gerne sagen würde…"

truncate("Hallo alle zusammen!", 20) == "Hallo alle zusammen!"

Öffnen Sie eine Sandbox mit Tests.

Lösung

Die maximale Länge muss maxlength sein, also müssen wir sie etwas kürzer schneiden, um Platz für die Auslassungspunkte zu schaffen.

Beachten Sie, dass es tatsächlich ein einziges Unicode-Zeichen für Auslassungspunkte gibt. Das sind keine drei Punkte.

 Funktion truncate(str, maxlength) {
  return (str.length > maxlength) ?
    str.slice(0, maxlength - 1) + '…' : str;
}

Öffnen Sie die Lösung mit Tests in einer Sandbox.

Extrahieren Sie das Geld

Wichtigkeit: 4

Wir haben einen Kostenvoranschlag in der Form "$120" . Das heißt: Zuerst kommt das Dollarzeichen und dann die Zahl.

Erstellen Sie eine Funktion extractCurrencyValue(str) die den numerischen Wert aus einer solchen Zeichenfolge extrahiert und zurückgibt.

Das Beispiel:

 alarm( extractCurrencyValue('$120') === 120 ); // WAHR

Öffnen Sie eine Sandbox mit Tests.

Lösung

 Funktion extractCurrencyValue(str) {
  return +str.slice(1);
}

Öffnen Sie die Lösung mit Tests in einer Sandbox.