mkdir 命令详解#

mkdir（make directory）是 Linux 系统中用于创建目录的命令，是最基本、最常用的目录操作命令之一。它可以创建单个目录、嵌套目录，以及设置目录权限。

入门#

基本用法#

# 创建单个目录
mkdir directory

# 创建多个目录
mkdir directory1 directory2

# 创建嵌套目录
mkdir -p parent/child/grandchild

# 创建目录并设置权限
mkdir -m 755 directory

常用选项#

选项	说明
`-p`	递归创建目录，必要时创建父目录
`-m`	设置目录的权限模式
`-v`	显示创建目录的详细信息
`-Z`	设置 SELinux 安全上下文
`--help`	显示帮助信息
`--version`	显示版本信息

基本示例#

# 创建单个目录
mkdir test

# 创建多个目录
mkdir dir1 dir2 dir3

# 创建嵌套目录
mkdir -p a/b/c

# 创建目录并设置权限
mkdir -m 755 public

# 显示创建过程
mkdir -v test
# 输出: mkdir: created directory 'test'

中级#

高级用法#

# 创建带空格的目录
mkdir "My Directory"

# 创建带特殊字符的目录
mkdir My\ Directory\[1\]

# 创建日期命名的目录
mkdir $(date +%Y-%m-%d)

# 创建权限为 777 的目录
mkdir -m 777 shared

# 创建多个嵌套目录
mkdir -p dir1/{subdir1,subdir2,subdir3}

# 创建目录结构
mkdir -p project/{src,tests,docs,bin}

组合选项#

# 递归创建并显示详细信息
mkdir -pv a/b/c

# 递归创建并设置权限
mkdir -pm 755 a/b/c

# 创建多个目录结构
mkdir -p {dir1,dir2,dir3}/{subdir1,subdir2}

# 创建带时间戳的目录
mkdir -p backup/$(date +%Y/%m/%d)

# 创建用户主目录结构
mkdir -p ~/Documents/{Work,Personal,Projects}

脚本集成#

# 目录创建脚本
#!/bin/bash

function create_directory() {
    local dir="$1"
    local permissions="$2"
    
    if [ -z "$dir" ]; then
        echo "Usage: create_directory <directory> [permissions]"
        return 1
    fi
    
    if [ -d "$dir" ]; then
        echo "Directory already exists: $dir"
        return 0
    fi
    
    if [ -n "$permissions" ]; then
        mkdir -p -m "$permissions" "$dir"
    else
        mkdir -p "$dir"
    fi
    
    if [ $? -eq 0 ]; then
        echo "Created directory: $dir"
        if [ -n "$permissions" ]; then
            echo "Permissions: $permissions"
        fi
    else
        echo "Error creating directory: $dir"
        return 1
    fi
}

# 项目结构创建脚本
#!/bin/bash

function create_project() {
    local name="$1"
    local dir="$2"
    
    if [ -z "$name" ]; then
        echo "Usage: create_project <name> [directory]"
        return 1
    fi
    
    if [ -z "$dir" ]; then
        dir=$(pwd)
    fi
    
    local project_dir="$dir/$name"
    
    echo "Creating project structure for: $name"
    echo "=================================="
    
    # 创建目录结构
    mkdir -p "$project_dir/src"
    mkdir -p "$project_dir/tests"
    mkdir -p "$project_dir/docs"
    mkdir -p "$project_dir/bin"
    mkdir -p "$project_dir/config"
    
    # 创建初始文件
    touch "$project_dir/README.md"
    touch "$project_dir/.gitignore"
    
    echo "=================================="
    echo "Project structure created at: $project_dir"
    ls -la "$project_dir"
}

# 备份目录创建脚本
#!/bin/bash

function create_backup_dir() {
    local base_dir="$1"
    
    if [ -z "$base_dir" ]; then
        base_dir="$HOME/backup"
    fi
    
    local backup_dir="$base_dir/$(date +%Y/%m/%d/%H-%M-%S)"
    
    echo "Creating backup directory: $backup_dir"
    mkdir -p "$backup_dir"
    
    if [ $? -eq 0 ]; then
        echo "Backup directory created successfully"
        echo "Directory: $backup_dir"
        return 0
    else
        echo "Error creating backup directory"
        return 1
    fi
}

实用技巧#

# 批量创建目录
for i in {1..10}; do
    mkdir dir$i
done

# 创建带序号的目录
for i in $(seq -w 1 10); do
    mkdir dir$i
done

# 创建日期范围目录
for month in {01..12}; do
    mkdir -p 2026-$month
done

# 创建用户目录
for user in alice bob charlie; do
    mkdir -p /home/$user/{Documents,Downloads,Pictures}
done

# 创建项目环境
mkdir -p project/{dev,staging,prod}/{config,logs,data}

高级#

复杂应用#

# 结合其他命令
mkdir -p $(pwd)/newdir

# 与 find 结合
find . -name "olddir" -type d -exec mkdir -p {}/newdir \;

# 与 grep 结合
ls -la | grep "dir" | awk '{print $9}' | xargs -I {} mkdir -p {}/subdir

# 与 sed 结合
echo "dir1 dir2 dir3" | sed 's/ /\n/g' | xargs mkdir -p

# 与 awk 结合
ls -la | awk '{if ($1 ~ /^d/) print $9}' | xargs -I {} mkdir -p {}/backup

系统管理#

# 创建系统目录
mkdir -p /var/log/app
mkdir -p /opt/app/{bin,lib,conf}

# 创建用户目录结构
mkdir -p /home/user/{bin,lib,src,docs}

# 创建临时目录
mkdir -p /tmp/app/{cache,logs}

# 创建数据目录
mkdir -p /data/{db,files,backups}

# 创建配置目录
mkdir -p /etc/app/{conf.d,ssl,modules}

自动化脚本#

# 目录结构检查脚本
#!/bin/bash

function check_directory_structure() {
    local base_dir="$1"
    
    if [ -z "$base_dir" ]; then
        base_dir=$(pwd)
    fi
    
    echo "Checking directory structure for: $base_dir"
    echo "=================================="
    
    # 检查必要目录
    local required_dirs=(
        "src"
        "tests"
        "docs"
        "bin"
        "config"
    )
    
    for dir in "${required_dirs[@]}"; do
        if [ -d "$base_dir/$dir" ]; then
            echo "✓ Directory exists: $dir"
        else
            echo "✗ Directory missing: $dir"
            echo "Creating directory: $dir"
            mkdir -p "$base_dir/$dir"
        fi
    done
    
    echo "=================================="
    echo "Directory structure check completed"
}

# 批量目录创建脚本
#!/bin/bash

function batch_create_dirs() {
    local pattern="$1"
    local count="$2"
    
    if [ -z "$pattern" ] || [ -z "$count" ]; then
        echo "Usage: batch_create_dirs <pattern> <count>"
        return 1
    fi
    
    echo "Creating $count directories with pattern: $pattern"
    echo "=================================="
    
    for i in $(seq -w 1 "$count"); do
        local dir_name=$(echo "$pattern" | sed "s/%d/$i/")
        mkdir -p "$dir_name"
        echo "Created: $dir_name"
    done
    
    echo "=================================="
    echo "Batch directory creation completed"
}

# 目录权限设置脚本
#!/bin/bash

function setup_directory_permissions() {
    local base_dir="$1"
    
    if [ -z "$base_dir" ]; then
        base_dir=$(pwd)
    fi
    
    echo "Setting up directory permissions for: $base_dir"
    echo "=================================="
    
    # 创建目录结构
    mkdir -p "$base_dir/{public,private,logs,tmp}"
    
    # 设置权限
    chmod 755 "$base_dir/public"
    chmod 700 "$base_dir/private"
    chmod 755 "$base_dir/logs"
    chmod 1777 "$base_dir/tmp"  # sticky bit
    
    echo "Permissions set:"
    ls -la "$base_dir"
    
    echo "=================================="
    echo "Directory permissions setup completed"
}

与其他工具集成#

# 与 git 结合
git init && mkdir -p {src,tests,docs}

# 与 docker 结合
docker run --rm -v $(pwd):/app alpine mkdir -p /app/{src,tests,docs}

# 与 rsync 结合
rsync -av /source/ /dest/ && mkdir -p /dest/newdir

# 与 scp 结合
mkdir -p ~/backup && scp user@remote:/path/file ~/backup/

# 与 tar 结合
tar -xzf archive.tar.gz && mkdir -p extracted/{src,tests}

大师#

高级技巧#

# 目录结构生成器
function generate_directory_structure() {
    local config_file="$1"
    
    if [ -z "$config_file" ] || [ ! -f "$config_file" ]; then
        echo "Usage: generate_directory_structure <config_file>"
        echo "Config file format: each line is a directory path"
        return 1
    fi
    
    echo "Generating directory structure from: $config_file"
    echo "=================================="
    
    while IFS= read -r line; do
        if [ -n "$line" ] && [[ ! "$line" =~ ^# ]]; then
            mkdir -p "$line"
            echo "Created: $line"
        fi
    done < "$config_file"
    
    echo "=================================="
    echo "Directory structure generation completed"
}

# 递归目录权限修复
function fix_directory_permissions() {
    local base_dir="$1"
    
    if [ -z "$base_dir" ]; then
        base_dir=$(pwd)
    fi
    
    echo "Fixing directory permissions for: $base_dir"
    echo "=================================="
    
    # 设置目录权限为 755
    find "$base_dir" -type d -exec chmod 755 {} \;
    
    # 设置文件权限为 644
    find "$base_dir" -type f -exec chmod 644 {} \;
    
    # 设置脚本权限为 755
    find "$base_dir" -name "*.sh" -type f -exec chmod 755 {} \;
    
    echo "Permissions fixed"
    ls -la "$base_dir"
}

# 目录占用分析
function analyze_directory_usage() {
    local base_dir="$1"
    local max_depth="$2"
    
    if [ -z "$base_dir" ]; then
        base_dir=$(pwd)
    fi
    
    if [ -z "$max_depth" ]; then
        max_depth=2
    fi
    
    echo "Analyzing directory usage for: $base_dir"
    echo "Max depth: $max_depth"
    echo "=================================="
    
    du -h --max-depth="$max_depth" "$base_dir" | sort -hr
    
    echo "=================================="
    echo "Directory usage analysis completed"
}

# 目录同步
function sync_directories() {
    local source="$1"
    local dest="$2"
    
    if [ -z "$source" ] || [ -z "$dest" ]; then
        echo "Usage: sync_directories <source> <dest>"
        return 1
    fi
    
    echo "Syncing directories:"
    echo "Source: $source"
    echo "Destination: $dest"
    echo "=================================="
    
    # 创建目标目录结构
    find "$source" -type d | sed "s|^$source|$dest|" | xargs mkdir -p
    
    # 同步文件
    rsync -av "$source/" "$dest/"
    
    echo "=================================="
    echo "Directory sync completed"
}

大规模目录管理#

# 批量创建用户目录
for user in $(cat users.txt); do
    mkdir -p /home/$user/{Documents,Downloads,Pictures,Music}
    chown -R $user:$user /home/$user
done

# 并行创建目录
ls -la | grep "^d" | awk '{print $9}' | xargs -P 4 -I {} mkdir -p {}/subdir

# 分布式目录创建
find /path -type d -name "project*" | xargs -I {} mkdir -p {}/newdir

# 目录结构复制
find /source -type d | sed "s|^/source|/dest|" | xargs mkdir -p

# 大规模目录迁移
rsync -av /old/path/ /new/path/ && find /new/path -type d | xargs chmod 755

自动化工作流#

# 开发工作流
function dev_workflow() {
    local project="$1"
    local language="$2"
    
    if [ -z "$project" ]; then
        echo "Usage: dev_workflow <project> [language]"
        return 1
    fi
    
    if [ -z "$language" ]; then
        language="python"
    fi
    
    # 创建项目目录
    mkdir -p "$project"
    cd "$project"
    
    echo "Development Workflow"
    echo "Project: $project"
    echo "Language: $language"
    echo "Directory: $(pwd)"
    echo "=================================="
    
    # 创建语言特定的目录结构
    case "$language" in
        "python")
            mkdir -p {src,tests,docs,examples}
            touch setup.py requirements.txt
            ;;
        "nodejs")
            mkdir -p {src,test,docs,examples}
            touch package.json
            ;;
        "java")
            mkdir -p {src/main/java,src/test/java,src/main/resources,docs}
            touch pom.xml
            ;;
        *)
            mkdir -p {src,tests,docs,examples}
            ;;
    esac
    
    # 初始化 git
    git init
    touch .gitignore
    
    echo "=================================="
    echo "Project setup completed"
    ls -la
}

# 数据处理工作流
function data_workflow() {
    local dataset="$1"
    
    if [ -z "$dataset" ]; then
        echo "Usage: data_workflow <dataset>"
        return 1
    fi
    
    # 创建数据目录
    mkdir -p "data/$dataset"
    cd "data/$dataset"
    
    echo "Data Processing Workflow"
    echo "Dataset: $dataset"
    echo "Directory: $(pwd)"
    echo "=================================="
    
    # 创建数据目录结构
    mkdir -p {raw,processed,analyzed,visualizations}
    
    # 创建 README
    touch README.md
    echo "# $dataset" > README.md
    echo "Created: $(date)" >> README.md
    
    echo "=================================="
    echo "Data workflow setup completed"
    ls -la
}

# 系统部署工作流
function deploy_workflow() {
    local app="$1"
    local env="$2"
    
    if [ -z "$app" ] || [ -z "$env" ]; then
        echo "Usage: deploy_workflow <app> <env>"
        return 1
    fi
    
    # 创建部署目录
    mkdir -p "deploy/$app/$env"
    cd "deploy/$app/$env"
    
    echo "Deployment Workflow"
    echo "Application: $app"
    echo "Environment: $env"
    echo "Directory: $(pwd)"
    echo "=================================="
    
    # 创建部署目录结构
    mkdir -p {bin,lib,conf,logs,tmp}
    
    # 创建配置文件
    touch conf/app.conf
    echo "env = $env" > conf/app.conf
    echo "app = $app" >> conf/app.conf
    
    echo "=================================="
    echo "Deployment setup completed"
    ls -la
}

与其他工具集成#

# 与 AWS CLI 结合
aws s3 ls s3://bucket/ | grep "PRE" | awk '{print $2}' | xargs -I {} mkdir -p local/{}

# 与 GCP CLI 结合
gsutil ls gs://bucket/ | grep "/$" | sed 's|gs://bucket/||' | sed 's|/$||' | xargs -I {} mkdir -p local/{}

# 与 Kubernetes 结合
kubectl get pods -o name | xargs -I {} mkdir -p logs/{}

# 与 Docker Compose 结合
docker-compose up -d && mkdir -p {logs,data,conf}

# 与 Terraform 结合
terraform init && mkdir -p {modules,envs,scripts}

无敌#

高级技巧#

# 目录结构模板
function create_from_template() {
    local template="$1"
    local target="$2"
    
    if [ -z "$template" ] || [ -z "$target" ]; then
        echo "Usage: create_from_template <template> <target>"
        return 1
    fi
    
    echo "Creating directory structure from template: $template"
    echo "Target: $target"
    echo "=================================="
    
    # 读取模板文件
    if [ -f "$template" ]; then
        while IFS= read -r line; do
            if [ -n "$line" ] && [[ ! "$line" =~ ^# ]]; then
                dir_path="$target/$line"
                mkdir -p "$dir_path"
                echo "Created: $dir_path"
            fi
        done < "$template"
    else
        echo "Template file not found: $template"
        return 1
    fi
    
    echo "=================================="
    echo "Directory structure created from template"
}

# 目录权限矩阵
function set_permission_matrix() {
    local base_dir="$1"
    
    if [ -z "$base_dir" ]; then
        base_dir=$(pwd)
    fi
    
    echo "Setting permission matrix for: $base_dir"
    echo "=================================="
    
    # 定义权限矩阵
    declare -A permissions=( 
        ["public"]="755"
        ["private"]="700"
        ["group"]="770"
        ["temp"]="1777"
        ["exec"]="755"
        ["data"]="644"
    )
    
    # 创建目录并设置权限
    for dir in "${!permissions[@]}"; do
        dir_path="$base_dir/$dir"
        mkdir -p "$dir_path"
        chmod "${permissions[$dir]}" "$dir_path"
        echo "Created $dir_path with permissions ${permissions[$dir]}"
    done
    
    echo "=================================="
    echo "Permission matrix set"
    ls -la "$base_dir"
}

# 目录同步工具
function sync_dirs() {
    local source="$1"
    local dest="$2"
    local exclude="$3"
    
    if [ -z "$source" ] || [ -z "$dest" ]; then
        echo "Usage: sync_dirs <source> <dest> [exclude]"
        return 1
    fi
    
    echo "Syncing directories:"
    echo "Source: $source"
    echo "Destination: $dest"
    echo "=================================="
    
    # 创建目标目录结构
    find "$source" -type d | sed "s|^$source|$dest|" | xargs mkdir -p
    
    # 同步文件
    if [ -n "$exclude" ]; then
        rsync -av --exclude="$exclude" "$source/" "$dest/"
    else
        rsync -av "$source/" "$dest/"
    fi
    
    echo "=================================="
    echo "Directory sync completed"
}

# 目录备份工具
function backup_dir() {
    local dir="$1"
    local backup_dir="$2"
    
    if [ -z "$dir" ]; then
        dir=$(pwd)
    fi
    
    if [ -z "$backup_dir" ]; then
        backup_dir="$HOME/backup"
    fi
    
    local backup_path="$backup_dir/$(basename "$dir")_$(date +%Y-%m-%d_%H-%M-%S)"
    
    echo "Backing up directory: $dir"
    echo "Backup location: $backup_path"
    echo "=================================="
    
    # 创建备份目录
    mkdir -p "$backup_path"
    
    # 复制目录内容
    cp -r "$dir/" "$backup_path/"
    
    # 压缩备份
    tar -czf "$backup_path.tar.gz" "$backup_path"
    rm -rf "$backup_path"
    
    echo "=================================="
    echo "Directory backup completed"
    echo "Backup file: $backup_path.tar.gz"
}

大规模数据处理#

# 批量创建数据目录
for i in {1..100}; do
    mkdir -p data/batch$i
    echo "Created batch$i"
done

# 并行处理目录
ls -la data | grep "^d" | awk '{print $9}' | xargs -P 8 -I {} sh -c 'echo "Processing: {}"'

# 分布式目录创建
find /path -type d -name "node*" | xargs -I {} mkdir -p {}/data

# 目录结构分析
find /path -type d | wc -l
find /path -type d | sort | uniq | wc -l

# 目录权限审计
find /path -type d -not -perm 755 | wc -l
find /path -type d -not -perm 755 | xargs ls -la

自动化工作流#

# 持续集成工作流
function ci_workflow() {
    local repo="$1"
    local branch="$2"
    
    if [ -z "$repo" ]; then
        echo "Usage: ci_workflow <repo> [branch]"
        return 1
    fi
    
    if [ -z "$branch" ]; then
        branch="main"
    fi
    
    # 创建工作目录
    local work_dir="/tmp/ci_$(date +%s)"
    mkdir -p "$work_dir"
    cd "$work_dir"
    
    echo "CI Workflow"
    echo "Repository: $repo"
    echo "Branch: $branch"
    echo "Work directory: $(pwd)"
    echo "=================================="
    
    # 克隆仓库
    git clone "$repo" .
    git checkout "$branch"
    
    # 创建构建目录
    mkdir -p build
    
    # 构建项目
    echo "Building project..."
    # 执行构建命令
    
    # 运行测试
    echo "Running tests..."
    # 执行测试命令
    
    echo "=================================="
    echo "CI Workflow completed"
}

# 数据科学工作流
function data_science_workflow() {
    local dataset="$1"
    local analysis="$2"
    
    if [ -z "$dataset" ]; then
        echo "Usage: data_science_workflow <dataset> [analysis]"
        return 1
    fi
    
    if [ -z "$analysis" ]; then
        analysis="exploratory"
    fi
    
    # 创建工作目录
    local work_dir="/tmp/data_science_$(date +%s)"
    mkdir -p "$work_dir"
    cd "$work_dir"
    
    echo "Data Science Workflow"
    echo "Dataset: $dataset"
    echo "Analysis: $analysis"
    echo "Work directory: $(pwd)"
    echo "=================================="
    
    # 创建目录结构
    mkdir -p {data,scripts,models,visualizations,reports}
    
    # 下载数据
    echo "Downloading data..."
    # 执行数据下载命令
    
    # 运行分析
    echo "Running analysis..."
    # 执行分析命令
    
    echo "=================================="
    echo "Data Science Workflow completed"
}

# 系统管理工作流
function sysadmin_workflow() {
    local task="$1"
    local target="$2"
    
    if [ -z "$task" ]; then
        echo "Usage: sysadmin_workflow <task> [target]"
        return 1
    fi
    
    if [ -z "$target" ]; then
        target="localhost"
    fi
    
    # 创建工作目录
    local work_dir="/tmp/sysadmin_$(date +%s)"
    mkdir -p "$work_dir"
    cd "$work_dir"
    
    echo "System Administration Workflow"
    echo "Task: $task"
    echo "Target: $target"
    echo "Work directory: $(pwd)"
    echo "=================================="
    
    # 创建目录结构
    mkdir -p {logs,config,scripts,backups}
    
    # 执行任务
    echo "Executing task..."
    # 执行系统管理命令
    
    echo "=================================="
    echo "System Administration Workflow completed"
}

性能调优#

# 监控 mkdir 命令性能
time mkdir -p a/b/c
time mkdir -p {1..100}
time mkdir -p {1..1000}

# 批量创建优化
seq 100 | xargs -P 4 -I {} mkdir -p dir{}

# 减少系统调用
function fast_mkdir() {
    mkdir -p -- "$@"
}

# 并行目录创建
ls -la | grep "^d" | awk '{print $9}' | xargs -P 8 -I {} mkdir -p {}/subdir

# 缓存目录结构
DIR_STRUCTURE="a/b/c d/e/f g/h/i"
echo "$DIR_STRUCTURE" | tr ' ' '\n' | xargs mkdir -p

高级应用场景#

# 容器管理
function docker_mkdir() {
    local container="$1"
    local dir="$2"
    
    if [ -z "$container" ] || [ -z "$dir" ]; then
        echo "Usage: docker_mkdir <container> <directory>"
        return 1
    fi
    
    # 在容器内创建目录
    docker exec "$container" mkdir -p "$dir"
    echo "Created directory $dir in container $container"
}

# 虚拟机管理
function vm_mkdir() {
    local vm="$1"
    local dir="$2"
    
    if [ -z "$vm" ] || [ -z "$dir" ]; then
        echo "Usage: vm_mkdir <vm> <directory>"
        return 1
    fi
    
    # 在虚拟机内创建目录
    virsh domifaddr "$vm" | grep -oP '\d+\.\d+\.\d+\.\d+' | xargs -I {} ssh user@{} mkdir -p "$dir"
    echo "Created directory $dir in VM $vm"
}

# 云服务管理
function cloud_mkdir() {
    local instance="$1"
    local dir="$2"
    
    if [ -z "$instance" ] || [ -z "$dir" ]; then
        echo "Usage: cloud_mkdir <instance> <directory>"
        return 1
    fi
    
    # 在云实例内创建目录
    aws ec2-instance-connect send-ssh-public-key --instance-id "$instance" --availability-zone us-east-1a --instance-os-user ec2-user --ssh-public-key file://~/.ssh/id_rsa.pub
    ssh ec2-user@$(aws ec2 describe-instances --instance-ids "$instance" --query 'Reservations[0].Instances[0].PublicIpAddress' --output text) mkdir -p "$dir"
    echo "Created directory $dir in instance $instance"
}

# 网络文件系统管理
function nfs_mkdir() {
    local mount_point="$1"
    local dir="$2"
    
    if [ -z "$mount_point" ] || [ -z "$dir" ]; then
        echo "Usage: nfs_mkdir <mount_point> <directory>"
        return 1
    fi
    
    # 在 NFS 挂载点创建目录
    if mount | grep "$mount_point" | grep -q nfs; then
        mkdir -p "$mount_point/$dir"
        echo "Created directory $dir in NFS mount $mount_point"
    else
        echo "Error: Not an NFS mount point: $mount_point"
        return 1
    fi
}

最佳实践#

1. 使用场景#

创建单个或多个目录
创建嵌套目录结构
设置目录权限
脚本和自动化
系统管理

2. 性能优化#

3. 错误处理#

检查目录是否存在
处理权限问题
提供有意义的错误信息
使用 try-catch 模式

4. 脚本集成#

使用子shell避免影响当前目录
保存和恢复当前目录
处理目录不存在的情况
添加日志和调试信息

5. 学习路径#

先掌握基本目录创建
学习嵌套目录创建
掌握权限设置
学习脚本集成
最后学习自动化工作流

常见问题#

Q: 如何创建嵌套目录？#

A: 使用 mkdir -p 命令，例如 mkdir -p a/b/c。

Q: 如何同时创建多个目录？#

A: 在 mkdir 命令后列出多个目录名，例如 mkdir dir1 dir2 dir3。

Q: 如何创建目录时设置权限？#

A: 使用 -m 选项，例如 mkdir -m 755 dir。

Q: 如何创建带空格的目录名？#

A: 使用引号包裹目录名，例如 mkdir "My Directory"。

Q: 如何批量创建目录结构？#

A: 使用大括号扩展，例如 mkdir -p project/{src,tests,docs}。

mkdir 命令详解#

入门#

基本用法#

常用选项#

基本示例#

中级#

高级用法#

组合选项#

脚本集成#

实用技巧#

高级#

复杂应用#

系统管理#

自动化脚本#

与其他工具集成#

大师#

高级技巧#

大规模目录管理#

自动化工作流#

与其他工具集成#

无敌#

高级技巧#

大规模数据处理#

自动化工作流#

性能调优#

高级应用场景#

最佳实践#

1. 使用场景#

2. 性能优化#

3. 错误处理#

4. 脚本集成#

5. 学习路径#

常见问题#

Q: 如何创建嵌套目录？#

Q: 如何同时创建多个目录？#

Q: 如何创建目录时设置权限？#

Q: 如何创建带空格的目录名？#

Q: 如何批量创建目录结构？#

相关命令#