लगता है कि मुझे पार्टी में 3 साल देर हो गई है ...
दुर्भाग्य से आप के रूप में इंगित नहीं किया गया है। देखें क्या जावास्क्रिप्ट तार अपरिवर्तनीय? क्या मुझे जावास्क्रिप्ट में "स्ट्रिंग बिल्डर" की आवश्यकता है?
अगली सबसे अच्छी चीज जो आप कर सकते हैं वह है "व्यू" या "रैपर" बनाना, जो एक स्ट्रिंग लेता है और आपके द्वारा उपयोग किए जा रहे स्ट्रिंग एपीआई के कुछ हिस्सों को पुन: लागू करता है, लेकिन स्ट्रिंग का दिखावा उल्टा होता है। उदाहरण के लिए:
var identity = function(x){return x};
function LazyString(s) {
this.original = s;
this.length = s.length;
this.start = 0; this.stop = this.length; this.dir = 1; // "virtual" slicing
// (dir=-1 if reversed)
this._caseTransform = identity;
}
// syntactic sugar to create new object:
function S(s) {
return new LazyString(s);
}
//We now implement a `"...".reversed` which toggles a flag which will change our math:
(function(){ // begin anonymous scope
var x = LazyString.prototype;
// Addition to the String API
x.reversed = function() {
var s = new LazyString(this.original);
s.start = this.stop - this.dir;
s.stop = this.start - this.dir;
s.dir = -1*this.dir;
s.length = this.length;
s._caseTransform = this._caseTransform;
return s;
}
//We also override string coercion for some extra versatility (not really necessary):
// OVERRIDE STRING COERCION
// - for string concatenation e.g. "abc"+reversed("abc")
x.toString = function() {
if (typeof this._realized == 'undefined') { // cached, to avoid recalculation
this._realized = this.dir==1 ?
this.original.slice(this.start,this.stop) :
this.original.slice(this.stop+1,this.start+1).split("").reverse().join("");
this._realized = this._caseTransform.call(this._realized, this._realized);
}
return this._realized;
}
//Now we reimplement the String API by doing some math:
// String API:
// Do some math to figure out which character we really want
x.charAt = function(i) {
return this.slice(i, i+1).toString();
}
x.charCodeAt = function(i) {
return this.slice(i, i+1).toString().charCodeAt(0);
}
// Slicing functions:
x.slice = function(start,stop) {
// lazy chaining version of https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/slice
if (stop===undefined)
stop = this.length;
var relativeStart = start<0 ? this.length+start : start;
var relativeStop = stop<0 ? this.length+stop : stop;
if (relativeStart >= this.length)
relativeStart = this.length;
if (relativeStart < 0)
relativeStart = 0;
if (relativeStop > this.length)
relativeStop = this.length;
if (relativeStop < 0)
relativeStop = 0;
if (relativeStop < relativeStart)
relativeStop = relativeStart;
var s = new LazyString(this.original);
s.length = relativeStop - relativeStart;
s.start = this.start + this.dir*relativeStart;
s.stop = s.start + this.dir*s.length;
s.dir = this.dir;
//console.log([this.start,this.stop,this.dir,this.length], [s.start,s.stop,s.dir,s.length])
s._caseTransform = this._caseTransform;
return s;
}
x.substring = function() {
// ...
}
x.substr = function() {
// ...
}
//Miscellaneous functions:
// Iterative search
x.indexOf = function(value) {
for(var i=0; i<this.length; i++)
if (value==this.charAt(i))
return i;
return -1;
}
x.lastIndexOf = function() {
for(var i=this.length-1; i>=0; i--)
if (value==this.charAt(i))
return i;
return -1;
}
// The following functions are too complicated to reimplement easily.
// Instead just realize the slice and do it the usual non-in-place way.
x.match = function() {
var s = this.toString();
return s.apply(s, arguments);
}
x.replace = function() {
var s = this.toString();
return s.apply(s, arguments);
}
x.search = function() {
var s = this.toString();
return s.apply(s, arguments);
}
x.split = function() {
var s = this.toString();
return s.apply(s, arguments);
}
// Case transforms:
x.toLowerCase = function() {
var s = new LazyString(this.original);
s._caseTransform = ''.toLowerCase;
s.start=this.start; s.stop=this.stop; s.dir=this.dir; s.length=this.length;
return s;
}
x.toUpperCase = function() {
var s = new LazyString(this.original);
s._caseTransform = ''.toUpperCase;
s.start=this.start; s.stop=this.stop; s.dir=this.dir; s.length=this.length;
return s;
}
})() // end anonymous scope
डेमो:
> r = S('abcABC')
LazyString
original: "abcABC"
__proto__: LazyString
> r.charAt(1); // doesn't reverse string!!! (good if very long)
"B"
> r.toLowerCase() // must reverse string, so does so
"cbacba"
> r.toUpperCase() // string already reversed: no extra work
"CBACBA"
> r + '-demo-' + r // natural coercion, string already reversed: no extra work
"CBAcba-demo-CBAcba"
किकर - निम्नलिखित को शुद्ध गणित द्वारा किया जाता है, प्रत्येक वर्ण पर केवल एक बार जाकर, और केवल आवश्यक होने पर:
> 'demo: ' + S('0123456789abcdef').slice(3).reversed().slice(1,-1).toUpperCase()
"demo: EDCBA987654"
> S('0123456789ABCDEF').slice(3).reversed().slice(1,-1).toLowerCase().charAt(3)
"b"
यदि आप केवल एक अपेक्षाकृत छोटे स्लाइस ले रहे हैं, तो यह बहुत बड़ी स्ट्रिंग पर लागू होने पर महत्वपूर्ण बचत देता है।
क्या यह इसके लायक है (अधिकांश प्रोग्रामिंग भाषाओं में उलट-ए-कॉपी की तरह) अत्यधिक आपके उपयोग के मामले पर निर्भर करता है और आप स्ट्रिंग एपीआई को कितनी कुशलता से लागू करते हैं। उदाहरण के लिए, यदि आप चाहते हैं कि स्ट्रिंग इंडेक्स में हेरफेर करना है, या छोटे sliceएस या substrएस लेना है, तो यह आपको स्थान और समय बचाएगा। यदि आप बड़े उलटे स्लाइस या सबस्ट्रिंग को प्रिंट करने की योजना बना रहे हैं, तो बचत वास्तव में छोटी हो सकती है, यहां तक कि पूर्ण प्रतिलिपि बनाने से भी बदतर। आपके "उलट" स्ट्रिंग का प्रकार भी नहीं होगा string, हालांकि आप इसे प्रोटोटाइप के साथ नकली करने में सक्षम हो सकते हैं।
उपरोक्त डेमो कार्यान्वयन, Rev RevStString प्रकार का एक नया ऑब्जेक्ट बनाता है। यह प्रोटोटाइप है, और इसलिए काफी कुशल है, लगभग न्यूनतम काम और न्यूनतम स्थान के साथ ओवरहेड (प्रोटोटाइप परिभाषाएं साझा की जाती हैं)। यह एक आलसी कार्यान्वयन है जिसमें आस्थगित कताई शामिल है। जब भी आप किसी फ़ंक्शन को पसंद करते हैं .sliceया .reversed, यह इंडेक्स गणित का प्रदर्शन करेगा। अंत में जब आप डेटा निकालते हैं (संक्षेप में कॉल करके .toString()या.charCodeAt(...) कुछ और करके), तो यह "स्मार्ट" तरीके से लागू होगा, कम से कम डेटा को छू सकता है।
नोट: उपरोक्त स्ट्रिंग एपीआई एक उदाहरण है, और इसे पूरी तरह से लागू नहीं किया जा सकता है। आप केवल 1-2 फ़ंक्शन का उपयोग कर सकते हैं, जिनकी आपको आवश्यकता है।