Dos respuestas para ti:
Basado en análisis
Expresión regular
Tenga en cuenta que en ambos casos, he interpretado "entero positivo" para incluir 0, aunque 0no es positivo. Incluyo notas si desea no permitir 0.
Basado en análisis
Si desea que sea una cadena entera decimal normalizada en un rango razonable de valores, puede hacer esto:
function isNormalInteger(str) {
var n = Math.floor(Number(str));
return n !== Infinity && String(n) === str && n >= 0;
}
o si desea permitir espacios en blanco y ceros a la izquierda:
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;
}
Banco de pruebas en vivo (sin manejar ceros a la izquierda o espacios en blanco):
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">
Banco de pruebas en vivo ( con manejo de ceros y espacios en blanco):
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">
Si desea rechazar 0, simplemente cambie >= 0a > 0. (O, en la versión que permite los ceros a la izquierda, elimine el || "0"en la replacelínea).
Cómo funciona eso:
En la versión que permite espacios en blanco y ceros a la izquierda:
str = str.trim(); elimina cualquier espacio en blanco inicial y final.if (!str) atrapa una cadena en blanco y regresa, no tiene sentido hacer el resto del trabajo.str = str.replace(/^0+/, "") || "0"; elimina todos los 0 iniciales de la cadena, pero si eso resulta en una cadena en blanco, restaura un solo 0.
Number(str): Convertir stra un número; el número bien puede tener una porción fraccional, o puede ser NaN.
Math.floor: Trunca el número (corta cualquier porción fraccional).
String(...): Convierte el resultado nuevamente en una cadena decimal normal. Para números realmente grandes, esto irá a notación científica, lo que puede romper este enfoque. (No sé exactamente dónde está la división, los detalles están en la especificación , pero para los números enteros creo que es en el momento en que has excedido los 21 dígitos [en ese momento el número se ha vuelto muy impreciso, como IEEE-754 los números de doble precisión solo tienen 15 dígitos precisos de precisión ...)
... === str: Compara eso con la cadena original.
n >= 0: Comprueba que sea positivo.
Tenga en cuenta que esto falla para la entrada "+1", cualquier entrada en notación científica que no se convierta en la misma notación científica en la String(...)etapa, y para cualquier valor que utilice el tipo de número que JavaScript utiliza (punto flotante binario de doble precisión IEEE-754) no puede representar con precisión qué análisis está más cerca de un valor diferente que el dado (que incluye muchos enteros de más de 9,007,199,254,740,992; por ejemplo, 1234567890123456789fallará). El primero es una solución fácil, los dos últimos no tanto.
Expresión regular
El otro enfoque es probar los caracteres de la cadena a través de una expresión regular, si su objetivo es permitir (digamos) una opción +seguida por una 0o una cadena en formato decimal normal:
function isNormalInteger(str) {
return /^\+?(0|[1-9]\d*)$/.test(str);
}
Banco de pruebas en vivo:
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">
Cómo funciona eso:
^: Inicio de la secuencia del partido
\+?: Permitir un solo, opcional +(elimine esto si no lo desea)
(?:...|...): Permita una de estas dos opciones (sin crear un grupo de captura):
(0|...): Permitir 0por sí solo ...
(...|[1-9]\d*): ... o un número que comienza con algo diferente 0y seguido de cualquier número de dígitos decimales.
$: Coincide con el final de la cadena.
Si desea rechazar 0(porque no es positivo), la expresión regular se vuelve justa /^\+?[1-9]\d*$/(por ejemplo, podemos perder la alternancia que necesitábamos permitir 0).
Si desea permitir ceros a la izquierda (0123, 00524), simplemente reemplace la alternancia (?:0|[1-9]\d*)con\d+
function isNormalInteger(str) {
return /^\+?\d+$/.test(str);
}
Si desea permitir espacios en blanco, agregue \s*justo después ^y \s*justo antes $.
Nota para cuando convierta eso en un número: en los motores modernos probablemente estaría bien usarlo +stro Number(str)hacerlo, pero los más antiguos podrían extenderlos de una manera no estándar (pero permitida anteriormente) que dice que un cero inicial significa octal (base 8), por ejemplo, "010" => 8. Una vez que haya validado el número, puede usarlo parseInt(str, 10)con seguridad para asegurarse de que se analiza como decimal (base 10). parseIntignoraría la basura al final de la cadena, pero nos hemos asegurado de que no haya ninguna con la expresión regular.