PHP
Daniela Araújo
Copyright © 2009. Daniela Araújo. Todos os direitos reservados.
[email protected] / [email protected]












Introdução
Instalação e configuração
Programação em Web
Var, constantes, tipos de dados, ...
Instruções
Funções
Arrays
Manipulação de Strings
PHP e BD SQL
Autenticação
Programação Orientada a Objeto
Mail
Introdução a PHP
O que é PHP



Linguagem com larga possibilidade de
utilização tradicionalmente usada para
desenvolvimento Web: armazena e consulta
BD, processa pedidos dos usuários, cria
documentos com informações apropriadas,
interage com os servidores...
Opera do lado servidor
Funciona dentro de um documento HTML
para gerar instruções específicas
O que é PHP





Simplicidade
Forma fácil de usar o BD – conectividade com
vários bancos
Independência de plataforma
Sistema de processamento de scripts bem
otimizado, para respostas rápidas
Pode escolher entre utilizar programação
estrutural ou programação orientada a
objeto, ou ainda uma mistura deles.
Módulos/Ferramentas






Conectividade com BD (MySQL, Oracle,
Informix, PostgreSQL, Sybase, ..., ou
qualquer que suporte ODBC)
XML (separa conteúdo de apresentação)
IMAP e SMTP são suportados
PDF e PostScript usando API
SNMP (instalar biblioteca)
...
Plataformas


Unix – Apache (como módulo) e demais
servidores Web
NT – IIS, PWS, Omni, Xitami, Apache
Referências






http://www.php.net
http://www.apache.org
http://www.mysql.com
Tutoriais - http://www.phpbuilder.com e
http://www.webtutoriais.com/categorias.php?
categoria=php
Aplicativo de carrinho de compras –
http://www.fni.com/fcsql/
Repositório – http://px.sklar.com
CGI - Common Gateway
Interface




Foi a mais comum das tecnologias Web do
lado do servidor. Pode ser escrito em
praticamente qualquer linguagem, a mais
popular é Perl.
Os servidores Web que implementam CGI
funcionam como meio de comunicação entre
a requisição do usuário e os dados
solicitados.
Sempre que uma requisição é recebida pelo
servidor Web, um novo processo por inteiro é
criado.
http://hoohoo.ncsa.uiuc.edu/cgi/interface.html
CGI
Servidor Web
CGI

Processo 1
Processo 2
Processo 3
Var. ambiente
Var. ambiente
Var. ambiente
Programa
Programa
Programa
E quando um grande número de solicitações é
recebido simultaneamente? Os recursos seriam
fortemente exigidos, podendo travar o servidor.
Interpretador CGI x Módulo
Apache


Melhor desempenho que CGI, alguns recursos só disponíveis
como módulo e maior segurança.
CGI, mais difícil travar o servidor Web, usuários diferentes
executam scripts (Apache-nobody).
PHP configurado como um interpretador CGI
Servidor
Web
Módulo
PHP
PHP compilado como um módulo Apache
Servidor
Web
Módulo
PHP
Processamento 2
Processamento 1
Processamento 1
O que acontece com as
páginas PHP
Obtém a página
<html>
<?php codigo PHP ?>
</html>
Requisição HTTP
Interpreta o código
Resposta do servidor
O navegador
cria a página
<html>
<b>Bom dia, Lucas.</b>
</html>
O que o sistema PHP pode
fazer e o que HTML não pode?







Como o servidor Web lida com as páginas?
HTML puro é interpretado pelo navegador,
mas não é executada pelo servidor.
Facilitar a edição do conteúdo, usando BD
Personalizar páginas para cada usuário
Exibir e atualizar BD, desenvolvendo
aplicações
Obter dados dos usuários e retornar
informações para o mesmo conforme a
entrada.
Além de muito mais ...
Instalação e configuração
Instalação e configuração


Orientações para instalação do Servidor Web
Apache, com PHP e módulo MySQL:
Existem pacotes com scripts prontos para
instalação de todas estas ferramentas, alguns
exemplos em:


http://www.hotscripts.com/PHP/Software_and_Ser
vers/Installation_Kits/
Pacotes: XAMPP, WAMP, PHPTriad,...
Servidor Web - Apache





Instale o servidor Web. Usamos o Apache.
Download em http://www.apache.org  HTTTP
Server (http://httpd.apache.org/)
Escolha uma das versões, por exemplo 2, clique
em download
Escolha Win32 Binary (MSI Installer), observe a
versão desejada. (Ex: apache_2.0.8-win32-x86no_ssl.msi)
Execute o arquivo. Coloque o domínio, o nome
da máquina, e-mail do administrador, para quem
(para todos, na porta 80, como serviço), instalação
típica, no diretório indicado.
PHP




Instale o PHP (http://www.php.net) 
downloads Windows Binaries  PHP 5.2.9
installer
Veja a documentação  Instalação em
sistemas Windows  Apache 2.0.x no Microsoft
Windows.
Instalando como um módulo do Apache
Insira estas linhas no arquivo Apache
Group\Apache\conf\httpd.conf
Continua...
PHP
PHP e Apache 2.0 como Módulo
 # Para o PHP 5 faça algo assim:
LoadModule php5_module "c:/php/php5apache2.dll"
AddType application/x-httpd-php .php
 # configure o caminho para o arquivo php.ini
PHPIniDir "C:/php"

Instalação e configuração

TODOS OS ARQUIVOS WEB DEVEM
FICAR NO DIRETÓRIO HTDOCS DO
APACHE (versão do Windows) ou no
diretório correspondente.
Instalação e configuração

Como fazer para a página padrão ser
index.php?



Configure o arquivo Apache
Group\Apache\conf\httpd.conf
DirectoryIndex index.php index.html
index.htm
Após tudo configurado:

Reinicie o servidor Web.
Programação em Web
Como escrever uma página
PHP

PHP escrevendo texto simples.
<html>
<?php
echo (“Texto gerado pelo PHP”);
?>
</html>
Como escrever uma página
PHP
PHP escrevendo HTML
<html>
<?php
echo (“Texto gerado pelo<B>PHP</B>”);
?>
</html>

PHP e o código do lado do
cliente
PHP escrevendo HTML com JavaScript
<html>
<?php
echo (“<script
language=‘JavaScript’>alert(‘Texto gerado
pelo PHP’);</script>”);
?>
</html>

Primeira página
Crie um novo arquivo chamado primeira.php e coloque-o em
seu diretório root do seu servidor web com o seguinte
conteúdo:
<html>
<body>
<?php
echo (“Olá, bem vindo!”);
?>
</body>
</html>

Use o seu navegador para acessar o arquivo pelo endereço de
seu servidor web, ao final do endereço coloque o arquivo
"/primeira.php“ ex: http://localhost/primeira.php

Primeira página

Neste exemplo nós usamos <?php para
indicar que à partir daquele ponto começa
um código PHP. Então nós colocamos uma
declaração de fechamento para indicar que o
script PHP acabou, usando a tag ?>. Você
pode usar o PHP em qualquer parte do seu
código HTML, e também pode usar várias
tags de abertura e fechamento no mesmo
arquivo.
Phpinfo()
Crie um novo arquivo chamado info.php e coloque-o em seu
diretório root do seu servidor web com o seguinte conteúdo:
<html>
<body>
<?php
phpinfo();
?>
</body>
</html>

Verá todas as informações sobre seu sistema e configurações
disponíveis como a de variáveis pré-definidas e módulos
carregados pelo PHP.

Variáveis
<?php
$nome = “”;
echo ($nome);
?>
Processamento de dados de
formulário

Get (URL)






Padrão
? separa a localização dos dados
chave=valor
& separa pares chave=valor
+ substitui espaço
Post (corpo)

Mais dados podem ser passados
Processamento de dados de
formulário

Get (URL)


Post (corpo)


$_GET[‘nomedoelemento’]
$_POST[‘nomedoelemento’]
Get, Post ou Cookies

$_REQUEST[‘nomedoelemento’]
Processamento de dados de
formulário
1º arquivo, com formulário que chama a ação:
<html>
<body>
<form action=processeform.php method=post>
Digite o seu nome:<br>
<input type=text name=nome><br><br>
<input type=submit value=“Enviar”>
</form>
</body>
</html>
formulario.php

Processamento de dados de
formulário
2º arquivo, a ação, que processa os
dados recebidos (enviados, neste caso, pelo
formulário):
<html>
<?php echo(“Bem vindo, “ . $_POST[‘nome’] .
“!”); ?>
</html>
processeform.php

Processamento de dados de
formulário

Identifique o método usado através da
variável $_SERVER['REQUEST_METHOD'] :
<?php
switch($_SERVER['REQUEST_METHOD'])
{
case 'GET': $metodo = &$_GET; break;
case 'POST': $metodo = &$_POST;break;
default: ...
}
?>
Processamento de dados de
formulário

Variáveis externas não são mais
registradas no escopo global por
padrão. Em outras palavras, com o PHP
» 4.2.0 a diretiva register_globals está
desligada por padrão no arquivo
php.ini. O método utilizado atualmente
é o de acessar estes valores via arrays
auto-globais.
Como comentar código


// e # em uma linha de código,
comentando o resto da linha
/* e */ múltiplas linhas
OBS:
<!-- e --> são comentários HTML!!

<?php ... ?>


Para escrever grandes blocos de texto, sair do modo
de interpretação do PHP é geralmente mais eficiente
do que enviar todo o texto através de echo() ou
print(). Ex:
<?php
if ($expressao) {
?>
<b>Isto é verdadeiro.</b>
<?php
} else {
?>
<b>Isto é falso.</b>
<?php
}
?>
Var, constantes, tipos de
dados, ...
Var, constantes e tipos de
dados

Tipos de dados





integer, double/float, string e boolean
Array, object
NULL
Identificadores diferenciam maiúsculas e
minúsculas (funções internas e estruturas não
diferenciam)
A variável é considerada null se:



ela foi assimilada com a constante NULL.
ela ainda não recebeu nenhum valor ainda.
ela foi apagada com unset().
Constantes
define(“amarelo”, “#FFFF00”);
define(“version”, 3);
Certo
echo(“Amarelo hexa é” . amarelo);
 Errado
echo(“Amarelo hexa é amarelo”);

Variáveis

O tipo de uma variável geralmente não
é definido pelo programador: isto é
decidido em tempo de execução pelo
PHP, dependendo do contexto no qual a
variável é usada.
Variáveis
Conversões de variáveis
$a = 1; // é inteiro
$a = 1.2; // agora é um double
$a = “1”; // agora é uma string

Variáveis
Type casting
$a = 11.2;
// double
$a = (int) $a; // integer 11
$a = (double) $a; // double 11.0
$a = (string) $a;
// string “11”

Variáveis

Formulários HTML não passam inteiros,
floats ou booleans, eles passam strings.
Para descobrir se uma string é
numérica, você pode usar is_numeric().
Variáveis



Convertendo para boolean
(bool) 1
Quando convertendo para booleano, os seguintes
valores são considerados FALSE:







o próprio booleano FALSE
o inteiro 0 (zero)
o ponto flutuante 0.0 (zero)
uma string vazia e a string "0"
um array sem elementos
o tipo especial NULL (incluindo variáveis não definidas)
É considerado TRUE qualquer valor não zero,
negativo ou positivo.
Variáveis


Strings
Não é problema para uma string ser
bastante longa. PHP não impõe limite
de tamanho de uma string; o único
limite é o de memória disponível do
computador no qual o PHP está sendo
executado.
Variáveis pré-definidas















Superglobais — Superglobais são variáveis nativas que estão sempre
disponíveis em todos escopos
$GLOBALS — Referencia todas variáveis disponíveis no escopo global
$_SERVER — Informação do servidor e ambiente de execução
$_GET — HTTP GET variáveis
$_POST — HTTP POST variables
$_FILES — HTTP File Upload variáveis
$_REQUEST — Variáveis de requisição HTTP
$_SESSION — Variáveis de sessão
$_ENV — Environment variables
$_COOKIE — HTTP Cookies
$php_errormsg — A mensagem de erro anterior
$HTTP_RAW_POST_DATA — Informação não-tratada do POST
$http_response_header — Cabeçalhos de resposta HTTP
$argc — O número de argumentos passados para o script
$argv — Array de argumentos passados para o script
Funções úteis para variáveis





gettype(var) – Informa o tipo de dados de
uma variável (integer, double, string, array,
object, class, unknown type)
settype(var, tipo) – Especifica explicitamente
o tipo de uma variável
unset() – para destruir uma variável da
memória
isset() – para saber se uma variável já
recebeu um valor
empty() – para saber se uma variável foi
especificada, ou valor zero ou string vazia.
Operadores (alguns)

Aritméticos


Atribuição



==, <, >, <=, >=, !=, <>
=== (se iguais e se são do mesmo tipo)
Lógicos


$x = 1;
Comparação


+, -, *, /, %
&&, and, ||, or, xor, !
Mais detalhes
Supressão de erro
(complemento)


O operador @ é usado para suprimir a
informação de erros oriundos de
funções internas.
print (5/0)



Warning: Division by zero in ...arquivo.php
on line 2.
@print (5/0) ou
print @(5/0)
Supressão de erro
(complemento)


Se o recurso track_errors estiver habilitado, qualquer
mensagem de erro gerada pela expressão será
gravada na variável $php_errormsg. Esta variável
será sobrescrita em cada erro, verifique-a
constantemente.
O operador @ funciona somente em expressões.
Uma regra simples para lembrar disso: se você pode
pegar o valor de alguma coisa, você pode prefixar
isso com o @. Assim, você pode prefixar chamadas
de variáveis, funções e include()s, constantes e afins.
Você não pode prefixar definições de funções ou
classe, estruturas condicionais como o if, foreach e
assim por diante.
Operadores de
incremento/decremento

Pré-incremento: ++$a


Pós-incremento: $a++


Retorna $a, e então incrementa $a em um.
Pré-decremento: --$a


Incrementa $a em um, e então retorna $a.
Decrementa $a em um, e então retorna $a.
Pós-decremento: $a–

Retorna $a, e então decrementa $a em um.
Concatenação de strings


Ponto (.)
Iguais:



echo($dia . “/” . $mes . “/” . $ano);
echo(“$dia / $mes / $ano”);
Uso:

$data = $dia . “/” . $mes . “/” . $ano;
Concatenação de strings
Ponto (.)
 Operador de atribuição de
concatenação ('.=')
<?php
$a = "Olá ";
$a .= "mundo!"; // $a contém "Olá mundo!"
?>

Inclusão de arquivos
Include – avalia e executa código do
arquivo externo (ou require)
<?php
include(“db_config.php”);
Tempo de
execução
?>

Este arquivo pode conter códigos em HTML,
PHP, JavaScritp...
Inclusão de arquivos


Include_once (ou require_once): seu comportamento
é similar a instrução include(), a não ser que o
arquivo informado já tenha sido incluído, não
refazendo a operação novamente. Como o nome
sugere, ele será incluído apenas uma vez.
include_once() pode ser utilizado nos casos em
que o mesmo arquivo pode acabar sendo incluído
mais de uma vez durante a execução de um script
em particular, quando na verdade ele só pode ser
incluído apenas uma para evitar problemas com
redefinições de funções, alterações nos valores de
variáveis, etc.
Instruções
If
if (condição) {
//comandos;
}
else {
//comandos;
}
ou
if (condição) {
//comandos;
}
elseif [else if]
(condição) {
//comandos;
}
else {
//comandos;
}
If
if ($pais == “ca”):
echo (“Canada”);
elseif ($pais == “de”):
echo (“Alemanha”);
else:
// tem que ser “us”
echo (“Estados Unidos”);
endif;
If
<?php if ($pais == “ca”): ?>
<h1>Canada</h1>
<?php elseif ($pais == “de”): ?>
<h1>Alemanha</h1>
<?php else: ?>
<h1>Estados Unidos</h1>
<?php endif; ?>
Switch
switch ($pais) {
case “ca”:
echo (“Canada”);
break;
case “de”:
echo (“Alemanha”);
break;
default:
echo (“Estados Unidos”);
}
While
while (condição) {
//instruções;
}
Ou
while (expressao):
instrucoes ...
endwhile;
do ... while
o loop irá executar pelo menos uma
vez.
do {
// instrução
} while (condição);

For
for (expr1; expr2; expr3){
instrucoes
}



A primeira expressão (expr1) é executada uma vez
incondicionalmente no começo do loop.
No começo de cada iteração, expr2 é avaliada. Se ela
é avaliada como TRUE, o loop continua e os
comandos aninhados são executados. Se é avaliada
como FALSE, a execução do 'loop' termina.
No fim de cada iteração, expr3 é executada.
For
for ($i = 1; $i < 11 ; ++$i) {
echo (“$i <BR> \n”); // escreve de 1 a 10
}
for ($i = 1; my_function($i) !=“error” ; ++$i) {
// fazer algo com $i até retornar um erro.
}
Sair de uma página PHP

Exit – para toda a execução e sai da mesma.
Não escreve mais o documento, mesmo em
HTML, JS ou PHP.
if (my_function($i) == “error”) {
echo(“<BR><b>Ocorreu um erro</b>\n” .
“Nao e possivel terminar de carregar o
documento.<br>\n”);
exit;
}
Funções
Funções

O PHP reserva todos os nomes de
funções começando com __ , portanto é
recomendável que você não utilize
nome de funções começando com __
no PHP.
Funções
function cube($num) {
return $num * $num * $num;
}
Valor retornado pela função
....
echo (cube(6)); // escreve 216
Funções - valor
function print_double($n) {
$n = $n * 2;
echo ($n);
}
$a = 5;
echo (“$a <br>\n”);
print_double($a);
echo($a);
// 5
// 10
// 5
Argumentos por valor
Variável do parâmetro
dentro da função recebe uma
cópia do valor que lhe é
passado.
Se o valor mudar, não afetará
o valor da variável na
instrução chamada.
Funções - referência
function raise(&$salary, $percent) {
$salary += $salary * $percent/100;
Argumentos por referência
}
As mudanças na variável do
parâmetro alteram a variável
da instrução chamadora.
$sal = 5000;
echo (“Antes do aumento $sal<br>\n”); //
5000
raise($sal, 4);
echo (“Depois do aumento $sal<br>\n”); //
5200
Funções – referência cuidados
function raise(&$salary, $percent) {
$salary += $salary * $percent/100;
}
Argumento por referência tem que
ser uma variável. Não um literal,
nem uma constante.
$sal = 5000;
echo (“Antes do aumento $sal<br>\n”); // 5000
raise(5000, 4); // ERRO!! Não pode passar argumento por ref.
echo (“Depois do aumento $sal<br>\n”); // 5200
Funções - padrão
function novalinha($l=1) {
//escreve <BR> $l vezes
for ($i = 0; $i < $l; ++$i){
echo(“<BR>\n”);
}
}
Argumento opcional
echo(“linha 1”);
novalinha(); //escreve <BR> uma vez
echo(“linha 1”);
novalinha(2); //escreve <BR> duas vezes
Funções – ordem do padrão
function raise ($percent = 4, &$salary) {
$salary += $salary * $percent/100;
ERRO
}
Interpreta $sal(ou $percent) como
sendo o primeiro parâmetro recebido.
Argumentos opcionais devem
ficar no final.
$sal = 5000;
echo (“Antes do aumento $sal<br>\n”); //
5000
raise($sal);
echo (“Depois do aumento $sal<br>\n”); //
5200
Abrangência
O escopo de uma variável determina que
partes do programa tem acesso a ela.
global, acessada e alterada por
$posicao = “m”; Alcance
qualquer código no script que esteja dentro

de uma função.
function change_pos(){
$posicao = “b”; Alcance local, é uma variável diferente
de $posicao que aparece fora da função.
}
change_pos();
echo (“$posicao”);
// escreve “m”
Abrangência
Instrução global
$posicao = “m”;
function change_pos(){
global posicao; Para acessar uma variável
Global de dentro de uma função
$posicao = “b”;
}
change_pos();
echo (“$posicao”);
// escreve “b”

Tempo de vida
Quando queremos que uma variável local de
uma função retenha seu valor entre uma
chamada da função e outra.
function contador(){
static $conte = 0; // na 1ª será criada e inicializada
++$conte;
}
 Se o usuário recarregar a página a variável
reinicializa de novo.

Arrays
Arrays


Cada elemento de um mesmo array
pode se de qualquer tipo de dado,
independente dos outros elementos.
Default: índice 0.
$paises[0] $paises[1] $paises[2] $paises[3] $paises[4]
“ca”
“us”
“fr”
“it”
“br”
Inicialização de arrays
$paises[]=“ca”;
$paises[]=“us”;
$paises[]=“fr”;
$paises[0]=“ca”;
$paises[1]=“us”;
$paises[2]=“fr”;
Iguais, se nenhum
outro elemento já
tiver sido colocado
no array
Inicialização de arrays
$paises[50]=“ca”;
$paises[20]=“us”;
$paises[10]=“fr”;
$paises[]=“br”; // índice igual a 51
echo (“$paises[20]”); // escreve us
echo (count ($paises)); // escreve 4
Inicialização de arrays
Construtor array
$paises = array (“ca”, “us”, “fr”);
 Operador de índice específico =>
$paises = array(1 => “ca”, “us”, “fr”);
ou
$paises = array( “ca”, 7 => “us”, “fr”);

Arrays indexados
sequencialmentes
$paises = array (“ca”, “us”, “fr”);
$num_elements = count ($paises);
for ($i = 0; $i < $num_elements; ++$i){
echo (“$paises[$i] <BR>\n”);
}
Arrays indexados não
sequencialmente
$paises[50]=“ca”;
O elemento atual o primeiro,
$paises[20]=“us”;
pois o array acaba de ser criado
$paises[10]=“fr”;
$paises[]=“br”; // índice 51
$key = key ($paises);
// 50
$value = current ($paises); // ca
echo (“Elemento $key igual a $value”);
Algumas funções
reset ($paises); // Aponta p/ o 1º elemento
while (list ($indice, $valor) = each
($paises)) {
echo (“Element $key igual a $value
<BR>\n”);
}
/* para cada chave do array faça $key igual a chave do
elemento e $value igual ao valor do elemento. A
função each avança o ponteiro do array cada vez que
é chamada. */
Algumas funções
foreach (expressao_array as $valor)
instrucoes
 varre uma dada matriz dada por
expressao_array. Em cada 'loop', o
valor do elemento corrente é atribuído
a $valor e o ponteiro interno da matriz
é avançado em uma posição (assim, no
próxima iteração você estará olhando
para o próximo elemento)
Algumas funções

next() e prev(), move o cursor para o
próximo ou o anterior e recebe o valor
do array como retorno.
Algumas funções
array_walk(), percorre um array e
aplica uma função para cada membro.
function println($s) {
echo (“$s<BR>\n”);
}
$paises = array (“ca”, “us”, “fr”, “it”);
array_walk ($paises, println);

Arrays indexados com string
$paises[“ca”]=“Canada”;
$paises[“us”]=“Estados Unidos”;
$paises[“fr”]=“Franca”;
echo (“$paises[“ca”]”); //Canada
Funções de classificação







sort(); ordena o array pelo valor e altera os
índice para acompanhar a ordem. Troca
índices string por numéricos!!!
asort(); semelhante ao sort() mas não perde
o índice de string, somente o ordena.
rsort(); sort() de ordem reversa.
arsort(), asort() de ordem reversa.
ksort(), ordena pelo índice e não pelo valor.
krsort(), ksort() de ordem reversa.
unsort(), reorganiza os elementos ao acaso.
Funções de classificação
range(x, y); cria um array com o
escopo dos índices passados como
parâmetros.
cria um array de 1 a 100:
$paises = range(1, 100)

Manipulação de Strings
Funções básicas de string





substr()
string substr (string origem, int começo, int
[comprimento]);
retorna uma parte de uma string e recebe
três argumentos.
Começo, é por onde começa a retornar a
string, onde a primeira posição é zero. Se
negativo, contará de trás para frente.
Se o comprimento for negativo, a string
terminará com esse número de caracteres
contados a partir do final.
Funções básicas de string




echo
echo
echo
echo
(substr(“Daniela”,
(substr(“Daniela”,
(substr(“Daniela”,
(substr(“Daniela”,
4)); // ela
2, 3)); // nie
-3, -1)); // el
0, -1)); //Daniel
D
A
N
I
E
L
A
0
1
2
3
4
5
6
Funções básicas de string


str_replace ( mixed
$search , mixed $replace ,
mixed $subject [, int &$count ]
)
string
Esta função retorna uma string ou um
array com todas as ocorrências de
search em subject substituidas com a o
valor dado para replace .
Funções básicas de string
<?php
// Devolve: Hll Wrld f PHP
$vowels = array("a", "e", "i", "o", "u", "A", "E", "I", "O", "U");
$onlyconsonants = str_replace($vowels, "", "Hello World of PHP");
// Devolve: você comeria pizza, cerveja e sorvete todos os dias
$frase = "você comeria frutas, vegetais, e fibra todos os dias.";
$saudavel = array("frutas", "vegetais", "fibra");
$saboroso = array("pizza", "cerveja", "sorvete");
$novafrase = str_replace($saudavel, $saboroso, $frase);
?>
// Uso do parâmetro count está disponível no PHP 5.0.0
$str = str_replace("ll", "", "good golly miss molly!", $count);
echo $count; // 2
Funções básicas de string




string strstr ( string $entrada , mixed $procurada [,
bool $before_needle ] )
Retorna parte da string entrada a partir da primeira
ocorrência de produrada até o final de entrada.
Esta função diferencia maiúsculas e minúsculas. Para
pesquisas que não diferenciem, use stristr().
Se você quer somente determinar se um específica
procurada existe em entrada , use a função mais
rápida e que usa menos memória ao invés, strpos().
Funções básicas de string

<?php
$email = '[email protected]';
$domain = strstr($email, '@');
echo $domain; // mostra @example.com.br
$user = strstr($email, '@', true); // A partir d
o PHP 5.3.0
echo $user; // mostra name
?>
Funções básicas de string
trim() – elimina os caracteres de
espaços em branco (espaços, tab,
novas linhas) do início e do final.
echo (trim(“ Exemplo trim
”));
// exibirá ‘Exemplo trim’
 ltrim() – elimina brancos no inicio
 chop() – elimina brancos no final

Funções básicas de string
chr() – recebe um inteiro que
representa um código ASCII e retorna o
caractere correspondente.
echo (chr(34)); // exibirá o sinal aspas ”
 strlen() – retorna o número de
caracteres de uma string.

PHP e BD SQL
PHP e BD SQL


Com um BD na retaguarda do site, o
site atingirá um nível mais avançado de
complexidade e flexibilidade.
3 níveis



Cliente Web
Servidor Web
Servidor de BD
Insert com MySQL
mysql_connect(“localhost”, “usuario", “senha”) or die(“Falha na
conexão”);
mysql_select_db(“nomebanco”) or die(“Falha ao selecionar o
banco”);
$sql = “Insert into clientes (nome, endereco, telefone) values (‘$nome’,
‘$endereco’, ‘$tel’);
$resultado = mysql_query($sql);
// Para testar se falhou:
if (!$resultado){
die("Problema na gravação!");
}
else {
echo("Gravado com sucesso!");
}
Update com MySQL
mysql_connect(“localhost”, “usuario", “senha”) or die(“Falha na
conexão”);
mysql_select_db(“nomebanco”) or die(“Falha ao selecionar o
banco”);
$sql = “Update clientes set nome=‘$nome’, telefone=‘$tel’ where
cod=$codigo”;
$resultado = mysql_query($sql);
// Para testar se falhou:
if (!$resultado){
die("Problema na alteração!");
}
else {
echo(“Alterado com sucesso!");
}
Delete com MySQL
mysql_connect(“localhost”, “usuario", “senha”) or die(“Falha na
conexão”);
mysql_select_db(“nomebanco”) or die(“Falha ao selecionar o
banco”);
$sql = “Delete from clientes where cod=$codigo”;
$resultado = mysql_query($sql);
// Para testar se falhou:
if (!$resultado){
die("Problema na exclusão!");
}
else {
echo(“Excluído com sucesso!");
}
Select com MySQL
mysql_connect(“localhost”, “usuario", “senha”) or die(“Falha na
conexão”);
mysql_select_db(“nomebanco”) or die(“Falha ao selecionar o
banco”);
$sql = “SELECT * from clientes”;
$resultado = mysql_query($sql);
for($i = 0; $i < mysql_num_rows($resultado); $i++){
$registro = mysql_fetch_row($resultado); ?>
<tr>
<td>Nome<?php echo($registro[1]); ?></td>
<td>Telefone<?php echo($registro[3]); ?></td>
</tr>
<?
} ?>
Comandos phpMySql

Conexão



int mysql_connect (string
[nomehost[:porta][:/caminho_soquete]], string
[nomedousuario], string [senha]);
$link = mysql_connect ($host, $user, $password);
Conexão persistente



Link identificador, ou 0 (falso)
mysql_pconnect(($host, $user, $password)
Cria uma conexão persistente, deve ser usada em
aplicações PHP onde, por um período de tempo
curto é feito um grande nº de conexões com o
servidor MySQL usando o mesmo usuário e senha.
Fecha a conexão

mysql_close()
Comandos phpMySql

Seleciona um BD como ativo



Envia SQL para execução no servidor



int mysql_select_db(string nome_bd, int
[link_identificador]);
mysql_select_db($database);
int mysql_query(string consulta, int
[link_identificador]);
$result = mysql_query($query);
Retorna o nº de erro da última operação, e a
mensagem


int mysql_errno(int [link_identificador]);
string mysql_error(int [link_identificador]);
Comandos phpMySql

O número de campos em um resultado



O nome de um campo em um BD



int mysql_num_fields(int identificador_resultado);
$i < mysql_num_fields($result)
string mysql_field_name(int identificador, int
indice_campo);
echo(mysql_field_name($result, $i));
Retorna o número de linhas do resultado do
SQL


int mysql_num_rows(int indentificador_resultado);
$i < myslq_num_rows($db_table)
Comandos phpMySql

Armazena a linha como um array e move o
ponteiro



array mysql_fetch_row(int identificador_resultado);
$registro = mysql_fetch_row($result);
Obtém uma linha como uma matriz
associativa, uma matriz numérica, ou ambas
e move o ponteiro


array mysql_fetch_array ( resource $result [,
int $result_type ] )
$registro = mysql_fetch_array($result);
Outros comandos phpMySql

mysql_insert_id()


Obtém o ID gerado pela operação INSERT
anterior (para auto_increment)
mysql_affected_rows($link_identifier)

Obtém o número de linhas atingidas pela
consulta INSERT, UPDATE, REPLACE ou
DELETE mais recente associada ao
link_identifier
Outros comandos phpMySql

mysql_create_db($novobanco)


mysql_drop_db($nomebanco)


Exclui um banco de dados
mysql_list_tables($nomebanco)


Cria um novo banco de dados
Lista o nome de todas as tabelas de um BD
mysql_list_dbs($link)

Nomes dos bancos de dados disponíveis
Autenticação
Tela de login
<form name="autentica" action=“logar.php">
Login<input name="login" type="text" size="10"
maxlength="10">
Senha<input name="senha" type="password" size="10"
maxlength="10">
<input name="ok" type="image" src="img/botao_ok.gif"
width="19" height="19" border="0">
</form>
Logar.php
<?php
$login=$_POST[‘login’];
$senha=$_POST[‘senha’];
mysql_connect(“localhost”, “usuariodb",
“senhadb”);
mysql_select_db(“nomebanco”);
$sql = "SELECT * FROM login WHERE login =
'$login' AND senha = '$senha';";
$resultado = mysql_query("$sql");
$contagem = mysql_num_rows($resultado);
Logar.php
if ( $contagem != 1 )
{
header("Location: sempermissao.php");
} else {
$registro = mysql_fetch_row($resultado);
//criando uma sessão
session_start();
$_SESSION[‘autentica’] = $registro[0];
header("Location: compermissao.php");
} ?>
Sempermissao.php
<html>
<head>
</head>
<body>
<?php
echo ("Sem permissão de acesso!");
?>
</body>
</html>
Compermissao.php
<?php
//sempre coloque session_start(); NA PRIMEIRA LINHA DE QUALQUER
PAGINA
session_start();
if (!isset($_SESSION[‘autentica’]))
{
include("sempermissao.php");
}
else {
?>
<HTML>
...
</HTML>
<?php
} //fecha else
?>
Logoff
<?php
// Destruindo uma sessão. Voltando para
a página de autenticação
session_start();
session_destroy();
header("Location: index.php");
?>
Programação Orientada a
Objeto (complemento)
Programação Orientada a
Objeto


Mesmo sem todos os recursos da POO
(Programação Orientada a Objetos)
implementados no PHP 4, muitas bibliotecas
de código e grandes aplicações (incluindo a
biblioteca PEAR) são escritas somente em
código POO. O PHP 5 corrige as fraquezas da
POO do PHP 4, e introduz um modelo de
objetos completo.
No PHP 5 há um novo Modelo de Objeto. O
tratamento de objetos do PHP foi
completamente reescrito, permitindo uma
melhor performance e mais vantagens.
Programação Orientada a
Objeto




Permite usar um código comum em
diversos scripts
Classe é um modelo de um objeto.
Propriedade e métodos, descrevem um
objeto e o que ele é capaz de fazer.
Os objetos criados por um modelo de
classe são denominados INSTÂNCIAS.
Definindo um classe
<?php
class NomeDaClasse
{
/* definição da classe aparece aqui e inclui
as propriedades e métodos desta classe.*/
}
?>
Definindo um classe
<?php
class CarrinhoDeCompras {
var $items; // Itens do carrinho de compras – propriedades
// métodos
// Acrescenta a quantidade $num do artigo $artnr no carrinho
function add_item($artnr, $num) {
$this->items[$artnr] += $num;
}
// Retira a quantidade $num de artigos $artnr do carrinho
}
?>
function remove_item($artnr, $num) {
if ($this->items[$artnr] > $num) {
$this->items[$artnr] -= $num;
return true;
} elseif ($this->items[$artnr] == $num) {
unset($this->items[$artnr]);
return true;
} else {
return false;
}
}
Construtor
Para inicializar variáveis com valores
não constantes, você precisará de
uma função de inicialização
chamada automaticamente quando
o objeto for construído a partir da
classe. Por isso, essa função é
conhecida como construtor.
Construtor
<?php
class CarrinhoDeCompras {
var $data_de_hoje;
var $nome;
var $proprietario;
var $items = array("VCR", "TV");
}
?>
function CarrinhoDeCompras() {
$this->data_de_hoje = date("Y-m-d");
$this->nome = $GLOBALS['primeiro_nome'];
/* etc. . . */
}
Construtor
(php5)
class ClasseBase {
function __construct() {
print "No construtor da ClasseBase<br>";
}
}
class SubClasse extends ClasseBase {
function __construct() {
parent::__construct();
print "No construtor da SubClasse<br>";
}
}
$obj = new ClasseBase();
$obj = new SubClasse();
?>
Destrutor


(php5)
void __destruct ( void )
PHP 5 introduz um conceito de destrutor
similar ao de outras linguagens orientadas a
objeto, como o Java. O método destrutor
será chamado assim que todas as referências
a um objeto particular forem removidas ou
quando o objeto for explicitamente destruído
ou qualquer ordem na sequência de
encerramento.
Destrutor

(php5)
<?php
class MinhaClasseDestruivel {
function __construct() {
print "No construtor<br>";
$this->name = "MinhaClasseDestruivel";
}
}
function __destruct() {
print "Destruindo " . $this->name . "<br>";
}
$obj = new MinhaClasseDestruivel();
?>
Instanciação
Classes são tipos, ou seja, são apenas um
modelo das variáveis normais. Você
pode criar uma variável (ou instância)
do tipo desejado com o operador new.
Instanciação
<?php
$carrinho = new CarrinhoDeCompras;
$carrinho->add_item("10", 1);
$outro_carrinho = new CarrinhoDeCom
pras;
$outro_carrinho->add_item("0815", 3);
?>
Extends


Permite classes com variáveis e funções similares a uma
outra classe. De fato, é uma boa prática definir classes
genéricas que podem ser utilizadas em todos os seus
projetos, e adaptar essas classes com as necessidades
específicas de cada projeto. Para facilitar isso, classes
podem ser extensões de outras classes. A classe
estendida ou derivada tem todas as variáveis e funções
da classe base (chamado herança) e mais aquelas que
venha a acrescentar na versão estendida.
Uma classe estendida é sempre dependente de uma
única classe base, e portanto, herança múltipla não é
suportada.
Extends
<?php
class CarrinhoDeComprasNomeado extend
s CarrinhoDeCompras {
var $proprietario;
}
?>
function set_proprietario ($name) {
$this->proprietario = $name;
}
Extends
<?php
$ncart = new CarrinhoDeComprasNomead
o;
$ncart->set_proprietario("kris");
print $ncart->proprietario;
$ncart>add_item("10", 1); // (funcionalidade he
rdade do CarrinhoDeCompras)
?>
Visibilidade

A visibilidade de uma propriedade ou
método pode ser definida prefixando a
declaração com as palavras-chave:
'public','protected' ou 'private'. Itens
declarados como public podem ser
acessados por todo mundo. Protected
limita o acesso a classes herdadas (e para
a classe que define o item). Private limita
a visibilidade para apenas a classe que
define o item.
Visibilidade dos membros
<?php
/*** Define MinhaClasse */
class MinhaClasse
{
public $publica = 'Public';
protected $protegida = 'Protected';
private $privada = 'Private';
}
function imprimeAlo()
{
echo $this->publica;
echo $this->protegida;
echo $this->privada;
}
$obj = new MinhaClasse();
echo $obj->publica; // Funciona
echo $obj->protegida; // Erro Fatal
echo $obj->privada; // Erro Fatal
$obj->imprimeAlo(); // Mostra Public, Protected e Private
...
Visibilidade dos membros
/*** Define MinhaClasse2 */
class MinhaClasse2 extends MinhaClasse
{
// Podemos redeclarar as propriedades públicas e protegidas mas não as privadas
protected $protegida = 'Protected2';
function imprimeAlo()
{
echo $this->publica;
echo $this->protegida;
echo $this->privada;
}
}
$obj2 = new MinhaClasse2();
echo $obj2->publica; // Works
echo $obj2->privada; // Undefined
echo $obj2->protegida; // Fatal Error
$obj2->imprimeAlo(); // Mostra Public, Protected2, Undefined
?>
Visibilidade dos Métodos
Métodos de classe devem ser definidos com
public, private, ou protected. Métodos sem
qualquer declaração são definidas como
public.
Visibilidade dos Métodos
<?php
/*** Define MinhaClasse */
class MinhaClasse
{
// Declara um construtor público
public function __construct() { }
// Declara um método public
public function MeuPublico() { }
// Declara um método protected
protected function MeuProtegido() { }
// Declara um método private
private function MeuPrivado() { }
// Esse é public
function Foo()
{
$this->MeuPublico();
$this->MeuProtegido();
$this->MeuPrivado();
}
}
$minhaclasse = new MinhaClasse;
$minhaclasse->MeuPublico(); // Funciona
$minhaclasse->MeuProtegido(); // Erro Fatal
$minhaclasse->MeuPrivado(); // Erro Fatal
$minhaclasse->Foo(); // Public, Protected e Private funcionam
Visibilidade dos Métodos
/*** Define MinhaClasse2 */
class MinhaClasse2 extends MinhaClasse
{
// Esse é public
function Foo2()
{
$this->MeuPublico();
$this->MeuProtegido();
$this->MeuPrivado(); // Erro Fatal
}
}
$minhaclasse2 = new MinhaClasse2;
$minhaclasse2->MeuPublico(); // Funciona
$minhaclasse2->Foo2(); // Public e Protected funcionam, Private não
Visibilidade dos Métodos
class Bar {
public function test() {
$this->testPrivate();
$this->testPublic();
}
public function testPublic() {
echo "Bar::testPublic\n";
}
private function testPrivate() {
echo "Bar::testPrivate\n";
}
}
class Foo extends Bar
{
public function testPublic() {
echo "Foo::testPublic\n";
}
}
private function testPrivate() {
echo "Foo::testPrivate\n";
}
$myFoo = new foo();
$myFoo->test(); // Bar::testPrivate
// Foo::testPublic
?>
Operador de Resolução de
Escopo (::)


Dois pontos duplo é um token que
permite acesso a métodos ou membros
estáticos, constantes, e
sobrecarregados de uma classe.
Quando referenciando esses itens de
fora da definição da classe, você usa o
nome da classe.
Operador de Resolução de
Escopo (::)
De fora da definição da classe
<?php
class MinhaClasse {
const VALOR_CONST = 'Um valor constante';
}

$classname = 'MinhaClasse';
echo $classname::VALOR_CONST; // No PHP 5.3.0
echo MinhaClasse::VALOR_CONST;
?>
Operador de Resolução de
Escopo (::)
De dentro da definição da classe
<?php
class OutraClasse extends MinhaClasse {
public static $meu_estatico = 'variável estática';

}
public static function doisPontosDuplo() {
echo parent::VALOR_CONST . "\n";
echo self::$meu_estatico . "\n";
}
$classname = 'OutraClasse';
echo $classname::doisPontosDuplo(); // No PHP 5.3.0
OutraClasse::doisPontosDuplo();
?>
Operador de Resolução de
Escopo (::)
Quando uma subclasse sobrecarrega a definição de um método do pai, php não chamará o
método pai. Fica a cargo da subclasse chamar o método pai ou não.

Chamando um método pai
<?php
class MinhaClasse {

}
protected function minhaFuncao() {
echo "MinhaClasse::minhaFuncao()\n";
}
class OutraClasse extends MinhaClasse {
/* Sobrecarrega a definição do pai */
public function minhaFuncao() {
}
}
/* Mas ainda chama a função pai */
parent::minhaFuncao();
echo "OutraClasse::minhaFuncao()\n";
$classe = new OutraClasse();
$classe->minhaFuncao();
?>
Mail (complemento)
Mail


bool mail ( string $to , string $subject ,
string $message [, string $additional_headers
[, string $additional_parameters ]] )
$to




Receptor, ou receptores do email.
O formato desta string precisa estar de acordo
com » RFC 2822. Alguns exemplos:
[email protected], [email protected]
User <[email protected]>, Another User
<[email protected]>
Mail


bool mail ( string $to , string $subject ,
string $message [, string
$additional_headers [, string
$additional_parameters ]] )
$subject


Assunto do email a ser enviado.
Não deve conter caractere de nova linha,
ou o email pode não ser enviado
corretamente.
Mail


bool mail ( string $to , string $subject ,
string $message [, string
$additional_headers [, string
$additional_parameters ]] )
$message


Mensagem a ser enviada.
Cada linha deve ser separada com um LF
(\n). Linhas não deve ser maiores que 70
caracteres.
Mail


bool mail ( string $to , string $subject ,
string $message [, string $additional_headers
[, string $additional_parameters ]] )
$additional_headers (opcional)


String a ser inserida no final do cabeçalho do
email.
Esta é normalmente usada para adicionar
cabeçalhos extras (From, Cc, e Bcc). Múltiplos
cabeçalhos extra devem ser separados com um
CRLF (\r\n).
Mail


bool mail ( string $to , string $subject ,
string $message [, string
$additional_headers [, string
$additional_parameters ]] )
$additional_parameters (opcional)

pode ser usado para passar um parâmetro
adicional para o programa configurado
para usa quando enviando email usando a
configuração sendmail_path.
Mail - exemplo
<?php
// multiple recipients
$to = '[email protected]' . ', '; // observe a vírgula
$to .= '[email protected]';
// subject
$subject = ‘Aniversariantes do mês';
// message
$message = '
<html>
<head>
<title>Aniversariantes</title>
</head>
<body>
<p>Aniversariantes do mês!</p>
<table>
<tr><th>Pessoa</th><th>Dia</th></tr>
<tr><td>João</td><td>3rd</td></tr>
<tr><td>Pedro</td><td>17th</td></tr>
</table>
</body>
</html>
';
Mail - exemplo
// To send HTML mail, the Content-type header must be set
$headers = 'MIME-Version: 1.0' . "\r\n";
$headers .= 'Content-type: text/html; charset=iso-8859-1' . "\r\n";
// Additional headers
$headers .= 'To: Mari <[email protected]>, Ana <[email protected]
m>' . "\r\n";
$headers .= 'From: RH <[email protected]>' . "\r\n";
$headers .= 'Cc: [email protected]' . "\r\n";
$headers .= 'Bcc: [email protected]' . "\r\n";
// enviando o e-mail
mail($to, $subject, $message, $headers);
?>
Download

php