PHP Strings Curso

Curso de PHP – Strings Fábio M. Pereira
UNIVERSIDADE ESTADUAL DO SUDOESTE DA BAHIA – UESB
UNIDADE ORGANIZACIONAL DE INFORMÁTICA - UINFOR

Roteiro
•Uso de Aspas em Constantes String
•Impressão
•Acesso a Caracteres Individuais
•Limpeza
•Codificação e Utilização de Escapes
•Comparação
•Manipulação e Busca
•Expressões Regulares

Uso de Aspas em Constantes String
•Existem três maneiras de escrever uma string em um programa:
–Utilizando aspas simples
–Aspas duplas
–Formato heredoc derivado do shell do Unix
•Estes métodos diferem na maneira com que eles reconhecem sequências de escape que permite codificar outros caracteres ou interpolar variáveis

Interpolação de Variáveis
•Quando definimos uma literal string utilizando aspas duplas ou heredoc, uma string pode conter variáveis interpoladas
–Processo de substituição dos nomes pelos valores das variáveis em uma string
•Maneira 1:
$who = 'Kilroy';
$where = 'here';
echo "$who was $where";
Kilroy was here
•Maneira 2 (mais indicada):
$n = 12;
echo "You are the {$n}th person";
You are the 12th person

Interpolação de Variáveis
•Strings são processadas primeiro e o resultado armazenado
–Ou seja, não são processadas em tempo de execução
•Outro exemplo:
$bar = 'this is not printed';
$foo = '$bar'; // aspas simples
print("$foo");
$bar

Strings com Aspas Simples
•Strings com aspas simples não interpolam variáveis
•Exemplo:
$name = 'Fred';
$str = 'Hello, $name'; // aspas simples
echo $str;
Hello, $name
•As únicas sequências de escape que funcionam são ’, que coloca uma aspas simples na string, e , que coloca uma barra invertida
$name = 'Tim O'Reilly';// escape aspas simples
echo $name;
$path = 'C:WINDOWS'; // escape barra invertida
echo $path;
$nope = 'n'; // não é um escape
echo $nope;
Tim O'Reilly
C:WINDOWS
n

Strings com Aspas Duplas
•Strings com aspas duplas interpolam variáveis e expandem muitas sequências de escape PHP
•Qualquer sequência de escape diferente das contidas na tabela abaixo será ignorada por PHP

Strings com Aspas Duplas
•Strings com aspas duplas interpolam variáveis e expandem muitas sequências de escape PHP
•Qualquer sequência de escape diferente das contidas na tabela abaixo será ignorada por PHP
Sequêcia de Escape
Caractere representado
"
Aspas duplas
n
Nova linha
r
Retorno de carro
t
Tabulação

Barra invertida
$
Sinal $
{
Abre chaves
}
Fecha chaves
[
Abre colchetes
]
Fecha colchetes
0 até 777
Caractere ASCII representado por um valor octal
x0 até xFF
Caractere ASCII representado por um valor hexadecimal

Strings com Here Documents
•Permite a colocação fácil de múltiplas linhas de texto em um programa:
$clerihew = <<< FimDasAspas
Sir Humphrey Davy
Abominated gravy.
He lived in the odium
Of having discovered sodium.
FimDasAspas;
echo $clerihew;
Sir Humphrey Davy
Abominated gravy.
He lived in the odium
Of having discovered sodium.

•O token <<< identificador informa ao parser PHP que iremos escrever um heredoc
•Deve haver um espaço após o <<< e antes do identificador
•Podemos escolher o identificador que iremos utilizar
•A próxima linha inicia o texto limitado pelo heredoc, que continua até encontrar uma linha que não contenha nada além do identificador
•Em casos especiais, podemos colocar um ponto e vírgula após o identificador de término, para concluir a instrução, como no exemplo anterior
•Se estivermos usando o heredoc em uma expressão mais complexa, precisamos continuar a expressão na próxima linha:

•O token <<< identificador informa ao parser PHP que iremos escrever um heredoc
•Deve haver um espaço após o <<< e antes do identificador
•Podemos escolher o identificador que iremos utilizar
•A próxima linha inicia o texto limitado pelo heredoc, que continua até encontrar uma linha que não contenha nada além do identificador
•Em casos especiais, podemos colocar um ponto e vírgula após o identificador de término, para concluir a instrução, como no exemplo anterior
•Se estivermos usando o heredoc em uma expressão mais complexa, precisamos continuar a expressão na próxima linha:
printf(<<< Template
%s is %d years old.
Template
, "Fred", 35);

•Aspas simples ou duplas são ignoradas em um heredoc:
$dialogue = <<< NoMore
"It's not going to happen!" she fumed.
He raised an eyebrow. "Want to bet?"
NoMore;
echo $dialogue;
"It's not going to happen!" she fumed.
He raised an eyebrow. "Want to bet?"

Impressão de Strings
•Existem quatro maneiras de enviar saída para o navegador:
–O construtor echo – permite a impressão de vários valores de uma só vez
–A função print() – imprime apenas um valor
–A função printf() – constrói uma string formatada pela inserção de valores dentro de um modelo
–A função print_r() – útil para correção de erros pois imprime o conteúdo de arrays, objetos e outros de uma forma mais legível para humanos

echo
•Utilizada para colocar uma string em uma página HTML
•Embora pareça e na maioria das vezes se comporte como uma função, echo é um construtor da linguagem
–Permite que possamos omitir os parênteses, então as seguintes instruções são equivalentes:
echo "Printy";
echo("Printy"); // também é válida
•Podemos especificar múltiplos itens para impressão separando-os com vírgula:
echo "First", "second", "third";
Firstsecondthird
•Ocorrerá um erro caso utilizemos parênteses com múltiplos valores:
// este é um erro
echo("Hello", "world");

echo
•Considerando que echo não é uma função de verdade, não podemos usá-la como parte de uma expressão maior:
// erro
if (echo("test")) {
echo("It worked!");
}
•Nestes casos podemos utilizar as funções print() ou printf()

print()
•Envia um valor (o seu argumento) para o navegador:
if (print("test")) {
print("It worked!");
}
It worked!

printf()
•Tem como saída uma string através da substituição de valores dentro de um modelo
–Derivada da função de mesmo nome do C
•O primeiro argumento de printf() é a string de formatação
•Os argumentos restantes são os valores a serem substituídos
•Um caractere % na string de formatação indica uma substituição

Modificadores de Formato
•Cada marcador de substituição (%) pode ser seguido por modificadores da lista e terminar com um especificador de tipo
•Os modificadores devem aparecer na ordem em que eles são listados aqui:
–Um especificador de preenchimento denotando o caractere a ser utilizado para preencher os resultados de um tamanho apropriado – especifique 0, espaço (o padrão) ou qualquer outro caractere
–Um sinal, com efeito diferente em strings e números – em strings, um menos (-) força o alinhamento à esquerda (o padrão é alinhamento à direita); em números, um mais (+) força números positivos serem impressos com o sinal (ex. 25 seria impresso como +25)

Modificadores de Formato
•Modificadores (cont.):
–A quantidade mínima de caracteres que este elemento deve conter – se o resultado for menor que este número de caracteres, os especificadores de sinal e preenchimento irão governar como preencher este espaço
–Para números de ponto flutuante, um especificador de precisão consistindo de um ponto e um número – indica quantos dígitos decimais serão mostrados (para outros tipos, este especificador será ignorado)

Especificadores de Tipo
•Indica ao printf() qual tipo de dado está sendo substituído
•Determina a interpretação dos modificadores listados anteriormente
Especificador
Significado
%
Mostra o caractere %
b
O argumento é um inteiro e será mostrado como um número binário
c
O argumento é um inteiro e será mostrado como o caractere com aquele valor
d
O argumento é um inteiro e será mostrado como um número decimal
e
O argumento é um double e será mostrado em notação científica
E
O argumento é um double e será mostrado em notação científica utilizando letras maiúsculas

Especificadores de Tipo
Especificador
Significado
f
O argumento é um float e será mostrado como tal, utilizando a formatação (locale) atual
F
O argumento é um float e será mostrado como tal
g
O argumento é um double e será mostrado tanto em notação científica (como no especificador %e) como um float (como no especificador %f), o que for mais curto
G
O argumento é um double e será mostrado tanto em notação científica (como no especificador %E) como um float (como no especificador %f), o que for mais curto
o
O argumento é um inteiro e será mostrado como um número octal
s
O argumento é uma string e será mostrado como tal
u
O argumento é um inteiro sem tipo e será mostrado como um número decimal
x
O argumento é um inteiro e será mostrado como um número hexadecimal, letras minúsculas serão utilizadas
X
O argumento é um inteiro e será mostrado como um número hexadecimal, letras maiúsculas serão utilizadas

Exemplos
printf('%.2f', 27.452);
27.45
printf('The hex value of %d is %x', 214, 214);
The hex value of 214 is d6
printf('Bond. James Bond. %03d.', 7);
Bond. James Bond. 007.
printf('%02d/%02d/%04d', $month, $day, $year);
02/15/2005
printf('%.2f%% Complete', 2.1);
2.10% Complete
printf('You've spent $%5.2f so far', 4.1);
You've spent $ 4.10 so far

sprintf()
•A função sprintf() recebe os mesmos argumentos que printf(), mas retorna o construtor da string em vez de imprimi-la
•Isto permite a atribuição da string a uma variável antes de utilizá-la:
$date = sprintf("%02d/%02d/%04d", $month, $day,
$year);
// agora podemos interpolar $date
// em qualquer lugar que precisemos da data

print_r() e var_dump()
•O construtor print_r() mostra de maneira inteligente o que for passado a ele, convertendo tudo para uma string
•Strings e números são simplesmente impressos
•Arrays aparecem como listas entre parênteses de chaves e valores:
$a = array('name' => 'Fred', 'age' => 35, 'wife' =>
'Wilma');
print_r($a);
Array
(
[name] => Fred
[age] => 35
[wife] => Wilma)

•Objetos:
class P {
var $name = 'nat';
// ...
}
$p = new P;
print_r($p);
Object
(
[name] => nat)
•Booleanos e NULL:
print_r(true); // imprime "1";
1
print_r(false); // imprime "";
print_r(null); // imprime "";

•Para correção de erros, var_dump() é melhor que print_r()
•var_dump() mostra qualquer valor PHP em um formato mais legível:

•Para correção de erros, var_dump() é melhor que print_r()
•var_dump() mostra qualquer valor PHP em um formato mais legível:
var_dump(true);
var_dump(false);
var_dump(null);
var_dump(array('name' => "Fred", 'age' => 35));
class P {
var $name = 'Nat';
// ...
}
$p = new P;
var_dump($p);
bool(true)
bool(false)
bool(null)
array(2) {
["name"]=>
string(4) "Fred"
["age"]=>
int(35)
}
object(p)(1) {
["name"]=>
string(3) "Nat"
}

•Tenha cuidado ao utilizar estas funções em uma estrutura recursiva como em $GLOBALS
–A função print_r() entra em laço infinito
–Enquanto var_dump() realizar um corte após visitar o mesmo elemento por três vezes

STRINGS Acesso a Caracteres Individuais

Acesso a Caracteres Individuais
•A função strlen() retorna a quantidade de caracteres em uma string:
$string = 'Hello, world';
$length = strlen($string); // $length é 12
•Podemos acessar caracteres individuais através da sintaxe:
$string = 'Hello';
for ($i=0; $i < strlen($string); $i++) {
printf("The %dth character is %sn", $i,
$string{$i});
}
The 0th character is H
The 1th character is e
The 2th character is l
The 3th character is l
The 4th character is o

Limpeza de Strings
•Frequentemente, quando pegamos strings a partir de arquivos ou entradas dos usuários precisamos limpá-las antes de utilizá-las
•Dois problemas comuns com esses tipos de dados são a presença de espaços em branco extras e capitalização incorreta (maiúsculas x minúsculas)

Removendo Espaços em Branco
•Podemos remover espaços com as funções:
–trim() – retorna uma cópia da string com espaços removidos do início e do fim
–ltrim() – faz o mesmo, mas remove espaços apenas do início da string
–rtrim() – remove espaços apenas do fim da string
•Sintaxe:
$trimmed = trim(string [, charlist ]);
$trimmed = ltrim(string [, charlist ]);
$trimmed = rtrim(string [, charlist ]);
•O argumento charlist opcional é uma string que especifica todos os caracteres a remover

Removendo Espaços em Branco
•Podemos remover espaços com as funções:
–trim() – retorna uma cópia da string com espaços removidos do início e do fim
–ltrim() – faz o mesmo, mas remove espaços apenas do início da string
–rtrim() – remove espaços apenas do fim da string
•Sintaxe:
$trimmed = trim(string [, charlist ]);
$trimmed = ltrim(string [, charlist ]);
$trimmed = rtrim(string [, charlist ]);
•O argumento charlist opcional é uma string que especifica todos os caracteres a remover
Caractere
Significado
“ “
Espaço
“t”
Tab
“n”
Nova linha
“r”
Retorno de carro
“0”
NULL
“x0B”
Tabulação vertical

Exemplos
$title = " Programming PHP n";
$str1 = ltrim($title);
// $str1 é "Programming PHP n"
$str2 = rtrim($title);
// $str2 é " Programming PHP"
$str3 = trim($title);
// $str3 é "Programming PHP“
$record = " FredtFlintstonet35tWilmat n";
$record = trim($record, " rn0x0B");
// $record is "FredtFlintstonet35tWilma"

Modificando a Caixa
•PHP possui várias funções para modificar a caixa de strings:
–strtolower() e strtoupper() – operam em toda a string
–ucfirst() – opera apenas no primeiro caractere da string
–ucwords() – opera apenas no primeiro caractere de cada palavra da string
–Cada função recebe uma string para modificar como argumento e retorna uma cópia da string, devidamente modificada

Modificando a Caixa
•PHP possui várias funções para modificar a caixa de strings:
–strtolower() e strtoupper() – operam em toda a string
–ucfirst() – opera apenas no primeiro caractere da string
–ucwords() – opera apenas no primeiro caractere de cada palavra da string
–Cada função recebe uma string para modificar como argumento e retorna uma cópia da string, devidamente modificada
$string1 = "FRED flintstone";
$string2 = "barney rubble";
print(strtolower($string1));
print(strtoupper($string1));
print(ucfirst($string2));
print(ucwords($string2));
fred flintstone
FRED FLINTSTONE
Barney rubble
Barney Rubble

STRINGS Codificação e Utilização de Escapes

Codificação e Utilização de Escapes
•Pelo fato de programas PHP frequentemente interagirem com páginas HTML, endereços web (URLs) e bancos de dados, existem funções que ajudam a trabalhar com esses tipos de dados
–Todos são strings, mas eles requerem diferentes caracteres de escape para serem usados de diferentes maneiras
–Por exemplo, um espaço em um endereço web deve ser escrito como %20, enquanto um literal menor que (<) em um documento HTML deve ser escrito como <
•PHP possui várias funções para conversão dessas codificações

HTML
•Caracteres especiais em HTML são representados por entidades como em & e <
•Existem duas funções PHP que transformam caracteres em uma string dessas entidades: uma para remover marcadores (tags) HTML e outra para extrair apenas meta tags
•htmlentities() modifica todos os caracteres com entidades HTML em seus equivalentes (com exceção do espaço)
•strip_tags() remove todos os marcadores HTML de uma string

HTML
•get_meta_tags() retorna um array contendo os meta tags de uma página HTML, dado um nome de arquivo local ou URL
–O nome da meta tag (keywords, author, description, etc.) se torna a chave do array e o seu conteúdo o valor correspondente
$metaTags =
get_meta_tags('http://www.example.com/');
echo "Web page made by {$metaTags['author']}";
Web page made by John Doe

URL
•PHP fornece funções para converter para e de codificação URL
•rawurlencode() e rawurldecode() – converte URLs no formato RFC 3986 (p.ex. espaços são tratados como %20)
•Exemplos:
$name = "Programming PHP";
$output = rawurlencode($name);
echo "http://localhost/{$output}";
http://localhost/Programming%20PHP
$encoded = 'Programming%20PHP'; echo rawurldecode($encoded); Programming PHP

URL
•urlencode() e urldecode() – diferem apenas por codificar espaços como um sinal de mais (+) em vez da sequência %20
–Este é o formato utilizado para criar strings de consulta e valores de cookie
$baseUrl = 'http://www.google.com/q=';
$query = 'PHP sessions -cookies';
$url = $baseUrl . urlencode($query);
echo $url;
http://www.google.com/q=PHP+sessions+-cookies

SQL
•O sistema de codificação em SQL é bem simples:
–Aspas simples, aspas duplas, bytes NUL e barras invertidas precisam ser precedidos por uma barra invertida
•A função addslashes() adiciona essas barras e a função stripslashes() as remove:
$string = <<< EOF
"It's never going to work," she cried,
as she hit the backslash () key.
EOF;
$string = addslashes($string);
echo $string;
echo stripslashes($string);

Comparação Exata
•Podemos utilizar os operadores:
–== – converte operandos não string para string, dessa forma, 3 e “3” são iguais
–=== – não converte, retornando false caso os tipos dos argumentos sejam diferentes
$o1 = 3;
$o2 = "3";
if ($o1 == $o2) {
echo("== returns true ");
}
if ($o1 === $o2) {
echo("=== returns true ");
}
== returns true

Comparação Exata
•Os operadores de comparação (<, <=, >, >=) também podem ser usados em strings:
$him = "Fred";
$her = "Wilma";
if ($him < $her) {
print "{$him} comes before {$her} in the
alphabet.n";
}
Fred comes before Wilma in the alphabet

Comparação Exata
•Entretanto, operadores de comparação podem dar resultados inesperados quando comparamos uma string com um número
$string = "PHP Rocks";
$number = 5;
if ($string < $number) {
echo("{$string} < {$number}");
}
PHP Rocks < 5
•PHP tenta converter a string “PHP Rocks” para um número, resultando em 0, que é menor que 5
•Para comparar duas strings, convertendo números para strings, quando necessário, utilize a função strcmp()

strcmp()
•Sintaxe:
$relationship = strcmp(string_1, string_2);
•A função retornará um número menor que 0, se a ordem de string_1 for anterior à de string_2
•Maior que zero se a ordem de string_2 for anterior à de string_1
•Ou 0 se forem iguais
$n = strcmp("PHP Rocks", 5);
echo($n);
1
•strcasecmp() converte strings para minúsculas antes de compará-las:
$n = strcasecmp("Fred", "frED"); // $n é 0

strncmp() e strncasecmp()
•strncmp() e strncasecmp() comparam apenas os caracteres iniciais das strings
–Recebem um argumento adicional que é o número de caracteres iniciais a usar para a comparação
$relationship = strncmp(string_1, string_2, len);
$relationship = strncasecmp(string_1, string_2,
len);

strnatcmp() e strnatcasecmp()
•strnatcmp() e strnatcasecmp() realizam comparação em ordem natural
–Identifica pares numéricas das strings comparadas e ordena a parte textual separadamente da parte numérica
Ordem natural
Ordem ASCII
pic1.jpg
pic5.jpg
pic10.jpg
pic50.jpg
pic1.jpg
pic10.jpg
pic5.jpg
pic50.jpg

Igualdade Aproximada
•PHP fornece várias funções para verificação de igualdade aproximada entre strings:
$soundexCode = soundex($string);
$metaphoneCode = metaphone($string);
$inCommon = similar_text($string_1, $string_2 [,
$percentage ]);
$similarity = levenshtein($string_1, $string_2);
$similarity = levenshtein($string_1, $string_2 [,
$cost_ins, $cost_rep, $cost_del ]);

Soundex e Metaphone
$soundexCode = soundex($string);
$metaphoneCode = metaphone($string);
•Os algoritmos Soundex e Metaphone produzem uma string que representa aproximadamente como uma palavra é pronunciada em Inglês
–Para ver se duas strings são aproximadamente iguais com estes algoritmos, compare suas pronúncias
–Podemos comparar valores Soundex apenas com valores Soundex, e valores Metaphone apenas com valores Metaphone
–Geralmente o algoritmo Metaphone é mais preciso

Soundex e Metaphone
$known = "Fred";
$query = "Phred";
if (soundex($known) == soundex($query)) {
print "soundex: {$known} sounds like {$query} ";
}
else {
print "soundex: {$known} doesn't sound like {$query} ";
}
if (metaphone($known) == metaphone($query)) {
print "metaphone: {$known} sounds like {$query} ";
}
else {
print "metaphone: {$known} doesn't sound like {$query} ";
}
soundex: Fred doesn't sound like Phred
metaphone: Fred sounds like Phred

similar_text()
$inCommon = similar_text($string_1, $string_2 [,
$percentage ]);
•Retorna o número de caracteres que os dois agumentos string têm em comum
•O terceiro argumento, se presente, é uma variável na qual será armazenado a similaridade em percentual
$string1 = "Rasmus Lerdorf";
$string2 = "Razmus Lehrdorf";
$common = similar_text($string1, $string2,
$percent);
printf("They have %d chars in common (%.2f%%).",
$common, $percent);
They have 13 chars in common (89.66%).

Algoritmo de Levenshtein
$similarity = levenshtein($string_1, $string_2);
$similarity = levenshtein($string_1, $string_2 [,
$cost_ins, $cost_rep, $cost_del ]);
•O algoritmo de Levenshtein calcula a similaridade de duas strings baseada em quantos caracteres devem ser adicionados, substituídos ou removidos para torná-las iguais
–Por exemplo, “cat” e “cot” têm uma distância de Levenshtein de 1, porque precisamos modificar apenas um caractere para torná-las iguais
$similarity = levenshtein("cat", "cot");
// $similarity é 1

Algoritmo de Levenshtein
•Opcionalmente podemos passar três valores para a função individualmente atribuir pesos para inserções, exclusões e substituições, por exemplo
–Por exemplo, a comparação a seguir atribui valor excessivo à inserções, uma vez que em uma contração nunca inserimos caracteres:
echo levenshtein('would not', 'wouldn't', 500,
1, 1);

Manipulação e Busca
•As funções mais comunas para manipulação e buscas em strings são aquelas que utilizam expressões regulares para descrever a string em questão
•Aqui são listadas as funções que não utilizam expressões regulares
–Elas são mais rápidas que expressões regulares
–Mas funcionam apenas quando estamos buscando por uma string fixa (por exemplo, buscar por “12/11/01” em vez de qualquer número separados por barras)

Substrings
•Função substr():
$piece = substr(string, start [, length ]);
–start – posição inicial do texto a ser removido, 0 é o primeiro caractere
–length – número de caracteres a serem copiados (o padrão é copiar até o final da string)
$name = "Fred Flintstone";
$fluff = substr($name, 6, 4); // $fluff é "lint"
$sound = substr($name, 11); // $sound é "tone“

Substrings
•Para saber quantas vezes uma string ocorre em uma maior, utilize sbstr_count():
$number = substr_count(big_string, small_string);
•Exemplo:
$sketch = <<< EndOfSketch
Well, there's egg and bacon; egg sausage and bacon; egg and spam;
egg bacon and spam; egg bacon sausage and spam; spam bacon sausage
and spam; spam egg spam spam bacon and spam; spam sausage spam spam
bacon spam tomato and spam;
EndOfSketch;
$count = substr_count($sketch, "spam");
print("The word spam occurs {$count} times.");
The word spam occurs 14 times.

Substrings
•A função substr_replace() permite vários tipos de modificações em uma string:
$string = substr_replace(original, new, start [,
length ]);
•A função substitui a parte de original indicada pelos valores de start e length pela string new
–Se o valor de length não for fornecido, removerá o texto a partir de start até o final da string
•Exemplo:
$greeting = "good morning citizen";
$farewell = substr_replace($greeting, "bye", 5, 7);
// $farewell é "good bye citizen"
•Use um tamanho de 0 para inserir o texto sem exclusão:
$farewell = substr_replace($farewell, "kind ", 9, 0);
// $farewell é "good bye kind citizen"

Substrings
•Use uma substituição por “” para exclusão sem inserção:
$farewell = substr_replace($farewell, "", 8);
// $farewell é "good bye"
•Como inserir um texto no um texto no início da string:
$farewell = substr_replace($farewell,
"now it's time to say ", 0, 0);
// $farewell é "now it's time to say good bye"'
•Um valor negativo para start indica o número de caracteres a partir do final da string onde iniciará a substituição
$farewell = substr_replace($farewell, "riddance", −3);
// $farewell é "now it's time to say good riddance"
•Um valor negativo de length indica o número de caracteres a partir do final da string para terminar a exclusão
$farewell = substr_replace($farewell, "", −8, −5);
// $farewell é "now it's time to say good dance"

Funções Diversas
•Função strrev()
–Recebe uma string e retorna uma cópia invertida da mesma
echo strrev("There is no cabal");
labac on si erehT
•Função str_repeat()
–Recebe uma string e um número e retorna uma nova string consistindo do argumento repetido a quantidade determinada de vezes
echo str_repeat('_.-.', 40);

Funções Diversas
•Função str_pad()
–Preenche uma string com outra, opcionalmente podemos informar a string de preenchimento (padrão = espaço) e o local (direita, esquerda ou ambos)
–Sintaxe:
$padded = str_pad(to_pad, length [, with [,
pad_type ]]);
–Exemplos:
$string = str_pad('Fred Flintstone', 30);
echo "{$string}:35:Wilma";
Fred Flintstone :35:Wilma

Funções Diversas
–Sintaxe:
pad_type ]]);
–Exemplos:
$string = str_pad('Fred Flintstone', 30);
echo "{$string}:35:Wilma";
Fred Flintstone :35:Wilma
$string = str_pad('Fred Flintstone', 30, '. ');
echo "{$string}35";
Fred Flintstone. . . . . . . .35

Funções Diversas
–Sintaxe:
pad_type ]]);
–Exemplos:
$string = str_pad('Fred Flintstone', 30); echo "{$string}:35:Wilma"; Fred Flintstone :35:Wilma
$string = str_pad('Fred Flintstone', 30, '. ');
echo "{$string}35";
Fred Flintstone. . . . . . . .35
echo '[' . str_pad('Fred Flintstone', 30, ' ', STR_PAD_LEFT) . "]n";
echo '[' . str_pad('Fred Flintstone', 30, ' ', STR_PAD_BOTH) . "]n";
[ Fred Flintstone]
[ Fred Flintstone ]

Decompondo uma String
•PHP fornece várias funções para quebrar uma string em componentes menores
•Em ordem crescente de complexidade, elas são explode(), strtok(), sscanf()

Explodindo e Implodindo
•Dados geralmente chegam como strings, que devemos dividir em um array de valores
–Por exemplo, podemos querer encontrar campos separados por vírgula como em “Fred,25,Wilma”
–Nesta situação utilizamos a função explode()
$array = explode(separator, string [, limit]);
•O primeiro argumento, separator, é uma string contendo o separador de campos
•O segundo argumento, string, é a string a ser dividida
•O terceiro argumento opcional, limit, é o número máximo de valores a serem retornados no array
–Se o limite é alcançado, o último elemento do array contém o restante da string

•Dados geralmente chegam como strings, que devemos dividir em um array de valores
–Por exemplo, podemos querer encontrar campos separados por vírgula como em “Fred,25,Wilma”
–Nesta situação utilizamos a função explode()
$array = explode(separator, string [, limit]);
•O primeiro argumento, separator, é uma string contendo o separador de campos
•O segundo argumento, string, é a string a ser dividida
•O terceiro argumento opcional, limit, é o número máximo de valores a serem retornados no array
–Se o limite é alcançado, o último elemento do array contém o restante da string
$input = 'Fred,25,Wilma';
$fields = explode(',', $input);
// $fields é array('Fred', '25', 'Wilma')
$fields = explode(',', $input, 2);
// $fields é array('Fred', '25,Wilma')

•A função implode() não faz exatamente o oposto de explode() – ela cria uma string maior a partir de um array de strings menores
$string = implode(separator, array);
•O primeiro argumento, separator, é a string a ser colocada entre os elementos do segundo argumento, array
•A função join() é um apelido para implode()
•Exemplo:
$fields = array('Fred', '25', 'Wilma');
$string = implode(',', $fields); // $string is 'Fred,25,Wilma'

Tokens
•A função strtok() permite a iteração através de uma string, pegando uma remessa por vez (token)
•Exemplo:
$firstChunk = strtok(string, separator);
•Para recuperar os tokens restantes, chame repetidamente strtok() com apenas o separador:
$nextChunk = strtok(separator);
–A função retornará false quando não existirem mais tokens
•Chame strtok() com dois argumentos para reinicializar a iteração
•Exemplo:

Tokens
•A função strtok() permite a iteração através de uma string, pegando uma remessa por vez (token)
•Exemplo:
$firstChunk = strtok(string, separator);
•Para recuperar os tokens restantes, chame repetidamente strtok() com apenas o separador:
$nextChunk = strtok(separator);
–A função retornará false quando não existirem mais tokens
•Chame strtok() com dois argumentos para reinicializar a iteração
•Exemplo:
$string = "Fred,Flintstone,35,Wilma"; $token = strtok($string, ","); while ($token !== false) { echo("{$token} "); $token = strtok(","); } Fred Flintstone 35 Wilma

sscanf()
•Decompõe uma string de acordo com o padrão printf()
$array = sscanf(string, template);
$count = sscanf(string, template, var1, ... );
•Se utilizada sem as variáveis opcionais, sscanf() retorna um array de campos:
$string = "FredtFlintstone (35)";
$a = sscanf($string, "%st%s (%d)");
print_r($a);
Array
(
[0] => Fred
[1] => Flintstone
[2] => 35
)

sscanf()
•Passe variáveis por referência para ter os valores dos campos armazenados
–Será retornado o número de campos atribuídos
$string = "FredtFlintstone (35)";
$n = sscanf($string, "%st%s (%d)", $first, $last,
$age);
echo "Matched {$n} fields: {$first} {$last} is {$age} years old";
Matched 3 fields: Fred Flintstone is 35 years old

Funções de Busca em Strings
•Existem várias funções para buscar uma string ou caractere em uma string maior
•Elas se dividem em três famílias:
–strpos() e strrpos(), que retornam uma posição
–strstr() e strchr(), e outras, que retornam a string de busca
–strspn() e strcspn(), que retornam quanto do início da string correspondem a uma máscara
•Em todas elas, se especificarmos um valor numérico como string de busca, PHP tratará este número como o valor ordinal do caractere a ser procurado
–Estas funções são idênticas pois o código ASCII da vírgula é 44:
$pos = strpos($large, ","); // busca uma vírgula
$pos = strpos($large, 44); // também busca vírgula

Funções de Busca em Strings
•Todas as funções de busca em strings retornarão false se não encontrarem a substring especificada
•Se a substring ocorre no início da string, retornará 0
•Como false é convertido para o número 0, sempre compare o valor retornado com === quando testando por falha:
if ($pos === false) {
// não encontrado
}
else {
// encontrado, $pos é a posição
}

Buscas que Retornam a Posição
•A função strpos() encontra a primeira ocorrência de uma string em outra:
$position = strpos(large_string, small_string);
•Se não encontrada, strpos() retorna false
•A função strrpos() retorna a última ocorrência
–Ela recebe os mesmos argumentos e retorna o mesmo tipo de valor que strpos()
•Exemplo:
$record = "Fred,Flintstone,35,Wilma";
$pos = strrpos($record, ","); // busca última vírgula
echo("The last comma in the record is at pos {$pos}");
The last comma in the record is at pos 18

Buscas que Retornam Restante da String
•A função strstr() encontra a primeira ocorrência da string e retorna o restante da string a partir desta ocorrência
$record = "Fred,Flintstone,35,Wilma";
$rest = strstr($record, ",");
// $rest é ",Flintstone,35,Wilma“
•Variações de strstr():
–stristr(): não sensível à caixa
–strchr(): apelido para strstr()
–strrchr(): encontra a última ocorrência do caractere na string
•Assim como strrpos(), strrchr() busca na string de trás para frente, mas apenas por um único caractere

Buscas Usando Máscaras
•As funções strspn() e strcspn() informa quantos caracteres do início de uma string são compostos de certos caracteres:
$length = strspn(string, charset);
•O exemplo a seguir testa se uma string possui um número octal:
function isOctal($str)
{
return strspn($str, '01234567') == strlen($str);
}
•O c em strcspn() vem de complemento – ela informa quantos caracteres do início da string não são compostas dos caracteres no conjunto
–Utilize-a quando o número de caracteres que importam é maior que o número de caracteres que não são interessantes
•No exemplo a seguir, a função testa se a string possui qualquer caractere NUL-byte, tabulação ou CR:

Buscas Usando Máscaras
•As funções strspn() e strcspn() informa quantos caracteres do início de uma string são compostos de certos caracteres:
$length = strspn(string, charset);
•O exemplo a seguir testa se uma string possui um número octal:
function isOctal($str)
{
return strspn($str, '01234567') == strlen($str);
}
•O c em strcspn() vem de complemento – ela informa quantos caracteres do início da string não são compostas dos caracteres no conjunto
–Utilize-a quando o número de caracteres que importam é maior que o número de caracteres que não são interessantes
•No exemplo a seguir, a função testa se a string possui qualquer caractere NUL-byte, tabulação ou CR:
function hasBadChars($str)
{
return strcspn($str, "nt0") != strlen($str);
}

Decompondo URLs
•A função parse_url() retorna um array de componentes de uma URL:
$array = parse_url(url);
•Exemplo:
$bits = parse_url("http://me:secret@example.com/cgi-
bin/board?user=fred");
print_r($bits);
Array
(
[scheme] => http
[host] => example.com
[user] => me
[pass] => secret
[path] => /cgi-bin/board
[query] => user=fred)

Expressões Regulares
•Uma expressão regular é uma string que representa um padrão que é comparado a uma outra string, então é feita a verificação se o padrão é compatível ou modificações na string são realizadas
•Existem três usos para expressões regulares:
–Comparação, que também pode ser utilizada para extração de informação de uma string
–Substituição de novo texto pelo texto compatível
–Divisão da string em um array ou em strings menores
–PHP tem funções para todos os casos

O Básico
•A maioria dos caracteres em uma expressão regular são caracteres literais, isso significa que eles só são compatíveis com eles mesmos
•Por exemplo, se buscarmos pela expressão regular “cow” na string “Dave was a cowhand”, haverá uma combinação porque “cow” ocorre na string
•Alguns caracteres têm significado especial em um ER
–Por exemplo, um circunflexo (^) no início de uma ER indica que ela deve combinar com o início da string:
preg_match("/^cow/", "Dave was a cowhand");
// retorna false
preg_match("/^cow/", "cowabunga!"); // retorna true

O Básico
•De maneira similar, um sinal de cifrão ($) no final de uma ER significa que ela deve combinar com o final da string:
preg_match("/cow$/", "Dave was a cowhand");
// returns false
preg_match("/cow$/", "Don't have a cow");
// returns true
•Um ponto (.) em uma ER combina com um único caractere qualquer:
preg_match("/c.t/", "cat"); // returns true
preg_match("/c.t/", "cut"); // returns true
preg_match("/c.t/", "c t"); // returns true
preg_match("/c.t/", "bat"); // returns false
preg_match("/c.t/", "ct"); // returns false

O Básico
•Se quisermos combinar qualquer desses caracteres especiais (chamados de meta-caracteres), devemos utilizar a barra invertida:
preg_match("/$5.00", "Your bill is $5.00 exactly");
// returns true
preg_match("/$5.00", "Your bill is $5.00 exactly");
// returns false
•O poder real das ERs vem da habilidade de podermos especificar padrões abstratos que podem combinar com diferentes sequências de caracteres

Classes de Caracteres
•Para especificar um conjunto de caracteres aceitáveis no padrão, podemos construir uma classe de caracteres ou utilizar uma previamente definida
•Podemos construir nossa própria classe colocando os caracteres aceitáveis entre colchetes
•Exemplo – busca por um ‘c’ seguido por uma vogal e então por um ‘t’:
preg_match("/c[aeiou]t/", "I cut my hand"); // true
preg_match("/c[aeiou]t/", "This crusty cat"); // true
preg_match("/c[aeiou]t/", "What cart?"); // false
preg_match("/c[aeiou]t/", "14ct gold"); // false

Classes de Caracteres
•Podemos “negar” uma classe de caracteres com um circunflexo (^) no início:
preg_match("/c[âeiou]t/", "I cut my hand"); // false
preg_match("/c[âeiou]t/", "Reboot chthon"); // true
preg_match("/c[âeiou]t/", "14ct gold"); // false
•Podemos definir uma faixa de caracteres com um hífen (-):
preg_match("/[0-9]%/", "we are 25% complete"); // true
preg_match("/[0123456789]%/", "we are 25% complete");
// true
preg_match("/[a-z]t/", "11th"); // false
preg_match("/[a-z]t/", "cat"); // true
preg_match("/[a-z]t/", "PIT"); // false
preg_match("/[a-zA-Z]!/", "11!"); // false
preg_match("/[a-zA-Z]!/", "stop!"); // true

Alternativas
•A barra vertical (|) pode ser utilizada para especificar caracteres alternativos em uma ER:
preg_match("/cat|dog/", "the cat rubbed my legs");
// true
preg_match("/cat|dog/", "the dog rubbed my legs");
// true
preg_match("/cat|dog/", "the rabbit rubbed my legs");
// false
•Outros exemplos:
–"/^cat|dog$/" – uma linha que inicia com “cat” ou termina com “dog”
–"/^(cat|dog)$/" – uma linha que contém apenas “cat” ou “dog”

Alternativas
•Uma linha que não inicie com letras maiúsculas:
preg_match("/^([a-z]|[0-9])/", "The quick brown fox");
// false
preg_match("/^([a-z]|[0-9])/", "jumped over"); // true
preg_match("/^([a-z]|[0-9])/", "10 lazy dogs"); // true

Repetindo Sequências
•Para repetir um padrão devemos utilizar um quantificador
•O quantificador aparece depois do padrão que será repetido e indica quantas vezes deverá ocorrer
•Quantificadores PHP:
Quantificador
Significado
?
0 ou 1
*
0 ou mais
+
1 ou mais
{n}
Exatamente n vezes
{n, m}
Pelo menos n, não mais que m vezes
{n,}
Pelo menos n vezes

Repetindo Sequências
•Exemplos:
preg_match("/ca+t/", "caaaaaaat"); // true
preg_match("/ca+t/", "ct"); // false
preg_match("/ca?t/", "caaaaaaat"); // false
preg_match("/ca*t/", "ct"); // true
•Validando um número de telefone:
preg_match("/[0-9]{3}-[0-9]{3}-[0-9]{4}/",
"303-555-1212"); // true
preg_match("/[0-9]{3}-[0-9]{3}-[0-9]{4}/",
"64-9-555-1234"); // false

Outros Tópicos em ERs
•Subpadrões
•Delimitadores
•Âncoras
•Corte
•Funções
•...

PHP Strings Curso

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a PHP Strings Curso

Semelhante a PHP Strings Curso (20)

Mais de Fabio Moura Pereira

Mais de Fabio Moura Pereira (12)

PHP Strings Curso