Recursos para Desenvolvedores e Trechos de Código

Aqui você pode encontrar exemplos de código para trabalhar com timestamps Unix em diferentes linguagens de programação. Selecione uma linguagem nas opções abaixo:

Trechos de timestamp Unix por linguagem

Aqui você pode encontrar exemplos de código para trabalhar com timestamps Unix em diferentes linguagens de programação. Selecione uma linguagem nas opções abaixo:

Ferramentas relacionadas: Epoch Converterer, Date Converterer, Unix ms to Date, Conversor de fuso horário

Perguntas frequentes

How do I get the current Unix timestamp in JavaScript? Use Math.floor(Date.now() / 1000) for Unix seconds or Date.now() for Unix milliseconds in JavaScript.

How do I convert epoch to datetime in Python, PHP, or SQL? Use the language-specific examples on this page to parse Unix timestamps into UTC or local datetime output for debugging, APIs, and database work.

What is the difference between Unix seconds and Unix milliseconds in code? Unix seconds are usually 10 digits and are common in backend systems. Unix milliseconds are usually 13 digits and are common in JavaScript, analytics, and browser events.

Obter timestamp atual

JavaScript

// Get current Unix timestamp (seconds)
const timestampInSegundos = Math.floor(Date.now() / 1000);
console.log(timestampInSegundos);

// Get current Unix timestamp (milliseconds)
const timestampInMilissegundos = Date.now();
console.log(timestampInMilissegundos);

Converter timestamp em data

JavaScript

// Converter Unix timestamp to date
const timestamp = 1609459200; // 2021-01-01 00:00:00 UTC
const date = new Date(timestamp * 1000);

console.log(date.toISOString()); // "2021-01-01T00:00:00.000Z"
console.log(date.toLocaleString()); // Localized format

Converter data em timestamp

JavaScript

// Converter date string to Unix timestamp
const dateString = '2021-01-01T00:00:00Z';
const timestamp = Math.floor(new Date(dateString).getTime() / 1000);
console.log(timestamp); // 1609459200

// Converter Date object to Unix timestamp
const date = new Date(2021, 0, 1); // Observação: months start at 0
const timestampFromDate = Math.floor(date.getTime() / 1000);
console.log(timestampFromDate);

Observação:

Date.now() do JavaScript retorna milissegundos. Divida por 1000 para obter segundos.

Ao converter de segundos para um objeto Date, multiplique por 1000.

Obter timestamp atual

Python

import time
import datetime

# Get current Unix timestamp (seconds)
timestamp_seconds = int(time.time())
print(timestamp_seconds)

# Get current Unix timestamp (milliseconds)
timestamp_milliseconds = int(time.time() * 1000)
print(timestamp_milliseconds)

# Using datetime
dt = datetime.datetime.now()
timestamp_from_datetime = int(dt.timestamp())
print(timestamp_from_datetime)

Converter timestamp em data

Python

import time
import datetime

# Converter Unix timestamp to date
timestamp = 1609459200  # 2021-01-01 00:00:00 UTC

# Using time module
date_str = time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime(timestamp))
print(date_str)  # '2021-01-01 00:00:00'

# Using datetime module
date_obj = datetime.datetime.fromtimestamp(timestamp, tz=datetime.timezone.utc)
print(date_obj.strftime('%Y-%m-%d %H:%M:%S'))  # '2021-01-01 00:00:00'

Converter data em timestamp

Python

import datetime

# Converter date string to Unix timestamp
date_string = '2021-01-01 00:00:00'
date_obj = datetime.datetime.strptime(date_string, '%Y-%m-%d %H:%M:%S')

# Converter to timestamp (assumes local timezone)
timestamp = int(date_obj.timestamp())
print(timestamp)

# Explicitly specify UTC timezone
date_obj_utc = date_obj.replace(tzinfo=datetime.timezone.utc)
timestamp_utc = int(date_obj_utc.timestamp())
print(timestamp_utc)

Observação:

time.time() do Python retorna segundos em ponto flutuante. Use int() para segundos inteiros.

Para lidar com fusos horários, considere usar a biblioteca pytz para um suporte mais robusto.

Obter timestamp atual

Java

import java.time.Instant;

public class TimestampExample {
    public static void main(String[] args) {
        // Get current Unix timestamp (seconds)
        long timestampInSegundos = Instant.now().getEpochSecond();
        System.out.println(timestampInSegundos);

        // Get current Unix timestamp (milliseconds)
        long timestampInMilissegundos = Instant.now().toEpochMilli();
        System.out.println(timestampInMilissegundos);

        // Traditional method
        long currentTimeMillis = System.currentTimeMillis();
        long timestampSegundos = currentTimeMillis / 1000L;
        System.out.println(timestampSegundos);
    }
}

Converter timestamp em data

Java

import java.time.Instant;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;

public class TimestampToDateExample {
    public static void main(String[] args) {
        // Converter Unix timestamp to date
        long timestamp = 1609459200L; // 2021-01-01 00:00:00 UTC

        // Using Instant and formatter
        Instant instant = Instant.ofEpochSecond(timestamp);
        DateTimeFormatter formatter = DateTimeFormatter
            .ofPattern("yyyy-MM-dd HH:mm:ss")
            .withZone(ZoneId.of("UTC"));

        String formattedDate = formatter.format(instant);
        System.out.println(formattedDate); // "2021-01-01 00:00:00"
    }
}

Converter data em timestamp

Java

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

public class DateToTimestampExample {
    public static void main(String[] args) {
        // Converter date string to Unix timestamp
        String dateString = "2021-01-01 00:00:00";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        // Parse and convert to timestamp (assuming UTC)
        LocalDateTime dateTime = LocalDateTime.parse(dateString, formatter);
        ZonedDateTime zonedDateTime = dateTime.atZone(ZoneId.of("UTC"));
        long timestamp = zonedDateTime.toEpochSecond();

        System.out.println(timestamp); // 1609459200
    }
}

Observação:

O Java 8+ introduziu o pacote java.time com melhor tratamento de data/hora.

Use Instant para timestamps UTC e ZonedDateTime para operações com reconhecimento de fuso horário.

Obter timestamp atual

PHP

<?php
// Get current Unix timestamp (seconds)
$timestampInSegundos = time();
echo $timestampInSegundos;

// Get current Unix timestamp (milliseconds)
$timestampInMilissegundos = round(microtime(true) * 1000);
echo $timestampInMilissegundos;

// Using DateTime class
$dateTime = new DateTime();
$timestampFromDateTime = $dateTime->getTimestamp();
echo $timestampFromDateTime;
?>

Converter timestamp em data

PHP

<?php
// Converter Unix timestamp to date
$timestamp = 1609459200; // 2021-01-01 00:00:00 UTC

// Using date function (local timezone)
$dateFormatted = date('Y-m-d H:i:s', $timestamp);
echo $dateFormatted;

// Using gmdate for UTC
$dateFormattedUTC = gmdate('Y-m-d H:i:s', $timestamp);
echo $dateFormattedUTC; // "2021-01-01 00:00:00"

// Using DateTime class
$dateTime = new DateTime("@$timestamp");
$dateTime->setTimezone(new DateTimeZone('UTC'));
echo $dateTime->format('Y-m-d H:i:s');
?>

Converter data em timestamp

PHP

<?php
// Converter date string to Unix timestamp
$dateString = '2021-01-01 00:00:00';

// Using strtotime (assumes local timezone)
$timestamp = strtotime($dateString);
echo $timestamp;

// Specify UTC timezone
$timestampUTC = strtotime($dateString . ' UTC');
echo $timestampUTC;

// Using DateTime class with timezone
$dateTime = new DateTime($dateString, new DateTimeZone('UTC'));
$timestamp = $dateTime->getTimestamp();
echo $timestamp; // 1609459200
?>

Observação:

time() do PHP retorna segundos. Use microtime(true) para segundos fracionários.

Fique atento às configurações de fuso horário ao usar as funções date() e strtotime().

Obter timestamp atual

package main

import (
    "fmt"
    "time"
)

func main() {
    // Get current Unix timestamp (seconds)
    timestampInSegundos := time.Now().Unix()
    fmt.Println(timestampInSegundos)

    // Get current Unix timestamp (milliseconds)
    // UnixMilli() requires Go 1.17+, using UnixNano() for better compatibility
    timestampInMilissegundos := time.Now().UnixNano() / int64(time.Millisecond)
    fmt.Println(timestampInMilissegundos)
}

Converter timestamp em data

package main

import (
    "fmt"
    "time"
)

func main() {
    // Converter Unix timestamp to date
    timestamp := int64(1609459200) // 2021-01-01 00:00:00 UTC

    // Create time object
    t := time.Unix(timestamp, 0)

    // Format date (UTC)
    fmt.Println(t.UTC().Format("2006-01-02 15:04:05"))

    // Format date (local timezone)
    fmt.Println(t.Format("2006-01-02 15:04:05"))
}

Converter data em timestamp

package main

import (
    "fmt"
    "time"
)

func main() {
    // Converter date string to Unix timestamp
    dateString := "2021-01-01 00:00:00"

    // Parse date string (assuming UTC)
    // Go uses the reference time "2006-01-02 15:04:05" for time formatting layouts
    t, err := time.Parse("2006-01-02 15:04:05", dateString)
    if err != nil {
        fmt.Println(err)
        return
    }

    // Get Unix timestamp
    timestamp := t.Unix()
    fmt.Printf("Timestamp: %d\n", timestamp) // 1609459200
}

Observação:

Go usa o horário de referência "2006-01-02 15:04:05" para layouts de formatação de tempo.

Use time.Now().Unix() para segundos e time.Now().UnixMilli() para milissegundos (Go 1.17+).

Obter timestamp atual

using System;

class Program
{
    static void Main()
    {
        // Get current Unix timestamp (seconds)
        DateTimeOffset now = DateTimeOffset.UtcNow;
        long timestampInSegundos = now.ToUnixTimeSegundos();
        Console.WriteLine(timestampInSegundos);

        // Get current Unix timestamp (milliseconds)
        long timestampInMilissegundos = now.ToUnixTimeMilissegundos();
        Console.WriteLine(timestampInMilissegundos);

        // Alternative method for older .NET versions
        DateTime unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
        TimeSpan timeSpan = DateTime.UtcNow - unixEpoch;
        long timestampSegundosAlt = (long)timeSpan.TotalSegundos;
        Console.WriteLine(timestampSegundosAlt);
    }
}

Converter timestamp em data

using System;

class Program
{
    static void Main()
    {
        // Converter Unix timestamp to date
        long timestamp = 1609459200; // 2021-01-01 00:00:00 UTC

        // Using DateTimeOffset (.NET Standard 2.0+)
        DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSegundos(timestamp);
        Console.WriteLine(dateTimeOffset.ToString("yyyy-MM-dd HH:mm:ss")); // UTC

        // Converter to local time
        DateTimeOffset localTime = dateTimeOffset.ToLocalTime();
        Console.WriteLine(localTime.ToString("yyyy-MM-dd HH:mm:ss")); // Local
    }
}

Converter data em timestamp

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        // Converter date string to Unix timestamp
        string dateString = "2021-01-01 00:00:00";

        // Parse date string (assume UTC)
        DateTime dateTime = DateTime.ParseExact(
            dateString,
            "yyyy-MM-dd HH:mm:ss",
            CultureInfo.InvariantCulture,
            DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal);

        // Converter to timestamp
        DateTimeOffset dateTimeOffset = new DateTimeOffset(dateTime);
        long timestamp = dateTimeOffset.ToUnixTimeSegundos();
        Console.WriteLine($"Timestamp: {timestamp}"); // 1609459200
    }
}

Observação:

Use DateTimeOffset para operações com timestamps Unix no .NET Standard 2.0+.

Tenha cuidado com DateTimeKind ao trabalhar com objetos DateTime.

Obter timestamp atual

Ruby

# Get current Unix timestamp (seconds)
timestamp_seconds = Time.now.to_i
puts timestamp_seconds

# Get current Unix timestamp (milliseconds)
timestamp_milliseconds = (Time.now.to_f * 1000).to_i
puts timestamp_milliseconds

# Get current UTC timestamp
require 'time'
utc_timestamp = Time.now.utc.to_i
puts utc_timestamp

Converter timestamp em data

Ruby

require 'time'

# Converter Unix timestamp to date
timestamp = 1609459200  # 2021-01-01 00:00:00 UTC

# Create Time object (local timezone)
time = Time.at(timestamp)
puts time.strftime('%Y-%m-%d %H:%M:%S')

# Create UTC Time object
time_utc = Time.at(timestamp).utc
puts time_utc.strftime('%Y-%m-%d %H:%M:%S')  # "2021-01-01 00:00:00"

# ISO 8601 format
puts time_utc.iso8601

Converter data em timestamp

Ruby

require 'time'

# Converter date string to Unix timestamp
date_string = '2021-01-01 00:00:00'

# Parse date string (local timezone)
time = Time.parse(date_string)
timestamp = time.to_i
puts timestamp

# Parse date string as UTC
time_utc = Time.parse(date_string + ' UTC')
timestamp_utc = time_utc.to_i
puts timestamp_utc  # 1609459200

# More precise parsing
require 'date'
datetime = DateTime.strptime(date_string, '%Y-%m-%d %H:%M:%S')
timestamp_from_datetime = datetime.to_time.to_i
puts timestamp_from_datetime

Observação:

Time.now.to_i do Ruby retorna segundos. Use (Time.now.to_f * 1000).to_i para milissegundos.

Para lidar com fusos horários complexos, considere usar a gem tzinfo.

Obter timestamp atual

SQL

-- MySQL
SELECT UNIX_TIMESTAMP() AS current_timestamp;
SELECT UNIX_TIMESTAMP(NOW(3)) * 1000 AS current_timestamp_ms;

-- PostgreSQL
SELECT EXTRACT(EPOCH FROM NOW()) AS current_timestamp;
SELECT EXTRACT(EPOCH FROM NOW()) * 1000 AS current_timestamp_ms;

-- SQLite
SELECT STRFTIME('%s', 'now') AS current_timestamp;
SELECT STRFTIME('%s', 'now') * 1000 AS current_timestamp_ms;

-- SQL Server
SELECT DATEDIFF(SECOND, '1970-01-01', GETUTCDATE()) AS current_timestamp;
SELECT DATEDIFF(MILLISECOND, '1970-01-01', GETUTCDATE()) AS current_timestamp_ms;

Converter timestamp em data

SQL

-- MySQL
SELECT FROM_UNIXTIME(1609459200) AS datetime;
SELECT FROM_UNIXTIME(1609459200, '%Y-%m-%d %H:%i:%s') AS formatted_datetime;

-- PostgreSQL
SELECT TO_TIMESTAMP(1609459200) AS datetime;
SELECT TO_CHAR(TO_TIMESTAMP(1609459200), 'YYYY-MM-DD HH24:MI:SS') AS formatted_datetime;

-- SQLite
SELECT DATETIME(1609459200, 'unixepoch') AS datetime;
SELECT STRFTIME('%Y-%m-%d %H:%M:%S', 1609459200, 'unixepoch') AS formatted_datetime;

-- SQL Server
SELECT DATEADD(SECOND, 1609459200, '1970-01-01') AS datetime;

Converter data em timestamp

SQL

-- MySQL
SELECT UNIX_TIMESTAMP('2021-01-01 00:00:00') AS timestamp;

-- PostgreSQL
SELECT EXTRACT(EPOCH FROM TIMESTAMP '2021-01-01 00:00:00') AS timestamp;

-- SQLite
SELECT STRFTIME('%s', '2021-01-01 00:00:00') AS timestamp;

-- SQL Server
SELECT DATEDIFF(SECOND, '1970-01-01', '2021-01-01 00:00:00') AS timestamp;

Observação:

Diferentes sistemas de banco de dados têm funções variadas para lidar com timestamps.

Sempre considere as implicações de fuso horário ao trabalhar com timestamps em bancos de dados.

Obter timestamp atual

Excel

' Get current Unix timestamp (seconds)
=INT((NOW()-DATE(1970,1,1))*86400)

' Get current Unix timestamp (milliseconds)
=INT((NOW()-DATE(1970,1,1))*86400*1000)

' Get timestamp for date in cell A1
=INT((A1-DATE(1970,1,1))*86400)

' Account for timezone (subtract 8 hours for UTC+8)
=INT((NOW()-DATE(1970,1,1)-TIME(8,0,0))*86400)

Converter timestamp em data

Excel

' Converter Unix timestamp (seconds) to Excel date
' Assuming A1 contains the timestamp
=DATE(1970,1,1)+A1/86400

' Converter Unix timestamp (milliseconds) to Excel date
=DATE(1970,1,1)+A1/86400/1000

' Converter to local timezone (add 8 hours for UTC+8)
=DATE(1970,1,1)+A1/86400+TIME(8,0,0)

' Format as text
=TEXT(DATE(1970,1,1)+A1/86400,"yyyy-mm-dd hh:mm:ss")

VBA Functions

VBA

' Converter Unix timestamp to Excel date
Function UnixToExcelDate(UnixTimestamp As Long) As Date
    UnixToExcelDate = DateAdd("s", UnixTimestamp, DateSerial(1970, 1, 1))
End Function

' Converter Excel date to Unix timestamp
Function ExcelDateToUnix(ExcelDate As Date) As Long
    ExcelDateToUnix = DateDiff("s", DateSerial(1970, 1, 1), ExcelDate)
End Function

' Get current Unix timestamp
Function GetCurrentUnixTimestamp() As Long
    GetCurrentUnixTimestamp = DateDiff("s", DateSerial(1970, 1, 1), Now)
End Function

' Usage examples:
' =UnixToExcelDate(1609459200)
' =ExcelDateToUnix(NOW())
' =GetCurrentUnixTimestamp()

Observação:

Excel stores dates as serial numbers, with 1970-01-01 being day 25569 in the 1900 date system.

Always consider timezone conversions when working with timestamps in Excel.

VBA functions provide more flexibility for complex timestamp operations.

UnixEpoch

Tempo

Calculadora

Conversores

Idioma

Recursos para Desenvolvedores e Trechos de Código

Trechos de timestamp Unix por linguagem

Perguntas frequentes

Obter timestamp atual

Converter timestamp em data

Converter data em timestamp

Obter timestamp atual

Converter timestamp em data

Converter data em timestamp

Obter timestamp atual

Converter timestamp em data

Converter data em timestamp

Obter timestamp atual

Converter timestamp em data

Converter data em timestamp

Obter timestamp atual

Converter timestamp em data

Converter data em timestamp

Obter timestamp atual

Converter timestamp em data

Converter data em timestamp

Obter timestamp atual

Converter timestamp em data

Converter data em timestamp

Obter timestamp atual

Converter timestamp em data

Converter data em timestamp

Obter timestamp atual

Converter timestamp em data

VBA Functions