Curso PHP Introdução

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

Roteiro
•Introdução
•Instalação e Configuração
•PHP Básico
–Estrutura Léxica
–Tipos de Dados
–Variáveis
–Expressões e Operadores
–Instruções de Controle de Fluxo
–Incluindo Código
–PHP Embarcado em Páginas Web

Introdução
•PHP é um acrônimo recursivo para “PHP: Hypertext Preprocessor”, originalmente Personal Home Page
•É uma linguagem interpretada livre, usada originalmente apenas para o desenvolvimento de aplicações presentes e atuantes no lado do servidor, capazes de gerar conteúdo dinâmico na Web
•Figura entre as primeiras linguagens passíveis de inserção em documentos HTML
•O código é interpretado no lado do servidor pelo módulo PHP, que também gera a página web a ser visualizada no lado do cliente como documentos HTML

Introdução
•Criado por Rasmus Lerdorf em 1995
•É mantida por uma organização chamada The PHP Group
•É software livre, licenciado sob a PHP License
–Uma licença incompatível com a GNU General Public License (GPL) devido a restrições no uso do termo PHP
•Possui como principais vantagens:
–Gratuita
–Orientada a Web (projetada especificamente para o uso em sites Web)
–Fácil de usar
–Rápida (projetada tendo a velocidade como principal objetivo)
–Grande número de usuários e de suporte disponível
–Customizável (código aberto)

Instalação e Configuração
•O ambiente ideal:
–Servidor Web
–PHP
–Banco de Dados
•Principais servidores do mercado:

Bancos de Dados Mais Populares

Linguagens de Programação Mais Populares

•Forma mais simples: instalação do JavaBridge.war no Tomcat
–Implementação de um streaming que pode ser utilizado para conectar máquinas de script nativas, por exemplo PHP, Scheme ou Python
–Não é necessário a instalação de componentes adicionais para invocar procedimentos em Java a partir de PHP ou procedimentos em PHP a partir de Java
•Rodando aplicações PHP no Tomcat
–Baixe e instale o Java e o Tomcat (http://tomcat.apache.org/)
–Baixe o arquivo JavaBridge.war, que contém código binário PHP embarcado (http://php-java-bridge.sourceforge.net/pjb/)
–Configure o Tomcat para que seja possível a instalação do PHP

•Configuração do Tomcat para que seja possível a instalação do PHP
–A configuração padrão do Tomcat possui um limite de 50Mb para instalação de arquivos de aplicação .war
–O JavaBridge.war possui aproximadamente 52Mb
–Modifique o arquivo web.xml localizado na pasta webappsmanagerWEB-INF, dentro do local de instalação do Tomcat, aumentando o limite de tamanho do arquivo de instalação:

•Rodando aplicações PHP no Tomcat (cont.)
–Para instalar o JavaBridge.war você deve criar um usuário que possua as permissões para gerenciar o Tomcat
–Modifique o arquivo tomcat-users.xml da pasta conf:
–Acesse o gerenciador de aplicações do Tomcat e instale a aplicação JavaBridge.war
–Se lembre de definir o caminho de contexto para /php

•Instalando o JavaBridge.war no Tomcat:
•Pronto! Você já pode desenvolver a sua aplicação e armazená-la na pasta webappsphp dentro do local de instalação do Tomcat

Testando...
•Configure o Netbeans ou IDE de sua preferência para editar o código a seguir:

Estrutura Léxica
•Conjunto de regras básicas que governam como escrever um programa em uma determinada linguagem
•Nível mais baixo da sintaxe de uma linguagem
•Especifica como os elementos e nomes de variáveis devem parecer, quais caracteres são utilizados para comentários e como instruções do programa são separadas umas das outras

Sensibilidade à Caixa
•Os nomes de classes e funções definidas pelo usuário, bem como construtores internos e palavras-chave como echo, while, class, etc., são insensíveis à caixa (case- insensitive)
•Então, estas três linhas são equivalentes:
echo(“hello, world”);
ECHO(“hello, world”);
EcHo(“hello, world”);
•Variáveis, por outro lado, são sensíveis à caixa (case- sensitive)
–$nome, $NOME e $NoME são três variáveis diferentes

Instruções e Ponto e Vírgula
•Uma instrução é uma coleção de código PHP que faz alguma coisa
•Pode ser simples como uma atribuição de variável ou tão complexa como um laço com múltiplos pontos de saída
•Um pequeno exemplo de instruções PHP, incluindo chamada de função, atribuição e uma instrução if:
echo “Hello, world”;
myFunction(42, “O’Reilly”);
$a = 1;
$name = “Elphaba”;
$b = $a / 25.0;
if ($a == $b) {
echo “Rhyme? And Reason?”;
}

•PHP utiliza o ponto e vírgula para separar instruções simples
•Instruções compostas que utilizam chaves para marcar um bloco de código, como em um teste condicional ou laço, não precisam de um ponto e vírgula após o fechamento da chave
•Diferentemente de outras linguagens, um ponto e vírgula antes de um fechamento de chave não é opcional
if ($needed) {
echo "We must have it!"; // ponto e vírgula necessário
} // não necessário o uso de ponto e vírgula aqui

•O ponto e vírgula, no entanto, é opcional antes do fechamento de uma tag PHP:
<?php
if ($a == $b) {
echo "Rhyme? And Reason?";
}
echo "Hello, world" // ponto e vírgula opcional
?>

Espaços em Branco e Quebras de Linha
•De maneira geral, espaços não são importantes em um programam PHP
•Você pode escrever uma instrução através de qualquer número de linhas, ou colocar várias instruções em uma única linha
•Exemplo:
raisePrices($inventory, $inflation, $costOfLiving, $greed);
É equivalente a
raisePrices (
$inventory ,
$inflation ,
$costOfLiving ,
$greed
) ;
Ou ainda, com menos espaços em branco
raisePrices($inventory,$inflation,$costOfLiving,$greed);

Comentários
•Estilo shell script
#######################
## Cookie functions
#######################
if ($doubleCheck) {
# create an HTML form
echo confirmationForm();
}
$value = $p * exp($r * $t); # calculate interest

Comentários
•Estilo C++
///////////////////////
// Cookie functions
///////////////////////
if ($doubleCheck) {
// create an HTML form
echo confirmationForm();
}
$value = $p * exp($r * $t); // calculate interest

Comentários
•Estilo C
/* In this section, we take a bunch of variables and
assign numbers to them. There is no real reason to
do this, we're just having fun.
*/
$a = 1;
$b = 2;
$c = 3;
$d = 4;
/* These comments can be mixed with code too,
see? */ $e = 5; /* This works just fine. */

Literais
•Um literal é um valor que aparece diretamente em um programa
•São literais válidas em PHP:
2001
0xFE
1.4142
"Hello World"
'Hi'
true
null

Identificadores
•Um identificador é simplesmente um nome
•Em PHP, identificadores são usados para nomes de variáveis, funções, constantes e classes
•O primeiro caractere de um identificador deve ser uma letra ASCII (caixa alta ou caixa baixa), o caractere underscore (_), ou qualquer caractere entre o ASCII 0x7F (127) e o ASCII 0xFF (255)
•Após o caractere inicial, estes caracteres e os dígitos de 0- 9 são válidos

Nome de Variáveis
•Sempre iniciam com o sinal cifrão ($) e são sensíveis à caixa
•Alguns nomes de variáveis válidos:
$bill $head_count
$MaximumForce $I_HEART_PHP
$_underscore $_int
•Alguns nomes ilegais:
$not valid $|
$3wa
•Estas variáveis são todas diferentes:
$hot_stuff $Hot_stuff
$hot_Stuff $HOT_STUFF

Nomes de Funções
•Nomes de funções não são sensíveis à caixa
•Alguns nomes de funções válidos:
tally
list_all_users
deleteTclFiles
LOWERCASE_IS_FOR_WIMPS
_hide
•Estes nomes se referem à mesma função:
howdy HoWdY HOWDY HOWdy howdy

Nomes de Classes
•Seguem o padrão PHP e não são sensíveis à caixa
•Exemplos de nomes de classes válidos:
Person
account
•O nome de classe stdClass é reservado

Constantes
•É um identificador para um valor simples
•Apenas valores escalares – Boolean, integer, double e string – podem ser constantes
•Uma vez atribuído, o seu valor não poderá ser modificado
•Constantes são referenciadas pelo seu identificador e são atribuídas através da função define():
define('PUBLISHER', "O'Reilly & Associates");
echo PUBLISHER;

Palavras-Chave
•Uma palavra-chave (ou palavra reservada) é um conjunto de palavras utilizados pela linguagem para sua finalidade central
•Não pode ser atribuída a uma variável, função, classe ou constante
•Lista de palavras-chave em PHP:
__CLASS__ and continue
__DIR__ array() declare
__FILE__ as default
__FUNCTION__ break die()
__LINE__ callable do
__METHOD__ case echo
__NAMESPACE__ catch else
__TRAIT__ class elseif
__halt_compiler() clone empty()
abstract const enddeclare

Palavras-Chave
•Lista de palavras-chave em PHP (cont.):
endfor instanceof trait
endforeach insteadof try
endif interface unset()
endswitch isset() use
endwhile list() var
eval() namespace while
exit() new xor
extends or
final print
for private
foreach protected
function public
global require
goto require_once
if return
implements static
include switch
include_once throw

Tipos de Dados
•PHP fornece oito tipos de valores ou tipos de dados
•Quatro são tipos escalares (valore únicos): inteiros, números de ponto flutuante, textos e booleanos
•Dois são tipos compostos (coleções): matrizes e objetos
•Os outros dois restantes são tipos especiais: recursos e NULL

Inteiros
•Números como 1, 12 e 256
•A faixa de valores válidos varia de acordo com a plataforma, mas tipicamente se estendem entre -2,147,483,648 e +2,147,483,647
•Literais em inteiros podem ser escritas em decimal, octal (precedido por um zero), hexadecimal (0x) ou binário (0b):
1998 -641 +33
0755 // decimal 493 +010 // decimal 8
0xFF // decimal 255 0x10 // decimal 16
-0xDAD1 // decimal −56017 0b01100000 // decimal 96
0b00000010 // decimal 2 -0b10 // decimal −2
•Utilize a função is_int() (ou o seu apelido is_integer()) para testar se um valor é um inteiro:
if (is_int($x)) {
// $x is an integer
}

Números de Ponto Flutuante
•Também chamados de números reais, representam valores numéricos com dígitos decimais
•Seus limites dependem de detalhes da máquina, usualmente entre 1.7E-308 e 1.7E+308 com 15 dígitos de precisão
•Se você precisar de valores mais apurados ou em uma faixa maior, pode usar extensões BC ou GMP
•Você pode usar a notação usual ou a científica:
3.14 0.017 -7.1
0.314E1 // 0.314*10^1, ou 3.14
17.0E-3 // 17.0*10(-3), ou 0.017

Números de Ponto Flutuante
•Cuidado ao comparar dois número de ponto flutuantes usando o ==, uma melhor abordagem seria:
if (intval($a * 1000) == intval($b * 1000)) {
// numbers equal to three decimal places
}
•Utilize a função is_float() (ou seu apelido is_real()) para testar se um valor é um número de ponto flutuante
if (is_float($x)) {
// $x is a floating-point number
}

Textos (Strings)
•Por ser muito comum em aplicações Web, PHP inclui suporte de nível central para criação e manipulação de strings
•Uma string é uma sequência de caracteres de tamanho arbitrário
•Literais string são delimitadas tanto por aspas simples como por aspas duplas:
‘big dog’ “fat hog”
•Variáveis são expandidas (intercaladas) com aspas duplas, mas não com aspas simples:
$name = “Guido”;
echo “Hi, $namen”; Hi, Guido
echo ‘Hi, $name’; Hi, $name

Textos (Strings)
•Aspas duplas também dá suporte a uma variedade de sequências esc ():
Sequência
Caractere representado
Sequência
”
Aspas duplas
n
Nova linha
r
Retorno de carro
t
Tab

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

Textos (Strings)
•Aspas duplas também dá suporte a uma variedade de sequências esc ():
Sequência
Sequência
”
Aspas duplas
n
Nova linha
r
Retorno de carro
t
Tab

Backslash
$
Sinal $
{
Abre chaves
}
Fecha chaves
[
Abre colchetes
]
Fecha colchetes
0 até 777
Caractere ASCII representado por um valor octal
x0 até xFF
Caractere ASCII representado por um valor hexadecimal
$dosPath = ‘C:WINDOWSSYSTEM’;
$publisher = ‘Tim O’Reilly’;
echo “$dosPath $publishern”;
C:WINDOWSSYSTEM Tim O’Reilly

Textos (Strings)
•Para verificar se duas strings são iguais, utilize o operador de comparação ==:
if ($a == $b) {
echo “a e b são iguais”
}
•Use a função is_string() para testar se um valor é uma string:
if (is_string($x)) {
// $x é uma string
}

Booleanos
•Em PHP os seguintes valores correspondem a falso:
–A palavra-chave false
–O inteiro 0
–O ponto flutuante 0.0
–A string vazia (“”) e a string “0”
–Um array com nenhum elemento
–Um objeto sem valores ou funções
–O valor NULL
•Um valor que não é considerado falso, é verdadeiro
•Exemplos:
$x = 5; // $x tem um valor verdadeiro
$x = true; // maneira mais clara de escrever isso
$y = “”; // $y tem um valor falso
$y = false; // maneira mais clara de escrever isso

Booleanos
•Use a função is_bool() para testar se um valor é um booleano:
if (is_bool($x)) {
// $x é um booleano
}

Arrays/Matrizes
•Um array armazena um grupo de valores que podemos identificar através de uma posição (um número, com zero como a primeira posição) ou algum nome identificador (string), chamado de índice associativo:
$person[0] = "Edison";
$person[1] = "Wankel";
$person[2] = "Crapper";
$creator['Light bulb'] = "Edison";
$creator['Rotary Engine'] = "Wankel";
$creator['Toilet'] = "Crapper";

Arrays/Matrizes
•Podemos utilizar o construtor array() cria um array:
$person = array("Edison", "Wankel", "Crapper");
$creator = array('Light bulb' => "Edison",
'Rotary Engine' => "Wankel",
'Toilet' => "Crapper");
•Existem várias maneiras de percorrer um array, mas a mais comum é através do laço foreach:

Arrays/Matrizes
•Podemos utilizar o construtor array() cria um array:
$person = array("Edison", "Wankel", "Crapper");
$creator = array('Light bulb' => "Edison",
'Rotary Engine' => "Wankel",
'Toilet' => "Crapper");
•Existem várias maneiras de percorrer um array, mas a mais comum é através do laço foreach:
foreach ($person as $name) {
echo "Hello, {$name}n";
}
foreach ($creator as $invention => $inventor) {
echo "{$inventor} created the {$invention}n";
}
Hello, Edison
Hello, Wankel
Hello, Crapper
Edison created the Light bulb
Wankel created the Rotary Engine
Crapper created the Toilet

Arrays/Matrizes
•Podemos ordenar os elementos de um array com as várias funções de ordenação:
sort($person);
// $person is now array("Crapper", "Edison",
// "Wankel")
asort($creator);
// $creator is now array('Toilet' => "Crapper",
// 'Light bulb' => "Edison",
// 'Rotary Engine' => "Wankel");
•Use a função is_array() para testar se um valor é um array:
if (is_array($x)) {
// $x é um array
}

Objetos
•PHP também dá suporte à programação orientada a objetos (POO)
•Classes são os blocos de construção de projetos orientados a objetos, uma classe é uma definição de uma estrutura que contém propriedades (variáveis) e métodos (funções)
•Classes são definidas através da palavra-chave class:
class Person {
public $name = '';
function name ($newname = NULL) {
if (!is_null($newname)) {
$this->name = $newname;
}
return $this->name;
}
}

Objetos
•Uma vez que uma classe está definida, podemos fazer qualquer número de objetos a partir da mesma, com o uso da palavra-chave new, e propriedades e métodos podem ser acessados com o construtor ->:
$ed = new Person;
$ed->name('Edison');
echo "Hello, {$ed->name}n";
$tc = new Person;
$tc->name('Crapper');
echo "Look out below {$tc->name}n";
Hello, Edison
Look out below Crapper

Objetos
•Use a função is_object() para testar se um valor é um objeto:
if (is_object($x)) {
// $x é um objeto
}

Recursos
•Muitos módulos fornecem várias funções para lidar com o ambiente externo
•Por exemplo, toda extensão de banco de dados possui pelo menos uma função para conexão com o banco de dados, uma para enviar consultas e uma função para fechar a conexão com o banco
•Como podemos ter múltiplas conexões com o banco de dados abertas simultaneamente, a função de conexão fornece algo para identificar unicamente cada uma, para que possamos chamar as funções de consulta e de fechamento: um recurso (ou “manipulador”)
•Cada recurso ativo possui um identificador único
•Cada identificador é um índice numérico dentro de uma tabela de busca interna do PHP que manipula informações sobre os recursos ativos

Recursos
•Muitos módulos fornecem várias funções para lidar com o ambiente externo
•Por exemplo, toda extensão de banco de dados possui pelo menos uma função para conexão com o banco de dados, uma para enviar consultas e uma função para fechar a conexão com o banco
•Como podemos ter múltiplas conexões como banco de dados abertas simultaneamente, a função de conexão fornece algo para identificar unicamente cada uma, para que possamos chamar as funções de consulta e de fechamento: um recurso (ou “manipulador”)
•Cada recurso ativo possui um identificador único
•Cada identificador é um índice numérico dentro de uma tabela de busca interna do PHP que manipula informações sobre os recursos ativos
$res = database_connect();
// função fictícia de conexão com o BD
database_query($res);
$res = "boo";
// a conexão com o BD é fechada automaticamente
// porque $res é redefinido

Recursos
•Use a função is_resource() para testar se um valor é um recurso:
if (is_resource($x)) {
// $x é um recurso
}

Callbacks
•Callbacks são funções ou métodos de objetos usados por algumas funções, como call_user_func()
•Callbacks podem também ser criados pelo método create_function()
$callback = function myCallbackFunction()
{
echo "callback achieved";
}
call_user_func($callback);
callback achieved

NULL
•O tipo de dado nulo está disponível através da palavra- chave não sensível à caixa NULL
•O valor NULL representa uma variável que não possui valor (similar ao undef de Perl ou None de Python)
$aleph = "beta";
$aleph = null; // o valor da variável é perdido
$aleph = Null; // o mesmo
$aleph = NULL; // o mesmo
•Use a função is_null() para testar se um valor é nulo:
if (is_null($x)) {
// $x é nulo
}

Variáveis
•Variáveis PHP são identificadas através do prefixo cifrão ($):
$name $Age $_debugging $MAXIMUM_IMPACT
•Uma variável pode conter um valor de qualquer tipo
•Não há checagem de tipo de variáveis em tempo de compilação ou de execução
•Podemos substituir o valor de uma variável por outro de um tipo diferente:
$what = “Fred”;
$what = 35;
$what = array(“Fred”, 35, “Wilma”);

Variáveis
•Não há sintaxe explícita para declaração de variáveis em PHP: na primeira vez em que um valor é atribuído, a variável é criada – atribuir um valor a uma variável também funciona como uma declaração
$day = 60 * 60 * 24;
echo "There are {$day} seconds in a day.n";
There are 86400 seconds in a day.
•Uma variável cujo valor não foi atribuído se comporta como um valor nulo:
if ($uninitializedVariable === NULL) {
echo "Yes!";
}
Yes!
Verdadeiro (true) se os valores são iguais, e eles são do mesmo tipo (introduzido no PHP4).

Variáveis com Nomes de Variáveis
•Podemos referenciar o valor de uma variável cujo nome está armazenado em uma outra variável através de um cifrão ($) adicional antes da variável de referência
•Exemplo:
$foo = "bar";
$$foo = "baz";
•Após a execução da segunda instrução, o valor da variável $bar será “baz”

Referência a Variáveis
•Em PHP, referência é a forma de criar apelidos para variáveis
•Para fazer $black uma referência à variável $white, use:
$black =& $white;
•O valor anterior de $black, se existir, será perdido
•Em vez disso, $black passa a ser um outro nome para o valor que é armazenado em $white

•Em PHP, referência é a forma de criar apelidos para variáveis
•Para fazer $black uma referência à variável $white, use:
$black =& $white;
•O valor anterior de $black, se existir, será perdido
•Em vez disso, $black passa a ser um outro nome para o valor que é armazenado em $white
$bigLongVariableName = "PHP";
$short =& $bigLongVariableName;
$bigLongVariableName .= " rocks!";
print "$short is $shortn";
print "Long is $bigLongVariableNamen";
$short is PHP rocks!
Long is PHP rocks!
$short = "Programming $short";
print "$short is $shortn";
print "Long is $bigLongVariableNamen";
$short is Programming PHP rocks!
Long is Programming PHP rocks!

•Após a atribuição, as duas variáveis são nomes alternativos para o mesmo valor
•Remover o valor de uma variável que possui um apelido não afeta outros nomes para o valor da variável:
$white = "snow";
$black =& $white;
unset($white);
print $black;
snow

•Funções podem retornar valores por referência (para evitar copiar strings ou arrays muito grandes, por exemplo)
function &retRef() // note o &
{
$var = "PHP";
return $var;
}
$v =& retRef(); // note o &

Escopo de Variáveis
•O escopo de uma variável, que é controlado pela localização da declaração da variável, determina as partes do programa que podem acessá-la
•Em PHP existem quatro tipos de escopo de variáveis: local, global, estático e parâmetros de função

Escopo Local
•Uma variável declarada em uma função é local àquela função, ou seja, é visível apenas no código da função e não é acessível fora da função
•Por outro lado, uma variável definida fora da função (chamada de variável global) não é acessível dentro da função
•Uma função que atualiza uma variável local em vez de uma variável global:
function updateCounter()
{
$counter++;
}
$counter = 10;
updateCounter();
echo $counter;
10

Escopo Local
•O $counter dentro da função é local à função, porque não indicamos outra coisa
•A função incrementa sua variável privada $counter, que é destruída quando a subrotina termina
•A variável $counter global permanece com o valor 10
•Apenas funções podem fornecer escopo local
•Diferentemente de outras linguagens, em PHP não podemos criar uma variável cujo escopo é um laço, ramo condicional ou outro tipo de bloco

Escopo Global
•Variáveis declaradas fora de uma função são globais, ou seja, podem ser acessadas de qualquer parte do programa, entretanto, por padrão, elas não estão disponíveis dentro das funções
•Para permitir que uma função acesse uma variável global, podemos usar a palavra-chave global para declarar a variável dentro da função
•Modificando a função updateCounter() para permitir acesso à variável global $counter:
{
global $counter;
$counter++;
}
$counter = 10;
updateCounter();
echo $counter;
11

Escopo Global
•Uma forma mais “complicada” para atualizar uma variável global é usar o array PHP $GLOBALS em vez de acessar a variável diretamente:
{
$GLOBALS[“counter”]++;
}
$counter = 10;
updateCounter();
echo $counter;
11

Variáveis Estáticas
•Uma variável estática retém o seu valor entre chamadas a uma função, mas é visível apenas dentro da função
•Declaramos uma variável estática com a palavra-chave static
•Exemplo:

Variáveis Estáticas
•Uma variável estática retém o seu valor entre chamadas a uma função, mas é visível apenas dentro da função
•Declaramos uma variável estática com a palavra-chave static
•Exemplo:
{
static $counter = 0;
$counter++;
echo "Static counter is now {$counter}n";
}
$counter = 10;
updateCounter();
updateCounter();
echo "Global counter is {$counter}n";
Static counter is now 1
Static counter is now 2
Global counter is 10

Parâmetros de Função
•Como será melhor apresentado adiante, um definição de função pode receber parâmetros com nomes:
function greet($name)
{
echo "Hello, {$name}n";
}
greet("Janet");
Hello, Janet
•Parâmetros de função são locais, o que significa que estão disponíveis apenas dentro das funções
•Neste caso, $name é inacessível fora de greet()

Gerenciamento de Memória
•PHP utiliza:
–Contador de referência, para garantir que a memória seja retornada ao SO quando não for mais necessária
–Copiar-quando-escrever (copy-on-write), para que a memória não seja desperdiçada ao copiar valores entre variáveis
•PHP possui uma tabela de símbolos que corresponde a um array que mapeia nomes de variáveis para as posições de seus valores na memória
•Quando copiamos um valor de uma variável para outra, PHP não utiliza mais memória para fazer uma cópia do valor, em vez disso, ele atualiza a tabela de símbolos indicando que ambos os nomes apontam para o mesmo local da memória

•O código a seguir não cria um novo array:
$worker = array("Fred", 35, "Wilma");
$other = $worker; // o array não é copiado
•Se uma moficação subsequente ocorrer, PHP aloca a memória necessária e realiza a cópia:
$worker[1] = 36; // o array é copiado, valor modificado
•Por adiar a alocação e cópia, PHP salva tempo e memória em muitas situações, isto é copy-on-write

•Cada valor apontado por um símbolo possui um contador de referência
–Um número que representa a quantidade de maneiras para acessar aquela parte da memória
–Após as atribuições iniciais de $worker e de $worker para $other, o array apontado pelas entradas na tabela de símbolos para $worker e $other possui um contador de referência de 2, ou seja, aquela posição de memória pode ser acessada de duas maneiras: através de $worker ou $other
–Após a mudança do valor de $worker[1], PHP cria um novo array para $worker, e o contador de referência de cada um dos arrays passa a ser apenas 1
•Quando uma variável sai do escopo, como parâmetros de uma função e variáveis locais no final de uma função, o contador de referência é diminuído em um

•Quando é atribuída a uma variável uma área diferente da memória, o contador de referência do valor anterior é diminuído em um
•Quando o contador de referência de um valor chega a 0, a sua memória é liberada
•Para verificar se uma variável foi atribuída a algo, use a função isset():
$s1 = isset($name); // $s1 é false
$name = "Fred";
$s2 = isset($name); // $s2 é true
•Utilize a função unset() para remover o valor de uma variável:
$name = "Fred";
unset($name); // $name é NULL

PHP BÁSICO Expressões e Operadores

Expressões e Operadores
•Uma expressão é uma parte do PHP que pode ser avaliada para produzir um valor
•As expressões mais simples são valores literais e variáveis
•Expressões mais complexas podem ser formadas usando expressões simples e operadores
•Um operador pega algum valor (os operandos) e faz alguma coisa (por exemplo, adicioná-los)
–Alguns operadores podem modificar seus operandos, mas a maioria não o faz
•A seguir são apresentados os principais operadores PHP por ordem de precedência (maior para o menor)

Operadores
Prec.
Operador
Operação
21
clone, new
Cria um novo objeto
20
[
Substring de um array
19
++
Incremento
--
Decremento
(int), (bool), (float), (string), (array), (object), (unset)
Conversão
@
Inibição de erros
18
instance of
Teste de tipo
17
!
Não lógico (NOT)
16
*
Multiplicação
/
Divisão
%
Módulo (resto da divisão)

Operadores
Prec.
Operador
Operação
15
+
Adição
-
Subtração
.
Concatenação de strings
13
<, <=
Menor, menor ou igual a
>, >=
Maior, maior ou igual a
12
==
Valor igual a
!=, <>
Diferença
===
Tipos e valores iguais
!==
Tipos e valores diferentes
8
&&
E lógico (AND)
7
||
OU lógico (OR)
6
?:
Operador condicional

Operadores
Prec.
Operador
Operação
5
=
Atribuição
+=, -=, *=, /=, .=, %=
Atribuição com operação
4
and
AND lógico
3
xor
XOR lógico
2
Or
OR lógico
1
,
Separador de lista

Conversão Implícita
•Muitos operadores esperam certos tipos de seus operandos
•PHP tenta converter valores de um tipo para outro quando necessário
•Regras de conversão implícita para operações aritméticas binárias:
Tipo do primeiro operando
Tipo do segundo operando
Conversão realizada
Inteiro
Ponto flutuante
O inteiro é convertido para um número de ponto flutuante
Inteiro
String
A string é convertida para um número; se o valor após a conversão é um ponto flutuante, o inteiro é convertido para ponto flutuante
Ponto flutuante
String
A string é convertida para ponto flutuante

•Alguns operadores esperam diferentes tipos de operandos e portanto possuem diferentes regras
•Por exemplo, o operador de concatenação de strings converte ambos operandos para strings antes de realizar a concatenação:
3 . 2.74 // produz a string 32.74
•Podemos usar uma string em qualquer lugar onde PHP espera por um número
–Presume-se que a string inicie com um número inteiro ou de ponto flutuante
–Se não for encontrado um número no início da string, o valor numérico da string é 0
–Se a string possui um ponto (.) ou um (e) maiúsculo ou minúsculo, a avaliação produz um número de ponto flutuante

•Alguns operadores esperam diferentes tipos de operandos e portanto possuem diferentes regras
•Por exemplo, o operador de concatenação de strings converte ambos operandos para strings antes de realizar a concatenação:
3 . 2.74 // produz a string 32.74
•Podemos usar uma string em qualquer lugar onde PHP espera por um número
–Presume-se que a string inicie com um número inteiro ou de ponto flutuante
–Se não for encontrado um número no início da string, o valor numérico da string é 0
–Se a string possui um ponto (.) ou um (e) maiúsculo ou minúsculo, a avaliação produz um número de ponto flutuante
"9 Lives" - 1; // 8 (int)
"3.14 Pies" * 2; // 6.28 (float)
"9 Lives." - 1; // 8 (float)
"1E3 Points of Light" + 1; // 1001 (float)

Auto Incremento/Decremento
•Realizado através dos operadores unários:
–(++) auto incremento
–(--) auto decremento
•Funcionam apenas em variáveis, eles modificam o valor do operando e retornam um valor
•Operações:
Operador
Nome
Valor Retornado
Efeito em $var
$var++
Pós-incremento
$var
Incrementado
++$var
Pré-incremento
$var + 1
Incrementado
$var--
Pós-decremento
$var
Decrementado
--$var
Pré-decremento
$var – 1
Decrementado

Auto Incremento/Decremento
•Estes operadores podem ser aplicados a strings da mesma forma como a números
•Exemplos:
Incrementando isto
Temos isto
“a”
“b”
“z”
“aa”
“spaz”
“spba”
“K9”
“L0”
“42”
“43”

PHP BÁSICO Instruções de Controle de Fluxo

if
•Sintaxe:
if (expressão)
instrução
else instrução (opcional)
•Exemplo:
if ($user_validated)
echo "Welcome!";
else
echo "Access Forbidden!";
•Para incluir mais de uma instrução, utilize um delimitador de bloco:
– { }
– :

if – Exemplos
if ($user_validated) {
echo "Welcome!";
$greeted = 1;
}
else {
exit;
}

if – Exemplos
echo "Welcome!";
$greeted = 1;
}
else {
exit;
}
if ($user_validated): echo "Welcome!"; $greeted = 1; else: echo "Access Forbidden!"; exit; endif;

if – Exemplos
echo "Welcome!";
$greeted = 1;
}
else {
exit;
}
if ($user_validated): echo "Welcome!"; $greeted = 1; else: echo "Access Forbidden!"; exit; endif;
<? if ($user_validated) :?>
<table>
<tr>
<td>First Name:</td><td>Sophia</td>
</tr>
<tr>
<td>Last Name:</td><td>Lee</td>
</tr>
</table>
<? else: ?>
Please log in.
<? endif ?>

if – Exemplos
if ($good) {
print("Dandy!");
}
else {
if ($error) {
print("Oh, no!");
}
else {
print("I'm ambivalent...");
}
}

if – Exemplos
if ($good) { print("Dandy!"); } else { if ($error) { print("Oh, no!"); } else { print("I'm ambivalent..."); } }
if ($good) {
print("Dandy!");
}
elseif ($error) {
print("Oh, no!");
}
else {
print("I'm ambivalent...");
}
<td><?php if($active) {echo "yes";} else {echo "no";} ?></td>
<td><?php echo $active ? "yes" : "no"; ?></td>

switch
•O valor de uma única variável pode levar a uma quantidade de escolhas diferentes
•Dada uma expressão, compara o seu valor com todos os casos do switch
–Quando encontra um caso, executa as instruções até que o primeiro break seja encontrado
–Se não encontrar nenhum caso, e default é fornecido, executa as instruções após a palavra-chave default até que um break seja encontrado

switch – Exemplos
if ($name == 'ktatroe') {
// do something
}
else if ($name == 'dawn') {
// do something
}
else if ($name == 'petermac') {
// do something
}
else if ($name == 'bobk') {
// do something
}

switch – Exemplos
// do something
}
// do something
}
// do something
}
// do something
}
switch($name) {
case 'ktatroe':
// do something
break;
case 'dawn':
// do something
break;
case 'petermac':
// do something
break;
case 'bobk':
// do something
break;
}

switch – Exemplos
// do something
}
// do something
}
// do something
}
// do something
}
switch($name) { case 'ktatroe': // do something break; case 'dawn': // do something break; case 'petermac': // do something break; case 'bobk': // do something break; }
switch($name):
case 'ktatroe':
// do something
break;
case 'dawn':
// do something
break;
case 'petermac':
// do something
break;
case 'bobk':
// do something
break;
endswitch;

switch – Exemplos
// do something
}
// do something
}
// do something
}
// do something
}
switch($name) {
case 'ktatroe':
// do something
break;
case 'dawn':
// do something
break;
case 'petermac':
// do something
break;
case 'bobk':
// do something
break;
}
switch($name):
case 'ktatroe':
// do something
break;
case 'dawn':
// do something
break;
case 'petermac':
// do something
break;
case 'bobk':
// do something
break;
endswitch;
switch ($name) {
case 'sylvie': // cascata
case 'bruno':
print("yes");
break;
default:
print("no");
break;
}

while
•Forma mais simples de instrução de laço
while (expressão)instrução
•Sintaxe alternativa:
while (expr):
instrução;
mais instruções;
endwhile;
$total = 0;
$i = 1;
while ($i <= 10) {
$total += $i;
$i++;
}
$total = 0;
$i = 1;
while ($i <= 10):
$total += $i;
$i++;
endwhile;

while
•Podemos sair do laço prematuramente utilizando uma instrução break
$total = 0;
$i = 1;
while ($i <= 10) {
if ($i == 5) {
break; // abandona o laço
}
$total += $i;
$i++;
}

while
•Opcionalmente podemos colocar um número após a palavra- chave break, indicando quantos níveis da estrutura de laço devem ser interrompidos
$i = 0;
$j = 0;
while ($i < 10) {
while ($j < 10) {
if ($j == 5) {
break 2; // interrompe 2 níveis de laço while
}
$j++;
}
$i++;
}
echo "{$i}, {$j}";
0, 5

while
•A instrução continue salta para o próximo teste da condição do laço
–Assim como no break, podemos saltar uma determinada quantidade de níveis na estrutura de laços
while ($i < 10) {
$i++;
while ($j < 10) {
if ($j == 5) {
continue 2; // continua 2 níveis acima
}
$j++;
}
}

while
•PHP também dá suporte à estrutura de laço do/while na forma
do
instrução
while (expressão)
•Utilize do/while quando o laço deve ser executado pelo menos uma vez
$total = 0;
$i = 1;
do {
$total += $i++;
} while ($i <= 10);

for
•Semelhante à instrução while, porém adiciona uma inicialização e uma expressão de manipulação do contador, além de ser mais curta e de mais fácil leitura que o laço while equivalente
•Estrutura da instrução for:
for (início; condição; incremento)
{ instrução(ões); }
•Sintaxe alternativa
for (expr1; expr2; expr3):
instrução;
...;
endfor;

for
$counter = 0;
while ($counter < 10) {
echo "Counter is {$counter}n";
$counter++;
}
for ($counter = 0; $counter < 10; $counter++) {
echo "Counter is $countern";
}
$total = 0;
for ($i= 1; $i <= 10; $i++) {
$total += $i;
}
$total = 0;
for ($i = 1; $i <= 10; $i++):
$total += $i;
endfor;

for
•Podemos especificar múltiplas expressões em qualquer das expressões de uma instrução for, desde que separemos as expressões com vírgulas
$total = 0;
for ($i = 0, $j = 0; $i <= 10; $i++, $j *= 2) {
$total += $j;
}
•Podemos também criar um laço infinito com for:
for (;;) {
echo "Can't stop me!<br />";
}

foreach
•Permite a interação sobre os elementos de um array
•Sintaxe:
foreach ($array as $current) {
// ...
}
foreach ($array as $current):
// ...
endforeach;

foreach
•Acessando tanto a chave como o valor:
foreach ($array as $key => $value) {
// ...
}
foreach ($array as $key => $value):
// ...
endforeach;

try..catch
•Estrutura para manipulação de erros
•Garantindo que uma aplicação web tenha uma conexão válida com um banco de dados antes de continuar:
try {
$dbhandle = new PDO('mysql:host=localhost; '.
'dbname=library', $username, $pwd);
doDB_Work($dbhandle); // função de conexão
$dbhandle = null; // libera o handle
}
catch (PDOException $error) {
print "Erro!: ". $error->getMessage(). "<br/>";
die();
}

exit e return
•A instrução return é utilizada para o retorno de uma função ou, no mais alto nível do programa, do script
•A instrução exit termina a execução do script
–Pode ter como parâmetro um valor opcional, se for um número, corresponde ao estado de saída do processo; se for uma string, o valor será impresso antes que o processo termine
–A função die() é um apelido para a instrução exit
$db = mysql_connect("localhost", $USERNAME,
$PASSWORD);
if (!$db) {
die("Could not connect to database");
}

exit e return
•A instrução return é utilizada para o retorno de uma função ou, no mais alto nível do programa, do script
•A instrução exit termina a execução do script
–Pode ter como parâmetro um valor opcional, se for um número, corresponde ao estado de saída do processo; se for uma string, o valor será impresso antes que o processo termine
–A função die() é um apelido para a instrução exit
$db = mysql_connect("localhost", $USERNAME,
$PASSWORD);
if (!$db) {
die("Could not connect to database");
}
Que também pode ser escrita da seguinte forma:
$db = mysql_connect("localhost", $USERNAME, $PASSWORD)
or die("Could not connect to database");

goto
•Permite realizar um “salto” para outro lugar em um programa
•Podemos especificar pontos de execução adicionando um rótulo, que é um identificador seguido por dois pontos (:)
for ($i = 0; $i < $count; $i++) {
// oops, found an error
if ($error) {
goto cleanup;
}
}
cleanup:
// faça algo cleanup

Incluindo Código
•PHP fornece dois construtores para ler código e HTML de um outro módulo: require e include
•As duas instruções carregam um arquivo, funcionam em condicionais e laços e geram erro se o arquivo não puder ser encontrado
•A diferença está no fato de que se o arquivo não puder ser encontrado, require gera um erro fatal, enquanto include gera um aviso mas não interrompe a execução do script
•Um uso comum de include é separar conteúdo específico da página do projeto geral do site:
<?php include "header.html"; ?>
content
<?php include "footer.html"; ?>

Incluindo Código
•O construtor require é mais rigoroso e mais adequado para carregamento de bibliotecas de código, onde a página não pode ser exibida se a biblioteca não for carregada:
require "codelib.php";
mysub(); // definida em codelib.php
•Se ao carregar alguma parte do arquivo PHP não conseguir realizar a análise gramatical, uma mensagem é exibida e a execução continua
–Podemos bloquear a exibição dessas mensagens utilizando o operador de silêncio (@) – por exemplo, @include

Incluindo Código
•Se a opção allow_url_fopen estiver habilitada no arquivo de configuração PHP, php.ini, podemos incluir arquivos de uma biblioteca remota, fornecendo a URL correspondente:
include "http://www.example.com/codelib.php";
•Código em um arquivo incluído é importado com escopo onde a instrução include estiver localizada
•O código importado pode ler e alterar as variáveis de seu código
// main page
include "userprefs.php";
echo "Hello, {$user}.";

Incluindo Código
•Considerando que include e require são palavras-chaves, não instruções reais, devemos colocá-las entre chaves em instruções condicionais e laços:
for ($i = 0; $i < 10; $i++) {
include "repeated_element.html";
}
•Utilize a função get_included_files() para saber quais arquivos seu script carregou
–Ela retorna um array contendo o nome e caminho completo de cada um dos arquivos carregados

PHP BÁSICO PHP Embarcado em Páginas Web

PHP Embarcado em Páginas Web
•Embora seja possível escrever e rodar programas PHP standalone, a maioria do código PHP está embarcado em arquivos HTML ou XML
–Este é o motivo pelo qual a linguagem foi criada em primeiro lugar
•Considerando que normalmente um único arquivo contém código PHP e não-PHP, precisamos de uma maneira de identificar as regiões em que o código PHP será executado
•PHP fornece quatro maneiras diferentes de fazer isso:
–O primeiro, e preferencial, método parece com XML
–O segundo com SGML
–O terceiro é baseado em tags ASP
–O quarto método utiliza a tag HTML <script>, o que torna fácil editar páginas com PHP utilizando um editor HTML comum

Estilo Padrão (XML)
•Por causa do advento da eXtensible Markup Language (XML) e a migração de HTML para uma linguagem XML (XHTML), a técnica atual preferida para embarcar PHP usa tags compatíveis com XML para denotar instruções PHP
•Para utilizar este estilo, devemos colocar o código PHP com <?php e ?>
•Tudo entre estas marcas é interpretado como PHP, e tudo fora delas, não é
•Exemplo:
<?php echo "Hello, world"; ?>

Estilo Padrão (XML)
•Instruções PHP podem ser colocadas em qualquer lugar em um arquivo, mesmo dentro de uma tag HTML válida
•Por exemplo:
<input type="text" name="first_name"
value="<?php echo "Peter"; ?>" />
•Que equivale a:
<input type="text" name="first_name"
value="Peter" />

Estilo SGML
•Uma outra forma de embutir código PHP é através de tags de processamento de instruções SGML
•Para utilizar este método, colocamos o PHP entre <? e ?>
<? echo "Hello, world"; ?>
•Este estilo é conhecido como tags curtas e está desligado por padrão
•Podemos habilitá-lo através da opção short_open_tag no arquivo de configuração PHP

Estilo ASP
•Alguns editores HTML podem não dar suporte correto à sintaxe PHP, mas o fazem com ASP (Active Server Pages)
•Podemos, então, utilizar tags com o estilo ASP para embutir código PHP
•O estilo de tags ASP é similar ao SGML, mas utiliza % em vez de ?
<% echo "Hello, world"; %>
•Para utilizarmos este estilo, devemos habilitar asp_tags no arquivo de configuração PHP

Estilo Script
•Utiliza a tag inventada para permitir scripts do lado cliente em páginas HTML, a tag <script>
•Também utilizada quando embarcamos JavaScript
•Como PHP é processado e removido do arquivo antes de alcançar o navegador, podemos utilizar a tag <script> para envolver o código PHP
<script language="php">
echo "Hello, world";
</script>
•Este método é muito útil quando utilizamos editores que funcionam apenas com arquivos HTML estritamente legais e não dá suporte aos comandos de processamento XML

Curso PHP Introdução

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a Curso PHP Introdução

Semelhante a Curso PHP Introdução (20)

Mais de Fabio Moura Pereira

Mais de Fabio Moura Pereira (20)

Curso PHP Introdução