edubun
Português

Strings e template literals

"5" + 3 dá "53", não 8. Quando um dos lados do + é uma string, o JavaScript junta textos em vez de somar números.

Texto num programa

Nomes, mensagens, endereços, senhas e páginas web inteiras são texto, e o JavaScript guarda texto como strings. Uma string é uma sequência de caracteres entre aspas. O JavaScript aceita três tipos de aspas: aspas duplas "assim", aspas simples 'assim' e crases `assim`. Os dois primeiros funcionam do mesmo jeito. As crases criam um template literal, que tem poderes extras explicados mais abaixo.

Se o seu texto tem um tipo de aspas, envolva-o com o outro: "It's late" funciona porque o apóstrofo não é uma aspa dupla. Você também pode pôr uma barra invertida antes de uma aspa para dizer "esta faz parte do texto": 'It\'s late'. Uma barra invertida seguida de n, escrita \n, quer dizer uma quebra de linha dentro da string.

Comprimento e posições

Toda string sabe quantos caracteres tem: "JavaScript".length é 10. Cada caractere também tem uma posição, chamada índice, e a contagem começa em 0, não em 1. Então em "JavaScript" o índice 0 é J, o índice 4 é S e o último índice é 9, um a menos que o comprimento. Você lê um único caractere com colchetes: word[0]. Começar do 0 parece estranho no início, mas a maioria das linguagens de programação conta assim, e você vai ver isso de novo com arrays.

const word = "JavaScript";
console.log(word.length);                // mostra 10
console.log(word[0]);                    // mostra J
console.log(word[word.length - 1]);      // mostra t

Métodos úteis de string

As strings vêm com ferramentas embutidas chamadas métodos, que você chama com um ponto depois da string. toUpperCase() e toLowerCase() devolvem uma cópia em maiúsculas ou minúsculas. includes("Script") responde true ou false conforme o texto aparece ou não lá dentro. slice(0, 4) devolve os caracteres do índice 0 até o índice 4, sem incluí-lo, o que em "JavaScript" dá "Java". trim() tira os espaços das duas pontas, útil para limpar algo que uma pessoa digitou. Nenhum deles muda a string original. Em JavaScript, strings não podem ser alteradas no lugar; os métodos sempre devolvem uma string nova.

Juntando strings com +

O operador + junta strings ponta com ponta, o que se chama concatenação. "Hello, " + "Mina" dá "Hello, Mina". Os espaços não são postos para você, então ponha-os dentro das aspas. Aqui está a armadilha da abertura: se qualquer um dos lados do + é uma string, o JavaScript transforma o outro lado em string e junta os dois. "5" + 3 dá "53". Os outros operadores aritméticos não juntam texto, então "5" * 2 converte "5" em número e dá 10. Para transformar uma string com algarismos num número de verdade, use Number("5").

Template literals

Montar uma frase com + vira bagunça rápido: name + " is " + age + " years old." exige cuidado com espaços e aspas. Um template literal, escrito com crases, deixa você pôr valores direto no texto com ${ }. O que estiver dentro das chaves é avaliado como expressão e o resultado é colocado na string. Template literals também podem ocupar várias linhas.

const name = "Mina";
const age = 14;
console.log(`${name} is ${age} years old.`);   // mostra: Mina is 14 years old.
console.log(`Next year: ${age + 1}`);           // mostra: Next year: 15

Exemplo resolvido. Uma etiqueta de loja precisa dizer "3 apples cost 4.5". Com const n = 3, price = 1.5; o template `${n} apples cost ${n * price}` resolve numa linha só, e a multiplicação acontece dentro das chaves.

Crases em volta do texto, cifrão e chaves em volta de cada valor: `Hi ${name}`

stringTexto entre aspas ou crases
índicePosição de um caractere, contando a partir de 0
.lengthQuantos caracteres uma string tem
concatenaçãoJuntando strings com +
template literalUma string entre crases com marcadores ${ }
métodoUma ferramenta chamada com um ponto: word.toUpperCase()
slice(a, b)Os caracteres do índice a até b, sem incluir b
sequência de escape \nUma quebra de linha dentro de uma string
  1. O que isto mostra?
    console.log("5" + 3);
  2. O que isto mostra?
    console.log("5" * 3);
  3. O que isto mostra?
    console.log("cat".length);
  4. O que isto mostra?
    const s = "Seoul";
    console.log(s[1]);
  5. O que isto mostra?
    console.log("JavaScript".slice(4, 10));
  6. O que isto mostra?
    const a = 2;
    const b = 3;
    console.log(`${a} + ${b} = ${a + b}`);
    • 2 + 3 = 5
    • ${a} + ${b} = ${a + b}
    • 2 + 3 = 23
  7. O que isto mostra?
    console.log("Hi" + " " + "there".toUpperCase());
  8. O que isto mostra?
    console.log("banana".includes("nan"));
    • true
    • false
  9. O que isto mostra?
    console.log(1 + 2 + "3");
  10. O que isto mostra?
    console.log(Number("7") + 1);
  11. Qual é o último índice de uma string de comprimento 6?
Pontos-chave
  • Strings usam aspas "duplas", 'simples' ou `crases`.
  • Os índices começam em 0; o último índice é length - 1.
  • Métodos como toUpperCase, includes, slice e trim devolvem strings novas.
  • Se um dos lados do + é string, + junta texto.
  • Template literals: `texto ${expressão} texto`.
Fontes deste curso (2)
  • MDN Web Docs, JavaScript Guide (developer.mozilla.org/en-US/docs/Web/JavaScript/Guide, chapters Introduction, Grammar and types, Control flow, Loops and iteration, Functions, Expressions and operators, Numbers and strings, Indexed collections, Working with objects; checked 2026-10-17)
  • Ecma International, ECMA-262 ECMAScript 2026 Language Specification, 17th edition, June 2026 (tc39.es/ecma262 and ecma-international.org/publications-and-standards/standards/ecma-262, checked 2026-10-17)

Data de verificação: 2026-10-17