PHP - Strings

Curso da Linguagem de Programação PHP da disciplina Desenvolvimento de Sistemas Web da Universidade Estadual do Sudoeste da Bahia - UESB.

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

2. 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

3. STRINGS
Uso de Aspas

4. 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

5. 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

6. 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

7. 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

8. 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

9. 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

10. 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.

11. Strings com Here Documents
•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:

12. Strings com Here Documents
•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);

13. Strings com Here Documents
•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?"

14. STRINGS
Impressão

15. 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

16. 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");

17. 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()

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

It worked!

19. 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

20. 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)

21. 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)

22. 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

23. 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

24. 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

25. 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

26. 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)

27. print_r() e var_dump()
•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 "";

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

29. print_r() e var_dump()
•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"
}

30. print_r() e var_dump()
•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

31. STRINGS
Acesso a Caracteres Individuais

32. 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 %s\n", $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

33. STRINGS
Limpeza

34. 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)

35. 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

36. 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

37. 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 = " Fred\tFlintstone\t35\tWilma\t \n";
$record = trim($record, " \r\n\0\x0B");
// $record is "Fred\tFlintstone\t35\tWilma"

38. 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

39. 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

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

41. 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 &lt;
•PHP possui várias funções para conversão dessas
codificações

42. HTML
•Caracteres especiais em HTML são representados por
entidades como em &amp; e &lt;
•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

43. 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

44. 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

45. 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

46. 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);

\"It\'s never going to work, \" she cried,
as she hit the backslash (\\) key.
"It's never going to work," she cried,
as she hit the backslash (\) key.

47. STRINGS
Comparação

48. 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<br>");
}
if ($o1 === $o2) {
echo("=== returns true<br>");
}

== returns true

49. 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

50. 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()

51. 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

52. 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);

53. 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

54. 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 ]);

55. 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

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

soundex: Fred doesn't sound like Phred
metaphone: Fred sounds like Phred

57. 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%).

58. 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

59. 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);

60. STRINGS
Manipulação e Busca

61. 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)

62. 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“

63. 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.

64. 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"

65. 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"

66. 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);

67. 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

68. 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
$string = str_pad('Fred Flintstone', 30, '. ');
echo "{$string}35";

Fred Flintstone. . . . . . . .35

69. 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
$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 ]

70. 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()

71. 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

72. 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
$input = 'Fred,25,Wilma';
$fields = explode(',', $input);
// $fields é array('Fred', '25', 'Wilma')
$fields = explode(',', $input, 2);
// $fields é array('Fred', '25,Wilma')

73. Explodindo e Implodindo
•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'

74. 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:

75. 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}<br />");
$token = strtok(",");
}

Fred
Flintstone
35
Wilma

76. 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 = "Fred\tFlintstone (35)";
$a = sscanf($string, "%s\t%s (%d)");
print_r($a);

Array
(
[0] => Fred
[1] => Flintstone
[2] => 35
)

77. sscanf()
•Passe variáveis por referência para ter os valores dos
campos armazenados
–Será retornado o número de campos atribuídos

$string = "Fred\tFlintstone (35)";
$n = sscanf($string, "%s\t%s (%d)", $first, $last,
$age);
echo "Matched {$n} fields: {$first} {$last} is
{$age} years old";

Matched 3 fields: Fred Flintstone is 35 years old

78. 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

79. 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
}

80. 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

81. 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

82. 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:

83. 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, "\n\t\0") != strlen($str);
}

84. 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:[email protected]/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)

85. STRINGS
Expressões Regulares

86. 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

87. 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

88. 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

89. 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

90. 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

91. Classes de Caracteres
•Podemos “negar” uma classe de caracteres com um
circunflexo (^) no início:
preg_match("/c[^aeiou]t/", "I cut my hand"); // false
preg_match("/c[^aeiou]t/", "Reboot chthon"); // true
preg_match("/c[^aeiou]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

92. 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”

93. 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

94. 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

95. 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

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

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

98. Baseado em...