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

Question

我有一根绳子你好，世界，我需要替换索引3处的字符。如何通过指定索引来替换字符？

var str=“hello world”；

我需要这样的东西

str.replaceAt（0，“h”）；

Answer 1

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

您需要定义替换At（）发挥自己的作用：

String.prototype.replaceAt=函数（索引，替换）{返回this.substring（0，index）+replacement+this.substring（index+replacement.length）；}

并按如下方式使用：

var hello=“hello World”；alert（hello.replaceAt（2，“！！”）；//他！！o世界

Answer 2

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

函数rep（）{var str='Hello World'；str=setCharAt（str，4，'a'）；警报（str）；}函数setCharAt（str，index，chr）{如果（index>str.length-1）返回str；返回str.substring（0，index）+chr+str.substrang（index+1）；}

单击

Answer 3

不能。将位置前后的字符连接成新字符串：

var s=“Hello world”；var指数=3；s=s.substring（0，索引）+“x”+s.substring（索引+1）；

Answer 4

str=str.split（“”）；str[3]=“h”；str=str.join（“”）；

Answer 5

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

• 方法1：使用两个子字符串拆分字符串，并在它们之间填充字符
• METHOD2：将字符串转换为字符数组，替换一个数组成员并将其联接

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

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

@vsync，@Cory Mawhoter：你的评论很明确；然而，再说一遍，什么是大字符串？我同意，对于32…100kb的性能应该更好，对于这一个字符替换操作，应该使用子字符串变量。

但是，如果我必须更换一些，会发生什么呢？

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

var str=“…｛此处有一个大字符串｝…”；对于（var i=0；i<100000；i++）{var n=''+数学地板（Math.random（）*10）；var p=数学地板（Math.random（）*1000）；//替换位置*p上的字符*n**}

我为此制作了一把小提琴在这里.有两个测试，TEST1（子字符串）和TEST2（数组转换）。

结果：

• 测试1:195ms
• 测试2:6ms

看起来数组转换比子串快2个数量级！那么，这里到底发生了什么？？？

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

所以，这一切都是为了选择适合这份工作的工具。再一次。

Answer 6

编辑：一个优雅的解决方案是使用数组，尽管只建议用于小字符串：

String.prototype.replaceAt=函数（索引，字符）{var a=this.split（“”）；a[索引]=字符；返回a.join（“”）；}

运行此代码段：

String.prototype.replaceAt=函数（索引，字符）{var a=this.split（“”）；a[索引]=字符；返回a.join（“”）；}var str=“hello world”；str=str.replaceAt（3，“#”）；document.write（str）；

Answer 7

在Javascript中，字符串是不可变的，因此您必须执行以下操作

var x=“你好，世界”x=x.substring（0，i）+‘h’+x.substring（i+1）；

将x中i处的字符替换为“h”

Answer 8

函数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=result；console.log（结果）；}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=“length”type=“number”min=“0”value=“1”style=“width:50px”placeholder=“longth”/><input id=“text”type=“text）value=“F”placeholder=“New character”/><br>运行<p id=“output”></p>

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

var x=“白狗”；var arr=x.split（“”）；//[“W”、“h”、“i”、“t”、“e”、“”、“D”、“o”、“g”]重复排列（6,1，'F'）；/* 这里6是起始索引，1是要删除的数组元素数最后一个参数“F”是要插入的新字符。*/var结果=arr.join（“”）；//“白雾”

Answer 9

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

//0-要替换的索引，“f”-替换字符串“dog”。替换（/./g，（c，i）=>i==0？”f’：c）//“雾”

解释：

//String.replace将在每个模式匹配时调用回调//在本例中-每个字符'dog'.replace（/./g，函数（字符，索引）{如果（index==0）//我们想替换第一个字符返回'f'返回字符//其他字符保持不变})

Answer 10

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

函数replaceAt（str，index，ch）{return str.replace（/./g，（c，i）=>i==索引？ch:c）；}let str='Hello World'；str=replaceAt（str，1，'u'）；console.log（str）；//赫尔洛世界

让我们展开并解释正则表达式和replacer函数：

函数replaceAt（str，index，newChar）{函数替换器（origChar，strIndex）{if（strIndex===索引）return newChar；其他的return origChar；}return str.replace（/./g，替换器）；}let str='Hello World'；str=replaceAt（str，1，'u'）；console.log（str）；//赫尔洛世界

正则表达式.只匹配一个字符。这个克使其匹配for循环中的每个字符。这个替代品在给定原始字符和字符串中该字符所在位置的索引的情况下调用函数如果语句来确定是否返回origChar（原始字符）或newChar（新字符）.

Answer 11

var str=“hello world”；console.log（str）；var arr=[…str]；arr[0]=“H”；str=arr.join（“”）；console.log（str）；

Answer 12

其工作原理类似于阵列拼接:

String.prototype.splice=函数（i，j，str）{返回this.substr（0，i）+str+this.subs（j，this.length）；};

Answer 13

你可以试试

var strArr=str.split（“”）；strArr[0]=“h”；str=strArr.join（“”）；

Answer 14

这很容易通过RegExp实现！

const str='你好RegEx！'；常数指数=11；const replaceWith='p'；//“你好，RegEx！”。替换（/^（.{11}）（.）/，`$1p`）；str.replace（新RegExp（`^（.{${index}}）（.）`），`$1${replaceWith}`）；//<“你好RegExp”

Answer 15

使用扩展语法，您可以将字符串转换为数组，在给定位置分配字符，然后转换回字符串：

const str=“hello world”；函数replaceAt（s，i，c）{const arr=[…s]；//将字符串转换为数组arr[i]=c；//在位置i处设置字符c返回arr.join（“”）；//返回字符串}//打印“哈罗世界”console.log（replaceAt（str，1，'a'））；

Answer 16

你可以试试

var strArr=str.split（“”）；strArr[0]=“h”；str=strArr.join（“”）；

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

步骤（3）//       '#  '//       '## '//       '###'函数步骤（n，i=0，arr=Array（n）.fill（''）.join（''））{如果（i===n）{回报；}str=arr.split（''）；str[i]=“#”；str=str.join（“”）；console.log（str）；步骤（n，（i=i+1），str）；}

Answer 17

@CemKalyoncu：谢谢你的回答！

我还稍微修改了一下，使其更像Array.splice方法（并考虑了@Ates的注释）：

spliceString=函数（字符串，索引，numToDelete，char）{return string.subtr（0，index）+char+string.sUBR（index+numToDelete）；}var myString=“hello world！”；拼接字符串（myString，myString.lastIndexOf（'l'），2，'mlo'）；//“你好，虫洞！”

Answer 18

如果要替换字符串中的字符，应该创建可变字符串。这些基本上是字符数组。您可以创建工厂：

函数MutableString（str）{var结果=str.split（“”）；result.toString=函数（）{return this.join（“”）；}返回结果；}

然后，您可以访问这些字符，当用作字符串时，整个数组将转换为字符串：

var x=可变字符串（“Hello”）；x[0]=“B”；//是的，我们可以改变角色x.push（“！”）；//性能良好：没有创建新字符串var y=“你好”，+x；//转换为字符串：“嗨，贝洛！”

Answer 19

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

String.prototype.append=函数（索引、值）{返回this.slice（0，index）+值+this.slie（index）；};var s=“新字符串”；警报（s.append（4，“完成”）；

然后可以调用函数：

Answer 20

您可以使用子字符串函数进行连接，首先选择目标索引之前和目标索引之后的文本，然后与潜在的字符或字符串进行连接

const myString=“Hello world”；常数指数=3；const stringBeforeIndex=myString.substring（0，index）；const stringAfterIndex=myString.substring（索引+1）；const replaceChar=“X”；myString=字符串BeforeIndex+replaceChar+字符串AfterIndex；console.log（“新字符串-”，myString）

或

const myString=“Hello world”；设指数=3；myString=myString.substring（0，index）+“X”+myString.substring；

Answer 21

我的负指数安全方法：

/***@param{string}字符串*@param｛number｝索引*@param{string}替换*@返回{string}*/函数replaceAt（str，index，replacement）{如果（index<0）index=str.length+index；if（索引<0||索引>=str.length）抛出新错误（`Index（${Index}）out-of-bounds“${str}”`）；返回str.substring（0，index）+替换+str.substrang（index+1）；}

按如下方式使用：

replaceAt（'my string'，-1，'G'）//'我的字符串'replaceAt（'my-string'，2，'yy'）//'myyystring'replaceAt（'my string'，22，'yy'）//未捕获错误：索引（22）超出边界“my string”

Answer 22

我做了一个函数，它的功能与您的要求类似，它检查字符串中的字符是否位于不允许的字符数组中，如果是，它将其替换为“”

var验证=函数（值）{var notAllowed=[“；”，“_”，“>”，“<”，“'”，“%”，“$”，“&”，“/”，“|”，“：”，“=”，“*”]；对于（var i=0；i<值长度；i++）{if（notAllowed.indexOf（value.charAt（i））>-1）{value=value.replace（value.charAt（i），“”）；值=验证（值）；}}返回值；}

Answer 23

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

replaceAt（yourArrayOfIndexes、yourString/或ArrayofStrings）

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

函数replaceAt（indexArray，[…string]）{const replaceValue=i=>string[i]=<b>{string[i]}</b>；indexArray.forEach（replaceValue）；返回字符串；}

这是另一种替代方法

函数replaceAt（indexArray，[…string]）{const startTag=“<b>”；const endTag=“</b>”；const-tagLetter=i=>string.splice（i，1，startTag+string[i]+endTag）；indexArray.forEach（标记字母）；return string.join（''）；}

还有一个。。。

函数replaceAt（indexArray，[…string]）{for（设i=0；i<indexArray.length；i++）{string=Object.assign（字符串{[indexArray[i]]：<b>{string[indexArray[i]]}</b>});}返回字符串；}

Answer 24

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

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

函数replaceAt（）{const replaceAt=document.getElementById（'replaceAtt'）.value；const str=“ThisIsTestStringToReplaceCharAtSomePosition”；const newStr=数组.from（str）.map（（character，charIndex）=>charIndex==（replaceAt-1）？“”：字符）.join（“”）；console.log（`新字符串：$｛newStr｝`）；}

<input type=“number”id=“replaceAt”min=“1”max=“44”oninput=“replace At（）”/>

Answer 25

假设你想替换千分位索引（基于0的索引）“Z”. 你可以使用Regex公司这样做。

var-re=var-re=新RegExp（“（.）{”+K+“}）（（.）}）”）str.replace（re，“$1A$`”）；

Answer 26

您可以使用以下函数替换字符或字符串在字符串的特定位置。要替换以下所有匹配情况，请使用String.prototype.replaceAllMatches（）功能。

String.prototype.replaceMatch=函数（matchkey，replaceStr，matchIndex）{var retStr=此，repeatedIndex=0；for（var x=0；（matchkey！=null）&&（retStr.indexOf（matchkey）>-1）；x++）{if（重复索引==0&&x==0）{repeatedIndex=retStr.indexOf（匹配键）；}else{//matchIndex>0repatedIndex=retStr.indexOf（匹配键，repatedindex+1）；}如果（x==matchIndex）{retStr=retStr.substring（0，repeatedIndex）+replaceStr+retStr.substring（repeatedIndex+（matchkey.length））；matchkey=null；//打破循环。}}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））；

输出：

匹配的索引替换：yash yas$dfd***匹配的索引替换为：yash~ as$dfdas**

Answer 27

我这样做是为了使字符串大小写正确，也就是说，第一个字母是大写字母，其余所有字母都是小写字母：

函数toPropertCase（someString）{return someString.charAt（0）.toUpperCase（）.concat（someString.toLowerBase（）.substring（1，someStringe.length））；};

首先要做的是确保所有字符串都是小写的-someString.toLowerCase（）

然后将第一个字符转换为大写-someString.charAt（0）.toUpperCase（）

然后取剩余字符串的子字符串减去第一个字符-someString.toLowerCase（）.substring（1，someString.length））

然后，它将这两者连接起来并返回新字符串-someString.charAt（0）.toUpperCase（）.concat（someString.toLowerCase（。substring（1，someStringe.length））

可以为替换字符索引和替换字符添加新参数，然后形成两个子字符串，替换索引字符，然后以大致相同的方式连接。

Answer 28

这个解决方案对负索引不起作用，所以我添加了一个补丁。

String.prototype.replaceAt=函数（索引，字符）{如果（index>-1）返回this.substr（0，index）+字符+this.subs（index+字符.length）；否则返回this.substr（0，this.length+index）+字符+this.subs（index+character.length）；}

Answer 29

“hello world”.replace（/（.{3}）./，“1小时”）//“helho世界”

Answer 30

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

var myString=“这是我的字符串”；myString=myString.replace（myString.charAt（此处显示数字），“在此处插入替换”）；

这很简单。