模块 FileTest

FileTest 实现类似于 File::Stat 中使用的文件测试操作。它作为一个独立的模块存在，其方法也被暗示到 File 类中。（注意，这不是通过包含完成的：解释器作弊）。

公共实例方法

blockdev?(filepath) → true 或 false 点击切换源代码

如果 filepath 指向块设备，则返回 true，否则返回 false

File.blockdev?('/dev/sda1')       # => true
File.blockdev?(File.new('t.tmp')) # => 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;
}
chardev?(filepath) → true 或 false 点击切换源代码

如果 filepath 指向字符设备，则返回 true，否则返回 false。

File.chardev?($stdin)     # => true
File.chardev?('t.txt')     # => 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;
}
directory?(path) → true 或 false 点击切换源代码

给定字符串 object，如果 path 是指向目录的字符串路径，或指向目录的符号链接，则返回 true；否则返回 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 对象。

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;
}
empty?(p1)

如果命名文件存在且大小为零，则返回 true。

file_name 可以是 IO 对象。

别名：zero?
executable?(file_name) → true 或 false 点击切换源代码

如果命名文件可被此进程的有效用户和组 ID 执行，则返回 true。参见 eaccess(3)。

Windows 不单独支持执行权限，而是与读取权限捆绑在一起。在 Windows 上，只有以 .bat、.cmd、.com 或 .exe 结尾的文件才被视为可执行文件。

请注意，某些操作系统级别的安全功能可能会导致即使文件不可由有效用户/组执行，此方法也返回 true。

static VALUE
rb_file_executable_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_eaccess(fname, X_OK) >= 0);
}
executable_real?(file_name) → true 或 false 点击切换源代码

如果指定的文件可由此进程的真实用户和组 ID 执行，则返回 true。请参阅 access(3)。

Windows 不单独支持执行权限，而是与读取权限捆绑在一起。在 Windows 上，只有以 .bat、.cmd、.com 或 .exe 结尾的文件才被视为可执行文件。

请注意，某些操作系统级别的安全功能可能会导致即使文件不可由真实用户/组执行，此方法也返回 true。

static VALUE
rb_file_executable_real_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_access(fname, X_OK) >= 0);
}
exist?(file_name) → true 或 false 点击切换源代码

如果指定的文件存在，则返回 true。

file_name 可以是 IO 对象。

“文件存在”意味着 stat() 或 fstat() 系统调用成功。

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

    if (rb_stat(fname, &st) < 0) return Qfalse;
    return Qtrue;
}
file?(file) → true 或 false 点击切换源代码

如果指定的文件存在且为普通文件，则返回 true。

file 可以是 IO 对象。

如果 file 参数是符号链接，它将解析符号链接并使用链接引用的文件。

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));
}
grpowned?(file_name) → true 或 false 点击切换源代码

如果指定的文件存在且调用进程的有效组 ID 是该文件的拥有者，则返回 true。在 Windows 上返回 false。

file_name 可以是 IO 对象。

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;
}
identical?(file_1, file_2) → true 或 false 点击切换源代码

如果指定的文件相同，则返回 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

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
}
owned?(file_name) → true 或 false 点击切换源代码

如果指定的文件存在且调用进程的有效用户 ID 是该文件的拥有者，则返回 true。

file_name 可以是 IO 对象。

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());
}
pipe?(filepath) → true 或 false 点击切换源代码

如果 filepath 指向管道，则返回 true，否则返回 false

File.mkfifo('tmp/fifo')
File.pipe?('tmp/fifo') # => true
File.pipe?('t.txt')    # => 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;
}
readable?(file_name) → true 或 false 点击切换源代码

如果指定的文件名可被当前进程的有效用户和组 ID 读取，则返回 true。参见 eaccess(3)。

注意，某些操作系统级别的安全功能可能会导致此方法返回 true，即使文件实际上不可被有效用户/组读取。

static VALUE
rb_file_readable_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_eaccess(fname, R_OK) >= 0);
}
readable_real?(file_name) → true 或 false 点击切换源代码

如果指定的文件名可被当前进程的真实用户和组 ID 读取，则返回 true。参见 access(3)。

注意，某些操作系统级别的安全功能可能会导致此方法返回 true，即使文件实际上不可被真实用户/组读取。

static VALUE
rb_file_readable_real_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_access(fname, R_OK) >= 0);
}
setgid?(file_name) → true 或 false 点击切换源代码

如果指定的文件名设置了 setgid 位，则返回 true。

file_name 可以是 IO 对象。

static VALUE
rb_file_sgid_p(VALUE obj, VALUE fname)
{
#ifdef S_ISGID
    return check3rdbyte(fname, S_ISGID);
#else
    return Qfalse;
#endif
}
setuid?(file_name) → true 或 false 点击切换源代码

如果指定的文件名设置了 setuid 位，则返回 true。

file_name 可以是 IO 对象。

static VALUE
rb_file_suid_p(VALUE obj, VALUE fname)
{
#ifdef S_ISUID
    return check3rdbyte(fname, S_ISUID);
#else
    return Qfalse;
#endif
}
size(file_name) → 整数 点击切换源代码

返回 file_name 的大小。

file_name 可以是 IO 对象。

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);
}
size?(file_name) → 整数 或 nil 点击切换源代码

如果 file_name 不存在或大小为零，则返回 nil，否则返回文件的大小。

file_name 可以是 IO 对象。

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);
}
socket?(filepath) → true 或 false 点击切换源代码

如果 filepath 指向一个套接字，则返回 true，否则返回 false。

require 'socket'
File.socket?(Socket.new(:INET, :STREAM)) # => true
File.socket?(File.new('t.txt'))          # => 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;
}
sticky?(file_name) → true 或 false 点击切换源代码

如果指定的文件名设置了 sticky 位，则返回 true。

file_name 可以是 IO 对象。

static VALUE
rb_file_sticky_p(VALUE obj, VALUE fname)
{
#ifdef S_ISVTX
    return check3rdbyte(fname, S_ISVTX);
#else
    return Qfalse;
#endif
}
symlink?(filepath) → true 或 false 点击切换源代码

如果 filepath 指向一个符号链接，则返回 true，否则返回 false。

symlink = File.symlink('t.txt', 'symlink')
File.symlink?('symlink') # => true
File.symlink?('t.txt')   # => false
world_readable?(file_name) → 整数 或 nil 点击切换源代码

如果 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"

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;
}
world_writable?(file_name) → 整数 或 nil 点击切换源代码

如果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"

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;
}
writable?(file_name) → true 或 false 点击切换源代码

如果命名文件对该进程的有效用户和组 ID 可写，则返回true。请参见 eaccess(3)。

请注意，某些操作系统级安全功能可能会导致此方法返回 true，即使文件对有效用户/组不可写。

static VALUE
rb_file_writable_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_eaccess(fname, W_OK) >= 0);
}
writable_real?(file_name) → true 或 false 点击切换源代码

如果命名文件对该进程的真实用户和组 ID 可写，则返回true。请参见 access(3)。

请注意，某些操作系统级安全功能可能会导致此方法返回 true，即使文件对真实用户/组不可写。

static VALUE
rb_file_writable_real_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_access(fname, W_OK) >= 0);
}
zero?(file_name) → true 或 false 点击切换源代码

如果命名文件存在且大小为零，则返回 true。

file_name 可以是 IO 对象。

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);
}
也称为：empty?