javascript - Hoe te controleren of een variabele een geheel getal is in JavaScript?

Hoe controleer ik of een variabele een geheel getal is in JavaScript en een alert gooit als het niet is? Ik heb dit geprobeerd, maar het werkt niet:

<html>
    <head>
        <script type="text/javascript">
            var data = 22;
            alert(NaN(data));
        </script>
    </head>
</html>

1, Autoriteit 100%

Gebruik de bediener === (Strenge gelijkheid ) zoals hieronder,

if (data === parseInt(data, 10))
    alert("data is integer")
else
    alert("data is not an integer")

2, Autoriteit 147%

Dat hangt er vanaf, wil je ook snaren als potentiële gehele getallen gooien?

Dit zal doen:

function isInt(value) {
  return !isNaN(value) && 
         parseInt(Number(value)) == value && 
         !isNaN(parseInt(value, 10));
}

met bitwise-operaties

Eenvoudig ontleden en controleren

function isInt(value) {
  var x = parseFloat(value);
  return !isNaN(value) && (x | 0) === x;
}

Short-circuits en opslaan van een parse-werking:

function isInt(value) {
  if (isNaN(value)) {
    return false;
  }
  var x = parseFloat(value);
  return (x | 0) === x;
}

of misschien zowel in één keer:

function isInt(value) {
  return !isNaN(value) && (function(x) { return (x | 0) === x; })(parseFloat(value))
}

Testen:

isInt(42)        // true
isInt("42")      // true
isInt(4e2)       // true
isInt("4e2")     // true
isInt(" 1 ")     // true
isInt("")        // false
isInt("  ")      // false
isInt(42.1)      // false
isInt("1a")      // false
isInt("4e2a")    // false
isInt(null)      // false
isInt(undefined) // false
isInt(NaN)       // false

Hier is de viool: http://jsfiddle.net/opfyrqwp/28/

Prestaties

Uit testen blijkt dat de kortsluitoplossing de beste prestaties levert (ops/sec).

// Short-circuiting, and saving a parse operation
function isInt(value) {
  var x;
  if (isNaN(value)) {
    return false;
  }
  x = parseFloat(value);
  return (x | 0) === x;
}

Hier is een benchmark:
http://jsben.ch/#/htLVw

Als je zin hebt in een kortere, stompe vorm van kortsluiting:

function isInt(value) {
  var x;
  return isNaN(value) ? !1 : (x = parseFloat(value), (0 | x) === x);
}

Natuurlijk stel ik voor dat de minifier daarvoor zorgt.

Antwoord 3, autoriteit 34%

Ervan uitgaande dat u niets weet over de betreffende variabele, moet u deze benadering volgen:

if(typeof data === 'number') {
    var remainder = (data % 1);
    if(remainder === 0) {
        // yes, it is an integer
    }
    else if(isNaN(remainder)) {
        // no, data is either: NaN, Infinity, or -Infinity
    }
    else {
        // no, it is a float (still a number though)
    }
}
else {
    // no way, it is not even a number
}

Om het eenvoudig te doen:

if(typeof data==='number' && (data%1)===0) {
    // data is an integer
}

4, Autoriteit 32%

Number.isInteger()lijkt de manier te zijn om te gaan.

MDN heeft ook de volgende polyfill voor browsers verstrekt die niet worden ondersteund Number.isInteger(), voornamelijk alle versies van IE.

Link naar MDN-pagina

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

5, Autoriteit 21%

U kunt controleren of het nummer een rest heeft:

var data = 22;
if(data % 1 === 0){
   // yes it's an integer.
}

Let op, als uw invoer ook tekst kan zijn en u wilt eerst controleren, is het niet, dan kunt u het type eerst controleren:

var data = 22;
if(typeof data === 'number'){
     // yes it is numeric
    if(data % 1 === 0){
       // yes it's an integer.
    }
}

6, Autoriteit 7%

U kunt een eenvoudige reguliere expressie gebruiken:

function isInt(value) {
    var er = /^-?[0-9]+$/;
    return er.test(value);
}

Antwoord 7, autoriteit 5%

In ES6zijn 2 nieuwe methoden toegevoegd voor Number Object.

In it Number.isInteger()methode retourneert trueals het argument een geheel getal is, anders wordt false geretourneerd.

Belangrijke opmerking:de methode retourneert ook waar voor getallen met drijvende komma die als geheel getal kunnen worden weergegeven. Bijv.: 5.0 (omdat het precies gelijk is aan 5 )

Voorbeeld gebruik:

Number.isInteger(0);         // true
Number.isInteger(1);         // true
Number.isInteger(-100000);   // true
Number.isInteger(99999999999999999999999); // true
Number.isInteger(0.1);       // false
Number.isInteger(Math.PI);   // false
Number.isInteger(NaN);       // false
Number.isInteger(Infinity);  // false
Number.isInteger(-Infinity); // false
Number.isInteger('10');      // false
Number.isInteger(true);      // false
Number.isInteger(false);     // false
Number.isInteger([1]);       // false
Number.isInteger(5.0);       // true
Number.isInteger(5.000000000000001); // false
Number.isInteger(5.0000000000000001); // true

Antwoord 8, autoriteit 4%

Ten eerste is NaN een “getal” (ja ik weet dat het raar is, rol er maar mee door), en geen “functie”.

Je moet zowel controleren of het type van de variabele een getal is, als om te controleren op een geheel getal zou ik modulus gebruiken.

alert(typeof data === 'number' && data%1 == 0);

Antwoord 9, autoriteit 4%

Wees voorzichtig bij het gebruik

aantal % 1

lege tekenreeks (”) of boolean (waar of onwaar) wordt geretourneerd als geheel getal. Misschien wil je dat niet doen

false % 1 // true
'' % 1 //true

Number.isInteger(data)

Number.isInteger(22); //true
Number.isInteger(22.2); //false
Number.isInteger('22'); //false

functie ingebouwd in de browser. Ondersteunt geen oudere browsers

Alternatieven:

Math.round(num)=== num

Math.round() zal echter ook mislukken voor lege string en boolean

Antwoord 10, autoriteit 2%

Om te controleren of integer zoals poster wil:

if (+data===parseInt(data)) {return true} else {return false}

let op + voor gegevens (converteert tekenreeks naar getal), en === voor exact.

Hier zijn voorbeelden:

data=10
+data===parseInt(data)
true
data="10"
+data===parseInt(data)
true
data="10.2"
+data===parseInt(data)
false

Antwoord 11, autoriteit 2%

De eenvoudigste en schoonste pre-ECMAScript-6-oplossing (die ook voldoende robuust is om false te retourneren, zelfs als een niet-numerieke waarde zoals een string of null aan de functie wordt doorgegeven) zou de volgende zijn:

function isInteger(x) { return (x^0) === x; }

De volgende oplossing zou ook werken, hoewel niet zo elegant als de bovenstaande:

function isInteger(x) { return Math.round(x) === x; }

Merk opdat Math.ceil() of Math.floor() even goed kunnen worden gebruikt (in plaats van Math.round()) in de bovenstaande implementatie.

Of anders:

function isInteger(x) { return (typeof x === 'number') && (x % 1 === 0); }

Een vrij veel voorkomende onjuiste oplossing is de volgende:

function isInteger(x) { return parseInt(x, 10) === x; }

Hoewel deze op parseInt gebaseerde benadering goed zal werken voor veel waarden van x, zal het, zodra x behoorlijk groot wordt, niet meer goed werken. Het probleem is dat parseInt() de eerste parameter dwingt tot een tekenreeks voordat de cijfers worden geparseerd. Daarom, zodra het getal voldoende groot wordt, zal de tekenreeksrepresentatie in exponentiële vorm worden gepresenteerd (bijvoorbeeld 1e + 21). Dienovereenkomstig zal parseInt() dan proberen 1e+21 te ontleden, maar zal het ontleden stoppen wanneer het het e-teken bereikt en daarom een waarde van 1 teruggeven. Let op:

> String(1000000000000000000000)
'1e+21'
> parseInt(1000000000000000000000, 10)
1
> parseInt(1000000000000000000000, 10) === 1000000000000000000000
false

Antwoord 12, autoriteit 2%

Waarom heeft niemand Number.isInteger()genoemd?

https://developer.mozilla. org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger

Werkt perfect voor mij en lost het probleem op met de NaNdie begint met een nummer.

Antwoord 13

if(Number.isInteger(Number(data))){
    //-----
}

14

ECMA-262 6.0 (ES6) Standaard omvatten nummer. Isinteger functie.

Om ondersteuning voor oude browser toe te voegen, raad ik het ten zeerste aan met behulp van sterke en community ondersteunde oplossing van:

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

die puur is ES6 JS Polyfills-bibliotheek .

Merk op dat deze lib ES5-shim nodig heeft, volg gewoon Readme.md.

15

U kunt Number.isInteger(Number(value))Proberen als valueeen geheel getal in de reeksformulier is, bijvoorbeeld var value = "23"En u wilt dit evalueren naar true. Vermijd het proberen Number.isInteger(parseInt(value))omdat dit niet altijd de juiste waarde retourneert. E.g als var value = "23abc"en u gebruikt de parseIntimplementatie, het zou nog steeds true retourneren.

Maar als u strikt gehele waarden wilt, dan waarschijnlijk Number.isInteger(value)zou de truc moeten doen.

16

var x = 1.5;
if(!isNaN(x)){
 console.log('Number');
 if(x % 1 == 0){
   console.log('Integer');
 }
}else {
 console.log('not a number');
}

Antwoord 17

Mijn aanpak:

a >= 1e+21→ Alleen passvoor zeer grote aantallen. Dit dekt zeker alle gevallen, in tegenstelling tot andere oplossingen die in deze discussie zijn gegeven.

a === (a|0)→ als het argument van de gegeven functie exacthetzelfde is (===) als de bitsgewijze getransformeerde waarde, betekent dit dat het argument een geheel getal is.

a|0→ retourneer 0voor elke waarde van adie geen getal is, en als ainderdaad een getal is, wordt alles achter de komma verwijderd, dus 1.0001wordt 1

function isInteger(a){
    return a >= 1e+21 ? true : a === (a|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( a => console.log(typeof a, a, isInteger(a)) )

Antwoord 18

Controleer of de variabele gelijk is aan diezelfde variabele, afgerond op een geheel getal, als volgt:

if(Math.round(data) != data) {
    alert("Variable is not an integer!");
}

Antwoord 19

Je zou deze functie kunnen gebruiken:

function isInteger(value) {
    return (value == parseInt(value));
}

Het geeft true terug, zelfs als de waarde een tekenreeks is die een geheel getal bevat.
De resultaten zijn dus:

alert(isInteger(1)); // true
alert(isInteger(1.2)); // false
alert(isInteger("1")); // true
alert(isInteger("1.2")); // false
alert(isInteger("abc")); // false

Antwoord 20

Bovendien Number.isInteger(). Misschien is Number.isSafeInteger()een andere optie hiermet behulp van de ES6-gespecificeerde.

Om Number.isSafeInteger(..)polyfill in pre-ES6 browsers:

Number.isSafeInteger = Number.isSafeInteger || function(num) {
    return typeof num === "number" && 
           isFinite(num) && 
           Math.floor(num) === num &&
           Math.abs( num ) <= Number.MAX_SAFE_INTEGER;
};

Antwoord 21

Number.isInteger()is de beste manier als je browser het ondersteunt, zo niet, dan denk ik dat er zoveel manieren zijn:

function isInt1(value){
  return (value^0) === value
}

of:

function isInt2(value){
  return (typeof value === 'number') && (value % 1 === 0); 
}

of:

function isInt3(value){
  return parseInt(value, 10) === value; 
}

of:

function isInt4(value){
  return Math.round(value) === value; 
}

nu kunnen we de resultaten testen:

var value = 1
isInt1(value)   // return true
isInt2(value)   // return true
isInt3(value)   // return true
isInt4(value)   // return true
var value = 1.1
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false
var value = 1000000000000000000
isInt1(value)   // return false
isInt2(value)   // return true
isInt3(value)   // return false
isInt4(value)   // return true
var value = undefined
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false
var value = '1' //number as string
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false

Dus al deze methoden zijn werken, maar als het getal erg groot is, zouden de parseInt- en ^-operator niet goed werken.

Antwoord 22

Probeer dit eens:

let number = 5;
if (Number.isInteger(number)) {
    //do something
}

Antwoord 23

Het ‘geaccepteerde’ antwoord is fout (zoals sommige opmerkingen hieronder aangeven).
deze wijziging kan het laten werken:

if (data.toString() === parseInt(data, 10).toString())
    alert("data is a valid integer")
else
    alert("data is not a valid integer")

Antwoord 24

Hoe zit het met grote gehele getallen (`BigInt`)?

De meeste van deze antwoorden mislukken op grote gehele getallen (2⁵³en groter): Bitsgewijze tests (bijv. (x | 0) === x), testen van typeof x === 'number', reguliere int-functies (bijv. parseInt), reguliere rekenkunde mislukken op grote gehele getallen. Dit kan worden opgelost met behulp van BigInt.

Ik heb verschillende antwoorden in één fragment samengevoegd om de resultaten weer te geven. De meeste mislukken ronduit met grote gehele getallen, terwijl andere werken, behalve wanneer het type BigIntwordt doorgegeven (bijv. 1n). Ik heb geen dubbele antwoorden toegevoegd en heb ook alle antwoorden weggelaten die decimalen toestaan of die niet proberen het type te testen)

Antwoord 25

U kunt hiervoor regexp gebruiken:

function isInteger(n) {
    return (typeof n == 'number' && /^-?\d+$/.test(n+''));
}

Antwoord 26

Van http://www.toptal.com/javascript/interview-questions:

function isInteger(x) { return (x^0) === x; }

Ik vond dit de beste manier om dit te doen.

Antwoord 27

Hiermee wordt er nog een scenario (121 ) opgelost, een punt aan het einde

function isInt(value) {
        var ind = value.indexOf(".");
        if (ind > -1) { return false; }
        if (isNaN(value)) {
            return false;
        }
        var x = parseFloat(value);
        return (x | 0) === x;
    }

28

Voor positieve integerwaarden zonder scheiders:

return ( data !== '' && data === data.replace(/\D/, '') );

Tests
1. Zo niet leeg en
2. Indien de waarde gelijk is aan het resultaat van een vervanging van een niet-cijferige Char in zijn waarde.

29

OK gekregen min, oorzaak heeft mijn voorbeeld niet beschreven, dus meer voorbeelden :):

Ik gebruik regelmatige expressie- en testmethode:

var isInteger = /^[0-9]\d*$/;
isInteger.test(123); //true
isInteger.test('123'); // true
isInteger.test('sdf'); //false
isInteger.test('123sdf'); //false
// If u want to avoid string value:
typeof testVal !== 'string' && isInteger.test(testValue);

Previous articleHoe kan ik meerdere git-commits terugdraaien?

Next articleHuidige tijdsopmaak met JavaScript

Hoe te controleren of een variabele een geheel getal is in JavaScript?