Make-plural is a JavaScript module that translates Unicode CLDR pluralization
rules to JavaScript functions. It includes both a live parser as well as the
generated output for the latest edition of the CLDR; the latter is just over 2kB
in size when minified & gzipped and covers 199 languages, so it's probably what
you want unless you really know what you're doing.
Make-plural is written in ECMAScript 6 and transpiled using Babel and
Browserify to CommonJS and AMD and ES6 module formats, as well as being
suitable for use in browser environments.
npm install make-plural
or bower install make-plural
or git clone https://github.com/eemeli/make-plural.git cd make-plural npm install make all
or download the latest release from
here
umd/plurals.js contains an UMD module that can be included with node'srequire or AMD's define. In a browser environment, it will populate a global
object plurals. Said module contains 199 functions (one per language),
each taking as a first parameter the value to be classified (either a number or
a string), and as an optional second parameter, a boolean that if true, applies
ordinal rather than cardinal rules.
umd/pluralCategories.js has a similar structure to umd/plurals.js, but
contains an array of the pluralization categories the cardinal and ordinal rules
each language's pluralization function may output.
es6/plurals.js and es6/pluralCategories.js are the ES6 module equivalents of
the above.
If your language isn't directly included in either of the above, try removing
any trailing parts that are separated from the stem by - or _. Note also
that the capitalization of locale codes is lowercase for the language, but
uppercase for the country, so for example the code for Portugese as spoken in
Portugal is pt-PT.
var plurals = require('make-plural')
// { af: [Function],
// ak: [Function],
// am: [Function],
// snip 193 lines...
// yo: [Function],
// zh: [Function],
// zu: [Function] }
plurals.en(1) // 1st param is the value
// 'one'
plurals.en(2)
// 'other'
plurals.en(2, true) // 2nd param, if true-ish, is for ordinal rules
// 'two'
console.log(plurals.en.toString())
// function (n, ord) {
// var s = String(n).split('.'), v0 = !s[1], t0 = Number(s[0]) == n,
// n10 = t0 && s[0].slice(-1), n100 = t0 && s[0].slice(-2);
// if (ord) return (n10 == 1 && n100 != 11) ? 'one'
// : (n10 == 2 && n100 != 12) ? 'two'
// : (n10 == 3 && n100 != 13) ? 'few'
// : 'other';
// return (n == 1 && v0) ? 'one' : 'other';
// }
var pluralCategories = require('make-plural/umd/pluralCategories')
// { af: { cardinal: [ 'one', 'other' ], ordinal: [ 'other' ] },
// ak: { cardinal: [ 'one', 'other' ], ordinal: [ 'other' ] },
// am: { cardinal: [ 'one', 'other' ], ordinal: [ 'other' ] },
// ar:
// { cardinal: [ 'zero', 'one', 'two', 'few', 'many', 'other' ],
// ordinal: [ 'other' ] },
// snip 255 lines...
// zh: { cardinal: [ 'other' ], ordinal: [ 'other' ] },
// zu: { cardinal: [ 'one', 'other' ], ordinal: [ 'other' ] } }
<script src="path/to/make-plural/umd/plurals.js"></script>
<script>
var ru = plurals.ru
console.log('1: ' + plurals.ru(1) + ', 3.0: ' + plurals.ru(3.0) +
', "1.0": ' + plurals.ru('1.0') + ', "0": ' + plurals.ru('0'));
console.log(plurals.ru.toString());
</script>
With outputs:
```
1: one, 3.0: few, "1.0": other, "0": many
function(n, ord) {
var s = String(n).split('.'), i = s[0], v0 = !s[1], i10 = i.slice(-1),
i100 = i.slice(-2);
if (ord) return 'other';
return (v0 && i10 == 1 && i100 != 11) ? 'one'
: (v0 && (i10 >= 2 && i10 <= 4) && (i100 < 12
|| i100 > 14)) ? 'few'
: (v0 && i10 == 0 || v0 && (i10 >= 5 && i10 <= 9)
|| v0 && (i100 >= 11 && i100 <= 14)) ? 'many'
: 'other';
}
```
Note that with umd/plurals.min.js, the stringified function would be rendered
as:js function (e,t){var r=String(e).split("."),n=r[0],o=!r[1],c=n.slice(-1), i=n.slice(-2);return t?"other":o&&1==c&&11!=i?"one":o&&c>=2&&4>=c&&(12>i||i>14)? "few":o&&0==c||o&&c>=5&&9>=c||o&&i>=11&&14>=i?"many":"other"}
make-plural.jsLoads CLDR rules from one or more cldr variables, each of which must be an
object formatted like this.
No plural data is included by default, so you'll need to call this at least
once, or otherwise fill the MakePlural.rules object.
The default CLDR rules are included in make-plural, and may be loaded as seen
in the examples below.
Returns a function that takes an argument n and returns its plural category
for the given locale lc. If no direct match for lc is found, it is compared
case-insensitively to known locales.
The returned function has an overloaded toString(name) method that may be
used to generate a clean string representation of the function, with an
optional name name.
The optional second parameter may contain the following boolean members:
* cardinals — if true, rules for cardinal values (1 day, 2 days, etc.) are
included
* ordinals — if true, rules for ordinal values (1st, 2nd, etc.) are included
If both cardinals and ordinals are true, the returned function takes a
second parameter ord. Then, if ord is true, the function will return the
ordinal rather than cardinal category applicable to n in locale lc.
If the second parameter is undefined, the values are taken fromMakePlural.cardinals (default true) and MakePlural.ordinals (defaultfalse).
var MakePlural = require('make-plural/make-plural').load(
require('make-plural/data/plurals.json'),
require('make-plural/data/ordinals.json'))
// { [Function: MakePlural]
// cardinals: true,
// ordinals: false,
// rules:
// { cardinal:
// { af: [Object],
// ak: [Object],
// am: [Object],
// snip 193 lines...
// yo: [Object],
// zh: [Object],
// zu: [Object] },
// ordinal:
// { af: [Object],
// am: [Object],
// ar: [Object],
// snip 78 lines...
// vi: [Object],
// zh: [Object],
// zu: [Object] } } }
var sk = new MakePlural('sk') // Note: not including ordinals by default
// { [Function]
// _obj:
// { lc: 'sk',
// cardinals: true,
// ordinals: false,
// categories: { cardinal: [Object], ordinal: [] },
// parser: { v0: 1, i: 1 },
// tests: { obj: [Circular], ordinal: {}, cardinal: [Object] },
// fn: [Circular] },
// categories: { cardinal: [ 'one', 'few', 'many', 'other' ], ordinal: [] },
// test: [Function],
// toString: [Function] }
sk(1)
// 'one'
sk(3.0)
// 'few'
sk('1.0')
// 'many'
sk('0')
// 'other'
console.log(sk.toString())
// function(n) {
// var s = String(n).split('.'), i = s[0], v0 = !s[1];
// return (i == 1 && v0 ) ? 'one'
// : ((i >= 2 && i <= 4) && v0 ) ? 'few'
// : (!v0 ) ? 'many'
// : 'other';
// }
make-plural may also be used in browser environments; see test/index.html
for an example of its use.
$ ./bin/make-plural > plurals.js
$ ./bin/make-plural fr
function fr(n, ord) {
if (ord) return (n == 1) ? 'one' : 'other';
return (n >= 0 && n < 2) ? 'one' : 'other';
}
$ ./bin/make-plural --locale fr --value 1.5
one
$ ./bin/make-plural 1.5 -l fr --ordinal
other
Please see the source of src/index.js for more details.
Make-plural has no required runtime dependencies. CLDR plural rule data is
included in JSON format; make-plural supports the LDML Language Plural Rules
as used in CLDR release 24 and later.
The CLI binary bin/make-plural does use minimist as an argument parser, but
that is not required for any other use.
Using MakePlural.load(), you may make use of external sources of CLDR data.
For example, the following works when using together with cldr-data:js var cldr = require('cldr-data'); var MakePlural = require('make-plural/make-plural').load( cldr('supplemental/plurals'), cldr('supplemental/ordinals') ); var en = new MakePlural('en'); en(3, true); // 'few'