CONVERSION DES NOMBRES EN LETTRE

cs_bultez Messages postés 13615 Date d'inscription jeudi 13 février 2003 Statut Membre Dernière intervention 15 octobre 2013 - 19 oct. 2007 à 15:52
 drissolmac - 19 janv. 2019 à 01:50
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.

https://codes-sources.commentcamarche.net/source/44435-conversion-des-nombres-en-lettre

c coooll merci bcp pour ce code mais ya t'il une solution pour avoir le resultat sous un input type text a la place de div merci de me repondre
linnnux Messages postés 3 Date d'inscription samedi 30 septembre 2017 Statut Membre Dernière intervention 30 septembre 2017
30 sept. 2017 à 21:11
Salut , ton programme m'a été très utile , je l'ai réadapté pour un autre projet, je te dis un GRAND MERCI pour le partage ;)
Non pas du tout ;) Désolé... instit, c'est tout. Et puis il y a aussi "soixante-onze" qui pose aussi problème. Mais si tu n'as pas le temps ou l'envie de modifier... ce n'est pas grave. Très bonne soirée.
Whismeril Messages postés 19025 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 19 avril 2024 656 > jcb
6 mars 2017 à 06:52
Au temps pour moi, tu as déjà les corrections de Jordane.
Le javascript n'étant pas ma tasse de thé, il faut que je me pose, et le lundi c'est pas le jour...

En attendant, si tu as excel (ça n'est pas le cas de l'école de mes enfants), il y a ce code. Le fichier excel est à télécharger à la fin. J'ai aussi écrit une version alternative mais sans interface, , il faut lire tous les commentaires, il y a eu une correction de ma part et de la part de pijaku.
Whismeril Messages postés 19025 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 19 avril 2024 656 > Whismeril Messages postés 19025 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 19 avril 2024
6 mars 2017 à 11:50
J'ai eu un peu de temps ce matin.

La fonction est récursive, ce qui veut dire qu'elle s'appelle sans cesse elle même.
De ce fait elle traite les nombres par "petits morceaux" et dans le cas de ton 400 000, elle traite 400 sans savoir qu'il y' a mille derrière.
J'ai ajouté un paramètre à la fonction et fait en sorte que ce paramètre soit facultatif, il suffit donc dans le traitement de l'ajouter uniquement quand c'est nécessaire.

Je n'ai pas traité 400 000 000, car j'ai lu que million n'est pas un adjectif numéral et du coup je ne sais pas si la bonne orthographe est quatre cents millions ou quatre cent millions.
J'attends que tu me dise avant de poster le code.
Whismeril Messages postés 19025 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 19 avril 2024 656 > Whismeril Messages postés 19025 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 19 avril 2024
7 mars 2017 à 19:03
Bonsoir,

j'ai demandé à l'instit de mon fils, elle m'a dit que s'il y a un mot après le cent, pas de s, donc
<!DOCTYPE html>
<html>
<body>
 
<p>Cliquer sur le bouton va convertir le nombre en texte.</p>
 
<button onclick="Test()">Click me</button>
 
<p id="demo">400400400400400</p>
 
<script>
function Test()
{
                var monP = document.getElementById("demo");
                monP.innerHTML = NumberToLetter(400400400400400);
}
 
function Unite( nombre ){
                var unite;
                switch( nombre ){
                               case 0: unite = "zéro";                  break;
                               case 1: unite = "un";                      break;
                               case 2: unite = "deux";                 break;
                               case 3: unite = "trois";   break;
                               case 4: unite = "quatre";              break;
                               case 5: unite = "cinq";   break;
                               case 6: unite = "six";                      break;
                               case 7: unite = "sept";   break;
                               case 8: unite = "huit";    break;
                               case 9: unite = "neuf"; break;
                }//fin switch
                return unite;
}//-----------------------------------------------------------------------
 
function Dizaine( nombre ){
                switch( nombre ){
                               case 10: dizaine = "dix"; break;
                               case 11: dizaine = "onze"; break;
                               case 12: dizaine = "douze"; break;
                               case 13: dizaine = "treize"; break;
                               case 14: dizaine = "quatorze"; break;
                               case 15: dizaine = "quinze"; break;
                               case 16: dizaine = "seize"; break;
                               case 17: dizaine = "dix-sept"; break;
                               case 18: dizaine = "dix-huit"; break;
                               case 19: dizaine = "dix-neuf"; break;
                               case 20: dizaine = "vingt"; break;
                               case 30: dizaine = "trente"; break;
                               case 40: dizaine = "quarante"; break;
                               case 50: dizaine = "cinquante"; break;
                               case 60: dizaine = "soixante"; break;
                               case 70: dizaine = "soixante-dix"; break;
                               case 80: dizaine = "quatre-vingt"; break;
                               case 90: dizaine = "quatre-vingt-dix"; break;
                }//fin switch
                return dizaine;
}//-----------------------------------------------------------------------
 
function NumberToLetter( nombre, centMille){
                var i, j, n, quotient, reste, nb ;
                var ch
                var numberToLetter='';
 
                if( typeof(centMille) == 'undefined' ){
                centMille = false;
                }
                //__________________________________
               
                if(  nombre.toString().replace( / /gi, "" ).length > 15  )   return "dépassement de capacité";
                if(  isNaN(nombre.toString().replace( / /gi, "" ))  )                           return "Nombre non valide";
 
                nb = parseFloat(nombre.toString().replace( / /gi, "" ));
                if(  Math.ceil(nb) != nb  )             return  "Nombre avec virgule non géré.";
               
                n = nb.toString().length;
                switch( n ){
                               case 1: numberToLetter = Unite(nb); break;
                               case 2: if(  nb > 19  ){
                                                                                 quotient = Math.floor(nb / 10);
                                                                                 reste = nb % 10;
           
                                                                                 if(  nb < 71 || (nb > 79 && nb < 91)  ){
                                                                                                              if(  reste == 0  ) numberToLetter = Dizaine(quotient * 10);
                                                                                                              if(  reste == 1  ){
                  if(nb==81){
                    numberToLetter = Dizaine(quotient * 10) + "-" + Unite(reste);
                  }else{                 
                    numberToLetter = Dizaine(quotient * 10) + "-et-" + Unite(reste);
                  }
               }
                                                                                                              if(  reste > 1   ) numberToLetter = Dizaine(quotient * 10) + "-" + Unite(reste);
                                                                                 }else{
                console.log(nb);
             console.log(quotient);
               if(nb==71){
                  numberToLetter = Dizaine((quotient - 1) * 10) + " et " + Dizaine(10 + reste);
               }else {
                 numberToLetter = Dizaine((quotient - 1) * 10) + "-" + Dizaine(10 + reste);
               }
             }
                                                               }else numberToLetter = Dizaine(nb);
                                                               break;
                               case 3: quotient = Math.floor(nb / 100);
                                                               reste = nb % 100;
                                                               if(  quotient == 1 && reste == 0   ) numberToLetter = "cent";
                                                               if(  quotient == 1 && reste != 0   ) numberToLetter = "cent" + " " + NumberToLetter(reste);
                                                               if(  quotient > 1 && reste == 0  && centMille == false) numberToLetter = Unite(quotient) + " cents";
                                                               if(  quotient > 1 && reste == 0  && centMille == true  ) numberToLetter = Unite(quotient) + " cent";
                                                               if(  quotient > 1 && reste != 0    ) numberToLetter = Unite(quotient) + " cent " + NumberToLetter(reste);
                                                               break;
                               case 4 :  quotient = Math.floor(nb / 1000);
                                                                                reste = nb - quotient * 1000;
                                                                                if(  quotient == 1 && reste == 0   ) numberToLetter = "mille";
                                                                                if(  quotient == 1 && reste != 0   ) numberToLetter = "mille" + " " + NumberToLetter(reste);
                                                                                if(  quotient > 1 && reste == 0    ) numberToLetter = NumberToLetter(quotient) + " mille";
                                                                                if(  quotient > 1 && reste != 0    ) numberToLetter = NumberToLetter(quotient) + " mille " + NumberToLetter(reste);
                                                                                break;
                               case 5 :  quotient = Math.floor(nb / 1000);
                                                                                reste = nb - quotient * 1000;
                                                                                if(  quotient == 1 && reste == 0   ) numberToLetter = "mille";
                                                                                if(  quotient == 1 && reste != 0   ) numberToLetter = "mille" + " " + NumberToLetter(reste);
                                                                                if(  quotient > 1 && reste == 0    ) numberToLetter = NumberToLetter(quotient, true) + " mille";
                                                                                if(  quotient > 1 && reste != 0    ) numberToLetter = NumberToLetter(quotient, true) + " mille " + NumberToLetter(reste);
                                                                                break;
                               case 6 :  quotient = Math.floor(nb / 1000);
                                                                                reste = nb - quotient * 1000;
                                                                                if(  quotient == 1 && reste == 0   ) numberToLetter = "mille";
                                                                                if(  quotient == 1 && reste != 0   ) numberToLetter = "mille" + " " + NumberToLetter(reste);
                                                                                if(  quotient > 1 && reste == 0    ) numberToLetter = NumberToLetter(quotient, true) + " mille";
                                                                                if(  quotient > 1 && reste != 0    ) numberToLetter = NumberToLetter(quotient, true) + " mille " + NumberToLetter(reste);
                                                                                break;
                               case 7: quotient = Math.floor(nb / 1000000);
                                                                                reste = nb % 1000000;
                                                                                if(  quotient == 1 && reste == 0  ) numberToLetter = "un million";
                                                                                if(  quotient == 1 && reste != 0  ) numberToLetter = "un million" + " " + NumberToLetter(reste);
                                                                                if(  quotient > 1 && reste == 0   ) numberToLetter = NumberToLetter(quotient, true) + " millions";
                                                                                if(  quotient > 1 && reste != 0   ) numberToLetter = NumberToLetter(quotient, true) + " millions " + NumberToLetter(reste);
                                                                                break; 
                                case 8: quotient = Math.floor(nb / 1000000);
                                                                                reste = nb % 1000000;
                                                                                if(  quotient == 1 && reste == 0  ) numberToLetter = "un million";
                                                                                if(  quotient == 1 && reste != 0  ) numberToLetter = "un million" + " " + NumberToLetter(reste);
                                                                                if(  quotient > 1 && reste == 0   ) numberToLetter = NumberToLetter(quotient, true) + " millions";
                                                                                if(  quotient > 1 && reste != 0   ) numberToLetter = NumberToLetter(quotient, true) + " millions " + NumberToLetter(reste);
                                                                                break; 
                                case 9: quotient = Math.floor(nb / 1000000);
                                                                                reste = nb % 1000000;
                                                                                if(  quotient == 1 && reste == 0  ) numberToLetter = "un million";
                                                                                if(  quotient == 1 && reste != 0  ) numberToLetter = "un million" + " " + NumberToLetter(reste);
                                                                                if(  quotient > 1 && reste == 0   ) numberToLetter = NumberToLetter(quotient, true) + " millions";
                                                                                if(  quotient > 1 && reste != 0   ) numberToLetter = NumberToLetter(quotient, true) + " millions " + NumberToLetter(reste);
                                                                                break; 
                                case 10: quotient = Math.floor(nb / 1000000000);
                                                                                              reste = nb - quotient * 1000000000;
                                                                                              if(  quotient == 1 && reste == 0  ) numberToLetter = "un milliard";
                                                                                              if(  quotient == 1 && reste != 0  ) numberToLetter = "un milliard" + " " + NumberToLetter(reste);
                                                                                              if(  quotient > 1 && reste == 0   ) numberToLetter = NumberToLetter(quotient, true) + " milliards";
                                                                                              if(  quotient > 1 && reste != 0   ) numberToLetter = NumberToLetter(quotient, true) + " milliards " + NumberToLetter(reste);
                                                                                  break;             
                               case 11: quotient = Math.floor(nb / 1000000000);
                                                                                              reste = nb - quotient * 1000000000;
                                                                                              if(  quotient == 1 && reste == 0  ) numberToLetter = "un milliard";
                                                                                              if(  quotient == 1 && reste != 0  ) numberToLetter = "un milliard" + " " + NumberToLetter(reste);
                                                                                              if(  quotient > 1 && reste == 0   ) numberToLetter = NumberToLetter(quotient, true) + " milliards";
                                                                                              if(  quotient > 1 && reste != 0   ) numberToLetter = NumberToLetter(quotient, true) + " milliards " + NumberToLetter(reste);
                                                                                  break;             
                               case 12: quotient = Math.floor(nb / 1000000000);
                                                                                              reste = nb - quotient * 1000000000;
                                                                                              if(  quotient == 1 && reste == 0  ) numberToLetter = "un milliard";
                                                                                              if(  quotient == 1 && reste != 0  ) numberToLetter = "un milliard" + " " + NumberToLetter(reste);
                                                                                              if(  quotient > 1 && reste == 0   ) numberToLetter = NumberToLetter(quotient, true) + " milliards";
                                                                                              if(  quotient > 1 && reste != 0   ) numberToLetter = NumberToLetter(quotient, true) + " milliards " + NumberToLetter(reste);
                                                                                  break;             
                               case 13: quotient = Math.floor(nb / 1000000000000);
                                                                                              reste = nb - quotient * 1000000000000;
                                                                                              if(  quotient == 1 && reste == 0  ) numberToLetter = "un billion";
                                                                                              if(  quotient == 1 && reste != 0  ) numberToLetter = "un billion" + " " + NumberToLetter(reste);
                                                                                              if(  quotient > 1 && reste == 0   ) numberToLetter = NumberToLetter(quotient, true) + " billions";
                                                                                              if(  quotient > 1 && reste != 0   ) numberToLetter = NumberToLetter(quotient, true) + " billions " + NumberToLetter(reste);
                                                                                  break;             
                                case 14: quotient = Math.floor(nb / 1000000000000);
                                                                                              reste = nb - quotient * 1000000000000;
                                                                                              if(  quotient == 1 && reste == 0  ) numberToLetter = "un billion";
                                                                                              if(  quotient == 1 && reste != 0  ) numberToLetter = "un billion" + " " + NumberToLetter(reste);
                                                                                              if(  quotient > 1 && reste == 0   ) numberToLetter = NumberToLetter(quotient, true) + " billions";
                                                                                              if(  quotient > 1 && reste != 0   ) numberToLetter = NumberToLetter(quotient, true) + " billions " + NumberToLetter(reste);
                                                                                   break;             
                                case 15: quotient = Math.floor(nb / 1000000000000);
                                                                                              reste = nb - quotient * 1000000000000;
                                                                                              if(  quotient == 1 && reste == 0  ) numberToLetter = "un billion";
                                                                                              if(  quotient == 1 && reste != 0  ) numberToLetter = "un billion" + " " + NumberToLetter(reste);
                                                                                              if(  quotient > 1 && reste == 0   ) numberToLetter = NumberToLetter(quotient, true) + " billions";
                                                                                              if(  quotient > 1 && reste != 0   ) numberToLetter = NumberToLetter(quotient, true) + " billions " + NumberToLetter(reste);
                                                                                  break;             
                 }//fin switch
                /*respect de l'accord de quatre-vingt*/
                if(  numberToLetter.substr(numberToLetter.length-"quatre-vingt".length,"quatre-vingt".length) == "quatre-vingt"  ) numberToLetter = numberToLetter + "s";
               
                 return numberToLetter;
}//-----------------------------------------------------------------------
</script>
 
</body>
</html>


Par contre, elle m'a aussi dit qu'avec la nouvelle orthographe, il faudrait mettre des - partout
jcb > Whismeril Messages postés 19025 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 19 avril 2024
14 mars 2017 à 22:10
Les traits d'union partout... c'est pas obligatoire... les 2 règles fonctionnent.
Whismeril Messages postés 19025 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 19 avril 2024 656 > jcb
14 mars 2017 à 22:29
Ça tombe bien, je ne l'ai pas fait.
jordane45 Messages postés 38138 Date d'inscription mercredi 22 octobre 2003 Statut Modérateur Dernière intervention 17 avril 2024 344 > jcb
5 mars 2017 à 23:02
pour le 71 et le 81 j'ai apporté une modification
case 2: if(  nb > 19  ){
					   quotient = Math.floor(nb / 10);
					   reste = nb % 10;
            
					   if(  nb < 71 || (nb > 79 && nb < 91)  ){
							 if(  reste == 0  ) numberToLetter = Dizaine(quotient * 10);
							 if(  reste == 1  ){
                  if(nb==81){
                    numberToLetter = Dizaine(quotient * 10) + "-" + Unite(reste);
                  }else{                  
                    numberToLetter = Dizaine(quotient * 10) + "-et-" + Unite(reste);
                  }
               }
							 if(  reste > 1   ) numberToLetter = Dizaine(quotient * 10) + "-" + Unite(reste);
					   }else{
                console.log(nb);
             console.log(quotient);
               if(nb==71){
                  numberToLetter = Dizaine((quotient - 1) * 10) + " et " + Dizaine(10 + reste);
               }else {
                 numberToLetter = Dizaine((quotient - 1) * 10) + "-" + Dizaine(10 + reste);
               }
             }
				 }else numberToLetter = Dizaine(nb);
				 break;

(en mode brouillon.. mais qui fonctionne )...
Pour le reste je n'ai pas regardé ....; je laisse l'auteur de la source s'en occuper si il repasse par ici un jour ...(sachant qu'il n'est pas revenu depuis 2003 ... )
Bonjour,
Effectivement... très bon script... mais des petites erreurs et du coup je ne peux pas le proposer à mes élèves.
ex : un million quatre cents mille hélas... pas de s
et puis quatre-vingt-et-un... pas de et. Est-il possible d'avoir le script corrigé ?
Merci
Whismeril Messages postés 19025 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 19 avril 2024 656 > jcb
5 mars 2017 à 20:33
Bonsoir, si tu es prof de javascript, je pense que tu as largement le niveau de corriger ces erreurs non?
Bonjour,
merci pour le partage
code qui ma servi dans une de mes applications.

Par contre quelques coquilles :
par exemple :
180 000 donne cent-quatre-vingtS-mille
Lazaro > raikkin
21 oct. 2015 à 17:19
Pouvez-vous s'il vous plaît partager les corrections que vous avez apportées au code ?
Whismeril Messages postés 19025 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 19 avril 2024 656 > raikkin
4 juil. 2015 à 10:33
Bonjour, en ce cas ce serait sympa de poster les corrections que tu as apportées en utilisant la coloration syntaxique.
elshabab Messages postés 1 Date d'inscription lundi 24 septembre 2007 Statut Membre Dernière intervention 9 novembre 2007
9 nov. 2007 à 09:09
C'est une très bonne programmation mais dommage qu'on ne puisse tebir compte des décimaux.
JE suis en train de travailler sur un module pouvant palier à ce manque.

Best Regards
cs_bultez Messages postés 13615 Date d'inscription jeudi 13 février 2003 Statut Membre Dernière intervention 15 octobre 2013 30
19 oct. 2007 à 15:52
même s'il existe de nombreuses versions,
dans une foultitude de langages, une de
plus, respectant l'orthographe en français
aurait été la bienvenue ( c'est très loin
d'être le cas pour toutes ! )
je n'ai pas vérifié cette affirmation, car :
>>if( Math.ceil(nb) != nb ) return "Nombre avec virgule non géré.";
donc
>>utile dans des applications comptables ou pour les sites commerciaux
difficile sans décimales.
c'est dommage ?
ce, sans faire de remarques sur la source, où
quelques améliorations me semblent possibles.
et je n'ai pas testé du coup.

Cordialement.
Rejoignez-nous