Strings, o Objeto String e seus Métodos - JavaScript

Para criar strings no JavaScript, é comum atribuir diretamente uma string a uma variável ou constante, como no exemplo abaixo:

Além disso, pode-se usar o construtor String para criar uma string:

Embora ambas as formas sejam válidas, a primeira é mais breve e geralmente preferida. No primeiro caso, o JavaScript automaticamente converte a variável de tipo primitivo para um objeto String quando necessário.

Para acessar caracteres individuais de uma string, é possível usar índices, semelhante ao acesso a elementos de um array:

const message = "Hello";
console.log(message[0]);    // H 
console.log(message[4]);    // o

O objeto String possui uma série de propriedades e métodos que permitem manipular strings de diversas maneiras.

Comprimento da String

A propriedade length indica o comprimento da string:

const message = "Hello";
console.log(message.length);        //  5 caracteres

Repetição de Strings

O método repeat() cria uma string repetindo outra string várias vezes. O número de repetições é passado como argumento:

const message = "hello ";
console.log(message.repeat(3)); // hello hello hello

Pesquisa em Strings

indexOf() e lastIndexOf()

Os métodos indexOf() e lastIndexOf() são usados para procurar uma substring dentro de uma string. Eles retornam o índice da primeira e da última ocorrência da substring, respectivamente, e aceitam um índice opcional a partir do qual começar a busca. Se a substring não for encontrada, retornam -1.

const message = "Hello, world!";
console.log(message.indexOf("o"));       // 4
console.log(message.lastIndexOf("o"));   // 8
console.log(message.indexOf("o", 5));    // 8
console.log(message.lastIndexOf("o", 7)); // 4
console.log(message.indexOf("x"));       // -1

Deve-se considerar que a busca é sensível a maiúsculas e minúsculas:

const message = "Hello, world!";
console.log(message.indexOf("World")); // -1

includes()

O método includes() retorna true se a string contém uma determinada substring.

const message = "Hello, world!";
console.log(message.includes("world")); // true
console.log(message.includes("World")); // false
console.log(message.includes("world", 7)); // false

Seleção de Substring

Para extrair uma substring de uma string, os métodos substring() e slice() são utilizados.

substring()

O método substring() aceita dois parâmetros:

• startIndex: índice do caractere na string a partir do qual a substring será extraída. Este é um parâmetro obrigatório.

• endIndex: índice até o qual a string deve ser cortada. Este é um parâmetro opcional; se não for fornecido, a string será cortada até o final.

const hello = "Hello, world!";
console.log(hello.substring(0, 5)); // Hello
console.log(hello.substring(7));    // world!

slice()

O método slice() também permite extrair uma parte de uma string. Ele aceita dois parâmetros:

• startIndex: índice inicial da substring na string. Este é um parâmetro obrigatório.

• endIndex: índice final da substring na string. Este é um parâmetro opcional; se não for fornecido, a string será cortada até o final.

const hello = "Hello, world!";
console.log(hello.slice(0, 5)); // Hello
console.log(hello.slice(7));    // world!

É possível notar que este método é semelhante ao substring(), no entanto, existem pequenas diferenças. Primeiramente, em slice(), o índice inicial deve ser menor que o índice final. Em substring(), se o índice inicial for maior que o final, os índices são invertidos (ou seja, substring(5, 1) será equivalente a substring(1, 5)):

const hello = "Hello, world!";
console.log(hello.slice(5, 0)); // "" - não funciona
console.log(hello.substring(5, 0)); // Hello - do 0º ao 5º índice

Outra diferença é que slice() permite usar índices negativos. Um índice negativo indica um índice de caractere em relação ao final da string. substring(), por outro lado, não suporta índices negativos:

const hello = "Hello, world!";
console.log(hello.slice(-13, -8));    // Hello -  do 13º índice a partir do final até o 8º índice a partir do final
console.log(hello.substring(-13, -8)); // "" - não funciona

Gerenciamento de Registro de Caracteres

Para alterar o registro de caracteres, utilizam-se os métodos toLowerCase() (para converter para minúsculas) e toUpperCase() (para converter para maiúsculas).

const hello = "Olá Tom";
console.log(hello.toLowerCase()); // olá tom
console.log(hello.toUpperCase()); // OLÁ TOM

Obtendo Caracter por Índice

Para obter um determinado caractere em uma string por índice, pode-se usar a sintaxe de arrays. O JavaScript também fornece os métodos charAt() e charCodeAt(). Ambos os métodos aceitam o índice do caractere como parâmetro:

const hello = "Olá Tom";
console.log(hello.charAt(2));       // á
console.log(hello.charCodeAt(2));   // 225

O método charAt() retorna o próprio caractere, enquanto charCodeAt() retorna o código numérico desse caractere.

Removendo Espaços

Para remover espaços no início e no final de uma string, utiliza-se o método trim():

let hello = "   Olá Tom  ";
const beforeLength = hello.length;
hello = hello.trim();
const afterLength = hello.length;
console.log("Comprimento antes: ", beforeLength);     // 12
console.log("Comprimento depois: ", afterLength);   // 7

Adicionalmente, existem métodos que removem espaços de um lado específico da string:

• trimLeft() e trimStart(): removem espaços da parte esquerda da string

• trimRight() e trimEnd(): removem espaços da parte direita da string

Unindo Strings

O método concat() junta duas strings:

let hello = "Olá ";
const world = "mundo";
hello = hello.concat(world);
console.log(hello); // Olá mundo

Substituindo Substring

O método replace() substitui a primeira ocorrência de uma substring por outra:

let hello = "Bom dia";
hello = hello.replace("dia", "tarde");
console.log(hello); // Bom tarde

O primeiro parâmetro do método indica qual substring deve ser substituída, e o segundo parâmetro indica a nova substring.

Este método substitui apenas a primeira ocorrência:

let menu = "Café: pão, chá. Almoço: sopa, chá. Jantar: salada, chá.";
menu = menu.replace("chá", "café");
console.log(menu);  // Café: pão, café. Almoço: sopa, chá. Jantar: salada, chá.

O método replaceAll() permite substituir todas as ocorrências de uma substring:

let menu = "Café: pão, chá. Almoço: sopa, chá. Jantar: salada, chá.";
menu = menu.replaceAll("chá", "café");
console.log(menu);  // Café: pão, café. Almoço: sopa, café. Jantar: salada, café.

Dividindo String

O método split() divide a string em um array de substrings de acordo com um delimitador. O delimitador é uma string passada como parâmetro para o método:

const message = "Hoje o dia está lindo";
const messageParts = message.split(" ");
console.log(messageParts);  // ["Hoje", "o", "dia", "está", "lindo"]

Neste caso, a string é dividida por espaços, resultando em um array com cinco elementos.

Verificando Início e Fim da String

O método startsWith() retorna true se a string começa com uma determinada substring. O método endsWith() retorna true se a string termina com uma determinada substring.

const hello = "let me speak from my heart";
console.log(hello.startsWith("let"));       // true
console.log(hello.startsWith("Let"));       // false
console.log(hello.startsWith("lets"));      // false
  
console.log(hello.endsWith("heart"));       // true
console.log(hello.startsWith("bart"));      // false

A verificação é sensível ao caso, como visto no exemplo acima onde "let" não é equivalente a "Let".

Um segundo parâmetro opcional permite especificar um índice para comparação:

const hello = "let me speak from my heart";
console.log(hello.startsWith("me", 4));     // true - "me" está no índice 4 a partir do início
console.log(hello.startsWith("my", hello.length - 8));    // true - "my" está no índice 8 a partir do final

console.log(hello.startsWith("me", 1));    // false - "me" não está no índice 1 a partir do início

Preenchendo String

Os métodos padStart() e padEnd() expandem a string para um comprimento específico, preenchendo com caracteres à esquerda e à direita, respectivamente.

let hello = "hello".padStart(8);  // "   hello"
console.log(hello);
hello = "hello".padEnd(8);      // "hello   "
console.log(hello);

A chamada hello.padStart(8) expande a string "hello" para 8 caracteres, adicionando 3 espaços no início. Da mesma forma, hello.padEnd(8) adiciona espaços no final da string até que ela tenha 8 caracteres.

Por padrão, esses métodos utilizam espaços para preenchimento, mas pode-se passar um segundo parâmetro para especificar o caractere de preenchimento:

let hello = "hello".padStart(17, "JavaScript, ");  // "JavaScript, hello"
console.log(hello);
hello = "hello".padEnd(12, " World");      // "hello World"
console.log(hello);

Se a quantidade de caracteres a ser adicionada for maior que a string de preenchimento, a string de preenchimento será repetida:

let hello = "123".padStart(6, "0");  // "000123"
console.log(hello);
hello = "123".padEnd(6, "0");       // "123000"
console.log(hello);