You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
<?php// NULL -> não tem valor// Inferência é a capacidade do compilador de saber o tipo do dado sem que este esteja explicitamente declarado// Quando adicionamos um método ou função para ser executado como paramêtro de outra função, // chamamos isso de callback// exemplo = call_user_func()$idade = 20;
$nome = 'alex';
// ver tipo de variável
var_dump($idade, $nome)
// imprime saida no console
print 'abc';
// print_r é uma função que imprime o conteúdo de uma variável de forma detalhada, assim como a var_dump(), mas em um formato mais legível para o programador, com os conteúdos alinhados e suprimindo os tipos de dados.$vetor = array('Alex', 'Fruta', 'Galhardo');
print_r($vetor);
// Constantes// Uma constante é um valor que não sofre modificações durante a execução do programa. // Ela é representada por um identificador, assim como as variáveis, com a exceção de que só pode conter valores escalares (booleano, inteiro, ponto flutuante e string) ou arrays. // As regras de nomenclatura de constantes são as mesmas regras das variáveis, exceto pelo fato de as constantes não serem precedidas pelo sinal de cifrão ($) e geralmente utilizarem nomes em letras maiúsculas.// MAXIMO_CLIENTES // exemplo de constante// Você pode definir uma constante utilizando a função define(). // Quando uma constante é definida, ela não pode mais ser modificada ou anulada. Exemplo:
define('MAXIMO_CLIENTES', 100);
echoMAXIMO_CLIENTES;
Resultado:
100/** * Funções */functionsomarNumero($x, $y){
return$x + $y;
}
somarNumero(4, 5);
/** * principais funções matemáticas */echo abs(-10); // 10 torna o valor absoluto de um númeroecho ceil(5.6); // 6 arredonda para cimaecho floor(2.9999); // 2 arredonda para baixoecho round(2.5); // 3 arredonda para o mais próximoecho round(2.4); // 2 echo rand(3, 9); // número aleatório entre 3 e 9$lista = array('alex', 'galhardo', 'jaum', 'maria');
$sorteado = rand(0, 4);
echo "O sorteado é: " . $lista[$sorteado];
// Manipualação de strings/texto
print_r(explode(',', 'g,a,l,h,a,r,d,o')); // digive uma string em diversos valores em um array ~ o primeiro paramêtro é quando vai ser separado, no caso pela vírgula, e o segundo parametro será a string
print_r(implode(' ', array('Alex', 'Galhardo'))); // é o inverso do explode, ele junta todas as strings do array de acordo com o primeiro parametro, ou seja, vai juntar cada string com 1 espaçoecho number_format(8.2723523763, 2); // formato o número de acordo com as casas decimais definidas no segundo parâmetro// nesse primeiro caso é no padrão americano, priemrio pela virgula, depois pelo pontoecho number_format(8.2723523763, 2, ',', '.');
// no padrão brasileiro, adicionamos mais esses 2 parâmetros// 8.234,567echo str_replace('roeu', 'comeu', 'O rato roeu a roupa'); // troque a primeira palavra, pela palavra do segundo palavra, na string do terceiro parametro ~ o rato comeu a roupaecho strtolower('GALHARDO'); // clássico, tudo minusculo ~ galhardoecho strtoupper('alex'); // clássico, tudo UPPERCASE ~ ALEXecho substr('Galhardo', 0, 3); // corte a string, começe pelo indice 0, ande 3 indices ~ galecho ucfirst('galhardo'); // clássico para nomes em formulários, transforma primeira letra em UPPERCASE ~ Galhardoecho ucwords('alex galhardo vieira'); // transforma em PascalCase toda a string ~ Alex Galhardo Vieira/** * Manipulação de Arrays */$array = array(
'nome'=>'alex',
'idade' => 21,
'sexo' => 'm',
'cidade' => 'magrathea'
);
echo array_keys($array); // uma das principais funções de array, ela devolve um array com os indices e as chaves respectivas deste arrayecho array_values($array); // mesma lógica do anterior, porém retorna todos os valores do array de acordo com o seu indiceecho array_pop($array); // remove o último registro do array, ou seja, o último indiceecho array_shift($array) ; // mesma ĺógica que o pop, porém remove o primeiro indice do array [0]echo asort($array); // ordena os VALORES do array em ordem alfabeticaecho asort($array);// mesma lógica que o asort, porém ordena os valors em ordem decrescente do alfabeticoecho count($array); // retorna o total de registros(indices) do arrayecho in_array('alex', $array); // muito usado em condicionais, ou seja, existe o valor 'alex' no $array? se tiver, ele torna TRUE/** * Valores Numericos */
floatval($valor); // transforma o valor no tipo float
intval($valor); // transforma o valor no tipo inteiro// Superglobais // são variáveis disponibilizadas pelo próprio PHP em qualquer local em que você esteja executando, seja no programa principal, dentro de uma função, ou por um método específico. Elas possivelmente carregam alguns conteúdos, dependendo de como o script foi invocado, como nos exemplos a seguir:// • $_SERVER – Contém informações sobre o ambiente em que o script está rodando, como endereço do servidor, da requisição, nome do script acessado, entre outros. Por exemplo, na posição HTTP_USER_AGENT, há informações sobre o browser do request; na posição SCRIPT_FILENAME, há o caminho do script sendo executado no servidor.// • $_GET – Contém um vetor com as variáveis informadas em uma requisição $_GET. Por exemplo, a requisição http://localhost/sample.php?name=john&age20 retorna um vetor com as posições john e age, contendo os respectivos valores.// • $_POST – Funciona da mesma maneira que $_GET, mas contém as informações enviadas pelo método POST, geralmente usado no envio de formulários.// • $_FILES – Contém um vetor com informações dos arquivos enviados para upload. Esta pode ser acessada logo após o upload de um arquivo por upload via formulário.// • $_COOKIE – Contém um vetor com as informações recebidas pelo script que atualmente estão armazenadas nos cookies.// • $_SESSION – Contém um vetor com as variáveis da sessão do usuário.// • $_REQUEST – Contém um vetor com as informações de $_GET, $_POST, e $_COOKIE.// • $_ENV – Contém um vetor com variáveis de ambiente. Possivelmente útil ao executarmos um script PHP pela linha de comando, pois contém informações sobre o usuário do sistema operacional (USER), diretório home do usuário (HOME), entre outros dados.// • $GLOBALS – Contém uma lista com todas as variáveis globais disponíveis para o script./** * Tipagem Estrita * deve ser usado onde a função for chamada, e não definada! */declare(strict_types=1);
functioncalcula_imc(float$peso, float$altura):float {
var_dump($peso, $altura);
return$peso / ($altura*$altura);
}
var_dump(calcula_imc(75, 1.85));
var_dump(calcula_imc('75.1', 2));
/** * utf8_encode * * formata o texto com charset utf8 */
utf8_encode('string_aqui');
/** * in_array() * * verifica se determinada string está presenta na string */
in_array('ana', 'banana'); // true/** * https://www.wikiwand.com/pt/Crontab */
curl "http://galhardoo.com/agenda.php"/** * file_exists() * * verifica se certo arquivo existe em determinado local */
file_exists('./classes/Usuarios.class.php');
/** * explode() * * separa em um array, uma string onde bate com o caracter */
explode('.', 'alex.galhardo'); // -> ['alex', 'galhardo']/** * count() * * conta o número de elementos */
count(array('alex', 'galhardo', 'vieira')) // 3
// Uma função é um pedaço de código com um objetivo específico, encapsulado sob uma estrutura única que recebe um conjunto de parâmetros e retorna um dado. // Uma função é declarada uma única vez, mas pode ser utilizada diversas vezes.// É uma das estruturas mais básicas para prover reusabilidade.// Para declarar uma função em PHP, usa-se o operador function seguido do nome que desejamos definir, sem espaços em branco e iniciando obrigatoriamente com uma letra. // Na mesma linha, digitamos a lista de argumentos (parâmetros) que a função irá receber, separados por vírgula. // Em seguida, encapsulado por chaves {}, vem o código da função. // No final, utiliza-se a cláusula return para retornar o resultado da função (integer, string, array, objeto etc.)functionnome_da_funcao ($arg1, $arg2, $argN) {
$valor = $arg1 + $arg2 + $argN;
return$valor;
}
// No exemplo a seguir, criamos uma função que calcula o índice de massa corporal. // Essa função recebe dois parâmetros ($peso e $altura) e retorna o valor definido pela fórmula.functioncalcula_imc($peso, $altura) {
return$peso / ($altura * $altura);
}
echo calcula_imc(75, 1.85);
Resultado:
21.913805697589// Variáveis globais// Todas as variáveis declaradas dentro do escopo de uma função são locais. // Para acessar uma variável externa ao contexto de uma função sem passá-la como parâmetro, é necessário declará-la como global. Uma variável global é acessada a partir de qualquer ponto da aplicação. // No exemplo a seguir, a função criada converte quilômetros para milhas, enquanto acumula a quantidade de quilômetros percorridos em uma variável global ($total).$total = 0;
functionkm2mi($quilometros) {
global$total;
$total += $quilometros;
return$quilometros * 0.6;
}
echo'percorreu ' . km2mi(100) . " milhas <br>\n";
echo'percorreu ' . km2mi(200) . " milhas <br>\n";
echo'percorreu no total ' . $total . " quilometros <br>\n";
// Resultado:
percorreu 60 milhas
percorreu 120 milhas
percorreu no total 300 quilometros
// Observação: a utilização de variáveis globais não é considerada uma boa prática de programação, pois uma variável global pode ser alterada a partir de qualquer parte da aplicação. // Dessa maneira, valores inconsistentes podem ser armazenados em uma variável global, podendo resultar em um comportamento inesperado da aplicação.// Variáveis estáticas// Dentro do escopo de uma função, podemos armazenar variáveis de forma estática. Assim, elas mantêm o valor que lhes foi atribuído na última execução. Declaramos uma variável estática com o operador static.functionpercorre($quilometros) {
static$total;
$total += $quilometros;
echo "percorreu mais $quilometros do total de $total<br>\n";
}
percorre(100);
percorre(200);
percorre(50);
// Resultado:
percorreu mais 100do total de 100
percorreu mais 200do total de 300
percorreu mais 50do total de 350// Passagem de parâmetros// Há dois tipos de passagem de parâmetros: por valor (by value) e por referência (by reference). // Por padrão, os valores são passados by value para as funções.// Assim o parâmetro que a função recebe é tratado como variável local dentro do contexto da função, não alterando o seu valor externo.// Os objetos são uma exceção, pois são tratados por referência na passagem de parâmetros.function incrementa($variavel, $valor) {
$variavel += $valor;
}
$a = 10;
incrementa($a, 20);
echo$a;
// Resultado:10// Para efetuar a passagem de parâmetros by reference para as funções, basta utilizar o operador & na frente do
parâmetro;
// isso faz com que as transformações feitas pela função sobre a variável sejam válidas no contexto externo à função.functionincrementa(&$variavel, $valor) {
$variavel += $valor;
}
$a = 10;
incrementa($a, 20);
echo$a;
// Resultado:30// O PHP permite definir valores default para parâmetros. // Reescreveremos a função anterior, declarando o default de $valor como 40. // Assim, se o programador executar a função sem especificar o parâmetro, será assumido o valor 40.functionincrementa(&$variavel, $valor = 40) {
$variavel += $valor;
}
$a = 10;
incrementa($a);
echo$a;
// O PHP também permite definir uma função com o número de argumentos variáveis, ou seja, permite obtê-los de forma dinâmica, mesmo sem saber quais são ou quantos são. // Para saber quais são, utilizamos a função func_get_args(); para saber a quantidade de argumentos, utilizamos a função func_num_args().functionola() {
$argumentos = func_get_args();
$quantidade = func_num_args();
for($n=0; $n<$quantidade; $n++) {
echo'Olá ' . $argumentos[$n] . ', ';
}
}
ola('João', 'Maria', 'José', 'Pedro');
// Resultado:OláJoão, OláMaria, OláJosé, OláPedro,
// Recursão// O PHP permite chamadas de funções recursivamente. // No caso a seguir, criaremos uma função para calcular o fatorial de um número.functionfatorial($numero) {
if ($numero == 1)
return$numero;
elsereturn$numero * fatorial($numero -1);
}
echo fatorial(5) . "<br>\n";
echo fatorial(7) . "<br>\n";
// Resultado:120// Funções anônimas// Funções anônimas, ou lambda functions, são funções que podem ser definidas em qualquer instante e, diferentemente das funções tradicionais, não têm um nome definido. Funções anônimas podem ficar atreladas à uma variável. // Nesse caso, a variável é usada para fazer a chamada imediata da função, bem como passá-la como parâmetro de alguma função. Caso a variável não esteja visível no escopo, a função fica fora de alcance. // Uma função anônima pode ser vista como uma função descartável, que se aplica ao contexto no qual é criada.// Observação: no PHP, funções anônimas são instâncias de uma classe interna chamada Closure.// Funções anônimas são úteis para várias coisas, como passagem de parâmetros e uso como callback de funções. // Para iniciar a explicação de funções anônimas, vamos criar uma função anônima que remova o acento de alguns caracteres e atribuir essa função à variável $remove_acento. Veja que a função não tem nome.// A única referência para esse código criado é a variável para a qual a função foi atribuída.// A partir da atribuição, a função pode ser atribuída e passada como parâmetro para funções e métodos de objetos. // Sempre que quisermos utilizar a função anônima, basta usar a variável na qual ela está definida, como estamos fazendo neste exemplo ao remover os acentos de “José da Conceição”. // Por fim, estamos definindo um vetor com vários termos acentuados e chamando a função array_map(), que recebe em seu primeiro parâmetro uma função a ser aplicada (Callback) e como segundo parâmetro um vetor a ser percorrido.// Neste caso, estamos aplicando a função $remove_acento ao vetor e exibindo seu resultado.$remove_acento = function($str) {
$a = array('À', 'Á', 'Â', 'Ã', 'Ä', 'Ç', 'È', 'É', 'Ê',
'Ì', 'Í', 'Ò', 'Ó', 'Ô', 'Õ', 'Ù', 'Ú', 'à',
'á', 'â', 'ã', 'ç', 'è', 'é', 'ê', 'í', 'î',
'ò', 'ó', 'ô', 'õ', 'ù', 'ú', 'û', 'ü');
$b = array('A', 'A', 'A', 'A', 'A', 'C', 'E', 'E', 'E',
'I', 'I', 'O', 'O', 'O', 'O', 'U', 'U', 'a',
'a', 'a', 'a', 'c', 'e', 'e', 'e', 'i', 'i',
'o', 'o', 'o', 'o', 'u', 'u', 'u', 'u');
return str_replace($a, $b, $str);
};
print $remove_acento('José da Conceição');
print '<br>' . PHP_EOL;
$palavras = array();
$palavras[] = 'José da Conceição';
$palavras[] = 'Jéferson Araújo';
$palavras[] = 'Félix Júnior';
$palavras[] = 'Ênio Müller';
$palavras[] = 'Ângelo Ônix';
// array array_map ( callback $callback , array $arr1 [, array $... ] )$r = array_map( $remove_acento, $palavras );
print_r($r);
// Resultado:Jose da ConceicaoArray (
[0] => Jose da Conceicao
[1] => JefersonAraujo
[2] => FelixJunior
[3] => EnioMuller
[4] => AngeloOnix
)
?>
PHP Data Object
index.php
<?php
require 'usuarios.php';
$u = new Usuarios();
$res = $u->selecionar(1);
$atualizado = $u->atualizar("Galhardo", "galhardo@gmail.com", "123456", 4);
$u->deletar(3);
$u->deletar(2);
print_r($res); // retorna um array com os dados da linha selecionada do banco
usuarios.php
classUsuarios {
private$db;
publicfunction__construct(){
try {
$this->db = newPDO("mysql:dbname=mp_pdo_statement;host=localhost", "root", "");
} catch(PDOException$e){
echo "ERRO: " . $e->getMessage();
}
}
publicfunctionselecionar($id){
// padrão// $sql = "SELECT * FROM usuarios WHERE id = '$id';"// novo comando usando PDO// muito mais seguro, pq ele verifica erros de segurança// como SQL Injection por exemplo$sql = $this->db->prepare("SELECT * FROM usuarios WHERE id = :id");
/** * no bindValue é como se ele passase a variável por valor * ou seja, uma cópia */$sql->bindValue(":id", $id);
$sql->execute();
$array = array();
if($sql->rowCount() > 0){
$array = $sql->fetch(); // só retorna os dados daquele item especifico
}
return$array;
}
publicfunctioninserir($nome, $email, $senha){
$sql = $this->db->prepare("INSERT INTO usuarios SET nome = :nome, email = :email, senha = :senha");
/** * No bindParam, ele vai associar/REFERENCIAR o apelido * diretamente com a variável * * é como se fosse um ponteiro em C */$sql->bindParam(":nome", $nome);
$sql->bindParam(":email", $email);
$sql->bindValue(":senha", MD5($senha));
// se eu mudar o $nome = 'outroNome' por exemplo// o bindParam garante que ele vai executar com o valor pela referência// lógico, antes de executar o ->execute();$sql->execute();
}
publicfunctionatualizar($nome, $email, $senha, $id){
$sql = $this->db->prepare("UPDATE usuarios SET nome = ?, email = ?, senha = ? WHERE id = ?");
$sql->execute(array(
$nome, $email, md5($senha), $id
));
}
publicfunctiondeletar($id){
$sql = $this->db->prepare("DELETE FROM usuarios WHERE id = ?");
$sql->bindValue(1, $id);
$sql->execute();
}
}
