Convalidare i numeri decimali in JavaScript – IsNumeric ()

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 

@ La risposta di Joel è piuttosto vicina, ma fallirà nei seguenti casi:

 // Whitespace strings: IsNumeric(' ') == true; IsNumeric('\t\t') == true; IsNumeric('\n\r') == true; // Number literals: IsNumeric(-1) == false; IsNumeric(0) == false; IsNumeric(1.1) == false; IsNumeric(8e5) == false; 

Qualche tempo fa ho dovuto implementare una funzione IsNumeric , per scoprire se una variabile conteneva un valore numerico, indipendentemente dal suo tipo , poteva essere una String contenente un valore numerico (dovevo considerare anche la notazione esponenziale, ecc.), Number object, praticamente qualsiasi cosa potrebbe essere passata a quella funzione, non potrei fare nessun tipo di ipotesi, avendo cura della coercizione di tipo (ad esempio +true == 1; ma true non dovrebbe essere considerato come "numeric" ).

Credo valga la pena condividere questo set di +30 unit test fatti su numerose implementazioni di funzioni, e condividere anche quello che supera tutti i miei test:

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

PS isNaN e isFinite hanno un comportamento confuso dovuto alla conversione forzata in numero. In ES6, Number.isNaN e Number.isFinite risolvono questi problemi. Tienilo a mente quando li usi.


Aggiornamento : ecco come jQuery lo fa ora (2.2-stabile) :

 isNumeric: function(obj) { var realStringObj = obj && obj.toString(); return !jQuery.isArray(obj) && (realStringObj - parseFloat(realStringObj) + 1) >= 0; } 

Aggiornamento : angular 4.3 :

 export function isNumeric(value: any): boolean { return !isNaN(value - parseFloat(value)); } 

Arrrgh! Non ascoltare le risposte alle espressioni regolari. RegEx è icky per questo, e non sto parlando solo delle prestazioni. È così facile rendere sottile, imansible 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 è ansible utilizzare questo è se per qualche ragione devi evitare isNaN ().

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 

Yahoo! L’interfaccia utente utilizza questo:

 isNumber: function(o) { return typeof o === 'number' && isFinite(o); } 
 function IsNumeric(num) { return (num >=0 || num < 0); } 

Funziona anche per i numeri di tipo 0x23.

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

isNumber Test Cases

Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.95 Safari/537.11

  1. Integer Literals (0, 10, 10)
    1. Negative integer string
    2. Zero string
    3. Positive integer string
    4. Negative integer number
    5. Zero integer number
    6. Positive integer number
    7. Octal integer literal string
    8. Octal integer literal
    9. Hexadecimal integer literal string
    10. Hexadecimal integer literal
  2. Foating-Point Literals (0, 6, 6)
    1. Negative floating point string
    2. Positive floating point string
    3. Negative floating point number
    4. Positive floating point number
    5. Exponential notation
    6. Exponential notation string
  3. Non-Numeric values (0, 18, 18)
    1. Empty string: false
    2. Whitespace characters string: false
    3. Tab characters string: false
    4. Alphanumeric character string: false
    5. Non-numeric character string: false
    6. Boolean true literal: false
    7. Boolean false literal: false
    8. Number with preceding non-numeric characters: false
    9. Number with trailling non-numeric characters: false
    10. Undefined value: false
    11. Null value: false
    12. NaN value: false
    13. Infinity primitive: false
    14. Positive Infinity: false
    15. Negative Infinity: false
    16. Date object: false
    17. Empty object: false
    18. Instance of a function: false
This page contains tests for a set of isNumber functions. To see them, take a look at the source.

Tests completed in 0 milliseconds.
0 tests of 0 failed.

Sì, il built-in isNaN(object) sarà molto più veloce di qualsiasi analisi regex, perché è integrato e compilato, invece di essere interpretato al volo.

Anche se i risultati sono leggermente diversi da quello che stai cercando ( provalo ):

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

Dal momento che jQuery 1.7, è ansible utilizzare 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)

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

Può essere fatto senza RegExp come

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

Mi rendo conto che la domanda originale non menzionava jQuery, ma se usi jQuery, puoi fare:

 $.isNumeric(val) 

Semplice.

https://api.jquery.com/jQuery.isNumeric/ (come da jQuery 1.7)

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 ansible, ma credo che catturi tutte le sottigliezze più sottili della syntax 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 
 return (input - 0) == input && input.length > 0; 

non ha funzionato per me Quando ho messo un avviso e testato, input.length era undefined . Penso che non ci siano proprietà per controllare la lunghezza intera. Quindi quello che ho fatto è stato

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

Ha funzionato bene.

Per me, questo è il modo migliore:

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

Un valore intero può essere verificato da:

 function isNumeric(value) { var bool = isNaN(+value)); bool = bool || (value.indexOf('.') != -1); bool = bool || (value.indexOf(",") != -1); return !bool; }; 

In questo modo è più facile e più veloce! Tutti i test sono controllati!

Ecco una versione leggermente migliorata (probabilmente la via più veloce là fuori) che uso al posto della variante esatta di jQuery, non so davvero perché non usano questo:

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

Lo svantaggio della versione di jQuery è che se si passa una stringa con numeri e lettere "123abc" come "123abc" il parseFloat | parseInt parseFloat | parseInt estrae la frazione numerica e restituisce 123, MA, la seconda guardia isFinite fallirà comunque. Con l’operatore unario + morirà sulla prima guardia da + getta NaN per tali ibridi 🙂 Un po ‘di performance, tuttavia, penso che un solido guadagno semantico.

L’unico problema che ho avuto con la risposta di @ 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 risposta , ma gestisce le esadecimali e altre rappresentazioni di numeri.

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

La mia soluzione,

 function isNumeric(input) { var number = /^\-{0,1}(?:[0-9]+){0,1}(?:\.[0-9]+){0,1}$/i; var regex = RegExp(number); return regex.test(input) && input.length>0; } 

Sembra funzionare in ogni situazione, ma potrei sbagliarmi.

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.

I’d like to add the following:

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

Positive hex numbers start with 0x and negative hex numbers start with -0x . Positive oct numbers start with 0 and negative oct numbers start with -0 . This one takes most of what has already been mentioned into consideration, but includes hex and octal numbers, negative scientific, Infinity and has removed decimal scientific ( 4e3.2 is not valid).

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

I’m using simpler solution:

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

None of the answers return false for empty strings, a fix for that…

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

@CMS’ answer : Your snippet failed on whitespace cases on my machine using nodejs. So I combined it with @joel’s answer to the following:

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

I unittested it with those cases that are floats:

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

and those cases that are no floats (including empty whitespaces and objects / arrays):

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

Everything works as expected here. Maybe this helps.

Full source code for this can be found here .

The following seems to works fine for many cases:

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

This is built on top of this answer (which is for this answer too): https://stackoverflow.com/a/1561597/1985601

I realize this has been answered many times, but the following is a decent candidate which can be useful in some scenarios.

it should be noted that it assumes that ‘.42’ is NOT a number, and ‘4.’ is NOT a number, so this should be taken into account.

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

The isDecimal passes the following 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'); } 

The idea here is that every number or integer has one “canonical” string representation, and every non-canonical representation should be rejected. So we cast to a number and back, and see if the result is the original string.

Whether these functions are useful for you depends on the use case. One feature is that distinct strings represent distinct numbers (if both pass the isNumber() test).

This is relevant eg for numbers as object property names.

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

knockoutJs Inbuild library validation functions

By extending it the field get validated

1) number

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

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

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

This field accept value between 5 and 10 only

TestCase

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

To check if a variable contains a valid number and not just a String which looks like a number, Number.isFinite(value) can be used.

This is part of the language since ES2015

Esempi:

 Number.isFinite(Infinity) // false Number.isFinite(NaN) // false Number.isFinite(-Infinity) // false Number.isFinite(0) // true Number.isFinite(2e64) // true Number.isFinite('0') // false Number.isFinite(null) // false 

You can minimize this function in a lot of way, and you can also implement it with a custom regex for negative values or custom charts:

 $('.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) }); 
 function inNumeric(n){ return Number(n).toString() === n; } 

If n is numeric Number(n) will return the numeric value and toString() will turn it back to a string. But if n isn’t numeric Number(n) will return NaN so it won’t match the original n