javascript - right - substring en html

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

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

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

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

Aquí está su artículo sobre este http://www.bennadel.com/blog/2159-using-slice-substring-and-substr-in-javascript.htm

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

String.slice String.substring

La única diferencia entre corte y método de subcadena es de argumentos.

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

No puede pasar un valor negativo como primer argumento para el método de subcadena , sino para que el método de división lo atraviese desde el final.

Detalles del argumento del método de corte:

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

Argumentos

Índice de inicio de índice desde donde debe comenzar la división . Si el valor se proporciona en negativo, significa comenzar desde el último. por ejemplo, -1 para el último carácter. Índice end_index después del final del sector. Si no se proporciona, la división se tomará de start_index al final de la cadena. En caso de que el índice de valor negativo sea medido desde el final de la cadena.

Detalles del argumento del método de subcadena:

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

Argumentos

from Debe ser un entero no negativo para especificar el índice desde donde debe comenzar la subcadena. a Un entero opcional no negativo para proporcionar un índice antes de la cual se debe finalizar la subcadena.

La diferencia entre subcadena y sector: es cómo funcionan con argumentos negativos y que pasan por alto las líneas en el extranjero:

subcadena (inicio, final)

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> final, los argumentos se intercambian, es decir, los resultados de la línea de trazado 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 subcadena lógica extraña.

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

Si la elección de uno de estos tres métodos, para su uso en la mayoría de las situaciones, será una rebanada : argumentos negativos y se mantiene y opera de la manera más obvia.

La 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:

1) índices negativos. La subcadena requiere índices positivos, y establecerá un índice negativo en 0. El índice nagativo 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 volverá a ordenar los índices para que el primer índice sea menor o igual al 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 división o subcadena. Espero que "1234" .slice (2,2) devuelva "3". Esto hace que la confusión de Andy por encima de lo justificado: 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.

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 toda la información.

Permítanme comenzar exponiendo los hechos:

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

¿Que hace?
El método slice() extrae partes de una cadena y devuelve las partes extraídas en una nueva cadena.
El método substr() extrae partes de una cadena, comenzando en el carácter en la posición especificada, y devuelve el número especificado de caracteres.
El método substring() 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 lo hace
substr() no
substring() no
Nota # 3: slice()==substring()

Usando números negativos como argumento:
slice() selecciona caracteres a partir del final de la cadena
substr() selecciona caracteres a partir del final de la cadena
substring() no realiza
Nota # 3: slice()==substr()

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

el primer argumento:
slice() Obligatorio, indica: Índice de inicio
substr() Requerido, indica: Índice de Inicio
substring() Requerido, indica: Índice de Inicio
Nota # 4: slice()==substr()==substring()

El Segundo Argumento:
slice() Opcional, la posición (hasta, pero no incluida) donde finalizar la extracción
substr() Opcional, el número de caracteres para extraer
substring() Opcional, la posición (hasta, pero no incluida) dónde 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 de inicio hasta el final de la cadena
substr() selecciona todos los caracteres desde la posición de inicio hasta el final de la cadena
substring() selecciona todos los caracteres desde la posición de inicio hasta el final de la cadena
Nota # 6: slice()==substr()==substring()

entonces, puede 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 incluirá), use slice()
Si conoce la longitud de los caracteres que se van a extraer, utilice substr() .

Para slice (start, stop), si stop es negativo, stop se establecerá en: string.length - Math.abs (stop), en lugar de (string.length - 1) - Math.abs (stop).

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

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

Lo que tienen en común:

Si start es igual a stop : devuelve una cadena vacía
Si se omite la stop : extrae los caracteres al final de la cadena
Si cualquiera de los dos argumentos es mayor que la longitud de la cadena, en su lugar se usará la longitud de la cadena.

Distinciones de substring() :

Si start > stop , la substring intercambiará esos 2 argumentos.
Si cualquiera de los argumentos es negativo o es NaN , se trata como si fuera 0 .

Distinciones de slice() :

Si start > stop , slice() NO intercambiará los 2 argumentos.
Si el start es negativo: establece char desde el final de la cadena, exactamente igual que substr() en Firefox. Este comportamiento se observa tanto en Firefox como en IE.
Si stop es negativo: establece stop en: string.length – Math.abs(stop) (valor original), excepto el límite en 0 (por lo tanto, Math.max(0, string.length + stop) ) según lo cubierto en la especificación ECMA .

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