Metodi delle stringhe

Come abbiamo visto nella lezione precedente, le stringhe consentono di rappresentare e salvare del testo. Oltre a ciò, JavaScript offre diversi metodi, che sono una serie di funzioni predefinite per lavorare con le stringhe in vari modi. Ad esempio, trasformare il testo in caratteri maiuscoli.

Lista completa dei metodi

Vediamo la lista completa di tutti i metodi predefiniti delle stringhe.

Metodi più importanti

I metodi predefiniti elencati qui sopra sono 25. Tuttavia, solo alcuni sono veramente importanti. I metodi più utilizzati sono:

Quindi, vediamo prima i metodi più importanti.

Nota: tutti i metodi si uniscono ad una variabile stringa tramite il simbolo del punto.

Il metodo length

Il metodo length è uno dei più utilizzati e semplici. Questo metodo consente di conoscere la lunghezza di una stringa.

let stringa = "js";
alert(stringa.length);  // Risultato: 2

Il metodo toUpperCase() e toLowerCase()

I metodi toUpperCase() e toLowerCase() permettono di modificare i caratteri di una stringa. Con il primo metodo, i caratteri diventano tutti maiuscoli, con il secondo tutti minuscoli.

let parola = "liNGuagGiO";

alert(parola.toUpperCase());  // Risultato: LINGUAGGIO
alert(parola.toLowerCase());  // Risultato: linguaggio

Questo metodo può essere utile, ad esempio, quando dobbiamo correggere degli esercizi online. L'utente potrebbe inserire la maiuscola all'inizio della parola, ad esempio. Quindi, possiamo utilizzare toLowerCase() per trasformare tutto in minuscolo e controllare se la stringa è uguale a quella corretta.

let parola_inserita = "JavaScript";  // Potrebbe anche essere Javascript o javascript
let correzione = "javascript";

parola_inserita = parola_inserita.toLowerCase();  // Tutto in minuscolo

if(parola_inserita==correzione)
// Proseguimento del codice...

Le condizioni (if) le vedremo nelle prossime lezioni.

I metodi replace() e replaceAll()

I metodi metodo replace() e replaceAll() permettono di sostituire una parte di stringa con un'altra. Con replace() solo la prima corrispondenza, con replaceAll() tutte le corrispondenze.

Hanno la sintassi:
replace(stringa_da_sostituire,stringa_nuova) e replaceAll(stringa_da_sostituire,stringa_nuova).

let stringa = "Sto studiano programmazione";
let sostituisci = "programmazione";
let nuova_parola = "JavaScript";

let nuova_stringa = stringa.replace(sostituisci, nuova_parola);
// Risultato: "Sto studiando JavaScript"

Puoi anche inserire le stringhe direttamente in replace() senza utilizzare variabili.

let stringa = "Sto studiano programmazione";

let nuova_stringa = stringa.replace("programmazione", "JavaScript");
// Risultato: "Sto studiando JavaScript"

Ecco invece un esempio con replaceAll():

let stringa = "a e i a i o i a o";

let nuova_stringa = stringa.replaceAll("a", "c");
alert(nuova_stringa);  // Risultato: "c e i c i o i c o"

Il metodo includes()

Il metodo includes() controlla se una stringa è presente in un'altra stringa. 

La sintassi è includes(stringa_da_cercare,posizione). La posizione indica da quale lettera partire la ricerca della stringa e non è obbligatoria. Se non viene indicata, includes() cercherà all'interno di tutta la stringa.

let stringa = "Io utilizzo JavaScript e HTML";

let ricerca = stringa.includes("HTML");
alert(ricerca);  // Risultato: true

Il metodo slice()

Il metodo slice() permette di generare una parte di stringa da una stringa. Ad esempio, vogliamo rimuovere dalla stringa "Il PC non supporta Windows" la parte "Il PC" e mantenere "non supporta Windows".

La sintassi di questo metodo è slice(indice_di_inzio,indice_di_fine). L'indice di inizio (compreso) e l'indice di fine (escluso) sono la posizione dei caratteri in cui mantenere la stringa. L'indice di fine non è obbligatorio; in caso di assenza, verrà mantenuta tutta la stringa fino alla fine.

let stringa = "Il PC non supporta Windows";

let nuova_stringa = stringa.slice(6);
alert(nuova_stringa);  // Risultato: "non supporta Windows"

I metodi startsWith() e endsWith()

I metodi startsWith() e endsWith() controllano se una stringa inizia o finisce con un'altra stringa specificata.

La sintassi è: startsWith(stringa_inizio) e endsWith(stringa_fine).

let stringa = "JavaScript è un linguaggio";

let inizio = stringa.startsWith("JavaScript");
alert(inizio);  // Risultato: true

let fine = stringa.endsWith("linguaggio");
alert(fine);  // Risultato: true

Altri metodi

Ora che abbiamo visto i metodi più importanti, passiamo agli altri.

Il metodo charAt()

Questo metodo permette di sapere a quale carattere corrisponde una posizione.

Sintassi: charAt(posizione). La posizione inizia da 0 (che è il primo carattere).

let stringa = "JavaScript";

let lettera = stringa.charAt(2);
alert(lettera);  // Risultato: "v"

Il metodo charCodeAt()

Il metodo charCodeAt() permette di sapere il codice UTF-16 del carattere della posizione specificata in una stringa.

La sintassi di questo metodo è charCodeAt(posizione). La posizione inizia da 0 (che è il primo carattere).

let stringa = "JavaScript";

let lettera = stringa.charCodeAt(0);
alert(lettera);  // Risultato: 74

Il metodo concat()

Questo metodo permette di unire due o più stringhe stringhe insieme.

La sua sintassi è: stringa.concat(stringa1,stringa2,stringa3, ...). La prima stringa è la stringa da cui parte la concatenazione.

let parola1 = "JavaScript";
let parola2 = " è un ";
let parola3 = "linguaggio";

let frase = parola1.concat(parola2, parola3);
alert(frase);  // Risultato: JavaScript è un linguaggio

Il metodo indexOf()

Il metodo indexOf() restituisce la prima posizione di una stringa all'interno di un'altra stringa.

Sintassi di questo metodo: indexOf(stringa_da_cercare,posizione_di_inizio). La posizione_di_inizio inizia da 0 (che è il primo carattere) e non è obbligatoria.

let stringa = "Compra un PC";

let posizione = stringa.indexOf("PC");
alert(posizione);  // Risultato: 10

Il metodo lastIndexOf()

Il metodo lastIndexOf() restituisce l'ultima posizione di una stringa all'interno di un'altra stringa.

Sintassi di questo metodo: lastIndexOf(stringa_da_cercare,posizione_di_inizio). La posizione_di_inizio inizia da 0 (che è il primo carattere) e non è obbligatoria.

let stringa = "Compra un PC";

let posizione = stringa.lastIndexOf("C");
alert(posizione);  // Risultato: 11

Il metodo localeCompare()

Questo metodo compara due stringhe per controllare se una stringa si trova prima, dopo o nella stessa posizione della seconda stringa rispetto all'ordine alfabetico. Ad esempio, tra "A" e "B".

Sintassi: stringa1.localeCompare(stringa2). Questo metodo restituisce:

let A = "A";
let B = "B";

let posizione = A.localeCompare(B);
alert(posizione); // Risultato: -1

I metodi match() e matchAll()

Questi due metodi restituiscono il risultato delle corrispondenze in una stringa di un'espressione regolare.

Il metodo match() restituisce il risultato di una sola corrispondenza, mentre matchAll() una lista di tutte le corrispondenze.

Sintassi: stringa.match(espressione_regolare) e stringa.matchAll(espressione_regolare).

let stringa = "L'informatica è utile";

let risultato = stringa.match(/u/); // Trova la "u"
alert(risultato);  // Risultato: "u" --> è trovata

let risultati = stringa.matchAll(/a/g); // Trova la "a"
for (const match of matches) { // Visualizza uno ad uno le corrispondenze
  alert(match[0]);
}

I metodi padStart() e padEnd()

I metodi padStart() e padEnd() consentono di aggiungere all'inizio o alla fine una stringa per uno specifico numero di volte.

La sintassi di questi metodi è padStart(lunghezza,stringa) e padEnd(lunghezza,stringa). La lunghezza rappresenta il numero di caratteri finale che deve raggiungere la stringa.

let stringa = "PC"
let inizio = stringa.padStart(5,"0");
alert(inizio);  // Risultato: 000PC

let fine = stringa.padEnd(5,"0");
alert(fine);  // Risultato: PC000

Il metodo repeat()

Questo metodo serve per ripetere una stringa per il numero di volte specificato.

La sintassi è semplice: stringa.repeat(numero_volte).

let stringa = "JS"
let nuova_stringa = stringa.repeat(5);
alert(nuova_stringa);  // Risultato: JSJSJSJSJS

Il metodo search()

Il metodo search() restituisce la posizione della prima corrispondenza tra una stringa e un'espressione regolare.

Sintassi: stringa.search(espressione_regolare);

let stringa = "Il JS è l'abbreviazione di JavaScript";
let risultato = stringa.search(/JavaScript/); // Cerca "JavaScript"

alert(risultato);  // Risultato: 27

Il metodo split()

Questo metodo puoi utilizzarlo per dividere una stringa in tante sottostringhe in corrispondenza di una specifica stringa.

La sintassi è: stringa.split(corrispondenza).

let stringa = "a-b-c-d-e";
let risultato = stringa.split("-");

console.log(risultato);  // Risultato nella console: ["a", "b", "c", "d", "e"]

Il metodo substring()

Questo metodo restituisce una parte di una stringa in base agli indici di inizio e fine specificati.

La sintassi è substring(inizio,fine). L'inizio inizia da 0 (che è il primo carattere) e il carattere in fine è escluso. Il fine non è obbligatorio.

let stringa = "JavaScript";
let risultato = stringa.substring(0,4);

alert(risultato);  // Risultato: Java

Il metodo trim()

Questo metodo permette di rimuove gli spazi vuoti all'inizio e alla fine di una stringa.

Sintassi: stringa.trim().

let stringa = "   JavaScript   ";
let risultato = stringa.trim();

alert(risultato);  // Risultato: "JavaScript"