Como posso remover um caractere de uma string usando Javascript?

Estou tão perto de conseguir isso, mas simplesmente não está certo. Tudo o que eu gostaria de fazer é remover o caractere rde uma string. O problema é que há mais de uma instância de rna sequência. No entanto, é sempre o caractere no índice 4 (portanto, o quinto caractere).

cadeia de exemplo: crt/r2002_2

O que eu quero: crt/2002_2

Essa função de substituição remove os dois r

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

Produz: ct/2002_2

Eu tentei esta função:

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

Só funciona se eu o substituir por outro caractere. Não o removerá simplesmente.

Alguma ideia?

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

será substituído /rpelo /uso String.prototype.replace.

Como alternativa, você pode usar regex com uma bandeira global (como sugerido por Erik Reppen e Sagar Gala , abaixo) para substituir todas as ocorrências por

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

EDIT: Como todo mundo está se divertindo muito aqui e o user1293504 parece não voltar tão cedo para responder a perguntas esclarecedoras, aqui está um método para remover o caractere N-ésimo de uma string:

String.prototype.removeCharAt = function (i) {
    var tmp = this.split(''); // convert to an array
    tmp.splice(i - 1 , 1); // remove 1 element from the array (adjusting for non-zero-indexed counts)
    return tmp.join(''); // reconstruct the string
}

console.log("crt/r2002_2".removeCharAt(4));

Como o user1293504 usou a contagem normal em vez de uma contagem com índice zero, precisamos remover 1 do índice, se você desejar usá-lo para replicar como as charAtobras não subtraem 1 do índice na terceira linha e, em tmp.splice(i, 1)vez disso, usam .

Uma maneira simples de javascript funcional seria

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

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

Sempre há as funções de string, se você souber que sempre removerá o quarto caractere:

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

Sua primeira função está quase certa. Apenas remova o sinalizador 'g' que significa 'global' (editar) e dê a ele algum contexto para identificar o segundo 'r'.

Edit: não vi que era o segundo 'r' antes, então adicionei o '/'. Precisa \ / para escapar do '/' ao usar um argumento regEx. Obrigado pelas votações, mas eu estava errado, então corrigirei e adicionarei mais detalhes para as pessoas interessadas em entender melhor o básico do regEx, mas isso funcionaria:

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

Agora, a explicação excessiva:

Ao ler / escrever um padrão regEx, pense em termos de: <um caractere ou conjunto de caracteres> seguido por <a caractere ou conjunto de caracteres> seguido por <...

No regEx, <um caractere ou conjunto de caracteres> pode 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 <a caractere ou conjunto de caracteres> poderia ser caracteres descritos por uma classe de caracteres:

/[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 seqüencial):

/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 junte um monte:

   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 exagerei, mas meu argumento era simplesmente o seguinte:

/cat/

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

E assim é isso:

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

Por mais maluco que o regEx comece a parecer, tudo se decompõe em uma série de coisas (coisas potencialmente com vários caracteres) que se sucedem sequencialmente. É um ponto básico, mas que demorei um pouco para passar, por isso exagerei na explicação aqui, pois acho que ajudaria o OP e outros novos no RegEx a entender o que está acontecendo. A chave para ler / escrever regEx é dividi-la em partes.

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

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

Basta corrigir o seu replaceAt:

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

mystring.replaceAt(4, 1);

Eu chamaria assim removeAt. :)

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

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

Se for sempre o quarto caractere em suaString, você pode tentar:

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

Só funciona se eu o substituir por outro caractere. Não o removerá simplesmente.

Isso ocorre porque quando charé igual a "", char.lengthé 0, então suas substrings se combinam para formar a sequência original. Indo com sua tentativa de código, o seguinte 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

Criar função como abaixo

  String.prototype.replaceAt = function (index, char) {
      if(char=='') {
          return this.slice(0,index)+this.substr(index+1 + char.length);
      } else {
          return this.substr(0, index) + char + this.substr(index + char.length);
      }
  }

Para substituir, dê um caractere como abaixo

  var a="12346";
  a.replaceAt(4,'5');

e para remover o caractere no índice definido, forneça o segundo parâmetro como string vazia

a.replaceAt(4,'');

Se você deseja apenas remover um caractere e se souber o índice de um caractere que deseja remover, poderá usar a seguinte função:

/**
 * Remove single character at particular index from string
 * @param {*} index index of character you want to remove
 * @param {*} str string from which character should be removed
 */
function removeCharAtIndex(index, str) {
    var maxIndex=index==0?0:index;
    return str.substring(0, maxIndex) + str.substring(index, str.length)
}

Não gosto de usar a função replace para remover caracteres da string. Isso não é lógico para fazer assim. Normalmente, programa em C # (Sharp) e, sempre que quero remover caracteres da string, uso o método Remove da classe String, mas não o método Replace, mesmo que exista, porque quando estou prestes a remover, removo, sem substituição. Isso é lógico!

Em Javascript, não há função de remoção para string, mas existe a função substr. Você pode usar a função substr uma ou duas vezes para remover caracteres da string. Você pode criar a seguinte função para remover caracteres no índice inicial até o final da sequência, assim como o método c # sobrecarrega primeiro a String.Remove (int startIndex):

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

e / ou você também pode criar a seguinte função para remover caracteres no índice inicial e na contagem, 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 essas duas funções ou uma delas para suas necessidades!

Exemplo:

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

Saída: crt / 2002_2

Atingir objetivos executando técnicas sem lógica pode causar confusões no entendimento do código e erros futuros, se você fizer muito isso em um projeto grande!

A seguinte função 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);
}

A maneira mais curta seria usar a emenda

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

Você pode usar isto: if ( str[4] === 'r' ) str = str.slice(0, 4) + str.slice(5)

Explicação:

1. if ( str[4] === 'r' )
   Verifique se o quinto caractere é um 'r'
   

2. str.slice(0, 4)
   Corte a corda para obter tudo antes do 'r'

3. + str.slice(5)
   Adicione o restante da string.

Minificado: s=s[4]=='r'?s.slice(0,4)+s.slice(5):s [37 bytes!]

DEMO:

function remove5thR (s) {
  s=s[4]=='r'?s.slice(0,4)+s.slice(5):s;
  console.log(s); // log output
}

remove5thR('crt/r2002_2')  // > 'crt/2002_2'
remove5thR('crt|r2002_2')  // > 'crt|2002_2'
remove5thR('rrrrr')        // > 'rrrr'
remove5thR('RRRRR')        // > 'RRRRR' (no change)

let str = '1234567';
let index = 3;
str = str.substring(0, index) + str.substring(index + 1);
console.log(str) // 123567 - number "4" under index "3" is removed

Isso é melhoria da resposta simpleigh (omitir comprimento)

s.slice(0,4)+s.slice(5)

let s="crt/r2002_2";

let o= s.slice(0,4)+s.slice(5);

let delAtIdx= (s,i) => s.slice(0,i)+s.slice(i+1); // this function remove letter at index i

console.log(o);
console.log(delAtIdx(s,4));

Em C # (Nítido), 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 por vários locais e verifique se o javascript permite criar caracteres vazios, como o C #. Se sim, aprenda como fazê-lo e talvez a função replaceAt finalmente funcione, e você conseguirá o que deseja!

Finalmente, esse caractere 'r' será removido!