javascript decimal - Valide que una cadena es un entero positivo




es6 int (9)

(~~a == a) donde a es la cadena.

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

isNaN(str) devuelve true para todo tipo de valores no enteros y parseInt(str) devuelve enteros para cadenas flotantes, como "2.5". Y no quiero tener que usar un plugin jQuery tampoco.


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

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;        
        }

Si está utilizando formularios HTML5, puede usar el atributo min="0" para el elemento de 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


Solo para aprovechar la respuesta de VisioN anterior, si está utilizando el complemento de validación de jQuery, puede 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, puede usar en su conjunto de reglas normales o agregarlo dinámicamente de esta manera:

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

Dos respuestas para ti:

  • Basado en el análisis

  • Expresión regular

Tenga en cuenta que en ambos casos, he interpretado "entero positivo" para incluir 0 , aunque 0 no es positivo. Incluyo notas si desea deshabilitar 0 .

Basado en el análisis

Si desea que sea una cadena de enteros 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;
}

Testbed en vivo:

function isNormalInteger(str) {
    var n = Math.floor(Number(str));
    return String(n) === str && n >= 0;
}
function gid(id) {
  return document.getElementById(id);
}
function test(str, expect) {
  console.log(str + ": " + (isNormalInteger(str) ? "Yes" : "No"));
}
gid("btn").addEventListener(
  "click",
  function() {
    test(gid("text").value);
  },
  false
);
test("1");
test("1.23");
test("1234567890123");
test("1234567890123.1");
<label>
  String:
  <input id="text" type="text" value="">
<label>
<input id="btn" type="button" value="Check">

Si desea rechazar 0 , simplemente cambie >= 0 a > 0 .

Cómo funciona eso:

  1. Number(str) : Convierta str en un número; el número bien puede tener una porción fraccionaria, o puede ser NaN .

  2. Math.floor : Math.floor el número (corta cualquier porción fraccionaria).

  3. String(...) : convierte el resultado en una cadena decimal normal. Para números realmente grandes, esto irá a la notación científica, que puede romper este enfoque. (No sé exactamente dónde está dividida, los detalles están en la especificación , pero para los números enteros creo que está en el punto en que superó 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 exactamente 15 dígitos de precisión ...)

  4. ... === str : lo compara con la cadena original.

  5. 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 vuelva a la misma notación científica en la etapa String(...) , y para cualquier valor que use el tipo de número de JavaScript ( IEEE-754 punto flotante binario de precisión doble) no puede representar con precisión qué analiza más cerca de un valor diferente al dado (que incluye muchos enteros superiores a 9,007,199,254,740,992; por ejemplo, 1234567890123456789 fallará). El primero es una solución fácil, los últimos dos 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 simplemente permitir (decir) un + opcional seguido por 0 o una cadena en formato decimal normal:

function isNormalInteger(str) {
    return /^\+?(0|[1-9]\d*)$/.test(str);
}

Testbed en vivo:

function isNormalInteger(str) {
    return /^\+?(0|[1-9]\d*)$/.test(str);
}
function gid(id) {
  return document.getElementById(id);
}
function test(str, expect) {
  console.log(str + ": " + (isNormalInteger(str) ? "Yes" : "No"));
}
gid("btn").addEventListener(
  "click",
  function() {
    test(gid("text").value);
  },
  false
);
test("1");
test("1.23");
test("1234567890123");
test("1234567890123.1");
<label>
  String:
  <input id="text" type="text" value="">
<label>
<input id="btn" type="button" value="Check">

Cómo funciona eso:

  1. ^ : Comienzo del partido de la secuencia

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

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

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

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

  4. $ : Coincide con el final de la cadena.

Si desea deshabilitar 0 (porque no es positivo), la expresión regular se convierte en solo /^\+?[1-9]\d*$/ (por ejemplo, podemos perder la alternancia que necesitamos para 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);
}

Tenga en cuenta que cuando lo convierta en un número: en los motores modernos, probablemente sería mejor usar +str o Number(str) para hacerlo, pero los más antiguos podrían ampliarlos de una forma no estándar (pero anteriormente permitida) que dice que un cero inicial significa octal (base 8), por ejemplo, "010" => 8. Una vez que hayas validado el número, puedes usar parseInt(str, 10) para asegurarte de que se analiza como decimal (base 10). parseInt ignoraría la basura al final de la cadena, pero nos aseguramos de que no haya ninguna con la expresión regular.


Esta es casi una pregunta duplicada para este:

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;
}

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

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

return (input - 0) == input && input.length > 0;

no funciono para mi Cuando puse una alerta y probé, input.length estaba undefined . Creo que no hay ninguna propiedad para verificar la longitud del número entero. Así que lo que hice fue

var temp = '' + input;
return (input - 0) == input && temp.length > 0;

Funcionó bien







javascript