Detaillierte Erklärung der Javascript-String-Methoden

Zeichenfolgenlänge: Länge

Holen Sie sich den Wert an einer bestimmten Position in einer Zeichenfolge

charAt()

Rückgabewert

str.charAt(2) // c
str[2] // c
str.charAt(30) // ''
str[30] // undefiniert

Wenn der Wert von index nicht innerhalb des Längenbereichs von str liegt, gibt str[index] „undefined“ zurück und charAt(index) gibt eine leere Zeichenfolge zurück.

Hinweis: str[index] ist nicht mit ie6-ie8 kompatibel, aber charAt(index) ist kompatibel.

charCodeAt()

Holen Sie sich den Unicode-Wert des Zeichens an der String-Indexposition

str.charAt(2) // c
str[2] // c
str.charAt(30) // ''
str[30] // undefiniert

Überprüfen, ob eine Zeichenfolge einen Wert enthält

indexOf()

Suche nach einem Zeichen und gib die Indexposition der ersten Übereinstimmung zurück, falls gefunden , andernfalls gib -1 zurück, Suche in positiver Reihenfolge:

str.indexOf('e')
// 4 Indexposition str.indexOf('e',5)
// -1

Syntax: string.indexOf(value,startIndex)

Wert: erforderlich, gibt den abzurufenden Zeichenfolgenwert an;

startIndex: Ein optionaler ganzzahliger Parameter mit einem Standardwert von 0, der die Startposition für die Suche in positiver Reihenfolge darstellt. Der zulässige Wert liegt zwischen 0 und string.length - 1.

letzterIndexVon()

Suche nach einem Zeichen, gib die letzte passende Position zurück, falls gefunden, andernfalls gib -1 zurück, entgegengesetzt zu indexOf, Suche in umgekehrter Reihenfolge:

str.lastIndexOf('e')
// 10
str.lastIndexOf('e',8) // Suche in umgekehrter Reihenfolge nach e innerhalb des Index 0-8
// 4
str.lastIndexOf('e',3) // Suche in umgekehrter Reihenfolge nach e innerhalb der Indizes 0-3
// -1

Syntax: string.lastIndexOf(value,startIndex)

Wert: erforderlich, gibt den abzurufenden Zeichenfolgenwert an;

startIndex: Ein optionaler Integer-Parameter, der Standardwert ist string.length – 1, der verwendet wird, um die Startindexposition in umgekehrter Reihenfolge zu suchen. Der zulässige Wert liegt zwischen 0 und string.length - 1.

beinhaltet()

Bestimmt, ob eine Zeichenfolge eine angegebene Teilzeichenfolge enthält. Gibt „true“ zurück, wenn eine passende Zeichenfolge gefunden wird, andernfalls „false“.

str.includes('e') // wahr
str.includes('e',11) // falsch 

Syntax: string.includes(value, startIndex)

Wert: erforderlich, gibt den abzurufenden Zeichenfolgenwert an;

startIndex: Ein optionaler Ganzzahlparameter, der Standardwert ist 0 und die Suche beginnt an der Indexposition. Der zulässige Wert liegt zwischen 0 und string.length - 1.

beginntMit()

Mit dieser Methode wird festgestellt, ob eine Zeichenfolge mit einer angegebenen Teilzeichenfolge beginnt. Gibt „true“ zurück, wenn es mit der angegebenen Teilzeichenfolge beginnt, andernfalls „false“.

str.startsWith('ab') // true
str.startsWith('ef') // falsch
str.startsWith('ef',4) // wahr

Syntax: string.startsWith(value, startIndex)

Wert: erforderlich, gibt den abzurufenden Zeichenfolgenwert an;

startIndex: Ein optionaler Ganzzahlparameter, der Standardwert ist 0 und die Suche beginnt an der Indexposition. Der zulässige Wert liegt zwischen 0 und string.length - 1.

endetMit()

Mit dieser Methode wird ermittelt, 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“.

str.endsWith('ba') // wahr
str.endsWith('ef') // falsch
str.endsWith('ef',6) // wahr

Syntax: string.endsWith(value, length)

Wert: erforderlich, gibt den abzurufenden Zeichenfolgenwert an;

Länge: Die Länge der Teilzeichenfolge, der Standardwert ist die ursprüngliche Zeichenfolgenlänge string.length

Zeichenfolgenverkettung

Verkettung

Verkettet zwei oder mehr Zeichenfolgen. Diese Methode ändert die ursprüngliche Zeichenfolge nicht, sondern gibt eine neue Zeichenfolge zurück, die zwei oder mehr Zeichenfolgen verkettet.

sei a = "asdf"
sei b = '123'
sei s = a.concat(b)
sei s2 = a + b
Konsole(a,b,s,s2)
// 'asdf' '123' 'asdf123' 'asdf123'

Syntax: string.concat(string1, string2, ..., stringX)

​ Verkette string1, string2... stringX nach string

'+' Zeichen

Wie im obigen Kontaktbeispiel gezeigt, wird diese Methode im Allgemeinen verwendet, die einfach und effizient ist

Zeichenfolge in Array aufteilen

Teilt()

Teilen Sie eine Zeichenfolge in ein Zeichenfolgenarray auf. Diese Methode ändert die ursprüngliche Zeichenfolge nicht.

str.split('') // ["a", "b", "c", "d", "e", "f", "g", "h", "g", "f", "e", "d", "c", "b", "a"]
str.split('',4) // ["a", "b", "c", "d"]
str.split('',20) // ["a", "b", "c", "d", "e", "f", "g", "h", "g", "f", "e", "d", "c", "b", "a"]

Syntax: string.split(separator,limit)

Trennzeichen: erforderlich. Zeichenfolge oder regulärer Ausdruck, Zeichenfolge ab der durch diesen Parameter angegebenen Stelle teilen

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.

Abfangen einer Zeichenfolge

Scheibe()

Extrahiert einen Teil einer Zeichenfolge und gibt den extrahierten Teil als neue Zeichenfolge zurück.

str.slice(1,3) // bc
str.slice(-3,-1) // cb

Syntax: string.slice(start,end)

Start: Erforderlich. Der Startindex des zu extrahierenden Segments, mit dem ersten Zeichen an Position 0. Wenn es eine negative Zahl ist, 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, sollte Ende größer als Start und kleiner als 0 sein.

Die von dieser Methode zurückgegebene Teilzeichenfolge enthält die Zeichen am Anfang, jedoch nicht die Zeichen am Ende.

substr()

Wird verwendet, um eine angegebene Anzahl Zeichen aus einer Zeichenfolge zu extrahieren, beginnend mit dem Startindex.

str.substr(5) // fghgfedcba
str.substr(5,3) // fgh

Syntax: string.substr(start,length)

Start: Erforderlich. Der Startindex der zu extrahierenden Teilzeichenfolge. Muss ein numerischer Wert sein. Handelt es sich um eine negative Zahl, gibt der Parameter die Position beginnend am Ende der Zeichenfolge an. Es kann eine negative Zahl sein, die angibt, dass am Ende begonnen wird.

Länge: optional. Die Anzahl der Zeichen in der Teilzeichenfolge. Muss ein numerischer Wert sein. Wenn dieser Parameter weggelassen wird, wird die Zeichenfolge vom Anfang bis zum Ende der Zeichenfolge zurückgegeben.

Teilzeichenfolge()

Wird verwendet, um Zeichen zwischen zwei angegebenen Indizes in einer Zeichenfolge zu extrahieren.

str.substring(3,5) // de
str.substring(5,3) // de

Syntax: string.substring(start, end)

Start: Erforderlich. Eine nicht negative Ganzzahl, die die Position des ersten Zeichens der zu extrahierenden Teilzeichenfolge in der Zeichenfolge angibt.

Ende: 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.

Beachten:

Weder start noch end akzeptieren negative Zahlen. Die zurückgegebene Teilzeichenfolge enthält start, aber nicht end. Wenn start = end, wird eine leere Zeichenfolge zurückgegeben. Wenn start < end, vertauscht die Methode die beiden Parameter automatisch.

Konvertierung von Zeichenfolgen

toLowerCase()

Wandelt eine Zeichenfolge in Kleinbuchstaben um.

sei t = 'AXC'
t.toLowerCase() // axc

toUpperCase()

Wandelt eine Zeichenfolge in Großbuchstaben um.

str.toUpperCase() // ABCDEFGHGFEDCBA

Zeichenfolgenmusterabgleich

ersetzen()

Wird verwendet, um einige Zeichen in einer Zeichenfolge durch andere Zeichen zu ersetzen oder eine Teilzeichenfolge zu ersetzen, die einem regulären Ausdruck entspricht.

str.replace('b',11) // a11cdefghgfedcba
str.replace(/b/g,11) // a11cdefghgfedc11a g: bedeutet global, wenn nicht, wird das erste standardmäßig ersetzt, i: bedeutet Groß-/Kleinschreibung ignorieren

Syntax: string.replace(oldValue, newValue)

alterWert: 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.

neuerWert: erforderlich. Ein Zeichenfolgenwert. Gibt Ersatztext oder eine Funktion an, die Ersatztext generiert.

replaceAll()

Globaler Ersatz der replace()-Methode:

str.replace(/b/g,11) ist gleichwertig mit str.replaceAll('b',11)

übereinstimmen()

Wird verwendet, um nach einem angegebenen Wert innerhalb einer Zeichenfolge zu suchen oder um Übereinstimmungen 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.

str.match('ghg') // ["ghg", Index: 6, Eingabe: "abcdefghgfedcba", Gruppen: undefiniert]
str.match(/ghg/g) // ["ghg"]
str.match(/a/g) // ["ein", "ein"]
str.match(/t/g) // null

Syntax: string.match(regexp)

regexp Erforderlich; ein RegExp-Objekt, das das abzugleichende Muster angibt.

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.

suchen()

Wird verwendet, um nach einer angegebenen Teilzeichenfolge in einer Zeichenfolge zu suchen oder nach einer Teilzeichenfolge zu suchen, die einem regulären Ausdruck entspricht.

str.search(/ghg/) // 6
str.search(/a/) // 0
str.search(/a/g) // 0
str.search(/t/g) // -1

Syntax: string.search(value)

Regex kann eine in der Zeichenfolge zu suchende Teilzeichenfolge oder ein zu durchsuchendes RegExp-Objekt sein.

Beachten:

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. Gibt die Startposition der ersten Teilzeichenfolge in str zurück, die dem regulären Ausdruck entspricht.

Entfernen von Leerzeichen aus einer Zeichenfolge

trimmen()

Wird verwendet, um führende und nachfolgende Leerzeichen aus einer Zeichenfolge zu entfernen. Diese Methode ändert die ursprüngliche Zeichenfolge nicht. Diese Methode ist nicht auf die Typen Null, undefiniert und Zahlen anwendbar.

sei s = ' 123 '
s.trim() // '123'

trimStart()

Wird verwendet, um Leerzeichen am Anfang einer Zeichenfolge zu entfernen. Diese Methode ändert die ursprüngliche Zeichenfolge nicht.

sei s = ' 123 '
s.trimStart() // '123 '

trimEnd()

Wird verwendet, um das nachstehende Leerzeichen einer Zeichenfolge zu entfernen. Diese Methode ändert die ursprüngliche Zeichenfolge nicht.

sei s = ' 123 '
s.trimEnd() // '123'

Andere Typen werden in Zeichenfolgen umgewandelt

zuString()

Gilt für: Boolean , Array , Number

sei arr = [1,2,3]
sei num = 123
let bool = true
sei obj = {a:1}
arr.toString() // '1,2,3'
num.toString() // '123'
bool.toString() // 'wahr'
obj.toString() // '[Objekt Objekt]'

Syntax: notStr.toString()

Zeichenfolge()

Gilt für: Boolean , Array , Number

sei arr = [1,2,3]
sei num = 123
let bool = true
sei obj = {a:1}
Zeichenfolge (arr) // '1,2,3'
Zeichenfolge (Zahl) // '123'
String(bool) // 'wahr'
String(obj) // '[Objekt Objekt]'

Syntax: String(notStr)

Implizite Konvertierung

Nicht-Zeichenfolge + Zeichenfolge = Zeichenfolge. Konvertieren Sie zuerst den ursprünglichen Datentyp implizit in eine Zeichenfolge und fügen Sie dann die neue Zeichenfolge hinzu.

Gilt für: Boolean , Array , Number , null

sei arr = [1,2,3]
sei num = 123
let bool = true
sei obj = {a:1}
arr+'' // '1,2,3'
arr+'t' // '1,2,3t'
Zahl+'t' // '123t'
bool+'' // 'wahr'
obj+'' // '[Objekt Objekt]'
null+'' // 'null'

JSON.stringify()

Gilt für: Boolean , Array , Number , null , undefined

sei arr = [1,2,3]
sei num = 123
let bool = true
sei obj = {a:1}
JSON.stringify(arr) // '[1,2,3]' behält die Klammern [] bei
JSON.stringify(num) // '123'
JSON.stringify(bool) // "wahr"
JSON.stringify(obj) // '{"a":1}'
JSON.stringify(null) // 'null'
JSON.stringify(NaN) // 'null'

Wiederherstellen mit JSON.parse()

sei arr = [1,2,3]
sei num = 123
let bool = true
sei obj = {a:1}
JSON.parse(JSON.stringify(arr)) // [1,2,3]
JSON.parse(JSON.stringify(num)) // 123
JSON.parse(JSON.stringify(bool)) // wahr
JSON.parse(JSON.stringify(obj)) // {a:1}
JSON.parse(JSON.stringify(null)) // null
JSON.parse(JSON.stringify(NaN)) // null

Wiederholen einer Zeichenfolge

wiederholen()

Gibt eine neue Zeichenfolge zurück, was bedeutet, dass die ursprüngliche Zeichenfolge n-mal wiederholt wird.

'cv'.wiederholen(3) // 'cvcvcv'
'cv'.wiederholen(0) // ''
'cv'.wiederholen(2.6) // 'cvcv'
'cv'.wiederholen('3') // 'cvcvcv'
'cv'.wiederholen('3a') // ''

Syntax: string.repeat(number)

Nummer: Anzahl der Wiederholungen

Beachten:

Wenn es 0 ist, wird eine leere Teilzeichenfolge zurückgegeben. Wenn es auf die Ganzzahl einer negativen Zahl oder Unendlich abgerundet wird, wird ein Fehler gemeldet. Eine negative Dezimalzahl zwischen 0 und -1 oder NaN entspricht 0. Wenn die Zahl eine Zeichenfolge ist, wird sie zuerst in einen numerischen Typ konvertiert. Eine Zeichenfolge vom numerischen Typ wird automatisch in die entsprechende Zahl konvertiert und dann die Zeichenfolge vom nicht numerischen Typ wiederholt, die 0 entspricht.

Länge der Füllzeichenfolge

padStart()

Header-Vervollständigung

let t = 'mosowe'
t.padStart(1,'nb') // 'Mäuse'
t.padStart(10,'nb') // 'nbnbmosowe'
t.padStart(10,'') // 'müssen'
t.padStart(10) // 'Mäuse'

Syntax: string.padStart(length,str)

Länge: die Länge der Zeichenfolge nach dem Auffüllen

str: zu vervollständigender String

Beachten:

Wenn die Länge des Originalstrings gleich oder größer als die angegebene Mindestlänge ist, wird der Originalstring zurückgegeben. Überschreitet die Summe der Längen des zu vervollständigenden Strings und des Originalstrings die angegebene Mindestlänge, wird der vervollständigte String gekürzt, wenn der zweite Parameter weggelassen wird. Standardmäßig werden Leerzeichen zur Vervollständigung verwendet. Ist der zweite Parameter ein leerer String, wird keine Vervollständigung durchgeführt.

padEnd()

Ende der Vervollständigung, siehe padStart()

Konvertieren Sie eine Zeichenfolge in eine Zahl parseInt()

parseInt("10") // 10
parseInt("10.11") // 10
parseInt("16",8) // 14 = 8+6, in Oktal umwandeln parseInt("010") // 10. Einige Browser sollen 8 sein, aber ich habe es mit mehreren einheimischen Browsern versucht und sie waren alle 10.
parseInt("") // NaN
parseInt("unh") // NaN
parseInt("123tt") // 123
parseInt("tt123") // NaN

Syntax: parseInt(string, radix)

Zeichenfolge: erforderlich. Die zu analysierende Zeichenfolge

Basis: Optional. Gibt die Basis der zu analysierenden Zahl an. Der Wert reicht von 2 bis 36 und der Standardwert ist 10.

parseFloat()

In dezimale Gleitkommazahl umwandeln

parseFloat("10") // 10
parseFloat("10.11") // 10.11
parseFloat("10.11.11111") // 10.11
parseFloat("010") // 10
parseFloat("") // NaN
parseFloat("unh") // NaN
parseFloat("123tt") // 123
parseFloat("tt123") // NaN

Syntax: parseFloat(string)

JSON.parse()

JSON.parse("10") // 10
JSON.parse("10.11") // 10.11
JSON.parse("10.11.11111") // Fehler
JSON.parse("010") // Fehler
JSON.parse("") // Fehler
JSON.parse("unh") // Fehler
JSON.parse("123tt") // Fehler
JSON.parse("tt123") // Fehler

Syntax: JSON.parse(string)

Nummer()

Zahl('') // 0
Zahl('10') // 10
Nummer('010') // 10
Zahl('2.3') // 2.3
Zahl('2.3.3') // NaN
Zahl('2TT') // NaN
Zahl('TT2') // NaN

Syntax: Number(string)

Zusammenfassen

Dieser Artikel endet hier. Ich hoffe, er kann Ihnen helfen. Ich hoffe auch, dass Sie mehr Inhalt auf 123WORDPRESS.COM lesen können!