如何在 Rust 中使用按位运算检查文件是否可执行？

Question

在许多编程语言中，可以通过执行 bitwise and between the mode bits 和 0111 来确定文件是否可执行，例如：

is_exec = (mode & 0111) != 0

其中 mode 表示具有类似于 100755 或 755.

的八进制值的模式位

命令行示例：

perl -e 'printf "%o\n", (stat "file")[2] & 0111'

我正在尝试使用 Rust 遵循这种方法，但无法使其工作，这是我正在使用的代码：

fn print_dir(path: &PathBuf) {                                                                                                                                            
    let files = match fs::read_dir(&path) {                                                                                                                               
        Err(f) => {                                                                                                                                                       
            println!("{}", f);                                                                                                                                            
            return;                                                                                                                                                       
        }                                                                                                                                                                 
        Ok(f) => f                                                                                                                                                        
    };                                                                                                                                                                    

    for f in files {                                                                                                                                                      
        let file = f.unwrap();                                                                                                                                            
        let mode = file.metadata().unwrap().permissions().mode();                                                                                                         
        println!("path: {} {:o} - {} {:0}", file.path().display(), mode, mode, mode & 0111);                                                                              
    }                                                                                                                                                                     
}

mode & 0111 没有像预期的那样表现，因为它总是 returns 积极。我在 Go 中尝试了类似的代码，它非常简单：

var is_exec bool
if m := f.Mode(); !m.IsDir() && m&0111 != 0 {
    is_exec = true
}

知道如何用 Rust 做到这一点吗？

Answer 1

你很接近，你会想要使用这个（为了简洁，我在示例中使用 unwrap()）：

let mode = fs::metadata(&f).unwrap().mode();
if mode & 0o111 != 0 {
    println!("binary...");
}

归功于 some code 我前一段时间工作过。

Answer 2

在 Rust 中，前导 0 并不意味着数字是八进制的。您想要使用前缀 0o 代替：

fn main() {
    println!("{}", 0111);  // 111
    println!("{}", 0o111); //  73
}

Other prefixes您可能感兴趣：

0xBEEF // Hex    (Base 16) => 48879
0o1234 // Octal  (Base  8) =>   668
0b0101 // Binary (Base  2) =>     5

如何在 Rust 中使用按位运算检查文件是否可执行？

How to check if file is executable using bitwise operations in Rust?

file-permissions

bitwise-operators

rust