মনে হচ্ছে পার্টিতে আমি 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 , যদিও আপনি প্রোটোটাইপিং দিয়ে এটি জাল করতে সক্ষম হতে পারেন।
উপরের ডেমো প্রয়োগটি রিভার্সডস্ট্রিং টাইপের একটি নতুন অবজেক্ট তৈরি করে। এটি প্রোটোটাইপযুক্ত, এবং তাই প্রায় ন্যূনতম কাজ এবং ন্যূনতম স্পেস ওভারহেড (প্রোটোটাইপ সংজ্ঞাগুলি ভাগ করা হয়) দিয়ে মোটামুটি দক্ষ। এটি পিছনে কাটা জড়িত একটি অলস বাস্তবায়ন। আপনি যখনই .sliceবা এর মতো কোনও কার্য সম্পাদন করেন .reversedএটি সূচক গণিত সম্পাদন করবে। অবশেষে যখন আপনি ডেটা উত্তোলন করবেন (স্পষ্টভাবে কলিং .toString()বা .charCodeAt(...)কোনও কিছু দিয়ে), এটি "স্মার্ট" পদ্ধতিতে প্রয়োগ করা হবে, সম্ভাব্যতম ডেটা স্পর্শ করা।
দ্রষ্টব্য: উপরের স্ট্রিং এপিআই একটি উদাহরণ এবং পুরোপুরি প্রয়োগ করা যেতে পারে না। আপনি প্রয়োজন মাত্র 1-2 ফাংশন ব্যবহার করতে পারেন।