JavaScript: reemplaza la última aparición de texto en una cadena

Vea mi fragmento de código a continuación:

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

Quiero reemplazar la última aparición de la palabra uno con la palabra final en la cadena, lo que tengo no funcionará porque el método de reemplazo solo reemplazará la primera aparición. ¿Alguien sabe cómo puedo modificar ese fragmento para que solo reemplace la última instancia de 'uno'

Bueno, si la cadena realmente termina con el patrón, puedes hacer esto:

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

Puede usar String#lastIndexOfpara encontrar la última aparición de la palabra y luego una String#substringconcatenación para construir la cadena de reemplazo.

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

... o en ese sentido.

Sé que esto es una tontería, pero me siento creativo esta mañana:

'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"

Entonces, realmente, todo lo que necesita hacer es agregar esta función al prototipo String:

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

Entonces ejecútelo así: str = str.replaceLast('one', 'finish');

Una limitación que debe saber es que, dado que la función se divide por espacio, probablemente no pueda encontrar / reemplazar nada con un espacio.

En realidad, ahora que lo pienso, podrías solucionar el problema del 'espacio' dividiéndote con un token vacío.

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

No es tan elegante como las respuestas de expresiones regulares anteriores, pero es más fácil de seguir para los que no son tan inteligentes entre nosotros:

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

Me doy cuenta de que esto es probablemente más lento y más derrochador que los ejemplos de expresiones regulares, pero creo que podría ser útil como ilustración de cómo se pueden realizar las manipulaciones de cadenas. (También se puede condensar un poco, pero nuevamente, quería que cada paso fuera claro).

Este es un método que solo usa dividir y unir. Es un poco más legible, así que pensé que valía la pena compartirlo:

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

Pensé que respondería aquí ya que esto apareció primero en mi búsqueda de Google y no hay respuesta (fuera de la respuesta creativa de Matt :)) que reemplaza genéricamente la última aparición de una cadena de caracteres cuando el texto a reemplazar podría no estar al final de la cuerda.

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

Una respuesta simple sin ninguna expresión regular sería:

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

¿No podría simplemente invertir la cadena y reemplazar solo la primera aparición del patrón de búsqueda invertido? Estoy pensando . . .

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

Si la velocidad es importante, use esto:

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

Es más rápido que usar RegExp.

Código antiguo y grande, pero lo más eficiente posible:

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

La solución simple sería utilizar el método de subcadena. Dado que la cadena termina con el elemento de la lista, podemos usar string.length y calcular el índice final para la subcadena sin usar el lastIndexOfmétodo

str = str.substring(0, str.length - list[i].length) + "finish"

No me gustó ninguna de las respuestas anteriores y se me ocurrió la siguiente

function replaceLastOccurrenceInString(input, find, replaceWith) {
    if (!input || !find || !replaceWith || !input.length || !find.length || !replaceWith.length) {
        // 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);
}

Uso:

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

¡Espero que ayude!

Sugeriría usar el paquete replace-last 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>

Esto funciona para reemplazos de cadenas y expresiones regulares.

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