Converting Float Numbers to Whole Numbers in JavaScript

In JavaScript, converting a float number to a whole number is a common operation that can be achieved through various methods. This tutorial will cover the different techniques for performing this conversion, including truncation and rounding.

Introduction to Conversion Methods

There are two primary methods for converting float numbers to whole numbers: truncation and rounding. Truncation involves removing the decimal part of the number, while rounding involves approximating the number to the nearest integer.

Using Math Functions

JavaScript provides several math functions that can be used for conversion:

• Math.floor(): Returns the largest integer less than or equal to the given number.
• Math.ceil(): Returns the smallest integer greater than or equal to the given number.
• Math.round(): Returns the nearest integer to the given number.
• Math.trunc(): Returns the integer part of the given number, effectively truncating the decimal part.

Here are some examples:

// Truncation using Math.trunc()
let floatNumber = 3.7;
let truncatedNumber = Math.trunc(floatNumber);
console.log(truncatedNumber); // Output: 3

// Rounding using Math.round()
floatNumber = 4.2;
let roundedNumber = Math.round(floatNumber);
console.log(roundedNumber); // Output: 4

// Truncation using Math.floor() and Math.ceil()
floatNumber = -3.1;
let truncatedNegativeNumber = floatNumber < 0 ? Math.ceil(floatNumber) : Math.floor(floatNumber);
console.log(truncatedNegativeNumber); // Output: -3

Bitwise Operations

Bitwise operations can also be used to convert float numbers to whole numbers. The bitwise OR operator (|) and the bitwise NOT operator (~) can be used for this purpose.

// Truncation using bitwise OR operator
floatNumber = 3.7;
let truncatedNumberUsingOr = floatNumber | 0;
console.log(truncatedNumberUsingOr); // Output: 3

// Truncation using bitwise NOT operator
floatNumber = -3.1;
let truncatedNegativeNumberUsingNot = ~~floatNumber;
console.log(truncatedNegativeNumberUsingNot); // Output: -3

Performance Comparison

When it comes to performance, bitwise operations are generally faster than math functions. However, for large numbers, the Math functions provide more accurate results.

// Performance comparison using JSPerf test
function floatToIntUsingMath(val) {
    return Math.floor(val);
}

function floatToIntUsingBitwiseOr(val) {
    return val | 0;
}

function floatToIntUsingBitwiseNot(val) {
    return ~~val;
}

Best Practices

When converting float numbers to whole numbers, consider the following best practices:

• Use Math.trunc() for truncation when possible.
• Use bitwise operations for performance-critical code, but be aware of their limitations for large numbers.
• Avoid using parseInt() for conversion, as it can lead to unexpected results.

By understanding the different methods for converting float numbers to whole numbers in JavaScript, you can write more efficient and accurate code.