CONVERSION DES NOMBRES EN LETTRE

cs_bultez 13619 Messages postés jeudi 13 février 2003Date d'inscription 15 octobre 2013 Dernière intervention - 19 oct. 2007 à 15:52 - Dernière réponse : linnnux 3 Messages postés samedi 30 septembre 2017Date d'inscription 30 septembre 2017 Dernière intervention
- 30 sept. 2017 à 21:11
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.

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

Afficher la suite 
Whismeril 11411 Messages postés mardi 11 mars 2003Date d'inscriptionContributeurStatut 22 avril 2018 Dernière intervention > Whismeril 11411 Messages postés mardi 11 mars 2003Date d'inscriptionContributeurStatut 22 avril 2018 Dernière intervention - 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 11411 Messages postés mardi 11 mars 2003Date d'inscriptionContributeurStatut 22 avril 2018 Dernière intervention > Whismeril 11411 Messages postés mardi 11 mars 2003Date d'inscriptionContributeurStatut 22 avril 2018 Dernière intervention - 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 11411 Messages postés mardi 11 mars 2003Date d'inscriptionContributeurStatut 22 avril 2018 Dernière intervention - 14 mars 2017 à 22:10
Les traits d'union partout... c'est pas obligatoire... les 2 règles fonctionnent.
Whismeril 11411 Messages postés mardi 11 mars 2003Date d'inscriptionContributeurStatut 22 avril 2018 Dernière intervention > jcb - 14 mars 2017 à 22:29
Ça tombe bien, je ne l'ai pas fait.
linnnux 3 Messages postés samedi 30 septembre 2017Date d'inscription 30 septembre 2017 Dernière intervention - 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 ;)
Commenter la réponse de cs_bultez

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.