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

Kennt jemand den Unterschied zwischen diesen beiden Methoden:

 String.slice String.substring 
582
11 февр. tmim am 11. Februar eingestellt 2010-02-11 13:34 '10 um 13:34 2010-02-11 13:34
@ 9 Antworten

slice() arbeitet als substring() mit verschiedenen Verhaltensweisen.

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

Was haben sie gemeinsam:

  1. Wenn start stop : gibt eine leere Zeichenfolge zurück
  2. Wenn stop : extrahiert Zeichen bis zum Zeilenende
  3. Wenn ein Argument größer als die Länge der Zeichenfolge ist, wird stattdessen die Länge der Zeichenfolge verwendet.

Unterschiede substring() :

  1. Wenn start > stop , ersetzt der substring diese beiden Argumente.
  2. Wenn ein Argument negativ oder NaN , wird es so verarbeitet, als wäre es 0 .

Unterschiede in der slice() :

  1. Bei start > stop slice() 2 Argumente.
  2. Wenn start negativ ist: setzt das Zeichen vom Ende der Zeile aus, genau wie substr() in Firefox. Dieses Verhalten wird sowohl in Firefox als auch im IE beobachtet.
  3. Wenn stop negativ ist: setzt stop für: string.length – Math.abs(stop) (ursprünglicher Wert), mit Ausnahme der begrenzten 0 (also Math.max(0, string.length + stop) ), wie in der ECMA-Spezifikation beschrieben .

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

652
11 февр. Antwort von Daniel Vassallo am 11. Februar. 2010-02-11 13:36 '10 am 1:36 PM 2010-02-11 13:36

Hinweis: Wenn Sie es eilig haben und / oder nach einer kurzen Antwort suchen, scrollen Sie bis zum Ende der Antwort und lesen Sie die letzten beiden Zeilen. Wenn nicht in Eile, alles zu lesen.

>
Lassen Sie mich mit den Tatsachen beginnen:

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

Was macht er?
Die slice() -Methode ruft Teile eines Strings ab und gibt extrahierte Teile in eine neue Zeile zurück.
Die substr() -Methode ruft Teile des Strings ab dem Zeichen an der angegebenen Position ab 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.
Hinweis 2: slice()==substring()

Ändert die Quellzeichenfolge?
slice() Nicht wert von substr() Wert von substring() Nicht wert Anmerkung 3: slice()==substring()

Verwenden Sie negative Zahlen als Argument:
slice() wählt Zeichen aus, die am Ende der Zeile beginnen
substr() wählt Zeichen aus, die am Ende der Zeile beginnen
substring() Nicht ausgeführt Hinweis Nr. 3: slice()==substr()==substr()

wenn das erste Argument mehr als das zweite ist:
slice() Führt substr() , da das zweite Argument NICHT eine Position, sondern ein Längenwert ist. Es wird wie üblich ohne Probleme ausgeführt
substring() ersetzt zwei Argumente und führt sie wie gewohnt aus.

border=0

Erstes Argument:
slice() Erforderlich, zeigt an: Anfangsindex
substr() Erforderlich, zeigt an: Anfangsindex
substring() Erforderlich, zeigt an: Anfangsindex
Hinweis 4: slice()==substr()==substring()

Das zweite Argument:
slice() Optional die Position (bis einschließlich), an der die Extraktion endet
substr() Optional die Anzahl der Zeichen zum Extrahieren des substring() Optional, die Position (bis einschließlich), an der die Extraktion endet
Hinweis 5: slice()==substring()

Was ist, wenn das zweite Argument weggelassen wird?
slice() wählt alle Zeichen von der Startposition bis zum Ende der Zeile 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 zwischen slice() und substr() ein Unterschied besteht, und substring() ist im Grunde eine Kopie von slice() .

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

66
10 авг. die antwort wird von waddah 10 aug gegeben. 2015-08-10 04:58 '15 am 4:58 2015-08-10 04:58

Ben Nadel hat dazu einen guten Artikel geschrieben und weist auf den Unterschied in den Parametern dieser Funktionen hin:

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

Es zeigt auch an, dass, wenn die Parameter des Slices negativ sind, sie sich auf den String vom Ende beziehen. Unterstring und Teilnr

Hier ist sein Artikel auf diesem http://www.bennadel.com/blog/2159- using-slice-substring- and- substr-in- javascript.htm

18
05 дек. Antwort von Jón Viðar Þorsteinsson 5. Dezember 2014-12-05 19:11 '14 um 19:11 2014-12-05 19:11

Eine Antwort ist gut, erfordert jedoch wenig Nachlesen. Besonders bei der neuen Terminologie "Stop".

Mein Go - organisiert nach Unterschieden, um es zusätzlich zu Daniels erster Antwort oben nützlich zu machen:

1) negative Indizes. Ein Teilstring erfordert positive Indizes und setzt einen negativen Index auf 0. Das Schneiden des Schichtindex bedeutet die Position vom Ende der Zeile.

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

2) Börsenindizes. Der Teilstring ändert die Reihenfolge der Indizes, 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. Es scheint mir merkwürdig, dass der zweite Index die Position nach dem letzten Zeichen des Slice oder der Teilzeichenfolge ist. Ich würde erwarten, dass "1234" .slice (2.2) "3" zurückgibt. Dies führt dazu, dass Andy oben gemischt wird - ich erwarte, dass "1234" .slice (2, -1) "34" zurückgibt. Ja, das heißt, ich bin neu bei Javascript. Es bedeutet auch Folgendes:

 "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.

9
04 июня '14 в 17:32 2014-06-04 17:32 Die Antwort gibt Gerard ONeill am 04. Juni '14 um 17:32 Uhr 2014-06-04 17:32

Der Unterschied zwischen einem Teilstring und einem Slice besteht darin, wie sie mit negativen und ignorierenden Zeilen im Ausland arbeiten:

Teilzeichenfolge (Anfang, Ende)

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

Wenn start> end, sind die Argumente außerdem austauschbar, d. H. Die Zeile der Zeile kehrt zwischen dem Anfang und dem 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" 

schneiden

Negative Werte werden vom Zeilenende aus 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. 

Dies ist viel bequemer als ein seltsamer logischer Teilstring.

Der negative Wert des ersten Parameters für substr wird in allen Browsern mit Ausnahme von IE8 - unterstützt.

Wenn in den meisten Situationen eine dieser drei Methoden gewählt wird, ist Slice : negative Argumente, und es unterstützt und handelt am offensichtlichsten.

9
05 февр. Die Antwort wird gegeben: Alexandr 05 Feb. 2016-02-05 17:32 '16 um 17:32 2016-02-05 17:32

-------------------------------------- Unterschiede ----------- ---------------------------

String.prototype.slice

Behandlung von negativen Indikatoren

  • " Wenn [irgendein Argument] negativ ist, wird es als strLength + [ index ] behandelt, wobei strLength die Länge der Zeichenfolge ist (wenn [ index ] beispielsweise -3 ist, wird es als strLength - 3 ) ".

Startindex ist größer als der Endindex

  • Msgstr " Wenn [Anfangsindex] größer oder gleich [Verarbeitungsendindex] ist [Stringschnitt], gibt slice() eine leere Zeichenfolge zurück ".

    - MDN


String.prototype.substring

Behandlung von negativen Indikatoren

  • " Wenn eines der Argumente [negativ] [...] ist, wird es so behandelt, als ob es 0 "

Startindex ist größer als der Endindex

  • " Wenn [Anfangsindex] größer als [Endindex] ist, dann
    der substring() Effekt sieht aus, als wären beide Argumente ersetzt worden; Zum Beispiel: str.substring(1, 0) == str.substring(0, 1) . "

    - MDN

-------------------------------------- Ähnlichkeiten ----------- ---------------------------

Ich denke, alles andere ist das gleiche, einschließlich:

  • Wenn das Argument undefined index nicht undefined , wird es zur Länge der Zeichenfolge.
  • Argumente , die keine Zahlen sind und nicht zu Zahlen gezwungen werden können, werden zu 0 .

* Das Vorstehende gilt auch für die substr() -Methode, außer dass substr() kein abschließendes substr() hat.

------------------------------------------ Hinweise ------- -------------------------------

String.prototype.substr

[etwas außerhalb des Rahmens der Frage]

  • String.prototype.substr slice() sehr ähnlich, insbesondere im Hinblick auf die Verarbeitung negativer Zahlen für Indexwerte. Der Hauptunterschied besteht jedoch darin, dass das zweite Argument, substr() nicht den endgültigen Index angibt, sondern die Länge der vom Aufrufer zurückgegebenen Zeichen. Es genügt zu sagen, dass substr() sich so vorhersagbar verhält, wie slice() über diesen Hauptunterschied hinausgeht. Wenn Sie ein Argument mit negativer length mit dieser Methode eine leere Zeichenfolge zurückgegeben.

8
01 авг. Antwort von Quinn Dirks 1. August 2017-08-01 10:55 '17 am 10:55 2017-08-01 10:55

Der einzige Unterschied zwischen der Slice-Methode und der Teilzeichenfolge besteht aus Argumenten.

Beide haben zum Beispiel zwei Argumente. Start / von und Ende / bis.

Sie können einen negativen Wert nicht als erstes Argument für die substring- Methode angeben , sondern für die slice- Methode, um diesen vom Ende aus zu übergeben.

Details zum Fragment-Methodenargument:

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

Argumente

start_index Der Index, ab dem das Slice beginnen soll. Wenn der Wert negativ ist, beginnt er mit dem letzten. Zum Beispiel -1 für das letzte Zeichen. END_INDEX Index nach dem Ende des Slice. Wenn kein Slice bereitgestellt wird, wird es vom start_index bis zum Zeilenende entfernt. Bei einem negativen Wert wird der Index vom Zeilenende aus gemessen.

Details des Arguments der substring-Methode:

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

Argumente

from Es muss eine nicht negative ganze Zahl sein, um den Index anzugeben, ab dem der Teilstring beginnen soll. Eine optionale nicht negative ganze Zahl, die den Index bereitstellt, vor dem die Teilzeichenfolge abgeschlossen werden soll.

2
24 мая '16 в 16:37 2016-05-24 16:37 Die Antwort wird von Sohail Arif am 24. Mai '16 um 4:37 2016-05-24 16:37 gegeben

Bei einem Slice (Start, Stop) wird Stop bei negativem Stop auf Folgendes gesetzt: string.length - Math.abs (stop), stattdessen (string.length - 1) - Math.abs (stop).

0
29 марта '17 в 8:32 2017-03-29 08:32 Die Antwort ist gegeben tingxuanz 29. März 17 um 08:32 2017-03-29 08:32

slice (start: number, end: number) Ruft den Teil der Linie zwischen den angegebenen Start- / Endpositionen ab.

substring (start: number, end: number) Als Slice wird ein Teil einer Zeichenfolge zwischen den angegebenen Start- / Endpositionen extrahiert.

Für das Slice ist das zweite Argument optional. Der Teilstring ist wie ein Slice, aber zwei Argumente können in beliebiger Reihenfolge angegeben werden.

0
05 дек. Die Antwort wird von Hassan Shahzad 05 Dez. gegeben. 2017-12-05 19:12 '17 um 19:12 Uhr 2017-12-05 19:12

Weitere Fragen zu Tags oder Ask a Question