Zusammenfassung von 28 gängigen JavaScript-String-Methoden und Verwendungstipps

Vorwort

Sehen wir uns heute einige JavaScript-Grundlagen an. Die Grundlagen sind so wichtig. Ich erinnere mich noch genau daran, dass mich bei der Frühjahrsrekrutierung dieses Jahres ein Interviewer eines großen Unternehmens verspottete, weil ich mir die JavaScript-API nicht merken konnte 🤣 Es war so peinlich. Der Hauptgrund war, dass ich sie zu wenig verwendete, also muss ich sie noch mehr verwenden und in meinem täglichen Leben mehr ansammeln. Heute werden wir uns einige häufig verwendete String-Methoden in JavaScript ansehen! Der Artikel enthält viel Inhalt, daher wird empfohlen, dass Sie ihn vor dem Studium sammeln!

1. Ermitteln Sie die Länge einer Zeichenfolge

Zeichenfolgen in JavaScript verfügen über eine Längeneigenschaft, mit der die Länge der Zeichenfolge ermittelt werden kann:
const str = "hallo";
str.length // Ausgabe: 5

2. Holen Sie sich den Wert an der angegebenen Position der Zeichenfolge

Sowohl die Methode charAt() als auch die Methode charCodeAt() können den Wert an einer angegebenen Position per Index abrufen:

• Die Methode charAt() ruft das Zeichen an der angegebenen Position ab.
• Die Methode charCodeAt() ruft den Unicode-Wert des als Wert angegebenen Zeichens ab.

(1) charAt()

Die Methode charAt() gibt das Zeichen an der angegebenen Position zurück. Die Syntax lautet wie folgt:

Zeichenfolge.charAt(index)

Index stellt den Indexwert des Zeichens in der Zeichenfolge dar:

const str = "hallo";
str.charAt(1) // Ausgabe: e 

Wir wissen, dass Zeichenfolgen entsprechende Zeichen auch direkt über Indexwerte erhalten können. Was ist also der Unterschied zwischen diesem und charAt()? Schauen wir uns ein Beispiel an:

const str = "hallo";
str.charAt(1) // Ausgabe: e 
str[1] // Ausgabe: e 
str.charAt(5) // Ausgabe: '' 
str[5] // Ausgabe: undefiniert

Es ist ersichtlich, dass, wenn der Wert des Index nicht innerhalb des Längenbereichs von str liegt, str[index] „undefiniert“ zurückgibt, während charAt(index) eine leere Zeichenfolge zurückgibt; außerdem ist str[index] nicht mit ie6-ie8 kompatibel, während charAt(index) kompatibel ist.

(2) charCodeAt()

charCodeAt(): Diese Methode gibt den Unicode-Wert des Zeichens am angegebenen Index zurück. Der Rückgabewert ist eine Ganzzahl zwischen 0 und 65535, die die UTF-16-Codeeinheit am angegebenen Index darstellt. Wenn sich an der angegebenen Position kein Zeichen befindet, wird NaN zurückgegeben:

lass str = "abcdefg";
console.log(str.charCodeAt(1)); // "b" --> 98

Mit dieser Methode können Zeichen in einem angegebenen Unicode-Kodierungswertebereich in einer Zeichenfolge abgerufen werden. Beispielsweise ist der Unicode-Kodierungsbereich der Zahlen 0 bis 9: 48 bis 57. Sie können diese Methode verwenden, um Zahlen in einer Zeichenfolge zu filtern. Wenn Sie mit regulären Ausdrücken besser vertraut sind, ist dies natürlich bequemer.

3. Überprüfen Sie, ob eine Zeichenfolge eine bestimmte Sequenz enthält

Mit diesen fünf Methoden kann ermittelt werden, ob eine Zeichenfolge eine bestimmte Sequenz enthält. Die ersten beiden Methoden erhalten den Indexwert des angegebenen Elements und geben nur die Position des ersten übereinstimmenden Werts zurück. Die letzten drei Methoden geben einen Booleschen Wert zurück, der angibt, ob der angegebene Wert übereinstimmt.

Hinweis: Bei diesen 5 Methoden wird zwischen Groß- und Kleinschreibung unterschieden!

(1) indexVon()

indexOf(): Sucht nach einem Zeichen und gibt die erste passende Position zurück, wenn sie gefunden wird, andernfalls -1. Die Syntax lautet wie folgt:

string.indexOf(Suchwert,Vonindex)

Diese Methode verwendet zwei Parameter:

• Suchwert: erforderlich, gibt den zu suchenden Zeichenfolgenwert an;
• Fromindex: Ein optionaler Ganzzahlparameter, der die Position in der Zeichenfolge angibt, an der die Suche beginnt. Seine zulässigen Werte sind 0 bis string.length – 1. Wenn es weggelassen wird, beginnt die Suche beim ersten Zeichen der Zeichenfolge.

lass str = "abcdefgabc";
console.log(str.indexOf("a")); // Ausgabe: 0
console.log(str.indexOf("z")); // Ausgabe: -1
console.log(str.indexOf("c", 4)) // Ausgabe: 9

(2) letzterIndexVon()

lastIndexOf(): Sucht nach einem Zeichen und gibt die Position der letzten Übereinstimmung zurück, falls es eine gibt, andernfalls wird -1 zurückgegeben.

lass str = "abcabc";
console.log(str.lastIndexOf("a")); // Ausgabe: 3
console.log(str.lastIndexOf("z")); // Ausgabe: -1

Diese Methode ähnelt indexOf(), aber die Suchreihenfolge ist anders. indexOf() sucht in positiver Reihenfolge, während lastIndexOf() in umgekehrter Reihenfolge sucht.

(3) beinhaltet()

includes(): Mit dieser Methode wird ermittelt, ob eine Zeichenfolge eine angegebene Teilzeichenfolge enthält. Gibt „true“ zurück, wenn eine passende Zeichenfolge gefunden wird, andernfalls „false“. Die Syntax dieser Methode lautet wie folgt:

string.includes(Suchwert, Start)

Diese Methode verwendet zwei Parameter:

• Suchwert: erforderlich, die zu suchende Zeichenfolge;
• Start: Optional, legen Sie die Position fest, an der die Suche beginnen soll, der Standardwert ist 0.

let str = 'Hallo Welt!';

str.includes('o') // Ausgabe: true
str.includes('z') // Ausgabe: false
str.includes('e', 2) // Ausgabe: false

(4) beginntMit()

startsWith(): Mit dieser Methode wird erkannt, ob eine Zeichenfolge mit einer angegebenen Teilzeichenfolge beginnt. Gibt „true“ zurück, wenn es mit der angegebenen Teilzeichenfolge beginnt, andernfalls „false“. Die Syntax ist dieselbe wie für die Methode „includes()“ oben.

let str = 'Hallo Welt!';

str.startsWith('Hallo') // Ausgabe: true
str.startsWith('Helle') // Ausgabe: false
str.startsWith('wo', 6) // Ausgabe: true

(5) endet mit()

endsWith(): Mit dieser Methode wird bestimmt, ob die aktuelle Zeichenfolge mit der angegebenen Teilzeichenfolge endet. Gibt „true“ zurück, wenn sich die übergebene Teilzeichenfolge am Ende der Suchzeichenfolge befindet, andernfalls „false“. Die Syntax lautet wie folgt:

string.endsWith(Suchwert, Länge)

Diese Methode verwendet zwei Parameter:

• Suchwert: erforderlich, die zu suchende Teilzeichenfolge;
• Länge: Legt die Länge der Zeichenfolge fest. Der Standardwert ist die ursprüngliche Zeichenfolgenlänge string.length.

let str = 'Hallo Welt!';

str.endsWith('!') // Ausgabe: true
str.endsWith('llo') // Ausgabe: false
str.endsWith('llo', 5) // Ausgabe: true

Wie Sie sehen, wird die Suche ab den ersten 5 Zeichen der Zeichenfolge durchgeführt, wenn der zweite Parameter auf 5 gesetzt ist, sodass „true“ zurückgegeben wird.

4. Mehrere Zeichenfolgen verketten

Die Methode concat() wird zum Verketten von zwei oder mehr Zeichenfolgen verwendet. Diese Methode ändert die ursprüngliche Zeichenfolge nicht, sondern gibt eine neue Zeichenfolge zurück, die zwei oder mehr Zeichenfolgen verkettet. Die Syntax lautet wie folgt:

Zeichenfolge.concat(Zeichenfolge1, Zeichenfolge2, ..., ZeichenfolgeX)

Die Parameter string1, string2, ..., stringX sind erforderlich und stellen ein oder mehrere String-Objekte dar, die zu einem String verkettet werden.

lass str = "abc";
console.log(str.concat("efg")); //Ausgabe: "abcefg"
console.log(str.concat("efg","hijk")); //Ausgabe: "abcefghijk"

Obwohl die Methode concat() speziell zum Verketten von Zeichenfolgen verwendet wird, wird in der Entwicklung am häufigsten der Additionsoperator + verwendet, da er einfacher ist.

5. Teilen Sie einen String in ein Array auf

Mit der Methode split() wird ein String in ein String-Array aufgeteilt. Diese Methode ändert die ursprüngliche Zeichenfolge nicht. Die Syntax lautet wie folgt:

string.split(Trennzeichen,Grenzwert)

Diese Methode verwendet zwei Parameter:

• Trennzeichen: erforderlich. Eine Zeichenfolge oder ein regulärer Ausdruck, der die Zeichenfolge an der angegebenen Stelle teilt.
• Limit: Optional. Dieser Parameter gibt die maximale Länge des zurückgegebenen Arrays an. Wenn dieser Parameter gesetzt ist, werden nicht mehr Teilzeichenfolgen zurückgegeben als das durch diesen Parameter angegebene Array. Wenn dieser Parameter nicht gesetzt ist, wird die gesamte Zeichenfolge unabhängig von ihrer Länge aufgeteilt.

lass str = "abcdef";
str.split("c"); // Ausgabe: ["ab", "def"]
str.split("", 4) // Ausgabe: ['a', 'b', 'c', 'd'] 

Wenn eine leere Zeichenfolge als Trennzeichen verwendet wird, werden alle Zeichen in der Zeichenfolge getrennt.

str.split(""); // Ausgabe: ["a", "b", "c", "d", "e", "f"]

Tatsächlich können Sie beim Aufteilen eines Strings in ein Array mehrere Trennzeichen gleichzeitig aufteilen. Dies lässt sich mithilfe regulärer Ausdrücke erreichen:

const list = "Äpfel, Bananen; Kirschen"
const Früchte = Liste.split(/[,;]/)
console.log(Früchte); // Ausgabe: ["Äpfel", "Bananen", "Kirschen"]

6. Abfangen einer Zeichenfolge

Die Methoden substr(), substring() und slice() können alle zum Extrahieren von Zeichenfolgen verwendet werden.

(1) Scheibe ()

Mit der Methode slice() wird ein Teil einer Zeichenfolge extrahiert und der extrahierte Teil als neue Zeichenfolge zurückgegeben. Die Syntax lautet wie folgt:

Zeichenfolge.Slice(Start, Ende)

Diese Methode verwendet zwei Parameter:

• Start: Erforderlich. Der Startindex des abzufangenden Fragments, wobei die erste Zeichenposition 0 ist. Handelt es sich um eine negative Zahl, wird sie am Ende abgeschnitten.
• Ende: Optional. Der Index des Endes des abzuschneidenden Segments. Wenn dieser Parameter nicht angegeben ist, umfasst die zu extrahierende Teilzeichenfolge die Zeichenfolge vom Anfang bis zum Ende der ursprünglichen Zeichenfolge. Wenn dieser Parameter negativ ist, gibt er die Position vom Ende der Zeichenfolge an.

Wenn „Start“ eine negative Zahl ist, gibt der Parameter, wie oben erwähnt, die Position beginnend am Ende der Zeichenfolge an. Das heißt, -1 bezieht sich auf das letzte Zeichen der Zeichenfolge, -2 auf das vorletzte Zeichen und so weiter:

lass str = "abcdef";
str.slice(1,6); // Ausgabe: "bcdef" 
str.slice(1); // Ausgabe: "bcdefg" 
str.slice(); // Ausgabe: "abcdefg" 
str.slice(-2); // Ausgabe: "fg"
str.slice(6, 1); // Ausgabe: ""

Beachten Sie, dass diese Methode die Teilzeichenfolge einschließlich der Startzeichen, jedoch nicht der Endzeichen zurückgibt.

(2) substr()

Mit der Methode substr() wird eine bestimmte Anzahl von Zeichen aus einer Zeichenfolge extrahiert, beginnend mit dem Startindex. Die Syntax lautet wie folgt:

string.substr(Start,Länge)

Diese Methode verwendet zwei Parameter:

• Start erforderlich. Der Startindex der zu extrahierenden Teilzeichenfolge. Muss ein numerischer Wert sein. Wenn der Parameter negativ ist, gibt er die Position vom Ende der Zeichenfolge an. Das heißt, -1 bezieht sich auf das letzte Zeichen in der Zeichenfolge, -2 auf das vorletzte Zeichen und so weiter.
• Länge: optional. Die Anzahl der Zeichen in der Teilzeichenfolge. Muss ein numerischer Wert sein. Wenn dieser Parameter weggelassen wird, wird die Zeichenfolge von der Startposition bis zum Ende des Zeichenfolgenobjekts zurückgegeben.

lass str = "abcdef";
str.substr(1,6); // Ausgabe: "bcdefg" 
str.substr(1); // Ausgabe: "bcdefg" ist gleichbedeutend mit intercepting [1, str.length-1]
str.substr(); // Ausgabe: "abcdefg" ist gleichbedeutend mit intercepting [0, str.length-1]
str.substr(-1); // Ausgabe: "g"

(3) Teilzeichenfolge()

Die Methode substring() wird verwendet, um Zeichen aus einer Zeichenfolge zwischen zwei angegebenen Indizes zu extrahieren. Die Syntax lautet wie folgt:

Zeichenfolge.Teilzeichenfolge(von, bis)

Diese Methode verwendet zwei Parameter:

• von: erforderlich. Eine nicht negative Ganzzahl, die die Position des ersten Zeichens der zu extrahierenden Teilzeichenfolge in der Zeichenfolge angibt.
• bis: Optional. Eine nicht negative Ganzzahl, die um eins größer ist als die Position des letzten Zeichens der zu extrahierenden Teilzeichenfolge in der Zeichenfolge. Wenn dieser Parameter weggelassen wird, endet die zurückgegebene Teilzeichenfolge am Ende der Zeichenfolge.

Hinweis: Wenn die Parameter „von“ und „bis“ gleich sind, gibt diese Methode eine leere Zeichenfolge zurück (d. h. eine Zeichenfolge der Länge 0). Wenn „von“ größer als „bis“ ist, vertauscht die Methode die beiden Parameter, bevor die Teilzeichenfolge extrahiert wird. Und diese Methode akzeptiert keine negativen Parameter. Wenn der Parameter eine negative Zahl ist, wird die Zeichenfolge zurückgegeben.

lass str = "abcdef";
str.substring(1,6); // Ausgabe: "bcdef" [1,6)
str.substring(1); // Ausgabe: "bcdefg" [1,str.length-1]
str.substring(); // Ausgabe: "abcdefg" [0,str.length-1]
str.substring(6,1); // Ausgabeergebnis "bcdef" [1,6)
str.substring(-1); // Ausgabe: "abcdefg"

Beachten Sie, dass diese Methode die Teilzeichenfolge einschließlich der Startzeichen, jedoch nicht der Endzeichen zurückgibt.

7. Konvertierung von Zeichenfolgen

Mit den Methoden toLowerCase() und toUpperCase() kann die Groß-/Kleinschreibung einer Zeichenfolge konvertiert werden.

(1) toLowerCase()

toLowerCase(): Diese Methode wird verwendet, um eine Zeichenfolge in Kleinbuchstaben umzuwandeln.
let str = "adABDndj";
str.toLowerCase(); // Ausgabe: "adabdndj"

(2) toUpperCase()

toUpperCase(): Mit dieser Methode wird eine Zeichenfolge in Großbuchstaben umgewandelt.

let str = "adABDndj";
str.toUpperCase(); // Ausgabe: "ADABDNDJ"

Mit dieser Methode können wir den ersten Buchstaben einer Zeichenfolge groß schreiben:

lass Wort = "Apfel"
Wort = Wort[0].toUpperCase() + Wort.substr(1)
console.log(word) // Ausgabe: „Apple“

8. Zeichenfolgenmustervergleich

Mit den Methoden replace(), match() und search() können Zeichen abgeglichen oder ersetzt werden.

(1) ersetzen()

replace(): Diese Methode wird verwendet, um einige Zeichen in einer Zeichenfolge durch andere Zeichen zu ersetzen oder eine Teilzeichenfolge zu ersetzen, die einem regulären Ausdruck entspricht. Die Syntax lautet wie folgt:

string.replace(Suchwert, neuerWert)

Diese Methode verwendet zwei Parameter:

• Suchwert: erforderlich. Ein RegExp-Objekt, das die zu ersetzende Teilzeichenfolge oder das zu ersetzende Muster angibt. Wenn der Wert eine Zeichenfolge ist, wird er als wörtliches Textmuster behandelt, das abgerufen werden soll, statt zuerst in ein RegExp-Objekt konvertiert zu werden.
• neuer Wert: erforderlich. Ein Zeichenfolgenwert. Gibt Ersatztext oder eine Funktion an, die Ersatztext generiert.

lass str = "abcdef";
str.replace("c", "z") // Ausgabe: abzdef

Führen Sie einen globalen Ersetzungsvorgang durch und beachten Sie dabei die Groß-/Kleinschreibung:

let str="Mr. Blue hat ein blaues Haus und ein blaues Auto";
str.replace(/blue/gi, "red"); // Ausgabe: 'Mr. Red hat ein rotes Haus und ein rotes Auto'

Hinweis: Wenn der reguläre Ausdruck das globale Flag „g“ hat, ersetzt die Methode „replace()“ alle übereinstimmenden Teilzeichenfolgen. Andernfalls wird nur die erste passende Teilzeichenfolge ersetzt.

(2) Übereinstimmung()

match(): Diese Methode wird verwendet, um nach einem angegebenen Wert innerhalb einer Zeichenfolge zu suchen oder eine Übereinstimmung für einen oder mehrere reguläre Ausdrücke zu finden. Diese Methode ähnelt indexOf() und lastIndexOf(), gibt jedoch den angegebenen Wert anstelle der Position in der Zeichenfolge zurück. Die Syntax lautet wie folgt:

Zeichenfolge.Übereinstimmung(regulärer Ausdruck)

Der Regexp-Parameter dieser Methode ist erforderlich und gibt das RegExp-Objekt des abzugleichenden Musters an. Wenn der Parameter kein RegExp-Objekt ist, müssen Sie ihn zuerst an den RegExp-Konstruktor übergeben, um ihn in ein RegExp-Objekt zu konvertieren.

Hinweis: Diese Methode gibt ein Array mit den übereinstimmenden Ergebnissen zurück. Der Inhalt dieses Arrays hängt davon ab, ob der reguläre Ausdruck das globale Flag g hat.

lass str = "abcdef";
console.log(str.match("c")) // ["c", Index: 2, Eingabe: "abcdef", Gruppen: undefiniert]

(3) Suche()

Mit der Methode search() können Sie in einer Zeichenfolge nach einer angegebenen Teilzeichenfolge suchen oder nach einer Teilzeichenfolge suchen, die einem regulären Ausdruck entspricht. Die Syntax lautet wie folgt:

string.search(Suchwert)

Der Parameter regex dieser Methode kann die im String zu suchende Teilzeichenfolge oder das zu suchende RegExp-Objekt sein.

Hinweis: Um eine Suche ohne Berücksichtigung der Groß-/Kleinschreibung durchzuführen, hängen Sie das Flag „i“ an. Diese Methode führt kein globales Matching durch und ignoriert das Flag g, d. h., es wird nur das Ergebnis des ersten erfolgreichen Matches zurückgegeben. Wenn keine passende Teilzeichenfolge gefunden wird, wird -1 zurückgegeben.

Rückgabewert: Gibt die Startposition der ersten Teilzeichenfolge in str zurück, die mit dem regulären Ausdruck übereinstimmt.

lass str = "abcdef";
str.search(/bcd/) // Ausgabe: 1

9. Entfernen Sie nachstehende Leerzeichen aus einer Zeichenfolge

Mit den Methoden trim(), trimStart() und trimEnd() können führende und nachfolgende Leerzeichen aus einer Zeichenfolge entfernt werden. Zu den Leerzeichen zählen Leerzeichen, Tabulatoren, Zeilenumbrüche und andere Leerzeichen.

(1) trimmen()

Mit der Methode trim() werden führende und nachfolgende Leerzeichen aus einer Zeichenfolge entfernt. Diese Methode ändert die ursprüngliche Zeichenfolge nicht:

lass str = " abcdef "
str.trim() // Ausgabe: "abcdef"

Beachten Sie, dass diese Methode nicht auf die Typen Null, undefiniert und Zahlen anwendbar ist.

(2) trimStart()

Die Methode trimStart() verhält sich genauso wie trim(), gibt aber einen neuen String zurück, bei dem die Leerzeichen am Anfang des Originalstrings entfernt wurden, ohne den Originalstring zu ändern:

Konstante s = "abc";

s.trimStart() // "abc "

(3) trimEnd()

Die Methode trimEnd() verhält sich genauso wie trim(), gibt aber einen neuen String zurück, bei dem die Leerzeichen am Ende des Originalstrings entfernt wurden, ohne den Originalstring zu ändern:

Konstante s = "abc";

s.trimEnd() // " abc"

10. Holen Sie sich die Zeichenfolge selbst

Sowohl die Methode valueOf() als auch die Methode toString() geben den Wert der Zeichenfolge selbst zurück, was wenig nützlich zu sein scheint.

(1) Wert von ()

valueOf(): Gibt den primitiven Wert eines String-Objekts zurück. Diese Methode wird normalerweise automatisch von JavaScript aufgerufen und nicht explizit in Ihrem Code.

lass str = "abcdef"
console.log(str.valueOf()) // "abcdef"

(2) toString()

toString(): Gibt das String-Objekt selbst zurück

lass str = "abcdef"
Konsole.log(str.toString()) // "abcdef"

11. Wiederholen Sie eine Zeichenfolge

Die Methode repeat() gibt einen neuen String zurück, was bedeutet, dass der ursprüngliche String n-mal wiederholt wird:

'x'.repeat(3) // Ausgabe: "xxx"
'hallo'.repeat(2) // Ausgabe: "hallohallo"
'na'.repeat(0) // Ausgabe: ""

Wenn das Argument eine Dezimalzahl ist, wird es abgerundet:

'na'.repeat(2.9) // Ausgabe: "nana"

Wenn der Parameter eine negative Zahl oder Unendlich ist, wird ein Fehler gemeldet:

'na'.repeat(Unendlich) // Bereichsfehler
'na'.repeat(-1) // Bereichsfehler

Wenn das Argument eine Dezimalzahl zwischen 0 und -1 ist, ist es gleichbedeutend mit 0, da zuerst gerundet wird. Eine Dezimalzahl zwischen 0 und -1, die auf -0 gerundet wird und bei Wiederholung als 0 gilt.

'na'.repeat(-0.9) // Ausgabe: ""

Wenn das Argument NaN ist, ist es gleichwertig mit 0:

'na'.repeat(NaN) // Ausgabe: ""

Wenn das zu wiederholende Argument eine Zeichenfolge ist, wird es zuerst in eine Zahl umgewandelt.

'na'.repeat('na') // Ausgabe: ""
'na'.repeat('3') // Ausgabe: "nanana"

12. Auffüllen der Zeichenfolgenlänge

Die Methoden padStart() und padEnd() werden verwendet, um die Länge der Zeichenfolge aufzufüllen. Wenn eine Zeichenfolge nicht die angegebene Länge hat, wird sie am Anfang oder Ende aufgefüllt.

(1) padStart()

padStart() wird zur Header-Vervollständigung verwendet. Diese Methode hat zwei Parameter. Der erste Parameter ist eine Zahl, die die Länge der Zeichenfolge nach dem Auffüllen angibt. Der zweite Parameter ist die Zeichenfolge, die zum Auffüllen verwendet wird.​

Wenn die Länge der ursprünglichen Zeichenfolge gleich oder größer als die angegebene Mindestlänge ist, wird die ursprüngliche Zeichenfolge zurückgegeben:

'x'.padStart(1, 'ab') // 'x'

Überschreitet die Summe der Längen des zur Vervollständigung verwendeten Strings und des Originalstrings die angegebene Mindestlänge, werden die überzähligen Ziffern im Vervollständigungsstring abgeschnitten:

'x'.padStart(5, 'ab') // 'ababx'
'x'.padStart(4, 'ab') // 'abax'

Wenn das zweite Argument weggelassen wird, wird die Länge standardmäßig durch Leerzeichen vervollständigt:

'x'.padStart(4, 'ab') // 'ein '

Eine häufige Verwendung von padStart() besteht darin, einen Wert auf eine bestimmte Anzahl von Ziffern aufzufüllen. Eine der Anforderungen, die ich kürzlich gestellt habe, besteht darin, die zurückgegebene Seitenzahl auf drei Ziffern aufzufüllen. Beispielsweise wird Seite 1 als 001 angezeigt. Mit dieser Methode können Sie Folgendes tun:

"1".padStart(3, '0') // Ausgabe: '001'
"15".padStart(3, '0') // Ausgabe: '015'

(2) padEnd()

padEnd() wird zur Endvervollständigung verwendet. Diese Methode akzeptiert auch zwei Parameter. Der erste Parameter ist die maximale Länge der Zeichenfolgenvervollständigung, damit sie wirksam wird, und der zweite Parameter ist die Zeichenfolge, die für die Vervollständigung verwendet wird:

'x'.padEnd(5, 'ab') // 'xabab'
'x'.padEnd(4, 'ab') // 'xaba'

13. Konvertieren Sie eine Zeichenfolge in eine Zahl

Sowohl die Methode parseInt() als auch die Methode parseFloat() werden verwendet, um Zeichenfolgen in Zahlen umzuwandeln.

(1) parseInt()

Die Methode parseInt() wird verwendet, um eine Zeichenfolge zu analysieren und eine Ganzzahl zurückzugeben. Die Syntax lautet wie folgt:

parseInt(Zeichenfolge, Basis)

Diese Methode verwendet zwei Parameter:

• Zeichenfolge: erforderlich. Die zu analysierende Zeichenfolge.
• Basis: Optional. Gibt die Basis der zu analysierenden Zahl an. Der Wert liegt zwischen 2 und 36.

Wenn der Wert des Radix-Parameters 0 ist oder nicht festgelegt ist, bestimmt parseInt() die Basis der Zahl basierend auf der Zeichenfolge.

parseInt("10"); // Ausgabe: 10
parseInt("17",8); // Ausgabe: 15 (8+7)
parseInt("010"); // Ausgabe: 10 oder 8

Wenn der Wert des Radix-Parameters mit „0x“ oder „0X“ beginnt, ist die Basis 16:

parseInt("0x10") // Ausgabe: 16

Wenn das Argument kleiner als 2 oder größer als 36 ist, gibt parseInt() NaN zurück:

parseInt("50", 1) // Ausgabe: NaN
parseInt("50", 40) // Ausgabe: NaN

Es wird nur die erste Ziffer in der Zeichenfolge zurückgegeben, bis das erste Zeichen gefunden wird, das keine Ziffer ist:

parseInt("40 4years") // Ausgabe: 40

Wenn das erste Zeichen der Zeichenfolge nicht in eine Zahl umgewandelt werden kann, wird NaN zurückgegeben:

parseInt("new100") // Ausgabe: NaN

Führende und nachfolgende Leerzeichen sind zulässig:

parseInt(" 60 ") // Ausgabe: 60

(2) parseFloat()

Die Methode parseFloat() analysiert einen String und gibt eine Gleitkommazahl zurück. Diese Methode gibt an, ob das erste Zeichen in einer Zeichenfolge eine Ziffer ist. Wenn dies der Fall ist, wird die Zeichenfolge analysiert, bis das Ende der Zahl erreicht ist, und die Zahl wird als Zahl und nicht als Zeichenfolge zurückgegeben. Die Syntax lautet wie folgt:

parseFloat(Zeichenfolge)

parseFloat analysiert sein String-Argument in eine Gleitkommazahl und gibt es zurück. Wenn es beim Parsen auf ein beliebiges Zeichen stößt, das kein Vorzeichen (+ oder -), keine Zahl (0-9), kein Dezimalkomma und kein Exponent (e oder E) in wissenschaftlicher Notation ist, ignoriert es dieses Zeichen und alle nachfolgenden Zeichen und gibt die Gleitkommazahl zurück, die bisher analysiert wurde. Außerdem werden führende Leerzeichen in der Argumentzeichenfolge ignoriert.

parseFloat("10.00") // Ausgabe: 10.00
parseFloat("10.01") // Ausgabe: 10.01
parseFloat("-10.01") // Ausgabe: -10.01
parseFloat("40,5 Jahre") // Ausgabe: 40,5

Wenn das erste Zeichen der Argumentzeichenfolge nicht als Zahl analysiert werden kann, gibt parseFloat NaN zurück.

parseFloat("new40.5") // Ausgabe: NaN

Zusammenfassen

Damit ist dieser Artikel über häufig verwendete String-Methoden und Verwendungstipps in JavaScript abgeschlossen. Weitere häufig verwendete String-Methoden und Tipps zu JS finden Sie in den vorherigen Artikeln von 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, dass jeder 123WORDPRESS.COM in Zukunft unterstützen wird!