String em TypeScript: interpolação, multilinha e contains

Uma string em TypeScript é uma string do JavaScript com o tipo string. Para interpolação, escreva um template literal: crases com marcadores ${expression}. Aspas simples e duplas criam strings simples, sem interpolação.

const author: string = "Ada";
const year = 1843;

// String interpolation with a template literal
const intro = `${author} published her notes in ${year}.`;
console.log(intro);

// Any expression works inside ${ }
const price = 19.5;
const qty = 3;
console.log(`Total: $${(price * qty).toFixed(2)}`); // Total: $58.50
console.log(`${qty > 1 ? "items" : "item"} in cart: ${qty}`);

Os três estilos de aspas produzem o mesmo tipo, string. O primeiro $ em $${...} é um cifrão literal; só ${ inicia um marcador.

Interpolação de strings

Dentro de ${ } você pode colocar uma variável, uma conta, uma chamada de função, um ternário ou um template literal aninhado. O valor é convertido em string do mesmo jeito que String(value) faria (a exceção é symbol: interpolar um é o erro de compilação TS2731, e em tempo de execução lançaria um TypeError; escreva String(sym)).

type User = { name: string; roles: string[]; lastLogin: Date | null };

const user: User = {
    name: "grace",
    roles: ["admin", "editor"],
    lastLogin: new Date("2024-03-15T10:30:00Z"),
};

const capitalize = (s: string) => s[0].toUpperCase() + s.slice(1);

console.log(`User: ${capitalize(user.name)}`);
console.log(`Roles: ${user.roles.join(", ")}`);
console.log(`Last login: ${user.lastLogin?.toISOString() ?? "never"}`);
console.log(`Raw array: ${user.roles}`); // arrays join with commas

Interpolar um objeto imprime [object Object], o que quase nunca é o que você quer. Escolha os campos ou use JSON.stringify(obj).

Strings de várias linhas

Um template literal pode ocupar várias linhas. As quebras de linha são mantidas, assim como qualquer indentação no início de cada linha, porque tudo o que está entre as crases faz parte da string.

const poem = `Roses are red,
Violets are blue,
Types are erased,
And so are you.`;
console.log(poem);

function card(title: string, body: string): string {
    return `
    [${title}]
    ${body}`; // the leading spaces and first newline are in the string
}
console.log(JSON.stringify(card("Note", "Hi")));

// Alternatives without the indentation problem:
const lines = ["first line", "second line"].join("\n");
console.log(lines);

Quando a indentação do seu código vazaria para dentro da string, monte-a com um array e join("\n"), ou deixe as linhas do template literal encostadas no início da linha.

Verificando se uma string contém uma substring

includes responde "contém ou não" com um boolean. startsWith e endsWith verificam as pontas. indexOf dá a posição, ou -1 quando a substring não aparece. Todos diferenciam maiúsculas de minúsculas.

const file = "Report-2024.PDF";

console.log(file.includes("2024"));    // true
console.log(file.includes("pdf"));     // false: case-sensitive
console.log(file.toLowerCase().endsWith(".pdf")); // true
console.log(file.startsWith("Report")); // true
console.log(file.indexOf("-"));        // 6
console.log(file.indexOf("x"));        // -1

// A regular expression for patterns, with the i flag for case-insensitive
console.log(/report-\d{4}/i.test(file)); // true

includes também aceita uma posição inicial: file.includes("R", 1) só procura a partir do índice 1.

Métodos comuns e seus tipos

O TypeScript conhece o tipo de retorno de todo método nativo. Os que podem voltar vazios são os que merecem atenção, porque com strict você precisa tratar null ou undefined antes de usar o resultado.

const log = "error=404 path=/users";

const match = log.match(/error=(\d+)/);
// match is RegExpMatchArray | null: check before indexing
if (match) {
    console.log(Number(match[1])); // 404
}

const last = "abc".at(-1); // string | undefined
console.log(last?.toUpperCase()); // C

const parts = log.split(" ").map((p) => p.split("="));
console.log(parts); // [ [ 'error', '404' ], [ 'path', '/users' ] ]

O acesso por índice simples, s[5], tem o tipo string mesmo quando o índice passa do fim (onde o valor em tempo de execução é undefined). A opção de compilador noUncheckedIndexedAccess faz com que ele seja string | undefined.

Strings são imutáveis

Não dá para alterar um caractere no lugar. O TypeScript aponta a atribuição a um índice como o erro TS2542, Index signature in type 'String' only permits reading., e no JavaScript em modo strict para o qual o código é compilado a mesma atribuição lançaria um TypeError em tempo de execução. Todo método que parece modificar uma string retorna uma nova.

let word = "hello";

// @ts-expect-error: Index signature in type 'String' only permits reading.
const change = () => { word[0] = "H"; };

word = "H" + word.slice(1); // build a new string instead
console.log(word);          // Hello

Para transformar outros valores em strings, ou strings em números, veja string para número.

Tipos literais de string

string aceita qualquer texto. Um tipo literal de string aceita um único valor exato, e uma union deles forma um conjunto de strings permitidas, parecido com um enum:

type Status = "draft" | "published" | "archived";

function label(status: Status): string {
    return `Post is ${status}`;
}

console.log(label("draft"));
// @ts-expect-error: Argument of type '"deleted"' is not assignable to parameter of type 'Status'.
console.log(label("deleted"));

Os tipos literais são verificados só em tempo de compilação; em tempo de execução label("deleted") ainda rodaria e imprimiria Post is deleted, que é o que a segunda linha faz aqui. A sintaxe de template literal também funciona no nível dos tipos, como em type EventName = `on${string}`, que aceita qualquer string que comece com on.