Unix Timestamp en secondes vs millisecondes : pourquoi la date affiche 1970

Vous avez converti un timestamp et vous tombez en janvier 1970. Ce n’est presque jamais une horloge cassée. Le nombre a été lu en millisecondes alors qu’il était en secondes—ou l’inverse.

Qu’est-ce qu’un Unix timestamp ?

Un Unix timestamp mesure le temps depuis l’epoch Unix : 1970-01-01 00:00:00 UTC. Il utilise souvent des secondes entières. Le même instant peut aussi être stocké en millisecondes (secondes × 1 000). Le nombre n’indique pas l’unité.

Secondes vs millisecondes : l’écart ×1 000

Une seconde vaut 1 000 millisecondes. Comparez 1720000000 et 1720000000000. Si le premier est en secondes et le second en millisecondes, c’est le même instant. Lisez le premier en millisecondes, et la date saute vers 1970.

Ces résultats UTC ont été calculés à partir des nombres ci-dessus, pas estimés.

Valeur	Unité probable	Interprétation (UTC)
1720000000	Secondes	Date moderne lue en secondes : 2024-07-03 09:46:40 UTC
1720000000000	Millisecondes	Le même instant lu en millisecondes : 2024-07-03 09:46:40 UTC
1720000000 en millisecondes	Mauvaise unité	Date vers 1970 : 1970-01-20 21:46:40 UTC

Pourquoi mon timestamp affiche-t-il 1970 ?

Si une valeur en secondes est traitée en millisecondes, le nombre est 1 000 fois trop petit. JavaScript ne compte alors qu’un court intervalle après l’epoch Unix, et la date reste en 1970 :

const seconds = 1720000000;

new Date(seconds);
// 1970-01-20 21:46:40 UTC

new Date(seconds * 1000);
// 2024-07-03 09:46:40 UTC

Cette date de 1970, c’est l’epoch plus deux semaines environ. Multipliez les secondes par 1 000 avant de les passer à Date.

• SECONDES
• 1720000000
• × 1000
• ↓
• MILLISECONDES
• 1720000000000

• Valeur en secondes
• ↓
• Traitée par erreur en millisecondes
• ↓
• Date vers 1970

10 chiffres = secondes et 13 chiffres = millisecondes ?

Pour les dates actuelles, 10 chiffres sont souvent des secondes et 13 des millisecondes. C’est un indice, pas une règle de validation. Le nombre de chiffres dépend de la plage temporelle, et certaines API stockent des microsecondes ou nanosecondes. Confirmez l’unité avec la documentation ou une date plausible.

Pourquoi cela arrive si souvent en JavaScript

En JavaScript, une valeur Date numérique est en millisecondes depuis l’epoch. Beaucoup de backends, bases et outils Unix stockent encore des secondes. Passer une valeur en secondes directement à Date est une erreur fréquente :

const unixSeconds = 1720000000;

const wrong = new Date(unixSeconds);
const correct = new Date(unixSeconds * 1000);

wrong tombe vers 1970 (1970-01-20 21:46:40 UTC). correct est l’instant moderne (2024-07-03 09:46:40 UTC).

D’autres systèmes utilisent d’autres unités

D’autres langages, API et bases peuvent utiliser secondes ou millisecondes. Certains stockent microsecondes ou nanosecondes. Ne supposez pas qu’un langage utilise toujours une unité : lisez la documentation. Si le nombre est dans du JSON, Formater et comparer du JSON rend le champ lisible ; il ne dira toujours pas l’unité.

Comment savoir quelle unité utilise mon timestamp ?

Suivez ces vérifications dans l’ordre. Le nombre de chiffres ne suffit pas.

1. Consultez la documentation de l’API ou de la base.
2. Regardez le nombre approximatif de chiffres.
3. Comparez la valeur à un timestamp moderne plausible.
4. Testez la valeur en secondes et en millisecondes.
5. Vérifiez si la date obtenue a du sens.

Si une interprétation tombe en 1970 et l’autre sur une date que vous reconnaissez, l’unité est en cause.

Erreurs fréquentes avec les Unix timestamp

• Secondes lues en millisecondes. La date s’effondre vers 1970, comme dans l’exemple.
• Millisecondes lues en secondes. La date saute très loin dans le futur, ou la conversion échoue.
• Multiplier deux fois par 1 000. Une valeur déjà en millisecondes devient énorme et la date avance de siècles.
• Diviser deux fois par 1 000. Une valeur en secondes rétrécit encore, de nouveau vers 1970.
• Accuser le fuseau horaire. Un fuseau peut décaler les heures ou le jour calendaire. Il ne transforme pas un timestamp moderne en 1970.
• Traiter une date formatée comme Unix timestamp. Une valeur comme 2024-07-03T09:46:40Z n’est pas un nombre epoch. Analysez-la comme une date, pas comme des secondes.

Le fuseau horaire cause-t-il le problème 1970 ?

En général, non. Un fuseau peut changer l’heure affichée et, près de minuit, la date du calendrier. Il ne transforme pas un Unix timestamp moderne en 1970. Si le résultat est 1970, vérifiez d’abord secondes contre millisecondes.

Convertir et vérifier un Unix timestamp

NEXNARA Convertisseur date et heure peut convertir un Unix timestamp dans le navigateur.

Collez des secondes ou millisecondes Unix, utilisez l’horodatage actuel, voyez UTC et l’heure locale, convertissez les fuseaux et formatez une date. La détection auto traite souvent 10 chiffres comme secondes et 13 comme millisecondes ; vous pouvez encore choisir l’unité.

La conversion se fait dans votre navigateur. Cet outil n’envoie pas dates ni timestamps à un serveur NEXNARA. Les publicités et autres fonctions du site utilisent encore le réseau ; c’est distinct de la conversion.

Besoin de vérifier un Unix timestamp ? Ouvrez Convertisseur date et heure et comparez secondes et millisecondes.

FAQ

Pourquoi mon Unix timestamp affiche-t-il 1970 ?

Ce sont souvent des secondes lues en millisecondes. JavaScript traite un nombre bien plus petit, la date tombe juste après 1970-01-01 00:00:00 UTC. Multipliez les secondes par 1 000 et reconvertissez.

Les Unix timestamp sont-ils en secondes ou en millisecondes ?

Ils utilisent souvent des secondes. Beaucoup d’API web et Date en JavaScript utilisent des millisecondes. Vérifiez la documentation. Certains systèmes utilisent microsecondes ou nanosecondes.

Comment convertir des secondes en millisecondes ?

Multipliez par 1 000. 1720000000 secondes font 1720000000000 millisecondes. Dans l’autre sens, divisez par 1 000.

Pourquoi Date en JavaScript utilise-t-il des millisecondes ?

Le timestamp numérique de Date en JavaScript est défini en millisecondes depuis l’epoch Unix. C’est pourquoi new Date(unixSeconds) est faux si unixSeconds est en secondes Unix.

Un timestamp à 10 chiffres est-il toujours en secondes ?

Non. Pour les dates actuelles, c’est souvent le cas, et 13 chiffres sont souvent des millisecondes. Le nombre de chiffres est un indice, pas une règle. Confirmez avec la documentation ou une date cohérente.

Un Unix timestamp contient-il un fuseau horaire ?

Non. Un Unix timestamp est un instant compté depuis 1970-01-01 00:00:00 UTC. Les fuseaux changent l’affichage, pas le nombre lui-même.