Spero che ci sia qualcosa nello stesso spazio concettuale della vecchia IsNumeric()funzione VB6 ?

Per verificare se una variabile (inclusa una stringa) è un numero, controlla se non è un numero:

Funziona indipendentemente dal fatto che il contenuto della variabile sia una stringa o un numero.

isNaN(num)         // returns true if the variable does NOT contain a valid number

Esempi

isNaN(123)         // false
isNaN('123')       // false
isNaN('1e10000')   // false (This translates to Infinity, which is a number)
isNaN('foo')       // true
isNaN('10px')      // true

Certo, puoi negarlo se necessario. Ad esempio, per implementare l' IsNumericesempio che hai fornito:

function isNumeric(num){
  return !isNaN(num)
}

Per convertire una stringa contenente un numero in un numero:

Funziona solo se la stringa contiene solo caratteri numerici, altrimenti restituisce NaN.

+num               // returns the numeric value of the string, or NaN 
                   // if the string isn't purely numeric characters

Esempi

+'12'              // 12
+'12.'             // 12
+'12..'            // NaN
+'.12'             // 0.12
+'..12'            // NaN
+'foo'             // NaN
+'12px'            // NaN

Per convertire una stringa liberamente in un numero

Utile per convertire "12px" in 12, ad esempio:

parseInt(num)      // extracts a numeric value from the 
                   // start of the string, or NaN.

Esempi

parseInt('12')     // 12
parseInt('aaa')    // NaN
parseInt('12px')   // 12
parseInt('foo2')   // NaN      These last two may be different
parseInt('12a5')   // 12       from what you expected to see. 

Galleggianti

Tieni presente che, diversamente +num, parseInt(come suggerisce il nome) convertirai un float in un numero intero tagliando via tutto ciò che segue il punto decimale (se vuoi usare a parseInt() causa di questo comportamento, probabilmente stai meglio usando un altro metodo ) :

+'12.345'          // 12.345
parseInt(12.345)   // 12
parseInt('12.345') // 12

Stringhe vuote

Le stringhe vuote possono essere poco intuitive. +numconverte le stringhe o le stringhe vuote con spazi in zero e isNaN()assume lo stesso:

+''                // 0
+'   '             // 0
isNaN('')          // false
isNaN('   ')       // false

Ma parseInt()non è d'accordo:

parseInt('')       // NaN
parseInt('   ')    // NaN

E potresti andare nel modo RegExp:

var num = "987238";

if(num.match(/^-{0,1}\d+$/)){
  //valid integer (positive or negative)
}else if(num.match(/^\d+\.\d+$/)){
  //valid float
}else{
  //not valid number
}

Se stai solo cercando di verificare se una stringa è un numero intero (senza posizioni decimali), regex è un buon modo per andare. Altri metodi come isNaNsono troppo complicati per qualcosa di così semplice.

function isNumeric(value) {
    return /^-{0,1}\d+$/.test(value);
}

console.log(isNumeric('abcd'));         // false
console.log(isNumeric('123a'));         // false
console.log(isNumeric('1'));            // true
console.log(isNumeric('1234567890'));   // true
console.log(isNumeric('-23'));          // true
console.log(isNumeric(1234));           // true
console.log(isNumeric('123.4'));        // false
console.log(isNumeric(''));             // false
console.log(isNumeric(undefined));      // false
console.log(isNumeric(null));           // false

Per consentire solo numeri interi positivi utilizzare questo:

function isNumeric(value) {
    return /^\d+$/.test(value);
}

console.log(isNumeric('123'));          // true
console.log(isNumeric('-23'));          // false

Se davvero si vuole fare in modo che una stringa contiene solo un numero, un numero qualsiasi (numero intero o in virgola mobile), ed esattamente un numero, non è possibile utilizzare parseInt()/ parseFloat(), Number()o !isNaN()da soli. Nota che in !isNaN()realtà sta tornando truequando Number()restituirebbe un numero e falsequando ritornerebbe NaN, quindi lo escluderò dal resto della discussione.

Il problema parseFloat()è che restituirà un numero se la stringa contiene un numero qualsiasi, anche se la stringa non contiene solo ed esattamente un numero:

parseFloat("2016-12-31")  // returns 2016
parseFloat("1-1") // return 1
parseFloat("1.2.3") // returns 1.2

Il problema Number()è che restituirà un numero nei casi in cui il valore passato non è affatto un numero!

Number("") // returns 0
Number(" ") // returns 0
Number(" \u00A0   \t\n\r") // returns 0

Il problema con il rotolamento del proprio regex è che, a meno che non si crei il regex esatto per abbinare un numero in virgola mobile come Javascript lo riconosce, si perderanno casi o si riconosceranno casi in cui non si dovrebbe. E anche se riesci a creare il tuo regex, perché? Esistono modi più semplici per farlo.

Tuttavia, si scopre che Number()(e isNaN()) fa la cosa giusta per ogni caso in cui parseFloat()restituisce un numero quando non dovrebbe, e viceversa. Quindi, per scoprire se una stringa è davvero esattamente e solo un numero, chiama entrambe le funzioni e vedi se entrambe restituiscono true:

function isNumber(str) {
  if (typeof str != "string") return false // we only process strings!
  // could also coerce to string: str = ""+str
  return !isNaN(str) && !isNaN(parseFloat(str))
}

La risposta accettata per questa domanda ha alcuni difetti (come evidenziato da un paio di altri utenti). Questo è uno dei modi più semplici e comprovati per affrontarlo in javascript:

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

Di seguito sono riportati alcuni buoni casi di test:

console.log(isNumeric(12345678912345678912)); // true
console.log(isNumeric('2 '));                 // true
console.log(isNumeric('-32.2 '));             // true
console.log(isNumeric(-32.2));                // true
console.log(isNumeric(undefined));            // false

// the accepted answer fails at these tests:
console.log(isNumeric(''));                   // false
console.log(isNumeric(null));                 // false
console.log(isNumeric([]));                   // false

Prova la funzione isNan :

La funzione isNaN () determina se un valore è un numero non valido (non un numero).

Questa funzione restituisce true se il valore equivale a NaN. Altrimenti restituisce false.

Questa funzione è diversa dal metodo Number.isNaN () specifico per il numero .

  La funzione isNaN () globale, converte il valore testato in un numero, quindi lo verifica.

Number.isNan () non converte i valori in un numero e non restituirà true per qualsiasi valore che non sia del tipo Numero ...

Vecchia domanda, ma mancano diversi punti nelle risposte fornite.

Notazione scientifica.

!isNaN('1e+30')è true, tuttavia nella maggior parte dei casi quando le persone chiedono numeri, non vogliono abbinare cose come 1e+30.

I grandi numeri fluttuanti possono comportarsi in modo strano

Osservare (usando Node.js):

> var s = Array(16 + 1).join('9')
undefined
> s.length
16
> s
'9999999999999999'
> !isNaN(s)
true
> Number(s)
10000000000000000
> String(Number(s)) === s
false
>

D'altro canto:

> var s = Array(16 + 1).join('1')
undefined
> String(Number(s)) === s
true
> var s = Array(15 + 1).join('9')
undefined
> String(Number(s)) === s
true
>

Quindi, se uno si aspetta String(Number(s)) === s, allora limitare meglio le stringhe a un massimo di 15 cifre (dopo aver omesso gli zeri iniziali).

Infinito

> typeof Infinity
'number'
> !isNaN('Infinity')
true
> isFinite('Infinity')
false
>

Detto questo, verificando che la stringa data sia un numero che soddisfi tutti i seguenti elementi:

• notazione non scientifica
• conversione prevedibile in Number e ritorno aString
• finito

non è un compito così facile. Ecco una versione semplice:

  function isNonScientificNumberString(o) {
    if (!o || typeof o !== 'string') {
      // Should not be given anything but strings.
      return false;
    }
    return o.length <= 15 && o.indexOf('e+') < 0 && o.indexOf('E+') < 0 && !isNaN(o) && isFinite(o);
  }

Tuttavia, anche questo è lungi dall'essere completo. Gli zeri iniziali non vengono gestiti qui, ma avvitano il test di lunghezza.

Ho testato e la soluzione di Michael è la migliore. Vota la sua risposta sopra (cerca questa pagina per "Se vuoi davvero assicurarti che una stringa" per trovarla). In sostanza, la sua risposta è questa:

function isNumeric(num){
  num = "" + num; //coerce num to be a string
  return !isNaN(num) && !isNaN(parseFloat(num));
}

Funziona per ogni caso di test, che ho documentato qui: https://jsfiddle.net/wggehvp9/5/

Molte delle altre soluzioni falliscono per questi casi limite: '', null, "", true e []. In teoria, potresti usarli, con una corretta gestione degli errori, ad esempio:

return !isNaN(num);

o

return (+num === +num);

con una gestione speciale per / \ s /, null, "", true, false, [] (e altri?)

È possibile utilizzare il risultato di Numero quando si passa un argomento al suo costruttore.

Se l'argomento (una stringa) non può essere convertito in un numero, restituisce NaN, quindi è possibile determinare se la stringa fornita fosse o meno un numero valido.

Note: Nota quando passa stringa vuota o '\t\t'e '\n\t'come numero tornerà 0; Il passaggio true restituirà 1 e false restituirà 0.

    Number('34.00') // 34
    Number('-34') // -34
    Number('123e5') // 12300000
    Number('123e-5') // 0.00123
    Number('999999999999') // 999999999999
    Number('9999999999999999') // 10000000000000000 (integer accuracy up to 15 digit)
    Number('0xFF') // 255
    Number('Infinity') // Infinity  

    Number('34px') // NaN
    Number('xyz') // NaN
    Number('true') // NaN
    Number('false') // NaN

    // cavets
    Number('    ') // 0
    Number('\t\t') // 0
    Number('\n\t') // 0

Forse ci sono una o due persone che incontrano questa domanda che hanno bisogno di un controllo molto più rigoroso del solito (come ho fatto io). In tal caso, questo potrebbe essere utile:

if(str === String(Number(str))) {
  // it's a "perfectly formatted" number
}

Attenzione! Questo rifiuterà stringhe come .1, 40.000, 080, 00.1. È molto esigente - la stringa deve corrispondere alla " forma perfetta più minimale " del numero per superare questo test.

Utilizza il costruttore Stringe Numberper eseguire il cast della stringa in un numero e viceversa e quindi controlla se la "forma minima perfetta" del motore JavaScript (quella in cui è stata convertita con il Numbercostruttore iniziale ) corrisponde alla stringa originale.

parseInt (), ma tieni presente che questa funzione è leggermente diversa, nel senso che ad esempio restituisce 100 per parseInt ("100px").

Citazione:

isNaN (num) // restituisce true se la variabile NON contiene un numero valido

non è del tutto vero se è necessario verificare la presenza di spazi iniziali / finali, ad esempio quando è richiesta una determinata quantità di cifre e è necessario ottenere, ad esempio, "1111" e non "111" o "111", forse per un PIN ingresso.

Meglio usare:

var num = /^\d+$/.test(num)

Perché l'implementazione di jQuery non è abbastanza buona?

function isNumeric(a) {
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0;
};

Michael ha suggerito qualcosa del genere (anche se ho rubato qui la versione modificata di "user1691651 - John"):

function isNumeric(num){
    num = "" + num; //coerce num to be a string
    return !isNaN(num) && !isNaN(parseFloat(num));
}

Quella che segue è una soluzione con molto probabilmente cattive prestazioni, ma risultati concreti. È un aggeggio fatto dall'implementazione di jQuery 1.12.4 e dalla risposta di Michael, con un controllo extra per gli spazi iniziali / finali (perché la versione di Michael ritorna vera per i numeri con spazi iniziali / finali):

function isNumeric(a) {
    var str = a + "";
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0 &&
           !/^\s+|\s+$/g.test(str) &&
           !isNaN(str) && !isNaN(parseFloat(str));
};

Tuttavia, quest'ultima versione ha due nuove variabili. Si potrebbe aggirare uno di questi, facendo:

function isNumeric(a) {
    if ($.isArray(a)) return false;
    var b = a && a.toString();
    a = a + "";
    return b - parseFloat(b) + 1 >= 0 &&
            !/^\s+|\s+$/g.test(a) &&
            !isNaN(a) && !isNaN(parseFloat(a));
};

Non ho ancora testato nessuno di questi, con altri metodi che testare manualmente i pochi casi d'uso che colpirò con la mia situazione attuale, che è tutta roba molto standard. Questa è una situazione "in piedi sulle spalle dei giganti".

Non è valido per TypeScript come:

declare function isNaN(number: number): boolean;

Per TypeScript puoi usare:

/^\d+$/.test(key)

Bene, sto usando questo che ho fatto ...

Ha funzionato finora:

function checkNumber(value) {
    if ( value % 1 == 0 )
    return true;
    else
    return false;
}

Se riscontri qualche problema, dimmelo, per favore.

Se qualcuno arriva così in basso, ho passato un po 'di tempo a fare questo hacker cercando di correggere moment.js ( https://github.com/moment/moment ). Ecco qualcosa che ho tolto da esso:

function isNumeric(val) {
    var _val = +val;
    return (val !== val + 1) //infinity check
        && (_val === +val) //Cute coercion check
        && (typeof val !== 'object') //Array/object check
}

Gestisce i seguenti casi:

Vero! :

isNumeric("1"))
isNumeric(1e10))
isNumeric(1E10))
isNumeric(+"6e4"))
isNumeric("1.2222"))
isNumeric("-1.2222"))
isNumeric("-1.222200000000000000"))
isNumeric("1.222200000000000000"))
isNumeric(1))
isNumeric(0))
isNumeric(-0))
isNumeric(1010010293029))
isNumeric(1.100393830000))
isNumeric(Math.LN2))
isNumeric(Math.PI))
isNumeric(5e10))

Falso! :

isNumeric(NaN))
isNumeric(Infinity))
isNumeric(-Infinity))
isNumeric())
isNumeric(undefined))
isNumeric('[1,2,3]'))
isNumeric({a:1,b:2}))
isNumeric(null))
isNumeric([1]))
isNumeric(new Date()))

Ironia della sorte, quello con cui sto lottando di più:

isNumeric(new Number(1)) => false

Eventuali suggerimenti sono benvenuti. :]

Utilizzando JavaScript semplice:

Number.isNaN(Number('1')); // false
Number.isNaN(Number('asdf')); // true

Utilizzando Lodash:

_.isNaN(_.toNumber('1')); // false
_.isNaN(_.toNumber('asdf')); // true

function isNumberCandidate(s) {
  const str = (''+ s).trim();
  if (str.length === 0) return false;
  return !isNaN(+str);
}

console.log(isNumberCandidate('1'));       // true
console.log(isNumberCandidate('a'));       // false
console.log(isNumberCandidate('000'));     // true
console.log(isNumberCandidate('1a'));      // false 
console.log(isNumberCandidate('1e'));      // false
console.log(isNumberCandidate('1e-1'));    // true
console.log(isNumberCandidate('123.3'));   // true
console.log(isNumberCandidate(''));        // false
console.log(isNumberCandidate(' '));       // false
console.log(isNumberCandidate(1));         // true
console.log(isNumberCandidate(0));         // true
console.log(isNumberCandidate(NaN));       // false
console.log(isNumberCandidate(undefined)); // false
console.log(isNumberCandidate(null));      // false
console.log(isNumberCandidate(-1));        // true
console.log(isNumberCandidate('-1'));      // true
console.log(isNumberCandidate('-1.2'));    // true
console.log(isNumberCandidate(0.0000001)); // true
console.log(isNumberCandidate('0.0000001')); // true
console.log(isNumberCandidate(Infinity));    // true
console.log(isNumberCandidate(-Infinity));    // true

console.log(isNumberCandidate('Infinity'));  // true

if (isNumberCandidate(s)) {
  // use +s as a number
  +s ...
}

2019: inclusi ES3, ES6 ed esempi TypeScript

Forse questo è stato riproposto troppe volte, tuttavia ho combattuto anche con questo oggi e volevo pubblicare la mia risposta, poiché non ho visto nessun'altra risposta che lo fa in modo semplice o completo:

ES3

var isNumeric = function(num){
    return (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);  
}

ES6

const isNumeric = (num) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);

Dattiloscritto

const isNumeric = (num: any) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num as number);

Questo sembra abbastanza semplice e copre tutte le basi che ho visto su molti altri post e ho pensato:

// Positive Cases
console.log(0, isNumeric(0) === true);
console.log(1, isNumeric(1) === true);
console.log(1234567890, isNumeric(1234567890) === true);
console.log('1234567890', isNumeric('1234567890') === true);
console.log('0', isNumeric('0') === true);
console.log('1', isNumeric('1') === true);
console.log('1.1', isNumeric('1.1') === true);
console.log('-1', isNumeric('-1') === true);
console.log('-1.2354', isNumeric('-1.2354') === true);
console.log('-1234567890', isNumeric('-1234567890') === true);
console.log(-1, isNumeric(-1) === true);
console.log(-32.1, isNumeric(-32.1) === true);
console.log('0x1', isNumeric('0x1') === true);  // Valid number in hex
// Negative Cases
console.log(true, isNumeric(true) === false);
console.log(false, isNumeric(false) === false);
console.log('1..1', isNumeric('1..1') === false);
console.log('1,1', isNumeric('1,1') === false);
console.log('-32.1.12', isNumeric('-32.1.12') === false);
console.log('[blank]', isNumeric('') === false);
console.log('[spaces]', isNumeric('   ') === false);
console.log('null', isNumeric(null) === false);
console.log('undefined', isNumeric(undefined) === false);
console.log([], isNumeric([]) === false);
console.log('NaN', isNumeric(NaN) === false);

Puoi anche provare il tuo isNumeric funzione e appena passato in questi casi d'uso e scansionare "vero" per tutti loro.

Oppure, per vedere i valori che ognuno restituisce:

2019: controllo numerico pratico e rigoroso

Spesso, un "numero valido" indica un numero Javascript che esclude NaN e Infinity, ovvero un "numero finito".

Per verificare la validità numerica di un valore (ad esempio da una fonte esterna), è possibile definire in stile ESlint Airbnb:

/**
 * Returns true if 'candidate' is a finite number or a string referring (not just 'including') a finite number
 * To keep in mind:
 *   Number(true) = 1
 *   Number('') = 0
 *   Number("   10  ") = 10
 *   !isNaN(true) = true
 *   parseFloat('10 a') = 10
 *
 * @param {?} candidate
 * @return {boolean}
 */
function isReferringFiniteNumber(candidate) {
  if (typeof (candidate) === 'number') return Number.isFinite(candidate);
  if (typeof (candidate) === 'string') {
    return (candidate.trim() !== '') && Number.isFinite(Number(candidate));
  }
  return false;
}

e usalo in questo modo:

if (isReferringFiniteNumber(theirValue)) {
  myCheckedValue = Number(theirValue);
} else {
  console.warn('The provided value doesn\'t refer to a finite number');
}

PFB la soluzione di lavoro:

 function(check){ 
    check = check + "";
    var isNumber =   check.trim().length>0? !isNaN(check):false;
    return isNumber;
    }

Salva te stesso il mal di testa nel tentativo di trovare una soluzione "integrata".

Non c'è una buona risposta e la risposta enormemente votata in questo thread è sbagliata.

npm install is-number

In JavaScript, non è sempre così semplice come dovrebbe essere per verificare in modo affidabile se un valore è un numero. È comune per gli sviluppatori usare +, - o Number () per trasmettere un valore di stringa a un numero (ad esempio, quando i valori vengono restituiti dall'input dell'utente, corrispondenze regex, parser, ecc.). Ma ci sono molti casi limite non intuitivi che producono risultati inaspettati:

console.log(+[]); //=> 0
console.log(+''); //=> 0
console.log(+'   '); //=> 0
console.log(typeof NaN); //=> 'number'

Di recente ho scritto un articolo su come garantire che una variabile sia un numero valido: https://github.com/jehugaleahsa/artifacts/blob/master/2018/typescript_num_hack.md L'articolo spiega come garantire il virgola mobile o intero, se è importante ( +xvs~~x ).

L'articolo presuppone che la variabile sia a stringo a numberper cominciare ed trimè disponibile / polifilata. Non sarebbe difficile estenderlo per gestire anche altri tipi. Ecco la carne di esso:

// Check for a valid float
if (x == null
    || ("" + x).trim() === ""
    || isNaN(+x)) {
    return false;  // not a float
}

// Check for a valid integer
if (x == null
    || ("" + x).trim() === ""
    || ~~x !== +x) {
    return false;  // not an integer
}

Il mio tentativo di un po 'di confusione, Pherhaps non è la soluzione migliore

function isInt(a){
    return a === ""+~~a
}


console.log(isInt('abcd'));         // false
console.log(isInt('123a'));         // false
console.log(isInt('1'));            // true
console.log(isInt('0'));            // true
console.log(isInt('-0'));           // false
console.log(isInt('01'));           // false
console.log(isInt('10'));           // true
console.log(isInt('-1234567890'));  // true
console.log(isInt(1234));           // false
console.log(isInt('123.4'));        // false
console.log(isInt(''));             // false

// other types then string returns false
console.log(isInt(5));              // false
console.log(isInt(undefined));      // false
console.log(isInt(null));           // false
console.log(isInt('0x1'));          // false
console.log(isInt(Infinity));       // false

Nella mia applicazione consentiamo solo az AZ e 0-9 caratteri. Ho trovato la risposta sopra usando " stringa % 1 === 0" funzionava a meno che la stringa non iniziasse con 0xnn (come 0x10) e poi l'avrebbe restituita come numero quando non lo volevamo. La seguente semplice trappola nel mio controllo numerico sembra fare il trucco nei nostri casi specifici.

function isStringNumeric(str_input){   
    //concat a temporary 1 during the modulus to keep a beginning hex switch combination from messing us up   
    //very simple and as long as special characters (non a-z A-Z 0-9) are trapped it is fine   
    return '1'.concat(str_input) % 1 === 0;}

Avvertenza : questo potrebbe sfruttare un bug di vecchia data in Javascript e Actionscript [Number ("1" + the_string)% 1 === 0)], non posso parlarne, ma è esattamente ciò di cui avevamo bisogno.

La mia soluzione:

// returns true for positive ints; 
// no scientific notation, hexadecimals or floating point dots

var isPositiveInt = function(str) { 
   var result = true, chr;
   for (var i = 0, n = str.length; i < n; i++) {
       chr = str.charAt(i);
       if ((chr < "0" || chr > "9") && chr != ",") { //not digit or thousands separator
         result = false;
         break;
       };
       if (i == 0 && (chr == "0" || chr == ",")) {  //should not start with 0 or ,
         result = false;
         break;
       };
   };
   return result;
 };

È possibile aggiungere condizioni aggiuntive all'interno del loop, per adattarsi a esigenze particolari.

È possibile utilizzare tipi, come con la libreria di flusso y, per ottenere un controllo statico del tempo di compilazione. Ovviamente non estremamente utile per l'input dell'utente.

// @flow

function acceptsNumber(value: number) {
  // ...
}

acceptsNumber(42);       // Works!
acceptsNumber(3.14);     // Works!
acceptsNumber(NaN);      // Works!
acceptsNumber(Infinity); // Works!
acceptsNumber("foo");    // Error!

Ecco una riga per verificare se sNumè un valore numerico valido; è stato testato per un'ampia varietà di input:

!isNaN(+s.replace(/\s|\$/g, ''));  // returns True if numeric value

Basta usare isNaN(), questo convertirà la stringa in un numero e se ottieni un numero valido , restituirà false...

isNaN("Alireza"); //return true
isNaN("123"); //return false

Sto usando il seguente:

const isNumber = s => !isNaN(+s)