класс Time

# File timev.rb, line 282
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 563
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

Десериализует строку JSON, преобразуя время с момента эпохи в Time

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 384
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
  

• Строками-целыми числами:

  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

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

# File timev.rb, line 223
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 378
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 505
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{2}))?\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 453
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

Индикатор полудня (“ДО Н.Э.” или “ПОСЛЕ Н.Э.”)

%P

Индикатор полудня (“до н.э.” или “после н.э.”)

%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
  

• Строковые целые числа:

  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

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

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

Time.gm является псевдонимом для Time.utc.

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

# File lib/time.rb, line 617
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 79
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 22
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

Возвращает хэш, который будет преобразован в объект JSON и представлять этот объект.

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#asctime является псевдонимом для Time#ctime.

Связанные: 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_getgmtime(VALUE time)
{
    return time_gmtime(time_dup(time));
}

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

local = Time.local(2000) # => 2000-01-01 00:00:00 -0600
local.utc?               # => false
utc = local.getutc       # => 2000-01-01 06:00:00 UTC
utc.utc?                 # => true
utc == local             # => true

Time#getgm является псевдонимом для Time#getutc.

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_gmtime(VALUE time)
{
    struct time_object *tobj;
    struct vtm vtm;

    GetTimeval(time, tobj);
    if (TZMODE_UTC_P(tobj)) {
        if (tobj->tm_got)
            return time;
    }
    else {
        time_modify(time);
    }

    vtm.zone = str_utc;
    GMTIMEW(tobj->timew, &vtm);
    tobj->vtm = vtm;

    tobj->tm_got = 1;
    TZMODE_SET_UTC(tobj);
    return time;
}

Возвращает self, преобразованное в часовой пояс UTC:

t = Time.new(2000) # => 2000-01-01 00:00:00 -0600
t.utc?             # => false
t.utc              # => 2000-01-01 06:00:00 UTC
t.utc?             # => true

Time#gmtime — псевдоним для Time#utc.

Связанные: Time#getutc (возвращает новый преобразованный объект Time).

VALUE
rb_time_utc_offset(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);

    if (TZMODE_UTC_P(tobj)) {
        return INT2FIX(0);
    }
    else {
        MAKE_TM(time, tobj);
        return tobj->vtm.utc_offset;
    }
}

Возвращает смещение во времени в секундах между часовыми поясами UTC и self:

Time.utc(2000, 1, 1).utc_offset   # => 0
Time.local(2000, 1, 1).utc_offset # => -21600 # -6*3600, or minus six hours.

Time#gmt_offset и Time#gmtoff — псевдонимы для Time#utc_offset.

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 689
def httpdate
  getutc.strftime('%a, %d %b %Y %T GMT')
end

Возвращает строку, представляющую время как дату RFC 1123 HTTP-даты, определённой 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_isdst(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    if (tobj->vtm.isdst == VTM_ISDST_INITVAL) {
        rb_raise(rb_eRuntimeError, "isdst is not set yet");
    }
    return RBOOL(tobj->vtm.isdst);
}

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

t = Time.local(2000, 1, 1) # => 2000-01-01 00:00:00 -0600
t.zone                     # => "Central Standard Time"
t.dst?                     # => false
t = Time.local(2000, 7, 1) # => 2000-07-01 00:00:00 -0500
t.zone                     # => "Central Daylight Time"
t.dst?                     # => true

Time#isdst — псевдоним для Time#dst?.

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_mday(VALUE time)
{
    struct time_object *tobj;

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

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

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

Time#day — псевдоним для Time#mday.

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

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#month — псевдоним для Time#mday.

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

Хранимое значение 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#tv_sec является псевдонимом для Time#to_i.

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

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

Сохраняет имя класса (Time) с количеством секунд с эпохи и количеством микросекунд для Time как строку в формате JSON.

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_nsec(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return rb_to_int(w2v(wmulquoll(wmod(tobj->timew, WINT2WV(TIME_SCALE)), 1000000000, TIME_SCALE)));
}

Возвращает количество наносекунд в долях секунды self в диапазоне (0..999_999_999); младшие разряды усекаются, а не округляются:

t = Time.now # => 2022-07-11 15:04:53.3219637 -0500
t.nsec       # => 321963700

Связанные: Time#subsec (возвращает точные доли секунды).

Time#tv_nsec — псевдоним для Time#usec.

static VALUE
time_usec(VALUE time)
{
    struct time_object *tobj;
    wideval_t w, q, r;

    GetTimeval(time, tobj);

    w = wmod(tobj->timew, WINT2WV(TIME_SCALE));
    wmuldivmod(w, WINT2FIXWV(1000000), WINT2FIXWV(TIME_SCALE), &q, &r);
    return rb_to_int(w2v(q));
}

Возвращает количество микросекунд в долях секунды self в диапазоне (0..999_999); младшие разряды усекаются, а не округляются:

t = Time.now # => 2022-07-11 14:59:47.5484697 -0500
t.usec       # => 548469

Связанные: Time#subsec (возвращает точные доли секунды).

Time#tv_usec — псевдоним для Time#usec.

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#gmt? — псевдоним для Time#utc?.

Связанные: 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 714
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"