Stringhe e metodi per lavorare con esse

4.1 Introduzione alle stringhe

Le stringhe in JavaScript sono sequenze di caratteri e rappresentano uno dei principali tipi di dati. Le stringhe possono essere create utilizzando virgolette singole ('testo'), virgolette doppie ("testo"), o backticks (`testo`).

Esempi di stringhe:

    
      let singleQuote = 'Hello, World!';
      let doubleQuote = "Hello, World!";
      let backticks = `Hello, World!`;
    
  

Sul tipo stringa possiamo invocare vari metodi:

4.2 Metodi principali per lavorare con le stringhe

Esempi di utilizzo dei metodi

1. Proprietà length

Restituisce la lunghezza della stringa:

    
      let str = 'Hello';
      console.log(str.length); // 5
    
  

2. Metodo charAt(index)

Restituisce il carattere alla posizione indicata:

    
      let str = 'Hello';
      let result = str.charAt(1);
      console.log(result); // 'e'
    
  

3. Metodo toUpperCase() e toLowerCase():

Convertono la stringa in maiuscolo o minuscolo:

    
      let str = 'Hello';
      console.log(str.toUpperCase()); // 'HELLO'
      console.log(str.toLowerCase()); // 'hello'
    
  

4. Metodo indexOf(substring)

Restituisce l'indice della prima occorrenza della sottostringa o -1 se non trovata:

    
      let str = 'Hello, world!';
      let result = str.indexOf('world');
      console.log(result); // 7
    
  

5. Metodo includes(substring)

Verifica se la stringa contiene la sottostringa specificata, restituisce true o false:

    
      let str = 'Hello, world!';
      let result = str.includes('world');
      console.log(result); // true
    
  

6. Metodo trim()

Rimuove gli spazi all'inizio e alla fine della stringa:

    
      let str = '   Hello, world!   ';
      console.log(str.trim()); // 'Hello, world!'
    
  

7. Metodo replace(searchValue, newValue)

Sostituisce la sottostringa specificata con una nuova:

    
      let str = 'Hello, world!';
      console.log(str.replace('world', 'JavaScript')); // 'Hello, JavaScript!'
    
  

8. Metodo split(separator)

Divide la stringa in un array di sottostringhe utilizzando il separatore indicato:

    
      let str = 'Hello, world!';
      let words = str.split(' ');
      console.log(words); // ['Hello,', 'world!']
    
  

9. Metodo substring(start, end)

Restituisce una sottostringa tra due indici:

    
      let str = 'Hello, world!';
      console.log(str.substring(0, 5)); // 'Hello'
    
  

10. Metodo substr(start, length)

Restituisce una sottostringa a partire dall'indice specificato e con una lunghezza pari al numero di caratteri specificato:

    
      let str = 'Hello, world!';
      console.log(str.substr(0, 5)); // 'Hello'
    
  

11. Metodo slice(start, end)

Estrae una parte della stringa e restituisce una nuova stringa:

    
      let str = 'Hello, world!';
      console.log(str.slice(0, 5)); // 'Hello'
    
  

12. Metodo startsWith(substring)

Verifica se la stringa inizia con la sottostringa specificata, restituisce true o false:

    
      let str = 'Hello, world!';
      console.log(str.startsWith('Hello')); // true
    
  

13. Metodo endsWith(substring)

Verifica se la stringa termina con la sottostringa specificata, restituisce true o false:

    
      let str = 'Hello, world!';
      console.log(str.endsWith('world!')); // true
    
  

14. Metodo repeat(count)

Restituisce una nuova stringa contenente il numero specificato di copie della stringa di origine:

    
      let str = 'Hello';
      console.log(str.repeat(3)); // 'HelloHelloHello'

      let str2 = '-';
      console.log(str2.repeat(30)); // '---------------------------------------------------------------'
    
  

4.3 Stringhe di nuova generazione

Le stringhe template (template strings) sono state introdotte recentemente in JavaScript. Offrono un modo più comodo e leggibile per lavorare con il testo rispetto alle stringhe normali. Vanno racchiusi in backticks (`) e supportano l'interpolazione di espressioni e testo multiriga.

Sintassi:

    
      `stringa di nuova generazione`
    
  

Esempio:

Il template literal greeting viene creato utilizzando i backticks.

    
      const greeting = `Hello, World!`;
      console.log(greeting); // "Hello, World!"
    
  

Caratteristiche principali delle stringhe template:

• Interpolazione di espressioni: le stringhe template permettono di inserire espressioni e variabili all'interno della stringa usando ${}
• Testo multiriga: le stringhe template supportano il testo multiriga senza la necessità di usare caratteri speciali per andare a capo
• Espressioni incorporate: dentro le stringhe template si possono usare tutte le espressioni JavaScript, incluse le funzioni

Esaminiamo alcuni esempi di utilizzo delle stringhe template.

Interpolazione di espressioni

Le stringhe template permettono di inserire facilmente i valori delle variabili e i risultati delle espressioni all'interno della stringa:

    
      let name = "Alice";
      let age = 30;
      let greeting = `Hello, ${name}! You are ${age} years old.`;
      console.log(greeting); // "Hello, Alice! You are 30 years old."
    
  

In questo esempio le variabili name e age vengono inserite all'interno della stringa usando ${}.

Testo multiriga

Le stringhe template semplificano la creazione di stringhe su più righe senza la necessità di utilizzare caratteri di nuova riga (\n):

    
      let multiLine = `Lorem ipsum dolor, consectetuer adipiscing elit.
      Sit lorem mattis eget maximus.`;

      console.log(multiLine);
    
  

Espressioni incorporate

Dentro le stringhe template si possono utilizzare tutte le espressioni JavaScript, incluse le chiamate a funzioni:

    
      let a = 5;
      let b = 10;
      let result = `The sum of ${a} and ${b} is ${a + b}.`;
      console.log(result); // "The sum of 5 and 10 is 15."

      function getGreeting(name) {
        return `Hello, ${name}!`;
      }

      let greeting = `${getGreeting("Bob")}`;
      console.log(greeting); // "Hello, Bob!"
    
  

Meglio non chiamare le funzioni dentro le stringhe, ma se vuoi davvero, puoi farlo.