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

Question

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

var str = "hello world";

Ho bisogno di qualcosa come

str.replaceAt(0,"h");

Answer 1

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 tu stesso la funzione replaceAt () :

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

Answer 2

Non esiste alcuna funzione replaceAt in JavaScript. Puoi 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>

Answer 3

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

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

Answer 4

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

• METODO1: dividi la stringa usando due sottostringhe e riempi 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. Lasciami spiegare.

@FabioPhms: il tuo metodo era quello che ho usato inizialmente e temevo che fosse un problema con la stringa con molti caratteri. Tuttavia, la domanda è: quanti personaggi ci sono? L'ho provato su 10 "lorem ipsum" paragrafi 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 dell'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 realmente accade è che tutte le operazioni in TEST2 vengono eseguite sull'array stesso, usando un'espressione di assegnazione come strarr2 [p] = n . L'assegnazione è molto rapida rispetto alla sottostringa di una stringa di grandi dimensioni ed è evidente che vincerà.

Quindi, si tratta solo di scegliere lo strumento giusto per il lavoro. Anche in questo caso.

Answer 5

Il lavoro con i vettori è in genere 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 snippet:

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

Answer 6

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'

Answer 7

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

Answer 8

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 piccole dimensioni ma può essere lento per testi più grandi.

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

Answer 9

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

Answer 10

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

Answer 11

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

Answer 12

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 puoi accedere ai caratteri e l'intero array si converte in stringa quando usato 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!"

Answer 13

Potresti provare

var strArr = str.split("");

strArr[0] = 'h';

str = strArr.join("");

Answer 14

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

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

Answer 15

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

}

Answer 16

Diciamo che vuoi sostituire l'indice Kth (indice basato su 0) con 'Z' . Per fare ciò puoi usare Regex .

var re = var re = new RegExp("((.){" + K + "})((.){1})")
str.replace(re, "$1A
 Diciamo che vuoi sostituire l'indice  Kth  (indice basato su 0) con  'Z' .
Per fare ciò puoi usare  Regex . 

");

Answer 17

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"

Answer 18

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

Answer 19

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. g fa corrispondere ogni carattere in un ciclo for. La funzione replacer viene chiamata in base al carattere originale e all'indice di dove si trova quel carattere nella stringa. Facciamo una semplice dichiarazione if per determinare se restituiremo origChar o newChar .

Answer 20

Puoi estendere il tipo di stringa per includere il metodo 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 "));

Quindi puoi chiamare la funzione:

Answer 21

È possibile utilizzare la seguente funzione per sostituire Character o String in una posizione particolare di una stringa. Per sostituire tutti i seguenti casi di corrispondenza, utilizzare la funzione 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;
};

Prova:

var str = "yash yas $dfdas.**";

console.log('Index Matched replace : ', str.replaceMatch('as', '*', 2) );
console.log('Index Matched replace : ', str.replaceMatch('y', '~', 1) );

Output:

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

Answer 22

I metodi qui sono complicati. Lo farei in questo modo:

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

Questo è semplice come si arriva.