Prüfen Sie, ob die Variable in JavaScript eine Zahl oder eine Zeichenfolge ist

Am besten verwenden Sie den isNaN + -Typ:

Aktualisierte All-In-Methode:

function isNumber(n) { return !isNaN(parseFloat(n)) && !isNaN(n - 0) }

Dasselbe mit Regex:

function isNumber(n) { return /^-?[\d.]+(?:e-?\d+)?$/.test(n); } 

------------------------

isNumber ('123'); // true  
isNumber ('123abc'); // true  
isNumber (5); // true  
isNumber ('q345'); // false
isNumber(null); // false
isNumber(undefined); // false
isNumber(false); // false
isNumber('   '); // false

Der beste Weg, den ich gefunden habe, ist, entweder nach einer Methode für den String zu suchen, d. H .:

if (x.substring) {
// do string thing
} else{
// do other thing
}

oder wenn Sie etwas mit der Nummer machen wollen, prüfen Sie eine Nummerneigenschaft,

if (x.toFixed) {
// do number thing
} else {
// do other thing
}

Das ist eine Art "Entenschreiben", es liegt an Ihnen, welcher Weg am sinnvollsten ist. Ich habe nicht genug Karma, um etwas zu kommentieren, aber typeof schlägt für geschachtelte Strings und Zahlen fehl, d. H .:

alert(typeof new String('Hello World'));
alert(typeof new Number(5));

wird "Objekt" alarmieren.

Prüfen Sie, ob der Wert ein String-Literal oder ein String-Objekt ist:

function isString(o) {
    return typeof o == "string" || (typeof o == "object" && o.constructor === String);
}

Gerätetest:

function assertTrue(value, message) {
    if (!value) {
        alert("Assertion error: " + message);
    }
}

function assertFalse(value, message)
{
    assertTrue(!value, message);
}

assertTrue(isString("string literal"), "number literal");
assertTrue(isString(new String("String object")), "String object");
assertFalse(isString(1), "number literal");
assertFalse(isString(true), "boolean literal");
assertFalse(isString({}), "object");

Das Prüfen auf eine Nummer ist ähnlich:

function isNumber(o) {
    return typeof o == "number" || (typeof o == "object" && o.constructor === Number);
}

Sie suchen nach isNaN():

console.log(!isNaN(123));
console.log(!isNaN(-1.23));
console.log(!isNaN(5-2));
console.log(!isNaN(0));
console.log(!isNaN("0"));
console.log(!isNaN("2"));
console.log(!isNaN("Hello"));
console.log(!isNaN("2005/12/12"));

Siehe JavaScript isNaN () Funktion am MDN.

Seit ES2015 ist der korrekte Weg, um zu prüfen, ob eine Variable.

Number.isFinite(value)

Beispiele:

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

Versuche dies,

<script>
var regInteger = /^\d+$/;

function isInteger( str ) {    
    return regInteger.test( str );
}

if(isInteger("1a11")) {
   console.log( 'Integer' );
} else {
   console.log( 'Non Integer' );
}
</script>

//testing data types accurately in JavaScript (opposed to "typeof")
//from http://bonsaiden.github.com/JavaScript-Garden/
function is(type, obj) {
    var clas = Object.prototype.toString.call(obj).slice(8, -1);
    return obj !== undefined && obj !== null && clas === type;
}

//basic usage
is('String', 'test'); // true
is('Array', true); // false

Oder passen Sie es an, um einen unbekannten Typ zurückzugeben:

function realTypeOf(obj) {
    return Object.prototype.toString.call(obj).slice(8, -1);
}

//usage
realTypeOf(999); // 'Number'

12. Mai 2012 Update: Vollständiges Beispiel bei Javascript: Ein besserer Typ von .

Am besten so:

function isNumber(num) {
  return (typeof num == 'string' || typeof num == 'number') && !isNaN(num - 0) && num !== '';
};

Dies erfüllt die folgenden Testfälle:

assertEquals("ISNUMBER-True: 0", true, isNumber(0));
assertEquals("ISNUMBER-True: 1", true, isNumber(-1));
assertEquals("ISNUMBER-True: 2", true, isNumber(-500));
assertEquals("ISNUMBER-True: 3", true, isNumber(15000));
assertEquals("ISNUMBER-True: 4", true, isNumber(0.35));
assertEquals("ISNUMBER-True: 5", true, isNumber(-10.35));
assertEquals("ISNUMBER-True: 6", true, isNumber(2.534e25));
assertEquals("ISNUMBER-True: 7", true, isNumber('2.534e25'));
assertEquals("ISNUMBER-True: 8", true, isNumber('52334'));
assertEquals("ISNUMBER-True: 9", true, isNumber('-234'));

assertEquals("ISNUMBER-False: 0", false, isNumber(NaN));
assertEquals("ISNUMBER-False: 1", false, isNumber({}));
assertEquals("ISNUMBER-False: 2", false, isNumber([]));
assertEquals("ISNUMBER-False: 3", false, isNumber(''));
assertEquals("ISNUMBER-False: 4", false, isNumber('one'));
assertEquals("ISNUMBER-False: 5", false, isNumber(true));
assertEquals("ISNUMBER-False: 6", false, isNumber(false));
assertEquals("ISNUMBER-False: 7", false, isNumber());
assertEquals("ISNUMBER-False: 8", false, isNumber(undefined));
assertEquals("ISNUMBER-False: 9", false, isNumber(null));

Hier ist ein Ansatz, der auf der Idee basiert, die Eingabe in eine Zahl oder eine Zeichenfolge umzuwandeln, indem eine Null- oder Nullzeichenfolge hinzugefügt wird, und dann einen typisierten Gleichheitsvergleich durchführen.

function is_number(x) { return x === x+0;  }
function is_string(x) { return x === x+""; }

Aus irgendeinem unerfindlichen Grund scheint x===x+0 besser zu sein als x===+x.

Gibt es Fälle, in denen dies fehlschlägt?

In der gleichen Richtung:

function is_boolean(x) { return x === !!x; }

Dies scheint geringfügig schneller zu sein als x===true || x===false oder typeof x==="boolean" (und viel schneller als x===Boolean(x)).

Dann gibt es auch noch 

function is_regexp(x)  { return x === RegExp(x); }

All dies hängt von der Existenz einer "Identitäts" -Operation für jeden Typ ab, die auf jeden Wert angewendet werden kann und zuverlässig einen Wert des betreffenden Typs erzeugt. Ich kann mir keine solche Operation für Termine vorstellen.

Für NaN gibt es

function is_nan(x) { return x !== x;}

Dies ist im Grunde die Unterstreichungsversion, und wie sie aussieht, ist sie etwa viermal schneller als isNaN(), aber die Kommentare in der Unterstreichungsquelle erwähnen, dass "NaN ist die einzige Zahl die sich selbst nicht gleich ist" und fügt eine Prüfung für _ hinzu. ist Nummer. Warum? Welche anderen Objekte würden sich nicht gleich sein? Unterstriche verwenden auch x !== +x--, aber was könnte der + hier ausmachen?

Dann für die Paranoiker:

function is_undefined(x) { return x===[][0]; }

Kannst du es einfach durch 1 teilen?

Ich gehe davon aus, dass das Problem eine Zeicheneingabe wie "123ABG" wäre.

var Check = "123ABG"

if(Check == Check / 1)
{
alert("This IS a number \n")
}

else
{
alert("This is NOT a number \n")
}

So habe ich es kürzlich getan.

äh, wie wäre es nur mit:

function IsString(obj) {
    return obj !== undefined && obj != null && obj.toLowerCase !== undefined;
}

Nach einer weiteren Überprüfung nach vielen Monaten garantiert dies nur, dass obj ein Objekt ist, für das der Methoden- oder Eigenschaftsname toLowerCase definiert ist. Ich schäme mich meiner Antwort. Bitte sehen Sie sich die Top-gewählt typeof an.

Ich denke, das Konvertieren der var in einen String verringert die Leistung, zumindest zeigt dies test in den neuesten Browsern so.

Wenn Sie also Wert auf Leistung legen, würde ich Folgendes verwenden:

typeof str === "string" || str instanceof String

um zu überprüfen, ob die Variable eine Zeichenfolge ist (selbst wenn Sie var str = new String("foo") verwenden, gibt str instanceof String true zurück).

Um zu überprüfen, ob es sich um eine Zahl handelt, würde ich mich für das Native entscheiden: isNaN; Funktion.

oder verwenden Sie einfach die Invertierung von isNaN

if (! isNaN (Daten)) mach etwas mit der Nummer sonst Es ist eine Zeichenfolge

und ja - mit jQuery - $ .isNumeric () macht mehr Spaß für das Geld.

Diese Lösung löst viele der hier angesprochenen Probleme!

Dies ist bei weitem die zuverlässigste Methode, die ich bisher verwendet habe. Ich habe das nicht erfunden und kann mich nicht erinnern, wo ich es ursprünglich gefunden habe. Aber es funktioniert, wo andere Techniken versagen:

// Begin public utility /getVarType/
// Returns 'Function', 'Object', 'Array',
// 'String', 'Number', 'Boolean', or 'Undefined'
getVarType = function ( data ){
  if (undefined === data ){ return 'Undefined'; }
  if (data === null ){ return 'Null'; }
  return {}.toString.call(data).slice(8, -1);
};  
// End public utility /getVarType/

Beispiel für Korrektheit

var str = new String();
console.warn( getVarType(str) ); // Reports "String"    
console.warn( typeof str );      // Reports "object"

var num = new Number();
console.warn( getVarType(num) ); // Reports "Number"
console.warn( typeof num );      // Reports "object"

var list = [];
console.warn( getVarType( list ) ); // Reports "Array"
console.warn( typeof list );        // Reports "object"

typeof funktioniert in den meisten Fällen sehr gut für mich. Sie können es mit einer if-Anweisung versuchen

if(typeof x === 'string' || typeof x === 'number') {
    console.log("Your statement");
}

dabei ist x ein beliebiger Variablenname Ihrer Wahl

@ BitOfUniverses Antwort ist gut und ich finde einen neuen Weg:

function isNum(n) {
    return !isNaN(n/0);
}

isNum('')  // false
isNum(2)   // true
isNum('2k') // false
isNum('2')  //true

Ich weiß, dass 0 keine Dividende sein kann, aber hier funktioniert die Funktion einwandfrei.

der beste Weg, den ich gefunden habe, der auch an positive und negative Zahlen denkt, stammt von: O'Reilly Javascript und DHTML Cookbook :

function isNumber(elem) {
var str = elem.value;
var oneDecimal = false;
var oneChar = 0;
// make sure value hasn't cast to a number data type
str = str.toString( );
for (var i = 0; i < str.length; i++) {
    oneChar = str.charAt(i).charCodeAt(0);
    // OK for minus sign as first character
    if (oneChar =  = 45) {
        if (i =  = 0) {
            continue;
        } else {
            alert("Only the first character may be a minus sign.");
            return false;
        }
    }
    // OK for one decimal point
    if (oneChar =  = 46) {
        if (!oneDecimal) {
            oneDecimal = true;
            continue;
        } else {
            alert("Only one decimal is allowed in a number.");
            return false;
        }
    }
    // characters outside of 0 through 9 not OK
    if (oneChar < 48 || oneChar > 57) {
        alert("Enter only numbers into the field.");
        return false;
    }
}
return true;

}

da eine Zeichenfolge als '1234' mit typeof 'Zeichenfolge' anzeigt und die Umkehrung niemals vorkommen kann (typof 123 wird immer number sein), ist es am besten, einen einfachen Regex /^\-?\d+$/.test(var) zu verwenden. Oder ein weiter fortgeschrittener Vergleich von Gleitkommazahlen, Ganzzahlen und negativen Zahlen, /^[\-\+]?[\d]+\.?(\d+)?$/ Die wichtige Seite von .test ist, dass KEINE Ausnahme ausgelöst wird, wenn var keine Zeichenfolge ist. 

var val, regex = /^[\-\+]?[\d]+\.?(\d+)?$/;

regex.test(val)       // false 
val = '1234';
regex.test(val)       // true
val = '-213';
regex.test(val)       // true
val = '-213.2312';
regex.test(val)       // true
val = '+213.2312';
regex.test(val)       // true
val = 123;
regex.test(val)       // true
val = new Number(123);
regex.test(val)       // true
val = new String('123');
regex.test(val)       // true
val = '1234e';
regex.test(val)       // false 
val = {};
regex.test(val)       // false 
val = false;
regex.test(val)       // false 
regex.test(undefined) // false 
regex.test(null)      // false 
regex.test(window)    // false 
regex.test(document)  // false 

Wenn Sie nach dem echten Typ suchen, ist typeof alleine ausreichend. 

Nur eine Info, wenn Sie jQuery verwenden

$.isNumeric() 

damit umgehen. Weitere Informationen finden Sie auf http://api.jquery.com/jQuery.isNumeric/

Errr? Verwenden Sie einfach reguläre Ausdrücke! :)

function isInteger(val) {
  return val.match(/^[0-9]$/)
}

function isFloat(val) {
  return val.match(/^[0-9]*/\.[0-9]+$/)
}

jQuery verwendet das:

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

Die XOR-Operation kann zur Erkennung von Zahlen oder Zeichenfolgen verwendet werden. Zahl ^ 0 gibt immer die Zahl als Ausgabe aus und Zeichenfolge ^ 0 gibt 0 als Ausgabe aus.

Example: 
   1)  2 ^ 0 = 2
   2)  '2' ^ 0  = 2
   3)  'Str' ^ 0 = 0

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

Was denkst du über dieses? 

const numberOrString='10' 
const isNumber = !isNaN(numberOrString*1) 

Um Zahlen zu ermitteln, ist die folgende Passage von JavaScript relevant: The Good Parts von Douglas Crockford:

Die Funktion isFinite ist der beste Weg, um zu bestimmen, ob ein Wert als Zahl verwendet werden kann, da NaN und Infinity abgelehnt werden. Leider wird isFinite versuchen, seinen Operanden in eine Zahl umzuwandeln. Daher ist es kein guter Test, wenn ein Wert nicht tatsächlich eine Zahl ist. Vielleicht möchten Sie Ihre eigene isNumber-Funktion definieren:

var isNumber = function isNumber(value) { return typeof value === 'number' &&
            isFinite(value);
};

Sie können einfach verwenden:

!isNaN(+variable);

Sehr spät zur Party; Das Folgende hat jedoch immer gut funktioniert, wenn ich prüfen möchte, ob eine Eingabe entweder eine Zeichenfolge oder eine Zahl in einem Schuss ist.

return !!Object.prototype.toString.call(input).match(/\[object (String|Number)\]/);

Einfach verwenden 

myVar.constructor == String

oder

myVar.constructor == Number

wenn Sie Zeichenfolgen behandeln möchten, die als Objekte oder Literale definiert sind, und wenn Sie sparen, möchten Sie keine Hilfsfunktion verwenden.

Erstellt einen jsperf bei der Überprüfung, ob eine Variable eine Zahl ist. Ziemlich interessant! Typof hat tatsächlich eine Performance-Nutzung. Bei Verwendung von typeof für andere als Zahlen beträgt die Geschwindigkeit im Allgemeinen ein Drittel der Geschwindigkeit von variable.constructor, Da die meisten Datentypen in JavaScript Objekte sind. Zahlen sind nicht!

http://jsperf.com/jemiloii-fastest-method-to-check-if-type-is-a-number

typeof variable === 'number' | am schnellsten wenn Sie eine Zahl wie 5 und nicht '5' wollen
typeof parseFloat(variable) === 'number' | am schnellsten wenn Sie eine Zahl möchten, wie 5 und '5'

isNaN() ist langsamer, aber nicht so viel langsamer. Ich hatte große Hoffnungen auf parseInt und parseFloat, aber sie waren schrecklich langsamer.