Esta função converte um valor numérico (em reais e centavos) para sua representação por extenso em português, formatando-o corretamente para valores em trilhões, bilhões, milhões, milhares, reais e centavos.
As Vantagens de Usar uma Função do Power Query para Converter Números em Texto com Dólares
Ao trabalhar com dados financeiros em ferramentas como Power BI ou Excel, apresentar números em um formato legível e escrito pode melhorar significativamente relatórios e a experiência do usuário. A função em Power Query (M) foi aprimorada, oferecendo uma solução robusta para converter valores numéricos em sua forma escrita em Reais, em português do Brasil e em inglês para dólares americanos (por exemplo, 1234.56 se torna "one thousand two hundred thirty-four dollars and fifty-six cents"). Este artigo explora as principais vantagens de usar essa função, tornando-a uma ferramenta valiosa para analistas de dados, contadores e profissionais de negócios que buscam automação e precisão.
1. Maior Legibilidade em Relatórios Financeiros
Uma das principais vantagens dessa função é sua capacidade de transformar números brutos em um formato amigável para humanos. Em relatórios financeiros, onde a clareza é essencial, converter valores em texto por extenso garante que stakeholders — sejam clientes, gestores ou auditores — possam interpretar os valores rapidamente sem erros de leitura. Ao integrar essa função do Power Query ao seu fluxo de trabalho, você automatiza o processo, elimina falhas manuais e economiza tempo, produzindo documentos profissionais como faturas ou balanços otimizados para legibilidade.
2. Suporte Dinâmico para Números Grandes
Diferente de scripts simples com limites fixos, essa função lida dinamicamente com números de qualquer tamanho, desde valores pequenos como 5,25 até cifras enormes como 1 trilhão. Sua abordagem com List.Accumulate e classes predefinidas (trilhões, bilhões, milhões, milhares) garante escalabilidade, sendo ideal para empresas que trabalham com diferentes escalas financeiras. Essa flexibilidade é revolucionária para setores como bancos ou investimentos, onde grandes quantias em dólares são comuns e a precisão na representação escrita é imprescindível.
3. Tratamento Robusto de Erros para Resultados Confiáveis
A integridade dos dados é crucial em aplicações financeiras, e essa função se destaca com seu tratamento de erros integrado. Ela rejeita números negativos e entradas não numéricas com mensagens claras (ex.: "Negative numbers are not supported"), evitando resultados incorretos que poderiam comprometer análises ou relatórios. Para usuários buscando "conversão de números para texto no Power Query" ou "ferramentas confiáveis para dados financeiros", esse recurso aumenta a confiança, garantindo saídas consistentes e precisas.
4. Integração Perfeita com Power BI e Excel
Desenvolvida em Power Query (M), essa função se integra facilmente ao Power BI e ao Excel, duas das ferramentas mais usadas para análise e visualização de dados. Ao incorporá-la ao seu pipeline de transformação de dados, você pode automatizar a conversão de valores em dólares diretamente nos seus fluxos de trabalho, aumentando a eficiência. Essa compatibilidade a torna uma escolha ideal para profissionais pesquisando "ferramentas de relatórios financeiros no Power BI" ou "scripts de automação no Excel".
5. Apresentação Profissional em Inglês com Dólares
Para mercados de língua inglesa, especialmente nos EUA, a saída da função em inglês correto (ex.: "twenty-five dollars and ten cents") está alinhada com práticas padrão de documentação financeira. Isso é particularmente vantajoso para criar documentos legalmente conformes, como contratos ou cheques, onde valores em dólares escritos são exigidos. Seu foco otimizado para "converter números para texto em dólares" ou "conversão de texto financeiro em inglês" atende às necessidades de usuários voltados a padrões empresariais americanos.
6. Economia de Tempo com Automação e Escalabilidade
A conversão manual de números para texto é demorada e propensa a erros, especialmente com grandes conjuntos de dados. Essa função automatiza a tarefa, permitindo processar milhares de registros instantaneamente no Power Query. Seu design modular — com funções auxiliares como ConvertHundreds — também facilita a manutenção ou expansão para outras moedas, oferecendo escalabilidade para necessidades futuras. Para quem busca "automatizar conversão de valores em dólares", essa ferramenta proporciona eficiência e adaptabilidade incomparáveis.
7. Uso Gratuito e Aberto com Atribuição Adequada
Por fim, a política de uso aberto da função (com crédito a Edney Franklin Siqueira) a torna uma solução econômica para indivíduos e organizações. Você pode implementá-la sem custos de licenciamento, desde que reconheça o desenvolvedor original, mesmo após a refatoração que realizei, seguindo práticas éticas de codificação. Essa acessibilidade, combinada com seus recursos poderosos, a posiciona como uma opção destacada para quem pesquisa "scripts gratuitos para Power Query" ou "ferramentas financeiras open-source", agregando valor sem comprometer o orçamento.
Autores:
- Desenvolvida com o objetivo de ser utilizada em contextos onde a conversão de valores monetários é necessária para apresentação formal (como documentos financeiros).
Funcionalidade:
Recebe um valor numérico e o converte para extenso, incluindo as divisões de trilhões, bilhões, milhões, milhares, reais e centavos, adequando o plural ou singular conforme necessário.
- Exemplo de valor de entrada: 1523.45
- Exemplo de saída: "mil quinhentos e vinte e três reais e quarenta e cinco centavos"
Redução de Redundância:
Condições repetitivas foram encapsuladas em funções auxiliares para melhorar a legibilidade e a manutenibilidade.
Uso de Funções Auxiliares:
Funções auxiliares para a formatação de centenas, dezenas e unidades foram criadas para reduzir a repetição de código.
Melhoria na Estrutura de Condições:
As condições foram reestruturadas para melhorar a lógica e evitar repetições desnecessárias.
Simplificação de Cálculos:
Cálculos para os valores de trilhões, bilhões, milhões, etc., foram otimizados.
Comentários Detalhados:
Adição de comentários detalhados para facilitar a compreensão e manutenção do código.
Versão de inspiração
(valor as number) =>
let
url = "https://www.4devs.com.br/ferramentas_online.php",
Source =
Text.FromBinary(Web.Contents(url, [Headers=[#"Content-Type"="application/x-www-form-urlencoded;charset=UTF-8"], Content=Text.ToBinary("acao=escrever_extenso&unidade=R&txt_valor=" & Text.From(valor) & "&tipo_letra=pr")]))
in
Source
Versão Original
/*Função criada por Edney Franklin Siqueira e pode ser utilizada desde que citado o desenvolvedor.*/(valor as number) => let// Define listas de palavras para números de 0 a 20, dezenas de 20 a 90 e centenas de 100 a 900ext_0a20 = {"", " um ", " dois ", " três ", " quatro ", " cinco ", " seis ", " sete ", " oito ", " nove ", " dez ", " onze ", " doze ", " treze ", " quatorze ", " quinze ", " dezesseis ", " dezessete ", " dezoito ", " dezenove ", " vinte "},ext_20a90 = { " vinte ", " trinta ", " quarenta ", " cinquenta ", " sessenta ", " setenta ", " oitenta ", " noventa "},ext_100a900 = {"", " cento ", " duzentos ", " trezentos ", " quatrocentos ", " quinhentos ", " seiscentos ", " setecentos ", " oitocentos ", " novecentos " },// Extrai e formata a parte decimal (centavos) como string com 3 dígitos, arredondando para 0 casasdecimal = Text.PadStart( Text.From( Number.Round( (valor - Number.RoundDown(valor,0))*100,0) ) , 3, "0"),// Extrai e formata a parte inteira como string com 15 dígitos, preenchendo com zeros à esquerdainteiro = Text.PadStart( Text.From( Number.RoundDown(valor,0) ), 15, "0"),// Concatena parte inteira e decimal para criar um número único com 18 dígitosnumero = inteiro & decimal,// Converte o número em uma lista de dígitos individuaistab_num = Text.ToList(numero),// Calcula valores para cada classe (trilhões, bilhões, milhões, milhares, centenas, centavos) a partir dos dígitostrilhao = Number.From( tab_num{00} )*100 + Number.From( tab_num{01} )*10 + Number.From( tab_num{02} ),bilhao = Number.From( tab_num{03} )*100 + Number.From( tab_num{04} )*10 + Number.From( tab_num{05} ),milhao = Number.From( tab_num{06} )*100 + Number.From( tab_num{07} )*10 + Number.From( tab_num{08} ),milhar = Number.From( tab_num{09} )*100 + Number.From( tab_num{10} )*10 + Number.From( tab_num{11} ),centena = Number.From( tab_num{12} )*100 + Number.From( tab_num{13} )*10 + Number.From( tab_num{14} ),centavo = Number.From( tab_num{15} )*100 + Number.From( tab_num{16} )*10 + Number.From( tab_num{17} ),// Define os sufixos das classes, ajustando singular/plural conforme o valorclasse_tril = if trilhao = 0 then "" else if trilhao = 1 then "trilhão " else "trilhões ",classe_bilh = if bilhao = 0 then "" else if bilhao = 1 then "bilhão " else "bilhões ",classe_milh = if milhao = 0 then "" else if milhao = 1 then "milhão " else "milhões ",classe_mil = if milhar = 0 then "" else "mil ",classe_real = if Number.RoundDown(valor,0) = 0 then "" else if Number.RoundDown(valor,0) = 1 then "real " else if centena+milhar = 0 then "de reais " else "reais ",classe_cent = if centavo = 0 then "" else if centavo = 1 then "centavo " else "centavos ",// Converte trilhões por extenso, considerando faixas (0-20, 20-99, 100+) e exceções como "cem"ordem_trilhao = if trilhao <= 20 then ext_0a20{trilhao} & classe_trilelse if trilhao <= 99 then ext_20a90{ ( Number.From( tab_num{01} )*10 - 20) /10 } & "e" & ext_0a20{ Number.From( tab_num{02} )} & classe_trilelse if trilhao = 100 then " Cem " & classe_trilelse if Number.From( tab_num{01} )*10 + Number.From( tab_num{02} ) <= 20 then ext_100a900{ (Number.From( tab_num{00} )*100)/100 } & "e" & ext_0a20{Number.From( tab_num{01} )*10 + Number.From( tab_num{02} )} & classe_trilelse ext_100a900{ (Number.From( tab_num{00} )*100)/100 } & "e" & ext_20a90{ ( Number.From( tab_num{01} )*10 - 20) /10 } & "e" & ext_0a20{ Number.From( tab_num{02} )} & classe_tril,// Converte bilhões por extenso, seguindo a mesma lógica de trilhõesordem_bilhao = if bilhao <= 20 then ext_0a20{bilhao} & classe_bilhelse if bilhao <= 99 then ext_20a90{ ( Number.From( tab_num{04} )*10 - 20) /10 } & "e" & ext_0a20{ Number.From( tab_num{05} )}else if bilhao = 100 then " Cem " & classe_bilhelse if Number.From( tab_num{04} )*10 + Number.From( tab_num{05} ) <= 20 then ext_100a900{ (Number.From( tab_num{03} )*100)/100 } & "e" & ext_0a20{Number.From( tab_num{04} )*10 + Number.From( tab_num{05} )} & classe_bilhelse ext_100a900{ (Number.From( tab_num{03} )*100)/100 } & "e" & ext_20a90{ ( Number.From( tab_num{04} )*10 - 20) /10 } & "e" & ext_0a20{ Number.From( tab_num{05} )} & classe_bilh,// Converte milhões por extenso, com lógica similarordem_milhao = if milhao <= 20 then ext_0a20{milhao} & classe_milhelse if milhao <= 99 then ext_20a90{ ( Number.From( tab_num{07} )*10 - 20) /10 } & "e" & ext_0a20{ Number.From( tab_num{08} )} & classe_milhelse if milhao = 100 then " Cem " & classe_milhelse if Number.From( tab_num{07} )*10 + Number.From( tab_num{08} ) <= 20 then ext_100a900{ (Number.From( tab_num{06} )*100)/100 } & "e" & ext_0a20{Number.From( tab_num{07} )*10 + Number.From( tab_num{08} )} & classe_milhelse ext_100a900{ (Number.From( tab_num{06} )*100)/100 } & "e" & ext_20a90{ ( Number.From( tab_num{07} )*10 - 20) /10 } & "e" & ext_0a20{ Number.From( tab_num{08} )} & classe_milh,// Converte milhares por extensoordem_milhar = if milhar <= 20 then ext_0a20{milhar} & classe_milelse if milhar <= 99 then ext_20a90{ ( Number.From( tab_num{10} )*10 - 20) /10 } & "e" & ext_0a20{ Number.From( tab_num{11} )} & classe_milelse if milhar = 100 then " Cem " & classe_milelse if Number.From( tab_num{10} )*10 + Number.From( tab_num{11} ) <= 20 then ext_100a900{ (Number.From( tab_num{09} )*100)/100 } & "e" & ext_0a20{Number.From( tab_num{10} )*10 + Number.From( tab_num{11} )} & classe_milelse ext_100a900{ (Number.From( tab_num{09} )*100)/100 } & "e" & ext_20a90{ ( Number.From( tab_num{10} )*10 - 20) /10 } & "e" & ext_0a20{ Number.From( tab_num{11} )} & classe_mil,// Converte centenas por extenso, incluindo sufixo "real" ou "reais"ordem_centena = if centena <= 20 then ext_0a20{centena} & classe_realelse if centena <= 99 then ext_20a90{ ( Number.From( tab_num{13} )*10 - 20) /10 } & "e" & ext_0a20{ Number.From( tab_num{14} )} & classe_realelse if centena = 100 then " Cem " & classe_realelse if Number.From( tab_num{13} )*10 + Number.From( tab_num{14} ) <= 20 then ext_100a900{ (Number.From( tab_num{12} )*100)/100 } & "e" & ext_0a20{Number.From( tab_num{13} )*10 + Number.From( tab_num{14} )} & classe_realelse ext_100a900{ (Number.From( tab_num{12} )*100)/100 } & "e" & ext_20a90{ ( Number.From( tab_num{13} )*10 - 20) /10 } & "e" & ext_0a20{ Number.From( tab_num{14} )} & classe_real,// Converte centavos por extensoordem_centavo = if centavo <= 20 then ext_0a20{centavo} & classe_centelse ext_20a90{ (Number.From( tab_num{16} )*10-20)/10 } & "e" & ext_0a20{Number.From( tab_num{17} )} & classe_cent,// Define conectores "e" entre as classes, se necessárioe_trilhao = if trilhao > 0 and bilhao + milhao + milhar + centena + centavo > 0 then " e" else "",e_bilhao = if bilhao > 0 and milhao + milhar + centena + centavo > 0 then " e" else "",e_milhao = if milhao > 0 and milhar + centena + centavo > 0 then " e" else "",e_milhar = if milhar > 0 and centena + centavo > 0 then " e" else "",e_centena = if centena > 0 and centavo > 0 then " e" else "",// Concatena todas as partes para formar o texto final por extensoextenso = ordem_trilhao & e_trilhao & ordem_bilhao & e_bilhao & ordem_milhao & e_milhao & ordem_milhar & e_milhar & ordem_centena & e_centena & ordem_centavoinextenso // Retorna o valor por extenso como resultado final
PARAMETRIZADO PARA REAIS
/* Função criada por Edney Franklin Siqueira e refatorada por André Bernardes. Pode ser utilizada livremente desde que citado o desenvolvedor original. Converte um número em sua representação por extenso em português brasileiro (ex.: 1234.56 -> "mil duzentos e trinta e quatro reais e cinquenta e seis centavos"). Suporta números grandes dinamicamente e trata entradas inválidas. */ (valor as any) => let // Validação inicial da entrada ValorValidado = if Type.Is(Value.Type(valor), type number) then if valor < 0 then error "Número negativo não suportado" else valor else error "Entrada deve ser um número", // Define dicionários de palavras para unidades, dezenas e centenas ExtensoNumeros = [ Unidades = {"", "um", "dois", "três", "quatro", "cinco", "seis", "sete", "oito", "nove", "dez", "onze", "doze", "treze", "quatorze", "quinze", "dezesseis", "dezessete", "dezoito", "dezenove", "vinte"}, Dezenas = {"", "", "vinte", "trinta", "quarenta", "cinquenta", "sessenta", "setenta", "oitenta", "noventa"}, Centenas = {"", "cento", "duzentos", "trezentos", "quatrocentos", "quinhentos", "seiscentos", "setecentos", "oitocentos", "novecentos"} ], // Define classes numéricas e seus sufixos (ordem decrescente de magnitude) Classes = { [10^12, "trilhão", "trilhões"], // 1.000.000.000.000 [10^9, "bilhão", "bilhões"], // 1.000.000.000 [10^6, "milhão", "milhões"], // 1.000.000 [10^3, "mil", "mil"] // 1.000 (sem plural) }, // Função auxiliar para converter um número de 0 a 999 em texto ConverterCentena = (num as number) as text => let cent = Number.RoundDown(num / 100, 0), // Extrai a centena resto = Number.Mod(num, 100), // Calcula o resto (dezenas e unidades) dez = Number.RoundDown(resto / 10, 0), // Extrai a dezena unid = Number.Mod(resto, 10), // Extrai a unidade textoCentena = if num = 100 then "cem" // Caso especial: "cem" em vez de "cento" else if cent > 0 then ExtensoNumeros[Centenas]{cent} else "", textoResto = if resto <= 20 and resto > 0 then ExtensoNumeros[Unidades]{resto} // Usa unidades para 1-20 else if resto > 0 then ExtensoNumeros[Dezenas]{dez} & (if unid > 0 then " e " & ExtensoNumeros[Unidades]{unid} else "") else "", resultado = textoCentena & (if textoCentena <> "" and textoResto <> "" then " e " else "") & textoResto in resultado, // Função auxiliar para aplicar uma classe (ex.: milhões) a um valor AplicarClasse = (valorClasse as number, potencia as number, singular as text, plural as text) as text => let qtd = Number.RoundDown(valorClasse / potencia, 0), // Calcula a quantidade para a classe texto = if qtd = 0 then "" else ConverterCentena(qtd) & " " & (if qtd = 1 and plural <> "mil" then singular else plural) in texto, // Separa o número em parte inteira e decimal Inteiro = Number.RoundDown(ValorValidado, 0), // Parte inteira Decimal = Number.Round((ValorValidado - Inteiro) * 100, 0), // Centavos, arredondado // Converte a parte inteira em texto, processando dinamicamente todas as classes ProcessarInteiro = let Restante = Inteiro, // Valor restante a ser processado Partes = List.Accumulate( Classes, // Itera sobre as classes definidas [ValorRestante = Restante, Texto = {}], // Estado inicial: valor total e lista de textos (estado, classe) => let potencia = classe{0}, // Potência da classe (ex.: 10^12 para trilhões) singular = classe{1}, // Sufixo singular plural = classe{2}, // Sufixo plural (ou "mil" sem plural) textoClasse = AplicarClasse(estado[ValorRestante], potencia, singular, plural), // Converte a classe novoRestante = Number.Mod(estado[ValorRestante], potencia), // Atualiza o restante novoTexto = if textoClasse = "" then estado[Texto] else estado[Texto] & {textoClasse} // Adiciona texto se não vazio in [ValorRestante = novoRestante, Texto = novoTexto] ), Centena = Number.Mod(Partes[ValorRestante], 1000), // Última centena (0-999) TextoCentena = if Centena = 0 and Inteiro > 0 then "" else ConverterCentena(Centena), TextoReal = if Inteiro = 0 then "" else if Inteiro = 1 then " real" else if Centena = 0 and List.Count(Partes[Texto]) = 0 then " de reais" else " reais", TodasPartes = Partes[Texto] & {if TextoCentena <> "" then TextoCentena & TextoReal else TextoReal} in TodasPartes, // Converte a parte decimal (centavos) em texto TextoCentavo = if Decimal = 0 then "" else ConverterCentena(Decimal) & " " & (if Decimal = 1 then "centavo" else "centavos"), // Combina todas as partes não vazias com "e" como separador PartesNaoVazias = List.Select(ProcessarInteiro & {TextoCentavo}, each _ <> ""), ExtensoFinal = if List.IsEmpty(PartesNaoVazias) then "zero reais" else Text.Combine(PartesNaoVazias, " e ") inExtensoFinal // Retorna o texto final por extenso
PARAMETRIZADO PARA DÓLAR
/*
Function created by Edney Franklin Siqueira and refactored by André Bernardes.
May be used freely provided the original developer is credited. Converts a number to its written form in English with dollars (e.g., 1234.56 -> "one thousand two hundred thirty-four dollars and fifty-six cents"). Supports large numbers dynamically and handles invalid inputs. */ (value as any) => let // Initial input validation ValidatedValue = if Type.Is(Value.Type(value), type number) then if value < 0 then error "Negative numbers are not supported" else value else error "Input must be a number", // Define dictionaries for numbers, tens, and hundreds in English NumberWords = [ Units = {"", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen", "twenty"}, Tens = {"", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"}, Hundreds = {"", "one hundred", "two hundred", "three hundred", "four hundred", "five hundred", "six hundred", "seven hundred", "eight hundred", "nine hundred"} ], // Define numeric classes and their suffixes (in descending order of magnitude) Classes = { [10^12, "trillion", "trillions"], // 1,000,000,000,000 [10^9, "billion", "billions"], // 1,000,000,000 [10^6, "million", "millions"], // 1,000,000 [10^3, "thousand", "thousand"] // 1,000 (no plural variation) }, // Helper function to convert a number from 0 to 999 to text ConvertHundreds = (num as number) as text => let hundreds = Number.RoundDown(num / 100, 0), // Extract hundreds remainder = Number.Mod(num, 100), // Calculate remainder (tens and units) tens = Number.RoundDown(remainder / 10, 0), // Extract tens units = Number.Mod(remainder, 10), // Extract units hundredsText = if hundreds > 0 then NumberWords[Hundreds]{hundreds} else "", remainderText = if remainder <= 20 and remainder > 0 then NumberWords[Units]{remainder} // Use units for 1-20 else if remainder > 0 then NumberWords[Tens]{tens} & (if units > 0 then "-" & NumberWords[Units]{units} else "") else "", result = hundredsText & (if hundredsText <> "" and remainderText <> "" then " " else "") & remainderText in result, // Helper function to apply a class (e.g., millions) to a value ApplyClass = (classValue as number, power as number, singular as text, plural as text) as text => let qty = Number.RoundDown(classValue / power, 0), // Calculate quantity for the class text = if qty = 0 then "" else ConvertHundreds(qty) & " " & (if qty = 1 and plural <> "thousand" then singular else plural) in text, // Split the number into integer and decimal parts Integer = Number.RoundDown(ValidatedValue, 0), // Integer part Decimal = Number.Round((ValidatedValue - Integer) * 100, 0), // Cents, rounded // Convert the integer part to text, dynamically processing all classes ProcessInteger = let Remaining = Integer, // Value left to process Parts = List.Accumulate( Classes, // Iterate over defined classes [ValueRemaining = Remaining, Text = {}], // Initial state: full value and empty text list (state, class) => let power = class{0}, // Power of the class (e.g., 10^12 for trillions) singular = class{1}, // Singular suffix plural = class{2}, // Plural suffix (or "thousand" without plural) classText = ApplyClass(state[ValueRemaining], power, singular, plural), // Convert the class newRemaining = Number.Mod(state[ValueRemaining], power), // Update remaining value newText = if classText = "" then state[Text] else state[Text] & {classText} // Add text if not empty in [ValueRemaining = newRemaining, Text = newText] ), Hundreds = Number.Mod(Parts[ValueRemaining], 1000), // Last hundreds (0-999) HundredsText = if Hundreds = 0 and Integer > 0 then "" else ConvertHundreds(Hundreds), DollarText = if Integer = 0 then "" else if Integer = 1 then " dollar" else " dollars", AllParts = Parts[Text] & {if HundredsText <> "" then HundredsText & DollarText else DollarText} in AllParts, // Convert the decimal part (cents) to text CentsText = if Decimal = 0 then "" else ConvertHundreds(Decimal) & " " & (if Decimal = 1 then "cent" else "cents"), // Combine all non-empty parts with "and" as separator NonEmptyParts = List.Select(ProcessInteger & {CentsText}, each _ <> ""), FinalText = if List.IsEmpty(NonEmptyParts) then "zero dollars" else Text.Combine(NonEmptyParts, " and ") in FinalText // Return the final written text
Explicação das Melhorias:
Funções Auxiliares: A função calcularExtenso foi criada para processar cada classe (centenas, dezenas e unidades) e retornar o valor correspondente por extenso, eliminando a repetição de lógica. Isso melhora a clareza e a organização do código.
Estrutura Lógica Simplificada: A forma como as classes (trilhões, bilhões, milhões, etc.) são montadas foi simplificada, evitando redundância.
Formatação Dinâmica: O uso de expressões comoText.Trimgarante que o resultado final não contenha espaços extras, mantendo o formato de saída limpo.
Legibilidade: A melhoria na estrutura condicional torna o código mais fácil de entender e ajustar para futuras necessidades.
Essa nova versão mantém a funcionalidade original, mas melhora o código em termos de manutenção, legibilidade e eficiência.
Como implementar?
Vá até o editor do Power Query e adicione uma consulta nula:
Abra o editor avançado:
Apague tudo que tiver escrito no editor:
Copie e cole o código dentro da área de trabalho:
Clique em concluído.
Agora conseguirá usar a função personalizada para converter valores por extenso.
Você pode inserir um número de até 12 dígitos e 2 casas decimais:
Use vírgula para casa decimal:
Mas você também pode invocar a função para converter os valores de uma tabela por extenso. Basta selecionar a tabela com os valores:
Ir na guia adicionar colunas e escolher Invocar função personalizada
E pronto os numeros estarão por extenso!
The Advantages of Using a Power Query Function to Convert Numbers to Words in Dollars
When working with financial data in tools like Power BI or Excel, presenting numbers in a readable, written format can significantly enhance reports and user experience. The refactored Power Query (M) function, originally created by Edney Franklin Siqueira and enhanced by André Bernardes, offers a robust solution to convert numeric values into their English written form with dollars (e.g., 1234.56 becomes "one thousand two hundred thirty-four dollars and fifty-six cents"). This article explores the key benefits of using this function, making it a valuable tool for data analysts, accountants, and business professionals seeking automation and precision.
1. Enhanced Readability for Financial Reports
One of the primary advantages of this function is its ability to transform raw numbers into a human-friendly format. In financial reporting, where clarity is critical, converting dollar amounts to words ensures that stakeholders—whether clients, managers, or auditors—can quickly interpret values without misreading digits. By integrating this Power Query function into your workflow, you can automate the process, eliminating manual errors and saving time while producing professional-grade documents like invoices or balance sheets optimized for readability.
2. Dynamic Support for Large Numbers
Unlike simpler scripts with fixed limits, this function dynamically handles numbers of any size, from small amounts like $5.25 to massive figures like $1 trillion. Its use of a List.Accumulate approach and predefined classes (trillions, billions, millions, thousands) ensures scalability, making it ideal for businesses dealing with diverse financial scales. This flexibility is a game-changer for industries such as banking or investment, where large dollar amounts are common, and precision in written representation is non-negotiable.
3. Robust Error Handling for Reliable Outputs
Data integrity is paramount in financial applications, and this function excels with its built-in error handling. It rejects negative numbers and non-numeric inputs with clear error messages (e.g., "Negative numbers are not supported"), preventing faulty results that could derail analysis or reporting. For users searching for "Power Query number to text conversion" or "reliable financial data tools," this feature boosts confidence, ensuring consistent and accurate outputs every time.
4. Seamless Integration with Power BI and Excel
Designed in Power Query (M), this function integrates effortlessly with Power BI and Excel, two of the most widely used tools for data analysis and visualization. By embedding it into your data transformation pipeline, you can automate the conversion of dollar amounts directly within your workflows, enhancing efficiency. This compatibility makes it a top choice for professionals looking to streamline processes, as evidenced by its applicability in queries like "Power BI financial reporting tools" or "Excel automation scripts."
5. Professional Presentation in English with Dollars
For English-speaking markets, particularly in the U.S., the function’s output in proper English (e.g., "twenty-five dollars and ten cents") aligns with standard financial documentation practices. This is especially advantageous for creating legally compliant documents like contracts or checks, where written dollar amounts are required. Its SEO-friendly focus on "convert numbers to words in dollars" or "English financial text conversion" ensures it meets the needs of users targeting American business standards.
6. Time-Saving Automation and Scalability
Manual conversion of numbers to text is tedious and error-prone, especially with large datasets. This function automates the task, allowing users to process thousands of records instantly within Power Query. Its modular design—featuring helper functions like ConvertHundreds—also makes it easy to maintain or extend for other currencies, offering scalability for future needs. For those searching "automate dollar amount text conversion," this tool delivers unmatched efficiency and adaptability.
7. Free and Open Usage with Proper Attribution
Finally, the function’s open usage policy (credit to Edney Franklin Siqueira) makes it a cost-effective solution for individuals and organizations. You can implement it without licensing fees, provided you acknowledge the original developer, aligning with ethical coding practices. This accessibility, combined with its powerful features, positions it as a standout option for anyone researching "free Power Query scripts" or "open-source financial tools," driving value without breaking the budget.
👉 Não se esqueça de seguir André Bernardes no Linkedin. Clique aqui e me contate via What's App.
.png "Integrando Microsoft Fabric com Azure: Dicas e Melhores Práticas | Integrating Microsoft Fabric with Azure: Tips and Best Practices")
