Como Manipular Datas com PHP

Como Manipular Datas com PHP

29 de julho de 2016 3 Por Ramos de Souza Janones

Utilizando a função date()

A função date() aceita dois parâmetros, sendo um deles opcional. O primeiro é uma string de formato eu segundo, que é opcional, é um registro de data/hora do Unix. Se você não especificar em registro de data/hora, então date() assumirá como padrão a data/hora atual. Essa função retorna uma string formatada para representar a data apropriada.

Uma chamada típica à função de data poderia ser:

1
2
3
4
5
6
7
  <?php 
     echo date('jS F y'); 
     // formato 17 de abril de 2016. 
     // OU 
     echo date("d/m/Y"); 
     // 17/03/2016 
  ?>

Logo abaixo segue os formatos aceito por date().

Código de formato para função date() do PHP

Código        Descrição

a                   Antes ou depois do meio-dia, representados como dois caracteres em letras minúsculas, am ou pm.

A                  Antes ou depois do meio-dia, representados como dois caracteres em letras maiúsculas, AM ou PM.

B                  Swatch Internet Time, em esquema universal de data/hora. Informações adicionais estão disponíveis em https://www.swatch.com/pt_br/internet-time/.

c                   Data ISO 8601. Uma data é representada como YYY-MM-DD. Um T maiúsculo separa a data da hora. A hora é representada como HH:MM:SS. Finalmente, o fuso horário é representado como um deslocamento da Hora Média de Greenwich (GMT –  Greenwich Meam Time) – por exemplo, 2004-03-26T21 : 04 :42+11:00. (Esse formato foi acrescentado no PHP5).

d                   Dia do mês como um número de 2 dígitos com um zero inicial. O intervalo é de 0 a 31.

D                  Dia da semana no formato de texto abreviado em 3 caracteres. Intervalo é de Mon a Sun.

F                   Mês do ano em formato de texto completo. Intervalo é de January a December.

g                   Hora do dia em formato 12 horas sem zeros iniciais. O intervalo é de 1 a 12.

G                  Hora do dia em formato 24 horas sem zeros iniciais. O intervalo é de 0 a 23.

h                  Hora do dia em formato 12 horas cem zeros iniciais. O intervalo é de 01 a 12.

H                 Hora do dia em formato 24 horas cem zeros iniciais. O intervalo é de 00 a 24.

i                   Minutos depois da horam com zeros iniciais. O intervalo é de 00 a 59.

I                   Horários especiais de verão/inverno, representados como um valor booleano. Isso retornará 1 se a data estiver no horário especial de verão/inverno e 0 se não estiver.

J                   Dia do mês como um número sem zeros iniciais. O intervalo é de 1 a 31.

l                   Dia da semana no formato completo de texto. O intervalo é de Monday a Sunday.

L                  Ano bissexto, representado como um valor booleano. Isso retornará 1 se a data estiver em um ano bissexto e 0 se não estiver.

                Mês do ano com um número de 2 algarismos com zeros iniciais. O intervalo é de 01 a 12.

M                 Mês do ano no formato de texto abreviado de 3 caracteres. O intervalo é de Jan a Dec.

n                  Mês do ano como um número sem zeros iniciais. O intervalo é de 1 a 12.

O                 A diferença em horas entre o fuso horário atual e a Hora Média de Greenwich (GMT – Greenwich Mean Time), por exemplo +1600.

r                  A RFC822 formatou a data e a hora, por exemplo, Wed, 9 Oct 2002 18:45:30 +1600.(Acrescentado no PHP 4.0.4.)

s                 Segundos depois do minuto com zeros iniciais. O intervalo é de 00 59.

S                 Sufixo ordinal para datas no formato de 2 caracteres. Isso pode ser st, nd, rd, ou th dependendo do número que acompanha.

t                 Número total de dias no mês da data. O intervalo é de 28 a 31.

T                Configuração de fuso horário do servidor no formato de 3 caracteres, por exemplo, EST.

U                Número total de segundos desde 1º de janeiro de 1970 até o momento atual; também conhecido como o registro de data/hora do Unix para essa data.

w               Dia da semana como um único dígito. O intervalo é de 0 (domingo) a 6 (sábado).

W              O número de semana no ano, compatível com o ISO-8601. (Acrescentado no PHP 4.1.0.)

y               Ano no formato de 2 algarismos, por exemplo, 16.

Y              Ano no formato de 4 algarismos, por exemplo, 2016.

z              Dia do ano como um número. O Intervalo é de 0 a 365.

Z             deslocamento em relação ao fuso horário atual em segundos. O intervalo é -43200 a 43200.

Lidando com registro de data/hora do Unix 

O segundo parâmetro para a função date() é um registro de data/hora do Unix. Em caso de você estar querendo saber exatamente o que isso significa, a maioria dos sistemas de Unix armazena a data e a hora atuais como um inteiro de 32 bits contendo o número de segundos desde a meia-noite de 1º de janeiro de 1970, GMT, também conhecido como a Unix Epoch. Isso pode parecer um pouco esotérico se você não estiver familiarizado com o assunto, mas é um padrão e os computadores lidam facilmente com inteiros.

Curso de PHP ERP com NFe.

Os registros de data/hora (timestamps) do Unix são uma maneira compacta de armazenar uma data e hora, mas vale notar que eles não sofrem do problema do ano 2000 (Y2K) que afeta alguns outros formatos de data abreviados ou compactos. Eles têm problemas parecidos, porém porque representam apenas uma gama limitada de horário usando um inteiro de 32 bits. Se seu software precisa lidar com eventos antes de 1902 ou depois de 2038, você terá problemas.

Você não precisa se preocupar sobre seu software até ser usado em 2038. Os registros de data/hora não têm um tamanho fixo, mas são associados ao tamanho de um long do C, que tem pelo menos 32 bits. Se seu software ainda estiver em uso em 2038, é muito provável que seu compilador estará usando um tipo maior.

Os cursos online de programação e tecnologia mais recomendados para 2019

Apesar de ser uma convenção padrão UNIX, esse é ainda o formato que é utilizado por date()e várias outras funções do PHP mesmo se você estiver executando em um Windows. A única diferença é que, para Windows, o registro de data/hora tem de ser positivo.

Se quiser converter uma data/hora para um registro do Unix, você pode utilizar a funçãomktime(), que tem o seguinte protótipo:

1
   int mktime ([int hora[, int minuto[, int segundo[, int mes[, int dia[, int ano [, int is_dst]]]]]]]);

Os parâmetros são relativamente auto-explicativos, com a exceção do último, is_dst, que representa se a data está ou não no horário de verão. Você pode configurar isso como 1 se estiver, 0 se não estiver, ou -1 (o valor padrão) se você não souber. Isso é opcional; então, de qualquer jeito, você raramente irá utilizá-lo.

A principal armadilha a evitar com essa função é que os parâmetros estão em uma ordem relativamente não-intuitiva. A ordenação não serve para omitir a hora. Se não estiver preocupado com a hora, você pode passar 0s para os parâmetros hora, minuto e segundo.Mas você pode omitir valores do lado direito da lista de parâmetro. Se você deixar parâmetros em branco, eles serão configurados como os valores atuais. Portanto, uma chamada como

1
   $timestamp = mktime();

retornará o registro de data/hora do Unix para a data e a hora atuais. Você poderia também, naturalmente, obter isso chamando:

1
   $timestamp = time();

A função time() não tem nenhum parâmetro e sempre retorna o registro de data/hora do Unix para a data atuais.

Outra opção éa função date(), como já foi discutido. A string de formato “U” exige um registro de data/hora. A intrução a seguir é equivalente as duas anteriores:

1
   timestamp = date("U");

Você pode passar um ano de 2 ou 4 algarismos para mktime(). Valores de dois dígitos de 0 a 69 serão interpretados como os anos 2000 a 2069 e valores de 70 a 99 serão interpretados como 1970 a 1999.

Aqui estão alguns exemplos para ilustrar o uso de mktime():

1
   $time = mktime(12, 0, 0);

fornece o meio-dia da data de hoje.

1
   $time = mktime(0,0,0,1,1);

fornece 1º de janeiro do ano atual.

Você também pode utilizar mktime() para aritmética de data simples. Por exemplo,

1
   $time = mktime(12,0,0, $mes, $dia + 30, $ano);

adiciona 30 dias à data especificada nos componentes, embora ($dia+30) seja geralmente mais do que o número de dias naquele mês.

Para eliminar alguns problemas com hora, use hora 12 em vez de hora 0. Se você adicionar (24 * 60 * 60) a meia-noite em um dia 25 horas, será o mesmo dia. Adicione o mesmo número a meio-dia, e será 11am, mas pelo menos será o dia correto.

Utilizando a função time() 

A função time() retorna qualquer número de segundos desde a era Unix, que é de 1º de Janeiro de 1970 00:00:00 até a hora atual de execução. Este número também é chamado de timestamp Unix. Para utilizar a função basta declará-la conforme exemplo:

Veja exemplo 1 da função time().

1
2
3
4
5
6
7
8
9
   <?php 
      $proximasemana = time() + (7 * 24 * 60 * 60) ; 
      echo 'agora:          '. date('d-m-Y') ."<br>"; 
      echo 'Próxima Semana: '. date('d-m-Y', $proximasemana) ."<br>"; 
      echo 'Próxima Semana: '. date('d-m-Y', strtotime('+1 semana')) ."<br>"; 
      // Agora: 2015/04/07 Um dado Atual 
      // Próxima Semana: 2015/11/07 à Uma semana após um Atual dados 
      // Próxima Semana: 2015/11/07 à uma semana após a dados Atual utilizando strtotime 
   ?>

Utilizando time() podemos, por exemplo, apresentar em nosso sistema a data atual para o usuário, além da data da próxima semana a data de execução do exemplo apresentado.

Função strtotime

A função strtotime() recebe como parâmetro uma string de formato de data em inglês e tenta analisar esse formato. É como tentar transformar uma frase que possui possíveis informações de data em uma data real, como mostra o código a seguir:

Exemplo 2:

1
2
3
4
   <?php
      echo 'Próximo Mês: '. date('d-m-Y', strtotime('+1 mês')) ."<br>";
      // Próximo Mês: 17-03-2016
   ?>

A função date() traz a data atual da execução. Usando a função strtotime() e acrescentando +1 month, a mesma interpretará que a função deve retornar a data de execução mais um mês.

Função mktime

A função mktime() recebe como parâmetro hora, minuto, segundo, mês, dia e ano, como mostrado no Exemplo 3:.

1
2
3
4
5
6
7
8
9
10
11
   <?php
      $data = mktime(02,30,00,04,30,1995);
      // Mostra 30-04-1995
      echo date("d-m-Y", $data)."<br>";
 
      // Mostra 30-04-1995 02:30
      echo date("d-m-Y H:i", $data)."<br>";
 
      // Mostra 1995 
      echo date("Y", $data)."<br>";
   ?>

Função DateTime

A função DateTime permite trabalhar com data e hora como se fossem objetos que podem ser facilmente manipulados através de diversos métodos, facilitando a criação de regras de negócio com base em datas, além da conversão e a manipulação de diferentes formatos. A criação de um objeto da classe DateTime é a maneira mais fácil de manipular datas na sua aplicação. Veja a seguir:

Exemplo 4: Função DateTime().

1
2
3
4
5
6
7
8
9
10
11
   <?php
      $atual = new DateTime();
      $especifica = new DateTime(' 1990-01-22');
      $texto = new DateTime(' +1 month');
 
      print_r($atual);
      print_r($especifica);
      print_r($texto);
 
      / * DateTime Object ([data] => 2015/06/20 19:03:45 [timezone_type] => 3 [timezone] => UTC) DateTime Object ([data] => 1990/01/22 00:00: 00 [timezone_type] => 3 [timezone] => UTC) DateTime Object ([data] => 2015/07/20 19:03:45 [timezone_type] => 3 [timezone] => UTC) * /
    ?>

Veja que $atual é um novo objeto da classe DateTime e, como não é especificado nenhum parâmetro, então recebe a data e hora atual da execução. Já $especifica recebe o objeto também só que é especificado a data que será mostrada, enquanto que $texto recebe o mesmo objeto, só que um mês a frente da data atual da execução.

A partir do momento que o objeto da classe DateTime é instanciado podemos transformá-lo em uma string utilizando o método format(). Este método permite que se especifique um padrão, como é mostrado no Exemplo 5:

1
2
3
4
5
6
7
8
9
  <?php 
     $data = new DateTime(); 
     echo $data->format('d-m-Y H:i:s'); 
     $data = new DateTime('+ 1 mês'); 
     echo $data->format('d-m-Y H:i:s'); 
 
     // 20-03-2016 15:39:19 
     // 20-04-2016 15:39:19 
  ?>

Fizemos a mesma coisa que na Exemplo 4, só que agora com o “->” acessamos o método format e definimos que o formato de nossa data e hora será Dia, mês, ano, Hora, Min e seg.

Podemos também alterar a data do objeto criado através da classe DataTime utilizando o método modify(), como mostra o Exemplo 6.

Método modify().

1
2
3
4
5
6
7
   <?php
      $data = new DateTime('22-01-1990');
      $data->modificar('+ 1 mês');
      echo $data->format('d-m-Y H:i:s');
 
      // 22-02-1990 00:00:00
  ?>

Criamos na $data um objeto da classe DateTime e passamos uma data. Com o “->” dizemos para o método modify acrescentar um mês e quando demos echo é apresentado a data com um mês acrescido a data que já tínhamos definido.

Ajustando a data

Com o objeto da classe DateTime criado podemos alterar apenas a data do objeto, utilizando para isso o método setDate(), que recebe três parâmetros: o ano, o mês e o dia para qual desejamos ajustar, como mostra o Exemplo 7:

Método setDate().

1
2
3
4
5
6
7
   <?php 
      $data = new DateTime('22-01-1990'); 
      $data->setDate(1995, 3, 9); 
      echo $data->format('d-m-Y H:i:s'); 
 
      // 09- 03-1995 00:00:00 
   ?>

A $data tem um objeto da classe DateTime recebendo uma data. Através do -> acessamos o método setDate() e alteramos a data para 1995, 3, 9.

Caso tenha uma data vinda de um formulário no formato DD/MM/YYYY, não é necessário converter o formato da mesma para trabalhar com ela. Basta, através do métodocreateFromFormat, especificar o formato que esteja trabalhando. Observe o exemplo a seguir:

1
2
3
4
5
6
   <?php
      $data = '09-03-1995 ';
      $data1 = DateTime::createFromFormat("d-m-Y", $data);
      echo $data1->format("d-m-Y");
      // 09-03-1995
   ?>

Note que o resultado retornado foi no formato d-m-Y.

Ajustando o horário

Também podemos alterar apenas o horário do nosso objeto da classe DateTime utilizando o método setTime(). O mesmo recebe três parâmetros: a hora, os minutos e os segundos, sendo que os segundos é um parâmetro opcional, como mostra o Exemplo 8.

Método setTime().

1
2
3
4
5
6
   <?php
      $data = new DateTime('22-01-1990');
      $data->setTime(9, 15, 44);                  
      echo $data->format('d-m-Y H:i:s');
      // 22-01-1990 09:15:44
   ?>

Através do método setTime() definimos o horário e com o método format() definimos o formato de nossa data e hora.

Ajustando o fuso

Para ajustarmos o fuso horário de um objeto data precisamos criar um novo objeto da classeDateTimeZone. Um objeto desta classe representa um fuso horário válido e pode ser utilizado junto ao método setTimezone() da classe DateTime, como mostra o Exemplo 9.

Classe DateTimeZone().

1
2
3
4
5
6
7
   <?php 
      $fuso = new DateTimeZone('America/New_York'); 
      $data = new DateTime('22-01-1990'); 
      $data->setTimeZone($zona); 
      echo $data->format('d-m-Y H:i:s'); 
      // 21-01-1990 19:00:00 
   ?>

$fuso é um objeto da classe DateTimeZone e recebe como parâmetro o fuso horário. $data é um objeto da classe DateTime e nele definimos uma data que, através do métodosetTimezone executamos o $fuso e com o método format() definimos um padrão de formato para nossa data e hora.

Intervalos

Em alguns momentos será necessária a criação e análise de intervalos entre datas. Objetos da classe DateInterval representam um intervalo entre datas que pode armazenar um tempo (em anos, meses, dias ou horas) ou uma string relativa ao tempo que pode ser interpretada pelo construtor da classe DateTime.

Podemos criar intervalos utilizando um padrão que será passado ao método construtor da classe DateInterval. O padrão começa com a letra P, de período. A duração de cada período é representada por um número inteiro, seguido de um outro identificador de período. Se a duração do período contém horas, usamos o identificador T. Veja a seguir alguns identificadores existentes no PHP:

  • Y    =>   Anos
  • M   =>   Meses
  • D    =>   Dias
  • W   =>   Semanas
  • H    =>   Horas
  • M   =>   Minutos
  • S    =>   Segundos

Alguns exemplos para entenderem melhor:

  • P2D           =>   Período de dois dias
  • P3M          =>   Período de três meses
  • PT5S         =>   Período de cinco segundos
  • P3YT8M   =>   Período de três anos e oito minutos

Veja a criação do objeto de intervalo em ação na Exemplo 10.

Classe DateInterval().

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
   <?php 
      $intervalo = new DateInterval('P3YT8M'); 
      print_r($intervalo); 
 
      / * 
       DateInterval Object 
       ( 
          [Y] => 3 
          [M] => 0 
          [D] => 0 
          [H] => 0 
          [I] => 8 
          [S] => 0 
          [invert] => 0 
          [days] => 
       ) 
      * / 
   ?>

No exemplo criamos um novo objeto da classe DateInterval e passamos como parâmetro um período de três anos e oito minutos. Utilizando o print_r podemos ver perfeitamente o retorno, onde [y] =>3 representa os três anos e [i] => 8 representa os oito minutos.

Além de montar um intervalo, podemos formatá-lo utilizando outro padrão, como o a seguir:

  • %Y     =>    Ano, com dois dígitos;
  • %y     =>    Ano, com um ou dois dígitos
  • %M    =>    Mês, com dois dígitos
  • %m    =>    Mês, com um ou dois dígitos
  • %D     =>    Dia, com dois dígitos
  • %d     =>     Dia, com um ou dois dígitos
  • %a     =>     Total de dias
  • %H     =>     Hora, com dois dígitos
  • %h     =>     Hora, com um ou dois dígitos
  • %I      =>     Minuto, com dois dígitos
  • %i      =>     Minuto, com um ou dois dígitos
  • %S     =>     Segundo, com dois dígitos
  • %s     =>     Segundo, com um ou dois dígitos
  • %R    =>     Sinal de mais quando for um período positivo, menos quando negativo
  • %r     =>    Sinal de menos quando for um período negativo, vazio quando positivo

Através do método format() aplicamos o padrão apresentado anteriormente em nosso objeto:

1
2
3
4
5
   <?php
      $intervalo = new DateInterval('P2Y4D');
      echo $intervalo->format('%y anos e %d dias');
      // 2 anos e 4 dias
   ?>

O objeto $intervalo é criado da classe DateInterval e passamos como parâmetro um período de dois anos, que é representado por 2Y, e quatro dias, que é representado por 4D.

Diferença entre datas

Quando temos dois objetos da classe DateTime podemos compará-los com o método diff(), que retorna um objeto da classe DateInterval que também pode ser formato para mostrar na tela, como mostra o exemplo do Exemplo 11.

Método diff().

1
2
3
4
5
6
7
   <?php 
      $data1 = new DateTime('2011-09-11'); 
      $data2 = new DateTime('2011-10-13'); 
      $intervalo = $data1->diff ($data2); 
      echo $intervalo->format('%R%a dias'); 
      // 32 dias 
   >?

Criamos $data1 e $data2, da classe DateTime, e passamos uma data. Nosso $intervaloutilizando o método diff() faz a diferença de datas entre as variáveis data1 e data2. Utilizando o método format é retornado para nós a diferença de datas entre nossas variáveis.

Comparando datas

Uma das grandes vantagens de se trabalhar com objetos da classe DateTime é que podemos compará-los utilizando operadores comuns, como podemos ver nos exemplos do Exemplo 12.

Utilizando operadores simples para comparação de datas.

1
2
3
4
5
6
7
8
9
10
   <?php 
      $data1 = new DateTime('2011-09-11'); 
      $data2 = new DateTime('2011-10-13'); 
      var_dump($data1 == $data2); 
      var_dump($data1 > $data2); 
      var_dump($data1 < $data2); 
      // false booleano 
      // false booleano 
      // boolean true 
   ?>

Foram criados objetos da classe DateTime e passado a eles datas. Com o var_dump fazemos comparações, por exemplo, em var_dump($data 1 > $data2) perguntamos se $data1 é maior que $data2 e como não é, então foi retornado um boolean false.

Somando intervalo a data e horário

A classe DateTime nós traz um método chamado add(), que nos permite acrescentar um período de tempo ao objeto DateTime criado, como vemos no Exemplo 13.

Método add().

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
   <?php 
      $data = new DateTime('2011-09-11'); 
      print_r($data); 
 
      $data->add(new DateInterval('P2M5D')); 
      print_r($data); 
 
      / * 
       DateTime Object 
       ( 
         [date] => 2011-09-11 00:00:00 
         [Timezone_type] => 3 
         [Fuso Horário] => UTC 
       ) 
       DateTime Object 
       ( 
         [date] => 2011-11-16 00:00:00 
         [timezone_type] => 3 
         [timezone] => UTC 
       ) 
      * / 
   ?>

Em $data criamos um novo objeto da classe DateTime e passamos uma data. Através doprint_r apresentamos o resultado e depois com o método add() adicionamos a nossa a data um período de dois meses e cinco dias. Note que o primeiro resultado é a nossa data que definimos e no outro resultado já vem acrescido os meses e os dias que pedimos.

Subtraindo intervalo a data e horário

Da mesma forma que conseguimos adicionar hora, também podemos subtrair um determinado período sobre um objeto da classe DateTime, como vemos no Exemplo 14.

Método sub().

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
   <?php 
      $data = new DateTime('2011-12-31'); 
      print_r($data); 
 
      $data->sub(new DateInterval('P7D')); 
      print_r($data); 
      / * 
      DateTime Object 
      ( 
        [date] => 2011-12-31 00:00:00 
        [timezone_type] => 3 
        [timezone] => UTC 
      ) 
      DateTime Object 
      ( 
        [date] => 2011-12-24 00:00:00 
        [timezone_type] => 3 
        [timezone] => UTC 
      ) 
      * / 
   ?>

Note que agora utilizando o método sub(), o que antes era o dia de nossa data (31) agora passou para 24, ou seja, diminuímos dias que é o que queríamos que ocorresse.

Configuração do Fuso Horário no PHP

Por padrão, o PHP utiliza sempre como fuso horário o valor já configurado na máquina onde ele está instalado. Isso pode ser um problema quando você tem várias aplicações rodando em um mesmo servidor que podem possuir um fuso horário diferente. Um exemplo disso é quando queremos atingir um público estrangeiro e outro brasileiro. Para especificar atimezone para cada aplicação utilizamos a função date_default_timezone_set(). Esta recebe apenas um parâmetro, que é o identificador de fuso-horário. Veja a seguir um exemplo.

1
2
3
   <?php 
      date_default_timezone_set('America/Sao_Paulo'); 
   ?>

Veja que setamos o fuso horário da máquina como sendo de São Paulo.

Os identificadores disponíveis mais comuns são:

  • America/Rio_Branco;
  • America/Maceio;
  • America/Belem;
  • America/Manaus;
  • America/Bahia;
  • America/Fortaleza;
  • America/Sao_Paulo;
  • America/Recife;
  • America/Cuiaba;
  • America/Campo_Grande;
  • America/Noronha;
  • America/Porto_Velho;
  • America/Boa_Vista;
  • America_Araguaina;
  • Brazil/Acre;
  • Brazil/deNoronha;
  • Brasil / Oriente;
  • Brazil/West.

Datas em outras línguas

Haverá momentos em que nós vamos precisar utilizar as funções de data em nossa aplicação e receber os nomes de meses e dias em português ou em outra língua. Nessa situação não podemos utilizar a função date() e sim a função strftime(), que permite a criação de strings a partir de uma timezone com outras línguas.

O comportamento da strftime() é muito similar à date, tendo apenas um padrão diferente, como vemos a seguir:

  • %e    =>    Dia em número
  • %a    =>    Dia abreviado
  • %A    =>    Dia por extenso
  • %m   =>    Mês em número
  • %b    =>    Mês abreviado
  • %B    =>    Mês por extenso
  • %y    =>    Ano com dois dígitos
  • %Y    =>    Ano com quadro dígitos

Veja um exemplo simples do comportamento da strftime():

1
2
3
4
   <?php
      echo strftime("%A");
      // Wednesday
   ?>

Veja que mostramos o dia atual, que no caso é Wednesday. Os resultados obtidos vêm de acordo com a data atual de seu computador.

Uma ótima função para se trabalhar com date() é a getlastmod(), pois essa função apresenta para o tempo da última modificação na página, como mostra o Exemplo 15.

Função getlastmod().

1
2
3
4
5
   <?php 
      header('Content-Type: text/html; charset=UTF-8');                    
      echo "Última Modificação:" .date("F d Y H:i:s", getlastmod()); 
      // Última Modificação: June 24 2015 22:41:53 
   ?>

Utilizamos a função date juntamente com getlastmod para mostrar na página a última modificação que ela teve.

Validando datas

Você pode utilizar a função checkdate() para verificar se uma data é válida. Isso é especialmente útil para verificar datas de entrada de usuário. A função checkdate() tem os seguinte protótipo:

1
   int checkdate(int mês, int dia, ano int);

Ela verificará se o ano é um inteiro válido entre 0 e 32.767, se o mês é um inteiro entre 1 e 12 e se o dia fornecido existe nesse mês particular. A função leva em consideração os horários de verão. Por exemplo,

1
   checkdate(9, 18, 1972);

retornará true enquanto

1
   checkdate(9, 31, 2000);

não retornará.

Veremos no Exemplo 16 uma função que checa se a data está correta. Por exemplo, sabemos que o mês de fevereiro é, quase sempre, de 28 dias, então, caso o usuário passe um valor que não esteja de acordo com o mês, está função barra tal ação.

Função checkdate.

1
2
3
4
5
6
7
   <?php 
      var_dump(checkdate(12, 31, 2000)); 
      var_dump(checkdate(2, 29, 2001)); 
 
      // Boolean true 
      // Boolean false 
   ?>

Nosso exemplo está no formato (Mês, dia e ano). A função checkdate retorna um boolean falseou true. Em nosso primeiro var_dump é passado uma data correta, então foi retornado umboolean true. Já no segundo var_dump ocorre o erro, pois foi passado como dia 29 para o mês de fevereiro, como no ano de 2000 fevereiro teve apenas 28 dias, sendo assim, foi retornado um boolean false.

Utilizando a função getdate()

Outra função para determinar data que você talvez ache útil é a função getdate(). Essa função tem o seguinte protótipo:

1
   getdate array(timestamp int);

Ela aceita um registro de data/hora como parâmetro e retorna um array associativo representando as partes dessa data e hora como é mostrado abaixo:

Pares de chave-valor de array associativo a partir da função getdate()

Chave              Valor

seconds           Segundos, numérico

minutes           Minutos, numérico

hours               Horas, numérico

mday                Dia do mês, numérico

wday                 Dia da semana, numérico

mon                  Mês, numérico

year                  Ano, numérico

yday                 Dia do ano, numérico

weekday         Dia da semana, formato completo de texto

month             Mês, formato completo de texto

                      Registro de data/hora, numérico

Depois de ter esssas partes em um array, você pode facilmente processá-las em qualquer formato requerido. O elemento no array (o registro de data/hora) pode parecer inútil, mas se você chamar gatdate() sem um parâmetro, ele dará o registro de data/hora atual.

No Exemplo 17 teremos a função getdate, que retorna para um array com dados. Por exemplo, qual dia do ano estamos, hora, minuto, e por ai vai.

Função getdate.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
   <?php
      $today = getdate();
      print_r($today);
 
      /*
        Array 
       ( 
         [seconds] => 42 
         [minutes] => 18 
         [hour] => 1 
         [mday] => 25 
         [wday] => 4 
         [mon] => 6 
         [year] => 2015 
         [yday] => 175 
         [weekday] => Thursday 
         [month] => June 
         [0] => 1435195122
       )
       */
   ?>

Veja que foi retornado um array com os dados atuais da data do computador em que foi executado o programa. Além das informações básicas, temos o [yday], que é 175, exatamente em qual dia dos 365 dias de 2015 que estamos.

Por último temos a função explode(), que pode ser usada quando queremos dividir uma data. Veja no Exemplo 18.

Função explode().

1
2
3
4
5
6
7
8
9
10
   <?php
      $data = date("d/m/Y");
 
      $data = explode("/", $data);
 
      list($dia, $mes, $ano) = $data;
 
      $data = "$ano/$mes/$dia";
      echo $data;
   ?>

Criamos $data que guarda a data atual no formato (Dia, Mês, Ano) e ao utilizar a função explode, separamos os dados. Depois criamos $dia, $mes, $ano que é armazenado em $data. Com os dados guardados apenas passamos as variáveis de acordo com o formato que queremos, que é YYYY/MM/DD.

Função idate

A função idate, em conjunto com a strtotime, recebe como parâmetro uma string de data em inglês e é interpretada pelo PHP. Veja no Exemplo 19 como funciona.

Utilizando idate().

1
2
3
4
5
   <?php
      $timestamp = strtotime('9st March 1995');
      echo idate('m', $timestamp);
      // 3
   ?>

Criamos $timestamp que recebe a função strtotime com as palavras em inglês. Utilizando a função idate() passamos o termo m, que significa que queremos que o PHP interprete o mês (march) e devolva para nós em número.

Convertendo entre formatos de data do PHP e do MySQL

As datas e as horas no MySQL são recuperadas de maneira ligeiramente diferente da maneira como você poderia esperar. Os campos de data/hora funcionam de maneira relativamente normal, mas o MySQL espera que as datas sejam inseridas com o ano primeiro. Por exemplo, a data 29 de agosto de 2000 poderia ser inserida como 2000-08-29 ou como 00-08-29. As datas recuperadas a partir do MySQL também estarão nessa ordem por padrão.

Dependendo do público-alvo, você pode não achar essa função amigável ao usuário. Para se comunicar entre PHP e MySQL então, normalmente precisamos realizar alguma conversão de data. Isso pode ser feito em qualquer extremidade.

Ao colocar datas no MySQL a partir do PHP, você pode facilmente colocá-las no formato correto utilizando a função date() como mostrado anteriormente. Um pequeno cuidado é que você deve utilizar as versões do dia e mês com zeros iniciais para evitar confundir o MySQL. Você pode usar um ano com dois dígitos. Se escolher fazer a conversão no MySQL, duas funções úteis são DATE_FORMAT() e Unix_TIMESTAMP().

A função DATE_FORMAT() funciona de maneira semelhante à função equivalente do PHP mas utiliza diferentes códigos de formato. Algo comum que queremos fazer é formatar uma data no formato MM-DD-AAAA em vez de no formato nativo AAAA-MM-DD do MySQL. Você pode fazer isso escrevendo sua consulta da seguinte maneira:

SELECT DATE_FORMAT(coluna_de_data, ‘%m %d %Y’)
FROM nomedatabela;

O código de formato %m representa o mês como um número de 2 algarismos; %d, o dia como um número de 2 algarismos; e %Y, o ano como um número de 4 algarismos. Um resumo dos códigos de formato do MySQL mais úteis para esse é mostrado a seguir:

Código            Descrição

%M                Mês, texto completo

%W                Nome do dia da semana, texto completo

%D                 Dia do mês, numérico, com sufixo de texto (por exemplo, 1)

%Y                 Ano, numérico, 4 dígitos

%y                  Ano, numérico, 2 algarismos

%a                  Nome do dia da semana, e, 3 caracteres

%d                  Dia de mês, zeros iniciais e numéricos

%e                  Dia de mês, numérico, sem zeros iniciais

%m                 Mês, numérico, zeros iniciais

%c                  Mês, numérico, sem zeros iniciais

%b                  Mês, texto, 3 caracteres

%j                   Dia do ano, numérico

%H                 Hora, relógio de 24 horas, zeros iniciais

%k                  Hora, relógio de 24 horas, sem zeros iniciais

% h ou %I     Hora, relógio de 12 horas, zeros iniciais

%l                   Hora, relógio de 12 horas, sem zeros iniciais

%i                   Minutos, zeros iniciais, numéricos

%r                  Hora, 12 horas (hh:mm:ss [AM|PM])

%T                 Hora, 24 horas (hh:mm:ss)

%S ou %s      Segundos, numéricos, zeros iniciais

%p                  AM ou PM

%w                 Dia da semana, numérico, de 0 (domingo) a 6 (sábado)

A função Unix_TIMESTAMP funciona de maneira semelhante, mas converte uma coluna em um registro de data/hora do Unix. Por exemplo,

SELECT Unix_TIMESTAMP(coluna_de_data)
FROM nomedatabela;

retornará a data formatada como um registro de data/hora do Unix. Você pode então fazer como faria com ele no PHP.

Você pode facilmente realizar cálculos e comparações com o registro de data/hora do Unix. Lembre-se, no entanto, de que um registro de data/hora geralmente pode representar datas apenas entre 1902 e 2038, enquanto o tipo de data do MySQL possui um alcance maior.

Uma maneira prática de proceder é usar o registro de data/hora do Unix para cálculos de data e o formato de data padrão estiver apenas armazenando ou exibindo datas.

Calculando datas em PHP

A maneira mais simples de calcular o período de tempo entre duas datas no PHP é utilizando a diferença entre registros de data/hora do Unix. Utilizamos essa abordagem no script mostrado abaixo.

Script descobre a idade de uma pessoa com base na sua data de nascimento – calc_age.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
  <?php
     // configura a data para cálculo
     $dia = 18;
     $mes = 9;
     $ano = 1972;
 
     // lembre-se de que você precisa de bday como dia e ano
     $bdayunix = mktime (' ', ' ', ' ', $mes, $dia, $ano);
     // obtêm ts unix para bday
     $nowunix = time(); // obtêm ts unix para hoje
     $ageunix = $nowunix - $bdayunix; // acha a diferença
     $idade = floor($ageunix / (365 * 24 * 60 * 60)); // converte de segundos para anos
 
     echo “Idade é $idade”;
   ?>

Nesse script, configuramos a data para calcular a idade. Em uma aplicação real, é possível que essas informações talvez venham de um formulário HTML. Começamos chamandomktime() para calcular o registro de data/hora para o aniversário e o tempo atual:

1
2
3
4
  <?php
     $bdayunix = mktime(' ', ' ', ' ', $mes, $dia, $ano);
     $nowunix = mktime(); // obtêm ts unix para hoje
   ?>

Agora, a parte um pouco mais difícil – converter esse período de tempo de volta para uma unidade de medida em segundos. Podemos converter de volta para anos dividindo pelo número de segundos em um ano. Então, arredondamos utilizando a função floor() uma vez que não se diz que uma pessoa tem, por exemplo 20 anos, até o final do seu vigésimo ano:

1
2
3
  <?php
     $idade = floor($ageunix / (365 * 24 * 60 * 60)); // converte de segundos para anos
   ?>

Entretanto, observe que essa abordagem é um pouco falha porque é limitada pelo limite de registro de data/hora do Unix (geralmente inteiros de 32 bits). Datas de nascimento não são ideais para registros de data/hora. Esse exemplo funciona em todas as plataformas apenas para pessoas nascidas em 1970 e posteriormente. O Windows não pode gerenciar registros de data/hora anteriores a 1970. Mesmo assim, esse cálculo não é sempre preciso porque não permite anos bissextos e pode falhar se o nascimento da pessoa ocorrer na troca do horário de verão.

Calculando datas no MySQL

O PHP não possui muitas funções de manipulação de datas embutidas. Obviamente, você pode escrever as suas próprias, mas garantindo que conte corretamente os anos bissextos e o horário de verão. Outra opção é fazer download de funções de terceiros. Você pode descobrir muitas notas de contribuição de usuários no manual do PHP, mas apenas algumas são bem elaboradas.

Uma opção que pode não parecer óbvia a princípio é usar o MySQL. Ele fornece um limite extensivo de funções de manipulação de datas que funcionam para horas fora do limite confiável do registro de data/hora do Unix. Você precisa se conectar a um servidor MySQL para executar uma consulta MySQL, mas não precisa usar dados do banco de dados.

A seguinte consulta adiciona um dia à data 28 de fevereiro de 1700, e retorna a data resultante:

select adddate(‘1700-02-28’, interval 1 day)

O ano de 1700 não é um ano bissexto, então o resultado é 1700-03-01 (ano, mês, dia).

Você pode descobrir uma sintaxe extensiva para descrever e modificar datas e horas descritas no manual do MySQL, em:
https://dev.mysql.com/doc/refman/5.5/en/date-and-time-functions.html

Infelizmente, não há uma maneira simples de obter o número de anos entre duas datas; portanto, o exemplo da data de nascimento ainda é um pouco falho. É possível obter a idade de uma pessoa, em dias muito facilmente, e o próximo exemplo converte a idade em anos de forma imprecisa.

Utilizando o MySQL para calcular a idade de uma pessoa com base na data de nascimento

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
  <?php
     // define data para cálculos  
     $dia = 18;
     $mes = 9;
     $ano = 1972;
 
     // formata a data de nascimento como uma data ISO 8601
     $bdayISO = date(“c”, mktime(0, 0, 0, $mes, $dia, $ano));
 
     // usa a consulta mysql para calcular uma idade em dias
     $db = msqli_connect('localhost', 'user', 'pass');
     $res = mysqli_query($db, “select datediff(now(), '$bdayISO')”);
     $idade = mysqli_fetch_array($res);
 
     // converte a idade em dias para a idade em anos (aproximadamente)
     echo “Idade é ”.floor($age[0]/365.25);
   ?>
 Depois de formatar o dia do nascimento como um registro de data/hora ISO, passe a seguinte consulta ao MySQL:

 

LEIA TAMBÉM:  BITBUCKET – REPOSITÓRIO ON-LINE GRÁTIS

select datediff(now(), ‘1972-09-18T00:00:00+10:00’)

A função MySQl now() sempre retorna a data e a hora atuais. A função MySQL datediff()(acrescentada na versão 4.1.1) subtrai uma data de outra e retorna em dias.

É importante notar que você não está selecionando dados de uma tabela ou mesmo escolhendo um banco de dados para ser usado nesse script, mas você precisa fazer login no servidor MySQL com um nome de usuário e senha válidos.

Como nenhuma função embutida específica está disponível para esses cálculos, uma consulta SQL para calcular o número exato de anos é razoavelmente complexa. Aqui, tomamos um atalho e dividimos a idade em dias por 365;25 para obtermos a idade em anos. Esse cálculo pode ficar com um ano a menos se feito no aniversário de alguém, dependendo de quantos anos bissextos tiver ocorrido na vida da pessoa.

Utilizando microssengundos 

Para algumas aplicações, medir o tempo em segundos não é preciso o suficiente para ser considerado útil. Se você quiser medir períodos muito curtos, como o tempo que leva para executar uma parte ou todo um script do PHP, precisa utilizar a função microtime().

Se estiver utilizando o PHP5, chame microtime() como o parâmetro get_as_float definido paratrue. Essa chamada retorna um registro de data/hora como número de ponto flutuante pronto para qualquer uso desejado. Esse registro de data/hora é o mesmo retornado pormktime(), time() ou date(), mas possui um componente fracional.

A instrução

1
2
3
  <?php
      echo number_format(microtime(true), 10, '.', ' ');
   ?>

produz algo como 1080303003.1321949959.

Em versões anteriores, você não pode pedir o resultado como flutuante. Ele é fornecido como string. Uma chamada a microtime() sem um parâmetro retorna uma string deste formato “0.021493000 1080302326”. O primeiro número é a parte fracionada, e o segundo é o número de segundos desde 1º de janeiro de 1970.

É mais útil lidar com números em vez de strings; portanto, se você não se importar de seu código exigir o PHP 5.0 para ser executado, é mais fácil chamar microtime() com o parâmetrotrue.

Utilizando funções de calendário 

O PHP tem um conjunto de funções que permite converter entre diferentes sistemas de calendário. Os principais calendários com que você trabalhará são o gregoriano, o juliano e o de contagem de dias do calendário juliano (Julian Day Count).

O calendário gregoriano é o que a maioria dos países ocidentais utiliza atualmente. A data 15 de outubro de 1582 no calendário gregoriano é equivalente a 5 de outubro de 1582 do calendário juliano. Antes da data, o calendário juliano era comumente utilizado. Países diferentes converteram para o calendário gregoriano em momentos diferentes e alguns não fizeram até o início do século XX.

Embora talvez você já tenha ouvido a respeito desses dois calendários, talvez não tenha ouvido falar do calendário de contagem de dias do calendário juliano. Sob vários aspectos, isso é semelhante a um registro de data/hora do Unix. É uma contagem do número de dias desde uma data em torno de 4000 AC. Por si só, não é particularmente útil, mas é útil para converter entre formatos. Para converter de um formato para o outro, você primeiro converte para um calendário de contagem de dias juliano e então para o calendário de saída desejado.

Para utilizar essas funções sob o Unix, você precisará ter compilado a extensão do calendário no PHP. Eles são integrados na instalação padrão do Windows.

Para dar a você uma prévia dessas funções, considere os protótipos para as funções que você utilizaria para converter do calendário gregoriano para o juliano:

1
2
3
4
  <?php
     int gregoriantojd(int month, int day, int year)
     string jdtojulian(int julianday)
   ?>

Para converter uma data, precisaríamos chamar estas duas funções:

1
2
3
4
  <?php
     $jd = gregoriantojd(9, 18, 1582);
     echo jdtojulian($jd);
   ?>

Isso ecoa a data juliana em um formato mm/dd/aaaa.

Essas variações de funções existem para converter entre calendários gregoriano, juliano, francês, judaico e os registros de data/hora do Unix.

Saiba Mais 

Mais informações sobre funções de data e hora no PHP e MySQL, você pode consultar em:
https://php.net/manual/en/ref.datetime.php
https://dev.mysql.com/doc/refman/5.5/en/date-and-time-functions.html

Se você estiver convertendo entre calendários, consulte a página do manual para funções de calendário do PHP:
https://php.net/manual/en/ref.calendar.php

 

Os cursos online de programação e tecnologia mais recomendados para 2019

(Fonte: DevMedia; Livro: PHP e MySql Desenvolvimento Web)

Subscribe to our mailing list

* indicates required


Além de PHP e MySQL, deseja receber outro tema?

LEIA TAMBÉM:  Mibew – Instale e Configure uma Central de Atendimento Online
Email Format


Ramos de Souza Janones

Janones, é um empreendedor brasileiro apaixonado por empreendedorismo e tecnologia. Ao longo dos anos trabalhando com o desenvolvimento de softwares desktop desde a linguagem Clipper, passando pelo Delphi e atualmente com Java.

Optou pela formação de Publicidade e Marketing por sua segunda empresa de tecnologia ter participado do "boom" da internet nos anos 90 e na procura de melhorar seus conhecimentos em negócios.

Em razão da principal formação e profundos conhecimentos em programação e banco de dados, é capaz de realizar o desenvolvimento de aplicativos web, desktop e mobile com maior criatividade e inovação que profissionais de desenvolvimento com uma formação única e mais especifica, dedicada somente ao desenvolvimento de softwares.

Com toda sua experiência com empresas de software, sua formação e paixão por negócios escreveu o livro "Marketing para Empresas e Profissionais de Software", publicado pela editora carioca Ciência Moderna em 2012. Além de outros livros sobre programação.
Sumário
Como Manipular Datas com PHP
Nome do artigo
Como Manipular Datas com PHP
Descrição
Tutorial sobre como manipular data com PHP.
Autor
Nome
Ramos da Informática
Logo