web-dev-qa-db-fra.com

Javascript pluralise une chaîne

En PHP, j'utilise la classe de Kuwamoto pour pluraliser les noms dans mes chaînes. Je n'ai pas trouvé quelque chose d'aussi bon que ce script en javascript à l'exception de quelques plugins. Donc, ce serait génial d'avoir une fonction javascript basée sur la classe de Kuwamoto.

http://kuwamoto.org/2007/12/17/improved- pluralizing-in-php-actionscript-and-ror/

javascriptpluralizeplural
23
pmrotule

Alors, je réponds à ma propre question en partageant ma traduction en javascript de la classe PHP de Kuwamoto.

String.prototype.plural = function(revert){

    var plural = {
        '(quiz)$'               : "$1zes",
        '^(ox)$'                : "$1en",
        '([m|l])ouse$'          : "$1ice",
        '(matr|vert|ind)ix|ex$' : "$1ices",
        '(x|ch|ss|sh)$'         : "$1es",
        '([^aeiouy]|qu)y$'      : "$1ies",
        '(Hive)$'               : "$1s",
        '(?:([^f])fe|([lr])f)$' : "$1$2ves",
        '(shea|lea|loa|thie)f$' : "$1ves",
        'sis$'                  : "ses",
        '([ti])um$'             : "$1a",
        '(tomat|potat|ech|her|vet)o$': "$1oes",
        '(bu)s$'                : "$1ses",
        '(alias)$'              : "$1es",
        '(octop)us$'            : "$1i",
        '(ax|test)is$'          : "$1es",
        '(us)$'                 : "$1es",
        '([^s]+)$'              : "$1s"
    };

    var singular = {
        '(quiz)zes$'             : "$1",
        '(matr)ices$'            : "$1ix",
        '(vert|ind)ices$'        : "$1ex",
        '^(ox)en$'               : "$1",
        '(alias)es$'             : "$1",
        '(octop|vir)i$'          : "$1us",
        '(cris|ax|test)es$'      : "$1is",
        '(shoe)s$'               : "$1",
        '(o)es$'                 : "$1",
        '(bus)es$'               : "$1",
        '([m|l])ice$'            : "$1ouse",
        '(x|ch|ss|sh)es$'        : "$1",
        '(m)ovies$'              : "$1ovie",
        '(s)eries$'              : "$1eries",
        '([^aeiouy]|qu)ies$'     : "$1y",
        '([lr])ves$'             : "$1f",
        '(tive)s$'               : "$1",
        '(Hive)s$'               : "$1",
        '(li|wi|kni)ves$'        : "$1fe",
        '(shea|loa|lea|thie)ves$': "$1f",
        '(^analy)ses$'           : "$1sis",
        '((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$': "$1$2sis",        
        '([ti])a$'               : "$1um",
        '(n)ews$'                : "$1ews",
        '(h|bl)ouses$'           : "$1ouse",
        '(corpse)s$'             : "$1",
        '(us)es$'                : "$1",
        's$'                     : ""
    };

    var irregular = {
        'move'   : 'moves',
        'foot'   : 'feet',
        'goose'  : 'geese',
        'sex'    : 'sexes',
        'child'  : 'children',
        'man'    : 'men',
        'tooth'  : 'teeth',
        'person' : 'people'
    };

    var uncountable = [
        'sheep', 
        'fish',
        'deer',
        'moose',
        'series',
        'species',
        'money',
        'rice',
        'information',
        'equipment'
    ];

    // save some time in the case that singular and plural are the same
    if(uncountable.indexOf(this.toLowerCase()) >= 0)
      return this;

    // check for irregular forms
    for(Word in irregular){

      if(revert){
              var pattern = new RegExp(irregular[Word]+'$', 'i');
              var replace = Word;
      } else{ var pattern = new RegExp(Word+'$', 'i');
              var replace = irregular[Word];
      }
      if(pattern.test(this))
        return this.replace(pattern, replace);
    }

    if(revert) var array = singular;
         else  var array = plural;

    // check for matches using regular expressions
    for(reg in array){

      var pattern = new RegExp(reg, 'i');

      if(pattern.test(this))
        return this.replace(pattern, array[reg]);
    }

    return this;
}

Facile à utiliser:

alert("page".plural()); // return plural form => pages
alert("mouse".plural()); // return plural form => mice
alert("women".plural(true)); // return singular form => woman

DÉMO

26
pmrotule

Version simple (ES6):

const maybePluralize = (count, noun, suffix = 's') =>
  `${count} ${noun}${count !== 1 ? suffix : ''}`;

Usage:

maybePluralize(0, 'turtle'); // 0 turtles
maybePluralize(1, 'turtle'); // 1 turtle
maybePluralize(2, 'turtle'); // 2 turtles
maybePluralize(3, 'fox', 'es'); // 3 foxes

Cela ne prend évidemment pas en charge tous les cas anglais, mais convient à la plupart des applications

25
sarink

Utiliser Pluralize

Il existe une superbe petite bibliothèque appelée Pluralize qui est emballée dans npm et bower.

Voici à quoi ça ressemble d'utiliser: 

import Pluralize from 'pluralize';

Pluralize( 'Towel', 42 );       // "Towels"

Pluralize( 'Towel', 42, true ); // "42 Towels"

Et vous pouvez l'obtenir ici: 

https://github.com/blakeembrey/pluralize

21
Joshua Pinter

Tiré de mon blog: https://sergiotapia.me/pluralizing-strings-in-javascript-es6-b5d4d651d403

Vous pouvez utiliser la bibliothèque pluralize pour cela.

NPM:
npm install pluralize --save

Yarn:
yarn add pluralize

Où que vous souhaitiez utiliser la bibliothèque, vous pouvez en avoir besoin facilement.

var pluralize = require('pluralize')

J'aime l'ajouter à l'objet window pour pouvoir simplement appeler pluralize () partout où j'en ai besoin. Dans mon fichier racine application.js:

window.pluralize = require('pluralize')

Ensuite, vous pouvez simplement l’utiliser n'importe où, avec des composants React ou simplement en Javascript:

<span className="pull-left">
  {`${item.score} ${pluralize('point', item.score)}`}
</span>

console.log(pluralize('point', item.score))
7
Sergio Tapia
function pluralize( /* n, [ n2, n3, ... ] str */ ) {
    var n = Array.prototype.slice.call( arguments ) ;
    var str = n.pop(), iMax = n.length - 1, i = -1, j ;
    str = str.replace( /\$\$|\$(\d+)/g,
        function( m, p1 ) { return m == '$$' ? '$' : n[+p1-1] }
    ) ;
    return str.replace( /[(](.*?)([+-])(\d*)(?:,([^,)]*))?(?:,([^)]*))?[)]/g,
        function( match, one, sign, abs, not1, zero ) {
            // if abs, use indicated element in the array of numbers
            // instead of using the next element in sequence
            abs ? ( j = +abs - 1 ) : ( i < iMax && i++, j = i ) ;
            if ( zero != undefined && n[j] == 0 ) return zero ;
            return ( n[j] != 1 ) == ( sign == '+' ) ? ( not1 || 's' ) : one ;
        }
    ) ;  
}

console.log( pluralize( 1, 'the cat(+) live(-) outside' ) ) ;
// the cat lives outside
console.log( pluralize( 2, 'the child(+,ren) (is+,are) inside' ) ) ;
// the children are inside
console.log( pluralize( 0, '$1 dog(+), ($1+,$1,no) dog(+), ($1+,$1,no) dog(+,,)' ) ) ;
// 0 dogs, no dogs, no dog
console.log( pluralize( 100, 1, '$1 penn(y+,ies) make(-1) $$$2' ) ) ;
// 100 pennies make $1
console.log( pluralize( 1, 0.01, '$1 penn(y+,ies) make(-1) $$$2' ) ) ;
// 1 penny makes $0.01
1
barncat

J'ai créé une bibliothèque très simple pouvant être utilisée pour la pluralisation de mots en JavaScript. Il utilise de manière transparente la base de données CLDR pour plusieurs paramètres régionaux, de sorte qu'il prend en charge presque toutes les langues que vous souhaitez utiliser. L’API est très minimaliste et l’intégration extrêmement simple. Il s’appelle Nombreux .

J’ai également écrit un petit article d’introduction: « Comment pluraliser un mot dans différentes langues en utilisant JavaScript? ».

N'hésitez pas à l'utiliser dans votre projet. Je serai également heureux de vos commentaires à ce sujet.

1
Slava Fomin II

En utilisant la réponse de @ sarink, j'ai créé une fonction permettant de créer une chaîne en utilisant des données de paires clé-valeur et en pluralisant les clés. Voici l'extrait de code:

// Function to create a string from given key value pairs and pluralize keys
const stringPluralize = function(data){
    var suffix = 's';
    var str = '';
    $.each(data, function(key, val){
        if(str != ''){
            str += val>0 ? ` and ${val} ${key}${val !== 1 ? suffix : ''}` : '';
        }
        else{
            str = val>0 ? `${val} ${key}${val !== 1 ? suffix : ''}` : '';
        }
    });
    return str;
}
var leftDays = '1';
var leftHours = '12';
var str = stringPluralize({day:leftDays, hour:leftHours});
console.log(str) // Gives 1 day and 12 hours
0
Chintan Bhatt