Como posso remover um caractere de uma string usando JavaScript?

Estou tão perto de conseguir isso, mas isso não está certo. Tudo que eu gostaria de fazer é remover o caractere “r” de uma string. O problema é que há mais de uma instância de “r” na string. No entanto, é sempre o quarto personagem.

exemplo string: “crt / r2002_2” O que eu quero: “crt / 2002_2”

Esta function de substituição remove os dois “r”

mystring.replace(/r/g, '') 

Produz: “ct / 2002_2”

Eu tentei esta function:

 String.prototype.replaceAt = function (index, char) { return this.substr(0, index) + char + this.substr(index + char.length); } mystring.replaceAt(4, '') 

Só funciona se eu substituí-lo por outro personagem. Não irá simplesmente removê-lo.

Alguma ideia?

 var mystring = "crt/r2002_2"; mystring = mystring.replace('/r','/'); 

replaceá /r por / usando String.prototype.replace .

Alternativamente, você pode usar o regex com uma bandeira global (como sugerido por Erik Reppen & Sagar Gala , abaixo) para replace todas as ocorrências com

 mystring = mystring.replace(/\/r/g, '/'); 

Há sempre as funções de string, se você sabe que sempre removerá o quarto caractere:

 str.slice(0, 4) + str.slice(5, str.length)) 

Uma forma simples e funcional de javascript seria

mystring = mystring.split('/r').join('/')

simples, rápido, substitui globalmente e não precisa de funções ou protótipos

Seu primeiro func está quase certo. Apenas remova a flag ‘g’ que significa ‘global’ (edit) e dê um contexto para localizar o segundo ‘r’.

Edit: não viu que era o segundo ‘r’ antes, então acrescentou o ‘/’. Necessidades \ / para escaping do ‘/’ ao usar um argumento regEx. Obrigado pelos upvotes, mas eu estava errado, então eu vou corrigir e adicionar mais detalhes para as pessoas interessadas em entender o básico de regEx melhor, mas isso funcionaria:

 mystring.replace(/\/r/, '/') 

Agora, para a explicação excessiva:

Ao ler / escrever um padrão regEx, pense em termos de: seguido por seguido por <...

Em regEx poderia ser um de cada vez:

 /each char in this pattern/ 

Então leia como e, seguido por a, seguido por c, etc …

Ou um único poderia ser um caractere descrito por uma class de caractere:

 /[123!y]/ //any one of these /[^123!y]/ //anything but one of the chars following '^' (very useful/performance enhancing btw) 

Ou expandido para corresponder a uma quantidade de caracteres (mas ainda melhor pensar como um elemento único em termos do padrão sequencial):

 /a{2}/ //precisely two 'a' chars - matches identically as /aa/ would /[aA]{1,3}/ //1-3 matches of 'a' or 'A' /[a-zA-Z]+/ //one or more matches of any letter in the alphabet upper and lower //'-' denotes a sequence in a character class /[0-9]*/ //0 to any number of matches of any decimal character (/\d*/ would also work) 

Então smoosh um monte juntos:

  var rePattern = /[aA]{4,8}(Eat at Joes|Joes all you can eat)[0-5]+/g var joesStr = 'aaaAAAaaEat at Joes123454321 or maybe aAaAJoes all you can eat098765'; joesStr.match(rePattern); //returns ["aaaAAAaaEat at Joes123454321", "aAaAJoes all you can eat0"] //without the 'g' after the closing '/' it would just stop at the first match and return: //["aaaAAAaaEat at Joes123454321"] 

E é claro que eu tenho elaborado demais, mas meu ponto era simplesmente que isso:

 /cat/ 

é uma série de 3 elementos padrão (uma coisa seguida por uma coisa seguida por uma coisa).

E assim é isto:

 /[aA]{4,8}(Eat at Joes|Joes all you can eat)[0-5]+/ 

Tão maluco quanto regEx começa a parecer, tudo se divide em uma série de coisas (potencialmente coisas de múltiplos caracteres) seguindo uma a outra sequencialmente. Meio que um ponto básico, mas um que demorou um pouco para passar, então eu fui ao mar explicando isso aqui, pois acho que é um que ajudaria o OP e outros novos a entenderem o que está acontecendo. A chave para ler / escrever regEx é decompor essas partes.

Para a substituição global de ‘/ r’, esse código funcionou para mim.

 mystring = mystring.replace(/\/r/g,''); 

Apenas corrija seu replaceAt :

 String.prototype.replaceAt = function(index, charcount) { return this.substr(0, index) + this.substr(index + charcount); } mystring.replaceAt(4, 1); 

Eu chamaria isso de removeAt vez disso. 🙂

 return this.substr(0, index) + char + this.substr(index + char.length); 

char.length é zero. Você precisa adicionar 1 neste caso para pular o personagem.

Só funciona se eu substituí-lo por outro personagem. Não irá simplesmente removê-lo.

Isso ocorre porque quando char é igual a "" , char.length é 0, então suas subseqüências se combinam para formar a string original. Indo com sua tentativa de código, o seguinte irá funcionar:

 String.prototype.replaceAt = function (index, char) { return this.substr(0, index) + char + this.substr(index + 1); // this will 'replace' the character at index with char ^ } 
  • DEMO

Se é sempre o quarto char em yourString você pode tentar:

 yourString.replace(/^(.{4})(r)/, function($1, $2) { return $2; }); 

Eu não gosto de usar a function replace para remover caracteres da string. Isso não é lógico para fazer assim. Normalmente eu programo em C # (Sharp), e sempre que eu quero remover caracteres da string, eu uso o método Remove da class String, mas não substituo o método, mesmo que ele exista, porque quando eu estou prestes a remover, eu removo não substitua. Isso é lógico!

Em Javascript, não há function remove para string, mas há function substr. Você pode usar a function substr uma ou duas vezes para remover caracteres da string. Você pode fazer a seguinte function para remover caracteres no índice inicial para o final da string, assim como o método c # sobrecarga primeiro String.Remove (int startIndex):

 function Remove(str, startIndex) { return str.substr(0, startIndex); } 

e / ou você também pode fazer a seguinte function para remover caracteres no índice inicial e contar, assim como a segunda sobrecarga do método c # String.Remove (int startIndex, int count):

 function Remove(str, startIndex, count) { return str.substr(0, startIndex) + str.substr(startIndex + count); } 

e então você pode usar estas duas funções ou uma delas para as suas necessidades!

Exemplo:

 alert(Remove("crt/r2002_2", 4, 1)); 

Saída: crt / 2002_2

Atingir metas fazendo técnicas sem lógica pode causar confusões na compreensão do código e erros futuros, se você fizer isso muito em um projeto grande!

Em C # (Sharp), você pode criar um caractere vazio como ‘\ 0’. Talvez você possa fazer isso:

 String.prototype.replaceAt = function (index, char) { return this.substr(0, index) + char + this.substr(index + char.length); } mystring.replaceAt(4, '\0') 

Pesquise no google ou navegue no interent e verifique se o javascript permite criar caracteres vazios, como o C #. Se sim, então aprenda como fazê-lo, e talvez a function replaceAt funcione finalmente, e você conseguirá o que deseja!

Finalmente esse personagem ‘r’ será removido!

A seguinte function funcionou melhor para o meu caso:

 public static cut(value: string, cutStart: number, cutEnd: number): string { return value.substring(0, cutStart) + value.substring(cutEnd + 1, value.length); } 

O caminho mais curto seria usar splice

 var inputString = "abc"; // convert to array and remove 1 element at position 4 and save directly to the array itself let result = inputString.split("").splice(3, 1).join(); console.log(result);