prof° alexandre eugÊnio da silva - eugeniosolucoes.eti.br · curso adonai disciplina linguagem...

“Deus é fiel! Sem Ele nada somos e nada faríamos”

Rua da Quitanda 185 Centro - Rio de Janeiro - RJ Telefone: (021) 2233-4982 / 2233-6186 [email protected]

Prof° Alexandre EUGÊNIO da Silva

Curso Adonai Disciplina Linguagem PHP

Profº Alexandre Eugênio da Silva Página 1

SUMÁRIO

1. Estrutura e visão geral da linguagem

1.1. Interação entre PHP e HTML

1.2. Identificadores

1.3. Variáveis

1.4. Constantes

1.5. Operadores

1.6. Estruturas de controle

2. Arrays

3. Manipulação de strings

4. Utilização de funções

5. Conceitos e implementação de orientação a objeto:

5.1. Classe

5.2. Objeto

5.3. Herança

5.4. Criação de objetos

5.5. Controle de acesso



1. Estrutura e visão geral da linguagem

PHP (um acrônimo recursivo para "PHP: Hypertext Preprocessor") é uma linguagem de script Open Source de uso geral, muito utilizada e especialmente utilizada para o desenvolvimento de aplicações Web.

Programas ou aplicaçãos desenvolvidas para WEB através de uma linguagem de script como PHP possuem um escopo muito diferente em relação aos mesmos desenvolvidos para Desktop (programas que rodam no computador do usuário). Primeiramente alguns conceitos devem ser muito bem entendidos para que possamos analisar o comportamento desse tipo de desenvolvimento: Scripts – Um script como o próprio nome sugere, nada mais é que uma sequência de rotinas ou instruções que nos retornarão um resultado esperado. Dentro do contexto WEB, os scripts são arquivos de texto1 os quais colocamos os códigos-fonte da linguagem de programação utilizada. Server Side – Existem scripts do tipo “Server Side”, os mesmo são interpretados (processados / executados) pelo Servidor WEB que os retornam para o Navegador WEB cliente. Client Side – Scripts do tipo “Client Side”, são interpretados (processados / executados) pelo Navegador WEB do cliente. O script “Client Side”, mais utilizado no mundo é o JAVASCRIPT. 1 – Arquivo de texto – Este arquivo texto possuirá a extensão da linguagem empregada. Exemplo: .php para script PHP; .asp para linguagem ASP; .aspx para linguagem .NET; .jsp para linguagem JAVA para WEB.



1.1. Interação entre PHP e HTML Página PHP Crie um novo arquivo chamado ola.php e coloque-o em seu diretório root do seu servidor web com o seguinte conteúdo: Ex.: Nosso primeiro script PHP: ola.php <html> <head> <title>PHP Teste</title> </head> <body> <?php echo "<p>Olá Mundo</p>"; ?> </body> </html> Use o seu navegador para acessar o arquivo pelo endereço de seu servidor web, ao final do endereço coloque o arquivo "/ola.php" como referência. Quando o desenvolvimento é local você usará uma url como esta http://localhost/ola.php ou http://127.0.0.1/ola.php. Se tudo foi configurado corretamente, o arquivo irá ser interpretado pelo PHP e irá mostrar a seguinte mensagem de saída no seu navegador: Saída no navegador Código-fonte

Olá Mundo <html> <head> <title>PHP Teste</title> </head> <body> <p>Olá Mundo</p> </body> </html>

Note que isto não é como em um script CGI. O arquivo não precisa ser executável ou especial em nenhum aspecto. Pense nesse arquivo como um arquivo HTML normal mas com a diferença que ele pode conter algumas tags especiais à mais que permitem a você fazer coisas mais interessantes do que somente páginas HTML estáticas. Este exemplo é extremamente simples e você realmente não precisa usar o PHP para criar uma página como esta. Tudo o que ele faz é mostrar uma mensagem Olá Mundo usando a declaração echo() do PHP. O objetivo do exemplo é mostrar o formato especial das tags do PHP. Neste exemplo nós usamos <?php para indicar que à partir daquele ponto começa um código PHP. Então nós colocamos uma declaração de fechamento para indicar que o script PHP acabou, usando a tag ?>. Você pode usar o PHP em qualquer parte do seu código HTML, e também pode usar várias tags de abertura e fechamento no mesmo arquivo.



1.2. Identificadores Os identificadores são os nomes de variáveis, funções e classes. Há algumas regras simples sobre indentificadores:

• Os identificadores podem ser de qualquer comprimento e podem consister em letras, números, sublinhados e sinais de cifrão;

• Os identificadores não podem iniciar com um dígito; • Diferenciam letras maiúsculas e minúsculas. Os nomes de funções são uma exceção a essa

regra. • Uma variável pode ter o mesmo nome que uma função. Mas isso é confuso e deve ser

evitado. • Além disso, você não pode criar uma função com o mesmo nome de outra.

<?php $var = 'Bob'; $Var = 'Joe'; echo "$var, $Var"; // exibe "Bob, Joe" $4site = 'not yet'; // inválido; começa com um número $_4site = 'not yet'; // válido; começa com um sublinhado $täyte = 'mansikka'; // válido; 'ä' é um caracter ASCII (extendido) 228 ?> 1.3. Variáveis As variáveis no PHP são representadas por um cifrão ($) seguido pelo nome da variável. Os nomes de variável no PHP fazem distinção entre maiúsculas e minúsculas. $this é uma variável especial que não pode ser atribuída. Tipos Booleanos Este é o tipo mais fácil. Um booleano expressa um valor de verdade. Ele pode ser TRUE ou FALSE. Sintaxe Para especificar um literal booleano, use as palavras chave TRUE ou FALSE. Ambas são insensitivas ao caso. <?php $foo = True; // assimila o valor TRUE para $foo ?>



Usualmente você pode utilizar algum tipo de operador que retorne um valor booleano, e passá-lo para uma estrutura de controle. <?php

// == é um operador que testa // igualdade e retorna um booleano if ($action == "mostrar_versao") { echo "A versão é 1.23"; } // isto não é necessário ... if ($exibir_separadores == TRUE) { echo "<hr>\n"; } // ... porque você pode simplesmente escrever isso: if ($exibir_separadores) { echo "<hr>\n"; }

?>

Convertendo para booleano Para converter explicitamente um valor para booleano, utilize-se dos modificadores (bool) ou (boolean). Entretanto, na maioria dos casos, você não precisa utilizar o modificador, desde que qualquer valor será convertido automaticamente se um operador, função ou estrutura de controle requerer um argumento booleano. Veja também Manipulação de tipos. Quando convertendo para booleano, os seguintes valores são considerados FALSE:

• o próprio booleano FALSE • o inteiro 0 (zero) • o ponto flutuante 0.0 (zero) • uma string vazia e a string "0" • um array sem elementos • o tipo especial NULL (incluindo variáveis não definidas)

Qualquer outro valor é considerado TRUE (incluindo qualquer recurso). Aviso -1 é considerado TRUE, como qualquer valor não zero (negativos ou positivos)! <?php

var_dump((bool) ""); // bool(false) var_dump((bool) 1); // bool(true) var_dump((bool) -2); // bool(true) var_dump((bool) "foo"); // bool(true) var_dump((bool) 2.3e5); // bool(true) var_dump((bool) array(12)); // bool(true) var_dump((bool) array()); // bool(false) var_dump((bool) "false"); // bool(true)

?>



Inteiros Um inteiro é um número do conjunto Z = {..., -2, -1, 0, 1, 2, ...}. Sintaxe Inteiros podem ser especificados em notação decimal (base 10), hexadecimal (base 16) ou octal (base 8), opcionalmente precedido de sinal (- ou +). Para usar a notação octal, você precisa preceder o número com um 0 (zero). Para utilizar a notação hexadecimal, preceda número com 0x. Literais inteiras <?php

$a = 1234; // número decimal $a = -123; // um número negativo $a = 0123; // número octal (equivalente a 83 em decimal) $a = 0x1A; // número hexadecimal (equivalente a 26 em decimal)

?> Números de ponto flutuante Números de ponto flutuante ("floats", "doubles" ou "números reais") podem ser especificados utilizando qualquer uma das sintaxes seguintes: <?php

$a = 1.234; $b = 1.2e3; $c = 7E-10;

?> Strings Uma string é uma série de caracteres. No PHP, um caracter é o mesmo que um byte, ou seja, há exatamente 256 caracteres diferentes possíveis. Nota: Não há nenhum problema nas strings se tornarem muito grandes. Não há nenhum limite para o tamanho de strings imposta pelo PHP, então não há razão para se preocupar com strings longas. Sintaxe

• apóstrofo • aspas

Apóstrofos A maneira mais simples para especificar uma string é delimitá-la entre apóstrofos (também conhecido por aspas simples). Para especificar um apóstrofo você precisará "escapá-lo" com um contra barra (\), como em muitas outras linguagens. Se uma contra barra precisa ocorrer antes de um apóstrofo ou no final da string, você precisa duplicá-la. Note que se você tentar escapar qualquer outro caracter, a contra barra também será impressa! Então geralmente não é necessário escapar a própria contra barra.



Nota: Diferentemente das duas outras sintaxes, variáveis e seqüências de escape para caracteres especiais não serão substituídas quando elas ocorrerem dentro de strings delimitadas por apóstrofes. <?php

echo 'isto é uma string comum'; echo 'Você pode incluir novas linhas em strings, dessa maneira que estará tudo bem'; // Imprime: Arnold disse uma vez: "I\'ll be back" echo 'Arnold disse uma vez: "I\'ll be back"'; // Imprime: Você tem certeza em apagar C:\*.*? echo 'Você tem certeza em apagar C:\\*.*?'; // Imprime: Você tem certeza em apagar C:\*.*? echo 'Você tem certeza em apagar C:\*.*?'; // Imprime: Isto não será substituido: \n uma nova linha echo 'Isto não será substituido: \n uma nova linha'; // Imprime: Variaveis $também não $expandem echo 'Variaveis $também não $expandem';

?> Aspas Se a string é delimitada entre aspas ("), o PHP entende mais seqüências de escape para caracteres especiais:

Seqüências de escape Seqüência Significado \n fim de linha (linefeed ou LF ou 0x0A (10) em ASCII) \r retorno de carro (carriage return ou CR ou 0x0D (13) em ASCII) \t TAB horizontal (HT ou 0x09 (9) em ASCII) \\ contra barra ou barra invertida \$ sinal de cifrão \" Aspas Arrays Um array no PHP é atualmente um mapa ordenado. Um mapa é um tipo que relaciona valores para chaves. Este tipo é otimizado de várias maneiras, então você pode usá-lo como um array real, ou uma lista (vetor), hashtable (que é uma implementação de mapa), dicionário, coleção, pilha, fila e provavelmente mais. Como você pode ter outro array PHP como um valor, você pode facilmente simular árvores. Um array pode ser criado com o construtor de linguagem array(). Ele pega certo número de pares separados por vírgula chave => valor . array( chave => valor ) // chave pode ser tanto string ou um integer // valor pode ser qualquer coisa



<?php

$arr = array("foo" => "bar", 12 => true); echo $arr["foo"]; // bar echo $arr[12]; // 1

?>

A chave pode ser tanto um integer ou uma string. Se a chave é uma representação padrão de um integer, ele será interpretado assim (por exemplo, "8" será interpretado como 8, enquanto "08" será interpretado como "08"). Floats em chaves são truncados para integer. O valor pode ser qualquer tipo PHP: <?php

$arr = array("somearray" => array(6 => 5, 13 => 9, "a" => 42)); echo $arr["somearray"][6]; // 5 echo $arr["somearray"][13]; // 9 echo $arr["somearray"]["a"]; // 42

?>

Se omitir a chave quando fornece um novo item, o maior índice inteiro é obtido, e a nova chave será esse máximo + 1. Se você especificar uma chave que já possui um valor assimilada a ela, então o valor é sobrescrito. <?php

// Esse array é como ... array(5 => 43, 32, 56, "b" => 12); // ... este array array(5 => 43, 6 => 32, 7 => 56, "b" => 12);

?>

Você pode também modificar um array existente explicitamente assimilando valores nele. Isto é feito apenas assimilando valores para o array enquanto especificando a chave em colchetes. Você pode omitir a chave, colocando um par vazio de colchetes ("[]"). $arr[chave] = valor; $arr[] = valor; // chave tanto um integer ou string // valor pode ser qualquer coisa



Se $arr não existir ainda, ele será criado. Então isto é um meio alternativo para especificar um array. Para mudar um certo valor, apenas assimile um novo valor para um elemento especificado por sua chave. Se você quiser remover um par chave/valor, você deve aplicar unset() neste par. <?php

$arr = array(5 => 1, 12 => 2); $arr["x"] = 42; // Isto acrescenta um novo elemento // para o array com a chave "x" unset($arr[5]); // Isto remove um elemento do array unset($arr); // E isto apaga todo o array

?>

Objetos Inicialização de objetos Para inicializar um objeto, você usa a instrução new, criando uma instância do objeto em uma variável. <?php

class MinhaClasse { function metodo() { echo "Executando metodo."; } } $bar = new MinhaClasse; $bar->metodo();

?> Convertendo para objeto Se um objeto é convertido para objeto, ele não é modificado. Se um valor de outro tipo é convertido para objeto, uma nova instância da stdClass é criada. Se o valor é NULL, a nova instância estará vazia. Arrays convertem para um objeto com propriedades chamadas pelas chaves do array e com os respectivos valores. Para qualquer outro valor, uma variável membro chamada scalar irá conter o valor. <?php

$obj = (object) 'palavra'; echo $obj->scalar; // exibe 'palavra'

?> 1.4. Constantes

Uma constante é um identificador (nome) para um único valor. Como o nome sugere, esse valor não pode mudar durante a execução do script. As constantes são case-sensitive (distinguem letras maiúsculas e minúsculas) por padrão. Por convenção os nomes de constantes são sempre em maiúsculas. O nome de uma constante tem as mesmas regras de qualquer identificador no PHP. Um nome de constante válida começa com uma letra ou sublinhado, seguido por qualquer número de letras, números ou sublinhados.



Nomes de constantes válidos e inválidos <?php

// Nomes de constantes válidos define("FOO", "alguma coisa"); define("FOO2", "alguma outra coisa"); define("FOO_BAR", "alguma coisa mais"); // Nomes de constantes inválidas define("2FOO", "alguma coisa");

?>

O escopo de uma constante é global. Você pode acessar constantes de qualquer lugar em seu script sem se preocupar com o escopo. Sintaxe Você pode definir uma constante utilizando-se da função define(). Quando uma constante é definida, ela não pode ser mais modificada ou anulada. Somente dados escalares (boolean, integer, float e string) pode ser colocados em constantes. Não defina constantes do tipo resource (recurso). Você pode obter o valor de uma constante simplesmente especificando seu nome. Diferentemente de variáveis, você não pode prefixar uma constante com um sinal de $. Você também pode utilizar a função constant() para ler o valor de uma constante, se você precisar obter seu valor dinamicamente. Utilize get_defined_constants() para obter a lista de todas as constantes definidas. Estas são as diferenças entre constantes e variáveis:

• Constantes não podem ter um sinal de cifrão ($) antes delas; • Constantes só podem ser definidas utilizando a função define(), e não por simples

assimilação; • Constantes podem ser definidas e acessadas de qualquer lugar sem que a regras de escopo

de variáveis sejam aplicadas; • Constantes não podem ser redefinidas ou eliminadas depois que elas são criadas; e • Constantes só podem conter valores escalares.

Definindo Constantes <?php

define("CONSTANT", "Hello world."); echo CONSTANT; // imprime "Hello world." echo Constant; // imprime "Constant" e gera um aviso de alerta.

?>



1.5. Operadores

Operadores Aritméticos Exemplo Nome Resultado -$a Negação Oposto de $a. $a + $b Adição Soma de $a e $b. $a - $b Subtração Diferença entre $a e $b. $a * $b Multiplicação Produto de $a e $b. $a / $b Divisão Quociente de $a por $b. $a % $b Módulo Resto de $a dividido por $b. O operador de divisão ("/") sempre retorna um valor com ponto flutuante, a não ser que os dois operados sejam inteiros (ou strings que são convertidas para inteiros) e numéricos inteiramente divisíveis, em outro caso um inteiro é retornado. Operadores de Atribuição O operador básico de atribuição é "=". Isto quer dizer, na verdade, que o operando da esquerda recebe o valor da expressão da direita (ou seja, "é configurado para"). O valor de uma expressão de atribuição é o valor atribuído. Ou seja, o valor de "$a = 3" é 3. Isto permite que você crie algumas expressões como: <?php

$a = ($b = 4) + 5; // $a é igual a 9 agora e $b foi configurado como 4. ?>

Além do operador básico de atribuição, há "operadores combinados" para todos os operadores aritméticos, de array e string que permitem a você pegar um valor de uma expressão e então usar seu próprio valor para o resultado daquela expressão. Por exemplo: <?php

$a = 3; $a += 5; // configura $a para 8, como se disséssemos: $a = $a + 5; $b = "Bom "; $b .= "Dia!"; // configura $b para "Bom Dia!", como em $b = $b . "Dia!";

?>

Operadores de Comparação Operadores de comparação, como os seus nomes implicam, permitem que você compare dois valores. Você pode se interessar em ver as tabelas de comparação de tipos, que tem exemplo das várias comparações entre tipos relacionadas.



Operadores de comparação Exemplo Nome Resultado $a == $b Igual Verdadeiro (TRUE) se $a é igual a $b. $a === $b Idêntico Verdadeiro (TRUE) se $a é igual a $b, e eles são do mesmo tipo

(introduzido no PHP4). $a != $b Diferente Verdadeiro se $a não é igual a $b. $a <> $b Diferente Verdadeiro se $a não é igual a $b. $a !== $b Não idêntico Verdadeiro de $a não é igual a $b, ou eles não são do mesmo tipo

(introduzido no PHP4). $a < $b Menor que Verdadeiro se $a é estritamente menor que $b. $a > $b Maior que Verdadeiro se $a é estritamente maior que $b. $a <= $b Menor ou igual Verdadeiro se $a é menor ou igual a $b. $a >= $b Maior ou igual Verdadeiro se $a é maior ou igual a $b. Se você comparar um inteiro com uma string, a string é convertida para um número. Se você comparar 2 strings numéricas, elas serão comparadas como inteiras. Estas regras também se aplicam ao comando switch. <?php

var_dump(0 == "a"); // 0 == 0 -> true var_dump("1" == "01"); // 1 == 1 -> true var_dump("1" == "1e0"); // 1 == 1 -> true switch ("a") { case 0: echo "0"; break; case "a": // nunca é alcançado porque "a" já foi combinado com 0 echo "a"; break; }

?>

Para vários tipos, comparações são feitas de acordo com a seguinte tabela (em ordem). Comparação com vários tipos Tipo do 1º operando Tipo do 2º operando Resultado null ou string string Converte NULL para "", numérico ou

comparação léxica bool or null qualquer Converte para bool, FALSE < TRUE object object Classes nativas podem definir como são

comparadas, classes diferentes são incomparáveis. Classes de mesmo tipo – comparação de propriedades

string, resource ou number

string, resource ou number Transforma strings e resources para números

array array Array com menos membros é menor, se a chave do operando 1 não é encontrada no operando 2, então os arrays são incomparáveis, caso contrário - compara valor por valor (veja o seguinte exemplo)

array qualquer array é sempre maior Object qualquer object é sempre maior Transcrição do padrão de comparação de array



<?php

function comparacao_array($op1, $op2) { if (count($op1) < count($op2)) { return -1; // $op1 < $op2 } elseif (count($op1) > count($op2)) { return 1; // $op1 > $op2 } foreach ($op1 as $key => $val) { if (!array_key_exists($key, $op2)) { return null; // incomparavel } elseif ($val < $op2[$key]) { return -1; } elseif ($val > $op2[$key]) { return 1; } } return 0; // $op1 == $op2

} ?>

Operador Ternário Outro operador condicional é o operador ?: (ou ternário). Atribuindo um valor padrão <?php

$action = (empty($_POST['action'])) ? 'default' : $_POST['action']; // o mesmo que if (empty($_POST['action'])) { $action = 'default'; } else { $action = $_POST['action']; }

?>

A expressão (expr1) ? (expr2) : (expr3) é avaliada para expr2 se expr1 é avaliada como TRUE, ou expr3 se expr1 é avaliada como FALSE. Nota: Note que o operador ternário é um comando, e ele não é avaliado para uma variável, mas para o resultado do comando. Isto é importante saber se você quer retornar uma variável por referência. O comando return $var == 42 ? $a : $b; em uma função que retorna por referência conseqüentemente não irá funcionar e será avisado nas últimas versões do PHP. Nota: É recomendado evitar "stacking" de expressões ternárias. O comportamento do PHP quando usando mais de um operador ternário no único comando não é óbvio:



Comportamento do ternário (não recomendado) <?php // o seguinte aparenta imprimir 'true' echo (true?'true':false?'t':'f'); // conteudo, a saída acima é 't' // isto por causa da expressão ternário se avaliada da esquerda para direita // o seguinte é a versão mais óbvia do mesmo código acima echo ((true ? 'true' : 'false') ? 't' : 'f'); // aqui, você pode ver que a primeira expressão é avaliada para 'true', que // por sua vez avalia para (bool)true, assim retornando a parte true da // segunda expressão ternária. ?> Operadores de controle de erro O PHP suporta um operador de controle de erro: o sinal 'arroba' (@). Quando ele precede uma expressão em PHP, qualquer mensagem de alerta ou erro que possa ser gerada por aquela expressão será ignorada. <?php

/* Erro de arquivo intencional */ $my_file = @file ('arquivo_nao_existente') or die ("Falha abrindo arquivo: '$php_errormsg'"); // Isto funciona para qualquer expressão, não apenas para funções: $value = @$cache[$key]; // você não receberá nenhum aviso se a chave $key não existir.

?> Nota: O operador @ funciona somente em expressões. Uma regra simples para lembrar disso: se você pode pegar o valor de alguma coisa, você pode prefixar isso com o @. Assim, você pode prefixar chamadas de variáveis, funções e include()s, constantes e afins. Você não pode prefixar definições de funções ou classe, estruturas condicionais como o if, foreach e assim por diante. Nota: O prefixo de controle de erro "@" não desabilita mensagens que são resultado de erros de interpretação (parse errors). Operadores de Execução O PHP suporta um operador de execução: acentos graves (``). Note que não são apóstrofes! O PHP tentará executar o conteúdo dos acentos graves como um comando do shell; a saída será retornada (isto é, ela não será simplesmente descarregada para a saída; ela pode ser atribuída a uma variável). A utilização do operador contra-apóstrofo é idêntica a função shell_exec(). <?php

$output = `ls -l`; echo "<pre>$output</pre>";

?> Nota: O operador de execução fica desabilitado quando safe mode está ativo ou shell_exec() está desabilitado. Operadores de Incremento/Decremento O PHP suporta operadores de pré e pós-incremento e decremento no estilo C.



Nota: Os operadores incremento/decremento não afetam valores booleanos. Decrementando valores NULL não há efeito também, mas incrementando resulta em 1. Operadores de Incremento / Decremento Exemplo

Nome Efeito

++$a Pré-incremento Incrementa $a em um, e então retorna $a. $a++ Pós-incremento Retorna $a, e então incrementa $a em um. --$a Pré-decremento Decrementa $a em um, e então retorna $a. $a-- Pós-decremento Retorna $a, e então decrementa $a em um. Aqui está um script de exemplo simples: <?php

echo "<h3>Pós-incremento</h3>"; $a = 5; echo "Deve ser 5: " . $a++ . "<br />\n"; echo "Deve ser 6: " . $a . "<br />\n"; echo "<h3>Pré-incremento</h3>"; $a = 5; echo "Deve ser 6: " . ++$a . "<br />\n"; echo "Deve ser 6: " . $a . "<br />\n"; echo "<h3>Pós-decremento</h3>"; $a = 5; echo "Deve ser 5: " . $a-- . "<br />\n"; echo "Deve ser 4: " . $a . "<br />\n"; echo "<h3>Pré-decremento</h3>"; $a = 5; echo "Deve ser 4: " . --$a . "<br />\n"; echo "Deve ser 4: " . $a . "<br />\n";

?>

Operações aritmétricas em variáveis caracter <?php

$i = 'W'; for ($n=0; $n<6; $n++) { echo ++$i . "\n"; }

?> O exemplo acima irá imprimir: X Y Z AA AB AC Operadores Lógicos Exemplo Nome Resultado $a and $b E Verdadeiro (TRUE) se tanto $a quanto $b são verdadeiros. $a or $b OU Verdadeiro se $a ou $b são verdadeiros. $a xor $b XOR Verdadeiro se $a ou $b são verdadeiros, mas não ambos.



! $a NÃO Verdadeiro se $a não é verdadeiro. $a && $b E Verdadeiro se tanto $a quanto $b são verdadeiros. $a || $b OU Verdadeiro se $a ou $b são verdadeiros. A razão para as duas variantes dos operandos "and" e "or" é que eles operam com precedências diferentes. (Veja Precedência de Operadores.) Ilustrando operadores lógicos <?php

// "&&" tem maior precedência que "and" $a = false && true; $b = true and false; var_dump($a, $b); // "||" tem maior precedência que "or" $c = false || true; $d = true or false; var_dump($c, $d);

?>

O exemplo acima irá imprimir algo similar a: bool(false) bool(true) bool(true) bool(true)

Operadores de String Há dois operadores de string. O primeiro é o operador de concatenação ('.'), que retorna a concatenação dos seus argumentos direito e esquerdo. O segundo é o operador de atribuição e concatenação ('.='), que acrescenta o argumento do lado direito no argumento do lado esquerdo. <?php

$a = "Olá "; $b = $a . "mundo!"; // agora $b contém "Olá mundo!" $a .= "mundo!"; // agora $a contém "Olá mundo!"

?>

O operador + acrescenta os elementos da direita no array da esquerda, contudo, chaves duplicadas NÃO são sobrescritas. <?php

$a = array("a" => "maçã", "b" => "banana"); $b = array("a" =>"pêra", "b" => "framboesa", "c" => "morango"); $c = $a + $b; // Uniao de $a e $b echo "União de \$a e \$b: \n"; var_dump($c);



$c = $b + $a; // União de $b e $a echo "União de \$b e \$a: \n"; var_dump($c);

?>

Quando executado, o script produz uma saída assim: União de $a e $b: array(3) { ["a"]=> string(5) "maçã" ["b"]=> string(6) "banana" ["c"]=> string(6) "morango" } União de $b e $a: array(3) { ["a"]=> string(4) "pêra" ["b"]=> string(10) "framboesa" ["c"]=> string(6) "morango" }

Elementos do array são iguais para efeitos de comparação se eles possuem o mesmo valor e chave. Comparando arrays <?php

$a = array("maçã", "banana"); $b = array(1 => "banana", "0" => "maçã"); var_dump($a == $b); // bool(true) var_dump($a === $b); // bool(false)

?> Operadores de tipo instanceof é usado para determinar se um variável do PHP é uma objeto instânciado de uma certa classe: Usando instanceof com classes <?php

class A {} class B {} $a = new A; var_dump($a instanceof A); var_dump($a instanceof B );

?>

O exemplo acima irá imprimir:



bool(true) bool(false) instanceof pode também ser usado para determinar se uma variável é um objeto instanciado de uma classe que herda de uma classe pai: Usando instanceof com herança <?php

class ClasseMae { } class MinhaClasse extends ClasseMae { } $a = new MinhaClasse; var_dump($a instanceof MinhaClasse); var_dump($a instanceof ClasseMae);

?>

O exemplo acima irá imprimir: bool(true) bool(true) Por fim, instanceof pode também ser usado para determinar se uma variável é um objeto instanciado de uma classe que implementa uma interface: Usando instanceof para classe <?php

interface MinhaInterface {} class MinhaClasse implements MinhaInterface { } $a = new MinhaClasse; var_dump($a instanceof MinhaClasse); var_dump($a instanceof MinhaInterface);

?>

O exemplo acima irá imprimir: bool(true) bool(true) Embora instanceof é usualmente usado com um nome de classe literal, ele pode também ser usado com outro objeto ou uma variável string: Usando instanceof com outras variáveis <?php

interface MinhaInterface {} class MinhaClasse implements MinhaInterface {} $a = new MinhaClasse; $b = new MinhaClasse; $c = 'MinhaClasse'; $d = 'NaoMinhaClasse'; var_dump($a instanceof $b); // $b é um objeto da classe MinhaClasse var_dump($a instanceof $c); // $c é uma string 'MinhaClasse' var_dump($a instanceof $d); // $d é uma string 'NaoMinhaClasse'

?>



O exemplo acima irá imprimir: bool(true) bool(true) bool(false) 1.6. Estruturas de controle

if A construção if é uma das mais importantes implementações de muitas linguagens, incluindo o PHP. Ela permite a execução condicional de fragmentos de código. O PHP implementa uma estrutura if que é similar aquela do C: if (expressao) instrucoes Uma expressão é avaliada por seu contexto booleano. Se expressão for avaliado como TRUE, o PHP executará as instruções, e se for avaliado como FALSE, ele será ignorado. Os exemplos a seguir mostrariam “a é maior que b” se $a for maior que $b: <?php

if ($a > $b) echo "a é maior que b";

?> Normalmente você vai querer ter mais que uma instrução executada condicionalmente. E é claro, não há necessidade de englobar cada instrução com uma cláusula if. Em vez disso, você pode colocar várias instruções em um agrupamento de comandos. Por exemplo, este código mostraria “a é maior que b” se $a for maior que $b, e então atribuiria o valor de $a para $b: <?php

if ($a > $b) { echo "a é maior que b"; $b = $a; }

?> Comandos if podem ser aninhados indefinidamente dentro de outros comandos if, o que faz com que você complete a flexibilidade para a execução condicional de várias partes do seu programa. else Normalmente você vai querer executar uma instrução se uma certa condição for encontrada, e uma instrução diferente se a condição não for encontrada. Isto é o que o else faz. Else interpreta a saída de um comando if para executar uma instrução, caso a expressão no comando if seja avaliada como FALSE o else será executado. Por exemplo, o código a seguir mostraria “a é maior que b” se $a for maior que $b, e a NÃO é maior que b caso contrário:



<?php if ($a > $b) { echo "a é maior que b"; } else { echo "a NÃO é maior que b"; }

?> elseif elseif, como seu nome sugere, é uma combinação de if e else. Da mesma forma que o else, ele estende um comando if para executar uma instrução diferente no caso de a expressão if original ser avaliada como FALSE. Porém, ao contrário de else, ele executará aquela expressão alternativa somente se a expressão condicional do elseif for avaliada como TRUE. Por exemplo, o código a seguir mostraria “a é maior que b”, “a é igual a b” ou “a é menor que b”: <?php

if ($a > $b) { echo "a é maior que b"; } elseif ($a == $b) { echo "a é igual a b"; } else { echo "a é menor que b b"; }

?>

Podem haver vários elseifs dentro da mesma instrução if. A primeira expressão elseif (se houver) que for avaliada como TRUE será executada. No PHP, você também pode escrever 'else if' (em duas palavras) e o comportamento será idêntico a um 'elseif' (em uma só palavra). O comando elseif só é executado se a expressão if precedente e quaisquer expressões elseif anteriores forem avaliadas como FALSE, e a expressão elseif atual for avaliada como TRUE. while Loops while são o tipo mais simples de criar um laços em PHP. Eles se comportam como seus compatíveis em C. O formato básico de um comando while é: while (expressao) instrucoes O significado de um comando while é simples. Ele pede que o PHP execute os comandos aninhados repetidamente, enquanto a expressão do while é avaliada como TRUE. O valor da expressão é verificado cada vez que se passa no começo do 'loop', desta forma, mesmo que este valor mude durante a execução do(s) comando(s) aninhado(s), a execução não parará até que o fim da iteração (cada vez que o PHP executa os comandos dentro do 'loop' é uma iteração). Às vezes, se a expressão while é avaliada como FALSE logo no início, o(s) comando(s) aninhado(s) não será(ão) rodado(s) nem uma vez sequer. Como no comando if, você pode agrupar múltiplos comandos dentro do mesmo laço while englobando um grupo de instruções com chaves, ou usando a sintaxe alternativa: while (expressao): instrucoes ... endwhile;



Os exemplos a seguir são idênticos, e ambos imprimem números de 1 até 10: <?php

/* exemplo 1 */ $i = 1; while ($i <= 10) { echo $i++; /* o valor impresso será $i depois do acréscimo (post-increment) */ } /* exemplo 2 */ $i = 1; while ($i <= 10): echo $i; $i++; endwhile;

?> do-while Loops do-while são bem similares aos loops while, exceto pelo fato de que a condição é verificada no fim de cada iteração em vez de no começo. A diferença principal dos loops while regulares é que a primeira iteração de um loop do-while é garantidamente executada (a condição só é verificada no fim da iteração) enquanto que ele pode não rodar necessariamente em um loop while normal (a condição é verificada no começo de cada iteração, se ela é avaliada como FALSE logo no começo, a execução do loop terminaria imediatamente). Há apenas uma sintaxe para loops do-while: <?php $i = 0; do { echo $i; } while ($i > 0); ?> O loop acima rodaria exatamente uma vez, desde que depois da primeira iteração, quando a condição é verificada, ela é avaliada como FALSE ($i não é maior que zero 0) e a execução do loop termina. for Loops for são os laços mais complexos em PHP. Eles se comportam como os seus compatíveis em C. A sintaxe de um loop for é: for (expr1; expr2; expr3) instrucoes A primeira expressão (expr1) é avaliada (executada) uma vez incondicionalmente no começo do loop. No começo de cada iteração, expr2 é avaliada. Se ela é avaliada como TRUE, o loop continua e o(s) comando(s) aninhado(s) é(são) executado(s). Se é avaliada como FALSE, a execução do 'loop' termina. No fim de cada iteração, expr3 é avaliada (executada).



Cada uma das expressões pode ser vazia ou conter múltiplas expressões separadas por vírgulas. Em expr2, todas as expressões separadas por vírgula são avaliadas mas o resultado é obtido pela última parte. expr2 vazia significa que o loop pode rodar indefinidamente (PHP considera-a implicitamente como TRUE, como em C). Isto pode não ser tão inútil quanto você pode pensar, pois freqüentemente você pode querer terminar o 'loop' usando uma instrução break condicional em vez de usar a expressão-verdade do for. Considere os seguintes exemplos. Todos eles mostram números de 1 até 10: <?php

/* exemplo 1 */ for ($i = 1; $i <= 10; $i++) { echo $i; } /* exemplo 2 */ for ($i = 1; ; $i++) { if ($i > 10) { break; } echo $i; } /* exemplo 3 */ $i = 1; for (; ; ) { if ($i > 10) { break; } echo $i; $i++; } /* exemplo 4 */ for ($i = 1, $j = 0; $i <= 10; $j += $i, print $i, $i++);

?>

Obviamente, o primeiro exemplo parece ser o mais bonito (ou talvez o quarto), mas você pode perceber que a possível utilização de expressões vazias em laços for se torna prático em algumas ocasiões. foreach O PHP4 inclui um construtor foreach, muito parecido com o Perl e outras linguagens. Isto oferece uma maneira fácil de iterar sobre matrizes. foreach funciona somente com arrays, e lançará um erro se tentar utilizá-lo em uma variável de qualquer tipo diferente ou em variáveis não inicializadas. Há duas sintaxes: foreach (expressao_array as $valor) instrucoes foreach (expressao_array as $chave => $valor) instrucoes A primeira forma varre uma dada matriz dada por expressao_array. Em cada 'loop', o valor do elemento corrente é atribuído a $valor e o ponteiro interno da matriz é avançado em uma posição (assim, no próxima iteração você estará olhando para o próximo elemento). A segunda forma faz a mesma coisa, exceto pelo fato de que a chave do elemento atual será atribuído à variável $chave em cada iteração.



A partir do PHP 5, é possível iterar objetos também. Nota: Quando o foreach inicia sua primeira execução, o ponteiro interno da matriz é zerado automaticamente para o primeiro elemento do array. Isto significa que você não precisa chamar reset() antes de um loop foreach . A partir do PHP 5, você pode modificar facilmente os elementos da matriz precedendo $value com &. Isto irá definir uma referência ao invés de copiar o valor. <?php

$arr = array(1, 2, 3, 4); foreach ($arr as &$value) { $value = $value * 2; } // $arr is now array(2, 4, 6, 8) unset($value); // quebra a referência com o último elemento

?> Nota: No foreach é possível utilizar o operador '@' para evitar mensagens de erro. Você pode ter notado que os seguintes itens são funcionalmente idênticos: <?php

$arr = array("um", "dois", "três"); reset ($arr); while (list(, $value) = each ($arr)) { echo "Valor: $value<br />\n"; } foreach ($arr as $value) { echo "Valor: $value<br />\n"; } ?> Os seguintes também são funcionalmente idênticos: <?php $arr = array("one", "two", "three"); reset($arr); while (list($key, $value) = each ($arr)) { echo "Chave: $key; Valor: $value<br />\n"; } foreach ($arr as $key => $value) { echo "Chave: $key; Valor: $value<br />\n"; }

?>



Mais alguns exemplos para demonstrar os usos: <?php

/* exemplo foreach 1: somente valores */ $a = array(1, 2, 3, 17); foreach ($a as $v) { echo "Valor atual de \$a: $v.\n"; } /* exemplo foreach 2: valores (com as chaves impressas para ilustração) */ $a = array(1, 2, 3, 17); $i = 0; /* para exemplo somente */ foreach ($a as $v) { echo "\$a[$i] => $v.\n"; $i++; } /* exemplo foreach 3: chaves e valores */ $a = array ( "um" => 1, "dois" => 2, "três" => 3, "dezessete" => 17 ); foreach ($a as $k => $v) { echo "\$a[$k] => $v.\n"; } /* exemplo foreach 4: arrays multidimensionais */ $a = array(); $a[0][0] = "a"; $a[0][1] = "b"; $a[1][0] = "y"; $a[1][1] = "z"; foreach ($a as $v1) { foreach ($v1 as $v2) { echo "$v2\n"; } } /* exemplo foreach 5: arrays expressos */ foreach (array(1, 2, 3, 4, 5) as $v) { echo "$v\n"; }

?> break break cancela a execução do comando for, foreach, while, do-while ou switch atual. break aceita um argumento numérico opcional que diz a ele quantas estruturas aninhadas englobadas devem ser quebradas.



<?php $arr = array('um', 'dois', 'três', 'quatro', 'PARE', 'cinco'); while (list (, $val) = each ($arr)) { if ($val == 'PARE') { break; /* Você poderia colocar 'break 1;' aqui. */ } echo "$val<br />\n"; } /* Utilizando o argumento opcional. */ $i = 0; while (++$i) { switch ($i) { case 5: echo "No 5<br />\n"; break 1; /* Sai somente do switch. */ case 10: echo "No 10; saindo<br />\n"; break 2; /* Sai do switch e while. */ default: break; } }

?> continue continue é usado dentro de estruturas de loops para saltar o resto da iteração do loop atual e continuar a execução na avaliação e no início da próxima iteração. Nota: Note que no PHP a instrução switch é considerada uma estrutura de loop quando relacionada ao comando continue. continue aceita um argumento numérico opcional que diz a ele de quantos níveis de loops aninhados ele deve saltar até o fim. $arr = array(0,1,2,3,4,5,6,7,8,9); while (list ($key, $value) = each ($arr)) { if (!($key % 2)) { // pula itens pares continue; } echo $value; } echo "<br/>"; $i = 0; while ($i++ < 5) { echo "Fora<br />\n"; while (1) { echo " Meio<br />\n"; while (1) { echo " Dentro<br />\n"; continue 3; } echo "Isto nunca será exibido.<br />\n"; } echo "Nem isso.<br />\n"; } ?>



Omitindo o ponto e vírgula depois do continue pode resultar em confusão. Este é um exemplo do que você NÃO deve fazer. <?php

for ($i = 0; $i < 5; ++$i) { if ($i == 2) continue print "$i\n"; }

?> Um resultado esperado poderia ser: 0 1 3 4 mas esse script somente exibirá: 2 porque o valor de retorno da chamada a print() é int(1), e então ele se parecerá como o argumento numérico opcional mencionado acima. switch A instrução switch é similar a uma série de instruções IFs aninhados. Em muitas ocasiões, você poderá ter que comparar a mesma variável (ou expressão) com muitos valores diferentes, executando códigos diferentes dependendo com qual valor ele se encaixar. É exatamente para isso que a instrução switch faz. Nota: Note que diferentemente de outras linguagens, a instrução continue se aplica a switch e age similarmente a um break. Se você tem um switch dentro de um loop e deseja continuar para a próxima iteração do loop, use continue 2. Nota: Note que switch/case fazem comparações soltas. Os exemplos seguintes mostram duas maneiras diferentes de escrever a mesma coisa, uma utilizando uma série de ifs e elseifs e a outra utlizando a instrução switch:



<?php if ($i == 0) { echo "i igual a 0"; } elseif ($i == 1) { echo "i igual a 1"; } elseif ($i == 2) { echo "i igual a 2"; } switch ($i) { case 0: echo "i igual a 0"; break; case 1: echo "i igual a 1"; break; case 2: echo "i igual a 2"; break; }

?> A estrutura switch permite uso de strings <?php

switch ($i) { case "apple": echo "i is apple"; break; case "bar": echo "i is bar"; break; case "cake": echo "i is cake"; break; }

?>

É importante entender como a instrução switch funciona para evitar enganos. A instrução switch executa linha a linha (atualmente, instrução a instrução). No início, nenhum código é executado. Somente quando uma instrução case é encontrada com um valor que combina com a expressão do switch faz com que o PHP execute as instruções a partir daí. O PHP continua executando as instruções até o fim do bloco switch ou na primeira vez que encontrar uma instrução break. Se você não escrever uma instrução break no fim das instruções case, o PHP continuará executando os cases seguintes. Exemplo: <?php

switch ($i) { case 0: echo "i igual a 0"; case 1: echo "i igual a 1"; case 2: echo "i igual a 2"; }

?>



Aqui, se $i é igual a zero, o PHP executará todas as instruções echo! Se $i é igual a 1, o PHP executará os últimas duas instruções echo, e somente se $i for igual a 2, você terá o comportamento 'esperado' apenas onde 'i igual a 2' será mostrado. Então é importante não se esquecer das instruções break (e as vezes não colocá-las para obter esse resultado em certas circunstâncias). Em uma instrução switch, a condição somente será avaliada e resultado comparado para cada instrução case. Em uma instrução elseif, a condição é avaliada novamente. Se sua condição é mais complicada que um simples comparação e/ou e dentro de um loop, um switch é mais rápido. Um case pode não ter nenhuma instrução dentro, o que simplesmente passa o controle para o próximo case. <?php

switch ($i) { case 0: case 1: case 2: echo "i é menor que 3 mas não negativo"; break; case 3: echo "i é 3"; }

?>

Um case especial é o default. Esse case é executado quando nenhum outro case combina. Por exemplo: <?php

switch ($i) { case 0: echo "i igual a 0"; break; case 1: echo "i igual a 1"; break; case 2: echo "i igual a 2"; break; default: echo "i não é igual a 0, 1 ou 2"; }

?>

A expressão avaliada pelo case precisa ser um tipo simples, ou seja, inteiros, números de ponto flutuante e strings. Arrays ou objetos não podem ser utilizados a não ser que eles impliquem num tipo simples. A sintaxe alternativa para estruturas de controle é suportada para os switches. Para maiores informações, veja Sintaxe alternativa para estruturas de controle.



<?php switch ($i): case 0: echo "i igual a 0"; break; case 1: echo "i igual a 1"; break; case 2: echo "i igual a 2"; break; default: echo "i não é igual a 0, 1 ou 2"; endswitch;

?>

return Se chamada em uma função, a instrução return() termina imediatamente a execução da função atual e retorna seu argumento como o valor da função. return() também termina a execução de uma instrução eval() ou de um script. Se chamada no escopo global, a execução do script atual será terminada. Se o arquivo do script atual foi incluído com include() ou require(), então a execução é devolvida para o arquivo chamador. Especificamente para arquivos de script incluídos com include(), o valor fornecido para return() será devolvido como o valor da chamada include(). Se return() for chamado do arquivo de script principal, então o programa pára. Se o arquivo de script atual é o configurado em auto_prepend_file ou auto_append_file do php.ini, então a execução desses scripts é finalizada. Nota: Note que return() é um construtor de linguagem e não uma função, e parênteses em volta do argumento não é requerido. è comum deixa-los, e você atualmente deve faze-lo, já que o PHP tem menos trabalho para fazer neste caso. Nota: Você jamais deve usar parênteses em torno da sua variável retornada ao retornar por referência, já que isto não irá funcionar. Você pode retornar apenas variáveis por referência, não o resultado de um comando. Se você usar return ($a); então você não esta retornando uma variável, mas o resultado da expressão ($a) (o qual é, claro, o valor de $a). require A instrução require() inclui e avalia um arquivo específico. require() e include() são idênticos em todas as formas exceto pela manipulação de erros. Ambas produzem um Warning, mas require() resultará em um Fatal Error. Em outras palavras, não hesite em utilizar require() se na falta de um arquivo quiser parar o processamento da página. include() não se comporta da mesma maneira, e o script poderá continuar nessa situação. Em todo caso, vale a pena confirmar a configuração da diretiva include_path. Exemplos simples de require()s <?php

require 'prepend.php'; require $somefile; require ('somefile.txt');

?> include



A instrução include() inclui e avalia o arquivo informado. A documentação a seguir se aplica também a require(). Esses dois construtores são idênticos a exceção de como eles manipulam erros. Ambas produzem um Warning mas require() resultará em um Fatal Error. Em outras palavras, utilize require() se você deseja que um arquivo faltando interrompa o processamento da página. include() não se comporta da mesma maneira, permitindo que o script continue nessas situações. Em todo caso, vale a pena confirmar a configuração da diretiva include_path. Esteja avisado que um erro de interpretação no arquivo incluído não causa a parada do processamento em versões do PHP anteriores a PHP 4.3.5. A partir desta versão, causa. Arquivos a incluir são procurados primeiramente no include_path relativo ao diretório atual de trabalho, e então no diretório atual do script. Por exemplo, se seu include_path é libraries, o diretório atual é /www/, se você incluiu include/a.php e há um b.php nesse arquivo, b.php será procurado primeiro em /www/libraries/ e somente depois em /www/include/.0 Se o nome do arquivo começa com ./ ou ../, ele é procurado apenas no diretório atual. Quando um arquivo é incluído, seu código entra no escopo de variável da linha onde a inclusão ocorre. Qualquer variável disponível da linha onde a chamada da inclusão ocorre estará disponível para o arquivo incluído, daquele ponto em diante. Entretanto, todas as funções e classes definidas no arquivo incluído tem um escopo global. Exemplos de include()s simples variaveis.php <?php

$cor = 'verde'; $fruta = 'maçã'; ?> teste.php <?php echo "Uma $fruta $cor"; // Uma include 'vars.php'; echo "Uma $fruta $cor"; // Uma maçã verde

?> Se o include ocorre dentro de uma função do arquivo principal, então todo o código incluído será executado como se ele tivesse sido definido dentro daquela função. Da mesma forma, ele seguirá o escopo de variáveis da função. Uma exceção para esta regra são as constantes mágicas que são avaliadas pelo parser antes dos includes ocorrerem. Incluindo dentro de funções <?php

function foo() { global $cor; include 'variaveis.php'; echo "Uma $fruta $cor"; } /* variaveis.php está no escopo de foo(), * .* então $fruta NÃO está disponível fora de * .* seu escopo. $cor estará porque ela foi * .* declarada como global */ foo(); // Uma maçã verde echo "A $fruta $cor"; // Uma maçã

?> require_once



A instrução require_once() incluí e avalia o arquivo especificado durante a execução do script. Seu comportamento é similar ao da instrução require(), a não ser que o arquivo informado já tenha sido incluído, não refazendo a operação novamente. Veja a documentação de require() para maiores informações sobre como essa instrução funciona. require_once() pode ser utilizado nos casos em que o mesmo arquivo pode acabar sendo incluído mais de uma vez durante a execução de um script em particular, quando na verdade ele só pode ser incluído apenas uma, para evitar problemas com redefinições de funções, alterações nos valores de variáveis, etc. include_once A instrução include_once() inclui e avalia o arquivo especificado durante a execução de um script. Seu comportamento é similar a instrução include(), a não ser que o arquivo informado já tenha sido incluído, não refazendo a operação novamente. Como o nome sugere, ele será incluído apenas uma vez. include_once() pode ser utilizado nos casos em que o mesmo arquivo pode acabar sendo incluído mais de uma vez durante a execução de um script em particular, quando na verdade ele só pode ser incluído apenas uma para evitar problemas com redefinições de funções, alterações nos valores de variáveis, etc. 2. Arrays Um array é uma variável cujo objetivo é armazenar um conjunto de valores. Arrays indexados numericamente Quando não inicializamos um array usando o par associativo (chave e valor), implícitamente será adicionado um índice númerico a cada valor adicionado a array. Arrays indexados não numericamente Quando inicializamos um array usando o par associativo (chave e valor), essa chave explícitamente adicionada será o índice do array. Operadores de array Exemplo Nome Resultado $a + $b União União de $a e $b. $a == $b Igualdade TRUE se $a e $b tem os mesmos pares de chave/valor. $a === $b Identidade TRUE se $a e $b tem os mesmos pares de chave/valor na mesma

ordem e do mesmo tipo. $a != $b Desigualdade TRUE se $a não é igual a $b. $a <> $b Desigualdade TRUE se $a não é igual a $b. $a !== $b Não identidade TRUE se $a não é identico a $b. Array multidimensionais Os arrays não têm de ser uma lista simples de chaves e valores – cada localização no array pode armazenar outro array.



<pre> <?php $escopo = range(2, 10, 2); $mult = array ("cores" => array ( "a" => "amarelo", "b" => "azul", "c" => "verde" ), "Pares 1 a 10" => $escopo, "espaços" => array ("primeiro", 5 => "segundo", "terceiro" ) ); var_dump($mult); ?> </pre> <?php

print $mult["espaços"][5]; ?>

Resultado: array(3) { ["cores"]=> array(3) { ["a"]=> string(7) "amarelo" ["b"]=> string(4) "azul" ["c"]=> string(5) "verde" } ["Pares 1 a 10"]=> array(5) { [0]=> int(2) [1]=> int(4) [2]=> int(6) [3]=> int(8) [4]=> int(10) } ["espaços"]=> array(3) { [0]=> string(8) "primeiro" [5]=> string(7) "segundo" [6]=> string(8) "terceiro" } } segundo Classificação de arrays Classificar um array é poder ordená-lo de acordo com o critério desejado.



sort — Ordena um array Descrição bool sort ( array &$array [, int $sort_flags ] ) Essa função ordena um array. Os elementos serão ordenados do menor para o maior ao final da execução dessa função. Nota: Esta função define novas chaves para os elementos em array . Ela irá remover qualquer chave que você tenha definido, ao invés de simplesmente reordenar as chaves. Retorna TRUE em caso de sucesso ou FALSE em falhas. Exemplo de sort() <?php

$frutas = array("limao", "laranja", "banana", "melancia"); sort($frutas); foreach ($fruits as $key => $val) { echo "frutas[".$chave."] = ".$valor."\n"; }

?> O exemplo acima irá imprimir: fruits[0] = banana fruits[1] = laranja fruits[2] = limao fruits[3] = melancia



asort — Ordena um array mantendo a associação entre índices e valores Descrição bool asort ( array &$array [, int $sort_flags ] ) Essa função ordena um array de forma que a correlação entre índices e valores é mantida. É usada principalmente para ordenar arrays associativos onde a ordem dos elementos é um fator importante. Retorna TRUE em caso de sucesso ou FALSE em falhas. Exemplo de asort() <?php

$frutas = array("d" => "limao", "a" => "laranja", "b" => "banana", "c" => "melancia"); asort($frutas); foreach( $frutas as $chave => $valor ){ echo "$chave = $valor\n"; }

?> O exemplo acima irá imprimir: b = banana a = laranja d = limao c = melancia ksort — Ordena um array pelas chaves Descrição int ksort ( array $array [, int $sort_flags ] ) Ordena um array pelas chaves, mantendo a correlação entre as chaves e os valores. Essa função é bastante útil principalmente para arrays associativos. Exemplo de ksort() <?php

$frutas = array("d"=>"limao", "a"=>"laranja", "b" =>"banana", "c"=>"maçã"); ksort($frutas); reset($frutas); while (list($chave, $valor) = each($frutas)) { echo "$chave = $valor\n"; }

?> O programa acima mostraria: a = laranja b = banana c = maçã d = limao



usort — Ordena um array pelos valores utilizando uma função de comparação definida pelo usuário Descrição bool usort ( array &$array , string $cmp_function ) Essa função irá ordenar um array pelos valores usando uma função de classificação definida pelo usuário. Se o array precisar ser ordenado utilizando um critério não trivial, você deve usar essa função. A função de comparação deve retornar um inteiro menor, igual ou maior que zero se o primeiro argumento for considerado respectivamente menor, igual, ou maior que o segundo. Nota: Se dois elementos são considerados iguais, a ordem deles fica indefinida no array resultante. Até o PHP 4.0.6 as funções definidas pelo usuário manteriam a ordem original desses elementos, mas com o novo algoritmo de ordenação introduzido no 4.1.0 esse não é o caso, pois não existe solução para fazer isso de modo eficiente. Nota: Esta função define novas chaves para os elementos em array . Ela irá remover qualquer chave que você tenha definido, ao invés de simplesmente reordenar as chaves. Retorna TRUE em caso de sucesso ou FALSE em falhas. Exemplo de usort() <?php

function cmp($a, $b) { if ($a == $b) { return 0; } return ($a < $b) ? -1 : 1; } $a = array(3, 2, 5, 6, 1); usort($a, "cmp"); foreach ($a as $key => $value) { echo "$chave: $valor\n"; }

?>

O exemplo acima irá imprimir: 0: 1 1: 2 2: 3 3: 5 4: 6 Funções de arrays shuffle — Mistura os elementos de um array Descrição bool shuffle ( array &$array )



Essa função mistura de forma aleatória os elementos de um array. Nota: Esta função define novas chaves para os elementos em array . Ela irá remover qualquer chave que você tenha definido, ao invés de simplesmente reordenar as chaves. Exemplo de shuffle() <?php

$numbers = range(1,20); srand((float)microtime()*1000000); shuffle($numbers); foreach ($numbers as $number) { echo "$number "; }

?> count — Conta o número de elementos de uma variável, ou propriedades de um objeto Descrição int count ( mixed $var [, int $mode ] ) Retorna o número de elementos de var , que normalmente é um array (uma vez que qualquer outra coisa terá apenas um elemento). Para objetos, se você tem SPL instalada, você pode fazer um gancho na count() implementando a interface Countable. A interface tem exatamente um método, count(), que retorna o valor retornado para função count(). Se var não for um array ou um objeto, com a interface Countable implementada, 1 será retornado. Há uma exceção, se var é NULL, 0 é retornado. Nota: O parâmetro opcional mode esta disponível apartir do PHP 4.2.0. Se o parâmetro opcional mode for COUNT_RECURSIVE (ou 1), a função count() irá recursivamente contar a matriz. Isto é particularmente util para contar elementos em matriz multidimensional. O valor padrão para mode é 0. count() não detecta infinita recursão. Cuidado count() pode retornar 0 para uma variável que não existe, mas também pode retornar 0 para uma variável que tenha sido inicializada como um array vazio. Use isset() para checar se a variável existe. Por favor, veja a sessão Array do manual para uma explicação mais detalhada sobre como os arrays são implementados e utilizados no PHP.



Exemplo de count() <?php

$a[0] = 1; $a[1] = 3; $a[2] = 5; $result = count($a); // $result == 3 $b[0] = 7; $b[5] = 9; $b[10] = 11; $result = count($b); // $result == 3 $result = count(null); // $result == 0 $result = count(false); // $result == 1

?>

3. Manipulação de strings

Formatando strings trim — Retira espaço no ínicio e final de uma string Descrição string trim ( string $str [, string $charlist] ) Esta função retorna uma string com os espaçoes retirados do ínicio e do final de str. Sem o segundo parâmetro, trim() irá retirar estes caracteres " " (ASCII 32 (0x20)), um espaço normal. "\t" (ASCII 9 (0x09)), uma tabulação. "\n" (ASCII 10 (0x0A)), uma linha nova (line feed). "\r" (ASCII 13 (0x0D)), um retono de carro. "\0" (ASCII 0 (0x00)), o byte NULL. "\x0B" (ASCII 11 (0x0B)), uma tabulação vertical. Você também pode especificar quais caracteres você quer retirar, através do parâmetro charlist. Simplesmente liste todos os caracteres que você quer retirar. Com .. você pode especificar um intervalo de caracteres. Exemplo de uso de trim() <?php

$text = "\t\tThese are a few words :) ... "; $trimmed = trim($text); // $trimmed = "These are a few words :) ..." $trimmed = trim($text," \t."); // $trimmed = "These are a few words :)" $clean = trim($binary,"\0x00..\0x1F"); // trim the ASCII control characters at the beginning and end of $binary // (from 0 to 31 inclusive)

?> ltrim — Retira espaço em branco do início da string



rtrim — Retira espaço em branco do fim da string nl2br — Insere quebras de linha HTML antes de todas novas linhas em uma string Descrição string nl2br ( string $string ) Retorna string com '<br />' inserido antes de todas as novas linhas. Parâmetros string A string de entrada. Valor Retornado Retorna a string alterada. Exemplo <?php

echo nl2br("foo isn't\n bar"); ?> O exemplo acima irá imprimir: foo isn't<br />

bar Unindo e dividindo strings implode ou join — Junta elementos de uma matriz em uma string Descrição string implode ( string $glue, array $pieces ) Retorna uma string contendo os elementos da matriz na mesma ordem com uma ligação entre cada elemento. Exemplo <?php

$array = array('lastname', 'email', 'phone'); $comma_separated = implode(",", $array); print $comma_separated; // lastname,email,phone

?> explode — Divide uma string em strings Valor Retornado array explode ( string $delimiter, string $string [, int $limit] ) Retorna uma matriz de strings, cada uma como substring de string formada pela divisão dela a partir do delimiter. Parâmetros



delimiter O delimitador. string A string de entrada. limit Se limit é definido, o array retornado irá conter o máximo de elementos igual a limit com o último elemento contendo o resto da string. Se o parâmetro limit é negativo, todos componentes são retornados exceto os (x) últimos. Valor Retornado Se delimiter é uma string vazia (""), explode() irá retornar FALSE. Se delimiter contém um valor que não contém em string, então explode() irá retornar um array contendo string. Exemplos <?php

$pizza = "piece1 piece2 piece3 piece4 piece5 piece6"; $pieces = explode(" ", $pizza); echo $pieces[0]; // piece1 echo $pieces[1]; // piece2 // Example 2 $data = "foo:*:1023:1000::/home/foo:/bin/sh"; list($user, $pass, $uid, $gid, $gecos, $home, $shell) = explode(":", $data); echo $user; // foo echo $pass; // *

?>

Exemplos de parâmetro limit <?php

$str = 'one|two|three|four'; // positive limit print_r(explode('|', $str, 2)); // negative limit print_r(explode('|', $str, -1));

?> O exemplo acima irá imprimir: Array ( [0] => one [1] => two|three|four ) Array ( [0] => one [1] => two [2] => three )



substr — Retorna uma parte de uma string Descrição string substr ( string $string, int $start [, int $length] ) substr()retorna a parte de string especificada pelo parâmetro start e length. Se start não for negativo, a string retornada iniciará na posição start em string, começando em zero. Por exemplo, na string 'abcdef', o caractere na posição 0 é 'a', o caractere na posição 2 é 'c', e assim em diante. Uso basico de substr() <?php

$rest = substr("abcdef", 1); // retorna "bcdef" $rest = substr("abcdef", 1, 3); // retorna "bcd" $rest = substr("abcdef", 0, 4); // retorna "abcd" $rest = substr("abcdef", 0, 8); // retorna "abcdef" // Outra opção é acessar atravéz de chaves $string = 'abcdef'; echo $string{0}; // retorna a echo $string{3}; // retorna d

?> Se start for negativo, a string retornada irá começar no caractere start a partir do fim de string. Usando um inicio negativo <?php

$rest = substr("abcdef", -1); // retorna "f" $rest = substr("abcdef", -2); // retorna "ef" $rest = substr("abcdef", -3, 1); // retorna "d"

?> Se length for dado e for positivo, a string retornada irá conter length caracteres começando em start (dependendo do tamanho de string). Se a string é menor do que start, será retornado FALSE. Se length for dado e for negativo, então esta quantidade caracteres serão omitidos do final de string (após a posicão de inicio ter sido calculada quando start for negativo). Se start denota uma posição além da truncagem, uma string vazia será retornada. Usando um length negativo <?php

$rest = substr("abcdef", 0, -1); // retorna "abcde" $rest = substr("abcdef", 2, -1); // retorna "cde" $rest = substr("abcdef", 4, -4); // retorna "" $rest = substr("abcdef", -3, -1); // retorna "de"

?>



Comparando strings strcmp — Comparação de string segura para binário Descrição int strcmp ( string $str1, string $str2 ) Retorna < 0 se str1 é menor do que str2; > 0 se str1 é maior do que str2, e 0 se forem iguais. Note que esta função diferencia maiúsculas e minúsculas. strcasecmp — Comparação de strings sem diferenciar maiúsculas e minúsculas segura para binário Descrição int strcasecmp ( string $str1, string $str2 ) Retorna < 0 se str1 é menor do que str2; > 0 se str1 é maior do que str2, e 0 se forem iguais. Exemplo strcasecmp() <?php

$var1 = "Hello"; $var2 = "hello"; if (strcasecmp($var1, $var2) == 0) { echo '$var1 é igual a $var2 numa comparação sem diferenciar maiúsculas e minúsculas'; }

?> strnatcmp — Comparação de strings usando o algoritmo "natural order" Descrição int strnatcmp ( string $str1, string $str2 ) Esta função implementa um algoritmo de comparação de strings alfanumérico do jeito que um ser humano faz, isto é descrito como "ordem natural". Um exemplo da diferença entre este algoritmo e os algoritmos regulares de ordenação (usado em strcmp()) pode ser visto abaixo: <?php

$arr1 = $arr2 = array("img12.png","img10.png","img2.png","img1.png"); echo "Comparação de string padrão\n"; usort($arr1,"strcmp"); print_r($arr1); echo "\nComparação usando ordem natural\n"; usort($arr2,"strnatcmp"); print_r($arr2);

?>

O código acima irá gerar a seguinte saída:



Comparação de string padrão Array ( [0] => img1.png [1] => img10.png [2] => img12.png [3] => img2.png ) Comparação usando ordem natural Array ( [0] => img1.png [1] => img2.png [2] => img10.png [3] => img12.png )

strlen — Retorna o tamanho de uma string Descrição int strlen ( string $str ) Retorna o tamanho de string. Exemplo strlen() <?php

$str = 'abcdef'; echo strlen($str); // 6 $str = ' ab cd '; echo strlen($str); // 7

?> Localizando e substituindo substrings com funções de string strstr — Encontra a primeira ocorrencia de uma string Descrição string strstr ( string $haystack, string $needle, bool $before_needle ) Retorna parte da string haystack a partir da primeira ocorrência de needle até o final de haystack. Nota: Esta função diferencia maiúsculas e minúsculas. Para pesquisas que não diferenciem, use stristr(). Nota: Se você quer somente determinar se um específica needle existem em haystack, use a função mais rápida e que usa menos memória ao invés, strpos(). Parâmetros haystack A string de entrada. needle



Se needle não é uma string, é convertido para um inteiro e aplicado como valor ordinal de um caractere. before_needle Se TRUE (o padrão é FALSE), strstr() retorna a parte de haystack antes da primeira ocorrência de needle. Valor Retornado Retorna a parte da string, ou FALSE se needle não é encontrado. Exemplo strstr() <?php

$email = '[email protected]'; $domain = strstr($email, '@'); echo $domain; // prints @example.com $user = strstr($email, '@', true); echo $user; // prints name

?> strpos — Encontra a posição da primeira ocorrência de uma string Descrição int strpos ( string $haystack, string $needle [, int $offset] ) Retorna a posição numérica da primeira ocorrência de needle dentro de haystack. Diferentemente de strrpos(), esta função pode ter uma string inteira como o parâmetro needle e toda a string será usada. Se needle não for encontrado, strpos() irá retornar o boolean FALSE. Atenção Esta função pode retornar o booleano FALSE, mas também pode retornar um valor não-booleano que pode ser avaliado como FALSE, como 0 ou "". Leia a seção em Booleanos para maiores informações. Utilize o operador === para testar o valor retornado por esta função. Exemplos strpos() <?php

$mystring = 'abc'; $findme = 'a'; $pos = strpos($mystring, $findme); // Note o uso de ===. Simples == não funcionaria como esperado // por causa da posição de 'a' é 0 (primeiro) caractere. if ($pos === false) { echo "A string '$findme' não foi encontrada na string '$mystring'"; } else { echo "A string '$findme' foi encontrada na string '$mystring'"; echo " e existe na posição $pos"; }

?>



Se o parâmetro needle não é uma string, é convertido para um inteiro e aplicado o valor do caractere. O parâmetro opcional offset permite a você definir a partir de qual caractere em haystack iniciar a busca. A posição retorna ainda é relativa ao inicio de haystack. strrpos — Encontra a posição da última ocorrência de um caractere em uma string Descrição int strrpos ( string $haystack, string $needle [, int $offset] ) Retorna a posição numérica da última ocorrência de needle na string haystack. Note que a needle neste caso pode apenas ser um simples caractere PHP 4. Se uma string é passada como a needle, então apenas o primeiro caractere dessa string será usado. Se needle não é encontrado, retorna FALSE. É fácil errar a interpretação dos valores de retorno para "character found at position 0" e "character not found". Aqui segue um exemplo de como detectar a diferença: <?php

// no PHP 4.0.0 e posterior: $pos = strrpos($mystring, "b"); if ($pos === false) { // note: três sinais iguais // não encontrado... } // em versões mais antigas do que 4.0.0: $pos = strrpos($mystring, "b"); if (is_bool($pos) && !$pos) { // não encontrado... }

?> Se needle não é uma string, ela é convertida para um inteiro e aplicada como o valor ordinal de um caractere. Nota: No PHP 5.0.0 o offset pode ser especificado para iniciar a busca num número arbitrário de caracteres dentro da string. Valores negativos irão parar a busca em um ponto arbitrário antes do final da string. Nota: A needle pode ser uma string de mais de um caractere no PHP 5. Parâmetros haystack needle offset strrchr — Encontra a ultima ocorrência de um caractere em uma string Descrição string strrchr ( string $haystack, char $needle )



Esta função retorna a parte de haystack que inicia na última ocorrência de needle e vai até o fim de haystack. Retorna FALSE se needle não for encontrado. Se needle conter mais de um caractere, apenas o primeiro é usado. Isto é diferente da função strchr(). Se needle não for uma string, é convertido para uma string e é aplicado o valor do caractere. Exemplo strrchr() <?php

// get last directory in $PATH $dir = substr(strrchr($PATH, ":"), 1); // get everything after last newline $text = "Line 1\nLine 2\nLine 3"; $last = substr(strrchr($text, 10), 1 );

?>

str_replace — Substitui todas as ocorrências da string de procura com a string de substituição Descrição mixed str_replace ( mixed $pesquisa, mixed $substitui, mixed $assunto [, int $&count] ) Esta função retorna uma string ou um array com todas as ocorrências de pesquisa em assunto substituidas com a o valor dado para substitui. Exemplo <?php

// Fornece: <body text='black'> $bodytag = str_replace("%body%", "black", "<body text='%body%'>"); // Fornece: Hll Wrld f PHP $vowels = array("a", "e", "i", "o", "u", "A", "E", "I", "O", "U"); $onlyconsonants = str_replace($vowels, "", "Hello World of PHP"); // Fornece: você comeria pizza, cerveja e sorvete todos os dias $frase = "você comeria frutas, vegetais, e fibra todos os dias."; $saudavel = array("frutas", "vegetais", "fibra"); $saboroso = array("pizza", "cerveja", "sorvete"); $novafrase = str_replace($saudavel, $saboroso, $frase); // Uso do parâmetro count está disponível no PHP 5.0.0 $str = str_replace("ll", "", "good golly miss molly!", $count); echo $count; // 2

?> substr_replace — Substitui o texto dentro de uma parte de uma string Descrição mixed substr_replace ( mixed $string, string $replacement, int $start [, int $length] ) substr_replace() substitui uma cópia de string delimitada pelos parâmetros start e (opcionalmente) length com a string dada em replacement. Parâmetros string



A string de entrada. replacement A string substituta. start Se start é positivo, a substituição começará no start-ésimo caractere da string. Se start é negativo, a substituição começará no start-ésimo caractere do final de string. length Se dado e é positivo, ele representa o comprimento da porção de string que é para ser substituída. Se ele é negativo, ele representa o número de caracteres do final de string para parar de substituir. Se ele não é dado, então o padrão será até strlen( string ); i.e. o fim da substituição no final de string. Obviamente, se length é zero então esta função irá ter efeito de inserir replacement em string na dada posição start. Valor Retornado A string de resultado é retornada. Se string é um array, então um array será retornado. Exemplos <?php

$var = 'ABCDEFGH:/MNRPQR/'; echo "Original: $var<hr />\n"; /* Estes dois exemplos substituem tudo de $var com 'bob'. */ echo substr_replace($var, 'bob', 0) . "<br />\n"; echo substr_replace($var, 'bob', 0, strlen($var)) . "<br />\n"; /* Insere 'bob' direto no começo de $var. */ echo substr_replace($var, 'bob', 0, 0) . "<br />\n"; /* Estes dois exemplos substituem 'MNRPQR' em $var com 'bob'. */ echo substr_replace($var, 'bob', 10, -1) . "<br />\n"; echo substr_replace($var, 'bob', -7, -1) . "<br />\n"; /* Deleta 'MNRPQR' de $var. */ echo substr_replace($var, '', 10, -1) . "<br />\n";

?> 4. Utilização de funções Argumentos de funções Informações podem ser passadas para funções através da lista de argumentos, que é uma lista de expressões delimitados por vírgulas. Passando arrays para funções <?php

function takes_array($input) { echo "$input[0] + $input[1] = ", $input[0]+$input[1]; }

?>



Fazendo argumentos serem passados por referência Por padrão, argumentos de função são passados por valor (de forma que se você mudar o valor do parâmetro dentro da função, ele não é alterado fora da função). Se você deseja permitir que uma função modifique seus argumentos, você precisa passá-los por referência. Se você quer que um argumento para uma função sempre seja passado por referência, você pode preceder o nome do argumento com um "e comercial" (&) na definição da função: <?php

function add_some_extra(&$string) { $string .= ' e alguma coisa mais.'; } $str = 'Isto é uma string,'; add_some_extra($str); echo $str; // imprime 'Isto é uma string, e alguma coisa mais.'

?>

Valores padrão de argumentos Uma função pode definir valores padrão no estilo C++ para argumentos escalares, como a seguir: <?php

function cafeteira ($tipo = "cappuccino") { return "Fazendo uma xícara de café $tipo.\n"; } echo cafeteira (); echo makecoffee(null); echo cafeteira ("expresso");

?>

A saída do código acima será: Fazendo uma xícara de café cappucino. Fazendo uma xícara de . Fazendo uma xícara de café expresso. O PHP também permite que você use matrizes e o tipo especial NULL como valor padrão, por exemplo: Usando tipos não escalares como valores padrões <?php

function makecoffee($types = array("cappuccino"), $coffeeMaker = NULL) { $device = is_null($coffeeMaker) ? "hands" : $coffeeMaker; return "Making a cup of ".join(", ", $types)." with $device.\n"; } echo makecoffee(); echo makecoffee(array("cappuccino", "lavazza"), "teapot");

?>



5. Conceitos e implementação de orientação a objeto 5.1. Classe Toda definição de classe começa com a palavra-chave class, seguido por um nome da classe, que pode ser qualquer nome que não seja uma palavra reservada no PHP. seguido por um par de chaves, que contém a definição dos membros e métodos da classe. Uma pseudo variável, $this, está disponível quando um método é chamado dentro de um contexto de objeto. $this é uma referência para o objeto chamador do método (normalmente o objeto ao qual o método pertence, mas pode ser outro objeto, se o método é chamado statically do contexto de um objeto secundário). Isso é ilustrado no exemplo a seguir: Variável $this em linguagens com orientação à objetos <?php

class A { function foo() { if (isset($this)) { echo '$this está definida ('; echo get_class($this); echo ")\n"; } else { echo "\$this não está definida.\n"; } } } class B { function bar() { A::foo(); } } $a = new A(); $a->foo(); A::foo(); $b = new B(); $b->bar(); B::bar();

?>

O exemplo acima irá imprimir: $this está definida (a) $this não está definida. $this está definida (b) $this não está definida.



Definição de SimpleClass <?php

class SimpleClass { // declaração de membro public $var = 'um valor padrão'; // declaração de método public function displayVar() { echo $this->var; } }

?>

5.2. Objeto new Para criar uma instância de um objeto, um novo objeto deve ser criado e atribuído à uma variável. Um objeto sempre será atribuído quando for criado um novo objeto, a não ser que o objeto tenha um construtor definido que dispare uma exceção por um erro. Classes devem ser definidas antes de serem instanciadas (e em alguns casos isso é um requerimento). Criando uma instância <?php

$instance = new SimpleClass(); ?> No contexto da classe, é possível criar um novo objeto por new self and new parent. Quando atribuír um instância já criada de um objeto à uma variável nova, essa acessarpa a mesma instância do objeto que foi atribuído. Esse comportamento se mantem quando passando instâncias à uma função. Uma nova instância de um objeto já criado pode ser feita clonando o mesmo. Atribuíção de Objetos <?php

$assigned = $instance; $reference =& $instance; $instance->var = '$assigned terá esse valor'; $instance = null; // $instance e $reference tornam-se nulos var_dump($instance); var_dump($reference); var_dump($assigned);

?>

O exemplo acima irá imprimir: NULL NULL object(SimpleClass)#1 (1) { ["var"]=> string(30) "$assigned terá esse valor" }



5.3. Herança Extends Uma classe pode herdar métodos e membros de outra classe usando a palavra-chave extends na sua declaração. Não é possível herdar classes múltiplas, uma classe só pode herdar uma classe base. Os métodos e membros herdados podem ser sobrescritos, a não ser que a classe pai definiu um método como final, redeclarando eles com o mesmo nome definido na classe pai. É possível acessar os sobreescritos métodos ou membros estáticos referenciado-os com parent:: Herança Simples <?php class ExtendClass extends SimpleClass { // Redefine o método pai function displayVar() { echo "Classe Herdeira\n"; parent::displayVar(); } } $extended = new ExtendClass(); $extended->displayVar(); ?>

O exemplo acima irá imprimir: Classe Herdeira um valor padrão Sobrecarga Tanto chamada de métodos e acesso a membros podem ser sobrecarregados pelos métodos __call, __get e __set. Esses métodos só serão disparados quando seu objeto ou o objeto herdado não contiver o membro ou método que você está tentando acessar. Todos os métodos sobrecarregados devem ser definidos estáticos. Todos os métodos sobrecarregados devem ser definidos public. É possível sobrecarregar as funções isset() and unset() através dos métodos __isset e __unset respectivamente. O método __isset também é chamado com a função empty(). Sobrecarga de membros void __set ( string $name, mixed $value ) mixed __get ( string $name ) bool __isset ( string $name ) void __unset ( string $name ) Nota: O método __set() não pode obter argumentos por referência. Exemplo de sobrecarga com __get, __set, __isset e __unset



<?php class Setter { public $n; private $x = array("a" => 1, "b" => 2, "c" => 3); public function __get($nm) { echo "Getting [$nm]\n"; if (isset($this->x[$nm])) { $r = $this->x[$nm]; print "Returning: $r\n"; return $r; } else { echo "Nothing!\n"; } } public function __set($nm, $val) { echo "Setting [$nm] to $val\n"; if (isset($this->x[$nm])) { $this->x[$nm] = $val; echo "OK!\n"; } else { echo "Not OK!\n"; } } public function __isset($nm) { echo "Checking if $nm is set\n"; return isset($this->x[$nm]); } public function __unset($nm) { echo "Unsetting $nm\n"; unset($this->x[$nm]); } } $foo = new Setter(); $foo->n = 1; $foo->a = 100; $foo->a++; $foo->z++; var_dump(isset($foo->a)); //true unset($foo->a); var_dump(isset($foo->a)); //false // Isso não passa pelo método __isset() // porque 'n' é uma proriedade pública var_dump(isset($foo->n)); var_dump($foo);

?>

O exemplo acima irá imprimir:



Setting [a] to 100 OK! Getting [a] Returning: 100 Setting [a] to 101 OK! Getting [z] Nothing! Setting [z] to 1 Not OK! Checking if a is set bool(true) Unsetting a Checking if a is set bool(false) bool(true) object(Setter)#1 (2) { ["n"]=> int(1) ["x:private"]=> array(2) { ["b"]=> int(2) ["c"]=> int(3) } }

Sobrecarga de método mixed __call ( string $name, array $arguments ) O método mágico __call() permite captura a invocação de métodos não existentes. Dessa forma, __call() pode ser usado para implementar tratamento de métodos definidos pelo usuário que dependem do nome do próprio método ser chamado. Isso é útil para implementações proxy, por exemplo. Os argumentos que são passados na função serão definidos como um array no parâmetro $arguments. O valor retornado do método __call() será retornado ao chamador do método. Exemplo de sobrecarga com __call <?php

class Caller { private $x = array(1, 2, 3); function __call($m, $a) { print "Método $m chamado:\n"; var_dump($a); return $this->x; } } $foo = new Caller(); $a = $foo->teste(1, "2", 3.4, true); var_dump($a);

?>



O exemplo acima irá imprimir: Método teste chamado: array(4) { [0]=> int(1) [1]=> string(1) "2" [2]=> float(3.4) [3]=> bool(true) } array(3) { [0]=> int(1) [1]=> int(2) [2]=> int(3) }

5.4. Criação de objetos Construtores void __construct ( [mixed $args [, $...]] ) PHP 5 permite que os desenvolvedores declarem métodos construtores para as classes. Classes que tem um método construtor chamam esse método cada vez que um objeto novo é criado, então é apropriado para qualquer inicialização que o objeto possa vir a precisar antes de ser usado. Nota: Construtores pais não são chamados implicitamente se a classe filha define um construtor. Para executar o construtor da classe pai, uma chamada a parent::__construct() dentro do construtor da classe filha é necessária. Usando novos construtores unificados <?php

class ClasseBase { function __construct() { print "No construtor da ClasseBase\n"; } } class SubClasse extends ClasseBase { function __construct() { parent::__construct(); print "No construtor da SubClasse\n"; } } $obj = new ClasseBase(); $obj = new SubClasse();

?>



Destrutores void __destruct ( void ) Exemplo de Destrutor <?php

class MinhaClasseDestruivel { function __construct() { print "No construtor\n"; $this->name = "MinhaClasseDestruivel"; } function __destruct() { print "Destruindo " . $this->name . "\n"; } } $obj = new MinhaClasseDestruivel();

?> 5.5. Controle de acesso Visibilidade A visibilidade de uma propriedade ou método pode ser definida prefixando a declaração com as palavras-chave: 'public','protected' ou 'private'. Itens declarados como public podem ser acessados por todo mundo. Protected limita o acesso a classes herdadas (e para a classe que define o item). Private limita a visibilidade para apenas a classe que define o item. Visibilidade dos membros Membros de uma classe devem ser definidos com public, private, ou protected. Declaração de Membros <?php

/** * Define MinhaClasse */ class MinhaClasse { public $publica = 'Public'; protected $protegida = 'Protected'; private $privada = 'Private'; function imprimeAlo() { echo $this->publica; echo $this->protegida; echo $this->privada; } } $obj = new MinhaClasse(); echo $obj->publica; // Funciona echo $obj->protegida; // Erro Fatal echo $obj->privada; // Erro Fatal $obj->imprimeAlo(); // Mostra Public, Protected e Private



/** * Define MinhaClasse2 */ class MinhaClasse2 extends MinhaClasse { // Nós podemos redeclarar as propriedades públicas e protegidas mas não as privadas protected $protegida = 'Protected2'; function imprimeAlo() { echo $this->publica; echo $this->protegida; echo $this->privada; } } $obj2 = new MinhaClasse2(); echo $obj2->publica; // Works echo $obj2->privada; // Undefined echo $obj2->protegida; // Fatal Error $obj2->imprimeAlo(); // Mostra Public, Protected2, Undefined

?>

Visibilidades de métodos Métodos de classe devem ser definidos com public, private, ou protected. Métodos sem qualquer declaração são definidas como public. Declaração de método <?php

/** * Define MinhaClasse */ class MinhaClasse { // Contrutores devem ser public public function __construct() { } // Declara um método public public function MeuPublico() { } // Declara um método protected protected function MeuProtegido() { } // Declara um método private private function MeuPrivado() { } // Esse é public function Foo() { $this->MeuPublico(); $this->MeuProtegido(); $this->MeuPrivado(); } } $minhaclasse = new MinhaClasse; $minhaclasse->MeuPublico(); // Funciona $minhaclasse->MeuProtegido(); // Erro Fatal $minhaclasse->MeuPrivado(); // Erro Fatal



$minhaclasse->Foo(); // Public, Protected e Private funcionam /** * Define MinhaClasse2 */ class MinhaClasse2 extends MinhaClasse { // Esse é public function Foo2() { $this->MeuPublico(); $this->MeuProtegido(); $this->MeuPrivado(); // Erro Fatal } } $minhaclasse2 = new MinhaClasse2; $minhaclasse2->MeuPublico(); // Funciona $minhaclasse2->Foo2(); // Public e Protected funcionam, Private não class Bar { public function test() { $this->testPrivate(); $this->testPublic(); } public function testPublic() { echo "Bar::testPublic\n"; } private function testPrivate() { echo "Bar::testPrivate\n"; } } class Foo extends Bar { public function testPublic() { echo "Foo::testPublic\n"; } private function testPrivate() { echo "Foo::testPrivate\n"; } } $myFoo = new foo(); $myFoo->test(); // Bar::testPrivate // Foo::testPublic

?>



QUESTÕES DE CONHECIMENTO DO CONTEÚDO HTML 1. O que significa a HTML?

Hyper Text Markup Language

Home Tool Markup Language

Hyperlinks and Text Markup

2. Quem é a responsável pelos padrões da WEB?

Netscape

The World Wide Web Consortium

Microsoft

3. Escolha a tag HTML correta que representa o Título.

<h1>

<head>

<heading>

<h6>

4. Qual é a tag correta para inserir uma quebra de linha?

<lb>

<br>

<break>

5. Qual é a correta HTML para adicionar uma cor de fundo?

<background>yellow</background>

<body color="yellow">

<body bgcolor="yellow">

6. Escolha a correta tag HTML que faz o texto negrito

<bld>

<bold>

<b>

<bb>



7. Escolha a correta tag HTML que faz o texto ítalico

<italics>

<i>

<ii>

8. Qual a correta HTML representa um hyperlink?

<a name="http://www.w3schools.com">W3Schools.com</a>

<a href="http://www.w3schools.com">W3Schools</a>

<a url="http://www.w3schools.com">W3Schools.com</a>

<a>http://www.w3schools.com</a>

9. Como você pode fazer um e-mail link?

<a href="xxx@yyy">

<mail>xxx@yyy</mail>

<mail href="xxx@yyy">

<a href="mailto:xxx@yyy">

10. Como você pode abrir um link in uma nova janela do navegdor?

<a href="url" target="_blank">

<a href="url" new>

<a href="url" target="new">

11. Qual dessas são tags de Tabela?

<table><tr><td>

<table><tr><tt>

<thead><body><tr>

<table><head><tfoot>



12. Escolha a correta HTML para alinha a esquerda o conteúdo dentro da célula de uma tabela

<td valign="left">

<td align="left">

<tdleft>

<td leftalign>

13. Como posso fazer uma lista de itens numéricos?

<dl>

<list>

<ul>

<ol>

14. Como posso fazer uma lista de cujos itens sejam marcadores em forma de pontos ou circulos?

<ul>

<ol>

<dl>

<list>

15. Qual é a correta HTML para fazer uma Caixa de Seleção?

<input type="check">

<check>

<input type="checkbox">

<checkbox>

16. Qual é a correta HTML para fazer um campo de entrada do tipo texto?

<input type="text">

<textfield>

<input type="textfield">

<textinput type="text">



17. Qual é a correta HTML para fazer uma lista do tipo drop-down (similar a Combobox no Delphi)?

<input type="list">

<input type="dropdown">

<select>

<list>

18. Qual é a correta HTML para fazer uma área de texto?

<input type="textarea">

<input type="textbox">

<textarea>

19. Qual é a correta HTML para inserir uma imagem?

<img src="image.gif">

<img>image.gif</img>

<image src="image.gif">

<img href="image.gif>

20. Qual é a correta HTML para inserir uma imagem de fundo?

<img src="background.gif" background>

<body background="background.gif">

<background img="background.gif">

prof° alexandre eugÊnio da silva - eugeniosolucoes.eti.br · curso adonai disciplina linguagem...

Documents