Linux 进程控制实战：微型 Shell 命令行解释器实现

代码实现（提示符模块）：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

// 全局变量：存储当前工作目录（避免频繁分配内存）
#define BUF_SIZE 1024
char g_pwd[BUF_SIZE] = {0};
char g_last_pwd[BUF_SIZE] = {0};// 存储上次工作目录，用于 cd -

// 1. 获取用户名
static char* get_username() {
    char* username = getenv("USER");
    return (username == NULL) ? "unknown" : username;
}

// 2. 获取主机名
static char* get_hostname() {
    char* hostname = getenv("HOSTNAME");
    return (hostname == NULL) ? "unknown-host" : hostname;
}

// 3. 获取当前工作目录（并更新 PWD 环境变量）
static char* get_current_dir() {
    if (getcwd(g_pwd, BUF_SIZE) == NULL) {
        perror("getcwd failed");
        return "unknown-dir";
    }
    // 更新环境变量 PWD（确保 echo $PWD 能显示正确路径）
    static char pwd_env[BUF_SIZE] = {0};
    snprintf(pwd_env, BUF_SIZE, "PWD=%s", g_pwd);
    putenv(pwd_env); // putenv 修改当前进程的环境变量
    return g_pwd;
}

// 4. 简化工作目录（只显示最后一级）
static char* simplify_dir(char* full_dir) {
    if (full_dir == NULL || strcmp(full_dir, "/") == 0) {
        return "/"; // 根目录直接返回 /
    }
    // 逆序查找最后一个/（如/home/ubuntu/myshell → 找到最后一个/，返回 myshell）
    char* last_slash = strrchr(full_dir, '/');
    return (last_slash == NULL) ? full_dir : (last_slash + 1);
}

// 5. 打印命令行提示符
void print_prompt() {
    char* username = get_username();
    char* hostname = get_hostname();
    char* full_dir = get_current_dir();
    char* simple_dir = simplify_dir(full_dir);
    // 格式：[用户名@主机名 简化目录]$ 
    printf("[%s@%s %s]$ ", username, hostname, simple_dir);
    fflush(stdout); // 强制刷新缓冲区，确保提示符立即显示
}

效果演示：

调用 print_prompt() 后，终端会显示类似：

[ubuntu@localhost myshell]$ 

2.2 模块 2：命令获取与解析——把'字符串'变成'可执行指令'

用户输入的命令是'字符串'（如 ls -l /home），我们需要将其拆分为'命令名 + 参数数组'（如 ["ls", "-l", "/home", NULL]），才能传给 execvp 执行。这一步分两个子任务：

子任务 1：获取用户输入（用 fgets 而非 scanf）

• scanf 的问题：遇到空格就停止读取，无法获取带空格的命令（如 echo "hello world"）；
• fgets 的优势：读取一整行输入，包含空格，完美适配命令输入场景；
• 处理细节：fgets 会把用户输入的'回车符 \n'也读入，需将其替换为字符串结束符 \0；若输入为空行（只按回车），直接跳过。

子任务 2：解析命令（用 strtok 按空格拆分）

strtok 是 C 标准库的字符串拆分函数，能按指定分隔符（这里是空格）拆分字符串：

• 第一次调用：strtok(command, " ")，传入要拆分的命令字符串，返回第一个'非空格'的子串（命令名）；
• 后续调用：strtok(NULL, " ")，传入 NULL 表示'继续拆分上次的字符串'，直到返回 NULL（拆分结束）；
• 注意：拆分后的参数数组最后必须加 NULL，因为 execvp 要求参数数组以 NULL 结尾。

代码实现（命令获取与解析模块）：

#include <ctype.h> // 包含 isspace 函数

// 全局变量：存储命令参数（命令名 + 参数，最后以 NULL 结尾）
#define ARGV_MAX 64
char* g_argv[ARGV_MAX] = {0};
int g_argc = 0; // 命令参数个数（包含命令名）

// 1. 去除字符串前后的空格（避免空参数，如" ls -l " → "ls -l"）
static void trim_space(char* str) {
    if (str == NULL) return;
    // 去除前面的空格
    char* start = str;
    while (isspace(*start)) start++;
    // 去除后面的空格
    char* end = str + strlen(str) - 1;
    while (end >= start && isspace(*end)) end--;
    // 给字符串加结束符 *(end + 1) = '\0';
    // 移动字符串（覆盖前面的空格）
    memmove(str, start, end - start + 2); // +2：包含 end+1 的 \0
}

// 2. 获取用户输入的命令
int get_command(char* command_buf, int buf_size) {
    // 读取一行命令（fgets 会读入 \n）
    if (fgets(command_buf, buf_size, stdin) == NULL) {
        // 若用户按 Ctrl+D（EOF），返回 -1 表示退出
        printf("\n");
        return -1;
    }
    // 去除换行符（将 \n 替换为 \0）
    command_buf[strcspn(command_buf, "\n")] = '\0';
    // 去除前后空格
    trim_space(command_buf);
    // 处理空行（用户只按了回车）
    if (strlen(command_buf) == 0) {
        return 0;
    }
    return 1; // 成功获取有效命令
}

// 3. 解析命令（拆分为 g_argv 数组）
void parse_command(char* command_buf) {
    // 重置全局变量（避免上次命令的残留）
    memset(g_argv, 0, sizeof(g_argv));
    g_argc = 0;
    // 第一次拆分：获取命令名
    char* token = strtok(command_buf, " ");
    while (token != NULL && g_argc < ARGV_MAX - 1) {
        // 留一个位置放 NULL
        g_argv[g_argc++] = token;
        // 后续拆分：获取参数
        token = strtok(NULL, " ");
    }
    g_argv[g_argc] = NULL; // 参数数组必须以 NULL 结尾
}

// 调试用：打印解析后的参数（可选）
void debug_print_argv() {
    printf("解析结果：argc=%d\n", g_argc);
    for (int i = 0; i < g_argc; i++) {
        printf("argv[%d] = %s\n", i, g_argv[i]);
    }
}

效果演示：

用户输入 ls -l /home，解析后：

• g_argc = 3；
• g_argv = ["ls", "-l", "/home", NULL]。

2.3 模块 3：内建命令处理——Shell'自己动手'的命令

内建命令（Built-in Command）是必须由 Shell 进程自身执行的命令，因为它们需要修改 Shell 的'自身状态'（如 cd 修改工作目录、export 修改环境变量）—— 若用子进程执行，修改的是子进程的状态，父进程（Shell）的状态不会变（进程具有独立性）。

迷你 Shell 将实现 4 个核心内建命令：cd、export、env、echo，我们逐个实现。

3.3.1 内建命令 1：cd——切换工作目录

cd 的核心是调用 chdir 系统函数修改当前进程的工作目录，但需要处理特殊场景：

• cd（无参数）：切换到用户家目录（getenv("HOME")）；
• cd ~：同无参数，切换到家目录；
• cd -：切换到'上次的工作目录'（需用 g_last_pwd 存储上次目录）；
• cd 目录路径：切换到指定目录（如 cd /home）。

3.3.2 内建命令 2：export——导出环境变量

export 的作用是'将变量添加到当前进程的环境变量表中'，供后续执行的命令继承（如 export MY_VAR=123）：

• 实现方式：用 putenv 函数（C 标准库），将'KEY=VALUE'格式的字符串添加到环境变量表；
• 注意：export 无参数时，可打印所有已导出的环境变量（可选功能）。

3.3.3 内建命令 3：env——打印所有环境变量

env 的作用是'打印当前进程的所有环境变量'，实现方式是遍历全局环境变量数组 environ（extern char **environ），逐个打印每个环境变量（格式为'KEY=VALUE'）。

3.3.4 内建命令 4：echo——打印内容或环境变量

echo 支持三种场景：

• echo 文本：直接打印文本（如 echo hello → 输出 hello）；
• echo $环境变量：打印指定环境变量的值（如 echo $PATH → 输出 /bin:/usr/bin）；
• echo $?：打印'上次命令的退出码'（需用全局变量 g_last_code 存储）。

代码实现（内建命令模块）：

#include <sys/wait.h>

// 全局变量：存储上次命令的退出码（供 echo $? 使用）
int g_last_code = 0;

// 全局变量：存储环境变量表（从父进程继承）
extern char** environ;

// 1. 判断是否为内建命令（返回 1=是，0=否）
int is_builtin_command() {
    if (g_argc == 0 || g_argv[0] == NULL) return 0;
    // 支持的内建命令列表
    const char* builtin_list[] = {"cd", "export", "env", "echo", NULL};
    for (int i = 0; builtin_list[i] != NULL; i++) {
        if (strcmp(g_argv[0], builtin_list[i]) == 0) {
            return 1;
        }
    }
    return 0;
}

// 2. 执行内建命令 cd
static void exec_cd() {
    char* target_dir = NULL;
    // 保存当前目录（用于 cd -）
    strncpy(g_last_pwd, g_pwd, BUF_SIZE);
    // 处理不同参数场景
    if (g_argc == 1) {
        // cd 无参数 → 切换到家目录
        target_dir = getenv("HOME");
    } else if (strcmp(g_argv[1], "~") == 0) {
        // cd ~ → 切换到家目录
        target_dir = getenv("HOME");
    } else if (strcmp(g_argv[1], "-") == 0) {
        // cd - → 切换到上次目录
        target_dir = g_last_pwd;
        printf("%s\n", target_dir); // 模仿 bash，打印切换后的目录
    } else {
        // cd 目录路径 → 切换到指定目录
        target_dir = g_argv[1];
    }
    // 调用 chdir 切换目录
    if (chdir(target_dir) == -1) {
        perror("cd failed");
        g_last_code = 1; // 退出码设为 1（表示失败）
    } else {
        g_last_code = 0; // 退出码设为 0（表示成功）
    }
}

// 3. 执行内建命令 export
static void exec_export() {
    if (g_argc != 2) {
        // 参数错误（如 export 无参数或多参数）
        fprintf(stderr, "用法：export KEY=VALUE\n");
        g_last_code = 2;
        return;
    }
    // 检查参数格式（必须包含=，如 MY_VAR=123）
    if (strchr(g_argv[1], '=') == NULL) {
        fprintf(stderr, "错误：export 参数必须包含'='\n");
        g_last_code = 2;
        return;
    }
    // 调用 putenv 添加环境变量
    if (putenv(g_argv[1]) != 0) {
        perror("export failed");
        g_last_code = 1;
    } else {
        g_last_code = 0;
    }
}

// 4. 执行内建命令 env
static void exec_env() {
    // 遍历 environ 数组，打印所有环境变量
    for (int i = 0; environ[i] != NULL; i++) {
        printf("%s\n", environ[i]);
    }
    g_last_code = 0;
}

// 5. 执行内建命令 echo
static void exec_echo() {
    if (g_argc < 2) {
        // echo 无参数 → 打印空行
        printf("\n");
        g_last_code = 0;
        return;
    }
    char* content = g_argv[1];
    if (content[0] == '$') {
        // 场景 1：echo $变量（如$PATH、$?）
        if (strcmp(content, "?$") == 0) {
            // echo $? → 打印上次命令的退出码
            printf("%d\n", g_last_code);
        } else {
            // echo $环境变量 → 打印环境变量的值
            char* var_name = content + 1; // 跳过$，取变量名（如$PATH → PATH）
            char* var_value = getenv(var_name);
            if (var_value != NULL) {
                printf("%s\n", var_value);
            }
            // 变量不存在时，不打印（模仿 bash）
        }
    } else {
        // 场景 2：echo 文本 → 打印文本（支持多参数，如 echo hello world）
        for (int i = 1; i < g_argc; i++) {
            printf("%s ", g_argv[i]);
        }
        printf("\n");
    }
    g_last_code = 0;
}

// 6. 统一执行内建命令
void exec_builtin_command() {
    if (strcmp(g_argv[0], "cd") == 0) {
        exec_cd();
    } else if (strcmp(g_argv[0], "export") == 0) {
        exec_export();
    } else if (strcmp(g_argv[0], "env") == 0) {
        exec_env();
    } else if (strcmp(g_argv[0], "echo") == 0) {
        exec_echo();
    }
}

2.4 模块 4：外部命令执行——Shell'找帮手'的命令

外部命令（如 ls/ps/gcc）是'独立的可执行程序'，需要 Shell 创建子进程执行（避免覆盖 Shell 自身代码），核心流程是：

1. fork 创建子进程；
2. 子进程用 execvp 替换为目标程序（自动从 PATH 查找命令路径）；
3. 父进程用 waitpid 等待子进程退出，获取退出码（更新 g_last_code）；
4. 若 execvp 失败（如命令不存在），子进程退出并设置错误退出码。

代码实现（外部命令模块）：

void exec_external_command() {
    pid_t pid = fork();
    if (pid == -1) {
        // fork 失败（如系统进程过多）
        perror("fork failed");
        g_last_code = 1;
        return;
    }
    if (pid == 0) {
        // 子进程：执行外部命令
        execvp(g_argv[0], g_argv);
        // 只有 execvp 失败时，才会执行到这里（成功则子进程代码被覆盖）
        perror("command not found");
        exit(127); // 退出码 127：标准的'命令未找到'错误码
    } else {
        // 父进程：等待子进程退出，获取退出码
        int status;
        waitpid(pid, &status, 0); // 阻塞等待子进程
        // 解析子进程的退出状态，更新 g_last_code
        if (WIFEXITED(status)) {
            // 正常退出：获取退出码
            g_last_code = WEXITSTATUS(status);
        } else if (WIFSIGNALED(status)) {
            // 被信号终止（如 Ctrl+C → SIGINT，kill -9 → SIGKILL）
            g_last_code = 128 + WTERMSIG(status); // 符合 Linux 标准（如 128+2=130）
        }
    }
}

效果演示：

用户输入 ls -l，执行流程：

1. Shell 判断 ls 是外部命令，fork 子进程；
2. 子进程调用 execvp("ls", ["ls", "-l", NULL])，从 PATH 找到 /bin/ls，替换为 ls 程序；
3. ls 执行完毕后退出，父进程 waitpid 获取退出码（0 表示成功）；
4. g_last_code 更新为 0，下次执行 echo $? 会输出 0。

2.5 模块 5：环境变量初始化——继承父进程的'配置'

Shell 启动时，需要继承父进程的环境变量（如 PATH/HOME/USER），这些环境变量存储在全局数组 environ 中（无需手动定义，只需用 extern 声明）。我们可以在 Shell 启动时，打印关键环境变量（可选），确保继承正常。

代码实现（环境变量初始化）：

// 初始化环境变量（打印关键变量，验证继承）
void init_env() {
    printf("=== 迷你 Shell 启动 ===");
    // 打印关键环境变量（可选，用于调试）
    char* path = getenv("PATH");
    char* home = getenv("HOME");
    char* user = getenv("USER");
    if (path != NULL) printf("\nPATH: %s", path);
    if (home != NULL) printf("\nHOME: %s", home);
    if (user != NULL) printf("\nUSER: %s", user);
    printf("\n====================\n\n");
    // 初始化上次工作目录（启动时的当前目录）
    get_current_dir();
    strncpy(g_last_pwd, g_pwd, BUF_SIZE);
}

三、迷你 Shell 完整源码与运行演示

将上述模块整合为完整代码（mini_shell.c），添加 main 函数实现'无限循环'的核心逻辑，再编译运行验证功能。

3.1 完整源码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/wait.h>

// 全局常量定义
#define BUF_SIZE 1024 // 命令缓冲区大小
#define ARGV_MAX 64 // 命令参数最大个数

// 全局变量定义
char g_pwd[BUF_SIZE] = {0}; // 当前工作目录
char g_last_pwd[BUF_SIZE] = {0}; // 上次工作目录（用于 cd -）
char* g_argv[ARGV_MAX] = {0}; // 命令参数数组
int g_argc = 0; // 命令参数个数
int g_last_code = 0; // 上次命令的退出码
extern char** environ; // 全局环境变量数组

// ------------------------------ 模块 1：命令行提示符 ------------------------------
static char* get_username() {
    char* username = getenv("USER");
    return (username == NULL) ? "unknown" : username;
}

static char* get_hostname() {
    char* hostname = getenv("HOSTNAME");
    return (hostname == NULL) ? "unknown-host" : hostname;
}

static char* get_current_dir() {
    if (getcwd(g_pwd, BUF_SIZE) == NULL) {
        perror("getcwd failed");
        return "unknown-dir";
    }
    static char pwd_env[BUF_SIZE] = {0};
    snprintf(pwd_env, BUF_SIZE, "PWD=%s", g_pwd);
    putenv(pwd_env);
    return g_pwd;
}

static char* simplify_dir(char* full_dir) {
    if (full_dir == NULL || strcmp(full_dir, "/") == 0) {
        return "/";
    }
    char* last_slash = strrchr(full_dir, '/');
    return (last_slash == NULL) ? full_dir : (last_slash + 1);
}

void print_prompt() {
    char* username = get_username();
    char* hostname = get_hostname();
    char* full_dir = get_current_dir();
    char* simple_dir = simplify_dir(full_dir);
    printf("[%s@%s %s]$ ", username, hostname, simple_dir);
    fflush(stdout);
}

// ------------------------------ 模块 2：命令获取与解析 ------------------------------
static void trim_space(char* str) {
    if (str == NULL) return;
    char* start = str;
    while (isspace(*start)) start++;
    char* end = str + strlen(str) - 1;
    while (end >= start && isspace(*end)) end--;
    *(end + 1) = '\0';
    memmove(str, start, end - start + 2);
}

int get_command(char* command_buf, int buf_size) {
    if (fgets(command_buf, buf_size, stdin) == NULL) {
        printf("\n");
        return -1;
    }
    command_buf[strcspn(command_buf, "\n")] = '\0';
    trim_space(command_buf);
    if (strlen(command_buf) == 0) {
        return 0;
    }
    return 1;
}

void parse_command(char* command_buf) {
    memset(g_argv, 0, sizeof(g_argv));
    g_argc = 0;
    char* token = strtok(command_buf, " ");
    while (token != NULL && g_argc < ARGV_MAX - 1) {
        g_argv[g_argc++] = token;
        token = strtok(NULL, " ");
    }
    g_argv[g_argc] = NULL;
}

// ------------------------------ 模块 3：内建命令处理 ------------------------------
int is_builtin_command() {
    if (g_argc == 0 || g_argv[0] == NULL) return 0;
    const char* builtin_list[] = {"cd", "export", "env", "echo", NULL};
    for (int i = 0; builtin_list[i] != NULL; i++) {
        if (strcmp(g_argv[0], builtin_list[i]) == 0) {
            return 1;
        }
    }
    return 0;
}

static void exec_cd() {
    char* target_dir = NULL;
    strncpy(g_last_pwd, g_pwd, BUF_SIZE);
    if (g_argc == 1) {
        target_dir = getenv("HOME");
    } else if (strcmp(g_argv[1], "~") == 0) {
        target_dir = getenv("HOME");
    } else if (strcmp(g_argv[1], "-") == 0) {
        target_dir = g_last_pwd;
        printf("%s\n", target_dir);
    } else {
        target_dir = g_argv[1];
    }
    if (chdir(target_dir) == -1) {
        perror("cd failed");
        g_last_code = 1;
    } else {
        g_last_code = 0;
    }
}

static void exec_export() {
    if (g_argc != 2) {
        fprintf(stderr, "用法：export KEY=VALUE\n");
        g_last_code = 2;
        return;
    }
    if (strchr(g_argv[1], '=') == NULL) {
        fprintf(stderr, "错误：export 参数必须包含'='\n");
        g_last_code = 2;
        return;
    }
    if (putenv(g_argv[1]) != 0) {
        perror("export failed");
        g_last_code = 1;
    } else {
        g_last_code = 0;
    }
}

static void exec_env() {
    for (int i = 0; environ[i] != NULL; i++) {
        printf("%s\n", environ[i]);
    }
    g_last_code = 0;
}

static void exec_echo() {
    if (g_argc < 2) {
        printf("\n");
        g_last_code = 0;
        return;
    }
    char* content = g_argv[1];
    if (content[0] == '$') {
        if (strcmp(content, "?$") == 0) {
            printf("%d\n", g_last_code);
        } else {
            char* var_name = content + 1;
            char* var_value = getenv(var_name);
            if (var_value != NULL) {
                printf("%s\n", var_value);
            }
        }
    } else {
        for (int i = 1; i < g_argc; i++) {
            printf("%s ", g_argv[i]);
        }
        printf("\n");
    }
    g_last_code = 0;
}

void exec_builtin_command() {
    if (strcmp(g_argv[0], "cd") == 0) {
        exec_cd();
    } else if (strcmp(g_argv[0], "export") == 0) {
        exec_export();
    } else if (strcmp(g_argv[0], "env") == 0) {
        exec_env();
    } else if (strcmp(g_argv[0], "echo") == 0) {
        exec_echo();
    }
}

// ------------------------------ 模块 4：外部命令执行 ------------------------------
void exec_external_command() {
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork failed");
        g_last_code = 1;
        return;
    }
    if (pid == 0) {
        execvp(g_argv[0], g_argv);
        perror("command not found");
        exit(127);
    } else {
        int status;
        waitpid(pid, &status, 0);
        if (WIFEXITED(status)) {
            g_last_code = WEXITSTATUS(status);
        } else if (WIFSIGNALED(status)) {
            g_last_code = 128 + WTERMSIG(status);
        }
    }
}

// ------------------------------ 模块 5：环境变量初始化 ------------------------------
void init_env() {
    printf("=== 迷你 Shell 启动 ===");
    char* path = getenv("PATH");
    char* home = getenv("HOME");
    char* user = getenv("USER");
    if (path != NULL) printf("\nPATH: %s", path);
    if (home != NULL) printf("\nHOME: %s", home);
    if (user != NULL) printf("\nUSER: %s", user);
    printf("\n====================\n\n");
    get_current_dir();
    strncpy(g_last_pwd, g_pwd, BUF_SIZE);
}

// ------------------------------ 主函数（核心循环） ------------------------------
int main() {
    char command_buf[BUF_SIZE] = {0};
    init_env(); // 初始化环境变量
    // Shell 核心循环：获取命令→解析→执行→循环
    while (1) {
        print_prompt(); // 1. 打印提示符
        int ret = get_command(command_buf, BUF_SIZE); // 2. 获取命令
        if (ret == -1) {
            // 用户按 Ctrl+D，退出 Shell
            printf("=== 迷你 Shell 退出 ===\n");
            break;
        } else if (ret == 0) {
            // 空行，跳过
            continue;
        }
        parse_command(command_buf); // 3. 解析命令
        // debug_print_argv(); // 调试用：打印解析结果
        if (is_builtin_command()) {
            // 4. 执行内建命令
            exec_builtin_command();
        } else {
            // 5. 执行外部命令
            exec_external_command();
        }
    }
    return 0;
}

3.2 编译与运行演示

步骤 1：编译代码

在 Linux 终端中，执行编译命令：

gcc mini_shell.c -o mini_shell -Wall

• -o mini_shell：指定输出文件名为 mini_shell；
• -Wall：显示所有警告（避免潜在错误）。

步骤 2：运行迷你 Shell

./mini_shell

启动后会显示初始化信息和提示符：

=== 迷你 Shell 启动 ===
PATH: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HOME: /home/ubuntu
USER: ubuntu
====================

[ubuntu@localhost myshell]$ 

步骤 3：测试核心功能

退出迷你 Shell：按 Ctrl+D 或输入 exit（可扩展 exit 内建命令），Shell 会退出：

[ubuntu@localhost ubuntu]$ === 迷你 Shell 退出 ===

测试 echo $?（查看退出码）：

[ubuntu@localhost ubuntu]$ ls -l # 成功执行，退出码 0
[ubuntu@localhost ubuntu]$ echo$?
0
[ubuntu@localhost ubuntu]$ lss # 命令不存在，退出码 127
command not found: lss
[ubuntu@localhost ubuntu]$ echo$?
127

测试外部命令 ls 与 ps：

[ubuntu@localhost ubuntu]$ ls -l # 执行外部命令 ls
total 4
drwxrwxr-x 2 ubuntu ubuntu 4096 Oct 116:00 myshell
[ubuntu@localhost ubuntu]$ ps # 执行外部命令 ps
PID TTY TIME CMD
1234 pts/0 00:00:00 bash
5678 pts/0 00:00:00 mini_shell
5679 pts/0 00:00:00 ps

测试内建命令 env：

[ubuntu@localhost ubuntu]$ env|grep MY_VAR # 查看导出的环境变量
MY_VAR=hello_mini_shell

测试内建命令 export 与 echo：

[ubuntu@localhost ubuntu]$ export MY_VAR=hello_mini_shell
[ubuntu@localhost ubuntu]$ echo$MY_VAR # 打印环境变量 hello_mini_shell
[ubuntu@localhost ubuntu]$ echo$PATH # 打印系统环境变量
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
[ubuntu@localhost ubuntu]$ echo hello world # 打印文本
hello world

测试内建命令 cd：

[ubuntu@localhost myshell]$ cd /home
[ubuntu@localhost home]$ cd ubuntu
[ubuntu@localhost ubuntu]$ cd - # 切换到上次目录（/home）
/home
[ubuntu@localhost home]$ cd ~ # 切换到家目录（/home/ubuntu）
[ubuntu@localhost ubuntu]$ 

四、进阶扩展：让迷你 Shell 更实用

当前的迷你 Shell 已实现核心功能，但还可以扩展以下进阶功能，使其更接近真实 Shell（如 bash）：

4.1 扩展 1：支持命令别名（如 ll=ls -l）

• 实现思路：用哈希表（如 struct alias_map）存储'别名→原命令'的映射；
• 新增内建命令 alias：alias ll='ls -l'，将别名添加到哈希表；
• 命令解析时：若命令是别名，替换为原命令（如 ll→ls -l）。

4.2 扩展 2：支持命令补全（按 Tab 补全命令 / 路径）

• 实现思路：监听 Tab 键（需关闭终端的'行缓冲'，用 tcsetattr 修改终端属性）；
• 补全逻辑：若输入的是命令前缀（如 l），遍历 PATH 目录，找出以 l 开头的命令（如 ls/less）；若输入的是路径前缀（如 /hom），调用 readdir 遍历目录，补全为 /home。

4.3 扩展 3：支持重定向（如 ls > file.txt）

• 实现思路：解析命令时识别 >/< 等重定向符号，拆分'命令'与'重定向目标'；
• 子进程执行前：调用 open 打开目标文件，用 dup2 重定向标准输出（stdout）或标准输入（stdin），再执行 execvp。

4.4 扩展 4：支持管道（如 ls | grep txt）

• 实现思路：用 pipe 创建管道，fork 两个子进程：
  • 子进程 1：执行 ls，将标准输出重定向到管道写入端；
  • 子进程 2：执行 grep txt，将标准输入重定向到管道读取端；
  • 父进程：等待两个子进程退出，关闭管道两端。

五、总结：迷你 Shell 背后的'进程控制逻辑'

这个迷你 Shell 虽然简单，但完全基于前面四篇文章的核心知识，是进程控制的'集大成者'。我们可以用一张图总结其核心逻辑：

用户输入 → 提示符（print_prompt） ↓
获取命令（get_command）→ 空行/EOF 处理 ↓
解析命令（parse_command）→ 生成 g_argv 数组 ↓
判断命令类型：
├─ 内建命令（is_builtin_command）→ Shell 自身执行（如 cd 修改工作目录）
└─ 外部命令 → fork 子进程 → 子进程 execvp 替换 → 父进程 waitpid 回收 ↓
更新退出码（g_last_code）→ 回到提示符，循环

通过这个实战，你应该能深刻理解：

• 内建命令与外部命令的本质区别：是否需要修改 Shell 自身状态；
• 进程控制的'全链路'应用：fork（创建子进程）→ exec（替换程序）→ waitpid（回收资源）→ exit（终止进程）；
• Linux Shell 的工作原理：不是'自己执行命令'，而是'管理子进程执行命令'的'管家'。

至此，Linux 进程控制系统系列文章已全部完成。从进程的创建、终止、等待、替换，到最终实现迷你 Shell，我们走过了'理论→实践'的完整路径。希望你能亲手运行代码，修改扩展，真正将这些知识内化为自己的技能。