深入理解 Linux 环境变量

那么这就意味着，我们自己编写的程序，想要像指令一样不加路径直接运行，有两种方法：

1. 将我们的自己的程序放入 PATH 中存在的路径中：
   • 以程序 mycmd 为例，只需要将其移动到环境变量 PATH 中的目录即可
   • 使用 mv mycmd /usr/bin 命令，常见系统的指令通常位于 /usr/bin 目录下
2. 将我们自己的程序所处的路径加入到 PATH 环境变量中

接下来我们演示第二种方法，并演示 PATH 的修改

• 环境变量 PATH 的访问和修改方法

# 查看环境变量的内容
echo $PATH
# $表示取环境变量的内容
# 修改 PATH=$PATH:newContent # PATH=newPath # 错误行为 会把 PATH 中之前的内容覆盖掉

修改环境变量使用等号 =，这里的等号可以类比为赋值，赋值会把 PATH 中之前的内容覆盖掉。我们需要将指定的路径追加到 PATH 中，因此指令为：PATH=$PATH:newPath，这里的行为依然是覆盖，但是 $PATH 保证了我们取出了 PATH 中已有的内容，并在后面加上 :newPATH，保证了修改是追加新路径

• 通过这种方式修改的 PATH，是一种内存级别的 PATH，在 shell 中保存
• 如果我们错误的修改了 PATH，只需关闭终端后重新登陆 shell
• shell 没有启动时，PATH 在系统的配置文件中保存。shell 启动时，环境变量从系统的配置文件中加载到内存
  • which 指令搜索时，也是在环境变量 PATH 中搜索的

HOME

• HOME : 指定用户的主工作目录 (即用户登陆到 Linux 系统中时，默认的目录)
  • 为什么我们在首次登录 Linux 时，默认所处的目录是自己的家目录呢？
  • 为什么默认所处的路径为 /home/userName 呢

原因是，当我们登录时，shell 会识别当前登录的用户名，给当前用户填充 $HOME 环境变量，填充的值为 /home/用户名

当我们使用远程工具登录 Linux 时，命令行解释器会分配命令行解释器，命令行解释器会执行类似 cd $HOME 的命令，因此初次登录时，处于当前用户的家目录

SHELL

• SHELL：当前终端使用的 Shell 程序，它的值通常是/bin/bash
  • 如何查看当前系统中使用的是哪一个 shell 呢？
  • 只需要查看环境变量 SHELL 中的值，命令为：echo $SHELL

# 查看当前系统中正在使用的 shell
echo $SHELL

• 经验证，默认使用的 shell 一般是 /bin/bash

其他常见环境变量

除了以上环境变量，系统中还有很多其他的环境变量。

环境变量如此多，我们进行查看呢？我们可以使用 env 命令

• env：查看到当前的进程和 bash 进程从系统中继承下来的所有环境变量。

PWD 与 OLDPWD

• 环境变量 PWD：记录当前进程所处的工作路径
• 环境变量 OLDPWD：会记录当前进程所处的工作路径的上个路径
  • 我们的 cd - 命令会被解析为 cd $OLDPWD，因此可以跳转到上次所处的路径中

LOGNAME 与 USER

• 可以看到，当我们在不同用户之间切换时，env 获取到的环境变量值中的 LOGNAME 与 USER 也都在同步变化。

SSH_TTY

这里对环境便令 SSH_TTY 简单提一下。SSH_TTY 表示当前终端所使用的字符设备文件。当前 SSH_TTY 的值为 /dev/pts/0

我们再开启一个终端，向该文件中追加内容时，另一个终端中便会显示我们追加的内容。

由环境变量理解权限

使用系统调用获取环境变量

我们可以通过系统调用接口 getenv() 来获取环境变量，需要给该函数传入字符串格式的环境变量名。该函数返回环境变量值，格式为 char 风格的字符串*。

理解权限

• 我们Linux 的权限理解部分，同一个文件，不同的用户在使用时，拥有不同的操作权限
  • 那么系统想要给我们限制权限，首先要获取到我们是谁。
  • 操作系统可以通过系统调用来获取当前用户是谁
• 不同的用户执行相同的代码时，环境变量获取到的值就不一样，因此可以操作系统可以辨识出当前使用用户的身份

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

// 环境变量，可以让程序获取到当前系统中的用户是谁
int main() {
    char who[32];
    strcpy(who, getenv("USER"));
    if (strcmp(who, "root") == 0) {
        printf("你是 root 用户，可以做任何事情\n");
    } else {
        printf("你是普通用户，受到权限约束\n");
    }
    return 0;
}

• 有了环境变量，程序内部便可以获取环境变量，从而获知当前是哪个用户正在执行指令的

有了环境变量的存在，系统就有了获知当前是哪个用户正在执行指令的能力，获取后就可以将文件属性中的拥有者、所属组和文件所对应的权限进行比对，进而判定当前用户有无特定的权限

3. 总结什么是环境变量

经过以上对环境变量的熟悉和使用，我们可以得出环境变量的最终概念

环境变量是操作系统提供的一组 name=value 形式的变量，不同的环境变量有不同的用途，通常具有全局属性

环境变量的本质

• 本质上是 以字符串形式存储在内存中的一组键值对
• 每个运行中的进程都维护着一份自己的环境变量表，初始化来源是其父进程。

4. 命令行参数和环境变量的全局性

命令行参数

什么是命令行参数？

• 命令行参数：是指在命令行界面运行程序时，跟随在程序名称后的额外输出参数，用于控制程序的运行或传递数据

我们 C/C++ 的 main 函数是可以有参数的

int main(int argc, char* argv[]) {
    return 0;
}

• 其中：
  • argc 是一个整数，argv 是一个字符串数组 (指针数组)
  • argv 字符串数组的大小由 argc 决定

main 函数也是函数，因此main 函数可以调用其他函数，同时也可以被其他函数调用。C/C++ 程序运行起来时，int argc 和 char* argv[] 这两个参数会被调用方进行传参。

• 用户层面上：main 函数是被第一个调用的函数
• 系统层面上：第一个调用的函数是Startup() 函数或 CRTStartup() 函数，该函数会调用 main 函数，给 main 函数传参

使用以下代码查看 char* argv[] 中的内容：

int main(int argc, char* argv[]) {
    int i = 0;
    for (; i < argc; ++i) {
        printf("argv[%d]->%s\n", i, argv[i]);
    }
    return 0;
}

可以看到 char* argv 中的内容，就是我们输入的指令和附带的选项。

• argv[0] 是 ./mycmd
• argv[i] 是后面附带的不同选项

为什么会这样呢？

这是因为，我们在 bash 中输入的指令，本质上都是字符串，bash 会把他们以空格为分隔符，分割成子字符串，分割成多少个字符串，就初始化 argc 为多少

打散后，argv 指针数组中，每个空间，存放的都是相应字符串的地址。最后一个空间存放的是空指针 NULL

• 在系统层面上，被打散的字符串的地址存入 char* argv[] 中并初始化 argc。shell 命令行解释器，会把这两个参数传递给程序的 main 函数。
• 既然 char* argv[] 的最后一个位置的值为 NULL，那么我们遍历 argv[] 就有了新的方式：
  • for 循环的第二个位置表示循环终止条件，当 argv[i] 的值为 NULL 时，循环结束，也就完成了对 argv[] 的遍历

int main(int argc, char* argv[]) {
    int i = 0;
    for (; argv[i]; ++i) {
        printf("argv[%d]->%s\n", i, argv[i]);
    }
    return 0;
}

以上就是命令行参数。以空格为分隔符。将输入的指令分割的过程，就叫做命令行解析

为什么要有 main 函数要有命令行参数？

• 我们 Linux 中的指令都是 C 语言写的
  • main 函数的命令行参数为指令、工具、软件提供命令行选项的支持
  • 调用同一个程序时，使用不同的选项，可以完成不同的功能

main 函数的第三个参数

main 函数不只有 argc 和 argv 两个参数，还可以带第三个参数，如下：

int main(int argc, char* argv[], char* env[]) {
    return 0;
}

• 这里的第三个参数 char* env[] 表示的是从父进程继承过来的环境变量，其内容和 env 命令输出的内容一模一样
  • 使用以下代码验证

// C/C++ 程序 两张表 main 函数的第三个参数
// 1. 命令行参数 向量表 2. 环境变量 向量表 这两张表的结构一模一样
int main(int argc, char* argv[], char* env[]) {
    int i = 0;
    // argv 和 env 的最后一个元素存储的是 NULL，遍历到结尾时，条件自动为假，所以退出循环
    for (; env[i]; ++i) {
        printf("env[%d]->%s\n", i, env[i]);
    }
    return 0;
}

• 综上：通过参数和 char* env[] 查看的环境变量和 env 命令查看到的环境变量一模一样
  • char* argv[] 和 char* env[] 的结构一模一样，且最后一个元素都是 NULL 指针
• 不能简单的认为程序启动时，就是简单的将程序加载到内存。

而是程序在启动时，Startup 函数会调用 main 函数，给 main 函数传递参数，传递两张表。命令行参数表和环境变量表。

环境变量具有全局属性

我们在命令行下所运行的所有进程，都是 bash 的子进程。bash 在启动的时候，会从操作系统的配置文件中读取环境变量信息。子进程会继承父进程交给我的环境变量。子进程可以通过 main 函数的第三个参数 char* env[] 访问环境变量。

• 而子进程再创建子进程，环境变量表就被无穷尽的传递下去了，因此说，环境变量具有全局性

环境变量也是进程的数据，进程具有独立性，父子进程 fork 之后的代码共享，数据，读时共享，写时拷贝

• 一个进程还没有创建子进程时，如果已经创建好了环境变量，再创建子进程，就会被子进程继承下去
• 环境变量的继承有两种方式
  • main 函数传参
  • 直接继承

5. 环境变量可以被子进程继承

如何验证环境变量可以被子进程继承呢？

我们可以在系统的环境变量中加入一个我们自己的环境变量

增加环境变量命令：

export [name=value]

# env 可以查看全部的环境变量
# echo $PATH 等可以查看特定环境变量的内容
# 那么如何增加环境变量
# 增加该环境变量 MY_VALUE=123456
export MY_VALUE=123456

• export 增加环境变量后，env 命令中就多了我们添加的环境变量
• export 增加环境变量后，我们运行的 bash 的子进程 ./mycmd 中，获取到的环境变量也有我们新增加的环境变量

这是因为：环境变量可以被子进程继承

• 发源进程只有一个，是 bash，因此 bash 及其的所有子进程构成的进程树，拥有相同的环境变量

如果今天我想让我的所有进程都遵守一套规则，我可以把这套规则放在 bash 的环境变量中，这样所有的子进程都会有相同的环境变量

系统中的权限，每条指令都应该遵守，这些功能的实现就和环境变量有关

取消环境变量：

# 取消我们刚刚新增的环境变量 MY_VALUE
unset MY_VALUE

bash 进程取消环境变量 MY_VALUE 后，之后的子进程就也没有相应的环境变量了，读者可以自行验证

• 另外，编译器在编译时，会对 main 函数的命令行参数进行检查，会进行条件编译。如果 main 函数有参数，会传入相应个数的参数。没有参数，就不传入参数

6. 本地变量与内建命令

本地变量

与环境变量对应的还有本地变量。

什么是本地变量？本地变量就是我们直接在 shell 中定义的变量

# 直接在 bash 命令行中定义
a=1
b=2
c=3

本地变量只会在本 bash 内部有效，不会被子进程继承

set 命令：可以显示系统中所有的变量。包括环境变量和本地变量

本地变量不能被子进程继承

• 我们用本地变量 MYVAL 来测试，以下程序查看 MYVAL 的值

int main(int argc, char* argv[], char* env[]) {
    printf("MYVAL: %s\n", getenv("MYVAL"));
    return 0;
}

内建命令

• 观察以下输出，思考问题

• 前文提到，bash 命令行中执行的程序，都是 bash 的子进程。

• 前文提到，本地变量只在本 bash 内部有效，不会被子进程继承

• 那么，echo $MY_val 命令，echo 也是 Bash 的子进程，./mycmd 也是 bash 的子进程，无法获取到本地变量。echo 也是 bash 的子进程，为什么能取到本地变量的？

我们纠正之前的结论：命令行中所启动的指令，不一定全都要创建子进程

我们的命令要被分成两类：

• 常规命令：执行时，bash 通过创建子进程执行
• 内建命令：执行时，bash 不创建子进程，而是 bash 自己亲自执行的。类似于bash 调用了自己写的或者系统提供的函数。已知常见的内建命令如下：
  • echo：echo 是由 bash 执行的，bash 内部有一个函数叫 echo，echo $MY_val 时，echo 获取到 bash 内部的本地变量输出出来就行了
  • cd：每个进程都有自己的当前工作目录，如果 cd 命令在执行时创建子进程，那么 cd 改变的将是子进程的工作目录，而不会改变主进程的工作目录

结合系统调用体会内建命令 cd

bash 也是一个程序，其内部在实现时，读取到用户输入 cd 时，bash 并不会创建子进程，而是直接调用系统调用 chdir 改变 bash 程序当前的路径。

我们可以用如下代码进行验证：

由于我们执行 mycmd 时，bash 会创建子进程，因此我们无法直接观察到 bash 的工作路径改变，我们可以观察 /proc 目录下进程的 cwd 目录

// 验证 cd 命令
int main(int argc, char* argv[]) {
    printf("before change:\n");
    sleep(40);
    if (argc == 2) {
        chdir(argv[1]);
    }
    printf("change end:\n");
    sleep(20);
    return 0;
}

• sleep() 是为了给我们输入指令查看进程的 cwd 留出时间

通过 C 语言提供的外部变量获取环境变量

// 通过 C 语言提供的 外部变量 environ 获取环境变量
int main() {
    int i = 0;
    extern char** environ;
    for (; environ[i]; ++i) {
        printf("%s\n", environ[i]);
    }
    return 0;
}

至此，我们已经系统地学习了 Linux 环境变量的方方面面：它们的结构、用途、修改方式、继承机制，以及它们在程序启动和系统权限管理中的关键角色。从 PATH 到 HOME，从命令行参数到环境变量表，从本地变量的局部性到子进程的继承性，环境变量贯穿了整个 Linux 系统的运行脉络。