Pathname 類別

Pathname 代表檔案系統上檔案或目錄的名稱,但不是檔案本身。

路徑名稱取決於作業系統:Unix、Windows 等。此程式庫會使用本機作業系統的路徑名稱,但實驗性地支援非 Unix 路徑名稱。

Pathname 可以是相對或絕對路徑。只有當您嘗試參照檔案時,檔案是否存在才重要。

Pathname 是不可變的。它沒有用於破壞性更新的方法。

此類別的目標是比標準 Ruby 提供的方式更簡潔地處理檔案路徑資訊。以下範例說明了差異。

所有來自 FileFileTest 的功能,以及來自 DirFileUtils 的部分功能,都包含在其中,一點也不令人意外。它基本上是所有這些功能的門面,而且還有更多功能。

範例

範例 1:使用 Pathname

require 'pathname'
pn = Pathname.new("/usr/bin/ruby")
size = pn.size              # 27662
isdir = pn.directory?       # false
dir  = pn.dirname           # Pathname:/usr/bin
base = pn.basename          # Pathname:ruby
dir, base = pn.split        # [Pathname:/usr/bin, Pathname:ruby]
data = pn.read
pn.open { |f| _ }
pn.each_line { |line| _ }

範例 2:使用標準 Ruby

pn = "/usr/bin/ruby"
size = File.size(pn)        # 27662
isdir = File.directory?(pn) # false
dir  = File.dirname(pn)     # "/usr/bin"
base = File.basename(pn)    # "ruby"
dir, base = File.split(pn)  # ["/usr/bin", "ruby"]
data = File.read(pn)
File.open(pn) { |f| _ }
File.foreach(pn) { |line| _ }

範例 3:特殊功能

p1 = Pathname.new("/usr/lib")   # Pathname:/usr/lib
p2 = p1 + "ruby/1.8"            # Pathname:/usr/lib/ruby/1.8
p3 = p1.parent                  # Pathname:/usr
p4 = p2.relative_path_from(p3)  # Pathname:lib/ruby/1.8
pwd = Pathname.pwd              # Pathname:/home/gavin
pwd.absolute?                   # true
p5 = Pathname.new "."           # Pathname:.
p5 = p5 + "music/../articles"   # Pathname:music/../articles
p5.cleanpath                    # Pathname:articles
p5.realpath                     # Pathname:/home/gavin/articles
p5.children                     # [Pathname:/home/gavin/articles/linux, ...]

功能細目

核心方法

這些方法有效地處理 String,因為路徑就是字串。除了 mountpoint?childreneach_childrealdirpathrealpath 之外,這些方法都不會存取檔案系統。

File 狀態謂詞方法

這些方法是 FileTest 的門面

File 屬性和處理方法

這些方法是 File 的門面

目錄方法

這些方法是 Dir 的門面

IO

這些方法是 IO 的門面

工具

這些方法是 FindFileUtils 和其他方法的混合

Method 文件

如上節所示,Pathname 中的大多數方法都是門面。這些方法的文件通常只會說,例如「請參閱 FileTest.writable?」,因為您無論如何都應該熟悉原始方法,而其文件(例如透過 ri)將包含更多資訊。在某些情況下,將會隨附簡短說明。

常數

VERSION

公開類別方法

getwd() 按一下以切換來源

傳回目前工作目錄為 Pathname

Pathname.getwd
    #=> #<Pathname:/home/zzak/projects/ruby>

請參閱 Dir.getwd

static VALUE
path_s_getwd(VALUE klass)
{
    VALUE str;
    str = rb_funcall(rb_cDir, id_getwd, 0);
    return rb_class_new_instance(1, &str, klass);
}
glob(p1, p2 = v2, p3 = v3) 按一下以切換來源

傳回或產生 Pathname 物件。

Pathname.glob("lib/i*.rb")
    #=> [#<Pathname:lib/ipaddr.rb>, #<Pathname:lib/irb.rb>]

請參閱 Dir.glob

static VALUE
path_s_glob(int argc, VALUE *argv, VALUE klass)
{
    VALUE args[3];
    int n;

    n = rb_scan_args(argc, argv, "12", &args[0], &args[1], &args[2]);
    if (rb_block_given_p()) {
        return rb_block_call_kw(rb_cDir, id_glob, n, args, s_glob_i, klass, RB_PASS_CALLED_KEYWORDS);
    }
    else {
        VALUE ary;
        long i;
        ary = rb_funcallv_kw(rb_cDir, id_glob, n, args, RB_PASS_CALLED_KEYWORDS);
        ary = rb_convert_type(ary, T_ARRAY, "Array", "to_ary");
        for (i = 0; i < RARRAY_LEN(ary); i++) {
            VALUE elt = RARRAY_AREF(ary, i);
            elt = rb_class_new_instance(1, &elt, klass);
            rb_ary_store(ary, i, elt);
        }
        return ary;
    }
}
new(p1) 按一下以切換來源

從指定的 String (或類字串物件) 建立 Pathname 物件。如果 path 包含 NULL 字元 (\0),則會引發 ArgumentError

static VALUE
path_initialize(VALUE self, VALUE arg)
{
    VALUE str;
    if (RB_TYPE_P(arg, T_STRING)) {
        str = arg;
    }
    else {
        str = rb_check_funcall(arg, id_to_path, 0, NULL);
        if (str == Qundef)
            str = arg;
        StringValue(str);
    }
    if (memchr(RSTRING_PTR(str), '\0', RSTRING_LEN(str)))
        rb_raise(rb_eArgError, "pathname contains null byte");
    str = rb_obj_dup(str);

    set_strpath(self, str);
    return self;
}
pwd() 按一下以切換來源

傳回目前工作目錄為 Pathname

Pathname.getwd
    #=> #<Pathname:/home/zzak/projects/ruby>

請參閱 Dir.getwd

static VALUE
path_s_getwd(VALUE klass)
{
    VALUE str;
    str = rb_funcall(rb_cDir, id_getwd, 0);
    return rb_class_new_instance(1, &str, klass);
}

公開實例方法

+(other) 按一下以切換來源

將路徑片段附加至 self 以產生新的 Pathname 物件。由於 other 被視為相對於 self 的路徑,因此如果 other 是絕對路徑,則新的 Pathname 物件將僅從 other 建立。

p1 = Pathname.new("/usr")      # Pathname:/usr
p2 = p1 + "bin/ruby"           # Pathname:/usr/bin/ruby
p3 = p1 + "/etc/passwd"        # Pathname:/etc/passwd

# / is aliased to +.
p4 = p1 / "bin/ruby"           # Pathname:/usr/bin/ruby
p5 = p1 / "/etc/passwd"        # Pathname:/etc/passwd

此方法不會存取檔案系統;它是純粹的字串處理。

# File ext/pathname/lib/pathname.rb, line 356
def +(other)
  other = Pathname.new(other) unless Pathname === other
  Pathname.new(plus(@path, other.to_s))
end
別名:/
/(other)
別名:+
<=>(p1) 按一下以切換來源

提供路徑名稱大小寫敏感的比較運算子。

Pathname.new('/usr') <=> Pathname.new('/usr/bin')
    #=> -1
Pathname.new('/usr/bin') <=> Pathname.new('/usr/bin')
    #=> 0
Pathname.new('/usr/bin') <=> Pathname.new('/USR/BIN')
    #=> 1

它會傳回 -101,依據左邊引數相對於右邊引數的值而定。或者,如果引數無法比較,它會傳回 nil

static VALUE
path_cmp(VALUE self, VALUE other)
{
    VALUE s1, s2;
    char *p1, *p2;
    char *e1, *e2;
    if (!rb_obj_is_kind_of(other, rb_cPathname))
        return Qnil;
    s1 = get_strpath(self);
    s2 = get_strpath(other);
    p1 = RSTRING_PTR(s1);
    p2 = RSTRING_PTR(s2);
    e1 = p1 + RSTRING_LEN(s1);
    e2 = p2 + RSTRING_LEN(s2);
    while (p1 < e1 && p2 < e2) {
        int c1, c2;
        c1 = (unsigned char)*p1++;
        c2 = (unsigned char)*p2++;
        if (c1 == '/') c1 = '\0';
        if (c2 == '/') c2 = '\0';
        if (c1 != c2) {
            if (c1 < c2)
                return INT2FIX(-1);
            else
                return INT2FIX(1);
        }
    }
    if (p1 < e1)
        return INT2FIX(1);
    if (p2 < e2)
        return INT2FIX(-1);
    return INT2FIX(0);
}
==(p1) 按一下以切換來源

將此路徑名稱與 other 進行比較。比較是基於字串。請注意,兩個不同的路徑 (foo.txt./foo.txt) 可以指同一個檔案。

static VALUE
path_eq(VALUE self, VALUE other)
{
    if (!rb_obj_is_kind_of(other, rb_cPathname))
        return Qfalse;
    return rb_str_equal(get_strpath(self), get_strpath(other));
}
別名:===eql?
===(p1)

將此路徑名稱與 other 進行比較。比較是基於字串。請注意,兩個不同的路徑 (foo.txt./foo.txt) 可以指同一個檔案。

別名:==
absolute?() 按一下以切換來源

用於測試路徑是否為絕對路徑的謂詞方法。

如果路徑名稱以斜線開頭,則傳回 true

p = Pathname.new('/im/sure')
p.absolute?
    #=> true

p = Pathname.new('not/so/sure')
p.absolute?
    #=> false
# File ext/pathname/lib/pathname.rb, line 233
def absolute?
  ABSOLUTE_PATH.match? @path
end
ascend() { |self| ... } 按一下以切換來源

針對指定路徑中的每個元素,以遞增順序進行反覆運算,並產生新的 Pathname 物件。

Pathname.new('/path/to/some/file.rb').ascend {|v| p v}
   #<Pathname:/path/to/some/file.rb>
   #<Pathname:/path/to/some>
   #<Pathname:/path/to>
   #<Pathname:/path>
   #<Pathname:/>

Pathname.new('path/to/some/file.rb').ascend {|v| p v}
   #<Pathname:path/to/some/file.rb>
   #<Pathname:path/to/some>
   #<Pathname:path/to>
   #<Pathname:path>

如果未提供區塊,則傳回 Enumerator

enum = Pathname.new("/usr/bin/ruby").ascend
  # ... do stuff ...
enum.each { |e| ... }
  # yields Pathnames /usr/bin/ruby, /usr/bin, /usr, and /.

它不會存取檔案系統。

# File ext/pathname/lib/pathname.rb, line 330
def ascend
  return to_enum(__method__) unless block_given?
  path = @path
  yield self
  while r = chop_basename(path)
    path, = r
    break if path.empty?
    yield self.class.new(del_trailing_separator(path))
  end
end
atime → time 按一下以切換來源

傳回檔案的最後存取時間。

請參閱 File.atime

static VALUE
path_atime(VALUE self)
{
    return rb_funcall(rb_cFile, id_atime, 1, get_strpath(self));
}
basename(p1 = v1) 按一下以切換來源

傳回路徑的最後一個組成部分。

請參閱 File.basename

static VALUE
path_basename(int argc, VALUE *argv, VALUE self)
{
    VALUE str = get_strpath(self);
    VALUE fext;
    if (rb_scan_args(argc, argv, "01", &fext) == 0)
        str = rb_funcall(rb_cFile, id_basename, 1, str);
    else
        str = rb_funcall(rb_cFile, id_basename, 2, str, fext);
    return rb_class_new_instance(1, &str, rb_obj_class(self));
}
binread([length [, offset]]) → string 按一下以切換來源

傳回檔案中的所有位元組,或如果已指定,則傳回前 N 個位元組。

請參閱 File.binread

static VALUE
path_binread(int argc, VALUE *argv, VALUE self)
{
    VALUE args[3];
    int n;

    args[0] = get_strpath(self);
    n = rb_scan_args(argc, argv, "02", &args[1], &args[2]);
    return rb_funcallv(rb_cFile, id_binread, 1+n, args);
}
binwrite(string, [offset] ) → fixnum 按一下以切換來源
binwrite(string, [offset], open_args ) → fixnum

contents 寫入檔案,並以二進位模式開啟檔案。

請參閱 File.binwrite

static VALUE
path_binwrite(int argc, VALUE *argv, VALUE self)
{
    VALUE args[4];
    int n;

    args[0] = get_strpath(self);
    n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
    return rb_funcallv_kw(rb_cFile, id_binwrite, 1+n, args, RB_PASS_CALLED_KEYWORDS);
}
birthtime → time 按一下以切換來源

傳回檔案的建立時間。如果平台沒有建立時間,則引發 NotImplementedError

請參閱 File.birthtime

static VALUE
path_birthtime(VALUE self)
{
    return rb_funcall(rb_cFile, id_birthtime, 1, get_strpath(self));
}
blockdev?() 按一下以切換來源

請參閱 FileTest.blockdev?

static VALUE
path_blockdev_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_blockdev_p, 1, get_strpath(self));
}
chardev?() 按一下以切換來源

請參閱 FileTest.chardev?

static VALUE
path_chardev_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_chardev_p, 1, get_strpath(self));
}
children(with_directory=true) 按一下以切換來源

傳回目錄的子目錄(檔案和子目錄,非遞迴)作為 Pathname 物件陣列。

預設情況下,傳回的路徑名稱將有足夠的資訊來存取檔案。如果您將 with_directory 設定為 false,則傳回的路徑名稱將只包含檔名。

例如

pn = Pathname("/usr/lib/ruby/1.8")
pn.children
    # -> [ Pathname:/usr/lib/ruby/1.8/English.rb,
           Pathname:/usr/lib/ruby/1.8/Env.rb,
           Pathname:/usr/lib/ruby/1.8/abbrev.rb, ... ]
pn.children(false)
    # -> [ Pathname:English.rb, Pathname:Env.rb, Pathname:abbrev.rb, ... ]

請注意,結果永遠不會包含目錄中的 ... 項目,因為它們不是子目錄。

# File ext/pathname/lib/pathname.rb, line 449
def children(with_directory=true)
  with_directory = false if @path == '.'
  result = []
  Dir.foreach(@path) {|e|
    next if e == '.' || e == '..'
    if with_directory
      result << self.class.new(File.join(@path, e))
    else
      result << self.class.new(e)
    end
  }
  result
end
chmod(mode_int) → integer 按一下以切換來源

變更檔案權限。

請參閱 File.chmod

static VALUE
path_chmod(VALUE self, VALUE mode)
{
    return rb_funcall(rb_cFile, id_chmod, 2, mode, get_strpath(self));
}
chown(owner_int, group_int) → integer 按一下以切換來源

變更檔案的所有者和群組。

請參閱 File.chown

static VALUE
path_chown(VALUE self, VALUE owner, VALUE group)
{
    return rb_funcall(rb_cFile, id_chown, 3, owner, group, get_strpath(self));
}
cleanpath(consider_symlink=false) 按一下以切換來源

傳回 self 的乾淨路徑名稱,並移除連續斜線和無用的點。不會存取檔案系統。

如果 consider_symlinktrue,則會使用較保守的演算法來避免中斷符號連結。這可能會保留比絕對必要更多的 .. 項目,但如果不存取檔案系統,就無法避免這種情況。

請參閱 Pathname#realpath

# File ext/pathname/lib/pathname.rb, line 94
def cleanpath(consider_symlink=false)
  if consider_symlink
    cleanpath_conservative
  else
    cleanpath_aggressive
  end
end
ctime → time 按一下以切換來源

傳回最後變更時間,使用目錄資訊,而不是檔案本身。

請參閱 File.ctime

static VALUE
path_ctime(VALUE self)
{
    return rb_funcall(rb_cFile, id_ctime, 1, get_strpath(self));
}
delete()

移除檔案或目錄,如果 self 是檔案,則使用 File.unlink,或視需要使用 Dir.unlink

別名:unlink
descend() { |v| ... } 按一下以切換來源

反覆運算並針對給定路徑中的每個元素產生新的 Pathname 物件,順序為遞減。

Pathname.new('/path/to/some/file.rb').descend {|v| p v}
   #<Pathname:/>
   #<Pathname:/path>
   #<Pathname:/path/to>
   #<Pathname:/path/to/some>
   #<Pathname:/path/to/some/file.rb>

Pathname.new('path/to/some/file.rb').descend {|v| p v}
   #<Pathname:path>
   #<Pathname:path/to>
   #<Pathname:path/to/some>
   #<Pathname:path/to/some/file.rb>

如果未提供區塊,則傳回 Enumerator

enum = Pathname.new("/usr/bin/ruby").descend
  # ... do stuff ...
enum.each { |e| ... }
  # yields Pathnames /, /usr, /usr/bin, and /usr/bin/ruby.

它不會存取檔案系統。

# File ext/pathname/lib/pathname.rb, line 297
def descend
  return to_enum(__method__) unless block_given?
  vs = []
  ascend {|v| vs << v }
  vs.reverse_each {|v| yield v }
  nil
end
directory?() 按一下以切換來源

請參閱 FileTest.directory?

static VALUE
path_directory_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_directory_p, 1, get_strpath(self));
}
dirname() 按一下以切換來源

傳回路徑的所有部分,但最後一個部分除外。

請參閱 File.dirname

static VALUE
path_dirname(VALUE self)
{
    VALUE str = get_strpath(self);
    str = rb_funcall(rb_cFile, id_dirname, 1, str);
    return rb_class_new_instance(1, &str, rb_obj_class(self));
}
each_child(with_directory=true, &b) 按一下以切換來源

反覆運算目錄的子目錄(檔案和子目錄,非遞迴)。

它會為每個子目錄產生 Pathname 物件。

預設情況下,產生的路徑名稱將有足夠的資訊來存取檔案。

如果您將 with_directory 設為 false,則傳回的路徑名稱將只包含檔名。

Pathname("/usr/local").each_child {|f| p f }
#=> #<Pathname:/usr/local/share>
#   #<Pathname:/usr/local/bin>
#   #<Pathname:/usr/local/games>
#   #<Pathname:/usr/local/lib>
#   #<Pathname:/usr/local/include>
#   #<Pathname:/usr/local/sbin>
#   #<Pathname:/usr/local/src>
#   #<Pathname:/usr/local/man>

Pathname("/usr/local").each_child(false) {|f| p f }
#=> #<Pathname:share>
#   #<Pathname:bin>
#   #<Pathname:games>
#   #<Pathname:lib>
#   #<Pathname:include>
#   #<Pathname:sbin>
#   #<Pathname:src>
#   #<Pathname:man>

請注意,結果永遠不會包含目錄中的 ... 項目,因為它們不是子目錄。

請參閱 Pathname#children

# File ext/pathname/lib/pathname.rb, line 499
def each_child(with_directory=true, &b)
  children(with_directory).each(&b)
end
each_entry() 按一下以切換來源

重複目錄中的項目(檔案和子目錄),為每個項目產生一個 Pathname 物件。

static VALUE
path_each_entry(VALUE self)
{
    VALUE args[1];
    RETURN_ENUMERATOR(self, 0, 0);

    args[0] = get_strpath(self);
    return rb_block_call(rb_cDir, id_foreach, 1, args, each_entry_i, rb_obj_class(self));
}
each_filename() { |filename| ... } 按一下以切換來源

重複路徑的每個組成部分。

Pathname.new("/usr/bin/ruby").each_filename {|filename| ... }
  # yields "usr", "bin", and "ruby".

如果未提供區塊,則傳回 Enumerator

enum = Pathname.new("/usr/bin/ruby").each_filename
  # ... do stuff ...
enum.each { |e| ... }
  # yields "usr", "bin", and "ruby".
# File ext/pathname/lib/pathname.rb, line 265
def each_filename # :yield: filename
  return to_enum(__method__) unless block_given?
  _, names = split_names(@path)
  names.each {|filename| yield filename }
  nil
end
each_line {|line| ... } 按一下以切換來源
each_line(sep=$/ [, open_args]) {|line| block } → nil
each_line(limit [, open_args]) {|line| block } → nil
each_line(sep, limit [, open_args]) {|line| block } → nil
each_line(...) → an_enumerator

重複檔案中的每一行,並為每一行產生一個 String 物件。

static VALUE
path_each_line(int argc, VALUE *argv, VALUE self)
{
    VALUE args[4];
    int n;

    args[0] = get_strpath(self);
    n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
    if (rb_block_given_p()) {
        return rb_block_call_kw(rb_cFile, id_foreach, 1+n, args, 0, 0, RB_PASS_CALLED_KEYWORDS);
    }
    else {
        return rb_funcallv_kw(rb_cFile, id_foreach, 1+n, args, RB_PASS_CALLED_KEYWORDS);
    }
}
empty?() 按一下以切換來源

測試檔案是否為空。

請參閱 Dir#empty? 和 FileTest.empty?

static VALUE
path_empty_p(VALUE self)
{

    VALUE path = get_strpath(self);
    if (RTEST(rb_funcall(rb_mFileTest, id_directory_p, 1, path)))
        return rb_funcall(rb_cDir, id_empty_p, 1, path);
    else
        return rb_funcall(rb_mFileTest, id_empty_p, 1, path);
}
entries() 按一下以切換來源

傳回目錄中的項目(檔案和子目錄),每個項目都是一個 Pathname 物件。

結果只包含目錄中的名稱,沒有任何尾隨斜線或遞迴查詢。

pp Pathname.new('/usr/local').entries
#=> [#<Pathname:share>,
#    #<Pathname:lib>,
#    #<Pathname:..>,
#    #<Pathname:include>,
#    #<Pathname:etc>,
#    #<Pathname:bin>,
#    #<Pathname:man>,
#    #<Pathname:games>,
#    #<Pathname:.>,
#    #<Pathname:sbin>,
#    #<Pathname:src>]

結果可能包含目前目錄 #<Pathname:.> 和父目錄 #<Pathname:..>

如果您不想要 ...,而且想要目錄,請考慮 Pathname#children

static VALUE
path_entries(VALUE self)
{
    VALUE klass, str, ary;
    long i;
    klass = rb_obj_class(self);
    str = get_strpath(self);
    ary = rb_funcall(rb_cDir, id_entries, 1, str);
    ary = rb_convert_type(ary, T_ARRAY, "Array", "to_ary");
    for (i = 0; i < RARRAY_LEN(ary); i++) {
        VALUE elt = RARRAY_AREF(ary, i);
        elt = rb_class_new_instance(1, &elt, klass);
        rb_ary_store(ary, i, elt);
    }
    return ary;
}
eql?(p1)

將此路徑名稱與 other 進行比較。比較是基於字串。請注意,兩個不同的路徑 (foo.txt./foo.txt) 可以指同一個檔案。

別名:==
executable?() 按一下以切換來源

請參閱 FileTest.executable?

static VALUE
path_executable_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_executable_p, 1, get_strpath(self));
}
executable_real?() 按一下以切換來源

請參閱 FileTest.executable_real?

static VALUE
path_executable_real_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_executable_real_p, 1, get_strpath(self));
}
exist?() 按一下以切換來源

請參閱 FileTest.exist?

static VALUE
path_exist_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_exist_p, 1, get_strpath(self));
}
expand_path(p1 = v1) 按一下以切換來源

傳回檔案的絕對路徑。

請參閱 File.expand_path

static VALUE
path_expand_path(int argc, VALUE *argv, VALUE self)
{
    VALUE str = get_strpath(self);
    VALUE dname;
    if (rb_scan_args(argc, argv, "01", &dname) == 0)
        str = rb_funcall(rb_cFile, id_expand_path, 1, str);
    else
        str = rb_funcall(rb_cFile, id_expand_path, 2, str, dname);
    return rb_class_new_instance(1, &str, rb_obj_class(self));
}
extname() 按一下以切換來源

傳回檔案的副檔名。

請參閱 File.extname

static VALUE
path_extname(VALUE self)
{
    VALUE str = get_strpath(self);
    return rb_funcall(rb_cFile, id_extname, 1, str);
}
file?() 按一下以切換來源

請參閱 FileTest.file?

static VALUE
path_file_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_file_p, 1, get_strpath(self));
}
find(ignore_error: true) { |pathname| ... } 按一下以切換來源

以深度優先的方式遍歷目錄樹,為「此」目錄下的每個檔案產生一個 Pathname

如果未提供區塊,則傳回一個 Enumerator

由於此方法是由標準函式庫模組 Find 實作,因此可以使用 Find.prune 來控制遍歷。

如果 self.,則產生的路徑名稱會以目前目錄中的檔案名稱開頭,而不是 ./

請參閱 Find.find

# File ext/pathname/lib/pathname.rb, line 571
def find(ignore_error: true) # :yield: pathname
  return to_enum(__method__, ignore_error: ignore_error) unless block_given?
  require 'find'
  if @path == '.'
    Find.find(@path, ignore_error: ignore_error) {|f| yield self.class.new(f.sub(%r{\A\./}, '')) }
  else
    Find.find(@path, ignore_error: ignore_error) {|f| yield self.class.new(f) }
  end
end
fnmatch(pattern, [flags]) → true 或 false 按一下以切換來源

如果接收者符合指定的模式,則傳回 true

請參閱 File.fnmatch

static VALUE
path_fnmatch(int argc, VALUE *argv, VALUE self)
{
    VALUE str = get_strpath(self);
    VALUE pattern, flags;
    if (rb_scan_args(argc, argv, "11", &pattern, &flags) == 1)
        return rb_funcall(rb_cFile, id_fnmatch, 2, pattern, str);
    else
        return rb_funcall(rb_cFile, id_fnmatch, 3, pattern, str, flags);
}
別名為:fnmatch?
fnmatch?(pattern, [flags]) → true 或 false

如果接收者符合指定的模式,則傳回 true

請參閱 File.fnmatch

別名為:fnmatch
freeze → obj 按一下以切換來源

凍結此 Pathname

請參閱 Object.freeze

static VALUE
path_freeze(VALUE self)
{
    rb_call_super(0, 0);
    rb_str_freeze(get_strpath(self));
    return self;
}
ftype → 字串 按一下以切換來源

傳回檔案的「類型」(「檔案」、「目錄」等)。

請參閱 File.ftype

static VALUE
path_ftype(VALUE self)
{
    return rb_funcall(rb_cFile, id_ftype, 1, get_strpath(self));
}
glob(p1, p2 = v2) 按一下以切換來源

傳回或產生 Pathname 物件。

Pathname("ruby-2.4.2").glob("R*.md")
#=> [#<Pathname:ruby-2.4.2/README.md>, #<Pathname:ruby-2.4.2/README.ja.md>]

請參閱 Dir.glob。此方法使用 Dir.globbase 關鍵字引數。

static VALUE
path_glob(int argc, VALUE *argv, VALUE self)
{
    VALUE args[3];
    int n;

    n = rb_scan_args(argc, argv, "11", &args[0], &args[1]);
    if (n == 1)
      args[1] = INT2FIX(0);

    args[2] = rb_hash_new();
    rb_hash_aset(args[2], ID2SYM(id_base), get_strpath(self));

    n = 3;

    if (rb_block_given_p()) {
        return rb_block_call_kw(rb_cDir, id_glob, n, args, glob_i, self, RB_PASS_KEYWORDS);
    }
    else {
        VALUE ary;
        long i;
        ary = rb_funcallv_kw(rb_cDir, id_glob, n, args, RB_PASS_KEYWORDS);
        ary = rb_convert_type(ary, T_ARRAY, "Array", "to_ary");
        for (i = 0; i < RARRAY_LEN(ary); i++) {
            VALUE elt = RARRAY_AREF(ary, i);
            elt = rb_funcall(self, '+', 1, elt);
            rb_ary_store(ary, i, elt);
        }
        return ary;
    }
}
grpowned?() 按一下以切換來源

請參閱 FileTest.grpowned?

static VALUE
path_grpowned_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_grpowned_p, 1, get_strpath(self));
}
join(*args) 按一下切換來源

將給定的路徑名稱加入 self 以建立新的 Pathname 物件。這實際上與使用 Pathname#+ 依序附加 self 和所有參數相同。

path0 = Pathname.new("/usr")                # Pathname:/usr
path0 = path0.join("bin/ruby")              # Pathname:/usr/bin/ruby
    # is the same as
path1 = Pathname.new("/usr") + "bin/ruby"   # Pathname:/usr/bin/ruby
path0 == path1
    #=> true
# File ext/pathname/lib/pathname.rb, line 416
def join(*args)
  return self if args.empty?
  result = args.pop
  result = Pathname.new(result) unless Pathname === result
  return result if result.absolute?
  args.reverse_each {|arg|
    arg = Pathname.new(arg) unless Pathname === arg
    result = arg + result
    return result if result.absolute?
  }
  self + result
end
lchmod(mode_int) → integer 按一下切換來源

Pathname.chmod 相同,但不會追蹤符號連結。

請參閱 File.lchmod

static VALUE
path_lchmod(VALUE self, VALUE mode)
{
    return rb_funcall(rb_cFile, id_lchmod, 2, mode, get_strpath(self));
}
lchown(owner_int, group_int) → integer 按一下切換來源

Pathname.chown 相同,但不會追蹤符號連結。

請參閱 File.lchown

static VALUE
path_lchown(VALUE self, VALUE owner, VALUE group)
{
    return rb_funcall(rb_cFile, id_lchown, 3, owner, group, get_strpath(self));
}
lstat() 按一下切換來源

請參閱 File.lstat

static VALUE
path_lstat(VALUE self)
{
    return rb_funcall(rb_cFile, id_lstat, 1, get_strpath(self));
}
lutime(p1, p2) 按一下切換來源

更新檔案的存取時間和修改時間。

Pathname#utime 相同,但不會追蹤符號連結。

請參閱 File.lutime

static VALUE
path_lutime(VALUE self, VALUE atime, VALUE mtime)
{
    return rb_funcall(rb_cFile, id_lutime, 3, atime, mtime, get_strpath(self));
}
mkdir(p1 = v1) 按一下切換來源

建立參考目錄。

請參閱 Dir.mkdir

static VALUE
path_mkdir(int argc, VALUE *argv, VALUE self)
{
    VALUE str = get_strpath(self);
    VALUE vmode;
    if (rb_scan_args(argc, argv, "01", &vmode) == 0)
        return rb_funcall(rb_cDir, id_mkdir, 1, str);
    else
        return rb_funcall(rb_cDir, id_mkdir, 2, str, vmode);
}
mkpath(mode: nil) 按一下切換來源

建立完整路徑,包括任何尚未存在的中間目錄。

請參閱 FileUtils.mkpathFileUtils.mkdir_p

# File ext/pathname/lib/pathname.rb, line 590
def mkpath(mode: nil)
  FileUtils.mkpath(@path, mode: mode)
  nil
end
mountpoint?() 按一下切換來源

如果 self 指向掛載點,則傳回 true

# File ext/pathname/lib/pathname.rb, line 201
def mountpoint?
  begin
    stat1 = self.lstat
    stat2 = self.parent.lstat
    stat1.dev != stat2.dev || stat1.ino == stat2.ino
  rescue Errno::ENOENT
    false
  end
end
mtime → time 按一下切換來源

傳回檔案的最後修改時間。

請參閱 File.mtime

static VALUE
path_mtime(VALUE self)
{
    return rb_funcall(rb_cFile, id_mtime, 1, get_strpath(self));
}
open() 按一下切換來源
open(mode="r" [, opt]) → file
open([mode [, perm]] [, opt]) → file
open(mode="r" [, opt]) {|file| block } → obj
open([mode [, perm]] [, opt]) {|file| block } → obj

開啟檔案以進行讀取或寫入。

請參閱 File.open

static VALUE
path_open(int argc, VALUE *argv, VALUE self)
{
    VALUE args[4];
    int n;

    args[0] = get_strpath(self);
    n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
    if (rb_block_given_p()) {
        return rb_block_call_kw(rb_cFile, id_open, 1+n, args, 0, 0, RB_PASS_CALLED_KEYWORDS);
    }
    else {
        return rb_funcallv_kw(rb_cFile, id_open, 1+n, args, RB_PASS_CALLED_KEYWORDS);
    }
}
opendir() 按一下以切換來源

開啟所參考的目錄。

請參閱 Dir.open

static VALUE
path_opendir(VALUE self)
{
    VALUE args[1];

    args[0] = get_strpath(self);
    return rb_block_call(rb_cDir, id_open, 1, args, 0, 0);
}
owned?() 按一下以切換來源

請參閱 FileTest.owned?

static VALUE
path_owned_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_owned_p, 1, get_strpath(self));
}
parent() 按一下以切換來源

傳回父目錄。

這與 self + '..' 相同。

# File ext/pathname/lib/pathname.rb, line 196
def parent
  self + '..'
end
pipe?() 按一下以切換來源

請參閱 FileTest.pipe?

static VALUE
path_pipe_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_pipe_p, 1, get_strpath(self));
}
read([length [, offset]]) → string 按一下以切換來源
read([length [, offset]], open_args) → string

傳回檔案中的所有資料,或指定時傳回前 N 個位元組。

請參閱 File.read

static VALUE
path_read(int argc, VALUE *argv, VALUE self)
{
    VALUE args[4];
    int n;

    args[0] = get_strpath(self);
    n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
    return rb_funcallv_kw(rb_cFile, id_read, 1+n, args, RB_PASS_CALLED_KEYWORDS);
}
readable?() 按一下以切換來源

請參閱 FileTest.readable?

static VALUE
path_readable_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_readable_p, 1, get_strpath(self));
}
readable_real?() 按一下以切換來源

請參閱 FileTest.readable_real?

static VALUE
path_readable_real_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_readable_real_p, 1, get_strpath(self));
}
readlines(sep=$/ [, open_args]) → array 按一下以切換來源
readlines(limit [, open_args]) → array
readlines(sep, limit [, open_args]) → array

傳回檔案中的所有行。

請參閱 File.readlines

static VALUE
path_readlines(int argc, VALUE *argv, VALUE self)
{
    VALUE args[4];
    int n;

    args[0] = get_strpath(self);
    n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
    return rb_funcallv_kw(rb_cFile, id_readlines, 1+n, args, RB_PASS_CALLED_KEYWORDS);
}
realdirpath(p1 = v1) 按一下以切換來源

傳回 self 在實際檔案系統中的真實(絕對)路徑名稱。

不包含符號連結或無用的點號,...

真實路徑名稱的最後一個組成部分可能不存在。

static VALUE
path_realdirpath(int argc, VALUE *argv, VALUE self)
{
    VALUE basedir, str;
    rb_scan_args(argc, argv, "01", &basedir);
    str = rb_funcall(rb_cFile, id_realdirpath, 2, get_strpath(self), basedir);
    return rb_class_new_instance(1, &str, rb_obj_class(self));
}
realpath(p1 = v1) 按一下以切換來源

傳回 self 在實際檔案系統中的真實(絕對)路徑名稱。

不包含符號連結或無用的點號,...

呼叫此方法時,路徑名稱的所有組成部分都必須存在。

static VALUE
path_realpath(int argc, VALUE *argv, VALUE self)
{
    VALUE basedir, str;
    rb_scan_args(argc, argv, "01", &basedir);
    str = rb_funcall(rb_cFile, id_realpath, 2, get_strpath(self), basedir);
    return rb_class_new_instance(1, &str, rb_obj_class(self));
}
relative?() 按一下以切換來源

Pathname#absolute? 的相反。

如果路徑名稱以斜線開頭,則傳回 false

p = Pathname.new('/im/sure')
p.relative?
    #=> false

p = Pathname.new('not/so/sure')
p.relative?
    #=> true
# File ext/pathname/lib/pathname.rb, line 248
def relative?
  !absolute?
end
relative_path_from(base_directory) 按一下以切換來源

傳回從給定的 base_directory 到接收者的相對路徑。

如果 self 是絕對路徑,則 base_directory 也必須是絕對路徑。

如果 self 是相對路徑,則 base_directory 也必須是相對路徑。

此方法不會存取檔案系統。它假設沒有符號連結。

當找不到相對路徑時,會引發 ArgumentError

請注意,此方法不會處理使用中檔案系統的大小寫敏感性與作業系統預設值不同的情況。

# File ext/pathname/lib/pathname.rb, line 517
def relative_path_from(base_directory)
  base_directory = Pathname.new(base_directory) unless base_directory.is_a? Pathname
  dest_directory = self.cleanpath.to_s
  base_directory = base_directory.cleanpath.to_s
  dest_prefix = dest_directory
  dest_names = []
  while r = chop_basename(dest_prefix)
    dest_prefix, basename = r
    dest_names.unshift basename if basename != '.'
  end
  base_prefix = base_directory
  base_names = []
  while r = chop_basename(base_prefix)
    base_prefix, basename = r
    base_names.unshift basename if basename != '.'
  end
  unless SAME_PATHS[dest_prefix, base_prefix]
    raise ArgumentError, "different prefix: #{dest_prefix.inspect} and #{base_directory.inspect}"
  end
  while !dest_names.empty? &&
        !base_names.empty? &&
        SAME_PATHS[dest_names.first, base_names.first]
    dest_names.shift
    base_names.shift
  end
  if base_names.include? '..'
    raise ArgumentError, "base_directory has ..: #{base_directory.inspect}"
  end
  base_names.fill('..')
  relpath_names = base_names + dest_names
  if relpath_names.empty?
    Pathname.new('.')
  else
    Pathname.new(File.join(*relpath_names))
  end
end
rename(p1) 按一下以切換來源

重新命名檔案。

請參閱 File.rename

static VALUE
path_rename(VALUE self, VALUE to)
{
    return rb_funcall(rb_cFile, id_rename, 2, get_strpath(self), to);
}
rmdir() 按一下以切換來源

移除參考的目錄。

請參閱 Dir.rmdir

static VALUE
path_rmdir(VALUE self)
{
    return rb_funcall(rb_cDir, id_rmdir, 1, get_strpath(self));
}
rmtree(noop: nil, verbose: nil, secure: nil) 按一下以切換來源

遞迴刪除目錄,包括其下的所有目錄。

請參閱 FileUtils.rm_rf

# File ext/pathname/lib/pathname.rb, line 598
def rmtree(noop: nil, verbose: nil, secure: nil)
  # The name "rmtree" is borrowed from File::Path of Perl.
  # File::Path provides "mkpath" and "rmtree".
  require 'fileutils'
  FileUtils.rm_rf(@path, noop: noop, verbose: verbose, secure: secure)
  nil
end
root?() 按一下以切換來源

根目錄的謂詞方法。如果路徑名稱由連續的斜線組成,則傳回 true

它不會存取檔案系統。因此,它可能會為指向根目錄的路徑名稱(例如 /usr/..)傳回 false

# File ext/pathname/lib/pathname.rb, line 218
def root?
  chop_basename(@path) == nil && /#{SEPARATOR_PAT}/o.match?(@path)
end
setgid?() 按一下以切換來源

請參閱 FileTest.setgid?

static VALUE
path_setgid_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_setgid_p, 1, get_strpath(self));
}
setuid?() 按一下以切換來源

請參閱 FileTest.setuid?

static VALUE
path_setuid_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_setuid_p, 1, get_strpath(self));
}
size() 按一下以切換來源

請參閱 FileTest.size

static VALUE
path_size(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_size, 1, get_strpath(self));
}
size?() 按一下以切換來源

請參閱 FileTest.size?

static VALUE
path_size_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_size_p, 1, get_strpath(self));
}
socket?() 按一下以切換來源

請參閱 FileTest.socket?

static VALUE
path_socket_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_socket_p, 1, get_strpath(self));
}
split() 按一下以切換來源

Array 中傳回 dirnamebasename

請參閱 File.split

static VALUE
path_split(VALUE self)
{
    VALUE str = get_strpath(self);
    VALUE ary, dirname, basename;
    ary = rb_funcall(rb_cFile, id_split, 1, str);
    Check_Type(ary, T_ARRAY);
    dirname = rb_ary_entry(ary, 0);
    basename = rb_ary_entry(ary, 1);
    dirname = rb_class_new_instance(1, &dirname, rb_obj_class(self));
    basename = rb_class_new_instance(1, &basename, rb_obj_class(self));
    return rb_ary_new3(2, dirname, basename);
}
stat() 按一下以切換來源

傳回 File::Stat 物件。

請參閱 File.stat

static VALUE
path_stat(VALUE self)
{
    return rb_funcall(rb_cFile, id_stat, 1, get_strpath(self));
}
sticky?() 按一下以切換來源

請參閱 FileTest.sticky?

static VALUE
path_sticky_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_sticky_p, 1, get_strpath(self));
}
sub(*args) 按一下以切換來源

傳回由 String#sub 替換的檔案路徑。

path1 = Pathname.new('/usr/bin/perl')
path1.sub('perl', 'ruby')
    #=> #<Pathname:/usr/bin/ruby>
static VALUE
path_sub(int argc, VALUE *argv, VALUE self)
{
    VALUE str = get_strpath(self);

    if (rb_block_given_p()) {
        str = rb_block_call(str, id_sub, argc, argv, 0, 0);
    }
    else {
        str = rb_funcallv(str, id_sub, argc, argv);
    }
    return rb_class_new_instance(1, &str, rb_obj_class(self));
}
sub_ext(p1) 按一下以切換來源

傳回檔案路徑,其中 repl 已新增為基本檔名的字尾。

如果 self 沒有擴充功能部分,則會附加 repl

Pathname.new('/usr/bin/shutdown').sub_ext('.rb')
    #=> #<Pathname:/usr/bin/shutdown.rb>
static VALUE
path_sub_ext(VALUE self, VALUE repl)
{
    VALUE str = get_strpath(self);
    VALUE str2;
    long extlen;
    const char *ext;
    const char *p;

    StringValue(repl);
    p = RSTRING_PTR(str);
    extlen = RSTRING_LEN(str);
    ext = ruby_enc_find_extname(p, &extlen, rb_enc_get(str));
    if (ext == NULL) {
        ext = p + RSTRING_LEN(str);
    }
    else if (extlen <= 1) {
        ext += extlen;
    }
    str2 = rb_str_subseq(str, 0, ext-p);
    rb_str_append(str2, repl);
    return rb_class_new_instance(1, &str2, rb_obj_class(self));
}
sysopen([mode, [perm]]) → fixnum 按一下以切換來源

請參閱 IO.sysopen

static VALUE
path_sysopen(int argc, VALUE *argv, VALUE self)
{
    VALUE args[3];
    int n;

    args[0] = get_strpath(self);
    n = rb_scan_args(argc, argv, "02", &args[1], &args[2]);
    return rb_funcallv(rb_cIO, id_sysopen, 1+n, args);
}
to_path → string

傳回檔案路徑作為 String

to_path 已實作,因此 Pathname 物件可用於 File.open 等。

別名:to_s
to_s → 字串 按一下以切換來源

傳回檔案路徑作為 String

to_path 已實作,因此 Pathname 物件可用於 File.open 等。

static VALUE
path_to_s(VALUE self)
{
    return rb_obj_dup(get_strpath(self));
}
別名為:to_path
truncate(p1) 按一下以切換來源

將檔案截斷為長度為 length 的位元組。

請參閱 File.truncate

static VALUE
path_truncate(VALUE self, VALUE length)
{
    return rb_funcall(rb_cFile, id_truncate, 2, get_strpath(self), length);
}
utime(p1, p2) 按一下以切換來源

更新檔案的存取時間和修改時間。

請參閱 File.utime

static VALUE
path_utime(VALUE self, VALUE atime, VALUE mtime)
{
    return rb_funcall(rb_cFile, id_utime, 3, atime, mtime, get_strpath(self));
}
world_readable?() 按一下以切換來源

請參閱 FileTest.world_readable?

static VALUE
path_world_readable_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_world_readable_p, 1, get_strpath(self));
}
world_writable?() 按一下以切換來源

請參閱 FileTest.world_writable?

static VALUE
path_world_writable_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_world_writable_p, 1, get_strpath(self));
}
writable?() 按一下以切換來源

請參閱 FileTest.writable?

static VALUE
path_writable_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_writable_p, 1, get_strpath(self));
}
writable_real?() 按一下以切換來源

請參閱 FileTest.writable_real?

static VALUE
path_writable_real_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_writable_real_p, 1, get_strpath(self));
}
write(字串, [位移] ) → 定數 按一下以切換來源
write(字串, [位移], open_args ) → 定數

contents 寫入檔案。

請參閱 File.write

static VALUE
path_write(int argc, VALUE *argv, VALUE self)
{
    VALUE args[4];
    int n;

    args[0] = get_strpath(self);
    n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
    return rb_funcallv_kw(rb_cFile, id_write, 1+n, args, RB_PASS_CALLED_KEYWORDS);
}
zero?() 按一下以切換來源

請參閱 FileTest.zero?

static VALUE
path_zero_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, id_zero_p, 1, get_strpath(self));
}