Artigo original: Three Ways to Reverse a String in JavaScript
Este artigo se baseia no script de algoritmos básicos do Free Code Camp chamado “Inverter uma string”
Inverter uma string é uma das perguntas mais frequentemente feitas sobre JavaScript nas rodadas de entrevistas técnicas. Os entrevistadores podem pedire que você escreva maneiras diferentes de inverter uma string, pedir que você inverta uma string sem usar os métodos integrados ou ainda pedir que você inverta uma string usando recursão.
Há dezenas de maneiras em potencial de se fazer isso, que não incluem a função integrada reverse, já que o JavaScript não tem essa função.
Abaixo estão as três formas mais interessantes de resolver o problema de inverter uma string em JavaScript.
Desafio do algoritmo
Inverta a string fornecida.
Você pode ter que transformar a string em um array antes de poder inverter.
Seu resultado deve ser uma string.
function reverseString(str) {
return str;
}
reverseString("hello");Casos de teste fornecidos
- reverseString(“hello”) deve retornar a string “olleh”
- reverseString(“Howdy”) deve retornar a string “ydwoH”
- reverseString(“Greetings from Earth”) deve retornar a string “htraE morf sgniteerG”
1. Inverter uma string com funções integradas
Para esta solução, usaremos três métodos: o método String.prototype.split() method, o método Array.prototype.reverse() e o método Array.prototype.join().
- O método split() divide um objeto de string em um array de string separando a string em substrings.
- O método reverse() inverte um array diretamente. O primeiro elemento do array passa a ser o último e o último se torna o primeiro.
- O método join() une todos os elementos de um array em uma string.
function reverseString(str) {
// Passo 1. Use o método split() para retornar um novo array
var splitString = str.split(""); // var splitString = "hello".split("");
// ["h", "e", "l", "l", "o"]
// Passo 2. Use o método reverse() para inverter o array recém-criado
var reverseArray = splitString.reverse(); // var reverseArray = ["h", "e", "l", "l", "o"].reverse();
// ["o", "l", "l", "e", "h"]
// Passo 3. Use o método join() para unir todos os elementos do array em uma string
var joinArray = reverseArray.join(""); // var joinArray = ["o", "l", "l", "e", "h"].join("");
// "olleh"
// Passo 4. Retorne a string invertida
return joinArray; // "olleh"
}
reverseString("hello");Unindo os três métodos em uma única declaração:
function reverseString(str) {
return str.split("").reverse().join("");
}
reverseString("hello");2. Inverter uma string com um laço for por decremento
function reverseString(str) {
// Passo 1. Crie uma string vazia que vai receber a nova string criada
var newString = "";
// Step 2. Crie o laço FOR
/* O ponto inicial do laço será (str.length - 1), que corresponde ao
último caractere da string, "o"
Enquanto i for maior ou igual a 0, o laço continuará
Decrementamos i após cada iteração */
for (var i = str.length - 1; i >= 0; i--) {
newString += str[i]; // ou newString = newString + str[i];
}
/* Aqui, hello's length é igual a 5
Para cada iteração: i = str.length - 1 e newString = newString + str[i]
Primeira iteração: i = 5 - 1 = 4, newString = "" + "o" = "o"
Segunda iteração: i = 4 - 1 = 3, newString = "o" + "l" = "ol"
Terceira iteração: i = 3 - 1 = 2, newString = "ol" + "l" = "oll"
Quarta iteração: i = 2 - 1 = 1, newString = "oll" + "e" = "olle"
Quinta iteração: i = 1 - 1 = 0, newString = "olle" + "h" = "olleh"
Fim do laço FOR*/
// Passo 3. Retorne a string invertida
return newString; // "olleh"
}
reverseString('hello');Sem comentários:
function reverseString(str) {
var newString = "";
for (var i = str.length - 1; i >= 0; i--) {
newString += str[i];
}
return newString;
}
reverseString('hello');3. Inverter uma string com recursão
Para esta solução, usaremos dois métodos: o método String.prototype.substr() e o método String.prototype.charAt().
- O método substr() retorna os caracteres em uma string começando da localização especificada pelo número especificado de caracteres.
"hello".substr(1); // "ello"- O método charAt() retorna o caractere especificado de uma string.
"hello".charAt(0); // "h"A profundidade da recursão é igual ao tamanho da string. Esta solução não é a melhor e será muito lenta se a string for muito longa. O tamanho da pilha (ou stack) será um problema a considerar.
function reverseString(str) {
if (str === "") // Este é o caso terminal que encerrará a recursão
return "";
else
return reverseString(str.substr(1)) + str.charAt(0);
/*
Primeira parte do método de recursão
Lembre-se de que não fará apenas uma chamada, mas diversas chamadas aninhadas
Cada chamada: str === "?" reverseString(str.subst(1)) + str.charAt(0)
1ª chamada – reverseString("Hello") retornará reverseString("ello") + "h"
2ª chamada – reverseString("ello") retornará reverseString("llo") + "e"
3ª chamada – reverseString("llo") retornará reverseString("lo") + "l"
4ª chamada – reverseString("lo") retornará reverseString("o") + "l"
5ª chamada – reverseString("o") retornará reverseString("") + "o"
Segunda parte do método de recursão
O método chega na condição expressa pelo if e a chamada aninhada mais acima é retornada imediatamente
A 5ª chamada retornará reverseString("") + "o" = "o"
A 4ª chamada retornará reverseString("o") + "l" = "o" + "l"
A 3ª chamada retornará reverseString("lo") + "l" = "o" + "l" + "l"
A 2ª chamada retornará reverserString("llo") + "e" = "o" + "l" + "l" + "e"
A 1ª chamada retornará reverserString("ello") + "h" = "o" + "l" + "l" + "e" + "h"
*/
}
reverseString("hello");Sem comentários:
function reverseString(str) {
if (str === "")
return "";
else
return reverseString(str.substr(1)) + str.charAt(0);
}
reverseString("hello");Operador condicional (ternário):
function reverseString(str) {
return (str === '') ? '' : reverseString(str.substr(1)) + str.charAt(0);
}
reverseString("hello");Inverter uma string em JavaScript é um algoritmo pequeno e simples que pode ser solicitado em uma triagem técnica por telefone ou em uma entrevista técnica. Você pode seguir o caminho mais curto na resolução deste problema, ou ainda utilizar a abordagem de resolver a questão usando recursão ou soluções ainda mais complexas.
Espero que você tenha achado este artigo útil. Ele é parte de uma série de artigos chamada, no original em inglês, de “How to Solve FCC Algorithms” (Como resolver os algoritmos do freeCodeCamp), onde a autora propõe diversas soluções e explica o passo a passo do que acontece por debaixo dos panos (todos os textos abaixo, de momento, ainda se encontram em inglês).
Se você tiver sua própria solução ou alguma sugestão, compartilhe-as abaixo, nos comentários.
Além disso, você pode seguir a autora no Medium, no Twitter, no Github e no LinkedIn.
Recursos