Come posso sostituire un carattere in un determinato indice in JavaScript?

Ho una stringa, diciamo Hello worlde devo sostituire il carattere all'indice 3. Come posso sostituire un carattere specificando un indice?

var str = "hello world";

Ho bisogno di qualcosa del genere

str.replaceAt(0,"h");

In JavaScript, le stringhe sono immutabili , il che significa che il meglio che puoi fare è creare una nuova stringa con il contenuto modificato e assegnare la variabile in modo che punti ad essa.

Dovrai definire replaceAt()tu stesso la funzione:

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

E usalo in questo modo:

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

Non esiste alcuna replaceAtfunzione in JavaScript. È possibile utilizzare il seguente codice per sostituire qualsiasi carattere in qualsiasi stringa nella posizione specificata:

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>

Non puoi. Prendi i caratteri prima e dopo la posizione e concateli in una nuova stringa:

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

Ci sono molte risposte qui e tutte sono basate su due metodi:

• METODO 1: dividere la stringa usando due sottostringhe e riempire il carattere tra loro
• METODO2: converti la stringa in array di caratteri, sostituisci un membro dell'array e unisciti a esso

Personalmente, userei questi due metodi in diversi casi. Lasciatemi spiegare.

@FabioPhms: il tuo metodo era quello inizialmente usato e temevo che fosse un problema con la stringa con molti caratteri. Tuttavia, la domanda è: quanti personaggi ci sono? L'ho testato su 10 paragrafi "Lorem ipsum" e ci sono voluti alcuni millisecondi. Poi l'ho provato su una stringa 10 volte più grande - non c'era davvero nessuna grande differenza. Hm.

@vsync, @Cory Mawhorter: i tuoi commenti non sono ambigui; tuttavia, di nuovo, cos'è una stringa di grandi dimensioni? Concordo sul fatto che per 32 ... 100kb le prestazioni dovrebbero essere migliori e si dovrebbe usare la variante di sottostringa per questa operazione di sostituzione dei caratteri.

Ma cosa succederà se dovrò effettuare parecchie sostituzioni?

Avevo bisogno di eseguire i miei test per dimostrare cosa è più veloce in quel caso. Diciamo che abbiamo un algoritmo che manipolerà una stringa relativamente corta composta da 1000 caratteri. Ci aspettiamo che in media ogni carattere in quella stringa venga sostituito ~ 100 volte. Quindi, il codice per testare qualcosa del genere è:

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

Ho creato un violino per questo, ed è qui . Esistono due test, TEST1 (sottostringa) e TEST2 (conversione array).

risultati:

• TEST1: 195ms
• TEST2: 6ms

Sembra che la conversione dell'array superi la sottostringa di 2 ordini di grandezza! Quindi - che diavolo è successo qui ???

Ciò che effettivamente accade è che tutte le operazioni in TEST2 vengono eseguite sull'array stesso, usando espressioni di assegnazione simili strarr2[p] = n. L'assegnazione è molto rapida rispetto alla sottostringa su una stringa di grandi dimensioni ed è evidente che vincerà.

Quindi, si tratta solo di scegliere lo strumento giusto per il lavoro. Ancora.

Il lavoro con i vettori è generalmente più efficace per contattare String.

Suggerisco la seguente funzione:

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

Esegui questo frammento:

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

Nelle stringhe Javascript sono immutabili, quindi devi fare qualcosa del genere

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

Per sostituire il carattere in x at i con 'h'

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

One-liner usando String.replace con callback (nessun supporto emoji):

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

Ha spiegato:

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

Questo metodo è utile per stringhe di lunghezza ridotta, ma può essere lento per testo più grande.

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. 
*/

@CemKalyoncu: Grazie per l'ottima risposta!

L'ho anche adattato leggermente per renderlo più simile al metodo Array.splice (e ho preso in considerazione la nota di @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!"

Funziona in modo simile a Array.splice:

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

Potresti provare

var strArr = str.split("");

strArr[0] = 'h';

str = strArr.join("");

Se si desidera sostituire i caratteri nella stringa, è necessario creare stringhe mutabili. Questi sono essenzialmente array di caratteri. Potresti creare una fabbrica:

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

Quindi è possibile accedere ai caratteri e l'intero array viene convertito in stringa se utilizzato come stringa:

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

Generalizzando la risposta di Afanasii Kurakin, abbiamo:

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

Espandiamo e spieghiamo sia l'espressione regolare che la funzione di sostituzione:

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'espressione regolare .corrisponde esattamente a un carattere. Lo gfa abbinare ogni personaggio in un ciclo for. La replacerfunzione viene chiamata in base al carattere originale e all'indice di dove si trova quel carattere nella stringa. Facciamo una semplice ifdichiarazione per determinare se restituiremo origCharo newChar.

È possibile estendere il tipo di stringa per includere il metodo inset:

String.prototype.append = function (index,value) {
  return this.slice(0,index) + value + this.slice(index);
};

var s = "New string";
alert(s.append(4,"complete "));

Quindi puoi chiamare la funzione:

Ho fatto una funzione che fa qualcosa di simile a quello che chiedi, controlla se un carattere nella stringa è in una matrice di caratteri non consentiti se lo sostituisce con ''

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

questo è facilmente raggiungibile con 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"

Ecco una versione che mi è venuta in mente se vuoi dare uno stile a parole o singoli caratteri nel loro indice in reagire / javascript.

replaceAt( yourArrayOfIndexes, yourString/orArrayOfStrings ) 

Esempio di lavoro: https://codesandbox.io/s/ov7zxp9mjq

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

Ed ecco un altro metodo alternativo

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

E un altro...

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

So che questo è vecchio ma la soluzione non funziona per l'indice negativo, quindi aggiungo una patch. spero che aiuti qualcuno

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

}

Diciamo che vuoi sostituire l' Kthindice (indice basato su 0) con 'Z'. Potresti usare Regexper fare questo.

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

È possibile utilizzare la seguente funzione per sostituire Charactero Stringin una posizione particolare di una stringa. Per sostituire tutti i seguenti casi di corrispondenza utilizzare la String.prototype.replaceAllMatches()funzione.

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

Produzione:

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

Ecco la mia soluzione usando l'operatore ternario e cartografico. Più leggibile, più facilmente gestibile e più facile da capire se me lo chiedi.

È più in es6 e migliori pratiche.

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()"/>

I metodi qui sono complicati. Lo farei così:

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

Questo è semplice come si arriva.