Why is there no type guard for Number.isFinite()?

Question

Why is there no type guard for Number.isFinite()?

Why doesn't Number.isFinite have a type guard like number is number?

This example triggers an error Object is possibly 'undefined'

function inc (n?: number) {
  return Number.isFinite(n) ? n + 1 : 1;
}

Check it out on the Playground:

https://www.typescriptlang.org/play?ssl=1&ssc=1&pln=3&pc=2#code/GYVwdgxgLglg9mABDSiAUYD8AuRYQC2ARgKYBOAlIgN4BQiiZJUIZSAcoaWQHQwDOAMRQwoJDFUx5EAakQBGRLnkBuWgF8gA

javascript typescript

Answer 1

Answer №1

Number.isFinite() isn't considered a type guard due to its potential for unexpected behavior in certain cases.

For example, Number.isFinite(4) returns true because the value is a number, which is expected. However, Number.isFinite("apple") returns false because the value is not a number. Here's where it gets tricky - Number.isFinite(Infinity) returns false, even though the value is technically a number.

In JavaScript, values like Infinity, -Infinity, and NaN are considered type number but are not finite. Despite the confusion, this distinction is crucial.

While non-finite values are not usually important, they are still valid for mathematical operations and can have practical uses in certain scenarios.

If Number.isFinite() were to act as a type guard, unexpected results could occur. Consider the following code snippet:

function atLeast(minValue: string | number, num: number): boolean {
    const min: number = Number.isFinite(minValue)
        ? minValue
        : Number(minValue.replace(/\D/g, "")); //convert

    return num >= min;
}

Executing this code can lead to errors, such as treating a non-number as a number, due to improper type assertion.

In a practical use case, you might encounter a scenario where inadvertent type narrowing results in unexpected behavior. This is why Number.isFinite() is not suitable as a type guard, as it can incorrectly define the type of a value.

¹ NaN serves as a placeholder for values that cannot be converted to a number, preventing unintentional conversions. This behavior is essential for maintaining the integrity of mathematical operations in JavaScript.

Due to the ambiguous nature of NaN, comparisons involving it may yield unexpected results, mirroring comparisons between dissimilar string values.

Answer 2

Number.isFinite() isn't considered a type guard due to its potential for unexpected behavior in certain cases.

For example, Number.isFinite(4) returns true because the value is a number, which is expected. However, Number.isFinite("apple") returns false because the value is not a number. Here's where it gets tricky - Number.isFinite(Infinity) returns false, even though the value is technically a number.

In JavaScript, values like Infinity, -Infinity, and NaN are considered type number but are not finite. Despite the confusion, this distinction is crucial.

While non-finite values are not usually important, they are still valid for mathematical operations and can have practical uses in certain scenarios.

If Number.isFinite() were to act as a type guard, unexpected results could occur. Consider the following code snippet:

function atLeast(minValue: string | number, num: number): boolean {
    const min: number = Number.isFinite(minValue)
        ? minValue
        : Number(minValue.replace(/\D/g, "")); //convert

    return num >= min;
}

Executing this code can lead to errors, such as treating a non-number as a number, due to improper type assertion.

In a practical use case, you might encounter a scenario where inadvertent type narrowing results in unexpected behavior. This is why Number.isFinite() is not suitable as a type guard, as it can incorrectly define the type of a value.

¹ NaN serves as a placeholder for values that cannot be converted to a number, preventing unintentional conversions. This behavior is essential for maintaining the integrity of mathematical operations in JavaScript.

Due to the ambiguous nature of NaN, comparisons involving it may yield unexpected results, mirroring comparisons between dissimilar string values.

Answer 3

Answer №2

Before delving deeper into this topic, let's provide some context. At first glance, it appears that the issue at hand revolves around the distinction between two JavaScript functions:

isFinite

This function will take its argument and convert it into a number before proceeding with the operation. On the other hand, we have:

Number.isFinite

This function, in contrast, accepts any type of argument and only returns true if the input is a finite number, without performing any implicit conversions. In TypeScript, these functions have the following signatures:

function isFinite(number: number): boolean

(method) NumberConstructor.isFinite(number: unknown): boolean

One notable difference is that the parameter type in the second method is unknown instead of number. This is due to the fact that in JavaScript, Number.isFinite will return false for non-numbers, while isFinite will coerce non-numeric inputs.

> Number.isFinite(false)
false
> isFinite(false)
true
> Number.isFinite(Symbol(2))
false
> isFinite(Symbol(2))
Uncaught TypeError: Cannot convert a Symbol value to a number at isFinite (<anonymous>)

Given that Number.isFinite is expected to handle inputs of any type and return false for non-numeric values, it makes sense for the parameter type in TypeScript to be unknown. Conversely, for isFinite which is designed to operate solely on numbers and performs coercion that TypeScript helps us avoid, restricting the parameter type to number is logical.

However, a valid question arises - why can't Number.isFinite be used as a type guard, since it only returns true for numerical inputs? The reason is that while it may return true for some numbers, it does not cover all cases. Attempting to create a custom guard:

function numberIsFinite(n: any): n is number {
    return Number.isFinite(n)
}

shows expected behavior for certain inputs:

console.log(numberIsFinite(20)) // true
console.log(numberIsFinite(Number.MAX_VALUE)) // true
console.log(numberIsFinite(undefined)) // false
console.log(numberIsFinite("still ok")) // false

However, when dealing with values such as Infinity and NaN:

console.log(numberIsFinite(Infinity)) // false but uh-oh
console.log(numberIsFinite(NaN)) // false but uh-oh

The type guard fails in these scenarios, resulting in unexpected outcomes. This highlights the limitations of using Number.isFinite as a reliable type guard. If there existed a TS type specifically for "finite numbers," then considering Number.isFinite as a type guard might make more sense.

I'd like to acknowledge @VLAZ for laying the groundwork for this explanation in their answer. I have expanded upon their insights in this revised response.

Answer 4

Before delving deeper into this topic, let's provide some context. At first glance, it appears that the issue at hand revolves around the distinction between two JavaScript functions:

isFinite

This function will take its argument and convert it into a number before proceeding with the operation. On the other hand, we have:

Number.isFinite

This function, in contrast, accepts any type of argument and only returns true if the input is a finite number, without performing any implicit conversions. In TypeScript, these functions have the following signatures:

function isFinite(number: number): boolean

(method) NumberConstructor.isFinite(number: unknown): boolean

One notable difference is that the parameter type in the second method is unknown instead of number. This is due to the fact that in JavaScript, Number.isFinite will return false for non-numbers, while isFinite will coerce non-numeric inputs.

> Number.isFinite(false)
false
> isFinite(false)
true
> Number.isFinite(Symbol(2))
false
> isFinite(Symbol(2))
Uncaught TypeError: Cannot convert a Symbol value to a number at isFinite (<anonymous>)

Given that Number.isFinite is expected to handle inputs of any type and return false for non-numeric values, it makes sense for the parameter type in TypeScript to be unknown. Conversely, for isFinite which is designed to operate solely on numbers and performs coercion that TypeScript helps us avoid, restricting the parameter type to number is logical.

However, a valid question arises - why can't Number.isFinite be used as a type guard, since it only returns true for numerical inputs? The reason is that while it may return true for some numbers, it does not cover all cases. Attempting to create a custom guard:

function numberIsFinite(n: any): n is number {
    return Number.isFinite(n)
}

shows expected behavior for certain inputs:

console.log(numberIsFinite(20)) // true
console.log(numberIsFinite(Number.MAX_VALUE)) // true
console.log(numberIsFinite(undefined)) // false
console.log(numberIsFinite("still ok")) // false

However, when dealing with values such as Infinity and NaN:

console.log(numberIsFinite(Infinity)) // false but uh-oh
console.log(numberIsFinite(NaN)) // false but uh-oh

The type guard fails in these scenarios, resulting in unexpected outcomes. This highlights the limitations of using Number.isFinite as a reliable type guard. If there existed a TS type specifically for "finite numbers," then considering Number.isFinite as a type guard might make more sense.

I'd like to acknowledge @VLAZ for laying the groundwork for this explanation in their answer. I have expanded upon their insights in this revised response.

Answer 5

Answer №3

In TypeScript, there is no direct way to handle returning a value while also checking for specific conditions. One approach is to include an extra validation step to ensure non-undefined values are considered (potentially removing the need for Number.isFinite in some cases).

function increment (num?: number) {
    return typeof num === "number" && Number.isFinite(num) ? num + 1 : 1;
}

Alternatively, you can create your custom guard function for checking finite numbers.

Answer 6

In TypeScript, there is no direct way to handle returning a value while also checking for specific conditions. One approach is to include an extra validation step to ensure non-undefined values are considered (potentially removing the need for Number.isFinite in some cases).

function increment (num?: number) {
    return typeof num === "number" && Number.isFinite(num) ? num + 1 : 1;
}

Alternatively, you can create your custom guard function for checking finite numbers.

Why is there no type guard for Number.isFinite()?

Answer №1

Answer №2

Answer №3

Similar questions

Unable to `.catch()` an error while utilizing Jquery.ajax().then()

How to Preserve Scroll Position when Toggling a Div using jQuery

html retrieve newly updated page from the provided link

Exploring Angular 9: Harnessing the Power of Fork Join with an Array of

put two elements next to each other in a single row

Can you demonstrate how to display the chosen toggle button within Angular 4 alongside the remaining options?

Transferring PHP data to JQuery through HTML elements

Avoid working on the script for the element in the partial view during the event

Issue: TypeError - 'process.env' can only accept a configurable while installing windows-build-tools

What is the best way to save a Firebase user's unique identifier in a React application?

Experiencing Strange Issues with Jquery Image Carousel... Assistance Needed!

There seems to be an issue with byRole as it is failing to return

Retrieve all attributes of an element with the help of jQuery

Mastering the Art of jQuery Function Chaining for Beginners

The JavaScript button's onClick event is not functioning properly, despite the method executing normally

Switching an element from li to div and vice versa using Jquery Drag and Drop

Tips for effectively handling the auth middleware in react.js by utilizing LocalStorage

Node.js Conditional Logic using Javascript

"Upon inspection, the TrackerReact Container shows that the user's profile.avatar is set, yet the console is indicating that

Recalling the use of jquery toggle throughout the website?