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

834

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

String.prototype.slice
String.prototype.substring
tmim
fuente
216
Es un ejemplo del mal diseño de JavaScript que terminamos con tres métodos que hacen lo mismo, pero con diferentes peculiaridades. OMI slicees el que tiene el comportamiento menos inesperado.
bobince
2
La subcadena IMO cuando se usa para tomar una subcadena desde idx hasta el final es más comprensible de un vistazo. Especialmente para los
novatos
1
Según este sitio web , en slicerealidad puede reemplazarlo substringy no hay razón para usarlo.
Derek 朕 會 功夫
55
@AmolMKulkarni No es cierto en absoluto. Si lo intentas var a = "asdf".substring(-1);, se trata como var a = "asdf".substring(0);. No hay excepción lanzada. Y si lo usa var a = "asdf".substring(2, -1);, lo usa 0en lugar de -1(como antes), y cambia los argumentos para que actúe como var a = "asdf".substring(0, 2);. Incluso probé estos en IE 8 y obtuve los resultados sin excepciones
Ian
35
"Incluso probé estos en IE 8" - Me encanta la programación.
Quemeful

Respuestas:

863

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 ()

Daniel Vassallo
fuente
8
En su última nota sobre slice(), debería serstring.length - stop
Andy
16
En su última nota sobre slice(), creo que debería ser (string.length – 1) + stopo, para que quede claro que es negativo,(string.length – 1) – Math.abs(stop)
Oriol
99
@Longpoke: String.slicese agregó para que haya un método de cadena coherente con Array.slice. substringha estado allí para siempre, por lo que no lo rompieron y agregaron otro método. Difícilmente una mala decisión como 1. la consistencia es agradable y 2. permite que la sintaxis de corte de CoffeeScript funcione en matrices y cadenas. @Oriol: lo editó.
ovejas voladoras
66
Parece que hay una diferencia de rendimiento entre la subcadena y el corte en Firefox 22. jsperf.com/string-slice-vs-substring
Rick
44
Andy tenía razón. stopse establecerá en string.length + stopsi stopes negativo. ¡Recuerde que stopes el índice después del último carácter extraído!
user1537366
97

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().

Waddah
fuente
24

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.

Jón Viðar Þorsteinsson
fuente
3
Esto es incorrecto, substr maneja parámetros negativos. '0123456789'.substr(-3, 2) -> '78'
Neil Fraser
14

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.

Gerard ONeill
fuente
11

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.

Alexandr
fuente
4

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

subham ruj
fuente
3

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.

Sohail Arif
fuente
0

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)
tingxuanz
fuente