Weiß jemand, wie ich überprüfen kann, ob eine Variable eine Zahl oder eine Zeichenfolge in JavaScript ist?
Weiß jemand, wie ich überprüfen kann, ob eine Variable eine Zahl oder eine Zeichenfolge in JavaScript ist?
Antworten:
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 typeof
zurückkehren object
zu 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 true
für Folgendes zurück:
_.isString("Jonathan"); // true
_.isString(new String("Jonathan")); // true
var myString = new String("stuff I like"); isString(myString)
dies false zurückgibt. Außerdem bin ich mir nicht ganz sicher, wie lange die Hintergrundkonvertierung dauert. Ich weiß, wenn ich "hi" .length aufrufe, wird "hi" in ein Objekt konvertiert, nicht sicher, wie schnell es wieder konvertiert wird oder ob dies jemals gebunden ist zur Variablen.
Der beste Weg, dies zu tun, ist das isNaN
Casting 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
null
wird auf 0 gezwungen und gibt true fürisNumber(null);
function is_number(n) { return /^-?[\d.]+(?:e-?\d+)?$/.test(n);}
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.
typeof
es immer auf einen String testen kann, ob primitiv oder String-Objekt. Sie müssen nur nach einer Methode suchen, die für den gewünschten Typ eindeutig ist.
{substring:"hello"}
. Ich weiß für meine Zwecke, dass ich gerade getestet habe, was die spezifische Operation, die ich ausführen musste (Modul), für den Typ bewirkt, nach dem ich suchen musste (bei Zeichenfolgen gibt der Modul undefiniert zurück), und dann darauf überprüft habe, anstatt den Typ zu erhalten.
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.
isNaN
Renditen false
für null
(aber true
für undefined
).
Ü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);
}
function is (type, value) { return value["constructor"] === type; }
?
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 .
realTypeOf
: realTypeOf(NaN) -> "Number"
das gleiche Verhalten wie typeof
vereinbart, aber immer noch alles andere als ideal.
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+0
scheint 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===false
oder 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 !== +x
aber 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 obj
es sich um ein Objekt handelt, für das der Methoden- oder Eigenschaftsname toLowerCase
definiert 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ß.
isNaN('123')
gibt false, obwohl das Argument eine numerische Zeichenfolge und kein numerischer Typ ist
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 String
wü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"
typeof
Wenn ich eine Geschwindigkeit von mehr als 1 Million Iterationen teste , finde ich, dass sie nicht schlechter als die Hälfte der Geschwindigkeit der nativen Methode (0,788 s gegenüber 1,481 s) in Chrome ist. Dies ist angesichts der verbesserten Ergebnisse sicherlich eine akzeptable Leistung. Warum denkst du, ist es "sehr langsam"? Vielleicht ist es - in IE6 / 7/8? Aber in diesen Browsern ist alles "sehr langsam".
typeof
ist 100x schneller. Was fehlt mir?
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 .test
ist, 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ß, 0
kann keine Dividende sein, aber hier funktioniert die Funktion perfekt.
Sie können den Variablentyp mit dem typeof
Operator überprüfen :
typeof variable
Der folgende Code gibt true für Zahlen und false für alles andere zurück:
!isNaN(+variable);
typeof
Operator verwenden! @ JustAMartin
number
aber wenn ich '123' oder 'abc' oder ein anderes zitiertes Literal übergebe, ist es eine Zeichenfolge, und es spielt keine Rolle, ob es in eine Zahl analysiert werden kann oder nicht.
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'));
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 typeof
etwas anderes als Zahlen verwenden, beträgt die Geschwindigkeit im Allgemeinen ein variable.constructor
Drittel, 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 parseInt
und parseFloat
sie 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);
};