Atelier Temps Epoch

Suivez l'heure Epoch Unix en direct, générez des timestamps depuis A/M/J/H/M/S, inspectez les bornes de périodes et calculez les deltas de durée localement.

Aucun téléversementSans inscriptionRésultats instantanés
Jour / Semaine / Mois / AnnéeCalculateur de delta EpochSQL, JS, Python, Go & Bash
Ouvrir l'atelier Epoch
Moteur hors ligne prêtEspace 100% privé dans le navigateur • Aucun transfert cloud
100 % Privé • Aucun fichier envoyé sur un serveur

Pourquoi utiliser Atelier Temps Epoch gratuitement sur Utiliome ?

Conçu pour garantir une confidentialité stricte, sans inscription ni abonnement requis.

Horloge en Direct et Constructeur de Dates A/M/J/H/M/S

Surveillez une horloge Epoch Unix temps réel avec mise en pause en secondes et millisecondes tout en construisant des entiers Epoch exacts à partir des champs année, mois, jour, heure, minute et seconde en UTC ou dans tout fuseau horaire IANA.

Tables de Bornes par Jour, Semaine, Mois et Année

Générez les timestamps Epoch de début et de fin de période pour la date active en UTC et dans les fuseaux IANA, prêts à être collés dans des clauses SQL WHERE, des requêtes Prometheus ou des filtres analytiques.

Calculateur de Durée Delta entre Deux Timestamps

Calculez le temps écoulé signé et absolu entre deux entiers Epoch quelconques, avec décomposition en jours, heures, minutes, secondes, millisecondes et chaînes de durée ISO-8601 canoniques (PnDTnHnMnS).

Extraits de Code Multilangages Prêts à Copier

Copiez des extraits de code idiomatiques pour obtenir l'Epoch actuel et convertir des timestamps en JavaScript, Python, Go, Rust, PostgreSQL/MySQL et Bash, entièrement calculés localement dans votre navigateur sans aucune requête réseau.

Utiliome vs alternatives cloud traditionnelles

Comparez notre moteur local WebAssembly aux outils cloud anciens.

Fonctionnalité Utiliome (Navigateur local) Convertisseurs cloud anciens
Horloge en Direct et Constructeur de Dates A/M/J/H/M/S Surveillez une horloge Epoch Unix temps réel avec mise en pause en secondes et millisecondes tout en construisant des entiers Epoch exacts à partir des champs année, mois, jour, heure, minute et seconde en UTC ou dans tout fuseau horaire IANA. Options limitées sans personnalisation avancée
Tables de Bornes par Jour, Semaine, Mois et Année Générez les timestamps Epoch de début et de fin de période pour la date active en UTC et dans les fuseaux IANA, prêts à être collés dans des clauses SQL WHERE, des requêtes Prometheus ou des filtres analytiques. Nécessite des outils externes ou un traitement manuel
Confidentialité et Traitement 100 % local dans le navigateur (zéro envoi serveur) Envoie les données vers des serveurs cloud tiers
Tarif et Inscription 100 % gratuit à vie, sans compte ni filigrane Inscription obligatoire ou abonnement payant
Comment ça marche

Comment utiliser Atelier Temps Epoch en 3 étapes simples

Aucune installation requise. Tout s'exécute directement dans votre navigateur web.

1

Capturez l'Heure en Direct ou Construisez via A/M/J/H/M/S

Figez l'horloge Epoch Unix à l'instant présent, saisissez des valeurs distinctes d'année, mois, jour, heure, minute et seconde, ou chargez un entier Epoch de référence en UTC ou dans un fuseau horaire IANA.

2

Inspectez les Bornes de Périodes et Calculez les Deltas

Consultez les entiers Epoch de début et de fin pour le jour, la semaine ISO, le mois et l'année correspondants, ou fournissez un second timestamp pour calculer la durée exacte écoulée.

3

Copiez les Plages de Requêtes ou les Extraits de Code

Copiez les entiers de bornes en secondes ou millisecondes directement dans vos filtres SQL ou d'observabilité, ou récupérez des extraits Epoch prêts à l'emploi pour JavaScript, Python, Go, Rust, SQL et Bash.

Construction de Plages Epoch, Bornes de Dates et Deltas de Durée

Réponse rapide: Assemblez un entier Epoch Unix à partir de champs A/M/J/H/M/S distincts en UTC ou dans un fuseau horaire IANA pour obtenir immédiatement les bornes de début et de fin de jour, de semaine ISO, de mois et d'année, ainsi que les deltas de durée entre deux timestamps et des extraits de code prêts à copier.

Lors de l'écriture de migrations de bases de données, de la planification de tâches cron ou du bornage de requêtes d'observabilité, vous partez rarement d'un entier brut à 10 chiffres : vous partez d'une date calendaire, d'un fuseau horaire et d'une fenêtre de reporting. En saisissant 2026-07-15 14:30:00 en UTC dans le Constructeur A/M/J/H/M/S, l'outil résout l'instant cible et génère la table complète des bornes englobantes en secondes et millisecondes :

{
  "builtInput": "2026-07-15 14:30:00 (UTC)",
  "epochSeconds": 1784125800,
  "epochMilliseconds": 1784125800000,
  "boundariesUtc": {
    "day": {
      "start": 1784073600,
      "end": 1784159999,
      "rangeIso": "2026-07-15T00:00:00Z .. 2026-07-15T23:59:59Z"
    },
    "isoWeek": {
      "week": "2026-W29",
      "start": 1783900800,
      "end": 1784505599,
      "rangeIso": "2026-07-13T00:00:00Z .. 2026-07-19T23:59:59Z"
    },
    "month": {
      "start": 1782864000,
      "end": 1785542399,
      "rangeIso": "2026-07-01T00:00:00Z .. 2026-07-31T23:59:59Z"
    },
    "year": {
      "start": 1767225600,
      "end": 1798761599,
      "rangeIso": "2026-01-01T00:00:00Z .. 2026-12-31T23:59:59Z"
    }
  }
}

Pour mesurer le MTTR d'un incident, des fenêtres SLA ou la durée de vie (TTL) de jetons, saisissez deux timestamps dans le Calculateur de Delta et copiez les expressions de l'Epoch actuel depuis la Bibliothèque d'Extraits de Code :

# Calcul de Delta entre Deux Timestamps
Timestamp A (Début) : 1784125800 (2026-07-15T14:30:00Z)
Timestamp B (Fin) :   1784310325 (2026-07-17T17:45:25Z)
Delta Signé :         +184525 s (+184525000 ms)
Décomposition :       2 jours, 3 heures, 15 minutes, 25 secondes (51h 15m 25s)
Durée ISO-8601 :      P2DT3H15M25S

# Extraits Prêts à Copier pour l'Epoch Unix Actuel
JavaScript (s / ms) : Math.floor(Date.now() / 1000)  |  Date.now()
Python 3 (s / ns) :   int(time.time())               |  time.time_ns()
Go (s / ns) :         time.Now().Unix()              |  time.Now().UnixNano()
Rust (std) :          SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs()
PostgreSQL / MySQL :  SELECT EXTRACT(EPOCH FROM NOW())::bigint;  |  SELECT UNIX_TIMESTAMP();
Bash (GNU / macOS) :  date +%s  |  date -u -d @1784125800  |  date -u -r 1784125800

Arithmétique Calendrier vers Epoch, Transitions d'Heure d'Été et Requêtes de Plages

Réponse rapide: La correspondance entre les champs civils A/M/J/H/M/S, les bornes de périodes calendaires et les entiers Epoch Unix repose sur l'arithmétique du calendrier grégorien proleptique, des prédicats SQL semi-ouverts [début, débutSuivant) qui préservent les fractions de la dernière seconde, et la résolution des sauts et doublons liés aux changements d'heure (DST) IANA.

Arithmétique du Calendrier Grégorien Proleptique vers Epoch

La conversion de champs civils distincts (Y, M, D, H, Min, S) en UTC vers un entier Epoch Unix compte le nombre exact de jours écoulés depuis le 1970-01-01 selon le cycle bissextile grégorien de 400 ans (les années divisibles par 4 sont des années bissextiles de 366 jours, à l'exception des années séculaires non divisibles par 400 — faisant de 2000 une année bissextile tandis que 2100 compte 365 jours) et multiplie ce total par 86 400 :

epoch_utc = days_from_civil(Y, M, D) * 86400 + H * 3600 + Min * 60 + S

Lorsque les champs saisis représentent l'heure locale dans un fuseau horaire IANA plutôt qu'en UTC, le décalage UTC dépend lui-même de la date cible, car les régions modifient leurs décalages standards et leurs règles d'heure d'été (DST) au fil du temps.

Bornes Fermées `23:59:59` vs Intervalles de Requêtes Semi-Ouverts `[début, débutSuivant)`

Les tables de bornes affichent généralement la dernière seconde entière incluse d'une journée UTC (par exemple 1784159999 pour 2026-07-15T23:59:59Z) ainsi que son équivalent en millisecondes (1784159999999 pour 23:59:59.999Z). Dans les bases de données de production stockant des colonnes en millisecondes, microsecondes ou TIMESTAMPTZ, un filtrage avec WHERE created_at BETWEEN 1784073600 AND 1784159999 ignore silencieusement les événements enregistrés durant les 999 dernières millisecondes de la journée (comme 23:59:59.450Z).

Pour éliminer ces fuites de bornes inférieures à la seconde sans coupler votre requête à la résolution de la colonne, privilégiez des prédicats semi-ouverts ancrés sur le début 00:00:00 de la période suivante (1784160000, soit 1784159999 + 1) :

-- Intervalle semi-ouvert (capture toutes les fractions de seconde jusqu'à 23:59:59.999999...)
WHERE epoch_sec >= 1784073600 AND epoch_sec < 1784160000
WHERE epoch_ms  >= 1784073600000 AND epoch_ms < 1784160000000

Sauts, Doublons d'Heure d'Été (DST) et Journées Locales Différentes de 86 400 Secondes

Ne calculez jamais les bornes d'une journée locale en ajoutant 86400 à minuit local. Dans les fuseaux IANA appliquant le changement d'heure (tels que America/New_York ou Europe/Paris), deux jours calendaires par an ne durent pas 86 400 secondes :

  • Saut du passage à l'heure d'été (journée de 23 heures = 82 800 secondes) : Lorsque les horloges passent directement de 01:59:59 à 03:00:00, les heures locales telles que 02:30:00 n'existent pas à cette date calendaire.
  • Doublon du retour à l'heure d'hiver (journée de 25 heures = 90 000 secondes) : Lorsque les horloges répètent la plage de 02:00:00 à 02:59:59 (ou de 01:00:00 à 01:59:59 selon la zone), une heure locale correspond à deux entiers Epoch Unix distincts séparés par 3 600 secondes (d'abord sous le décalage d'été, puis sous le décalage d'hiver).

La résolution du 00:00:00 de chaque borne via la base de données des fuseaux horaires IANA garantit l'exactitude des Epochs de début de journée et de début de mois lors des transitions d'heure d'été.

Epochs d'Horloge Murale vs Compteurs de Durée Monotones

Les appels d'exécution tels que Date.now(), time.time(), time.Now().Unix() et SystemTime::now() lisent l'horloge système (CLOCK_REALTIME), essentielle pour sérialiser des timestamps et corréler des événements entre machines, mais susceptible de reculer ou d'être ajustée lors d'une synchronisation NTP. Utilisez les deltas Epoch Unix pour les timestamps historiques persistés, et associez-les à des horloges monotones (performance.now(), time.monotonic_ns(), std::time::Instant) lorsque vous mesurez la latence interne d'un processus.

Atelier Temps Epoch vs Convertisseur Timestamp Unix : Lequel Choisir ?

Réponse rapide: Utilisez l'Atelier Temps Epoch pour suivre l'horloge Unix en direct, assembler des timestamps à partir de champs A/M/J/H/M/S, obtenir les tables de bornes jour/semaine/mois/année, calculer des deltas entre deux timestamps ou copier des extraits de code. Utilisez le Convertisseur Timestamp Unix pour décoder à l'unité ou en lot des entiers en s, ms, µs et ns ainsi que des chaînes ISO-8601 ou RFC 3339.

Les deux outils Utiliome s'exécutent à 100 % localement dans votre navigateur, séparant clairement la construction interactive d'Epochs et la planification de plages du décodage de précision et de la conversion de journaux en lot. Restez dans l'Atelier Temps Epoch lorsque vous construisez des bornes de requêtes, suivez l'horloge Unix en direct, calculez des deltas de durée ou copiez des extraits de code. Passez à l'outil complémentaire Convertisseur Timestamp Unix lorsque vous devez décoder des timestamps bruts à 10, 13, 16 ou 19 chiffres ou des extraits de logs multilignes.

Fonctionnalité Atelier Temps Epoch Convertisseur Timestamp Unix
Flux de Travail Principal Horloge en direct, constructeur A/M/J/H/M/S, bornes de périodes, deltas et extraits de code Décodage bidirectionnel en lot de timestamps s/ms/µs/ns et formats ISO-8601/RFC 3339
Horloge Epoch Unix en Direct Oui — compteur temps réel en secondes et millisecondes avec gel/capture Non inclus — axé sur la conversion déterministe de charges utiles
Constructeur de Champs A/M/J/H/M/S Saisie interactive de champs calendaires en UTC ou dans tout fuseau IANA Analyse directement les chaînes ISO-8601, RFC 3339 et RFC 2822 collées
Tables Jour / Semaine / Mois / Année Précalcule les entiers Epoch de début et de fin pour les quatre périodes Non inclus
Calculateur de Delta à Deux Timestamps Décomposition complète T2 - T1 (j/h/m/s/ms et ISO-8601 PnDTnHnMnS) Décalage relatif par rapport à l'horloge système actuelle uniquement
BigInt µs (16 chiffres) et ns (19 chiffres) Axé sur les secondes (10 chiffres) et les millisecondes (13 chiffres) Détection automatique BigInt 64 bits complète pour s, ms, µs et ns (19 chiffres)
Conversion en Lot Multiligne Date de référence unique + paire de timestamps pour calcul de delta Oui — convertit des centaines de timestamps séparés par des sauts de ligne en une passe

Vous inspectez des traces OpenTelemetry en nanosecondes à 19 chiffres, des valeurs PostgreSQL en microsecondes à 16 chiffres ou un export de logs contenant des timestamps mixtes ? Ouvrez le Convertisseur Timestamp Unix.

FAQ

FAQ et guide technique sur Atelier Temps Epoch

Tout ce qu'il faut savoir sur l'utilisation en ligne gratuite de convertisseur temps epoch.

Pourquoi les requêtes SQL et séries temporelles doivent-elles utiliser des bornes Epoch semi-ouvertes plutôt que 23:59:59 ?

Une borne supérieure inclusive se terminant à 23:59:59 (telle que 1784159999) omet tout enregistrement comportant des fractions de millisecondes ou de microsecondes comprises entre 23:59:59.001 et 23:59:59.999. L'écriture d'un prédicat semi-ouvert ancré sur le début 00:00:00 de la période suivante (ts >= 1784073600 AND ts < 1784160000 en secondes, ou ts >= 1784073600000 AND ts < 1784160000000 en millisecondes) capture l'intégralité de la journée quelle que soit la précision inférieure à la seconde.

Pourquoi une journée calendaire locale ne dure-t-elle pas toujours 86 400 secondes Epoch ?

Une journée UTC dure toujours exactement 86 400 secondes POSIX, mais un fuseau horaire IANA appliquant l'heure d'été connaît une journée de 23 heures (82 800 secondes) lors de l'avancement des horloges au printemps et une journée de 25 heures (90 000 secondes) lors du recul des horloges à l'automne. Comme l'ajout de 86 400 à minuit local décale les bornes d'une heure lors des transitions d'heure d'été, la table des bornes résout chaque instant local 00:00:00 via la base de données des fuseaux horaires IANA.

Comment le constructeur A/M/J/H/M/S gère-t-il les heures d'été ambiguës ou inexistantes ?

Lors du passage à l'heure d'été (par exemple le saut de 02:00 à 03:00 dans America/New_York ou Europe/Paris), les minutes de l'heure sautée n'existent pas et avancent au-delà de l'intervalle manquant. Lors du retour à l'heure standard, l'heure répétée se produit deux fois — à 3 600 secondes d'intervalle — d'abord sous le décalage d'heure d'été, puis sous le décalage standard. Pour les tâches cron et les arrêtés de facturation exigeant une monotonie stricte, définissez toujours vos bornes en UTC.

Comment les bornes de semaines ISO-8601 sont-elles définies dans la table des bornes ?

Selon la norme ISO-8601, chaque semaine commence le lundi à 00:00:00 et se termine le dimanche à 23:59:59.999. La semaine ISO 1 (W01) d'une année est définie comme la semaine du lundi au dimanche contenant le premier jeudi de l'année (soit de manière équivalente la semaine contenant le 4 janvier), ce qui signifie que W01 peut commencer le 29, le 30 ou le 31 décembre de l'année civile précédente.

Pourquoi les commandes Bash sous GNU Linux et macOS utilisent-elles des options différentes pour formater un entier Epoch ?

La commande date de GNU coreutils sous Linux analyse un entier Epoch Unix à l'aide du préfixe -d @TIMESTAMP (date -u -d @1784125800 +%Y-%m-%dT%H:%M:%SZ), tandis que la commande date BSD sous macOS et FreeBSD utilise l'option -r TIMESTAMP (date -u -r 1784125800 +%Y-%m-%dT%H:%M:%SZ). Les deux plateformes prennent en charge date +%s de manière identique pour afficher l'Epoch Unix actuel en secondes.