класс 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, который:

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

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

Режим чтения/записи 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)

Примечание: Method 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 проверяет наличие BOM (Unicode Byte Order Mark) в входном документе, чтобы определить кодировку. Для 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 и 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_atime(&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)
{
    statx_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, fname);
}

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

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_ctime(&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 или 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, если указанный файл существует и имеет размер 0 байт.

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

executable?(file_name) → true или 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 или 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 или 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 должна быть установлена правильно). «~пользователь» расширяется до домашней директории указанного пользователя.

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) → строка

Исходный код

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 или 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 может быть объектом IO.

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

fnmatch( pattern, path, [flags] ) → (true или false)

Исходный код

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

Возвращает true, если шаблон path соответствует пути pattern.

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

*

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

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

Для соответствия скрытым файлам (начинающимся с .), установите флаг File::FNM_DOTMATCH.

**

Соответствует директориям рекурсивно или файлам расширительно.

?

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

[set]

Соответствует любому символу из set.

\

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

{a,b}

Соответствует шаблону a и шаблону b, если включён флаг File::FNM_EXTGLOB. Ведёт себя как объединение в регулярных выражениях ((?:a|b)).

flags — это битовое ИЛИ констант FNM_XXX. Тот же шаблон и флаги используются в 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) → строка

Исходный код

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

Определяет тип указанного файла; возвращаемая строка — одна из «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 или 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, если указанный файл существует и эффективная группа вызывающего процесса является владельцем файла. Возвращает false в Windows.

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

END_OF_DOCUMENT_MARKER

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
    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_stat_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_mtime(&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 не является tty. См. 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);
}

Возвращает строковое представление пути

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

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)
{
    struct stat st;

    FilePathValue(fname);
    fname = rb_str_encode_ospath(fname);
    if (stat_without_gvl(RSTRING_PTR(fname), &st) < 0) {
        rb_sys_fail_path(fname);
    }
    return rb_stat_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 → время

Исходный код

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_atime(&st);
}

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

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

birthtime → время

Исходный код

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

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

Возвращает время создания файла 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->fd, 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 → время

Исходный код

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_ctime(&st);
}

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

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

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

flock(locking_constant) → 0 или 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;
    struct stat st;
    VALUE path;

    GetOpenFile(obj, fptr);
    if (NIL_P(fptr->pathv)) return Qnil;
    path = rb_str_encode_ospath(fptr->pathv);
    if (lstat_without_gvl(RSTRING_PTR(path), &st) == -1) {
        rb_sys_fail_path(fptr->pathv);
    }
    return rb_stat_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 → время

Исходный код

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_mtime(&st);
}

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

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

size → целое число

Исходный код

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

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

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

truncate(целое число) → 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–2024 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.