web-dev-qa-db-de.com

Wie ersetze ich ein Zeichen an einem bestimmten Index in JavaScript?

Ich habe einen String, sagen wir Hello world, und ich muss das Zeichen in Index 3 ersetzen. Wie kann ich ein Zeichen durch Angeben eines Index ersetzen?

var str = "hello world";

Ich brauche so etwas

str.replaceAt(0,"h");
437
Santhosh

In JavaScript sind Zeichenfolgen immutable . Dies bedeutet, dass Sie am besten eine neue Zeichenfolge mit dem geänderten Inhalt erstellen und die Variable so zuweisen, dass sie darauf verweist.

Sie müssen die Funktion replaceAt() selbst definieren:

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

Und benutze es so:

var hello="Hello World";
alert(hello.replaceAt(2, "!!")); //should display He!!o World
504
Cem Kalyoncu

Es gibt keine replaceAt Funktion in JavaScript. Sie können den folgenden Code verwenden, um ein beliebiges Zeichen in einer beliebigen Zeichenfolge an der angegebenen Position zu ersetzen:

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>
81
rahul

Du kannst nicht Nimm die Zeichen vor und nach der Position und concat in einen neuen String:

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

Hier gibt es viele Antworten, und alle basieren auf zwei Methoden:

  • METHOD1: Teilen Sie den String mit zwei Teilstrings und füllen Sie das Zeichen dazwischen
  • METHOD2: Konvertieren Sie die Zeichenfolge in ein Zeichenarray, ersetzen Sie ein Arraymitglied und fügen Sie es hinzu

Ich persönlich würde diese beiden Methoden in verschiedenen Fällen anwenden. Lassen Sie mich erklären.

@FabioPhms: Deine Methode war die, die ich anfangs verwendet habe, und ich hatte befürchtet, dass die Zeichenfolge schlecht ist. Die Frage ist jedoch, was viele Charaktere sind. Ich habe es in 10 "Lorem ipsum" -Absätzen getestet und es dauerte einige Millisekunden. Dann habe ich es an einer 10-fach größeren Saite getestet - es gab wirklich keinen großen Unterschied. Hm.

@vsync, @Cory Mawhorter: Ihre Kommentare sind eindeutig; Was ist jedoch eine große Zeichenfolge? Ich bin damit einverstanden, dass für 32 ... 100kb Leistung besser sein sollte und man für diese eine Operation der Zeichenersetzung die substring-Variante verwenden sollte.

Was passiert aber, wenn ich einige Nachfolger machen muss?

Ich musste meine eigenen Tests durchführen, um zu beweisen, was in diesem Fall schneller ist. Nehmen wir an, wir haben einen Algorithmus, der eine relativ kurze Zeichenfolge mit 1000 Zeichen manipuliert. Wir erwarten, dass im Durchschnitt jedes Zeichen in dieser Zeichenkette ~ 100 Mal ersetzt wird. So lautet der Code, um so etwas zu testen:

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

Ich habe eine Geige dafür erstellt, und es ist hier . Es gibt zwei Tests, TEST1 (Teilzeichenfolge) und TEST2 (Array-Konvertierung).

Ergebnisse:

  • Test1: 195 ms
  • Test2: 6 ms

Es scheint, dass die Array-Umwandlung den Teilstring um 2 Größenordnungen übertrifft! Also, was zum Teufel ist hier passiert ???

Was tatsächlich passiert, ist, dass alle Operationen in TEST2 im Array selbst ausgeführt werden und den Zuweisungsausdruck wie strarr2[p] = n verwenden. Die Zuweisung ist im Vergleich zu einer großen Zeichenfolge sehr schnell, und es ist klar, dass sie gewinnen wird.

Es geht also darum, das richtige Werkzeug für den Job zu wählen. Nochmal.

29

Die Arbeit mit Vektoren ist normalerweise am effektivsten, um mit String in Kontakt zu treten.

Ich schlage folgende Funktion vor:

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

Führen Sie dieses Snippet aus:

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

28
Fabio Phms

In Javascript sind Zeichenfolgen unveränderlich

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

Um das Zeichen in x an i durch 'h' zu ersetzen

25
DevDevDev
str = str.split('');
str[3] = 'h';
str = str.join('');
24
colllin

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>

Diese Methode eignet sich für Zeichenfolgen mit geringer Länge, kann jedoch für größeren Text langsam sein.

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

Dies funktioniert ähnlich wie Array.splice:

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

Einzeiler mit String.replace mit Callback (keine Emoji-Unterstützung):

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

Erklärt:

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

@CemKalyoncu: Danke für die tolle Antwort!

Ich habe es auch ein wenig angepasst, um es der Array.splice-Methode ähnlicher zu machen (und berücksichtigt @Ates 'Anmerkung):

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

Wenn Sie Zeichen in einer Zeichenfolge ersetzen möchten, sollten Sie veränderliche Zeichenfolgen erstellen. Dies sind im Wesentlichen Zeichenarrays. Sie könnten eine Fabrik erstellen:

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

Dann können Sie auf die Zeichen zugreifen und das gesamte Array wird in String umgewandelt, wenn es als String verwendet wird:

  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!"
1
Jan Turoň

Ich weiß, das ist alt, aber die Lösung funktioniert nicht für den negativen Index, also füge ich einen Patch hinzu. hoffe es hilft jemandem

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

}
1
cesar moro

Ich habe eine Funktion ausgeführt, die in etwa dem entspricht, was Sie fragen. Sie prüft, ob ein Zeichen in einem String in einem Array nicht zulässiger Zeichen enthalten ist.

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

Du könntest es versuchen

var strArr = str.split("");

strArr[0] = 'h';

str = strArr.join("");
1
Mehulkumar

Um die Antwort von Afanasii Kurakin zu verallgemeinern, haben wir:

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

Lassen Sie uns sowohl den regulären Ausdruck als auch die Ersetzungsfunktion erweitern und erklären:

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

Der reguläre Ausdruck . entspricht genau einem Zeichen. Das g sorgt dafür, dass es mit jedem Zeichen in einer for-Schleife übereinstimmt. Die Funktion replacer wird aufgerufen, wenn sowohl das ursprüngliche Zeichen als auch der Index angegeben werden, in dem sich dieses Zeichen in der Zeichenfolge befindet. Wir geben eine einfache if -Anweisung ab, um zu bestimmen, ob wir entweder origChar oder newChar zurückgeben.

0
Stephen Quan

Sie können etwas verwenden, das als Ersetzen bezeichnet wird. Es ersetzt also einen bestimmten Teil der Zeichenfolge, der zum Beispiel angegeben ist:

function replaceTheString() {
  const str = "Donald Trump";
  console.log(str.replace("Tr", "L"));
}

Wenn Sie die Funktion ausführen, wird Donald Lump in die Konsole ausgegeben. Natürlich kannst du das mit jedem Buchstaben machen und es wird funktionieren. Wenn Sie string.replace besser verstehen möchten, empfehlen wir Ihnen Folgendes: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace)

0
Samuel Chen

Sie können den String-Typ erweitern, um die Inset-Methode einzuschließen:

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

Dann können Sie die Funktion aufrufen:

0
mbadeveloper

Hier ist eine Version, die ich mir ausgedacht habe, wenn Sie Wörter oder einzelne Zeichen in ihrem Index formatieren möchten.

replaceAt( yourArrayOfIndexes, yourString/orArrayOfStrings ) 

Arbeitsbeispiel: https://codesandbox.io/s/pjp6jk48jj

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

Und hier ist eine andere alternative Methode

function replaceAt(indexArray, inputString) {
  const string = [...inputString];
  const startTag = '<b>';
  const endTag = '</b>';
  const tagLetter = i => string.splice(i, 1, startTag + string[i] + endTag);
  indexArray.forEach(tagLetter);
  return string.join('');
}

Und ein anderer...

function replaceAt(indexArray, string) {
  let newString = [...string];

  for (let i = 0; i < indexArray.length; i++) {
    newString = Object.assign(newString, {
      [indexArray[i]]: <b>{newString[indexArray[i]]}</b>
    });
  }

  return newString;
}
0
Matt Wright

Sie können die folgende Funktion verwenden, um Character oder String an einer bestimmten Position eines Strings zu ersetzen. Um alle folgenden Übereinstimmungen zu ersetzen, verwenden Sie die Funktion 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;
};

Prüfung:

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

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

Ausgabe:

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

dies ist mit RegExp leicht zu erreichen!

const str = 'Hello RegEx!';
const index = 11;
const replaceWith = 'p';

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

//< "Hello RegExp"
0
Madmadi

Angenommen, Sie möchten den Kth-Index (0-basierten Index) durch 'Z' ersetzen. Sie können Regex verwenden.

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