Strings e seus Métodos em JavaScript
Para criar strings no JavaScript, é comum atribuir diretamente uma string a uma variável ou constante, como no exemplo abaixo:
const message = "Hello";
Além disso, pode-se usar o construtor String
para criar uma string:
const message = new String("Hello");
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
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:
substring(startIndex, endIndex);
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:
slice(startIndex, endIndex);
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()
etrimStart()
: removem espaços da parte esquerda da stringtrimRight()
etrimEnd()
: 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);