Nivel inicial11 min de lectura · Publicado el

Time en Ruby: fechas, horas y strftime

Time en Ruby: un sello con la fecha y hora exactas; strftime elige cómo se imprime: 07/11/2026, Saturday o 09:05. Una fecha, muchos formatosrubentejera.com Time"%d/%m/%Y"07/11/2026"%A"Saturday"%H:%M"09:05strftime elige la plantilla
Time es el sello, con la fecha y la hora exactas; strftime, la plantilla con la que lo imprimes. Ojo: %A y %B salen en inglés (Saturday, November), porque Ruby puro no traduce los nombres.

Un objeto Time en Ruby es como un sello con fecha y hora exactas. strftime es la plantilla con la que decides cómo imprimir ese sello: «07/11/2026», «Saturday» (en inglés) o «09:05».

El cero de los tiempos

Ruby cuenta el tiempo en segundos desde el 1 de enero de 1970 a las 00:00:00 UTC, el llamado epoch de Unix:

puts Time.at(0).utc   # 1970-01-01 00:00:00 UTC

Las fechas anteriores también funcionan: simplemente tienen un número de segundos negativo.

puts Time.new(1969, 7, 20, 20, 17, 0, "UTC").to_i   # -14182980
puts Time.new(1492, 10, 12, 0, 0, 0, "UTC")         # 1492-10-12 00:00:00 UTC

Crear una fecha

Time.now es el momento actual, así que lo que devuelve cambia cada vez que lo ejecutas. Para que los ejemplos den siempre lo mismo, usan una fecha fija creada con Time.new:

t = Time.new(2026, 11, 7, 9, 5, 3, "+01:00") # año, mes, día, hora, min, seg, zona

puts t.year    # 2026
puts t.month   # 11
puts t.day     # 7
puts t.wday    # 6 (0 es domingo, 6 es sábado)
puts t.yday    # 311 (día del año)

Con Time.now funcionan los mismos métodos: Time.now.year, Time.now.day… Solo que el resultado será el de hoy.

La zona horaria: de qué depende cada salida

Un Time guarda un instante exacto y, además, la zona en la que se muestra. Es como una llamada a la misma hora entre Madrid y Canarias: el momento es el mismo, pero cada reloj marca una hora distinta.

  • Si al crear la hora le das la diferencia con UTC ("+01:00"), se queda con ella, sea cual sea la configuración del ordenador.
  • Si no se la das (Time.now, Time.at, Time.new(2026, 11, 7)), usa la zona horaria del sistema. En Linux y macOS la decide la variable de entorno TZ si está definida.
t = Time.new(2026, 11, 7, 9, 5, 3, "+01:00")

puts t              # 2026-11-07 09:05:03 +0100
puts t.utc          # 2026-11-07 08:05:03 UTC
puts t.to_i         # 1794038703

Este bloque da lo mismo en cualquier ordenador, porque la hora lleva su zona. En cambio, el mismo número de segundos se muestra distinto según TZ:

TZ=Europe/Madrid ruby -e 'puts Time.at(1794038703)'
TZ=Atlantic/Canary ruby -e 'puts Time.at(1794038703)'
TZ=UTC ruby -e 'puts Time.at(1794038703)'
2026-11-07 09:05:03 +0100
2026-11-07 08:05:03 +0000
2026-11-07 08:05:03 +0000

Es el mismo instante tres veces: en Madrid son las 9:05 y en Canarias y en UTC, las 8:05. Si un servidor está en UTC y tu portátil en Europe/Madrid, el mismo código puede escribir horas distintas. Por eso, en este artículo, cuando un resultado depende de la zona del sistema se dice.

Formatear con strftime

strftime (de string format time) recibe una plantilla con códigos que empiezan por %:

t = Time.new(2026, 11, 7, 9, 5, 3, "+01:00")

puts t.strftime("%d/%m/%Y %H:%M:%S")   # 07/11/2026 09:05:03
puts t.strftime("%A")                  # Saturday
puts t.strftime("%B")                  # November
puts t.strftime("son las %H:%M %z")    # son las 09:05 +0100
puts t.strftime("%F %T")               # 2026-11-07 09:05:03
puts t.strftime("%-d/%-m/%y %I:%M %p") # 7/11/26 09:05 AM
Código Significado Ejemplo
%d Día del mes (dos cifras) 07
%-d Día del mes sin cero delante 7
%m Mes (dos cifras) 11
%Y Año con cuatro cifras 2026
%y Año con dos cifras 26
%H Hora en formato 24 horas 09
%I / %p Hora en formato 12 horas / AM o PM 09 / AM
%M Minutos 05
%S Segundos 03
%A Día de la semana Saturday
%B Nombre del mes November
%j Día del año 311
%z Diferencia con UTC +0100
%Z Nombre de la zona horaria CET
%F Atajo de %Y-%m-%d 2026-11-07
%T Atajo de %H:%M:%S 09:05:03

Dos detalles que conviene saber:

  • %A y %B salen en inglés. Ruby puro no traduce los nombres; en Rails se hace con I18n.l(fecha) y un fichero de traducciones.
  • %Z sale vacío si creaste la hora con una diferencia fija ("+01:00"). Con Time.now muestra la zona del sistema: CET con TZ=Europe/Madrid en invierno, WET con TZ=Atlantic/Canary y UTC con TZ=UTC. Si necesitas algo fiable, usa %z.

Fechas en formato ISO 8601

ISO 8601 es el formato estándar para intercambiar fechas entre programas: 2026-11-07T09:05:03+01:00. Es el que esperan la mayoría de las API y el que conviene guardar en ficheros, porque no se presta a confusiones entre día y mes y lleva la zona.

t = Time.new(2026, 11, 7, 9, 5, 3, "+01:00")

puts t.iso8601       # 2026-11-07T09:05:03+01:00
puts t.utc.iso8601   # 2026-11-07T08:05:03Z

La Z final significa UTC. Desde Ruby 3.4, Time#iso8601 (y su alias xmlschema) forma parte del núcleo de Ruby y funciona sin ningún require; en versiones anteriores había que escribir require "time".

Sumar y restar tiempo

Sumar o restar un número cambia la fecha en segundos:

nochebuena = Time.new(2026, 12, 24, 20, 0, 0, "+01:00")
puts nochebuena + 3600     # 2026-12-24 21:00:00 +0100 (una hora después)
puts nochebuena - 86400    # 2026-12-23 20:00:00 +0100 (un día antes)

Restar dos fechas devuelve los segundos que hay entre ellas. Divide entre 86 400 para tener días:

# Sigue del bloque anterior: usa nochebuena
dia_de_reyes = Time.new(2027, 1, 6, 0, 0, 0, "+01:00")
puts (dia_de_reyes - nochebuena) / 86400   # 12.166666666666666

Sale con decimales porque la Nochebuena del ejemplo empieza a las 20:00. Y para saber cuánto falta desde hoy, (nochebuena - Time.now) / 86400, que cada día dará un número distinto.

Convertir texto en fecha

Para leer una fecha escrita como texto hace falta require "time":

require "time"

Time.parse("2026-11-07 10:00")                                  # adivina el formato
Time.iso8601("2026-11-07T10:00:00+01:00")                       # exige ISO 8601
Time.strptime("07/11/2026 10:00", "%d/%m/%Y %H:%M")             # le dices tú el formato

Los tres dan el 7 de noviembre de 2026 a las 10:00. Pero ojo con la zona: el texto de Time.iso8601 lleva +01:00 y siempre da +0100; los otros dos no la llevan, así que usan la del sistema. Con TZ=Europe/Madrid salen con +0100; con TZ=UTC, con +0000.

Time.parse es cómodo, pero intenta adivinar. Si conoces el formato, strptime con su plantilla (los mismos códigos de strftime) es más seguro, y si el texto viene de otro programa, pide ISO 8601 y usa Time.iso8601.

Date: cuando solo importa el día

Para cumpleaños, festivos o fechas de entrega, la hora sobra. Date guarda solo el día, y ahí sumar 1 es sumar un día, no un segundo:

require "date"

hoy = Date.new(2026, 11, 7)
puts hoy                     # 2026-11-07
puts hoy + 1                 # 2026-11-08: con Date se suman días
puts hoy >> 1                # 2026-12-07: >> suma meses
puts (Date.new(2026, 12, 24) - hoy).to_i   # 47
puts Date.new(2026, 1, 31) >> 1            # 2026-02-28

Fíjate en la última línea: al sumar un mes al 31 de enero, Date se queda en el último día de febrero en vez de inventarse un 31 de febrero. Para pasar de uno a otro, con require "date", tienes Time#to_date y Date#to_time.

¿Y DateTime? Es una clase antigua que mezcla las dos cosas. La documentación oficial la considera obsoleta y recomienda Time, así que no hace falta para nada nuevo.

¿Buscabas times?

Si llegaste aquí buscando «times», es otra cosa: Integer#times repite un bloque varias veces.

3.times { |i| puts "Vuelta #{i}" }
# Vuelta 0
# Vuelta 1
# Vuelta 2

Lo tienes explicado con más detalle en bucles e iteradores en Ruby. Y para meter fechas dentro de textos, mira interpolación de cadenas en Ruby.

Errores frecuentes

Las salidas son de Ruby 4.0.9, recortadas a las líneas que importan; en Ruby 3.4.12 el mensaje es el mismo.

1. Usar Time.parse sin require "time". Time está siempre disponible, pero parse, strptime y Time.iso8601 vienen en una librería aparte:

Time.parse("2026-11-07 10:00")
noparse.rb:1:in '<main>': undefined method 'parse' for class Time (NoMethodError)

2. Pasarle a Time.parse algo que no es una fecha:

require "time"
Time.parse("hola")
/usr/local/lib/ruby/4.0.0/time.rb:203:in 'Time.make_time': no time information in "hola" (ArgumentError)

Si el texto viene del usuario, captura el ArgumentError (lo tienes en excepciones en Ruby).

3. Creer que Time.new avisa de los días que no existen. Avisa del mes 13, pero no del 31 de febrero: lo convierte en silencio en otro día.

Time.new(2026, 13, 1)
mes13.rb:1:in 'Time#initialize': mon out of range (ArgumentError)

En Ruby 3.4.12 la primera línea empieza por <internal:timev>:452:in 'Time#initialize' en vez de mes13.rb:1; el mensaje es el mismo.

p Time.new(2026, 2, 31)   # 2026-03-03 00:00:00 +0100 (con TZ=Europe/Madrid)

El 31 de febrero se convierte en el 3 de marzo, sin error. Date sí lo rechaza:

require "date"
Date.new(2026, 2, 31)
date31.rb:2:in 'Date#initialize': invalid date (Date::Error)

Si validas fechas que escribe alguien, compruébalas con Date (o con Date.valid_date?(2026, 2, 31), que devuelve false).

4. Sumar 86 400 segundos para «mañana a la misma hora». Casi siempre funciona, salvo el día del cambio de hora. En España, el horario de verano de 2026 terminó el domingo 25 de octubre, y ese día duró 25 horas:

sabado = Time.new(2026, 10, 24, 12, 0, 0)   # sin zona: usa la del sistema
puts sabado
puts sabado + 86400

require "date"
puts (sabado.to_date + 1)

Con TZ=Europe/Madrid sale:

2026-10-24 12:00:00 +0200
2026-10-25 11:00:00 +0100
2026-10-25

Han pasado exactamente 24 horas, pero el reloj marca las 11:00, no las 12:00. Con TZ=UTC sale 12:00 las dos veces, porque UTC no cambia de hora; por eso el error no aparece en un servidor en UTC y sí en el portátil. Si lo que quieres es «el día siguiente», suma días con Date; si lo que quieres es «dentro de 24 horas», suma segundos.

Compruébalo con un test

Un test que usa Time.now cambia de resultado cada día. La salida es pasarle la hora como parámetro y crearla en el test con su zona. Crea formato_fecha.rb:

def formato_fecha(tiempo)
  tiempo.strftime("%d/%m/%Y %H:%M")
end

Y formato_fecha_test.rb, con Minitest, que viene con Ruby:

require "minitest/autorun"
require_relative "formato_fecha"

class FormatoFechaTest < Minitest::Test
  def test_dia_y_mes_con_dos_cifras
    t = Time.new(2026, 1, 5, 9, 7, 0, "+01:00")
    assert_equal "05/01/2026 09:07", formato_fecha(t)
  end

  def test_no_depende_de_la_zona_del_sistema
    t = Time.new(2026, 11, 7, 23, 30, 0, "+01:00")
    assert_equal "07/11/2026 23:30", formato_fecha(t)
  end
end
ruby formato_fecha_test.rb
2 runs, 2 assertions, 0 failures, 0 errors, 0 skips

Pasa igual con TZ=UTC que con TZ=Pacific/Auckland, a doce horas de distancia, porque cada hora del test lleva su "+01:00". Si en el segundo test conviertes la hora a UTC antes de formatearla (formato_fecha(t.utc)), el resultado pasa a 07/11/2026 22:30 y el test falla: la misma hora, escrita en otra zona. Para empezar con tests, lee la introducción al testing en Ruby.

Cuándo no usar Time

  • Para fechas sin hora, usa Date. Te ahorras el cambio de hora y las zonas.
  • Para medir cuánto tarda algo, no restes dos Time.now: si el reloj del sistema se ajusta mientras tanto, la cuenta sale mal. Usa el reloj monotónico, que solo avanza:
inicio = Process.clock_gettime(Process::CLOCK_MONOTONIC)
sleep 0.2
fin = Process.clock_gettime(Process::CLOCK_MONOTONIC)
puts (fin - inicio).round(1)   # 0.2
  • Para zonas horarias con nombre («la hora de Madrid» en un servidor en UTC), Ruby solo no basta: entiende diferencias fijas como "+01:00" y la zona del sistema, pero no trae la base de datos de zonas. Fuera de Rails, Time acepta los objetos de zona de la gema tzinfo (versión 2.0.6, instalada con gem install tzinfo), que sí sabe cuándo cambia la hora cada zona:
require "tzinfo"

madrid = TZInfo::Timezone.get("Europe/Madrid")
t = Time.new(2026, 7, 1, 12, 0, 0, in: madrid)
puts t              # 2026-07-01 12:00:00 +0200: horario de verano
puts t.utc          # 2026-07-01 10:00:00 UTC

Da lo mismo con cualquier TZ, porque la zona va en el objeto. En Rails tienes Time.zone e in_time_zone, de Active Support, que usa tzinfo por debajo.

Ejercicio de cinco minutos

  1. Escribe con strftime la fecha de hoy con el formato 12-11-2026 (día 316 del año).
  2. Ejecuta puts Time.now con TZ=UTC y con TZ=Atlantic/Canary, y explica por qué salen las mismas cifras o no.
  3. Con Date, calcula cuántos días faltan para la próxima Nochebuena y añade un test con dos fechas fijas.

Fuentes

  • Documentación oficial de Ruby 4.0: Time, formatos de fecha y hora de strftime, Date y Process.clock_gettime. La de Time indica que la zona puede ser un objeto de zona horaria, como los de TZInfo, y que Time.new lo acepta como argumento o con in:.
  • Gema tzinfo en RubyGems: versión 2.0.6, la última publicada en noviembre de 2026.
  • DateTime (Ruby 4.0): «DateTime class is considered deprecated. Use Time class».
  • Notas de la versión de Ruby 3.4: Time#xmlschema y su alias Time#iso8601 pasan al núcleo de Time; antes los aportaba la librería time.
  • Los ejemplos del artículo original se ejecutaron con Ruby 3.4.12 (imagen oficial ruby:3.4 de Docker) en noviembre de 2026, con TZ=Europe/Madrid. Las secciones nuevas (zona horaria, ISO 8601, Date, errores frecuentes, test y reloj monotónico) se ejecutaron el 12 de noviembre de 2026 con ruby:3.4 (Ruby 3.4.12, Minitest 5.25.4) y ruby:4.0 (Ruby 4.0.9, Minitest 6.0.0), con TZ fijada a Europe/Madrid, Atlantic/Canary, UTC y, en el test, Pacific/Auckland. El ejemplo de tzinfo se ejecutó con tzinfo 2.0.6 (y concurrent-ruby 1.3.8) en las dos versiones, con TZ=UTC. Los resultados coinciden en las dos versiones; solo cambia cómo se recortan algunas trazas de error.