Wie überprüfe ich, ob eine Zahl float oder integer ist?

717

Wie finde ich heraus, dass eine Nummer floatoder ist integer?

1.25 --> float  
1 --> integer  
0 --> integer  
0.25 --> float
coure2011
quelle
47
Ich verstehe, was Sie hier fragen, aber nur um klar zu sein: <nit-pick>JavaScript hat keine unterschiedlichen numerischen Integer- und Float-Typen. Jede Zahl in JavaScript ist nur eine Number. </nit-pick>
Matt Ball
4
Ist für Sie Infinityein ganzzahliger oder ein nicht ganzzahliger Wert? Die Antworten hier sind in dieser Hinsicht ziemlich gleichmäßig verteilt.
Mike Samuel
11
@MikeSamuel Um mathematisch genau zu sein: Da Unendlichkeit keine reelle Zahl ist und alle ganzen Zahlen reelle Zahlen sind, Infinitykann sie nicht als ganze Zahl betrachtet werden.
Rvighne
@rvighne, Die Frage fragt nach "float", nicht nach "real". In beiden Fällen sind Realzahlen irrelevant, da Computer nur berechenbare Zahlen darstellen können .
Mike Samuel
2
@rvighne, ich denke, wir sind uns einig, dass die Tatsache, dass die Unendlichkeiten und NaN keine reellen Zahlen sind, bedeutet, dass IEEE-754-Floats keine Teilmenge von reellen Zahlen sind. Alle auf IEEE-754 basierenden numerischen Analysen müssen sich mit dieser Tatsache befassen. Was ich nicht verstehe, ist, wie Sie denken, dass diese Tatsache bestimmt, wie sich is_integral bei Kardinalitäten verhalten soll. Persönlich denke ich, dass ((x% 1) == 0) ein guter Proxy ist und vollständig von IEEE-754 spezifiziert wird, so dass es nicht nötig ist, über Entsprechungen zwischen verschiedenen Zahlenlinien zu streiten.
Mike Samuel

Antworten:

1255

Überprüfen Sie auf einen Rest, wenn Sie durch 1 teilen:

function isInt(n) {
   return n % 1 === 0;
}

Wenn Sie nicht wissen, dass das Argument eine Zahl ist, benötigen Sie zwei Tests:

function isInt(n){
    return Number(n) === n && n % 1 === 0;
}

function isFloat(n){
    return Number(n) === n && n % 1 !== 0;
}

Update 2019 5 Jahre nach dem Schreiben dieser Antwort wurde eine Lösung in ECMA Script 2015 standardisiert. Diese Lösung wird in dieser Antwort behandelt .

kennebec
quelle
138
Sorgfältige, wird dies auch wahr , zurückkehren für eine leere Zeichenkette, eine Zeichenkette eine ganze Zahl darstellt, true, false, null, ein leeres Array, ein Array mit einer einzigen integralen Nummer enthält, ein Array eine Zeichenfolge , die eine ganzzahlige Anzahl enthält, und vielleicht mehr.
Dagg Nabbit
17
Netter Trick, aber nicht die richtige Antwort, da er die leere Zeichenfolge nicht überprüft ""und 1.0 isInt("");&& isInt(1.0);beide dazu führen, truedass diese Demo angezeigt wird. Jsbin.com/elohuq/1/edit
Champ
9
Ina wird die Verwendung von === im Allgemeinen gegenüber == empfohlen, da dies zu mehr Typensicherheit und vorhersehbarerem, einheitlichem Verhalten führt. Wie frühere Antwortende festgestellt haben, ist diese Antwort absolut 100% falsch. Die Werte null, leere Zeichenfolge, 1.0 und zahlreiche andere werden fälschlicherweise als Ganzzahlen registriert (auch bei der Prüfung ===).
Whoblitz
54
Die Frage war, wie man prüft, ob eine Zahl eine ganze Zahl ist, und nicht, wie man einen Wert prüft.
kennebec
24
Viele feindliche Kommentare darüber, wie es Strings nicht validiert. Das ist nicht Teil der Frage des OP. Wenn ich auf SO gehe, um eine Frage zum Abrufen des letzten Elements eines Arrays zu stellen, und jemand mit antwortet function last (array) { return array[array.length - 1]; }, ist dies "einfach falsch" oder "Schlechteste Antwort auf SO", weil nicht geprüft wird, ob das Argument zuerst ein Array ist? Ja, gute Praxis, um Argumente zu überprüfen, aber das liegt in der Verantwortung des Entwicklers. SO-Antworten sollten kurz sein und die Frage so klar wie möglich direkt beantworten.
M Miller
150

Probieren Sie diese Funktionen aus, um zu testen, ob ein Wert ein primitiver Zahlenwert ist, der keinen Bruchteil enthält und innerhalb der Größengrenzen dessen liegt, was als exakte Ganzzahl dargestellt werden kann.

function isFloat(n) {
    return n === +n && n !== (n|0);
}

function isInteger(n) {
    return n === +n && n === (n|0);
}
Dagg Nabbit
quelle
5
heh awesom Exploit, es ist so ziemlich meins ( n===+num nach Zahlen n|0zu suchen, um zu runden), aber mit eingebauten Operatoren. funky
Claudiu
7
@ John Hartsock Eine Zeichenfolge wird niemals ein numerischer Wert sein. Es ist eine Schnur. Mit dieser Funktion soll geprüft werden, ob ein Wert ein numerischer Javascript-Wert ist, der keinen Bruchteil enthält und innerhalb der Größengrenzen dessen liegt, was als exakte Ganzzahl dargestellt werden kann. Wenn Sie eine Zeichenfolge überprüfen möchten, um festzustellen, ob sie eine Folge von Zeichen enthält, die eine Zahl darstellen, rufen Sie parseFloat()zuerst auf.
Pointy
4
@ John Hartsock: Es wird nicht wahr zurückgegeben, es sei denn, ein Zahlenprimitiv wurde übergeben. Ich denke, das macht angesichts der Namen der Funktionen Sinn. Alles andere sollte ein Kandidat für isString, isBoolean usw. sein, wenn solche Funktionen geschrieben werden.
Dagg Nabbit
4
@Pointy: Floats mit doppelter Genauigkeit können ganzzahlige Werte genau bis zu 2 ^ 53 darstellen. Es kommt also darauf an, ob das OP nach Ganzzahlen im mathematischen Sinne (ganze Zahlen) oder im 32-Bit-Datensinn gefragt hat. Wenn es das letztere ist, ist Ihre Lösung perfekt.
DJD
8
In Javascript arbeiten bitweise Operatoren wie |(OR) nur mit vorzeichenbehafteten 32-Bit-Ganzzahlen. OP gibt nicht an, ob das Ziel darin besteht, nach signierten int32-Werten zu suchen. Dies funktioniert also nicht mit Zahlen außerhalb des Bereichs. isInteger(5000000000)wird zurückkehren, falsewas falsch ist!
Onur Yıldırım
93

Warum nicht so etwas:

var isInt = function(n) { return parseInt(n) === n };
Warfares
quelle
Dies ist eigentlich der Kern einer guten Lösung für mich. Ich musste positive ganze Zahlen zulassen und Floats, Strings und negative ganze Zahlen nicht zulassen.
Imran-UK
4
Dies scheint eine weitaus bessere Lösung zu sein als die anderen in diesem Thread. Könnte die Community vielleicht Kritik üben?
Sbichenko
5
var y = 1,00; y === parseInt (y, 10); // das gibt für mich wahr zurück, was nicht wirklich das ist, was wir wollen.
Whoughton
Der einzige "Nachteil", den ich sehe, ist, dass die angegebene Zahl von nin eine Zeichenfolge von konvertiert wird parseInt. Siehe MDN . Aber ich werde diese Lösung verwenden. :)
RhinoDevel
2
@ekussberg: Warum sollte das falsch zurückgeben? 1 ist ein int. und 02, das zweite Argument, wird ignoriert.
Flimzy
88

Es gibt eine Methode namens, Number.isInteger()die derzeit in allem außer IE implementiert ist. MDN bietet auch eine Polyfüllung für andere Browser:

Number.isInteger = Number.isInteger || function(value) {
  return typeof value === 'number' && 
    isFinite(value) && 
    Math.floor(value) === value;
};

In den meisten Anwendungsfällen ist es jedoch besser Number.isSafeInteger , wenn Sie auch prüfen, ob der Wert so hoch / niedrig ist, dass Dezimalstellen ohnehin verloren gegangen wären. MDN hat auch dafür ein Polyfil. (Sie benötigen auch die isIntegerPollyfill oben.)

if (!Number.MAX_SAFE_INTEGER) {
    Number.MAX_SAFE_INTEGER = 9007199254740991; // Math.pow(2, 53) - 1;
}
Number.isSafeInteger = Number.isSafeInteger || function (value) {
   return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
};
paperstreet7
quelle
Dies funktioniert jetzt auch in meinem Chrome und wahrscheinlich der Weg in die Zukunft
Dukeatcoding
1
Meiner Meinung nach die beste Lösung.
Automatico
1
Dies ist mit der Polyfüllung die zuverlässigste und einfachste Lösung.
Francesco Pasa
2
@ SergeyPanfilov 12.0 ∈ ℤ.
Константин Ван
1
Ich weiß nicht, ob sich die Spezifikation geändert hat, seit diese Antwort gegeben wurde, aber beachten Sie, dass die obige Funktion keine korrekte Polyfüllung für ist Number.isInteger. Es ist jedoch eine korrekte Polyfüllung für Number.isSafeInteger. Number.isIntegersollte nicht prüfen, ob die Zahl eine "sichere Ganzzahl" ist. Siehe zu MDN: isInteger und isSafeInteger .
Nunocastromartins
33

Sie können einen einfachen regulären Ausdruck verwenden:

function isInt(value) {

    var er = /^-?[0-9]+$/;

    return er.test(value);
}

Oder Sie können die folgenden Funktionen entsprechend Ihren Anforderungen verwenden. Sie werden vom PHPJS-Projekt entwickelt .

is_int() => Überprüfen Sie, ob der Variablentyp eine Ganzzahl ist und ob sein Inhalt eine Ganzzahl ist

is_float() => Überprüfen Sie, ob der Variablentyp float ist und ob sein Inhalt float ist

ctype_digit() => Überprüfen Sie, ob der Variablentyp ein String ist und ob sein Inhalt nur Dezimalstellen enthält

Update 1

Jetzt werden auch negative Zahlen überprüft, danke für den Kommentar von @ChrisBartley !

Marcio Mazzucato
quelle
1
Perfekt, um einfache Ganzzahlen ohne Vorzeichen zu testen.
tothemario
7
Ein Liner:/^[0-9]+$/.test(String(value))
tothemario
Kürzere und etwas weniger lesbare /^[0-9]+$/.test(''+value)
Einzeiler
3
Behandelt keine negativen Ganzzahlen. Sie benötigen den ternären Operator auch nicht, da test () einen Booleschen Wert zurückgibt. Dies sollte es tun:return /^-?\d+$/.test(String(value));
Chris Bartley
@ ChrisBartley, danke! Ich habe ein Update durchgeführt, einschließlich Ihrer Credits. Bitte überprüfen Sie, ob jetzt alles in Ordnung ist.
Marcio Mazzucato
19

Hier sind effiziente Funktionen, die prüfen, ob der Wert eine Zahl ist oder sicher in eine Zahl umgewandelt werden kann :

function isNumber(value) {
    if ((undefined === value) || (null === value)) {
        return false;
    }
    if (typeof value == 'number') {
        return true;
    }
    return !isNaN(value - 0);
}

Und für ganze Zahlen (würde false zurückgeben, wenn der Wert ein Float ist):

function isInteger(value) {
    if ((undefined === value) || (null === value)) {
        return false;
    }
    return value % 1 == 0;
}

Die Effizienz hierbei ist, dass parseInt (oder parseNumber) vermieden werden, wenn der Wert bereits eine Zahl ist. Beide Parsing-Funktionen immer konvertieren in eine Zeichenfolge und versuchen dann, diese Zeichenfolge zu analysieren. Dies wäre eine Verschwendung, wenn der Wert bereits eine Zahl ist.

Vielen Dank an die anderen Beiträge hier für weitere Ideen zur Optimierung!

Tal Liron
quelle
3
Diese Funktion schlägt bei der leeren Zeichenfolge fehl: isNumber ('') ist true.
Jason Grout
14
function isInteger(x) { return typeof x === "number" && isFinite(x) && Math.floor(x) === x; }
function isFloat(x) { return !!(x % 1); }

// give it a spin

isInteger(1.0);        // true
isFloat(1.0);          // false
isFloat(1.2);          // true
isInteger(1.2);        // false
isFloat(1);            // false
isInteger(1);          // true    
isFloat(2e+2);         // false
isInteger(2e+2);       // true
isFloat('1');          // false
isInteger('1');        // false
isFloat(NaN);          // false
isInteger(NaN);        // false
isFloat(null);         // false
isInteger(null);       // false
isFloat(undefined);    // false
isInteger(undefined);  // false
shime
quelle
4
Anscheinend werden Floats, die mit .0 enden, in JavaScript automatisch in Int umgewandelt.
fehlgeschlagen mit 1.2. Testen Sie numerische Funktionen immer mit 0,1 0,2 0,3
Lukas Liesis
@ LukasLiesis nicht für mich.
DoubleOrt
Hier besteht keine Notwendigkeit für einen der strengen Gleichheitsoperatoren.
DoubleOrt
isFloat (1563457121531) gibt false zurück
Aalex Gabi
9
function isInt(n) 
{
    return n != "" && !isNaN(n) && Math.round(n) == n;
}
function isFloat(n){
    return n != "" && !isNaN(n) && Math.round(n) != n;
}

funktioniert für alle Fälle.

Deepak Yadav
quelle
2
+1 Das ist gut. isInt('1')kehrt truewie erwartet zurück (zumindest für mich). Seltsam genug, aber diese Rückkehr truezu isInt([5])auch. War für mich nicht wichtig, aber vielleicht für dich, also pass auf dich auf.
Acdcjunior
2
isFloat (12.0) ist falsch
Django
6

Wie andere bereits erwähnt haben, haben Sie in JS nur Doppel. Wie definieren Sie eine Zahl als Ganzzahl? Überprüfen Sie einfach, ob die gerundete Zahl gleich ist:

function isInteger(f) {
    return typeof(f)==="number" && Math.round(f) == f;
}
function isFloat(f) { return typeof(f)==="number" && !isInteger(f); }
Claudiu
quelle
3
Vielleicht möchten Sie überprüfen, ob der Wert numerisch ist ... gibt isFloat('abc')zurücktrue
Dagg Nabbit
isFloat(NaN) // true
Shime
@ Shime: Guter Fang. NaN ist technisch gesehen eine Gleitkommazahl ... hängt davon ab, was der Anwendungsfall ist, nehme ich an.
Claudiu
6

Wie wäre es mit diesem?

isFloat(num) {
    return typeof num === "number" && !Number.isInteger(num);
}
Goehybrid
quelle
Versuchen Sie die console.log(isFloat(1.0));Ergebnisse falsch.
Fabian Picone
5

Folgendes verwende ich für ganze Zahlen:

Math.ceil(parseFloat(val)) === val

Kurz, schön :) Funktioniert die ganze Zeit. Dies ist, was David Flanagan vorschlägt, wenn ich mich nicht irre.

Arman McHitarian
quelle
Ich mag diese, weil es eine kurze, einfache Antwort ist, die nicht auf kryptischen bitweisen Operationen beruht.
Jim
Warum parseFloat?
DoubleOrt
4

Es kommt wirklich darauf an, was Sie erreichen wollen. Wenn Sie stark typisierte Sprachen "emulieren" möchten, empfehle ich Ihnen, es nicht zu versuchen. Wie bereits erwähnt, haben alle Zahlen dieselbe Darstellung (denselben Typ).

Mit etwas wie Claudiu zur Verfügung gestellt:

isInteger( 1.0 ) -> wahr

Das sieht gut aus für den gesunden Menschenverstand, aber in so etwas wie C würde man bekommen false

gblazex
quelle
4

Alle Float-Zahlen mit einem Dezimalteil von Null (z. B. 1.0, 12.00, 0.0) werden implizit in Integer umgewandelt, sodass nicht überprüft werden kann, ob sie Float sind oder nicht.

Mike Mancini
quelle
4
!!(24%1) // false
!!(24.2%1) // true
Виктор Дакалов
quelle
!!(24.0%1)ist falsch
Rohmer
3

Es muss wirklich nicht so kompliziert sein. Der numerische Wert der Entsprechungen parseFloat () und parseInt () einer Ganzzahl ist identisch. So können Sie Folgendes tun:

function isInt(value){ 
    return (parseFloat(value) == parseInt(value)) && !isNaN(value);
}

Dann

if (isInt(x)) // do work

Dies ermöglicht auch Zeichenfolgenprüfungen und ist daher nicht streng. Wenn Sie eine starke Lösung wünschen (auch bekannt als, funktioniert nicht mit Zeichenfolgen):

function is_int(value){ return !isNaN(parseInt(value * 1) }
SpYk3HH
quelle
isInteger (12.0) ist wahr
Django
3
var isInt = function (n) { return n === (n | 0); };

Ich hatte noch keinen Fall, in dem dies nicht funktioniert hat.

ankr
quelle
Hey, tut mir leid, warum dies falsch zurückgibt. console.log (isInt (7932938942839482938));
Es ist der
4
Weil das MaxInt überschreitet.
Ankr
aber Sie können eine Int max Länge nein einstellen? Was ist, wenn ich nicht weiß, dass die int-Länge zurückgegeben wird?
Es ist der
1
@ekussberg Ja, weil 2es sich um eine Ganzzahl handelt und 23als zweites Argument für die Funktion betrachtet wird. In Javascript werden Dezimalstellen mit Punkt als Trennzeichen geschrieben - so sollte es sein 2.23.
ankr
1
Oder es ist eine großartige Gelegenheit, etwas über bitweise Operationen zu lernen. Sie werden in Zukunft viel davon profitieren.
ankr
2

Dies ist der endgültige Code für die Überprüfung von INT und FLOAT

function isInt(n) { 
   if(typeof n == 'number' && Math.Round(n) % 1 == 0) {
       return true;
   } else {
       return false;
   }
} 

ODER

function isInt(n) {   
   return typeof n == 'number' && Math.Round(n) % 1 == 0;   
}   
Ken Le
quelle
Dies testet nur für float, wenn n zufällig eine Zahl ist
hacklikecrack
2
function isInteger(n) {
   return ((typeof n==='number')&&(n%1===0));
}

function isFloat(n) {
   return ((typeof n==='number')&&(n%1!==0));
}

function isNumber(n) {
   return (typeof n==='number');
}
Vitim.us
quelle
Eine Ganzzahl ist kein Float? Neuigkeiten für mich.
Maarten Bodewes
2

Es ist so einfach wie:

if( n === parseInt(n) ) ...

Versuchen Sie dies in der Konsole:

x=1;
x===parseInt(x); // true
x="1";
x===parseInt(x); // false
x=1.1;
x===parseInt(x); // false, obviously

// BUT!

x=1.0;
x===parseInt(x); // true, because 1.0 is NOT a float!

Das verwirrt viele Leute. Immer wenn etwas .0 ist, ist es kein Float mehr. Es ist eine ganze Zahl. Oder man kann es einfach "eine numerische Sache" nennen, denn es gibt keine strenge Unterscheidung wie damals in C. Gute alte Zeiten.

Alles, was Sie tun können, ist, nach einer Ganzzahl zu suchen und die Tatsache zu akzeptieren, dass 1.000 eine Ganzzahl ist.

Interessante Randnotiz

Es gab einen Kommentar über große Zahlen. Riesige Zahlen bedeuten für diesen Ansatz KEIN Problem. Wenn parseInt die Zahl nicht verarbeiten kann (weil sie zu groß ist), wird etwas anderes als der tatsächliche Wert zurückgegeben, sodass der Test FALSE zurückgibt. Dies ist eine gute Sache, denn wenn Sie etwas als "Zahl" betrachten, erwarten Sie normalerweise, dass JS damit rechnen kann - also ja, die Zahlen sind begrenzt und parseInt wird dies berücksichtigen , um es so auszudrücken .

Versuche dies:

<script>

var a = 99999999999999999999;
var b = 999999999999999999999; // just one more 9 will kill the show!
var aIsInteger = (a===parseInt(a))?"a is ok":"a fails";
var bIsInteger = (b===parseInt(b))?"b is ok":"b fails";
alert(aIsInteger+"; "+bIsInteger);

</script>

In meinem Browser (IE8) gibt dies "a ist in Ordnung; b schlägt fehl" zurück, was genau auf die große Zahl in b zurückzuführen ist. Das Limit kann variieren, aber ich denke, 20 Ziffern "sollten für jeden reichen", um einen Klassiker zu zitieren :)

dkellner
quelle
Dies ist in Ordnung, wenn Sie nur nach ganzzahligen Zahlen (aus einem mathematischen POV) suchen müssen, aber wenn Sie sicherstellen möchten, dass sie tatsächlich wie ganze Zahlen (aus einem Computer-POV) funktionieren , ist dies für große Zahlen falsch. Siehe diesen Kommentar .
Dagg Nabbit
Mmmmmmm ... Warum denkst du das? Ich meine, wenn parseInt etwas zurückgibt und es der Variablen selbst entspricht, können Sie sicher sein, dass Ihr n wirklich als Ganzzahl funktioniert. Ich fand heraus, dass 99999999999999999999 (dh 20 mal "9") eine Zahl ist, während das Hinzufügen einer weiteren "9" parseInt fehlschlägt (Rückgabe 1). Es kann browserabhängig sein; JA, es gibt jedoch ein Limit und NEIN. Was auch immer außerhalb dieses Limits liegt, wird für die obige Prüfung nicht als wahr zurückgegeben.
dkellner
Was ich damit meine ist, dass bitweise Operatoren (die Zahlen als 32-Bit-Ints behandeln) nicht die erwarteten Ergebnisse für Zahlen liefern, die nicht als 32-Bit-Ints dargestellt werden können. Daher sollten diese Zahlen nicht als Ints identifiziert werden. Dies steht im Einklang mit der Funktionsweise des Vorschlags Number.isInteger.
Dagg Nabbit
Etwas kann eine echte Ganzzahl sein, ohne auf eine bestimmte Weise gespeichert zu werden. Ich verstehe Ihren Standpunkt, aber Ganzzahlen sind Ganzzahlen, weil sie keinen Bruchteil haben und beliebig addiert / subtrahiert werden können, ohne floatartige Ergebnisse zu erhalten. Wenn Sie Zahlen als Bitfelder behandeln, nehmen Sie an, wie sie gespeichert werden, was meiner Meinung nach praktisch funktioniert, aber nicht zu 100% zuverlässig ist. Wenn Sie nach einer "auf eine bestimmte Weise gespeicherten Ganzzahl" suchen, bin ich mir nicht sicher, ob es einen einzeiligen Test gibt, den Sie sicher auf allen Plattformen verwenden können.
dkellner
Zahlen, die als 32-Bit-Ints ausgedrückt werden können, funktionieren mit bitweisen Operatoren zu 100% zuverlässig. Sie nehmen nicht an, "wie sie gespeichert werden". Die Zahlen werden gemäß Spezifikation in vorzeichenbehaftete 32-Bit-Big-Endian-Two-Komplement-Ganzzahlen konvertiert. Zahlen, die in diesem Format nicht dargestellt werden können, sollten nicht als Ganzzahlen betrachtet werden. Auch dies entspricht der Funktionsweise Number.isInteger. Ein Einzeilentest ist n === (n | 0)wie in einer anderen Antwort gezeigt.
Dagg Nabbit
2

Diese Lösung hat bei mir funktioniert.

<html>
<body>
  <form method="post" action="#">
    <input type="text" id="number_id"/>
    <input type="submit" value="send"/>
  </form>
  <p id="message"></p>
  <script>
    var flt=document.getElementById("number_id").value;
    if(isNaN(flt)==false && Number.isInteger(flt)==false)
    {
     document.getElementById("message").innerHTML="the number_id is a float ";
    }
   else 
   {
     document.getElementById("message").innerHTML="the number_id is a Integer";
   }
  </script>
</body>
</html>
Abdelraouf GR
quelle
1

Für ganze Zahlen verwende ich dies

function integer_or_null(value) {
    if ((undefined === value) || (null === value)) {
        return null;
    }
    if(value % 1 != 0) {
        return null;
    }
    return value;
}
neoneye
quelle
1

In Java-Skripten sind alle Zahlen internally 64 bit floating pointidentisch mit Double in Java. Es gibt keine unterschiedlichen Typen in Javascript, alle werden nach Typ dargestellt number. Daher können Sie keinen instanceofScheck machen. Sie können jedoch die oben angegebenen Lösungen verwenden, um herauszufinden, ob es sich um eine Bruchzahl handelt. Designer von Java-Skripten, die mit einem einzigen Typ gefühlt haben, können zahlreiche Typumwandlungsfehler vermeiden.

Punith Raj
quelle
1

Manchmal können Sie mit Number-Objekten den Mod-Operator (%) nicht direkt verwenden. Wenn Sie mit diesem Fall konfrontiert sind, können Sie diese Lösung verwenden.

if(object instanceof Number ){
   if( ((Number) object).doubleValue() % 1 == 0 ){
      //your object is an integer
   }
   else{
      //your object is a double
   }
}
toddsalpen
quelle
1

Als ich einige der Antworten hier versuchte, schrieb ich diese Lösung. Dies funktioniert auch mit Zahlen innerhalb einer Zeichenfolge.

function isInt(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return !(number - parseInt(number));
}

function isFloat(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return number - parseInt(number) ? true : false;
}

    var tests = {
        'integer' : 1,
        'float' : 1.1,
        'integerInString' : '5',
        'floatInString' : '5.5',
        'negativeInt' : -345,
        'negativeFloat' : -34.98,
        'negativeIntString' : '-45',
        'negativeFloatString' : '-23.09',
        'notValidFalse' : false,
        'notValidTrue' : true,
        'notValidString' : '45lorem',
        'notValidStringFloat' : '4.5lorem',
        'notValidNan' : NaN,
        'notValidObj' : {},
        'notValidArr' : [1,2],
    };

    function isInt(number) {
        if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
        return !(number - parseInt(number));
    }
    
    function isFloat(number) {
        if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
        return number - parseInt(number) ? true : false;
    }

    function testFunctions(obj) {
        var keys = Object.keys(obj);
        var values = Object.values(obj);

        values.forEach(function(element, index){
            console.log(`Is ${keys[index]} (${element}) var an integer? ${isInt(element)}`);
            console.log(`Is ${keys[index]} (${element}) var a float? ${isFloat(element)}`);
        });
    }

    testFunctions(tests);

Alejandro Hernandez
quelle
0

Dies ist möglicherweise nicht so performant wie die% -Antwort, wodurch verhindert wird, dass Sie zuerst in einen String konvertieren müssen, aber ich habe noch niemanden gesehen, der ihn veröffentlicht hat. Hier ist eine weitere Option, die gut funktionieren sollte:

function isInteger(num) {
    return num.toString().indexOf('.') === -1;
}
Achse
quelle
Guter Ansatz IMHO
Sergei Panfilov
Ich würde hinzufügen, dass die ES6-Methode include () diese Antwort noch einfacher macht
Axle
0

Für diejenigen, die neugierig sind und Benchmark.js verwenden, habe ich die am besten bewerteten Antworten (und die heute veröffentlichten) auf diesen Beitrag getestet. Hier sind meine Ergebnisse:

var n = -10.4375892034758293405790;
var suite = new Benchmark.Suite;
suite
    // kennebec
    .add('0', function() {
        return n % 1 == 0;
    })
    // kennebec
    .add('1', function() {
        return typeof n === 'number' && n % 1 == 0;
    })
    // kennebec
    .add('2', function() {
        return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
    })

    // Axle
    .add('3', function() {
        return n.toString().indexOf('.') === -1;
    })

    // Dagg Nabbit
    .add('4', function() {
        return n === +n && n === (n|0);
    })

    // warfares
    .add('5', function() {
        return parseInt(n) === n;
    })

    // Marcio Simao
    .add('6', function() {
        return /^-?[0-9]+$/.test(n.toString());
    })

    // Tal Liron
    .add('7', function() {
        if ((undefined === n) || (null === n)) {
            return false;
        }
        if (typeof n == 'number') {
            return true;
        }
        return !isNaN(n - 0);
    });

// Define logs and Run
suite.on('cycle', function(event) {
    console.log(String(event.target));
}).on('complete', function() {
    console.log('Fastest is ' + this.filter('fastest').pluck('name'));
}).run({ 'async': true });

0 x 12,832,357 ops/sec ±0.65% (90 runs sampled)
1 x 12,916,439 ops/sec ±0.62% (95 runs sampled)
2 x 2,776,583 ops/sec ±0.93% (92 runs sampled)
3 x 10,345,379 ops/sec ±0.49% (97 runs sampled)
4 x 53,766,106 ops/sec ±0.66% (93 runs sampled)
5 x 26,514,109 ops/sec ±2.72% (93 runs sampled)
6 x 10,146,270 ops/sec ±2.54% (90 runs sampled)
7 x 60,353,419 ops/sec ±0.35% (97 runs sampled)

Fastest is 7 Tal Liron
jnthnjns
quelle
0

Hier ist mein Code. Es wird überprüft, ob es sich um eine leere Zeichenfolge handelt (die sonst übergeben wird), und anschließend in ein numerisches Format konvertiert. Abhängig davon, ob '1.1' gleich 1.1 sein soll, ist dies möglicherweise das, wonach Sie suchen, oder auch nicht.

var isFloat = function(n) {
    n = n.length > 0 ? Number(n) : false;
    return (n === parseFloat(n));
};
var isInteger = function(n) {
    n = n.length > 0 ? Number(n) : false;
    return (n === parseInt(n));
};

var isNumeric = function(n){

   if(isInteger(n) || isFloat(n)){
        return true;
   }
   return false;

};
Michael Ryan Soileau
quelle
0

Ich mag diese kleine Funktion, die sowohl für positive als auch für negative ganze Zahlen wahr ist:

function isInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN(val+".0");
}

Dies funktioniert, weil 1 oder "1" zu "1.0" wird, was ist, dass NaN () false zurückgibt (was wir dann negieren und zurückgeben), aber 1.0 oder "1.0" zu "1.0.0" wird, während "string" zu "string" wird. 0 ", von denen keine Zahlen sind, daher gibt isNaN () false zurück (und wird erneut negiert).

Wenn Sie nur positive ganze Zahlen möchten, gibt es diese Variante:

function isPositiveInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN("0"+val);
}

oder für negative ganze Zahlen:

function isNegativeInt(val) {
    return `["string","number"].indexOf(typeof(val)) > -1` && val !== '' && isNaN("0"+val);
}

isPositiveInt () verschiebt die verkettete numerische Zeichenfolge vor den zu testenden Wert. Zum Beispiel führt isPositiveInt (1) dazu, dass isNaN () "01" auswertet, was false auswertet. Währenddessen führt isPositiveInt (-1) dazu, dass isNaN () "0-1" auswertet, was true ergibt. Wir negieren den Rückgabewert und das gibt uns, was wir wollen. isNegativeInt () funktioniert ähnlich, ohne jedoch den Rückgabewert von isNaN () zu negieren.

Bearbeiten:

Meine ursprüngliche Implementierung würde auch für Arrays und leere Zeichenfolgen true zurückgeben. Diese Implementierung hat diesen Fehler nicht. Es hat auch den Vorteil, dass es frühzeitig zurückgegeben wird, wenn val keine Zeichenfolge oder Zahl ist oder wenn es eine leere Zeichenfolge ist, was es in diesen Fällen schneller macht. Sie können es weiter ändern, indem Sie die ersten beiden Klauseln durch ersetzen

typeof(val) != "number"

wenn Sie nur Literalzahlen (und keine Zeichenfolgen) abgleichen möchten)

Bearbeiten:

Ich kann noch keine Kommentare posten, daher füge ich dies meiner Antwort hinzu. Der von @Asok veröffentlichte Benchmark ist sehr informativ. Die schnellste Funktion entspricht jedoch nicht den Anforderungen, da sie auch TRUE für Floats, Arrays, Boolesche Werte und leere Zeichenfolgen zurückgibt.

Ich habe die folgende Testsuite erstellt, um jede der Funktionen zu testen, und meine Antwort ebenfalls zur Liste hinzugefügt (Funktion 8, die Zeichenfolgen analysiert, und Funktion 9, die dies nicht tut):

funcs = [
    function(n) {
        return n % 1 == 0;
    },
    function(n) {
        return typeof n === 'number' && n % 1 == 0;
    },
    function(n) {
        return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
    },
    function(n) {
        return n.toString().indexOf('.') === -1;
    },
    function(n) {
        return n === +n && n === (n|0);
    },
    function(n) {
        return parseInt(n) === n;
    },
    function(n) {
        return /^-?[0-9]+$/.test(n.toString());
    },
    function(n) {
        if ((undefined === n) || (null === n)) {
            return false;
        }
        if (typeof n == 'number') {
            return true;
        }
        return !isNaN(n - 0);
    },
    function(n) {
        return ["string","number"].indexOf(typeof(n)) > -1 && n !== '' && !isNaN(n+".0");
    }
];
vals = [
    [1,true],
    [-1,true],
    [1.1,false],
    [-1.1,false],
    [[],false],
    [{},false],
    [true,false],
    [false,false],
    [null,false],
    ["",false],
    ["a",false],
    ["1",null],
    ["-1",null],
    ["1.1",null],
    ["-1.1",null]
];

for (var i in funcs) {
    var pass = true;
    console.log("Testing function "+i);
    for (var ii in vals) {
        var n = vals[ii][0];
        var ns;
        if (n === null) {
            ns = n+"";
        } else {
            switch (typeof(n)) {
                case "string":
                    ns = "'" + n + "'";
                    break;
                case "object":
                    ns = Object.prototype.toString.call(n);
                    break;
                default:
                    ns = n;
            }
            ns = "("+typeof(n)+") "+ns;
        }

        var x = vals[ii][1];
        var xs;
        if (x === null) {
            xs = "(ANY)";
        } else {
            switch (typeof(x)) {
                case "string":
                    xs = "'" + n + "'";
                    break;
                case "object":
                    xs = Object.prototype.toString.call(x);
                    break;
                default:
                    xs = x;
            }
            xs = "("+typeof(x)+") "+xs;
        }

        var rms;
        try {
            var r = funcs[i](n);
            var rs;
            if (r === null) {
                rs = r+"";
            } else {
                switch (typeof(r)) {
                    case "string":
                        rs = "'" + r + "'";
                        break;
                    case "object":
                        rs = Object.prototype.toString.call(r);
                        break;
                    default:
                        rs = r;
                }
                rs = "("+typeof(r)+") "+rs;
            }

            var m;
            var ms;
            if (x === null) {
                m = true;
                ms = "N/A";
            } else if (typeof(x) == 'object') {
                m = (xs === rs);
                ms = m;
            } else {
                m = (x === r);
                ms = m;
            }
            if (!m) {
                pass = false;
            }
            rms = "Result: "+rs+", Match: "+ms;
        } catch (e) {
            rms = "Test skipped; function threw exception!"
        }

        console.log("    Value: "+ns+", Expect: "+xs+", "+rms);
    }
    console.log(pass ? "PASS!" : "FAIL!");
}

Ich habe auch den Benchmark mit der Funktion # 8 wiederholt, die der Liste hinzugefügt wurde. Ich werde das Ergebnis nicht veröffentlichen, da sie etwas peinlich sind (z. B. ist diese Funktion NICHT schnell) ...

Die (gekürzt - ich habe erfolgreiche Tests entfernt, da die Ausgabe ziemlich lang ist) Ergebnisse sind wie folgt:

Testing function 0
Value: (object) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 1
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 2
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 3
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) 'a', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 4
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 5
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 6
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 7
Value: (number) 1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (number) -1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
FAIL!

Testing function 8
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 9
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Ich habe Fehler hinterlassen, damit Sie sehen können, wo jede Funktion ausfällt, und die (Zeichenfolge) '#' testet, damit Sie sehen können, wie jede Funktion Ganzzahl- und Gleitkommawerte in Zeichenfolgen behandelt, da einige diese möglicherweise als Zahlen und andere analysieren möchten nicht dürfen.

Von den 10 getesteten Funktionen sind diejenigen, die tatsächlich den Anforderungen von OP entsprechen, [1,3,5,6,8,9]

KeMBro2012
quelle
0

Bedingung für die Floating-Validierung:

if (lnk.value == +lnk.value && lnk.value != (lnk.value | 0)) 

Bedingung für die Ganzzahlvalidierung:

if (lnk.value == +lnk.value && lnk.value == (lnk.value | 0)) 

Hoffe das könnte hilfreich sein.

Joe Mike
quelle
0
function int(a) {
  return a - a === 0 && a.toString(32).indexOf('.') === -1
}

function float(a) {
  return a - a === 0 && a.toString(32).indexOf('.') !== -1
}

Sie können hinzufügen, typeof a === 'number'wenn Sie Zeichenfolgen ausschließen möchten.

Mirek Rusin
quelle