Javascript 是否有用于字符串的拼接方法？

Javascript

splice

仅适用于数组。字符串是否有类似的方法？或者我应该创建自己的自定义函数

substr（）

和

substring（）

方法将只返回提取的字符串，而不修改原始字符串。我要做的是从字符串中删除一些部分，并将更改应用于原始字符串。此外，方法

replace（）

在我的例子中不起作用，因为我想删除从索引开始到其他索引结束的部分，就像我可以使用

splice（）

方法一样。我尝试将字符串转换为数组，但这不是一个简单的方法。

Edit 这当然不是“拼接”字符串的最佳方式，我已经给出了一个示例，说明了实现的方式，这是有缺陷的，从split（）、splice（）和join（）中可以明显看出。有关更好的实现，请参见方法

---

不，没有

字符串.拼接

，但您可以尝试以下方法：

newStr = str.split(''); // or newStr = [...str];
newStr.splice(2,5);
newStr = newStr.join('');

---

我意识到数组中没有

splice

函数，因此必须将字符串转换为数组。运气不好…

将字符串切片两次会更快，如下所示：

function spliceSlice(str, index, count, add) {
  // We cannot pass negative indexes directly to the 2nd slicing operation.
  if (index < 0) {
    index = str.length + index;
    if (index < 0) {
      index = 0;
    }
  }

  return str.slice(0, index) + (add || "") + str.slice(index + count);
}

function spliceSplit(str, index, count, add) {
  var ar = str.split('');
  ar.splice(index, count, add);
  return ar.join('');
}

var creditCardNumber = "5500000000000004";
var cardSuffix = creditCardNumber.splice(0,12,'****');
console.log(cardSuffix);  // output: ****0004

下面是一个比较这两种方法和其他几种方法的例子。（jsperf已经下降了几个月。请在评论中提出替代方案。）

尽管上面的代码实现了重现

splice

一般功能的函数，但针对询问者提出的情况优化代码（即，不向修改的字符串中添加任何内容）并不会改变各种方法的相对性能。

这里有一个很好的小Curry，它提供了更好的可读性（IMHO）: 第二个函数的签名与

Array.prototype.splice

方法相同

function mutate(s) {
    return function splice() {
        var a = s.split('');
        Array.prototype.splice.apply(a, arguments);
        return a.join('');
    };
}

mutate('101')(1, 1, '1');

---

我知道已经有了一个公认的答案，但希望这是有用的。

我想提供一个比库马尔/科迪和路易斯方法更简单的替代方法。在我运行的所有测试中，它的执行速度与Louis方法一样快（请参阅基准测试的fiddle测试）

您可以这样使用它：

function spliceSlice(str, index, count, add) {
  // We cannot pass negative indexes directly to the 2nd slicing operation.
  if (index < 0) {
    index = str.length + index;
    if (index < 0) {
      index = 0;
    }
  }

  return str.slice(0, index) + (add || "") + str.slice(index + count);
}

function spliceSplit(str, index, count, add) {
  var ar = str.split('');
  ar.splice(index, count, add);
  return ar.join('');
}

var creditCardNumber = "5500000000000004";
var cardSuffix = creditCardNumber.splice(0,12,'****');
console.log(cardSuffix);  // output: ****0004

见测试结果：

方法答案，作为

字符串

原型函数：

String.prototype.splice = function(index, count, add) {
  if (index < 0) {
    index = this.length + index;
    if (index < 0) {
      index = 0;
    }
  }
  return this.slice(0, index) + (add || "") + this.slice(index + count);
}

String.prototype.splice=函数（索引、计数、添加）{
如果（指数<0）{
索引=this.length+索引；
如果（指数<0）{
指数=0；
}
}
返回此.slice（0，索引）+（添加| |“”）+此.slice（索引+计数）；
}

例如：

 > "Held!".splice(3,0,"lo Worl")
 < "Hello World!"

>“保持！”.拼接（3,0，“lo Worl”）
<“你好，世界！”

只需对字符串使用substr

前

---

结果=埃洛世界

似乎有很多困惑，只有elclanrs和raina77ow在评论中提到过，所以让我发布一个澄清的答案

澄清 从“

string.splice

”可以预期，它与用于阵列的类似：

• 最多接受3个参数：起始位置、长度和（可选）插入（字符串）
• 返回剪切部分
• 修改原始字符串

问题是，3d需求无法满足，因为字符串是不可变的（相关：，），我找到了最专用的注释：

在JavaScript中，字符串是基本值类型，而不是对象（）。事实上，从ES5开始，它们是与

null

、

undefined

、

number

和

boolean

并列的5种值类型之一。字符串是按值而不是按引用分配的，并按此方式传递。因此，字符串不仅仅是不可变的，它们是一个值。将字符串

“hello”

更改为

“world”

就像决定从现在起数字3就是数字4。。。这毫无意义

因此，考虑到这一点，人们可能期望“

string.splice

”这件事只会：

• 最多接受2个参数：起始位置、长度（插入没有意义，因为字符串没有更改）
• 返回剪切部分

这就是

substr

所做的；或者，或者

• 最多接受3个参数：起始位置、长度和（可选）插入（字符串）
• 返回修改后的字符串（不带剪切部分和插入部分）

这是下一节的主题

解决 如果您关心优化，您可能应该使用Mike的实现：

String.prototype.splice = function(index, count, add) {
    if (index < 0) {
        index += this.length;
        if (index < 0)
            index = 0;
    }
    return this.slice(0, index) + (add || "") + this.slice(index + count);
}

演出 性能上的差异随着弦的长度而急剧增加。jsperf表示，对于长度为10的字符串，后一种解决方案（拆分和连接）的速度是前一种解决方案（使用切片）的两倍，对于100个字母的字符串，它是x5，对于1000个字母的字符串，它是x50，单位为Ops/sec：

                      10 letters   100 letters   1000 letters
slice implementation    1.25 M       2.00 M         1.91 M
split implementation    0.63 M       0.22 M         0.04 M

---

请注意，当从10个字母移动到100个字母时，我已经更改了第一个和第二个参数（但我仍然感到惊讶的是，100个字母的测试速度比10个字母的测试速度快）。

因此，无论如何向字符串原型添加拼接方法，都无法对规范透明

让我们做一些扩展：

String.prototype.splice=函数（…a）{
对于（var r=''，p=0，i=1；i

• 每3个参数组以拼接样式“插入”
• 特殊如果有一个以上的3 args组，则每个切割的结束将是下一个切割的开始。
  • “0123456789”。拼接（4,1，“第四”，“8,1”，“第八”）//返回'0123fourth567eighth9'
• 您可以删除或归零每个组中的最后一个参数（视为“无需插入”）
  • “0123456789”。拼接（-4,2）//返回'0123459'
• 您可以删除最后一组中除第一个arg之外的所有arg（被视为“第一个arg位置后全部剪切”）
  • “0123456789”。拼接（0,2，空，3,1，空，5,2，“/”，8）//返回“24/7”
• 若你们通过了多次，你们必须检查剩下的位置的种类-

  String.prototype.splice = function(index, count, add) {
      var chars = this.split('');
      chars.splice(index, count, add);
      return chars.join('');
  }
  

                        10 letters   100 letters   1000 letters
  slice implementation    1.25 M       2.00 M         1.91 M
  split implementation    0.63 M       0.22 M         0.04 M
  

  String.prototype.splice = function(...a){
      for(var r = '', p = 0, i = 1; i < a.length; i+=3)
          r+= this.slice(p, p=a[i-1]) + (a[i+1]||'') + this.slice(p+a[i], p=a[i+2]||this.length);
      return r;
  }
  

  function spliceSlice(str, index, count, add) {
    if (index < 0) {
      index = str.length + index;
      if (index < 0) {
        index = 0;
      }
    }
    const hasAdd = typeof add !== 'undefined';
    return str.slice(0, index) + (hasAdd ? add : '') + str.slice(index + count);
  }
  

  let str = "I need to remove a character from this";
  let pos = str.indexOf("character")
  
  if(pos>-1){
    let result = str.slice(0, pos-2) + str.slice(pos, str.length);
    console.log(result) //I need to remove character from this 
  }