ForHosting KIT · Mathématiques

Calculatrice ET logique

Vrai ET vrai donne vrai ; les trois autres combinaisons donnent faux. Combinez deux conditions, comme « a accepté les conditions » et « a confirmé son âge », et obtenez un résultat fiable, sans conversion cachée de valeurs qui ressemblent seulement à vrai ou faux. 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

La calculatrice ET logique prend exactement deux opérandes booléens et renvoie leur conjonction : true lorsque les deux opérandes sont true, et false dans tous les autres cas. C'est la plus petite brique de la logique booléenne, exposée comme un point d'accès strict et déterministe qui refuse tout ce qui n'est pas un vrai booléen — pas de chaînes truthy, pas de 1 ni de 0, aucune coercition silencieuse. Utilisez-la pour valider des paires de règles, tester des conditions d'accès ou enseigner la table de vérité avec un outil qui se comporte exactement comme la définition formelle.

Ce qu'est réellement une conjonction logique

La conjonction est l'opération binaire notée A ∧ B en logique et par l'opérateur && dans la plupart des langages de programmation. Sa table de vérité compte exactement quatre lignes : true AND true vaut true, et les trois autres combinaisons — true AND false, false AND true, false AND false — valent toutes false.

L'opération est commutative, associative et idempotente, ce qui signifie que A AND B est égal à B AND A, que les chaînes de AND peuvent être regroupées dans n'importe quel ordre et que A AND A vaut simplement A. Ce point d'accès implémente précisément cette définition sur deux opérandes, rien de plus. Délibérément, il n'évalue pas d'expressions, n'accepte pas trois opérandes et ne fait pas d'arithmétique bit à bit sur des entiers.

Si vous envoyez deux booléens authentiques, vous recevez la conjonction accompagnée d'un écho des deux opérandes, de sorte que la réponse se décrit elle-même et peut être journalisée ou conservée comme trace d'une décision. Tout dans le calcul est déterministe : les deux mêmes entrées produisent toujours la même sortie, à la périphérie du réseau, dans le navigateur ou dans vos propres tests.

Pourquoi la validation des entrées est stricte

La plupart des bogues autour de la logique booléenne viennent de la coercition, pas de la logique elle-même. La rigueur est la fonctionnalité. Quand un pipeline, un formulaire ou un moteur de règles envoie une valeur qui ressemble seulement à un booléen, vous voulez que l'appel échoue bruyamment à la frontière plutôt que de propager un true ou un false erroné vers une décision d'accès, une règle de tarification ou un contrôle d'éligibilité.

Les erreurs ne sont jamais facturées : une requête rejetée renvoie le code et le message d'erreur, et rien d'autre.

Où un ET à deux opérandes gagne sa place

Une seule conjonction semble triviale jusqu'à ce qu'on compte combien de fois les systèmes doivent l'évaluer de manière cohérente à plusieurs endroits. Les services de feature flags combinent un drapeau d'activation avec un drapeau d'éligibilité de l'utilisateur ; les validateurs de formulaires vérifient qu'une case est cochée et qu'un champ associé est confirmé ; les portails de surveillance ne se déclenchent que lorsque deux sondes indépendantes sont d'accord.

Faire passer ce contrôle par un point d'accès partagé unique — ou par la version navigateur gratuite du même code — garantit que chaque surface applique la même définition stricte du booléen, au lieu que chaque client invente ses propres règles de coercition.

Cas d’usage

Conditionner un feature flag à deux conditions

Combinez un drapeau d'activation global avec un drapeau d'éligibilité par compte et n'activez la fonctionnalité que lorsque les deux valent true.

Valider des confirmations appariées dans un formulaire

Vérifiez que l'utilisateur a accepté les conditions et confirmé son âge avant de laisser passer l'envoi.

Enseigner la table de vérité booléenne

Démontrez la conjonction en direct avec un outil qui applique la définition formelle et rejette les raccourcis non booléens.

Questions fréquentes

Combien ça coûte ?

Elle est aussi gratuite dans votre navigateur sur cette page, avec exactement le même code.

Que renvoie-t-elle ?

Un objet avec les deux opérandes reprises (a et b) et le champ result, qui vaut true seulement lorsque les deux opérandes valent true.

Puis-je chaîner plus de deux opérandes ?

Pas en un seul appel — la conjonction est associative, donc le ET de nombreuses valeurs n'est qu'un ET par paires répété. Appelez-la une fois par paire ou réduisez la liste dans votre propre code.

Mes opérandes sont-elles stockées ou journalisées ?

Non. Les valeurs sont évaluées en mémoire puis détruites ; seule la conjonction est renvoyée.

Puis-je saisir 1 et 0 à la place de vrai et faux ?

Non. Seules les vraies valeurs vrai ou faux sont acceptées. Un nombre, un texte comme le mot faux ou une valeur vide sont refusés avec un message qui indique laquelle pose problème, pour qu'un résultat erroné ne passe jamais inaperçu.

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/math/and

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/math/and \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"a":true,"b":false}'

const res = await fetch("https://api.kit.forhosting.com/math/and", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "a": true,
    "b": false
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/math/and",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "a": true,
    "b": false
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/and", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"a":true,"b":false}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"a":true,"b":false}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/and", 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": true,
  "b": false
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "math.and",
  "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

Pourquoi la validation des entrées est stricte

JavaScript considère la chaîne "false" comme truthy, de nombreuses API acceptent 1 et 0 comme ersatz de booléens, et un champ absent devient silencieusement undefined, qui est falsy — une implémentation naïve renvoie donc discrètement la mauvaise réponse au lieu de protester. Cette calculatrice et logique rejette tout cela : chaque opérande doit être le booléen JSON true ou false, et toute autre valeur — une chaîne, un nombre, null, un objet, un tableau ou un champ absent — échoue avec une erreur invalid_input claire qui nomme l'opérande fautif.

Où un ET à deux opérandes gagne sa place

Le même module qui alimente l'API tourne gratuitement sur cette page, si bien que les développeurs peuvent prototyper le comportement exact qu'ils automatiseront ensuite, et que les enseignants peuvent démontrer la table de vérité en direct. Quand vous l'automatiserez, l'appel coûtera $0.002 par requête, sans minimum et sans stockage de vos opérandes : les valeurs sont évaluées puis détruites, et seule la conjonction est renvoyée.

Questions techniques

Quelles valeurs sont acceptées comme opérandes ?

Uniquement les booléens JSON true et false. Les chaînes comme "true", les nombres comme 1 ou 0, null, les objets et les tableaux sont tous rejetés avec une erreur invalid_input.

Que se passe-t-il s'il manque un opérande ?

La requête échoue avec une erreur invalid_input qui nomme le champ manquant, et elle n'est pas facturée.

Consulter la documentation complète du KIT →

Lancer gratuitement

Ce qu'est réellement une conjonction logique

Pourquoi la validation des entrées est stricte

Où un ET à deux opérandes gagne sa place

Cas d’usage

Conditionner un feature flag à deux conditions

Valider des confirmations appariées dans un formulaire

Enseigner la table de vérité booléenne

Questions fréquentes

Outils associés

Pour les développeurs — accès API

Endpoint

Appeler depuis votre stack

Exemple de requête

Exemple de réponse

Tarifs

Erreurs

Notes techniques

Pourquoi la validation des entrées est stricte

Où un ET à deux opérandes gagne sa place

Questions techniques

merci