класс File

Родительский класс:: IO

Объект File представляет файл на базовой платформе.

Класс File расширяет модуль FileTest и поддерживает такие методы класса, как File.exist?.

Об этих примерах

Во многих примерах здесь используются следующие переменные:

# English text with newlines.
text = <<~EOT
  First line
  Second line

  Fourth line
  Fifth line
EOT

# Russian text.
russian = "\u{442 435 441 442}" # => "тест"

# Binary data.
data = "\u9990\u9991\u9992\u9993\u9994"

# Text file.
File.write('t.txt', text)

# File with Russian text.
File.write('t.rus', russian)

# File with binary data.
f = File.new('t.dat', 'wb:UTF-16')
f.write(data)
f.close

Режимы доступа

Методы File.new и File.open создают объект File для заданного пути к файлу.

Строковые режимы доступа

Методы File.new и File.open могут принимать строковый аргумент mode, который:

Начинается с одно- или двухсимвольного режима чтения/записи.
Также может содержать один символ режима данных.
Также может содержать один символ режима создания файла.

Режим чтения/записи

Режим чтения/записи mode определяет:

Будет ли файл изначально усечён.
Разрешено ли чтение и, если разрешено:
- Начальную позицию чтения в файле.
- Область файла, в которой может выполняться чтение.
Разрешена ли запись и, если разрешена:
- Начальную позицию записи в файле.
- Область файла, в которой может выполняться запись.

В следующих таблицах приведены сводные данные:

Read/Write Modes for Existing File

|------|-----------|----------|----------|----------|-----------|
| R/W  | Initial   |          | Initial  |          | Initial   |
| Mode | Truncate? |  Read    | Read Pos |  Write   | Write Pos |
|------|-----------|----------|----------|----------|-----------|
| 'r'  |    No     | Anywhere |    0     |   Error  |     -     |
| 'w'  |    Yes    |   Error  |    -     | Anywhere |     0     |
| 'a'  |    No     |   Error  |    -     | End only |    End    |
| 'r+' |    No     | Anywhere |    0     | Anywhere |     0     |
| 'w+' |    Yes    | Anywhere |    0     | Anywhere |     0     |
| 'a+' |    No     | Anywhere |   End    | End only |    End    |
|------|-----------|----------|----------|----------|-----------|

Read/Write Modes for \File To Be Created

|------|----------|----------|----------|-----------|
| R/W  |          | Initial  |          | Initial   |
| Mode |  Read    | Read Pos |  Write   | Write Pos |
|------|----------|----------|----------|-----------|
| 'w'  |   Error  |    -     | Anywhere |     0     |
| 'a'  |   Error  |    -     | End only |     0     |
| 'w+' | Anywhere |    0     | Anywhere |     0     |
| 'a+' | Anywhere |    0     | End only |    End    |
|------|----------|----------|----------|-----------|

Обратите внимание: режимы 'r' и 'r+' недопустимы для несуществующего файла (возникает исключение).

В таблицах:

Anywhere означает, что методы IO#rewind, IO#pos= и IO#seek можно использовать для изменения позиции в файле, чтобы разрешённые операции чтения или записи могли выполняться в любой его части.
End only означает, что запись возможна только в конце файла и что методы IO#rewind, IO#pos= и IO#seek не влияют на запись.
Error означает, что при попытке выполнить запрещённую операцию чтения или записи возникает исключение.

Режимы чтения/записи для существующего файла

'r':

Файл изначально не усекается:

f = File.new('t.txt') # => #<File:t.txt>
f.size == 0           # => false

Начальная позиция чтения в файле равна 0:
```
f.pos # => 0
```

Файл можно читать в любом месте; см. IO#rewind, IO#pos=, IO#seek:

f.readline # => "First line\n"
f.readline # => "Second line\n"

f.rewind
f.readline # => "First line\n"

f.pos = 1
f.readline # => "irst line\n"

f.seek(1, :CUR)
f.readline # => "econd line\n"

Запись запрещена:
```
f.write('foo') # Raises IOError.
```

'w':

Файл изначально усекается:

path = 't.tmp'
File.write(path, text)
f = File.new(path, 'w')
f.size == 0 # => true

Начальная позиция записи в файле равна 0:
```
f.pos # => 0
```

Запись в файл возможна в любом месте (даже за концом файла); см. IO#rewind, IO#pos=, IO#seek:

f.write('foo')
f.flush
File.read(path) # => "foo"
f.pos # => 3

f.write('bar')
f.flush
File.read(path) # => "foobar"
f.pos # => 6

f.rewind
f.write('baz')
f.flush
File.read(path) # => "bazbar"
f.pos # => 3

f.pos = 3
f.write('foo')
f.flush
File.read(path) # => "bazfoo"
f.pos # => 6

f.seek(-3, :END)
f.write('bam')
f.flush
File.read(path) # => "bazbam"
f.pos # => 6

f.pos = 8
f.write('bah')  # Zero padding as needed.
f.flush
File.read(path) # => "bazbam\u0000\u0000bah"
f.pos # => 11

Чтение запрещено:
```
f.read # Raises IOError.
```

'a':
- Файл изначально не усекается:
```
path = 't.tmp'
File.write(path, 'foo')
f = File.new(path, 'a')
f.size == 0 # => false
```
- Начальная позиция файла равна 0 (но игнорируется):
```
f.pos # => 0
```
- Запись в файл возможна только в его конце; методы IO#rewind, IO#pos=, IO#seek не влияют на запись:
```
f.write('bar')
f.flush
File.read(path) # => "foobar"
f.write('baz')
f.flush
File.read(path) # => "foobarbaz"

f.rewind
f.write('bat')
f.flush
File.read(path) # => "foobarbazbat"
```
- Чтение запрещено:
```
f.read # Raises IOError.
```

'r+':

Файл изначально не усекается:

path = 't.tmp'
File.write(path, text)
f = File.new(path, 'r+')
f.size == 0 # => false

Начальная позиция чтения в файле равна 0:
```
f.pos # => 0
```

Файл можно читать или записывать в любом месте (даже за концом файла); см. IO#rewind, IO#pos=, IO#seek:

f.readline # => "First line\n"
f.readline # => "Second line\n"

f.rewind
f.readline # => "First line\n"

f.pos = 1
f.readline # => "irst line\n"

f.seek(1, :CUR)
f.readline # => "econd line\n"

f.rewind
f.write('WWW')
f.flush
File.read(path)
# => "WWWst line\nSecond line\nFourth line\nFifth line\n"

f.pos = 10
f.write('XXX')
f.flush
File.read(path)
# => "WWWst lineXXXecond line\nFourth line\nFifth line\n"

f.seek(-6, :END)
# => 0
f.write('YYY')
# => 3
f.flush
# => #<File:t.tmp>
File.read(path)
# => "WWWst lineXXXecond line\nFourth line\nFifth YYYe\n"

f.seek(2, :END)
f.write('ZZZ') # Zero padding as needed.
f.flush
File.read(path)
# => "WWWst lineXXXecond line\nFourth line\nFifth YYYe\n\u0000\u0000ZZZ"

'a+':

Файл изначально не усекается:

path = 't.tmp'
File.write(path, 'foo')
f = File.new(path, 'a+')
f.size == 0 # => false

Начальная позиция чтения в файле равна 0:
```
f.pos # => 0
```

Запись в файл возможна только в его конце; методы IO#rewind, IO#pos=, IO#seek не влияют на запись:

f.write('bar')
f.flush
File.read(path)      # => "foobar"
f.write('baz')
f.flush
File.read(path)      # => "foobarbaz"

f.rewind
f.write('bat')
f.flush
File.read(path) # => "foobarbazbat"

Файл можно читать в любом месте; см. IO#rewind, IO#pos=, IO#seek:

f.rewind
f.read # => "foobarbazbat"

f.pos = 3
f.read # => "barbazbat"

f.seek(-3, :END)
f.read # => "bat"

Режимы чтения/записи для создаваемого файла

Обратите внимание: режимы 'r' и 'r+' недопустимы для несуществующего файла (возникает исключение).

'w':

Начальная позиция записи в файле равна 0:

path = 't.tmp'
FileUtils.rm_f(path)
f = File.new(path, 'w')
f.pos # => 0

Запись в файл возможна в любом месте (даже за концом файла); см. IO#rewind, IO#pos=, IO#seek:

f.write('foo')
f.flush
File.read(path) # => "foo"
f.pos # => 3

f.write('bar')
f.flush
File.read(path) # => "foobar"
f.pos # => 6

f.rewind
f.write('baz')
f.flush
File.read(path) # => "bazbar"
f.pos # => 3

f.pos = 3
f.write('foo')
f.flush
File.read(path) # => "bazfoo"
f.pos # => 6

f.seek(-3, :END)
f.write('bam')
f.flush
File.read(path) # => "bazbam"
f.pos # => 6

f.pos = 8
f.write('bah')  # Zero padding as needed.
f.flush
File.read(path) # => "bazbam\u0000\u0000bah"
f.pos # => 11

Чтение запрещено:
```
f.read # Raises IOError.
```

'a':

Начальная позиция записи в файле равна 0:

path = 't.tmp'
FileUtils.rm_f(path)
f = File.new(path, 'a')
f.pos # => 0

Запись выполняется только в конце файла:

f.write('foo')
f.pos # => 3
f.write('bar')
f.pos # => 6
f.flush
File.read(path) # => "foobar"

f.rewind
f.write('baz')
f.flush
File.read(path) # => "foobarbaz"

Чтение запрещено:
```
f.read # Raises IOError.
```

'w+':

Начальная позиция файла равна 0:

path = 't.tmp'
FileUtils.rm_f(path)
f = File.new(path, 'w+')
f.pos # => 0

Запись в файл возможна в любом месте (даже за концом файла); см. IO#rewind, IO#pos=, IO#seek:

f.write('foo')
f.flush
File.read(path) # => "foo"
f.pos # => 3

f.write('bar')
f.flush
File.read(path) # => "foobar"
f.pos # => 6

f.rewind
f.write('baz')
f.flush
File.read(path) # => "bazbar"
f.pos # => 3

f.pos = 3
f.write('foo')
f.flush
File.read(path) # => "bazfoo"
f.pos # => 6

f.seek(-3, :END)
f.write('bam')
f.flush
File.read(path) # => "bazbam"
f.pos # => 6

f.pos = 8
f.write('bah')  # Zero padding as needed.
f.flush
File.read(path) # => "bazbam\u0000\u0000bah"
f.pos # => 11

Файл можно читать в любом месте (даже за концом файла); см. IO#rewind, IO#pos=, IO#seek:

f.rewind
# => 0
f.read
# => "bazbam\u0000\u0000bah"

f.pos = 3
# => 3
f.read
# => "bam\u0000\u0000bah"

f.seek(-3, :END)
# => 0
f.read
# => "bah"

'a+':

Начальная позиция записи в файле равна 0:

path = 't.tmp'
FileUtils.rm_f(path)
f = File.new(path, 'a+')
f.pos # => 0

Запись выполняется только в конце файла:

f.write('foo')
f.pos # => 3
f.write('bar')
f.pos # => 6
f.flush
File.read(path) # => "foobar"

f.rewind
f.write('baz')
f.flush
File.read(path) # => "foobarbaz"

Файл можно читать в любом месте (даже за концом файла); см. IO#rewind, IO#pos=, IO#seek:

f.rewind
f.read # => "foobarbaz"

f.pos = 3
f.read # => "barbaz"

f.seek(-3, :END)
f.read # => "baz"

f.pos = 800
f.read # => ""

Режим данных

Чтобы указать, следует ли обрабатывать данные как текстовые или двоичные, к любому из описанных выше строковых режимов чтения/записи можно добавить один из следующих суффиксов:

't': текстовые данные; задаёт внешнюю кодировку по умолчанию Encoding::UTF_8; в Windows включает преобразование EOL и CRLF и позволяет интерпретировать 0x1A как маркер конца файла.
'b': двоичные данные; задаёт внешнюю кодировку по умолчанию Encoding::ASCII_8BIT; в Windows отключает преобразование EOL и CRLF и запрещает интерпретировать 0x1A как маркер конца файла.

Если не указан ни один из вариантов, по умолчанию поток обрабатывает текстовые данные.

Примеры:

File.new('t.txt', 'rt')
File.new('t.dat', 'rb')

Если указан режим данных, режим чтения/записи нельзя опустить, а режим данных должен предшествовать режиму создания файла, если он указан:

File.new('t.dat', 'b')   # Raises an exception.
File.new('t.dat', 'rxb') # Raises an exception.

Режим создания файла

К любому из приведённых выше строковых режимов с возможностью записи можно добавить следующий суффикс:

'x': создаёт файл, если он не существует; если файл существует, возникает исключение.

Пример:

File.new('t.tmp', 'wx')

Если указан режим создания файла, режим чтения/записи нельзя опустить, а режим создания файла должен следовать за режимом данных:

File.new('t.dat', 'x')   # Raises an exception.
File.new('t.dat', 'rxb') # Raises an exception.

Целочисленные режимы доступа

Если режим задан целым числом, оно должно быть одной или несколькими из следующих констант, которые можно объединять побитовым оператором ИЛИ |:

File::RDONLY: открыть только для чтения.
File::WRONLY: открыть только для записи.
File::RDWR: открыть для чтения и записи.
File::APPEND: открыть только для добавления.

Примеры:

File.new('t.txt', File::RDONLY)
File.new('t.tmp', File::RDWR | File::CREAT | File::EXCL)

Примечание: метод IO#set_encoding не позволяет указывать режим целым числом.

Режим создания файла, заданный целым числом

Эти константы также можно объединять с целочисленным режимом с помощью оператора ИЛИ:

File::CREAT: создать файл, если он не существует.
File::EXCL: вызвать исключение, если задан File::CREAT и файл существует.

Режим данных, заданный целым числом

Режим данных нельзя задать целым числом. Если режим доступа к потоку задан целым числом, режим данных всегда текстовый, а не двоичный.

Обратите внимание: хотя существует константа File::BINARY, её установка в целочисленном режиме потока не даёт эффекта. Это связано с тем, что, как описано в File::Constants, значение File::BINARY отключает преобразование кодов перевода строки, но не меняет внешнюю кодировку.

Кодировки

В любом из приведённых выше строковых режимов можно указать кодировки — только внешнюю или одновременно внешнюю и внутреннюю — добавив одно или оба имени кодировок, разделённых двоеточиями:

f = File.new('t.dat', 'rb')
f.external_encoding # => #<Encoding:ASCII-8BIT>
f.internal_encoding # => nil
f = File.new('t.dat', 'rb:UTF-16')
f.external_encoding # => #<Encoding:UTF-16 (dummy)>
f.internal_encoding # => nil
f = File.new('t.dat', 'rb:UTF-16:UTF-16')
f.external_encoding # => #<Encoding:UTF-16 (dummy)>
f.internal_encoding # => #<Encoding:UTF-16>
f.close

Многочисленные имена кодировок доступны в массиве Encoding.name_list:

Encoding.name_list.take(3) # => ["ASCII-8BIT", "UTF-8", "US-ASCII"]

При задании внешней кодировки прочитанные строки помечаются этой кодировкой, а записываемые строки преобразуются в неё.

Если заданы и внешняя, и внутренняя кодировки, прочитанные строки преобразуются из внешней кодировки во внутреннюю, а записываемые — из внутренней во внешнюю. Дополнительные сведения о перекодировании ввода и вывода см. в разделе Кодировки.

Если внешняя кодировка — 'BOM|UTF-8', 'BOM|UTF-16LE' или 'BOM|UTF16-BE', Ruby проверяет наличие спецификации порядка байтов Unicode (BOM) во входном документе, чтобы помочь определить кодировку. Для кодировок UTF-16 режим открытия файла должен быть двоичным. Если BOM обнаружена, она удаляется, а в качестве внешней используется кодировка, указанная в BOM.

Обратите внимание: параметр кодировки в формате BOM не чувствителен к регистру, поэтому допустима также запись 'bom|utf-8'.

Права доступа к файлу

Объект File имеет права доступа — целое восьмеричное число, представляющее права доступа к реальному файлу на базовой платформе.

Обратите внимание: права доступа к файлу существенно отличаются от режима файлового потока (объекта File).

Права доступа объекта File можно получить следующим образом; метод mode, несмотря на своё название, возвращает права доступа:

f = File.new('t.txt')
f.lstat.mode.to_s(8) # => "100644"

В операционных системах на базе Unix три младшие восьмеричные цифры представляют права владельца (6), группы (4) и всех остальных (4). Три бита каждой восьмеричной цифры соответствуют правам на чтение, запись и выполнение.

Таким образом, права 0644 обозначают доступ на чтение и запись для владельца и доступ только на чтение для группы и всех остальных. См. справочные страницы open(2) и chmod(2).

Для каталога значение бита выполнения меняется: если он установлен, каталог можно просматривать.

Старшие биты прав доступа могут указывать тип файла (обычный файл, каталог, канал, сокет и т. д.) и различные другие специальные свойства.

В операционных системах, не соответствующих POSIX, права доступа могут включать только доступ для чтения или чтения и записи; в этом случае остальные права будут иметь типичные значения. Например, в Windows права по умолчанию — 0644; единственное доступное изменение — сделать файл доступным только для чтения, что отображается как 0444.

Для метода, который действительно создаёт файл на базовой платформе (а не только объект File), можно указать права доступа:

File.new('t.tmp', File::CREAT, 0644)
File.new('t.tmp', File::CREAT, 0444)

Права доступа также можно изменить:

f = File.new('t.tmp', File::CREAT, 0444)
f.chmod(0644)
f.chmod(0444)

Константы File

Различные константы, используемые в методах File и IO, можно найти в модуле File::Constants; массив их имён возвращается методом File::Constants.constants.

Что здесь есть

Сначала — о том, что находится в других местах. Класс File:

Наследует от класса IO, в частности, методы для создания, чтения и записи файлов
Подключает модуль FileTest, предоставляющий десятки дополнительных методов.

Здесь класс File предоставляет методы, полезные для:

Создание

::new: открывает файл по заданному пути и возвращает его.
::open: аналогичен ::new, но при передаче блока передаёт ему файл и закрывает файл после выхода из блока.
::link: создаёт новое имя для существующего файла с помощью жёсткой ссылки.
::mkfifo: возвращает FIFO-файл, созданный по заданному пути.
::symlink: создаёт символическую ссылку для заданного пути к файлу.

Получение сведений

Пути

::absolute_path: возвращает абсолютный путь к файлу для заданного пути.
::absolute_path?: возвращает значение, указывающее, является ли заданный путь абсолютным путём к файлу.
::basename: возвращает последний компонент заданного пути к файлу.
::dirname: возвращает все компоненты заданного пути к файлу, кроме последнего.
::expand_path: возвращает абсолютный путь к файлу для заданного пути, подставляя домашний каталог вместо ~.
::extname: возвращает расширение файла для заданного пути.
::fnmatch? (псевдоним ::fnmatch): возвращает значение, указывающее, соответствует ли заданный путь к файлу заданному шаблону.
::join: объединяет компоненты пути в одну строку.
::path: возвращает строковое представление заданного пути.
::readlink: возвращает путь к файлу, на который указывает заданная символическая ссылка.
::realdirpath: возвращает реальный путь для заданного пути к файлу; последний компонент может не существовать.
::realpath: возвращает реальный путь для заданного пути к файлу; все компоненты должны существовать.
::split: возвращает массив из двух строк: имени каталога и базового имени файла по заданному пути.
path (псевдоним to_path): возвращает строковое представление заданного пути.

Время

::atime: возвращает объект Time, соответствующий последнему обращению к заданному файлу.
::birthtime: возвращает объект Time, соответствующий времени создания заданного файла.
::ctime: возвращает объект Time, соответствующий времени изменения метаданных заданного файла.
::mtime: возвращает объект Time, соответствующий времени последнего изменения данных в содержимом заданного файла.
atime: возвращает объект Time, соответствующий последнему обращению к self.
birthtime: возвращает объект Time, соответствующий времени создания self.
ctime: возвращает объект Time, соответствующий времени изменения метаданных self.
mtime: возвращает объект Time, соответствующий времени последнего изменения данных в содержимом self.

Типы

::blockdev?: возвращает значение, указывающее, является ли файл по заданному пути блочным устройством.
::chardev?: возвращает значение, указывающее, является ли файл по заданному пути символьным устройством.
::directory?: возвращает значение, указывающее, является ли файл по заданному пути каталогом.
::executable?: возвращает значение, указывающее, может ли эффективный пользователь и группа текущего процесса выполнять файл по заданному пути.
::executable_real?: возвращает значение, указывающее, может ли реальный пользователь и группа текущего процесса выполнять файл по заданному пути.
::exist?: возвращает значение, указывающее, существует ли файл по заданному пути.
::file?: возвращает значение, указывающее, является ли файл по заданному пути обычным файлом.
::ftype: возвращает строку, указывающую тип файла по заданному пути.
::grpowned?: возвращает значение, указывающее, принадлежит ли файл по заданному пути эффективной группе текущего процесса.
::identical?: возвращает значение, указывающее, идентичны ли файлы по двум заданным путям.
::lstat: возвращает объект File::Stat для последней символической ссылки в заданном пути.
::owned?: возвращает значение, указывающее, принадлежит ли файл по заданному пути эффективному пользователю текущего процесса.
::pipe?: возвращает значение, указывающее, является ли файл по заданному пути каналом.
::readable?: возвращает значение, указывающее, может ли эффективный пользователь и группа текущего процесса читать файл по заданному пути.
::readable_real?: возвращает значение, указывающее, может ли реальный пользователь и группа текущего процесса читать файл по заданному пути.
::setgid?: возвращает значение, указывающее, установлен ли бит setgid для файла по заданному пути.
::setuid?: возвращает значение, указывающее, установлен ли бит setuid для файла по заданному пути.
::socket?: возвращает значение, указывающее, является ли файл по заданному пути сокетом.
::stat: возвращает объект File::Stat для файла по заданному пути.
::sticky?: возвращает значение, указывающее, установлен ли для файла по заданному пути sticky-бит.
::symlink?: возвращает значение, указывающее, является ли файл по заданному пути символической ссылкой.
::umask: возвращает значение umask для текущего процесса.
::world_readable?: возвращает значение, указывающее, могут ли другие пользователи читать файл по заданному пути.
::world_writable?: возвращает значение, указывающее, могут ли другие пользователи записывать в файл по заданному пути.
::writable?: возвращает значение, указывающее, может ли эффективный пользователь и группа текущего процесса записывать в файл по заданному пути.
::writable_real?: возвращает значение, указывающее, может ли реальный пользователь и группа текущего процесса записывать в файл по заданному пути.
lstat: возвращает объект File::Stat для последней символической ссылки в пути к self.

Содержимое

::empty? (псевдоним ::zero?): возвращает значение, указывающее, существует ли файл по заданному пути и пуст ли он.
::size: возвращает размер файла в байтах по заданному пути.
::size?: возвращает nil, если файл по заданному пути не существует или пуст; в противном случае возвращает размер файла в байтах.
size: возвращает размер self в байтах.

Настройки

::chmod: изменяет права доступа к файлу по заданному пути.
::chown: изменяет владельца файла по заданному пути.
::lchmod: изменяет права доступа к последней символической ссылке в заданном пути.
::lchown: изменяет владельца последней символической ссылки в заданном пути.
::lutime: для каждого заданного пути к файлу устанавливает время доступа и время изменения последней символической ссылки в пути.
::rename: перемещает файл из одного заданного пути по другому заданному пути.
::utime: устанавливает время доступа и время изменения каждого файла по заданным путям.
flock: блокирует или разблокирует self.

Прочее

::truncate: усекает файл по заданному пути до заданного размера.
::unlink (псевдоним ::delete): удаляет файл для каждого заданного пути.
truncate: усекает self до заданного размера.

Константы

ALT_SEPARATOR: альтернативный разделитель, зависящий от платформы
PATH_SEPARATOR: разделитель элементов списка путей
SEPARATOR: разделяет части пути, соответствующие каталогам
Separator: разделяет части пути, соответствующие каталогам

Общедоступные методы класса

absolute_path(file_name [, dir_string] ) → abs_file_name Показать исходный код

static VALUE
s_absolute_path(int c, const VALUE * v, VALUE _)
{
    return rb_file_s_absolute_path(c, v);
}

Преобразует имя пути в абсолютное имя пути. Относительные пути отсчитываются от текущего рабочего каталога процесса, если не задан dir_string; в этом случае он используется в качестве начальной точки. Если заданное имя пути начинается с «~», оно НЕ разворачивается и рассматривается как обычное имя каталога.

File.absolute_path("~oracle/bin")       #=> "<relative_path>/~oracle/bin"

absolute_path?(file_name) → true or false Показать исходный код

static VALUE
s_absolute_path_p(VALUE klass, VALUE fname)
{
    VALUE path = rb_get_path(fname);

    if (!rb_is_absolute_path(RSTRING_PTR(path))) return Qfalse;
    return Qtrue;
}

Возвращает true, если file_name является абсолютным путём, и false в противном случае.

File.absolute_path?("c:/foo")     #=> false (on Linux), true (on Windows)

atime(file_name) → time Показать исходный код

static VALUE
rb_file_s_atime(VALUE klass, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) {
        int e = errno;
        FilePathValue(fname);
        rb_syserr_fail_path(e, fname);
    }
    return stat_time(stat_atimespec(&st));
}

Возвращает время последнего доступа к указанному файлу в виде объекта Time.

file_name может быть объектом IO.

File.atime("testfile")   #=> Wed Apr 09 08:51:48 CDT 2003

basename(file_name [, suffix] ) → base_name Показать исходный код

static VALUE
rb_file_s_basename(int argc, VALUE *argv, VALUE _)
{
    VALUE fname, fext, basename;
    const char *name, *p;
    long f, n;
    rb_encoding *enc;

    fext = Qnil;
    if (rb_check_arity(argc, 1, 2) == 2) {
        fext = argv[1];
        StringValue(fext);
        enc = check_path_encoding(fext);
    }
    fname = argv[0];
    FilePathStringValue(fname);
    if (NIL_P(fext) || !(enc = rb_enc_compatible(fname, fext))) {
        enc = rb_enc_get(fname);
        fext = Qnil;
    }
    if ((n = RSTRING_LEN(fname)) == 0 || !*(name = RSTRING_PTR(fname)))
        return rb_str_new_shared(fname);

    p = ruby_enc_find_basename(name, &f, &n, enc);
    if (n >= 0) {
        if (NIL_P(fext)) {
            f = n;
        }
        else {
            const char *fp;
            fp = StringValueCStr(fext);
            if (!(f = rmext(p, f, n, fp, RSTRING_LEN(fext), enc))) {
                f = n;
            }
            RB_GC_GUARD(fext);
        }
        if (f == RSTRING_LEN(fname)) return rb_str_new_shared(fname);
    }

    basename = rb_str_new(p, f);
    rb_enc_copy(basename, fname);
    return basename;
}

Возвращает последний компонент имени файла, заданного в file_name (предварительно удалив завершающие разделители). В качестве разделителя можно использовать как File::SEPARATOR, так и File::ALT_SEPARATOR, если File::ALT_SEPARATOR не равен nil. Если заданный suffix присутствует в конце file_name, он удаляется. Если suffix равен «.*», удаляется любое расширение.

File.basename("/home/gumby/work/ruby.rb")          #=> "ruby.rb"
File.basename("/home/gumby/work/ruby.rb", ".rb")   #=> "ruby"
File.basename("/home/gumby/work/ruby.rb", ".*")    #=> "ruby"

birthtime(file_name) → time Показать исходный код

VALUE
rb_file_s_birthtime(VALUE klass, VALUE fname)
{
    rb_io_stat_data st;

    if (rb_statx(fname, &st, STATX_BTIME) < 0) {
        int e = errno;
        FilePathValue(fname);
        rb_syserr_fail_path(e, fname);
    }
    return statx_birthtime(&st);
}

Возвращает время создания указанного файла.

file_name может быть объектом IO.

File.birthtime("testfile")   #=> Wed Apr 09 08:53:13 CDT 2003

Если платформа не поддерживает время создания, вызывает исключение NotImplementedError.

blockdev?(filepath) → true or false Показать исходный код

static VALUE
rb_file_blockdev_p(VALUE obj, VALUE fname)
{
#ifndef S_ISBLK
#   ifdef S_IFBLK
#       define S_ISBLK(m) (((m) & S_IFMT) == S_IFBLK)
#   else
#       define S_ISBLK(m) (0)  /* anytime false */
#   endif
#endif

#ifdef S_ISBLK
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    if (S_ISBLK(st.st_mode)) return Qtrue;

#endif
    return Qfalse;
}

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

File.blockdev?('/dev/sda1')       # => true
File.blockdev?(File.new('t.tmp')) # => false

chardev?(filepath) → true or false Показать исходный код

static VALUE
rb_file_chardev_p(VALUE obj, VALUE fname)
{
#ifndef S_ISCHR
#   define S_ISCHR(m) (((m) & S_IFMT) == S_IFCHR)
#endif

    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    if (S_ISCHR(st.st_mode)) return Qtrue;

    return Qfalse;
}

Возвращает true, если filepath указывает на символьное устройство, и false в противном случае.

File.chardev?($stdin)     # => true
File.chardev?('t.txt')     # => false

chmod(mode_int, file_name, ... ) → integer Показать исходный код

static VALUE
rb_file_s_chmod(int argc, VALUE *argv, VALUE _)
{
    mode_t mode;

    apply2args(1);
    mode = NUM2MODET(*argv++);

    return apply2files(chmod_internal, argc, argv, &mode);
}

Изменяет биты разрешений указанных файлов в соответствии с битовой маской, представленной значением mode_int. Фактический результат зависит от операционной системы (см. начало этого раздела). Подробности для систем Unix см. в chmod(2). Возвращает количество обработанных файлов.

File.chmod(0644, "testfile", "out")   #=> 2

chown(owner_int, group_int, file_name, ...) → integer Показать исходный код

static VALUE
rb_file_s_chown(int argc, VALUE *argv, VALUE _)
{
    struct chown_args arg;

    apply2args(2);
    arg.owner = to_uid(*argv++);
    arg.group = to_gid(*argv++);

    return apply2files(chown_internal, argc, argv, &arg);
}

Изменяет владельца и группу указанных файлов на заданные числовые идентификаторы владельца и группы. Изменять владельца файла может только процесс с привилегиями суперпользователя. Текущий владелец файла может изменить его группу на любую группу, в которую он входит. Идентификатор владельца или группы nil либо -1 игнорируется. Возвращает количество обработанных файлов.

File.chown(nil, 100, "testfile")

ctime(file_name) → time Показать исходный код

static VALUE
rb_file_s_ctime(VALUE klass, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) {
        int e = errno;
        FilePathValue(fname);
        rb_syserr_fail_path(e, fname);
    }
    return stat_time(stat_ctimespec(&st));
}

Возвращает время изменения указанного файла (время изменения сведений о файле в каталоге, а не самого файла).

file_name может быть объектом IO.

Обратите внимание: в Windows (NTFS) возвращается время создания файла.

File.ctime("testfile")   #=> Wed Apr 09 08:53:13 CDT 2003

delete(file_name, ...) → integer Показать исходный код

unlink(file_name, ...) → integer

static VALUE
rb_file_s_unlink(int argc, VALUE *argv, VALUE klass)
{
    return apply2files(unlink_internal, argc, argv, 0);
}

Удаляет указанные файлы и возвращает количество переданных в качестве аргументов имён. При любой ошибке вызывает исключение. Поскольку базовая реализация использует системный вызов unlink(2), тип вызываемого исключения зависит от типа ошибки (см. linux.die.net/man/2/unlink) и имеет, например, вид Errno::ENOENT.

См. также Dir::rmdir.

directory?(path) → true or false Показать исходный код

VALUE
rb_file_directory_p(VALUE obj, VALUE fname)
{
#ifndef S_ISDIR
#   define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
#endif

    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    if (S_ISDIR(st.st_mode)) return Qtrue;
    return Qfalse;
}

Если задана строка object, возвращает true, если path — строковый путь, ведущий к каталогу или символической ссылке на каталог; в противном случае возвращает false:

File.directory?('.')              # => true
File.directory?('foo')            # => false
File.symlink('.', 'dirlink')      # => 0
File.directory?('dirlink')        # => true
File.symlink('t,txt', 'filelink') # => 0
File.directory?('filelink')       # => false

Аргумент path может быть объектом IO.

dirname(file_name, level = 1) → dir_name Показать исходный код

static VALUE
rb_file_s_dirname(int argc, VALUE *argv, VALUE klass)
{
    int n = 1;
    if ((argc = rb_check_arity(argc, 1, 2)) > 1) {
        n = NUM2INT(argv[1]);
    }
    return rb_file_dirname_n(argv[0], n);
}

Возвращает все компоненты имени файла, заданного в file_name, кроме последнего (предварительно удалив завершающие разделители). В качестве разделителя можно использовать как File::SEPARATOR, так и File::ALT_SEPARATOR, если File::ALT_SEPARATOR не равен nil.

File.dirname("/home/gumby/work/ruby.rb")   #=> "/home/gumby/work"

Если задан level, удаляются последние level компонентов, а не только один.

File.dirname("/home/gumby/work/ruby.rb", 2) #=> "/home/gumby"
File.dirname("/home/gumby/work/ruby.rb", 4) #=> "/"

zero?(file_name) → true or false Показать исходный код

static VALUE
rb_file_zero_p(VALUE obj, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    return RBOOL(st.st_size == 0);
}

Возвращает true, если указанный файл существует и имеет нулевой размер.

file_name может быть объектом IO.

executable?(file_name) → true or false Показать исходный код

static VALUE
rb_file_executable_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_eaccess(fname, X_OK) >= 0);
}

Возвращает true, если указанный файл доступен для выполнения эффективному идентификатору пользователя и группы этого процесса. См. eaccess(3).

В Windows права на выполнение не поддерживаются отдельно от прав на чтение. В Windows файл считается исполняемым, только если его имя оканчивается на .bat, .cmd, .com или .exe.

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

executable_real?(file_name) → true or false Показать исходный код

static VALUE
rb_file_executable_real_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_access(fname, X_OK) >= 0);
}

Возвращает true, если указанный файл доступен для выполнения реальному идентификатору пользователя и группы этого процесса. См. access(3).

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

exist?(file_name) → true or false Показать исходный код

static VALUE
rb_file_exist_p(VALUE obj, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    return Qtrue;
}

Возвращает true, если указанный файл существует.

file_name может быть объектом IO.

«Файл существует» означает, что системный вызов stat() или fstat() выполнен успешно.

expand_path(file_name [, dir_string] ) → abs_file_name Показать исходный код

static VALUE
s_expand_path(int c, const VALUE * v, VALUE _)
{
    return rb_file_s_expand_path(c, v);
}

Преобразует имя пути в абсолютное имя пути. Относительные пути отсчитываются от текущего рабочего каталога процесса, если не задан dir_string; в этом случае он используется в качестве начальной точки. Заданный путь может начинаться с «~», который разворачивается в домашний каталог владельца процесса (переменная окружения HOME должна быть правильно задана). «~user» разворачивается в домашний каталог указанного пользователя.

File.expand_path("~oracle/bin")           #=> "/home/oracle/bin"

Простой пример использования dir_string:

File.expand_path("ruby", "/usr/bin")      #=> "/usr/bin/ruby"

Ниже приведён более сложный пример, который также разрешает родительский каталог. Предположим, что мы находимся в bin/mygem и хотим получить абсолютный путь к lib/mygem.rb.

File.expand_path("../../lib/mygem.rb", __FILE__)
#=> ".../path/to/project/lib/mygem.rb"

Сначала определяется родительский каталог __FILE__, то есть bin/, затем выполняется переход в родительский каталог — корень проекта — и добавляется lib/mygem.rb.

extname(path) → string Показать исходный код

static VALUE
rb_file_s_extname(VALUE klass, VALUE fname)
{
    const char *name, *e;
    long len;
    VALUE extname;

    FilePathStringValue(fname);
    name = StringValueCStr(fname);
    len = RSTRING_LEN(fname);
    e = ruby_enc_find_extname(name, &len, rb_enc_get(fname));
    if (len < 1)
        return rb_str_new(0, 0);
    extname = rb_str_subseq(fname, e - name, len); /* keep the dot, too! */
    return extname;
}

Возвращает расширение (часть имени файла в path, начинающуюся с последней точки).

Если path является скрытым файлом или начинается с точки, начальная точка не считается началом расширения.

Также возвращается пустая строка, если точка является последним символом в path.

В Windows завершающие точки отсекаются.

File.extname("test.rb")         #=> ".rb"
File.extname("a/b/d/test.rb")   #=> ".rb"
File.extname(".a/b/d/test.rb")  #=> ".rb"
File.extname("foo.")            #=> "" on Windows
File.extname("foo.")            #=> "." on non-Windows
File.extname("test")            #=> ""
File.extname(".profile")        #=> ""
File.extname(".profile.sh")     #=> ".sh"

file?(file) → true or false Показать исходный код

static VALUE
rb_file_file_p(VALUE obj, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    return RBOOL(S_ISREG(st.st_mode));
}

Возвращает true, если указанный file существует и является обычным файлом.

file может быть объектом IO.

Если аргумент file является символической ссылкой, она разрешается, и используется файл, на который указывает ссылка.

fnmatch( pattern, path, [flags] ) → (true or false) Показать исходный код

# File dir.rb, line 503
def fnmatch(pattern, path, flags = 0)
end

Возвращает true, если path соответствует pattern. Шаблон не является регулярным выражением; вместо этого он следует правилам, похожим на правила подстановки имён файлов в оболочке. Он может содержать следующие метасимволы:

*

Соответствует любому файлу. Может ограничиваться другими значениями в шаблоне glob. Эквивалентен /.*/x в регулярном выражении.

*: Соответствует всем обычным файлам
c*: Соответствует всем файлам, начинающимся с c
*c: Соответствует всем файлам, заканчивающимся на c
*c*: Соответствует всем файлам, содержащим c (в том числе в начале или в конце).

Чтобы находить скрытые файлы (начинающиеся с .), установите флаг File::FNM_DOTMATCH.

**

Рекурсивно находит каталоги или файлы на любой глубине.

?

Соответствует любому одному символу. Эквивалентен /.{1}/ в регулярном выражении.

[set]

Соответствует любому одному символу из set. Работает точно так же, как наборы символов в Regexp, включая отрицание набора ([^a-z]).

\

Экранирует следующий метасимвол.

{a,b}

Соответствует шаблону a или шаблону b, если установлен флаг File::FNM_EXTGLOB. Работает как объединение Regexp ((?:a|b)).

flags — это побитовое ИЛИ констант FNM_XXX. Тот же шаблон glob и флаги используются в Dir::glob.

Примеры:

File.fnmatch('cat',       'cat')        #=> true  # match entire string
File.fnmatch('cat',       'category')   #=> false # only match partial string

File.fnmatch('c{at,ub}s', 'cats')                    #=> false # { } isn't supported by default
File.fnmatch('c{at,ub}s', 'cats', File::FNM_EXTGLOB) #=> true  # { } is supported on FNM_EXTGLOB

File.fnmatch('c?t',     'cat')          #=> true  # '?' match only 1 character
File.fnmatch('c??t',    'cat')          #=> false # ditto
File.fnmatch('c*',      'cats')         #=> true  # '*' match 0 or more characters
File.fnmatch('c*t',     'c/a/b/t')      #=> true  # ditto
File.fnmatch('ca[a-z]', 'cat')          #=> true  # inclusive bracket expression
File.fnmatch('ca[^t]',  'cat')          #=> false # exclusive bracket expression ('^' or '!')

File.fnmatch('cat', 'CAT')                     #=> false # case sensitive
File.fnmatch('cat', 'CAT', File::FNM_CASEFOLD) #=> true  # case insensitive
File.fnmatch('cat', 'CAT', File::FNM_SYSCASE)  #=> true or false # depends on the system default

File.fnmatch('?',   '/', File::FNM_PATHNAME)  #=> false # wildcard doesn't match '/' on FNM_PATHNAME
File.fnmatch('*',   '/', File::FNM_PATHNAME)  #=> false # ditto
File.fnmatch('[/]', '/', File::FNM_PATHNAME)  #=> false # ditto

File.fnmatch('\?',   '?')                       #=> true  # escaped wildcard becomes ordinary
File.fnmatch('\a',   'a')                       #=> true  # escaped ordinary remains ordinary
File.fnmatch('\a',   '\a', File::FNM_NOESCAPE)  #=> true  # FNM_NOESCAPE makes '\' ordinary
File.fnmatch('[\?]', '?')                       #=> true  # can escape inside bracket expression

File.fnmatch('*',   '.profile')                      #=> false # wildcard doesn't match leading
File.fnmatch('*',   '.profile', File::FNM_DOTMATCH)  #=> true  # period by default.
File.fnmatch('.*',  '.profile')                      #=> true

File.fnmatch('**/*.rb', 'main.rb')                  #=> false
File.fnmatch('**/*.rb', './main.rb')                #=> false
File.fnmatch('**/*.rb', 'lib/song.rb')              #=> true
File.fnmatch('**.rb', 'main.rb')                    #=> true
File.fnmatch('**.rb', './main.rb')                  #=> false
File.fnmatch('**.rb', 'lib/song.rb')                #=> true
File.fnmatch('*',     'dave/.profile')              #=> true

File.fnmatch('**/foo', 'a/b/c/foo', File::FNM_PATHNAME)     #=> true
File.fnmatch('**/foo', '/a/b/c/foo', File::FNM_PATHNAME)    #=> true
File.fnmatch('**/foo', 'c:/a/b/c/foo', File::FNM_PATHNAME)  #=> true
File.fnmatch('**/foo', 'a/.b/c/foo', File::FNM_PATHNAME)    #=> false
File.fnmatch('**/foo', 'a/.b/c/foo', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true

Также имеет псевдоним: fnmatch?

fnmatch?( pattern, path, [flags] ) → (true or false)

Псевдоним для: fnmatch

ftype(file_name) → string Показать исходный код

static VALUE
rb_file_s_ftype(VALUE klass, VALUE fname)
{
    struct stat st;

    FilePathValue(fname);
    fname = rb_str_encode_ospath(fname);
    if (lstat_without_gvl(StringValueCStr(fname), &st) == -1) {
        rb_sys_fail_path(fname);
    }

    return rb_file_ftype(st.st_mode);
}

Определяет тип указанного файла; возвращаемая строка — одно из значений «file», «directory», «characterSpecial», «blockSpecial», «fifo», «link», «socket» или «unknown».

File.ftype("testfile")            #=> "file"
File.ftype("/dev/tty")            #=> "characterSpecial"
File.ftype("/tmp/.X11-unix/X0")   #=> "socket"

grpowned?(file_name) → true or false Показать исходный код

static VALUE
rb_file_grpowned_p(VALUE obj, VALUE fname)
{
#ifndef _WIN32
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    if (rb_group_member(st.st_gid)) return Qtrue;
#endif
    return Qfalse;
}

Возвращает true, если указанный файл существует и эффективный идентификатор группы вызывающего процесса является владельцем файла. В Windows возвращает false.

file_name может быть объектом IO.

identical?(file_1, file_2) → true or false Показать исходный код

static VALUE
rb_file_identical_p(VALUE obj, VALUE fname1, VALUE fname2)
{
#ifndef _WIN32
    struct stat st1, st2;

    if (rb_stat(fname1, &st1) < 0) return Qfalse;
    if (rb_stat(fname2, &st2) < 0) return Qfalse;
    if (st1.st_dev != st2.st_dev) return Qfalse;
    if (st1.st_ino != st2.st_ino) return Qfalse;
    return Qtrue;
#else
    extern VALUE rb_w32_file_identical_p(VALUE, VALUE);
    return rb_w32_file_identical_p(fname1, fname2);
#endif
}

Возвращает true, если указанные файлы идентичны.

file_1 и file_2 могут быть объектами IO.

open("a", "w") {}
p File.identical?("a", "a")      #=> true
p File.identical?("a", "./a")    #=> true
File.link("a", "b")
p File.identical?("a", "b")      #=> true
File.symlink("a", "c")
p File.identical?("a", "c")      #=> true
open("d", "w") {}
p File.identical?("a", "d")      #=> false

join(string, ...) → string Показать исходный код

static VALUE
rb_file_s_join(VALUE klass, VALUE args)
{
    return rb_file_join(args);
}

Возвращает новую строку, полученную объединением строк с помощью "/".

File.join("usr", "mail", "gumby")   #=> "usr/mail/gumby"

lchmod(mode_int, file_name, ...) → integer Показать исходный код

static VALUE
rb_file_s_lchmod(int argc, VALUE *argv, VALUE _)
{
    mode_t mode;

    apply2args(1);
    mode = NUM2MODET(*argv++);

    return apply2files(lchmod_internal, argc, argv, &mode);
}

Эквивалентен File::chmod, но не следует по символическим ссылкам (то есть изменяет разрешения, связанные со ссылкой, а не с файлом, на который она указывает). Часто недоступен.

lchown(owner_int, group_int, file_name,..) → integer Показать исходный код

static VALUE
rb_file_s_lchown(int argc, VALUE *argv, VALUE _)
{
    struct chown_args arg;

    apply2args(2);
    arg.owner = to_uid(*argv++);
    arg.group = to_gid(*argv++);

    return apply2files(lchown_internal, argc, argv, &arg);
}

Эквивалентен File::chown, но не следует по символическим ссылкам (то есть изменяет владельца, связанного со ссылкой, а не файла, на который она указывает). Часто недоступен. Возвращает количество файлов в списке аргументов.

link(old_name, new_name) → 0 Показать исходный код

static VALUE
rb_file_s_link(VALUE klass, VALUE from, VALUE to)
{
    FilePathValue(from);
    FilePathValue(to);
    from = rb_str_encode_ospath(from);
    to = rb_str_encode_ospath(to);

    if (link(StringValueCStr(from), StringValueCStr(to)) < 0) {
        sys_fail2(from, to);
    }
    return INT2FIX(0);
}

Создаёт новое имя для существующего файла с помощью жёсткой ссылки. Если new_name уже существует, он не будет перезаписан (будет вызван подкласс SystemCallError). Доступно не на всех платформах.

File.link("testfile", ".testfile")   #=> 0
IO.readlines(".testfile")[0]         #=> "This is line one\n"

lstat(filepath) → stat Показать исходный код

static VALUE
rb_file_s_lstat(VALUE klass, VALUE fname)
{
#ifdef HAVE_LSTAT
    rb_io_stat_data st;

    FilePathValue(fname);
    fname = rb_str_encode_ospath(fname);
    if (lstatx_without_gvl(StringValueCStr(fname), &st, STATX_ALL) == -1) {
        rb_sys_fail_path(fname);
    }
    return rb_statx_new(&st);
#else
    return rb_file_s_stat(klass, fname);
#endif
}

Подобен File::stat, но не следует по последней символической ссылке; вместо этого возвращает объект File::Stat для самой ссылки.

File.symlink('t.txt', 'symlink')
File.stat('symlink').size  # => 47
File.lstat('symlink').size # => 5

lutime(atime, mtime, file_name, ...) → integer Показать исходный код

static VALUE
rb_file_s_lutime(int argc, VALUE *argv, VALUE _)
{
    return utime_internal_i(argc, argv, TRUE);
}

Устанавливает время доступа и изменения каждого указанного файла в соответствии с первыми двумя аргументами. Если файл является символической ссылкой, этот метод действует на саму ссылку, а не на объект, на который она указывает; для обратного поведения см. File.utime. Возвращает количество имён файлов в списке аргументов.

mkfifo(file_name, mode=0666) → 0 Показать исходный код

static VALUE
rb_file_s_mkfifo(int argc, VALUE *argv, VALUE _)
{
    VALUE path;
    struct mkfifo_arg ma;

    ma.mode = 0666;
    rb_check_arity(argc, 1, 2);
    if (argc > 1) {
        ma.mode = NUM2MODET(argv[1]);
    }
    path = argv[0];
    FilePathValue(path);
    path = rb_str_encode_ospath(path);
    ma.path = RSTRING_PTR(path);
    if (IO_WITHOUT_GVL(nogvl_mkfifo, &ma)) {
        rb_sys_fail_path(path);
    }
    return INT2FIX(0);
}

Создаёт специальный файл FIFO с именем file_name. Параметр mode задаёт разрешения FIFO. Как обычно, на него влияет маска процесса umask: разрешения созданного файла равны (mode & ~umask).

mtime(file_name) → time Показать исходный код

static VALUE
rb_file_s_mtime(VALUE klass, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) {
        int e = errno;
        FilePathValue(fname);
        rb_syserr_fail_path(e, fname);
    }
    return stat_time(stat_mtimespec(&st));
}

Возвращает время изменения указанного файла в виде объекта Time.

file_name может быть объектом IO.

File.mtime("testfile")   #=> Tue Apr 08 12:58:04 CDT 2003

new(path, mode = 'r', perm = 0666, **opts) → file Показать исходный код

static VALUE
rb_file_initialize(int argc, VALUE *argv, VALUE io)
{
    if (RFILE(io)->fptr) {
        rb_raise(rb_eRuntimeError, "reinitializing File");
    }
    VALUE fname, vmode, vperm, opt;
    int posargc = rb_scan_args(argc, argv, "12:", &fname, &vmode, &vperm, &opt);
    if (posargc < 3) {          /* perm is File only */
        VALUE fd = rb_check_to_int(fname);

        if (!NIL_P(fd)) {
            return io_initialize(io, fd, vmode, opt);
        }
    }
    return rb_open_file(io, fname, vmode, vperm, opt);
}

Открывает файл по указанному path в соответствии с заданным mode; создаёт и возвращает новый объект File для этого файла.

Новый объект File работает в буферизованном режиме (или в режиме без синхронизации), если только filename не является терминалом. См. IO#flush, IO#fsync, IO#fdatasync и IO#sync=.

Аргумент path должен быть допустимым путём к файлу:

f = File.new('/etc/fstab')
f.close
f = File.new('t.txt')
f.close

Необязательный аргумент mode (по умолчанию — ‘r’) должен задавать допустимый режим; см. Режимы доступа:

f = File.new('t.tmp', 'w')
f.close
f = File.new('t.tmp', File::RDONLY)
f.close

Необязательный аргумент perm (по умолчанию — 0666) должен задавать допустимые разрешения; см. Разрешения файлов:

f = File.new('t.tmp', File::CREAT, 0644)
f.close
f = File.new('t.tmp', File::CREAT, 0444)
f.close

Необязательные именованные аргументы opts задают:

open(path, mode = 'r', perm = 0666, **opts) → file Показать исходный код

open(path, mode = 'r', perm = 0666, **opts) {|f| ... } → object

static VALUE
rb_io_s_open(int argc, VALUE *argv, VALUE klass)
{
    VALUE io = rb_class_new_instance_kw(argc, argv, klass, RB_PASS_CALLED_KEYWORDS);

    if (rb_block_given_p()) {
        return rb_ensure(rb_yield, io, io_close, io);
    }

    return io;
}

Создаёт новый объект File с помощью File.new, передавая ему заданные аргументы.

Если блок не задан, возвращает объект File.

Если блок задан, вызывает его, передавая объект File, и возвращает значение блока.

owned?(file_name) → true or false Показать исходный код

static VALUE
rb_file_owned_p(VALUE obj, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    return RBOOL(st.st_uid == geteuid());
}

Возвращает true, если указанный файл существует и эффективный идентификатор пользователя вызывающего процесса является владельцем файла.

file_name может быть объектом IO.

path(path) → string Показать исходный код

static VALUE
rb_file_s_path(VALUE klass, VALUE fname)
{
    return rb_get_path(fname);
}

Returns the string representation of the path

   File.path(File::NULL)           #=> "/dev/null"
   File.path(Pathname.new("/tmp")) #=> "/tmp"

Если path не является строкой:

Если у него есть метод to_path, этот метод будет вызван для преобразования в String.
В противном случае, а также если результат преобразования тоже не является String, для этого объекта будет выполнено стандартное преобразование с помощью метода to_str. (См. также String.try_convert.)

Преобразованная строка должна удовлетворять следующим условиям:

Она должна иметь ASCII-совместимую кодировку; в противном случае будет вызвано исключение Encoding::CompatibilityError.
Она не должна содержать символ NUL (\0); в противном случае будет вызвано исключение ArgumentError.

pipe?(filepath) → true or false Показать исходный код

static VALUE
rb_file_pipe_p(VALUE obj, VALUE fname)
{
#ifdef S_IFIFO
#  ifndef S_ISFIFO
#    define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)
#  endif

    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    if (S_ISFIFO(st.st_mode)) return Qtrue;

#endif
    return Qfalse;
}

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

File.mkfifo('tmp/fifo')
File.pipe?('tmp/fifo') # => true
File.pipe?('t.txt')    # => false

readable?(file_name) → true or false Показать исходный код

static VALUE
rb_file_readable_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_eaccess(fname, R_OK) >= 0);
}

Возвращает true, если указанный файл доступен для чтения эффективному идентификатору пользователя и группы этого процесса. См. eaccess(3).

Обратите внимание: некоторые средства безопасности на уровне ОС могут привести к тому, что метод вернёт true, даже если файл недоступен для чтения эффективному пользователю/группе.

readable_real?(file_name) → true or false Показать исходный код

static VALUE
rb_file_readable_real_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_access(fname, R_OK) >= 0);
}

Возвращает true, если указанный файл доступен для чтения реальному идентификатору пользователя и группы этого процесса. См. access(3).

Обратите внимание: некоторые средства безопасности на уровне ОС могут привести к тому, что метод вернёт true, даже если файл недоступен для чтения реальному пользователю/группе.

readlink(link_name) → file_name Показать исходный код

static VALUE
rb_file_s_readlink(VALUE klass, VALUE path)
{
    return rb_readlink(path, rb_filesystem_encoding());
}

Возвращает имя файла, на который ссылается указанная ссылка. Метод доступен не на всех платформах.

File.symlink("testfile", "link2test")   #=> 0
File.readlink("link2test")              #=> "testfile"

realdirpath(pathname [, dir_string]) → real_pathname Показать исходный код

static VALUE
rb_file_s_realdirpath(int argc, VALUE *argv, VALUE klass)
{
    VALUE basedir = (rb_check_arity(argc, 1, 2) > 1) ? argv[1] : Qnil;
    VALUE path = argv[0];
    FilePathValue(path);
    return rb_realpath_internal(basedir, path, 0);
}

Возвращает реальный (абсолютный) путь к pathname в фактической файловой системе. Реальный путь не содержит символических ссылок и ненужных точек.

Если указан dir_string, он используется в качестве базового каталога для интерпретации относительного пути вместо текущего каталога.

Последний компонент реального пути может не существовать.

realpath(pathname [, dir_string]) → real_pathname Показать исходный код

static VALUE
rb_file_s_realpath(int argc, VALUE *argv, VALUE klass)
{
    VALUE basedir = (rb_check_arity(argc, 1, 2) > 1) ? argv[1] : Qnil;
    VALUE path = argv[0];
    FilePathValue(path);
    return rb_realpath_internal(basedir, path, 1);
}

Возвращает реальный (абсолютный) путь к pathname в фактической файловой системе без символических ссылок и ненужных точек.

На момент вызова этого метода должны существовать все компоненты пути.

rename(old_name, new_name) → 0 Показать исходный код

static VALUE
rb_file_s_rename(VALUE klass, VALUE from, VALUE to)
{
    struct rename_args ra;
    VALUE f, t;

    FilePathValue(from);
    FilePathValue(to);
    f = rb_str_encode_ospath(from);
    t = rb_str_encode_ospath(to);
    ra.src = StringValueCStr(f);
    ra.dst = StringValueCStr(t);
#if defined __CYGWIN__
    errno = 0;
#endif
    if (IO_WITHOUT_GVL_INT(no_gvl_rename, &ra) < 0) {
        int e = errno;
#if defined DOSISH
        switch (e) {
          case EEXIST:
            if (chmod(ra.dst, 0666) == 0 &&
                unlink(ra.dst) == 0 &&
                rename(ra.src, ra.dst) == 0)
                return INT2FIX(0);
        }
#endif
        syserr_fail2(e, from, to);
    }

    return INT2FIX(0);
}

Переименовывает указанный файл. Если файл невозможно переименовать, вызывает исключение SystemCallError.

File.rename("afile", "afile.bak")   #=> 0

setgid?(file_name) → true or false Показать исходный код

static VALUE
rb_file_sgid_p(VALUE obj, VALUE fname)
{
#ifdef S_ISGID
    return check3rdbyte(fname, S_ISGID);
#else
    return Qfalse;
#endif
}

Возвращает true, если для указанного файла установлен бит setgid.

file_name может быть объектом IO.

setuid?(file_name) → true or false Показать исходный код

static VALUE
rb_file_suid_p(VALUE obj, VALUE fname)
{
#ifdef S_ISUID
    return check3rdbyte(fname, S_ISUID);
#else
    return Qfalse;
#endif
}

Возвращает true, если для указанного файла установлен бит setuid.

file_name может быть объектом IO.

size(file_name) → integer Показать исходный код

static VALUE
rb_file_s_size(VALUE klass, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) {
        int e = errno;
        FilePathValue(fname);
        rb_syserr_fail_path(e, fname);
    }
    return OFFT2NUM(st.st_size);
}

Возвращает размер file_name.

file_name может быть объектом IO.

size?(file_name) → Integer or nil Показать исходный код

static VALUE
rb_file_size_p(VALUE obj, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qnil;
    if (st.st_size == 0) return Qnil;
    return OFFT2NUM(st.st_size);
}

Возвращает nil, если file_name не существует или имеет нулевой размер; в противном случае возвращает размер файла.

file_name может быть объектом IO.

socket?(filepath) → true or false Показать исходный код

static VALUE
rb_file_socket_p(VALUE obj, VALUE fname)
{
#ifndef S_ISSOCK
#  ifdef _S_ISSOCK
#    define S_ISSOCK(m) _S_ISSOCK(m)
#  else
#    ifdef _S_IFSOCK
#      define S_ISSOCK(m) (((m) & S_IFMT) == _S_IFSOCK)
#    else
#      ifdef S_IFSOCK
#        define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)
#      endif
#    endif
#  endif
#endif

#ifdef S_ISSOCK
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    if (S_ISSOCK(st.st_mode)) return Qtrue;
#endif

    return Qfalse;
}

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

require 'socket'
File.socket?(Socket.new(:INET, :STREAM)) # => true
File.socket?(File.new('t.txt'))          # => false

split(file_name) → array Показать исходный код

static VALUE
rb_file_s_split(VALUE klass, VALUE path)
{
    FilePathStringValue(path);          /* get rid of converting twice */
    return rb_assoc_new(rb_file_dirname(path), rb_file_s_basename(1,&path,Qundef));
}

Разделяет указанную строку на каталог и компонент файла и возвращает их в массиве из двух элементов. См. также File::dirname и File::basename.

File.split("/home/gumby/.profile")   #=> ["/home/gumby", ".profile"]

stat(filepath) → stat Показать исходный код

static VALUE
rb_file_s_stat(VALUE klass, VALUE fname)
{
    rb_io_stat_data st;

    FilePathValue(fname);
    fname = rb_str_encode_ospath(fname);
    if (statx_without_gvl(RSTRING_PTR(fname), &st, STATX_ALL) < 0) {
        rb_sys_fail_path(fname);
    }
    return rb_statx_new(&st);
}

Возвращает объект File::Stat для файла по пути filepath (см. File::Stat):

File.stat('t.txt').class # => File::Stat

sticky?(file_name) → true or false Показать исходный код

static VALUE
rb_file_sticky_p(VALUE obj, VALUE fname)
{
#ifdef S_ISVTX
    return check3rdbyte(fname, S_ISVTX);
#else
    return Qfalse;
#endif
}

Возвращает true, если для указанного файла установлен sticky bit.

file_name может быть объектом IO.

symlink(old_name, new_name) → 0 Показать исходный код

static VALUE
rb_file_s_symlink(VALUE klass, VALUE from, VALUE to)
{
    FilePathValue(from);
    FilePathValue(to);
    from = rb_str_encode_ospath(from);
    to = rb_str_encode_ospath(to);

    if (symlink(StringValueCStr(from), StringValueCStr(to)) < 0) {
        sys_fail2(from, to);
    }
    return INT2FIX(0);
}

Создаёт символическую ссылку с именем new_name для существующего файла old_name. На платформах, не поддерживающих символические ссылки, вызывает исключение NotImplemented.

File.symlink("testfile", "link2test")   #=> 0

symlink?(filepath) → true or false Показать исходный код

static VALUE
rb_file_symlink_p(VALUE obj, VALUE fname)
{
#ifndef S_ISLNK
#  ifdef _S_ISLNK
#    define S_ISLNK(m) _S_ISLNK(m)
#  else
#    ifdef _S_IFLNK
#      define S_ISLNK(m) (((m) & S_IFMT) == _S_IFLNK)
#    else
#      ifdef S_IFLNK
#        define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
#      endif
#    endif
#  endif
#endif

#ifdef S_ISLNK
    struct stat st;

    FilePathValue(fname);
    fname = rb_str_encode_ospath(fname);
    if (lstat_without_gvl(StringValueCStr(fname), &st) < 0) return Qfalse;
    if (S_ISLNK(st.st_mode)) return Qtrue;
#endif

    return Qfalse;
}

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

symlink = File.symlink('t.txt', 'symlink')
File.symlink?('symlink') # => true
File.symlink?('t.txt')   # => false

truncate(file_name, integer) → 0 Показать исходный код

static VALUE
rb_file_s_truncate(VALUE klass, VALUE path, VALUE len)
{
    struct truncate_arg ta;
    int r;

    ta.pos = NUM2OFFT(len);
    FilePathValue(path);
    path = rb_str_encode_ospath(path);
    ta.path = StringValueCStr(path);

    r = IO_WITHOUT_GVL_INT(nogvl_truncate, &ta);
    if (r < 0)
        rb_sys_fail_path(path);
    return INT2FIX(0);
}

Усекает файл file_name до размера не более integer байт. Метод доступен не на всех платформах.

f = File.new("out", "w")
f.write("1234567890")     #=> 10
f.close                   #=> nil
File.truncate("out", 5)   #=> 0
File.size("out")          #=> 5

umask() → integer Показать исходный код

umask(integer) → integer

static VALUE
rb_file_s_umask(int argc, VALUE *argv, VALUE _)
{
    mode_t omask = 0;

    switch (argc) {
      case 0:
        omask = umask(0);
        umask(omask);
        break;
      case 1:
        omask = umask(NUM2MODET(argv[0]));
        break;
      default:
        rb_error_arity(argc, 0, 1);
    }
    return MODET2NUM(omask);
}

Возвращает текущее значение umask для этого процесса. Если указан необязательный аргумент, устанавливает umask в это значение и возвращает предыдущее. Значения umask вычитаются из разрешений по умолчанию, поэтому umask со значением 0222 сделает файл доступным только для чтения всем пользователям.

File.umask(0006)   #=> 18
File.umask         #=> 6

delete(file_name, ...) → integer Показать исходный код

unlink(file_name, ...) → integer

static VALUE
rb_file_s_unlink(int argc, VALUE *argv, VALUE klass)
{
    return apply2files(unlink_internal, argc, argv, 0);
}

Удаляет указанные файлы и возвращает количество переданных в качестве аргументов имён. При любой ошибке вызывает исключение. Поскольку реализация использует системный вызов unlink(2), тип вызываемого исключения зависит от типа ошибки (см. linux.die.net/man/2/unlink) и имеет, например, вид Errno::ENOENT.

См. также Dir::rmdir.

utime(atime, mtime, file_name, ...) → integer Показать исходный код

static VALUE
rb_file_s_utime(int argc, VALUE *argv, VALUE _)
{
    return utime_internal_i(argc, argv, FALSE);
}

Устанавливает время доступа и время изменения каждого указанного файла в значения первых двух аргументов. Если файл является символической ссылкой, метод применяется к целевому файлу, а не к самой ссылке; обратное поведение описано в File.lutime. Возвращает количество имён файлов в списке аргументов.

world_readable?(file_name) → integer or nil Показать исходный код

static VALUE
rb_file_world_readable_p(VALUE obj, VALUE fname)
{
#ifdef S_IROTH
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qnil;
    if ((st.st_mode & (S_IROTH)) == S_IROTH) {
        return UINT2NUM(st.st_mode & (S_IRUGO|S_IWUGO|S_IXUGO));
    }
#endif
    return Qnil;
}

Если файл file_name доступен для чтения другим пользователям, возвращает целое число, представляющее биты разрешений файла file_name. В противном случае возвращает nil. Значение битов зависит от платформы; в системах Unix см. stat(2).

file_name может быть объектом IO.

File.world_readable?("/etc/passwd")           #=> 420
m = File.world_readable?("/etc/passwd")
sprintf("%o", m)                              #=> "644"

world_writable?(file_name) → integer or nil Показать исходный код

static VALUE
rb_file_world_writable_p(VALUE obj, VALUE fname)
{
#ifdef S_IWOTH
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qnil;
    if ((st.st_mode & (S_IWOTH)) == S_IWOTH) {
        return UINT2NUM(st.st_mode & (S_IRUGO|S_IWUGO|S_IXUGO));
    }
#endif
    return Qnil;
}

Если файл file_name доступен для записи другим пользователям, возвращает целое число, представляющее биты разрешений файла file_name. В противном случае возвращает nil. Значение битов зависит от платформы; в системах Unix см. stat(2).

file_name может быть объектом IO.

File.world_writable?("/tmp")                  #=> 511
m = File.world_writable?("/tmp")
sprintf("%o", m)                              #=> "777"

writable?(file_name) → true or false Показать исходный код

static VALUE
rb_file_writable_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_eaccess(fname, W_OK) >= 0);
}

Возвращает true, если указанный файл доступен для записи эффективному идентификатору пользователя и группы этого процесса. См. eaccess(3).

Обратите внимание: некоторые средства безопасности на уровне ОС могут привести к тому, что метод вернёт true, даже если файл недоступен для записи эффективному пользователю/группе.

writable_real?(file_name) → true or false Показать исходный код

static VALUE
rb_file_writable_real_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_access(fname, W_OK) >= 0);
}

Возвращает true, если указанный файл доступен для записи реальному идентификатору пользователя и группы этого процесса. См. access(3).

Обратите внимание: некоторые средства безопасности на уровне ОС могут привести к тому, что метод вернёт true, даже если файл недоступен для записи реальному пользователю/группе.

zero?(file_name) → true or false Показать исходный код

static VALUE
rb_file_zero_p(VALUE obj, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    return RBOOL(st.st_size == 0);
}

Возвращает true, если указанный файл существует и имеет нулевой размер.

file_name может быть объектом IO.

Открытые методы экземпляра

atime → time Показать исходный код

static VALUE
rb_file_atime(VALUE obj)
{
    rb_io_t *fptr;
    struct stat st;

    GetOpenFile(obj, fptr);
    if (fstat(fptr->fd, &st) == -1) {
        rb_sys_fail_path(fptr->pathv);
    }
    return stat_time(stat_atimespec(&st));
}

Возвращает время последнего доступа к file (объект Time) или время эпохи, если к file не обращались.

File.new("testfile").atime   #=> Wed Dec 31 18:00:00 CST 1969

birthtime → time Показать исходный код

static VALUE
rb_file_birthtime(VALUE obj)
{
    rb_io_t *fptr;
    rb_io_stat_data st;

    GetOpenFile(obj, fptr);
    if (fstatx_without_gvl(fptr, &st, STATX_BTIME) == -1) {
        rb_sys_fail_path(fptr->pathv);
    }
    return statx_birthtime(&st);
}

Возвращает время создания file.

File.new("testfile").birthtime   #=> Wed Apr 09 08:53:14 CDT 2003

Если платформа не поддерживает время создания, вызывает исключение NotImplementedError.

chmod(mode_int) → 0 Показать исходный код

static VALUE
rb_file_chmod(VALUE obj, VALUE vmode)
{
    rb_io_t *fptr;
    mode_t mode;
#if !defined HAVE_FCHMOD || !HAVE_FCHMOD
    VALUE path;
#endif

    mode = NUM2MODET(vmode);

    GetOpenFile(obj, fptr);
#ifdef HAVE_FCHMOD
    if (rb_fchmod(fptr, mode) == -1) {
        if (HAVE_FCHMOD || errno != ENOSYS)
            rb_sys_fail_path(fptr->pathv);
    }
    else {
        if (!HAVE_FCHMOD) return INT2FIX(0);
    }
#endif
#if !defined HAVE_FCHMOD || !HAVE_FCHMOD
    if (NIL_P(fptr->pathv)) return Qnil;
    path = rb_str_encode_ospath(fptr->pathv);
    if (rb_chmod(RSTRING_PTR(path), mode) == -1)
        rb_sys_fail_path(fptr->pathv);
#endif

    return INT2FIX(0);
}

Изменяет биты разрешений file в соответствии с битовым шаблоном, заданным mode_int. Фактический результат зависит от платформы; подробности для систем Unix см. в chmod(2). Переходит по символическим ссылкам. См. также File#lchmod.

f = File.new("out", "w");
f.chmod(0644)   #=> 0

chown(owner_int, group_int ) → 0 Показать исходный код

static VALUE
rb_file_chown(VALUE obj, VALUE owner, VALUE group)
{
    rb_io_t *fptr;
    rb_uid_t o;
    rb_gid_t g;
#ifndef HAVE_FCHOWN
    VALUE path;
#endif

    o = to_uid(owner);
    g = to_gid(group);
    GetOpenFile(obj, fptr);
#ifndef HAVE_FCHOWN
    if (NIL_P(fptr->pathv)) return Qnil;
    path = rb_str_encode_ospath(fptr->pathv);
    if (rb_chown(RSTRING_PTR(path), o, g) == -1)
        rb_sys_fail_path(fptr->pathv);
#else
    if (rb_fchown(fptr->fd, o, g) == -1)
        rb_sys_fail_path(fptr->pathv);
#endif

    return INT2FIX(0);
}

Изменяет владельца и группу file на заданные числовые идентификаторы владельца и группы. Только процесс с привилегиями суперпользователя может изменить владельца файла. Текущий владелец файла может изменить его группу на любую группу, к которой он принадлежит. Идентификатор владельца или группы nil либо -1 игнорируется. Переходит по символическим ссылкам. См. также File#lchown.

File.new("testfile").chown(502, 1000)

ctime → time Показать исходный код

static VALUE
rb_file_ctime(VALUE obj)
{
    rb_io_t *fptr;
    struct stat st;

    GetOpenFile(obj, fptr);
    if (fstat(fptr->fd, &st) == -1) {
        rb_sys_fail_path(fptr->pathv);
    }
    return stat_time(stat_ctimespec(&st));
}

Возвращает время изменения file (то есть время изменения сведений о файле в каталоге, а не самого файла).

Обратите внимание: в Windows (NTFS) возвращается время создания (время рождения).

File.new("testfile").ctime   #=> Wed Apr 09 08:53:14 CDT 2003

flock(locking_constant) → 0 or false Показать исходный код

static VALUE
rb_file_flock(VALUE obj, VALUE operation)
{
    rb_io_t *fptr;
    int op[2], op1;
    struct timeval time;

    op[1] = op1 = NUM2INT(operation);
    GetOpenFile(obj, fptr);
    op[0] = fptr->fd;

    if (fptr->mode & FMODE_WRITABLE) {
        rb_io_flush_raw(obj, 0);
    }
    while ((int)rb_io_blocking_region(fptr, rb_thread_flock, op) < 0) {
        int e = errno;
        switch (e) {
          case EAGAIN:
          case EACCES:
#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
          case EWOULDBLOCK:
#endif
            if (op1 & LOCK_NB) return Qfalse;

            time.tv_sec = 0;
            time.tv_usec = 100 * 1000;  /* 0.1 sec */
            rb_thread_wait_for(time);
            rb_io_check_closed(fptr);
            continue;

          case EINTR:
#if defined(ERESTART)
          case ERESTART:
#endif
            break;

          default:
            rb_syserr_fail_path(e, fptr->pathv);
        }
    }
    return INT2FIX(0);
}

Блокирует или разблокирует файл self в соответствии с заданным locking_constant — побитовым ИЛИ значений из таблицы ниже.

Метод доступен не на всех платформах.

Возвращает false, если указан File::LOCK_NB и операция была бы заблокирована; в противном случае возвращает 0.

Константа	Блокировка	Действие
`File::LOCK_EX`	Эксклюзивная	В каждый момент времени только один процесс может удерживать эксклюзивную блокировку для `self`.
`File::LOCK_NB`	Неблокирующая	Без ожидания; может сочетаться с `File::LOCK_SH` или `File::LOCK_EX` с помощью побитового оператора ИЛИ `\|`.
`File::LOCK_SH`	Совместная	Несколько процессов могут одновременно удерживать совместную блокировку для `self`.
`File::LOCK_UN`	Разблокировка	Снимает существующую блокировку, удерживаемую этим процессом.

Пример:

# Update a counter using an exclusive lock.
# Don't use File::WRONLY because it truncates the file.
File.open('counter', File::RDWR | File::CREAT, 0644) do |f|
  f.flock(File::LOCK_EX)
  value = f.read.to_i + 1
  f.rewind
  f.write("#{value}\n")
  f.flush
  f.truncate(f.pos)
end

# Read the counter using a shared lock.
File.open('counter', 'r') do |f|
  f.flock(File::LOCK_SH)
  f.read
end

lstat → stat Показать исходный код

static VALUE
rb_file_lstat(VALUE obj)
{
#ifdef HAVE_LSTAT
    rb_io_t *fptr;
    rb_io_stat_data st;
    VALUE path;

    GetOpenFile(obj, fptr);
    if (NIL_P(fptr->pathv)) return Qnil;
    path = rb_str_encode_ospath(fptr->pathv);
    if (lstatx_without_gvl(RSTRING_PTR(path), &st, STATX_ALL) == -1) {
        rb_sys_fail_path(fptr->pathv);
    }
    return rb_statx_new(&st);
#else
    return rb_io_stat(obj);
#endif
}

Подобно File#stat, но не переходит по последней символической ссылке; вместо этого возвращает объект File::Stat для самой ссылки:

File.symlink('t.txt', 'symlink')
f = File.new('symlink')
f.stat.size  # => 47
f.lstat.size # => 11

mtime → time Показать исходный код

static VALUE
rb_file_mtime(VALUE obj)
{
    rb_io_t *fptr;
    struct stat st;

    GetOpenFile(obj, fptr);
    if (fstat(fptr->fd, &st) == -1) {
        rb_sys_fail_path(fptr->pathv);
    }
    return stat_time(stat_mtimespec(&st));
}

Возвращает время изменения file.

File.new("testfile").mtime   #=> Wed Apr 09 08:53:14 CDT 2003

size → integer Показать исходный код

static VALUE
file_size(VALUE self)
{
    return OFFT2NUM(rb_file_size(self));
}

Возвращает размер file в байтах.

File.new("testfile").size   #=> 66

truncate(integer) → 0 Показать исходный код

static VALUE
rb_file_truncate(VALUE obj, VALUE len)
{
    rb_io_t *fptr;
    struct ftruncate_arg fa;

    fa.pos = NUM2OFFT(len);
    GetOpenFile(obj, fptr);
    if (!(fptr->mode & FMODE_WRITABLE)) {
        rb_raise(rb_eIOError, "not opened for writing");
    }
    rb_io_flush_raw(obj, 0);
    fa.fd = fptr->fd;
    if ((int)rb_io_blocking_region(fptr, nogvl_ftruncate, &fa) < 0) {
        rb_sys_fail_path(fptr->pathv);
    }
    return INT2FIX(0);
}

Усекает file до размера не более integer байт. Файл должен быть открыт для записи. Метод доступен не на всех платформах.

f = File.new("out", "w")
f.syswrite("1234567890")   #=> 10
f.truncate(5)              #=> 0
f.close()                  #=> nil
File.size("out")           #=> 5

Ruby Core © 1993–2025 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.