Aprenda PHP

Tudo sobre PHP Parte 5

Rotinas em PHP - Parte 1

Assim como no Javascript, também existem as funções em PHP, as rotinas são tratadas como funções ou procedimentos, indicadas pela palavra function. Veja um exemplo:


function soma($a, $b) {
    $s = $a + $b;
    echo "<p>A soma vale $s.</p>";
}
soma(3, 4); // Essa é a chamada da função.

E também dá pra mudar as variáveis, dessa forma:


function soma($a, $b) {
    $s = $a + $b;
    echo "<p>A soma vale $s.</p>";
}
$x = 9;
$y = 12;
soma($x, $y);

Como também dá pra inicializar os parâmetros com valores padrão, dessa forma:


function soma($a = 0, $b = 0) {
    $s = $a + $b;
    echo "<p>A soma vale $s.</p>";
}

soma(10, 15);
soma(20);
soma();

Também podemos usar o return para retornar um valor (os códigos acima não retornam valores), como esse:


function soma($a, $b) {
    return $a + $b;
}
$x = 3;
$y = 4;
$r = soma($x, $y);
echo "A soma entre $x e $y é igual a $r.";

Dentro das funções, podemos usar func_get_args() (que pega os argumentos e coloca dentro de um vetor, para criar novas variáveis). E func_num_args() Retorna o número de argumentos que foram passados.


function soma() {
    $p = func_get_args();
    $t = func_num_args();
    $s = 0;
    for($i = 0; $i < $t; $i++) {
        $s += $p[$i];
    }
    return $s;
}
$r = soma(3, 5, 2);
echo "A soma dos valores é $r";

Também podemos adicionar mais valores na função, por exemplo:


$r = soma(3, 5, 2, 4, 8, 9);

PS: Vetores são variáveis compostas, e o índice começa do 0, e não do 1. Inclusive nos parâmetros também podemos passar arrays, simplesmente passando a variável, algo tipo funcao($parametrovetor).

Rotinas em PHP - Parte 2

Continuando o assunto de rotinas, vamos ver mais um exemplo:


function teste($x) {
    $x += 2;
    echo "O valor de X é $x.<br/>";
}
$a = 3;
teste($a); // Exibe a soma com a variável.
echo "O valor de A é $a."; // Exibe o valor da variável sem alterar;

Mas nesse caso, usaremos uma variável referenciada, assim:


function teste(&$x) {
    $x += 2;
    echo "O valor de X é $x.<br/>";
}
$a = 3;
teste($a); // Exibe a soma com a variável.
echo "O valor de A é $a."; // Também exibe a soma, qualquer alteração em X altera A.

Usar uma função em PHP de outro arquivo PHP também é possível, usando o comando include.

PHP separado:


function ola() {
    echo "Olá Mundo!";
}

Nas páginas à receberem as importações:


include "funcoes.php";
ola();

Outro exemplo:

Página PHP separada:


function mostraValor($v) {
    echo "Acabei de receber o valor $v";
}

Nas que recebem as importações:


include "funcoes.php";
mostraValor(4);

Na teoria, o include pode ser uma extensão do código PHP, independente do conteúdo do mesmo.

Temos também o comando require (requerido), que também incluí, mas esse código é requerido, caso o arquivo à ser incluído não exista, o código para no ponto dele. O include tentaria continuar os outros códigos existentes.

Temos também as variações de ambos, que include_once e require_once, que é pra não incluir o arquivo mais de uma vez. Por exemplo:


include "funcoes.php"; // Carrega o script.
include_once "funcoes.php"; // Só carrega caso não tenha carregado.

Rotinas em PHP - Parte 3

A partir da versão 7, podemos especificar os tipos das variáveis e do retorno de funções, por exemplo:


function exibirMensagem(string $msg): void { // Parâmetro só pode ser string, void não retorna nada
    printf("%s<br/>", $msg);
}

function soma(int $n1, int $n2): int { // Tanto os parâmetros quanto o retorno são int
    return $n1 + $n2;
}

exibirMensagem("Olá!"); // Só pode passar string

$s = soma(5, 10); // Só pode passar inteiros

echo "$s<br/>";

Apesar do PHP ser uma linguagem fracamente e dinamicamente tipada, é possível definir tipos, principalmente por isso permitir tratamento de erros na linguagem.

Verificando Erros com Try Catch Finally

O try catch finally são utilizados para tratar erros. No bloco try nós inserirmos a rotina que queremos tratar o provável erro que acontecer. Quando ele acontece o erro no try, para a execução do bloco imediatamente, passa pro catch e passa essa exceção gerada pra ele, onde o erro será tratado propriamente dito, onde podemos interceptar a exceção e realizar o tratamento mais adequado ao programa. O finally sempre será executado, ele não é obrigatório.

Esse é a estrutura básica de um try catch:


try {
    echo "Mensagem de Teste!"; // É executado
}
catch(Exception $ex) {
    echo "ERRO!"; // Não é executado
}

No código acima, apenas o que está no try será executado, já que o código dentro dele está certo, o que está no catch não será executado (o parâmetro dentro dos parênteses do catch pode ter qualquer nome).

Nesse erro proposital, provocará a exceção de erro:


try {
    $palavra = isset($_GET["text"]) ? $_GET["text"] : "";

    if($palavra == "") {
        throw new Exception("Não foi Inserido nada no parâmetro!");
    }

    echo "A palavra passada foi $palavra."; // Daqui pra baixo não será executado, já que criou uma exceção de erro.
}
catch(Exception $ex) {
    echo $ex->getMessage(); // Será executado
}
finally {
    echo "<br/>Final do Programa!";
}

No caso acima, o que fez criar a exceção, foi o método throw new Exception(), pode ver que ele nem terminou de executar o código e já pulou pro catch. No finally, ele exibirá a mensagem independente se o erro ocorrer ou não.

PS: Alguns erros o PHP já trata sem precisar dessa estrutura, como por exemplo, ao tentar fazer uma divisão por 0, que retornará um aviso e o valor INF. No caso acima, fizemos um tratamento diferente pra essa exceção.

Vamos gerar um erro manualmente, numa verificação de números, onde a exceção é disparada ao receber um valor não-numérico:


try {
    $num = isset($_GET["n"]) ? $_GET["n"] : 0;
    
    if(!is_numeric($num)) {
        throw new Exception("Não foi inserido um número válido!");
    }
    
    echo "O número inserido foi: $num.";
}
catch(Exception $ex) {
    echo $ex->getMessage();
}

PS: Podemos usar tanto new Exception quanto new Error. Existem outros para dados mais específicos, como o PDOException, usado em ligação com banco de dados PDO.

Veja um exemplo de tratamento de erro de outro tipo:


function metade(int $n): int { // Aqui dizemos o tipo do parâmetro e o retorno
    return intval($n / 2);
}

try {
    $res = metade("Texto");

    echo "O resultado da divisão é $res!<br/>";
}
catch(TypeError $ex) {
    echo "Não foi passado um valor numérico!<br/>";
}

Veja uma criação de várias exceções no mesmo bloco:


function dividir($num1, $num2) {
    if(!is_numeric($num1)) {
        throw new InvalidArgumentException("O dividendo não é um número!<br/>");
    }

    // Outra condição:

    if(!is_numeric($num2)) {
        throw new InvalidArgumentException("O divisor não é um número!<br/>");
    }

    // Outra condição:

    if($num2 == 0) {
        throw new DivisionByZeroError("Não é possível realizar uma divisão por zero!<br/>");
    }

    $resultado = $num1 / $num2;

    return $resultado;
}

try {
    $resultado = dividir(6, 0);
    
    echo "O resultado da divisão é $resultado.";
}
catch(InvalidArgumentException $ex) {
    echo $ex->getMessage();
}
catch(DivisionByZeroError $ex) {
    echo $ex->getMessage();
}
catch(Exception $ex) {
    echo $ex->getMessage();
}

Funções String em PHP - Parte 1

Nós já vimos anteriormente que no PHP temos funções para manipular números (como abs(), pow(), sqrt(), entre outras), no PHP também podemos manipular strings. Veremos como fazer logo abaixo.

A primeira que veremos é o printf(), para imprimir formatado, usando máscaras (uma das heranças do C).


$prod = "leite";
$preco = 4.50;
printf("O %s está custando R\$%.2f", $prod, $preco);

No caso acima, o %s mostra uma string, e o %f pra formatar um número decimal.

Essas são algumas das máscaras aceitas em PHP:

Máscara	Significado
%d	Valor decimal (positivo ou negativo)
%u	Valor decimal sem sinal (só positivo)
%f	Valor real
%s	String

Existem vários outros, mas esses são mais usados.

A função print_r serve para mostrar detalhes de uma variável, principalmente se ela for um vetor (array), mais usada em testes. Veja no exemplo com vetores:


$x[0] = 4;
$x[1] = 3;
$x[2] = 8;
print_r($x);

Outro exemplo:


$x2 = array(3, 7, 6, 2, 1, 9);
print_r($x2);

PS: O símbolo => exibido na saída significa associação.

Podemos também substituir o print_r por var_dump() e var_export(). Cada uma formata de um jeito diferente.

A função wordwrap() cria quebra de linhas nos códigos. Veja um exemplo:


$txt = "Esse é um exemplo de string gigante que está aqui para exemplificar o uso da função wordwrap().";
$res = wordwrap($txt, 8);
print($res);

O código acima quebra a linha no HTML, mas ela não é visível na página, o número significa a quantidade máxima de caracteres por linha.

Para que a string seja visualizada também na página, faça dessa forma:


$txt = "Esse é um exemplo de string gigante que está aqui para exemplificar o uso da função wordwrap().";
$res = wordwrap($txt, 8, "<br/>\n", false);
print($res);

No caso acima, a tag <br/> quebra a linha na página e a sequência \n quebra a linha no código-fonte. O false é para evitar a quebra de linha em palavras inteiras com mais de oito letras (o true as quebrariam).

A função strlen() calcula o comprimento de uma string em caracteres. Por exemplo:


$txt = "Curso em Vídeo";
$tam = strlen($txt);
print($tam);

PS: Caso tenha erros com a função strlen em palavras acentuadas, utilize a função mb_strlen() com o UTF-8, assim:


$txt = "Curso em Vídeo";
$tam = mb_strlen($txt, "utf-8");
print($tam);

A função trim() é muito usada em dados vindos de formulários, para o caso de digitarem espaços desnecessários no início ou fim dos mesmos, o strlen() conta os caracteres da string incluindo espaços. Veja um exemplo:


$nome = "  José da Silva  ";
print("Comprimento da String com espaços:<br/>");
print(strlen($nome));
print("<br/>");
$novo = trim($nome);
print($novo);
print "<br/>Comprimento da String sem espaços:<br/>";
print(strlen($novo));

Temos também variações do trim, a ltrim() só elimina os espaços do início. A rtrim() faz o mesmo, mas só elimina os do final.

A str_word_count() mostra quantas palavras tem numa string. Veja um exemplo:


$frase = "Eu vou estudar PHP";
$cont = str_word_count($frase, 0);
print($cont);

PS: O 0 no código acima é pra fazer a contagem, se mudar o número vai criar um array (1 e 2), mas usando o print_r, dessa forma:.


$frase = "Eu vou estudar PHP";
$cont = str_word_count($frase, 1);
print_r($cont);

A função explode() funciona de maneira bem simples, baseada na str_word_count(), o explode() procura pelos espaços (ou outro caractere) e mostrará quais strings serão "explodidas" (ou seja, quebradas) e jogadas num vetor. Exemplo:


$site = "Curso em Vídeo";
$vetor = explode(" ", $site);
print_r($vetor);

O str_split é bem parecido com o explode(), só que esse faz com cada letra. Veja um exemplo:


$nome = "Maria";
$vetor = str_split($nome);
print_r($vetor);

A função implode() é basicamente o inverso do explode(), ele pega elemento de um array e coloca em apenas uma string (pode ser substituída também pela join()), dessa forma:


$vetor[0] = "Curso";
$vetor[1] = "em";
$vetor[2] = "Vídeo";
$texto = implode(" ", $vetor);
print($texto);

A função chr() recebe um número de um código que representa um caractere do teclado. Veja num exemplo, que mostrará o "C":


$letra = chr(67);
echo "A letra de código 67 é $letra";

A função ord() é basicamente o contrário do chr(). Veja um exemplo:


$letra = "C";
$cod = ord($letra);
echo "A letra $letra tem código $cod";