Número por Extenso no Excel: Como Escrever Números por Extenso

Como fazer número por extenso? Precisa transformar um número por extenso no Excel? Por exemplo, converter 123 em cento e vinte e três, 1,5 em um real e cinquenta centavos ou 25 em vinte e cinco quilos? Neste artigo você vai aprender como usar a função FEXTENSO, criada em VBA, para fazer isso de forma automática.

A ideia é simples: você informa o valor em uma célula e utiliza a função para gerar o texto por extenso. O mesmo recurso pode ser aplicado a números inteiros, valores monetários, percentuais, números decimais, frações e até unidades personalizadas.

Além de mostrar como instalar a função, vou explicar os principais parâmetros e apresentar exemplos práticos para você entender exatamente quando usar cada configuração. A estrutura foi pensada para servir tanto para quem está começando no Excel quanto para quem já cria planilhas profissionais e precisa gerar contratos, recibos, pedidos, orçamentos, relatórios ou documentos automaticamente.

O objetivo não é apenas mostrar uma fórmula pronta. É entender como a função trabalha para que você consiga adaptá-la às suas próprias planilhas.

Exemplos de número por extenso no Excel

Antes de entrar no código, vale visualizar o que a função consegue fazer. A tabela abaixo reúne exemplos de uso da FEXTENSO com diferentes tipos de dados. Ela também mostra a fórmula utilizada e o resultado esperado.

Observe que a mesma função pode assumir comportamentos diferentes de acordo com os parâmetros informados. Em um caso simples, basta indicar a célula que contém o número. Em outros, podemos definir moeda, unidade, forma de escrita, separação de milhares e capitalização do resultado.

Esse é um dos pontos mais interessantes da função: você não precisa criar uma fórmula diferente para cada situação. A estrutura principal permanece a mesma e os parâmetros determinam como o número será escrito.

O que é a função FEXTENSO?

A FEXTENSO é uma função personalizada de planilha desenvolvida em VBA (Visual Basic for Applications). Diferentemente das funções nativas do Excel, ela foi criada para atender a uma necessidade específica: transformar valores numéricos em texto por extenso.

Funções personalizadas em VBA podem ser utilizadas diretamente nas células da planilha, da mesma forma que outras funções. A Microsoft documenta esse recurso como uma forma de criar funções próprias quando as funções nativas não atendem a uma necessidade específica. citeturn0search0

Na prática, isso significa que, depois de instalar o código em um módulo VBA, você pode escrever algo como =FEXTENSO(B2) em uma célula e obter o texto correspondente ao número armazenado em B2.

Isso é especialmente útil em documentos que precisam apresentar o valor de duas maneiras: numericamente e por extenso. Um orçamento pode mostrar R$ 4.350,29 e também quatro mil trezentos e cinquenta reais e vinte e nove centavos. Um recibo pode apresentar o valor numérico e sua descrição por extenso. Uma planilha de contratos pode gerar textos automaticamente a partir dos valores cadastrados.

Como instalar a função para número por extenso no Excel

Como a função foi criada em VBA, é necessário inserir o código em um módulo do VBA da pasta de trabalho. A própria Microsoft orienta o uso do Editor do Visual Basic e a criação de um novo módulo para funções personalizadas. citeturn0search0

A recomendação é colocar o código na própria planilha que utiliza a função quando ela for distribuída como arquivo independente. Dessa forma, a pasta de trabalho leva consigo a função necessária para calcular os resultados.

Para instalar, siga estes passos:

1. Habilite a guia Desenvolvedor. Clique com o botão direito sobre qualquer área da Faixa de Opções do Excel e escolha Personalizar a Faixa de Opções. Ative a opção Desenvolvedor.

   

2. Na guia Desenvolvedor, clique em Visual Basic ou pressione Alt+F11 para abrir o Editor do Visual Basic.

3. No Editor do Visual Basic, clique em Inserir > Módulo. Será criado um módulo de código dentro do projeto da pasta de trabalho.

4. No módulo criado, cole o código abaixo.

Função VBA para colocar número por extenso no Excel

Cole este código no módulo criado na etapa anterior:

Function fExtenso(Num As Double, Optional FraçTipo As Integer, Optional UndNomeSing As String, _
        Optional UndNomePlur As String, Optional UndMasc As Boolean = True, _
        Optional UmMil As Boolean = True, Optional VirgEntrMilh As Boolean = False, _
        Optional CaixaAlta As Long = 1) As String
    Dim ExtensInt As String
    Dim ExtensFrac As String
    Dim UndNome As String
    Dim FracNome As String
    Dim Signif As Long
    Dim NumText As String
 
    If Num > 999999999999.99 Or Num < 0 Then
        fExtenso = "Erro! (Valores válidos: >=0 e < 1 trilhão)"
        Exit Function
    End If
 
    'Preparando nome da unidade, singular e plural
    If UndNomePlur = "" Then UndNomePlur = IIf(UndNomeSing = "", "", Pluralizar(UndNomeSing))
    'Se a função Pluralizar falhar palavras estrangeiras ou em exceções portuguesas, o argumento UndNomePlur pode ser usado.
 
    'Extenso parte inteira
    ExtensInt = fExtensoInt(Int(CDec(Num)), UndMasc, UmMil, VirgEntrMilh)
 
    'Extenso parte fracionária
    If FraçTipo = 0 And UndNomeSing = "" Then FraçTipo = 3
    If FraçTipo = 0 And UndNomeSing <> "" Then FraçTipo = 1
    Select Case FraçTipo
    Case 1, 5   'Lê fração em centavos ou cêntimos. Ideal para Moeda
        Num = Format(Num, "0.00") * 1   'Round(Num,2)
        ExtensFrac = fExtensoInt((Num - Int(CDec(Num))) * 100, True, UmMil, VirgEntrMilh)
        If ExtensInt = "" And ExtensFrac = "" Then ExtensInt = "zero"
 
        'Nome da unidade no singular ou plural
        UndNome = IIf(Num < 1, IIf(Num = 0, " " & UndNomePlur, ""), IIf(UndNomeSing = "" Or Right(ExtensInt, 1) = " ", "", " ") & IIf(Int(CDec(Num)) = 1, UndNomeSing, UndNomePlur) & IIf(Num = Int(CDec(Num)), "", " e "))
        'Nome da fração no singular ou plural
        FracNome = IIf(Num = Int(CDec(Num)), "", IIf(Int(CDec(Num * 100)) - Int(CDec(Num)) * 100 = 1, IIf(FraçTipo = 5, " cêntimo", " centavo"), IIf(FraçTipo = 5, " cêntimos", " centavos")))
 
        fExtenso = ExtensInt & UndNome & ExtensFrac & FracNome
 
    Case 2    'Lê a vírgula decimal, cada zero e o número restante como inteiro. Ideal para percentual.
        ExtensFrac = Num - Int(CDec(Num))
        If ExtensFrac = 0 Then
            fExtenso = ExtensInt
        Else
            ExtensFrac = Format(ExtensFrac, "0.############")
            ExtensFrac = Mid(ExtensFrac, 3, 15)
            fExtenso = IIf(ExtensInt = "", "zero", ExtensInt) & " vírgula"
            Do While Left(ExtensFrac, 1) = "0"
                fExtenso = fExtenso & " zero"
                ExtensFrac = Mid(ExtensFrac, 2, 15)
            Loop
            fExtenso = fExtenso & " " & fExtensoInt(ExtensFrac * 1, UndMasc, UmMil, VirgEntrMilh)
        End If
 
        If fExtenso = "" Then fExtenso = "zero"
 
        fExtenso = fExtenso & IIf(UndNomeSing <> "", " ", "") & IIf(Num = 1, UndNomeSing, UndNomePlur)
 
    Case 3    'Lê a fração de décimo a bilionésimo. Ideal para número puro.
        ExtensFrac = Num - Int(CDec(Num))
        If ExtensFrac = 0 Then
            ExtensFrac = ""
        Else
            ExtensFrac = Format(ExtensFrac, "0.############")
            Signif = Len(ExtensFrac) - 2
            If Signif > 3 And Signif <> 6 And Signif <> 9 And Signif <> 12 Then Signif = Int(CDec(Signif / 3)) * 3 + 3
            If Signif > 0 Then
                ExtensFrac = Format(ExtensFrac, "0.000000000000")
                ExtensFrac = fExtensoInt(Mid(ExtensFrac, 3, Signif) * 1, True, UmMil, VirgEntrMilh)
                FracNome = Choose(Signif, "décimo", "centésimo", "milésimo", , , "milionésimo", , , "bilionésimo", , , "trilionésimo")
                FracNome = " " & FracNome & IIf(ExtensFrac = "um", "", "s")
            Else
                ExtensFrac = ""
            End If
        End If
 
        If ExtensInt = "" And ExtensFrac = "" Then ExtensInt = "zero"
 
        If UndNomeSing = "" Then
            fExtenso = ExtensInt & IIf(ExtensInt <> "" And ExtensFrac <> "", ", e ", "") & ExtensFrac & FracNome
        Else
            'Nome da unidade no singular ou plural
            UndNome = IIf(Num < 1, IIf(Num = 0, " " & UndNomePlur, ""), IIf(UndNomeSing = "" Or Right(ExtensInt, 1) = " ", "", " ") & IIf(Int(CDec(Num)) = 1, UndNomeSing, UndNomePlur) & IIf(Num = Int(CDec(Num)), "", " e "))
            'Nome da fração no singular ou plural
            FracNome = IIf(Num = Int(CDec(Num)), "", FracNome & " de " & UndNomeSing)
 
            fExtenso = ExtensInt & UndNome & ExtensFrac & FracNome
        End If
 
    Case 4    'Não lê a fração mas escreve como fração com um denominador de 100, 1000, 1000000... Ideal para moeda com fração de milésimo
        ExtensFrac = Num - Int(CDec(Num))
        If ExtensFrac = 0 Then
            ExtensFrac = "nenhum/100"
        Else
            ExtensFrac = Format(ExtensFrac, "0.############")
            Signif = Len(ExtensFrac) - 2
            If Signif > 3 And Signif <> 6 And Signif <> 9 And Signif <> 12 Then Signif = Int(CDec(Signif / 3)) * 3 + 3
            If Signif > 1 Then
                ExtensFrac = (Num - Int(CDec(Num))) * 10 ^ Signif
                ExtensFrac = ExtensFrac & "/" & 10 ^ Signif
            Else
                ExtensFrac = (Num - Int(CDec(Num))) * 10 ^ 2
                ExtensFrac = ExtensFrac & "/100"
            End If
        End If
 
        If ExtensInt = "" Then ExtensInt = "zero"
 
        'Nome da unidade no singular ou plural
        UndNome = IIf(Int(CDec(Num)) = 1, UndNomeSing, UndNomePlur)
 
        fExtenso = ExtensInt & " " & UndNome & " e " & ExtensFrac
    End Select
 
    Select Case CaixaAlta
    Case 1
        fExtenso = LCase(fExtenso)
    Case 2
        fExtenso = UCase(Left(fExtenso, 1)) & Mid(fExtenso, 2)
    Case 3
        fExtenso = StrConv(fExtenso, vbProperCase)
        fExtenso = MyReplace(fExtenso, " E ", " e ")
    Case 4
        fExtenso = StrConv(fExtenso, vbUpperCase)
    End Select
 
    'Preservar caixa alta de letra antes de ponto em UndNome
    Dim lPos As Long
    Dim lPos1 As Long
    Do While InStr(lPos + 1, UndNome, ".") > 1
        lPos = InStr(lPos + 1, UndNome, ".")
        lPos1 = InStr(lPos1 + 1, fExtenso, ".")
        fExtenso = Left(fExtenso, lPos1 - 2) & Mid(UndNome, lPos - 1, 1) & Mid(fExtenso, lPos1)
    Loop
End Function
 
Private Function fExtensoInt(Num As Double, UndMasc As Boolean, UmMil As Boolean, VirgEntrMilh As Boolean) As String
'Gramática portuguesa:
'Regra Geral: Não se intercala a conjunção 'e' e nem vírgula entre posições de milhar.
'Exceção: Se a milhar posterior for menor que 100 ou for centena inteira (100,200,300...)
'Alguns gramáticos não aceitam essa exceção e outros já aceitam a vírgula.
'A variável ConjExc ativa/desativa a exceção
'A variável VirgEntrMilh usa vírgula entre milhares
 
   Dim NumText As String
   Dim Ce As String
   Dim Ma As String
   Dim Mõ As String
   Dim Bi As String
   Dim f As String
   Dim ConjExc As Boolean
   ConjExc = True
   If VirgEntrMilh Then ConjExc = False
 
   If Num = 0 Then
      fExtensoInt = ""
      Exit Function
   End If
 
   NumText = Format(Num, "000,000,000,000")
 
   '1º Posição de milhar, Centenas
   Ce = Mid(NumText, 13, 3)
   '2º Posição de milhar, Milhares
   Ma = Mid(NumText, 9, 3)
   '3º Posição de milhar, Milhões
   Mõ = Mid(NumText, 5, 3)
   '4º Posição de milhar, Bilhões
   Bi = Mid(NumText, 1, 3)
 
   f = fMilharText(Bi, UndMasc) & IIf(Bi > 0, IIf(Bi > 1, " bilhões", " bilhão"), "")
 
   f = f & IIf(VirgEntrMilh And Bi > 0 And Mõ > 0, ", ", IIf(Bi > 0 And Mõ > 0, " ", ""))
   f = f & IIf(ConjExc And Bi > 0 And Mõ > 0 And (Mõ < 100 Or Right(Mõ, 2) = "00"), "e ", "")
 
   f = f & fMilharText(Mõ, UndMasc) & IIf(Mõ > 0, IIf(Mõ > 1, " milhões", " milhão"), "")
 
   f = f & IIf(VirgEntrMilh And Bi + Mõ > 0 And Ma > 0, ", ", IIf(Bi + Mõ > 0 And Ma > 0, " ", ""))
   f = f & IIf(ConjExc And Bi + Mõ > 0 And Ma > 0 And (Ma < 100 Or Right(Ma, 2) = "00"), "e ", "")
 
   f = f & fMilharText(Ma, UndMasc) & IIf(Ma > 0, IIf(Ma > 1, " mil", " mil"), "")
   If Not UmMil Then If f = "um mil" Then f = "mil"  'Omitir 'um' em 'um mil'
 
   f = f & IIf(VirgEntrMilh And Bi + Mõ + Ma > 0 And Ce > 0, ", ", IIf(Bi + Mõ + Ma > 0 And Ce > 0, " ", ""))
   f = f & IIf(ConjExc And Bi + Mõ + Ma > 0 And Ce > 0 And (Ce < 100 Or Right(Ce, 2) = "00"), "e ", "")
 
   f = f & fMilharText(Ce, UndMasc) & IIf(Ce > 0, ",", "")
 
   f = IIf(Right(f, 1) = ",", Mid(f, 1, Len(f) - 1), f)
   f = IIf(Right(f, 2) = "ão", f & " de", f)
   f = IIf(Right(f, 3) = "ões", f & " de", f)
   fExtensoInt = f
End Function
 
Private Function fMilharText(NumText As String, UndMasc As Boolean)
'Gramática portuguesa:
'Regra Geral: Intercala-se a conjunção 'e' entre centenas, dezenas e unidades
 
   Dim UndText As String
   Dim DezenaText As String
   Dim CentenaText As String
   Const ConjDez_Un = " e "   'Conjunção entre Dezena e Unidade
   Const ConjCen_Dez = " e "   'Conjunção entre Centena e Unidade
 
   '  Unidade texto
   If Mid(NumText, 2, 1) <> "1" Then
      UndText = Choose(Mid(NumText, 3, 1) + 1, "", IIf(UndMasc, "um", "uma"), _
            IIf(UndMasc, "dois", "duas"), "três", "quatro", "cinco", "seis", _
            "sete", "oito", "nove")
   Else
      UndText = ""
   End If
 
   'Dezena texto
   If Mid(NumText, 2, 1) <> "1" Then
      DezenaText = Choose(Mid(NumText, 2, 1) + 1, "", "dez", "vinte", _
            "trinta", "quarenta", "cinqüenta", "sessenta", "setenta", _
            "oitenta", "noventa")
   Else
      DezenaText = Choose(Mid(NumText, 3, 1) + 1, "dez", "onze", _
            "doze", "treze", "quatorze", "quinze", "dezesseis", _
            "dezessete", "dezoito", "dezenove")
   End If
 
   'Centena texto
   If UndMasc Then
      CentenaText = Choose(Mid(NumText, 1, 1) + 1, "", "cento", "duzentos", _
            "trezentos", "quatrocentos", "quinhentos", "seiscentos", _
            "setecentos", "oitocentos", "novecentos")
   Else
      CentenaText = Choose(Mid(NumText, 1, 1) + 1, "", "cento", "duzentas", _
            "trezentas", "quatrocentas", "quinhentas", "seiscentas", _
            "setecentas", "oitocentas", "novecentas")
   End If
   If Mid(NumText, 1, 1) = "1" And Mid(NumText, 2, 2) = "00" Then CentenaText = "cem"
 
   'Milhar texto
   fMilharText = CentenaText & IIf(Mid(NumText, 2, 2) * 1 > 0 And CentenaText <> "", ConjCen_Dez, "") _
         & DezenaText & IIf(Mid(NumText, 2, 2) * 1 <= 19 Or Right(NumText, 1) = "0", "", ConjDez_Un) _
         & UndText
End Function
 
Function Pluralizar(Sing As String) As String
   Dim e As String
  
   Dim IsLCase As Boolean
  
   IsLCase = Right(Sing, 1) = LCase(Right(Sing, 1))
  
   'Regra geral:
   Pluralizar = IIf(Sing = "", "", Sing & IIf(IsLCase, "s", "S"))
 
   'Exceções: (Quase todas)
   ' Nomes terminados em al, el, ol, ul, il
   e = LCase(Right(Sing, 2))
   If e = "al" Or e = "el" Or e = "ol" Or e = "ul" Or e = "il" Then Pluralizar = Left(Sing, Len(Sing) - 1) & IIf(IsLCase, "is", "IS")
   'Nomes terminados em il
   If e = "il" Then Pluralizar = Left(Sing, Len(Sing) - 2) & IIf(IsLCase, "is", "IS")
   ' Nomes terminados em r, s, z
   e = LCase(Right(Sing, 1))
   If e = "r" Or e = "s" Or e = "z" Then Pluralizar = Sing & IIf(IsLCase, "es", "ES")
   ' Nomes terminados em m
   If e = "m" Then Pluralizar = Left(Sing, Len(Sing) - 1) & IIf(IsLCase, "ns", "NS")
   ' Nomes terminados em x
   If e = "x" Then Pluralizar = Sing
End Function
 
Private Function MyReplace(vText As String, vTxtFind As String, vTxtRep As String)
'Word 6.0 VBA doesn't have Replace function
    Dim lPos As Long
    lPos = 1 - Len(vTxtRep)
vStart:
    lPos = InStr(lPos + Len(vTxtRep), vText, vTxtFind)
    If lPos = 0 Or vTxtFind = "" Then
        MyReplace = vText
        Exit Function
    End If
    vText = Left(vText, lPos - 1) & vTxtRep & Right(vText, Len(vText) - lPos - Len(vTxtFind) + 1)
    GoTo vStart
End Function

Como usar a FEXTENSO na planilha

Depois de inserir o código, volte para a planilha. A função passa a poder ser utilizada em uma célula como qualquer outra função de Excel.

O uso mais simples é informar apenas a referência da célula que contém o número:

=FEXTENSO(B2)

Se B2 contiver o número 123, o resultado será cento e vinte e três.

Esse modelo é ideal quando você precisa apenas do número escrito por extenso e não quer acrescentar moeda, unidade, fração ou outra configuração.

Entenda os parâmetros da função FEXTENSO

A função possui vários parâmetros opcionais. Isso permite controlar o modo como o número será convertido. A estrutura da função é:

fExtenso(Num As Double, Optional FraçTipo As Integer, Optional UndNomeSing As String, _
Optional UndNomePlur As String, Optional UndMasc As Boolean = True, _
Optional UmMil As Boolean = True, Optional VirgEntrMilh As Boolean = False, _
Optional CaixaAlta As Long = 1)

O primeiro argumento, Num, é o número que será convertido. É o único argumento essencial para o uso básico da função. Os demais permitem personalizar o resultado.

1. Num — número a ser convertido

O argumento Num recebe o valor que você deseja escrever por extenso. Normalmente, você vai informar uma referência de célula.

Exemplo:

=FEXTENSO(B2)

Se B2 tiver 1.250, o resultado será um mil duzentos e cinquenta.

2. FraçTipo — tipo de tratamento do número

O parâmetro FraçTipo controla como a parte decimal será tratada. Nos exemplos apresentados, ele é utilizado para trabalhar com moeda, percentual, decimal e fração.

Para moeda, por exemplo, usamos:

=FEXTENSO(B5;1;"real";"reais")

Com B5 contendo 123,50, a função gera o texto correspondente ao valor monetário. Para percentuais, o exemplo utiliza 2; para números decimais, 3; e para frações, 4.

O importante é não decorar apenas o número do parâmetro. Entenda o cenário em que ele será utilizado e confira o resultado na sua planilha.

3. UndNomeSing e UndNomePlur — unidade personalizada

Esses dois argumentos permitem informar uma unidade própria para o número. O primeiro representa a forma singular e o segundo, a forma plural.

Por exemplo:

=FEXTENSO(B12;1;"quilo";"quilos")

Para o valor 25, o resultado será vinte e cinco quilos. Já para o valor 1, o resultado será um quilo.

Essa possibilidade amplia bastante o uso da função. Você pode trabalhar com unidades como quilo, tonelada, metro, unidade, caixa, peça, litro e outras palavras que façam sentido no documento.

4. UndMasc — gênero da unidade

O argumento UndMasc define o tratamento de palavras masculinas ou femininas. Isso é importante porque o número 1 pode resultar em um ou uma, e o número 2 pode resultar em dois ou duas, dependendo da unidade.

Esse parâmetro ajuda a deixar o texto gramaticalmente adequado quando a função é usada com unidades personalizadas.

5. UmMil — tratamento de 1.000

O parâmetro UmMil controla o comportamento utilizado para o número 1.000. Esse detalhe pode parecer pequeno, mas é importante em textos gerados automaticamente, porque você pode precisar adequar a forma como o milhar aparece de acordo com o padrão adotado pela sua aplicação.

Quando estiver criando uma planilha profissional, vale testar números de fronteira, como 999, 1.000, 1.001, 1.100 e 1.250, para verificar se o resultado atende ao padrão que você precisa.

6. VirgEntrMilh — separação entre milhões e milhares

O argumento VirgEntrMilh interfere na forma como a função trata a separação entre grandes grupos numéricos. Ele é útil principalmente quando a planilha trabalha com valores mais altos e você deseja controlar a construção do texto.

Assim como acontece com os outros parâmetros opcionais, o ideal é validar o resultado com alguns valores reais da sua aplicação antes de distribuir a planilha.

7. CaixaAlta — maiúsculas e capitalização

O argumento CaixaAlta permite controlar a capitalização do texto retornado. Na tabela de exemplos, o valor 2 é utilizado para gerar a primeira letra em maiúscula e o valor 4 para gerar todo o texto em letras maiúsculas.

Isso é útil em documentos nos quais o padrão visual já está definido. Em contratos e recibos, por exemplo, é comum encontrar valores escritos totalmente em maiúsculas.

Número por extenso com moeda

Um dos usos mais comuns é escrever valores financeiros por extenso. Para isso, você pode informar os nomes da unidade monetária no terceiro e no quarto argumentos.

Considere uma célula A1 com o valor 4.350,29. Para escrever o valor em reais por extenso, usamos:

=FEXTENSO(A1;;"Real";"Reais";;;;0)

O resultado será:

QUATRO MIL TREZENTOS E CINQÜENTA REAIS E VINTE E NOVE CENTAVOS

Esse tipo de aplicação é muito útil em recibos, pedidos, propostas comerciais, contratos e documentos financeiros gerados a partir de uma planilha.

Número por extenso para percentual

A função também pode ser utilizada para transformar números percentuais em texto. Na tabela de exemplos, o valor 12,5 é convertido em doze vírgula cinco com o parâmetro correspondente.

Exemplo:

=FEXTENSO(B7;2)

Esse recurso pode ser interessante em relatórios, textos automáticos e documentos nos quais o percentual precisa aparecer de forma textual.

Número decimal por extenso

Quando o objetivo é escrever a parte decimal como décimos ou centésimos, utilize o parâmetro indicado para números decimais.

Por exemplo:

=FEXTENSO(B9;3)

Com o valor 12,5, o resultado apresentado é doze, e cinco décimos. Para 0,25, o exemplo utiliza a mesma configuração e produz vinte e cinco centésimos.

Esse formato pode ser útil em documentos técnicos, educacionais e situações em que a representação decimal precisa ser explicada por extenso.

Como escrever uma fração por extenso

Outro exemplo interessante é o tratamento de frações. Na tabela, o valor 12,5 é utilizado com FraçTipo = 4, produzindo uma representação no formato doze e 50/100.

Essa possibilidade pode ser aproveitada em planilhas de medidas, documentos técnicos ou aplicações específicas nas quais a parte fracionária precisa ser apresentada de maneira diferente do formato decimal tradicional.

Como usar unidades personalizadas

Se você trabalha com quantidade de produtos, materiais ou serviços, não precisa limitar a função a valores monetários. É possível associar uma unidade personalizada ao resultado.

Exemplo:

=FEXTENSO(B12;1;"quilo";"quilos")

Com 25 na célula B12, o resultado será vinte e cinco quilos.

Para 1:

=FEXTENSO(B13;1;"quilo";"quilos")

O resultado será um quilo.

Essa estrutura é especialmente interessante para planilhas de estoque, produção, logística, compras e controle de materiais.

Como deixar o resultado com a primeira letra maiúscula

Nem sempre você vai querer o texto todo em letras minúsculas. Em alguns documentos, o padrão visual exige que apenas a primeira letra seja maiúscula.

Na tabela, o exemplo usa:

=FEXTENSO(B14;;;;;;2)

Com o número 123, o resultado é Cento e vinte e três.

Esse formato costuma ficar mais natural em frases e textos corridos.

Como deixar o número por extenso em letras maiúsculas

Para documentos formais, pode ser interessante gerar todo o texto em caixa alta.

O exemplo da tabela utiliza:

=FEXTENSO(B15;;;;;;4)

O resultado é CENTO E VINTE E TRÊS.

Além disso, depois de gerar o texto, você pode combiná-lo com outras funções de texto do Excel quando precisar fazer um tratamento adicional.

Erros comuns ao usar número por extenso no Excel

Se a função não funcionar, não comece alterando o código. Primeiro verifique a instalação e a estrutura da pasta de trabalho.

• O código não foi colocado em um módulo: a função precisa estar em um módulo VBA apropriado para ser chamada pela planilha.

• As macros estão bloqueadas: como a função utiliza VBA, as configurações de segurança do arquivo precisam permitir a execução do código.

• A função foi digitada com nome diferente: utilize exatamente FEXTENSO.

• Separador de argumentos incorreto: no Excel configurado para português do Brasil, normalmente utilizamos ; para separar os argumentos.

• Resultado diferente do esperado: teste primeiro com números simples, como 1, 10, 100, 999, 1.000 e 1.250, antes de testar valores complexos.

Como testar a função de forma profissional

Se você pretende utilizar a FEXTENSO em uma planilha que será entregue a clientes, recomendo criar uma pequena área de testes. Coloque os números na coluna B e a fórmula na coluna C. Dessa forma, você consegue testar várias situações sem alterar a estrutura principal da planilha.

Inclua pelo menos estes cenários: números inteiros, valores com duas casas decimais, valores próximos de 1.000, números com milhões, valor zero, unidade singular, unidade plural, percentual, decimal e diferentes opções de capitalização.

Esse cuidado é importante porque funções personalizadas fazem parte da lógica da planilha. Quanto mais situações você testar antes de entregar o arquivo, menor será a chance de encontrar um comportamento inesperado durante o uso real.

FEXTENSO ou uma fórmula nativa do Excel?

A FEXTENSO deste artigo é uma função personalizada em VBA. Portanto, ela é diferente das funções nativas do Excel. O VBA é uma alternativa muito útil quando você precisa encapsular uma lógica mais extensa em uma função reutilizável.

Em versões atuais do Excel, também existe a função LAMBDA, que permite criar funções personalizadas reutilizáveis sem VBA em cenários compatíveis. A Microsoft informa que LAMBDA pode transformar uma fórmula em uma função com nome próprio e não exige VBA, macros ou JavaScript. citeturn0search4

Isso não significa que uma solução substitua automaticamente a outra. A FEXTENSO apresentada aqui já possui uma lógica específica para conversão de números em texto e pode ser útil em arquivos que já utilizam VBA. Se você estiver desenvolvendo uma solução nova, vale avaliar qual tecnologia atende melhor ao seu cenário.

Onde usar número por extenso em uma planilha?

Depois que você entende a função, fica fácil enxergar várias aplicações práticas. Alguns exemplos são:

• recibos e comprovantes;

• orçamentos e propostas comerciais;

• pedidos de venda;

• contratos gerados pelo Excel;

• relatórios financeiros;

• documentos de compras;

• planilhas de estoque e produção;

• controle de quantidades e medidas;

• fichas de produtos;

• documentos administrativos.

Em todos esses casos, a vantagem é evitar a digitação manual. O número continua sendo armazenado como número, podendo participar de cálculos, e o texto por extenso é gerado automaticamente em outra célula.

Uma dica importante para planilhas profissionais

Evite digitar manualmente o texto por extenso ao lado do valor. Se o número mudar, o texto ficará desatualizado. A melhor abordagem é manter o valor como número em uma célula e gerar o texto por meio da função.

Por exemplo, imagine uma planilha de pedidos em que B2 contém o valor total. Em outra célula, você pode usar =FEXTENSO(B2;1;"real";"reais"). Quando o total mudar, o texto será recalculado junto com a planilha.

Essa separação entre dado e apresentação é uma prática importante na construção de planilhas profissionais. O número deve continuar disponível para cálculos, filtros e análises, enquanto o texto serve para apresentação e documentação.

Perguntas frequentes sobre número por extenso no Excel

É possível colocar número por extenso automaticamente no Excel?

Sim. Com uma função personalizada como a FEXTENSO, o valor de uma célula pode ser convertido automaticamente em texto por extenso.

A função FEXTENSO é uma função nativa do Excel?

Não. Ela é uma função personalizada desenvolvida em VBA. Depois de inserir o código no módulo da pasta de trabalho, ela pode ser chamada pela planilha como uma função.

Posso usar a FEXTENSO para reais?

Sim. A função possui parâmetros para informar a unidade monetária no singular e no plural, permitindo gerar valores como reais e centavos.

Posso usar outras unidades além de reais?

Sim. A função permite informar uma unidade personalizada, como quilo e quilos, conforme os parâmetros utilizados.

Preciso instalar alguma extensão para usar a função?

Não é necessário instalar uma extensão específica para utilizar o código apresentado. A função é inserida no VBA da pasta de trabalho. Para funções personalizadas em VBA, a Microsoft orienta a criação do código no Editor do Visual Basic e seu uso na própria planilha. citeturn0search0

Posso colocar o resultado em maiúsculas?

Sim. O parâmetro CaixaAlta permite controlar a capitalização, incluindo o formato em letras maiúsculas apresentado nos exemplos deste artigo.

Conclusão: número por extenso no Excel sem digitação manual

Transformar números em texto por extenso no Excel pode parecer uma tarefa simples, mas ganha bastante valor quando o resultado precisa ser utilizado em documentos profissionais. Com a FEXTENSO, você consegue automatizar essa conversão e ainda controlar moeda, unidades, decimais, frações e capitalização.

O ponto principal é entender que o número original continua sendo um valor numérico. A função cria uma representação textual desse valor, permitindo que você use o resultado em recibos, pedidos, contratos, orçamentos e relatórios sem precisar digitar o texto manualmente.

Se você está começando, faça primeiro o teste mais simples com =FEXTENSO(B2). Depois avance para moeda, unidades personalizadas, percentuais, decimais e opções de caixa alta. A tabela de exemplos deste artigo é um bom ponto de partida para testar cada possibilidade.

O código completo está disponível acima. Depois de inserir o código no módulo VBA, salve a pasta de trabalho em um formato que preserve as macros, como .xlsm, quando o arquivo precisar manter o VBA.

Download da planilha de exemplo

Realize o download do arquivo no formulário.

Resumo: para escrever número por extenso no Excel, instale a função FEXTENSO em um módulo VBA e utilize a referência da célula como primeiro argumento. A partir daí, você pode configurar moeda, unidade, decimal, fração e capitalização conforme a necessidade da sua planilha.