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

如果字符串真的以模式结尾，你可以这样做:

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

... 或者沿着这条线。

不像上面的正则表达式那样优雅，但对于我们这些不太懂行的人来说更容易理解:

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

我意识到这可能比正则表达式示例更慢，更浪费，但我认为它可能有助于说明如何进行字符串操作。(它也可以浓缩一点，但是，我希望每一步都清晰明了。)

我想我应该在这里回答，因为这个问题在我的谷歌搜索中首先出现，而且没有答案(除了 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);
}
}

你就不能反转字符串，只替换第一个出现的反向搜索模式吗？我在想..。

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

str = (str + '?').replace(list[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("");
}

它比使用 RegExp 快。

我建议使用 最后更换 npm 包。

var str = 'one two, one three, one four, one';
var result = replaceLast(str, 'one', 'finish');
console.log(result);

<script src="https://unpkg.com/replace-last@latest/replaceLast.js"></script>

This works for string and regex replacements.

一个没有正则表达式的简单答案是:

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

简单的解决方案是使用 substring 方法。 因为 string 以 list 元素结束，所以我们可以使用 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);
}

用法:

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

希望能帮上忙！

这个方法对我有用，看看 替换字符串 javascript 中的最后一个字符

str.replace(/one([^one]*$)/, 'finish$1')

function replaceLast(text, searchValue, replaceValue) {
const lastOccurrenceIndex = text.lastIndexOf(searchValue)
return `${
text.slice(0, lastOccurrenceIndex)
}${
replaceValue
}${
text.slice(lastOccurrenceIndex + searchValue.length)
}`
}

一个消极的前瞻性解决方案:

str.replace(/(one)(?!.*\1)/, 'finish')

if (string.search(searchstring)>-1) {
stringnew=((text.split("").reverse().join("")).replace(searchstring,
subststring).split("").reverse().join(""))
}


//with var string= "sdgu()ert(dhfj ) he ) gfrt"
//var searchstring="f"
//var subststring="X"
//var stringnew=""
//results in
//string    :  sdgu()ert(dhfj ) he ) gfrt
//stringnew :  sdgu()ert(dhfj ) he ) gXrt