当前位置：首页>Linux>手把手教学:Linux进程控制实战第五弹,从零打造你的微型Shell解释器

手把手教学:Linux进程控制实战第五弹,从零打造你的微型Shell解释器

2026-09-03 17:55:20

前面四篇文章，我们已经掌握了进程控制的 “全链路技能”：用fork创建子进程、exec替换程序、waitpid回收资源、exit终止进程。今天，我们将这些知识 “组装” 成一个能实际运行的工具 ——微型Shell命令行解释器（简称 “迷你 Shell”）。

今日文章阅读福利：《运维入门大礼包》

扫码添加小助理，发送暗号“运维”，即可获取。

这个迷你Shell将支持：命令行提示符（如[user@host dir]#）、内建命令（cd/export/env/echo）、外部命令（ls/ps等）、环境变量管理（继承与导出），完全遵循Linux Shell的核心工作逻辑。通过亲手实现，你会彻底明白 “输入一条命令后，Shell到底在做什么”。

一、先搞懂：Shell的本质是 “命令管家”

在写代码前，我们先回归本质：Shell是一个 “命令管家”—— 它的核心工作是 “接收用户命令→解析命令→调度资源执行命令→反馈结果”，具体流程可拆解为一个无限循环：

展示提示符：打印[用户名@主机名工作目录]$，告诉用户 “可以输入命令了”；
获取命令：读取用户输入的一行命令（如ls -l或cd /home）；
解析命令：将命令拆分为 “命令名 + 参数”（如ls -l拆成["ls", "-l", NULL]）；
执行命令：

若为内建命令（如cd）：Shell自己执行（需修改Shell进程自身状态，不能用子进程）；
若为外部命令（如ls）：Shell创建子进程，子进程用exec替换为目标程序，Shell等待子进程退出；

循环往复：回到第一步，等待用户输入下一条命令。

举个通俗的例子：Shell就像餐厅服务员 —— 提示符是 “请问需要点什么？”，用户输入是 “一份牛排”（命令），解析是 “牛排 + 七分熟”（命令 + 参数），执行是：

内建命令：服务员自己给你倒杯水（不用叫后厨）；

外部命令：服务员叫后厨（子进程）做牛排，自己在旁边等（waitpid），做好后给你端过来（反馈结果）。

二、迷你Shell的核心模块设计

我们将迷你Shell拆解为5个核心模块，逐个实现并讲解，最后整合为完整代码。每个模块都对应Shell的一个关键功能，且能复用前面学的进程控制知识。

2.1模块1：命令行提示符 —— 给用户 “交互的入口”

命令行提示符（如[ubuntu@localhost myshell]$）的作用是 “提示用户输入命令”，它需要包含三个关键信息：用户名、主机名、当前工作目录。我们通过 Linux提供的函数获取这些信息：

用户名：getenv("USER")（从环境变量中获取当前登录用户）；

主机名：getenv("HOSTNAME")（从环境变量中获取主机名）；

当前工作目录：getcwd()（获取当前进程的工作目录，比getenv("PWD")更准确，因为cd后PWD可能未更新）。

实现细节：

工作目录简化：默认显示完整路径（如/home/ubuntu/myshell），我们可以简化为 “最后一级目录”（如myshell），更符合常用Shell的习惯；

缓冲区刷新：printf默认是 “行缓冲”，若提示符不含\n，需用fflush(stdout)强制刷新，否则提示符会 “卡着不显示”。

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

#include <stdio.h>#include <stdlib.h>#include <string.h>#include <unistd.h>// 全局变量：存储当前工作目录（避免频繁分配内存）#define BUF_SIZE 1024char g_pwd[BUF_SIZE] = {0};char g_last_pwd[BUF_SIZE] = {0};  // 存储上次工作目录，用于cd -// 1. 获取用户名staticchar* get_username(){    char* username = getenv("USER");    return (username == NULL) ? "unknown" : username;}// 2. 获取主机名staticchar* get_hostname(){    char* hostname = getenv("HOSTNAME");    return (hostname == NULL) ? "unknown-host" : hostname;}// 3. 获取当前工作目录（并更新PWD环境变量）staticchar* get_current_dir(){    if (getcwd(g_pwd, BUF_SIZE) == NULL) {  // getcwd获取当前工作目录        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. 简化工作目录（只显示最后一级）staticchar* 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. 打印命令行提示符voidprint_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()后，终端会显示类似：

plaintext

[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 64char* g_argv[ARGV_MAX] = {0};int g_argc = 0;  // 命令参数个数（包含命令名）// 1. 去除字符串前后的空格（避免空参数，如"  ls  -l  " → "ls -l"）staticvoidtrim_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. 获取用户输入的命令intget_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数组）voidparse_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结尾}// 调试用：打印解析后的参数（可选）voiddebug_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 -：切换到 “上次的工作目录”（需用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=否）intis_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. 执行内建命令cdstaticvoidexec_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. 执行内建命令exportstaticvoidexec_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. 执行内建命令envstaticvoidexec_env(){    // 遍历environ数组，打印所有环境变量    for (int i = 0; environ[i] != NULL; i++) {        printf("%s\n", environ[i]);    }    g_last_code = 0;}// 5. 执行内建命令echostaticvoidexec_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. 统一执行内建命令voidexec_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自身代码），核心流程是：

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

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

voidexec_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，执行流程：

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

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

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

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

// 初始化环境变量（打印关键变量，验证继承）voidinit_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：命令行提示符 ------------------------------staticchar* get_username(){    char* username = getenv("USER");    return (username == NULL) ? "unknown" : username;}staticchar* get_hostname(){    char* hostname = getenv("HOSTNAME");    return (hostname == NULL) ? "unknown-host" : hostname;}staticchar* 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;}staticchar* 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);}voidprint_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：命令获取与解析 ------------------------------staticvoidtrim_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);}intget_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;}voidparse_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：内建命令处理 ------------------------------intis_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;}staticvoidexec_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;    }}staticvoidexec_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;    }}staticvoidexec_env(){    for (int i = 0; environ[i] != NULL; i++) {        printf("%s\n", environ[i]);    }    g_last_code = 0;}staticvoidexec_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;}voidexec_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：外部命令执行 ------------------------------voidexec_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：环境变量初始化 ------------------------------voidinit_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);}// ------------------------------ 主函数（核心循环） ------------------------------intmain(){    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终端中，执行编译命令：

bash

gcc mini_shell.c -o mini_shell -Wall

-o mini_shell：指定输出文件名为mini_shell；

-Wall：显示所有警告（避免潜在错误）。

步骤2：运行迷你Shell

bash

./mini_shell

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

plaintext

=== 迷你Shell启动 ===PATH: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/binHOME: /home/ubuntuUSER: ubuntu====================[ubuntu@localhost myshell]$

步骤3：测试核心功能

1.测试内建命令cd：

bash

[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]$

2.测试内建命令export与echo：

bash

[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

3.内建命令env：

bash

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

4.测试外部命令ls与ps：

bash

[ubuntu@localhost ubuntu]$ ls -l  # 执行外部命令lstotal 4drwxrwxr-x 2 ubuntu ubuntu 4096 Oct  1 16: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

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

bash

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

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

bash

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

四、进阶扩展：让迷你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虽然简单，但完全基于前面四篇文章的核心知识，是进程控制的 “集大成者”。我们可以用一张图总结其核心逻辑：

plaintext

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