validar - validate decimal number javascript




Validar números decimales en JavaScript-IsNumeric() (20)

¿Cuál es la forma más limpia y efectiva de validar números decimales en JavaScript?

Puntos de bonificación por:

  1. Claridad. La solución debe ser limpia y simple.
  2. Multiplataforma

Casos de prueba:

01. IsNumeric('-1')      => true
02. IsNumeric('-1.5')    => true
03. IsNumeric('0')       => true
04. IsNumeric('0.42')    => true
05. IsNumeric('.42')     => true
06. IsNumeric('99,999')  => false
07. IsNumeric('0x89f')   => false
08. IsNumeric('#abcdef') => false
09. IsNumeric('1.2.3')   => false
10. IsNumeric('')        => false
11. IsNumeric('blah')    => false

¡Arrrgh! No escuches las respuestas de expresiones regulares. RegEx es difícil por esto, y no estoy hablando solo de rendimiento. Es tan fácil cometer errores sutiles, imposibles de detectar con tu expresión regular.

Si no puedes usar isNaN() , esto debería funcionar mucho mejor:

function IsNumeric(input)
{
    return (input - 0) == input && (''+input).trim().length > 0;
}

Así es como funciona:

La expresión (input - 0) obliga a JavaScript a realizar coacción de tipo en su valor de entrada; primero debe interpretarse como un número para la operación de resta. Si esa conversión a un número falla, la expresión resultará en NaN . Este resultado numérico se compara con el valor original que se le pasó. Dado que el lado izquierdo ahora es numérico, se usa nuevamente el tipo de coerción. Ahora que la entrada de ambos lados fue forzada al mismo tipo desde el mismo valor original, usted pensaría que siempre deberían ser iguales (siempre cierto). Sin embargo, hay una regla especial que dice que NaN nunca es igual a NaN , por lo que un valor que no se puede convertir en un número (y solo los valores que no se pueden convertir en números) resultará en falso.

La verificación de la longitud es para un caso especial que involucra cadenas vacías. También tenga en cuenta que cae en su prueba 0x89f, pero eso se debe a que en muchos entornos es una buena manera de definir un número literal. Si desea detectar ese escenario específico, puede agregar una verificación adicional. Aún mejor, si esa es la razón por la que no usas isNaN() entonces envuelve tu propia función alrededor de isNaN() que también puede hacer la verificación adicional.

En resumen, si desea saber si un valor se puede convertir en un número, intente convertirlo en un número.

Regresé e investigué un poco por qué una cadena de espacios en blanco no tenía el resultado esperado, y creo que ahora lo entiendo: una cadena vacía se fuerza a 0 lugar de NaN . Simplemente recortar la cadena antes de la verificación de longitud manejará este caso.

Ejecutar las pruebas unitarias contra el nuevo código y solo falla en los infinitos y en los literales booleanos, y el único momento en que debería ser un problema es si estás generando código (en realidad, ¿quién escribiría un literal y verificaría si es numérico? Deberías saberlo , y ese sería un código extraño para generar.

Pero, nuevamente, la única razón para usar esto es si, por alguna razón, tiene que evitar isNaN ().


Aquí hay una versión mejorada (probablemente la forma más rápida de salir) que uso en lugar de la variante jQuery exacta, realmente no sé por qué no usan esta:

function isNumeric(val) {
    return !isNaN(+val) && isFinite(val);
}

La desventaja de la versión de jQuery es que si pasas una cadena con números y letras finales como "123abc" el parseFloat | parseInt parseFloat | parseInt extraerá la fracción numérica y devolverá 123, PERO, la segunda guarda es isFinite , de cualquier forma fallará. Con el operador unario + , morirá en la primera guardia ya que + lanza NaN para tales híbridos :) Un poco de rendimiento, sin embargo, creo que es una ganancia semántica sólida.


El único problema que tuve con la answer @ CMS es la exclusión de NaN e Infinity, que son números útiles para muchas situaciones. Una forma de verificar los NaN es verificar los valores numéricos que no son iguales, NaN != NaN ¡ NaN != NaN ! Entonces hay 3 pruebas con las que te gustaría lidiar ...

function isNumber(n) {
  n = parseFloat(n);
  return !isNaN(n) || n != n;
}
function isFiniteNumber(n) {
  n = parseFloat(n);
  return !isNaN(n) && isFinite(n);
}    
function isComparableNumber(n) {
  n = parseFloat(n);
  return (n >=0 || n < 0);
}

isFiniteNumber('NaN')
false
isFiniteNumber('OxFF')
true
isNumber('NaN')
true
isNumber(1/0-1/0)
true
isComparableNumber('NaN')
false
isComparableNumber('Infinity')
true

My isComparableNumber es bastante similar a otra answer elegante, pero maneja representaciones hexadecimales y de otras cadenas de números.


Esta manera parece funcionar bien:

function IsNumeric(input){
    var RE = /^-{0,1}\d*\.{0,1}\d+$/;
    return (RE.test(input));
}

Y para probarlo:

// alert(TestIsNumeric());

function TestIsNumeric(){
    var results = ''
    results += (IsNumeric('-1')?"Pass":"Fail") + ": IsNumeric('-1') => true\n";
    results += (IsNumeric('-1.5')?"Pass":"Fail") + ": IsNumeric('-1.5') => true\n";
    results += (IsNumeric('0')?"Pass":"Fail") + ": IsNumeric('0') => true\n";
    results += (IsNumeric('0.42')?"Pass":"Fail") + ": IsNumeric('0.42') => true\n";
    results += (IsNumeric('.42')?"Pass":"Fail") + ": IsNumeric('.42') => true\n";
    results += (!IsNumeric('99,999')?"Pass":"Fail") + ": IsNumeric('99,999') => false\n";
    results += (!IsNumeric('0x89f')?"Pass":"Fail") + ": IsNumeric('0x89f') => false\n";
    results += (!IsNumeric('#abcdef')?"Pass":"Fail") + ": IsNumeric('#abcdef') => false\n";
    results += (!IsNumeric('1.2.3')?"Pass":"Fail") + ": IsNumeric('1.2.3') => false\n";
    results += (!IsNumeric('')?"Pass":"Fail") + ": IsNumeric('') => false\n";
    results += (!IsNumeric('blah')?"Pass":"Fail") + ": IsNumeric('blah') => false\n";

    return results;
}

Tomé prestada esa expresión regular de http://www.codetoad.com/javascript/isnumeric.asp . Explicación:

/^ match beginning of string
-{0,1} optional negative sign
\d* optional digits
\.{0,1} optional decimal point
\d+ at least one digit
$/ match end of string

La respuesta aceptada falló tu prueba # 7 y supongo que es porque cambiaste de opinión. Así que esta es una respuesta a la respuesta aceptada, con la que tuve problemas.

Durante algunos proyectos he necesitado validar algunos datos y estar lo más seguro posible de que es un valor numérico de javascript que se puede usar en operaciones matemáticas.

jQuery y algunas otras bibliotecas de javascript ya incluyen dicha función, generalmente llamada isNumeric . También hay una publicación en que ha sido ampliamente aceptada como la respuesta, la misma rutina general que las bibliotecas mencionadas anteriormente están utilizando.

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

Primero, el código anterior devolvería verdadero si el argumento fuera una matriz de longitud 1, y ese único elemento era de un tipo considerado como numérico por la lógica anterior. En mi opinión, si es una matriz, entonces no es numérica.

Para aliviar este problema, agregué un cheque para descontar arreglos de la lógica

function isNumber(n) {
  return Object.prototype.toString.call(n) !== '[object Array]' &&!isNaN(parseFloat(n)) && isFinite(n);
}

Por supuesto, también puede usar Array.isArray , jquery $.isArray o prototype Object.isArray lugar de Object.prototype.toString.call(n) !== '[object Array]'

Mi segundo problema fue que las cadenas literales enteras hexadecimales negativas ("-0xA" -> -10) no se consideraban numéricas. Sin embargo, las cadenas literales enteras hexadecimales positivas ("0xA" -> 10) se trataron como numéricas. Necesitaba que ambos fueran numéricos válidos.

Luego modifiqué la lógica para tener esto en cuenta.

function isNumber(n) {
  return Object.prototype.toString.call(n) !== '[object Array]' &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(/^-/, ''));
}

Si está preocupado por la creación de la expresión regular cada vez que se llama a la función, podría reescribirla dentro de un cierre, algo como esto

var isNumber = (function () {
  var rx = /^-/;

  return function (n) {
      return Object.prototype.toString.call(n) !== '[object Array]' &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(rx, ''));
  };
}());

Luego tomé CMSs +30 casos de prueba y cloné las pruebas en jsfiddle. Agregué mis casos de prueba adicionales y mi solución descrita anteriormente.

Es posible que no reemplace la respuesta ampliamente aceptada / utilizada, pero si esto es más de lo que espera como resultado de su función isNumeric, entonces espero que esto sea de alguna ayuda.

EDITAR: Como señaló Bergi , hay otros objetos posibles que podrían considerarse numéricos y sería mejor hacer una lista blanca que una lista negra. Con esto en mente me gustaría añadir a los criterios.

Quiero que mi función isNumeric considere solo números o cadenas

Con esto en mente, sería mejor usar

function isNumber(n) {
  return (Object.prototype.toString.call(n) === '[object Number]' || Object.prototype.toString.call(n) === '[object String]') &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(/^-/, ''));
}

Probar las soluciones

var testHelper = function() {

  var testSuite = function() {
    test("Integer Literals", function() {
      ok(isNumber("-10"), "Negative integer string");
      ok(isNumber("0"), "Zero string");
      ok(isNumber("5"), "Positive integer string");
      ok(isNumber(-16), "Negative integer number");
      ok(isNumber(0), "Zero integer number");
      ok(isNumber(32), "Positive integer number");
      ok(isNumber("040"), "Octal integer literal string");
      ok(isNumber(0144), "Octal integer literal");
      ok(isNumber("-040"), "Negative Octal integer literal string");
      ok(isNumber(-0144), "Negative Octal integer literal");
      ok(isNumber("0xFF"), "Hexadecimal integer literal string");
      ok(isNumber(0xFFF), "Hexadecimal integer literal");
      ok(isNumber("-0xFF"), "Negative Hexadecimal integer literal string");
      ok(isNumber(-0xFFF), "Negative Hexadecimal integer literal");
    });

    test("Foating-Point Literals", function() {
      ok(isNumber("-1.6"), "Negative floating point string");
      ok(isNumber("4.536"), "Positive floating point string");
      ok(isNumber(-2.6), "Negative floating point number");
      ok(isNumber(3.1415), "Positive floating point number");
      ok(isNumber(8e5), "Exponential notation");
      ok(isNumber("123e-2"), "Exponential notation string");
    });

    test("Non-Numeric values", function() {
      equals(isNumber(""), false, "Empty string");
      equals(isNumber("        "), false, "Whitespace characters string");
      equals(isNumber("\t\t"), false, "Tab characters string");
      equals(isNumber("abcdefghijklm1234567890"), false, "Alphanumeric character string");
      equals(isNumber("xabcdefx"), false, "Non-numeric character string");
      equals(isNumber(true), false, "Boolean true literal");
      equals(isNumber(false), false, "Boolean false literal");
      equals(isNumber("bcfed5.2"), false, "Number with preceding non-numeric characters");
      equals(isNumber("7.2acdgs"), false, "Number with trailling non-numeric characters");
      equals(isNumber(undefined), false, "Undefined value");
      equals(isNumber(null), false, "Null value");
      equals(isNumber(NaN), false, "NaN value");
      equals(isNumber(Infinity), false, "Infinity primitive");
      equals(isNumber(Number.POSITIVE_INFINITY), false, "Positive Infinity");
      equals(isNumber(Number.NEGATIVE_INFINITY), false, "Negative Infinity");
      equals(isNumber(new Date(2009, 1, 1)), false, "Date object");
      equals(isNumber(new Object()), false, "Empty object");
      equals(isNumber(function() {}), false, "Instance of a function");
      equals(isNumber([]), false, "Empty Array");
      equals(isNumber(["-10"]), false, "Array Negative integer string");
      equals(isNumber(["0"]), false, "Array Zero string");
      equals(isNumber(["5"]), false, "Array Positive integer string");
      equals(isNumber([-16]), false, "Array Negative integer number");
      equals(isNumber([0]), false, "Array Zero integer number");
      equals(isNumber([32]), false, "Array Positive integer number");
      equals(isNumber(["040"]), false, "Array Octal integer literal string");
      equals(isNumber([0144]), false, "Array Octal integer literal");
      equals(isNumber(["-040"]), false, "Array Negative Octal integer literal string");
      equals(isNumber([-0144]), false, "Array Negative Octal integer literal");
      equals(isNumber(["0xFF"]), false, "Array Hexadecimal integer literal string");
      equals(isNumber([0xFFF]), false, "Array Hexadecimal integer literal");
      equals(isNumber(["-0xFF"]), false, "Array Negative Hexadecimal integer literal string");
      equals(isNumber([-0xFFF]), false, "Array Negative Hexadecimal integer literal");
      equals(isNumber([1, 2]), false, "Array with more than 1 Positive interger number");
      equals(isNumber([-1, -2]), false, "Array with more than 1 Negative interger number");
    });
  }

  var functionsToTest = [

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

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

    function(n) {
      return !isNaN((n));
    },

    function(n) {
      return !isNaN(parseFloat(n));
    },

    function(n) {
      return typeof(n) != "boolean" && !isNaN(n);
    },

    function(n) {
      return parseFloat(n) === Number(n);
    },

    function(n) {
      return parseInt(n) === Number(n);
    },

    function(n) {
      return !isNaN(Number(String(n)));
    },

    function(n) {
      return !isNaN(+('' + n));
    },

    function(n) {
      return (+n) == n;
    },

    function(n) {
      return n && /^-?\d+(\.\d+)?$/.test(n + '');
    },

    function(n) {
      return isFinite(Number(String(n)));
    },

    function(n) {
      return isFinite(String(n));
    },

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

    function(n) {
      return parseFloat(n) == n;
    },

    function(n) {
      return (n - 0) == n && n.length > 0;
    },

    function(n) {
      return typeof n === 'number' && isFinite(n);
    },

    function(n) {
      return !Array.isArray(n) && !isNaN(parseFloat(n)) && isFinite(n.toString().replace(/^-/, ''));
    }

  ];


  // Examines the functionsToTest array, extracts the return statement of each function
  // and fills the toTest select element.
  var fillToTestSelect = function() {
    for (var i = 0; i < functionsToTest.length; i++) {
      var f = functionsToTest[i].toString();
      var option = /[\s\S]*return ([\s\S]*);/.exec(f)[1];
      $("#toTest").append('<option value="' + i + '">' + (i + 1) + '. ' + option + '</option>');
    }
  }

  var performTest = function(functionNumber) {
    reset(); // Reset previous test
    $("#tests").html(""); //Clean test results
    isNumber = functionsToTest[functionNumber]; // Override the isNumber global function with the one to test
    testSuite(); // Run the test

    // Get test results
    var totalFail = 0;
    var totalPass = 0;
    $("b.fail").each(function() {
      totalFail += Number($(this).html());
    });
    $("b.pass").each(function() {
      totalPass += Number($(this).html());
    });
    $("#testresult").html(totalFail + " of " + (totalFail + totalPass) + " test failed.");

    $("#banner").attr("class", "").addClass(totalFail > 0 ? "fail" : "pass");
  }

  return {
    performTest: performTest,
    fillToTestSelect: fillToTestSelect,
    testSuite: testSuite
  };
}();


$(document).ready(function() {
  testHelper.fillToTestSelect();
  testHelper.performTest(0);

  $("#toTest").change(function() {
    testHelper.performTest($(this).children(":selected").val());
  });
});
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js" type="text/javascript"></script>
<script src="https://rawgit.com/Xotic750/testrunner-old/master/testrunner.js" type="text/javascript"></script>
<link href="https://rawgit.com/Xotic750/testrunner-old/master/testrunner.css" rel="stylesheet" type="text/css">
<h1>isNumber Test Cases</h1>

<h2 id="banner" class="pass"></h2>

<h2 id="userAgent">Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.95 Safari/537.11</h2>

<div id="currentFunction"></div>

<div id="selectFunction">
  <label for="toTest" style="font-weight:bold; font-size:Large;">Select function to test:</label>
  <select id="toTest" name="toTest">
  </select>
</div>

<div id="testCode"></div>

<ol id="tests">
  <li class="pass">
    <strong>Integer Literals <b style="color:black;">(0, 10, 10)</b></strong>

    <ol style="display: none;">
      <li class="pass">Negative integer string</li>

      <li class="pass">Zero string</li>

      <li class="pass">Positive integer string</li>

      <li class="pass">Negative integer number</li>

      <li class="pass">Zero integer number</li>

      <li class="pass">Positive integer number</li>

      <li class="pass">Octal integer literal string</li>

      <li class="pass">Octal integer literal</li>

      <li class="pass">Hexadecimal integer literal string</li>

      <li class="pass">Hexadecimal integer literal</li>
    </ol>
  </li>

  <li class="pass">
    <strong>Foating-Point Literals <b style="color:black;">(0, 6, 6)</b></strong>

    <ol style="display: none;">
      <li class="pass">Negative floating point string</li>

      <li class="pass">Positive floating point string</li>

      <li class="pass">Negative floating point number</li>

      <li class="pass">Positive floating point number</li>

      <li class="pass">Exponential notation</li>

      <li class="pass">Exponential notation string</li>
    </ol>
  </li>

  <li class="pass">
    <strong>Non-Numeric values <b style="color:black;">(0, 18, 18)</b></strong>

    <ol style="display: none;">
      <li class="pass">Empty string: false</li>

      <li class="pass">Whitespace characters string: false</li>

      <li class="pass">Tab characters string: false</li>

      <li class="pass">Alphanumeric character string: false</li>

      <li class="pass">Non-numeric character string: false</li>

      <li class="pass">Boolean true literal: false</li>

      <li class="pass">Boolean false literal: false</li>

      <li class="pass">Number with preceding non-numeric characters: false</li>

      <li class="pass">Number with trailling non-numeric characters: false</li>

      <li class="pass">Undefined value: false</li>

      <li class="pass">Null value: false</li>

      <li class="pass">NaN value: false</li>

      <li class="pass">Infinity primitive: false</li>

      <li class="pass">Positive Infinity: false</li>

      <li class="pass">Negative Infinity: false</li>

      <li class="pass">Date object: false</li>

      <li class="pass">Empty object: false</li>

      <li class="pass">Instance of a function: false</li>
    </ol>
  </li>
</ol>

<div id="main">
  This page contains tests for a set of isNumber functions. To see them, take a look at the source.
</div>

<div>
  <p class="result">Tests completed in 0 milliseconds.
    <br>0 tests of 0 failed.</p>
</div>



Para mí, esta es la mejor manera:

isNumber : function(v){
   return typeof v === 'number' && isFinite(v);
}

Sí, el isNaN(object) será mucho más rápido que cualquier análisis de isNaN(object) regulares, porque está integrado y compilado, en lugar de interpretarse sobre la marcha.

Aunque los resultados son algo diferentes a lo que estás buscando ( pruébalo ):

                                              // IS NUMERIC
document.write(!isNaN('-1') + "<br />");      // true
document.write(!isNaN('-1.5') + "<br />");    // true
document.write(!isNaN('0') + "<br />");       // true
document.write(!isNaN('0.42') + "<br />");    // true
document.write(!isNaN('.42') + "<br />");     // true
document.write(!isNaN('99,999') + "<br />");  // false
document.write(!isNaN('0x89f') + "<br />");   // true
document.write(!isNaN('#abcdef') + "<br />"); // false
document.write(!isNaN('1.2.3') + "<br />");   // false
document.write(!isNaN('') + "<br />");        // true
document.write(!isNaN('blah') + "<br />");    // false

Si no me equivoco, este debe coincidir con cualquier valor de número de JavaScript válido, excluyendo las constantes ( Infinity , NaN ) y los operadores de signo + / - (porque en realidad no son parte del número en lo que a mí respecta, son operadores independientes ):

Necesitaba esto para un tokenizer, donde enviar el número a JavaScript para evaluación no era una opción ... Definitivamente no es la expresión regular más corta posible, pero creo que capta todas las sutilezas más finas de la sintaxis numérica de JavaScript.

/^(?:(?:(?:[1-9]\d*|\d)\.\d*|(?:[1-9]\d*|\d)?\.\d+|(?:[1-9]\d*|\d)) 
(?:[e]\d+)?|0[0-7]+|0x[0-9a-f]+)$/i

Los números válidos incluirían:

 - 0
 - 00
 - 01
 - 10
 - 0e1
 - 0e01
 - .0
 - 0.
 - .0e1
 - 0.e1
 - 0.e00
 - 0xf
 - 0Xf

Los números inválidos serían

 - 00e1
 - 01e1
 - 00.0
 - 00x0
 - .
 - .e0

Un par de pruebas para agregar:

IsNumeric('01.05') => false
IsNumeric('1.') => false
IsNumeric('.') => false

Se me ocurrió esto:

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

La solución cubre:

  • Un signo negativo opcional al principio.
  • Un solo cero, o uno o más dígitos que no comiencen con 0, o nada mientras siga un período
  • Un período que es seguido por 1 o más números

Usa la función isNaN . Creo que si haces la prueba para !isNaN(yourstringhere) funciona bien en cualquiera de estas situaciones.


Respuesta de @CMS : su fragmento de código falló en casos de espacios en blanco en mi máquina usando nodejs. Así que lo combiné con la respuesta de @ joel a lo siguiente:

is_float = function(v) {
    return !isNaN(v) && isFinite(v) &&
        (typeof(v) == 'number' || v.replace(/^\s+|\s+$/g, '').length > 0);
}

Lo probé con aquellos casos que son flotadores:

var t = [
        0,
        1.2123,
        '0',
        '2123.4',
        -1,
        '-1',
        -123.423,
        '-123.432',
        07,
        0xad,
        '07',
        '0xad'
    ];

y aquellos casos que no son flotantes (incluidos espacios en blanco vacíos y objetos / arrays):

    var t = [
        'hallo',
        [],
        {},
        'jklsd0',
        '',
        "\t",
        "\n",
        ' '
    ];

Todo funciona como se espera aquí. Tal vez esto ayude.

El código fuente completo para esto se puede encontrar here .



knockoutJs Inbuild funciones de validación de la biblioteca

Al ampliarlo se valida el campo.

1) número

self.number = ko.observable(numberValue) .extend ({number: true}) ;

Caso de prueba

numberValue = '0.0'    --> true
numberValue = '0'      --> true
numberValue = '25'     --> true
numberValue = '-1'     --> true
numberValue = '-3.5'   --> true
numberValue = '11.112' --> true
numberValue = '0x89f'  --> false
numberValue = ''       --> false
numberValue = 'sfsd'   --> false
numberValue = 'dg##$'  --> false

2) dígito

self.number = ko.observable(numberValue) .extend ({digit: true}) ;

Caso de prueba

numberValue = '0'      --> true
numberValue = '25'     --> true
numberValue = '0.0'    --> false
numberValue = '-1'     --> false
numberValue = '-3.5'   --> false
numberValue = '11.112' --> false
numberValue = '0x89f'  --> false
numberValue = ''       --> false
numberValue = 'sfsd'   --> false
numberValue = 'dg##$'  --> false

3) min y max

self.number = ko.observable(numberValue) .extender ({min: 5}). extender ({max: 10}) ;

Este campo acepta valores entre 5 y 10 solamente.

Caso de prueba

numberValue = '5'    --> true
numberValue = '6'    --> true
numberValue = '6.5'  --> true
numberValue = '9'    --> true
numberValue = '11'   --> false
numberValue = '0'    --> false
numberValue = ''    --> false

Lo siguiente parece funcionar bien para muchos casos:

function isNumeric(num) {
    return (num > 0 || num === 0 || num === '0' || num < 0) && num !== true && isFinite(num);
}

Esto se basa en esta respuesta (que también es para esta respuesta): https://.com/a/1561597/1985601


Me doy cuenta de que esto se ha respondido muchas veces, pero el siguiente es un candidato decente que puede ser útil en algunos escenarios.

debe tenerse en cuenta que asume que '.42' NO es un número, y '4'. NO es un número, por lo que debe tenerse en cuenta.

function isDecimal(x) {
  return '' + x === '' + +x;
}

function isInteger(x) {
  return '' + x === '' + parseInt(x);
}

La isDecimalpasa la siguiente prueba:

function testIsNumber(f) {
  return f('-1') && f('-1.5') && f('0') && f('0.42')
    && !f('.42') && !f('99,999') && !f('0x89f')
    && !f('#abcdef') && !f('1.2.3') && !f('') && !f('blah');
}

La idea aquí es que cada número o entero tiene una representación de cadena "canónica", y toda representación no canónica debe ser rechazada. Así que hacemos una conversión a un número y viceversa, y vemos si el resultado es la cadena original.

Si estas funciones son útiles para usted depende del caso de uso. Una característica es que las cadenas distintas representan números distintos (si ambas pasan la isNumber()prueba).

Esto es relevante, por ejemplo, para números como nombres de propiedades de objetos.

var obj = {};
obj['4'] = 'canonical 4';
obj['04'] = 'alias of 4';
obj[4];  // prints 'canonical 4' to the console.

Puede minimizar esta función de muchas maneras, y también puede implementarla con una expresión regular personalizada para valores negativos o gráficos personalizados:

$('.number').on('input',function(){
    var n=$(this).val().replace(/ /g,'').replace(/\D/g,'');
    if (!$.isNumeric(n))
        $(this).val(n.slice(0, -1))
    else
        $(this).val(n)
});

Ninguna de las respuestas vuelve falsepara cadenas vacías, una solución para eso ...

function is_numeric(n)
{
 return (n != '' && !isNaN(parseFloat(n)) && isFinite(n));
}

function IsNumeric(num) {
     return (num >=0 || num < 0);
}

Esto funciona para números de tipo 0x23 también.


function inNumeric(n){
   return Number(n).toString() === n;
}

Si n es numérico Number(n)devolverá el valor numérico y toString()lo convertirá de nuevo en una cadena. Pero si n no es numérico Number(n), volverá NaNpara que no coincida con el originaln





numbers