String-Umkehr_JavaScript_Javascript-Tipps

Heute habe ich Fragen auf freeCodeCamp beantwortet und bin auf eine Frage zur String-Umkehr gestoßen. Das Umkehren einer Zeichenfolge ist eine der häufigsten Interviewfragen in JavaScript. Vielleicht gibt Ihnen der Interviewer die Zeichenfolge „Hallo Word!“ und bittet Sie, diese mithilfe von JavaScript in „!droW olleH“ umzuwandeln.

Ich bin auch ein Anfänger und habe den Test mit den zuvor erlernten Array-Kenntnissen bestanden. Später dachte ich: Gibt es andere Möglichkeiten, diese Frage zu lösen? Nach der Suche gibt es noch viele Methoden für die zukünftige Verwendung.

Aktivitäten

Was wir tun müssen:

Um die bereitgestellte Zeichenfolge vor der umgekehrten Zeichenfolge anzuzeigen, müssen Sie die Zeichenfolge in ein Array konvertieren. Das Endergebnis ist immer noch eine Zeichenfolge

Als nächstes werfen wir einen Blick auf einige Methoden, um die oben genannten Anforderungen zu erfüllen.

Eingebaute Funktionen verwenden

In der Übungsfrage werden wir daran erinnert, dass wir drei Methoden verwenden können, um eine Zeichenfolge erfolgreich in umgekehrter Reihenfolge anzuzeigen:

String.prototype.split()Array.prototype.reverse()Array.prototype.join()

Lass es uns kurz durchgehen:

Die Methode „split()“ teilt jedes Zeichen eines Zeichenfolgenobjekts auf und behandelt jede Zeichenfolge als jedes Element des Arrays. Die Methode „reverse()“ wird verwendet, um das Array zu ändern und die Elemente im Array in umgekehrter Reihenfolge anzuordnen Array-Element wird zum letzten und das letzte wird zum ersten. Die Methode join() verbindet alle Elemente im Array zu einer Zeichenfolge

Sehen wir uns ein Beispiel an:

function reverseString(str)
 { // 第一步，使用split()方法，返回一个新数组 
// var splitString = "hello".split(""); 
var splitString = str.split(""); 
//将字符串拆分 // 返回一个新数组["h", "e", "l", "l", "o"] 
// 第二步，使用reverse()方法创建一个新数组 
// var reverseArray = ["h", "e", "l", "l", "o"].reverse(); 
var reverseArray = splitString.reverse(); 
// 原数组元素顺序反转["o", "l", "l", "e", "h"] 
// 第三步，使用join()方法将数组的每个元素连接在一起，组合成一个新字符串 
// var joinArray = ["o", "l", "l", "e", "h"].join(""); 
var joinArray = reverseArray.join(""); // "olleh" 
// 第四步，返回一个反转的新字符串 return joinArray; 
// "olleh"}reverseString("hello"); 
// => olleh

Vereinfachen Sie die obige Methode und schreiben Sie sie wie folgt:

function reverseString(str) {
 return str.split("").reverse().join("");
}reverseString("hello"); 
// => olleh

Kehren Sie die Zeichenfolge mit einem absteigenden Schleifendurchlauf um

Diese Methode verwendet eine for-Schleife, um einen absteigenden Durchlauf der ursprünglichen Zeichenfolge durchzuführen, und kombiniert dann die durchlaufenen Zeichenfolgen erneut zu einer neuen Zeichenfolge:

function reverseString(str) { 
// 第一步：创建一个空的字符串用来存储新创建的字符串 var newString = ""; 
// 第二步：使用for循环 
// 循环从str.length-1开始做递减遍历,直到 i 大于或等于0，循环将继续
 // str.length - 1对应的就是字符串最后一个字符o for (var i = str.length - 1; i >= 0; i--) {
 newString += str[i]; // 或者 newString = newString + str[i]; } 
// 第三步：返回反转的字符串 return newString; }reverseString('hello'); 
// => // "olleh"

Einfacher Blick auf den Prozess der String-Traversierung. Angenommen, Sie müssen die Zeichenfolge „Hallo“ umkehren. Der gesamte Durchlaufvorgang ist in der folgenden Tabelle dargestellt:

Iterationsreihenfolge Der Wert, der i entspricht Neuer String newString Jede Iteration str.length - 1 newString + str[i] Erste Iteration 5 - 1 = 4 "" + "o" = "o" Zweite Iteration 4 - 1 = 3 "o" + "l" = "ol " Dritte Iteration 3 - 1 = 2 "ol" + "l" = "oll" Vierte Iteration 2 - 1 = 1 "oll" + "e" = "olle" Fünfte Iteration Iteration 1 - 1 = 0 "olle" + " h“ = „olleh“

Tatsächlich kann die obige for-Schleife auch durch eine while-Schleife ersetzt werden:

function reverseString (str) {
 var newString = '';
 var i = str.length; while (i > 0) {
 newString += str.substring(i - 1, i);
 i--; 
} 
return newString;}reverseString("hello"); 
// => olleh

while-Methode in der substring()-Schleife. substring() Gibt den Teilstring zwischen zwei Indizes des Strings (oder bis zum Ende des Strings) zurück.

String mit Rekursion umkehren

Eine Zeichenfolge kann auch mit den Methoden String.prototype.substr() und String.prototype.charAt() umgekehrt werden.

Die Methode

substr() gibt den Teilstring beginnend von der angegebenen Position bis zur angegebenen Länge im String zurück. Zum Beispiel:

var str = "abcdefghij";
console.log("(1,2): " + str.substr(1,2));
 // (1,2): bcconsole.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):

Die Methode

charAt() gibt das Zeichen an der angegebenen Position in der Zeichenfolge zurück. Zeichen in einer Zeichenfolge werden von links nach rechts indiziert, wobei das erste Zeichen den Indexwert 0 und das letzte Zeichen (vorausgesetzt, es befindet sich in der Zeichenfolge stringName) den Indexwert stringName.length - 1 hat. Wenn der angegebene index-Wert außerhalb dieses Bereichs liegt, wird eine leere Zeichenfolge zurückgegeben.

var anyString = "Brave new world";
console.log("The character at index 0 is '" + anyString.charAt(0) + "'"); 
// =>The character at index 0 is 'B'console.log("The character at index 1 is '" + anyString.charAt(1) + "'"); 
// =>The character at index 1 is 'r'console.log("The character at index 2 is '" + anyString.charAt(2) + "'"); 
// =>The character at index 2 is 'a'console.log("The character at index 3 is '" + anyString.charAt(3) + "'"); 
// => The character at index 3 is 'v'console.log("The character at index 4 is '" + anyString.charAt(4) + "'"); 
// => The character at index 4 is 'e'console.log("The character at index 999 is '" + anyString.charAt(999) + "'"); 
// => The character at index 999 is ''

Kombiniert können wir die Zeichenfolgenumkehr wie folgt durchführen:

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

Der erste Teil der rekursiven Methode. Sie müssen bedenken, dass Sie es nicht nur einmal aufrufen, sondern mehrere verschachtelte Aufrufe haben.

Jeder Aufruf von str === "?" reverseString(str.subst(1)) + str.charAt(0) Beim ersten Aufruf von reverseString("Hello") reverseString("ello") + "h" Beim zweiten Aufruf von reverseString("ello") reverseString("llo") + "e" Das drittes Mal Aufruf von reverseString("llo") reverseString("lo") + "l" Der vierte Aufruf von reverseString("lo") reverseString("o") + "l" Der fünfte Aufruf von reverseString("o") reverseString(" ") + "o"

Die rekursive Methode im zweiten Teil.

jeden Anruf Geben Sie den fünften Aufruf reverseString("") + "o" = "o" zurück, den vierten Aufruf reverseString("o") + "l" = "o" + "l" den dritten Aufruf reverseString("lo") + "l". " = "o" + "l" + "l" Der zweite Aufruf von reverserString("llo") + "e" = "o" + "l" + "l" + "e" Der erste Aufruf von reverserString("ello ") + "h" = "o" + "l" + "l" + "e" + "h"

Die obige Methode kann weiter verbessert und in den ternären Operator geändert werden

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

Sie können es auch auf diese Methode ändern

function reverseString(str) { 
return str && reverseString(str.substr(1)) + str[0];
}reverseString("hello");
 // => olleh

Andere Methoden

Zusätzlich zu den oben genannten Methoden gibt es tatsächlich noch einige andere Methoden:

Methode 1

Code kopieren Der Code lautet 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

Méthode 2

Copier le codeLe code est le suivant :

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

Troisième méthode

Copier le codeLe code est le suivant :

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

Méthode quatre

Copier le code Le code est le suivant :

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

Méthode 5

Copier le codeLe code est le suivant :

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

Méthode 6

Copiez le codeLe code est le suivant :

function reverseString(str) { return [].reduceRight.call(str, function(prev, curr) { return prev + curr; }, '');}reverseString("hello"); // =>olleh

Méthode ES6

Dans ES6, cela peut devenir plus simple, comme :

[...str].reverse().join('');

ou [...str].reduceRight( (prev, curr) => prev + curr );

ou :

const reverse = str => str && reverse(str.substr(1)) + str[0];

L'inversion de chaîne est un algorithme petit et simple. Comme mentionné précédemment, il est souvent utilisé dans les entretiens avec les bases de JavaScript. Vous pouvez utiliser différentes méthodes ci-dessus pour résoudre ce problème, ou même utiliser des solutions plus complexes. Si vous avez une meilleure méthode, ajoutez-la dans les commentaires ci-dessous et partagez-la avec nous.