Outil de conversion de timestamps Unix

Un outil professionnel de conversion de timestamps Unix permettant la conversion bidirectionnelle entre les timestamps et la date-heure, reconnaissant automatiquement les timestamps en secondes (9 à 10 chiffres), millisecondes (13), microsecondes (16) et nanosecondes (19) via leur nombre de chiffres. Il propose trois vues : heure locale, heure UTC et heure du fuseau horaire sélectionné, prend en charge plusieurs cartes de convertisseurs pour des comparaisons par lots, et inclut des plages horaires récentes intégrées ainsi que des durées courantes pour le développement, le débogage et les conversions quotidiennes. Interface réactive, conversion instantanée à la saisie, actualisation automatique des résultats lors du changement de fuseau horaire, toutes les opérations s'effectuent localement dans votre navigateur, garantissant confidentialité et sécurité.

Heure actuelle

Timestamp actuel (en secondes)

—

Heure actuelle

—

Fuseau horaire universel

Timestamp vers date

Prend en charge les timestamps en secondes, millisecondes, microsecondes et nanosecondes, détection automatique par le nombre de chiffres (9 à 10 chiffres pour les secondes, 13 pour les ms, 16 pour les μs, 19 pour les ns)

Résultat de conversion(Automatique)

Heure locale

Heure UTC

Heure du fuseau horaire sélectionné

Date vers timestamp

Résultat de conversion(Automatique)

Timestamp (en secondes)

Timestamp (en millisecondes)

Convertisseur de timestamps multiples vers date-heure

Convertisseur de dates multiples vers timestamps

Mode d'emploi

Cet outil permet de convertir rapidement des horodatages Unix en dates-heures et vice versa dans différents scénarios. Il prend en charge la précision en secondes et en millisecondes, et vous permet de sélectionner le fuseau horaire cible pour l'affichage comparatif. Il propose des convertisseurs à une ou plusieurs cartes. La conversion s'effectue au fur et à mesure de saisie, et les résultats sont actualisés automatiquement lors du changement de fuseau horaire. Il inclut également des plages horaires récentes et des durées courantes pour répondre aux besoins du débogage de développement et des conversions quotidiennes.

Détection automatique : L'outil détecte automatiquement la précision selon le nombre de chiffres : secondes (9 à 10 chiffres), millisecondes (13), microsecondes (16) et nanosecondes (19) — aucune sélection manuelle d'unité n'est nécessaire.

Fuseau horaire : Il affiche l'heure locale et l'heure UTC, pratique pour une utilisation dans différents fuseaux horaires.

Fonctionnalités de l'outil

Conversion au fur et à mesure de la saisie, avec reconnaissance automatique des horodatages en secondes / millisecondes / microsecondes / nanosecondes.
Prend en charge la sélection et l'affichage de fuseaux horaires mondiaux : trois vues (locale, UTC et fuseau horaire sélectionné).
Plusieurs cartes de convertisseurs pour faciliter la comparaison par lots.
Interface adaptative et ergonomique au clavier, avec une bonne accessibilité.
Plages horaires récentes et durées courantes intégrées, à copier et utiliser.

Qu'est-ce qu'un timestamp ?

Un horodatage Unix correspond au nombre total de secondes ou de millisecondes écoulées depuis le 1er janvier 1970 à 00:00:00 UTC (Époque Unix).

Un horodatage est un nombre représentant une date-heure, généralement exprimé en secondes ou en millisecondes.

Le point de départ d'un horodatage est le 1er janvier 1970 à 00:00:00 UTC, c'est ce que l'on appelle l'Époque Unix.

Les horodatages étaient à l'origine utilisés sur les systèmes d'exploitation Unix, c'est pourquoi on les appelle souvent horodatages Unix.

Les horodatages sont largement utilisés dans la programmation et la communication réseau, en particulier dans le développement web.

Précisions courantes : secondes (ex. : 1735689600) et millisecondes (ex. : 1735689600000). Lorsqu'il s'agit de dates-heures liées à des fuseaux horaires, elles doivent être formatées et affichées en fonction du fuseau horaire.

Timestamps récents (basés sur le fuseau horaire universel)

Timestamps courants (durées)

1 minute

60 Secondes

1 heure

3600 Secondes

1 jour

86400 Secondes

1 semaine

604800 Secondes

1 mois (30 jours)

2592000 Secondes

1 année (365 jours)

31536000 Secondes

Le problème de l'année 2038 des timestamps

Le problème de l'année 2038 concerne le dépassement de capacité d'un entier signé sur 32 bits qui stocke un horodatage Unix (en secondes depuis le 1er janvier 1970 à 00:00:00 UTC) après le 19 janvier 2038 à 03:14:07 UTC.

Étant donné que la plage d'un entier signé sur 32 bits va de -2 147 483 648 à 2 147 483 647, et que l'horodatage du 19 janvier 2038 à 03:14:07 UTC est 2 147 483 647, un entier signé sur 32 bits ne pourra plus représenter les horodatages postérieurs à cette date.

Ce problème affecte principalement les systèmes ou logiciels anciens qui utilisent un time_t sur 32 bits. Les systèmes modernes utilisent généralement des entiers sur 64 bits (par exemple, des millisecondes sur un entier 64 bits) et ne rencontrent pas ce problème.

Il est recommandé d'utiliser des horodatages sur 64 bits ou une bibliothèque de gestion du temps qui prend en charge une large plage de dates.

Comment obtenir/convertir des timestamps via des langages de programmation

JavaScript

Obtenir le timestamp actuel

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

Timestamp → Date

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

Date → Timestamp

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

PHP

Obtenir le timestamp actuel

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

Timestamp → Date

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

Date → Timestamp

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

Python

Obtenir le timestamp actuel

import time

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

Timestamp → Date

import datetime

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

Date → Timestamp

import datetime

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

Obtenir le timestamp actuel

import "time"

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

Timestamp → Date

import "time"

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

Date → Timestamp

import "time"

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

Rust

Obtenir le timestamp actuel

use chrono::Utc;

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

Timestamp → Date

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

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

Date → Timestamp

use chrono::DateTime;

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

SQL

Obtenir le timestamp actuel

-- MySQL / MariaDB
SELECT UNIX_TIMESTAMP();

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

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

Timestamp → Date

-- MySQL / MariaDB
SELECT FROM_UNIXTIME(1735689600);

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

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

Date → 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');