wake-up-neo.com

Wie kann eine Zeichenfolge in JavaScript umgekehrt werden?

Wie kehrt man eine Zeichenfolge in JavaScript um, wenn sie mit einer return-Anweisung an eine Funktion übergeben wird? Alles ohne die eingebauten Funktionen zu nutzen? .reverse(), .charAt() usw.

379
Jake

Solange Sie es mit einfachen ASCII -Zeichen zu tun haben und gern integrierte Funktionen verwenden, wird dies funktionieren:

function reverse(s){
    return s.split("").reverse().join("");
}

Wenn Sie eine Lösung benötigen, die UTF-16-Zeichen oder andere Multibyte-Zeichen unterstützt, müssen Sie beachten, dass diese Funktion ungültige Unicode-Zeichenfolgen oder gültige Zeichenfolgen liefert, die komisch aussehen. Möglicherweise möchten Sie stattdessen diese Antwort betrachten.

681
belacqua

Die folgende (oder ähnliche) Technik wird häufig zum Umkehren einer Zeichenfolge in JavaScript verwendet:

// Don’t use this!
var naiveReverse = function(string) {
    return string.split('').reverse().join('');
}

Tatsächlich sind alle bisher veröffentlichten Antworten eine Variation dieses Musters. Es gibt jedoch einige Probleme mit dieser Lösung. Zum Beispiel:

naiveReverse('foo ???? bar');
// → 'rab �� oof'
// Where did the `????` symbol go? Whoops!

Wenn Sie sich fragen, warum dies passiert, lesen Sie die interne Zeichencodierung von JavaScript . (TL; DR: ???? ist ein Astralsymbol, und JavaScript macht es als zwei separate Codeeinheiten verfügbar.)

Aber es gibt noch mehr:

// To see which symbols are being used here, check:
// http://mothereff.in/js-escapes#1ma%C3%B1ana%20man%CC%83ana
naiveReverse('mañana mañana');
// → 'anãnam anañam'
// Wait, so now the tilde is applied to the `a` instead of the `n`? WAT.

Eine gute Zeichenfolge zum Testen von umgekehrten Implementierungen von Zeichenfolgen ist die folgenden :

'foo ???? bar mañana mañana'

Warum? Weil es ein astrales Symbol (????) (das durch Ersatzzeichenpaare in JavaScript dargestellt wird) und eine Kombinationsmarkierung enthält (der im letzten mañana besteht tatsächlich aus zwei Symbolen: U + 006E LATIN SMALL LETTER N und U + 0303 TILDE KOMBINIEREN).

Die Reihenfolge, in der Ersatzpaare erscheinen, kann nicht umgekehrt werden, sonst erscheint das Astralsymbol nicht mehr in der "umgekehrten" Zeichenfolge. Deshalb haben Sie diese ��-Markierungen in der Ausgabe des vorherigen Beispiels gesehen.

Kombinationsmarkierungen werden immer auf das vorherige Symbol angewendet. Daher müssen Sie sowohl das Hauptsymbol (U + 006E LATIN SMALL LETTER N) als Kombinationsmarkierung (U + 0303 COMBINING TILDE) als Ganzes behandeln. Wenn Sie ihre Reihenfolge umkehren, wird die Kombinationsmarkierung mit einem anderen Symbol in der Zeichenfolge gekoppelt. Deshalb hatte die Beispielausgabe anstelle von ñ.

Hoffentlich erklärt das, warum alle bisher veröffentlichten Antworten falsch sind.


Um Ihre erste Frage zu beantworten - wie Sie eine Zeichenfolge in JavaScript umkehren -, habe ich eine kleine JavaScript-Bibliothek geschrieben, die Unicode-fähige Zeichenkettenumkehrung ermöglicht. Es gibt keine der Probleme, die ich gerade angesprochen habe. Die Bibliothek heißt Esrever ; Der Code befindet sich auf GitHub und funktioniert in nahezu jeder JavaScript-Umgebung. Es wird mit einem Shell-Hilfsprogramm/Binärprogramm geliefert, sodass Sie Strings von Ihrem Terminal aus problemlos umkehren können, wenn Sie möchten.

var input = 'foo ???? bar mañana mañana';
esrever.reverse(input);
// → 'anañam anañam rab ???? oof'

Bezüglich des In-Place-Teils siehe die anderen Antworten.

387
Mathias Bynens
String.prototype.reverse=function(){return this.split("").reverse().join("");}

oder

String.prototype.reverse = function() {
    var s = "";
    var i = this.length;
    while (i>0) {
        s += this.substring(i-1,i);
        i--;
    }
    return s;
}
88
Bob

Detaillierte Analyse und zehn verschiedene Möglichkeiten zum Umkehren einer Zeichenfolge und ihrer Leistungsdetails.

http://eddmann.com/posts/ten-ways-to-reverse-a-string-in-javascript/

Perfomance dieser Implementierungen:

Implementierung (en) mit der besten Leistung pro Browser

  • Chrome 15 - Implementierungen 1 und 6 
  • Firefox 7 - Implementierung 6 
  • IE 9 - Implementierung 4 
  • Opera 12 - Umsetzung 9

Hier sind diese Implementierungen:

Implementierung 1:

function reverse(s) {
  var o = '';
  for (var i = s.length - 1; i >= 0; i--)
    o += s[i];
  return o;
}

Implementierung 2:

function reverse(s) {
  var o = [];
  for (var i = s.length - 1, j = 0; i >= 0; i--, j++)
    o[j] = s[i];
  return o.join('');
}

Implementierung 3:

function reverse(s) {
  var o = [];
  for (var i = 0, len = s.length; i <= len; i++)
    o.Push(s.charAt(len - i));
  return o.join('');
}

Implementierung 4:

function reverse(s) {
  return s.split('').reverse().join('');
}

Implementierung 5:

function reverse(s) {
  var i = s.length,
      o = '';
  while (i > 0) {
    o += s.substring(i - 1, i);
    i--;
  }
  return o;
}

Implementierung 6:

function reverse(s) {
  for (var i = s.length - 1, o = ''; i >= 0; o += s[i--]) { }
  return o;
}

Implementierung 7:

function reverse(s) {
  return (s === '') ? '' : reverse(s.substr(1)) + s.charAt(0);
}

Implementierung 8:

function reverse(s) {
  function rev(s, len, o) {
    return (len === 0) ? o : rev(s, --len, (o += s[len]));
  };
  return rev(s, s.length, '');
}

Implementierung 9:

function reverse(s) {
  s = s.split('');
  var len = s.length,
      halfIndex = Math.floor(len / 2) - 1,
      tmp;


     for (var i = 0; i <= halfIndex; i++) {
        tmp = s[len - i - 1];
        s[len - i - 1] = s[i];
        s[i] = tmp;
      }
      return s.join('');
    }

Implementierung 10

function reverse(s) {
  if (s.length < 2)
    return s;
  var halfIndex = Math.ceil(s.length / 2);
  return reverse(s.substr(halfIndex)) +
         reverse(s.substr(0, halfIndex));
}
50
Anil Arrabole

Das ganze "Reverse a string in place" ist eine veraltete Interview-Frage an C-Programmierer, und Leute, die von ihnen interviewt wurden (aus Rache, vielleicht?), Werden fragen. Leider funktioniert der "In Place" -Teil nicht mehr, da Zeichenfolgen in praktisch jeder verwalteten Sprache (JS, C # usw.) unveränderliche Zeichenfolgen verwendet werden, was die Idee des Verschiebens einer Zeichenfolge zunichte macht, ohne neuen Speicher zuzuweisen.

Während die obigen Lösungen eine Zeichenfolge tatsächlich umkehren, tun sie dies nicht, ohne mehr Speicher zuzuweisen, und erfüllen somit nicht die Bedingungen. Sie müssen direkten Zugriff auf die zugewiesene Zeichenfolge haben und in der Lage sein, ihren ursprünglichen Speicherplatz zu ändern, um sie an ihrem Platz umkehren zu können.

Ich persönlich hasse solche Interviewfragen wirklich, aber ich bin mir sicher, dass wir sie auch in den nächsten Jahren sehen werden.

50
Mozleron

Verwenden Sie zuerst Array.from() , um eine Zeichenfolge in ein Array zu verwandeln, dann Array.prototype.reverse() , um das Array umzukehren, und dann Array.prototype.join() , um eine Zeichenfolge zu erstellen.

const reverse = str => Array.from(str).reverse().join('');
35

In ECMAScript 6 können Sie eine Zeichenfolge noch schneller umkehren, ohne die .split('') split-Methode zu verwenden, mit dem Operator spread wie folgt: 

var str = [...'racecar'].reverse().join('');
22
Luke

Anscheinend bin ich 3 Jahre zu spät zur Party ...

Leider kann man das nicht, wie gesagt wurde. Siehe Sind JavaScript-Zeichenfolgen unveränderlich? Benötige ich einen "String Builder" in JavaScript?

Die nächstbeste Sache, die Sie tun können, ist das Erstellen einer "Ansicht" oder eines "Wrappers", die eine Zeichenfolge benötigt und alle Teile der verwendeten API der Zeichenfolgen-API reimplementiert. 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 - das Folgende wird vor Ort durch reine Mathematik ausgeführt, wobei jeder Charakter nur einmal besucht wird und nur, wenn nötig:

> '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 Saite angewendet werden, wenn Sie nur eine relativ kleine Scheibe davon nehmen.

Ob sich dies lohnt (über die Umkehrung als Kopie wie in den meisten Programmiersprachen), hängt in hohem Maße von Ihrem Anwendungsfall und davon ab, wie effizient Sie die String-API erneut implementieren. Wenn Sie z. B. nur die Indexbearbeitung des Strings durchführen oder kleine slices oder substrs verwenden möchten, sparen Sie Platz und Zeit. Wenn Sie jedoch planen, große umgekehrte Segmente oder Teilzeichenfolgen zu drucken, können die Einsparungen tatsächlich gering sein, sogar noch schlimmer als eine vollständige Kopie. Ihre "umgekehrte" Zeichenfolge hat auch nicht den Typ string, obwohl Sie dies möglicherweise durch Prototyping vortäuschen können.

Die obige Demo-Implementierung erstellt ein neues Objekt vom Typ ReversedString. Es ist prototypisch und daher ziemlich effizient, mit fast minimalem Arbeitsaufwand und minimalem Platzbedarf (Prototypdefinitionen werden gemeinsam genutzt). Es ist eine faule Implementierung, die ein verzögertes Slicing beinhaltet. Immer, wenn Sie eine Funktion wie .slice oder .reversed ausführen, führt sie eine Indexmathematik aus. Wenn Sie schließlich Daten extrahieren (indem Sie .toString() oder .charCodeAt(...) oder etwas implizit aufrufen), werden diese auf "intelligente" Art und Weise angewendet und berühren so wenig Daten wie möglich.

Hinweis: Die obige String-API ist ein Beispiel und kann nicht perfekt implementiert werden. Sie können auch nur 1-2 Funktionen verwenden, die Sie benötigen.

19
ninjagecko

Während eines Interviews wurde ich gebeten, eine Zeichenfolge umzukehren, ohne Variablen oder native Methoden zu verwenden. Dies ist meine Lieblingsimplementierung:

function reverseString(str) {
    return str === '' ? '' : reverseString(str.slice(1)) + str[0];
}
10
Alex Hawkins
var str = 'sample string';
[].map.call(str, function(x) {
  return x;
}).reverse().join('');

OR

var str = 'sample string';
console.log(str.split('').reverse().join(''));

// Ausgabe: 'gnirts elpmas'

6
Yogesh

Dies ist die einfachste Art, wie ich denke

var reverse = function(str) {
    var arr = [];
    
    for (var i = 0, len = str.length; i <= len; i++) {
        arr.Push(str.charAt(len - i))
    }

    return arr.join('');
}

console.log(reverse('I want a ????'));

6
Fatih

Es gibt mehrere Möglichkeiten, dies zu tun. Sie können Folgendes prüfen:

1. Traditionelle for-Schleife (Inkrementieren):

function reverseString(str){
        let stringRev ="";
        for(let i= 0; i<str.length; i++){
            stringRev = str[i]+stringRev;
        }
        return stringRev;
}
alert(reverseString("Hello World!"));

2. Traditionell für Schleife (Dekrementieren):

function reverseString(str){
    let revstr = "";
    for(let i = str.length-1; i>=0; i--){
        revstr = revstr+ str[i];
    }
    return revstr;
}
alert(reverseString("Hello World!"));

3. for-of-Schleife verwenden

function reverseString(str){
    let strn ="";
    for(let char of str){
        strn = char + strn;
    }
    return strn;
}
alert(reverseString("Get well soon"));

4. Verwendung der Arraymethode forEach/high order:

function reverseString(str){

  let revSrring = "";
  str.split("").forEach(function(char){
    
    revSrring = char + revSrring;
  
  });
  return revSrring;
}
alert(reverseString("Learning JavaScript"));

5. ES6-Standard:

function reverseString(str){

  let revSrring = "";
  str.split("").forEach(char => revSrring = char + revSrring);
  return revSrring;
}
alert(reverseString("Learning JavaScript"));

6. Der neueste Weg:

function reverseString(str){

  return str.split("").reduce(function(revString, char){
       return char + revString;
  }, "");
 
}

alert(reverseString("Learning JavaScript"));

7. Sie können das Ergebnis auch mit folgendem Befehl erhalten:

function reverseString(str){

  return str.split("").reduce((revString, char)=> char + revString, "");
 
}
alert(reverseString("Learning JavaScript"));

6
Maher Hossain

Ich weiß, dass dies eine alte Frage ist, die gut beantwortet wurde, aber zu meiner eigenen Unterhaltung schrieb ich die folgende umgekehrte Funktion und dachte, ich würde sie teilen, falls sie für andere nützlich wäre. Es behandelt sowohl Ersatzpaare als auch kombinierte Marken:

function StringReverse (str)
{
  var charArray = [];
  for (var i = 0; i < str.length; i++)
    {
      if (i+1 < str.length)
        {
          var value = str.charCodeAt(i);
          var nextValue = str.charCodeAt(i+1);
          if (   (   value >= 0xD800 && value <= 0xDBFF
                  && (nextValue & 0xFC00) == 0xDC00) // Surrogate pair)
              || (nextValue >= 0x0300 && nextValue <= 0x036F)) // Combining marks
            {
              charArray.unshift(str.substring(i, i+2));
              i++; // Skip the other half
              continue;
            }
        }

      // Otherwise we just have a rogue surrogate marker or a plain old character.
      charArray.unshift(str[i]);
    }

  return charArray.join('');
}

Alle Requisiten an Mathias, Punycode und verschiedene andere Referenzen, um mich über die Komplexität der Zeichencodierung in JavaScript zu informieren.

5
Scott Gartner

Es gibt viele Möglichkeiten, einen String in JavaScript umzukehren. Ich schreibe drei Arten auf, die ich bevorzuge.

Ansatz 1 mit Rückwärtsfunktion:

function reverse(str) {
  return str.split('').reverse().join('');
}

Annäherung 2, die Zeichen durchläuft:

function reverse(str) {
  let reversed = '';

  for (let character of str) {
    reversed = character + reversed;
  }

  return reversed;
}

Ansatz 3 mit Reduktionsfunktion:

function reverse(str) {
  return str.split('').reduce((rev, char) => char + rev, '');
}

Ich hoffe das hilft :)

4

In ES6 haben Sie eine weitere Option

function reverseString (str) {
  return [...str].reverse().join('')
}

reverseString('Hello');
4
Dava E.

Sie können nicht, weil JS-Zeichenfolgen unveränderlich sind. Kurze nicht vor Ort Lösung

[...str].reverse().join``
let str = "Hello World!";
let r = [...str].reverse().join``;
console.log(r);
2

Die eigentliche Antwort lautet: Sie können sie nicht rückgängig machen, aber Sie können eine neue Zeichenfolge erstellen, die umgekehrt ist.

Eine Übung, um mit Rekursion zu spielen: Manchmal, wenn Sie zu einem Interview gehen, werden Sie möglicherweise vom Interviewer gefragt, wie dies mit Rekursion zu tun ist, und ich denke, die "bevorzugte Antwort" könnte sein: "Ich würde dies lieber nicht in Rekursion machen kann leicht zu einem Stack-Überlauf führen "(weil es sich nicht um O(n), sondern um O(log n) handelt. Wenn es sich um O(log n) handelt, ist es ziemlich schwierig, einen Stack-Overflow zu erhalten - 4 Milliarden Elemente könnten von einer Stack-Ebene von 32 als 2 ** 32 behandelt werden ist 4294967296. Wenn es sich jedoch um O(n) handelt, kann es leicht zu einem Stapelüberlauf kommen.

Manchmal fragt dich der Interviewer immer noch: "Nur als Übung, warum schreibst du es nicht immer noch mit Rekursion?" Und hier ist es:

String.prototype.reverse = function() {
    if (this.length <= 1) return this;
    else return this.slice(1).reverse() + this.slice(0,1);
}

testlauf:

var s = "";
for(var i = 0; i < 1000; i++) {
    s += ("Apple" + i);
}
console.log(s.reverse());

ausgabe:

999elppa899elppa...2elppa1elppa0elppa

Um einen Stack-Überlauf zu erzielen, habe ich in Google Chrome 1000 in 10000 geändert.

RangeError: Maximum call stack size exceeded
//es6
//array.from
const reverseString = (string) => Array.from(string).reduce((a, e) => e + a);
//split
const reverseString = (string) => string.split('').reduce((a, e) => e + a); 

//split problem
"????????".split('')[0] === Array.from("????????")[0] // "�" === "????" => false
"????????????".split('')[0] === Array.from("????????????")[0] // "�" === "????" => false
2
alejandro

Zeichenfolgen selbst sind unveränderlich, aber Sie können mit dem folgenden Code problemlos eine stornierte Kopie erstellen:

function reverseString(str) {

  var strArray = str.split("");
  strArray.reverse();

  var strReverse = strArray.join("");

  return strReverse;
}

reverseString("hello");

Wenn Sie keine eingebaute Funktion verwenden möchten. Versuche dies

        var string = 'abcdefg';
        var newstring = '';

        for(let i = 0; i < string.length; i++){
            newstring = string[i] += newstring
        }

        console.log(newstring)
2
jitendra rajput

Ich denke, String.prototype.reverse ist ein guter Weg, um dieses Problem zu lösen.

String.prototype.reverse = function() {
  return this.split('').reverse().join('');
}

var str = 'this is a good example for string reverse';
str.reverse();
-> "esrever gnirts rof elpmaxe doog a si siht";
1
jingyinggong

Behalte es DRY und einfach dumm !!

function reverse(s){
let str = s;
var reverse = '';
for (var i=str.length;i>0;i--){

    var newstr = str.substring(0,i)
    reverse += newstr.substr(-1,1)
}
return reverse;
}
1
Sagar Munjal
function reverseString(string) {
    var reversedString = "";
    var stringLength = string.length - 1;
    for (var i = stringLength; i >= 0; i--) {
        reversedString += string[i];
    }
    return reversedString;
}
1
GR1000

Mein eigener ursprünglicher Versuch ...

var str = "The Car";

function reverseStr(str) {
  var reversed = "";
  var len = str.length;
  for (var i = 1; i < (len + 1); i++) {  
    reversed += str[len - i];      
  }

  return reversed;
}

var strReverse = reverseStr(str);    
console.log(strReverse);
// "raC ehT"

http://jsbin.com/bujiwo/19/edit?js,console,output

1
AntonB

ohne Umwandlung von String in Array;

String.prototype.reverse = function() {

    var ret = "";
    var size = 0;

    for (var i = this.length - 1; -1 < i; i -= size) {

        if (
          '\uD800' <= this[i - 1] && this[i - 1] <= '\uDBFF' && 
          '\uDC00' <= this[i]     && this[i]     <= '\uDFFF'
        ) {
            size = 2;
            ret += this[i - 1] + this[i];
        } else {
            size = 1;
            ret += this[i];
        }
    }

    return ret;
}

console.log('anãnam anañam' === 'mañana mañana'.reverse());

verwenden von Array.reverse, ohne Zeichen in Codepunkte umzuwandeln;

String.prototype.reverse = function() {

    var array = this.split("").reverse();

    for (var i = 0; i < this.length; ++i) {

        if (
          '\uD800' <= this[i - 1] && this[i - 1] <= '\uDBFF' && 
          '\uDC00' <= this[i]     && this[i]     <= '\uDFFF'
        ) {
            array[i - 1] = array[i - 1] + array[i];
            array[i] = array[i - 1].substr(0, 1);
            array[i - 1] = array[i - 1].substr(1, 1);
        }

    }

    return array.join("");
}

console.log('anãnam anañam' === 'mañana mañana'.reverse());
1
masakielastic

Beste Möglichkeiten, eine Zeichenfolge in JavaScript umzukehren

1) Array.reverse:

Sie denken wahrscheinlich, ich dachte, wir würden eine Zeichenkette umkehren, warum verwenden Sie die Array.reverse-Methode. Mit der String.split-Methode konvertieren wir unseren String in ein Array von Zeichen. Dann kehren wir die Reihenfolge der einzelnen Werte im Array um, und schließlich konvertieren wir das Array mithilfe der Array.join-Methode zurück in einen String.

function reverseString(str) {
    return str.split('').reverse().join('');
}
reverseString('dwayne');

2) While-Schleife dekrementieren:

Diese Lösung ist zwar ziemlich ausführlich, hat jedoch gegenüber der ersten Lösung ihre Vorteile. Sie erstellen kein Array und verketten nur eine Zeichenfolge, die auf Zeichen der Quellzeichenfolge basiert.

Aus Performance-Sicht würde dies wahrscheinlich die besten Ergebnisse erzielen (wenn auch nicht getestet). Bei extrem langen Saiten können die Leistungssteigerungen jedoch aus dem Fenster fallen.

function reverseString(str) {
    var temp = '';
    var i = str.length;

    while (i > 0) {
        temp += str.substring(i - 1, i);
        i--;
    }


    return temp;
}
reverseString('dwayne');

3) Rekursion

Ich liebe es, wie einfach und klar diese Lösung ist. Sie können deutlich erkennen, dass die Methoden String.charAt und String.substr dazu verwendet werden, einen anderen Wert zu übergeben, indem Sie sich jedes Mal selbst aufrufen, bis die Zeichenfolge leer ist. Der Ternär würde lediglich eine leere Zeichenfolge zurückgeben, statt ihn selbst aufzurufen . Dies würde wahrscheinlich die zweitbeste Leistung nach der zweiten Lösung ergeben.

function reverseString(str) {
    return (str === '') ? '' : reverseString(str.substr(1)) + str.charAt(0);
}
reverseString('dwayne');
1

OK, ziemlich einfach, Sie können eine Funktion mit einer einfachen Schleife erstellen, um die Zeichenfolge rückgängig zu machen, ohne reverse(), charAt() usw. wie folgt zu verwenden:

Zum Beispiel haben Sie diese Zeichenfolge:

var name = "StackOverflow";

Erstellen Sie eine Funktion wie diese, ich nenne sie reverseString...

function reverseString(str) {
  if(!str.trim() || 'string' !== typeof str) {
    return;
  }
  let l=str.length, s='';
  while(l > 0) {
    l--;
    s+= str[l];
  }
  return s;
}

Und man kann es so nennen:

reverseString(name);

Und das Ergebnis wird sein:

"wolfrevOkcatS"
1
Alireza

Verwenden von Array-Funktionen

String.prototype.reverse = function(){
    return [].reduceRight.call(this, function(last, secLast){return last + secLast});
}
1
Darshan
var str = "my name is saurabh ";
var empStr='',finalString='';
var chunk=[];
function reverse(str){
var i,j=0,n=str.length;
    for(i=0;i<n;++i){
        if(str[i]===' '){
            chunk[j]=empStr;
            empStr = '';
            j++;
        }else{
            empStr=empStr+str[i];
        }
    }
    for(var z=chunk.length-1;z>=0;z--){
        finalString = finalString +' '+ chunk[z];
        console.log(finalString);
    }
    return true;
}
reverse(str);
1
Robin

Hier sind die vier häufigsten Methoden, mit denen Sie eine Stringumkehrung erreichen können

Geben Sie bei einer Zeichenfolge eine neue Zeichenfolge mit der umgekehrten Reihenfolge der Zeichen Zurück

Mehrere Lösungen für das Problem

//reverse('Apple') === 'leppa'
//reverse('hello') === 'olleh'
//reverse('Greetings!') === '!sgniteerG'

// 1. First method without using reverse function and negative for loop
function reverseFirst(str) {
    if(str !== '' || str !==undefined || str !== null) {
        const reversedStr = [];
        for(var i=str.length; i>-1; i--) {
        reversedStr.Push(str[i]);
        }
    return reversedStr.join("").toString();
    }
}

// 2. Second method using the reverse function
function reverseSecond(str) {
    return str.split('').reverse().join('');
}

// 3. Third method using the positive for loop
function reverseThird(str){
    const reversedStr = [];
    for(i=0; i<str.length;i++) {
        reversedStr.Push(str[str.length-1-i])
    }
    return reversedStr.join('').toString();
}

// 4. using the modified for loop ES6
function reverseForth(str) {
    const reversedStr = [];
    for(let character of str) {
        reversedStr = character + reversedStr;
    }
    return reversedStr;
}

// 5. Using Reduce function
function reverse(str) {
    return str.split('').reduce((reversed, character) => {
        return character + reversed;  
    }, '');
}
1
Harshit Pant

Eine kleine Funktion, die sowohl diakritische Zeichen als auch 2-Byte-Zeichen kombiniert:

(function(){
  var isCombiningDiacritic = function( code )
  {
    return (0x0300 <= code && code <= 0x036F)  // Comb. Diacritical Marks
        || (0x1AB0 <= code && code <= 0x1AFF)  // Comb. Diacritical Marks Extended
        || (0x1DC0 <= code && code <= 0x1DFF)  // Comb. Diacritical Marks Supplement
        || (0x20D0 <= code && code <= 0x20FF)  // Comb. Diacritical Marks for Symbols
        || (0xFE20 <= code && code <= 0xFE2F); // Comb. Half Marks

  };

  String.prototype.reverse = function()
  {
    var output = "",
        i      = this.length - 1,
        width;

    for ( ; i >= 0; --i )
    {
      width = 1;
      while( i > 0 && isCombiningDiacritic( this.charCodeAt(i) ) )
      {
        --i;
        width++;
      }

      if (
           i > 0
        && "\uDC00" <= this[i]   && this[i]   <= "\uDFFF"
        && "\uD800" <= this[i-1] && this[i-1] <= "\uDBFF"
      )
      {
        --i;
        width++;
      }

      output += this.substr( i, width );
    }

    return output;
  }
})();

// Tests
[
  'abcdefg',
  'ab\u0303c',
  'a\uD83C\uDFA5b',
  'a\uD83C\uDFA5b\uD83C\uDFA6c',
  'a\uD83C\uDFA5b\u0306c\uD83C\uDFA6d',
  'TO͇̹̺ͅƝ̴ȳ̳ TH̘Ë͖́̉ ͠P̯͍̭O̚​N̐Y̡' // copied from http://stackoverflow.com/a/1732454/1509264
].forEach(
  function(str){ console.log( str + " -> " + str.reverse() ); }
);
  

1
MT0

Das Folgende kann jedem helfen, der eine Zeichenfolge rekursiv umkehren möchte. Wurde in einem kürzlich durchgeführten Vorstellungsgespräch im funktionalen Programmierstil dazu aufgefordert:

var reverseStr = function(str) {
    return (str.length > 0) ? str[str.length - 1] + reverseStr(str.substr(0, str.length -   1)) : '';
};

//tests
console.log(reverseStr('setab retsam')); //master bates
0
Alex Hawkins
var str = "IAMA JavaScript Developer";
var a=str.split(''), b = a.length;
for (var i=0; i<b; i++) {
    a.unshift(a.splice(1+i,1).shift())
}
a.shift();
alert(a.join(''));
0
Nathan Romano

So etwas sollte nach den bewährten Methoden durchgeführt werden:

(function(){
	'use strict';
	var str = "testing";
	
	//using array methods
	var arr = new Array();
	arr = str.split("");
	arr.reverse();
	console.log(arr);
	
	//using custom methods
	var reverseString = function(str){
		
		if(str == null || str == undefined || str.length == 0 ){
			return "";
		}
		
		if(str.length == 1){
			return str;
		}
		
		var rev = [];
		for(var i = 0; i < str.length; i++){
			rev[i] = str[str.length - 1 - i];
		}
		return rev;
	} 
	
	console.log(reverseString(str));
	
})();

0
Pritam Banerjee

Sie könnten so etwas versuchen. Ich bin sicher, es gibt Raum für Refactoring. Mit der Split-Funktion konnte ich nicht umgehen. Vielleicht kennt jemand einen Weg, es ohne Split zu tun.

Der einzurichtende Code kann dies in Ihre .js-Bibliothek aufnehmen

Zu verwendender Code (hat clientseitigen Code, nur weil er in einem Browser getestet wurde):

var sentence = "My Stack is Overflowing."
document.write(sentence.reverseLetters() + '<br />');
document.write(sentence.reverseWords() + '<br />');

Snippet:

String.prototype.aggregate = function(vals, aggregateFunction) {

  var temp = '';
  for (var i = vals.length - 1; i >= 0; i--) {
    temp = aggregateFunction(vals[i], temp);
  }
  return temp;
}

String.prototype.reverseLetters = function() {
  return this.aggregate(this.split(''),
    function(current, Word) {
      return Word + current;
    })
}

String.prototype.reverseWords = function() {
  return this.aggregate(this.split(' '),
    function(current, Word) {
      return Word + ' ' + current;
    })
}

var sentence = "My Stack is Overflowing."
document.write(sentence.reverseLetters() + '<br />');
document.write(sentence.reverseWords() + '<br />');

0
Justin Largey

Das Hinzufügen zum String-Prototyp ist ideal (nur für den Fall, dass es in der JS-Kernsprache hinzugefügt wird). Sie müssen jedoch zunächst prüfen, ob es vorhanden ist, und es hinzufügen, wenn es nicht vorhanden ist.

String.prototype.reverse = String.prototype.reverse || function () {
    return this.split('').reverse().join('');
};
0
charlchad
Word.split('').reduce((acc, curr) => curr+""+acc)
0
Parth Chokshi

Ich denke, das wird für Sie funktionieren

function reverse(str){
    str = str.split("").reverse().join("").split(" ").reverse().join(" ");
    console.log(str)
}
0
M Sohaib Khan

Eine andere Variante (funktioniert das mit IE?):

String.prototype.reverse = function() {
    for (i=1,s=""; i<=this.length; s+=this.substr(-i++,1)) {}
    return s;
}

BEARBEITEN:

Dies ist ohne die Verwendung von integrierten Funktionen:

String.prototype.reverse = function() {
    for (i=this[-1],s=""; i>=0; s+=this[i--]) {}
    return s;
}

Hinweis: Diese [-1] enthält eine Länge der Zeichenfolge.

Es ist jedoch nicht möglich, die Zeichenfolge umzukehren, da die Zuweisung an einzelne Array-Elemente nicht mit dem String-Objekt (geschützt?) Funktioniert. Das heißt Sie können Zuweisungen machen, aber die resultierende Zeichenfolge ändert sich nicht.

0
Thevs
function reverse_string(string)
{
var string;

var len = string.length;

var stringExp = string.split('');
var i;
for (i = len-1; i >=0;i--)
{
var result = document.write(stringExp[i]);
}

return result;
}

reverse_string("This is a reversed string");

// ausgaben: gnirts desrever a si sihT

0
Steven Mcsorley

Hier ist ein einfaches unveränderliches Beispiel für ES6, ohne Array.prototype.reverse zu verwenden:

// :: reverse = String -> String
const reverse = s => [].reduceRight.call(s, (a, b) => a + b)

console.log(reverse('foo')) // => 'oof'
console.log(reverse('bar')) // => 'rab'
console.log(reverse('foo-bar')) // => 'rab-oof'

0
Alan R. Soares
function reverse(str){
var s = "";
for (var i = str.length - 1; i >= 0; i--){
    s += str[i];
}
return s;
};
reverse("your string comes here")
0
Henry Lynx
var reverseString = function(str){ 
  let length = str.length - 1;
  str = str.split('');

  for(let i=0;i<= length;i++){
    str[length + i + 1] = str[length - i];
  }

  return str.splice(length + 1).join('');
}
0
Yazan Rawashdeh