Examples of N ways to determine integer types in JavaScript_javascript skills

Integer type (Integer) often causes some strange problems in JavaScript. In the ECMAScript specification, they exist only as concepts:

All numbers are floating point numbers, and integers are just a set of numbers without decimals.

In this blog, I will explain how to check whether a value is an integer.
ECMAScript 5

There are many methods you can use in ES5. Sometimes, you may want to use your own method: a function isInteger(x), which returns true if it is an integer, otherwise it returns false.

Let’s look at some examples.

Pass remainder check

You can use the remainder operation (%) to calculate the remainder of a number by 1 to see if the remainder is 0.

function isInteger(x) {
  return x % 1 === 0;
}

I like this method because it is very simple and effective.

> isInteger(17)
true
> isInteger(17.13)
false

You have to be careful when operating remainder operations, because the result depends on the sign of the first number. If it is positive, the result is positive; otherwise, it is negative.

> 3.5 % 1
0.5
> -3.5 % 1
-0.5

Then, we can also check for 0, which is not really a problem. But the problem is: this method will also return true for non-numbers, because % will convert it to a number:

> isInteger('')
true
> isInteger('33')
true
> isInteger(false)
true
> isInteger(true)
true

Can be solved with a very simple type check:

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

Through Math.round(), if a number is the same as its previous value after rounding, then it is an integer. This can be checked via Math.round() in JavaScript:

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

This method is also good

> isInteger(17)
true
> isInteger(17.13)
false

It can also determine non-numbers, because Math.round() always returns numbers, and === returns true only when the types are the same.

> isInteger('')
false

If you want to make the code a little clearer, you can add type checking (which is what we did in previous versions). Additionally, Math.floor() and Math.ceil() work like Math.round(). Checking through bit operations Bit operators provide another way of "rounding":

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

This solution (like other bitwise operations) has a flaw: it cannot handle numbers larger than 32 bits.

> isInteger(Math.pow(2, 32))
false

Check by parseInt() parseInt() also provides a method similar to Math.round() to convert numbers into integers. Let's see why this method is good.

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

Like the Math.round() solution, it can also handle non-numeric cases, but it also does not handle all integer numbers correctly:

> isInteger(1000000000000000000000)
false

Why? parseInt() forces the first argument to be parsed as a string before parsing an integer. Therefore using this method to convert numbers to integers is not a good choice.

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

Just like the above, parseInt() stopped processing at 1 when parsing '1e 21', so it will return 1. ECMAScript 6 In addition to Math.round(), ES6 provides another number Method to convert to integer: Math.trunc(). This function removes the decimal part of a number.

> Math.trunc(4.1)
4
> Math.trunc(4.9)
4
> Math.trunc(-4.1)
-4
> Math.trunc(-4.9)
-4

Additionally, ECMAScript 6 does not need to deal with the trivial task of checking integers because it comes with a built-in function Number.isInteger().