ForHosting KIT · Dates et temps

Intersection d’intervalles

Saisissez deux intervalles de temps et obtenez la partie qu'ils partagent : de 10:00 à 12:00 et de 11:00 à 13:00 UTC, le chevauchement va de 11:00 à 12:00, soit une heure. S'ils se touchent seulement, le résultat est vide. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Exemple résolu

Si vous saisissez

Début de l'intervalle A: 2020-01-01T10:00:00.000Z
Fin de l'intervalle A: 2020-01-01T12:00:00.000Z
Début de l'intervalle B: 2020-01-01T11:00:00.000Z
Fin de l'intervalle B: 2020-01-01T13:00:00.000Z

Vous obtenez

Début de l’intersection: 2020-01-01T11:00:00.000Z
Fin de l’intersection: 2020-01-01T12:00:00.000Z
Durée de l’intersection (millisecondes): 3 600 000
Durée de l’intersection (heures): 1

Calcule le chevauchement de deux intervalles ISO avec ordre strict, durée en millisecondes et heures. Gratuit, déterministe et privé dans le navigateur.

Ce que signifie le chevauchement de deux intervalles

Deux intervalles de temps se chevauchent lorsqu'une période appartient aux deux. Pensez à deux réservations de salle ou à deux fenêtres d'incident sur un tableau de bord de support : la question n'est pas la durée de chacun, mais la partie qu'ils ont en commun. La règle est courte. La partie commune commence au plus tardif des deux débuts et se termine à la plus précoce des deux fins. Si ce début précède strictement cette fin, il y a chevauchement et vous obtenez la période avec sa durée en millisecondes et en heures. Pour 10:00 à 12:00 et 11:00 à 13:00 UTC, le chevauchement va de 11:00 à 12:00, soit une heure exactement.

Les cas limites qui piègent

Deux intervalles qui se touchent seulement, comme l'un qui finit à 12:00 et l'autre qui commence à 12:00, ne partagent aucun temps, car la fin est considérée comme exclue ; le résultat est vide et les deux durées valent zéro. L'outil ne renvoie jamais l'union des deux intervalles, seulement leur partie commune. Chaque valeur est un horodatage complet au format ISO 8601 et le résultat est exprimé en UTC. Un intervalle dont la fin précède le début, ou une valeur manquante ou invalide, est refusé au lieu d'être traité comme un chevauchement vide.

Entrées, sorties et cas limites

Les quatre champs sont des chaînes obligatoires afin que la sonde de schéma puisse construire un échantillon complet à partir des exemples publiés. Des intervalles adjacents qui se touchent seulement en un point produisent un résultat vide car la comparaison est strictement inférieure, ce qui correspond aux agendas qui traitent la fin comme exclusive. Les fenêtres qui se chevauchent renvoient uniquement le segment partagé, jamais l'union.

Types incorrects, champs manquants et plages inversées échouent tôt pour que les clients ne voient pas de chevauchements nuls silencieux. Les exemples dorés couvrent un chevauchement d'une heure, une paire disjointe vide, une plage A inversée et une charge complètement absente pour des liaisons d'interface honnêtes.

Cas d’usage

Chevauchement de réunions

Trouvez la fenêtre partagée entre deux réservations avec des durées stables.

Tableaux de support

Mettez en évidence la coïncidence de deux fenêtres d'incident sans tableur.

Automatisation

Appelez la même fonction pure depuis des scripts qui fusionnent des calendriers.

Questions fréquentes

Est-ce gratuit ?

Oui. Tier A s'exécute entièrement dans le navigateur sans compte.

Appelle-t-il le réseau ?

Non. Le moteur parse garde tout sur l'appareil.

Les résultats sont-ils stables ?

Oui. Mathématiques déterministes et exemples dorés figent le contrat.

Comment le chevauchement de deux intervalles est-il calculé ?

La partie commune commence au plus tardif des deux débuts et se termine à la plus précoce des deux fins. Si ce début précède cette fin, les intervalles partagent du temps ; sinon, le résultat est vide et la durée vaut zéro.

Que se passe-t-il si un intervalle finit pile quand l'autre commence ?

Le résultat est vide. La fin de chaque intervalle est considérée comme exclue, comme dans la plupart des systèmes de réservation : deux intervalles qui se touchent en un seul instant ne partagent aucun temps.

Outils associés

Pour les développeurs — accès API

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

Endpoint

POSThttps://api.kit.forhosting.com/date/interval-intersection

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

Appeler depuis votre stack

curl -X POST https://api.kit.forhosting.com/date/interval-intersection \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"a_start":"2020-01-01T10:00:00.000Z","a_end":"2020-01-01T12:00:00.000Z","b_start":"2020-01-01T11:00:00.000Z","b_end":"2020-01-01T13:00:00.000Z"}'

const res = await fetch("https://api.kit.forhosting.com/date/interval-intersection", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "a_start": "2020-01-01T10:00:00.000Z",
    "a_end": "2020-01-01T12:00:00.000Z",
    "b_start": "2020-01-01T11:00:00.000Z",
    "b_end": "2020-01-01T13:00:00.000Z"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/date/interval-intersection",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "a_start": "2020-01-01T10:00:00.000Z",
    "a_end": "2020-01-01T12:00:00.000Z",
    "b_start": "2020-01-01T11:00:00.000Z",
    "b_end": "2020-01-01T13:00:00.000Z"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/date/interval-intersection", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"a_start":"2020-01-01T10:00:00.000Z","a_end":"2020-01-01T12:00:00.000Z","b_start":"2020-01-01T11:00:00.000Z","b_end":"2020-01-01T13:00:00.000Z"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"a_start":"2020-01-01T10:00:00.000Z","a_end":"2020-01-01T12:00:00.000Z","b_start":"2020-01-01T11:00:00.000Z","b_end":"2020-01-01T13:00:00.000Z"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/date/interval-intersection", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Exemple de requête

{
  "a_start": "2020-01-01T10:00:00.000Z",
  "a_end": "2020-01-01T12:00:00.000Z",
  "b_start": "2020-01-01T11:00:00.000Z",
  "b_end": "2020-01-01T13:00:00.000Z"
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "date.interval_intersection",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

Tarifs

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Erreurs

HTTP	Code	Signification
`401`	`unauthorized`	Clé API absente ou invalide : vérifiez l’en-tête Authorization.
`402`	`insufficient_balance`	Solde insuffisant : rechargez votre compte pour lancer cette tâche.
`404`	`unknown_type`	Type de tâche inconnu : vérifiez le champ type de votre requête.
`429`	`rate_limited`	Trop de requêtes : ralentissez la cadence, puis réessayez.

Notes techniques

Fonctionnement de l'intersection d'intervalles

Le début de l'intersection est le maximum des deux débuts et la fin le minimum des deux fins. Deux intervalles civils A et B sont définis par quatre horodatages ISO-8601 : a_start, a_end, b_start et b_end. Le moteur analyse chaque borne avec le parseur Date de l'environnement, refuse les valeurs non chaînes ou non analysables avec des messages invalid_input clairs qui nomment le champ, et exige que a_start soit strictement inférieur à a_end et b_start strictement inférieur à b_end. Lorsque le début est strictement inférieur à la fin le résultat n'est pas vide et porte start et end en chaînes ISO UTC plus duration_ms et duration_hours arrondies à une décimale stable ; sinon empty est vrai, start et end sont null et les deux champs de durée valent zéro.

Déterminisme, limites et intégration

L'implémentation est une logique pure de moteur parse sans réseau, horloge ni hasard au-delà des horodatages fournis, de sorte que des entrées identiques produisent toujours des sorties identiques. Des horodatages extrêmement lointains restent soumis à la précision milliseconde IEEE du type Date de la plateforme ; documentez ce contrat lors du stockage. Examinez le schéma publié avant de brancher des métriques et ne liez que les clés de succès documentées empty, start, end, duration_ms et duration_hours.

Questions techniques

Et si l'entrée est invalide ?

Vous recevez invalid_input avec un message clair en anglais.

Qui est l'auteur ?

Aspire dans l'atelier KIT de ForHosting.

Consulter la documentation complète du KIT →

Lancer gratuitement