Javascript 仅使用文本偏移在字符串中插入标记

我一直在努力使用javascript字符串方法和正则表达式，我可能忽略了一些显而易见的东西。我希望我能更详细地重述tofutim的内容，不会违反任何协议。对他的问题的回答集中在s.replace（）上，但要实现这一点，您必须知道要替换的子字符串出现的位置，替换所有子字符串，或者能够通过正则表达式以某种方式唯一地标识要替换的字符串。像他一样，我只有一个文本偏移数组，如下所示：

[[5,9], [23,27]]

"eggs eggs spam and ham spam"

还有这样的字符串：

[[5,9], [23,27]]

"eggs eggs spam and ham spam"

考虑到这些约束，有没有一种简单的方法（javaScript或jQuery的快捷方式）来获得这样的字符串

"eggs <span>eggs</span> spam and ham <span>spam</span>"

“鸡蛋垃圾和火腿垃圾”

我事先不知道替换字符串是什么，也不知道它们在基本文本中出现了多少次。我只知道它们的偏移量，我只想用标签包装由它们的偏移量标识的引用

---

有什么想法吗？

你可以试试

slice

方法

var arr = [[5,9], [23,27]];
arr = arr.reverse()

$.each(arr, function(i, v){
    var f = v[0], last = v[1];
    $('p').html(function(i, v){
        var o = v.slice(0, f);
        var a = '<span>' + v.slice(f, last) + '</span>';
        var c = v.slice(last, -1);
        return o+a+c
    })
})

var-arr=[[5,9]，[23,27]；
arr=arr.reverse（）
$。每个（arr，功能（i，v）{
var f=v[0]，last=v[1]；
$（'p'）.html（函数（i，v）{
var o=v.切片（0，f）；
变量a=''+v.slice（f，last）+''；
var c=v.slice（最后，-1）；
返回o+a+c
})
})

---

您可以使用子字符串方法 String.substring（startIndex，endIndex）； 描述：返回开始索引和结束索引之间的字符串 用法：

您已经有了一个带有初始和最终索引的数组，所以您几乎完成了：）

iquick解决方案（未测试）

函数indexWrap（indexArr，str）{
//分解为每个字符的数组
var chars=str.split（“”）；
//循环遍历索引的MD数组
对于（var i=0；i首先，您希望向后迭代，以确保最终不会覆盖先前所做的替换，但是，在我的示例中，这并不重要，因为字符串在最后一次重新组装

// > interpolateOnIndices([[5,9], [23,27]], "eggs eggs spam and ham spam");
// < 'eggs <span>eggs</span> spam and ham <span>spam</span>'

function interpolateOnIndices(indices, string) {
    "use strict";
    var i, pair, position = string.length,
        len = indices.length - 1, buffer = [];
    for (i = len; i >= 0; i -= 1) {
        pair = indices[i];
        buffer.unshift("<span>",
                       string.substring(pair[0], pair[1]),
                       "</span>",
                       string.substring(pair[1], position));
        position = pair[0];
    }
    buffer.unshift(string.substr(0, position));
    return buffer.join("");
}

在amd64 Linux（FC-17）上针对V8（Node.js）进行测试

我没有测试未定义的答案，因为我不想加载该库，特别是因为它对测试没有任何用处。我可以想象它会在andbeyond和elclanrs的变体之间，更接近elclanrs的答案。
我找到了一种使用regexp的方法。性能不确定，但它很简单t和sweet：

/**
 * replaceOffset
 * @param str A string
 * @param offs Array of offsets in ascending order [[2,4],[6,8]]
 * @param tag HTML tag
 */
function replaceOffset(str, offs, tag) {
  tag = tag || 'span';
  offs.reverse().forEach(function(v) {
    str = str.replace(
      new RegExp('(.{'+v[0]+'})(.{'+(v[1]-v[0])+'})'), 
      '$1<'+tag+'>$2</'+tag+'>'
    );
  });
  return str;
}

/**
*替换偏移量
*@param str字符串
*@param offs按升序排列的偏移数组[[2,4]，[6,8]]
*@param标记HTML标记
*/
函数替换偏移量（str、offs、tag）{
标记=标记| |“span”；
offs.reverse（）.forEach（函数（v）{
str=str.replace(
新的正则表达式（'（.{'+v[0]+'}）（.{'+（v[1]-v[0]）+'}），
'$1$2'
);
});
返回str；
}

演示：
我认为您需要一个解析器，而不是一个简单的string.replace（）方法。您当然可以只使用string.replace（）来实现这一点，但它会很慢。一次读取一个字符、标记字符串、根据数组处理它并生成输出字符串可能会更高效。谢谢@jrista，可能类似于：
l=s.split（“”）
then
l[5]=“”+a[5]
对于每个偏移量对的每个元素都是这样，然后加入结果？我会尝试一下。这与我对jrista和jrista的回答类似。我有一个尴尬的发现：有很多好主意要处理。我对elclanrs的正则表达式解决方案特别感兴趣，因为这正是我一直在做的事情很抱歉，我不能提供一个实际的答案。我在工作中，在测试一组高吞吐量工作流程的大量负载和可扩展性测试的中间。我们正在测试的一些东西包括一些自定义解析，因此我的建议。如果涉及到多个字符串操作，它们在性能方面会有所滞后。如果您只是将字符从输入字符串中流出来，然后在输入数组中的任何适当索引处将必要的or添加到输出字符串中，结果就是……这正是我整天都在讨论的解决方案。谢谢，您找到了它！太棒了！我现在可以删除我的140行代码了。在我的上下文中，速度的提高并不是很重要，但这很好，谢谢@wvxvw。
/**
 * replaceOffset
 * @param str A string
 * @param offs Array of offsets in ascending order [[2,4],[6,8]]
 * @param tag HTML tag
 */
function replaceOffset(str, offs, tag) {
  tag = tag || 'span';
  offs.reverse().forEach(function(v) {
    str = str.replace(
      new RegExp('(.{'+v[0]+'})(.{'+(v[1]-v[0])+'})'), 
      '$1<'+tag+'>$2</'+tag+'>'
    );
  });
  return str;
}