Due risposte per te:
Basato sull'analisi
Espressione regolare
Si noti che in entrambi i casi ho interpretato "numero intero positivo" da includere 0, anche se 0non è positivo. Includo note se si desidera non consentire0 .
Basato sull'analisi
Se vuoi che sia una stringa intera decimale normalizzata su un intervallo ragionevole di valori, puoi farlo:
function isNormalInteger(str) {
var n = Math.floor(Number(str));
return n !== Infinity && String(n) === str && n >= 0;
}
o se si desidera consentire spazi bianchi e zeri iniziali:
function isNormalInteger(str) {
str = str.trim();
if (!str) {
return false;
}
str = str.replace(/^0+/, "") || "0";
var n = Math.floor(Number(str));
return n !== Infinity && String(n) === str && n >= 0;
}
Testbed live (senza gestire zeri iniziali o spazi bianchi):
function isNormalInteger(str) {
var n = Math.floor(Number(str));
return n !== Infinity && String(n) === str && n >= 0;
}
function gid(id) {
return document.getElementById(id);
}
function test(str, expect) {
var result = isNormalInteger(str);
console.log(
str + ": " +
(result ? "Yes" : "No") +
(expect === undefined ? "" : !!expect === !!result ? " <= OK" : " <= ERROR ***")
);
}
gid("btn").addEventListener(
"click",
function() {
test(gid("text").value);
},
false
);
test("1", true);
test("1.23", false);
test("1234567890123", true);
test("1234567890123.1", false);
test("0123", false); // false because we don't handle leading 0s
test(" 123 ", false); // false because we don't handle whitespace
<label>
String:
<input id="text" type="text" value="">
<label>
<input id="btn" type="button" value="Check">
Testbed live ( con gestione per zeri iniziali e spazi bianchi):
function isNormalInteger(str) {
str = str.trim();
if (!str) {
return false;
}
str = str.replace(/^0+/, "") || "0";
var n = Math.floor(Number(str));
return String(n) === str && n >= 0;
}
function gid(id) {
return document.getElementById(id);
}
function test(str, expect) {
var result = isNormalInteger(str);
console.log(
str + ": " +
(result ? "Yes" : "No") +
(expect === undefined ? "" : !!expect === !!result ? " <= OK" : " <= ERROR ***")
);
}
gid("btn").addEventListener(
"click",
function() {
test(gid("text").value);
},
false
);
test("1", true);
test("1.23", false);
test("1234567890123", true);
test("1234567890123.1", false);
test("0123", true);
test(" 123 ", true);
<label>
String:
<input id="text" type="text" value="">
<label>
<input id="btn" type="button" value="Check">
Se desideri non consentire 0, >= 0passa a > 0. (Oppure, nella versione che consente zeri iniziali, rimuovere || "0"ilreplace riga.)
Come funziona:
Nella versione che consente spazi bianchi e zeri iniziali:
str = str.trim(); rimuove qualsiasi spazio bianco iniziale e finale.if (!str) prende una stringa vuota e ritorna, inutile fare il resto del lavoro.str = str.replace(/^0+/, "") || "0"; rimuove tutti gli 0 iniziali dalla stringa, ma se ciò risulta in una stringa vuota, ripristina un singolo 0.
Number(str): Converti strin un numero; il numero può anche avere una porzione frazionaria o può essere NaN.
Math.floor: Tronca il numero (elimina qualsiasi porzione frazionaria).
String(...): Converte il risultato in una normale stringa decimale. Per numeri davvero grandi, questo andrà alla notazione scientifica, che potrebbe rompere questo approccio. (Non so bene dove sia la divisione, i dettagli sono nelle specifiche , ma per i numeri interi credo che sia nel momento in cui hai superato le 21 cifre [a quel punto il numero è diventato molto impreciso, come IEEE-754 i numeri a doppia precisione hanno solo circa 15 cifre di precisione ..)
... === str: Confronta quello con la stringa originale.
n >= 0: Verifica che sia positivo.
Si noti che ciò non riesce per l'input "+1", qualsiasi input nella notazione scientifica che non si trasforma nella stessa notazione scientifica nella String(...)fase e per qualsiasi valore che il tipo di numero utilizza JavaScript (punto mobile binario a doppia precisione IEEE-754) non è in grado di rappresentare con precisione quali analisi sono più vicine a un valore diverso da quello indicato (che include molti numeri interi oltre 9.007.199.254.740.992; ad esempio, 1234567890123456789fallirà). Il primo è una soluzione semplice, i secondi due non così tanto.
Espressione regolare
L'altro approccio è testare i caratteri della stringa tramite un'espressione regolare, se il tuo obiettivo è semplicemente consentire (diciamo) un opzionale +seguito da uno 0o da una stringa in normale formato decimale:
function isNormalInteger(str) {
return /^\+?(0|[1-9]\d*)$/.test(str);
}
Testbed live:
function isNormalInteger(str) {
return /^\+?(0|[1-9]\d*)$/.test(str);
}
function gid(id) {
return document.getElementById(id);
}
function test(str, expect) {
var result = isNormalInteger(str);
console.log(
str + ": " +
(result ? "Yes" : "No") +
(expect === undefined ? "" : !!expect === !!result ? " <= OK" : " <= ERROR ***")
);
}
gid("btn").addEventListener(
"click",
function() {
test(gid("text").value);
},
false
);
test("1", true);
test("1.23", false);
test("1234567890123", true);
test("1234567890123.1", false);
test("0123", false); // false because we don't handle leading 0s
test(" 123 ", false); // false because we don't handle whitespace
<label>
String:
<input id="text" type="text" value="">
<label>
<input id="btn" type="button" value="Check">
Come funziona:
^: Corrisponde all'inizio della stringa
\+?: Consenti un singolo, facoltativo +(rimuovilo se non vuoi)
(?:...|...): Consenti una di queste due opzioni (senza creare un gruppo di acquisizione):
(0|...): Consenti 0da solo ...
(...|[1-9]\d*): ... o un numero che inizia con qualcosa di diverso da 0e seguito da un numero qualsiasi di cifre decimali.
$: Corrisponde alla fine della stringa.
Se si desidera non consentire 0(perché non è positivo), l'espressione regolare diventa giusta /^\+?[1-9]\d*$/(ad esempio, possiamo perdere l'alternanza che dovevamo consentire 0).
Se si desidera consentire gli zeri iniziali (0123, 00524), sostituire semplicemente l'alternanza (?:0|[1-9]\d*)con\d+
function isNormalInteger(str) {
return /^\+?\d+$/.test(str);
}
Se vuoi consentire spazi bianchi, aggiungi \s*subito dopo ^e \s*subito prima $.
Nota per quando lo converti in un numero: sui motori moderni probabilmente sarebbe bene usarlo +stro Number(str)farlo, ma quelli più vecchi potrebbero estenderli in un modo non standard (ma precedentemente consentito) che dice che uno zero iniziale significa ottale (base 8), ad es. "010" => 8. Dopo aver convalidato il numero, puoi tranquillamente utilizzarlo parseInt(str, 10)per assicurarti che sia analizzato come decimale (base 10). parseIntignorerebbe la spazzatura alla fine della stringa, ma ci siamo assicurati che non ci fosse nessuno con la regex.