¿Cuál es la diferencia entre String.slice y String.substring?

¿Alguien sabe cuál es la diferencia entre estos dos métodos?

String.prototype.slice
String.prototype.substring

slice()funciona como substring()con algunos comportamientos diferentes.

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

Lo que tienen en común:

1. Si startes igual stop: devuelve una cadena vacía
2. Si stopse omite: extrae caracteres al final de la cadena
3. Si cualquiera de los argumentos es mayor que la longitud de la cadena, se utilizará la longitud de la cadena.

Distinciones de :substring()

1. Si start > stop, entonces substringintercambiará esos 2 argumentos.
2. Si cualquiera de los argumentos es negativo o lo es NaN, se trata como si lo fuera 0.

Distinciones de :slice()

1. Si start > stop, slice()devolverá la cadena vacía. ( "")
2. Si startes negativo: establece char desde el final de la cadena, exactamente como substr()en Firefox. Este comportamiento se observa tanto en Firefox como en IE.
3. Si stopes negativo: establece stop a: string.length – Math.abs(stop)(valor original), excepto limitado a 0 (por lo tanto Math.max(0, string.length + stop)) como se cubre en la especificación ECMA .

Fuente: Arte rudimentario de programación y desarrollo: Javascript: substr () vs substring ()

Nota: si tiene prisa y / o busca una respuesta corta, desplácese hasta el final de la respuesta y lea las dos últimas líneas. Si no tiene prisa, lea todo.


permítanme comenzar declarando los hechos:

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

¿Que hace?
El slice()método extrae partes de una cadena y devuelve las partes extraídas en una nueva cadena.
El substr()método extrae partes de una cadena, comenzando en el carácter en la posición especificada, y devuelve el número especificado de caracteres.
El substring()método extrae partes de una cadena y devuelve las partes extraídas en una nueva cadena.
Nota 2:slice()==substring()

Cambia la cadena original?
slice()No
substr()hace No
substring()hace No
Nota # 3:slice()==substring()

Uso de números negativos como argumento:
slice()selecciona caracteres que comienzan desde el final de la cadena
substr()selecciona caracteres que comienzan desde el final de la cadena
substring()No realiza la
nota # 3:slice()==substr()

si el primer argumento es mayor que el segundo:
slice()no se realiza
substr()ya que el segundo argumento NO es una posición, sino un valor de longitud, funcionará como de costumbre, sin problemas
substring()intercambiará los dos argumentos y funcionará como de costumbre

el primer argumento:
slice()obligatorio, indica: índice inicial
substr()obligatorio, indica: índice inicial
substring()obligatorio, indica: índice inicial
Nota # 4:slice()==substr()==substring()

El segundo argumento:
slice()Opcional, La posición (hasta, pero sin incluir) dónde finalizar la extracción
substr()Opcional, El número de caracteres para extraer
substring()Opcional, La posición (hasta, pero sin incluir) donde finalizar la extracción
Nota # 5:slice()==substring()

¿Qué pasa si se omite el segundo argumento?
slice()selecciona todos los caracteres desde la posición inicial hasta el final de la secuencia
substr()selecciona todos los caracteres desde la posición inicial hasta el final de la secuencia
substring()selecciona todos los caracteres desde la posición inicial hasta el final de la secuencia
Nota # 6:slice()==substr()==substring()

entonces, puedes decir que hay una diferencia entre slice()y substr(), mientras que substring()es básicamente una copia de slice().

en resumen:
si conoce el índice (la posición) en el que se detendrá (pero NO lo incluirá), use slice()
si conoce la longitud de los caracteres que se extraerán substr().

Ben Nadel ha escrito un buen artículo sobre esto, señala la diferencia en los parámetros de estas funciones:

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

También señala que si los parámetros para cortar son negativos, hacen referencia a la cadena desde el final. Subcadena y subcadena no.

Aquí está su artículo sobre esto.

La única respuesta está bien, pero requiere un poco de lectura. Especialmente con la nueva terminología "stop".

My Go: organizado por diferencias para que sea útil además de la primera respuesta de Daniel anterior:

1) índices negativos. La subcadena requiere índices positivos y establecerá un índice negativo en 0. El índice negativo de Slice significa la posición desde el final de la cadena.

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

2) Intercambio de índices. La subcadena reordenará los índices para que el primer índice sea menor o igual que el segundo índice.

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

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

Comentario general: me parece extraño que el segundo índice sea la posición después del último carácter de la porción o subcadena. Esperaría que "1234" .slice (2,2) devuelva "3". Esto justifica la confusión de Andy: esperaría que "1234" .slice (2, -1) devuelva "34". Sí, esto significa que soy nuevo en Javascript. Esto significa también este comportamiento:

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

Mi 2c.

La diferencia entre la subcadena y el corte es cómo funcionan con argumentos negativos y con líneas pasadas en el extranjero:

subcadena (inicio, fin)

Los argumentos negativos se interpretan como cero. Los valores demasiado grandes se truncan a la longitud de la cadena: alert ("testme" .substring (-2)); // "testme", -2 se convierte en 0

Además, si inicio> fin, los argumentos se intercambian, es decir, la línea de trazado regresa entre el inicio y el final:

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"

rebanada

Los valores negativos se miden desde el final de la línea:

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 mucho más conveniente que la extraña subcadena lógica.

Un valor negativo del primer parámetro para substr admitido en todos los navegadores, excepto IE8-.

Si elige uno de estos tres métodos, para usar en la mayoría de las situaciones, será una rebanada : argumentos negativos y mantiene y opera de manera más obvia.

substr: nos proporciona recuperar parte de la cadena en función del índice especificado. sintaxis de substr- string.substr (inicio, fin) inicio: el índice de inicio indica dónde comienza la recuperación. end: el índice final indica hasta dónde se obtiene la cadena. Es opcional.

rebanada: proporciona obtener parte de la cadena en función del índice especificado. Nos permite especificar positivo e índice. sintaxis de slice - string.slice (start, end) start - start index indica dónde comienza la recuperación. Es end - end index indica hasta dónde recupera la cadena. Es opcional. En 'empalme', tanto el índice inicial como el final ayudan a tomar índices positivos y negativos.

código de muestra para 'corte' en cadena

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

output: crip

código de muestra para 'subcadena' en cadena

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

output: avas

[* Nota: la indexación negativa comienza al final de la cadena.]

La única diferencia entre el método de división y subcadena es de argumentos

Ambos toman dos argumentos, por ejemplo, inicio / desde y final / hasta.

No se puede pasar un valor negativo como primer argumento para la subcadena método, pero para rebanada método para atravesar de un extremo.

Detalles del argumento del método de corte:

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

Argumentos

start_index Índice desde donde debe comenzar el sector. Si el valor se proporciona en negativo, significa comenzar desde el último. por ejemplo, -1 para el último personaje. end_index Índice después del final del segmento. Si no se proporciona, el segmento se tomará desde start_index hasta el final de la cadena. En caso de valor negativo, el índice se medirá desde el final de la cadena.

Detalles del argumento del método de subcadena:

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

Argumentos

de que debe ser un número entero no negativo para especificar el índice desde donde subcadena debe comenzar. a Un entero opcional no negativo para proporcionar un índice antes del cual se debe terminar la subcadena.

Para slice(start, stop), si stopes negativo, stopse establecerá en:

string.length – Math.abs(stop)

más bien que:

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