Como faço para replace um caractere em um determinado índice em JavaScript?

Eu tenho uma string, digamos Hello world e eu preciso replace o char no índice 3. Como posso replace um char, especificando um índice?

 var str = "hello world"; 

Eu preciso de algo parecido

 str.replaceAt(0,"h"); 

Em JavaScript, as strings são imutáveis , o que significa que o melhor que você pode fazer é criar uma nova string com o conteúdo alterado e atribuir a variável para apontar para ela.

Você precisará definir a function replaceAt() :

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

E usá-lo assim:

 var hello="Hello World"; alert(hello.replaceAt(2, "!!")); //should display He!!o World 

Não há function replaceAt em JavaScript. Você pode usar o seguinte código para replace qualquer caractere em qualquer string na posição especificada:

 function Rep() { var str = 'Hello World'; str = setCharAt(str,4,'a'); alert(str); } function setCharAt(str,index,chr) { if(index > str.length-1) return str; return str.substr(0,index) + chr + str.substr(index+1); } 
  

Você não pode. Pegue os caracteres antes e depois da posição e entre em uma nova string:

 var s = "Hello world"; var index = 3; s = s.substr(0, index) + 'x' + s.substr(index + 1); 

Há muitas respostas aqui, e todas elas são baseadas em dois methods:

  • MÉTODO1: dividir a string usando duas substrings e preencher o caractere entre elas
  • MÉTODO2: converta a cadeia em matriz de caracteres, substitua um membro da matriz e junte-o

Pessoalmente, eu usaria esses dois methods em diferentes casos. Deixe-me explicar.

@FabioPhms: Seu método foi o que eu usei inicialmente e fiquei com medo de que seja ruim na string com muitos caracteres. No entanto, pergunta é o que é um monte de personagens? Eu testei em 10 “lorem ipsum” parágrafos e demorou alguns milissegundos. Então eu testei em 10 vezes maior string – realmente não houve grande diferença. Hm

@vsync, @Cory Mawhorter: Seus comentários não são ambíguos; no entanto, novamente, o que é uma string grande? Concordo que para 32 … o desempenho de 100kb deve ser melhor e deve-se usar uma variante de substring para essa operação de substituição de caractere.

Mas o que acontecerá se eu tiver que fazer algumas substituições?

Eu precisava fazer meus próprios testes para provar o que é mais rápido nesse caso. Digamos que temos um algoritmo que manipulará uma string relativamente curta que consiste em 1000 caracteres. Esperamos que, em média, cada caractere nessa sequência seja substituído ~ 100 vezes. Então, o código para testar algo assim é:

 var str = "... {A LARGE STRING HERE} ..."; for(var i=0; i<100000; i++) { var n = '' + Math.floor(Math.random() * 10); var p = Math.floor(Math.random() * 1000); // replace character *n* on position *p* } 

Eu criei um violino para isso e está aqui . Existem dois testes, TEST1 (substring) e TEST2 (conversão de array).

Resultados:

  • TESTE 1: 195 ms
  • TEST2: 6ms

Parece que a conversão de array bate a substring em 2 ordens de magnitude! Então, o que diabos aconteceu aqui?

O que realmente acontece é que todas as operações no TEST2 são feitas no próprio array, usando expressões de atribuição como strarr2[p] = n . A atribuição é muito rápida em comparação com a substring em uma string grande, e está claro que ela vai vencer.

Então, é tudo sobre como escolher a ferramenta certa para o trabalho. Novamente.

Trabalhar com vetores geralmente é mais eficiente para entrar em contato com o String.

Eu sugiro a seguinte function:

 String.prototype.replaceAt=function(index, char) { var a = this.split(""); a[index] = char; return a.join(""); } 

Execute este trecho:

 String.prototype.replaceAt=function(index, char) { var a = this.split(""); a[index] = char; return a.join(""); } var str = "hello world"; str = str.replaceAt(3, "#"); document.write(str); 

Em JavaScript strings são imutáveis, então você tem que fazer algo como

 var x = "Hello world" x = x.substring(0, i) + 'h' + x.substring(i+1); 

Para replace o caractere em x em i por ‘h’

 str = str.split(''); str[3] = 'h'; str = str.join(''); 
 function dothis() { var x = document.getElementById("x").value; var index = document.getElementById("index").value; var text = document.getElementById("text").value; var arr = x.split(""); arr.splice(index, 1, text); var result = arr.join(""); document.getElementById('output').innerHTML = result; console.log(result); } dothis(); 
    

Isso funciona semelhante ao Array.splice :

 String.prototype.splice = function (i, j, str) { return this.substr(0, i) + str + this.substr(j, this.length); }; 

One-liner usando String.replace com retorno de chamada:

 // 0 - index to replace, 'f' - replacement string 'dog'.replace(/./g, (c, i) => i == 0? 'f': c) // "fog" 

@CemKalyoncu: Obrigado pela ótima resposta!

Eu também o adaptei um pouco para torná-lo mais parecido com o método Array.splice (e levei a nota da @Ates em consideração):

 spliceString=function(string, index, numToDelete, char) { return string.substr(0, index) + char + string.substr(index+numToDelete); } var myString="hello world!"; spliceString(myString,myString.lastIndexOf('l'),2,'mhole'); // "hello wormhole!" 

Eu fiz uma function que faz algo parecido com o que você pergunta, ele verifica se um caractere em string está em uma matriz de caracteres não permitidos se for substituído por ”

  var validate = function(value){ var notAllowed = [";","_",">","< ","'","%","$","&","/","|",":","=","*"]; for(var i=0; i -1){ value = value.replace(value.charAt(i), ""); value = validate(value); } } return value; } 

Se você quiser replace caracteres em string, crie strings mutáveis. Estes são essencialmente matrizes de caracteres. Você poderia criar uma fábrica:

  function MutableString(str) { var result = str.split(""); result.toString = function() { return this.join(""); } return result; } 

Então você pode acessar os caracteres e toda a matriz é convertida em string quando usada como string:

  var x = MutableString("Hello"); x[0] = "B"; // yes, we can alter the character x.push("!"); // good performance: no new string is created var y = "Hi, "+x; // converted to string: "Hi, Bello!" 

Eu sei que isso é antigo, mas a solução não funciona para o índice negativo, então eu adiciono um patch a ele. espero que ajude alguém

 String.prototype.replaceAt=function(index, character) { if(index>-1) return this.substr(0, index) + character + this.substr(index+character.length); else return this.substr(0, this.length+index) + character + this.substr(index+character.length); } 

Você pode estender o tipo de string para include o método inserido:

 String.prototype.insert = function (index,value) { return this.substr(0, index) + value + this.substr(index,this.length); }; var s = "new function"; alert(s.insert(4,"insert string ")); 

Vamos dizer que você quer replace o índice Kth (índice baseado em 0) com 'Z' . Você poderia usar o Regex para fazer isso.

 var re = var re = new RegExp("((.){" + K + "})((.){1})") str.replace(re, "$1A$`"); 

Os methods aqui são complicados. Eu faria assim:

 var myString = "this is my string"; myString = myString.replace(myString.charAt(number goes here), "insert replacement here"); 

Isso é tão simples quanto parece.