Der Unterschied zwischen substring(), substr() und Slice() in Javascript

Es gibt drei häufig verwendete Funktionen zum Abfangen von Zeichen in js: Slice(), Substring() und Substr(). Wir stellen Ihnen die Funktionen von Slice(), Substring() und Substr() beim Abfangen von Zeichen vor. Einige Verwendungen und Unterschiede.

stringObject.substring(start,stop)

wird verwendet, um die Zeichenfolge zwischen zwei Spezifikationen zu extrahieren die Zeichen zwischen den Indizes.

Start erforderlich. Eine nichtnegative Ganzzahl, die die Position des ersten Zeichens der zu extrahierenden Teilzeichenfolge in stringObject angibt.

Stopp ist optional. Eine nichtnegative Ganzzahl, die sich um eine Position im stringObject befindet, also um eins mehr als das letzte Zeichen der zu extrahierenden Teilzeichenfolge. Wenn dieser Parameter weggelassen wird, wird die zurückgegebene Teilzeichenfolge an das Ende der Zeichenfolge verschoben.

Start beginnt bei 0 und endet mit Stopp (ohne Stopp). Negative Parameter werden nicht akzeptiert.

stringObject.substr(start,length)

Kann die angegebene Anzahl von Zeichen beginnend mit dem Startindex in der Zeichenfolge extrahieren

Start Erforderlich. Der Startindex der zu extrahierenden Teilzeichenfolge. Muss ein numerischer Wert sein. Wenn dieser Parameter negativ ist, deklariert er die Position ab dem Ende der Zeichenfolge. Das heißt, -1 bezieht sich auf das letzte Zeichen in der Zeichenfolge, -2 bezieht sich 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 vom Anfang bis zum Ende von stringObject zurückgegeben.

stringObject.slice(start,end)

Extrahieren Sie einen bestimmten Teil der Zeichenfolge und geben Sie den extrahierten Teil als neuen Zeichenfolgenabschnitt zurück

start Der Startindex des zu extrahierenden Segments. Wenn es sich um eine negative Zahl handelt, gibt dieser Parameter die Position ab dem Ende der Zeichenfolge an. Das heißt, -1 bezieht sich auf das letzte Zeichen der Zeichenfolge, -2 bezieht sich auf das vorletzte Zeichen und so weiter.

end Der Index, der unmittelbar auf das Ende des zu extrahierenden Segments folgt. 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.

Gibt die neue Zeichenfolge einschließlich aller Zeichen von stringObject vom Anfang (einschließlich Start) bis zum Ende (ohne Ende) zurück

string.slice()
string.substring()
string.substr()
 
var stringValue = “hello world”;
alert(stringValue.slice(3));          //”lo world”
alert(stringValue.substring(3));      //”lo world”
alert(stringValue.substr(3));        //”lo world”
alert(stringValue.slice(3,7));         //”lo w”
alert(stringValue.substring(3,7));    //”lo w”
alert(stringValue.substr(3,7));       //”lo worl”

Wenn nur vorhanden Einer der drei Parameter n, der verbleibende String wird ab der n-ten Position zurückgegeben (die Position wird ab 0 berechnet)

Wenn es zwei Parameter n, m, Slice und Substring gibt, werden die zurückgegeben Zeichenfolge, die an der n-ten Position beginnt und an der m-ten Position endet (ohne die m-te Position), während substr m Zeichen zurückgibt, beginnend an der n-ten Position.

string.slice()
string.substring()
string.substr()
var stringValue = “hello world”;
alert(stringValue.slice(-3));          //”rld”
alert(stringValue.substring(-3));      //”hello world”
alert(stringValue.substr(-3));        //”rld”
alert(stringValue.slice(3,-4));         //”lo w”
alert(stringValue.substring(3,-4));    //”hel”
alert(stringValue.substr(3,-4));       //”"(空字符串)

Wenn der Parameter ein negativer Wert ist, fügt Slice den negativen Wert zur Zeichenfolgenlänge (string.length) hinzu und substr fügt den negativen Wert Eins hinzu Das Argument plus die Länge der Zeichenfolge wird in 0 konvertiert, und die Teilzeichenfolge konvertiert alle negativen Werte in 0.

Die JavaScript-Implementierung von IE hat ein Problem bei der Verarbeitung negativer Werte, die an die substr()-Methode übergeben werden, und gibt die ursprüngliche Zeichenfolge zurück.

Das Obige ist der gesamte Inhalt dieses Kapitels. Weitere verwandte Tutorials finden Sie unter JavaScript-Video-Tutorial!