Escolar Documentos
Profissional Documentos
Cultura Documentos
Apostila Completa de PHP Linux PDF
Apostila Completa de PHP Linux PDF
www.4linux.com.br
Capítulo 1
Introdução
4Linux – www.4linux.com.br Introdução
Neste curso iremos aprender o que é o PHP, entender como a linguagem funciona
e conhecê-la a fundo. O curso é recomendado para qualquer um interessado em
começar a desenvolver aplicações para a web. Se você já possui experiência com
alguma outra linguagem de programação, você entenderá os conceitos apresenta-
dos aqui rapidamente, mas o curso e a apostila irão assumir que você não possui
nenhuma experiência com desenvolvimento de software.
O curso Desenvolvimento Web com PHP (500) é o primeiro curso da Formação PHP
da 4Linux. Este curso de PHP foi desenvolvido para apresentar o poder do PHP
a quem teve algum contato com a linguagem ou programadores PHP que desejam
aprimorar seus conhecimentos e se atualizar. Ao longo do curso de PHP da 4Linux
serão desenvolvidos dois projetos: um microblog (similar ao Twitter) e um sistema de
blog (similar ao Wordpress), conhecendo a fundo e aplicando as funcionalidades da
linguagem PHP.
Desde 2006 presta suporte a softwares livres em ambientes de missão crítica para
a Caixa Econômica Federal, um dos principais cases mundiais de uso de padrões
abertos: atualmente quando um cidadão faz uma aposta nas loterias, saca um di-
nheiro em um ATM (caixa eletrônico), recebe um SMS com o saldo de seu FGTS ou
simula o valor de um financiamento imobiliário no ’feirão’ da casa própria, ele está
usando uma infraestrutura baseada em softwares livres com serviços prestados pela
4Linux.
O foco principal do PHP como linguagem é a web, portanto, é necessário que você
tenha um conhecimento sobre outras tecnologias para a web, como HTML e CSS.
Além disso, para facilitar seu aprendizado, ter boas noções de lógica de programação
é ideal. Para suprir essa necessidade a 4Linux preparou o Aula Zero, um conteúdo di-
gital exclusivo com tudo que você precisa saber sobre lógica de programação, HTML
e CSS.
O PHP surgiu em meados de 1994, criado por Rasmus Lerdorf como um pacote
de programas CGI. Em 1997, dois desenvolvedores israelitas, Zeev Suraski e Andi
Gutmans, entraram no projeto e reescreveram grande parte do código do PHP. Junto
com Rasmus, lançaram a versão 3.0 do PHP em junho de 2008. Para a próxima
versão, Zeev e Andi decidiram reescrever o core do projeto do zero, chamando-o de
Zend Engine. Esta nova versão, PHP 4, foi lançada em maio de 2000, contando com
funcionalidades novas como gerenciamento de sessão, buffer de saída e suporte
a vários servidores web. Infelizmente, a versão 4 ainda sofria com uma péssima
implementação do paradigma de programação orientada a objetos, então em julho de
2004, foi lançada a versão 5 do PHP, que trouxe várias novidades para a linguagem
e um jeito completamente novo de programar PHP.
Servidor Web
4Linux – www.4linux.com.br Servidor Web
O servidor web irá interpretar seu pedido, localizar a página no sistema de arquivos
da máquina e entregar o conteúdo da página para seu navegador, que irá intepretar
o código HTML da página e mostrá-lo para você. No caso de arquivos de música,
vídeo, etc, o navegador vai oferecer o download ao invés de mostrar o conteúdo.
Quando uma página é requisitada ao nosso servidor web, ele irá procurar pela pá-
gina requisitada no sistema de arquivos, e caso ele encontre, o conteúdo desta pá-
gina será exibido. Se esta página possuir hipertexto (HTML), vocês já sabem o que
acontece: teremos uma página web sendo exibida. O PHP funciona como uma etapa
extra.
Caso uma página PHP seja requisitada, o servidor web irá procurar pela página no
sistema de arquivos e, caso exista algum código PHP dentro desta, ele irá chamar
o PHP, que interpretará o código e retornará os dados. A sigla PHP é um acrônimo
recursivo que significa PHP: Hypertext Preprocessor, que mostra claramente o intuito
da linguagem processar informações e gerar hipertexto (HTML).
1 <html >
2 <head >
3 < title > Teste </ title >
4 </ head >
5 <body >
6 <p > Hoje é dia 10/10/2010 </ p >
7 </ body >
8 </ html >
1 <html >
2 <head >
3 < title > Teste </ title >
4 </ head >
5 <body >
6 <p > Hoje é dia <? php echo date ( ’ d / m /Y ’) ; ? > </p >
Pronto, nosso servidor web está instalado. Para termos certeza que ele está funcio-
nando, vamos entrar em nosso endereço web local:
Uma vez que temos o Apache instalado, ele já pode servidor páginas e arquivos.
Mas ele ainda não consegue intepretar arquivos PHP porque nós não instalamos o
PHP nesta máquina. Vamos fazer isso, instalando o pacote php5.
Para que o apache possa começar a intepretar nossas páginas PHP, precisamos
reiniciá-lo. Vamos fazer isso rodando o seguinte comando:
Está na hora de testar. Renomeie o arquivo index.html na pasta /var/www para in-
dex.php. Agora, abra o arquivo e coloque o código a seguir dentro dele:
1 <? php
2
3 echo " Oi mundo " ;
PHP
4Linux – www.4linux.com.br PHP
Quando criamos uma página, geralmente utilizamos a extensão .html. Quando criar-
mos páginas que possuem código PHP, vamos utilizar a sessão .php. Dentro desta
página, podemos colocar HTML e PHP misturados, desde que utilizemos algumas
tags específicas para delimitar o que é um código PHP. Para definirmos o que é um
código PHP dentro de uma página, utilizamos as tags:
1 <? php
2 ?>
1 <?
2 ?>
1 <%
2 %>
1 < script language = " php " > </ script >
• As tags ASP e script serão depreciadas nas versões futuras do PHP, portanto,
não as use!
• Caso você esteja criando uma página que só possua código PHP, não é neces-
sário utilizar a tag de fechamento (?>).
Olá Mundo
O código abaixo faz uso do comando echo, que permite que você envie dados para
a tela. A tela, no nosso caso, é o navegador. Note que o comando print faz a mesma
coisa que o echo.
1 <? php
2
3 echo ’Ol á mundo ! ’;
4 print ’Ol á mundo ! ’;
Comentários
1 <? php
2 // Coment á rio de uma linha
3
4 # Coment á rio de uma linha
5
6 /* Coment á rio
7 com vá rias
8 linhas
9 */
10
11 echo " teste " ; // Coment á rio
1 <? php
2 $nome = " Jo ã o " ;
3 $email = " joao@gmail . com " ;
4 $time = " Gr ê mio " ;
1 <? php
2 $time = " Gr ê mio " ;
3 echo $time ;
Nomes válidos
• Evite criar variáveis com nomes gigantes, abrevie sempre que possível
• Evite criar nomes sem sentido, como $a ou $xyz. O nome da variável deve
ajudar o programador, não confundi-lo
Variáveis variáveis
No PHP, podemos definir variáveis cujos nomes são... variáveis! Isso pode ser feito
de maneira bastante simples:
1 <? php
2 $var = " time " ;
3 $$var = " Gr ê mio " ;
4 echo $time ;
Observe que o valor da variável $var está sendo utilizado como nome de variável
durante a atribuição de valor, criando de forma dinâmica a variável $time.
Constantes
Uma constante é como uma variável, mas como seu nome pode indicar, seu valor é
sempre constante, invariável. O valor de uma constante jamais poderá ser alterado
em tempo de execução. Para definirmos uma constante, utilizamos a função define()
do PHP.
1 <? php
2 define (" VERSAO " , 2)
3 echo VERSAO ;
Constantes estão disponíveis por todo nosso script, inclusive dentro de funções que
veremos logo logo. As regras de nomenclatura das constantes são as mesmas das
variáveis. Contudo, é uma boa prática usar sempre letras maiúsculas e underline.
Ex.: MELHOR_TIME, LIMITE_CAMPOS
O PHP possui os seguintes tipos: Boolean, Integer, Float, String, Array, Objeto, Re-
curso, NULL
Boolean
Uma variável booleana pode conter apenas dois valores, true ou false. Booleanos
são a base das operações lógicas em nossas aplicações. Já que no PHP temos
tipagem dinâmica, um valor booleano por ter várias formas. True pode ser 1, false
pode ser 0, null ou uma string vazia.
Integer
Float
String
Uma string é geralmente um texto, mas para sermos mais corretos na definição, é
uma sequência ordenada de caracteres. Podemos usar como texto, mas seu con-
teúdo também pode ser binário, como o conteúdo de um arquivo MP3 ou JPG.
Array
Um array é uma estrutura de dados ordenados, que mantém uma série de elementos
que podem ter diferentes tipos. Arrays são importantíssimos e saberemos mais sobre
eles mais na frente.
Objeto
Recurso
Um recurso é um recurso externo utilizado nativamente pelo PHP. São, por exemplo,
conexões abertas com um banco de dados ou conexões abertas com um arquivo no
sistema.
NULL
Uma variável NULL indica que ela não possui valor algum. Uma variável é conside-
rada nula quando recebe o valor NULL ou nunca recebeu valor algum.
1 <? php
2 $v_ou_f = true ;
3 $inteiro = 10;
4 $flutuante = 5.22;
5 $string = " Testando " ;
6 $array = array ( ’a ’ , ’b ’ , ’c ’) ;
7 $objeto = new Objeto ;
8 $recurso = fopen ( ’ arquivo ’ , ’r ’) ;
9 $null = NULL ;
3.3.1 Pseudo-tipos
Durante a leitura desta apostila, exercícios em aula e até mesmo pesquisas na inter-
net, você encontrará vários menções a alguns tipos de variáveis conhecidos como
pseudo-tipos. Eles são utilizados como referências a situações específicas que ocor-
rem durante o desenvolvimento de uma aplicação.
mixed
O tipo mixed é utilizado para indicar que uma função pode esperar ou retornar mais
de um tipo de variável ao mesmo tempo. Por exemplo, uma função pode retornar
uma string ou um booleano, enquanto pode receber como parâmetro um array ou
string.
number
O tipo number é utilizado para indicar que a variável pode ser um inteiro ou um
float.
callback
Algumas funções no PHP podem esperar como parâmetro uma outra função definida
pelo usuário. Chamamos essas funções passadas como parâmetro de callbacks.
1 <? php
2 $var = "0 " ; // $var é uma string
3 $var += 2; // $var agora é um inteiro
4 $var = $var + 1.3; // $var agora é um float
5 $var = 5 + " 10 carros " ; // inteiro ( $var = 15)
6 $var = "1 casa " + " 1 casa " ; // inteiro ( $var = 2)
Embora a tipagem do PHP seja dinâmica, podemos forçar os tipos de nossas va-
riáveis utilizando uma técnica conhecida como type casting, ou conversão de tipos.
Veja no exemplo abaixo como podemos forçar os tipos de algumas variáveis:
1 <? php
2 $var = 10;
3 $cast = ( boolean ) $var ; // torna - se booleano
4 $cast = ( int ) $var ; // torna - se inteiro
5 $cast = ( float ) $var ; // torna - se float
6 $cast = ( string ) $var ; // torna - se string
7 $cast = ( array ) $var ; // torna - se array
8 $cast = ( object ) $var ; // torna - se object
9 $cast = ( unset ) $var ; // torna - se NULL
10 $cast = ( binary ) $var ; // torna - se uma string bin á ria
3.4 Operadores
Bom, até agora aprendemos o que são variáveis, como criá-las e como associar va-
lores a elas. Mas a vida de um desenvolvedor seria muito chata se isso fosse tudo
que pudéssemos fazer com elas. Vamos conhecer agora operadores, que permi-
tem que nós manipulemos o conteúdo de uma ou mais variáveis, produzindo novas
variáveis.
Operadores Aritméticos
1 <? php
2 $a = 3;
3 $b = 3;
4 $c = $a * $b ; // resultado é 9
5 $d = $a + $b ; // resultado é 6
6 $e = $c - $d ; // resultado é 3
• Adição: +
• Subtração: -
• Multiplicação:
• Divisão: /
• Módulo: %
1 <? php
2 $a = "5"; // string
3 echo $a + 2; // 7 , integer
4 echo $a + ’5 carros ’; // 10 , integer
Operadores de Atribuição
1 <? php
2 $a = 1; // A vari á vel $a é igual a 1
3 $a += 2; // Somamos 2 ao valor da vari á vel $a
4 $a -= 2; // Subtraimos 2 ao valor da vari á vel $a
5 $a *= 2; // Multiplicamos o valor da vari á vel $a por 2
6 $a /= 2; // Dividimos o valor da vari á vel $a por 2
1 <? php
2 $a = 1;
3 echo ++ $a ; // Incrementamos 1 e retornamos o valor
4 echo $a ++; // Retornamos o valor e incrementamos 1
5 echo -- $a ; // Decrementamos 1 e retornamos o valor
6 echo $a - -; // Retornamos o valor e decrementamos 1
Operadores Relacionais
• Igual: ==
• Idêntico: ===
• Diferente: != ou <>
Devido a tipagem dinâmica do PHP, você deve tomar alguns cuidados quando es-
tiver criando expressões lógicas envolvendo valores booleanos. Se você fizer uma
comparação utilizando o operador ==, o número inteiro 0 será igual ao booleano
false, assim como NULL e uma string vazia. Isso pode não trazer bons resultados.
Portanto, utilize sempre o operador ===, que checará não somente o conteúdo da
variável, e sim, o tipo dela.
Operadores Lógicos
Existem também os operadores lógicos, que são utilizados para combinar expres-
sões lógicas, criando testes condicionais. São eles:
• $a and $b
• $a or $b
• $a xor $b
• ! $a
• $a && $b
• $a || $bb
3.5 Strings
Uma string é, nada mais nada menos, que um texto. Para declarar uma string, utili-
zamos aspas simples ” ou aspas duplas .
1 <? php
2 echo " Testando " ;
3 echo ’ Testando ’;
Existe uma diferença bem clara entre a utilização de aspas duplas e aspas simples:
O modo como o PHP interpreta o conteúdo delas. Diferentemente das aspas simples,
as aspas duplas permitem que você faça uso de caracteres de escape e variáveis
dentro de uma string.
1 <? php
2 $nome = ’ Jo ão ’;
3 echo " $nome e Maria andam pela rua < br / > " ;
4 echo ’ $nome e Maria andam pela rua ’;
Ao contrário do que muitos pensam, não existe diferença alguma de performance en-
tre o uso de aspas duplas ou simples. O fato das aspas duplas fazerem substituição
de variáveis pelos seus respectivos valores não torna o código mais lento.
Caracteres de escape
1 Quebra de linha : \ n
2 Tabula ção : \ t
3 Retorno do carro : \ r
4 A pr ó pria barra : \\
5 Aspas simples : \ ’
6 Aspas duplas : \ "
1 <? php
2 echo " <pre > Vou quebrar a linha \ n " ;
3 echo "\ tEstou tabulado \ n " ;
4 echo " Mostrar aspas duplas , sem quebrar o c ó digo \ " \ n " ;
5 echo " Mostrar a barra \\ " ;
6 echo " </ pre > " ;
Navegadores, por padrão, não exibem caracteres de escape. Novas linhas e tabula-
ções que forem colocadas em strings só serão exibidas em texto puro, isto é, caso
você salve a string em um arquivo de texto. Para mostrar caracteres de escape no
navegador, é comum utilizar a tag HTML <pre>.
Concatenação
1 <? php
2 $carro = ’Gol ’;
3 $cor = ’Azul ’;
4
5 $meucarro = $carro . $cor ;
6 $outrocarro = ’ Meu ’. $carro . ’ é ’. $cor . ’ ’;
7
8 echo $meucarro ;
9 echo $outrocarro ;
Evite concatenar string quando seu único objetivo é colocar o valor de uma variável
dentro da outra. Para esse fim podemos utilizar as aspas duplas.
1 <? php
2 $idade = 15;
3 if ( $idade < 18) {
4 echo ’ Voc ê n ã o pode entrar aqui ! ’;
5 } else {
6 echo ’Bem - vindo ao Bar ! ’;
7 }
1 <? php
2 $idade = 21;
3 $carteirinha = true ;
4 if ( $idade > 18 && $carteirinha == true ) {
5 echo ’Bem - vindo ! ’;
6 }
Elseif
Além do IF/ELSE básico, podemos fazer uso do controle ELSEIF, que permite que
criemos uma outra condição, além da principal.
1 <? php
2 $nome = ’Z é ’;
3 if ( $nome == ’Z é ’) {
4 echo ’Ea í Z é ! ’;
5 } elseif ( $nome == ’ Maria ’) {
6 echo ’Ea í Maria ! ’;
7 } else {
8 echo ’Ea í ningu é m ! ’;
9 }
Switch
O ELSEIF pode ser muito útil, mas e quando tivermos muitas condições? Fica ruim
de manter um código cheio de ELSEIF’s. É aí que entra o SWITCH. O switch permite
que criemos infinitas condições de forma bastante simples e organizada:
1 <? php
2 $nome = ’Z é ’;
3 switch ( $nome ) {
4 case ’Z é ’:
5 echo ’ Ea í Z é ! ’;
6 break ;
7
8 case ’ Maria ’:
9 echo ’ Ea í Maria ! ’;
10 break ;
11
12 case ’ Darth ’:
13 echo ’ Ea í Vader ! ’;
14 break ;
15
16 case ’ Curinga ’:
17 echo ’ Ea í Curinga ! ’;
18 break ;
19
20 default :
21 echo ’ Ea í rap á ? ’;
22 break ;
23 }
Operador Ternário
Existe no PHP uma forma mais "curta"de criar condições. Ele é chamado de Opera-
dor Ternário. Embora ele deixe o código menos legível para programadores menos
experientes, ele nos salva tempo e o código torna-se mais limpo.
1 <? php
2
3 $a = 1;
4 $b = 0;
5
6 if ( $a > $b ) {
7 $c = ’A é maior que B ’;
8 } else {
9 $c = ’A n ã o é maior que B ’;
10 }
11
12 $d = ( $a > $b ) ? ’A é maior que B ’ : ’A n ã o é maior que B ’;
13
14 echo $c ;
15 echo $d ;
3.7 Loops
Os loops no PHP são estruturas de controle muito importantes. Eles permitem que
efetuemos um laço de repetição enquanto uma determinada condição for verdadeira.
Temos quatro tipos de loop no PHP: while, do while, for e foreach. O foreach foi
construído especialmente para lidar com arrays, portanto, vamos conhecê-lo mais
tarde.
while
O while permite que executemos um bloco de código enquanto a expressão que foi
passada como parâmetro seja verdadeira.
1 <? php
2
3 $contador = 0;
4
5 while ( $contador < 10) {
6 echo $contador ;
7 $contador ++;
8 }
Neste caso, contamos até 10. Observe que estamos incrementando o valor da variá-
vel logo depois de colocá-la na tela. Fiz dessa maneira para que ficasse mais claro
para vocês, mas poderíamos fazer o mesmo da seguinte forma:
1 <? php
2
3 $contador = 0;
4
5 while ( $contador < 10) {
6
7 echo $contador ++;
8
9 }
do while
O do while funciona da mesma forma que o while, com apenas uma diferença: Ele
avalia a expressão depois de fazer algo. Isso garante que o código seja executado
ao menos uma vez, mesmo que a expressão não seja verdadeira.
1 <? php
2
3 $contador = 1;
4
5 do {
6
7 $quadrado = $contador * $contador ;
8 echo "O quadrado de $contador é $quadrado < br / > " ;
9 $contador ++;
10
11 } while ( $contador <= 10) ;
Esse exemplo é similar ao exemplo anterior. Mas vamos supor que a variável $con-
tador não seja 0, seja 12 (maior que 10, portanto, falhando nossa condição). O do
while garantirá que nosso bloco de código será executado apenas uma vez, mesmo
a condição sendo falsa.
for
1 <? php
2
3 for ( $contador = 1; $contador <= 10; $contador ++) {
4
5 $quadrado = $contador * $contador ;
6 echo "O quadrado de $contador é $quadrado < br / > " ;
7
8 }
Quebrando loops
1 <? php
2
3 for ( $contador = 1; $contador <= 10; $contador ++) {
4
5 if ( $contador == 3) { continue ; }
6
7 $quadrado = $contador * $contador ;
8 echo "O quadrado de $contador é $quadrado < br / > " ;
9
10 }
Note que nosso contador irá pular o terceiro item do loop. Nosso if retornou verda-
deiro, portanto, o bloco de código contido nele foi executado. O bloco de código era
o continue, que fez com que a execução do loop fosse pulada naquele momento,
deixando de executar a conta do quadrado e nosso echo.
1 <? php
2
3 for ( $contador = 1; $contador <= 10; $contador ++) {
4
5 if ( $contador == 3) { break ; }
6
7 $quadrado = $contador * $contador ;
8 echo "O quadrado de $contador é $quadrado < br / > " ;
9
10 }
Observe agora que, ao invés de pular o terceiro item, nosso contador parou por ali.
O break finaliza a execução do loop.
3.8 Arrays
Arrays são mapas de dados, guardados em forma de chave = valor. Arrays podem
conter vários tipos diferentes de variáveis, até mesmo arrays. Se formos manter
nossa analogia de gavetas, arrays são grandes gavetas que possuem mais gavetas
dentro de si, etiquetadas ou não. A melhor forma de explicar o que eles são e como
funcionam, é através de código:
1 <? php
2 $pessoas = array ( ’ Jo ão ’ , ’ Maria ’ , ’ Pedro ’) ;
3 print_r ( $pessoas ) ;
No código acima, nós criamos um array chamado $pessoas e colocamos três valo-
res dentro dele. Esses valores são como variáveis, contidos dentro de uma grande
variável chamada $pessoas. Ela é a nossa grande gaveta e as pequenas gavetas
contidas nela podem possuir qualquer valor: string, inteiro, float, etc.
Note também que não utilizamos echo, e sim, uma função chamada print_r. A função
print_r lista as chaves e os valores de um array. Existe também a função var_dump:
1 <? php
2 $pessoas = array ( ’ Jo ão ’ , ’ Maria ’ , ’ Pedro ’) ;
3 var_dump ( $pessoas ) ;
Observe que a função var_dump irá exibir não só a estrutura do array, mas os tipos
dos valores contidos dentro dele.
Caso utilizemos echo $pessoas, o PHP irá retornar "Array()". Porque? Porque um
array é um mapa de dados e o echo não pode retornar o mapa inteiro. Para podermos
utilizar o echo com arrays, precisamos especificar qual chave queremos acessar.
1 <? php
2 $pessoas = array ( ’ Jo ão ’ , ’ Maria ’ , ’ Pedro ’) ;
3 echo $pessoas [1]; // Maria
3.8.1 Associativos
Por padrão, quando criamos um array, ele recebe chaves numéricas, incrementadas
automaticamente de acordo com novos valores. Contudo, podemos criar chaves que
são strings. Chamamos isto de arrays associativos. Para explicar melhor, faremos
um exemplo em que mostraremos a temperatura média de alguns meses do ano.
1 <? php
2 $temperaturas = array ( ’ Janeiro ’ = > 30 , ’ Fevereiro ’ = > 32 , ’ Mar ço ’
=> 29) ;
Observe que nossos valores, nossas pequenas gavetas dentro de uma grande ga-
veta, agora possuem nomes. Podemos utilizar estes nomes para nos referenciarmos
a um valor específico dentro de um array, permitindo que manipulemos nossos arrays
de maneira mais precisa.
1 <? php
2 $temperaturas = array ( ’ Janeiro ’ = > 30 , ’ Fevereiro ’ = > 32 , ’ Mar ço ’
=> 29) ;
3 echo "A temperatura m é dia em Janeiro foi de :
{ $temperaturas [ ’ Janeiro ’]} graus " ;
1 <? php
2
3 $nome = ’ Carlos Carne ’;
4 $time = array ( ’ melhor ’ = > ’ Gr ê mio ’ , ’ pior ’ = > ’ Curintia ’) ;
5
6 // Não concatenadas
7 echo " $nome torce para o { $time [ ’ melhor ’]} " ;
8 echo "{ $nome } torce para o { $time [ ’ melhor ’]} " ;
9
10 // Concatenadas
11 echo "". $nome . " torce para o " . $time [ ’ melhor ’] . " " ;
12 echo ’’. $nome . ’ torce para o ’. $time [ ’ melhor ’] . ’ ’;
Portanto, nunca utilize concatenação para acessar valores dentro de um array. Faça
uso das chaves e evite sujar seu código e diminuir sua manutenibilidade.
3.8.2 Multidimensionais
Arrays multidimensionais, por mais complexo que o nome seja, são basicamente,
arrays dentro de um array. Lembram que os valores de um array podem ter qualquer
tipo? String, float, inteiro? Bom, também podemos ter arrays!
Podemos ter infinitos arrays dentro de outros arrays para controlar e armazenar di-
versos dados diferentes. Mas, seguindo o nosso exemplo anterior, podemos ter os
dados de temperatura para vários anos:
1 <? php
2
3 $temperaturas = array (
4 ’2008 ’ = > array (
5 ’ Janeiro ’ = > 30 ,
6 ’ Fevereiro ’ = > 32 ,
Note que fiz uso de uma estrutura identada, similar a da saída do print_r, para visu-
alizar melhor os dados do array. Eu poderia colocar tudo em uma linha, mas ficaria
difícil de entender no futuro.
Sempre que você for trabalhar com arrays multidimensionais, procure identar sua
definição para manter o código limpo e fácil de entender.
3.8.3 Foreach
Aprendemos anteriormente alguns loops, mas faltou o foreach. O foreach está ligado
diretamente a arrays. A ideia do foreach é que você possa iterar entre cada elemento
de um array. Por exemplo:
1 <? php
2
3 $pessoas = array ( ’ Jo ão ’ , ’ Maria ’ , ’ Pedro ’) ;
4
5 foreach ( $pessoas as $valor ) {
6 echo " Ol á $valor ! < br / > " ;
7 }
1 <? php
2
3 $temperaturas = array ( ’ Janeiro ’ = > 30 , ’ Fevereiro ’ = > 32 , ’ Mar ço ’
=> 29) ;
4
5 foreach ( $temperaturas as $chave = > $valor ) {
6 echo "A temperatura m é dia de $chave foi de $valor graus < br / > " ;
7 }
1 <? php
2
3 $temperaturas = array (
4 ’2008 ’ = > array (
5 ’ Janeiro ’ = > 30 ,
6 ’ Fevereiro ’ = > 32 ,
7 ’ Mar ço ’ = > 29) ,
8 ’2009 ’ = > array (
9 ’ Janeiro ’ = > 31 ,
10 ’ Fevereiro ’ = > 34 ,
11 ’ Mar ço ’ = > 30) ,
12 ’2010 ’ = > array (
13 ’ Janeiro ’ = > 32 ,
14 ’ Fevereiro ’ = > 34 ,
15 ’ Mar ço ’ = > 28)
16 );
17
18 foreach ( $temperaturas as $ano = > $meses ) {
19 echo " < strong > Temperaturas em $ano </ strong > < br / > " ;
20
21 foreach ( $meses as $mes = > $temp ) {
22 echo " $mes : $temp graus < br / > " ;
23 }
24 }
Podemos criar arrays de forma simples e rápida utilizando o operador []. Dessa
forma, iremos apenas jogar dados dentro do nosso array, sem nos preocuparmos
com a chave.
1 <? php
2
3 $array = array ( ’ Jo ão ’ , ’ Maria ’) ;
4
5 $array [] = ’ Jos é ’;
6 $times [] = ’ Gr ê mio ’;
7
8 print_r ( $array ) ;
9 print_r ( $times ) ;
1 <? php
2
3 $array = array ( ’ nome ’ = > ’ Jo ão ’ , ’ time ’ = > ’ nenhum ’) ;
4
3.9 Funções
1 <? php
2
3 function negrito ( $valor ) {
4 echo " < strong > $valor </ strong > " ;
5 }
6
7 echo negrito ( " Ol á mundo ! " ) ;
8 echo negrito ( " Ol á mundo , novamente ! " ) ;
Observe que a função tem dois parênteses e dentro deles temos uma variável, cha-
mamos isso de parâmetro. Os parâmetros de uma função são somente valores,
mas sempre criamos apelidos para eles. A variável $valor poderia ter qualquer outro
nome, optamos por esse para ficar mais claro.
O conteúdo dela sempre será o valor que está sendo passado para a função durante
a chamada de função. Chamadas de função são muito simples. Basta você colocar
o nome da função e passar quaisquer parâmetros para ela. Algumas funções podem
não possuir parâmetros.
1 <? php
2
3 negrito (" Oi mundo " ) ;
4 italico (" Oi pessoas " ) ;
5 quebra () ;
6 lista (" Item 1 " , " Item 2 " , " Item 3 " ) ;
3.9.1 Retorno
Para fazer uma função retornar um valor, precisamos utilizar a palavra-chave return,
seguida do valor que desejamos retornar. Veja o exemplo:
1 <? php
2
3 function taxar ( $valor ) {
4 $valor = $valor * 1.09;
5 return $valor ;
6 }
7
8 $preco = 25;
9 $comtaxa = taxar ( $preco ) ;
10
11 echo "O pre ç o deste livro é $preco . Com taxa , fica : $comtaxa " ;
1 <? php
2
3 function taxar ( $valor , $subtaxa = 1) {
4 $valor = $valor * $subtaxa * 1.09;
5 return $valor ;
6 }
7
8 $preco = 25;
9 $comtaxa = taxar ( $preco ) ;
10 $comsubtaxa = taxar ( $preco , 1.02) ;
11
12 echo "O livro custa $preco . Com taxa , fica : $comtaxa . Com sub ,
fica : $comsubtaxa " ;
3.9.3 Escopo
Para podermos utilizar uma variável que está disponível no escopo global dentro
de nossas funções, precisamos alocá-las no escopo local utilizando a palavra-chave
global. Observe o código abaixo:
1 <? php
2
3 $taxa = 1.09;
4
5 function taxar ( $valor ) {
6 global $taxa ;
7
Quando passamos um valor para uma função, um parâmetro, aquele valor passa a
existir no escopo local da função. As alterações feitas nesse valor só existem no
escopo local, portanto, precisamos retornar algo em nossa função para fazer essas
alterações, se necessários, aparecerem no escopo global.
1 <? php
2
3 function adicionar (& $fruta ) {
4 return ++ $fruta ;
5 }
6
7 $laranjas = 5;
8
9 adicionar ( $laranjas ) ;
10
11 echo $laranjas ;
A variável $laranjas só existe no escopo global. Mas estamos passando essa variável
para uma função por referência, o que irá alterar o valor da variável em ambos os
escopos, sem que eu precise dizer que o valor da variável é igual ao retorno da
função.
Funções lambda, ou funções anônimas como são comumente conhecidas, são fun-
ções que podem ser definidas a qualquer momento, geralmente a uma variável e
disponível somente no escopo desta. Este conceito vem do cálculo lambda, introdu-
zido por Alonzo Church nos anos 30, que inspirou a criação de linguagens funcionais
como Lisp e Scheme.
Lambdas são muito úteis em conjunto com funções como array_filter e array_map.
Como podemos ver no exemplo abaixo, que monta um array somente com os valores
ímpares de outro:
1 <? php
2
3 $array = array (1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 , 12 , 13 , 14 , 15) ;
4 $impares = array_filter ( $array , function ( $valor ) { return $valor %
2; }) ;
5
6 print_r ( $impares ) ;
Closures, são muito similares a lambdas, mas acabam sendo mais úteis já que eles
podem interagir com o escopo global. Podemos importar variáveis do escopo glo-
bal para o escopo local do closure utilizando a palavra-chave use, que neste caso
funciona como a global que vimos anteriormente.
1 <? php
2
3 $teste = " Oi mundo " ;
4 $closure = function () use ( $teste ) { echo $teste ; };
5
6 $closure () ;
Funções Nativas
4Linux – www.4linux.com.br Funções Nativas
A função empty verifica se a variável é considerada vazia, ou seja, caso seu conteúdo
seja , 0, "0", NULL, FALSE, um array vazio, ou uma variável declarada porém sem
valor em uma classe.
1 <? php
2 $variavel = 0;
3
4 if ( empty ( $variavel ) ) {
5 echo ’ Esta vari á vel é considerada vazia ! ’;
6 }
1 <? php
2
3 $variavel = ’ ’;
4 if ( isset ( $variavel ) ) {
5 echo "A vari á vel existe !!! " ;
6 }
Como o próprio nome já diz, esta função verifica se determinada variável é um ar-
ray:
1 <? php
2
3 $vetor = array ( ’ Isto ’ , ’é ’, ’ um array ’) ;
4 echo is_array ( $vetor ) ? ’Sim , isto é um array . ’ : ’N ã o é um array ’;
1 <? php
2 $variavel1 = false ;
3
4 if ( is_bool ( $a ) ) {
5 echo ’A vari á vel $a é um valor booleano ’;
6 }
1 <? php
2
3 function teste () {
4 }
5
6 $variavel = ’ teste ’;
7
8 var_dump ( is_callable ( $variavel , false , $nome ) ) ;
9
10 echo $nome , " \ n " ;
A saída será true, pois teste é de fato o nome de uma função válida e logo depois será
apresentado na tela o nome da função, encontrada na variável. Teste este mesmo
exemplo modificando o conteúdo da variável para teste1 por exemplo. A saída deverá
ser falsa, tendo em vista que não há função com este nome.
1 <? php
2 $variavel = 13.33;
3 if ( is_float ( $variavel ) ) {
4 echo "É float !\ n " ;
5 } else {
6 echo "N ã o é float !\ n " ;
7 }
1 <? php
2 $variavel = 13;
3 if ( is_int ( $variavel ) ) {
4 echo "É inteiro !\ n " ;
5 } else {
6 echo "N ã o é inteiro !\ n " ;
7 }
1 <? php
2 $variavel = NULL ;
3
4 if ( is_int ( $variavel ) ) {
5 echo "É nulo !\ n " ;
6 } else {
7 echo "N ã o é nulo !\ n " ;
8 }
1 <? php
2 $variavel = 30;
3
4 if ( is_int ( $variavel ) ) {
5 echo "É um n ú mero !\ n " ;
6 } else {
7 echo "N ã o é um n ú mero !\ n " ;
8 }
1 <? php
2
3 function get_students ( $obj ) {
4 if (! is_object ( $obj ) ) {
5 return false ;
6 }
7
8 return $obj - > students ;
9 }
10
11 $obj = new stdClass () ;
12 $obj -> students = array ( ’ Kalle ’ , ’ Ross ’ , ’ Felipe ’) ;
13
14 var_dump ( get_students ( null ) ) ;
15 var_dump ( get_students ( $obj ) ) ;
1 <? php
2
3 $conexao = @mysql_connect ( ’ localhost ’ , ’ usuario ’ , ’ senha ’) ;
4 if (! is_resource ( $conexao ) ) {
5 die (’Nã o foi poss í vel conectar ! : ’ . mysql_error () ) ;
6 }
1 <? php
2 function show_var ( $variavel ) {
3 if ( is_scalar ( $variavel ) ) {
4 echo $variavel ;
5 } else {
6 echo " N ã o é escalar ! " ;
7 }
8 }
9
10 $pi = 3.1416;
11
12 show_var ( $pi ) ;
1 <? php
Saída:
Perceba que os valores dentro das aspas (simples ou duplas) são consideradas
strings, mesmo que se trate de números ou palavras reservadas.
1 <? php
2 $variavel = true ;
3 settype ( $variavel , " string " ) ;
Veja então que a variável que antes era booleana, foi convertida para seu correspon-
dente em string, "1".
1 <? php
2 $variavel = " teste " ;
3 echo ’ Esta vari á vel é do tipo ’ . gettype ( $variavel ) ;
1 <? php
2 set ( $variavel ) ;
3 echo " Vari á vel criada " ;
4 unset ( $variavel ) ;
5 echo " Vari á vel deletada " ;
Esta é uma das funções mais importantes para quem desenvolve em PHP. Ela apre-
senta detalhes a respeito de uma variável, o que torna mais fácil o reconhecimento
de problemas no código. Muito utilizada para compreender o funcionamento de ar-
rays.
1 <? php
2 $a = array (1 , 2 , array ( " a " , " b " , " c " ) ) ;
3 var_dump ( $a ) ;
1 array (3) {
2 [0]= >
3 int (1)
4 [1]= >
5 int (2)
6 [2]= >
7 array (3) {
8 [0]= >
9 string (1) " a "
10 [1]= >
11 string (1) " b "
12 [2]= >
13 string (1) " c "
14 }
15 }
Muio parecida com a função var_dump, porém a saída é um código PHP válido.
1 <? php
2 $vetor = array (1 , 2 , array ( " a " , " b " , " c " ) ) ;
3 var_export ( $vetor ) ;
4 ?>
1 array (
2 0 => 1,
3 1 => 2,
4 2 =>
5 array (
6 0 => ’a ’ ,
7 1 => ’b ’ ,
8 2 => ’c ’ ,
9 ),
10 )
O PHP possui muitas funções nativas para se trabalhar com strings e manipulá-las.
A partir de agora, veremos algumas dessas funções, exemplos de como trabalhar
com elas, e ver como elas são úteis no dia a dia de um programador PHP.
1 <? php
2 $artilheiro = ’ Ronaldo ’;
3 $gols = 19;
4
5 $formato = ’O artilheiro do brasileir ão , %s , tem % d gols . ’;
6 printf ( $formato , $artilheiro , $gols ) ;
• %s = String
• %f = Float
• %d = Integer
A função sprintf é similar a função printf, mas ao invés de mostrar a string na tela, ela
apenas monta a string.
1 <? php
2 $artilheiro = ’ Jonas ’;
3 $gols = 19;
4
5 $formato = ’O artilheiro do brasileir ão , %s , tem % d gols . ’;
6 $string = sprintf ( $formato , $artilheiro , $gols ) ;
7 echo $string ;
A função vsprintf é similar a função sprintf, mas ela aceita um array de valores a
serem substituídos, ao invés de uma série de parâmetros.
1 <? php
2 $formato = ’O artilheiro do brasileir ão , %s , tem % d gols . ’;
3
4 $string = vsprintf ( $formato , array ( ’ Jonas ’ , ’19 ’) ) ;
5 echo $string ;
A função str_replace permite que você substitua uma ou mais strings por outras,
dentro de uma string maior. Ela recebe três parâmetros: o que você quer substituir,
pelo quê você quer substituir e onde você quer substituir. A função irá retornar a
string com as substituições feitas. Veja o exemplo:
1 <? php
2
Observe que é possível passar não só uma string para os dois primeiros parâmetros,
mas arrays também. Podemos substituir mais de uma palavra por uma string, ou
substituir igualmente:
1 <? php
2
3 $string = " Ol á mundo cruel ! " ;
4
5 $original = array ( ’ mundo ’ , ’ cruel ’) ;
6 $substituto = array ( ’ mundinho ’ , ’ feliz ’) ;
7
8 $novastring = str_replace ( $original , " coisa " , $string ) ;
9 $outrastring = str_replace ( $original , $substituto , $string ) ;
10
11 echo $novastring ;
12 echo $outrastring ;
É exatamente isso que esta função faz. Para realizar o processo contrário, ou
seja, decodificar os caracteres, usamos a função html_entity_decode ou htmlspe-
cialchars_decode.
1 <? php
2 $string = " Tenha um <b > bom </ b > dia ! " ;
3 echo htmlentites ( $string ) ;
4
5 // A sa í da ser á : Tenha um & lt ; bom & gt ; dia !
1 <? php
2 $string = " E ela me disse : ’ tenha um <b > bom dia </ b > ’ e eu tive . " ;
3 echo htmlentities ( $string , ENT_QUOTES ) ;
4
5 // A sa í da ser á : E ela me disse : & # 039; tenha um & lt ; bom & gt ;'
dia e eu tive .
Observe que para verificar se a saída está correta você precisa ver o código fonte da
página.
1 <? php
2 $string = " <a href = ’ http :// www .4 linux . com . br ’ > 4 linux </a > " ;
Observe que para verificar se a saída está correta você precisa ver o código fonte da
página!
Podemos também realizar o processo inverso, ou seja, ao obter um texto que esteja
codificado, podemos transformá-lo em caracteres comuns.
1 <? php
2 $string = " Se ’3 & gt ; 2 ’ ent ã o ’2 & lt ; 3 ’ " ;
3 echo htmlspecialchars_decode ( $string , ENT_QUOTES ) ;
Observe que para verificar se a saída está correta você precisa ver o código fonte da
página!
Esta função retira espaços em branco no início e no final de uma string. Além de
espaços, esta função remove tabulações e linhas em branco. Também é possível
passar por parâmetro outros caracteres queremos remover.
1 <? php
2
3 $string = " \ t \ tTenha um bom dia !!! :) " ;
4 echo $string ;
5
6 $trimmed = trim ( $string ) ;
7 echo $trimmed ;
Veja que no exemplo acima, usando um simples echo, não conseguimos observar
exatamente a saída e que os espaços foram removidos. Para visualizar com mais
detalhes o comportamento da string, vamos utilizar a função var_dump, que nos mos-
trará o número de caracteres existentes na string original e na string modificada.
1 <? php
2
3 $string = " \ t \ tTenha um bom dia !!! :) " ;
4 var_dump ( $string ) ;
5
6 $trimmed = trim ( $string ) ;
7 var_dump ( $trimmed ) ;
1 <? php
2
3 $string = " Testando " ;
4 $trimmed = trim ( $string , " Tedo " ) ;
5 var_dump ( $trimmed ) ;
Esta é uma função bem simples, que recebe como parâmetro uma string e retorna
esta string com o primeiro caracter em maiúsculo.
1 <? php
2
3 $string = ’ hello world ! ’;
4 echo ucfirst ( $string ) ;
5
6 // Sa í da Hello world !
Parecida com ucfirst, porém a função ucwords converte para maiúsculo os primeiros
caracteres de todas as palavras de uma string:
1 <? php
2
3 $string = ’ hello world ! ’;
4 echo ucwords ( $string ) ;
5
6 // Sa í da Hello World !
O retorno desta função é o oposto do que vimos com ucfirst (upper case first). A fun-
ção lcfirst (lower case first) transforma o primeiro caracter da string em minúsculo.
1 <? php
2
3 $string = ’ Hello World ! ’;
4 echo lcfirst ( $string ) ;
5
6 // Sa í da hello World !
Esta função insere a tag <br /> no lugar das newlines presentes na string.
1 <? php
2
3 echo nl2br ( " linha 1\ nlinha2 \ nlinha3 \ n " ) ;
Observe que para verificar se a saída está correta você precisa ver o código fonte da
página!
Observe que por padrão, ele irá separar cada caracter em uma posição do vetor:
1 <? php
2
3 $string = " Oi , tudo bem ? " ;
4 $string1 = str_split ( $string ) ;
5 print_r ( $string1 ) ;
6
7 ?>
8
9 // Sa í da : Array ( [0] = > O [1] = > i [2] = > , [3] = > [4] = > t [5] = >
u [6] = > d [7] = > o [8] = > [9] = > b [10] = > e [11] = > m [12] = >
? )
1 <? php
2
3 $string = " Oi , tudo bem ? " ;
4 $string2 = str_split ( $string , 5) ;
5 print_r ( $string2 ) ;
6
7 ?>
8
9 // Sa í da : Array ( [0] = > Oi , t [1] = > udo b [2] = > em ? )
Esta é uma função simples, que repete a string de acordo com o valor indicado.
1 <? php
2 echo str_repeat ( " @ " , 10) ;
3 ?>
4
5 Sa í da : @@@@@@@@@@
1 <? php
2 $string = " May the force be with you ! " ;
3 print str_pad ( $string , 1000) ;
4 ?>
Observe que para verificar se a saída está correta você precisa ver o código fonte da
página!
1 <? php
2 $string = " May the force be with you ! " ;
3 print str_pad ( $string , 50 , " @ " , STR_PAD_LEFT ) ;
4 print str_pad ( $string , 50 , " @ " , STR_PAD_BOTH ) ;
5 print str_pad ( $string , 50 , " @ " ) ;
6 ?>
Esta função recebe uma string e tem como retorno o contúdo desta string, porém
com seus caracteres misturados.
1 <? php
2
3 $string = ’ labirinto ’;
4 $mix = str_shuffle ( $string ) ;
5 echo $mix ;
Função simples e muito útil. Conta o número de palavras em uma string. Utilizando o
parâmetro 0, mostrará apenas o de palavras. Com o parâmetro 1 mostrará um array
com todas as palavras encontradas naquela string. E com o parâmetro 2 retorna um
array onde a chave será a posição da palavra dentro da string.
1 <? php
2
3 $string = " Oi , como vai voce ? " ;
4 print_r ( str_word_count ( $string , 1) ) ;
5 echo str_word_count ( $string ) ;
6
7 // Sa í da : Array ( [0] = > Oi [1] = > como [2] = > vai [3] = > voce ) 4
Ou também:
1 <? php
2
3 $string = " Oi , como vai voce ? " ;
4 print_r ( str_word_count ( $string , 2) ) ;
5 echo str_word_count ( $string ) ;
6
7 // Sa í da : Array ( [0] = > Oi [4] = > como [9] = > vai [13] = > voce ) 4
1 <? php
2
3 $email = ’ linus@linux . org ’;
4 $dominio = strstr ( $email , ’@ ’) ;
5 echo $dominio ;
6
7 // Sa í da : linux . org
1 <? php
2
3 $user = strstr ( $email , ’@ ’ , true ) ;
4 echo $user ;
5
6 // Sa í da : linus
A funcão strcmp realiza uma comparação entre strings. No exemplo abaixo, como as
duas strings são iguais, o retorno é 0. Se a string1 for maior que a string2 o retorno
será um valor maior de zero, caso contrário o retorno será menor que zero.
1 <? php
2
3 $string1 = ’2 ’;
4 $string2 = ’2 ’;
5 var_dump ( strcmp ( $string1 , $string2 ) ) ;
1 <? php
2
3 $string = ’ May the source be with you ! ’;
4 echo strlen ( $string ) ;
5
6 // Sa í da : 28
1 <? php
2
3 $string = ’0123456789 ’;
4 $procurar = ’7 ’;
5 $pos = strpos ( $string , $procurar ) ;
6
7 if ( $pos === false ) {
8 echo " A string ’ $procurar ’ n ã o foi encontrada na string
’ $string ’ " ;
9 } else {
10 echo " A string ’ $procurar ’ foi encontrada na string ’ $string ’ " ;
11 echo " e existe na posi ç ã o $pos " ;
12 }
13
14 // Sa í da : A string ’7 ’ foi encontrada na string ’0123456789 ’ e
existe na posi ç ã o 7
Apenas um detalhe. Ao realizar esta busca, use três sinais de igual para realizar a
comparação (===). Ao usar apenas dois sinais de igual (==), quando o resultado for
a posição 0, a função retornará que a string não foi encontrada, tendo em vista que
o valor zero também equivale a false em booleano!
1 <? php
2
3 $string = ’0123456789 ’;
4 $procurar = ’0 ’;
5 $pos = strpos ( $string , $procurar ) ;
6
7 if ( $pos == false ) {
8 echo " A string ’ $procurar ’ n ã o foi encontrada na string
’ $string ’ " ;
9 } else {
1 <? php
2
3 $string = ’0123456789 ’;
4 $procurar = ’0 ’;
5 $pos = strpos ( $string , $procurar ) ;
6
7 if ( $pos === false ) {
8 echo " A string ’ $procurar ’ n ã o foi encontrada na string
’ $string ’ " ;
9 } else {
10 echo " A string ’ $procurar ’ foi encontrada na string ’ $string ’ " ;
11 echo " e existe na posi ç ã o $pos " ;
12 }
13
14 // Sa í da : A string ’0 ’ foi encontrada na string ’0123456789 ’ e
existe na posi ç ã o 0
Muito parecida com a função strpos, a função strrpos apresenta a última ocorrência
de um caracter em uma string.
No exemplo abaixo, observe que agora ao buscar o número zero, ele indica que sua
posição é a 10 e não mais a zero.
1 <? php
2
3 $string = ’01234567890123456789 ’;
4 $procurar = ’0 ’;
5 $pos = strrpos ( $string , $procurar ) ;
6
7 if ( $pos == false ) {
8 echo " A string ’ $procurar ’ n ã o foi encontrada na string
’ $string ’ " ;
9 } else {
10 echo " A string ’ $procurar ’ foi encontrada na string ’ $string ’ " ;
11 echo " e existe na posi ç ã o $pos " ;
12 }
13
14 // Sa í da : A string ’0 ’ foi encontrada na string
’01234567890123456789 ’ e existe na posi ç ã o 10
Faz a mesma coisa que a função strrpos, porém não é case sensitive. Ou seja, irá
pesquisar pela última ocorrência de um caracter em uma string, ignorando se a letra
está maiúscula ou minúscula.
1 <? php
2 $string = ’ abcdeABCDEabcdeABCDE ’;
3 $procurar = ’a ’;
4 $pos = strrpos ( $string , $procurar ) ;
5
6 if ( $pos === false ) {
7 echo " A string ’ $procurar ’ n ã o foi encontrada na string
’ $string ’ " ;
8 } else {
Perceba então, que o caracter ’a’ apesar está na posição 0, 5, 10 e 15, é apresentado
como última ocorrência na posição 15, mesmo que o ’A’ que está na posição 15
esteja em maiúsulo.
Faz a mesma coisa que a função strpos, porém não é case sensitive. Ou seja, irá
pesquisar pela primeira ocorrência de um caracter em uma string, ignorando se a
letra está maiúscula ou minúscula.
1 <? php
2
3 $string = ’ abcdeABCDEabcdeABCDE ’;
4 $procurar = ’A ’;
5 $pos = stripos ( $string , $procurar ) ;
6
7 if ( $pos === false ) {
8 echo " A string ’ $procurar ’ n ã o foi encontrada na string
’ $string ’ " ;
9 } else {
10 echo " A string ’ $procurar ’ foi encontrada na string ’ $string ’ " ;
11 echo " e existe na posi ç ã o $pos " ;
12 }
13
Perceba então, que o caracter ’A’ apesar está na posição 0, 5, 10 e 15, é apresentado
como primeira ocorrência na posição 0, mesmo que o ’a’ que está na posição 0 esteja
em minúsculo.
No exemplo abaixo, quero que a saída seja o caracter na posição zero até o caracter
que está na penúltima posição (-1):
1 <? php
2
3 $string = substr ( " 0123456789 " , 0 , -1) ;
4 echo $string ;
5
6 // Sa í da : 012345678
1 <? php
2
3 $string = substr ( " 0123456789 " , 1 , -4) ;
4 echo $string ;
5
6 // Sa í da : 12345
A função substr_replace, como o nome já diz, substitui uma string por outra. No
exemplo abaixo iremos substituir a palavra cedo por tarde:
1 <? php
2
3 $string = ’ hoje acordei muito cedo . ’;
4 echo " Original : $var < hr / >\ n " ;
5 echo substr_replace ( $var , ’ tarde ’ , -5 , -1) . " < br / >\ n " ;
6
7 // Sa í da : hoje acordei muito tarde .
Neste exemplo iremos substituir a palavra cedo por um espaço vazio, ou seja, esta-
remos deletando a plavra da string:
1 <? php
2
3 $string = ’ hoje acordei muito cedo . ’;
4 echo " Original : $var < hr / >\ n " ;
5 echo substr_replace ( $var , ’’, 12 , -1) . " < br / >\ n " ;
6
7 // Sa í da : hoje acordei .
1 <? php
2
Faz a mesma coisa que a função anterior porém ao contrário, ou seja, apresenta a
string em caixa baixa.
1 <? php
2
3 $string = " Luke , eu sou seu pai ! " ;
4 echo strtolower ( $string ) ;
5
6 // Sa í da : Luke , eu sou seu pai !
Existem várias funções nativas no PHP para ordenarmos arrays. Na tabela abaixo
você pode ver as funções mais comuns e suas diferenças, servindo de referência
rápida na hora de ordenar um array.
Exemplo:
1 <? php
2 function cubo ( $num )
3 {
4 return $num * $num * $num ;
5 }
6
7 $a = array (1 , 2 , 3 , 4 , 5) ;
8 $b = array_map ( " cubo " , $a ) ;
9 print_r ( $b ) ;
10 ?>
No exemplo acima, a função cubo recebe um valor como parâmetro e retorna seu
valor multiplicado por ele mesmo três vezes. Isso eqüivale ao número ao cubo. Logo
depois encontramos um arras denominado $a com 5 valores. Abaixo encontramos
um arras $b que chama a função array_map. Esta função está chamando a função
cubo e passando o array $a para que cada número dentro deste array seja calculado
dentro da função cubo.
1 Array ( [0] = > 1 [1] = > 8 [2] = > 27 [3] = > 64 [4] = > 125 )
1 <? php
2
3 function impar ( $variavel )
4 {
1 Impares :
2 Array
3 (
4 [1] = > 7
5 [3] = > 9
6 [5] = > 11
7 )
8 Pares :
9 Array
10 (
11 [0] = > 6
12 [2] = > 8
13 [4] = > 10
14 [6] = > 12
15 )
1 <? php
2
3 $vetor = array ( ’a ’ , ’b ’ , ’c ’ , ’d ’ , ’e ’ , ’f ’ , ’g ’ , ’h ’ , ’i ’) ;
4 print_r ( array_chunk ( $vetor , 3) ) ;
1 Array
2 (
3 [0] = > Array
4 (
5 [0] = > a
6 [1] = > b
7 [2] = > c
8 )
9
10 [1] = > Array
11 (
12 [0] = > d
13 [1] = > e
14 [2] = > f
15 )
16
17 [2] = > Array
18 (
19 [0] = > g
20 [1] = > h
21 [2] = > i
22 )
23
24 )
Perceba então que o array original com 9 itens foi separado em 3 arrays, com 3 itens
cada.
Esta função une dois arrays, sendo um array usado para as chaves e outro para os
itens.
1 <? php
2
3 $vetor1 = array ( ’1 ’ , ’2 ’ , ’3 ’) ;
4 $vetor2 = array ( ’ um ’ , ’ dois ’ , ’ tr ês ’) ;
5 $vetor3 = array_combine ( $vetor1 , $vetor2 ) ;
6
7 print_r ( $vetor3 ) ;
Desta forma teremos o vetor1 indicando o índice do vetor e vetor2 indicando os va-
lores.
1 Array
2 (
3 [1] = > um
4 [2] = > dois
5 [3] = > tr ê s
6 )
1 <? php
2
3 $vetor1 = array ( " a " = > " amor " , " paix ã o " , " carinho " , " saudade " ) ;
4 $vetor2 = array ( " b " = > " amor " , " paix ã o " , " saudade " ) ;
5 $resultado = array_diff ( $vetor1 , $vetor2 ) ;
6 print_r ( $resultado ) ;
1 Array
2 (
3 [1] => carinho
4 )
1 <? php
2
3 $vetor1 = array ( " cor " = > " vermelho " , 2 , 4) ;
4 $vetor2 = array ( " a " , " b " , " cor " = > " verde " , " forma " = >
" trapezoide " , 4) ;
1 Array
2 (
3 [ cor ] = > verde
4 [0] = > 2
5 [1] = > 4
6 [2] = > a
7 [3] = > b
8 [ forma ] = > trapezoide
9 [4] = > 4
10 )
Perceba que a cor verde sobrepôs a cor vermelha ao realizar o merge, pois estavam
utilizando o mesmo índice (string). Quando o índice era numérico não houve sobre-
posição, então os demais valores foram apenas unidos, formando assim um novo
array.
1 <? php
2
3 $vetor = array_fill (5 , 3 , ’ Preenchendo ’) ;
4 print_r ( $vetor ) ;
1 Array
2 (
3 [5] = > Preenchendo
4 [6] = > Preenchendo
5 [7] = > Preenchendo
6 )
Onde o valor 5 indica o índice, ou seja, o vetor será preenchido a partir daquele
índice. O valor 3 indica o número de itens a serem acrescentados.
1
2 <? php
3
4 $vetor = array ( " a " = > 0 , " b " = > 1 , " c " = > 2) ;
5 $vetor = array_flip ( $vetor ) ;
6 print_r ( $vetor ) ;
1 Array
2 (
3 [0] = > a
4 [1] = > b
5 [2] = > c
6 )
Esta função reduz o vetor a um único valor, utilizando para isso uma função.
1 <? php
2 function soma ( $v , $w ) {
3 $v += $w ;
4 return $v ;
5 }
6
7 $vetor = array (1 , 2 , 3 , 4 , 5) ;
8 $resultado = array_reduce ( $vetor , " soma " ) ;
9 echo $resultado ;
Saída: 15
1 <? php
2
3 $vetor = array ( " a " = > 1 , " b " = > 2) ;
4 if ( array_key_exists ( " b " , $vetor ) ) {
5 echo " O elemento ’b ’ est á no array ! " ;
6 }
Esta função faz uma busca em um vetor por um valor. Ao encontrá-lo, retorna a
chave indicando a posição em que o valor se encontra.
1 <? php
2
3 $vetor = array (0 = > ’a ’ , 1 = > ’b ’ , 2 = > ’c ’ , 3 = > ’d ’) ;
4 $chave = array_search ( ’d ’ , $vetor ) ;
5 echo $chave ;
Saída: 3
1 <? php
2 $vetor = array ( " a " , " b " , " c " , " d " , " e " ) ;
3 print_r ( array_slice ( $vetor , 0 , 3) ) ;
4 ?>
Onde 0 indica o índice do primeiro valor e 3 indica o número de itens que deve ser
apresentado.
Saída:
1 Array
2 (
3 [0] = > a
4 [1] = > b
5 [2] = > c
6
7 )
Esta função remove uma parte do vetor e subsitui com outros valores.
1 <? php
2
3 $vetor = array ( " vermelho " , " verde " , " azul " , " amarelo " ) ;
4 array_splice ( $vetor , -1 , 1 , array ( " preto " , " marrom " ) ) ;
Neste exemplo, o item amarelo será removido e substituído pelos valores preto e
marrom. Sendo assim o valor do vetor será: ("vermelho", "verde", "azul", "preto",
"marrom")
1 <? php
2 $vetor = array ( " laranja " , " banana " , " ma ç ã " , " mam ã o " ) ;
3 $subtituir = array (0 = > " abacaxi " , 4 = > " cereja " ) ;
4 print_r ( array_replace ( $vetor , $substituir ) ) ;
5 ?>
Saída:
1 Array
2 (
3 [0] = > abacaxi
4 [1] = > banana
5 [2] = > ma ç ã
6 [3] = > mam ã o
7 [4] = > cereja
8 )
1 <? php
2
3 $vetor = array (1 , 2 , 3 , 4) ;
4 echo "A soma dos valores é = " . array_sum ( $vetor ) ;
Saída: 11
1 <? php
2
3 $vetor = array (1 = > " verde " , 2 = > " vermelho " , 3 = > " verde " , 4 = >
" azul " , 5 = > " vermelho " ) ;
1 Array
2 (
3 [1] = > verde
4 [2] = > vermelho
5 [4] = > azul
6
7 )
1 <? php
2
3 $frutas = array ( " lim ã o " , " laranja " , " banana " , " melancia " ) ;
4
5 function test_print ( $item , $key ) {
6 echo " $key . $item < br >\ n " ;
7 }
8
9 array_walk ( $frutas , ’ test_print ’) ;
Mais uma função que verifica se determinado valor está presente em um vetor.
1 <? php
2
3 $vetor = array ( " um " , " dois " , " tr ê s " , " quatro " ) ;
4 if ( in_array ( " dois " , $vetor ) ) {
5 echo " Encontrei o valor dois " ;
6 }
1 <? php
2
3 $vetor = array ( " um " , " dois " , " tr ê s " , " quatro " ) ;
4 $resultado = count ( $vetor ) ;
5 echo $resultado ;
Saída: 4
A função serialize permite que você transforme um array em uma string, que pode
ser armazenada de várias formas diferentes.
1 <? php
2
3 $array = array ( ’ Luke ’ , ’ Leia ’ , ’ Han Solo ’ , array ( ’ Vader ’ , ’ Storm
Trooper ’) ) ;
4 serialize ( $array ) ;
A função mail, como o próprio nome diz, permite o envio de e-mails através do PHP.
1 <? php
2
3 $messagem = " Ol á \ nEnvio este e - mail para desejar \ num bom dia !!! " ;
4 mail (’ fulano@empresa . com . br ’ , ’ Assunto ’ , $messagem ) ;
1 <? php
2
3 $string = ’ exemplo ’;
4 echo md5 ( $string )
Assim como a função md5(), existem outras, relacionadas a outros tipos de algorit-
mos de hash como por exemplo sha1(), crc32(), etc. A função sha calcula a hash
sha1 de uma string.
1 <? php
2
3 $string = ’ exemplo ’;
4 echo sha1 ( $string )
Ainda é possível utiliza a função hash, que permite escolhermos qual tipo de algo-
ritmo de hash enviar como parâmetro para a função:
1 <? php
2
3 $string = ’ exemplo ’;
4 echo hash ( md5 , $string )
Funcionalidades Web
4Linux – www.4linux.com.br Funcionalidades Web
Toda aplicação web, seja ela construída utilizando PHP, Python, Ruby, Java ou qual-
quer outra linguagem, vive sob as normas e especificações do protocolo HTTP. O
protocolo HTTP, HyperText Transfer Protocol, define como mensagens são formata-
das e transmitidas, além de quais ações servidores web e navegadores devem tomar
em resposta a vários comandos diferentes. Por exemplo, quando você coloca uma
URL em seu navegador, isso na verdade envia um comando HTTP para o servidor
web desta página, que irá localizar o documento que você quer ver e transmiti-lo para
seu navegador.
São definidos no protocolo HTTP oito métodos que indicam a ação a ser realizada
a partir de uma requisição. Os oito métodos são GET, HEAD, POST, PUT, DELETE,
TRACE, OPTIONS e CONNECT.
5.2 Sessões
O protocolo HTTP é stateless, portanto, cada requisição GET, POST, PUT, etc. é
independente. Não é possível saber se o GET feito há 5 minutos foi feito por mim ou
por outro usuário. Isso complica um pouco a nossa vida quando queremos criar, por
exemplo, aplicações com autenticação, com partes da aplicação acessíveis somente
por um usuário específico.
Para contornar este problema, existe a sessão. A sessão pode ser criada pelo PHP,
que irá identificar o usuário e manter uma sessão viva para ele. Cada visitante terá
uma sessão e através dela poderemos identificar quem é que, inclusive, autenticá-
los.
O tempo de vida de uma sessão é, por padrão, 24 minutos. Esse valor pode ser
alterado na configuração do PHP, alterando a diretiva session.gc_maxlifetime.
5.3 Cookies
Podemos utilizar cookies para vários fins, mas seu uso mais comum é para salvar as
preferências do usuário na sua aplicação (língua padrão, cor do texto, se ele gosta de
café ou chá, etc.). Também é comum utilizar cookies para manter um usuário logado
em nosso sistema, mesmo que a sessão expire.
Cookies possuem um tempo de vida, definido pelo website que o criou. O navegador
irá removê-los automaticamente quando este tempo de vida expirar, mas o usuário
sempre poderá limpar os cookies de seu navegador manualmente.
O método GET serve para fazer uma requisição de recurso, seja este recurso uma
página web (HTML), um script (PHP) ou qualquer outro arquivo, como uma imagem
ou um vídeo. Uma vez feita a requisição, o servidor irá retornar o recurso pedido.
O método POST serve para enviar dados a serem processados pelo recurso espe-
cificado. Os dados a serem processados são sempre inclusos no corpo do método
POST. É através do método POST que é possível preencher e processar formulários
na web.
Por exemplo, quando colocamos uma URL em nosso navegador e apertamos enter,
a seguinte requisição é enviada:
Após essa requisição, nosso navegador receberá uma resposta. Que parece mais
ou menos com isto:
5 Connection : close
6 Pragma : public
7 Etag : " be65d40792fe1a9d5bebcad7dfdd8205 "
8 Cache - Control : max - age =3600 , public
9 Content - Type : text / html ; charset = UTF -8
10 Last - Modified : Thu , 18 Aug 2011 14:38:14 GMT
11 Content - Encoding : gzip
12 Vary : Accept - Encoding , Cookie , User - Agent
13
14 CONTE Ú DO DA P À GINA AQUI
1 <? php
2
3 header (’ Location : http :// www .4 linux . com . br ’) ;
Quando entrarmos nesse script PHP, seremos redirecionados para a página inicial
da 4Linux. Podemos também manipular os cabeçalhos HTTP e dizer que a página
não é realmente uma página, e sim, um arquivo qualquer. Por exemplo:
1 <? php
2 header (’ Content - type : application / pdf ’) ;
3
4 header (’ Content - Disposition : attachment ; filename = " documento . pdf " ’) ;
5
No PHP, existem variáveis nativas que estão disponíveis em qualquer escopo. Elas
são, na maioria das vezes, arrays bidimensionais ou multidimensionais. As variáveis
supergloais são essenciais para qualquer aplicação web. Já vimos um pouco sobre
POST e GET e logo logo veremos como trabalhar com eles no PHP.
5.6.1 $_SERVER
5.6.2 $_ENV
5.6.3 $_GET
Contém variáveis passadas para o script usando o método HTTP GET, isto é, através
da URL.
1 <? php
2 echo $_GET [ ’ meunome ’]; // Retorna Z é
5.6.4 $_POST
Contém variáveis passadas para o script usando o método HTTP POST, isto é, atra-
vés de um formulário.
1 <? php
2
3 if ( $_POST ) {
4 echo $_POST [ ’ meunome ’];
5 }
6
7 ?>
8 < form action = " teste . php " method = " POST " >
9 < input type = " text " name = " meunome " / >
10 < input type = " submit " value = " Enviar " / >
11 </ form >
5.6.5 $_SESSION
Contém variáveis definidas durante a sessão do navegador. Deve ser usada junto
com a função session_start().
1 <? php
2 session_start () ;
3
4 $_SESSION [ ’ MeuCarro ’] = ’ Palio ’;
5
6 echo $_SESSION [ ’ MeuCarro ’];
5.6.6 $_COOKIE
1 <? php
2 setcookie ( " MeuCarro " , " Palio " ) ;
3 echo $_COOKIE [ ’ MeuCarro ’];
1 <? php
2 setcookie ( " MeuCarro " , " Palio " , strtotime ( " +1 month " ) ) ;
3 echo $_COOKIE [ ’ MeuCarro ’];
5.6.7 $_REQUEST
5.6.8 $_FILES
5.6.9 $GLOBALS
1 <? php
2
3 function carro () {
4 $carro = " Fiesta local " ;
5
6 echo ’ $carro no escopo global ’ . $GLOBALS [ " carro " ] . ’ < br / > ’;
7 echo " \ $carro no escopo local : $carro " ;
8 }
9
10 $carro = " Fiesta global " ;
11 echo carro () ;
5.7 Formulários
Processamento de formulários é uma das tarefas mais comuns quando estamos tra-
balhando com aplicações web. É através dos formulários que nossos usuários po-
dem manipular e gerenciar informações, portanto é possível dizer que os formulários
são a pedra filosofal das aplicações web.
Quando um formulário é enviado, suas informações são enviadas para algum lugar
através do método POST. Este "algum lugar"irá interpretar as informações e fazer
"alguma coisa"com elas. Como fazemos essa teoria virar prática? Fácil. Já conhe-
cemos o protocolo, seus métodos e variáveis superglobais no PHP. Para montar um
formulário e processá-lo, só nos falta criar o formulário:
exemplos/formulario.html
1 < html >
2 < head >
3 <h1 > Meu formul á rio </ h1 >
4
5 < form action = " processa . php " method = " POST " >
6 <p >< label > Nome : </ label > < input type = " text " name = " nome " / > </ p >
7 <p >< label > Email : </ label > < input type = " text " name = " email " / > </ p >
8 <p ></p >
9 <p >< input type = " submit " value = " Enviar " / > </ p >
10 </ form >
11
12 </ head >
13 </ html >
Nosso formulário é bem simples. Observe que o campo action está direcionando
para o arquivo processa.php. É este arquivo que vai receber a requisição POST e
processar as informações do nosso formulário vindas no cabeçalho. Não temos ele
ainda, certo? Então vamos criá-lo:
exemplos/processa.php
1 <? php
2
3 echo " Recebi um formul á rio de { $_POST [ ’ nome ’]} , com o email
{ $_POST [ ’ email ’]}. " ;
Agora, observe este segundo exemplo. Não vamos mais ter o formulário em uma
página e processá-lo em outra, vamos fazer tudo em uma só página.
exemplos/formulario.php
1 <? php
2
3 if ( $_POST ) {
4 echo " Recebi um formul á rio de { $_POST [ ’ nome ’]} , com o email
{ $_POST [ ’ email ’]}. " ;
5 }
6
7 ?>
8 <html >
9 <head >
10 <h1 > Meu formul á rio </ h1 >
11
12 < form action = " " method = " POST " >
13 <p >< label > Nome : </ label > < input type = " text " name = " nome " / > </p >
14 <p >< label > Email : </ label > < input type = " text " name = " email " / > </p >
15 <p > </p >
16 <p >< input type = " submit " value = " Enviar " / > </p >
17 </ form >
18
19 </ head >
20 </ html >
Note que o campo action está vazio. Quando o campo action de um formulário está
vazio, ele irá fazer a requisição para a própria página. Note também que temos uma
condição envolvendo nosso echo. Essa condição serve para executarmos aquele
bloco de código somente quando recebermos uma requisição POST. Mas porque
isso? Porque não queremos acessar a variável superglobal $_POST sem que ela
possua valores, senão, teremos alguns erros em nossa página.
Banco de Dados
4Linux – www.4linux.com.br Banco de Dados
Durante a maior parte do tempo como um desenvolvedor, você irá criar ou encontrar
aplicações que utilizam alguma forma de armazenamento de dados. Estes dados
podem estar sendo armazenados em simples arquivos no sistema de arquivos de
máquina, ou podem estar sendo armazenados em estruturas mais complexas como
um banco de dados. Bancos de dados, em sua grande maioria, são constituídos
com base nas relações existentes entre suas entidades, dando o nome de bancos
de dados relacionais.
6.3 MySQL
Desde a versão 3, o PHP possui um suporte muito sólido ao MySQL. Hoje, na ver-
são 5, existem três formas de nos comunicarmos com um banco de dados MySQL.
Existe a extensão MySQL clássica, que existe desde a versão 3, e existe também a
extensão MySQL Improved (mysqli), adicionada na versão 5. E, é claro, a extensão
PDO (PHP Data Objects), também adicionada na versão 5. Neste curso, aprendere-
mos a trabalhar com a extensão clássica. No segundo curso da Formação PHP da
4Linux trabalharemos com o PDO.
A grande maioria das distribuições Linux possuem pacotes do MySQL em seus re-
positórios. Isso nos ajuda muito e torna a instalação do MySQL muito simples e
rápida. Abra o shell, logue como root e use o gerenciador de pacotes para instalar o
MySQL:
1 su
2 apt - get update
3 apt - get install mysql - server
Durante a instalação o MySQL irá pedir para você definir uma senha padrão para o
usuário root no MySQL. Escolha uma senha ou coloque 123456.
1 mysql -u root -p
O MySQL irá pedir a senha do usuário root. Por padrão, essa senha é definida por
você durante a instalação do MySQL. Uma vez dentro do shell do MySQL, podemos
começar a interagir com o sistema gerenciador de banco de dados utilizando a lin-
guagem SQL. Antes de trabalharmos em um banco de dados, precisamos selecioná-
lo para uso. No mySQL, fazemos isso utilizando o comando USE:
1 USE nomedobanco ;
6.4 PostgreSQL
O PHP trabalha muito bem com o PostgreSQL e, assim como o MySQL, possui
extensões nativas para trabalhar com ele. Existem duas formas de nos comunicar-
mos com um banco de dados PostgreSQL: a primeira, utilizando a extensão pgsql,
e a segunda, utilizando o PDO. Neste curso vamos conhecer a extensão pgsql e
como usá-la para fazer nossas aplicações interagirem com um banco de dados Post-
greSQL.
1 su
2 apt - get update
3 apt - get install postgresql
Para trabalhar com o PostgreSQL, você precisa estar logado como o superusuário
postgres.
1 su - postgres
1 psql
Uma vez dentro do shell do PostgreSQL, podemos começar a interagir com o sistema
gerenciador de banco de dados utilizando a linguagem SQL. Antes de trabalharmos
em um banco de dados, precisamos selecioná-lo para uso. No PostgreSQL, fazemos
isso pela linha de comando passando um parâmetro para o psql:
1 psql nomedobanco
6.5 SQLite
O PHP possui uma extensão para se trabalhar com o SQLite. Essa extensão traz
dentro de si o próprio SQLite, então podemos dizer que é como se o PHP tivesse
um banco de dados embutido, sem precisarmos conectar ou instalar um sistema
gerenciador de banco de dados como MySQL ou PostgreSQL.
Vamos conhecer alguns comandos SQL básicos para montarmos nosso primeiro
banco de dados. Embora o padrão SQL seja único, diferentes sistemas gerencia-
dores de banco de dados implementam o padrão de maneiras diferentes. Portanto,
alguns comandos em MySQL são diferentes em PostgreSQL. Vamos mostrar aqui as
principais diferenças.
Note que a linguagem SQL é muito fácil de compreender. Quando você está fazendo
uma declaração ou consulta, é praticamente uma frase que você está escrevendo.
Justamente por isso, é fácil se confundir entre informações e comandos. Portanto,
quando estiver escrevendo SQL, escreva comandos, cláusulas e expressões sempre
com letras maiúsculas, e informações, minúsculas.
6.6.1 Create
O comando CREATE permite que nós criemos uma série de elementos comuns em
um banco de dados. Com o comando create, podemos criar bancos de dados, tabe-
las, índices, sequências e muito mais. Vamos conhecer os casos mais comuns de
uso do Create.
Observe que declarações SQL sempre devem ser terminadas com um ponto-e-
vírgula.
Podemos criar uma tabela em nosso banco de dados utilizando a seguinte declara-
ção SQL:
Uma tabela é como uma pasta, onde podemos guardar informações separadas por
colunas. Vamos criar uma tabela "posts", para guardar as informações dos posts de
nosso blog, como o seu título e o conteúdo do post.
Observe que, a cada linha, criamos colunas para nossa tabela. Colunas são como
seções da pasta que criamos, que podem conter determinados tipos de informações.
Esses tipos de informações foram especificados na própria linha, onde dizemos de-
pois do nome da coluna se ela é VARCHAR ou TEXT. Logo veremos mais sobre
isso.
Observe também a linha PRIMARY KEY. Primary key significa chave primária e, do
ponto de vista de bancos de dados relacionais, é a chave que identifica o registro em
uma tabela. Cada registro é único e possui um valor. Esse valor é a chave primária.
Precisamos de uma coluna para nossas chaves primárias e estamos dizendo que a
coluna id será essa coluna.
Podemos criar uma sequência para uma tabela de nosso banco de dados utilizando
a seguinte declaração SQL:
Sequências são úteis para colunas que devem ser automaticamente incrementadas
ou decrementadas quando um registro for inserido na tabela.
Criar um índice
Podemos criar um índice em uma tabela de nosso banco de dados utilizando a se-
guinte declaração SQL:
Índices servem para melhorar a performance de nosso banco. Quando fazemos mui-
tas consultas em algumas colunas, é importante que seja criado um índice nessas
colunas.
Além de chaves primárias, nossas tabelas podem ter chaves estrangeiras. Chaves
estrangeiras são chaves que estão diretamente relacionadas com outras chaves de
outras tabelas no mesmo banco de dados. Por exemplo: um post e um usuário. Um
post está diretamente relacionado ao seu autor, isto é, usuário. Portanto, podemos
criar uma chave estrangeira e relacionar a tabela de posts com usuários:
6.6.3 Alter
Na primeira linha estamos modificando o tipo da coluna titulo para TEXT. Na se-
gunda, adicionamos uma nova coluna chamada autor. Na terceira, removemos a
coluna conteudo. E, na última linha, adicionamos uma chave primária em nossa
tabela na coluna id.
6.6.4 Drop
O comando DROP permite que nós deletemos bancos de dados e tabelas. Ele é
muito similar ao create, mas possui menos parâmetros.
6.6.5 Truncate
O comando TRUNCATE permite que nós esvaziemos uma tabela em nosso banco
de dados. Isso irá remover todos os registros de uma tabela.
6.6.6 Insert
O comando INSERT permite a inserção de registros em uma tabela. É com ele que
nós podemos começar a aprender mais sobre manipulação de dados em um banco
de dados relacional. Para inserir informações em uma tabela, podemos:
Observe que estamos especificando não só os valores que queremos inserir, mas
onde queremos inseri-los. Especificamos que vamos inserir dados nas colunas titulo
e conteudo, e logo depois com a cláusula VALUES, especificamos que valores irão
nestas colunas respectivamente.
6.6.7 Update
Podemos utilizar o comando UPDATE para atualizar registros em uma tabela. Para
atualizar registros, podemos:
1 UPDATE posts SET titulo = ’ Novo post ’ WHERE titulo = ’ Meu primeiro
post ’;
2 UPDATE posts SET titulo = ’ Novo post ’ , conteudo = ’ Novo conteudo ’
WHERE id =1;
Usamos a cláusula SET para especificar quais colunas receberão novos valores.
Podemos especificar mais de uma coluna separando-as por vírgulas.
Observe que temos uma cláusula WHERE junto de nosso comando UPDATE. A cláu-
sula WHERE espera uma condição e serve como filtro. Caso os registros de nossa
tabela batam com a condição especificada no WHERE, eles serão repassados para
o comando que utilizamos, neste caso o UPDATE.
É comum utilizarmos a chave primária de um registro para fazer condições onde que-
remos encontrar um registro específico, mas podemos fazer condições com qualquer
coluna da tabela. E não só condições de igualdade:
• Igual: =
• Diferente: != ou <>
1 UPDATE posts SET titulo = ’ Novo post ’ WHERE categoria = 1 AND tag =
’ futebol ’;
6.6.8 Delete
6.6.9 Select
O primeiro parâmetro que o comando SELECT espera são as colunas que queremos
ver. O segundo parâmetro é a tabela que queremos consultar. Quando não quiser-
mos ver colunas específicas, mas sim, todas as colunas de uma tabela, podemos
utilizar o asterisco.
Organizando resultados
Por padrão, será utilizada a ordem ascendente. Mas podemos, como na segunda
linha do exemplo acima, organizar de forma descendente. Se organizarmos de forma
descendente uma coluna que possui letras, não números, a ordem será Z-A não A-
Z.
Limitando resultados
Buscando informações
A primeira linha irá trazer todos os registros da tabela post que possuam exatamente
a frase "Meu carro"na coluna titulo. Já a segunda linha irá trazer todos os registros
que possuam em qualquer parte da coluna titulo a palavra "futebol".
Usamos o % para indicar um curinga, que pode representar qualquer letra, número
ou palavra em nossa string.
6.6.10 Join
O comando join permite que, em uma consulta SQL, nós juntemos duas tabelas a
partir de uma condição. Vamos supor que nós estamos querendo saber todos os
posts que possuem uma categoria. Vamos executar a seguinte consulta:
Esta consulta irá retornar apenas os posts que possuem categorias, deixando de
lado os posts que não possuem.
Esta consulta irá retornar todos os posts, mesmo que eles não possuam uma cate-
goria.
O comando right join é muito similar ao left join, contudo, ele preservará os resultados
da tabela que está à direita do comando.
O comando inner join é um pouco diferente dos joins que já vimos. Ele permite que
seja feita a união de tabelas através das suas relações com chaves estrangeiras,
também conhecidas como foreign keys. Vamos supor que nós temos duas tabelas,
uma de usuários e uma de seguidores. Algo como um mini-twitter.
As colunas de uma tabela em um banco de dados podem ter diferentes tipos. É im-
portantíssimo que durante a modelagem de nosso banco, façamos a escolha correta
de tipos de dados, garantindo boa performance e alocação correta de memória.
Tipos de dados
Tipos de números
Observe que X é onde você define o tamanho do dado. UNSIGNED significa que o
número inteiro só pode ser positivo.
Tipos de datas
Outros tipos
ENUM (’a’, ’b’, ’c’): Significa enumeração e permite que você especifique uma lista
de valores possíveis para a coluna. De 1 a 65535.
SET (’a’, ’b’, ’c’): Similar ao ENUM, exceto que múltiplos valores podem ser escolhi-
dos. De 1 a 64.
Quando criamos nossa tabela, criamos uma coluna do tipo INT, não nula. Depois,
definimos essa coluna como sendo a chave primária de nossa tabela. Chaves primá-
rias precisam ser únicas, portanto, não é interessante deixarmos o preenchimento
dessa coluna a cargo do software ou do usuário. O banco é que deveria controlar
essa chave.
Lembram das sequences que falamos anteriormente? Elas permitem que incremen-
temos ou decrementemos o valor de uma coluna quando um registro for inserido na
tabela desta coluna. E isso é exatamente o que queremos fazer quando estamos
trabalhando com bancos de dados relacionais e chaves primárias.
No PostgreSQL, criamos uma tabela e uma sequência para que a chave primária
seja incrementada toda vez que um registro for adicionado na tabela. Fazemos isso
da seguinte forma:
Para fazer nossa aplicação em PHP conversar com um banco de dados MySQL, nós
precisamos utilizar um conjunto de funções disponíveis na extensão MySQL do PHP.
Com essas funções, podemos conectar com um banco de dados, executar comandos
e fazer consultas.
Para podermos fazer uso dessas funções, precisamos instalar a extensão MySQL
em nosso PHP, o que pode ser feito com uma simples instalação de pacote:
6.9.1 Conexão
1 mysql_connect ( " localhost " , " root " , " 123456 " ) ;
2 mysql_select_db ( " nomedobanco " ) ;
A fim de interagirmos com nosso banco de dados, precisamos de uma função que
nos permita executar declarações e consultas SQL. Essa função é a mysql_query().
Com esta função, podemos executar INSERTs, UPDATEs e outros comandos SQL.
1 mysql_connect ( " localhost " , " root " , " 123456 " ) ;
2 mysql_select_db ( " blog " ) ;
3
4 $titulo = " Meu primeiro post " ;
5 $conteudo = " Meu post tri legal no meu blog ! "
6
7 mysql_query ( " INSERT INTO posts ( titulo , conteudo ) VALUES
(’ $titulo ’ , ’ $conteudo ’) " ) ;
Note também que não precisamos terminar nossa declaração com ponto-e-vírgula.
1 mysql_connect ( " localhost " , " root " , " 123456 " ) ;
2 mysql_select_db ( " blog " ) ;
3
4 $id = 1;
5 $titulo = " Meu novo post " ;
6
7 mysql_query ( " UPDATE posts SET titulo = ’ $titulo ’ WHERE id = $id " ) ;
1 mysql_connect ( " localhost " , " root " , " 123456 " ) ;
2 mysql_select_db ( " blog " ) ;
3
4 $id = 5;
5
6 mysql_query ( " DELETE FROM posts WHERE id = $id " ) ;
Para fazer uma consulta em uma tabela, sabemos que precisamos utilizar o comando
SELECT, portanto:
1 mysql_connect ( " localhost " , " root " , " 123456 " ) ;
2 mysql_select_db ( " blog " ) ;
3
4 mysql_query ( " SELECT * FROM posts " ) ;
Mas e agora? Fizemos a consulta, mas como podemos ver os resultados dela? A
função mysql_fetch_array() permite que nós vejamos os resultados de uma consulta
SQL como se fosse um array, onde as colunas são as chaves de nosso array e os
valores das colunas, valores do array.
1 mysql_connect ( " localhost " , " root " , " 123456 " ) ;
2 mysql_select_db ( " blog " ) ;
3
4 $query = mysql_query ( " SELECT * FROM posts " ) ;
5
6 while ( $item = mysql_fetch_array ( $query ) ) {
7 echo $item [ ’ titulo ’];
8 }
O bloco de código dentro do while simplesmente traz o valor contido na coluna titulo
no registro atual. Listaremos, assim, todos os registros da tabela. Note também
que associamos uma variável ao retorno da função mysql_query() e passamos essa
variável como parâmetro para a mysql_fetch_array(), que precisa saber com qual
consulta ela vai trabalhar.
Para fazer nossa aplicação em PHP conversar com um banco de dados PostgreSQL,
nós precisamos utilizar um conjunto de funções disponíveis na extensão PostgreSQL
do PHP. Com essas funções, podemos conectar com um banco de dados, executar
comandos e fazer consultas.
Para podermos fazer uso dessas funções, precisamos instalar a extensão Post-
greSQL em nosso PHP, o que pode ser feito com uma simples instalação de pa-
cote:
6.10.1 Conexão
1 pg_connect ( " host = localhost port =5432 dbname = blog user = root
password =123456 " ) ;
A função pg_connect() espera apenas um parâmetro, mas este parâmetro pode pos-
suir sub-parâmetros separados por espaço. Observe que na verdade estamos pas-
sando cinco parâmetros: o hostname do servidor que vamos conectar, a porta do
servidor, o nome do banco, o usuário e sua senha.
A fim de interagirmos com nosso banco de dados, precisamos de uma função que
nos permita executar declarações e consultas SQL. Essa função é a pg_query().
Com esta função, podemos executar INSERTs, UPDATEs e outros comandos SQL.
1 pg_connect ( " host = localhost port =5432 dbname = blog user = root
password =123456 " ) ;
2
3 $titulo = " Meu primeiro post " ;
4 $conteudo = " Meu post tri legal no meu blog ! "
5
6 pg_query ( " INSERT INTO posts ( titulo , conteudo ) VALUES ( ’ $titulo ’ ,
’ $conteudo ’) " ) ;
Note também que não precisamos terminar nossa declaração com ponto-e-vírgula.
1 pg_connect ( " host = localhost port =5432 dbname = blog user = root
password =123456 " ) ;
2
3 $id = 1;
4 $titulo = " Meu novo post " ;
5
6 pg_query ( " UPDATE posts SET titulo = ’ $titulo ’ WHERE id = $id " ) ;
1 pg_connect ( " host = localhost port =5432 dbname = blog user = root
password =123456 " ) ;
2
3 $id = 5;
4
5 pg_query ( " DELETE FROM posts WHERE id = $id " ) ;
Para fazer uma consulta em uma tabela, sabemos que precisamos utilizar o comando
SELECT, portanto:
1 pg_connect ( " host = localhost port =5432 dbname = blog user = root
password =123456 " ) ;
2
3 pg_query ( " SELECT * FROM posts " ) ;
Mas e agora? Fizemos a consulta, mas como podemos ver os resultados dela? A
função pg_fetch_all() permite que nós vejamos os resultados de uma consulta SQL
como se fosse um array, onde as colunas são as chaves de nosso array e os valores
das colunas, valores do array.
1 pg_connect ( " host = localhost port =5432 dbname = blog user = root
password =123456 " ) ;
2
3 $query = pg_query ( " SELECT * FROM posts " ) ;
4
5 $itens = pg_fetch_all ( $query ) ;
6
7 foreach ( $itens as $item ) {
8 echo $item [ ’ titulo ’];
9 }
Note também que associamos uma variável ao retorno da função pg_query() e pas-
samos essa variável como parâmetro para a pg_fetch_all(), que precisa saber com
qual consulta ela vai trabalhar.
Para fazer nossa aplicação em PHP conversar com um banco de dados SQLite, nós
precisamos utilizar um conjunto de funções disponíveis na extensão SQLite do PHP.
Com essas funções, podemos abrir um banco de dados, executar comandos e fazer
consultas.
Para podermos fazer uso dessas funções, precisamos instalar a extensão SQLite em
nosso PHP, o que pode ser feito com uma simples instalação de pacote:
6.11.1 Conexão
Este arquivo, criado pelo SQLite, é o seu banco de dados. Ele pode estar na pasta
da sua aplicação ou em qualquer outro parte do sistema. Para usarmos o banco,
mas abrir o arquivo. Caso o arquivo não exista, isto é, o banco não exista, ele será
criado automaticamente.
A fim de interagirmos com nosso banco de dados, precisamos de uma função que
nos permita executar declarações e consultas SQL. Essa função é a sqlite_query().
Com esta função, podemos executar INSERTs, UPDATEs e outros comandos SQL.
Note também que não precisamos terminar nossa declaração com ponto-e-vírgula.
Para fazer uma consulta em uma tabela, sabemos que precisamos utilizar o comando
SELECT, portanto:
Mas e agora? Fizemos a consulta, mas como podemos ver os resultados dela?
A função sqlite_fetch_all() permite que nós vejamos os resultados de uma consulta
SQL como se fosse um array, onde as colunas são as chaves de nosso array e os
valores das colunas, valores do array.