Was ist der Unterschied zwischen String.slice und String.substring?

Weiß jemand, was der Unterschied zwischen diesen beiden Methoden ist?

String.prototype.slice
String.prototype.substring

slice()funktioniert wie substring()mit ein paar verschiedenen Verhaltensweisen.

Syntax: string.slice(start, stop);
Syntax: string.substring(start, stop);

Was sie gemeinsam haben:

1. Wenn startgleich stop: gibt eine leere Zeichenfolge zurück
2. Wenn stopweggelassen wird: Extrahiert Zeichen bis zum Ende der Zeichenfolge
3. Wenn eines der Argumente größer als die Länge der Zeichenfolge ist, wird stattdessen die Länge der Zeichenfolge verwendet.

Unterscheidungen von :substring()

1. Wenn start > stop, dann substringwerden diese beiden Argumente ausgetauscht.
2. Wenn eines der Argumente negativ ist oder ist NaN, wird es so behandelt, als ob es wäre 0.

Unterscheidungen von :slice()

1. Wenn start > stop, slice()wird die leere Zeichenkette zurück. ( "")
2. If startist negativ: Setzt char am Ende des Strings, genau wie substr()in Firefox. Dieses Verhalten wird sowohl in Firefox als auch in IE beobachtet.
3. Wenn stopnegativ: Setzt Stop auf: string.length – Math.abs(stop)(ursprünglicher Wert), außer bei 0 (also Math.max(0, string.length + stop)), wie in der ECMA-Spezifikation beschrieben .

Quelle: Rudimentäre Kunst der Programmierung und Entwicklung: Javascript: substr () vs substring ()

Hinweis: Wenn Sie es eilig haben und / oder nach einer kurzen Antwort suchen, scrollen Sie zum Ende der Antwort und lesen Sie die letzten beiden Zeilen. Wenn Sie es nicht eilig haben, lesen Sie das Ganze.


Lassen Sie mich zunächst die Fakten darlegen:

Syntax:
string.slice(start,end)
string.substr(start,length)
string.substring(start,end)
Anmerkung 1:slice()==substring()

Was es macht?
Die slice()Methode extrahiert Teile einer Zeichenfolge und gibt die extrahierten Teile in einer neuen Zeichenfolge zurück.
Die substr()Methode extrahiert Teile einer Zeichenfolge, beginnend mit dem Zeichen an der angegebenen Position, und gibt die angegebene Anzahl von Zeichen zurück.
Die substring()Methode extrahiert Teile einer Zeichenfolge und gibt die extrahierten Teile in einer neuen Zeichenfolge zurück.
Anmerkung 2:slice()==substring()

Ändert die ursprüngliche Zeichenfolge?
slice()Nicht
substr()nicht
substring()Nicht
Anmerkung # 3:slice()==substring()

Negative Zahlen als Argument verwenden:
slice()Wählt Zeichen ab dem Ende der Zeichenfolge aus.
substr()Wählt Zeichen ab dem Ende der Zeichenfolge aus.
substring()Funktion
3 wird nicht ausgeführt. Hinweis 3:slice()==substr()

Wenn das erste Argument größer als das zweite ist: Wird
slice()nicht ausgeführt,
substr()da das zweite Argument KEINE Position, sondern ein Längenwert ist. Es wird wie gewohnt ausgeführt, ohne Probleme
substring()werden die beiden Argumente ausgetauscht und wie gewohnt ausgeführt

Das erste Argument:
slice()Erforderlich, zeigt an: Startindex
substr()erforderlich, zeigt an: Startindex
substring()erforderlich, zeigt an: Startindex
Hinweis Nr. 4:slice()==substr()==substring()

das zweite Argument:
slice()Optional, Die Position (bis zu, aber nicht einschließlich), an der die Extraktion beendet werden soll
substr()Optional, Die Anzahl der zu extrahierenden Zeichen
substring()Optional, Die Position (bis zu, aber nicht einschließlich), an der die Extraktion beendet werden soll
Hinweis Nr. 5:slice()==substring()

Was ist, wenn das zweite Argument weggelassen wird?
slice()Wählt alle Zeichen von der Startposition bis zum Ende der Zeichenfolge aus.
substr()Wählt alle Zeichen von der Startposition bis zum Ende der Zeichenfolge aus.
substring()Wählt alle Zeichen von der Startposition bis zum Ende der Zeichenfolge aus.
Hinweis 6:slice()==substr()==substring()

Man kann also sagen, dass es einen Unterschied zwischen slice()und gibt substr(), während substring()es sich im Grunde um eine Kopie von handelt slice().

in Zusammenfassung:
Wenn Sie den Index (die Position) kennen, an dem Sie anhalten (aber NICHT einschließen), verwenden slice()
Sie, wenn Sie die Länge der zu extrahierenden Zeichen kennen substr().

Ben Nadel hat einen guten Artikel darüber geschrieben, er weist auf den Unterschied in den Parametern zu diesen Funktionen hin:

String.slice( begin [, end ] )
String.substring( from [, to ] )
String.substr( start [, length ] )

Er weist auch darauf hin, dass die zu schneidenden Parameter negativ auf die Zeichenfolge vom Ende verweisen. Teilstring und Substrat nicht.

Hier ist sein Artikel darüber.

Die eine Antwort ist in Ordnung, erfordert aber ein wenig Einlesen. Besonders mit der neuen Terminologie "Stop".

My Go - organisiert nach Unterschieden, um es zusätzlich zu der ersten Antwort von Daniel oben nützlich zu machen:

1) negative Indizes. Die Teilzeichenfolge erfordert positive Indizes und setzt einen negativen Index auf 0. Der negative Index von Slice bedeutet die Position vom Ende der Zeichenfolge.

"1234".substring(-2, -1) == "1234".substring(0,0) == ""
"1234".slice(-2, -1) == "1234".slice(2, 3) == "3"

2) Austausch von Indizes. Durch Teilzeichenfolge werden die Indizes neu angeordnet, sodass der erste Index kleiner oder gleich dem zweiten Index ist.

"1234".substring(3,2) == "1234".substring(2,3) == "3"
"1234".slice(3,2) == ""

--------------------------

Allgemeiner Kommentar - Ich finde es seltsam, dass der zweite Index die Position nach dem letzten Zeichen des Slice oder Teilstrings ist. Ich würde erwarten, dass "1234" .slice (2,2) "3" zurückgibt. Dies macht Andys Verwirrung oben gerechtfertigt - ich würde erwarten, dass "1234" .slice (2, -1) "34" zurückgibt. Ja, das heißt, ich bin neu in Javascript. Dies bedeutet auch dieses Verhalten:

"1234".slice(-2, -2) == "", "1234".slice(-2, -1) == "3", "1234".slice(-2, -0) == "" <-- you have to use length or omit the argument to get the 4.
"1234".slice(3, -2) == "", "1234".slice(3, -1) == "", "1234".slice(3, -0) == "" <-- same issue, but seems weirder.

Mein 2c.

Der Unterschied zwischen Teilzeichenfolge und Slice besteht darin, wie sie mit negativen und übersehenen Zeilen im Ausland arbeiten:

Teilzeichenfolge (Anfang, Ende)

Negative Argumente werden als Null interpretiert. Zu große Werte werden auf die Länge der Zeichenfolge abgeschnitten: alert ("testme" .substring (-2)); // "testme", -2 wird 0

Wenn start> end ist, werden die Argumente vertauscht, dh die Plotlinie kehrt zwischen Start und Ende zurück:

alert ( "testme" .substring (4, -1)); // "test"
// -1 Becomes 0 -> got substring (4, 0)
// 4> 0, so that the arguments are swapped -> substring (0, 4) = "test"

Scheibe

Negative Werte werden am Ende der Zeile gemessen:

alert ( "testme" .slice (-2)); // "me", from the end position 2
alert ( "testme" .slice (1, -1)); // "estm", from the first position to the one at the end.

Es ist viel praktischer als die seltsame Logik-Teilzeichenfolge.

Ein negativer Wert des ersten Parameters für substr, der in allen Browsern außer IE8- unterstützt wird.

Wenn die Wahl einer dieser drei Methoden für die Verwendung in den meisten Situationen - es ist Slice : negative Argumente und es behält und funktioniert am offensichtlichsten.

substr: Es ermöglicht uns, einen Teil der Zeichenfolge basierend auf dem angegebenen Index abzurufen. Syntax von substrstring.substr (Start, Ende) Start - Startindex gibt an, wo der Abruf beginnt. Der End-End-Index gibt an, wo der String abgerufen wird. Es ist optional.

Slice: Es wird bereitgestellt, einen Teil der Zeichenfolge basierend auf dem angegebenen Index abzurufen. Es ermöglicht uns, Positiv und Index anzugeben. Die Syntax des Slice-String-Slice-Startindex (Start, Ende) gibt an, wo der Abruf beginnt. Der End-End-Index gibt an, wo der String abgerufen wird. Es ist optional. Beim 'Spleißen' helfen sowohl der Start- als auch der Endindex dabei, einen positiven und einen negativen Index zu erhalten.

Beispielcode für 'Slice' in String

var str="Javascript";
console.log(str.slice(-5,-1));

output: crip

Beispielcode für 'Teilzeichenfolge' in Zeichenfolge

var str="Javascript";
console.log(str.substring(1,5));

output: avas

[* Hinweis: Die negative Indizierung beginnt am Ende der Zeichenfolge.]

Der einzige Unterschied zwischen Slice- und Teilstring-Methode besteht in Argumenten

Beide nehmen zwei Argumente an, z. B. start / from und end / to.

Sie können keinen negativen Wert als erstes Argument für die Teilstring- Methode übergeben, sondern für die Slice- Methode, um ihn vom Ende zu durchlaufen.

Details der Slice-Methodenargumente:

REF: http://www.thesstech.com/javascript/string_slice_method

Argumente

start_index Index, von dem aus das Slice beginnen soll. Wenn der Wert negativ angegeben ist, bedeutet dies, dass vom letzten begonnen wird. zB -1 für das letzte Zeichen. end_index Index nach dem Ende des Slice. Wenn nicht angegeben, wird das Slice vom Startindex bis zum Ende der Zeichenfolge übernommen. Im Falle eines negativen Wertes wird der Index ab dem Ende der Zeichenfolge gemessen.

Details zum Argument der Teilzeichenfolge:

REF: http://www.thesstech.com/javascript/string_substring_method

Argumente

from Es sollte eine nicht negative Ganzzahl sein, um den Index anzugeben, von dem aus die Unterzeichenfolge beginnen soll. to Eine optionale nicht negative Ganzzahl, um einen Index bereitzustellen, vor dem die Unterzeichenfolge beendet werden soll.

Für slice(start, stop)wenn, stopnegativ ist, stopwird eingestellt auf:

string.length – Math.abs(stop)

eher, als:

string.length – 1 – Math.abs(stop)