Examples of N methods for judging integers in JavaScript

Integer types (Integer) often cause some strange problems in JavaScript. In the ECMAScript specification, they exist only in the concept:

All numbers are floating point numbers, and integers just don't have a set of numbers without decimals.

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

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

Let's take a look at some examples.

Pass the remainder check

You can use the remainder operation (%) and calculate the remainder 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 0, which is not actually a problem. But the problem is: this method will also return true for non-digits, because % will convert it to a number:

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

It can be solved by simple type checking:

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

If a number is rounded and still has the same value as the previous one, then it is an integer. In JavaScript, you can check it by ():

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

This method is also good

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

It can also judge non-numeric, because () always returns numbers and === returns true only if the type is the same.

> isInteger('')
false

If you want to make the code clearer, you can add type checking (which is what we did in previous versions). Also, () and () can work like (). Check the bit operator through bit operations to provide another "rounding" method:

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

This solution (like other bit operations) has one drawback: it cannot handle numbers that exceed 32 bits.

> isInteger((2, 32))
false

Checking parseInt() through parseInt() also provides a similar method to() to convert numbers into integers. Let's see why this method is good.

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

Like the() solution, it can handle non-numeric cases, but it also doesn't handle all integer numbers correctly:

> isInteger(1000000000000000000000)
false

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

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

Just like above, parseInt() stops processing at 1 when parsing '1e+21', so it returns 1. ECMAScript 6 For the () throw addition, ES6 provides another way to convert numbers into integers: (). This function removes the fractional part of the number.

> (4.1)
4
> (4.9)
4
> (-4.1)
-4
> (-4.9)
-4

In addition, ECMAScript6 does not need to deal with trivial tasks that check integers, because it comes with a built-in function ().