如何在 JavaScript 中替换特定索引处的字符？

在 JavaScript 中，字符串是不可变的，这意味着您能做的最好的事情就是使用更改的内容创建一个新字符串，并将变量分配给它。

您需要自己定义 replaceAt() 函数：

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

并像这样使用它：

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

---

JavaScript 中没有 replaceAt 函数。您可以使用以下代码替换指定位置的任何字符串中的任何字符：

function rep() { var str = 'Hello World'; str = setCharAt(str,4,'a');警报（str）； } function setCharAt(str,index,chr) { if(index > str.length-1) return str;返回 str.substring(0,index) + chr + str.substring(index+1); } 点击

---

你不能。取位置前后的字符并连接成一个新字符串：

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

---

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

---

这里有很多答案，所有答案都基于两种方法：

METHOD1：使用两个子字符串拆分字符串并将字符填充在它们之间

METHOD2：将字符串转换为字符数组，替换一个数组成员并加入

就个人而言，我会在不同的情况下使用这两种方法。让我解释。

@FabioPhms：您的方法是我最初使用的方法，我担心它对包含大量字符的字符串不好。然而，问题是什么是很多字符？我在 10 个“lorem ipsum”段落上对其进行了测试，只花了几毫秒。然后我在 10 倍大的绳子上测试了它——真的没有什么大的区别。嗯。

@vsync，@Cory Mawhorter：您的评论很明确；然而，再一次，什么是大字符串？我同意对于 32...100kb 的性能应该更好，并且应该使用 substring-variant 进行这一字符替换操作。

但是，如果我必须进行相当多的替换，会发生什么？

我需要执行自己的测试来证明在这种情况下什么更快。假设我们有一个算法可以处理一个由 1000 个字符组成的相对较短的字符串。我们预计该字符串中的每个字符平均将被替换约 100 次。所以，测试这样的代码是：

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

我为此创建了一个小提琴，它是 here。有两个测试，TEST1（子字符串）和TEST2（数组转换）。

结果：

测试1：195ms

测试2：6ms

似乎数组转换比子字符串高了 2 个数量级！所以 - 这里到底发生了什么？？？

实际发生的是 TEST2 中的所有操作都是在数组本身上完成的，使用像 strarr2[p] = n 这样的赋值表达式。与大字符串上的子字符串相比，赋值真的很快，而且很明显它会赢。

因此，关键在于为工作选择正确的工具。再次。

---

使用向量通常是最有效的联系字符串。

我建议以下功能：

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

运行此代码段：

String.prototype.replaceAt=function(index, char) { var a = this.split(""); a[索引] = 字符；返回 a.join(""); } var str = "你好世界"; str = str.replaceAt(3, "#"); document.write(str);

---

在 Javascript 中，字符串是不可变的，所以你必须做类似的事情

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

用 'h' 替换 i 处 x 中的字符

---

函数 dothis() { var x = document.getElementById("x").value; var index = document.getElementById("index").value; var text = document.getElementById("text").value; var length = document.getElementById("length").value; var arr = x.split(""); arr.splice（索引，长度，文本）； var 结果 = arr.join(""); document.getElementById('output').innerHTML = 结果；控制台.log（结果）； } 做这个（）;
运行

此方法适用于长度较小的字符串，但对于较大的文本可能会很慢。

var x = "White Dog";
var arr = x.split(""); // ["W", "h", "i", "t", "e", " ", "D", "o", "g"]
arr.splice(6, 1, 'F');

/* 
  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. 
*/
var result = arr.join(""); // "White Fog"

---

使用带有回调的 String.replace 的单线（不支持表情符号）：

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

---

概括 Afanasii Kurakin 的答案，我们有：

function replaceAt(str, index, ch) { return str.replace(/./g, (c, i) => i == index ? ch : c); } 让 str = 'Hello World'; str = replaceAt(str, 1, 'u');控制台.log(str); // 你好世界

让我们扩展并解释正则表达式和替换函数：

function replaceAt(str, index, newChar) { function replacer(origChar, strIndex) { if (strIndex === index) return newChar;否则返回 origChar； } return str.replace(/./g, replacer); } 让 str = 'Hello World'; str = replaceAt(str, 1, 'u');控制台.log(str); // 你好世界

正则表达式 . 只匹配一个字符。 g 使其匹配 for 循环中的每个字符。给定原始字符和该字符在字符串中的位置索引，调用 replacer 函数。我们创建一个简单的 if 语句来确定我们是要返回 origChar 还是 newChar。

---

var str = "你好世界";控制台.log(str); var arr = [...str]; arr[0] = "H"; str = arr.join("");控制台.log(str);

---

这与 Array.splice 类似：

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

---

你可以试试

var strArr = str.split("");

strArr[0] = 'h';

str = strArr.join("");

---

@CemKalyoncu：感谢您的出色回答！

我还对其进行了微调，使其更像 Array.splice 方法（并考虑了@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!"

---

你可以试试

var strArr = str.split("");

strArr[0] = 'h';

str = strArr.join("");

查看此功能以了解打印步骤

steps(3)
//       '#  '
//       '## '
//       '###'

function steps(n, i = 0, arr = Array(n).fill(' ').join('')) {
  if (i === n) {
    return;
  }

  str = arr.split('');
  str[i] = '#';
  str = str.join('');
  console.log(str);

  steps(n, (i = i + 1), str);
}

---

如果要替换字符串中的字符，则应创建可变字符串。这些本质上是字符数组。你可以创建一个工厂：

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

---

这很容易通过 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"

---

您可以扩展字符串类型以包含 inset 方法：

String.prototype.append = function (index,value) { return this.slice(0,index) + value + this.slice(index); }; var s = "新字符串";警报（s.append（4，“完成”））；

然后就可以调用函数了：

---

使用 spread syntax，您可以将字符串转换为数组，在给定位置分配字符，然后再转换回字符串：

const str = "你好世界";函数 replaceAt(s, i, c) { const arr = [...s]; // 将字符串转换为数组 arr[i] = c; // 将 char c 设置在 pos i return arr.join(''); // 返回字符串 } // 打印“你好世界” console.log(replaceAt(str, 1, 'a'));

---

您可以首先使用子字符串函数连接目标索引之前和目标索引之后的文本，然后与潜在的字符或字符串连接。这个更好

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

---

如果您想在 react/javascript 中的索引处设置单词或单个字符的样式，这是我提出的一个版本。

replaceAt( yourArrayOfIndexes, yourString/orArrayOfStrings ) 

工作示例：https://codesandbox.io/s/ov7zxp9mjq

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

---

这是我使用三元和映射运算符的解决方案。如果你问我，更易读、更易维护的目的更容易理解。

它更多地涉及 es6 和最佳实践。

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(`新字符串：${newStr}`); }

---

我知道这很旧，但是该解决方案不适用于负索引，因此我为其添加了一个补丁。希望它可以帮助某人

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

}

---

假设您想用 'Z' 替换 Kth 索引（基于 0 的索引）。您可以使用 Regex 来执行此操作。

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

---

您可以使用以下函数在字符串的特定位置替换 Character 或 String。要替换以下所有匹配案例，请使用 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;
};

测试：

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

---

我使用负索引的安全方法

/**
 * @param {string} str 
 * @param {number} index 
 * @param {string} replacement 
 * @returns {string}
 */
static replaceAt (str, index, replacement)
{
    if (index < 0) index = str.length + index
    if (index < 0 || index >= str.length) throw new Error(`Index (${index}) out of bounds "${str}"`)
    return str.substring(0, index) + replacement + str.substring(index + 1)
}

像这样使用它：

replaceAt('my string', -1, 'G') // 'my strinG'
replaceAt('my string', 2, 'yy') // 'myyystring'
replaceAt('my string', 22, 'yy') // Uncaught Error: Index (22) out of bounds "my string"

---

这里的方法很复杂。我会这样做：

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

这很简单。

---