的JavaScript：替换字符串文本中最后一次出现

Question

见我下面的代码片段：

var list = ['one', 'two', 'three', 'four']; 
var str = 'one two, one three, one four, one'; 
for (var i = 0; i < list.length; i++) 
{ 
    if (str.endsWith(list[i]) 
    { 
     str = str.replace(list[i], 'finish') 
    } 
} 

我想用字符串中的字完成替换的单词一个最后一次出现，我有什么不会因为替换方法只会取代它的第一次出现。有谁知道我可以修改该段，这样，只替换“一”

Answer 1

好吧，如果字符串真的与模式结束，你可以这样做的最后一个实例：

str = str.replace(new RegExp(list[i] + '$'), 'finish'); 

Answer 2

你可以使用String#lastIndexOf查找单词的最后一次出现，然后使用String#substring和串联来构建替换字符串。

n = str.lastIndexOf(list[i]); 
if (n >= 0 && n + list[i].length >= str.length) { 
    str = str.substring(0, n) + "finish"; 
} 

......或沿着这些线。

Answer 3

我知道这是愚蠢的，但我觉得这个创意早：

'one two, one three, one four, one' 
.split(' ') // array: ["one", "two,", "one", "three,", "one", "four,", "one"] 
.reverse() // array: ["one", "four,", "one", "three,", "one", "two,", "one"] 
.join(' ') // string: "one four, one three, one two, one" 
.replace(/one/, 'finish') // string: "finish four, one three, one two, one" 
.split(' ') // array: ["finish", "four,", "one", "three,", "one", "two,", "one"] 
.reverse() // array: ["one", "two,", "one", "three,", "one", "four,", "finish"] 
.join(' '); // final string: "one two, one three, one four, finish" 

所以真的，所有你需要做的就是这个功能添加到字符串原型：

String.prototype.replaceLast = function (what, replacement) { 
    return this.split(' ').reverse().join(' ').replace(new RegExp(what), replacement).split(' ').reverse().join(' '); 
}; 

然后像这样运行： 你应该知道str = str.replaceLast('one', 'finish');

一个限制是，由于功能是通过空间拆分，您 可能无法找到/替换任何空间。

事实上，现在我想起来了，你可以用一个空的标记来分解'空间'问题。

String.prototype.reverse = function() { 
    return this.split('').reverse().join(''); 
}; 

String.prototype.replaceLast = function (what, replacement) { 
    return this.reverse().replace(new RegExp(what.reverse()), replacement.reverse()).reverse(); 
}; 

str = str.replaceLast('one', 'finish'); 

Answer 4

不一样优雅与上述正则表达式的答案，但更容易执行的不是如精明的我们当中：

function removeLastInstance(badtext, str) { 
    var charpos = str.lastIndexOf(badtext); 
    if (charpos<0) return str; 
    ptone = str.substring(0,charpos); 
    pttwo = str.substring(charpos+(badtext.length)); 
    return (ptone+pttwo); 
} 

我意识到这可能是慢，比正则表达式的例子更浪费，但我认为这可能有助于说明如何完成字符串操作。 （它也可以缩小一点，但是我希望每一步都清楚。）

Answer 5

想到我会在这里回答，因为这在我的Google搜索中首先出现，并且没有答案（除了Matt的创造性答案:)），通常取代最后一次出现的字符串，当要替换的文本可能不在字符串末尾时。

if (!String.prototype.replaceLast) { 
    String.prototype.replaceLast = function(find, replace) { 
     var index = this.lastIndexOf(find); 

     if (index >= 0) { 
      return this.substring(0, index) + replace + this.substring(index + find.length); 
     } 

     return this.toString(); 
    }; 
} 

var str = 'one two, one three, one four, one'; 

// outputs: one two, one three, one four, finish 
console.log(str.replaceLast('one', 'finish')); 

// outputs: one two, one three, one four; one 
console.log(str.replaceLast(',', ';')); 

Answer 6

老式的和大的代码，但尽可能高效：

function replaceLast(origin,text){ 
    textLenght = text.length; 
    originLen = origin.length 
    if(textLenght == 0) 
     return origin; 

    start = originLen-textLenght; 
    if(start < 0){ 
     return origin; 
    } 
    if(start == 0){ 
     return ""; 
    } 
    for(i = start; i >= 0; i--){ 
     k = 0; 
     while(origin[i+k] == text[k]){ 
      k++ 
      if(k == textLenght) 
       break; 
     } 
     if(k == textLenght) 
      break; 
    } 
    //not founded 
    if(k != textLenght) 
     return origin; 

    //founded and i starts on correct and i+k is the first char after 
    end = origin.substring(i+k,originLen); 
    if(i == 0) 
     return end; 
    else{ 
     start = origin.substring(0,i) 
     return (start + end); 
    } 
} 

Answer 7

你不能只是扭转字符串，只替换逆转搜索模式的第一次出现？我在想 。 。 。

var list = ['one', 'two', 'three', 'four']; 
var str = 'one two, one three, one four, one'; 
for (var i = 0; i < list.length; i++) 
{ 
    if (str.endsWith(list[i]) 
    { 
     var reversedHaystack = str.split('').reverse().join(''); 
     var reversedNeedle = list[i].split('').reverse().join(''); 

     reversedHaystack = reversedHaystack.replace(reversedNeedle, 'hsinif'); 
     str = reversedHaystack.split('').reverse().join(''); 
    } 
} 

Answer 8

str = (str + '?').replace(list[i] + '?', 'finish'); 

Answer 9

下面是仅使用分裂和加入的方法。这是一个有点更具可读性，从而认为这是值得分享：

​​

Answer 10

如果速度是重要的，使用此：

/** 
* Replace last occurrence of a string with another string 
* x - the initial string 
* y - string to replace 
* z - string that will replace 
*/ 
function replaceLast(x, y, z){ 
    var a = x.split(""); 
    var length = y.length; 
    if(x.lastIndexOf(y) != -1) { 
     for(var i = x.lastIndexOf(y); i < x.lastIndexOf(y) + length; i++) { 
      if(i == x.lastIndexOf(y)) { 
       a[i] = z; 
      } 
      else { 
       delete a[i]; 
      } 
     } 
    } 

    return a.join(""); 
} 

这比使用正则表达式更快。