Struct std::path::PathBuf

1.0.0 · source ·

pub struct PathBuf { /* private fields */ }

Expand description

拥有的可变路径 (类似于 String)。

这种类型提供了 push 和 set_extension 之类的方法，这些方法会改变路径。它还实现了 Deref 到 Path，这意味着 Path 切片上的所有方法也可以在 PathBuf 值上使用。

有关整体方法的更多详细信息，请参见模块级文档。

Examples

您可以使用 push 从组件构建 PathBuf：

use std::path::PathBuf;

let mut path = PathBuf::new();

path.push(r"C:\");
path.push("windows");
path.push("system32");

path.set_extension("dll");

Run

但是，push 最适合用于动态情况。当您提前了解所有组件时，这是一种更好的方法：

use std::path::PathBuf;

let path: PathBuf = [r"C:\", "windows", "system32.dll"].iter().collect();

Run

我们仍然可以做得更好！由于这些都是字符串，因此我们可以使用 From::from:

use std::path::PathBuf;

let path = PathBuf::from(r"C:\windows\system32.dll");

Run

哪种方法最有效取决于您所处的情况。

Implementations§

source §

impl PathBuf

source

pub fn new() -> PathBuf

分配一个空的 PathBuf。

Examples

use std::path::PathBuf;

let path = PathBuf::new();

Run

1.44.0 · source

pub fn with_capacity(capacity: usize) -> PathBuf

创建具有给定容量的新 PathBuf，用于创建内部 OsString。请参见在 OsString 上定义的 with_capacity。

Examples

use std::path::PathBuf;

let mut path = PathBuf::with_capacity(10);
let capacity = path.capacity();

// 无需重新分配即可完成此推送
path.push(r"C:\");

assert_eq!(capacity, path.capacity());

Run

source

pub fn as_path(&self) -> &Path

强制转换为 Path 切片。

Examples

use std::path::{Path, PathBuf};

let p = PathBuf::from("/test");
assert_eq!(Path::new("/test"), p.as_path());

Run

source

pub fn push<P: AsRef<Path>>(&mut self, path: P)

用 path 扩展 self。

如果 path 是绝对路径，它将替换当前路径。

在 Windows 上：

如果 path 具有根但没有前缀 (例如 \windows)，它将替换 self 的前缀 (如果有) 之外的所有内容。
如果 path 有前缀但没有根，它将替换 self。
如果 self 有 verbatim 前缀 (例如 \\?\C:\windows) 并且 path 不为空，新路径被规范化：所有对 . 和 .. 的引用都被删除。

如果您需要一个新的 PathBuf 而不是在克隆的 PathBuf 上使用这个函数，请考虑使用 Path::join。

Examples

推动相对路径可扩展现有路径：

use std::path::PathBuf;

let mut path = PathBuf::from("/tmp");
path.push("file.bk");
assert_eq!(path, PathBuf::from("/tmp/file.bk"));

Run

推送绝对路径将替换现有路径：

use std::path::PathBuf;

let mut path = PathBuf::from("/tmp");
path.push("/etc");
assert_eq!(path, PathBuf::from("/etc"));

Run

source

pub fn pop(&mut self) -> bool

将 self 截断为 self.parent。

返回 false，如果 self.parent 为 None，则不执行任何操作。否则，返回 true。

Examples

use std::path::{Path, PathBuf};

let mut p = PathBuf::from("/spirited/away.rs");

p.pop();
assert_eq!(Path::new("/spirited"), p);
p.pop();
assert_eq!(Path::new("/"), p);

Run

source

pub fn set_file_name<S: AsRef<OsStr>>(&mut self, file_name: S)

将 self.file_name 更新为 file_name。

如果 self.file_name 是 None，则等效于按下 file_name。

否则，这等效于调用 pop，然后按 file_name。新路径将是原始路径的同级。 (也就是说，它将具有相同的父对象。)

Examples

use std::path::PathBuf;

let mut buf = PathBuf::from("/");
assert!(buf.file_name() == None);

buf.set_file_name("foo.txt");
assert!(buf == PathBuf::from("/foo.txt"));
assert!(buf.file_name().is_some());

buf.set_file_name("bar.txt");
assert!(buf == PathBuf::from("/bar.txt"));

buf.set_file_name("baz");
assert!(buf == PathBuf::from("/baz"));

Run

source

pub fn set_extension<S: AsRef<OsStr>>(&mut self, extension: S) -> bool

如果 extension 为空，则将 self.extension 更新为 Some(extension) 或更新为 None。

返回 false，如果 self.file_name 为 None，则不执行任何操作，否则返回 true，并更新扩展名。

如果 self.extension 为 None，则添加扩展名；否则将被替换。

如果 extension 为空字符串，则 self.extension 之后将是 None，而不是 Some("")。

Caveats

新的 extension 可能包含点，将被整体使用，但只有最后一个点之后的部分会反映在 self.extension 中。

如果文件主干包含内部点并且 extension 为空，则旧文件主干的一部分将被视为新的 self.extension。

请参见下面的示例。

Examples

use std::path::{Path, PathBuf};

let mut p = PathBuf::from("/feel/the");

p.set_extension("force");
assert_eq!(Path::new("/feel/the.force"), p.as_path());

p.set_extension("dark.side");
assert_eq!(Path::new("/feel/the.dark.side"), p.as_path());

p.set_extension("cookie");
assert_eq!(Path::new("/feel/the.dark.cookie"), p.as_path());

p.set_extension("");
assert_eq!(Path::new("/feel/the.dark"), p.as_path());

p.set_extension("");
assert_eq!(Path::new("/feel/the"), p.as_path());

p.set_extension("");
assert_eq!(Path::new("/feel/the"), p.as_path());

Run

1.70.0 · source

pub fn as_mut_os_string(&mut self) -> &mut OsString

对底层 OsString 实例产生可变引用。

Examples

use std::path::{Path, PathBuf};

let mut path = PathBuf::from("/foo");

path.push("bar");
assert_eq!(path, Path::new("/foo/bar"));

// OsString 的 `push` 没有加分隔符。
path.as_mut_os_string().push("baz");
assert_eq!(path, Path::new("/foo/barbaz"));

Run

source

pub fn into_os_string(self) -> OsString

消耗 PathBuf，产生其内部 OsString 存储。

Examples

use std::path::PathBuf;

let p = PathBuf::from("/the/head");
let os_str = p.into_os_string();

Run

1.20.0 · source

pub fn into_boxed_path(self) -> Box<Path>

将此 PathBuf 转换为 boxed Path。

1.44.0 · source

pub fn capacity(&self) -> usize

在 OsString 的底层实例上调用 capacity。

1.44.0 · source

pub fn clear(&mut self)

在 OsString 的底层实例上调用 clear。

1.44.0 · source

pub fn reserve(&mut self, additional: usize)

在 OsString 的底层实例上调用 reserve。

1.63.0 · source

pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

在 OsString 的底层实例上调用 try_reserve。

1.44.0 · source

pub fn reserve_exact(&mut self, additional: usize)

在 OsString 的底层实例上调用 reserve_exact。

1.63.0 · source

pub fn try_reserve_exact( &mut self, additional: usize ) -> Result<(), TryReserveError>

在 OsString 的底层实例上调用 try_reserve_exact。

1.44.0 · source

pub fn shrink_to_fit(&mut self)

在 OsString 的底层实例上调用 shrink_to_fit。

1.56.0 · source

pub fn shrink_to(&mut self, min_capacity: usize)

在 OsString 的底层实例上调用 shrink_to。

Methods from Deref<Target = Path>§

source

pub fn as_os_str(&self) -> &OsStr

产生底层的 OsStr 切片。

Examples

use std::path::Path;

let os_str = Path::new("foo.txt").as_os_str();
assert_eq!(os_str, std::ffi::OsStr::new("foo.txt"));

Run

1.70.0 · source

pub fn as_mut_os_str(&mut self) -> &mut OsStr

对底层 OsStr 切片产生可变引用。

Examples

use std::path::{Path, PathBuf};

let mut path = PathBuf::from("Foo.TXT");

assert_ne!(path, Path::new("foo.txt"));

path.as_mut_os_str().make_ascii_lowercase();
assert_eq!(path, Path::new("foo.txt"));

Run

source

pub fn to_str(&self) -> Option<&str>

如果 Path 是有效的 unicode，则产生 &str 切片。

此转换可能需要检查 UTF-8 有效性。请注意，执行验证是因为非 UTF-8 字符串对于某些 OS 完全有效。

Examples

use std::path::Path;

let path = Path::new("foo.txt");
assert_eq!(path.to_str(), Some("foo.txt"));

Run

source

pub fn to_string_lossy(&self) -> Cow<'_, str>

将 Path 转换为 Cow<str>。

任何非 Unicode 序列都将替换为 U+FFFD REPLACEMENT CHARACTER。

Examples

使用有效的 Unicode 在 Path 上调用 to_string_lossy：

use std::path::Path;

let path = Path::new("foo.txt");
assert_eq!(path.to_string_lossy(), "foo.txt");

Run

如果 path 包含无效的 unicode，则 to_string_lossy 调用可能已返回 "fo.txt"。

source

pub fn to_path_buf(&self) -> PathBuf

将 Path 转换为拥有的 PathBuf。

Examples

use std::path::Path;

let path_buf = Path::new("foo.txt").to_path_buf();
assert_eq!(path_buf, std::path::PathBuf::from("foo.txt"));

Run

source

pub fn is_absolute(&self) -> bool

如果 Path 是绝对的，即独立于当前目录，则返回 true。

在 Unix 上，如果路径以根开头，则它是绝对的，因此 is_absolute 和 has_root 是等效的。
在 Windows 上，如果路径具有前缀并以根开头，则它是绝对路径: c:\windows 是绝对路径，而 c:temp 和 \temp 不是。

Examples

use std::path::Path;

assert!(!Path::new("foo.txt").is_absolute());

Run

source

pub fn is_relative(&self) -> bool

如果 Path 是相对的，即不是绝对的，则返回 true。

有关更多详细信息，请参见 is_absolute 的文档。

Examples

use std::path::Path;

assert!(Path::new("foo.txt").is_relative());

Run

source

pub fn has_root(&self) -> bool

如果 Path 具有根，则返回 true。

在 Unix 上，如果路径以 / 开头，则该路径具有根。
在 Windows 上，如果路径具有根，则它是：
- 没有前缀并以分隔符开头，例如 \windows
- 有一个前缀，后跟一个分隔符，例如 c:\windows，但没有 c:windows
- 具有任何非磁盘前缀，例如 \\server\share

Examples

use std::path::Path;

assert!(Path::new("/etc/passwd").has_root());

Run

source

pub fn parent(&self) -> Option<&Path>

如果没有 Path，则返回不包含其最终组成部分的 Path。

这意味着它为具有一个组件的相对路径返回 Some("")。

如果路径以根或前缀终止，或者它是空字符串，则返回 None。

Examples

use std::path::Path;

let path = Path::new("/foo/bar");
let parent = path.parent().unwrap();
assert_eq!(parent, Path::new("/foo"));

let grand_parent = parent.parent().unwrap();
assert_eq!(grand_parent, Path::new("/"));
assert_eq!(grand_parent.parent(), None);

let relative_path = Path::new("foo/bar");
let parent = relative_path.parent();
assert_eq!(parent, Some(Path::new("foo")));
let grand_parent = parent.and_then(Path::parent);
assert_eq!(grand_parent, Some(Path::new("")));
let great_grand_parent = grand_parent.and_then(Path::parent);
assert_eq!(great_grand_parent, None);

Run

1.28.0 · source

pub fn ancestors(&self) -> Ancestors<'_> ⓘ

在 Path 及其祖先上生成一个迭代器。

如果 parent 方法使用了 0 次或多次，则迭代器将产生返回的 Path。这意味着，迭代器将产生 &self，&self.parent().unwrap()，&self.parent().unwrap().parent().unwrap() 等。如果 parent 方法返回 None，则迭代器也将这样做。

迭代器将始终产生至少一个值，即 &self。

Examples

use std::path::Path;

let mut ancestors = Path::new("/foo/bar").ancestors();
assert_eq!(ancestors.next(), Some(Path::new("/foo/bar")));
assert_eq!(ancestors.next(), Some(Path::new("/foo")));
assert_eq!(ancestors.next(), Some(Path::new("/")));
assert_eq!(ancestors.next(), None);

let mut ancestors = Path::new("../foo/bar").ancestors();
assert_eq!(ancestors.next(), Some(Path::new("../foo/bar")));
assert_eq!(ancestors.next(), Some(Path::new("../foo")));
assert_eq!(ancestors.next(), Some(Path::new("..")));
assert_eq!(ancestors.next(), Some(Path::new("")));
assert_eq!(ancestors.next(), None);

Run

source

pub fn file_name(&self) -> Option<&OsStr>

返回 Path 的最后一个组件 (如果有)。

如果路径是普通文件，则为文件名。如果是目录路径，则为目录名称。

如果路径以 .. 结尾，则返回 None。

Examples

use std::path::Path;
use std::ffi::OsStr;

assert_eq!(Some(OsStr::new("bin")), Path::new("/usr/bin/").file_name());
assert_eq!(Some(OsStr::new("foo.txt")), Path::new("tmp/foo.txt").file_name());
assert_eq!(Some(OsStr::new("foo.txt")), Path::new("foo.txt/.").file_name());
assert_eq!(Some(OsStr::new("foo.txt")), Path::new("foo.txt/.//").file_name());
assert_eq!(None, Path::new("foo.txt/..").file_name());
assert_eq!(None, Path::new("/").file_name());

Run

1.7.0 · source

pub fn strip_prefix(&self, base: P) -> Result<&Path, StripPrefixError>where P: AsRef<Path>,

返回连接到 base 时产生 self 的路径。

Errors

如果 base 不是 self 的前缀 (即 starts_with 返回 false)，则返回 Err。

Examples

use std::path::{Path, PathBuf};

let path = Path::new("/test/haha/foo.txt");

assert_eq!(path.strip_prefix("/"), Ok(Path::new("test/haha/foo.txt")));
assert_eq!(path.strip_prefix("/test"), Ok(Path::new("haha/foo.txt")));
assert_eq!(path.strip_prefix("/test/"), Ok(Path::new("haha/foo.txt")));
assert_eq!(path.strip_prefix("/test/haha/foo.txt"), Ok(Path::new("")));
assert_eq!(path.strip_prefix("/test/haha/foo.txt/"), Ok(Path::new("")));

assert!(path.strip_prefix("test").is_err());
assert!(path.strip_prefix("/haha").is_err());

let prefix = PathBuf::from("/test/");
assert_eq!(path.strip_prefix(prefix), Ok(Path::new("haha/foo.txt")));

Run

source

pub fn starts_with<P: AsRef<Path>>(&self, base: P) -> bool

确定 base 是否为 self 的前缀。

仅考虑整个路径组件匹配。

Examples

use std::path::Path;

let path = Path::new("/etc/passwd");

assert!(path.starts_with("/etc"));
assert!(path.starts_with("/etc/"));
assert!(path.starts_with("/etc/passwd"));
assert!(path.starts_with("/etc/passwd/")); // 额外的斜线是可以的
assert!(path.starts_with("/etc/passwd///")); // multiple extra slashes are okay

assert!(!path.starts_with("/e"));
assert!(!path.starts_with("/etc/passwd.txt"));

assert!(!Path::new("/etc/foo.rs").starts_with("/etc/foo"));

Run

source

pub fn ends_with<P: AsRef<Path>>(&self, child: P) -> bool

确定 child 是否为 self 的后缀。

仅考虑整个路径组件匹配。

Examples

use std::path::Path;

let path = Path::new("/etc/resolv.conf");

assert!(path.ends_with("resolv.conf"));
assert!(path.ends_with("etc/resolv.conf"));
assert!(path.ends_with("/etc/resolv.conf"));

assert!(!path.ends_with("/resolv.conf"));
assert!(!path.ends_with("conf")); // 改用 .extension()

Run

source

pub fn file_stem(&self) -> Option<&OsStr>

提取 self.file_name 的茎 (non-extension) 部分。

词干为：

None，如果没有文件名；
如果没有嵌入式 .，则为整个文件名; 否则为 0。
如果文件名以 . 开头且内部没有其他 .，则为整个文件名；
否则，文件名中最后 . 之前的部分

Examples

use std::path::Path;

assert_eq!("foo", Path::new("foo.rs").file_stem().unwrap());
assert_eq!("foo.tar", Path::new("foo.tar.gz").file_stem().unwrap());

Run

也可以看看

这个方法类似于 Path::file_prefix，提取 first . 之前的文件名部分

source

pub fn file_prefix(&self) -> Option<&OsStr>

🔬This is a nightly-only experimental API. (path_file_prefix #86319)

提取 self.file_name 的前缀。

前缀是：

None，如果没有文件名；
如果没有嵌入式 .，则为整个文件名; 否则为 0。
文件名中第一个非开头 . 之前的部分；
如果文件名以 . 开头且内部没有其他 .，则为整个文件名；
如果文件名以 . 开头，则为第二个 . 之前的文件名部分

Examples

use std::path::Path;

assert_eq!("foo", Path::new("foo.rs").file_prefix().unwrap());
assert_eq!("foo", Path::new("foo.tar.gz").file_prefix().unwrap());

Run

也可以看看

此方法类似于 Path::file_stem，提取文件名中 last . 之前的部分

source

pub fn extension(&self) -> Option<&OsStr>

如果可能，提取 self.file_name 的扩展名 (不带前导点)。

扩展名是：

None，如果没有文件名；
None，如果没有嵌入的 .；
None，如果文件名以 . 开头，并且里面没有其他的 .；
否则，文件名中最后一个 . 之后的部分

Examples

use std::path::Path;

assert_eq!("rs", Path::new("foo.rs").extension().unwrap());
assert_eq!("gz", Path::new("foo.tar.gz").extension().unwrap());

Run

source

pub fn join<P: AsRef<Path>>(&self, path: P) -> PathBuf

创建一个拥有的 PathBuf，并将 path 附加到 self。

如果 path 是绝对路径，它将替换当前路径。

有关连接路径的含义的更多详细信息，请参见 PathBuf::push。

Examples

use std::path::{Path, PathBuf};

assert_eq!(Path::new("/etc").join("passwd"), PathBuf::from("/etc/passwd"));
assert_eq!(Path::new("/etc").join("/bin/sh"), PathBuf::from("/bin/sh"));

Run

source

pub fn with_file_name<S: AsRef<OsStr>>(&self, file_name: S) -> PathBuf

创建一个拥有的 PathBuf，例如 self，但具有给定的文件名。

有关更多详细信息，请参见 PathBuf::set_file_name。

Examples

use std::path::{Path, PathBuf};

let path = Path::new("/tmp/foo.png");
assert_eq!(path.with_file_name("bar"), PathBuf::from("/tmp/bar"));
assert_eq!(path.with_file_name("bar.txt"), PathBuf::from("/tmp/bar.txt"));

let path = Path::new("/tmp");
assert_eq!(path.with_file_name("var"), PathBuf::from("/var"));

Run

source

pub fn with_extension<S: AsRef<OsStr>>(&self, extension: S) -> PathBuf

创建一个拥有的 PathBuf，例如 self，但具有给定的扩展名。

有关更多详细信息，请参见 PathBuf::set_extension。

Examples

use std::path::{Path, PathBuf};

let path = Path::new("foo.rs");
assert_eq!(path.with_extension("txt"), PathBuf::from("foo.txt"));

let path = Path::new("foo.tar.gz");
assert_eq!(path.with_extension(""), PathBuf::from("foo.tar"));
assert_eq!(path.with_extension("xz"), PathBuf::from("foo.tar.xz"));
assert_eq!(path.with_extension("").with_extension("txt"), PathBuf::from("foo.txt"));

Run

source

pub fn components(&self) -> Components<'_> ⓘ

生成路径的 Component 上的迭代器。

解析路径时，需要进行少量标准化：

重复的分隔符将被忽略，因此 a/b 和 a//b 都具有 a 和 b 作为组件。
. 的出现被归一化，除非它们位于路径的开头。例如，a/./b，a/b/，a/b/. 和 a/b 都具有 a 和 b 作为组件，但是 ./a/b 以附加的 CurDir 组件开头。
尾部的斜杠已标准化，/a/b 和 /a/b/ 是等效的。

请注意，没有其他标准化发生。特别是，a/c 和 a/b/../c 是不同的，以考虑到 b 是符号链接 (因此其父代不是 a) 的可能性。

Examples

use std::path::{Path, Component};
use std::ffi::OsStr;

let mut components = Path::new("/tmp/foo.txt").components();

assert_eq!(components.next(), Some(Component::RootDir));
assert_eq!(components.next(), Some(Component::Normal(OsStr::new("tmp"))));
assert_eq!(components.next(), Some(Component::Normal(OsStr::new("foo.txt"))));
assert_eq!(components.next(), None)

Run

source

pub fn iter(&self) -> Iter<'_> ⓘ

在视为 OsStr slice 的路径的组件上生成迭代器。

有关如何将路径分成多个组件的详细信息，请参见 components。

Examples

use std::path::{self, Path};
use std::ffi::OsStr;

let mut it = Path::new("/tmp/foo.txt").iter();
assert_eq!(it.next(), Some(OsStr::new(&path::MAIN_SEPARATOR.to_string())));
assert_eq!(it.next(), Some(OsStr::new("tmp")));
assert_eq!(it.next(), Some(OsStr::new("foo.txt")));
assert_eq!(it.next(), None)

Run

source

pub fn display(&self) -> Display<'_>

返回实现 Display 的对象，以安全地打印可能包含非 Unicode 数据的路径。

根据平台的不同，这可能会执行有损转换。如果您想要一个转义路径的实现，请改用 Debug。

Examples

use std::path::Path;

let path = Path::new("/tmp/foo.rs");

println!("{}", path.display());

Run

1.5.0 · source

pub fn metadata(&self) -> Result<Metadata>

查询文件系统以获取有关文件，目录等的信息。

该函数将遍历符号链接以查询有关目标文件的信息。

这是 fs::metadata 的别名。

Examples

use std::path::Path;

let path = Path::new("/Minas/tirith");
let metadata = path.metadata().expect("metadata call failed");
println!("{:?}", metadata.file_type());

Run

1.5.0 · source

pub fn symlink_metadata(&self) -> Result<Metadata>

查询有关文件的元数据，而无需遵循符号链接。

这是 fs::symlink_metadata 的别名。

Examples

use std::path::Path;

let path = Path::new("/Minas/tirith");
let metadata = path.symlink_metadata().expect("symlink_metadata call failed");
println!("{:?}", metadata.file_type());

Run

1.5.0 · source

pub fn canonicalize(&self) -> Result<PathBuf>

返回路径的规范，绝对形式，所有中间组件均已标准化，符号链接已解析。

这是 fs::canonicalize 的别名。

Examples

use std::path::{Path, PathBuf};

let path = Path::new("/foo/test/../test/bar.rs");
assert_eq!(path.canonicalize().unwrap(), PathBuf::from("/foo/test/bar.rs"));

Run

1.5.0 · source

pub fn read_link(&self) -> Result<PathBuf>

读取符号链接，返回链接指向的文件。

这是 fs::read_link 的别名。

Examples

use std::path::Path;

let path = Path::new("/laputa/sky_castle.rs");
let path_link = path.read_link().expect("read_link call failed");

Run

1.5.0 · source

pub fn read_dir(&self) -> Result<ReadDir>

返回目录中条目的迭代器。

迭代器将产生一个 io::Result<fs::DirEntry> 的实例。最初构造迭代器后，可能会遇到新的错误。

这是 fs::read_dir 的别名。

Examples

use std::path::Path;

let path = Path::new("/laputa");
for entry in path.read_dir().expect("read_dir call failed") {
    if let Ok(entry) = entry {
        println!("{:?}", entry.path());
    }
}

Run

1.5.0 · source

pub fn exists(&self) -> bool

如果路径指向现有实体，则返回 true。

警告: 此方法可能容易出错，请考虑改用 try_exists()! 它还存在将时间检查引入使用时间 (TOCTOU) 错误的风险。

该函数将遍历符号链接以查询有关目标文件的信息。

如果您无法访问文件的元数据，例如由于权限错误或损坏的符号链接，这将返回 false。

Examples

use std::path::Path;
assert!(!Path::new("does_not_exist.txt").exists());

Run

也可以看看

这是一个方便的函数，可将错误强制为 false。如果要检查错误，调用 Path::try_exists。

1.63.0 · source

pub fn try_exists(&self) -> Result<bool>

如果路径指向现有实体，则返回 Ok(true)。

该函数将遍历符号链接以查询有关目标文件的信息。如果符号链接断开，则将返回 Ok(false)。

Path::exists() 仅检查路径是否已找到且可读。相比之下，如果验证路径存在或不存在，try_exists 将分别返回 Ok(true) 或 Ok(false)。如果它的存在既不能被确认也不能被拒绝，它将传播一个 Err(_)。这可能是这种情况，例如对其中一个父目录的列表权限被拒绝。

请注意，虽然这避免了 exists() 方法的一些缺陷，但它仍然无法防止时间检查到使用时间 (TOCTOU) 错误。

您应该只在这些错误不是问题的情况下使用它。

Examples

use std::path::Path;
assert!(!Path::new("does_not_exist.txt").try_exists().expect("Can't check existence of file does_not_exist.txt"));
assert!(Path::new("/root/secret_file.txt").try_exists().is_err());

Run

1.5.0 · source

pub fn is_file(&self) -> bool

如果路径在磁盘上并且指向常规文件，则返回 true。

该函数将遍历符号链接以查询有关目标文件的信息。

如果您无法访问文件的元数据，例如由于权限错误或损坏的符号链接，这将返回 false。

Examples

use std::path::Path;
assert_eq!(Path::new("./is_a_directory/").is_file(), false);
assert_eq!(Path::new("a_file.txt").is_file(), true);

Run

也可以看看

这是一个方便的函数，可将错误强制为 false。如果要检查错误，请调用 fs::metadata 并处理其 Result。如果是 Ok，则调用 fs::Metadata::is_file。

当目标只是读取 (或写入) 源时，可以读取 (或写入) 最可靠的测试源方法是打开它。

例如，仅使用 is_file 才能中断类似 Unix 的系统上的工作流，例如 diff <( prog_a )。有关更多信息，请参见 fs::File::open 或 fs::OpenOptions::open。

1.5.0 · source

pub fn is_dir(&self) -> bool

如果路径在磁盘上并且指向目录，则返回 true。

该函数将遍历符号链接以查询有关目标文件的信息。

如果您无法访问文件的元数据，例如由于权限错误或损坏的符号链接，这将返回 false。

Examples

use std::path::Path;
assert_eq!(Path::new("./is_a_directory/").is_dir(), true);
assert_eq!(Path::new("a_file.txt").is_dir(), false);

Run

也可以看看

这是一个方便的函数，可将错误强制为 false。如果要检查错误，请调用 fs::metadata 并处理其 Result。如果是 Ok，则调用 fs::Metadata::is_dir。

1.58.0 · source

pub fn is_symlink(&self) -> bool

如果路径存在于磁盘上并且指向符号链接，则返回 true。

这个函数不会遍历符号链接。如果符号链接损坏，这也将返回 true。

如果您无法访问包含该文件的目录，例如，由于权限错误，这将返回 false。

Examples

use std::path::Path;
use std::os::unix::fs::symlink;

let link_path = Path::new("link");
symlink("/origin_does_not_exist/", link_path).unwrap();
assert_eq!(link_path.is_symlink(), true);
assert_eq!(link_path.exists(), false);

Run