How to convert long number into abbreviated string in JavaScript ?

Last Updated : 04 Jul, 2024

We are given a long number and the task is to convert it to the abbreviated string(eg.. 1234 to 1.2k). Here 2 approaches are discussed with the help of JavaScript.

Approaches to Convert Long Number to Abbreviated String:

Table of Content

Using JavaScript methods
Using Custom function
Using logarithms
Using Intl.NumberFormat
Using Recursion
Using External Library: numeral.js

Approach 1: Using JavaScript methods

Get the characters in an array(ar = ["", "k", "m", "b"])
Divide the length of the number by 3 and get the value in var(sNum).
If the sNum != 0 then calculate the precise value of the number by dividing it by 1000^sNum.
Append the character at index = sNum in the array, to the precise value to finally get the abbreviated number.

Example 1: This example implements the above approach.

JavaScript

// Input number 
let n = 123287342;
// Display input number
console.log(n);

// Function to convert number
function convert(val) {
    // Thousands, millions, billions etc..
    let s = ["", "k", "m", "b", "t"];

    // Dividing the value by 3.
    let sNum = Math.floor(("" + val).length / 3);

    // Calculating the precised value.
    let sVal = parseFloat(
        (sNum != 0
            ? val / Math.pow(1000, sNum)
            : val
        ).toPrecision(2)
    );

    if (sVal % 1 != 0) {
        sVal = sVal.toFixed(1);
    }

    // Appending the letter to precised val.
    return sVal + s[sNum];
}

// Function to show converted output
function GFG_Fun() {
    // Display output
    console.log("Number = " + convert(n));
}

GFG_Fun();

Output

123287342
Number = 0.1b

Approach 2: Using Custom function

Check if the number is less than 1e3, if it is then return the number as it is.
If the number is greater than or equal to 1e3 and less than 1e6 then remove the last three digits and append the character 'K' to it.
If the number is greater than or equal to 1e6 and less than 1e9 then remove the last six digits and append the character 'M' to it.
If the number is greater than or equal to 1e9 and less than 1e12 then remove the last nine digits and append the character 'B' to it.
If the number is greater than or equal to 1e12 remove the last 12 digits and append the character 'T' to it.

Example 2: This example implements the above approach.

JavaScript

// Input number
let n = 1232873425;

// Display input number
console.log(n);

// Function to convert
let convert = (n) => {
    if (n < 1e3) return n;
    if (n >= 1e3 && n < 1e6)
        return +(n / 1e3).toFixed(1) + "K";
    if (n >= 1e6 && n < 1e9)
        return +(n / 1e6).toFixed(1) + "M";
    if (n >= 1e9 && n < 1e12)
        return +(n / 1e9).toFixed(1) + "B";
    if (n >= 1e12) return +(n / 1e12).toFixed(1) + "T";
};

// Function to display converted output
function GFG_Fun() {
    // Display output
    console.log("Number = " + convert(n));
}

// Funcion call
GFG_Fun();

Output

1232873425
Number = 1.2B

Approach 3: Using logarithms

This approach involves using logarithms to determine the appropriate abbreviation for the number. We can take the logarithm base 10 of the given number to find its order of magnitude, which indicates the number of digits in the number. Then, we divide this order of magnitude by 3 to determine the appropriate index in the abbreviation array. Finally, we divide the number by 1000(order of magnitude/3) and append the corresponding abbreviation from the array.

JavaScript

// Input number
let n = 1232873425;

// Display input number
console.log(n);

// Function to convert
let convert = (n) => {
    // Abbreviation array
    let s = ["", "k", "m", "b", "t"];
    // Find the order of magnitude
    let orderOfMagnitude = Math.floor(Math.log10(n));
    // Determine the index in the abbreviation array
    let index = Math.floor(orderOfMagnitude / 3);
    // Calculate the abbreviated value
    let abbreviatedValue = parseFloat((n / Math.pow(1000, index)).toPrecision(2));
    // Append the abbreviation
    return abbreviatedValue + s[index];
};

// Function to display converted output
function GFG_Fun() {
    // Display output
    console.log("Number = " + convert(n));
}

// Function call
GFG_Fun();

Output

1232873425
Number = 1.2b

Approach 4: Using Intl.NumberFormat

In this approach, we can utilize the Intl.NumberFormat object in JavaScript to format the number according to a specified locale. By specifying a maximum significant digits count and using the notation property with the "compact" option, we can automatically abbreviate the number based on its magnitude.

Example:

JavaScript

// Function to convert a long number to an abbreviated string using Intl.NumberFormat
function convertToAbbreviation(number) {
    // Create a new Intl.NumberFormat object with options
    const formatter = new Intl.NumberFormat('en', {
        notation: 'compact',
        compactDisplay: 'short',
        maximumSignificantDigits: 3
    });
    
    // Format the number and return the result
    return formatter.format(number);
}

// Examples
console.log(convertToAbbreviation(1234)); // Output: 1.23k
console.log(convertToAbbreviation(1234567)); // Output: 1.23M
console.log(convertToAbbreviation(1234567890)); // Output: 1.23B
console.log(convertToAbbreviation(1234567890123)); // Output: 1.23T

Output

1.23K
1.23M
1.23B
1.23T

Approach 5: Using Recursion

This approach uses a recursive function to divide the number by 1000 and add the corresponding suffix ('K', 'M', 'B', 'T') until the number is less than 1000. This approach ensures the number is appropriately abbreviated for any magnitude.

This recursive approach is concise and elegant, handling any magnitude by breaking down the problem into smaller subproblems and solving each iteratively.

JavaScript

// Input number
let n = 1232873425;

// Display input number
console.log(n);

// Recursive function to convert number
function convert(n, suffix = '') {
    // Suffix array for thousands, millions, billions, etc.
    let suffixes = ['', 'K', 'M', 'B', 'T'];

    // Base case: if n is less than 1000, return the number with the suffix
    if (n < 1000) {
        return n.toFixed(1) + suffix;
    }

    // Recursive case: divide the number by 1000 and add the next suffix
    let index = suffix ? suffixes.indexOf(suffix) + 1 : 1;
    return convert(n / 1000, suffixes[index]);
}

// Function to display converted output
function GFG_Fun() {
    // Display output
    console.log("Number = " + convert(n));
}

// Function call
GFG_Fun();

Output

1232873425
Number = 1.2B

Approach 6: Using External Library: numeral.js

Using the numeral.js library, convert a long number into an abbreviated string by formatting it with numeral(number).format('0.0a'). This method simplifies number abbreviation, automatically handling large values like thousands (`k`), millions (`m`), and billions (`b`).

Example