Normalmente uma função em PHP segue essa estrutura:
function minhaFuncao() {
echo "Função Comum em PHP!";
}
Quando nós definimos uma função como esta acima, um nome lhe é atribuído (no caso, minhaFuncao), com isto o PHP então permite que, no código, seja possível se referir a essa função usando seu nome. Por exemplo, para se chamar a função do exemplo acima, fazemos apenas isto:
minhaFuncao();
As funções anônimas são semelhantes a essas funções e também pode ter argumentos e valores de retorno. A pricipal diferença é que funções anônimas não tem nome, como nesse exemplo abaixo:
function($nome, $sobrenome) {
return "Olá $nome $sobrenome!";
};
Existem duas diferenças muito importantes na definição de uma função normal e uma função anônima:
Essa função que criamos é perfeitamente válida, mas não é muito útil. Por não ter um nome, você não a pode referenciar esta função em qualquer outro ponto do código.
No entanto, uma vez que uma função anônima é uma expressão (tal como um número ou uma string), é possível fazer coisas interessantes e/ou úteis, por exemplo:
Quando uma função anônima é definida é possível então armazená-la em uma variável, assim:
$criaCartao = function($nome, $sobrenome) {
return "Olá $nome $sobrenome!";
};
PS: Muitas vezes, funções anônimas são colocadas em uma só linha para facilitar a identificação, assim:
$criaCartao = function($nome, $sobrenome) {return "Olá $nome $sobrenome!";};
Com isto, podemos chamar a função através da variável que lhe foi atribuída, assim:
echo $criaCartao("Juliana", "da Silva");
Podemos também armazenar várias funções dentro de um array, assim:
$sorteio = array(
function() {
echo "Você ganhou um video-game!";
},
function() {
echo "Você ganhou um carro!";
},
function() {
echo "Você ganhou R$1,00!";
}
);
Uma vez que isso tenha sido feito, o código pode decidir qual a função a ser chamada em tempo de execução, assim:
$resultado = rand(0, 2);
$sorteio[$resultado]();
Poddemos também usar as funções anônimas para criar simples função de callback inline.
Callback é uma função que foi criada e, em seguida, passda a outra função como um argumento. Uma vez que se tem aesso à sua função de retorno de chamada, a função receptora pode chamá-la sempre que seja preciso.
Muitas funções nativas do PHP aceitam retornos de chamada e é possível, também, escrever suas próprias funções de aceitação de callbacks.
Veja como é possível usar array_map() com uma função de callback:
// Cria uma função de callback:
$criaCartao = function($nome) {
return "Olá, " . ucfirst($nome) . "!";
};
// E mapeira a função de callback para elementos de um array:
$nomes = array("João", "Mariana", "Guilherme");
print_r(array_map($criaCartao, $nomes));
Embora funcione, é um pouco incômodo criar uma função regular apenas para atuar como uma callback simples. Ao invés disso, é possível criar a callback como uma função anônima:
$nomes = array("João", "Mariana", "Guilherme");
print_r(array_map(function($nome) {
return "Olá, " . ucfirst($nome) . "!";
}, $nomes));
Outro uso comum de callbacks é com a função usort() do PHP. Esta função permite ordenar arrays usando uma função de callback personalizada, por exemplo:
$pessoas = array(
array("Nome" => "João", "Idade" => 42),
array("Nome" => "Mariana", "Idade" => 26),
array("Nome" => "Guilherme", "Idade" => 14)
);
Num próximo exemplo, é preciso classificar o array em ordem de idade crescente. Neste caso não é possível usar funções nativas de ordenação de array, já que estas não sabem nada sobre a chave "idade".
Ao invés disso, é possível chamar usort() e passar em uma função anônima callback a ordenação do array por idade, desse jeito:
usort($pessoas, function($pessoaA, $pessoaB) {
return ($pessoaA["Idade"] < $pessoaB["Idade"]) ? -1 : 1;
});
print_r($pessoas);
Podemos também, ao invés de concatenar usando pontos, colocar as variáveis entre parênteses, por exemplo:
$soma = 50 + 20;
echo "A soma é $soma.";
Mas podemos também colocar as variáveis entre duas chaves, assim:
$soma = 50 + 20;
echo "A soma é {$soma}.";
Essa forma de usar as chaves, no entanto, é mais usadas com arrays e funções, que costumam dar erro ao colocar dentro das aspas da string.
Caso nós tenhamos um site que, por exemplo, o usuário pode escolher a cor de fundo do site, e sempre que ele entra, a cor escolhida por ele aparecerá para ele. Essa e muitas outras funcionalidades são feitas através dos cookies, que são arquivos que são salvos pelo navegador do usuário. Um exemplo clássico de uso de cookies são os cookies de rastreamento, usados em propagandas.
Os cookies ficam gravados no navegador temporariamente, caso o navegador seja limpo ou eles perdam a validade, eles serão excluídos, por isso, apesar de facilitarem (por não precisar chamar por links a todo momento), ele não são muito seguros.
Veja um exemplo prático de uso de cookies, que são criados com a função setcookie():
$variavel = "valor"; // Dado a ser trabalhado.
setcookie("nome", $variavel); // Criação do cookie, com o nome e a variável com os dados.
echo $_COOKIE["nome"]; // Isso exibe o cookie.
Note que a chamada do cookie funciona parecido com os métodos GET/POST, inclusive, sendo recomendado filtrar ele dessa forma:
echo filter_input(INPUT_COOKIE, "nome");
PS: Podemos usar a mesma função que previne SQL Injection nos cookies também.
Vamos fazer um exemplo com criação de cookies, em uma página do site, crie o cookie, dessa forma:
$bg = "red";
setcookie("bg", $bg);
E na página desejada, coloque apenas isso numa supertag PHP, antes do HTML:
$cor = $_COOKIE["bg"];
PS: O recomendado é filtrar e usar um operador ternário, dessa forma:
$cor = filter_input(INPUT_COOKIE, "bg") !== null ? filter_input(INPUT_COOKIE, "bg") : "black";
Para mudar a cor, abrimos no head uma tag style e colocaremos um parâmetro pro body, com a cor sendo mostrada num bloco PHP:
body {
background-color: <?php echo $cor; ?>;
}
Volte à página que criou o cookie e crie um link para ir à página que será mudada, clique nele e a cor mudará.
Experimente mudar o valor da cor (no caso, red), por outros como blue, red, ou valores hexadecimais ou rgb/rgba, igual se faz em CSS normalmente.
O cookie só será alterado (e consequentemente, a página também), quando você passar novamente pela página que o cookie foi criado, senão ela não será alterada.
Além dos valores, podemos também definir o tempo de duração dos mesmos, usando um terceiro parâmetro (time), nesse formato:
$variavel = "valor";
setcookie("nome", $variavel, time() + 3600); // Cookie duraria uma hora.
echo $_COOKIE["nome"];
PS: Note que o time funciona com segundos. Se não for definido nenhum valor, ele valerá até o fim da sessão.
Os cookies também podem ter seu tempo multiplicado diretamente, veja um exemplo pro próprio parâmetro de cor:
$bg = "black";
setcookie("bg", $bg, time() + 3600 * 24 * 7);
Outros parâmetros também podem ser usados (o de pasta e domínio são usados para evitar conflitos com cookies de outros sites):
$variavel = "valor";
setcookie("nome", $variavel, time() + 3600, "pastaDoSite", "dominioDoSite");
echo $_COOKIE["nome"];
PS: Caso queira fazer um cookie com a indicação de pasta e domínio, mas que seja válido até o fim da sessão, passe o valor null no lugar do time(), assim:
setcookie("nome", $variavel, null, "pastaDoSite", "dominioDoSite");
A sessão é um recurso do PHP que permite que você salve valores para serem usados ao logo da visita do usuário, e os valores da sessão podem ser usados em qualquer parte do site.
A sessão também é um cookie, e ela permanece ativa até que o usuário feche o browser ou seja destruída. A sessão é pessoal para cada visitante, quando alguém acessa seu site, é gerado um cookie para o computador dele, informando um ID único de sessão, o PHP usa esse identificador para organizar as sessões entre os visitantes do site.
A sessão sempre é a primeira coisa num bloco PHP, antes de qualquer código PHP ou HTML, para isso usamos session_start().
Um exemplo conhecido de sessão é em áreas restritas do site, onde quem tem acesso é apenas quem usar um usuário e uma senha (por exemplo, administradores).
Veja um exemplo simples de uso de sessões, crie a página entrar.php pra isso:
session_set_cookie_params(3600 * 24 * 365, "pastaDoSite", "dominioDoSite"); // Define o tempo de validade do cookie, podemos colocar num condicional para definir sessões.
session_start();
$login = "pcanal";
$senha = "122";
if($login == "pcanal" && $senha == "123") {
$_SESSION["logado"] = true;
echo "Logado!";
header("location: restrito.php"); // Isso será adicionado após a página restrito.php ser criada.
}
else {
$_SESSION["logado"] = null;
echo "Não Logado!";
}
Com esse exemplo, podemos criar páginas restritas. Como exemplo, criaremos uma nova página coo o nome restrito, apenas com código PHP e um HTML básico para mostrar "página restrita". Veja abaixo:
<?php
session_start();
?>
<?php if($_SESSION["logado"]): ?>
Usuário Logado
<?php else: ?>
Página Restrita, volte e tente novamente.
<?php endif; ?>
PS: Note que esse if e else são diferentes do que a gente viu até então, pois usamos vários blocos PHP e no final usamos o endif. Veja a sintaxe abaixo:
if($condicao):
// Conteúdo do if
elseif($condicao): // Nesse caso é tudo junto
// Conteúdo do else if
else:
// Conteúdo do else
endif;
Mas para funcionar corretamente, precisaremos encerrar sessões, senão o cookie permanecerá e a página "restrito" continuará a mostrar logado.
Continuando a parte anterior da página restrita, precisamos entender esses comandos:
Para isso, apenas adicionaremos um isset() no $_SESSION[] da página restrito, assim:
if(isset($_SESSION["logado"])):
E numa página vazia denominada "sair.php", sem HTML, apenas colocamos isso:
session_start();
unset($_SESSION["logado"]);
setcookie(session_name(), null, 0, "/");
header("location: restrito.php");
Para deslogar, na página restrito, apenas colocamos um link para a página sair, na parte "logada".
PS: O ideal é colocar ambas as páginas de logar e deslogar em arquivos PHP separados, sem HTML.
Primeiro crie um formulário em HTML, dessa forma:
<form method="post" action="formulario.php">
Nome: <input type="text" name="tNome" id="cNome" required/>
<br/>
Telefone: <input type="tel" name="tTel" id="cTel"/>
<br/>
E-Mail: <input type="email" name="tMail" id="cMail" required/>
<br/>
Mensagem: <textarea name="tMsg" id="cMsg"></textarea>
<br/>
<input type="submit" value="Enviar"/>
</form>
Agora criaremos um arquivo PHP vazio, com isso escrito, para vermos se os conteúdos estão sendo enviados:
$nome = $_POST["tNome"];
$fone = $_POST["tTel"];
$mail = $_POST["tMail"];
$msg = $_POST["tMsg"];
echo "$nome <br/>";
echo "$fone <br/>";
echo "$mail <br/>";
echo "$msg <br/>";
Agora vamos entender para que serve o $_REQUEST[], que pode receber tanto em GET como em POST, e também englobar todas as variáveis em uma única. Basta substituir no código acima em todos eles
Vamos nesse mesmo arquivo acima, apagar os dados anteriores e escrevermos isso (não esqueça da filtragem do request):
$para = "contato@teste.com";
$assunto = "Contato pelo Site";
$nome = $_REQUEST["tNome"];
$fone = $_REQUEST["tTel"];
$mail = $_REQUEST["tMail"];
$msg = $_REQUEST["tMsg"];
$corpo = "<b>Mensagem de Contato</b><br/><br/>";
$corpo .= "<b>Nome: </b> $nome<br/>";
$corpo .= "<b>Telefone: </b> $fone<br/>";
$corpo .= "<b>E-Mail: </b> $mail<br/>";
$corpo .= "<b>Mensagem: </b> $msg<br/>";
// O .= fará a atribuição com a concatenação.
$header = "From: $mail Reply-to: $mail";
$header .= "Content-Type: text/html; charset = utf-8";
mail($para, $assunto, $corpo, $header);
header("location: index.php?msg=enviado");
Para entendermos bem, o ponto com igual (.=) faz a atribuição e a concatenação com outros conteúdos numa variáveis (mas não a torna um array).
A função "mail" que enviará ao e-mail especificado as mensagens, no caso a sintaxe seria essa:
mail($endereco, $assunto, $mensagem, $cabecalho);
No caso acima, ele voltará para a página inicial com um parâmetro passado pela URL, nesse caso, colocaremos um código GET nela, antes do HTML, assim:
$msg = isset($_REQUEST["msg"]) ? $_REQUEST["msg"] : "";
E colocaremos antes do formulário isso:
<?php if($msg == "enviado"): ?>
Mensagem Enviada!
<?php else: ?>
(Conteúdo do formulário)
<?php endif; ?>
Mas tem um detalhe, essa mensagem dará erro caso estejamos trabalhando em servidor local (XAMPP, Wamp), só funcionará quando tiver realmente num servidor na web.