класс Time

# File timev.rb, line 284
def self.at(time, subsec = false, unit = :microsecond, in: nil)
  if Primitive.mandatory_only?
    Primitive.time_s_at1(time)
  else
    Primitive.time_s_at(time, subsec, unit, Primitive.arg!(:in))
  end
end

Возвращает новый объект Time на основе заданных аргументов.

Обязательный аргумент time может быть:

• Объектом Time, значение которого является основой для возвращаемого времени; также влияет на необязательный аргумент ключевого слова in: (см. ниже).

• Числовое значение секунд эпохи для возвращаемого времени.

Примеры:

t = Time.new(2000, 12, 31, 23, 59, 59) # => 2000-12-31 23:59:59 -0600
secs = t.to_i                          # => 978328799
Time.at(secs)                          # => 2000-12-31 23:59:59 -0600
Time.at(secs + 0.5)                    # => 2000-12-31 23:59:59.5 -0600
Time.at(1000000000)                    # => 2001-09-08 20:46:40 -0500
Time.at(0)                             # => 1969-12-31 18:00:00 -0600
Time.at(-1000000000)                   # => 1938-04-24 17:13:20 -0500

Необязательный числовой аргумент subsec и необязательный символьный аргумент units работают вместе, чтобы указать подсекунды для возвращаемого времени; аргумент units задаёт единицы измерения для subsec:

• :millisecond: subsec в миллисекундах:

  Time.at(secs, 0, :millisecond)     # => 2000-12-31 23:59:59 -0600
  Time.at(secs, 500, :millisecond)   # => 2000-12-31 23:59:59.5 -0600
  Time.at(secs, 1000, :millisecond)  # => 2001-01-01 00:00:00 -0600
  Time.at(secs, -1000, :millisecond) # => 2000-12-31 23:59:58 -0600
  

• :microsecond или :usec: subsec в микросекундах:

  Time.at(secs, 0, :microsecond)        # => 2000-12-31 23:59:59 -0600
  Time.at(secs, 500000, :microsecond)   # => 2000-12-31 23:59:59.5 -0600
  Time.at(secs, 1000000, :microsecond)  # => 2001-01-01 00:00:00 -0600
  Time.at(secs, -1000000, :microsecond) # => 2000-12-31 23:59:58 -0600
  

• :nanosecond или :nsec: subsec в наносекундах:

  Time.at(secs, 0, :nanosecond)           # => 2000-12-31 23:59:59 -0600
  Time.at(secs, 500000000, :nanosecond)   # => 2000-12-31 23:59:59.5 -0600
  Time.at(secs, 1000000000, :nanosecond)  # => 2001-01-01 00:00:00 -0600
  Time.at(secs, -1000000000, :nanosecond) # => 2000-12-31 23:59:58 -0600
  

Необязательный аргумент ключевого слова in: zone задаёт часовой пояс для возвращаемого времени:

Time.at(secs, in: '+12:00') # => 2001-01-01 17:59:59 +1200
Time.at(secs, in: '-12:00') # => 2000-12-31 17:59:59 -1200

Для форм аргумента zone, см. Спецификаторы часовых поясов.

# File lib/time.rb, line 566
def httpdate(date)
  if date.match?(/\A\s*
      (?:Mon|Tue|Wed|Thu|Fri|Sat|Sun),\x20
      (\d{2})\x20
      (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\x20
      (\d{4})\x20
      (\d{2}):(\d{2}):(\d{2})\x20
      GMT
      \s*\z/ix)
    self.rfc2822(date).utc
  elsif /\A\s*
         (?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday),\x20
         (\d\d)-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d\d)\x20
         (\d\d):(\d\d):(\d\d)\x20
         GMT
         \s*\z/ix =~ date
    year = $3.to_i
    if year < 50
      year += 2000
    else
      year += 1900
    end
    self.utc(year, $2, $1.to_i, $4.to_i, $5.to_i, $6.to_i)
  elsif /\A\s*
         (?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\x20
         (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\x20
         (\d\d|\x20\d)\x20
         (\d\d):(\d\d):(\d\d)\x20
         (\d{4})
         \s*\z/ix =~ date
    self.utc($6.to_i, MonthValue[$1.upcase], $2.to_i,
             $3.to_i, $4.to_i, $5.to_i)
  else
    raise ArgumentError.new("not RFC 2616 compliant date: #{date.inspect}")
  end
end

Парсит date как HTTP-дату, определённую RFC 2616, и преобразует её в объект Time.

ArgumentError генерируется, если date не соответствует RFC 2616 или если класс Time не может представить заданную дату.

См. httpdate для получения дополнительной информации об этом формате.

require 'time'

Time.httpdate("Thu, 06 Oct 2011 02:26:12 GMT")
#=> 2011-10-06 02:26:12 UTC

Для использования этого метода необходимо подключить модуль ‘time’.

# File ext/json/lib/json/add/time.rb, line 9
def self.json_create(object)
  if usec = object.delete('u') # used to be tv_usec -> tv_nsec
    object['n'] = usec * 1000
  end
  if method_defined?(:tv_nsec)
    at(object['s'], Rational(object['n'], 1000))
  else
    at(object['s'], object['n'] / 1000)
  end
end

См. as_json.

static VALUE
time_s_mktime(int argc, VALUE *argv, VALUE klass)
{
    struct vtm vtm;

    time_arg(argc, argv, &vtm);
    return time_localtime(time_new_timew(klass, timelocalw(&vtm)));
}

Аналогично Time.utc, за исключением того, что возвращаемый объект Time имеет локальный часовой пояс, а не часовой пояс UTC:

# With seven arguments.
Time.local(0, 1, 2, 3, 4, 5, 6)
# => 0000-01-02 03:04:05.000006 -0600
# With exactly ten arguments.
Time.local(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
# => 0005-04-03 02:01:00 -0600

# File timev.rb, line 395
def initialize(year = (now = true), mon = (str = year; nil), mday = nil, hour = nil, min = nil, sec = nil, zone = nil,
               in: nil, precision: 9)
  if zone
    if Primitive.arg!(:in)
      raise ArgumentError, "timezone argument given as positional and keyword arguments"
    end
  else
    zone = Primitive.arg!(:in)
  end

  if now
    return Primitive.time_init_now(zone)
  end

  if str and Primitive.time_init_parse(str, zone, precision)
    return self
  end

  Primitive.time_init_args(year, mon, mday, hour, min, sec, zone)
end

Возвращает новый объект Time на основе заданных аргументов, по умолчанию в локальном часовом поясе.

Без позиционных аргументов, возвращает значение Time.now:

Time.new # => 2021-04-24 17:27:46.0512465 -0500

С одним строковым аргументом, представляющим время, возвращает новый объект Time на основе данного аргумента, в локальном часовом поясе.

Time.new('2000-12-31 23:59:59.5')              # => 2000-12-31 23:59:59.5 -0600
Time.new('2000-12-31 23:59:59.5 +0900')        # => 2000-12-31 23:59:59.5 +0900
Time.new('2000-12-31 23:59:59.5', in: '+0900') # => 2000-12-31 23:59:59.5 +0900
Time.new('2000-12-31 23:59:59.5')              # => 2000-12-31 23:59:59.5 -0600
Time.new('2000-12-31 23:59:59.56789', precision: 3) # => 2000-12-31 23:59:59.567 -0600

С одним до шести аргументов, возвращает новый объект Time на основе заданных аргументов, в локальном часовом поясе.

Time.new(2000, 1, 2, 3, 4, 5) # => 2000-01-02 03:04:05 -0600

Для позиционных аргументов (кроме zone):

• year: Год без ограничений диапазона:

  Time.new(999999999)  # => 999999999-01-01 00:00:00 -0600
  Time.new(-999999999) # => -999999999-01-01 00:00:00 -0600
  

• month: Месяц в диапазоне (1..12) или 3-буквенное сокращённое название месяца (регистронезависимо):

  Time.new(2000, 1)     # => 2000-01-01 00:00:00 -0600
  Time.new(2000, 12)    # => 2000-12-01 00:00:00 -0600
  Time.new(2000, 'jan') # => 2000-01-01 00:00:00 -0600
  Time.new(2000, 'JAN') # => 2000-01-01 00:00:00 -0600
  

• mday: День месяца в диапазоне (1..31):

  Time.new(2000, 1, 1)  # => 2000-01-01 00:00:00 -0600
  Time.new(2000, 1, 31) # => 2000-01-31 00:00:00 -0600
  

• hour: Час в диапазоне (0..23), или 24, если min, sec, и usec равны нулю:

  Time.new(2000, 1, 1, 0)  # => 2000-01-01 00:00:00 -0600
  Time.new(2000, 1, 1, 23) # => 2000-01-01 23:00:00 -0600
  Time.new(2000, 1, 1, 24) # => 2000-01-02 00:00:00 -0600
  

• min: Минута в диапазоне (0..59):

  Time.new(2000, 1, 1, 0, 0)  # => 2000-01-01 00:00:00 -0600
  Time.new(2000, 1, 1, 0, 59) # => 2000-01-01 00:59:00 -0600
  

• sec: Секунда в диапазоне (0…61):

  Time.new(2000, 1, 1, 0, 0, 0)  # => 2000-01-01 00:00:00 -0600
  Time.new(2000, 1, 1, 0, 0, 59) # => 2000-01-01 00:00:59 -0600
  Time.new(2000, 1, 1, 0, 0, 60) # => 2000-01-01 00:01:00 -0600
  

  sec может быть Float или Rational.

  Time.new(2000, 1, 1, 0, 0, 59.5)  # => 2000-12-31 23:59:59.5 +0900
  Time.new(2000, 1, 1, 0, 0, 59.7r) # => 2000-12-31 23:59:59.7 +0900
  

Эти значения могут быть:

• Целыми числами, как указано выше.

• Числами, преобразуемыми в целые:

  Time.new(Float(0.0), Rational(1, 1), 1.0, 0.0, 0.0, 0.0)
  # => 0000-01-01 00:00:00 -0600
  

• String целыми числами:

  a = %w[0 1 1 0 0 0]
  # => ["0", "1", "1", "0", "0", "0"]
  Time.new(*a) # => 0000-01-01 00:00:00 -0600
  

Когда позиционный аргумент zone или аргумент ключевого слова in: задан, новый объект Time находится в указанном часовом поясе. Для форм аргумента zone, см. Спецификаторы часовых поясов:

Time.new(2000, 1, 1, 0, 0, 0, '+12:00')
# => 2000-01-01 00:00:00 +1200
Time.new(2000, 1, 1, 0, 0, 0, in: '-12:00')
# => 2000-01-01 00:00:00 -1200
Time.new(in: '-12:00')
# => 2022-08-23 08:49:26.1941467 -1200

Поскольку аргумент ключевого слова in: просто предоставляет значение по умолчанию, если первый аргумент в виде строки содержит информацию о часовом поясе, этот аргумент будет проигнорирован.

Time.new('2000-01-01 00:00:00 +0100', in: '-0500').utc_offset  # => 3600

• precision: максимальное количество эффективных цифр в подсекундной части, по умолчанию 9. Более цифры будут усечены, как и в других операциях с Time. Игнорируется, если первый аргумент не является строкой.

# File timev.rb, line 225
def self.now(in: nil)
  Primitive.time_s_now(Primitive.arg!(:in))
end

Создаёт новый объект Time из текущего системного времени. Это то же самое, что Time.new без аргументов.

Time.now               # => 2009-06-24 12:39:54 +0900
Time.now(in: '+04:00') # => 2009-06-24 07:39:54 +0400

Для форм аргумента zone, см. Спецификаторы часовых поясов.

# File lib/time.rb, line 381
def parse(date, now=self.now)
  comp = !block_given?
  d = Date._parse(date, comp)
  year = d[:year]
  year = yield(year) if year && !comp
  make_time(date, year, d[:yday], d[:mon], d[:mday], d[:hour], d[:min], d[:sec], d[:sec_fraction], d[:zone], now)
end

Принимает строковое представление Time и пытается разобрать его с помощью эвристики.

Этот метод **не** является валидатором. Если входная строка не строго соответствует допустимым форматам, вы можете получить криптическую информацию. Вместо этого метода следует использовать ‘Time.strptime`.

require 'time'

Time.parse("2010-10-31") #=> 2010-10-31 00:00:00 -0500

Пропущенные части даты выводятся на основе текущей даты.

require 'time'

# assuming the current date is "2011-10-31"
Time.parse("12:00") #=> 2011-10-31 12:00:00 -0500

Мы можем изменить дату, используемую для вывода пропущенных элементов, передав второй объект, который отвечает на mon, day и year, например, Date, Time или DateTime. Мы также можем использовать собственный объект.

require 'time'

class MyDate
  attr_reader :mon, :day, :year

  def initialize(mon, day, year)
    @mon, @day, @year = mon, day, year
  end
end

d  = Date.parse("2010-10-28")
t  = Time.parse("2010-10-29")
dt = DateTime.parse("2010-10-30")
md = MyDate.new(10,31,2010)

Time.parse("12:00", d)  #=> 2010-10-28 12:00:00 -0500
Time.parse("12:00", t)  #=> 2010-10-29 12:00:00 -0500
Time.parse("12:00", dt) #=> 2010-10-30 12:00:00 -0500
Time.parse("12:00", md) #=> 2010-10-31 12:00:00 -0500

Если блок задан, год, описанный в date, преобразуется блоком. Это специально разработано для обработки двухзначных годов. Например, если вы хотите рассматривать все двухзначные годы до 70 как год 2000+, вы можете написать так:

require 'time'

Time.parse("01-10-31") {|year| year + (year < 70 ? 2000 : 1900)}
#=> 2001-10-31 00:00:00 -0500
Time.parse("70-10-31") {|year| year + (year < 70 ? 2000 : 1900)}
#=> 1970-10-31 00:00:00 -0500

Если верхние компоненты заданного времени нарушены или отсутствуют, они дополняются компонентами now. Для нижних компонентов предполагаются минимальные значения (1 или 0), если они нарушены или отсутствуют. Например:

require 'time'

# Suppose it is "Thu Nov 29 14:33:20 2001" now and
# your time zone is EST which is GMT-5.
now = Time.parse("Thu Nov 29 14:33:20 2001")
Time.parse("16:30", now)     #=> 2001-11-29 16:30:00 -0500
Time.parse("7/23", now)      #=> 2001-07-23 00:00:00 -0500
Time.parse("Aug 31", now)    #=> 2001-08-31 00:00:00 -0500
Time.parse("Aug 2000", now)  #=> 2000-08-01 00:00:00 -0500

Поскольку существует множество конфликтов между локальными сокращениями часовых поясов по всему миру, этот метод не предназначен для понимания всех из них. Например, сокращение «CST» используется по-разному:

-06:00 in America/Chicago,
-05:00 in America/Havana,
+08:00 in Asia/Harbin,
+09:30 in Australia/Darwin,
+10:30 in Australia/Adelaide,
etc.

Исходя из этого, этот метод понимает только сокращения часовых поясов, описанные в RFC 822 и системном часовом поясе, в указанном порядке. (т. е. определение в RFC 822 переопределяет определение системного часового пояса). Системный часовой пояс берется из Time.local(year, 1, 1).zone и Time.local(year, 7, 1).zone. Если выделенное сокращение часового пояса не соответствует ни одному из них, оно игнорируется, и заданное время рассматривается как местное.

ArgumentError генерируется, если Date._parse не может извлечь информацию из date или если класс Time не может представить заданную дату.

Этот метод может использоваться как защита от сбоев для других методов парсинга, например:

Time.rfc2822(date) rescue Time.parse(date)
Time.httpdate(date) rescue Time.parse(date)
Time.xmlschema(date) rescue Time.parse(date)

Однако необходимо проверять успешность выполнения Time.parse.

Для использования этого метода необходимо подключить модуль ‘time’.

# File lib/time.rb, line 508
def rfc2822(date)
  if /\A\s*
      (?:(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s*,\s*)?
      (\d{1,2})\s+
      (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+
      (\d{2,})\s+
      (\d{2})\s*
      :\s*(\d{2})
      (?:\s*:\s*(\d\d))?\s+
      ([+-]\d{4}|
       UT|GMT|EST|EDT|CST|CDT|MST|MDT|PST|PDT|[A-IK-Z])/ix =~ date
    # Since RFC 2822 permit comments, the regexp has no right anchor.
    day = $1.to_i
    mon = MonthValue[$2.upcase]
    year = $3.to_i
    short_year_p = $3.length <= 3
    hour = $4.to_i
    min = $5.to_i
    sec = $6 ? $6.to_i : 0
    zone = $7

    if short_year_p
      # following year completion is compliant with RFC 2822.
      year = if year < 50
               2000 + year
             else
               1900 + year
             end
    end

    off = zone_offset(zone)
    year, mon, day, hour, min, sec =
      apply_offset(year, mon, day, hour, min, sec, off)
    t = self.utc(year, mon, day, hour, min, sec)
    force_zone!(t, zone, off)
    t
  else
    raise ArgumentError.new("not RFC 2822 compliant date: #{date.inspect}")
  end
end

Парсит date как дату и время, определенные в RFC 2822, и преобразует ее в объект Time. Формат идентичен формату даты, определенному в RFC 822 и обновленному в RFC 1123.

ArgumentError генерируется, если date не соответствует RFC 2822 или если класс Time не может представить заданную дату.

См. rfc2822 для получения дополнительной информации об этом формате.

require 'time'

Time.rfc2822("Wed, 05 Oct 2011 22:26:12 -0400")
#=> 2010-10-05 22:26:12 -0400

Для использования этого метода необходимо подключить модуль ‘time’.

# File lib/time.rb, line 456
def strptime(date, format, now=self.now)
  d = Date._strptime(date, format)
  raise ArgumentError, "invalid date or strptime format - `#{date}' `#{format}'" unless d
  if seconds = d[:seconds]
    if sec_fraction = d[:sec_fraction]
      usec = sec_fraction * 1000000
      usec *= -1 if seconds < 0
    else
      usec = 0
    end
    t = Time.at(seconds, usec)
    if zone = d[:zone]
      force_zone!(t, zone)
    end
  else
    year = d[:year]
    year = yield(year) if year && block_given?
    yday = d[:yday]
    if (d[:cwyear] && !year) || ((d[:cwday] || d[:cweek]) && !(d[:mon] && d[:mday]))
      # make_time doesn't deal with cwyear/cwday/cweek
      return Date.strptime(date, format).to_time
    end
    if (d[:wnum0] || d[:wnum1]) && !yday && !(d[:mon] && d[:mday])
      yday = Date.strptime(date, format).yday
    end
    t = make_time(date, year, yday, d[:mon], d[:mday], d[:hour], d[:min], d[:sec], d[:sec_fraction], d[:zone], now)
  end
  t
end

Работает аналогично parse за исключением того, что вместо использования эвристики для определения формата входной строки, вы предоставляете второй аргумент, описывающий формат строки.

Если блок задан, год, описанный в date, преобразуется блоком. Например:

Time.strptime(...) {|y| y < 100 ? (y >= 69 ? y + 1900 : y + 2000) : y}

Ниже приведен список опций форматирования:

%a

Сокращенное имя дня недели (“Вс”)

%A

Полное имя дня недели (“Воскресенье”)

%b

Сокращенное имя месяца (“Янв”)

%B

Полное имя месяца (“Январь”)

%c

Предпочтительная локальная запись даты и времени

%C

Века (20 в 2009)

%d

Число месяца (01..31)

%D

Date (%m/%d/%y)

%e

Число месяца, заполненное пробелами ( 1..31)

%F

Эквивалентно %Y-%m-%d (формат даты ISO 8601)

%g

Последние две цифры коммерческого года

%G

Год по ISO-8601 (неделя 1 начинается с понедельника и включает 4 января)

%h

Эквивалентно %b

%H

Часы в 24-часовом формате (00..23)

%I

Часы в 12-часовом формате (01..12)

%j

Номер дня в году (001..366)

%k

Часы в 24-часовом формате, заполненные пробелами ( 0..23)

%l

Часы в 12-часовом формате, заполненные пробелами ( 0..12)

%L

Миллисекунда (000..999)

%m

Номер месяца (01..12)

%M

Минуты (00..59)

%n

Новая строка (n)

%N

Цифры дробных секунд

%p

Индикатор полудня (“AM” или “PM”)

%P

Индикатор полудня (“am” или “pm”)

%r

Время в 12-часовом формате (то же, что и %I:%M:%S %p)

%R

Время в 24-часовом формате (%H:%M)

%s

Количество секунд с 1970-01-01 00:00:00 UTC.

%S

Секунды (00..60)

%t

Символ табуляции (t)

%T

Время в 24-часовом формате (%H:%M:%S)

%u

День недели в виде числа, понедельник — 1. (1..7)

%U

Номер недели в текущем году, начиная с первого воскресенья как первого дня первой недели (00..53)

%v

Дата VMS (%e-%b-%Y)

%V

Номер недели в году по ISO 8601 (01..53)

%W

Номер недели в текущем году, начиная с первого понедельника как первого дня первой недели (00..53)

%w

День недели (воскресенье — 0, 0..6)

%x

Предпочтительное представление даты без времени

%X

Предпочтительное представление времени без даты

%y

Год без века (00..99)

%Y

Год, который может включать век, если указан

%z

Time часовой пояс как смещение от UTC в часах (например, +0900)

%Z

Имя Time часового пояса

%%

Буквальный символ “%”

%+

date(1) (%a %b %e %H:%M:%S %Z %Y)

require 'time'

Time.strptime("2000-10-31", "%Y-%m-%d") #=> 2000-10-31 00:00:00 -0500

Для использования этого метода необходимо подключить модуль ‘time’.

static VALUE
time_s_mkutc(int argc, VALUE *argv, VALUE klass)
{
    struct vtm vtm;

    time_arg(argc, argv, &vtm);
    return time_gmtime(time_new_timew(klass, timegmw(&vtm)));
}

Возвращает новый объект Time на основе заданных аргументов в часовом поясе UTC.

При передаче от одного до семи аргументов, аргументы интерпретируются, как в первом вызове выше:

Time.utc(year, month = 1, mday = 1, hour = 0, min = 0, sec = 0, usec = 0)

Примеры:

Time.utc(2000)  # => 2000-01-01 00:00:00 UTC
Time.utc(-2000) # => -2000-01-01 00:00:00 UTC

Для обязательных аргументов нет минимальных и максимальных значений.

Для необязательных аргументов:

• month: Месяц в диапазоне (1..12), или имя месяца в сокращенном виде (3 буквы):

  Time.utc(2000, 1)     # => 2000-01-01 00:00:00 UTC
  Time.utc(2000, 12)    # => 2000-12-01 00:00:00 UTC
  Time.utc(2000, 'jan') # => 2000-01-01 00:00:00 UTC
  Time.utc(2000, 'JAN') # => 2000-01-01 00:00:00 UTC
  

• mday: День месяца в диапазоне (1..31):

  Time.utc(2000, 1, 1)  # => 2000-01-01 00:00:00 UTC
  Time.utc(2000, 1, 31) # => 2000-01-31 00:00:00 UTC
  

• hour: Часы в диапазоне (0..23), или 24, если min, sec, и usec равны нулю:

  Time.utc(2000, 1, 1, 0)  # => 2000-01-01 00:00:00 UTC
  Time.utc(2000, 1, 1, 23) # => 2000-01-01 23:00:00 UTC
  Time.utc(2000, 1, 1, 24) # => 2000-01-02 00:00:00 UTC
  

• min: Минуты в диапазоне (0..59):

  Time.utc(2000, 1, 1, 0, 0)  # => 2000-01-01 00:00:00 UTC
  Time.utc(2000, 1, 1, 0, 59) # => 2000-01-01 00:59:00 UTC
  

• sec: Секунды в диапазоне (0..59), или 60, если usec равно нулю:

  Time.utc(2000, 1, 1, 0, 0, 0)  # => 2000-01-01 00:00:00 UTC
  Time.utc(2000, 1, 1, 0, 0, 59) # => 2000-01-01 00:00:59 UTC
  Time.utc(2000, 1, 1, 0, 0, 60) # => 2000-01-01 00:01:00 UTC
  

• usec: Микросекунды в диапазоне (0..999999):

  Time.utc(2000, 1, 1, 0, 0, 0, 0)      # => 2000-01-01 00:00:00 UTC
  Time.utc(2000, 1, 1, 0, 0, 0, 999999) # => 2000-01-01 00:00:00.999999 UTC
  

Значения могут быть:

• Целыми числами, как указано выше.

• Числами, преобразуемыми в целые числа.

• String целыми числами:

Когда передаются ровно десять аргументов, аргументы интерпретируются, как во втором вызове выше:

Time.utc(sec, min, hour, mday, month, year, dummy, dummy, dummy, dummy)

где аргументы dummy игнорируются:

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Time.utc(*a) # => 0005-04-03 02:01:00 UTC

Эта форма полезна для создания объекта Time из 10-элементного массива, возвращаемого Time.to_a:

t = Time.new(2000, 1, 2, 3, 4, 5, 6) # => 2000-01-02 03:04:05 +000006
a = t.to_a   # => [5, 4, 3, 2, 1, 2000, 0, 2, false, nil]
Time.utc(*a) # => 2000-01-02 03:04:05 UTC

Обе формы имеют первые шесть аргументов общие, хотя в разном порядке; диапазоны этих общих аргументов одинаковы для обеих форм; см. выше.

Выбрасывает исключение, если количество аргументов равно восьми, девяти или больше десяти.

Связанное: Time.local.

# File lib/time.rb, line 620
def xmlschema(time)
  if /\A\s*
      (-?\d+)-(\d\d)-(\d\d)
      T
      (\d\d):(\d\d):(\d\d)
      (\.\d+)?
      (Z|[+-]\d\d(?::?\d\d)?)?
      \s*\z/ix =~ time
    year = $1.to_i
    mon = $2.to_i
    day = $3.to_i
    hour = $4.to_i
    min = $5.to_i
    sec = $6.to_i
    usec = 0
    if $7
      usec = Rational($7) * 1000000
    end
    if $8
      zone = $8
      off = zone_offset(zone)
      year, mon, day, hour, min, sec =
        apply_offset(year, mon, day, hour, min, sec, off)
      t = self.utc(year, mon, day, hour, min, sec, usec)
      force_zone!(t, zone, off)
      t
    else
      self.local(year, mon, day, hour, min, sec, usec)
    end
  else
    raise ArgumentError.new("invalid xmlschema format: #{time.inspect}")
  end
end

Парсит time как dateTime, определённый XML Schema, и преобразует его в объект Time. Формат — ограниченная версия формата, определённого в ISO 8601.

ArgumentError возникает, если time не соответствует формату или если класс Time не может представить указанное время.

См. xmlschema для получения дополнительной информации об этом формате.

require 'time'

Time.xmlschema("2011-10-05T22:26:12-04:00")
#=> 2011-10-05 22:26:12-04:00

Для использования этого метода необходимо загрузить модуль «time».

# File lib/time.rb, line 82
def zone_offset(zone, year=self.now.year)
  off = nil
  zone = zone.upcase
  if /\A([+-])(\d\d)(:?)(\d\d)(?:\3(\d\d))?\z/ =~ zone
    off = ($1 == '-' ? -1 : 1) * (($2.to_i * 60 + $4.to_i) * 60 + $5.to_i)
  elsif zone.match?(/\A[+-]\d\d\z/)
    off = zone.to_i * 3600
  elsif ZoneOffset.include?(zone)
    off = ZoneOffset[zone] * 3600
  elsif ((t = self.local(year, 1, 1)).zone.upcase == zone rescue false)
    off = t.utc_offset
  elsif ((t = self.local(year, 7, 1)).zone.upcase == zone rescue false)
    off = t.utc_offset
  end
  off
end

Возвращает разницу во времени, в секундах, между указанной часовой зоной и UTC.

Numeric часовые зоны, включающие минуты, такие как -10:00 или +1330, будут работать, как и более простые часовые зоны только с часами, такие как -10 или +13.

Также поддерживаются текстовые часовые зоны, перечисленные в ZoneOffset.

Если часовая зона не соответствует ни одному из вышеперечисленных вариантов, zone_offset проверит, соответствует ли местная часовая зона (с учётом и без учёта потенциальных изменений летнего времени) zone. Указание значения для year изменит год, используемый для определения местной часовой зоны.

Если zone_offset не сможет определить смещение, будет возвращено значение nil.

require 'time'

Time.zone_offset("EST") #=> -18000

Для использования этого метода необходимо загрузить модуль «time».

static VALUE
time_plus(VALUE time1, VALUE time2)
{
    struct time_object *tobj;
    GetTimeval(time1, tobj);

    if (IsTimeval(time2)) {
        rb_raise(rb_eTypeError, "time + time?");
    }
    return time_add(tobj, time1, time2, 1);
}

Возвращает новый объект Time, значение которого равно сумме числового значения self и заданного numeric:

t = Time.new(2000) # => 2000-01-01 00:00:00 -0600
t + (60 * 60 * 24) # => 2000-01-02 00:00:00 -0600
t + 0.5            # => 2000-01-01 00:00:00.5 -0600

Связанно с: Time#-.

static VALUE
time_minus(VALUE time1, VALUE time2)
{
    struct time_object *tobj;

    GetTimeval(time1, tobj);
    if (IsTimeval(time2)) {
        struct time_object *tobj2;

        GetTimeval(time2, tobj2);
        return rb_Float(rb_time_unmagnify_to_float(wsub(tobj->timew, tobj2->timew)));
    }
    return time_add(tobj, time1, time2, -1);
}

Когда задано numeric, возвращает новый объект Time, значение которого равно разности числового значения self и numeric:

t = Time.new(2000) # => 2000-01-01 00:00:00 -0600
t - (60 * 60 * 24) # => 1999-12-31 00:00:00 -0600
t - 0.5            # => 1999-12-31 23:59:59.5 -0600

Когда задан other_time, возвращает Float, значение которого равно разнице числовых значений self и other_time в секундах:

t - t # => 0.0

Связанно с: Time#+.

static VALUE
time_cmp(VALUE time1, VALUE time2)
{
    struct time_object *tobj1, *tobj2;
    int n;

    GetTimeval(time1, tobj1);
    if (IsTimeval(time2)) {
        GetTimeval(time2, tobj2);
        n = wcmp(tobj1->timew, tobj2->timew);
    }
    else {
        return rb_invcmp(time1, time2);
    }
    if (n == 0) return INT2FIX(0);
    if (n > 0) return INT2FIX(1);
    return INT2FIX(-1);
}

Сравнивает self с other_time; возвращает:

• -1, если self меньше other_time.

• 0, если self равно other_time.

• 1, если self больше other_time.

• nil, если self и other_time несравнимы.

Примеры:

t = Time.now     # => 2007-11-19 08:12:12 -0600
t2 = t + 2592000 # => 2007-12-19 08:12:12 -0600
t <=> t2         # => -1
t2 <=> t         # => 1

t = Time.now     # => 2007-11-19 08:13:38 -0600
t2 = t + 0.1     # => 2007-11-19 08:13:38 -0600
t.nsec           # => 98222999
t2.nsec          # => 198222999
t <=> t2         # => -1
t2 <=> t         # => 1
t <=> t          # => 0

# File ext/json/lib/json/add/time.rb, line 36
def as_json(*)
  nanoseconds = [ tv_usec * 1000 ]
  respond_to?(:tv_nsec) and nanoseconds << tv_nsec
  nanoseconds = nanoseconds.max
  {
    JSON.create_id => self.class.name,
    's'            => tv_sec,
    'n'            => nanoseconds,
  }
end

Методы Time#as_json и Time.json_create могут быть использованы для сериализации и десериализации объекта Time; см. Marshal.

Метод Time#as_json сериализует self, возвращая хеш из 2 элементов, представляющий self:

require 'json/add/time'
x = Time.now.as_json
# => {"json_class"=>"Time", "s"=>1700931656, "n"=>472846644}

Метод JSON.create десериализует такой хеш, возвращая объект Time:

Time.json_create(x)
# => 2023-11-25 11:00:56.472846644 -0600

static VALUE
time_ceil(int argc, VALUE *argv, VALUE time)
{
    VALUE ndigits, v, den;
    struct time_object *tobj;

    if (!rb_check_arity(argc, 0, 1) || NIL_P(ndigits = argv[0]))
        den = INT2FIX(1);
    else
        den = ndigits_denominator(ndigits);

    GetTimeval(time, tobj);
    v = w2v(rb_time_unmagnify(tobj->timew));

    v = modv(v, den);
    if (!rb_equal(v, INT2FIX(0))) {
        v = subv(den, v);
    }
    return time_add(tobj, time, v, 1);
}

Возвращает новый объект Time , численное значение которого больше или равно self, с усеченными до точности ndigits секундами:

t = Time.utc(2010, 3, 30, 5, 43, 25.123456789r)
t          # => 2010-03-30 05:43:25.123456789 UTC
t.ceil     # => 2010-03-30 05:43:26 UTC
t.ceil(2)  # => 2010-03-30 05:43:25.13 UTC
t.ceil(4)  # => 2010-03-30 05:43:25.1235 UTC
t.ceil(6)  # => 2010-03-30 05:43:25.123457 UTC
t.ceil(8)  # => 2010-03-30 05:43:25.12345679 UTC
t.ceil(10) # => 2010-03-30 05:43:25.123456789 UTC

t = Time.utc(1999, 12, 31, 23, 59, 59)
t              # => 1999-12-31 23:59:59 UTC
(t + 0.4).ceil # => 2000-01-01 00:00:00 UTC
(t + 0.9).ceil # => 2000-01-01 00:00:00 UTC
(t + 1.4).ceil # => 2000-01-01 00:00:01 UTC
(t + 1.9).ceil # => 2000-01-01 00:00:01 UTC

Связанно с: Time#floor, Time#round.

static VALUE
time_asctime(VALUE time)
{
    return strftimev("%a %b %e %T %Y", time, rb_usascii_encoding());
}

Возвращает строковое представление self, отформатированное в соответствии с strftime('%a %b %e %T %Y') или его сокращенным вариантом strftime('%c'); см. Форматы дат и времени:

t = Time.new(2000, 12, 31, 23, 59, 59, 0.5)
t.ctime                      # => "Sun Dec 31 23:59:59 2000"
t.strftime('%a %b %e %T %Y') # => "Sun Dec 31 23:59:59 2000"
t.strftime('%c')             # => "Sun Dec 31 23:59:59 2000"

Связанно с: Time#to_s, Time#inspect:

t.inspect                    # => "2000-12-31 23:59:59.5 +000001"
t.to_s                       # => "2000-12-31 23:59:59 +0000"

static VALUE
time_deconstruct_keys(VALUE time, VALUE keys)
{
    struct time_object *tobj;
    VALUE h;
    long i;

    GetTimeval(time, tobj);
    MAKE_TM_ENSURE(time, tobj, tobj->vtm.yday != 0);

    if (NIL_P(keys)) {
        h = rb_hash_new_with_size(11);

        rb_hash_aset(h, sym_year, tobj->vtm.year);
        rb_hash_aset(h, sym_month, INT2FIX(tobj->vtm.mon));
        rb_hash_aset(h, sym_day, INT2FIX(tobj->vtm.mday));
        rb_hash_aset(h, sym_yday, INT2FIX(tobj->vtm.yday));
        rb_hash_aset(h, sym_wday, INT2FIX(tobj->vtm.wday));
        rb_hash_aset(h, sym_hour, INT2FIX(tobj->vtm.hour));
        rb_hash_aset(h, sym_min, INT2FIX(tobj->vtm.min));
        rb_hash_aset(h, sym_sec, INT2FIX(tobj->vtm.sec));
        rb_hash_aset(h, sym_subsec,
                     quov(w2v(wmod(tobj->timew, WINT2FIXWV(TIME_SCALE))), INT2FIX(TIME_SCALE)));
        rb_hash_aset(h, sym_dst, RBOOL(tobj->vtm.isdst));
        rb_hash_aset(h, sym_zone, time_zone(time));

        return h;
    }
    if (UNLIKELY(!RB_TYPE_P(keys, T_ARRAY))) {
        rb_raise(rb_eTypeError,
                 "wrong argument type %"PRIsVALUE" (expected Array or nil)",
                 rb_obj_class(keys));

    }

    h = rb_hash_new_with_size(RARRAY_LEN(keys));

    for (i=0; i<RARRAY_LEN(keys); i++) {
        VALUE key = RARRAY_AREF(keys, i);

        if (sym_year == key) rb_hash_aset(h, key, tobj->vtm.year);
        if (sym_month == key) rb_hash_aset(h, key, INT2FIX(tobj->vtm.mon));
        if (sym_day == key) rb_hash_aset(h, key, INT2FIX(tobj->vtm.mday));
        if (sym_yday == key) rb_hash_aset(h, key, INT2FIX(tobj->vtm.yday));
        if (sym_wday == key) rb_hash_aset(h, key, INT2FIX(tobj->vtm.wday));
        if (sym_hour == key) rb_hash_aset(h, key, INT2FIX(tobj->vtm.hour));
        if (sym_min == key) rb_hash_aset(h, key, INT2FIX(tobj->vtm.min));
        if (sym_sec == key) rb_hash_aset(h, key, INT2FIX(tobj->vtm.sec));
        if (sym_subsec == key) {
            rb_hash_aset(h, key, quov(w2v(wmod(tobj->timew, WINT2FIXWV(TIME_SCALE))), INT2FIX(TIME_SCALE)));
        }
        if (sym_dst == key) rb_hash_aset(h, key, RBOOL(tobj->vtm.isdst));
        if (sym_zone == key) rb_hash_aset(h, key, time_zone(time));
    }
    return h;
}

Возвращает хеш пар имя/значение, для использования в сопоставлении с шаблоном. Возможные ключи: :year, :month, :day, :yday, :wday, :hour, :min, :sec, :subsec, :dst, :zone.

Возможные использования:

t = Time.utc(2022, 10, 5, 21, 25, 30)

if t in wday: 3, day: ..7  # uses deconstruct_keys underneath
  puts "first Wednesday of the month"
end
#=> prints "first Wednesday of the month"

case t
in year: ...2022
  puts "too old"
in month: ..9
  puts "quarter 1-3"
in wday: 1..5, month:
  puts "working day in month #{month}"
end
#=> prints "working day in month 10"

Обратите внимание, что деконструкцию по шаблону также можно объединить с проверкой класса:

if t in Time(wday: 3, day: ..7)
  puts "first Wednesday of the month"
end

static VALUE
time_eql(VALUE time1, VALUE time2)
{
    struct time_object *tobj1, *tobj2;

    GetTimeval(time1, tobj1);
    if (IsTimeval(time2)) {
        GetTimeval(time2, tobj2);
        return rb_equal(w2v(tobj1->timew), w2v(tobj2->timew));
    }
    return Qfalse;
}

Возвращает true , если self и other_time являются объектами Time с точно таким же значением времени.

static VALUE
time_floor(int argc, VALUE *argv, VALUE time)
{
    VALUE ndigits, v, den;
    struct time_object *tobj;

    if (!rb_check_arity(argc, 0, 1) || NIL_P(ndigits = argv[0]))
        den = INT2FIX(1);
    else
        den = ndigits_denominator(ndigits);

    GetTimeval(time, tobj);
    v = w2v(rb_time_unmagnify(tobj->timew));

    v = modv(v, den);
    return time_add(tobj, time, v, -1);
}

Возвращает новый объект Time , численное значение которого меньше или равно self, с усеченными до точности ndigits секундами:

t = Time.utc(2010, 3, 30, 5, 43, 25.123456789r)
t           # => 2010-03-30 05:43:25.123456789 UTC
t.floor     # => 2010-03-30 05:43:25 UTC
t.floor(2)  # => 2010-03-30 05:43:25.12 UTC
t.floor(4)  # => 2010-03-30 05:43:25.1234 UTC
t.floor(6)  # => 2010-03-30 05:43:25.123456 UTC
t.floor(8)  # => 2010-03-30 05:43:25.12345678 UTC
t.floor(10) # => 2010-03-30 05:43:25.123456789 UTC

t = Time.utc(1999, 12, 31, 23, 59, 59)
t               # => 1999-12-31 23:59:59 UTC
(t + 0.4).floor # => 1999-12-31 23:59:59 UTC
(t + 0.9).floor # => 1999-12-31 23:59:59 UTC
(t + 1.4).floor # => 2000-01-01 00:00:00 UTC
(t + 1.9).floor # => 2000-01-01 00:00:00 UTC

Связанно с: Time#ceil, Time#round.

static VALUE
time_friday(VALUE time)
{
    wday_p(5);
}

Возвращает true , если self представляет пятницу, false в противном случае:

t = Time.utc(2000, 1, 7) # => 2000-01-07 00:00:00 UTC
t.friday?                # => true

Связанно с: Time#saturday?, Time#sunday?, Time#monday?.

static VALUE
time_getlocaltime(int argc, VALUE *argv, VALUE time)
{
    VALUE off;

    if (rb_check_arity(argc, 0, 1) && !NIL_P(off = argv[0])) {
        VALUE zone = off;
        if (maybe_tzobj_p(zone)) {
            VALUE t = time_dup(time);
            if (zone_localtime(off, t)) return t;
        }

        if (NIL_P(off = utc_offset_arg(off))) {
            off = zone;
            if (NIL_P(zone = find_timezone(time, off))) invalid_utc_offset(off);
            time = time_dup(time);
            if (!zone_localtime(zone, time)) invalid_utc_offset(off);
            return time;
        }
        else if (off == UTC_ZONE) {
            return time_gmtime(time_dup(time));
        }
        validate_utc_offset(off);

        time = time_dup(time);
        time_set_utc_offset(time, off);
        return time_fixoff(time);
    }

    return time_localtime(time_dup(time));
}

Возвращает новый объект Time , представляющий значение self , преобразованное в заданную часовую зону; если zone равно nil, используется локальная часовая зона:

t = Time.utc(2000)                    # => 2000-01-01 00:00:00 UTC
t.getlocal                            # => 1999-12-31 18:00:00 -0600
t.getlocal('+12:00')                  # => 2000-01-01 12:00:00 +1200

Для форм аргумента zone, см. Спецификаторы часовых зон.

static VALUE
time_hash(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return rb_hash(w2v(tobj->timew));
}

Возвращает целочисленный код хэша для self.

Связанно с: Object#hash.

static VALUE
time_hour(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    return INT2FIX(tobj->vtm.hour);
}

Возвращает целое значение часа дня для self, в диапазоне (0..23):

t = Time.new(2000, 1, 2, 3, 4, 5, 6)
# => 2000-01-02 03:04:05 +000006
t.hour # => 3

Связанно с: Time#year, Time#mon, Time#min.

# File lib/time.rb, line 692
def httpdate
  getutc.strftime('%a, %d %b %Y %T GMT')
end

Возвращает строку, представляющую время как дату RFC 1123 в формате HTTP-date, определённом RFC 2616:

day-of-week, DD month-name CCYY hh:mm:ss GMT

Обратите внимание, что результат всегда UTC (GMT).

require 'time'

t = Time.now
t.httpdate # => "Thu, 06 Oct 2011 02:26:12 GMT"

Для использования этого метода необходимо подключить модуль 'time'.

static VALUE
time_inspect(VALUE time)
{
    struct time_object *tobj;
    VALUE str, subsec;

    GetTimeval(time, tobj);
    str = strftimev("%Y-%m-%d %H:%M:%S", time, rb_usascii_encoding());
    subsec = w2v(wmod(tobj->timew, WINT2FIXWV(TIME_SCALE)));
    if (subsec == INT2FIX(0)) {
    }
    else if (FIXNUM_P(subsec) && FIX2LONG(subsec) < TIME_SCALE) {
        long len;
        rb_str_catf(str, ".%09ld", FIX2LONG(subsec));
        for (len=RSTRING_LEN(str); RSTRING_PTR(str)[len-1] == '0' && len > 0; len--)
            ;
        rb_str_resize(str, len);
    }
    else {
        rb_str_cat_cstr(str, " ");
        subsec = quov(subsec, INT2FIX(TIME_SCALE));
        rb_str_concat(str, rb_obj_as_string(subsec));
    }
    if (TZMODE_UTC_P(tobj)) {
        rb_str_cat_cstr(str, " UTC");
    }
    else {
        /* ?TODO: subsecond offset */
        long off = NUM2LONG(rb_funcall(tobj->vtm.utc_offset, rb_intern("round"), 0));
        char sign = (off < 0) ? (off = -off, '-') : '+';
        int sec = off % 60;
        int min = (off /= 60) % 60;
        off /= 60;
        rb_str_catf(str, " %c%.2d%.2d", sign, (int)off, min);
        if (sec) rb_str_catf(str, "%.2d", sec);
    }
    return str;
}

Возвращает строковое представление self с дробными секундами:

t = Time.new(2000, 12, 31, 23, 59, 59, 0.5)
t.inspect # => "2000-12-31 23:59:59.5 +000001"

Связанно с: Time#ctime, Time#to_s:

t.ctime   # => "Sun Dec 31 23:59:59 2000"
t.to_s    # => "2000-12-31 23:59:59 +0000"

static VALUE
time_localtime_m(int argc, VALUE *argv, VALUE time)
{
    VALUE off;

    if (rb_check_arity(argc, 0, 1) && !NIL_P(off = argv[0])) {
        return time_zonelocal(time, off);
    }

    return time_localtime(time);
}

Без аргумента:

• Возвращает self если self является локальным временем.

• В противном случае возвращает новый Time в часовом поясе пользователя:

  t = Time.utc(2000, 1, 1, 20, 15, 1) # => 2000-01-01 20:15:01 UTC
  t.localtime                         # => 2000-01-01 14:15:01 -0600
  

С аргументом zone , возвращает новый объект Time , созданный путём преобразования self в заданный часовой пояс:

t = Time.utc(2000, 1, 1, 20, 15, 1) # => 2000-01-01 20:15:01 UTC
t.localtime("-09:00")               # => 2000-01-01 11:15:01 -0900

Форматы аргумента zone, смотрите в Спецификаторы часовых поясов.

static VALUE
time_min(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    return INT2FIX(tobj->vtm.min);
}

Возвращает целое значение минуты для self, в диапазоне (0..59):

t = Time.new(2000, 1, 2, 3, 4, 5, 6)
# => 2000-01-02 03:04:05 +000006
t.min # => 4

Связанно с: Time#year, Time#mon, Time#sec.

static VALUE
time_mon(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    return INT2FIX(tobj->vtm.mon);
}

Возвращает целое значение месяца для self, в диапазоне (1..12):

t = Time.new(2000, 1, 2, 3, 4, 5, 6)
# => 2000-01-02 03:04:05 +000006
t.mon # => 1

Связанно с: Time#year, Time#hour, Time#min.

static VALUE
time_monday(VALUE time)
{
    wday_p(1);
}

Возвращает true если self представляет собой понедельник, false в противном случае:

t = Time.utc(2000, 1, 3) # => 2000-01-03 00:00:00 UTC
t.monday?                # => true

Связанно с: Time#tuesday?, Time#wednesday?, Time#thursday?.

# File lib/time.rb, line 672
def rfc2822
  strftime('%a, %d %b %Y %T ') << (utc? ? '-0000' : strftime('%z'))
end

Возвращает строку, представляющую время в формате даты и времени RFC 2822:

day-of-week, DD month-name CCYY hh:mm:ss zone

где зона — [+-]ччмм.

Если self — время UTC, используется -0000 как зона.

require 'time'

t = Time.now
t.rfc2822  # => "Wed, 05 Oct 2011 22:26:12 -0400"

Для использования этого метода необходимо подключить модуль 'time'.

static VALUE
time_round(int argc, VALUE *argv, VALUE time)
{
    VALUE ndigits, v, den;
    struct time_object *tobj;

    if (!rb_check_arity(argc, 0, 1) || NIL_P(ndigits = argv[0]))
        den = INT2FIX(1);
    else
        den = ndigits_denominator(ndigits);

    GetTimeval(time, tobj);
    v = w2v(rb_time_unmagnify(tobj->timew));

    v = modv(v, den);
    if (lt(v, quov(den, INT2FIX(2))))
        return time_add(tobj, time, v, -1);
    else
        return time_add(tobj, time, subv(den, v), 1);
}

Возвращает новый объект Time , числовое значение которого соответствует значению self, с округлением значения секунд до точности ndigits:

t = Time.utc(2010, 3, 30, 5, 43, 25.123456789r)
t          # => 2010-03-30 05:43:25.123456789 UTC
t.round    # => 2010-03-30 05:43:25 UTC
t.round(0) # => 2010-03-30 05:43:25 UTC
t.round(1) # => 2010-03-30 05:43:25.1 UTC
t.round(2) # => 2010-03-30 05:43:25.12 UTC
t.round(3) # => 2010-03-30 05:43:25.123 UTC
t.round(4) # => 2010-03-30 05:43:25.1235 UTC

t = Time.utc(1999, 12,31, 23, 59, 59)
t                # => 1999-12-31 23:59:59 UTC
(t + 0.4).round  # => 1999-12-31 23:59:59 UTC
(t + 0.49).round # => 1999-12-31 23:59:59 UTC
(t + 0.5).round  # => 2000-01-01 00:00:00 UTC
(t + 1.4).round  # => 2000-01-01 00:00:00 UTC
(t + 1.49).round # => 2000-01-01 00:00:00 UTC
(t + 1.5).round  # => 2000-01-01 00:00:01 UTC

Связанно с: Time#ceil, Time#floor.

static VALUE
time_saturday(VALUE time)
{
    wday_p(6);
}

Возвращает true если self представляет собой субботу, false в противном случае:

t = Time.utc(2000, 1, 1) # => 2000-01-01 00:00:00 UTC
t.saturday?              # => true

Связанно с: Time#sunday?, Time#monday?, Time#tuesday?.

static VALUE
time_sec(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    return INT2FIX(tobj->vtm.sec);
}

Возвращает целое значение секунды для self, в диапазоне (0..60):

t = Time.new(2000, 1, 2, 3, 4, 5, 6)
# => 2000-01-02 03:04:05 +000006
t.sec # => 5

Примечание: значение секунды может быть 60 при наличии дополнительной секунды.

Связанно с: Time#year, Time#mon, Time#min.

static VALUE
time_strftime(VALUE time, VALUE format)
{
    struct time_object *tobj;
    const char *fmt;
    long len;
    rb_encoding *enc;
    VALUE tmp;

    GetTimeval(time, tobj);
    MAKE_TM_ENSURE(time, tobj, tobj->vtm.yday != 0);
    StringValue(format);
    if (!rb_enc_str_asciicompat_p(format)) {
        rb_raise(rb_eArgError, "format should have ASCII compatible encoding");
    }
    tmp = rb_str_tmp_frozen_acquire(format);
    fmt = RSTRING_PTR(tmp);
    len = RSTRING_LEN(tmp);
    enc = rb_enc_get(format);
    if (len == 0) {
        rb_warning("strftime called with empty format string");
        return rb_enc_str_new(0, 0, enc);
    }
    else {
        VALUE str = rb_strftime_alloc(fmt, len, enc, time, &tobj->vtm, tobj->timew,
                                      TZMODE_UTC_P(tobj));
        rb_str_tmp_frozen_release(format, tmp);
        if (!str) rb_raise(rb_eArgError, "invalid format: %"PRIsVALUE, format);
        return str;
    }
}

Возвращает строковое представление self, отформатированное в соответствии с заданной строкой format. Смотрите Форматы дат и времени.

static VALUE
time_subsec(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return quov(w2v(wmod(tobj->timew, WINT2FIXWV(TIME_SCALE))), INT2FIX(TIME_SCALE));
}

Возвращает точное значение долей секунды для self в виде Numeric (Integer или Rational):

t = Time.now # => 2022-07-11 15:11:36.8490302 -0500
t.subsec     # => (4245151/5000000)

Если доли секунды равны нулю, возвращает целое число ноль:

t = Time.new(2000, 1, 1, 2, 3, 4) # => 2000-01-01 02:03:04 -0600
t.subsec                          # => 0

static VALUE
time_sunday(VALUE time)
{
    wday_p(0);
}

Возвращает true, если self представляет собой воскресенье, false в противном случае:

t = Time.utc(2000, 1, 2) # => 2000-01-02 00:00:00 UTC
t.sunday?                # => true

Связанные: Time#monday?, Time#tuesday?, Time#wednesday?.

static VALUE
time_thursday(VALUE time)
{
    wday_p(4);
}

Возвращает true, если self представляет собой четверг, false в противном случае:

t = Time.utc(2000, 1, 6) # => 2000-01-06 00:00:00 UTC
t.thursday?              # => true

Связанные: Time#friday?, Time#saturday?, Time#sunday?.

static VALUE
time_to_a(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    MAKE_TM_ENSURE(time, tobj, tobj->vtm.yday != 0);
    return rb_ary_new3(10,
                    INT2FIX(tobj->vtm.sec),
                    INT2FIX(tobj->vtm.min),
                    INT2FIX(tobj->vtm.hour),
                    INT2FIX(tobj->vtm.mday),
                    INT2FIX(tobj->vtm.mon),
                    tobj->vtm.year,
                    INT2FIX(tobj->vtm.wday),
                    INT2FIX(tobj->vtm.yday),
                    RBOOL(tobj->vtm.isdst),
                    time_zone(time));
}

Возвращает массив из 10 элементов, представляющих self:

Time.utc(2000, 1, 1).to_a
# => [0,   0,   0,    1,   1,   2000, 6,    1,    false, "UTC"]
#    [sec, min, hour, day, mon, year, wday, yday, dst?,   zone]

Полученный массив подходит для использования в качестве аргумента для Time.utc или Time.local для создания нового объекта Time.

static VALUE
time_to_date(VALUE self)
{
    VALUE y, nth, ret;
    int ry, m, d;

    y = f_year(self);
    m = FIX2INT(f_mon(self));
    d = FIX2INT(f_mday(self));

    decode_year(y, -1, &nth, &ry);

    ret = d_simple_new_internal(cDate,
                                nth, 0,
                                GREGORIAN,
                                ry, m, d,
                                HAVE_CIVIL);
    {
        get_d1(ret);
        set_sg(dat, DEFAULT_SG);
    }
    return ret;
}

Возвращает объект Date, который обозначает себя.

static VALUE
time_to_datetime(VALUE self)
{
    VALUE y, sf, nth, ret;
    int ry, m, d, h, min, s, of;

    y = f_year(self);
    m = FIX2INT(f_mon(self));
    d = FIX2INT(f_mday(self));

    h = FIX2INT(f_hour(self));
    min = FIX2INT(f_min(self));
    s = FIX2INT(f_sec(self));
    if (s == 60)
        s = 59;

    sf = sec_to_ns(f_subsec(self));
    of = FIX2INT(f_utc_offset(self));

    decode_year(y, -1, &nth, &ry);

    ret = d_complex_new_internal(cDateTime,
                                 nth, 0,
                                 0, sf,
                                 of, GREGORIAN,
                                 ry, m, d,
                                 h, min, s,
                                 HAVE_CIVIL | HAVE_TIME);
    {
        get_d1(ret);
        set_sg(dat, DEFAULT_SG);
    }
    return ret;
}

Возвращает объект DateTime, который обозначает себя.

static VALUE
time_to_f(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return rb_Float(rb_time_unmagnify_to_float(tobj->timew));
}

Возвращает значение self как число с плавающей запятой число секунд эпохи; доли секунды включены.

Сохранённое значение self — рациональное число, поэтому возвращаемое значение может быть приблизительным:

Time.utc(1970, 1, 1, 0, 0, 0).to_f         # => 0.0
Time.utc(1970, 1, 1, 0, 0, 0, 999999).to_f # => 0.999999
Time.utc(1950, 1, 1, 0, 0, 0).to_f         # => -631152000.0
Time.utc(1990, 1, 1, 0, 0, 0).to_f         # => 631152000.0

Связанные: Time#to_i, Time#to_r.

static VALUE
time_to_i(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return w2v(wdiv(tobj->timew, WINT2FIXWV(TIME_SCALE)));
}

Возвращает значение self как целое число число секунд эпохи; доли секунды усекаются (не округляются):

Time.utc(1970, 1, 1, 0, 0, 0).to_i         # => 0
Time.utc(1970, 1, 1, 0, 0, 0, 999999).to_i # => 0
Time.utc(1950, 1, 1, 0, 0, 0).to_i         # => -631152000
Time.utc(1990, 1, 1, 0, 0, 0).to_i         # => 631152000

Связанные: Time#to_f Time#to_r.

# File ext/json/lib/json/add/time.rb, line 56
def to_json(*args)
  as_json.to_json(*args)
end

Возвращает строку JSON, представляющую self:

require 'json/add/time'
puts Time.now.to_json

Вывод:

{"json_class":"Time","s":1700931678,"n":980650786}

static VALUE
time_to_r(VALUE time)
{
    struct time_object *tobj;
    VALUE v;

    GetTimeval(time, tobj);
    v = rb_time_unmagnify_to_rational(tobj->timew);
    if (!RB_TYPE_P(v, T_RATIONAL)) {
        v = rb_Rational1(v);
    }
    return v;
}

Возвращает значение self как точное Rational число секунд эпохи;

Time.now.to_r # => (16571402750320203/10000000)

Связанные: Time#to_f, Time#to_i.

static VALUE
time_to_s(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (TZMODE_UTC_P(tobj))
        return strftimev("%Y-%m-%d %H:%M:%S UTC", time, rb_usascii_encoding());
    else
        return strftimev("%Y-%m-%d %H:%M:%S %z", time, rb_usascii_encoding());
}

Возвращает строковое представление self, без долей секунды:

t = Time.new(2000, 12, 31, 23, 59, 59, 0.5)
t.to_s    # => "2000-12-31 23:59:59 +0000"

Связанные: Time#ctime, Time#inspect:

t.ctime   # => "Sun Dec 31 23:59:59 2000"
t.inspect # => "2000-12-31 23:59:59.5 +000001"

static VALUE
time_to_time(VALUE self)
{
    return self;
}

Возвращает себя.

static VALUE
time_tuesday(VALUE time)
{
    wday_p(2);
}

Возвращает true, если self представляет вторник, false в противном случае:

t = Time.utc(2000, 1, 4) # => 2000-01-04 00:00:00 UTC
t.tuesday?               # => true

Связанные: Time#wednesday?, Time#thursday?, Time#friday?.

static VALUE
time_utc_p(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return RBOOL(TZMODE_UTC_P(tobj));
}

Возвращает true если self представляет время в UTC (GMT):

now = Time.now
# => 2022-08-18 10:24:13.5398485 -0500
now.utc? # => false
utc = Time.utc(2000, 1, 1, 20, 15, 1)
# => 2000-01-01 20:15:01 UTC
utc.utc? # => true

Связанные: Time.utc.

static VALUE
time_wday(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    MAKE_TM_ENSURE(time, tobj, tobj->vtm.wday != VTM_WDAY_INITVAL);
    return INT2FIX((int)tobj->vtm.wday);
}

Возвращает целое число дня недели для self, в диапазоне (0..6), где воскресенье — ноль.

t = Time.new(2000, 1, 2, 3, 4, 5, 6)
# => 2000-01-02 03:04:05 +000006
t.wday    # => 0
t.sunday? # => true

Связанные: Time#year, Time#hour, Time#min.

static VALUE
time_wednesday(VALUE time)
{
    wday_p(3);
}

Возвращает true , если self представляет среду, false в противном случае:

t = Time.utc(2000, 1, 5) # => 2000-01-05 00:00:00 UTC
t.wednesday?             # => true

Связанные: Time#thursday?, Time#friday?, Time#saturday?.

# File lib/time.rb, line 717
def xmlschema(fraction_digits=0)
  fraction_digits = fraction_digits.to_i
  s = strftime("%FT%T")
  if fraction_digits > 0
    s << strftime(".%#{fraction_digits}N")
  end
  s << (utc? ? 'Z' : strftime("%:z"))
end

Возвращает строку, представляющую время как dateTime, определённую XML Schema:

CCYY-MM-DDThh:mm:ssTZD
CCYY-MM-DDThh:mm:ss.sssTZD

где TZD — Z или [+-]чч:мм.

Если self — время UTC, используется Z в качестве TZD. В противном случае используется [+-]чч:мм.

fraction_digits указывает количество цифр, используемых для дробной части секунды. По умолчанию значение равно 0.

require 'time'

t = Time.now
t.iso8601  # => "2011-10-05T22:26:12-04:00"

Для использования этого метода необходимо подключить модуль ‘time’.

static VALUE
time_yday(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    MAKE_TM_ENSURE(time, tobj, tobj->vtm.yday != 0);
    return INT2FIX(tobj->vtm.yday);
}

Возвращает целое число дня года для self, в диапазоне (1..366).

Time.new(2000, 1, 1).yday   # => 1
Time.new(2000, 12, 31).yday # => 366

static VALUE
time_year(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    return tobj->vtm.year;
}

Возвращает целое число года для self:

t = Time.new(2000, 1, 2, 3, 4, 5, 6)
# => 2000-01-02 03:04:05 +000006
t.year # => 2000

Связанные: Time#mon, Time#hour, Time#min.

static VALUE
time_zone(VALUE time)
{
    struct time_object *tobj;
    VALUE zone;

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);

    if (TZMODE_UTC_P(tobj)) {
        return rb_usascii_str_new_cstr("UTC");
    }
    zone = tobj->vtm.zone;
    if (NIL_P(zone))
        return Qnil;

    if (RB_TYPE_P(zone, T_STRING))
        zone = rb_str_dup(zone);
    return zone;
}

Возвращает строковое имя часового пояса для self:

Time.utc(2000, 1, 1).zone # => "UTC"
Time.new(2000, 1, 1).zone # => "Central Standard Time"