Multiplicación de Duration por Integer en Go: secretos de 2025

¿Cómo multiplicar Duration por Integer en Go? Analizamos con ejemplos

¡Hola, colega! Si alguna vez has escrito código en Go que trabaja con temporizadores, intervalos o simplemente retrasos, seguramente te has topado con esta pregunta. Tomas time.Duration, quieres multiplicarlo por un número entero y obtienes un error de compilación. ¿Te suena? No te preocupes, es una de las preguntas más populares en Stack Overflow con miles de visitas. En este artículo analizaremos por qué sucede esto y cómo resolver el problema correctamente en 2025. ¡Allá vamos!

¿Por qué time.Duration * int no funciona?

Vamos al grano. En Go, time.Duration no es solo un número, sino un tipo separado, basado en int64 (nanosegundos). Cuando escribes:

package main\n\nimport (\n    "fmt"\n    "time"\n)\n\nfunc main() {\n    d := 2 * time.Second\n    multiplier := 3\n    result := d * multiplier // ¡Error de compilación!\n    fmt.Println(result)\n}\n

El compilador mostrará algo como: invalid operation: d * multiplier (mismatched types time.Duration and int). En Go hay tipado estricto y no se pueden multiplicar tipos diferentes directamente. Esto es una protección contra errores tontos, pero a veces es molesto. En 2025, esta regla no ha cambiado y hay que sortearla correctamente.

Mejores prácticas: cómo multiplicar Duration por Integer

Hay varias formas, y veremos cada una. Elige la que mejor se adapte a tu tarea.

1. Convertir int a time.Duration

El método más obvio y seguro es convertir el multiplicador al tipo time.Duration. Como time.Duration es un int64, la conversión funciona directamente:

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) // Salida: 6s\n}\n

Esta forma es ideal cuando el multiplicador es un número positivo pequeño. Pero ten cuidado: si multiplier es negativo o muy grande, el resultado puede ser inesperado (desbordamiento). En 2025 esto sigue siendo relevante, así que verifica los valores límite.

2. Usar time.Duration para cálculos

A veces es más conveniente trabajar directamente con constantes time.Duration. Por ejemplo, si necesitas aumentar un intervalo varias veces:

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) // Salida: 2s\n}\n

Este enfoque se lee más fácil, especialmente si el multiplicador es una constante. Pero no olvides que time.Duration son nanosegundos, por lo que time.Duration(4) son 4 nanosegundos, no 4 unidades de tiempo. Para multiplicar por "4 veces" funciona, pero para otros fines no.

3. Función envoltorio para mayor comodidad

Si en el código aparece a menudo la multiplicación de duration por int, crea una pequeña función. Esto mejorará la legibilidad y evitará duplicación:

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) // Salida: 6m0s\n}\n

En 2025, cuando los proyectos se vuelven más complejos, estas funciones auxiliares son imprescindibles. Protegen contra errores y hacen que el código sea autodocumentado.

4. Multiplicación con punto flotante (nivel avanzado)

A veces necesitas multiplicar duration por un número fraccionario (por ejemplo, 1.5). Go no permite multiplicar time.Duration por float64, pero se puede hacer un truco:

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