afs

The first choice of fs library for Rust

中文

afs Library Function Quick Reference

File Operations

Directory Operations

JSON File Operations

File/Directory Check Functions

File Size and Metadata Functions

System and Disk Functions

Temporary File and Directory Functions

Permission and Link Functions

Path Processing Functions

Hash Functions

Quick Find by Category

📁 File I/O

• Read: read_file
• Write: write_file, write_file_sync
• Append: append_file, append_file_sync
• Create: create_file_sync
• Delete: unlink_sync

📂 Directory Operations

• Create: mkdir, mkdir_sync
• Remove: rmdir, rmdir_sync

🔍 Existence Checks

• Files: file_exists, is_file, is_file_sync
• Directories: dir_exists, is_dir, is_dir_sync
• Symlinks: is_symlink, is_symlink_sync
• General: exists, exists_sync

📊 Size and Information

• File size: get_file_size, get_file_real_size
• Directory size: get_dir_size
• Metadata: stat, stat_sync
• Disk usage: diskusage

🛣️ Path Processing

• Normalize: normalize_path, get_filepath
• Resolve: resolve
• Extract: basename, filename, dirname

🔧 System Functions

• Temporary files: mktempdir, mktempfile
• Permissions: chmod_sync
• Links: soft_link
• Command lookup: which
• Hashing: hash, hash_sync

📋 JSON Operations

• Read: read_json, read_from_json
• Write: write_to_json

Usage Guide

Async vs Sync

• Functions with _sync suffix are synchronous versions
• Functions without suffix are usually asynchronous (require .await)
• Selection guidelines:
  • Use async versions in async environments
  • Use sync versions in sync environments or simple scripts

Error Handling

• Most functions return AnyResult<T>, requiring error handling
• Check functions (like exists, is_file, etc.) return bool directly

Path Format

• Cross-platform path support (auto-handles Windows and Unix separators)
• normalize_path can unify path format

Example Usage

use afs::*;

// Async file operations
async fn example() -> AnyResult<()> {
    // Read file
    let content = read_file("test.txt").await?;

    // Write file
    write_file("output.txt", &content).await?;

    // Check if file exists
    if file_exists("output.txt").await {
        println!("File created successfully");
    }

    // Get file size
    let size = get_file_size("output.txt").await?;
    println!("File size: {} bytes", size);

    Ok(())
}

// Sync operations
fn sync_example() -> AnyResult<()> {
    // Create directory
    mkdir_sync("new_dir")?;

    // Create file
    create_file_sync("new_dir/test.txt")?;

    // Write content
    write_file_sync("new_dir/test.txt", "Hello, World!")?;

    // Get path information
    let dir = dirname("new_dir/test.txt")?;
    let name = basename("new_dir/test.txt")?;

    println!("Directory: {}, Filename: {}", dir, name);

    Ok(())
}