Qual è la differenza tra String.slice e String.substring?

Qualcuno sa quale sia la differenza tra questi due methods:

String.slice String.substring 

slice() funziona come substring() con alcuni comportmenti diversi.

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

Che cosa hanno in comune:

  1. Se l' start equals stop : restituisce una string vuota
  2. Se la stop viene omessa: estrae i caratteri alla fine della string
  3. Se uno dei due argomenti è maggiore della lunghezza della string, invece, verrà utilizzata la lunghezza della string.

Distinzioni della substring() :

  1. Se l' start > stop , la substring scambia quei 2 argomenti.
  2. Se uno dei due argomenti è negativo o è NaN , viene trattato come se fosse 0 .

Distinzioni della slice() :

  1. Se start > stop , la slice() non scambia i due argomenti.
  2. Se l' start è negativo: imposta il carattere dalla fine della string, esattamente come substr() in Firefox. Questo comportmento viene osservato sia in Firefox che in IE.
  3. Se la stop è negativa: imposta fermarsi a: string.length – Math.abs(stop) (valore originale).

Fonte: Arte rudimentale di programmazione e sviluppo: Javascript: substr () vs substring ()

Nota: se sei in fretta e / o cerca una breve risposta, scorri fino alla fine della risposta e legga le ultime due righe. Se non fretta di leggere tutta la cosa.

mi permetta di cominciare dichiarando i fatti:

Sintassi:
string.slice(start,end)
string.substr(start,length)
string.substring(start,end)
Nota # 1: slice()==substring()

Cosa fa?
Il metodo slice() estrae parti di una string e restituisce le parti estratte in una nuova string.
Il metodo substr() estrae parti di una string, a partire dal carattere nella posizione specificata e restituisce il numero specificato di caratteri.
Il metodo substring() estrae parti di una string e restituisce le parti estratte in una nuova string.
Nota # 2: slice()==substring()

Modifica la string originale?
slice() non lo fa
substr() Non lo fa
substring() Non lo fa
Nota # 3: slice()==substring()

Utilizzo dei numbers negativi come argomento:
slice() seleziona i caratteri a partire dalla fine della string
substr() seleziona i caratteri a partire dalla fine della string
substring() non esegue
Nota # 3: slice()==substr()==substr()

se il primo argomento è più grande del secondo:
slice() non esegue
substr() dal momento che il secondo argomento NON è una posizione, ma il valore di lunghezza, esegue come al solito, senza problemi
substring() sostituirà i due argomenti e esegue come al solito

il primo argomento:
slice() Obbligatorio, indica: Indice di partenza
substr() Richiesto, indica: Indice di partenza
substring() Richiesto, indica: Indice di partenza
Nota # 4: slice()==substr()==substring()

il secondo argomento:
slice() opzionale, la posizione (fino a, ma non compreso) where finire l'estrazione
substr() Facoltativo, Il numero di caratteri da estrarre
substring() Facoltativo, La posizione (fino a non includere) where finire l'estrazione
Nota # 5: slice()==substring()

Che cosa succede se il secondo argomento è omesso?
slice() seleziona tutti i caratteri dalla posizione iniziale alla fine della string
substr() seleziona tutti i caratteri dalla posizione iniziale alla fine della string
substring() seleziona tutti i caratteri dalla posizione iniziale alla fine della string
Nota # 6: slice()==substr()==substring()

quindi puoi dire che c'è una differenza tra slice() e substr() , mentre substring() è fondamentalmente una copia di slice() .

In sintesi:
se si conosce l'indice (la posizione) in cui si arresta (ma non include), utilizzare la slice()
se si conosce la lunghezza dei caratteri da estrarre utilizzare substr() .

Ben Nadel ha scritto un buon articolo su questo, sottolinea la differenza nei parametri di queste funzioni:

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

Inoltre sottolinea che se i parametri a fetta sono negativi, essi riferiscono la string dalla fine. Sottostring e substr non.

Ecco il suo articolo su questo http://www.bennadel.com/blog/2159-using-slice-substring-and-substr-in-javascript.htm

La risposta è buona, ma richiede una leggera lettura. Soprattutto con la nuova terminologia "stop".

My Go – organizzato dalle differenze per renderlo utile oltre alla prima risposta di Daniel sopra:

1) indici negativi. La sottostring richiede indici positivi e imposta un indice negativo su 0. L'indice nagative di Slice significa la posizione dalla fine della string.

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

2) Scambio di indici. La sottostring riordinerà gli indici per rendere il primo indice less o uguale al secondo indice.

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

————————–

Commento generale – Mi sembra strano che il secondo indice sia la posizione dopo l'ultimo carattere della fetta o della sottostring. Mi aspetto "1234" .slice (2,2) per tornare "3". Questo rende la confusione di Andy sopra giustificata – mi aspetto "1234" .slice (2, -1) per tornare "34". Sì, questo significa che sono nuovo a Javascript. Questo significa anche questo comportmento:

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

Il mio 2c.

La differenza tra la sottostring e la fetta – è come lavorano con argomenti negativi e affacciati all'estero:

sottostring (inizio, fine)

Gli argomenti negativi vengono interpretati come zero. Valori troppo grandi vengono troncati alla lunghezza della string: alert ("testme" .substring (-2)); // "testme", -2 diventa 0

Inoltre, se l'avvio> fine, gli argomenti vengono intercettati, cioè la row di plot tra l'inizio e la fine:

 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" 

fetta

I valori negativi vengono misurati dalla fine della linea:

 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. 

È molto più conveniente della strana sottostruttura logica.

Un valore negativo del primo parametro a substr supportto in tutti i browser, ad exception di IE8-.

Se la scelta di uno di questi tre methods, per l'uso nella maggior parte delle situazioni – sarà fetta : argomenti negativi e mantiene e opera più evidente.

L'unica differenza tra il metodo di fetta e substring è di argomenti

Entrambi prendono due argomenti, ad esempio inizio / da e fine / a.

Non è ansible passare un valore negativo come primo argomento per il metodo di sottostring , ma per il metodo della fetta per attraversarlo dall'estremità.

Dettagli di argomento del metodo Slice:

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

argomenti

start_index Indice da where dovrebbe iniziare la fetta. Se il valore viene fornito in negativo significa partire dall'ultimo. ad esempio -1 per ultimo carattere. end_index Indice dopo fine della fetta. Se non viene fornita la fetta verrà prelevata da start_index fino alla fine della string. In caso di indice di valore negativo verrà misurato dall'estremità della string.

Dettagli di argomento del metodo Substring:

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

argomenti

da Essa dovrebbe essere un integer non negativo per specificare l'indice da where iniziare la sottoscheda. a Un numero integer non negativo opzionale per fornire indice prima di che la sottogruppo dovrebbe essere terminata.

differenze

String.prototype.slice

Trattamento degli indici negativi

  • " Se [ un argomento è ] negativo, viene trattato come strLength + [ index ] where strLength è la lunghezza della string (ad esempio, se [ index ] è -3 è trattato come strLength - 3 ). "

Indice di partenza maggiore dell'indice finale

  • " Se [ l'indice di partenza ] è maggiore o uguale al [ trattamento dell'indice finale ] della [ string slice ], slice() restituisce una string vuota. "

    – MDN

String.prototype.substring

Trattamento degli indici negativi

  • " Se uno dei due argomenti è [ negativo ] [ ], viene trattato come se fosse 0 " .

Indice di partenza maggiore dell'indice finale

  • " Se [ l 'indice di partenza ] è maggiore di [ l' indice di fine ], allora l '
    l'effetto di substring() è come se i due argomenti siano stati scambiati; ad esempio, str.substring(1, 0) == str.substring(0, 1) . "

    – MDN

Analogie

Tutto il resto è lo stesso, penso, tra cui:

  • Se un argomento dell'indice finale è undefined , diventa la lunghezza della string.
  • Gli argomenti che non sono numbers e non possono essere convertiti in numbers diventano 0 .

* Quanto sopra è anche vero per il metodo di substr() , tranne substr() non ha un argomento di indice di fine ( vedere le note sotto String.prototype.substr ).

Gli appunti

String.prototype.substring

  • Dove string.substring(startIndex, endIndex) ,

    • Limite di scambio di argomenti – se endIndex non è un numero quando viene passato come argomento, diventa 0 internamente per il metodo di substring() (lo stesso per la slice() ); tuttavia, non sostituirà il suo valore con startIndex ( si pensa che sia stato ragionevole per farlo, ma devo andare in discesa ) . Quindi, se endIndex = NaN , allora string.substring(startIndex, endIndex) === "" è vero (come per slice() ) indipendentemente dall'indice di partenza fornito.

    • Un pensiero per quanto riguarda lo scambio di argomenti – se endIndex è undefined diventa string.length ; se startIndex è maggiore della lunghezza della string, è ansible che si scambia il valore con endIndex , ma poiché in questo modo si ottiene una string vuota (poiché entrambi i valori sono al di là degli indici della string), sarebbe un punto fondamentale fare così. Invece, è probabile che sia solo un controllo interno per vedere se startIndex > string.length è vero in primo luogo, che poi restituisce una string vuota se è.

String.prototype.substr
[ leggermente al di là della portta della questione ]

  • String.prototype.substr è molto simile alla slice , specialmente per quanto riguarda il trattamento dei numbers negativi per i valori dell'indice; tuttavia, la differenza principale è che il secondo argomento di substr() non specifica un indice di fine, ma la lunghezza dei caratteri richiesti dal chiamante. Basta dire che substr() si comport come prevedibile come la fetta fa oltre quella differenza chiave.

Per la fetta (inizio, arresto), se la sosta è negativa, la sosta verrà impostata su: string.length – Math.abs (stop), piuttosto (string.length – 1) – Math.abs (stop).

fetta (inizio: numero, fine: numero) Estrae una porzione di una string tra le posizioni di partenza e di fine specificate.

substring (start: number, end: number) Come la fetta, estrae una porzione di una string tra le posizioni di inizio / fine specificate.

Per la fetta, il secondo argomento è facoltativo. la sottostring è simile alla fetta, ma i due argomenti possono essere dati in qualsiasi ordine.