класс Time

# File timev.rb, line 323
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 569
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
  at(object['s'], Rational(object['n'], 1000))
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 434
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) или трёхбуквенное название месяца (регистронезависимо):

  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 264
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 382
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 511
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 459
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 за исключением того, что вместо использования эвристики для определения формата входной строки вы предоставляете второй аргумент, описывающий формат строки.

Генерирует ArgumentError, если дата или формат некорректны.

Если задан блок, год, описанный в 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

Дата (%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

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

%Z

Название часового пояса

%%

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

%+

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

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

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

• 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
  

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

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

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

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

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

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

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

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

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

Вызывает исключение, если количество аргументов равно 8, 9 или больше 10.

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

# File lib/time.rb, line 623
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 83
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.

Часовые пояса, включающие минуты, такие как -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 32
def as_json(*)
  {
    JSON.create_id => self.class.name,
    's'            => tv_sec,
    'n'            => tv_nsec,
  }
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 695
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 675
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

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

Если 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 в виде числа с плавающей точкой Float — количество секунд с эпохи; включаются дробные секунды.

Хранимое значение self — Rational, что означает, что возвращаемое значение может быть приближенным:

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 49
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;
}

Возвращает 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 721
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"