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

请参见下面的我的代码片段：

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

var list=['1'，'2'，'3'，'4']；
var str='一二，一三，一四，一'；
对于（变量i=0；i

---

我想用字符串中最后出现的单词finish替换单词one，因为replace方法将只替换第一次出现的单词one。有人知道我如何修改该片段，使其只替换“one”的最后一个实例吗？如果字符串真的以模式结尾，您可以可以这样做：

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

您可以使用

String#lastIndexOf

查找单词的最后一个匹配项，然后使用

String#substring

和串联来构建替换字符串

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

---

…或者按照这些思路。

我知道这很愚蠢，但今天早上我觉得很有创意：

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

---

不像上面的正则表达式回答的那么优雅，但对于我们当中不那么精明的人来说，更容易理解：

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

函数removelastance（badtext，str）{
var charpos=str.lastIndexOf（badtext）；
如果（charpos认为我应该在这里回答，因为这在我的谷歌搜索中是第一个出现的，并且没有答案（除了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(',', ';'));

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

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

函数replaceLast（原点，文本）{
textLenght=text.length；
原始长度=原始长度
如果（文本长度==0）
返回原点；
开始=原始文本长度；
如果（开始<0）{
返回原点；
}
如果（开始==0）{
返回“”；
}
对于（i=start；i>=0；i--）{
k=0；
while（原点[i+k]==文本[k]）{
k++
如果（k==文本长度）
打破
}
如果（k==文本长度）
打破
}
//不成立
如果（k！=文本长度）
返回原点；
//创建并从正确开始，i+k是之后的第一个字符
结束=原点。子字符串（i+k，原点）；
如果（i==0）
返回端；
否则{
开始=原点。子字符串（0，i）
返回（开始+结束）；
}
}
你不能将字符串反转，只替换第一次出现的反转搜索模式吗？我在想

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('');
     }
 }

var list=['1'，'2'，'3'，'4']；
var str='一二，一三，一四，一'；
对于（变量i=0；i
str=（str+'？'）。替换（列表[i]+'？'，'finish'）；
这里有一个只使用拆分和联接的方法。它更具可读性，因此值得分享：

    String.prototype.replaceLast = function (what, replacement) {
        var pcs = this.split(what);
        var lastPc = pcs.pop();
        return pcs.join(what) + replacement + lastPc;
    };

如果速度很重要，请使用以下方法：

/**
 * 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("");
}

/**
*用另一个字符串替换最后出现的字符串
*x-初始字符串
*要替换的y字符串
*将替换的z字符串
*/
函数replaceLast（x，y，z）{
var a=x.split（“”）；
变量长度=y.长度；
如果（x.lastIndexOf（y）！=-1）{
对于（var i=x.lastIndexOf（y）；i

它比使用RegExp快。
我建议使用npm包


var str='一两，一三，一四，一'；
var result=replaceLast（str，'one'，'finish'）；
console.log（结果）；
没有任何正则表达式的简单答案是：

str = str.substr(0, str.lastIndexOf(list[i])) + 'finish'

简单的解决方法是使用子字符串方法。
由于字符串以列表元素结尾，我们可以使用string.length并计算子字符串的结束索引，而无需使用
lastIndexOf
方法

str=str.substring（0，str.length-list[i].length）+“finish”
我不喜欢上面的任何一个答案，于是想出了下面的答案

function isString(variable) { 
    return typeof (variable) === 'string'; 
}

function replaceLastOccurrenceInString(input, find, replaceWith) {
    if (!isString(input) || !isString(find) || !isString(replaceWith)) {
        // returns input on invalid arguments
        return input;
    }

    const lastIndex = input.lastIndexOf(find);
    if (lastIndex < 0) {
        return input;
    }

    return input.substr(0, lastIndex) + replaceWith + input.substr(lastIndex + find.length);
}


希望这会有帮助！
好主意。需要首先转义该字符串（尽管不是用她的样本数据，这是肯定的），这很重要。：-（@Ruth no prob！@TJ yes，确实是这样：Ruth如果你找到的“单词”包括正则表达式所用的特殊字符，你就需要“转义”这些，正如TJ所说是有点棘手的（但不是不可能的）。如果你想替换string2中最后出现的string1怎么办？@SuperUberDuper如果你想匹配由“/”字符包围的内容，那就是。有两种方法来创建RegExp实例：构造函数（
new RegExp（string）
），以及内联语法（
/something/
）。使用RegExp构造函数时不需要“/”字符。@TechLife您必须对字符串应用转换以“保护”所有带有
`-
+
，
*
，
？`，括号，方括号的正则表达式元字符，可能还有其他东西。另一个例子：var nameSplit=item.name.lastIndexOf（“，”）；if（nameSplit！=-1）item.name=item.name.substr（0，nameSplit）+”和“+item.name.substr（nameSplit+2）；通常，除了t之外，通常还需要一个解释
const input = 'ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen twenty';
const find = 'teen';
const replaceWith = 'teenhundred';

const output = replaceLastOccurrenceInString(input, find, replaceWith);
console.log(output);

// output: ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteenhundred twenty