Conversores

Conversor de moeda

Converta moedas com cotação inserida por você.

Converter moedas é expressar um valor em outra unidade monetária por meio de uma taxa de câmbio. Esta ferramenta multiplica o valor pela cotação informada pelo usuário, útil em estudos e simulações. A taxa é manual, não representa necessariamente o mercado atual e não inclui impostos, tarifas ou spreads.

Cotação manual — não representa necessariamente a cotação atual.

Valor não negativo e cotação positiva. Vírgula ou ponto decimal, sem separadores de milhar: 1234,56 ou 1234.56. 1.000 significa um, nunca mil. Até 15 dígitos inteiros e 12 casas decimais (máximo 999999999999999,999999999999; até 30 caracteres após retirar espaços externos). Sem expoentes, espaços internos ou separadores misturados. Impostos, tarifas e spreads não estão incluídos.

Valor de origem

Moeda de origem

Moeda de destino

Cotação: 1 USD = X BRL

Destino = origem × cotação, sem arredondamento intermediário. Resultado final: duas casas para BRL/USD/EUR/GBP; nenhuma para JPY. Metade para cima (ex.: 1,005 → 1,01; JPY 1,5 → 2).

Esta ferramenta foi desenvolvida para apoiar estudantes e programadores em atividades de aprendizagem, desenvolvimento e testes autorizados. Utilize os resultados com responsabilidade, respeitando a privacidade, os direitos de terceiros e as regras do ambiente em que forem aplicados. Sua finalidade é educativa e técnica, sem promover fraude, uso indevido de dados ou qualquer ação que prejudique instituições, pessoas ou grupos.

Como usar

Cotação manual — não representa necessariamente a cotação atual. Destino = origem × cotação; direção 1 origem = X destino. Valor não negativo; cotação positiva. Moedas iguais usam taxa 1. Trocar moeda limpa taxa e resultado, preservando valor. Vírgula ou ponto decimal, sem agrupamento; 1.000 significa um. Até 15 dígitos inteiros e 12 casas, sem expoentes. Frações exatas com BigInt; metade para cima somente no final: 2 casas BRL/USD/EUR/GBP e 0 JPY. Copiar usa valor arredondado sem agrupamento/código/símbolo. Sem impostos, tarifas ou spreads. Exemplo fictício; nenhuma API de câmbio.

Exemplos de código

Implemente no seu projeto

function executar(values = { amount: '10', from: 'USD', to: 'BRL', rate: '5' }) {
    const { parseDecimal: parseDecimal, multiplyDecimal: multiplyDecimal } = (() => {
        function parse(input, label) {
            const text = input.trim();
            if (text.length > 30 || !/^[+-]?\d{1,15}(?:[.,]\d{1,12})?$/.test(text))
                throw new Error(`${label}: informe um decimal válido, com até 15 dígitos inteiros e 12 casas; sem agrupamento, expoentes ou separadores misturados.`);
            const [integer, decimal = ''] = text.replace(',', '.').split('.');
            const sign = integer.startsWith('-') ? -BigInt(1) : BigInt(1);
            return { n: sign * BigInt(integer.replace(/^[+-]/, '') + decimal), d: BigInt(10) ** BigInt(decimal.length) };
        }
        const multiply = (a, b) => ({ n: a.n * b.n, d: a.d * b.d });
        return { parseDecimal: parse, multiplyDecimal: multiply };
    })();
    const CURRENCIES = ['BRL', 'USD', 'EUR', 'GBP', 'JPY'];
    function convertCurrency(input) {
        if (![input.from, input.to].every(code => CURRENCIES.includes(code)))
            throw new Error('Selecione uma moeda suportada: BRL, USD, EUR, GBP ou JPY.');
        const amount = parseDecimal(input.amount, 'Valor de origem');
        if (amount.n < BigInt(0))
            throw new Error('O valor de origem deve ser não negativo.');
        const rateText = input.from === input.to ? '1' : input.rate;
        const rate = parseDecimal(rateText, 'Cotação');
        if (rate.n <= BigInt(0))
            throw new Error('A cotação deve ser maior que zero.');
        const result = multiplyDecimal(amount, rate);
        const places = input.to === 'JPY' ? 0 : 2;
        const scale = BigInt(10) ** BigInt(places);
        const scaled = result.n * scale;
        let rounded = scaled / result.d;
        const remainder = scaled % result.d;
        if (remainder * BigInt(2) >= result.d)
            rounded++;
        const integer = String(rounded / scale);
        const decimals = places ? ',' + String(rounded % scale).padStart(places, '0') : '';
        const normalizedRate = rateText.trim().replace('.', ',').replace(/^\+/, '');
        return { value: integer + decimals, formatted: integer.replace(/\B(?=(\d{3})+(?!\d))/g, '.') + decimals + ' ' + input.to, rate: `1 ${input.from} = ${normalizedRate} ${input.to}`, rounded: remainder !== BigInt(0) };
    }
    return convertCurrency(values);
}

import re
from fractions import Fraction

def executar(values=None):
    values = {"amount":"10", "from":"USD", "to":"BRL", "rate":"5"} if values is None else values

    def parse(text):
        text = text.strip()
        if len(text) > 30 or not re.fullmatch(r"[+-]?[0-9]{1,15}(?:[.,][0-9]{1,12})?", text):
            raise ValueError("Use até 15 dígitos inteiros e 12 casas, sem agrupamento ou expoentes.")
        return Fraction(text.replace(",", "."))

    source, target = values.get("from"), values.get("to")
    if source not in ("BRL", "USD", "EUR", "GBP", "JPY") or target not in ("BRL", "USD", "EUR", "GBP", "JPY"):
        raise ValueError("Selecione BRL, USD, EUR, GBP ou JPY.")
    amount = parse(values.get("amount", ""))
    rate_text = "1" if source == target else values.get("rate", "")
    rate = parse(rate_text)
    if amount < 0 or rate <= 0:
        raise ValueError("Valor não negativo e cotação maior que zero são obrigatórios.")
    places = 0 if target == "JPY" else 2
    scaled = amount * rate * 10**places
    rounded, remainder = divmod(scaled.numerator, scaled.denominator)
    rounded += 2 * remainder >= scaled.denominator
    integer, fraction = divmod(rounded, 10**places)
    decimal = "," + str(fraction).zfill(places) if places else ""
    value = str(integer) + decimal
    formatted = f"{integer:,}".replace(",", ".") + decimal + " " + target
    return {"value":value, "formatted":formatted, "rate":f"1 {source} = {rate_text.strip().replace('.', ',').lstrip('+')} {target}", "rounded":remainder != 0}

<?php
use Brick\Math\BigRational;
use Brick\Math\RoundingMode;
require_once 'vendor/autoload.php';

function executar($values = ['amount'=>'10', 'from'=>'USD', 'to'=>'BRL', 'rate'=>'5']) {

    $parse = function ($text) {
        $text = trim($text);
        if (strlen($text) > 30 || !preg_match('/^[+-]?[0-9]{1,15}(?:[.,][0-9]{1,12})?$/D', $text)) throw new InvalidArgumentException('Use até 15 dígitos inteiros e 12 casas, sem agrupamento ou expoentes.');
        return BigRational::of(str_replace(',', '.', ltrim($text, '+')));
    };

    $from = $values['from'] ?? ''; $to = $values['to'] ?? '';
    $currencies = ['BRL', 'USD', 'EUR', 'GBP', 'JPY'];
    if (!in_array($from, $currencies, true) || !in_array($to, $currencies, true)) throw new InvalidArgumentException('Moeda inválida.');
    $amount = $parse($values['amount'] ?? '');
    $rateText = $from === $to ? '1' : ($values['rate'] ?? '');
    $rate = $parse($rateText);
    if ($amount->isNegative() || $rate->compareTo(0) <= 0) throw new InvalidArgumentException('Valor não negativo e cotação positiva são obrigatórios.');
    $places = $to === 'JPY' ? 0 : 2;
    $exact = $amount->multipliedBy($rate);
    $rounded = $exact->toScale($places, RoundingMode::HALF_UP);
    $value = str_replace('.', ',', (string)$rounded);
    $parts = explode(',', $value);
    $formatted = preg_replace('/\B(?=(\d{3})+(?!\d))/', '.', $parts[0]).(isset($parts[1]) ? ','.$parts[1] : '').' '.$to;
    return ['value'=>$value, 'formatted'=>$formatted, 'rate'=>'1 '.$from.' = '.str_replace('.', ',', ltrim(trim($rateText), '+')).' '.$to, 'rounded'=>$exact->compareTo($rounded) !== 0];
}