Comment écrire un nombre en toutes lettres avec une fonction Excel ?

Dans ce tutoriel, je vais répondre à l'une des questions qui m'est le plus souvent posée : comment écrire un nombre en toutes lettres sur Excel ? Pour cela, nous allons construire une fonction personnalisée qui a permettre d'effectuer cette opération très simplement.

Téléchargement

Vous pouvez télécharger le fichier d'exemple de cet article en cliquant sur le lien suivant :

Tutoriel Vidéo

1. Les nombres de zéro à 99

Pour débuter ce tutoriel en douceur, nous allons commencer par créer une fonction qui va nous permettre de récupérer un nombre compris entre zéro et 99 en toutes lettres.

Et pour cela, nous allons bien entendu devoir passer par un développement en VBA.

Pour que ce tutoriel soit accessible à tout le monde, nous allons revenir dans le détail sur aspect de cette dernière.

Si vous souhaitez aller plus loin dans la découverte du langage VBA, vous pouvez évidemment consulter la formation disponible sur le blog en cliquant ici.

Pour commencer, nous allons lancer l’éditeur de code VBE (pour Visual Basic Editor), qui est l’éditeur de code intégré dans les différentes applications de la suite Office et qui permet de développer des macro-commandes en VBA.

Pour cela, nous appuyons simplement sur les touches [Alt]+[F11] :

VBE s’ouvre alors et nous allons commencer par créer un nouveau module.

Un module est une feuille de saisie de code dans laquelle nous allons pouvoir saisir nos macros et fonctions.

Pour insérer un nouveau module, nous nous rendons dans le menu Insertion > Module :

Une fois le module inséré, nous allons pouvoir créer la fonction personnalisée en saisissant le mot-clé Function, suivi que nous souhaitons donner à la fonction, à savoir nombreEnLettres :

Function nombreEnLettres()
 
End Function

Excel ajoute alors automatiquement la ligne End Function, et tout ce que nous allons saisir entre ces deux lignes sera exécuté automatiquement dès que nous appellerons la fonction.

Entre les parenthèses ajoutées également de manière automatique, nous allons pouvoir insérer un argument, c’est-à-dire un élément à transmettre directement à la fonction, il s’agira ici du nombre que nous souhaitons écrire en toutes lettres.

Dans un premier temps, nous souhaitons ne convertir que des petits nombres, mais nous souhaiterons par la suite être en mesure de gérer de grands nombres avec des décimales. Nous typons donc cet argument en tant que Double :

Function nombreEnLettres(ByVal nombre As Double)

Ici nous n’allons pas nous embêter, la méthode la plus simple pour effectuer la correction va être de saisir les nombres correspondants dans un tableau, que nous pourrons ensuite exploiter.

Nous créons donc une nouvelle variable que nous appelons listeNombresLettres que nous allons utiliser comme un tableau, nous le typons en tant que Variant.

Ensuite, nous venons saisir les différentes valeurs :

    Dim listeNombresLettres As Variant
    listeNombresLettres = Array("Zéro",  "Un", "Deux", "Trois", "Quatre",  "Cinq", "Six", "Sept", "Huit",  "Neuf")

Nous commençons par saisir « Zéro », puis tous les nombres jusqu’à neuf.

Pour tester, il suffit de renvoyer comme résultat de la fonction la valeur de ce tableau identifié par la position correspondante à la valeur de l’argument nombre :

    nombreEnLettres = listeNombresLettres(nombre) 

Nous pouvons tester en appelant la fonction nombreEnLettres directement depuis la feuille de calcul, comme nous le ferions pour n’importe quelle autre fonction Excel :

=nombreEnLettres(5)

Le résultat retourné correspond effectivement au chiffre cinq, saisit en toutes lettres :

En suivant cette méthode, nous pouvons récupérer les nombres allant jusqu’à 99.

Pour vous éviter le labeur de devoir les saisir manuellement, vous pouvez bien entendu effectuer un copier-coller du tableau complet que voici :

    listeNombresLettres =  Array("Zéro", "Un", "Deux", "Trois",  "Quatre", "Cinq", "Six", "Sept",  "Huit", "Neuf", "Dix", _
    "Onze", "Douze", "Treize",  "Quatorze", "Quinze", "Seize",  "Dix-sept", "Dix-Huit", "Dix-Neuf", _
    "Vingt", "Vingt et Un", "Vingt  Deux", "Vingt Trois", "Vingt Quatre", "Vingt  Cinq", "Vingt Six", "Vingt Sept", "Vingt  Huit", "Vingt Neuf", _
    "Trente", "Trente et Un",  "Trente Deux", "Trente Trois", "Trente Quatre",  "Trente Cinq", "Trente Six", "Trente Sept",  "Trente Huit", "Trente Neuf", _
    "Quarante", "Quarante et Un",  "Quarante Deux", "Quarante Trois", "Quarante  Quatre", "Quarante Cinq", "Quarante Six",  "Quarante Sept", "Quarante Huit", "Quarante  Neuf", _
    "Cinquante", "Cinquante et Un",  "Cinquante Deux", "Cinquante Trois", "Cinquante  Quatre", "Cinquante Cinq", "Cinquante Six",  "Cinquante Sept", "Cinquante Huit", "Cinquante  Neuf", _
    "Soixante", "Soixante et Un",  "Soixante Deux", "Soixante Trois", "Soixante  Quatre", "Soixante Cinq", "Soixante Six",  "Soixante Sept", "Soixante Huit", "Soixante  Neuf", _
    "Soixante Dix", "Soixante et Onze",  "Soixante Douze", "Soixante Treize", "Soixante  Quatorze", "Soixante Quinze", "Soixante Seize",  "Soixante Dix-Sept", "Soixante Dix-Huit", "Soixante  Dix-Neuf", _
    "Quatre-Vingts", "Quatre-Vingt Un",  "Quatre-Vingt Deux", "Quatre-Vingt Trois",  "Quatre-Vingt Quatre", "Quatre-Vingt Cinq",  "Quatre-Vingt Six", "Quatre-Vingt Sept", "Quatre-Vingt  Huit", "Quatre-Vingt Neuf", _
    "Quatre-Vingt Dix", "Quatre-Vingt  Onze", "Quatre-Vingt Douze", "Quatre-Vingt Treize",  "Quatre-Vingt Quatorze", "Quatre-Vingt Quinze",  "Quatre-Vingt Seize", "Quatre-Vingt Dix-Sept",  "Quatre-Vingt Dix-Huit", "Quatre-Vingt Dix-Neuf")

Attention, comme vous pouvez le constater, les différents éléments de ce tableau sont saisis sur plusieurs lignes grâce à l’utilisation d’un underscore. En effet, si nous avions saisi ces éléments sur une même ligne, celle-ci aurait été trop longue, ce qui aurait causé une erreur dans VBA.

Maintenant, nous pouvons effectuer un nouveau test avec un nombre bien plus grand :

2. Gérer la centaine

Maintenant que nous savons comment afficher en toutes lettres un nombre compris entre zéro et 99, voyons comment aller un cran plus loin en gérant les centaines, c’est-à-dire un nombre allant jusqu’à 999.

Bien entendu utiliser la méthode du tableau n’est ici plus envisageable… nous allons donc devoir décomposer le afin de traiter la centaine à part du reste du nombre.

Pour cela, nous allons commencer par faire intervenir une variable qui va nous permettre d’enregistrer la chaîne de caractère.

Nous déclarons donc une variable String que nous appelons simplement chaine dans laquelle nous allons stocker la valeur retournée par le tableau :

    Dim chaine As String
    chaine = listeNombresLettres(nombre)
    nombreEnLettres = chaine

De cette manière, nous allons pouvoir intercaler de nouvelles lignes pour gérer la centaine.

Nous commençons par vérifier que le nombre à saisir est effectivement supérieur ou égal à 100 en utilisant une instruction If :

    If nombre >= 100 Then
    
    End If

Cette ligne étant à insérer avant l’affectation du tableau à la variable chaîne.

Entre ces lignes nous allons récupérer la centaine du nombre passé en argument, qui correspond à la partie entière du nombre à écrire que nous divisons par 100 :

        Dim centaine As Integer
        centaine = Int(nombre / 100)

Nous allons maintenant pouvoir stocker dans la variable chaine la conversion en toutes lettres de ce nombre auquel nous ajoutons le terme « Cent », pour l’instant au singulier :

        chaine = listeNombresLettres(centaine)  & " Cent"

Pour savoir si le terme « Cent » doit être au pluriel, nous allons devoir appliquer la règle qui prévoit que ce dernier s’accorde au pluriel si :

• Il y a plusieurs centaines, ce que nous allons pouvoir contrôler en consulter la valeur de la variable centaine
• Et si en plus de cela, il n’y a pas de nombre qui suit (trois cents est au pluriel, trois cent un est au singulier)

Pour la première règle, nous regardons donc si la valeur de la variable centaine est supérieure à 1, sachant que dans le cas contraire, celle-ci serait égale à 1, et donc nous n’aurions à saisir que le terme « Cent », pour éviter le résultat « Un Cent » :

        If centaine > 1 Then
            chaine = listeNombresLettres(centaine)  & " Cent"
        Else
            chaine = "Cent"
        End If

Pour la seconde règle, nous allons retirer la centaine de la variable nombre afin de pouvoir la contrôler pour savoir s’il faut passer le terme « Cent » au pluriel :

        nombre = nombre - centaine * 100
        
        If centaine > 1 Then
            chaine = listeNombresLettres(centaine)  & " Cent"
            If nombre = 0 Then
                chaine = chaine & "s"
            End If
        Else
            chaine = "Cent"
        End If

Avant de pouvoir tester la fonction, nous allons devoir modifier la manière dont nous récupérons les nombres inférieurs à 100 afin de tenir du travail que nous venons de mettre en place :

    chaine = chaine & " " & listeNombresLettres(nombre) 

3. Gérer les milliers

Maintenant, voyons comment prendre en compte les milliers (de 1000 à 999999).

Pour cela, quelques informations :

• Tout d’abord, le mot mille est invariable, nous n’aurons donc pas à gérer son pluriel.
• Ensuite, les milliers se décomposent en deux éléments : un groupe qui va de 1 à 999 (que nous sommes déjà en mesure de gérer à ce niveau du développement de la macro), puis le mot « mille »
• La seule exception à cette règle étant le nombre 1000 qui n’est composé que du mot « mille »

Pour gagner du temps, nous allons copier-coller la portion de code précédent qui permet de gérer les centaines, et remplacer simplement les valeurs :

    If nombre >= 1000 Then
        Dim millier As Integer
        millier = Int(nombre / 1000)
        
        nombre = nombre - millier * 1000
        
        If millier > 1 Then
            chaine = listeNombresLettres(millier)  & " Milles "
        Else
            chaine = "Mille "
        End If
    End If

Nous remplaçons les nombres 100 par 1000, la variable centaine par millier, le mot « Cent » par « Mille » et nous supprimons la gestion du « s » au pluriel.

Pour simplifier, et étant donné que mille est invariable, nous n’avons pas d’effectuer le test qui consiste à regarder si la valeur millier est supérieure à 1.

À la place, nous allons afficher systématiquement le nombre et le pluriel et effectuer la modification juste après :

         chaine = listeNombresLettres(millier)  & " Mille "

Il suffira ensuite de supprimer le « Un Mille » :

          chaine = Replace(chaine, "Un  Mille", "Mille")

Puis, nous modifions l’affectation de la valeur chaine dans la gestion des centaines afin de prendre en compte ce que nous venons d’insérer.

Nous modifions donc la ligne suivante :

            chaine = listeNombresLettres(centaine)  & " Cent"

Par :

            chaine = chaine & listeNombresLettres(centaine)  & " Cent"

Nous devons encore apporter une dernière modification à notre fonction pour être en mesure de calculer les milliers. En effet, en l’état la fonction nous retourne sans problème des valeurs comprises entre 0 et 99999. Mais au-delà, donc à partir de 100000, celle-ci nous retournera une erreur :

Pour corriger cette erreur, il suffit d’aller chercher le nombre de milliers à retourner non plus dans le tableau listeNombresLettres, mais directement dans la propre fonction que nous utilisons !

Si ce concept peut paraître assez complexe à comprendre, il suffit de tester en modifiant la ligne :

chaine = listeNombresLettres(millier) &  " Mille "

Par :

chaine = nombreEnLettres (millier) & "  Mille "

4. Gérer les très grands nombres (millions, milliards)

Ensuite, pour gérer les très grands nombres, c’est-à-dire les millions et les milliards (ainsi que les billions si nous le souhaitons), nous allons simplement partir de ce que nous venons d’insérer (la gestion des milliers) que nous allons adapter.

Pour cela, nous allons créer une nouvelle variable sous forme de tableaux, dans lesquelles nous allons stocker les paramètres à utiliser :

• Tout d’abord le nom de l’unité,
• Puis le nombre correspondant :

    Dim listeGrandsNombres As Variant
    listeGrandsNombres = Array(Array("Milliard",  1000000000), Array("Million", 1000000), Array("Mille",  1000))

De cette manière, il suffira de passer en revue chaque élément de ce tableau avec une boucle For Each dans laquelle nous allons encapsuler la partie qui permet de gérer les milliers :

    Dim grandNombre As Variant
    For Each grandNombre In listeGrandsNombres
        If nombre >= 1000 Then
            Dim millier As Integer
            millier = Int(nombre / 1000)
            
            nombre = nombre - millier * 1000
            
            chaine = nombreEnLettres (millier) &  " Mille "
            chaine = Replace(chaine, "Un Mille",  "Mille")
        End If
    Next

Ensuite, il suffit de remplacer les mots « Mille » par le premier élément (l’index 0) de la variable grandNombre et les nombres 1000 par le second élément (l’index 1) :

    Dim grandNombre As Variant
    For Each grandNombre In listeGrandsNombres
        If nombre >= grandNombre(1) Then
            Dim valeur As Integer
            valeur = Int(nombre / grandNombre(1))
            
            nombre = nombre - valeur * grandNombre(1)
            
            chaine = nombreEnLettres(valeur) & "  " & grandNombre(0) & " "
            chaine = Replace(chaine, "Un Mille",  "Mille")
        End If
    Next

Nous pouvons maintenant inclure la gestion des pluriels en effectuant un test sur la valeur.

Pour cela, nous remplaçons la ligne :

            chaine = nombreEnLettres(valeur) &  " Mille "

Par :

            If valeur > 1 Then
                chaine = nombreEnLettres(valeur) &  " " & grandNombre(0) & "s "
            Else
                chaine = nombreEnLettres(valeur) &  " " & grandNombre(0) & " "
            End If

Sans oublier que « Mille » doit toujours rester au singulier, nous ajoutons à la fin de la boucle :

            chaine = Replace(chaine,  "Milles", "Mille")

Comme nous pouvons le voir ici, parfois une espace s’insère au début de la chaîne de caractères.

Pour nous en débarrasser, nous pouvons utiliser la fonction Trim() au moment de retourner le texte à la fonction :

    nombreEnLettres = trim(chaine)

5. Gérer les décimales

Et voilà, notre fonction est bien avancée, il ne nous reste plus qu’à gérer les nombres placés derrière la virgule.

Pour cela, nous nous plaçons au tout début de la fonction afin de stocker la partie décimale dans une variable :

    Dim partieDecimale As Integer
    partieDecimale = (nombre - Int(nombre)) * 100

Puis, nous ne conservons que la partie entière de la variable nombre :

    nombre = Int(nombre)

Maintenant, nous nous plaçons en bas de la fonction pour ajouter à la chaîne de caractère la lecture de cette partie décimale, à condition bien sûr que cette valeur soit supérieure à zéro :

    If partieDecimale > 0 Then
    
    End If
    
    nombreEnLettres = Trim(chaine)

nous commençons par afficher le terme « Virgule » au nombre :

    If partieDecimale > 0 Then
        chaine = chaine & " Virgule "
    End If

Ensuite, nous regardons si le nombre de la partie décimale est inférieur à 10, dans quel cas nous ajouterons la mention « Zéro » :

        If partieDecimale < 10 Then
            chaine = chaine & " Zéro "
        End If

Et maintenant, il ne reste plus qu’à ajouter la suite du nombre, et sachant que celui-ci sera toujours inférieur à 100, nous pouvons donc le lire dans la table listeNombresLettres :

        chaine = chaine & listeNombresLettres(partieDecimale) 

6. Quelques petits bugs

Pour que notre fonction soit pleinement opérationnelle, il nous reste encore quelques petits bugs à corriger.

Pour commencer, si nous demandons à Excel d’écrire un nombre rond (par exemple 200 ou 2000), celui-ci nous rajoutera automatiquement un « Zéro » à la fin :

Pour corriger ce bug, nous allons simplement contrôler si la chaîne se termine par zéro, sans que celui-ci soit le seul terme :

    If chaine Like "* Zéro" And Trim(chaine)  <> "Zéro" Then
 
    End If

Et dans ce cas-là, nous pourrons supprimer le mot zéro de la chaîne :

        chaine = Replace(chaine, "Zéro",  "")

Le second bug, très léger nous affiche parfois des doubles espaces dans le texte.

Nous allons simplement utiliser la fonction Replace pour les remplacer par des espaces simples :

nombreEnLettres = Trim(replace(chaine, "   ", " "))

Et voilà, la fonction est maintenant terminée, surtout si vous constatez d’autres bugs, n’hésitez pas à m’en faire part pour que je les corrige !

Vous pouvez également télécharger le fichier en utilisant le lien au tout début de cet article, pour obtenir la fonction complète, avec la gestion des monnaies !