A JavaScript library for internationalization and localization that leverage the official Unicode CLDR JSON data.
Globalize is a JavaScript library for internationalization and localization. It provides tools for formatting and parsing dates, numbers, and currencies, as well as for handling pluralization and message translation.
Date Formatting
This feature allows you to format dates according to different locales. The code sample demonstrates how to format a date in the 'en' locale.
const Globalize = require('globalize');
Globalize.load(require('cldr-data').entireSupplemental());
Globalize.load(require('cldr-data').entireMainFor('en', 'es'));
Globalize.locale('en');
const formattedDate = Globalize.formatDate(new Date(), { datetime: 'medium' });
console.log(formattedDate);Number Formatting
This feature allows you to format numbers according to different locales. The code sample demonstrates how to format a number in the 'en' locale.
const Globalize = require('globalize');
Globalize.load(require('cldr-data').entireSupplemental());
Globalize.load(require('cldr-data').entireMainFor('en', 'es'));
Globalize.locale('en');
const formattedNumber = Globalize.formatNumber(12345.6789);
console.log(formattedNumber);Currency Formatting
This feature allows you to format currencies according to different locales. The code sample demonstrates how to format a currency in the 'en' locale.
const Globalize = require('globalize');
Globalize.load(require('cldr-data').entireSupplemental());
Globalize.load(require('cldr-data').entireMainFor('en', 'es'));
Globalize.locale('en');
const formattedCurrency = Globalize.formatCurrency(12345.6789, 'USD');
console.log(formattedCurrency);Message Translation
This feature allows you to translate messages according to different locales. The code sample demonstrates how to translate a message in the 'en' locale.
const Globalize = require('globalize');
Globalize.loadMessages({
en: { hello: 'Hello, {name}!' },
es: { hello: '¡Hola, {name}!' }
});
Globalize.locale('en');
const message = Globalize.messageFormatter('hello')({ name: 'John' });
console.log(message);Pluralization
This feature allows you to handle pluralization according to different locales. The code sample demonstrates how to handle pluralization in the 'en' locale.
const Globalize = require('globalize');
Globalize.load(require('cldr-data').entireSupplemental());
Globalize.load(require('cldr-data').entireMainFor('en', 'es'));
Globalize.locale('en');
const pluralize = Globalize.pluralGenerator();
console.log(pluralize(0)); // 'other'
console.log(pluralize(1)); // 'one'
console.log(pluralize(2)); // 'other'i18next is a popular internationalization framework for JavaScript. It provides similar functionalities to Globalize, such as translation, pluralization, and formatting. However, i18next is more focused on providing a comprehensive solution for managing translations and is often used in conjunction with React and other frameworks.
Moment.js is a widely-used library for parsing, validating, manipulating, and formatting dates. While it does not provide as comprehensive internationalization support as Globalize, it is highly effective for date and time manipulation and formatting.
Luxon is a modern JavaScript library for working with dates and times. It is a successor to Moment.js and provides better support for internationalization, including time zone handling and locale-aware formatting.
The Intl object is a built-in object in JavaScript that provides language-sensitive string comparison, number formatting, and date and time formatting. It is part of the ECMAScript Internationalization API and offers similar functionalities to Globalize, but it is built into the JavaScript language itself.
A JavaScript library for internationalization and localization that leverage the official Unicode CLDR JSON data. The library works both for the browser and as a Node.js module.
We're working on the migration to using the Unicode CLDR. This is an alpha version of Globalize. In other words, this is not a software for production environment (yet).
Patches to the previous 0.x codebase probably can't be used. If you have a problem, please create an issue first before trying to patch it.
Are you looking for 0.x docs? Find them here.
Each language, and the countries that speak that language, have different expectations when it comes to how numbers (including currency and percentages) and dates should appear. Obviously, each language has different names for the days of the week and the months of the year. But they also have different expectations for the structure of dates, such as what order the day, month and year are in. In number formatting, not only does the character used to delineate number groupings and the decimal portion differ, but the placement of those characters differ as well.
A user using an application should be able to read and write dates and numbers in the format they are accustomed to. This library makes this possible, providing an API to convert user-entered number and date strings - in their own format - into actual numbers and dates, and conversely, to format numbers and dates into that string format.
It's designed to work both in the browser, or in Node.js. It supports both AMD and CommonJS.
Globalize uses the Unicode CLDR, the largest and most extensive standard repository of locale data.
We do NOT embed any i18n data within our library. However, we make it really easy to use. Read How to get and load CLDR JSON data for more information on its usage.
| File | Minified + gzipped size | Summary |
|---|---|---|
| globalize.js | 1.3KB | Core library |
| globalize/currency.js | +2.6KB | Currency module provides currency formatting and parsing |
| globalize/date.js | +4.9KB | Date module provides date formatting and parsing |
| globalize/message.js | +5.6KB | Message module provides ICU message format support |
| globalize/number.js | +2.9KB | Number module provides number formatting and parsing |
| globalize/plural.js | +1.7KB | Plural module provides pluralization support |
Globalize 1.x supports the following browsers:
(Current - 1) or Current denotes that we support the current stable version of the browser and the version that preceded it. For example, if the current version of a browser is 24.x, we support the 24.x and 23.x versions.
IE 8 is supported, but it depends on the polyfill of the ES5 methods below, for which we suggest using es5-shim. Alternatives or more information can be found at Modernizr's polyfills list.
You need to satisfy Globalize dependencies prior to using it. The good news is, there is only one. It's the cldr.js, which is a CLDR low level manipulation tool.
If you use a package manager like bower or npm, you don't need to worry about it. If this isn't the case, then you need to manually download cldr.js yourself. Check the Hello World examples for more information.
Globalize is the i18n software (the engine). Unicode CLDR is the i18n content (the fuel). You need to feed Globalize on the appropriate portions of CLDR prior to using it.
(a) How do I figure out which CLDR portions are appropriate for my needs?
Each Globalize function requires a special set of CLDR portions. Once you know which Globalize functionalities you need, you can deduce its respective CLDR requirements. See table below.
| Module | Required CLDR JSON files |
|---|---|
| Core module | cldr/supplemental/likelySubtags.json |
| Currency module | cldr/main/locale/currencies.jsoncldr/supplemental/currencyData.json +CLDR JSON files from number module |
| Date module | cldr/main/locale/ca-gregorian.jsoncldr/main/ locale/timeZoneNames.jsoncldr/supplemental/timeData.json cldr/supplemental/weekData.json +CLDR JSON files from number module |
| Number module | cldr/main/locale/numbers.jsoncldr/supplemental/numberingSystems.json |
| Plural module | cldr/supplemental/plurals.json |
(b) How am I supposed to get and load CLDR content?
Learn how to get and load CLDR content....
By downloading a ZIP or a TAR.GZ...
Click the github releases tab and download the latest available Globalize package.
By using a package manager...
Use bower bower install globalize, or npm npm install globalize.
By using source files...
git clone https://github.com/jquery/globalize.git.Globalize's consumable-files are located in the ./dist directory. If you
don't find it, it's because you are using a development branch. You should
either use a tagged version or build the distribution files yourself.
Read installation above if you need more information on how to
download.
Globalize can be used for a variety of different i18n tasks, eg. formatting or
parsing dates, formatting or parsing numbers, formatting messages, etc. You may
NOT need Globalize in its entirety. For that reason, we made it modular. So, you
can cherry-pick the pieces you need, eg. load dist/globalize.js to get
Globalize core, load dist/globalize/date.js to extend Globalize with Date
functionalities, etc.
An example is worth a thousand words. Check out our Hello World demo (available to you in different flavors):
Globalize.load( cldrJSONData, ... )This method allows you to load CLDR JSON locale data. Globalize.load() is a
proxy to Cldr.load().
Globalize.locale( [locale|cldr] )Set default locale, or get it if locale argument is omitted.
[new] Globalize( locale|cldr )Create a Globalize instance.
.dateFormatter( pattern )
Return a function that formats a date according to the given pattern.
.dateParser( pattern )
Return a function that parses a string date according to the given pattern.
.formatDate( value, pattern )
Format a date value according to the given pattern.
.parseDate( value, pattern )
Parse a string representing a date into a JavaScript Date object according to the given pattern.
Globalize.loadMessages( json )Load messages data.
.messageFormatter( path ) ➡ function([ variables ])Return a function that formats a message (using ICU message format pattern) given its path and a set of variables into a user-readable string. It supports pluralization and gender inflections.
.formatMessage( path [, variables ] )Alias to .messageFormatter( path )([ variables ]).
.numberFormatter( [options] )
Return a function that formats a number according to the given options or locale's defaults.
.numberParser( [options] )
Return a function that parses a string representing a number according to the given options or locale's defaults.
.formatNumber( value [, options] )
Format a number according to the given options or locale's defaults.
.parseNumber( value [, options] )
Parse a string representing a number according to the given options or locale's defaults. If value is invalid, NaN is returned.
.currencyFormatter( currency [, options] )
Return a function that formats a currency according to the given options or locale's defaults.
.formatCurrency( value, currency [, options] )
Format a currency according to the given options or locale's defaults.
.pluralGenerator()Return a function that returns the value's corresponding plural group: zero, one, two, few,
many, or other.
.plural( value )Return the value's corresponding plural group: zero, one, two, few, many, or other.
E_INVALID_CLDRThrown when a CLDR item has an invalid or unexpected value.
E_MISSING_CLDRThrown when any required CLDR item is NOT found.
E_INVALID_PAR_TYPEThrown when a parameter has an invalid type on any static or instance methods.
E_INVALID_PAR_VALUEThrown for certain parameters when the type is correct, but the value is invalid.
E_MISSING_PARAMETERThrown when a required parameter is missing on any static or instance methods.
E_PAR_OUT_OF_RANGEThrown when a parameter is not within a valid range of values.
E_DEFAULT_LOCALE_NOT_DEFINEDThrown when any static method, eg. Globalize.formatNumber() is used prior to
setting the Global locale with Globalize.locale( <locale> ).
Read more...
E_MISSING_PLURAL_MODULEThrown when plural module is needed, but not loaded, eg. to format currencies using the named form. Read more...
E_UNSUPPORTEDThrown for unsupported features, eg. to format unsupported date patterns. Read more...
├── bower.json (metadata file)
├── CONTRIBUTING.md (doc file)
├── dist/ (consumable files, the built files)
├── external/ (external dependencies, eg. cldr.js, QUnit, RequireJS)
├── Gruntfile.js (Grunt tasks)
├── LICENSE.txt (license file)
├── package.json (metadata file)
├── README.md (doc file)
├── src/ (source code)
│ ├── build/ (build helpers, eg. intro, and outro)
│ ├── common/ (common function helpers across modules)
│ ├── core.js (core module)
│ ├── date/ (date source code)
│ ├── date.js (date module)
│ ├── message.js (message module)
│ ├── number.js (number module)
│ ├── number/ (number source code)
│ ├── plural.js (plural module)
│ ├── plural/ (plural source code)
│ └── util/ (basic JavaScript helpers polyfills, eg array.map)
└── test/ (unit and functional test files)
├── fixtures/ (CLDR fixture data)
├── functional/ (functional tests)
├── functional.html
├── functional.js
├── unit/ (unit tests)
├── unit.html
└── unit.js
The source files are as granular as possible. When combined to generate the build file, all the excessive/overhead wrappers are cut off. It's following the same build model of jQuery and Modernizr.
Core, and all modules' public APIs are located in the src/ directory, ie.
core.js, date.js, message.js, number.js, and plural.js.
Install Grunt and external dependencies. First, install the
grunt-cli and
bower packages if you haven't before. These should be
installed globally (like this: npm install -g grunt-cli bower). Then:
npm install && bower install
Tests can be run either in the browser or using Node.js (via Grunt) after having installed the external development dependencies (for more details, see above).
Unit tests
To run the unit tests, run grunt test:unit, or run grunt connect:keepalive
and open http://localhost:9001/test/unit.html in a browser (or
http://localhost:9001/test/unit-es5-shim.html for IE8). It tests the very
specific functionality of each function (sometimes internal/private).
The goal of the unit tests is to make it easy to spot bugs, easy to debug.
Functional tests
To run the functional tests, create the dist files by running grunt. Then, run
grunt test:functional, or open http://localhost:9001/test/functional.html in
a browser (or http://localhost:9001/test/functional-es5-shim.html for IE8).
Note that grunt will automatically run unit and functional tests for you to
ensure the built files are safe.
The goal of the functional tests is to ensure that everything works as expected when it is combined.
Build the distribution files after having installed the external development dependencies (for more details, see above).
grunt
FAQs
A JavaScript library for internationalization and localization that leverages the official Unicode CLDR JSON data.
The npm package globalize receives a total of 81,590 weekly downloads. As such, globalize popularity was classified as popular.
We found that globalize demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 3 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Research
A malicious npm package disguised as a WhatsApp client is exploiting authentication flows with a remote kill switch to exfiltrate data and destroy files.
Security News
PyPI now supports digital attestations, enhancing security and trust by allowing package maintainers to verify the authenticity of Python packages.
Security News
GitHub removed 27 malicious pull requests attempting to inject harmful code across multiple open source repositories, in another round of low-effort attacks.