PHP Funções de String

As funções de texto que você vai usar no dia a dia, agrupadas pelo que fazem, com as versões mb_* para textos com acento. Cada linha tem a assinatura, uma explicação curta, um exemplo e o resultado real, conferido no PHP 8.5 da máquina da Ana. Para aprender com calma, veja Strings, Funções de String, Acentos e mbstring e printf e sprintf.

Como ler as tabelas

Os exemplos usam estas variáveis (cada exemplo começa do zero):

<?php
$texto   = "banana";
$nome    = "  Ana Souza  ";
$palavra = "Ação";

A assinatura mostra os parâmetros e, depois dos dois-pontos, o tipo do resultado. Parâmetros com = valor são opcionais. int|false = devolve um número ou false.
Os resultados estão escritos como código PHP: 'nana' é um texto; true/false, booleanos; ['ab', 'cd'], um array. Textos com quebra de linha aparecem entre aspas duplas com \n; bytes soltos (um acento cortado ao meio) aparecem como "\xA7".
Os índices começam em 0: em "banana", o b é a posição 0. Nenhuma função muda o texto original; todas devolvem um texto novo.

Antes de tudo: bytes × letras

O PHP guarda textos em UTF-8, em que letras com acento ocupam 2 bytes. As funções sem mb_ contam e cortam bytes; as mb_* ("multibyte") contam letras. Com textos em português, a diferença aparece logo:

<?php
$palavra = "Ação";
echo strlen($palavra), " bytes, ", mb_strlen($palavra), " letras\n";
echo strtoupper($palavra), " × ", mb_strtoupper($palavra), "\n";
echo substr($palavra, 0, 2), " × ", mb_substr($palavra, 0, 2), "\n";

$ php bytes.php
6 bytes, 4 letras
AçãO × AÇÃO
A� × Aç

O substr cortou o ç no meio (ficou só o primeiro dos seus 2 bytes, que o terminal mostra como �). Regra prática: para contar, cortar, mudar maiúsculas ou completar textos que podem ter acento, use a versão mb_. Para procurar e trocar (str_contains, str_replace), as normais funcionam bem.

Para…	Sem acento (bytes)	Com acento (use)
Tamanho	`strlen`	`mb_strlen`
Pedaço	`substr`, `str_split`	`mb_substr`, `mb_str_split`, `mb_strimwidth`
Posição	`strpos`, `strrpos`	`mb_strpos`, `mb_strrpos`
Maiúsculas/minúsculas	`strtoupper`, `strtolower`, `ucfirst`, `ucwords`	`mb_strtoupper`, `mb_strtolower`, `mb_ucfirst` (8.4), `mb_convert_case`
Completar e aparar	`str_pad`, `trim`	`mb_str_pad` (8.3), `mb_trim` (8.4)

Atalhos: Tamanho · Pedaços · Procurar · Comparar · Maiúsculas · Espaços e preenchimento · Trocar · Formatar e converter · Web e segurança

Tamanho e contagem

Função	O que faz	Exemplo	Resultado
`strlen(string $texto): int`	Tamanho em bytes. Letras com acento ocupam 2 bytes (UTF-8): use `mb_strlen` para contar letras. Strings	`strlen($texto)` `strlen($palavra)` `strlen("")`	`6` `6` `0`
`mb_strlen(string $texto): int`	Tamanho em caracteres (letras de verdade). Acentos e mbstring	`mb_strlen($palavra)` `mb_strlen("😀")`	`4` `1`
`substr_count(string $texto, string $pedaço): int`	Quantas vezes o pedaço aparece. Funções de String	`substr_count($texto, "a")` `substr_count($texto, "na")`	`3` `2`
`str_word_count(string $texto): int`	Conta palavras, mas só entende letras sem acento. Funções de String	`str_word_count("Bom dia, Ana")` `str_word_count("Ação rápida")`	`3` `4`

Pedaços

Função	O que faz	Exemplo	Resultado
`substr(string $texto, int $início, ?int $tamanho = null): string`	Um pedaço, contando em bytes a partir de 0. Início negativo conta do fim. Funções de String	`substr($texto, 2)` `substr($texto, 1, 3)` `substr($texto, -2)` `substr($palavra, 0, 3)`	`'nana'` `'ana'` `'na'` `'Aç'`
`mb_substr(string $texto, int $início, ?int $tamanho = null): string`	O mesmo, contando caracteres (seguro com acentos). Acentos e mbstring	`mb_substr($palavra, 0, 3)` `mb_substr($palavra, -1)`	`'Açã'` `'o'`
`$texto[$i]`	Um byte da posição (negativo conta do fim). Strings	`$texto[0]` `$texto[-1]` `$palavra[2]`	`'b'` `'a'` `"\xA7"`
`str_split(string $texto, int $tamanho = 1): array`	Corta em pedaços de N bytes. Funções de String	`str_split("abcdef", 2)`	`['ab', 'cd', 'ef']`
`mb_str_split(string $texto, int $tamanho = 1): array`	Corta em pedaços de N caracteres. Acentos e mbstring	`mb_str_split($palavra)`	`['A', 'ç', 'ã', 'o']`
`strstr(string $texto, string $pedaço, bool $antes = false): string\|false`	Do pedaço até o fim (ou o que vem antes dele, com `true`). Funções de String	`strstr("ana@email.com", "@")` `strstr("ana@email.com", "@", true)`	`'@email.com'` `'ana'`
`strrchr(string $texto, string $caractere): string\|false`	Da última ocorrência do caractere até o fim. Funções de String	`strrchr("foto.final.jpg", ".")`	`'.jpg'`
`mb_strimwidth(string $texto, int $início, int $largura, string $marca = ""): string`	Encurta para caber na largura, com uma marca no fim (resumos de posts). Acentos e mbstring	`mb_strimwidth("Aprendendo PHP do zero", 0, 12, "…")`	`'Aprendendo …'`

Procurar

Função	O que faz	Exemplo	Resultado
`str_contains(string $texto, string $pedaço): bool` PHP 8.0+	Contém o pedaço? (diferencia maiúsculas) Funções de String	`str_contains($texto, "nan")` `str_contains($texto, "Ban")`	`true` `false`
`str_starts_with(string $texto, string $início): bool` PHP 8.0+	Começa com…? Funções de String	`str_starts_with($texto, "ba")`	`true`
`str_ends_with(string $texto, string $fim): bool` PHP 8.0+	Termina com…? Funções de String	`str_ends_with("foto.jpg", ".jpg")`	`true`
`strpos(string $texto, string $pedaço, int $aPartirDe = 0): int\|false`	Posição (em bytes) da primeira ocorrência, ou `false`. A posição pode ser `0`: compare com `=== false`. Funções de String	`strpos($texto, "na")` `strpos($texto, "na", 3)` `strpos($texto, "b")` `strpos($texto, "x")`	`2` `4` `0` `false`
`stripos(…): int\|false`	Como `strpos`, sem diferenciar maiúsculas. Funções de String	`stripos($texto, "NA")`	`2`
`strrpos(…): int\|false`	Posição da última ocorrência. Funções de String	`strrpos($texto, "na")`	`4`
`mb_strpos(string $texto, string $pedaço): int\|false`	Posição contada em caracteres. Acentos e mbstring	`strpos($palavra, "o")` `mb_strpos($palavra, "o")`	`5` `3`

A armadilha do strpos

strpos($texto, "b") dá 0 (achou, na posição 0), e 0 conta como falso num if. Escreva if (strpos($texto, "b") !== false), ou simplesmente if (str_contains($texto, "b")).

Comparar

Função	O que faz	Exemplo	Resultado
`$a === $b / $a == $b`	Iguais? (`===` também confere o tipo.) Diferencia maiúsculas. Comparação	`"Ana" === "ana"` `"10" == "10.0"` `"10" === "10.0"`	`false` `true` `false`
`strcmp(string $a, string $b): int`	Compara em ordem alfabética (pelos códigos dos bytes): negativo se `$a` vem antes, 0 se iguais, positivo se depois. O sinal é o mesmo de `$a <=> $b`; o número em si não importa. Funções de String	`strcmp("Ana", "Bia")` `strcmp("Bia", "Ana")` `strcmp("ana", "Bia")`	`-1` `1` `31`
`strcasecmp(string $a, string $b): int`	Igual, ignorando maiúsculas (só letras sem acento). Funções de String	`strcasecmp("ANA", "ana")`	`0`
`strncmp(string $a, string $b, int $n): int`	Compara só os `$n` primeiros bytes. Funções de String	`strncmp("foto1", "foto2", 4)`	`0`
`strnatcmp(string $a, string $b): int`	Ordem "natural": números dentro do texto comparados como números. Ordenar Arrays	`strcmp("foto10", "foto2")` `strnatcmp("foto10", "foto2")`	`-1` `1`
`similar_text(string $a, string $b, float &$porcento = null): int`	Quantos caracteres em comum (e a porcentagem). Funções de String	`similar_text("banana", "bacana", $p);` `round($p, 1)`	`66.7`
`levenshtein(string $a, string $b): int`	Quantas trocas de letra transformam um no outro (para "você quis dizer…?"). Funções de String	`levenshtein("banana", "bacana")`	`1`

Maiúsculas e minúsculas

Função	O que faz	Exemplo	Resultado
`strtoupper(string $texto): string`	Maiúsculas, só letras sem acento (desde o PHP 8.2, não depende do idioma). Funções de String	`strtoupper("banana")` `strtoupper($palavra)`	`'BANANA'` `'AçãO'`
`strtolower(string $texto): string`	Minúsculas, idem. Funções de String	`strtolower("ANA")` `strtolower("AÇÃO")`	`'ana'` `'aÇÃo'`
`mb_strtoupper(string $texto): string`	Maiúsculas de verdade, com acentos. Acentos e mbstring	`mb_strtoupper($palavra)`	`'AÇÃO'`
`mb_strtolower(string $texto): string`	Minúsculas com acentos. Acentos e mbstring	`mb_strtolower("AÇÃO")`	`'ação'`
`ucfirst(string $texto): string`	Primeira letra maiúscula (sem acento). Funções de String	`ucfirst("ana")` `ucfirst("ágata")`	`'Ana'` `'ágata'`
`mb_ucfirst(string $texto): string` PHP 8.4+	Primeira letra maiúscula, com acento. Acentos e mbstring	`mb_ucfirst("ágata")`	`'Ágata'`
`lcfirst(string $texto): string`	Primeira letra minúscula. Funções de String	`lcfirst("Ana")`	`'ana'`
`ucwords(string $texto): string`	Primeira letra de cada palavra maiúscula. Funções de String	`ucwords("ana souza")`	`'Ana Souza'`
`mb_convert_case(string $texto, int $modo): string`	Com `MB_CASE_TITLE`: cada palavra com inicial maiúscula e o resto minúsculo, com acentos. Acentos e mbstring	`mb_convert_case("ÉRICA DA SILVA", MB_CASE_TITLE)`	`'Érica Da Silva'`

Experimente: o nome veio do formulário com espaços sobrando e maiúsculas bagunçadas. Faça o programa mostrar Olá, Érica Da Silva!. Dica: trim e mb_convert_case(…, MB_CASE_TITLE). Tente também com ucwords(strtolower(…)) e veja o que acontece com o É.

<?php
$nome = "  érica DA silva ";
echo "Olá, $nome!\n";

<?php
$nome = "  érica DA silva ";
$limpo = mb_convert_case(trim($nome), MB_CASE_TITLE);
echo "Olá, $limpo!\n";

Espaços, preenchimento e repetição

Função	O que faz	Exemplo	Resultado
`trim(string $texto, string $caracteres = " \n\r\t\v\x00"): string`	Tira espaços (e quebras de linha) do começo e do fim. Com o 2º argumento, tira esses caracteres. Funções de String	`trim($nome)` `trim("--Ana--", "-")`	`'Ana Souza'` `'Ana'`
`ltrim(…) / rtrim(…)`	Só do começo (left) / só do fim (right). Funções de String	`ltrim($nome)` `rtrim("1,2,3,", ",")`	`'Ana Souza '` `'1,2,3'`
`mb_trim(string $texto): string` PHP 8.4+	Como `trim`, entendendo também espaços especiais do Unicode. Acentos e mbstring	`mb_trim("\u{3000}Ana\u{3000}")` `trim("\u{3000}Ana\u{3000}")`	`'Ana'` `'　Ana　'`
`str_pad(string $texto, int $tamanho, string $com = " ", int $lado = STR_PAD_RIGHT): string`	Completa até o tamanho (em bytes). Lados: `STR_PAD_LEFT`, `STR_PAD_BOTH`. Funções de String	`str_pad("7", 3, "0", STR_PAD_LEFT)` `str_pad("Ana", 7, "", STR_PAD_BOTH)` `str_pad($palavra, 6, "")`	`'007'` `'Ana'` `'Ação'`
`mb_str_pad(…): string` PHP 8.3+	Igual, contando caracteres. Acentos e mbstring	`mb_str_pad($palavra, 6, "*")`	`'Ação**'`
`str_repeat(string $texto, int $vezes): string`	Repete o texto. Funções de String	`str_repeat("-", 10)` `str_repeat("ab", 3)`	`'----------'` `'ababab'`
`wordwrap(string $texto, int $largura = 75, string $quebra = "\n", bool $cortar = false): string`	Quebra o texto em linhas de até N bytes, nos espaços. Funções de String	`wordwrap("Aprendendo PHP do zero", 10, "\n")`	`"Aprendendo\nPHP do\nzero"`
`nl2br(string $texto): string`	Põe `<br />` antes de cada quebra de linha (para mostrar textos de `<textarea>` em HTML). Escapar a Saída	`nl2br("linha 1\nlinha 2")`	`"linha 1<br />\nlinha 2"`

Trocar e inverter

Função	O que faz	Exemplo	Resultado
`str_replace(string\|array $procura, string\|array $troca, string $texto): string`	Troca todas as ocorrências (diferencia maiúsculas). Aceita arrays. Funções de String	`str_replace("na", "NA", $texto)` `str_replace(["a", "n"], ["4", "N"], $texto)` `str_replace(",", ".", "10,50")`	`'baNANA'` `'b4N4N4'` `'10.50'`
`str_ireplace(…): string`	Igual, ignorando maiúsculas. Funções de String	`str_ireplace("ANA", "Bia", "Oi, ana!")`	`'Oi, Bia!'`
`substr_replace(string $texto, string $troca, int $início, ?int $tamanho = null): string`	Troca um trecho por posição. Funções de String	`substr_replace("1234567890", "****", 0, 6)`	`'****7890'`
`strtr(string $texto, array $pares): string`	Troca vários pedaços de uma vez, sem uma troca afetar a outra. Funções de String	`strtr("Olá, {nome}!", ["{nome}" => "Ana"])`	`'Olá, Ana!'`
`strrev(string $texto): string`	Inverte os bytes (estraga acentos). Funções de String	`strrev($texto)` `strrev($palavra)`	`'ananab'` `"o\xA3\xC3\xA7\xC3A"`
`preg_replace(string $regex, string $troca, string $texto): string`	Troca o que casar com uma expressão regular. Funções de String	`preg_replace("/[^0-9]/", "", "(81) 98765-4321")`	`'81987654321'`
`preg_match(string $regex, string $texto, array &$achados = null): int`	Casa com a expressão? (1 ou 0) e guarda os pedaços. Funções de String	`preg_match("/(\d{2})\/(\d{2})\/(\d{4})/", "Nasceu em 15/03/1997", $m);` `$m`	`['15/03/1997', '15', '03', '1997']`

Expressões regulares (preg_*) são uma pequena linguagem de padrões: [^0-9] = "qualquer coisa que não seja dígito", \d{2} = "dois dígitos". A aula Funções de String mostra o básico.

Formatar e converter

Função	O que faz	Exemplo	Resultado
`sprintf(string $formato, mixed ...$valores): string`	Monta um texto a partir de um modelo: `%s` texto, `%d` inteiro, `%.2f` decimal com 2 casas (sempre com ponto), `%05d` com zeros à esquerda, `%-10s` alinhado à esquerda. printf e sprintf	`sprintf("%s tem %d anos", "Ana", 29)` `sprintf("%.2f", 3.14159)` `sprintf("%05d", 42)` `sprintf("[%-6s]", "Ana")` `sprintf("%5.1f%%", 12.345)`	`'Ana tem 29 anos'` `'3.14'` `'00042'` `'[Ana ]'` `' 12.3%'`
`number_format(float $n, int $casas = 0, string $decimal = ".", string $milhar = ","): string`	Número formatado; para o Brasil, `","` e `"."`. Formatar Números	`number_format(1234.5, 2, ",", ".")` `number_format(1234.5)`	`'1.234,50'` `'1,235'`
`implode(string $sep, array $a) / explode(string $sep, string $t)`	Array → texto / texto → array. Referência de Array	`implode("-", ["a", "b"])` `explode(" ", "Ana Souza")`	`'a-b'` `['Ana', 'Souza']`
`intval(mixed $v) / (int) $v`	Converte para inteiro: lê o número do começo e para no primeiro caractere inválido. Conversão de Tipos	`(int) "42"` `(int) "12abc"` `(int) "abc"` `(int) "3,99"`	`42` `12` `0` `3`
`floatval(mixed $v) / (float) $v`	Converte para `float` (a vírgula não é decimal!). Conversão de Tipos	`(float) "3.99"` `(float) "3,99"`	`3.99` `3.0`
`is_numeric(mixed $v): bool`	É um número (ou texto com um número completo)? Validar Dados	`is_numeric("42")` `is_numeric("4.2e3")` `is_numeric("12abc")` `is_numeric(" 42")`	`true` `true` `false` `true`
`ctype_digit(string $t): bool`	Só tem dígitos 0–9? (bom para CEP, códigos) Validar Dados	`ctype_digit("01234")` `ctype_digit("12.5")` `ctype_digit("")`	`true` `false` `false`
`ord(string $c) / chr(int $n)`	Código de um byte / byte de um código. Funções de String	`ord("A")` `chr(97)`	`65` `'a'`
`mb_ord(string $c) / mb_chr(int $n)`	Código Unicode de um caractere / caractere de um código. Acentos e mbstring	`mb_ord("ç")` `mb_chr(231)`	`231` `'ç'`

Os formatos de sprintf também valem para printf (que escreve direto na tela). O %.2f usa ponto mesmo com o sistema em português; para "R$ 1.234,50", use number_format. Detalhes em printf e sprintf e Formatar Números.

Web e segurança

Função	O que faz	Exemplo	Resultado
`htmlspecialchars(string $texto, int $flags = ENT_QUOTES \| ENT_SUBSTITUTE \| ENT_HTML401): string`	Troca `& < > " '` por códigos HTML. Use sempre ao mostrar dados do visitante (contra XSS). Escapar a Saída	`htmlspecialchars("<b>Ana</b> & \"Bia\"")` `htmlspecialchars("it's")`	`'<b>Ana</b> & "Bia"'` `'it's'`
`html_entity_decode(string $texto): string`	O contrário: códigos HTML viram caracteres. Escapar a Saída	`html_entity_decode("<b> & é")`	`'<b> & é'`
`strip_tags(string $texto, ?string $permitidas = null): string`	Remove as tags HTML (não substitui o `htmlspecialchars`). Escapar a Saída	`strip_tags("<p>Olá, <b>Ana</b></p>")`	`'Olá, Ana'`
`urlencode(string $texto): string`	Prepara um valor para ir na URL (espaço vira `+`). $_GET e $_POST	`urlencode("café com leite")`	`'caf%C3%A9+com+leite'`
`rawurlencode(string $texto): string`	Idem, com espaço como `%20` (para pedaços do caminho). $_GET e $_POST	`rawurlencode("café com leite")`	`'caf%C3%A9%20com%20leite'`
`http_build_query(array $dados): string`	Monta a query string inteira a partir de um array. $_GET e $_POST	`http_build_query(["busca" => "café", "pagina" => 2])`	`'busca=caf%C3%A9&pagina=2'`
`base64_encode(string $t) / base64_decode(string $t)`	Codifica bytes em texto seguro (não é criptografia!). Funções de String	`base64_encode("Ana")` `base64_decode("QW5h")`	`'QW5h'` `'Ana'`
`md5(string $t) / hash(string $algo, string $t)`	Resumo (hash) de um texto. Nunca para senhas: use `password_hash`. Senhas	`md5("Ana")` `hash("sha256", "Ana")`	`'9aba45a7f1999a9c5fc96ef2a45810fb'` `'dea210f058b407db5c1b5ea89b2e42a57221c003dba55e2f1776a75a3254d386'`
`bin2hex(random_bytes(int $n))`	Um código aleatório seguro em hexadecimal (tokens). CSRF	`strlen(bin2hex(random_bytes(16)))`	`32`

Qual usar para mostrar dados do visitante?

htmlspecialchars, sempre, no momento de escrever no HTML: ele mantém o texto como o visitante digitou, só que inofensivo. strip_tags apaga partes do texto e não protege atributos. Veja Escapar a Saída (XSS).

Missão: o endereço do post

Blogs mostram posts em endereços como /post/minha-primeira-receita-pao-de-queijo (um "slug"). Monte esse texto a partir do título.

Missão: transforme o título em minha-primeira-receita-pao-de-queijo: tudo minúsculo (mb_strtolower), sem acentos (strtr com um array de trocas), tudo o que não for letra ou número vira um - (preg_replace("/[^a-z0-9]+/", "-", …)) e sem - nas pontas (trim(…, "-")).

<?php
$titulo = "Minha Primeira Receita: Pão de Queijo!";
$slug = $titulo;
echo $slug, "\n";

<?php
$titulo = "Minha Primeira Receita: Pão de Queijo!";
$slug = mb_strtolower($titulo);
$slug = strtr($slug, ["á" => "a", "ã" => "a", "â" => "a", "é" => "e", "ê" => "e", "í" => "i", "ó" => "o", "õ" => "o", "ô" => "o", "ú" => "u", "ç" => "c"]);
$slug = preg_replace("/[^a-z0-9]+/", "-", $slug);
$slug = trim($slug, "-");
echo $slug, "\n";

$ php missao-s2.php
minha-primeira-receita-pao-de-queijo

Exercícios

1. Quanto dá strlen("Pão")?

3 4 6 Dá erro.

2. Qual teste diz corretamente se $email tem "@"?

if (strpos($email, "@")) if (strpos($email, "@") == 0) if (strlen($email, "@")) if (str_contains($email, "@"))

3. O que (float) "3,99" devolve?

3.0 3.99 399.0 Um TypeError.

Complete para mostrar o preço como 1.234,50:

echo ($preco, 2, ",", ".");

Complete para mostrar com segurança um comentário enviado pelo visitante:

echo ($comentario);

Complete para deixar "7" com três dígitos ("007"):

str_pad("7", 3, "0", )

Resumo

Sem mb_ = bytes; com mb_ = letras. Com acento, use mb_strlen, mb_substr, mb_strtoupper, mb_str_pad.
Procurar: str_contains, str_starts_with, str_ends_with (8.0); strpos devolve a posição ou false (compare com !== false).
Limpar e trocar: trim, str_replace, strtr, preg_replace.
Formatar: sprintf (ponto decimal sempre), number_format (padrão brasileiro com "," e "."), str_pad.
Converter: (int)/(float) leem só o começo e não entendem vírgula; valide com is_numeric/ctype_digit.
Web: htmlspecialchars na saída, sempre; urlencode/http_build_query para montar URLs.