Heute habe ich die Frage zum Freecodecamp geübt und auf eine Frage zur String -Inversion gestoßen. Die Umkehrung einer Zeichenfolge ist eine der gängigen Interviewfragen in JavaScript. Vielleicht gibt der Interviewer Ihnen eine Zeichenfolge "Hallo Word!", Die es Ihnen ermöglicht, ihn durch JavaScript in "! Drow Olleh" zu verwandeln.
Ich bin auch Anfänger. Ich habe den Test unter Verwendung des Wissens über die zuvor gelernten Arrays und die Tipps zu den Fragen bestanden. Später fragte ich mich, dass es eine andere Möglichkeit gibt, dieses Problem zu lösen? Nach der Suche gibt es immer noch viele Methoden. Hier sind einige dieser Methoden für die spätere Verwendung.
Dinge zu tun
Dinge, die wir tun wollen:
Bevor Sie die bereitgestellte Zeichenfolge vor der Rückwärtsschnur angezeigt haben, müssen Sie die Zeichenfolge in ein Array konvertieren, und das Endergebnis ist immer noch eine Zeichenfolge.
Schauen wir uns anschließend an, welche Methoden die oben genannten Anforderungen erfüllen können.
Verwenden integrierter Funktionen
In den Übungen werden wir aufgefordert, dass wir drei Methoden verwenden können, um eine Zeichenfolge erfolgreich in umgekehrt anzuzeigen:
String.prototype.split () array.prototype.reverse () array.prototype.join ()
Gehen Sie einfach kurz durch:
Split () Methode spaltet jedes Zeichen eines String -Objekts und behandelt jede Zeichenfolge als jedes Element eines Arrays, reverse () Methode, um das Array zu ändern, die Elemente im Array in umgekehrter Reihenfolge zu ordnen, das erste Array -Element wird zum letzten und das letzte wird die erste Join () -Methode verbindet alle Elemente in der Array in eine Zeichenfolge in eine Zeichenfolge, die in eine Zeichenkette verbindet ().
Schauen wir uns ein Beispiel an:
Function ReverseString (str) {// Der erste Schritt besteht darin, die Methode von Split () zu verwenden, um ein neues Array zurückzugeben // var splitstring = "Hallo" .Split (""); var splitstring = str.split (""); // Teilen Sie die Zeichenfolge // Geben Sie ein neues Array zurück ["h", "e", "l", "l", "l", "o"] // Der zweite Schritt besteht darin, die Reverse () -Methode zu verwenden, um ein neues Array zu erstellen // var Reversearray = ["H", "E", "L", "L", "O". var Reversearray = splitstring.reverse (); // Die ursprünglichen Array -Elemente sind in Sequenz ["o", "l", "l", "e", "h"] // Der dritte Schritt besteht darin, die join () -Methode zu verwenden, um jedem Element des Arrays beizutreten und es zu einer neuen String // var JoinArray = ["O", "L", "L", "E", ",", ",", "zu". var JoinArray = Reversearray.Join (""); // "Olleh" // Der vierte Schritt besteht darin, eine neue Zeichenfolge zurückzugeben, die umgekehrt ist. Rückkehr JoinArray; // "olleh"} ReverseString ("Hallo"); // => ollehVereinfachen Sie die obige Methode und können so geschrieben werden:
Funktion ReverseString (str) {return str.split (""). reverse (). join ("");} ReverseString ("Hallo"); // => ollehVerwenden Sie die Zeichenfolge unter Verwendung einer abnehmenden Schleifenquelle
Diese Methode verwendet eine for Schleife, um eine dekrementierte Durchführung zur ursprünglichen Zeichenfolge durchzuführen und dann die Traversed-Zeichenfolge in eine neue Zeichenfolge umzusetzen:
Function ReverseString (str) {// Schritt 1: Erstellen Sie eine leere Zeichenfolge, um das neu erstellte String var NewString = "" zu speichern; // Schritt 2: Verwenden Sie die für die Schleife // Schleife beginnt, die Durchquerung von Str.Length-1 zu verringern, bis ich größer oder gleich 0 ist. Die Schleife wird fortgesetzt // Str.Length-1 entspricht dem letzten Zeichen der Zeichenfolge O für (var i = Str.Length-1; i> = 0; // oder NewString = NewString + Str [i]; } // Schritt 3: Gibt den umgekehrten String -Return NewString zurück; } ReverseString ('Hallo'); // => // "Olleh"Ein einfacher Blick auf den Prozess der String -Traversal. Angenommen, Sie müssen die Zeichenfolge "Hallo" umkehren. Der gesamte Traversalprozess ist in der folgenden Tabelle angezeigt:
i Tatsächlich kann auch die for Schleife oben durch while -Schleife ersetzt werden:
Function ReverseString (str) {var NewString = ''; var i = str.length; while (i> 0) {NewString += str.Substring (i - 1, i); ich--; } return NewString;} ReverseString ("Hallo"); // => olleh substring() Methode in while Schleife. substring() gibt ein Substring zwischen zwei Indizes der Zeichenfolge (oder am Ende der Zeichenfolge) zurück.
Implementieren Sie die String -Inversion mithilfe der Rekursion
Eine Zeichenfolge kann auch mit String.prototype.substr() und String.prototype.charAt() umgekehrt werden.
substr() -Methode gibt ein Substring in der Zeichenfolge zurück, die von der angegebenen Position auf die angegebene Länge beginnt. Zum Beispiel:
var str = "abcdefghij"; console.log ("(1,2):" + str.substr (1,2)); // (1,2): bcdefghijconsole.log ("(-3,2):" + str.substr (-3,2)); // (-3,2): Hiconsole.log ("(-3):" + str.substr (-3)); // (-3): hijconsole.log ("(1):" + str.substr (1)); // (1): bcdefghijconsole.log ("(-20, 2):" + str.substr (-20, 2)); // (-20, 2): Abconsole.log ("(20, 2):" + str.substr (20, 2)); // (20, 2): charAt() -Methode gibt das Zeichen an der angegebenen Position in der Zeichenfolge zurück. Die Zeichen in der Zeichenfolge sind von links nach rechts indiziert, das erste Zeichen hat einen Indexwert von 0 und das letzte Zeichen (unter der Annahme, dass das Zeichen im String stringName liegt) hat einen Indexwert von stringName.length - 1 . Wenn der angegebene index außerhalb dieses Bereichs liegt, wird eine leere Zeichenfolge zurückgegeben.
var irgendeiner = "Brave New World"; Konsole.log ("Das Zeichen bei Index 0 ist '" + Anstring.charat (0) + "'"); // => Das Zeichen bei Index 0 lautet 'b'console.log ("Das Zeichen bei Index 1 ist'" + irgendeinerstring.charat (1) + "'"); // => Das Zeichen bei Index 1 ist 'r'console.log ("Das Zeichen bei Index 2 ist'" + irgendeinerstring.charat (2) + "'"); // => Das Zeichen bei Index 2 lautet 'a'console.log ("Das Zeichen bei Index 3 ist'" + irgendeinerstring.charat (3) + "'"); // => Das Zeichen bei Index 3 ist 'v'console.log ("Das Zeichen bei Index 4 ist'" + irgendeinerstring.charat (4) + "'"); // => Das Zeichen bei Index 4 ist 'e'console.log ("Das Zeichen bei Index 999 ist'" + irgendeinerstring.charat (999) + "'"); // => Das Zeichen am Index 999 ist '' ''Zusammen können wir dies tun, um die String -Inversion zu implementieren:
Funktion ReverSeString (str) {if (str === "") {return ""; } else {return ReverSeString (Str.Substr (1)) + str.charat (0); }} ReverSestring ("Hallo"); // => ollehDer erste Teil der rekursiven Methode. Sie müssen sich daran erinnern, dass Sie es nicht nur einmal anrufen, sondern mehrere verschachtelte Anrufe haben.
Teil 2 rekursive Methode.
Die obige Methode kann weiter verbessert und in einen ternären Operator geändert werden
Funktion ReverSeString (str) {return (str === '')? '': ReverseString (str.Substr (1)) + str.charat (0);} ReverseString ("Hallo"); // => ollehEs kann auch in diese Methode geändert werden
function ReverSeString (str) {return str && reverSeString (str.substr (1)) + str [0];} ReverseString ("Hallo"); // => ollehAndere Methoden
Zusätzlich zu den oben genannten Methoden gibt es tatsächlich einige andere Methoden:
Methode 1 COPY CODE CODE ist wie folgt: function reverseString (str) { var newString = []; for (var i = str.length - 1, j = 0; i >= 0; i--, j++) { newString[j] = str[i]; } return newString.join('');}reverseString("hello"); // => olleh Methode 2 lautet wie folgt: function reverseString (str) { for (var i = str.length - 1, newString = ''; i >= 0; newString += str[i--] ) { } return newString;}reverseString("hello"); // => olleh Methode lautet wie folgt: function reverseString (str) { function rev(str, len, newString) { return (len === 0) ? newString : rev(str, --len, (newString += str[len])); } return rev(str, str.length, '');}reverseString("hello"); // =>olleh Methode lautet wie folgt: function reverseString (str) { str = str.split(''); var len = str.length, halfIndex = Math.floor(len / 2) - 1, newString; for (var i = 0; i <= halfIndex; i++) { newString = str[len - i - 1]; str[len - i - 1] = str[i]; str[i] = newString; } return str.join('');}reverseString("hello"); // => olleh -Methode Fünf kopieren Code Code lautet wie folgt: function reverseString (str) { if (str.length < 2) { return str; } var halfIndex = Math.ceil(str.length / 2); return reverseString(str.substr(halfIndex)) + reverseString(str.substr(0, halfIndex));}reverseString("hello"); // =>olleh Methode lautet wie folgt: function reverseString(str) { return [].reduceRight.call(str, function(prev, curr) { return prev + curr; }, '');}reverseString("hello"); // =>olleh ES6 -Methode
In ES6 kann es einfacher gemacht werden, wie beispielsweise:
[...str].reverse().join('');
oder [...str].reduceRight( (prev, curr) => prev + curr );
oder:
const reverse = str => str && reverse(str.substr(1)) + str[0];
Die String -Inversion ist, wie bereits erwähnt, ein kleiner und einfacher Algorithmus und wird häufig verwendet, um grundlegende JavaScript zu befragen. Sie können die oben genannten Methoden verwenden, um dieses Problem zu lösen oder sogar komplexere Lösungen zu verwenden. Wenn Sie einen besseren Weg haben, fügen Sie ihn bitte in die Kommentare unten hinzu und teilen Sie es mit uns.