Wie überprüft man, ob eine Variable in JavaScript eine Ganzzahl ist?

Question

Wie überprüfe ich in JavaScript, ob eine Variable eine Ganzzahl ist, und gebe einen Alert aus, wenn nicht? Ich habe es versucht, aber es funktioniert nicht:

            var data = 22;
            alert(NaN(data));

Answer 1

Was ist mit großen Ganzzahlen (bigint)?

Die meisten dieser Antworten scheitern bei großen Ganzzahlen (253 und größer): Bitwise-Tests(z.B. (x | 0) === x), Testen von typeof x === 'number', regelmäßige Ganzzahlenfunktionen (z.B. parseInt), regelmäßige Arithmetik scheitern bei großen Ganzzahlen. Dies kann durch Verwendung von BigInt gelöst werden.

Ich habe mehrere Antworten zu einem Snippet zusammengefasst, um die Ergebnisse zu zeigen. Die meisten scheitern bei großen Ganzzahlen, während andere funktionieren, außer wenn der Typ BigInt übergeben wird (z.B. 1n). Ich habe keine doppelten Antworten aufgenommen und habe auch Antworten weggelassen, die Dezimalzahlen erlauben oder nicht versuchen, den Typ zu testen)

// diese alle scheitern
n = 1000000000000000000000000000000
b = 1n

// Diese alle scheitern bei großen Ganzzahlen
//https://stackoverflow.com/a/14636652/3600709
console.log('fehler',1,n === parseInt(n, 10))
//https://stackoverflow.com/a/14794066/3600709
console.log('fehler',2,!isNaN(n) && parseInt(Number(n)) == n && !isNaN(parseInt(n, 10)))
console.log('fehler',2,!isNaN(n) && (parseFloat(n) | 0) === parseFloat(n))
console.log('fehler',2,!isNaN(n) && (function(x) { return (x | 0) === x; })(parseFloat(n)))
//https://stackoverflow.com/a/21742529/3600709
console.log('fehler',3,n == ~~n)
//https://stackoverflow.com/a/28211631/3600709
console.log('fehler',4,!isNaN(n) && parseInt(n) == parseFloat(n))
//https://stackoverflow.com/a/41854178/3600709
console.log('fehler',5,String(parseInt(n, 10)) === String(n))

// Diese funktionieren für Ganzzahlen, aber nicht für BigInt-Typen (z.B. 1n)
//https://stackoverflow.com/a/14636725/3600709
console.log('teilweise',1,typeof n==='number' && (n%1)===0) // diese funktioniert
console.log('teilweise',1,typeof b==='number' && (b%1)===0) // diese scheitert
//https://stackoverflow.com/a/27424770/3600709
console.log('teilweise',2,Number.isInteger(n)) // diese funktioniert
console.log('teilweise',2,Number.isInteger(b)) // diese scheitern
//https://stackoverflow.com/a/14636638/3600709
console.log('teilweise',3,n % 1 === 0)
console.log('teilweise',3,b % 1 === 0) // gibt Uncaught-Typ bei BigInt

Typ überprüfen

Wenn Sie tatsächlich den Typ des eingehenden Werts überprüfen möchten, um sicherzustellen, dass es sich um eine Ganzzahl handelt, verwenden Sie stattdessen dies:

function isInt(value) {
    try {
        BigInt(value)
        return !['string','object','boolean'].includes(typeof value)
    } catch(e) {
        return false
    }
}

function isInt(value) {
    try {
        BigInt(value)
        return !['string','object','boolean'].includes(typeof value)
    } catch(e) {
        return false
    }
}

console.log('--- sollte false sein')
console.log(isInt(undefined))
console.log(isInt(''))
console.log(isInt(null))
console.log(isInt({}))
console.log(isInt([]))
console.log(isInt(1.1e-1))
console.log(isInt(1.1))
console.log(isInt(true))
console.log(isInt(NaN))
console.log(isInt('1'))
console.log(isInt(function(){}))
console.log(isInt(Infinity))

console.log('--- sollte true sein')
console.log(isInt(10))
console.log(isInt(0x11))
console.log(isInt(0))
console.log(isInt(-10000))
console.log(isInt(100000000000000000000000000000000000000))
console.log(isInt(1n)

---

Ohne Typüberprüfung

Wenn es Ihnen nicht wichtig ist, ob der eingehende Typ tatsächlich zu boolean, string usw. in eine Zahl konvertiert wird, verwenden Sie einfach folgendes:

function isInt(value) {
    try {
        BigInt(value)
        return true
    } catch(e) {
        return false
    }
}

function isInt(value) {
    try {
        BigInt(value)
        return true
    } catch(e) {
        return false
    }
}

console.log('--- sollte false sein')
console.log(isInt(undefined))
console.log(isInt(null))
console.log(isInt({}))
console.log(isInt(1.1e-1))
console.log(isInt(1.1))
console.log(isInt(NaN))
console.log(isInt(function(){}))
console.log(isInt(Infinity))

console.log('--- sollte true sein')
console.log(isInt(10))
console.log(isInt(0x11))
console.log(isInt(0))
console.log(isInt(-10000))
console.log(isInt(100000000000000000000000000000000000000))
console.log(isInt(1n))
// wird in eine Zahl umgewandelt
console.log(isInt(''))
console.log(isInt([]))
console.log(isInt(true))
console.log(isInt('1'))

Answer 2

Nur versuche das:

let number = 5;
if (Number.isInteger(number)) {
    //etwas tun
}

Answer 3

Der ECMA-262 6.0 (ES6) Standard enthält die Number.isInteger Funktion.

Um Unterstützung für alte Browser hinzuzufügen, empfehle ich dringend die Verwendung einer robusten und von der Community unterstützten Lösung von:

https://github.com/paulmillr/es6-shim

das ist eine reine ES6 JS Polyfills-Bibliothek.

Beachten Sie, dass diese Bibliothek es5-shim erfordert, folgen Sie einfach der README.md.

Answer 4

Mein Ansatz:

a >= 1e+21 Funktioniert nur für sehr große Zahlen. Dies wird sicherlich alle Fälle abdecken, im Gegensatz zu anderen Lösungen, die in dieser Diskussion bereitgestellt wurden.

a === (a|0) Wenn das Argument der gegebenen Funktion genau den gleichen (===) wie der bitweise transformierte Wert ist, bedeutet dies, dass das Argument eine Ganzzahl ist.

a|0 gibt 0 für jeden Wert von a zurück, der keine Zahl ist, und wenn a tatsächlich eine Zahl ist, entfernt es alles nach dem Dezimalpunkt, sodass 1.0001 zu 1 wird.

const isInteger = n => n >= 1e+21 ? true : n === (n|0);

// tests:
[
  [1,                         true],
  [1000000000000000000000,    true],
  [4e2,                       true],
  [Infinity,                  true],
  [1.0,                       true],
  [1.0000000000001,           false],
  [0.1,                       false],
  ["0",                       false],
  ["1",                       false],
  ["1.1",                     false],
  [NaN,                       false],
  [[],                        false],
  [{},                        false],
  [true,                      false],
  [false,                     false],
  [null,                      false],
  [undefined,                 false],
].forEach(([test, expected]) => 
  console.log(
    isInteger(test) === expected, 
    typeof test, 
    test
   ) 
)

Answer 5

Verwenden Sie den | Operator:

(5.3 | 0) === 5.3 // => false
(5.0 | 0) === 5.0 // => true

Also könnte eine Testfunktion so aussehen:

var isInteger = function (value) {
  if (typeof value !== 'number') {
    return false;
  }

  if ((value | 0) !== value) {
    return false;
  }

  return true;
};