Astuces pour l'inversion des chaînes_JavaScript_javascript

Aujourd'hui, je répondais à des questions sur freeCodeCamp et je suis tombé sur une question sur l'inversion de chaîne. L'inversion d'une chaîne est l'une des questions d'entretien courantes en JavaScript. Peut-être que l'intervieweur vous donnera une chaîne "Bonjour Word!" et vous demandera d'utiliser JavaScript pour la transformer en "!droW olleH".

Je suis également un débutant. Grâce aux connaissances liées aux tableaux que j'ai apprises plus tôt et aux conseils sur la question, j'ai réussi le test plus tard, j'ai pensé : existe-t-il d'autres moyens de résoudre cette question ? Après recherche, il existe encore de nombreuses méthodes. Voici ces méthodes pour une utilisation future.

Choses à faire

Ce que nous devons faire :

Pour afficher la chaîne fournie à l'envers avant la chaîne inversée, vous devez convertir la chaîne en tableau. Le résultat final est toujours une chaîne

.

Ensuite, examinons quelques méthodes pour répondre aux exigences ci-dessus.

Utiliser les fonctions intégrées

Dans la question de l'exercice, on rappelle que l'on peut utiliser trois méthodes pour réussir à afficher une chaîne à l'envers :

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

Parcourons-le brièvement :

La méthode split() divise chaque caractère d'un objet chaîne et traite chaque chaîne comme chaque élément du tableau. La méthode reverse() est utilisée pour changer le tableau et organiser les éléments du tableau dans l'ordre inverse. L'élément du tableau devient le dernier et le dernier devient le premier. La méthode join() connecte tous les éléments du tableau en une chaîne

.

Regardons un exemple :

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

Simplifiez la méthode ci-dessus et écrivez-la comme ceci :

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

Inversez la chaîne en utilisant un parcours de boucle descendant

Cette méthode utilise une boucle for pour effectuer un parcours descendant de la chaîne d'origine, puis recombine les chaînes parcourues en une nouvelle chaîne :

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"

Regard simple sur le processus de traversée de chaînes. Supposons que vous deviez inverser la chaîne « hello ». L'ensemble du processus de parcours est présenté dans le tableau suivant :

Ordre d'itération La valeur correspondant à i Nouvelle chaîne newString Chaque itération str.length - 1 newString + str[i] Première itération 5 - 1 = 4 "" + "o" = "o" Deuxième itération 4 - 1 = 3 "o" + "l" = "ol " Troisième itération 3 - 1 = 2 "ol" + "l" = "oll" Quatrième itération 2 - 1 = 1 "oll" + "e" = "olle" Cinquième itération Itération 1 - 1 = 0 "olle" + " h" = "olleh"

En fait, la boucle for ci-dessus peut également être remplacée par une boucle while :

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

Méthode

while en boucle substring(). substring() Renvoie la sous-chaîne entre deux indices de la chaîne (ou jusqu'à la fin de la chaîne).

Chaîne inversée utilisant la récursion

Une chaîne peut également être inversée en utilisant les méthodes String.prototype.substr() et String.prototype.charAt().

La méthode

substr() renvoie la sous-chaîne à partir de la position spécifiée jusqu'à la longueur spécifiée dans la chaîne. Par exemple :

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):

La méthode

charAt() renvoie le caractère à la position spécifiée dans la chaîne. Les caractères d'une chaîne sont indexés de gauche à droite, le premier caractère ayant une valeur d'index 0 et le dernier caractère (en supposant qu'il se trouve dans la chaîne stringName) ayant une valeur d'index stringName.length - 1. Si la valeur index spécifiée est en dehors de cette plage, une chaîne vide est renvoyée.

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 ''

Combinés, nous pouvons faire une inversion de chaîne comme ceci :

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

La première partie de la méthode récursive. Vous devez vous rappeler que vous ne l'appellerez pas une seule fois, vous aurez plusieurs appels imbriqués.

Chaque appel à str === "?" chaîneinverse(str.subst(1)) + str.charAt(0) La première fois que vous appelez reverseString("Hello") reverseString("ello") + "h" La deuxième fois que vous appelez reverseString("ello") reverseString("llo") + "e" Le troisième appel reverseString("llo") reverseString("lo") + "l" Le quatrième appel reverseString("lo") reverseString("o") + "l" Le cinquième appel reverseString("o") reverseString(" ") + "o"

La méthode récursive dans la deuxième partie.

chaque appel Renvoie le cinquième appel reverseString("") + "o" = "o" le quatrième appel reverseString("o") + "l" = "o" + "l" le troisième appel reverseString("lo") + "l " = "o" + "l" + "l" Le deuxième appel à reverserString("llo") + "e" = "o" + "l" + "l" + "e" Le premier appel reverserString("ello ") + "h" = "o" + "l" + "l" + "e" + "h"

La méthode ci-dessus peut être encore améliorée et remplacée par l'opérateur ternaire

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

Vous pouvez également le changer pour cette méthode

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

Autres méthodes

En plus des méthodes ci-dessus, il existe en fait d'autres méthodes :

Méthode 1

Copier le code Le code est le suivant :

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.