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 unterschiedlichen Verhaltensweisen.

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

Was sie gemeinsam haben:

1. Wenn start gleich stop: gibt eine leere Zeichenfolge zurück
2. Wenn stop wird weggelassen: 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 substring tauscht diese 2 Argumente aus.
2. Wenn eines der Argumente negativ ist oder ist NaN, es wird behandelt, als ob es wäre 0.

Unterscheidungen von slice():

1. Wenn start > stop, slice() gibt den leeren String zurück. ("")
2. Wenn start ist negativ: setzt char vom Ende der Zeichenfolge, genau wie substr() im Firefox. Dieses Verhalten wird sowohl in Firefox als auch in IE beobachtet.
3. Wenn stop ist negativ: setzt stop auf: string.length – Math.abs(stop) (ursprünglicher Wert), außer auf 0 begrenzt (also Math.max(0, string.length + stop)) wie in der abgedeckt ECMA-Spezifikation.

Quelle: Rudimentäre Programmier- und Entwicklungskunst: Javascript: substr() vs substring()

TL;DR;

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

Ansonsten lesen Sie weiter für einen vollständigen Vergleich

Syntax

• string.slice(start,end)
• string.substr(start,length)
• string.substring(start,end)

Anmerkung 1: slice()==substring()

Was es macht?

• Der slice() -Methode extrahiert Teile einer Zeichenfolge und gibt die extrahierten Teile in einer neuen Zeichenfolge zurück.
• Der substr() -Methode extrahiert Teile einer Zeichenfolge, beginnend mit dem Zeichen an der angegebenen Position, und gibt die angegebene Anzahl von Zeichen zurück.
• Der substring() -Methode extrahiert Teile einer Zeichenfolge und gibt die extrahierten Teile in einer neuen Zeichenfolge zurück.

Anmerkung 2: slice()==substring()

Ändert die Originalzeichenfolge?

• slice() Nicht
• substr() Nicht
• substring() Nicht
  Notiz 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() Funktioniert nicht

Notiz 3: slice()==substr()

Wenn das erste Argument größer ist als das zweite

• slice() Funktioniert nicht
• substr() Da das zweite Argument KEINE Position, sondern ein Längenwert ist, funktioniert es wie gewohnt ohne Probleme
• substring() vertauscht die beiden Argumente und verhält sich wie gewohnt

Das erste Argument

• slice() Erforderlich, gibt an: Startindex
• substr() Erforderlich, gibt an: Startindex
• substring() Erforderlich, gibt an: Startindex

Hinweis Nr. 4: slice()==substr()==substring()

Das zweite Argument

• slice() Optional: Die Position (bis einschließlich), an der die Extraktion beendet werden soll
• substr() Optional, die Anzahl der zu extrahierenden Zeichen
• substring() Optional: Die Position (bis einschließlich), an der die Extraktion beendet werden soll

Hinweis Nr. 5: slice()==substring()

Was ist, wenn das zweite Argument ausgelassen wird?

• slice() wählt alle Zeichen von der Startposition bis zum Ende des Strings aus
• substr() wählt alle Zeichen von der Startposition bis zum Ende des Strings aus
• substring() wählt alle Zeichen von der Startposition bis zum Ende des Strings aus

Hinweis Nr. 6: slice()==substr()==substring()

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

Ben Nadel hat dazu einen guten Artikel 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 wenn die zu schneidenden Parameter negativ sind, sie die Zeichenfolge vom Ende referenzieren. Substring und substr nicht.

Hier ist sein Artikel über das.

Die eine Antwort ist in Ordnung, erfordert aber ein wenig Einlesen. Vor allem mit der neuen Terminologie „Stopp“.

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

1) negative Indizes. Substring 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. Substring ordnet die Indizes neu an, um den ersten Index kleiner oder gleich dem zweiten Index zu machen.

"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 bedeutet, dass ich neu bei Javascript bin. Damit ist auch dieses Verhalten gemeint:

"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 substring und slice – So arbeiten sie mit negativen und übersehenden Linien im Ausland Argumente:

Teilstring (Anfang, Ende)

Negative Argumente werden als Null interpretiert. Zu große Werte werden auf die Länge des Strings gekürzt:

alert("testme".substring(-2)); // "testme", -2 becomes 0

Außerdem, wenn Anfang > Ende, werden die Argumente vertauscht, dh die Plotlinie kehrt zwischen Anfang 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 vom Ende der Linie 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 bequemer als die seltsame Logik substring.

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

Wenn Sie sich für eine dieser drei Methoden entscheiden, die in den meisten Situationen zum Einsatz kommen, wird dies der Fall sein slice: negative Argumente und es unterhält und funktioniert am offensichtlichsten.

Der einzige Unterschied zwischen der Slice- und der Substring-Methode besteht in den Argumenten

Beide nehmen zwei Argumente, zB start/from und end/to.

Sie können keinen negativen Wert als erstes Argument für übergeben Teilzeichenfolge Methode, aber für Scheibe Methode, um es von Ende zu durchlaufen.

Details zum Slice-Methodenargument:

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

Argumente

Startindex
Index, ab dem Slice beginnen soll. Wenn der Wert negativ angegeben wird, bedeutet dies, dass er beim letzten beginnt. zB -1 für letztes Zeichen.
end_index
Index nach Ende des Slice. Wenn nicht angegeben, wird Slice von start_index bis zum Ende der Zeichenfolge genommen. Bei negativem Wert wird der Index vom Ende der Zeichenfolge gemessen.

Details zum Argument der Substring-Methode:

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

Argumente

von
Es sollte eine nicht negative Ganzzahl sein, um den Index anzugeben, ab dem die Teilzeichenfolge beginnen soll.
zu
Eine optionale nicht negative Ganzzahl, um einen Index bereitzustellen, vor dem die Teilzeichenfolge beendet werden soll.

substr: Es ermöglicht uns, einen Teil der Zeichenfolge basierend auf dem angegebenen Index abzurufen. Syntax von substr- string.substr(start,end) start – Startindex gibt an, wo der Abruf beginnt. end – end index teilt mit, wo der String abgeholt wird. Es ist optional.

Slice: Es bietet die Möglichkeit, einen Teil der Zeichenfolge basierend auf dem angegebenen Index abzurufen. Es erlaubt uns, Positiv und Index anzugeben. Syntax von Slice – string.slice (Start, Ende) Start – Startindex gibt an, wo der Abruf beginnt. Sein Ende – Endindex gibt an, wo die Zeichenfolge abgerufen wird. Es ist optional. In ‘Splice’ helfen sowohl der Start- als auch der Endindex, einen positiven und negativen Index zu nehmen.

Beispielcode für „Slice“ in Zeichenfolge

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

output: crip

Beispielcode für ‘substring’ in string

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

output: avas

[*Note: negative indexing starts at the end of the string.]