Drei Möglichkeiten, einen String in JavaScript umzukehren

Dieser Artikel basiert auf dem Free Algorithmus Camp Basic Algorithm Scripting „Reverse a String“.

Das Umkehren einer Zeichenfolge ist eine der am häufigsten gestellten JavaScript-Fragen in der technischen Interviewrunde. Interviewer fordern Sie möglicherweise auf, verschiedene Methoden zum Umkehren einer Zeichenfolge zu schreiben, oder sie bitten Sie, eine Zeichenfolge ohne Verwendung eingebauter Methoden umzukehren, oder sie fordern Sie sogar auf, eine Zeichenfolge mithilfe der Rekursion umzukehren.

Es gibt möglicherweise zig verschiedene Möglichkeiten , es zu tun, ohne die eingebauten in umgekehrter Funktion, wie JavaScript keinen hat.

Im Folgenden sind meine drei interessantesten Möglichkeiten aufgeführt, um das Problem des Umkehrens einer Zeichenfolge in JavaScript zu lösen.

Algorithmus-Herausforderung

Kehren Sie die angegebene Zeichenfolge um.

Möglicherweise müssen Sie die Zeichenfolge in ein Array umwandeln, bevor Sie sie umkehren können.

Ihr Ergebnis muss eine Zeichenfolge sein.

function reverseString(str) { return str; } reverseString("hello");

Bereitgestellte Testfälle

  • reverseString ("Hallo") sollte "olleh" werden
  • reverseString ("Howdy") sollte "ydwoH" werden
  • reverseString ("Grüße von der Erde") sollte "htraE morf sgniteerG" zurückgeben.

1. Kehren Sie einen String mit integrierten Funktionen um

Für diese Lösung werden drei Methoden verwendet: die Methode String.prototype.split (), die Methode Array.prototype.reverse () und die Methode Array.prototype.join ().

  • Die split () -Methode teilt ein String-Objekt in ein Array von Strings auf, indem der String in Unterstrings unterteilt wird.
  • Die reverse () -Methode kehrt ein vorhandenes Array um. Das erste Array-Element wird zum letzten und das letzte zum ersten.
  • Die join () -Methode verbindet alle Elemente eines Arrays zu einer Zeichenfolge.
function reverseString(str) { // Step 1. Use the split() method to return a new array var splitString = str.split(""); // var splitString = "hello".split(""); // ["h", "e", "l", "l", "o"] // Step 2. Use the reverse() method to reverse the new created array var reverseArray = splitString.reverse(); // var reverseArray = ["h", "e", "l", "l", "o"].reverse(); // ["o", "l", "l", "e", "h"] // Step 3. Use the join() method to join all elements of the array into a string var joinArray = reverseArray.join(""); // var joinArray = ["o", "l", "l", "e", "h"].join(""); // "olleh" //Step 4. Return the reversed string return joinArray; // "olleh" } reverseString("hello");

Verketten der drei Methoden:

function reverseString(str) { return str.split("").reverse().join(""); } reverseString("hello");

2. Kehren Sie einen String mit einer dekrementierenden For-Schleife um

function reverseString(str) { // Step 1. Create an empty string that will host the new created string var newString = ""; // Step 2. Create the FOR loop /* The starting point of the loop will be (str.length - 1) which corresponds to the last character of the string, "o" As long as i is greater than or equals 0, the loop will go on We decrement i after each iteration */ for (var i = str.length - 1; i >= 0; i--) { newString += str[i]; // or newString = newString + str[i]; } /* Here hello's length equals 5 For each iteration: i = str.length - 1 and newString = newString + str[i] First iteration: i = 5 - 1 = 4, newString = "" + "o" = "o" Second iteration: i = 4 - 1 = 3, newString = "o" + "l" = "ol" Third iteration: i = 3 - 1 = 2, newString = "ol" + "l" = "oll" Fourth iteration: i = 2 - 1 = 1, newString = "oll" + "e" = "olle" Fifth iteration: i = 1 - 1 = 0, newString = "olle" + "h" = "olleh" End of the FOR Loop*/ // Step 3. Return the reversed string return newString; // "olleh" } reverseString('hello');

Ohne Kommentare:

function reverseString(str) { var newString = ""; for (var i = str.length - 1; i >= 0; i--) { newString += str[i]; } return newString; } reverseString('hello');

3. Kehren Sie einen String mit Rekursion um

Für diese Lösung verwenden wir zwei Methoden: die Methode String.prototype.substr () und die Methode String.prototype.charAt ().

  • Die substr () -Methode gibt die Zeichen in einer Zeichenfolge zurück, die an der angegebenen Stelle durch die angegebene Anzahl von Zeichen beginnt.
"hello".substr(1); // "ello"
  • Die charAt () -Methode gibt das angegebene Zeichen aus einer Zeichenfolge zurück.
"hello".charAt(0); // "h"

Die Tiefe der Rekursion entspricht der Länge des Strings. Diese Lösung ist nicht die beste und wird sehr langsam sein, wenn der String sehr lang ist und die Stapelgröße von großer Bedeutung ist.

function reverseString(str) { if (str === "") // This is the terminal case that will end the recursion return ""; else return reverseString(str.substr(1)) + str.charAt(0); /* First Part of the recursion method You need to remember that you won’t have just one call, you’ll have several nested calls Each call: str === "?" reverseString(str.subst(1)) + str.charAt(0) 1st call – reverseString("Hello") will return reverseString("ello") + "h" 2nd call – reverseString("ello") will return reverseString("llo") + "e" 3rd call – reverseString("llo") will return reverseString("lo") + "l" 4th call – reverseString("lo") will return reverseString("o") + "l" 5th call – reverseString("o") will return reverseString("") + "o" Second part of the recursion method The method hits the if condition and the most highly nested call returns immediately 5th call will return reverseString("") + "o" = "o" 4th call will return reverseString("o") + "l" = "o" + "l" 3rd call will return reverseString("lo") + "l" = "o" + "l" + "l" 2nd call will return reverserString("llo") + "e" = "o" + "l" + "l" + "e" 1st call will return reverserString("ello") + "h" = "o" + "l" + "l" + "e" + "h" */ } reverseString("hello");

Ohne Kommentare:

function reverseString(str) { if (str === "") return ""; else return reverseString(str.substr(1)) + str.charAt(0); } reverseString("hello");

Bedingter (ternärer) Operator:

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

Das Umkehren eines Strings in JavaScript ist ein kleiner und einfacher Algorithmus, der bei einem technischen Telefon-Screening oder einem technischen Interview abgefragt werden kann. Sie können den kurzen Weg zur Lösung dieses Problems einschlagen oder den Ansatz wählen, indem Sie ihn mit Rekursion oder noch komplexeren Lösungen lösen.

Ich hoffe, Sie fanden das hilfreich. Dies ist Teil meiner Artikelserie „Wie man FCC-Algorithmen löst“ zu den Herausforderungen des Free Code Camp-Algorithmus, in der ich verschiedene Lösungen vorschlage und Schritt für Schritt erkläre, was unter der Haube passiert.

Drei Möglichkeiten, eine Zeichenfolge in JavaScript zu wiederholen

In diesem Artikel werde ich erklären, wie Sie die Herausforderung "Wiederholen eines Strings, Wiederholen eines Strings" von freeCodeCamp lösen. Das beinhaltet…

Zwei Möglichkeiten, um das Ende eines Strings in JavaScript zu bestätigen

In diesem Artikel werde ich erklären, wie Sie die Herausforderung „Confirm the Ending“ von freeCodeCamp lösen können.

Drei Möglichkeiten, eine Zahl in JavaScript zu faktorisieren

Dieser Artikel basiert auf dem Free Algorithmus Camp Basic Algorithm Scripting „Factorialize a Number“.

Zwei Möglichkeiten, in JavaScript nach Palindromen zu suchen

Dieser Artikel basiert auf dem Free Code Camp Basic Algorithm Scripting „Auf Palindrome prüfen“.

Drei Möglichkeiten, das längste Wort in einer Zeichenfolge in JavaScript zu finden

Dieser Artikel basiert auf dem Free Algorithmus Camp Basic Algorithm Scripting „Finde das längste Wort in einer Zeichenfolge“.

Drei Möglichkeiten, einen Satz in JavaScript zu betiteln

Dieser Artikel basiert auf dem Free Algorithmus Camp Basic Algorithm Scripting „Title Case a Satz“.

Wenn Sie eine eigene Lösung oder Vorschläge haben, teilen Sie diese unten in den Kommentaren mit.

Oder du kannst mir auf Medium , Twitter, Github und LinkedIn folgen , gleich nachdem du auf das grüne Herz unten geklickt hast ;-)

‪#‎StayCurious‬, ‪#‎KeepOnHacking‬ & ‪#‎MakeItHappen‬!

Resources

  • split() method — MDN
  • reverse() method — MDN
  • join() method — MDN
  • String.length — MDN
  • substr() method — MDN
  • charAt() method — MDN