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

834

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

String.prototype.slice
String.prototype.substring
tmim
fonte
216
É um exemplo do mau design do JavaScript que acabamos com três métodos que fazem a mesma coisa, mas com peculiaridades diferentes. O IMO sliceé aquele com o comportamento menos inesperado.
22910
2
A substring da IMO, quando usada para obter uma substring do idx até o final, é mais compreensível à primeira vista. Especialmente para noobs
mplungjan
1
De acordo com este site , slicepode realmente substituir substringe não há razão para usá-lo.
Derek # 8/07
5
@AmolMKulkarni Não é verdade. Se você tentar var a = "asdf".substring(-1);, é tratado como var a = "asdf".substring(0);. Não há exceção lançada. E se você usar var a = "asdf".substring(2, -1);, ele usa 0no lugar de -1(como antes) e troca os argumentos para que funcionem como var a = "asdf".substring(0, 2);. Eu até tentei estes em IE 8 e tenho os resultados sem exceções
Ian
35
"Eu até tentei isso no IE 8" - adoro programação.
#

Respostas:

861

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

Daniel Vassallo
fonte
8
Em sua última observação slice(), deve ser #string.length - stop
Andy
16
Em sua última nota sobre slice(), eu acho que deveria ser (string.length – 1) + stop, ou, para torná-lo claro que é negativo,(string.length – 1) – Math.abs(stop)
Oriol
9
@ Longpoke: String.slicefoi adicionado para que haja um método de string consistente Array.slice. substringestá lá para sempre, então eles não quebraram e adicionaram outro método. Dificilmente uma decisão ruim como 1. a consistência é boa e 2. permite que a sintaxe de fatia do CoffeeScript funcione em matrizes e strings. @Oriol: editou-o em.
flying sheep sheep
6
Parece que há uma diferença de desempenho entre substring e fatia no Firefox 22. jsperf.com/string-slice-vs-substring
Rick
4
Andy estava certo. stopserá definido como string.length + stopse stopfor negativo. Lembre stop- se é o índice após o último caractere extraído!
user1537366
97

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

Waddah
fonte
11
substr () não deve ser usado developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
Killy
24

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.

Jón Viðar Þorsteinsson
fonte
3
Isso está incorreto, o substr lida com parâmetros negativos. '0123456789'.substr(-3, 2) -> '78'
Neil Fraser
14

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.

Gerard ONeill
fonte
11

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.

Alexandr
fonte
4

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

subham ruj
fonte
3

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.

Sohail Arif
fonte
0

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