Comment remplacer un personnage à un index particulier en JavaScript?
https://stackoverflow.com/questions/1431094
-
07-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
J'ai une chaîne, disons Hello world et je dois remplacer le caractère à l'index 3. Comment remplacer un caractère en spécifiant un index?
var str = "hello world";
j'ai besoin de quelque chose comme
str.replaceAt(0,"h");
La solution
En JavaScript, les chaînes sont immuables , ce qui signifie que le mieux que vous puissiez faire est de créer une nouvelle chaîne avec le contenu modifié et d'affecter la variable à pointer dessus.
Vous devrez définir vous-même la fonction replaceAt () :
String.prototype.replaceAt=function(index, replacement) {
return this.substr(0, index) + replacement+ this.substr(index + replacement.length);
}
Et utilisez-le comme ceci:
var hello="Hello World";
alert(hello.replaceAt(2, "!!")); //should display He!!o World
Autres conseils
Il n'y a pas de fonction replaceAt dans JavaScript. Vous pouvez utiliser le code suivant pour remplacer un caractère dans une chaîne quelconque à 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 concat 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 reposent sur deux méthodes:
- METHOD1: diviser la chaîne en deux sous-chaînes et insérer le caractère entre elles
- METHOD2: convertir la chaîne en tableau de caractères, remplacer un membre du tableau et le joindre
Personnellement, j'utiliserais ces deux méthodes dans des cas différents. Laissez-moi vous expliquer.
@FabioPhms: Votre méthode était celle que j'avais initialement utilisée et j'avais peur que ce soit une mauvaise chaîne avec beaucoup de caractères. Cependant, la question est ce qui est beaucoup de caractères? Je l’ai testé sur 10 "lorem ipsum". paragraphes et il a fallu quelques millisecondes. Ensuite, je l'ai testé sur une corde 10 fois plus grosse - il n'y avait pas vraiment 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 conviens que pour 32 ... 100 Ko, les performances devraient être meilleures et l’on devrait utiliser une variante de chaîne pour cette seule opération de remplacement de caractères.
Mais qu'arrivera-t-il si je dois effectuer quelques remplacements?
Je devais 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é environ 100 fois. Donc, le code pour tester quelque chose comme ceci est:
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 existe deux tests, TEST1 (sous-chaîne) et TEST2 (conversion de tableau).
Résultats:
- TEST1: 195ms
- TEST2: 6 ms
Il semble que la conversion de tableau bat la sous-chaîne de 2 ordres de grandeur! Alors, qu'est-ce qui s'est passé ici ???
En réalité, toutes les opérations dans TEST2 sont effectuées sur le tableau lui-même, en utilisant une expression d'affectation telle que strarr2 [p] = n . L’attribution est très rapide comparée à la sous-chaîne d’une grande chaîne, et il est clair qu’elle va gagner.
Il s’agit donc de choisir le bon outil pour le poste. Encore une fois.
Travailler avec des vecteurs est généralement plus efficace pour contacter String.
Je suggère la fonction suivante:
String.prototype.replaceAt=function(index, char) {
var a = this.split("");
a[index] = char;
return a.join("");
}
Exécuter 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 sur 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 convient aux chaînes de petite taille, mais peut être lente pour les textes plus volumineux.
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.
*/
Un seul support utilisant String.replace avec callback (pas de support emoji):
// 0 - index to replace, 'f' - replacement string
'dog'.replace(/./g, (c, i) => i == 0? 'f': c)
// "fog"
Expliqué:
//String.replace will call the callback on each pattern match
//in this case - each character
'dog'.replace(/./g, function (character, index) {
if (index == 0) //we want to replace the first character
return 'f'
return character //leaving other characters the same
})
@CemKalyoncu: Merci pour cette excellente réponse!
Je l'ai également légèrement adapté pour le rapprocher de la méthode Array.splice (et j'ai pris en compte 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!"
Cela fonctionne de la même manière que Array.splice :
String.prototype.splice = function (i, j, str) {
return this.substr(0, i) + str + this.substr(j, this.length);
};
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 l'ensemble du tableau est converti en chaîne lorsqu'il est utilisé en tant que 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!"
Vous pouvez essayer
var strArr = str.split("");
strArr[0] = 'h';
str = strArr.join("");
J'ai créé une fonction qui fait quelque chose de similaire à ce que vous demandez, elle vérifie si un caractère de chaîne fait partie d'un tableau de caractères non autorisés s'il le remplace par un ''
var validate = function(value){
var notAllowed = [";","_",">","<","'","%","<*>quot;,"&","/","|",":","=","*"];
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;
}
Je sais que c’est vieux, mais la solution ne fonctionnant pas avec un index négatif, j’ajoute un correctif. espérons que cela aidera 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);
}
Disons que vous souhaitez remplacer l'index Kth (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 Disons que vous souhaitez remplacer l'index Kth (index basé sur 0) par 'Z' .
Vous pouvez utiliser Regex pour ce faire.
");
Ceci est facilement réalisable avec RegExp!
const str = 'Hello RegEx!';
const index = 11;
const replaceWith = 'p';
//'Hello RegEx!'.replace(/^(.{11})(.)/, `$1p`);
str.replace(new RegExp(`^(.{${ index }})(.)`), `$1${ replaceWith }`);
//< "Hello RegExp"
Voici une version que j'ai créée si vous souhaitez styliser des mots ou des caractères individuels à leur index dans react / javascript.
replaceAt( yourArrayOfIndexes, yourString/orArrayOfStrings )
Exemple de travail: https://codesandbox.io/s/ov7zxp9mjq
function replaceAt(indexArray, [...string]) {
const replaceValue = i => string[i] = <b>{string[i]}</b>;
indexArray.forEach(replaceValue);
return string;
}
Et voici une autre méthode alternative
function replaceAt(indexArray, [...string]) {
const startTag = '<b>';
const endTag = '</b>';
const tagLetter = i => string.splice(i, 1, startTag + string[i] + endTag);
indexArray.forEach(tagLetter);
return string.join('');
}
Et un autre ...
function replaceAt(indexArray, [...string]) {
for (let i = 0; i < indexArray.length; i++) {
string = Object.assign(string, {
[indexArray[i]]: <b>{string[indexArray[i]]}</b>
});
}
return string;
}
Généralisant la réponse de Afanasii Kurakin, nous avons:
function replaceAt(str, index, ch) {
return str.replace(/./g, (c, i) => i == index ? ch : c)
}
let str = 'Hello World'
str = replaceAt(str, 1, 'u')
console.log(str) // Hullo World
Développons et expliquons l'expression régulière et la fonction de remplacement:
function replaceAt(str, index, newChar) {
function replacer(origChar, strIndex) {
if (strIndex === index)
return newChar
else
return origChar
}
return str.replace(/./g, replacer)
}
let str = 'Hello World'
str = replaceAt(str, 1, 'u')
console.log(str) // Hullo World
L'expression régulière . correspond exactement à un caractère. Le g fait en sorte qu'il corresponde à tous les caractères d'une boucle for. La fonction replacer est appelée en fonction du caractère d'origine et de l'index de l'emplacement de ce caractère dans la chaîne. Nous faisons une simple instruction if pour déterminer si nous allons renvoyer origChar ou newChar .
Vous pouvez étendre le type de chaîne pour inclure la méthode inset:
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 "));
Ensuite, vous pouvez appeler la fonction:
Vous pouvez utiliser la fonction suivante pour remplacer Caractère ou Chaîne à une position particulière d'une chaîne. Pour remplacer tous les cas de correspondance suivants, utilisez la fonction String.prototype.replaceAllMatches () .
String.prototype.replaceMatch = function(matchkey, replaceStr, matchIndex) {
var retStr = this, repeatedIndex = 0;
for (var x = 0; (matchkey != null) && (retStr.indexOf(matchkey) > -1); x++) {
if (repeatedIndex == 0 && x == 0) {
repeatedIndex = retStr.indexOf(matchkey);
} else { // matchIndex > 0
repeatedIndex = retStr.indexOf(matchkey, repeatedIndex + 1);
}
if (x == matchIndex) {
retStr = retStr.substring(0, repeatedIndex) + replaceStr + retStr.substring(repeatedIndex + (matchkey.length));
matchkey = null; // To break the loop.
}
}
return retStr;
};
Test:
var str = "yash yas $dfdas.**";
console.log('Index Matched replace : ', str.replaceMatch('as', '*', 2) );
console.log('Index Matched replace : ', str.replaceMatch('y', '~', 1) );
Sortie:
Index Matched replace : yash yas $dfd*.**
Index Matched replace : yash ~as $dfdas.**
Les méthodes décrites 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.
