class File::Stat

Родительский класс:: Object
Подключённые модули:: Comparable

Объекты класса File::Stat инкапсулируют общую информацию о состоянии объектов File. Информация фиксируется в момент создания объекта File::Stat; изменения, внесённые в файл после этого момента, не будут отражены. Объекты File::Stat возвращаются методами IO#stat, File::stat, File#lstat и File::lstat. Многие из этих методов возвращают значения, зависящие от платформы, и не все значения имеют смысл во всех системах. См. также Kernel#test.

Открытые методы класса

File::Stat.new(file_name) → stat Показать исходный код

static VALUE
rb_stat_init(VALUE obj, VALUE fname)
{
    rb_io_stat_data st;

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

    struct rb_stat *rb_st;
    TypedData_Get_Struct(obj, struct rb_stat, &stat_data_type, rb_st);

    rb_st->stat = st;
    rb_st->initialized = true;

    return Qnil;
}

Создаёт объект File::Stat для указанного имени файла (вызывает исключение, если файл не существует).

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

self <=> other → -1, 0, 1, or nil Показать исходный код

static VALUE
rb_stat_cmp(VALUE self, VALUE other)
{
    if (rb_obj_is_kind_of(other, rb_obj_class(self))) {
        stat_timestamp ts1 = statx_mtimespec(get_stat(self));
        stat_timestamp ts2 = statx_mtimespec(get_stat(other));
        if (ts1.tv_sec == ts2.tv_sec) {
            if (ts1.tv_nsec == ts2.tv_nsec) return INT2FIX(0);
            if (ts1.tv_nsec < ts2.tv_nsec) return INT2FIX(-1);
            return INT2FIX(1);
        }
        if (ts1.tv_sec < ts2.tv_sec) return INT2FIX(-1);
        return INT2FIX(1);
    }
    return Qnil;
}

Сравнивает self и other по времени изменения, то есть сравнивает self.mtime и other.mtime.

Возвращает:

-1, если self.mtime раньше.
0, если значения равны.
1, если self.mtime позже.
nil, если other не является объектом File::Stat.

Примеры:

stat0 = File.stat('README.md')
stat1 = File.stat('NEWS.md')
stat0.mtime         # => 2025-12-20 15:33:05.6972341 -0600
stat1.mtime         # => 2025-12-20 16:02:08.2672945 -0600
stat0 <=> stat1     # => -1
stat0 <=> stat0.dup # => 0
stat1 <=> stat0     # => 1
stat0 <=> :foo      # => nil

Класс File::Stat подключает модуль Comparable, каждый метод которого использует File::Stat#<=> для сравнения.

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

static VALUE
rb_stat_atime(VALUE self)
{
    return stat_time(statx_atimespec(get_stat(self)));
}

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

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

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

static VALUE
rb_stat_birthtime(VALUE self)
{
    return statx_birthtime(get_stat(self));
}

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

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

File.write("testfile", "foo")
sleep 10
File.write("testfile", "bar")
sleep 10
File.chmod(0644, "testfile")
sleep 10
File.read("testfile")
File.stat("testfile").birthtime   #=> 2014-02-24 11:19:17 +0900
File.stat("testfile").mtime       #=> 2014-02-24 11:19:27 +0900
File.stat("testfile").ctime       #=> 2014-02-24 11:19:37 +0900
File.stat("testfile").atime       #=> 2014-02-24 11:19:47 +0900

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

static VALUE
rb_stat_blksize(VALUE self)
{
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
    return ULONG2NUM(get_stat(self)->ST_(blksize));
#else
    return Qnil;
#endif
}

Возвращает размер блока родной файловой системы. На платформах, не поддерживающих эту информацию, возвращает nil.

File.stat("testfile").blksize   #=> 4096

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

static VALUE
rb_stat_b(VALUE obj)
{
#ifdef S_ISBLK
    if (S_ISBLK(get_stat(obj)->ST_(mode))) return Qtrue;

#endif
    return Qfalse;
}

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

File.stat("testfile").blockdev?    #=> false
File.stat("/dev/hda1").blockdev?   #=> true

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

static VALUE
rb_stat_blocks(VALUE self)
{
#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
# if SIZEOF_STRUCT_STAT_ST_BLOCKS > SIZEOF_LONG
    return ULL2NUM(get_stat(self)->ST_(blocks));
# else
    return ULONG2NUM(get_stat(self)->ST_(blocks));
# endif
#else
    return Qnil;
#endif
}

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

File.stat("testfile").blocks   #=> 2

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

static VALUE
rb_stat_c(VALUE obj)
{
    if (S_ISCHR(get_stat(obj)->ST_(mode))) return Qtrue;

    return Qfalse;
}

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

File.stat("/dev/tty").chardev?   #=> true

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

static VALUE
rb_stat_ctime(VALUE self)
{
    return stat_time(statx_ctimespec(get_stat(self)));
}

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

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

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

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

static VALUE
rb_stat_dev(VALUE self)
{
#if RUBY_USE_STATX
    unsigned int m = get_stat(self)->stx_dev_major;
    unsigned int n = get_stat(self)->stx_dev_minor;
    return ULL2NUM(makedev(m, n));
#elif SIZEOF_STRUCT_STAT_ST_DEV <= SIZEOF_DEV_T
    return DEVT2NUM(get_stat(self)->st_dev);
#elif SIZEOF_STRUCT_STAT_ST_DEV <= SIZEOF_LONG
    return ULONG2NUM(get_stat(self)->st_dev);
#else
    return ULL2NUM(get_stat(self)->st_dev);
#endif
}

Возвращает целое число, представляющее устройство, на котором находится stat.

File.stat("testfile").dev   #=> 774

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

static VALUE
rb_stat_dev_major(VALUE self)
{
#if RUBY_USE_STATX
    return UINT2NUM(get_stat(self)->stx_dev_major);
#elif defined(major)
    return UINT2NUM(major(get_stat(self)->st_dev));
#else
    return Qnil;
#endif
}

Возвращает старшую часть File_Stat#dev или nil.

File.stat("/dev/fd1").dev_major   #=> 2
File.stat("/dev/tty").dev_major   #=> 5

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

static VALUE
rb_stat_dev_minor(VALUE self)
{
#if RUBY_USE_STATX
    return UINT2NUM(get_stat(self)->stx_dev_minor);
#elif defined(minor)
    return UINT2NUM(minor(get_stat(self)->st_dev));
#else
    return Qnil;
#endif
}

Возвращает младшую часть File_Stat#dev или nil.

File.stat("/dev/fd1").dev_minor   #=> 1
File.stat("/dev/tty").dev_minor   #=> 0

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

static VALUE
rb_stat_d(VALUE obj)
{
    if (S_ISDIR(get_stat(obj)->ST_(mode))) return Qtrue;
    return Qfalse;
}

Возвращает true, если stat является каталогом, и false в противном случае.

File.stat("testfile").directory?   #=> false
File.stat(".").directory?          #=> true

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

static VALUE
rb_stat_x(VALUE obj)
{
    rb_io_stat_data *st = get_stat(obj);

#ifdef USE_GETEUID
    if (geteuid() == 0) {
        return RBOOL(st->ST_(mode) & S_IXUGO);
    }
#endif
#ifdef S_IXUSR
    if (rb_stat_owned(obj))
        return RBOOL(st->ST_(mode) & S_IXUSR);
#endif
#ifdef S_IXGRP
    if (rb_stat_grpowned(obj))
        return RBOOL(st->ST_(mode) & S_IXGRP);
#endif
#ifdef S_IXOTH
    if (!(st->ST_(mode) & S_IXOTH)) return Qfalse;
#endif
    return Qtrue;
}

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

File.stat("testfile").executable?   #=> false

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

static VALUE
rb_stat_X(VALUE obj)
{
    rb_io_stat_data *st = get_stat(obj);

#ifdef USE_GETEUID
    if (getuid() == 0) {
        return RBOOL(st->ST_(mode) & S_IXUGO);
    }
#endif
#ifdef S_IXUSR
    if (rb_stat_rowned(obj))
        return RBOOL(st->ST_(mode) & S_IXUSR);
#endif
#ifdef S_IXGRP
    if (rb_group_member(get_stat(obj)->ST_(gid)))
        return RBOOL(st->ST_(mode) & S_IXGRP);
#endif
#ifdef S_IXOTH
    if (!(st->ST_(mode) & S_IXOTH)) return Qfalse;
#endif
    return Qtrue;
}

То же, что и executable?, но проверка выполняется с использованием реального владельца процесса.

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

static VALUE
rb_stat_f(VALUE obj)
{
    if (S_ISREG(get_stat(obj)->ST_(mode))) return Qtrue;
    return Qfalse;
}

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

File.stat("testfile").file?   #=> true

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

static VALUE
rb_stat_ftype(VALUE obj)
{
    return rb_file_ftype(get_stat(obj)->ST_(mode));
}

Определяет тип stat. Возвращаемая строка — одна из следующих: «file», «directory», «characterSpecial», «blockSpecial», «fifo», «link», «socket» или «unknown».

File.stat("/dev/tty").ftype   #=> "characterSpecial"

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

static VALUE
rb_stat_gid(VALUE self)
{
    return GIDT2NUM(get_stat(self)->ST_(gid));
}

Возвращает числовой идентификатор группы владельца stat.

File.stat("testfile").gid   #=> 500

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

static VALUE
rb_stat_grpowned(VALUE obj)
{
#ifndef _WIN32
    if (rb_group_member(get_stat(obj)->ST_(gid))) return Qtrue;
#endif
    return Qfalse;
}

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

File.stat("testfile").grpowned?      #=> true
File.stat("/etc/passwd").grpowned?   #=> false

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

static VALUE
rb_stat_ino(VALUE self)
{
    rb_io_stat_data *ptr = get_stat(self);
#ifdef HAVE_STRUCT_STAT_ST_INOHIGH
    /* assume INTEGER_PACK_LSWORD_FIRST and st_inohigh is just next of st_ino */
    return rb_integer_unpack(&ptr->st_ino, 2,
            SIZEOF_STRUCT_STAT_ST_INO, 0,
            INTEGER_PACK_LSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER|
            INTEGER_PACK_2COMP);
#else
    return UIANY2NUM(ptr->ST_(ino));
#endif
}

Возвращает номер индексного дескриптора для stat.

File.stat("testfile").ino   #=> 1083669

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

static VALUE
rb_stat_inspect(VALUE self)
{
    VALUE str;
    size_t i;
    static const struct {
        const char *name;
        VALUE (*func)(VALUE);
    } member[] = {
        {"dev",     rb_stat_dev},
        {"ino",     rb_stat_ino},
        {"mode",    rb_stat_mode},
        {"nlink",   rb_stat_nlink},
        {"uid",     rb_stat_uid},
        {"gid",     rb_stat_gid},
        {"rdev",    rb_stat_rdev},
        {"size",    rb_stat_size},
        {"blksize", rb_stat_blksize},
        {"blocks",  rb_stat_blocks},
        {"atime",   rb_stat_atime},
        {"mtime",   rb_stat_mtime},
        {"ctime",   rb_stat_ctime},
#if defined(HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC)
        {"birthtime",   rb_stat_birthtime},
#endif
    };

    struct rb_stat* rb_st;
    TypedData_Get_Struct(self, struct rb_stat, &stat_data_type, rb_st);
    if (!rb_st->initialized) {
        return rb_sprintf("#<%s: uninitialized>", rb_obj_classname(self));
    }

    str = rb_str_buf_new2("#<");
    rb_str_buf_cat2(str, rb_obj_classname(self));
    rb_str_buf_cat2(str, " ");

    for (i = 0; i < sizeof(member)/sizeof(member[0]); i++) {
        VALUE v;

        if (i > 0) {
            rb_str_buf_cat2(str, ", ");
        }
        rb_str_buf_cat2(str, member[i].name);
        rb_str_buf_cat2(str, "=");
        v = (*member[i].func)(self);
        if (i == 2) {           /* mode */
            rb_str_catf(str, "0%lo", (unsigned long)NUM2ULONG(v));
        }
        else if (i == 0 || i == 6) { /* dev/rdev */
            rb_str_catf(str, "0x%"PRI_DEVT_PREFIX"x", NUM2DEVT(v));
        }
        else {
            rb_str_append(str, rb_inspect(v));
        }
    }
    rb_str_buf_cat2(str, ">");

    return str;
}

Создаёт хорошо отформатированное описание stat.

File.stat("/etc/passwd").inspect
   #=> "#<File::Stat dev=0xe000005, ino=1078078, mode=0100644,
   #    nlink=1, uid=0, gid=0, rdev=0x0, size=1374, blksize=4096,
   #    blocks=8, atime=Wed Dec 10 10:16:12 CST 2003,
   #    mtime=Fri Sep 12 15:41:41 CDT 2003,
   #    ctime=Mon Oct 27 11:20:27 CST 2003,
   #    birthtime=Mon Aug 04 08:13:49 CDT 2003>"

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

static VALUE
rb_stat_mode(VALUE self)
{
    return UINT2NUM(ST2UINT(get_stat(self)->ST_(mode)));
}

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

File.chmod(0644, "testfile")   #=> 1
s = File.stat("testfile")
sprintf("%o", s.mode)          #=> "100644"

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

static VALUE
rb_stat_mtime(VALUE self)
{
    return stat_time(statx_mtimespec(get_stat(self)));
}

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

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

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

static VALUE
rb_stat_nlink(VALUE self)
{
    /* struct stat::st_nlink is nlink_t in POSIX.  Not the case for Windows. */
    const rb_io_stat_data *ptr = get_stat(self);

    return UIANY2NUM(ptr->ST_(nlink));
}

Возвращает количество жёстких ссылок на stat.

File.stat("testfile").nlink             #=> 1
File.link("testfile", "testfile.bak")   #=> 0
File.stat("testfile").nlink             #=> 2

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

static VALUE
rb_stat_owned(VALUE obj)
{
    if (get_stat(obj)->ST_(uid) == geteuid()) return Qtrue;
    return Qfalse;
}

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

File.stat("testfile").owned?      #=> true
File.stat("/etc/passwd").owned?   #=> false

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

static VALUE
rb_stat_p(VALUE obj)
{
#ifdef S_IFIFO
    if (S_ISFIFO(get_stat(obj)->ST_(mode))) return Qtrue;

#endif
    return Qfalse;
}

Возвращает true, если операционная система поддерживает каналы и stat является каналом; в противном случае возвращает false.

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

static VALUE
rb_stat_rdev(VALUE self)
{
#if RUBY_USE_STATX
    unsigned int m = get_stat(self)->stx_rdev_major;
    unsigned int n = get_stat(self)->stx_rdev_minor;
    return ULL2NUM(makedev(m, n));
#elif !defined(HAVE_STRUCT_STAT_ST_RDEV)
    return Qnil;
#elif SIZEOF_STRUCT_STAT_ST_RDEV <= SIZEOF_DEV_T
    return DEVT2NUM(get_stat(self)->ST_(rdev));
#elif SIZEOF_STRUCT_STAT_ST_RDEV <= SIZEOF_LONG
    return ULONG2NUM(get_stat(self)->ST_(rdev));
#else
    return ULL2NUM(get_stat(self)->ST_(rdev));
#endif
}

Возвращает целое число, представляющее тип устройства, на котором находится stat. Возвращает nil, если операционная система не поддерживает эту возможность.

File.stat("/dev/fd1").rdev   #=> 513
File.stat("/dev/tty").rdev   #=> 1280

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

static VALUE
rb_stat_rdev_major(VALUE self)
{
#if RUBY_USE_STATX
    return UINT2NUM(get_stat(self)->stx_rdev_major);
#elif defined(HAVE_STRUCT_STAT_ST_RDEV) && defined(major)
    return UINT2NUM(major(get_stat(self)->ST_(rdev)));
#else
    return Qnil;
#endif
}

Возвращает старшую часть File_Stat#rdev или nil.

File.stat("/dev/fd1").rdev_major   #=> 2
File.stat("/dev/tty").rdev_major   #=> 5

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

static VALUE
rb_stat_rdev_minor(VALUE self)
{
#if RUBY_USE_STATX
    return UINT2NUM(get_stat(self)->stx_rdev_minor);
#elif defined(HAVE_STRUCT_STAT_ST_RDEV) && defined(minor)
    return UINT2NUM(minor(get_stat(self)->ST_(rdev)));
#else
    return Qnil;
#endif
}

Возвращает младшую часть File_Stat#rdev или nil.

File.stat("/dev/fd1").rdev_minor   #=> 1
File.stat("/dev/tty").rdev_minor   #=> 0

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

static VALUE
rb_stat_r(VALUE obj)
{
    rb_io_stat_data *st = get_stat(obj);

#ifdef USE_GETEUID
    if (geteuid() == 0) return Qtrue;
#endif
#ifdef S_IRUSR
    if (rb_stat_owned(obj))
        return RBOOL(st->ST_(mode) & S_IRUSR);
#endif
#ifdef S_IRGRP
    if (rb_stat_grpowned(obj))
        return RBOOL(st->ST_(mode) & S_IRGRP);
#endif
#ifdef S_IROTH
    if (!(st->ST_(mode) & S_IROTH)) return Qfalse;
#endif
    return Qtrue;
}

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

File.stat("testfile").readable?   #=> true

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

static VALUE
rb_stat_R(VALUE obj)
{
    rb_io_stat_data *st = get_stat(obj);

#ifdef USE_GETEUID
    if (getuid() == 0) return Qtrue;
#endif
#ifdef S_IRUSR
    if (rb_stat_rowned(obj))
        return RBOOL(st->ST_(mode) & S_IRUSR);
#endif
#ifdef S_IRGRP
    if (rb_group_member(get_stat(obj)->ST_(gid)))
        return RBOOL(st->ST_(mode) & S_IRGRP);
#endif
#ifdef S_IROTH
    if (!(st->ST_(mode) & S_IROTH)) return Qfalse;
#endif
    return Qtrue;
}

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

File.stat("testfile").readable_real?   #=> true

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

static VALUE
rb_stat_sgid(VALUE obj)
{
#ifdef S_ISGID
    if (get_stat(obj)->ST_(mode) & S_ISGID) return Qtrue;
#endif
    return Qfalse;
}

Возвращает true, если для stat установлен бит разрешения set-group-id, и false, если он не установлен или операционная система не поддерживает эту возможность.

File.stat("/usr/sbin/lpc").setgid?   #=> true

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

static VALUE
rb_stat_suid(VALUE obj)
{
#ifdef S_ISUID
    if (get_stat(obj)->ST_(mode) & S_ISUID) return Qtrue;
#endif
    return Qfalse;
}

Возвращает true, если для stat установлен бит разрешения set-user-id, и false, если он не установлен или операционная система не поддерживает эту возможность.

File.stat("/bin/su").setuid?   #=> true

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

static VALUE
rb_stat_size(VALUE self)
{
    return OFFT2NUM(get_stat(self)->ST_(size));
}

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

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

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

static VALUE
rb_stat_s(VALUE obj)
{
    rb_off_t size = get_stat(obj)->ST_(size);

    if (size == 0) return Qnil;
    return OFFT2NUM(size);
}

Возвращает nil, если stat — файл нулевой длины, и размер файла в противном случае.

File.stat("testfile").size?   #=> 66
File.stat(File::NULL).size?   #=> nil

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

static VALUE
rb_stat_S(VALUE obj)
{
#ifdef S_ISSOCK
    if (S_ISSOCK(get_stat(obj)->ST_(mode))) return Qtrue;

#endif
    return Qfalse;
}

Возвращает true, если stat является сокетом, и false, если это не так или операционная система не поддерживает эту возможность.

File.stat("testfile").socket?   #=> false

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

static VALUE
rb_stat_sticky(VALUE obj)
{
#ifdef S_ISVTX
    if (get_stat(obj)->ST_(mode) & S_ISVTX) return Qtrue;
#endif
    return Qfalse;
}

Возвращает true, если для stat установлен sticky-бит, и false, если он не установлен или операционная система не поддерживает эту возможность.

File.stat("testfile").sticky?   #=> false

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

static VALUE
rb_stat_l(VALUE obj)
{
#ifdef S_ISLNK
    if (S_ISLNK(get_stat(obj)->ST_(mode))) return Qtrue;
#endif
    return Qfalse;
}

Возвращает true, если stat является символической ссылкой, и false, если это не так или операционная система не поддерживает эту возможность. Поскольку File::stat автоматически следует по символическим ссылкам, symlink? всегда будет возвращать false для объекта, возвращённого методом File::stat.

File.symlink("testfile", "alink")   #=> 0
File.stat("alink").symlink?         #=> false
File.lstat("alink").symlink?        #=> true

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

static VALUE
rb_stat_uid(VALUE self)
{
    return UIDT2NUM(get_stat(self)->ST_(uid));
}

Возвращает числовой идентификатор пользователя — владельца stat.

File.stat("testfile").uid   #=> 501

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

static VALUE
rb_stat_wr(VALUE obj)
{
#ifdef S_IROTH
    rb_io_stat_data *st = get_stat(obj);
    if ((st->ST_(mode) & (S_IROTH)) == S_IROTH) {
        return UINT2NUM(st->ST_(mode) & (S_IRUGO|S_IWUGO|S_IXUGO));
    }
#endif
    return Qnil;
}

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

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

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

static VALUE
rb_stat_ww(VALUE obj)
{
#ifdef S_IWOTH
    rb_io_stat_data *st = get_stat(obj);
    if ((st->ST_(mode) & (S_IWOTH)) == S_IWOTH) {
        return UINT2NUM(st->ST_(mode) & (S_IRUGO|S_IWUGO|S_IXUGO));
    }
#endif
    return Qnil;
}

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

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

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

static VALUE
rb_stat_w(VALUE obj)
{
    rb_io_stat_data *st = get_stat(obj);

#ifdef USE_GETEUID
    if (geteuid() == 0) return Qtrue;
#endif
#ifdef S_IWUSR
    if (rb_stat_owned(obj))
        return RBOOL(st->ST_(mode) & S_IWUSR);
#endif
#ifdef S_IWGRP
    if (rb_stat_grpowned(obj))
        return RBOOL(st->ST_(mode) & S_IWGRP);
#endif
#ifdef S_IWOTH
    if (!(st->ST_(mode) & S_IWOTH)) return Qfalse;
#endif
    return Qtrue;
}

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

File.stat("testfile").writable?   #=> true

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

static VALUE
rb_stat_W(VALUE obj)
{
    rb_io_stat_data *st = get_stat(obj);

#ifdef USE_GETEUID
    if (getuid() == 0) return Qtrue;
#endif
#ifdef S_IWUSR
    if (rb_stat_rowned(obj))
        return RBOOL(st->ST_(mode) & S_IWUSR);
#endif
#ifdef S_IWGRP
    if (rb_group_member(get_stat(obj)->ST_(gid)))
        return RBOOL(st->ST_(mode) & S_IWGRP);
#endif
#ifdef S_IWOTH
    if (!(st->ST_(mode) & S_IWOTH)) return Qfalse;
#endif
    return Qtrue;
}

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

File.stat("testfile").writable_real?   #=> true

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

static VALUE
rb_stat_z(VALUE obj)
{
    if (get_stat(obj)->ST_(size) == 0) return Qtrue;
    return Qfalse;
}

Возвращает true, если stat — файл нулевой длины; в противном случае возвращает false.

File.stat("testfile").zero?   #=> false

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