Comment remplacer un caractère à un index particulier en JavaScript?

Il n'y a pas de fonction replaceAt en JavaScript. Vous pouvez utiliser le code suivant pour remplacer n'importe quel caractère dans une chaîne à la position spécifiée:

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

<button onclick="Rep();">click</button>

Vous ne pouvez pas. prenez les caractères avant et après la position et concatez dans une nouvelle chaîne:

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

Il y a beaucoup de réponses ici, et toutes sont basées sur deux méthodes:

• METHOD1: diviser la chaîne en utilisant deux sous-chaînes et bourrer le caractère entre eux
• METHOD2: convertissez la chaîne en tableau de caractères, remplacez un membre du tableau et rejoignez-le

Personnellement, j'utiliserais ces deux méthodes dans des cas différents. Laissez-moi vous expliquer.

@ FabioPhms: votre méthode était celle que j'ai initialement utilisée et j'avais peur que ce soit mauvais sur string avec beaucoup de caractère. Cependant, la question Est ce qui est beaucoup de personnages? Je l'ai testé sur 10 paragraphes "lorem ipsum" et il a fallu quelques millisecondes. Ensuite, je l'ai testé sur 10 fois plus grande chaîne-il n'y avait vraiment pas de grande différence. Hm.

@Vsync, @Cory Mawhorter: vos commentaires sont sans ambiguïté; cependant, encore une fois, qu'est-ce qu'une grande chaîne? Je suis d'accord pour 32...Les performances de 100 Ko devraient être meilleures et on devrait utiliser substring-variant pour cette opération de remplacement de caractères.

Mais qu'est-ce qui va arriver si je dois faire quelques remplacements?

J'avais besoin d'effectuer mes propres tests pour prouver ce qui est plus rapide dans ce cas. Disons que nous avons un algorithme qui manipulera une chaîne relativement courte composée de 1000 caractères. Nous nous attendons à ce qu'en moyenne chaque caractère de cette chaîne soit remplacé ~100 fois. Donc, le code pour tester quelque chose comme ceci:

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*
}

J'ai créé un violon pour cela, et c'est ici. Il y a deux tests, TEST1 (substring) et test2 (conversion de tableau).

Résultats:

• TEST1: 195ms
• TEST2: 6ms

Il semble que la conversion de tableau bat la sous-chaîne de 2 ordres de grandeur! Donc, - ce que l'enfer qui s'est passé ici???

Ce qui se passe réellement, c'est que toutes les opérations dans TEST2 sont effectuées sur le tableau lui-même, en utilisant une expression d'affectation comme strarr2[p] = n. L'affectation est vraiment rapide par rapport à la sous-chaîne sur une grande chaîne, et il est clair qu'elle va gagner.

Donc, il s'agit de choisir le bon outil pour le travail. Encore une fois.

Travailler avec des vecteurs est généralement plus efficace pour contacter la chaîne.

Je suggère la fonction suivante:

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

Exécutez cet extrait:

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

En Javascript, les chaînes sont immuables, vous devez donc faire quelque chose comme

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

Pour remplacer le caractère dans x at I par ' 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();

<input id="x" type="text" value="White Dog" placeholder="Enter Text" />
<input id="index" type="number" min="0"value="6" style="width:50px" placeholder="index" />
<input id="text" type="text" value="F" placeholder="New character" />
<br>
<button id="submit" onclick="dothis()">Run</button>
<p id="output"></p>

Cette méthode est bonne pour les chaînes de petite longueur mais peut être lente pour un texte plus grand.

var x = "White Dog";
var arr = x.split(""); // ["W", "h", "i", "t", "e", " ", "D", "o", "g"]
arr.splice(6, 1, 'F');
var result = arr.join(""); // "White Fog"

/* 
  Here 6 is starting index and 1 is no. of array elements to remove and 
  final argument 'F' is the new character to be inserted. 
*/

Cela fonctionne comme Array.splice:

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

One-liner utilisant la chaîne.remplacer par callback:

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

@ CemKalyoncu: Merci pour la bonne réponse!

Je l'ai également légèrement adapté pour le rendre plus semblable au tableau.méthode d'épissure (et a pris en considération la note de @Ates):

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!"

J'ai fait une fonction qui fait quelque chose de similaire à ce que vous demandez, elle vérifie si un caractère dans string est dans un tableau de caractères non autorisés s'il le remplace par "

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

Si vous souhaitez remplacer des caractères dans une chaîne, vous devez créer des chaînes mutables. Ce sont essentiellement des tableaux de caractères. Vous pouvez créer une usine:

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

Ensuite, vous pouvez accéder aux caractères et le tableau entier se convertit en chaîne lorsqu'il est utilisé comme chaîne:

  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!"

Je sais que c'est vieux mais la solution ne fonctionne pas pour l'index négatif donc j'y ajoute un patch. espérons que cela aide quelqu'un

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

}

Vous pouvez étendre le type de chaîne pour inclure la méthode encart:

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

, Alors vous pouvez appeler la fonction:

Disons que vous voulez remplacer Kth index (index basé sur 0) par 'Z'. Vous pouvez utiliser Regex pour ce faire.

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

Les méthodes ici sont compliquées. Je le ferais de cette façon:

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

C'est aussi simple que cela.