Multiplicação de Duration por Integer em Go: segredos de 2025

Como multiplicar Duration por Integer em Go? Analisando com exemplos

Olá, colega! Se você já escreveu código em Go que trabalha com temporizadores, intervalos ou simplesmente atrasos, certamente já se deparou com esta questão. Você pega um time.Duration, quer multiplicá-lo por um número inteiro — e recebe um erro de compilação. Familiar? Não se preocupe, esta é uma das perguntas mais populares no Stack Overflow com milhares de visualizações. Neste artigo, vamos analisar por que isso acontece e como resolver o problema corretamente em 2025. Vamos lá!

Por que time.Duration * int não funciona?

Vamos direto ao ponto. Em Go, time.Duration não é apenas um número, mas um tipo separado, baseado em int64 (nanossegundos). Quando você escreve:

package main\n\nimport (\n    "fmt"\n    "time"\n)\n\nfunc main() {\n    d := 2 * time.Second\n    multiplier := 3\n    result := d * multiplier // Erro de compilação!\n    fmt.Println(result)\n}\n

O compilador emitirá algo como: invalid operation: d * multiplier (mismatched types time.Duration and int). Em Go, a tipagem é forte e não é possível multiplicar tipos diferentes diretamente. Isso é uma proteção contra erros bobos, mas às vezes irrita. Em 2025, essa regra não mudou e precisa ser contornada corretamente.

Melhores práticas: como multiplicar Duration por Integer

Existem várias maneiras, e vamos analisar cada uma. Escolha a que melhor se adequa à sua tarefa.

1. Conversão de int para time.Duration

O método mais óbvio e seguro é converter o multiplicador para o tipo time.Duration. Como time.Duration é um int64, a conversão funciona diretamente:

package main\n\nimport (\n    "fmt"\n    "time"\n)\n\nfunc main() {\n    d := 2 * time.Second\n    multiplier := 3\n    result := d * time.Duration(multiplier)\n    fmt.Println(result) // Saída: 6s\n}\n

Esta forma é ideal quando o multiplicador é um número positivo pequeno. Mas cuidado: se multiplier for negativo ou muito grande, o resultado pode ser inesperado (estouro). Em 2025, isso ainda é relevante, portanto, verifique os valores limite.

2. Uso de time.Duration para cálculos

Às vezes é mais conveniente trabalhar diretamente com constantes time.Duration. Por exemplo, se precisar aumentar o intervalo várias vezes:

package main\n\nimport (\n    "fmt"\n    "time"\n)\n\nfunc main() {\n    base := 500 * time.Millisecond\n    multiplier := time.Duration(4)\n    result := base * multiplier\n    fmt.Println(result) // Saída: 2s\n}\n

Esta abordagem é mais legível, especialmente se o multiplicador for uma constante. Mas não esqueça que time.Duration são nanossegundos, então time.Duration(4) são 4 nanossegundos, e não 4 unidades de tempo. Para multiplicar por "4 vezes" funciona, mas para outros fins, não.

3. Função wrapper para conveniência

Se a multiplicação de duration por int aparece com frequência no código, crie uma pequena função. Isso melhora a legibilidade e evita duplicação:

package main\n\nimport (\n    "fmt"\n    "time"\n)\n\nfunc multiplyDuration(d time.Duration, factor int) time.Duration {\n    return d * time.Duration(factor)\n}\n\nfunc main() {\n    d := 3 * time.Minute\n    result := multiplyDuration(d, 2)\n    fmt.Println(result) // Saída: 6m0s\n}\n

Em 2025, com projetos cada vez mais complexos, essas funções auxiliares são essenciais. Elas protegem contra erros e tornam o código autodocumentado.

4. Multiplicação com ponto flutuante (nível avançado)

Às vezes é necessário multiplicar uma duration por um número fracionário (por exemplo, 1.5). Go não permite multiplicar time.Duration por float64, mas é possível contornar:

package main\n\nimport (\n    "fmt"\n    "time"\n)\n\nfunc main() {\n    d := 100 * time.Millisecond\n    factor := 1.5\n    result :=