Vérificateur d'entiers
42 est un entier, 3.0 aussi puisqu'il vaut trois, et 3.0000001 ne l'est pas. Saisissez n'importe quelle valeur et obtenez un oui ou non strict ; un texte comme abc est refusé avec un message au lieu de passer pour un simple non. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Valeur
- 42
- Valeur
- 42
Vous envoyez une valeur sous forme de texte — "42", "-7.5", "1e3" — et recevez un true ou un false strict, accompagné du nombre analysé. Elle comprend les espaces, les signes, les décimaux et la notation scientifique, et refuse de deviner : tout ce qui n'est pas un nombre fini, comme "abc", "Infinity" ou une chaîne vide, est rejeté avec une erreur claire plutôt qu'un false silencieux.
Qu'est-ce qui compte comme nombre entier
Un entier est un nombre sans partie fractionnaire : 42, -17 et 0 sont des entiers ; 3.5 et -0.01 ne le sont pas. Le vérificateur d'entiers applique exactement cette définition mathématique via le test standard Number.isInteger, sans arrondi ni tolérance. Cela signifie que 3.0 — écrit avec un point décimal mais égal à un nombre entier — renvoie true, car sa valeur est trois, tandis que 3.0000001 renvoie false.
La notation scientifique est résolue d'abord, donc 1e3 est un entier (mille) et 1.5e-1 ne l'est pas (0.15). La vérification porte sur la valeur, pas sur la façon dont elle a été écrite : les zéros finaux après le point décimal, un signe plus initial et les espaces autour sont acceptés, car aucun ne change ce que le nombre est réellement.
Si votre application exige une rigueur au niveau de la chaîne — par exemple rejeter "3.0" tel que saisi — c'est une règle de formatage à ajouter par-dessus cette vérification numérique.
Pourquoi une entrée non finie est une erreur, pas un false
Il existe deux sortes d'échecs lors de la validation d'un nombre. La première est un nombre bien formé qui n'est simplement pas entier — c'est un false légitime. La seconde est une entrée qui n'est même pas un nombre fini : "hello", "Infinity", "NaN", "12px" ou une chaîne vide.
Fondre le second cas dans false masque des problèmes de qualité des données : un pipeline qui reçoit "Infinity" d'une division cassée en amont le traiterait silencieusement comme « non entier » et continuerait. Ce point de terminaison sépare délibérément les deux cas. Une entrée numérique valide renvoie toujours un booléen.
Notez aussi que l'analyseur est strict sur la correspondance de la chaîne entière : "42abc" est rejeté, jamais tronqué en 42 comme le feraient certains analyseurs laxistes.
Cas d’usage
Protéger des points de terminaison réservés aux entiers
Vérifiez les numéros de page, les compteurs et les identifiants à la périphérie de votre service pour que les entrées fractionnaires ou non finies échouent vite au lieu de corrompre la logique en aval.
Questions fréquentes
Combien ça coûte ?
C'est aussi gratuit dans votre navigateur sur cette page.
"3.0" est-il un nombre entier ?
Oui. La vérification porte sur la valeur numérique, pas sur la notation : 3.0 vaut 3, c'est donc un entier. Des formes comme "3.5" ou "1.5e-1" n'en sont pas.
Que se passe-t-il avec "Infinity" ou "abc" ?
Seule une entrée numérique bien formée renvoie true ou false.
La notation scientifique est-elle acceptée ?
Oui. "1e3" est interprété comme 1000 et renvoie true ; "1.5e-1" vaut 0.15 et renvoie false.
Arrondit-il ou tolère-t-il les quasi-entiers ?
Non. La vérification est exacte : 3.0000001 n'est pas un entier et renvoie false. L'arrondi est une décision séparée que votre application doit prendre explicitement.
Les nombres négatifs sont-ils pris en charge ?
Oui. -17 est un entier, -0.01 ne l'est pas. Un signe plus initial et des espaces autour sont également acceptés.
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
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/integer \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":"42"}'const res = await fetch("https://api.kit.forhosting.com/math/integer", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": "42"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/integer",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": "42"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/integer", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":"42"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":"42"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/integer", 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
{
"value": "42"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.integer",
"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
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
L'API de vérification d'entiers répond à une question trompeusement simple : cette valeur est-elle un nombre entier ? Utilisez-la pour valider des formulaires, des charges utiles d'API et des imports de données avant qu'une valeur fractionnaire ne se glisse dans un champ qui n'accepte que des nombres entiers.
Pourquoi une entrée non finie est une erreur, pas un false
Tout le reste renvoie une erreur invalid_input avec un message expliquant le problème, afin que votre code puisse s'arrêter, consigner la valeur fautive et échouer rapidement au lieu de propager des données corrompues.
Comment l'intégrer
La réponse contient le nombre analysé et le résultat booléen, de sorte qu'un seul appel valide et convertit à la fois. Envoyez la valeur dans le champ appelé value, toujours sous forme de texte ; les alias number, n et input sont acceptés par commodité. Une intégration typique valide la saisie de l'utilisateur avant d'écrire dans une colonne de base de données de type entier, filtre les lignes d'un import CSV où un identifiant doit être entier, ou protège un point de terminaison d'API qui accepte des quantités. Les très grandes magnitudes méritent réflexion : au-delà de 2^53, le format double précision ne peut pas représenter chaque entier distinctement, donc 9007199254740993 est indiscernable de ses voisins — c'est une propriété du format IEEE-754 partagée par tout système compatible JavaScript, pas de cette vérification. Le même code s'exécute gratuitement dans votre navigateur sur cette page pour des tests rapides, et l'API coûte $0.002 par requête lorsque vous l'automatisez à grande échelle.
Cas d'intégration
Valider des formulaires et des entrées d'API
Rejetez les quantités fractionnaires avant qu'elles n'atteignent une colonne de base de données de type entier, avec une erreur claire à montrer à l'utilisateur.
Filtrer des lignes lors d'un import de données
Séparez une colonne de valeurs mixtes en nombres entiers et non entiers pendant un import CSV ou JSON, et mettez en quarantaine les invalides.