Me gustaría que la prueba más simple a prueba de fallas verifique que una cadena en JavaScript sea un entero positivo.

isNaN(str)devuelve verdadero para todo tipo de valores no enteros y parseInt(str)devuelve enteros para cadenas flotantes, como "2.5". Y tampoco quiero tener que usar algún complemento jQuery.

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:

1. 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.

2. Number(str): Convertir stra un número; el número bien puede tener una porción fraccional, o puede ser NaN.

3. Math.floor: Trunca el número (corta cualquier porción fraccional).

4. 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 ...)

5. ... === str: Compara eso con la cadena original.

6. 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:

1. ^: Inicio de la secuencia del partido

2. \+?: Permitir un solo, opcional +(elimine esto si no lo desea)

3. (?:...|...): Permita una de estas dos opciones (sin crear un grupo de captura):

   1. (0|...): Permitir 0por sí solo ...

   2. (...|[1-9]\d*): ... o un número que comienza con algo diferente 0y seguido de cualquier número de dígitos decimales.

4. $: 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.

Solución 1

Si consideramos que un entero JavaScript es un valor máximo 4294967295(es decir Math.pow(2,32)-1), entonces la siguiente solución breve funcionará perfectamente:

function isPositiveInteger(n) {
    return n >>> 0 === parseFloat(n);
}

DESCRIPCIÓN:

1. El operador de desplazamiento a la derecha de llenado a cero hace tres cosas importantes:
   • trunca la parte decimal
     • 123.45 >>> 0 === 123
   • hace el cambio para números negativos
     • -1 >>> 0 === 4294967295
   • "funciona" en el rango de MAX_INT
     • 1e10 >>> 0 === 1410065408
     • 1e7 >>> 0 === 10000000
2. parseFloatrealiza un análisis correcto de los números de cadena (configuración NaNpara cadenas no numéricas)

PRUEBAS

"0"                     : true
"23"                    : true
"-10"                   : false
"10.30"                 : false
"-40.1"                 : false
"string"                : false
"1234567890"            : true
"129000098131766699.1"  : false
"-1e7"                  : false
"1e7"                   : true
"1e10"                  : false
"1edf"                  : false
" "                     : false
""                      : false

DEMO: http://jsfiddle.net/5UCy4/37/

Solución 2

Otra forma es buena para todos los valores numéricos que son válidos hasta Number.MAX_VALUE, es decir, aproximadamente 1.7976931348623157e+308:

function isPositiveInteger(n) {
    return 0 === n % (!isNaN(parseFloat(n)) && 0 <= ~~n);
}

DESCRIPCIÓN:

1. !isNaN(parseFloat(n))se utiliza para filtrar puros valores de cadena, por ejemplo "", " ", "string";
2. 0 <= ~~nfiltra negativo y valores no enteros grandes, por ejemplo "-40.1", "129000098131766699";
3. (!isNaN(parseFloat(n)) && 0 <= ~~n)devuelve truesi el valor es tanto numérico como positivo ;
4. 0 === n % (...)comprueba si el valor no es flotante - aquí (...)(ver 3) se evalúa como 0en el caso de false, y como 1en el caso de true.

PRUEBAS

"0"                     : true
"23"                    : true
"-10"                   : false
"10.30"                 : false
"-40.1"                 : false
"string"                : false
"1234567890"            : true
"129000098131766699.1"  : false
"-1e10"                 : false
"1e10"                  : true
"1edf"                  : false
" "                     : false
""                      : false

DEMO: http://jsfiddle.net/5UCy4/14/

La versión anterior:

function isPositiveInteger(n) {
    return n == "0" || ((n | 0) > 0 && n % 1 == 0);
}

DEMO: http://jsfiddle.net/5UCy4/2/

Parece que una expresión regular es el camino a seguir:

var isInt = /^\+?\d+$/.test('the string');

La solución moderna que funciona en el nodo y en más del 90% de todos los navegadores (excepto IE y Opera Mini) es usar Number.isInteger seguido de una simple verificación positiva.

Number.isInteger(x) && x > 0

Esto se finalizó en ECMAScript 2015 .

function isPositiveInteger(x) {
    return Number.isInteger(x) && x > 0
}

El Polyfil es:

Number.isInteger = Number.isInteger || function(value) {
  return typeof value === 'number' && 
    isFinite(value) && 
    Math.floor(value) === value;
};

Si necesita admitir entradas que pueden estar en forma de cadena o número, entonces puede usar esta función contra la que escribí un gran conjunto de pruebas después de que todas las respuestas existentes (2/1/2018) fallaron en alguna forma de entrada.

function isPositiveInteger(v) {
  var i;
  return v && (i = parseInt(v)) && i > 0 && (i === v || ''+i === v);
}

Esta es casi una pregunta duplicada para esta:

Validar números decimales en JavaScript - IsNumeric ()

Su respuesta es:

function isNumber(n) {
  return !isNaN(parseFloat(n)) && isFinite(n);
}

entonces, un entero positivo sería:

function isPositiveInteger(n) {
  var floatN = parseFloat(n);
  return !isNaN(floatN) && isFinite(n) && floatN > 0
      && floatN % 1 == 0;
}

return ((parseInt(str, 10).toString() == str) && str.indexOf('-') === -1);

aunque no funcionará si le das una cadena como '0001'

Mi función verifica si el número es + ve y también podría tener un valor decimal.

       function validateNumeric(numValue){
            var value = parseFloat(numValue);
            if (!numValue.toString().match(/^[-]?\d*\.?\d*$/)) 
                    return false;
            else if (numValue < 0) {
                return false;
            }
            return true;        
        }

Solo para construir sobre la respuesta de VisioN anterior, si está utilizando el complemento de validación jQuery, podría usar esto:

$(document).ready(function() {
    $.validator.addMethod('integer', function(value, element, param) {
        return (value >>> 0 === parseFloat(value) && value > 0);
    }, 'Please enter a non zero integer value!');
}

Luego, podría usar en su conjunto de reglas normales o agregarlo dinámicamente de esta manera:

$("#positiveIntegerField").rules("add", {required:true, integer:true});

Sencillo

function isInteger(num) {
  return (num ^ 0) === num;
}

console.log(isInteger(1));

También puede extender Número y asignarle la función a través de un prototipo.

Si está utilizando formularios HTML5, puede usar el atributo min="0"para el elemento del formulario <input type="number" />. Esto es compatible con todos los principales navegadores. No implica Javascript para tareas tan simples, pero está integrado en el nuevo estándar html. Está documentado en https://www.w3schools.com/tags/att_input_min.asp

(~~a == a)donde aesta la cuerda

ES6:

Number.isInteger(Number(theNumberString)) > 0