Convertor de timestamp Unix

Un instrument de conversie bidirecțională între timestamp Unix/Linux și data/oră, cu comparare bazată pe mai multe fusuri orare.

Timpul curent

Timestamp-ul curent (secunde)

1766507772

Timpul curent

2025-12-23 16:36:12

Fus orar global

Conversie timestamp → dată

Rezultatul conversiei(automat)

Timpul local

Timpul UTC

Timpul din fusul orar selectat

Conversie dată → timestamp

Rezultatul conversiei(automat)

Timestamp (secunde)

Timestamp (milisecunde)

Convertor de timestamp-uri și date multiple

Convertor de date și timestamp-uri multiple

Instrucțiuni de utilizare

Acest instrument este utilizat pentru a realiza rapid conversia bidirecțională între timestamp-ul Unix și data/ora în diferite scenarii. Acesta acceptă precizia în secunde și milisecunde și permite selectarea fusului orar țintă pentru afișarea comparativă. Acest instrument oferă un convertor pentru un singur card și unul pentru mai multe carduri. Conversia se efectuează imediat ce introduceți datele, iar rezultatele se actualizează automat atunci când schimbați fusul orar. De asemenea, sunt incluse intervale de timp recente și perioade de timp frecvent utilizate, pentru a satisface nevoile de dezvoltare, depanare și de conversie zilnică.

Detectare automată: Instrumentul va detecta automat dacă ați introdus un timestamp în secunde (10 cifre) sau în milisecunde (13 cifre).

Fus orar: Afișează ora locală și ora UTC, facilitând utilizarea în diferite fusuri orare.

Caracteristicile instrumentului

Conversie imediat ce introduceți datele, cu suport pentru detectarea automată a timestamp-urilor în secunde/milisecunde.
Suport pentru selectarea și afișarea fusurilor orare globale: trei vizualizări - local, UTC și fusul orar selectat.
Mai multe carduri convertor, pentru a facilita compararea în serie.
Interfață responsivă și prietenoasă cu tastatura, cu o bună accesibilitate.
Incluse intervale de timp recente și perioade de timp frecvent utilizate, gata de copiat și folosit.

Ce este un timestamp?

Timestamp-ul Unix (Unix Timestamp) reprezintă numărul total de secunde sau milisecunde trecute de la 00:00:00 UTC pe data de 1 ianuarie 1970 (Unix Epoch).

Un timestamp este un număr care reprezintă o dată și o oră, de obicei exprimat în secunde sau milisecunde.

Punctul de pornire al timestamp-ului este 00:00:00 UTC pe data de 1 ianuarie 1970, această dată fiind numită epoca Unix.

Timestamp-ul a fost inițial utilizat în sistemul de operare Unix, de aceea este adesea numit timestamp Unix.

Timestamp-urile sunt larg utilizate în programare și comunicarea pe rețea, în special în dezvoltarea web.

Precizii comune: secunde (de exemplu, 1735689600) și milisecunde (de exemplu, 1735689600000). Când se reprezintă datele și orele legate de fusul orar, este necesar să le formatați în funcție de fusul orar.

Timestamp-uri recente (pe baza fusului orar global)

Timestamp-uri uzuale (durate)

1 minut

60 Secunde

1 oră

3600 Secunde

1 zi

86400 Secunde

1 săptămână

604800 Secunde

1 lună (pe 30 de zile)

2592000 Secunde

1 an (pe 365 de zile)

31536000 Secunde

Problema anului 2038 pentru timestamp-uri

Problema anului 2038 se referă la problema de overflow a timpului Unix (stocat ca număr întreg cu semn pe 32 de biți, exprimat în secunde, începând de la 00:00:00 UTC, 1970-01-01) după 03:14:07 UTC, 19 ianuarie 2038.

Deoarece intervalul unui număr întreg cu semn pe 32 de biți este între -2.147.483.648 și 2.147.483.647, iar timestamp-ul pentru 03:14:07 UTC, 19 ianuarie 2038 este 2.147.483.647, după acest moment, un număr întreg cu semn pe 32 de biți nu va mai putea reprezenta timestamp-urile ulterioare.

Cele mai multe sisteme sau software - uri vechi care folosesc time_t pe 32 de biți sunt afectate de această problemă. Sistemele moderne folosesc de obicei 64 de biți (de exemplu, un număr întreg pe 64 de biți exprimat în milisecunde), astfel încât nu se confruntă cu această problemă.

Se recomandă folosirea unui timestamp pe 64 de biți sau a unei biblioteci de timp care suportă un interval mare de date.

Cum să obțineți / convertiți timestamp-uri prin limbaje de programare

JavaScript

Obține timestamp-ul curent

Math.floor(Date.now() / 1000); // seconds
Date.now(); // milliseconds

Timestamp → dată

new Date(1735689600 * 1000).toISOString();

Dată → timestamp

new Date('2025-01-01T00:00:00Z').getTime();

PHP

Obține timestamp-ul curent

time();                // seconds
intval(microtime(true) * 1000); // milliseconds

Timestamp → dată

date('Y-m-d H:i:s', 1735689600);

Dată → timestamp

strtotime('2025-01-01 00:00:00');

Python

Obține timestamp-ul curent

import time

int(time.time())        # seconds
int(time.time() * 1000) # milliseconds

Timestamp → dată

import datetime

datetime.datetime.utcfromtimestamp(1735689600).isoformat()

Dată → timestamp

import datetime

int(datetime.datetime(2025,1,1,0,0,0,tzinfo=datetime.timezone.utc).timestamp())

Obține timestamp-ul curent

import "time"

time.Now().Unix()      // seconds
time.Now().UnixMilli() // milliseconds

Timestamp → dată

import "time"

time.Unix(1735689600, 0).UTC().Format(time.RFC3339)

Dată → timestamp

import "time"

ts := time.Date(2025,1,1,0,0,0,0,time.UTC).Unix()

Rust

Obține timestamp-ul curent

use chrono::Utc;

let now = Utc::now();
let sec = now.timestamp();        // seconds i64
let ms  = now.timestamp_millis(); // milliseconds i128

Timestamp → dată

use chrono::{DateTime, NaiveDateTime, Utc};

let dt: DateTime = NaiveDateTime::from_timestamp_opt(1735689600, 0)
    .unwrap()
    .and_utc();
let iso = dt.to_rfc3339();

Dată → timestamp

use chrono::DateTime;

let ts = DateTime::parse_from_rfc3339("2025-01-01T00:00:00Z")
    .unwrap()
    .timestamp();

SQL

Obține timestamp-ul curent

-- MySQL / MariaDB
SELECT UNIX_TIMESTAMP();

-- PostgreSQL
SELECT EXTRACT(EPOCH FROM NOW())::bigint;

-- SQLite
SELECT strftime('%s', 'now');

Timestamp → dată

-- MySQL / MariaDB
SELECT FROM_UNIXTIME(1735689600);

-- PostgreSQL
SELECT to_timestamp(1735689600) AT TIME ZONE 'UTC';

-- SQLite
SELECT datetime(1735689600, 'unixepoch');

Dată → timestamp

-- MySQL / MariaDB
SELECT UNIX_TIMESTAMP('2025-01-01 00:00:00');

-- PostgreSQL
SELECT EXTRACT(EPOCH FROM TIMESTAMP '2025-01-01 00:00:00+00')::bigint;

-- SQLite
SELECT strftime('%s', '2025-01-01 00:00:00');