Question

在许多编程语言中，通过在bitwise and和0111之间执行mode bits，可以找到文件是否可执行，如：

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表现不像预期，因为它总是返回正数。我在Go中尝试了类似的代码，它非常直接：

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

如何用Rust做到这一点？

Answer 1

在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

Answer 2

您已关闭，您将要使用此功能（为简洁起见，我在示例中使用unwrap()）：

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

由于some code而归功于我之前的工作。

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

2 个答案: