JavaScript, por ser uma linguagem versátil, oferece uma infinidade de funções para trabalhar com strings. Strings são um dos tipos de dados mais fundamentais em qualquer linguagem de programação, e entender como manipulá-las com eficiência pode aprimorar significativamente suas habilidades de codificação. Neste artigo, nos aprofundaremos nas funções de string JavaScript, fornecendo explicações detalhadas, exemplos e comentários para ajudá-lo a dominá-las.

Introdução às Strings em JavaScript

Em JavaScript, uma string é uma sequência de caracteres usada para representar texto. Strings são imutáveis, ou seja, uma vez criadas, não podem ser alteradas. Em vez disso, as operações de string criam novas strings.

let greeting = "Hello, World!";
console.log(greeting); // Output: Hello, World!

Criando Strings

Strings podem ser criadas usando aspas simples, aspas duplas ou crases para literais de modelo.

let singleQuoteStr = 'Hello';
let doubleQuoteStr = "Hello";
let templateLiteralStr = `Hello, ${singleQuoteStr}`;
console.log(templateLiteralStr); // Output: Hello, Hello

Propriedades de string

• comprimento: Retorna o comprimento da string.

let str = "JavaScript";
console.log(str.length); // Output: 10

Métodos de string

1. charAt()

Retorna o caractere em um índice especificado.

let str = "JavaScript";
console.log(str.charAt(0)); // Output: J

2.charCodeAt()

Retorna o Unicode do caractere em um índice especificado.

let str = "JavaScript";
console.log(str.charCodeAt(0)); // Output: 74

3.concat()

Concatena duas ou mais strings e retorna uma nova string.

let str1 = "Hello, ";
let str2 = "World!";
let result = str1.concat(str2);
console.log(result); // Output: Hello, World!

4. inclui()

Verifica se uma string contém um valor especificado, retornando verdadeiro ou falso.

let str = "JavaScript is awesome!";
console.log(str.includes("awesome")); // Output: true

5. terminaCom()

Verifica se uma string termina com um valor especificado, retornando verdadeiro ou falso.

let str = "Hello, World!";
console.log(str.endsWith("World!")); // Output: true

6. indexOf()

Retorna o índice da primeira ocorrência de um valor especificado ou -1 se não for encontrado.

let str = "JavaScript is awesome!";
console.log(str.indexOf("is")); // Output: 11

7. lastIndexOf()

Retorna o índice da última ocorrência de um valor especificado ou -1 se não for encontrado.

let str = "JavaScript is awesome! JavaScript is fun!";
console.log(str.lastIndexOf("JavaScript")); // Output: 22

8. correspondência()

Recupera as correspondências ao comparar uma string com uma expressão regular.

let str = "JavaScript is awesome!";
let regex = /is/g;
console.log(str.match(regex)); // Output: [ 'is', 'is' ]

9. repetir()

Retorna uma nova string com um número especificado de cópias da string em que foi chamada.

let str = "Hello!";
console.log(str.repeat(3)); // Output: Hello!Hello!Hello!

10. substituir()

Substitui um valor especificado por outro valor em uma string.

let str = "JavaScript is awesome!";
let newStr = str.replace("awesome", "fantastic");
console.log(newStr); // Output: JavaScript is fantastic!

11. pesquisa()

Pesquisa um valor especificado em uma string e retorna a posição da correspondência.

let str = "JavaScript is awesome!";
console.log(str.search("awesome")); // Output: 15

12. fatia()

Extrai uma parte de uma string e a retorna como uma nova string.

let str = "JavaScript";
console.log(str.slice(0, 4)); // Output: Java

13. divisão()

Divide uma string em uma matriz de substrings com base em um separador especificado.

let str = "Hello, World!";
let arr = str.split(", ");
console.log(arr); // Output: [ 'Hello', 'World!' ]

14. começaCom()

Verifica se uma string começa com um valor especificado, retornando verdadeiro ou falso.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "Olá, mundo!"; console.log(str.startsWith("Olá")); //Saída: verdadeiro

15. substring()

Extrai os caracteres de uma string entre dois índices especificados.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript"; console.log(str.substring(0, 4)); //Saída: Java

16. paraLowerCase()

Converte uma string em letras minúsculas.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript"; console.log(str.toLowerCase()); //Saída: javascript

17. paraUpperCase()

Converte uma string em letras maiúsculas.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript"; console.log(str.toUpperCase()); //Saída: JAVASCRIPT

18. aparar()

Remove espaços em branco de ambas as extremidades de uma string.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = " JavaScript "; console.log(str.trim()); //Saída: JavaScript

19. trimStart()

Remove espaços em branco do início de uma string.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = " JavaScript"; console.log(str.trimStart()); //Saída: JavaScript

20. trimEnd()

Remove espaços em branco do final de uma string.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript"; console.log(str.trimEnd()); //Saída: JavaScript

21. valorDe()

Retorna o valor primitivo de um objeto String.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

deixe str = new String("JavaScript"); console.log(str.valueOf()); //Saída: JavaScript

Literais de modelo

Os literais de modelo permitem expressões incorporadas, facilitando a concatenação de strings e strings multilinhas.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

deixe nome = "João"; deixe saudação = `Olá, ${nome}! Como você está?`; console.log(saudação); // Saída: Olá, John! Como vai você?

String.raw()

Retorna uma string criada a partir de uma string de modelo bruta, permitindo acesso a strings brutas à medida que são escritas.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = String.raw`Olá\nMundo!`; console.log(str); // Saída: Olá\nMundo!

Exemplos práticos

Exemplo 1: Invertendo uma String

function reverseString(str) {
    return str.split('').reverse().join('');
}
console.log(reverseString("JavaScript")); // Output: tpircSavaJ

função ReverseString(str) { return str.split('').reverse().join(''); } console.log(reverseString("JavaScript")); //Saída: tpircSavaJ

Exemplo 2: verificação de palíndromos

function reverseString(str) {
    return str.split('').reverse().join('');
}
console.log(reverseString("JavaScript")); // Output: tpircSavaJ

função éPalindrome(str) { deixe limpoStr = str.replace(/[\W_]/g, '').toLowerCase(); retornar limpoStr === limpoStr.split('').reverse().join(''); } console.log(isPalindrome("Um homem, um plano, um canal, Panamá")); //Saída: verdadeiro

Exemplo 3: Colocando a primeira letra de cada palavra em maiúscula

function reverseString(str) {
    return str.split('').reverse().join('');
}
console.log(reverseString("JavaScript")); // Output: tpircSavaJ

função capitalizePalavras(str) { return str.split(' ').map(word => word.charAt(0).toUpperCase() word.slice(1)).join(' '); } console.log(capitalizeWords("olá mundo")); //Saída: Olá Mundo

Conclusão

Dominar as funções de string JavaScript é crucial para uma manipulação eficiente de texto e dados. Desde operações básicas, como concatenação e fatiamento, até funções mais avançadas, como correspondência de expressões regulares e literais de modelo, o JavaScript fornece um rico conjunto de ferramentas para trabalhar com strings. Ao compreender e utilizar essas funções, você pode escrever códigos mais limpos e eficientes e enfrentar uma ampla gama de desafios de programação.

Este guia completo cobriu as funções de string mais importantes em JavaScript, completo com exemplos e explicações. Pratique essas funções e experimente diferentes casos de uso para solidificar sua compreensão e aprimorar sua proficiência em codificação.