Scheint, als wäre ich 3 Jahre zu spät zur Party ...
Leider können Sie nicht, wie bereits erwähnt wurde. Siehe Sind JavaScript-Zeichenfolgen unveränderlich? Benötige ich einen "String Builder" in JavaScript?
Das nächstbeste, was Sie tun können, ist, eine "Ansicht" oder einen "Wrapper" zu erstellen, der eine Zeichenfolge verwendet und alle Teile der von Ihnen verwendeten Zeichenfolgen-API neu implementiert, aber so tut, als wäre die Zeichenfolge umgekehrt. Zum Beispiel:
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
Demo:
> 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"
Der Kicker - Folgendes wird vor Ort durch reine Mathematik erledigt, wobei jeder Charakter nur einmal und nur bei Bedarf besucht wird:
> 'demo: ' + S('0123456789abcdef').slice(3).reversed().slice(1,-1).toUpperCase()
"demo: EDCBA987654"
> S('0123456789ABCDEF').slice(3).reversed().slice(1,-1).toLowerCase().charAt(3)
"b"
Dies führt zu erheblichen Einsparungen, wenn Sie auf eine sehr große Zeichenfolge angewendet werden, wenn Sie nur eine relativ kleine Scheibe davon nehmen.
Ob sich dies lohnt (über das Umkehren als Kopie wie in den meisten Programmiersprachen), hängt stark von Ihrem Anwendungsfall ab und davon, wie effizient Sie die Zeichenfolgen-API erneut implementieren. Wenn Sie beispielsweise nur einen String-Index bearbeiten oder kleine slices oder substrs nehmen möchten , sparen Sie Platz und Zeit. Wenn Sie jedoch große umgekehrte Schnitte oder Teilzeichenfolgen drucken möchten, sind die Einsparungen möglicherweise gering und sogar noch schlimmer als bei einer vollständigen Kopie. Ihre "umgekehrte" Zeichenfolge hat auch nicht den Typstring , obwohl Sie dies möglicherweise mit Prototyping vortäuschen können.
Die obige Demo-Implementierung erstellt ein neues Objekt vom Typ ReversedString. Es ist ein Prototyp und daher ziemlich effizient mit nahezu minimalem Arbeitsaufwand und minimalem Platzaufwand (Prototypdefinitionen werden gemeinsam genutzt). Es ist eine träge Implementierung, die ein verzögertes Schneiden beinhaltet. Wann immer Sie eine Funktion wie .sliceoder .reversedausführen, wird eine Indexmathematik ausgeführt. Schließlich, wenn Sie Daten extrahieren (indem Sie implizit .toString()oder aufrufen.charCodeAt(...) etwas anderes), werden diese auf "intelligente" Weise angewendet, wobei die geringstmöglichen Daten berührt werden.
Hinweis: Die obige Zeichenfolgen-API ist ein Beispiel und möglicherweise nicht perfekt implementiert. Sie können auch nur 1-2 Funktionen verwenden, die Sie benötigen.