जावास्क्रिप्ट: एक स्ट्रिंग में पाठ की अंतिम घटना की जगह

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#substring और प्रतिस्थापन स्ट्रिंग बनाने के लिए concatenation खोजने के लिए String#lastIndexOf का उपयोग करें।

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

के रूप में ऊपर regex जवाब के रूप में सुंदर है, लेकिन आसान नहीं हमारे बीच नहीं के रूप में सामान्य बुद्धि के लिए पालन करने के लिए:

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

मुझे पता है यह संभावना धीमी और regex उदाहरण से ज्यादा बेकार है , लेकिन मुझे लगता है कि स्ट्रिंग मैनिप्लेशंस कैसे किया जा सकता है इसका एक उदाहरण के रूप में यह सहायक हो सकता है। (इसे थोड़ा सा संकुचित भी किया जा सकता है, लेकिन फिर, मैं चाहता था कि प्रत्येक चरण स्पष्ट हो।)

Answer 5

सोचा था कि मैं यहां जवाब दूंगा क्योंकि यह मेरी Google खोज में पहले आया था और कोई जवाब नहीं है (मैट के रचनात्मक उत्तर के बाहर :)) जो सामान्य रूप से वर्णों की स्ट्रिंग की अंतिम घटना को प्रतिस्थापित करता है जब टेक्स्ट को प्रतिस्थापित करने के लिए स्ट्रिंग के अंत में नहीं हो सकता है।

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

यहाँ एक विधि है कि केवल बंटवारे और में शामिल होने का उपयोग करता है।

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

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

यह रेगुलर एक्सप्रेशन का उपयोग कर से अधिक तेज़ है यह थोड़ा अधिक पठनीय ऐसा लगा इसके लायक बंटवारे था।