Questo articolo è basato sulla sfida "Invertire una stringa" della sezione di Scrittura di algoritmi di base.

Invertire una stringa è una delle domande di JavaScript più chieste nei colloqui tecnici di lavoro. Gli intervistatori potrebbero chiederti di scrivere modi diversi di invertire una stringa, o potrebbero chiederti di invertire una stringa senza usare metodi predefiniti, o potrebbero chiederti di invertire una stringa usando la ricorsività.

Ci sono potenzialmente decine di metodi diversi per farlo, escludendo la funzione predefinita reverse, che JavaScript non ha.

Qui sotto ci sono i tre metodi più interessanti per risolvere il problema di invertire una stringa in JavaScript.

La sfida

Inverti la stringa fornita.
Potrebbe essere necessario trasformare la stringa in un array prima di poterla invertire.
Il tuo risultato deve essere una stringa.
function reverseString(str) {
    return str;
}
reverseString("hello");

I test

  • reverseString(“hello”) dovrebbe restituire “olleh”
  • reverseString(“Howdy”) dovrebbe restituire “ydwoH”
  • reverseString(“Greetings from Earth”) dovrebbe restituire “htraE morf sgniteerG”

1. Invertire una stringa con funzioni predefinite

Per questa soluzione useremo tre metodi: il metodo String.prototype.split(), il metodo Array.prototype.reverse() e il metodo Array.prototype.join().

  • Il metodo split() divide un oggetto String in un array di stringhe, separando la stringa in sottostringhe.
  • Il metodo reverse() inverte un array sul posto. Il primo elemento dell'array diventa l'ultimo e l'ultimo diventa il primo.
  • Il metodo join() unisce tutti gli elementi di un array in una stringa.
function reverseString(str) {
    // Step 1. Usa il metodo split() per restituire un nuovo array
    var splitString = str.split(""); // var splitString = "hello".split("");
    // ["h", "e", "l", "l", "o"]
 
    // Step 2. Usa il metodo reverse() per invertire l'array appena creato
    var reverseArray = splitString.reverse(); // var reverseArray = ["h", "e", "l", "l", "o"].reverse();
    // ["o", "l", "l", "e", "h"]
 
    // Step 3. Usa il metodo join() per unire tutti gli elementi della stringa in un array
    var joinArray = reverseArray.join(""); // var joinArray = ["o", "l", "l", "e", "h"].join("");
    // "olleh"
    
    //Step 4. Restituisci la stringa invertita
    return joinArray; // "olleh"
}
 
reverseString("hello");

Concatenando i tre metodi:

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

2. Invertire una stringa con un ciclo decrescente

function reverseString(str) {
    // Step 1. Crea una stringa vuota che ospiterà la stringa che stiamo creando
    var newString = "";
 
    // Step 2. Crea il ciclo FOR
    /* Il ciclo inizierà a (str.length - 1) che corrisponde 
       all'ultimo carattare della stringa, "o"
       Finché i è maggiore o uguale a 0, il ciclo continua
       Decrementiamo i dopo ogni iterazione */
    for (var i = str.length - 1; i >= 0; i--) { 
        newString += str[i]; // oppure newString = newString + str[i];
    }
    /* Qui la lunghezza di hello è uguale a 5
        Per ogni iterazione: i = str.length - 1 e newString = newString + str[i]
        Prima iterazione:     i = 5 - 1 = 4,         newString = "" + "o" = "o"
        Seconda iterazione:   i = 4 - 1 = 3,         newString = "o" + "l" = "ol"
        Terza iterazione:     i = 3 - 1 = 2,         newString = "ol" + "l" = "oll"
        Quarta iterazion:     i = 2 - 1 = 1,         newString = "oll" + "e" = "olle"
        Quinta iterazione:    i = 1 - 1 = 0,         newString = "olle" + "h" = "olleh"
    Fine del ciclo FOR */
 
    // Step 3. Restituisci la stringa invertita
    return newString; // "olleh"
}
 
reverseString('hello');

Senza commenti:

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

3. Invertire una stringa con la recursività

Per questa soluzione useremo due metodi: il metodo String.prototype.substr() e il metodo String.prototype.charAt().

  • Il metodo substr() restituisce i caratteri in una stringa iniziando alla posizione indicata e per il numero specificato di caratteri.
"hello".substr(1); // "ello"
  • Il metodo charAt() restituisce il carattere indicato da una stringa.
"hello".charAt(0); // "h"

La profondità della recursività è uguale alla lunghezza della stringa. Questa soluzione non è la migliore e diventa davvero lenta se la stringa è molto lunga e la dimenzione dello stack è una grande preoccupazione.

function reverseString(str) {
  if (str === "") // Questo è il caso terminale che farà finire la ricorsione
    return "";
  
  else
    return reverseString(str.substr(1)) + str.charAt(0);
/* 
Prima parte del metodo ricorsivo
Devi ricordare che non avrai solo una invocazione, ma avrai diverse invocazioni annidate

Ogni invocazione: str === "?"  	               reverseString(str.subst(1))     + str.charAt(0)
1a – reverseString("Hello")      will return   reverseString("ello")           + "h"
2a – reverseString("ello")       will return   reverseString("llo")            + "e"
3a – reverseString("llo")        will return   reverseString("lo")             + "l"
4a – reverseString("lo")         will return   reverseString("o")              + "l"
5a – reverseString("o")          will return   reverseString("")               + "o"

Seconda parte del metodo ricorsivo
Il metodo esegue la condizione if e l'invocazione più annidata restituisce immediatamente

5a invocazione restituisce reverseString("") + "o" = "o"
4a invocazione restituisce reverseString("o") + "l" = "o" + "l"
3a invocazione restituisce reverseString("lo") + "l" = "o" + "l" + "l"
2a invocazione restituisce reverserString("llo") + "e" = "o" + "l" + "l" + "e"
1a invocazione restituisce reverserString("ello") + "h" = "o" + "l" + "l" + "e" + "h" 
*/
}
reverseString("hello");

Senza commenti:

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

Operatore condizionale (ternario):

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

Invertire una stringa in JavaScript è un piccolo e semplice algoritmo che può essere usato nella valutazione tecnica dei colloqui di lavoro. Puoi orebdere ka strada breve per risolvere questo problema, o usare l'approccio della ricorsività o soluzioni ancora più complesse.

Spero hai trovato questo articolo utile. Questo articolo è parte della mia serie di articoli "Come risolvere gli algoritmi di FCC" sulle sfide di algoritmi di freeCodeCamp, dove propongo varie soluzioni e spiego passo passo cosa succede che non vediamo.

Puoi seguirmi Medium, Twitter, Github and LinkedIn.

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


Articolo originale Three Ways to Reverse a String in JavaScript
Scritto da Sonya Moisset
Tradotto e adattato da Ilenia Magoni