currency-formatter vs currency.js vs dinero.js vs numeral
JavaScript Currency Formatting Libraries
Search packages..
currency-formattercurrency.jsdinero.jsnumeralSimilar Packages:

JavaScript Currency Formatting Libraries

These libraries are designed to handle currency formatting and manipulation in JavaScript applications. They provide developers with tools to format numbers as currency, perform arithmetic operations on currency values, and ensure proper localization based on different currencies and locales. Each library has its unique features and use cases, making them suitable for various scenarios in web development.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
currency-formatter0213-154 years agoMIT
currency.js03,365-585 years agoMIT
dinero.js06,718858 kB413 days agoMIT
numeral09,724-3499 years agoMIT

Feature Comparison: currency-formatter vs currency.js vs dinero.js vs numeral

Currency Formatting

  • currency-formatter:

    currency-formatter provides simple methods to format numbers as currency strings based on locale and currency type. It supports various currencies and allows customization of decimal and thousand separators, making it easy to display currency values correctly.

  • currency.js:

    currency.js allows you to format currency values easily, but its primary focus is on arithmetic operations. It provides methods to format numbers as currency strings, ensuring that the output adheres to the specified currency format.

  • dinero.js:

    dinero.js offers comprehensive currency formatting capabilities, allowing you to format money objects into strings with specific currency symbols and formats. It supports localization and can handle various currencies seamlessly, making it ideal for international applications.

  • numeral:

    numeral provides a flexible formatting system that can format numbers as currency, percentages, and more. It allows for extensive customization of the output format, making it suitable for applications that require diverse number formatting.

Arithmetic Operations

  • currency-formatter:

    currency-formatter does not support arithmetic operations; it is strictly for formatting purposes. If calculations are needed, additional logic must be implemented separately.

  • currency.js:

    currency.js excels in performing accurate arithmetic operations on currency values. It ensures that calculations maintain precision, making it suitable for applications that require financial computations without rounding errors.

  • dinero.js:

    dinero.js is designed for complex arithmetic operations, allowing you to perform addition, subtraction, multiplication, and division on money objects. It maintains immutability, ensuring that operations do not alter the original value, which is crucial for financial applications.

  • numeral:

    numeral does not focus on arithmetic operations but can format numbers after calculations are performed. For arithmetic operations, you would need to use standard JavaScript methods or combine it with other libraries.

Localization Support

  • currency-formatter:

    currency-formatter supports multiple locales, allowing developers to format currency according to regional standards. This feature is essential for applications targeting international users, ensuring that currency displays are appropriate for different cultures.

  • currency.js:

    currency.js has limited localization support primarily focused on formatting. It does not provide extensive locale management, so developers may need to handle localization separately if required.

  • dinero.js:

    dinero.js supports localization by allowing you to specify currency codes and formats. It is well-suited for applications that need to handle multiple currencies and ensure that values are displayed correctly based on user preferences.

  • numeral:

    numeral provides some localization features, but its primary focus is on number formatting rather than currency-specific localization. Developers may need to implement additional logic for comprehensive localization.

Immutability

  • currency-formatter:

    currency-formatter does not deal with mutability as it is primarily a formatting library. It does not create or manage state, so immutability is not a concern.

  • currency.js:

    currency.js does not enforce immutability, which means that operations can change the state of currency objects. This can lead to potential issues if not managed carefully, especially in complex applications.

  • dinero.js:

    dinero.js emphasizes immutability, meaning that every operation returns a new instance of the money object rather than modifying the original. This feature helps prevent unintended side effects and makes it easier to manage state in applications.

  • numeral:

    numeral does not focus on immutability. It is primarily a formatting library, and while it can handle numbers, it does not enforce immutability in its operations.

Complexity and Learning Curve

  • currency-formatter:

    currency-formatter is straightforward and easy to use, making it suitable for developers who need quick currency formatting without a steep learning curve. Its API is simple and intuitive, allowing for rapid integration.

  • currency.js:

    currency.js has a moderate learning curve due to its focus on arithmetic operations. Developers need to understand how to use its methods effectively to manage currency calculations, but it is still relatively easy to pick up for those familiar with JavaScript.

  • dinero.js:

    dinero.js may have a steeper learning curve due to its comprehensive feature set and focus on immutability. Developers may need to invest time in understanding its API and concepts, but it provides powerful tools for managing money effectively.

  • numeral:

    numeral is easy to learn and use, especially for those familiar with number formatting in JavaScript. Its flexible API allows for quick implementation, making it accessible for developers of all skill levels.

How to Choose: currency-formatter vs currency.js vs dinero.js vs numeral

  • currency-formatter:

    Choose currency-formatter if you need a lightweight solution specifically for formatting currency values with options for different locales and currency symbols. It is ideal for simple applications where you only need to display currency without complex calculations.

  • currency.js:

    Opt for currency.js if you require a library that allows for precise arithmetic operations on currency values. It is particularly useful for applications that need to perform calculations while maintaining accuracy, such as e-commerce platforms or financial applications.

  • dinero.js:

    Select dinero.js if you need a robust library for handling money and currency calculations with a focus on immutability and chainable methods. It is suitable for applications that require complex financial computations and want to avoid issues related to floating-point arithmetic.

  • numeral:

    Use numeral if you need a versatile library for formatting numbers in various ways, including currency. It is great for applications that require extensive number formatting options beyond just currency, such as percentages and custom formats.

Similar Npm Packages to currency-formatter

currency-formatter is a lightweight JavaScript library designed to format currency values in a user-friendly manner. It allows developers to easily convert numbers into formatted currency strings, taking into account different currencies, locales, and formatting options. This package is particularly useful for applications that require displaying monetary values, such as e-commerce platforms or financial dashboards. While currency-formatter is a solid choice for currency formatting, there are several alternatives available that offer similar functionality. Here are a few noteworthy options:

  • accounting-js is a library that provides a set of utilities for formatting numbers, currencies, and percentages. It is highly customizable and allows developers to define their own formatting rules. accounting-js is particularly useful for applications that require more than just currency formatting, as it also supports number formatting and basic arithmetic operations. If you need a versatile library that can handle various types of number formatting, accounting-js is a great option.

  • 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 precision and accuracy in calculations. currency.js is particularly useful for applications that require strict handling of monetary values, as it avoids floating-point errors commonly encountered in JavaScript. If your application demands high precision in currency calculations, currency.js is an excellent choice.

  • intl is a built-in JavaScript object that provides internationalization support, including number and currency formatting. It leverages the Intl.NumberFormat API to format numbers and currencies according to the user's locale. While intl is not a standalone library, it is a powerful option for applications that need to support multiple languages and regions. If you are looking for a native solution that adheres to internationalization standards, using intl is a great way to go.

  • numeral is a library for formatting and manipulating numbers in JavaScript. It provides a simple API for formatting numbers, currencies, and percentages, making it easy to display numerical values in a user-friendly way. numeral is particularly useful for applications that require flexible number formatting options. If you need a straightforward library for number formatting without the additional complexity of currency-specific features, numeral is a solid choice.

To see how these packages compare, check out the comparison: Comparing accounting-js vs currency-formatter vs currency.js vs intl 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 dinero.js

dinero.js is a powerful JavaScript library designed for handling monetary values and currency calculations in a precise and reliable manner. It provides a robust API for creating, manipulating, and formatting currency values, making it an excellent choice for applications that require accurate financial computations. With features like currency conversion, rounding, and formatting, dinero.js helps developers avoid common pitfalls associated with floating-point arithmetic, ensuring that financial calculations are both accurate and easy to manage.

While dinero.js is a strong contender for handling monetary values, there are alternatives worth considering:

  • currency.js is a lightweight library that provides a simple API for currency manipulation and formatting. It focuses on basic arithmetic operations and supports various currency formats, making it easy to use for straightforward financial calculations. If your application requires basic currency handling without the need for advanced features like currency conversion or complex formatting, currency.js is a great option. Its simplicity and ease of use make it suitable for smaller projects or applications with less demanding financial requirements.

To see how dinero.js compares with currency.js, check out the comparison: Comparing currency.js vs dinero.js.

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.

README for currency-formatter

Currency Formatter

Build Status

A simple Javascript utility that helps you to display currency properly

STOP! You probably don't need this library

TL;DR: This library was created a long time ago. You should use Internationalization API instead.

Please don't add another dependency which you don't need. All modern browsers (and node.js) have this functionality built-in and do a much better job at formatting currencies. e.g. #57

Example:

new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' }).format(100000000)
// => "$100,000,000.00"

new Intl.NumberFormat('en-US', { style: 'currency', currency: 'EUR' }).format(100000000)
// => "€100,000,000.00"

new Intl.NumberFormat('de-DE', { style: 'currency', currency: 'USD' }).format(100000000)
// => "100.000.000,00 $"

new Intl.NumberFormat('de-DE', { style: 'currency', currency: 'EUR' }).format(100000000)
// => "100.000.000,00 €"

new Intl.NumberFormat('fr-FR', { style: 'currency', currency: 'EUR' }).format(100000000)
// => "100 000 000,00 €"

With that being said use this library if you need:

  • Your version of node.js doesn't come with the full-icu. See: #72 and #19214
  • Support old browsers.
  • Consistent formatting across all browsers.
  • You don't like the Intl APIs
  • ???

Install

npm install currency-formatter --save

Basic Usage

By specifying the currency code

var currencyFormatter = require('currency-formatter');

currencyFormatter.format(1000000, { code: 'USD' });
// => '$1,000,000.00'

currencyFormatter.format(1000000, { code: 'GBP' });
// => '£1,000,000.00'

currencyFormatter.format(1000000, { code: 'EUR' });
// => '1 000 000,00 €'

Or by specifying the locale

var currencyFormatter = require('currency-formatter');

currencyFormatter.format(1000000, { locale: 'en-US' });
// => '$1,000,000.00'

currencyFormatter.format(1000000, { locale: 'en-GB' });
// => '£1,000,000.00'

currencyFormatter.format(1000000, { locale: 'GB' });
// => '£1,000,000.00'

currencyFormatter.format(1000000, { locale: 'de-DE' });
// => '1.000.000,00 €'

currencyFormatter.format(1000000, { locale: 'nl-NL' });
// => '€1.000.000,00'

You can also get the currency information.

var currencyFormatter = require('currency-formatter');

currencyFormatter.findCurrency('USD');
// returns:
// {
//   code: 'USD',
//   symbol: '$',
//   thousandsSeparator: ',',
//   decimalSeparator: '.',
//   symbolOnLeft: true,
//   spaceBetweenAmountAndSymbol: false,
//   decimalDigits: 2
// }

Parse the number of a monetary value


currencyFormatter.unformat('$10.5', { code: 'USD' })
// => 10.5

currencyFormatter.unformat('$1,000,000', { code: 'USD' })
// => 1000000

currencyFormatter.unformat('10,5 €', { code: 'EUR' })
// => 10.5

currencyFormatter.unformat('1 000 000,00 €', { code: 'EUR' })
// => 1000000

currencyFormatter.unformat('1.000,99', { locale: 'de-DE' })
// => 1000.99

currencyFormatter.unformat('10\'000 CHF', { code: 'CHF' })
// => 10000

currencyFormatter.unformat('10.00 CHF', { code: 'CHF' })
// => 10

currencyFormatter.unformat('10,00 CHF', { code: 'CHF' })
// => 1000

Advanced Usage

Currency Formatter uses accounting library under the hood, and you can use its options to override the default behavior.

var currencyFormatter = require('currency-formatter');
currencyFormatter.format(1000000, {
  symbol: '@',
  decimal: '*',
  thousand: '^',
  precision: 1,
  format: '%v %s' // %s is the symbol and %v is the value
});

// => '1^000^000*0 @'

// Different formatting for positive and negative values
currencyFormatter.format(-10, {
  format: {
    pos: '%s%v' // %s is the symbol and %v is the value
    neg: '(%s%v)',
    zero: '%s%v'
  }
});

// => ($10)

You could also get a list of all the currencies here using one of the following:

var currencies = require('currency-formatter/currencies');
// OR
var currencyFormatter = require('currency-formatter');
var currencies = currencyFormatter.currencies;

Or the currencies in hashmap shape:

var currencies = require('currency-formatter/currencies.json');
// Result:
// {
//  "USD": {
//    "code": "USD",
//    "symbol": "$",
//    "thousandsSeparator": ",",
//    "decimalSeparator": ".",
//    "symbolOnLeft": true,
//    "spaceBetweenAmountAndSymbol": false,
//    "decimalDigits": 2
//  },
//  ...more currencies
// }

License

MIT

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. Please share your feedback via our GitHub repository. For more details, please refer to our Terms & Privacy.