Qual é a diferença entre String.slice e String.substring?

Alguém sabe qual é a diferença entre esses dois métodos?

String.prototype.slice
String.prototype.substring

slice()funciona como substring()com alguns comportamentos diferentes.

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

O que eles têm em comum:

1. Se startigual stop: retorna uma string vazia
2. Se stopfor omitido: extrai caracteres até o final da sequência
3. Se um dos argumentos for maior que o comprimento da string, o comprimento da string será usado.

Distinções de :substring()

1. Se start > stop, então substringirá trocar esses 2 argumentos.
2. Se um dos argumentos for negativo ou for NaN , será tratado como se fosse 0.

Distinções de slice():

1. E se start > stop , slice()retornará a seqüência vazia. ( "")
2. E se start for negativo: define char a partir do final da string, exatamente como substr()no Firefox. Esse comportamento é observado no Firefox e no IE.
3. Se stopfor negativo: os conjuntos param para: string.length – Math.abs(stop)(valor original), exceto delimitados em 0 (portanto, Math.max(0, string.length + stop)) conforme coberto no especificação ECMA .

Fonte: Arte rudimentar de programação e desenvolvimento: Javascript: substr () vs substring ()

Nota: se você estiver com pressa e / ou estiver procurando uma resposta curta, role até a parte inferior da resposta e leia as duas últimas linhas.se não estiver com pressa, leia tudo.


deixe-me começar declarando os fatos:

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

O que faz?
O slice()método extrai partes de uma sequência e retorna as partes extraídas em uma nova sequência.
O substr()método extrai partes de uma sequência, iniciando no caractere na posição especificada e retorna o número especificado de caracteres.
O substring()método extrai partes de uma sequência e retorna as partes extraídas em uma nova sequência.
Nota 2:slice()==substring()

Muda a string original?
slice()Não
substr()faz Não
substring()faz não
nota # 3:slice()==substring()

Usando números negativos como argumento:
slice()seleciona caracteres iniciando no final da seqüência de
substr()caracteres seleciona caracteres iniciando no final da seqüência de caracteres
substring()Não executa
Nota # 3:slice()==substr()

se o primeiro argumento for maior que o segundo:
slice()não for executado,
substr()pois o segundo argumento NÃO é uma posição, mas o valor de comprimento, ele será executado normalmente, sem problemas
substring(), os dois argumentos serão trocados e serão executados normalmente.

o primeiro argumento:
slice()obrigatório indica: Índice inicial
substr()obrigatório, indica: Índice inicial
substring()obrigatório, indica: Índice inicial
Nota # 4:slice()==substr()==substring()

o Segundo Argumento:
slice()Opcional, A posição (até, mas não incluindo) onde finalizar a extração
substr()Opcional, O número de caracteres a serem extraídos
substring()Opcional, A posição (até, mas não incluindo) onde finalizar a extração
Nota # 5:slice()==substring()

E se o segundo argumento for omitido?
slice()seleciona todos os caracteres da posição inicial até o final da sequência
substr()seleciona todos os caracteres da posição inicial até o final da sequência
substring()seleciona todos os caracteres da posição inicial até o final da sequência
Nota # 6:slice()==substr()==substring()

então, você pode dizer que há uma diferença entre slice()e substr(), enquanto substring()é basicamente uma cópia de slice().

Resumo:
se você souber o índice (a posição) em que irá parar (mas NÃO incluir), use slice()
se souber o tamanho dos caracteres a serem extraídos substr().

Ben Nadel escreveu um bom artigo sobre isso, ele aponta a diferença nos parâmetros para essas funções:

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

Ele também aponta que, se os parâmetros a serem fatiados são negativos, eles referenciam a string do final. Substring e substr não.

Aqui está o artigo dele sobre isso.

A única resposta é boa, mas requer uma pequena leitura. Especialmente com a nova terminologia "stop".

My Go - organizado por diferenças para torná-lo útil, além da primeira resposta de Daniel acima:

1) índices negativos. A sequência de caracteres requer índices positivos e definirá um índice negativo para 0. O índice negativo da fatia significa a posição do final da sequência.

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

2) Troca de índices. Substring reordenará os índices para tornar o primeiro índice menor ou igual ao segundo índice.

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

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

Comentário geral - acho estranho que o segundo índice seja a posição após o último caractere da fatia ou substring. Eu esperaria que "1234" .slice (2,2) retornasse "3". Isso justifica a confusão de Andy acima - eu esperaria que "1234" .slice (2, -1) retornasse "34". Sim, isso significa que eu sou novo em Javascript. Isso significa também esse 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.

Meu 2c.

A diferença entre substring e fatia - é como eles funcionam com argumentos negativos e com vista para linhas no exterior:

substring (início, fim)

Argumentos negativos são interpretados como zero. Valores muito grandes são truncados para o comprimento da string: alert ("testme" .substring (-2)); // "testme", -2 se torna 0

Além disso, se start> end, os argumentos são trocados, ou seja, a linha de plotagem retorna entre o início e o fim:

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"

fatia

Os valores negativos são medidos a partir do final da linha:

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.

É muito mais conveniente do que a estranha substring lógica.

Um valor negativo do primeiro parâmetro para substr suportado em todos os navegadores, exceto o IE8-.

Se a escolha de um destes três métodos, para uso na maioria das situações - será uma fatia : argumentos negativos e mantém e opera mais óbvio.

substr: Ele nos fornece buscar parte da string com base no índice especificado. sintaxe do substr- string.substr (start, end) start - start index informa onde a busca começa. O índice end - end indica até onde a string é buscada. É opcional.

fatia: está fornecendo para buscar parte da string com base no índice especificado. Isso nos permite especificar positivo e índice. sintaxe da fatia - string.slice (start, end) start - start index informa onde a busca é iniciada. É opcional. Na 'emenda', o índice inicial e final ajuda a obter um índice positivo e negativo.

código de exemplo para 'fatia' na string

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

output: crip

código de exemplo para 'substring' na string

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

output: avas

[* Nota: a indexação negativa começa no final da string.]

A única diferença entre o método de fatia e substring é de argumentos

Ambos aceitam dois argumentos, por exemplo, início / de e fim / para.

Você não pode passar um valor negativo como primeiro argumento para o método de substring , mas para que o método de fatia o atravesse do final.

Detalhes do argumento do método da fatia:

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

Argumentos

start_index Índice de onde a fatia deve começar. Se o valor for fornecido em negativo, significa começar do último. por exemplo, -1 para o último caractere. end_index Índice após o final da fatia. Se não for fornecido, a fatia será retirada do start_index até o final da string. No caso de valor negativo, o índice será medido a partir do final da string.

Detalhes do argumento do método de substring:

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

Argumentos

from Deve ser um número inteiro não negativo para especificar o índice de onde a sub-string deve iniciar. para Um número inteiro não negativo opcional para fornecer um índice antes do qual a sub-cadeia deve ser concluída.

Pois slice(start, stop), se stopfor negativo, stopserá definido como:

string.length – Math.abs(stop)

ao invés de:

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