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

Qualcuno sa qual è la differenza tra questi due metodi?

String.prototype.slice
String.prototype.substring

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

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

Cosa hanno in comune:

1. Se startuguale stop: restituisce una stringa vuota
2. Se stopomesso: estrae i caratteri alla fine della stringa
3. Se uno dei due argomenti è maggiore della lunghezza della stringa, verrà utilizzata la lunghezza della stringa.

Distinzioni di :substring()

1. Se start > stop, quindi substringscambieranno questi 2 argomenti.
2. Se uno degli argomenti è negativo o lo è NaN, viene trattato come se lo fosse 0.

Distinzioni di :slice()

1. Se start > stop, slice()restituirà la stringa vuota. ( "")
2. Se startè negativo: imposta il carattere dalla fine della stringa, esattamente come substr()in Firefox. Questo comportamento si osserva in Firefox e IE.
3. Se stopè negativo: imposta stop su: string.length – Math.abs(stop)(valore originale), tranne che limitato a 0 (quindi, Math.max(0, string.length + stop)) come indicato nelle specifiche ECMA .

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

Nota: se sei di fretta e / o stai cercando una risposta breve, scorri fino alla fine della risposta e leggi le ultime due righe. Se non hai fretta, leggi tutto.


vorrei iniziare affermando i fatti:

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

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

Cambia la stringa originale?
slice()Non
substr()fa
substring()Non
nota # 3:slice()==substring()

Utilizzo dei numeri negativi come argomento:
slice()seleziona i caratteri a partire dalla fine della stringa
substr()seleziona i caratteri a partire dalla fine della stringa
substring()Non esegue la
nota n. 3:slice()==substr()

se il primo argomento è maggiore del secondo:
slice()non funziona
substr()poiché il secondo argomento NON è una posizione, ma un valore di lunghezza, funzionerà come al solito, senza problemi
substring()scambieranno i due argomenti e funzionerà come al solito

il primo argomento:
slice()Richiesto, indica: Indice iniziale
substr()richiesto, indica: Indice iniziale
substring()richiesto, indica: Indice iniziale
Nota n. 4:slice()==substr()==substring()

il secondo argomento:
slice()Opzionale, La posizione (fino a, ma non incluso) dove terminare l'estrazione
substr()Facoltativo, Il numero di caratteri da estrarre
substring()Opzionale, La posizione (fino a, ma non incluso) dove terminare l'estrazione
Nota # 5:slice()==substring()

E se il secondo argomento fosse omesso?
slice()seleziona tutti i caratteri dalla posizione iniziale alla fine della stringa
substr()seleziona tutti i caratteri dalla posizione iniziale alla fine della stringa
substring()seleziona tutti i caratteri dalla posizione iniziale alla fine della stringa
Nota # 6:slice()==substr()==substring()

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

in Riepilogo:
se conosci l'indice (la posizione) su cui ti fermerai (ma NON includi), Usa slice()
se conosci la lunghezza dei caratteri da estrarre 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 ] )

Sottolinea inoltre che se i parametri da suddividere sono negativi, fanno riferimento alla stringa dalla fine. Sottostringa e substr no.

Ecco il suo articolo su questo.

L'unica risposta va bene, ma richiede una piccola lettura. Soprattutto con la nuova terminologia "stop".

My Go - organizzato in base alle differenze per renderlo utile in aggiunta alla prima risposta di Daniel sopra:

1) indici negativi. Il sottostringa richiede indici positivi e imposterà un indice negativo su 0. L'indice negativo di Slice indica la posizione dalla fine della stringa.

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

2) Scambio di indici. Il sottostringo riordinerà gli indici per rendere il primo indice inferiore o uguale al secondo indice.

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

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

Commento generale - Trovo strano che il secondo indice sia la posizione dopo l'ultimo carattere della porzione o sottostringa. Mi aspetto che "1234" .slice (2,2) restituisca "3". Questo rende la confusione di Andy sopra giustificata - mi aspetto che "1234" .slice (2, -1) restituisca "34". Sì, questo significa che sono nuovo di Javascript. Questo significa anche questo comportamento:

"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 sottostringa e slice - sta nel modo in cui funzionano con argomenti negativi e con linee trascuranti all'estero:

sottostringa (inizio, fine)

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

Inoltre, se inizio> fine, gli argomenti vengono scambiati, ovvero la riga della trama ritorna 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 sono misurati dalla fine della riga:

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 sottostringa logica.

Un valore negativo del primo parametro su substr supportato in tutti i browser tranne IE8-.

Se la scelta di uno di questi tre metodi, da utilizzare nella maggior parte delle situazioni, sarà suddivisa in due : argomenti negativi e mantiene e opera in modo più ovvio.

substr: ci sta fornendo per recuperare parte della stringa in base all'indice specificato. sintassi di substr- string.substr (inizio, fine) inizio: l'indice iniziale indica dove inizia il recupero. end - end index indica fino a dove recupera la stringa. È facoltativo

slice: sta fornendo per recuperare parte della stringa in base all'indice specificato. Ci consente di specificare positivo e indice. sintassi di slice - string.slice (inizio, fine) inizio - l'indice di inizio indica dove inizia il recupero. È la fine - l'indice di fine indica dove recupera la stringa. È facoltativo In 'splice' sia l'indice iniziale che quello finale aiutano a prendere l'indice positivo e negativo.

codice di esempio per "slice" nella stringa

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

output: crip

codice di esempio per "sottostringa" in stringa

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

output: avas

[* Nota: l'indicizzazione negativa inizia alla fine della stringa.]

L'unica differenza tra metodo slice e substring è degli argomenti

Entrambi accettano due argomenti, ad esempio start / from e end / to.

Non è possibile passare un valore negativo come primo argomento per il metodo di sottostringa ma per il metodo slice di attraversarlo dall'estremità.

Dettagli dell'argomento del metodo Slice:

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

argomenti

start_index Indice da cui deve iniziare la sezione. Se il valore viene fornito in negativo significa che inizia dall'ultimo. ad es. -1 per l'ultimo carattere. end_index Indice dopo la fine della sezione. Se non fornito, lo slice verrà preso da start_index alla fine della stringa. In caso di valore negativo, l'indice verrà misurato dalla fine della stringa.

Dettagli dell'argomento del metodo di sottostringa:

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

argomenti

da Dovrebbe essere un numero intero non negativo per specificare l'indice da cui dovrebbe iniziare la sottostringa. a Un numero intero non negativo facoltativo per fornire l'indice prima del quale deve essere terminata la sottostringa.

Perché slice(start, stop), se stopè negativo, stopsarà impostato su:

string.length – Math.abs(stop)

piuttosto che:

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