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

Weiß jemand, wie ich überprüfen kann, ob eine Variable eine Zahl oder eine Zeichenfolge in JavaScript ist?

Wenn Sie mit Literalnotation und nicht mit Konstruktoren arbeiten, können Sie typeof : verwenden.

typeof "Hello World"; // string
typeof 123;           // number

Wenn Sie Zahlen und Strings über einen Konstruktor erstellen, wie zum Beispiel var foo = new String("foo"), sollten Sie bedenken , dass typeofzurückkehren objectzu foo.

Eine narrensichere Methode zur Überprüfung des Typs wäre möglicherweise die Verwendung der Methode in underscore.js (kommentierte Quelle finden Sie hier ).

var toString = Object.prototype.toString;

_.isString = function (obj) {
  return toString.call(obj) == '[object String]';
}

Dies gibt einen Booleschen Wert truefür Folgendes zurück:

_.isString("Jonathan"); // true
_.isString(new String("Jonathan")); // true

Der beste Weg, dies zu tun, ist das isNaNCasting vom Typ +:

All-in-Methode aktualisiert:

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

Das gleiche mit Regex:

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

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

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

Der beste Weg, den ich gefunden habe, besteht darin, entweder nach einer Methode für die Zeichenfolge zu suchen, dh:

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

oder wenn Sie etwas mit der Nummernprüfung für eine Zahleneigenschaft tun möchten,

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

Dies ist eine Art "Ententippen". Es liegt an Ihnen, welcher Weg am sinnvollsten ist. Ich habe nicht genug Karma, um Kommentare abzugeben, aber typeof schlägt für Zeichenfolgen und Zahlen in Kästchen fehl, dh:

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

wird "Objekt" alarmieren.

Sie suchen 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 bei MDN.

Überprü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 Suchen nach einer Nummer ist ähnlich:

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

Seit ES2015 ist der richtige Weg zu prüfen, ob eine Variable eine gültige Nummer enthält 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>

Der beste Weg, dies zu tun:

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

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

Hier ist ein Ansatz, der auf der Idee basiert, die Eingabe in eine Zahl oder Zeichenfolge zu zwingen, indem Null oder die Nullzeichenfolge hinzugefügt werden, und dann einen typisierten Gleichheitsvergleich durchzuführen.

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

Aus irgendeinem unergründlichen Grund x===x+0scheint es besser zu funktionieren 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 etwas schneller als entweder x===true || x===falseoder typeof x==="boolean"(und viel schneller als x===Boolean(x)) zu sein.

Dann gibt es auch noch

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

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

Für NaN gibt es

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

Dies ist im Grunde genommen die Version des Unterstrichs, und sie ist derzeit etwa viermal schneller als isNaN(), aber die Kommentare in der Unterstrichquelle erwähnen, dass "NaN die einzige Zahl ist , die sich selbst nicht entspricht" und fügen eine Prüfung für _.isNumber hinzu. Warum? Welche anderen Objekte würden sich nicht selbst entsprechen? Auch Unterstrich verwendet - x !== +xaber welchen Unterschied könnte das +hier machen?

Dann für die Paranoiden:

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

oder dieses

function is_undefined(x) { return x===void(0); }

Kannst du es einfach durch 1 teilen?

Ich gehe davon aus, dass das Problem eine Zeichenfolgeneingabe wie "123ABG" ist.

var Check = "123ABG"

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

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

Nur so, wie ich es kürzlich gemacht habe.

Wie wäre es nur mit:

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

Nach einer weiteren Überprüfung viele Monate später wird nur garantiert, dass objes sich um ein Objekt handelt, für das der Methoden- oder Eigenschaftsname toLowerCasedefiniert ist. Ich schäme mich für meine Antwort. Bitte sehen Sie die am besten gewählte typeof.

Oder verwenden Sie einfach die Umkehrung von isNaN():

if(!isNaN(data))
  do something with the number
else
  it is a string

Und ja, die Verwendung von jQuery's $.isNumeric()macht mehr Spaß.

Ich denke, das Konvertieren der Variable in eine Zeichenfolge verringert die Leistung, zumindest zeigt dieser in den neuesten Browsern durchgeführte Test dies.

Wenn Sie sich also für Leistung interessieren, würde ich Folgendes verwenden:

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

zum Überprüfen, ob die Variable eine Zeichenfolge ist (selbst wenn Sie verwenden var str = new String("foo"), str instanceof Stringwürde true zurückgegeben).

Um zu überprüfen, ob es eine Nummer ist, würde ich mich für den Eingeborenen entscheiden : isNaN; Funktion.

jQuery verwendet Folgendes:

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

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

Dies ist bei weitem die zuverlässigste Methode, die ich bei weitem verwendet habe. Ich habe das nicht erfunden und kann mich nicht erinnern, wo ich es ursprünglich gefunden habe. Aber es funktioniert dort, 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 Richtigkeit

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"

Jsut ein FYI, wenn Sie jQuery verwenden, haben Sie

$.isNumeric() 

um damit umzugehen. Weitere Details unter http://api.jquery.com/jQuery.isNumeric/

Typ funktioniert in den meisten Fällen sehr gut für mich. Sie können versuchen, eine if-Anweisung zu verwenden

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

Dabei ist x ein beliebiger Variablenname Ihrer Wahl

Der beste Weg, den ich gefunden habe, der auch an positive und negative Zahlen denkt, ist 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;

}}

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]+$/)
}

Da eine Zeichenfolge als '1234' mit typeof 'string' anzeigt und die Umkehrung niemals passieren kann (typeof 123 ist immer eine Zahl), ist es am besten, einen einfachen regulären Ausdruck zu verwenden /^\-?\d+$/.test(var). Oder eine fortgeschrittenere Methode, um Floats, Ganzzahlen und negative Zahlen abzugleichen. /^[\-\+]?[\d]+\.?(\d+)?$/ Die wichtige Seite .testist, dass keine Ausnahme ausgelöst wird, wenn die Variable keine Zeichenfolge ist. Der Wert kann beliebig sein.

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, reicht nur typeof aus.

Die Antwort von @ BitOfUniverse ist gut und ich habe einen neuen Weg gefunden:

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

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

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

Typprüfung

Sie können den Variablentyp mit dem typeofOperator überprüfen :

typeof variable

Wertprüfung

Der folgende Code gibt true für Zahlen und false für alles andere zurück:

!isNaN(+variable);

Die XOR-Operation kann zum Erkennen von Zahlen oder Zeichenfolgen verwendet werden. Zahl ^ 0 gibt immer die Zahl als Ausgabe an und Zeichenfolge ^ 0 gibt 0 als Ausgabe an.

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

Einfach und gründlich:

function isNumber(x) {
  return parseFloat(x) == x
};

Testfälle:

console.log('***TRUE CASES***');
console.log(isNumber(0));
console.log(isNumber(-1));
console.log(isNumber(-500));
console.log(isNumber(15000));
console.log(isNumber(0.35));
console.log(isNumber(-10.35));
console.log(isNumber(2.534e25));
console.log(isNumber('2.534e25'));
console.log(isNumber('52334'));
console.log(isNumber('-234'));
console.log(isNumber(Infinity));
console.log(isNumber(-Infinity));
console.log(isNumber('Infinity'));
console.log(isNumber('-Infinity'));

console.log('***FALSE CASES***');
console.log(isNumber(NaN));
console.log(isNumber({}));
console.log(isNumber([]));
console.log(isNumber(''));
console.log(isNumber('one'));
console.log(isNumber(true));
console.log(isNumber(false));
console.log(isNumber());
console.log(isNumber(undefined));
console.log(isNumber(null));
console.log(isNumber('-234aa'));

Einfach benutzen

myVar.constructor == String

oder

myVar.constructor == Number

Wenn Sie Zeichenfolgen verarbeiten möchten, die als Objekte oder Literale definiert und gespeichert sind, möchten Sie keine Hilfsfunktion verwenden.

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

Sehr spät zur Party; Das Folgende hat für mich jedoch immer gut funktioniert, wenn ich überprüfen möchte, ob eine Eingabe entweder eine Zeichenfolge oder eine Zahl auf einmal ist.

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

Erstellt ein jsperf bei der Überprüfung, ob eine Variable eine Zahl ist. Ziemlich interessant! Typ hat tatsächlich eine Leistungsverwendung. Wenn Sie typeofetwas anderes als Zahlen verwenden, beträgt die Geschwindigkeit im Allgemeinen ein variable.constructorDrittel, 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'
typeof parseFloat(variable) === 'number'| möchten am schnellsten | Wenn Sie eine Zahl wie 5 und '5' möchten

isNaN()ist langsamer, aber nicht viel langsamer. Ich hatte große Hoffnungen auf parseIntund parseFloatsie waren jedoch schrecklich langsamer.

Für die Erkennung von Zahlen ist die folgende Passage aus JavaScript relevant: The Good Parts von Douglas Crockford:

Die isFinite-Funktion ist der beste Weg, um festzustellen, 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 tatsächlich keine Zahl ist. Möglicherweise möchten Sie Ihre eigene isNumber-Funktion definieren:

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