Hoe vervang ik een teken bij een bepaalde index in JavaScript?

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.substring(0,index) + chr + str.substring(index+1);
}

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

Antwoord 3, autoriteit 13%

Dat kan niet. Neem de karakters voor en na de positie en voeg ze samen in een nieuwe string:

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

Antwoord 4, autoriteit 6%

str = str.split('');
str[3] = 'h';
str = str.join('');

Antwoord 5, autoriteit 5%

Er zijn hier veel antwoorden, en ze zijn allemaal gebaseerd op twee methoden:

• METHODE1: splits de tekenreeks met twee subtekenreeksen en vul het teken ertussen
• METHODE2: converteer de tekenreeks naar tekenarray, vervang één arraylid en voeg eraan toe

Persoonlijk zou ik deze twee methoden in verschillende gevallen gebruiken. Laat het me uitleggen.

@FabioPhms: Jouw methode was degene die ik in eerste instantie gebruikte en ik was bang dat het slecht is op string met veel karakters. De vraag is echter wat veel karakters zijn? Ik heb het getest op 10 “lorem ipsum”-paragrafen en het duurde een paar milliseconden. Toen heb ik het getest op een 10 keer grotere snaar – er was echt geen groot verschil. Hmm.

@vsync, @Cory MaWhorter: Uw opmerkingen zijn ondubbelzinnig; maar nogmaals, wat is een grote string? Ik ben het ermee eens dat voor 32…100kb de prestaties beter zouden moeten zijn en dat men substring-variant zou moeten gebruiken voor deze ene bewerking van karaktervervanging.

Maar wat gebeurt er als ik nogal wat vervangingen moet doen?

Ik moest mijn eigen tests uitvoeren om te bewijzen wat in dat geval sneller is. Laten we zeggen dat we een algoritme hebben dat een relatief korte string van 1000 karakters zal manipuleren. We verwachten dat gemiddeld elk teken in die string ~ 100 keer zal worden vervangen. Dus de code om zoiets te testen is:

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

Ik heb hiervoor een viool gemaakt, en het is hier.
Er zijn twee tests, TEST1 (substring) en TEST2 (arrayconversie).

Resultaten:

• TEST1: 195 ms
• TEST2: 6 ms

Het lijkt erop dat array-conversie substring met 2 ordes van grootte verslaat! Dus – wat is hier in godsnaam gebeurd???

Wat er feitelijk gebeurt, is dat alle bewerkingen in TEST2 op de array zelf worden gedaan, met behulp van toewijzingsexpressies zoals strarr2[p] = n. Toewijzing is erg snel in vergelijking met substring op een grote string, en het is duidelijk dat het gaat winnen.

Het draait dus allemaal om het kiezen van het juiste gereedschap voor de klus. Nogmaals.

Antwoord 6, autoriteit 5%

Werken met vectoren is meestal het meest effectief om contact op te nemen met String.

Ik stel de volgende functie voor:

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

Voer dit fragment uit:

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

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

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

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

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

var strArr = str.split("");
strArr[0] = 'h';
str = strArr.join("");

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

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

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

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

String.prototype.append = function (index,value) {
  return this.slice(0,index) + value + this.slice(index);
};
var s = "New string";
alert(s.append(4,"complete "));

var str = "hello world";
console.log(str);
var arr = [...str];
arr[0] = "H";
str = arr.join("");
console.log(str);

const str = 'Hello RegEx!';
const index = 11;
const replaceWith = 'p';
//'Hello RegEx!'.replace(/^(.{11})(.)/, `$1p`);
str.replace(new RegExp(`^(.{${ index }})(.)`), `$1${ replaceWith }`);
//< "Hello RegExp"

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

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

replaceAt( yourArrayOfIndexes, yourString/orArrayOfStrings ) 

function replaceAt(indexArray, [...string]) {
    const replaceValue = i => string[i] = <b>{string[i]}</b>;
    indexArray.forEach(replaceValue);
    return string;
}

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

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

function replaceAt() {
  const replaceAt = document.getElementById('replaceAt').value;
  const str = 'ThisIsATestStringToReplaceCharAtSomePosition';
  const newStr = Array.from(str).map((character, charIndex) => charIndex === (replaceAt - 1) ? '' : character).join('');
  console.log(`New string: ${newStr}`);
}

<input type="number" id="replaceAt" min="1" max="44" oninput="replaceAt()"/>

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

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

var str = "yash yas $dfdas.**";
console.log('Index Matched replace : ', str.replaceMatch('as', '*', 2) );
console.log('Index Matched replace : ', str.replaceMatch('y', '~', 1) );

Index Matched replace :  yash yas $dfd*.**
Index Matched replace :  yash ~as $dfdas.**

const myString = "Hello world";
const index = 3;
const stringBeforeIndex = myString.substring(0, index);
const stringAfterIndex = myString.substring(index + 1);
const replaceChar = "X";
myString = stringBeforeIndex + replaceChar + stringAfterIndex;
console.log("New string - ", myString)

const myString = "Hello world";
let index = 3;
myString =  myString.substring(0, index) + "X" + myString.substring(index + 1);

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