Strings e métodos para trabalhar com elas

4.1 Introdução às strings

Strings no JavaScript são sequências de caracteres e são um dos principais tipos de dados. Você pode criar strings usando aspas simples ('texto'), aspas duplas ("texto"), ou crases (`texto`).

Exemplos de strings:

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

Nos objetos string, você pode chamar métodos como:

4.2 Principais métodos para trabalhar com strings

Exemplos de uso dos métodos

1. Propriedade length

Retorna o comprimento da string:

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

2. Método charAt(index)

Retorna o caractere no índice especificado:

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

3. Método toUpperCase() e toLowerCase():

Converte a string para letras maiúsculas ou minúsculas:

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

4. Método indexOf(substring)

Retorna o índice da primeira ocorrência da substring ou -1 se a substring não for encontrada:

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

5. Método includes(substring)

Verifica se a string contém a substring especificada, retorna true ou false:

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

6. Método trim()

Remove espaços do início e do fim da string:

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

7. Método replace(searchValue, newValue)

Substitui a substring especificada por uma nova substring:

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

8. Método split(separator)

Divide a string em um array de substrings usando o separador especificado:

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

9. Método substring(start, end)

Retorna a substring entre dois índices:

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

10. Método substr(start, length)

Retorna a substring começando no índice especificado e com o comprimento especificado:

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

11. Método slice(start, end)

Extrai parte da string e retorna uma nova string:

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

12. Método startsWith(substring)

Verifica se a string começa com a substring especificada, retorna true ou false:

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

13. Método endsWith(substring)

Verifica se a string termina com a substring especificada, retorna true ou false:

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

14. Método repeat(count)

Retorna uma nova string contendo o número especificado de cópias da string original:

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

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

4.3 String de nova geração

Strings template (template strings) foram adicionadas no JavaScript recentemente. Elas oferecem uma forma mais conveniente e legível de trabalhar com texto em comparação com strings comuns. São rodeadas por crases (`) e suportam interpolação de expressões e texto multilinha.

Sintaxe:

    
      `string de nova geração`
    
  

Exemplo:

Um literal template greeting é criado usando crases.

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

Principais características das strings template:

• Interpolação de expressões: strings template permitem inserir expressões e variáveis dentro da string usando ${}
• Texto multilinha: strings template suportam texto multilinha sem a necessidade de usar caracteres especiais para quebra de linha
• Expressões embutidas: dentro das strings template, é possível usar quaisquer expressões JavaScript, incluindo funções

Vamos ver alguns exemplos de uso das strings template.

Interpolação de expressões

Strings template permitem inserir facilmente valores de variáveis e resultados de expressões dentro da string:

    
      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."
    
  

Neste exemplo, as variáveis name e age são inseridas na string usando ${}.

Texto multilinha

Strings template tornam fácil criar strings multilinha sem a necessidade de usar caracteres de quebra de linha (\n):

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

      console.log(multiLine);
    
  

Expressões embutidas

Dentro das strings template é possível usar quaisquer expressões JavaScript, incluindo chamadas de funções:

    
      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!"
    
  

É melhor não usar chamadas de funções dentro de strings, mas se você realmente quiser, pode.