¿Alguien sabe cuál es la diferencia entre estos dos métodos?
String.prototype.slice
String.prototype.substring
fuente
¿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:
start
es igual stop
: devuelve una cadena vacíastop
se omite: extrae caracteres al final de la cadenaDistinciones de :substring()
start > stop
, entonces substring
intercambiará esos 2 argumentos.NaN
, se trata como si lo fuera 0
.Distinciones de :slice()
start > stop
, slice()
devolverá la cadena vacía. ( ""
)start
es negativo: establece char desde el final de la cadena, exactamente como substr()
en Firefox. Este comportamiento se observa tanto en Firefox como en IE.stop
es 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 ()
slice()
, debería serstring.length - stop
slice()
, creo que debería ser (string.length – 1) + stop
o, para que quede claro que es negativo,(string.length – 1) – Math.abs(stop)
String.slice
se agregó para que haya un método de cadena coherente con Array.slice
. substring
ha 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ó.
stop
se establecerá en string.length + stop
si stop
es negativo. ¡Recuerde que stop
es el índice después del último carácter extraído!
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.
'0123456789'.substr(-3, 2) -> '78'
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 stop
es negativo, stop
se establecerá en:
string.length – Math.abs(stop)
más bien que:
string.length – 1 – Math.abs(stop)
slice
es el que tiene el comportamiento menos inesperado.slice
realidad puede reemplazarlosubstring
y no hay razón para usarlo.var a = "asdf".substring(-1);
, se trata comovar a = "asdf".substring(0);
. No hay excepción lanzada. Y si lo usavar a = "asdf".substring(2, -1);
, lo usa0
en lugar de-1
(como antes), y cambia los argumentos para que actúe comovar a = "asdf".substring(0, 2);
. Incluso probé estos en IE 8 y obtuve los resultados sin excepciones