Verifica numeri interi
42 è un intero, 3.0 anche perché vale tre, e 3.0000001 no. Inserisca qualsiasi valore e ottenga un sì o un no rigoroso; un testo come abc viene rifiutato con un avviso invece di passare per un semplice no. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Valore
- 42
- Valore
- 42
Lei invia un valore come testo — "42", "-7.5", "1e3" — e riceve un true o un false rigoroso, insieme al numero analizzato. Comprende spazi, segni, decimali e notazione scientifica, e si rifiuta di indovinare: qualsiasi cosa non sia un numero finito, come "abc", "Infinity" o una stringa vuota, viene rifiutata con un errore chiaro invece di un false silenzioso.
Cosa conta come numero intero
Un intero è un numero senza parte frazionaria: 42, -17 e 0 sono interi; 3.5 e -0.01 non lo sono. Il verificatore di interi applica esattamente questa definizione matematica tramite il test standard Number.isInteger, senza arrotondamenti né tolleranze. Questo significa che 3.0 — scritto con il punto decimale ma uguale a un numero intero — restituisce true, perché il suo valore è tre, mentre 3.0000001 restituisce false.
La notazione scientifica viene risolta prima, quindi 1e3 è un intero (mille) e 1.5e-1 non lo è (0.15). La verifica riguarda il valore, non il modo in cui è stato scritto: gli zeri finali dopo il punto decimale, un segno più iniziale e gli spazi intorno sono accettati, perché nessuno di essi cambia ciò che il numero realmente è. Se la Sua applicazione richiede rigore a livello di stringa — per esempio rifiutare "3.0" così come digitato — quella è una regola di formattazione da aggiungere sopra questa verifica numerica.
Perché l'input non finito è un errore, non un false
Esistono due tipi di fallimento nella validazione di un numero. Il primo è un numero ben formato che semplicemente non è intero: è un false legittimo. Il secondo è un input che non è affatto un numero finito: "hello", "Infinity", "NaN", "12px" o una stringa vuota.
Ridurre il secondo caso a false nasconde problemi di qualità dei dati: una pipeline che riceve "Infinity" da una divisione rotta a monte lo tratterebbe silenziosamente come "non intero" e proseguirebbe. Un input numerico valido restituisce sempre un booleano. Noti anche che il parser è rigoroso sulla corrispondenza dell'intera stringa: "42abc" viene rifiutato, mai troncato a 42 come farebbero alcuni parser permissivi.
Domande frequenti
Quanto costa?
È anche gratis eseguirlo nel Suo browser su questa pagina.
"3.0" è un numero intero?
Sì. La verifica riguarda il valore numerico, non la notazione: 3.0 equivale a 3, quindi è un intero. Forme come "3.5" o "1.5e-1" non lo sono.
Cosa succede con "Infinity" o "abc"?
Solo input numerici ben formati restituiscono true o false.
Accetta la notazione scientifica?
Sì. "1e3" viene interpretato come 1000 e restituisce true; "1.5e-1" è 0.15 e restituisce false.
Arrotonda o tollera i quasi-interi?
No. La verifica è esatta: 3.0000001 non è un intero e restituisce false. L'arrotondamento è una decisione separata che la Sua applicazione deve prendere esplicitamente.
I numeri negativi sono supportati?
Sì. -17 è un intero, -0.01 no. Sono accettati anche un segno più iniziale e spazi intorno.
Strumenti correlati
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo 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)Esempio di richiesta
{
"value": "42"
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.integer",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |
Note tecniche
L'API di verifica degli interi risponde a una domanda ingannevolmente semplice: questo valore è un numero intero? La usi per validare moduli, payload di API e importazioni di dati prima che un valore frazionario finisca in un campo che accetta solo numeri interi.
Perché l'input non finito è un errore, non un false
Questo endpoint separa deliberatamente i due casi. Qualsiasi altra cosa restituisce un errore invalid_input con un messaggio che spiega cosa non andava, così il Suo codice può fermarsi, registrare il valore incriminato e fallire subito invece di propagare spazzatura.
Come integrarlo
La risposta contiene il numero analizzato e il risultato booleano, quindi una sola chiamata valida e converte insieme. Invii il valore nel campo chiamato value, sempre come testo; gli alias number, n e input sono accettati per comodità. Un'integrazione tipica valida l'input dell'utente prima di scrivere in una colonna di database di tipo intero, filtra le righe in un'importazione CSV in cui un ID deve essere intero, oppure protegge un endpoint API che accetta quantità. Le magnitudini molto grandi meritano un pensiero: oltre 2^53 il formato a doppia precisione non può rappresentare ogni intero in modo distinto, quindi 9007199254740993 è indistinguibile dai suoi vicini — è una proprietà del formato IEEE-754 condivisa da ogni sistema compatibile con JavaScript, non di questa verifica. Lo stesso codice gira gratis nel Suo browser su questa pagina per prove rapide, e l'API costa $0.002 per richiesta quando la automatizza su larga scala.
Casi di integrazione
Validare moduli e input di API
Rifiuti le quantità frazionarie prima che raggiungano una colonna di database di tipo intero, con un errore chiaro da mostrare all'utente.
Filtrare righe in un'importazione di dati
Separi una colonna di valori misti in numeri interi e non interi durante un'importazione CSV o JSON, e metta in quarantena quelli non validi.
Proteggere endpoint riservati agli interi
Verifichi numeri di pagina, conteggi e ID al confine del Suo servizio, così che input frazionari o non finiti falliscano subito invece di corrompere la logica a valle.