Banner Funções de String do PHP. Com as palavras str_contains, wordwrap, strcmp, trim, strlen, str_replace, substr, str_ends_with, strtoupper.

Strings são elementos fundamentais no desenvolvimento web, mas sua manipulação pode, por vezes, representar um desafio para os desenvolvedores. Para simplificar esse processo, o PHP oferece uma ampla variedade de funções dedicadas ao tratamento e à manipulação de strings, tornando as tarefas mais práticas e eficientes.

Neste post, exploraremos algumas das principais funções que o PHP oferece para a manipulação de strings.

Antes de analisarmos as funções de manipulação de strings, é importante compreender o conceito de Multibyte. Normalmente, um caractere é codificado utilizando um único byte, o que é suficiente para representar letras como “A”, “b” entre outras do alfabeto básico. No entanto, um byte não é suficiente para abranger os caracteres de outros idiomas ou mesmo acentos, exigindo o uso de mais de um byte para representá-los.

Essa característica não seria um grande problema se o objetivo fosse apenas exibir textos. No entanto, muitas funções no PHP que contam caracteres ou manipulam suas posições baseiam-se na contagem de bytes, e não de caracteres propriamente ditos. Para lidar com essa limitação, o PHP oferece o módulo mbstring, que disponibiliza funções específicas com o prefixo mb_. Essas funções são projetadas para trabalhar corretamente com caracteres multibyte, operando de maneira semelhante às suas equivalentes sem o prefixo.

Por exemplo, as funções strlen e mb_strlen calculam o tamanho de uma string. Se passarmos o texto "Coração" para strlen, ela retornará 9, pois os caracteres “ç” e “ã” utilizam 2 bytes cada para sua representação. Já a função mb_strlen, por lidar diretamente com caracteres multibyte, retornará o valor esperado de 7.

strlen

strlen é um uma função bem conhecida que retorna o tamanho de uma string passada como parâmetro.

$txt = "Lorem ipsum dolor sit amet";
echo strlen($txt)."\n";
// 26

$txt = "Meu coração bate como caroço de abacate";
echo strlen($txt)."\n";
// 42 ??? - os caracteres ç e ã utilizam mais de um byte para ser representados

$txt = "Meu coração bate como caroço de abacate";
echo mb_strlen($txt)."\n"; // utilizando a versão multibyte da função
// 39

strpos

A função strpos é utilizada para localizar a primeira ocorrência de uma substring dentro de uma string. A contagem das posições na string inicia no índice 0.

  • Primeiro parâmetro: a string na qual será feita a pesquisa.
  • Segundo parâmetro: a substring (letra, palavra ou frase) que será pesquisada.
  • Terceiro parâmetro(opcional): o offset, ou seja, a posição inicial na string a partir da qual a pesquisa será realizada.

A função retorna a posição da substring encontrada ou false caso ela não seja localizada.

$txt = "Uma frase de exemplo.";
$posicao = strpos($txt, 'frase');

echo "A posição da palavras 'frase' é: " . $posicao . "\n";
// Saída: A posição da palavras 'frase' é: 4
012345678910111213141516171819
Umafrasedeexemplo
Referência das posições dos caracteres na frase de exemplo.
$txt = "Um, dois, um, dois!";
$posicao1 = strpos($txt, 'dois');
$posicao2 = strpos($txt, 'dois', 8); // irá buscar somente a partir da posição 8 do $txt

echo "A primeira palavra 'dois' é: " . $posicao1 . "\n";
echo "A segunda palavra 'dois' é: " . $posicao2 . "\n";
// A primeira palavra 'dois' é: 4
// A segunda palavra 'dois' é: 14

$txt = "Algo para não encontrar!";
$posicao = mb_strpos($txt, '@'); // irá retornar false pois o caractere @ não esta presente em $txt
echo "O '@' foi encontrado: " . ( $posicao ? "SIM" : "NÃO") . "\n";
// O '@' foi encontrado: NÃO

A função strpos é case-sensitive, ou seja, diferencia letras maiúsculas de minúsculas. Por exemplo, uma pesquisa por "Frase" e "frase" será tratada como distinta.

Se for necessário realizar uma pesquisa case-insensitive, utilize a função stripos, que é a versão insensível a maiúsculas e minúsculas de strpos.

str_contains 

A função str_contains verifica se uma substring está presente dentro de outra string.

  • Primeiro parâmetro: a string na qual será realizada a pesquisa.
  • Segundo parâmetro: a substring que se deseja encontrar.

A função retorna um valor booleano: true, se o texto for encontrado e false, caso contrário.

$txt = "PHP é um linguagem muito legal!";
$presente = str_contains($txt, 'PHP'); // retorna true
echo "Contem a palavra 'PHP'? " . ( $presente ? "SIM" : "NÃO") . "\n";

$presente = str_contains($txt, 'chata'); // retorna false
echo "Contem a palavra 'chata'? " . ( $presente ? "SIM" : "NÃO") . "\n";

str_starts_with

A função str_starts_with verifica se uma string começa com uma determinada substring.

  • Primeiro argumento: a string na qual será feita a pesquisa.
  • Segundo argumento: a substring que se deseja verificar se está no começo.

A função retorna um valor booleano: true, se a string começar com a substring fornecida ou false, caso contrário.

$url = "https://www.botecodigital.com.br";
$comecaCom = str_starts_with($url, 'https://');
echo  "É uma url https? " . ($comecaCom ? "SIM" : "NÃO") . "\n";

$url = "http://www.botecodigital.com.br";
$comecaCom = str_starts_with($url, 'https://');
echo  "É uma url https? " . ($comecaCom ? "SIM" : "NÃO") . "\n";

str_ends_with

A função str_ends_with é semelhante à função str_starts_with, com a única diferença sendo que ela verifica se uma string termina com uma determinada substring, em vez de verificar o início.

  • Primeiro argumento: a string na qual será feita a pesquisa.
  • Segundo argumento: a substring que se deseja verificar no final da string.

A função retorna um valor booleano: true, se a string terminar com a substring fornecida ou false, caso contrário.

$filename = "/home/rodrigo/foto.png";
$ehPNG = str_ends_with($filename, '.png');
echo "O arquivo $filename termina com '.png'? " . ($ehPNG ? "SIM" : "NÃO") . "\n";

$filename = "/home/rodrigo/outra-foto.jpg";
$ehPNG = str_ends_with($filename, '.png');
echo "O arquivo $filename termina com '.png'? " . ($ehPNG ? "SIM" : "NÃO") . "\n";

substr

A função substr retorna uma parte de uma string. Ela funciona da seguinte maneira:

  • Primeiro parâmetro: o texto do qual se deseja extrair uma parte.
  • Segundo parâmetro: o offset, ou seja, o deslocamento inicial a partir do início da string. Se o valor for negativo, o deslocamento será contado a partir do final da string.
  • Terceiro parâmetro (opcional): a quantidade de caracteres que deve ser extraída a partir do offset. Se esse parâmetro não for fornecido, a função retornará até o final da string.
$txt = "Uma frase de exemplo para teste";
echo substr($txt, 0, 9) . "\n"; 
// retorna "Uma frase" já que o offset é 0 (o inicio do texto) e retorna 9 
// caracteres chegando até a posição 8

echo substr($txt, 10, 10) . "\n";
// retorna "de exemplo" já que o offset é 10 ou seja o caracter "d" e a 
// partir dele contando 10 caracteres  chega no caracter o na posição 19

echo substr($txt, 13) . "\n";
// retorna "exemplo para teste" já que o offset é 13 na letra "e" e como não
// é passado o terceiro argumento ele retorna até o final da string na 
// posição 30

echo substr($txt, -10) . "\n";
// retorna "para teste" já que no offset é passado um valor negativo então 
// ele começa contando 10 caracteres do final para o começo chegando  
// na posição 21 e o terceiro argumento não é passado então 
// ele retorna até o final do texto. É interessante para pegar os últimos 
// x caracteres de uma string
0123456789101112131415161718192021222324252627282930
Umafrasedeexemploparateste
Posições dos caracteres na frase de exemplo para teste

str_replace

A função str_replace substitui todas as ocorrências de uma string por outra dentro de um texto. Sua utilização funciona da seguinte forma:

  • Primeiro parâmetro: a string ou um array de strings a serem buscadas no texto. Se for passado um array, cada elemento será buscado e substituído no texto.
  • Segundo parâmetro: a string ou um array que contém as substituições. Se for passado um array, cada elemento substituirá o elemento de mesma posição no array de busca.
  • Terceiro parâmetro: o texto ou array onde será realizada a busca e substituição. Se for passado um array a substituição será realizada em cada elemento do array.
  • Quarto parâmetro (opcional): uma variável que receberá a quantidade de substituições realizadas pela função.
  • O retorno: a função retornará uma nova string com os valores substituídos. 
$txt = "Uma frase de exemplo para teste";

echo str_replace("exemplo", "ex.", $txt) . "\n";
// Saida: Uma frase de ex. para teste
// sem muito mistério enconta a palavra "exemplo" em $txt e substitui para "ex."

echo str_replace(['a','e', 'o'], ['4','3','0'], $txt) . "\n";
// Saída: Um4 fr4s3 d3 3x3mpl0 p4r4 t3st3
// para todo caracter "a" encontrado substitui pelo caractere "4" já que "a" é o 
// primeiro elemento do array de busca e "4" é o primeiro elemento do array 
// de substituição e assim sucessivamente para todos os elementos

str_repeat

A função str_repeat repete uma string um número específico de vezes. O primeiro parâmetro é a string que será repetida. O segundo parâmetro é um número inteiro que define quantas vezes a string será repetida.

echo str_repeat("-", 10) . "\n";
// Saída: ----------

echo str_repeat("-+-", 10) . "\n";
//Saída: -+--+--+--+--+--+--+--+--+--+-

ucfirst

A função ucfirst converte a primeira letra de uma string para maiúscula, deixando o restante do texto inalterado.

$txt = "vamos lá pessoal!";
echo ucfirst($txt) . "\n";
// Saída: "Vamos lá pessoal!"

ucwords

A função ucwords converte a primeira letra de cada palavra em uma string para maiúscula, enquanto mantém o restante dos caracteres inalterado.

$txt = "rodrigo pletsch aramburu";
echo ucwords($txt) . "\n";
// Saída: Rodrigo Pletsch Aramburu

strtoupper

A função strtoupper converte todos os caracteres de uma string para maiúsculas.

$txt = "funções de string do PHP";
echo mb_strtoupper($txt) . "\n";
// FUNÇÕES DE STRING DO PHP

strtolower

A função strtolower converte todos os caracteres de uma string para minúsculas.

$txt = "FUNÇÕES DE STRING DO PHP";
echo mb_strtolower($txt) . "\n";
// funções de string do php

trim

A função trim remove espaços em branco ou outros caracteres específicos do início e do final de uma string.

  • Primeiro parâmetro: a string que será “aparada”.
  • Segundo parâmetro (opcional): uma lista de caracteres a serem removidos das extremidades da string. Se não for especificado, o padrão é remover espaços em branco (incluindo tabulações, quebras de linha e outros caracteres de espaço).
$nome = " \t João dos Rios \n ";
echo $nome . "\n";
echo trim($nome) . "\n";
// Saída:
// "         João dos Rios 
// "
// "João dos Rios"

$nome = "### João dos Rios ###";
echo $nome . "\n";
echo trim($nome, "# ") . "\n";
// Saída
// ### João dos Rios ###
// João dos Rios
// retirou tanto o caractere # quanto o espaço já que os dois estavam
// na lista de caracteres do segundo parâmetro

ltrim e rtrim

As funções ltrim e rtrim funcionam de maneira semelhante à função trim, mas com diferenças específicas:

  • ltrim: remove caracteres apenas do início (esquerda) da string.
  • rtrim: remove caracteres apenas do final (direita) da string.

Ambas aceitam os mesmos parâmetros:

  • Primeiro parâmetro: a string que será “aparada”.
  • Segundo parâmetro (opcional): uma lista de caracteres a serem removidos. Se não especificado, removem espaços em branco.
$txt = "==== PHP!!!! ====";

echo ltrim($txt, '= ') . "\n";
echo rtrim($txt, '= ') . "\n";

// PHP!!!! ====
// ==== PHP!!!!

strrev

A função strrev inverte a ordem dos caracteres em uma string, retornando a string ao contrário.

$txt = "rodrigo";
echo strrev($txt) . "\n";
// Saída: ogirdor

strcmp

A função strcmp compara duas strings para determinarse uma string é maior que outra pela sua posição na tabela ASCII, normamente para fins de ordenação. Ela retorna um valor inteiro que indica o resultado da comparação:

  • Valor positivo: se a primeira string for maior que a segunda.
  • Valor negativo: se a primeira string for menor que a segunda.
  • Valor 0: se as strings forem iguais.

Lembre-se de que a função strcmp realiza a comparação caractere por caractere. Isso significa que a comparação é feita posição por posição até que seja encontrada uma diferença, ou até que todas as posições tenham sido verificadas. Por exemplo: ao comparar "aaa" e "aba", o segundo caractere define o resultado, já que a primeira letra é igual em ambas. Como "b" é maior que "a" na tabela ASCII, "aba" é considerada maior.

$text1 = "ana";
$text2 = "rodrigo";
$text3 = "thiago";

echo strcmp($text1, $text2) . "\n"; // retorna -1114371, pq ana é menor que rodrigo
echo strcmp($text2, $text3) . "\n"; // retorna -1114371, pq rodrigo é menor que thiago
echo strcmp($text2, $text2) . "\n"; // retorna 0, pq rodrigo é igual a rodrigo
echo strcmp($text2, $text1) . "\n"; // retorna 1114371, pq rodrigo é maior que ana

* OBS.: a função strcmp é case-sensitive, para uma comparação que seja case-insensitive utiliza a função strcasecmp.

strstr

A função strstr busca uma substring dentro de uma string e retorna a parte da string original a partir da primeira ocorrência da substring até o final.

  1. Primeiro parâmetro: a string na qual será feita a busca.
  2. Segundo parâmetro: o texto que será buscado.

A função retorna a parte da string original a partir da substring encontrada, incluindo a própria substring, ou false caso a substring não seja encontrada.

$txt = "Você deveria programar em PHP";
echo strstr($txt, "programar") . "\n";
// Saída: programar em PHP

Por padrão, a busca é case-sensitive. Para uma busca insensível a maiúsculas e minúsculas, use a função stristr.

wordwrap

A função wordwrap é usada para quebrar uma string em linhas com um número especificado de caracteres, respeitando os limites das palavras. Ela recebe os seguintes parâmetros:

  • Primeiro parâmetro: o texto que será “embrulhado” (ou seja, a string que será dividida em várias linhas).
  • Segundo parâmetro: o número máximo de caracteres por linha.
  • Terceiro parâmetro (opcional): o caractere que será usado para fazer a quebra de linha. O valor padrão é "\n", mas pode ser substituído por qualquer string, como <br> ou até mesmo um caractere não relacionado à quebra.
  • Quarto parâmetro (opcional): um valor booleano que, quando definido como true, permite que palavras maiores do que o número de caracteres por linha sejam divididas(quebrada), para que caibam dentro da largura especificada.
$text = "O PHP é uma linguagem de programação popular e amplamente utilizada para desenvolvimento web. Com uma sintaxe simples e uma ampla gama de recursos, ele permite criar sites dinâmicos, sistemas robustos e APIs eficientes.";
echo wordwrap($text, 20, "<br>\n") . "\n";

// Saída:
// O PHP é uma<br>
// linguagem de<br>
// programação<br>
// popular e amplamente<br>
// utilizada para<br>
// desenvolvimento web.<br>
// Com uma sintaxe<br>
// simples e uma ampla<br>
// gama de recursos,<br>
// ele permite criar<br>
// sites dinâmicos,<br>
// sistemas robustos e<br>
// APIs eficientes.

explode

A função explode quebra uma string em várias partes com base em um delimitador especificado. Ela retorna um array, onde cada item é uma parte da string original dividida pelo delimitador.

  1. Primeiro parâmetro: o delimitador, que é a string que irá separar as partes.
  2. Segundo parâmetro: a string a ser dividida.

A função retorna um array contendo as partes da string divididas pelo delimitador. Se o delimitador não for encontrado, o array conterá a string original como um único elemento.

$text = "Explode é um nome bem legal para uma função!";
$pedacos = explode(" ", $text); // quebra a string em palavras já que um espaço é usado como delimitador

foreach($pedacos as $p){
    echo $p . "\n";
}

implode

A função implode é o oposto da função explode. Ela junta os elementos de um array em uma única string, utilizando um delimitador entre os elementos.

  1. Primeiro parâmetro: o delimitador, que será inserido entre cada elemento do array ao formar a string.
  2. Segundo parâmetro: o array cujos elementos serão combinados em uma string.

A função retorna uma string composta pelos elementos do array, separados pelo delimitador fornecido.

A função implode possui um apelido(alias) como join, que pode ser utilizada no lugar

$nomes = ["João", "Maria", "Pedro"];
echo implode(" - ", $nomes) . "\n";
echo join(" - ", $nomes) . "\n";
// Saída: João - Maria - Pedro

str_split

A função str_split divide uma string em partes menores, retornando um array com os segmentos. O primeiro parâmetro da função é a string que será dividida, enquanto o segundo, opcional, define o número de caracteres de cada segmento. Caso o segundo parâmetro não seja informado, o valor padrão será 1, ou seja, a string será dividida caractere por caractere.

$txt = "Olá Amigo!";
$partes =  mb_str_split($txt);
print_r($partes);
// Saída:
// Array
// (
//     [0] => O
//     [1] => l
//     [2] => á
//     [3] =>
//     [4] => A
//     [5] => m
//     [6] => i
//     [7] => g
//     [8] => o
//     [9] => !
// )

$partes = mb_str_split($txt, 3);
print_r($partes);
// Saída:
// Array
// (
//     [0] => Olá
//     [1] =>  Am
//     [2] => igo
//     [3] => !
// )

chunk_split

A função chunk_split divide uma string em partes, mas diferente de explode ela o faz inserindo um delimitador entre as partes divididas.

  • Primeiro parâmetro: é a string a ser dividida;
  • Segundo parâmetro: define o número de caracteres em cada parte;
  • Terceiro parâmetro: especifica o delimitador a ser usado. Caso o delimitador não seja informado, o padrão será "\r\n".

A função retorna uma string inserido o delimitador entre as partes.

$txt = "Voce deveria programar em PHP";
echo chunk_split($txt, 4) . "\n";
// Saída:
// Voce
//  dev
// eria
//  pro
// gram
// ar e
// m PH
// P

$txt = "123456789";
echo chunk_split($txt, 3, ".") . "\n";
// 123.456.789.

addslashes

ChatGPT

A função addslashes adiciona o caractere de escape (\) antes de caracteres que precisam ser escapados em determinados contextos, como ', ", e \.

Muitas pessoas utilizam esta função para prevenir SQL Injection, mas a forma mais indicada para isso é utilizar prepared statments da api de acesso ao banco.

$txt = "Don't Panic!";
echo addslashes($txt) . "\n";
// Saída: Don\'t Panic!

stripslashes

A função stripslashes remove o caractere de escape \ dos caracteres que foram escapados na string. Por exemplo, as sequências \' e \" são transformadas em ' e ", respectivamente. Essa função é o oposto de addslashes.

$txt = "Don\'t Panic!";
echo stripslashes($txt) . "\n";
// Saída: Don't Panic!

htmlspecialchars

A função htmlspecialchars converte caracteres especiais em entidades HTML. Por exemplo, os caracteres <, >, " e & são convertidos para &lt;, &gt;, &quot; e &amp;, respectivamente. Além disso, a função aceita um segundo parâmetro, que é uma constante de flag para definir opções de conversão:

  • ENT_NOQUOTES: Não converte nenhum tipo de aspas.
  • ENT_COMPAT: Converte apenas aspas duplas, deixando aspas simples inalteradas.
  • ENT_QUOTES: Converte tanto aspas duplas quanto aspas simples.
$txt = '<a href="#">Clique aque</a> e conheça nossas <strong>Promoções</strong>';
echo htmlspecialchars($txt);
// Saída: &lt;a href=&quot;#&quot;&gt;Clique aque&lt;/a&gt; e conheça nossas &lt;strong&gt;Promoções&lt;/strong&gt;

echo htmlspecialchars("< > \" &", ENT_NOQUOTES) . "\n";
// Saída: &lt; &gt; " &amp;
// Note que o caractere de aspas duplas não foi convertido

html_entity_decode

A função html_entity_decode é o oposto de htmlspecialchars, convertendo entidades HTML de volta para seus respectivos caracteres. Por exemplo, &lt;, &gt;, &quot; e &amp; são transformados em <, >, " e &, respectivamente. Assim como htmlspecialchars, ela aceita um segundo parâmetro que define uma flag com as mesmas constantes.

$txt = "&lt;h1&gt;PHP&lt;/h1&gt;";
echo html_entity_decode($txt) . "\n";
// Saída: <h1>PHP</h1>

strip_tags

A função strip_tags remove as tags HTML de uma string, tornando o texto “limpo”. Opcionalmente, aceita um segundo parâmetro, que pode ser uma string ou um array com as tags que devem ser preservadas. Essa função é útil para processar entradas de usuários, como em campos de comentários, garantindo maior segurança e controle sobre o conteúdo.

$txt = '<a href="#">Um link perigoso</a> <strong>Atenção!</strong>';
echo strip_tags($txt) . "\n";
// Saída: Um link perigoso Atenção!

echo strip_tags($txt, ['strong']) . "\n";
// Saída: Um link perigoso <strong>Atenção!</strong>
// como foi passado a tag strong no array do segundo parâmetro ela não foi removida

nl2br

A função nl2br insere a tag <br> antes de cada quebra de linha (\n) em uma string, facilitando a exibição do texto em HTML com a formatação original de quebras de linha preservada.

$txt = "Uma\nFrase\nem\nmultiplas\nlinhas!";
echo nl2br($txt) . "\n";
// Saída: 
// Uma<br />
// Frase<br />
// em<br />
// multiplas<br />
// linhas!

str_pad

A função str_pad preenche uma string com outra string até alcançar um tamanho especificado.

  • O primeiro parâmetro é a string original a ser preenchida.
  • O segundo define o tamanho final desejado para a string.
  • O terceiro é a string usada para o preenchimento (opcional, sendo o padrão um espaço em branco).
  • O quarto é uma constante de flag opcional, que determina onde o preenchimento será adicionado:
    • STR_PAD_LEFT(padrão): Preenche à esquerda .
    • STR_PAD_RIGHT: Preenche à direita.
    • STR_PAD_BOTH: Distribui o preenchimento igualmente em ambos os lados.
$txt = "RODRIGO";
echo str_pad($txt, 10, "#") . "\n";
// Saída: RODRIGO###

echo str_pad($txt, 10, "_", STR_PAD_LEFT) . "\n";
// Saída: ___RODRIGO

echo str_pad($txt, 11, "_", STR_PAD_BOTH) . "\n";
// Saída: __RODRIGO__

similar_text

A função similar_text calcula a porcentagem de similaridade entre duas strings.

  • O primeiro e o segundo parâmetros são as strings a serem comparadas.
  • O terceiro parâmetro é uma variável que receberá a porcentagem de similaridade calculada.

A função retorna o número de caracteres correspondentes em ambas as strings.

Essa função é útil para medir o grau de correspondência entre dois textos.

$txt1 = "PHP é muito legal";
$txt2 = "PHP é muito bom";

 similar_text($txt1, $txt2, $porcentagem);

echo $porcentagem . "% similar\n";
// Saída: 76.470588235294% similar

str_word_count

A função str_word_count retorna informações sobre as palavras de uma string, podendo fornecer um número total ou um array, dependendo do formato especificado.

  • O primeiro parâmetro é a string a ser analisada.
  • O segundo parâmetro é um inteiro que define o formato do retorno:
    • 0 (padrão): Retorna o número total de palavras encontradas.
    • 1: Retorna um array contendo todas as palavras da string.
    • 2: Retorna um array associativo, onde as chaves representam as posições numéricas das palavras na string, e os valores são as palavras correspondentes.
$txt = "Uma frase com cinco palavras";
echo str_word_count($txt) . "\n";
// Saída: 5

print_r( str_word_count($txt, 1) );
// Saída: 
// Array
// (
//     [0] => Uma
//     [1] => frase
//     [2] => com
//     [3] => cinco
//     [4] => palavras
// )

print_r( str_word_count($txt, 2) );
//Saída: 
// Array
// (
//     [0] => Uma
//     [4] => frase
//     [10] => com
//     [14] => cinco
//     [20] => palavras
// )

urlencode

A função urlencode codifica uma string para o formato de uma URL, convertendo caracteres especiais em uma representação segura para transmissão em URLs.

$text = "programação PHP!";
echo urlencode($text) . "\n";
// Saída: programa%C3%A7%C3%A3o+PHP%21

parse_url

A função parse_url analisa uma URL e retorna um array associativo contendo seus componentes, como scheme, host, path, e query. Cada chave do array representa um componente da URL, e o valor associado é a informação correspondente extraída da URL fornecida.

$url = "https://www.example.com/path/file.php?param=value#fragment";
$components = parse_url($url);
print_r($components);
// Saída:
// Array
// (
//     [scheme] => https
//     [host] => www.example.com
//     [path] => /path/file.php
//     [query] => param=value
//     [fragment] => fragment
// )

parse_str

A função parse_str interpreta uma string como uma query string de URL e converte seus pares chave-valor em variáveis.

  • O primeiro parâmetro é a string a ser interpretada (no formato de query string).
  • O segundo parâmetro, é uma variável de array onde os pares chave-valor serão armazenados.
$query = "param1=value1&param2=value2";

parse_str($query, $variaveis);
print_r($variaveis);
// Saída: 
// Array
// (
//     [param1] => value1
//     [param2] => value2
// )

http_build_query

A função http_build_query gera uma query string para URL a partir de um array ou objeto fornecido. Cada chave e valor do array é convertido em pares no formato chave=valor, com os elementos separados por &.

$data = [
    'nome' => 'rodrigo',
    'sobrenome' => 'aramburu',
];

echo http_build_query($data) . "\n";
// Saída: nome=rodrigo&sobrenome=aramburu

chr

A função chr retorna o caractere correspondente ao código ASCII especificado. Recebe como parâmetro um número inteiro representando o código ASCII do caractere desejado.

echo chr(97) . "\n";
echo chr(98) . "\n";
echo chr(99) . "\n";

// Saída: 
a
b
c

ord

A função ord é o oposto de chr. Ela recebe um caractere como parâmetro e retorna o código numérico correspondente a esse caractere na tabela ASCII.

echo ord("a") . "\n";
echo ord("b") . "\n";
echo ord("c") . "\n";
//Saída:
// 97
// 98
// 99

str_increment

A função str_increment incrementa uma string alfanumérica, adicionando um valor incremental ao final dela. Disponível a partir do PHP 8.3

echo str_increment("a") . "\n";
// Saída: b

echo str_increment("b") . "\n";
// Saída: c

echo str_increment("c") . "\n";
// Saída: d

echo str_increment("Item1") . "\n";
// Saída: Item2

str_decrement

A função str_decrement é semelhante à função str_increment, mas em vez de incrementar, ela decrementa uma string alfanumérica, subtraindo um valor no final dela. Disponível a partir do PHP 8.3

echo str_decrement("aaa") . "\n";
// Saída: zz

echo str_decrement("aab") . "\n";
// Saída: aaa

echo str_decrement("aac") . "\n";
// Saída: aab

echo str_decrement("Item1") . "\n";
// Saída: Item0

Bom estas foram alguma funções de string do PHP que podem ser uteis no dia a dia ou podem economizar tempo e evitar a necessidade de reinventar soluções em casos especificos. Espero que sejam uteis.

T++