impl DirEntry

fn path(self: &Self) -> PathBuf

Returns the full path to the file that this entry represents.

The full path is created by joining the original path to read_dir with the filename of this entry.

Examples

use std::fs;

fn main() -> std::io::Result<()> {
    for entry in fs::read_dir(".")? {
        let dir = entry?;
        println!("{:?}", dir.path());
    }
    Ok(())
}

This prints output like:

"./whatever.txt"
"./foo.html"
"./hello_world.rs"

The exact text, of course, depends on what files you have in ..

fn metadata(self: &Self) -> io::Result<Metadata>

Returns the metadata for the file that this entry points at.

This function will not traverse symlinks if this entry points at a symlink. To traverse symlinks use fs::metadata or fs::File::metadata.

Platform-specific behavior

On Windows this function is cheap to call (no extra system calls needed), but on Unix platforms this function is the equivalent of calling symlink_metadata on the path.

Examples

use std::fs;

if let Ok(entries) = fs::read_dir(".") {
    for entry in entries {
        if let Ok(entry) = entry {
            // Here, `entry` is a `DirEntry`.
            if let Ok(metadata) = entry.metadata() {
                // Now let's show our entry's permissions!
                println!("{:?}: {:?}", entry.path(), metadata.permissions());
            } else {
                println!("Couldn't get metadata for {:?}", entry.path());
            }
        }
    }
}

fn file_type(self: &Self) -> io::Result<FileType>

Returns the file type for the file that this entry points at.

This function will not traverse symlinks if this entry points at a symlink.

Platform-specific behavior

On Windows and most Unix platforms this function is free (no extra system calls needed), but some Unix platforms may require the equivalent call to symlink_metadata to learn about the target file type.

Examples

use std::fs;

if let Ok(entries) = fs::read_dir(".") {
    for entry in entries {
        if let Ok(entry) = entry {
            // Here, `entry` is a `DirEntry`.
            if let Ok(file_type) = entry.file_type() {
                // Now let's show our entry's file type!
                println!("{:?}: {:?}", entry.path(), file_type);
            } else {
                println!("Couldn't get file type for {:?}", entry.path());
            }
        }
    }
}

fn file_name(self: &Self) -> OsString

Returns the file name of this directory entry without any leading path component(s).

As an example, the output of the function will result in "foo" for all the following paths:

• "./foo"
• "/the/foo"
• "../../foo"

Examples

use std::fs;

if let Ok(entries) = fs::read_dir(".") {
    for entry in entries {
        if let Ok(entry) = entry {
            // Here, `entry` is a `DirEntry`.
            println!("{:?}", entry.file_name());
        }
    }
}

impl Debug for DirEntry

fn fmt(self: &Self, f: &mut fmt::Formatter<'_>) -> fmt::Result

impl DirEntryExt for fs::DirEntry

fn ino(self: &Self) -> u64

impl DirEntryExt for fs::DirEntry

fn ino(self: &Self) -> u64

impl DirEntryExt2 for fs::DirEntry

fn file_name_ref(self: &Self) -> &OsStr

impl Freeze for DirEntry

impl RefUnwindSafe for DirEntry

impl Send for DirEntry

impl Sync for DirEntry

impl Unpin for DirEntry

impl UnwindSafe for DirEntry

impl<T> Any for DirEntry

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for DirEntry

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for DirEntry

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> From for DirEntry

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for DirEntry

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for DirEntry

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for DirEntry

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>