Sessões

Quando desenvolvemos aplicações para web uma

funcionalidade imprescindível a qual praticamente sempre
temos que desenvolver é a autenticação de usuário, onde
essa autenticação garante que cada usuário de nosso sistema
só acesse aquilo que lhe é permitido e nada mais, também
possibilitando que possamos saber tudo o que foi feito pelo
usuário logado dentro de nosso sistema.

Assim como também ajudando a garantir uns dos requisitos

mais essenciais para qualquer sistema computacional, que é
a segurança dele, de tal forma que não possibilite que
usuários sem autorização acessem o mesmo, o que poderia
comprometer os dados do sistema e vir a causar prejuízos
graves tanto para o cliente quanto para a empresa que criou
o sistema.

Então para que possamos implementar funcionalidades tais

como essa citada anteriormente, o PHP nos fornece o
recurso de sessão que permite que nós possamos gravar
determinados dados em uma página e recupera-los em outra
página de forma segura e sem perda de dados. Utilizando
um id único de identificação da sessão que é criado quando a
sessão é iniciada, assim esse id é propagado entre as
requisições do sistema, que pode ser por URL ou Cookies do
navegador, garantido que os dados da sessão possam ser
recuperado.

Iniciando uma sessão

Para que possamos começar a usar sessões em nossa
aplicação, primeiramente é imprescindível que façamos sua
inicialização. Para fazermos isso precisamos usar a
função session_start(), que irá iniciar uma nova sessão,
onde essa sessão terá um id único que é gerado junto com a
inicialização da sessão. Para ilustrar sua utilização vejamos o
seguinte exemplo:

<?php
session_start();//Uma nova sessão de usuário é iniciada.

No momento em que vamos iniciar uma sessão no PHP

sempre temos que levar em consideração alguns cuidados.
Como ter certeza que uma outra sessão não já tenha sido
aberta no mesmo script anteriormente ou em outros scripts
que foram incluídos no atual. Podemos verificar se uma
sessão não já está aberta da seguinte forma:

<?php
if (!isset($_SESSION)) {//Verificar se a sessão não já está
aberta.
session_start();
}

A partir da versão 5.4 o PHP fornece a seguinte

função session_status(), a qual possibilita que nós
possamos fazer essa verificação de forma mais consistente e
segura, pois simplesmente poderíamos criar a
variável $_SESSION, assim a condição do exemplo
anterior !isset($_SESSION)retornaria false, de forma a
não iniciar a sessão, certamente causando erros na
continuação do script. Essa função nos retorna três valores
possíveis como podemos ver na imagem a seguir:
Valores retornados para função session_status.

Agora que já sabemos como essa função basicamente

funciona, vamos ver a seguir um exemplo com sua
utilização:

<?php
if (session_status() !== PHP_SESSION_ACTIVE) {//Verificar se a sessão
não já está aberta.
session_start();
}

Outro ponto muito importante que devemos levar em

consideração ao iniciar uma sessão, é garantir que nenhuma
saída seja feita ao browser antes da chamada da
função session_start(), pois caso isso ocorra um erro será
retornado na execução do script. Como por exemplo:

<?php
echo 'Uma saída de texto qualquer.';
session_start();

Ao executar esse script um erro será retornado e a sessão de

usuário não será aberta, assim comprometendo a execução
correta do script.

Gravando valores na sessão

Agora que nossa sessão já se encontra aberta, nos podemos
gravar valores nela, de tal forma a poder recuperar-los
futuramente em outras páginas da aplicação web. Assim
vamos ver como é fácil gravar um valor dentro de nossa
sessão a partir da super global $_SESSION, que nada mais
é do que um Array de dados. Vejamos a seguir um exemplo
de como podemos fazer isso:
<?php
//Iniciando a sessão:
if (session_status() !== PHP_SESSION_ACTIVE) {
session_start();
}
//Gravando valores dentro da sessão aberta:
$_SESSION['nome_usuario'] = 'Yure Pereira';
$_SESSION['nome_login'] = 'yure_pereira';

Recuperando valores na sessão

Posteriormente a gravação de valores a uma sessão,
facilmente podemos recuperar esses valores gravados. Para
isso simplesmente acessando os valores dentro da super
global $_SESSION de forma como fazemos quando
usamos Arrays, pois como já foi mencionado antes uma
sessão no PHP é manipulada como um Array. Agora
vejamos um exemplo prático de como podemos acessar
valores em uma sessão:

<?php
//Iniciando a sessão:
if (session_status() !== PHP_SESSION_ACTIVE) {
session_start();
}
//Acessando valores dentro de uma sessão:
echo $_SESSION['nome_usuario'];
echo $_SESSION['nome_login'];

Como podemos ver no exemplo anterior, acessar valores

definidos dentro de uma sessão é algo bem simples de se
fazer, porém ao fazemos isso temos que ter certeza que a
sessão em nossa requisição atual esteja aberta. Pois caso não
esteja um erro será emitido, isso porque para o PHP
estaremos tentando acessar uma variável indefinida.

Deletando valores na sessão

Agora que já sabemos como criar e acessar valores dentro de
uma sessão, vamos ver como podemos deleta-los. Para isso
iremos usar a função unset do PHP que nos permiti deletar
variáveis. Sendo assim vamos ver como podemos deletar
variáveis dentro da super global $_SESSION utilizando
essa função:

<?php
//Iniciando a sessão:
if (session_status() !== PHP_SESSION_ACTIVE) {
session_start();
}
//Deletando uma sessão:
unset($_SESSION['nome_usuario']);

Limpando todos os dados de uma sessão

Em determinadas ocasiões pode vir a ocorrer à situação
onde precisaremos apagar todos os dados que estiverem
gravados em uma sessão, então para que possamos fazer
isso o PHP nos fornece a função session_unset(), que irá
apagar todos os dados da sessão atual, porém é muito
importante ressaltar que posteriormente a utilização dessa
função a sessão ainda estará ativa, assim podendo gravar
outros dados nela. A seguir podemos ver um exemplo de sua
utilização:

<?php
//Iniciando a sessão:
if (session_status() !== PHP_SESSION_ACTIVE) {
session_start();
}
//Apagando todos os dados de uma sessão:
session_unset();

Destruindo uma sessão

Da mesma forma em que em determinadas ocasiões pode
ocorrer de precisamos apagar todos os dados de uma sessão,
também pode ocorrer de precisamos destruir uma sessão, e
para isso podemos usar a função session_destroy(),
porém é bom ressaltar que essa função não irá limpar os
dados da super global $_SESSION da requisição atual. Ou
seja, após a utilização dessa função os dados que estavam na
super global $_SESSIONainda estarão acessíveis, contudo,
isso somente na requisição atual, assim quando for realizada
outra requisição ao servidor os dados não existiram mais.
Agora vejamos um exemplo para entender melhor seu uso:

<?php
//Iniciando a sessão:
if (session_status() !== PHP_SESSION_ACTIVE) {
session_start();
}
//Definindo valores na sessão:
$_SESSION['nome_usuario'] = 'Yure Pereira';
$_SESSION['nome_login'] = 'yure_pereira';
//Destruindo a sessão:
session_destroy();
//Mostrando os dados da sessão destruida:
print_r($_SESSION);

Após a execução desse script poderemos ver que a sessão

será destruída, contudo, na super global $_SESSION ainda
estará contido as duas variáveis as quais foram definidas na
sessão. O resultado do script será o seguinte:

Array
(
[nome_usuario] => Yure Pereira
[nome_login] => yure_pereira
)

Então quando formos destruir uma sessão é uma boa prático

que façamos uma limpeza nela antes de destruí-la, isso
utilizando a função session_unset(), como podemos ver
no seguinte exemplo:

<?php
//Iniciando a sessão:
if (session_status() !== PHP_SESSION_ACTIVE) {
 session_start();
}
//Definindo valores na sessão:
$_SESSION['nome_usuario'] = 'Yure Pereira';
$_SESSION['nome_login'] = 'yure_pereira';
//Apagando todos os dados da sessão:
session_unset();
//Destruindo a sessão:
session_destroy();
//Mostrando os dados da sessão destruida:
print_r($_SESSION);

É bom ressaltar que devemos usar a

função session_unset() sempre anteriormente a
utilização da função session_destroy(), pois se fizemos o
contrário a função session_unset() não resultará em
nenhum efeito, isso porque não terá nenhuma sessão aberta,
assim não terá o que a função session_unset() apagar.

Definindo o tempo de vida de uma sessão

Quando manipulamos sessão em certas ocasiões precisamos
definir um tempo de vida para que ela expire, isso, por
exemplo, quando implementamos autenticação de usuário,
onde em certo tempo de inatividade do sistema, o mesmo
deverá fazer logout (sair) da autenticação automaticamente.

Então para que possamos definir um tempo de vida para

nossa sessão o PHP nos fornece a
função session_cache_expire(), que podemos usar de
duas formas, a primeira é quando à chamamos sem passar
nenhum parâmetro, assim ela nos retornará o prazo de
cache (tempo de vida) atual que está definido nela, que
normalmente por padrão é 180 minutos.

Onde também podemos alterar esse valor padrão por um

valor a nossa escolha modificando o arquivo php.ini,
alterando a variável session.cache_expire para o valor a
qual nós queremos.
A segunda forma que podemos usar essa função é passando
um valor a ela por parâmetro, a qual esse valor deverá ser
um valor numérico inteiro, onde ele será usado para definir
o novo prazo para a cache da sessão expirar. Porém ao
usamos essa função, devemos usa-la antes da chamada da
função session_start(), pois, caso isso não ocorra o prazo
da nova sessão iniciada será o valor a qual estava definido
nela anteriormente. Agora vejamos um exemplo de sua
utilização:

<?php
//Iniciando a sessão:
if (session_status() !== PHP_SESSION_ACTIVE) {
//Definindo o prazo para a cache expirar em 60 minutos.
session_cache_expire(60);
session_start();
}

Obtendo o id de uma sessão

O PHP também nos possibilita que possamos obter o id que
é único de uma sessão iniciada utilizando a
função session_id(). Certamente é algo que não é muito
necessário para a maioria dos desenvolvedores, mas em
certas ocasiões pode vir a ser muito útil, por exemplo, caso
precisarmos tentar recuperar sessões anteriores a nossa. Um
exemplo simples de sua utilização é a seguinte:

<?php
//Iniciando a sessão:
if (session_status() !== PHP_SESSION_ACTIVE) {
session_start();
}
//Obtendo o id da sessão iniciada:
$idSession = session_id();

Conclusão
No decorrer do artigo vimos como podemos manipular uma
sessão de usuário de forma bem simples, desde sua
inicialização á limpeza de todos os dados gravados em si e
até sua destruição total.

Vimos como podemos adicionar, exibir, alterar e deletar

variáveis dentro de uma sessão utilizando a super
global $_SESSION, onde vimos que essa super global é
simplesmente um Array, possibilitando que possamos
aproveitar todas as funcionalidades de manipulação de
Arrays que o PHP nos fornece.

Também foi mostrando como podemos definir o tempo de

vida de nossa sessão, algo que é muito útil quando, por
exemplo, estamos implementando um sistema de
autenticação de usuário. A para finalizar vimos como
podemos obter o id de uma sessão, onde em certas ocasiões
podemos usá-lo.

Para finalizar é bom ressaltar que para nós desenvolveres é

muito importante que tenhamos o conhecimento da
manipulação de sessão no PHP, pois é um recurso que pode
nós ajudar muito na resolução de certos problemas, as quais
podem vir a aparecer em nosso dia a dia.