numeral vs accounting vs currency.js vs format-number vs intl vs numbro
Number Formatting and Currency Handling Libraries
Search packages..
numeralaccountingcurrency.jsformat-numberintlnumbroSimilar Packages:

Number Formatting and Currency Handling Libraries

These libraries provide utilities for formatting numbers, currencies, and performing mathematical operations in JavaScript. While some focus on lightweight formatting, others offer robust currency math or localization features. Modern development often favors native APIs, but these packages remain relevant for legacy support or specific functional needs like immutable currency objects.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
numeral2,481,4979,706-3459 years agoMIT
accounting04,979-14512 years ago-
currency.js03,382-615 years agoMIT
format-number050-69 years agoBSD-3-Clause
intl01,691-7910 years agoMIT
numbro01,1421.27 MB2692 years agoMIT

Number Formatting and Currency Handling: Architecture Comparison

These libraries solve number display and math problems in JavaScript, but they take different approaches. Some focus on simple string formatting, while others handle currency math with precision. Modern browsers also provide native tools that replace many of these needs. Let's compare how they tackle common engineering tasks.

⚠️ Maintenance Status: Active vs Unmaintained

Before writing code, check if the library is still safe to use. Several options here are no longer updated.

accounting is unmaintained.

  • Last update was years ago.
  • Use only for legacy support.
// accounting: No recent updates
// npm install accounting
var accounting = require('accounting');

currency.js is actively maintained.

  • Regular updates for currency data.
  • Safe for new projects.
// currency.js: Active development
// npm install currency.js
import currency from 'currency.js';

format-number is stable but minimal.

  • Rarely changes because it is simple.
  • Low risk but low feature set.
// format-number: Stable minimalism
// npm install format-number
var formatNumber = require('format-number');

intl is a polyfill for legacy browsers.

  • Native Intl is preferred now.
  • Only use for old browser support.
// intl: Polyfill package
// npm install intl
require('intl');

numbro is actively maintained.

  • Fork of numeral with fixes.
  • Safe for long-term use.
// numbro: Active fork
// npm install numbro
import numbro from 'numbro';

numeral is unmaintained.

  • No updates since 2017.
  • Do not use in new projects.
// numeral: Unmaintained
// npm install numeral
var numeral = require('numeral');

🔢 Formatting Syntax: How to Display Numbers

Each library has a different way to turn raw numbers into readable strings.

accounting uses specific format strings for money.

  • Focuses on currency symbols and decimals.
// accounting: Money format
accounting.formatMoney(1234567.89, "$ ", 2);
// Output: "$ 1,234,567.89"

currency.js chains format methods on objects.

  • Immutable currency object handles display.
// currency.js: Chain format
currency(1234567.89).format();
// Output: "$1,234,567.89"

format-number uses a configuration object.

  • Simple key-value pairs for style.
// format-number: Config object
formatNumber(1234567.89, { round: 2, thousand: ',' });
// Output: "1,234,567.89"

intl relies on native API constructors.

  • Standard browser implementation.
// intl: Native constructor
new Intl.NumberFormat('en-US').format(1234567.89);
// Output: "1,234,567.89"

numbro uses format strings similar to Excel.

  • Flexible pattern matching.
// numbro: Format string
numbro(1234567.89).format('$0,0.00');
// Output: "$1,234,567.89"

numeral uses the same format strings as numbro.

  • Legacy syntax still widely known.
// numeral: Legacy format string
numeral(1234567.89).format('$0,0.00');
// Output: "$1,234,567.89"

💰 Currency Handling: Math and Precision

Handling money requires more than just formatting. You need to avoid floating-point errors.

accounting does not handle math.

  • It is purely for display strings.
  • You must do math separately.
// accounting: No math support
var total = 10.50 + 20.30; // Manual math
accounting.formatMoney(total);

currency.js handles math internally.

  • Uses integer cents to avoid errors.
  • Safe for addition and subtraction.
// currency.js: Built-in math
currency(10.50).add(20.30).format();
// Output: "$30.80" (Precise)

format-number does not handle math.

  • Pure formatting utility only.
  • No currency logic included.
// format-number: No math support
var total = 10.50 + 20.30; // Manual math
formatNumber(total);

intl does not handle math.

  • Focuses on localization standards.
  • Math must be done with standard JS.
// intl: No math support
var total = 10.50 + 20.30; // Manual math
new Intl.NumberFormat('en-US').format(total);

numbro supports basic math operations.

  • Can multiply, divide, and add.
  • Still uses floating-point numbers.
// numbro: Basic math
numbro(10.50).add(20.30).format();
// Output: "30.80" (Floating point)

numeral supports basic math operations.

  • Same as numbro but unmaintained.
  • Risk of floating-point issues.
// numeral: Basic math
numeral(10.50).add(20.30).format();
// Output: "30.80" (Floating point)

🌍 Localization: Supporting Multiple Languages

Global apps need to show numbers correctly for different regions.

accounting has limited locale support.

  • You must manually configure symbols.
  • Hard to scale for many countries.
// accounting: Manual locale
accounting.settings.currency.symbol = "€";
accounting.formatMoney(1000);

currency.js allows custom locale settings.

  • You pass options during creation.
  • Good for specific currency needs.
// currency.js: Custom options
currency(1000, { symbol: '€', precision: 2 }).format();

format-number has no built-in locales.

  • You configure separators manually.
  • Not suitable for i18n heavy apps.
// format-number: Manual config
formatNumber(1000, { thousand: '.', decimal: ',' });

intl excels at localization.

  • Built-in data for hundreds of locales.
  • Best choice for global apps.
// intl: Native locale support
new Intl.NumberFormat('de-DE').format(1000);
// Output: "1.000"

numbro supports many languages.

  • Load language files as needed.
  • Good balance of features and size.
// numbro: Language load
numbro.language('de-DE');
numbro(1000).format();

numeral supports many languages.

  • Same as numbro but outdated data.
  • Risk of missing new locale standards.
// numeral: Language load
numbro.language('de-DE');
numeral(1000).format();

📊 Summary: Key Differences

Featureaccountingcurrency.jsformat-numberintlnumbronumeral
Status❌ Unmaintained✅ Active⚠️ Stable✅ Native✅ Active❌ Unmaintained
Math❌ None✅ Precise❌ None❌ None⚠️ Float⚠️ Float
i18n⚠️ Manual⚠️ Custom❌ None✅ Best✅ Good✅ Good
Use CaseLegacy MoneyFintech/CartsSimple DisplayGlobal AppsFormattingLegacy Format

💡 The Big Picture

currency.js is the top choice for financial logic.

  • It prevents math errors that cause real money loss.
  • Use it for carts, invoices, and balances.

intl (Native) is the top choice for display.

  • It requires no extra packages in modern browsers.
  • Use it for general number formatting in UI.

numbro is the fallback for complex formatting.

  • Use it if you need features native Intl lacks.
  • It is safer than numeral for long-term support.

numeral and accounting should be avoided.

  • They are unmaintained and pose security risks.
  • Migrate existing projects to numbro or native APIs.

Final Thought: For most modern apps, combine native Intl for display with currency.js for money math. This mix gives you precision without unnecessary dependencies.

How to Choose: numeral vs accounting vs currency.js vs format-number vs intl vs numbro

  • numeral:

    Do not choose numeral for new projects as it is unmaintained and has known issues with localization and bundle size. It was popular historically but is now considered deprecated in favor of numbro or native APIs. Only use it if you are maintaining an existing system that cannot be refactored.

  • accounting:

    Choose accounting only for legacy projects that require simple currency formatting without heavy dependencies. It is unmaintained and lacks modern localization features, so avoid it for new development. Use it if you need a quick fix for an old codebase that already relies on its specific API.

  • currency.js:

    Choose currency.js when you need immutable currency objects that handle math operations safely without floating-point errors. It is ideal for e-commerce carts, invoicing, or financial dashboards where precision matters. It combines formatting and calculation in one lightweight package.

  • format-number:

    Choose format-number if you need a minimalistic function to format numbers with separators and decimals without extra features. It is suitable for simple displays where localization is handled elsewhere or is not required. Avoid it for complex currency logic or internationalization needs.

  • intl:

    Choose the intl npm package only if you must support very old browsers that lack native Intl support. For all modern projects, use the built-in browser Intl API instead of this polyfill package. Relying on this package in new apps adds unnecessary weight and maintenance overhead.

  • numbro:

    Choose numbro if you need the feature set of numeral but require active maintenance and bug fixes. It is a community-driven fork that supports formatting, parsing, and basic math operations. It is a safer bet than numeral for long-term projects requiring extensive number formatting.

Similar Npm Packages to numeral

numeral is a JavaScript library designed for formatting and manipulating numbers. It provides a simple and intuitive API for formatting numbers into various styles, such as currency, percentages, and more. This makes it a popular choice for developers who need to present numerical data in a user-friendly manner. While numeral is a robust solution for number formatting, there are several alternatives available that also cater to similar needs. Here are a few noteworthy options:

  • accounting is a lightweight JavaScript library for number formatting and manipulation, particularly focused on financial data. It provides functions for formatting currency, percentages, and numbers with thousands separators. If your application primarily deals with financial data and you need a straightforward way to format and manipulate numbers, accounting is a solid choice. Its simplicity and focus on financial use cases make it an appealing alternative to numeral.

  • d3-format is part of the D3.js library, which is widely used for data visualization. The d3-format module provides powerful formatting capabilities for numbers, including support for custom formats. If you're already using D3 for visualizations or need advanced formatting options, d3-format can be a great choice. It allows for extensive customization and is particularly useful when working with complex datasets that require specific formatting rules.

  • numbro is another library for formatting numbers, inspired by numeral.js. It offers a similar API and supports various formats, including currency, percentages, and more. numbro is designed to be lightweight and easy to use, making it a good alternative for developers looking for a straightforward number formatting solution. Its compatibility with numeral.js means that transitioning between the two libraries can be relatively seamless.

For a detailed comparison of these libraries, check out the following link: Comparing accounting vs d3-format vs numbro vs numeral.

Similar Npm Packages to accounting

accounting is a JavaScript library designed for number formatting and currency manipulation. It provides a simple and intuitive API for formatting numbers, currencies, and percentages, making it a popular choice for developers who need to handle financial data in their applications. While accounting.js is a robust solution for number formatting, there are several alternatives available that also cater to similar needs. Here are a few noteworthy options:

  • currency.js is a lightweight library specifically focused on currency manipulation. It allows developers to perform arithmetic operations on currency values while ensuring precision and accuracy. With features like formatting, conversion, and rounding, currency.js is particularly useful for applications that require extensive currency calculations. If your project primarily deals with currency and you need a library that emphasizes accuracy and simplicity, currency.js is an excellent choice.

  • dinero.js is another powerful library for handling money and currency in JavaScript. It provides a rich set of features for creating, manipulating, and formatting monetary values. With support for multiple currencies, rounding, and currency conversion, dinero.js is ideal for applications that require complex financial calculations. Its immutable design ensures that all operations return new instances, which can help prevent unintended side effects in your code. If your application demands a comprehensive solution for managing money, dinero.js is worth considering.

  • numeral is a library focused on number formatting, providing a flexible and powerful way to format numbers in various ways, including currency, percentages, and custom formats. While it does not have the same level of currency-specific features as currency.js or dinero.js, it is an excellent choice for applications that require versatile number formatting capabilities. If your primary need is to format numbers in different ways without the complexities of currency manipulation, numeral can be a great fit.

For a detailed comparison of these libraries, check out the following link: Comparing accounting vs currency.js vs dinero.js vs numeral.

Similar Npm Packages to currency.js

currency.js is a lightweight JavaScript library designed for handling currency calculations and formatting. It provides a simple and intuitive API for performing arithmetic operations on currency values while ensuring precision and accuracy. This makes it an excellent choice for developers working on financial applications, e-commerce platforms, or any project that requires handling monetary values. While currency.js is a robust solution for currency management, there are several alternatives available in the ecosystem. Here are a few notable ones:

  • currency-formatter is a library focused on formatting currency values for display. It allows developers to easily format numbers as currency strings based on locale and currency type. While it does not handle arithmetic operations like currency.js, it excels in providing a straightforward way to display currency values in a user-friendly format. If your primary need is to format currency for presentation rather than perform calculations, currency-formatter is a suitable choice.

  • dinero.js is a powerful library for creating and manipulating monetary values. It provides a comprehensive API for performing arithmetic operations, formatting, and handling currency conversions. Dinero.js is particularly useful for applications that require complex financial calculations, as it ensures precision and supports multiple currencies. If your project involves advanced currency management, such as handling discounts, taxes, or multi-currency transactions, dinero.js is a strong contender.

  • numeral is a library for formatting and manipulating numbers, including currency values. It provides a flexible way to format numbers as currency, percentages, and more. While it is not specifically designed for currency management like currency.js or dinero.js, it offers a versatile solution for general number formatting needs. If your application requires a broader range of number formatting capabilities beyond just currency, numeral is a good option.

To explore how these libraries compare, check out the comparison: Comparing currency-formatter vs currency.js vs dinero.js vs numeral.

Similar Npm Packages to format-number

format-number is a lightweight JavaScript library designed to format numbers in a variety of ways. It provides an easy-to-use API for formatting numbers as currency, percentages, or general numeric values, making it a valuable tool for developers who need to present numerical data in a user-friendly manner. While format-number is a solid choice for number formatting, there are several alternatives in the JavaScript ecosystem that offer similar functionalities. Here are a few noteworthy options:

  • accounting is a comprehensive library for number formatting and currency manipulation. It provides a wide range of features, including formatting numbers, currencies, and percentages, as well as performing basic arithmetic operations. accounting is particularly useful for applications that require extensive financial calculations and formatting, making it a popular choice among developers working with financial data.

  • currency.js is a library specifically designed for handling currency values in JavaScript. It provides a simple API for creating, manipulating, and formatting currency values, ensuring that developers can easily work with monetary amounts without worrying about precision issues. currency.js is an excellent choice for applications that require accurate currency calculations and formatting, such as e-commerce platforms or financial applications.

  • numeral is a library that focuses on formatting and manipulating numbers in a variety of ways. It supports a wide range of formatting options, including currency, percentages, and custom formats. numeral is particularly useful for applications that need to display numbers in a specific format, making it a versatile choice for developers looking to enhance the presentation of numerical data.

To see how format-number compares with accounting, currency.js, and numeral, check out the comparison: Comparing accounting vs currency.js vs format-number vs numeral.

Similar Npm Packages to intl

intl is a JavaScript library that provides internationalization (i18n) support for applications. It enables developers to format dates, numbers, and currencies according to the user's locale, making it easier to create applications that cater to a global audience. While intl offers robust internationalization features, there are several alternatives in the ecosystem that also provide similar capabilities. Here are a few notable options:

  • date-fns is a modern JavaScript date utility library that provides a comprehensive set of functions for manipulating and formatting dates. Unlike intl, which focuses on internationalization, date-fns offers a modular approach to date manipulation, allowing developers to import only the functions they need. This results in a smaller bundle size and better performance. If your application requires extensive date manipulation without the overhead of a full internationalization library, date-fns is an excellent choice.
  • luxon is a powerful library for working with dates and times in JavaScript. It was created by one of the Moment.js maintainers and is designed to handle time zones, durations, and intervals with ease. luxon provides a rich API for formatting and parsing dates, making it a great alternative to intl for applications that require advanced date and time handling. If you need to manage time zones or perform complex date calculations, luxon is a highly recommended option.
  • react-intl is a library specifically designed for React applications that need internationalization support. It builds on the intl API and provides components and hooks to manage translations, formatting, and locale-specific data directly within React components. If you are building a React application and need to implement internationalization, react-intl offers a seamless integration with the React ecosystem, making it easier to manage translations and formatting.

To see how these libraries compare, check out the comparison: Comparing date-fns vs intl vs luxon vs react-intl.

Similar Npm Packages to numbro

numbro is a JavaScript library that provides a simple way to format and manipulate numbers. It is particularly useful for formatting currency, percentages, and other numerical values in a user-friendly manner. With its lightweight design and straightforward API, numbro makes it easy to present numbers in a readable format, which is essential for web applications that require clear data representation. While numbro is a great choice for number formatting, there are several alternatives that offer similar functionalities. Here are a few:

  • accounting is a lightweight JavaScript library for number, money, and currency formatting. It provides a simple API for formatting numbers and currencies, making it easy to handle financial data in web applications. Accounting.js is particularly useful for applications that require precise formatting and calculations, such as e-commerce platforms or financial dashboards. Its focus on simplicity and performance makes it a popular choice among developers.
  • currency.js is a library specifically designed for currency formatting and arithmetic. It allows developers to perform mathematical operations on currency values while ensuring that the formatting remains consistent. Currency.js is ideal for applications that need to handle complex currency calculations, such as invoicing systems or financial applications. Its robust features and easy-to-use API make it a strong alternative to numbro for currency-related tasks.
  • format-number is a simple library for formatting numbers in JavaScript. It provides a straightforward way to format numbers with customizable options, such as decimal places and thousands separators. If you need a lightweight solution for basic number formatting without the additional features of currency or accounting libraries, format-number is a good choice.
  • intl is a built-in JavaScript object that provides internationalization support, including number formatting. It allows developers to format numbers according to locale-specific conventions, making it a powerful tool for applications that need to cater to a global audience. While it may not be as specialized as numbro or other libraries, its native support in JavaScript makes it a viable option for number formatting.
  • numeral is a library for formatting and manipulating numbers in JavaScript. It provides a wide range of formatting options, including currency, percentages, and custom formats. Numeral.js is particularly useful for applications that require complex number formatting and manipulation, making it a strong alternative to numbro for developers looking for flexibility and power in their number handling.

To see how these libraries compare, check out the comparison: Comparing accounting vs currency.js vs format-number vs intl vs numbro vs numeral.

README for numeral

Numeral.js

A javascript library for formatting and manipulating numbers.

Website and documentation

Travis Build Status

Master Build Status

Develop Build Status

NPM

NPM

#CDNJS

CDNJS

Contributing

Important: Please create your branch from and submit pull requests to the develop branch. All pull requests must include the appropriate tests.

  1. Fork the library

  2. Install grunt

  3. Run npm install to install dependencies

  4. Create a new branch from develop

  5. Add your tests to the files in /tests

  6. To test your tests, run grunt

  7. When all your tests are passing, run grunt dist to compile and minify all files

  8. Submit a pull request to the develop branch.

Formats

Formats now exist in their own files and act more or less as plugins. Check out the bytes format for an example of how to create one.

Locales

When naming locale files use the ISO 639-1 language codes supplemented by ISO 3166-1 country codes when necessary.

Locale translations will not be merged without unit tests.

See the english unit tests for an example.

Changelog

2.0.6

Bug fix: Multi letter currency symbols and spacing

Added: Formatting of numbers with leading zeros

New format: Basic Point

Option: Added scalePercentBy100 (default: true) option to turn on/off scaling percentages

2.0.4

Bug fix: Incorrect abbreviations for values rounded up #187

Bug fix: Signed currency is inconsistent #89

2.0.2

Bug fix: Updated module definitions

2.0.1

Bug fix: Fixed regression for webpack/browserify/rollup

2.0.0

2.0.0 brings a lot of breaking changes and a reorganization of the repo, but also simplifies the api as well as the creating of custom formats.

Breaking change / Feature: All formats are now separate files. This makes it easy to create custom formats, and will also allow for custom builds with only certain formats. (Note: The built numeral.js still contains all formats in the repo).

Breaking change / Feature: All formats and locales are now loaded using numeral.register(type, name, {})

Breaking change: All language now renamed to locale and standardized to all lowercase filenames

Breaking change: The locale function no longer loads locales, it only sets the current locale

Breaking change: The unformat function has been removed numeral().unformat(string) and now happens on numeral init numeral(string)

Breaking change / Feature: Bytes are now formatted as: b (base 1000) and ib (base 1024)

Breaking change: numeral(NaN) is now treated the same as numeral(null) and no longer throws an error

Feature: Exponential format using e+ or e-

Bug fix: Update to floating point helpers (Note: Numeral does not fix JS floating point errors, but look to our tests to see that it covers quite a few cases.)

1.5.6

Bug fix: numeral converts strings to numbers

Bug fix: Null values return same as 0

1.5.5

Contained breaking changes, recommended to use 1.5.6

Bug fix: Switch bytes back to b and change iecBinary to ib, and calculate both using 1024 for backwards compatibility

1.5.4

Contained breaking changes, recommended to use 1.5.6

Tests: Changed all tests to use Mocha and Chai

Tests: Added browser tests for Chrome, Firefox, and IE using saucelabs

Added reset function to reset numeral to default options

Added nullFormat option

Update reduce polyfill

Added Binary bytes

Bug fix: Fixes problem with many optional decimals

1.5.3

Added currency symbol to optionally appear before negative sign / open paren

Added float precision math support

Added specification of abbreviation in thousands, millions, billions

1.5.2

Bug fix: Unformat should pass through if given a number

Added a mechanism to control rounding behaviour

Added languageData() for getting and setting language props at runtime

1.5.1

Bug fix: Make sure values aren't changed during formatting

1.5.0

Add defaultFormat(). numeral().format() uses the default to format if no string is provided

.unformat() returns 0 when passed no string

Added languages.js that contains all languages

Bug fix: Fix bug while unformatting ordinals

Add format option to always show signed value

Added ability to instantiate numeral with a string value of a number

1.4.9

Bug fix: Fix bug while unformatting ordinals

1.4.8

Bug fix: Throw error if language is not defined

1.4.7

Bug fix: Fix typo for trillion

1.4.6

Bug fix: remove ' from unformatting regex that was causing an error with fr-ch.js

1.4.5

Add zeroFormat() function that accepts a string for custom formating of zeros

Add valueOf() function

Chain functionality to language function

Make all minified files have the same .min.js filename ending

1.4.1

Bug fix: Bytes not formatting correctly

1.4.0

Add optional format for all decimals

1.3.4

Remove AMD module id. (This is encouraged by require.js to make the module more portable, and keep it from creating a global)

1.3.3

AMD define() compatibility.

1.3.2

Bug fix: Formatting some numbers results in the wrong value. Issue #21

1.3.1

Bug fix: Minor fix to unformatting parser

1.3.0

Add support for spaces before/after $, a, o, b in a format string

Bug fix: Fix unformat for languages that use '.' in ordinals

Bug fix: Fix round up floating numbers with no precision correctly.

Bug fix: Fix currency signs at the end in unformat

1.2.6

Add support for optional decimal places

1.2.5

Add support for appending currency symbol

1.2.4

Add support for humanized filesizes

1.2.3

Bug Fix: Fix unformatting for languages that use '.' as thousands delimiter

1.2.2

Changed language definition property 'money' to 'currency'

1.2.1

Bug fix: Fix unformatting non-negative abbreviations

1.2.0

Add language support

Update testing for to include languages

1.1.0

Add Tests

Bug fix: Fix difference returning negative values

1.0.4

Bug fix: Non negative numbers were displaying as negative when using parentheses

1.0.3

Add ordinal formatting using 'o' in the format

1.0.2

Add clone functionality

1.0.1

Added abbreviations for thousands and millions using 'a' in the format

1.0.0

Initial release

Acknowlegements

Numeral.js, while less complex, was inspired by and heavily borrowed from Moment.js

License

Numeral.js is freely distributable under the terms of the MIT license.

Copyright (c) 2012 Adam Draper

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.