javascript - number - jquery test is numeric




Convalidare i numeri decimali in JavaScript-IsNumeric() (20)

Arrrgh! Non ascoltare le risposte alle espressioni regolari. RegEx è icky per questo, e non sto parlando solo delle prestazioni. È così facile rendere sottile, impossibile individuare gli errori con la tua espressione regolare.

Se non puoi usare isNaN() , questo dovrebbe funzionare molto meglio:

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

Ecco come funziona:

L'espressione (input - 0) forza JavaScript a eseguire la coercizione di tipo sul valore di input; deve prima essere interpretato come un numero per l'operazione di sottrazione. Se la conversione in un numero fallisce, l'espressione risulterà in NaN . Questo risultato numerico viene quindi confrontato con il valore originale passato. Poiché il lato sinistro è ora numerico, viene nuovamente utilizzata la coercizione di tipo. Ora che l'input da entrambi i lati è stato forzato allo stesso tipo dello stesso valore originale, si potrebbe pensare che dovrebbero essere sempre gli stessi (sempre vero). Tuttavia, esiste una regola speciale che dice che NaN non è mai uguale a NaN e quindi un valore che non può essere convertito in un numero (e solo i valori che non possono essere convertiti in numeri) risulterà falso.

Il controllo sulla lunghezza è per un caso speciale che coinvolge stringhe vuote. Si noti inoltre che cade giù sul test 0x89f, ma questo perché in molti ambienti è un modo corretto per definire un numero letterale. Se vuoi cogliere uno scenario specifico, puoi aggiungere un ulteriore controllo. Ancora meglio, se questo è il motivo per cui non si usa isNaN() basta avvolgere la propria funzione attorno a isNaN() che può anche eseguire il controllo aggiuntivo.

In breve, se vuoi sapere se un valore può essere convertito in un numero, in realtà prova a convertirlo in un numero.

Sono tornato indietro e ho fatto qualche ricerca sul perché una stringa di spaziatura non avesse l'output atteso, e penso di ottenerlo ora: una stringa vuota è forzata a 0 anziché a NaN . Basta tagliare la stringa prima che il controllo della lunghezza gestisca questo caso.

Eseguendo l'unit test contro il nuovo codice, fallisce solo sui letterali infinito e booleano e l'unica volta che dovrebbe essere un problema è se stai generando codice (in realtà, chi digita un letterale e controlla se è numerico? Dovresti saperlo ), e quello sarebbe un codice strano da generare.

Ma, ancora una volta, l'unica ragione per cui è possibile utilizzare questo è se per qualche ragione devi evitare isNaN ().

Qual è il modo più pulito ed efficace per convalidare i numeri decimali in JavaScript?

Punti bonus per:

  1. Chiarezza. La soluzione dovrebbe essere pulita e semplice.
  2. Cross-platform.

Casi test:

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

Dal momento che jQuery 1.7, è possibile utilizzare api.jquery.com/jQuery.isNumeric :

$.isNumeric('-1');      // true
$.isNumeric('-1.5');    // true
$.isNumeric('0');       // true
$.isNumeric('0.42');    // true
$.isNumeric('.42');     // true
$.isNumeric('0x89f');   // true (valid hexa number)
$.isNumeric('99,999');  // false
$.isNumeric('#abcdef'); // false
$.isNumeric('1.2.3');   // false
$.isNumeric('');        // false
$.isNumeric('blah');    // false

Basta notare che a differenza di quello che hai detto, 0x89f è un numero valido (hexa)


In questo modo sembra funzionare bene:

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

E per testarlo:

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

Ho preso in prestito quella regex da http://www.codetoad.com/javascript/isnumeric.asp . Spiegazione:

/^ 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

L'unico problema che ho avuto con la answer @ CMS è l'esclusione di NaN e Infinity, che sono numeri utili per molte situazioni. Un modo per verificare la presenza di NaN è controllare i valori numerici che non sono uguali, NaN != NaN ! Quindi ci sono davvero 3 test che ti piacerebbe affrontare ...

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 è molto simile a un'altra elegante answer , ma gestisce le esadecimali e altre rappresentazioni di numeri.


La risposta accettata ha fallito il test n. 7 e immagino sia perché hai cambiato idea. Quindi questa è una risposta alla risposta accettata, con la quale ho avuto problemi.

Durante alcuni progetti ho avuto bisogno di convalidare alcuni dati e di essere il più certo possibile che si tratti di un valore numerico javascript che può essere utilizzato nelle operazioni matematiche.

jQuery e alcune altre librerie javascript includono già tale funzione, solitamente chiamata isNumeric . C'è anche un post su che è stato ampiamente accettato come risposta, la stessa routine generale che le librerie citate stanno usando.

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

Innanzitutto, il codice precedente restituirebbe true se l'argomento era una matrice di lunghezza 1 e quell'elemento singolo era di un tipo ritenuto numerico dalla logica precedente. A mio parere, se si tratta di un array, non è numerico.

Per alleviare questo problema, ho aggiunto un controllo per scartare gli array dalla logica

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

Ovviamente, è anche possibile utilizzare Array.isArray , jquery $.isArray o prototype Object.isArray invece di Object.prototype.toString.call(n) !== '[object Array]'

Il mio secondo problema era che le stringhe letterali esadecimali negative ("-0xA" -> -10) non venivano contate come numeriche. Tuttavia, le stringhe letterali esadecimali positive ("0xA" -> 10) sono state trattate come numeriche. Avevo bisogno che entrambi fossero validi numerici.

Ho quindi modificato la logica per tenerne conto.

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

Se sei preoccupato della creazione della regex ogni volta che viene chiamata la funzione, puoi riscriverla all'interno di una chiusura, qualcosa come questa

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

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

Ho quindi preso CMS +30 test case e clonato il test su jsfiddle aggiunto i miei casi di test extra e la mia soluzione sopra descritta.

Non può sostituire la risposta largamente accettata / usata, ma se questo è più di ciò che ti aspetti come risultato della tua funzione isNumeric, allora spero che questo sia di qualche aiuto.

EDIT: Come sottolineato da Bergi , ci sono altri possibili oggetti che potrebbero essere considerati numerici e sarebbe meglio inserire nella whitelist della blacklist. Con questo in mente vorrei aggiungere ai criteri.

Voglio che la mia funzione isNumeric consideri solo numeri o stringhe

Con questo in mente, sarebbe meglio usare

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(/^-/, ''));
}

Prova le soluzioni

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>



Può essere fatto senza RegExp come

function IsNumeric(data){
    return parseFloat(data)==data;
}

Questo dovrebbe funzionare. Alcune delle funzioni fornite qui sono difettose, anche qui dovrebbero essere più veloci di qualsiasi altra funzione.

        function isNumeric(n)
        {
            var n2 = n;
            n = parseFloat(n);
            return (n!='NaN' && n2==n);
        }

Ha spiegato:

Crea una copia di se stesso, quindi converte il numero in virgola mobile, quindi confronta se stesso con il numero originale, se è ancora un numero (se intero o float) e corrisponde al numero originale, ciò significa che è effettivamente un numero.

Funziona con stringhe numeriche e numeri semplici. Non funziona con numeri esadecimali.

Attenzione: utilizzare a proprio rischio, nessuna garanzia.


Se non sbaglio, questo dovrebbe corrispondere a qualsiasi valore di numero JavaScript valido, escluse le costanti ( Infinity , NaN ) e gli operatori di segno + / - (poiché non sono effettivamente parte del numero per quanto mi riguarda, sono operatori separati ):

Avevo bisogno di questo per un tokenizer, in cui l'invio del numero a JavaScript per la valutazione non era un'opzione ... Non è sicuramente l'espressione regolare più breve possibile, ma credo che catturi tutte le sottigliezze più sottili della sintassi del numero di 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

I numeri validi includeranno:

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

I numeri non validi sarebbero

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

Un paio di test da aggiungere:

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

Mi sono inventato questo:

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

La soluzione copre:

  • Un segno negativo facoltativo all'inizio
  • Un singolo zero, o una o più cifre che non iniziano con 0, o nulla finché segue un periodo
  • Un periodo seguito da 1 o più numeri

Usa la funzione isNaN . Credo che se provi per !isNaN(yourstringhere) funziona bene per ognuna di queste situazioni.


Risposta di @CMS : lo snippet non è riuscito sui casi di spazio bianco sul mio computer utilizzando nodejs. Quindi l'ho combinato con la risposta di @ joel al seguente:

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

Non l'ho mai provato con quei casi che sono float:

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

e quei casi che non sono float (inclusi spazi bianchi e oggetti / matrici):

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

Tutto funziona come previsto qui. Forse questo aiuta.

Il codice sorgente completo per questo può essere trovato here .



Funzioni di convalida della libreria Inbuild knockout

Estendendolo il campo viene convalidato

1) numero

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

TestCase

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) cifra

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

TestCase

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 e max

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

Questo campo accetta solo valori compresi tra 5 e 10

TestCase

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

Mi piacerebbe aggiungere il seguente:

1. IsNumeric('0x89f') => true
2. IsNumeric('075') => true

I numeri esadecimali positivi iniziano con 0xe i numeri esadecimali negativi iniziano con -0x. I numeri ottici positivi iniziano con 0e i numeri ottici negativi iniziano con -0. Questo prende la maggior parte di ciò che è già stato menzionato in considerazione, ma include numeri esadecimale e ottale, negativo scientifico, Infinito e ha rimosso decimale scientifico ( 4e3.2non è valido).

function IsNumeric(input){
  var RE = /^-?(0|INF|(0[1-7][0-7]*)|(0x[0-9a-fA-F]+)|((0|[1-9][0-9]*|(?=[\.,]))([\.,][0-9]+)?([eE]-?\d+)?))$/;
  return (RE.test(input));
}

Mi rendo conto che questo è stato risposto molte volte, ma il seguente è un candidato decente che può essere utile in alcuni scenari.

va notato che presuppone che ".42" NON sia un numero e "4." NON è un numero, quindi questo dovrebbe essere preso in considerazione.

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

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

Il isDecimalpassa il seguente test:

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

L'idea qui è che ogni numero o numero intero ha una rappresentazione "canonica" di stringa, e ogni rappresentazione non canonica dovrebbe essere rifiutata. Quindi lanciamo un numero e torniamo indietro e vediamo se il risultato è la stringa originale.

Se queste funzioni sono utili per te dipende dal caso d'uso. Una caratteristica è che le stringhe distinte rappresentano numeri distinti (se entrambi superano il isNumber()test).

Questo è rilevante, ad esempio per i numeri come nomi di proprietà dell'oggetto.

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

Sto usando una soluzione più semplice:

function isNumber(num) {
    return parseFloat(num).toString() == num
}

Nessuna delle risposte restituisce falsestringhe vuote, una correzione per quello ...

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

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

Funziona anche per i numeri di tipo 0x23.


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

Se n è numerico Number(n), restituirà il valore numerico e toString()lo restituirà a una stringa. Ma se n non è numerico Number(n)verrà restituito in NaNmodo che non corrisponda all'originalen





numbers