Linux Shell 变量的定义与使用方法

数值变量与算术运算

虽然 Shell 变量默认是字符串类型，但你可以通过特定语法进行数值计算。

使用 $(( )) 进行整数运算

a=10
b=3
sum=$((a + b))
product=$((a * b))
mod=$((a % b))
echo "Sum: $sum"       # 输出：13
echo "Product: $product" # 输出：30
echo "Mod: $mod"        # 输出：1

使用 expr 命令（较老的方式）

result=$(expr 5 + 3)
echo $result           # 输出：8

⚠️ 注意：expr 对空格敏感，操作符两侧必须有空格！

变量的作用域：局部 vs 全局

在 Shell 中，变量默认是全局变量，可以在当前 Shell 及其子进程中访问。若想限制变量作用域，可使用 local 关键字（仅在函数内有效）。

#!/bin/bash
global_var="I am global"

my_function(){
    local local_var="I am local"
    echo "Inside function: $global_var"
    echo "Inside function: $local_var"
}

my_function
echo "Outside function: $global_var"
echo "Outside function: $local_var" # 输出为空，因为 local_var 已销毁

环境变量与 export 命令

环境变量是被导出（export）给子进程使用的全局变量。常见的环境变量如 PATH, HOME, USER 等。

查看所有环境变量

printenv
# 或
env

导出自定义变量

MY_APP_HOME="/opt/myapp"
export MY_APP_HOME
# 或者一步到位：
export JAVA_HOME="/usr/lib/jvm/java-11-openjdk"

在子 Shell 中继承

export SECRET_KEY="abc123"
bash -c 'echo "Child shell sees: $SECRET_KEY"'
# 输出：Child shell sees: abc123

从命令行接收变量：位置参数

Shell 脚本可以通过 $1, $2, …, $9, ${10}, ${11} 等接收命令行传入的参数。

#!/bin/bash
echo "Script name: $0"
echo "First arg: $1"
echo "Second arg: $2"
echo "Number of args: $#"
echo "All args: $*"

运行：

./myscript.sh apple banana cherry

输出：

Script name: ./myscript.sh
First arg: apple
Second arg: banana
Number of args: 3
All args: apple banana cherry

特殊变量一览表

示例：

#!/bin/bash
echo "PID: $$"
sleep 5 &
bg_pid=$!
echo "Background job PID: $bg_pid"
wait $bg_pid
echo "Job finished with status: $?"

变量的扩展与替换

Shell 提供了强大的变量扩展功能，让你可以在不调用外部命令的情况下处理字符串。

1. 默认值设置 ${var:-default}

如果变量未设置或为空，则使用默认值：

echo ${USER_NAME:-"Guest"} # 若 USER_NAME 未定义，则输出 Guest

2. 设置默认值 ${var:=default}

如果变量未设置或为空，则赋值并返回：

echo ${COUNT:=0} # 若 COUNT 不存在，则设为 0 并输出 0

3. 错误提示 ${var:?message}

如果变量未设置或为空，则打印错误并退出：

echo ${REQUIRED_VAR:?"Required variable is missing!"} # 若 REQUIRED_VAR 为空，脚本终止并报错

4. 字符串截取

str="hello_world.txt"
echo ${str:0:5}     # 输出：hello
echo ${str:6}       # 输出：world.txt
echo ${str: -3}     # 输出：txt （注意空格）

5. 模式匹配替换

filename="document_v2.pdf"
echo ${filename%.pdf}   # 输出：document_v2
echo ${filename#*_}     # 输出：v2.pdf
echo ${filename/doc/DOC} # 输出：DOCument_v2.pdf

Shell 变量生命周期

Shell 变量调试技巧

1. 使用 set -x 开启调试模式

#!/bin/bash
set -x
name="Debug Mode"
echo "Hello $name"
set +x # 关闭调试

输出：

+ name='Debug Mode'
+ echo 'Hello Debug Mode'
Hello Debug Mode
+ set +x

2. 使用 declare 查看变量属性

declare -p PATH # 输出：declare -x PATH="/usr/local/bin:/usr/bin:..."

3. 使用 typeset 或 declare 定义带类型的变量（Bash 特有）

declare -i num=10          # 整型
declare -r const="immutable" # 只读
declare -a arr=("a" "b" "c") # 数组

# 尝试修改只读变量会报错
const="new value" # ❌ bash: const: readonly variable

数组变量的使用

Shell 支持一维数组，索引从 0 开始。

定义数组

fruits=("apple" "banana" "cherry")
nums=(1 2 3 4 5)

访问元素

echo ${fruits[0]}    # apple
echo ${fruits[1]}    # banana
echo ${fruits[@]}    # 所有元素
echo ${#fruits[@]}   # 数组长度：3

遍历数组

for fruit in "${fruits[@]}"; do
    echo "I like $fruit"
done

添加元素

fruits+=("orange")
fruits[${#fruits[@]}]="grape"

Shell 变量 vs Java 变量：对比学习

为了帮助 Java 开发者更快上手 Shell 变量，我们做一个对比表格：

Java 代码示例：模拟 Shell 变量行为

下面是一个 Java 类，模拟 Shell 变量的基本行为——动态类型、字符串存储、支持默认值等。

import java.util.HashMap;
import java.util.Map;

public class ShellVariableSimulator {
    private Map<String, String> variables = new HashMap<>();

    // 设置变量
    public void set(String key, String value) {
        variables.put(key, value);
    }

    // 获取变量，支持默认值
    public String get(String key, String defaultValue) {
        return variables.getOrDefault(key, defaultValue);
    }

    // 获取变量，无默认值则返回 null
    public String get(String key) {
        return variables.get(key);
    }

    // 模拟 ${var:-default} 语法
    public String getDefault(String key, String fallback) {
        String val = variables.get(key);
        return (val == null || val.isEmpty()) ? fallback : val;
    }

    // 模拟 ${var:=default}
    public String setDefault(String key, String fallback) {
        if (!variables.containsKey(key) || variables.get(key).isEmpty()) {
            variables.put(key, fallback);
        }
        return variables.get(key);
    }

    // 模拟 ${var:?message}
    public String require(String key, String errorMessage) throws RuntimeException {
        String val = variables.get(key);
        if (val == null || val.isEmpty()) {
            throw new RuntimeException(errorMessage);
        }
        return val;
    }

    // 打印所有变量
    public void printAll() {
        variables.forEach((k, v) -> System.out.println(k + " = " + v));
    }

    // 示例运行
    public static void main(String[] args) {
        ShellVariableSimulator sim = new ShellVariableSimulator();
        sim.set("USER", "john_doe");
        sim.set("TEMP_DIR", "");

        System.out.println("USER: " + sim.get("USER", "guest")); // john_doe
        System.out.println("HOST: " + sim.get("HOST", "localhost")); // localhost
        System.out.println("TEMP_DIR or /tmp: " + sim.getDefault("TEMP_DIR", "/tmp")); // /tmp
        sim.setDefault("LOG_LEVEL", "INFO");
        System.out.println("LOG_LEVEL: " + sim.get("LOG_LEVEL")); // INFO

        try {
            sim.require("REQUIRED_CONFIG", "配置项 REQUIRED_CONFIG 不能为空！");
        } catch (RuntimeException e) {
            System.out.println("错误：" + e.getMessage());
        }

        System.out.println("\n--- 所有变量 ---");
        sim.printAll();
    }
}

📌 运行结果：

USER: john_doe
HOST: localhost
TEMP_DIR or /tmp: /tmp
LOG_LEVEL: INFO
错误：配置项 REQUIRED_CONFIG 不能为空！
--- 所有变量 ---
USER = john_doe
TEMP_DIR =
LOG_LEVEL = INFO

这个模拟器虽然简化了很多 Shell 特性（比如数组、算术扩展、命令替换等），但它清晰地展示了 Shell 变量'动态'、'字符串为中心'、'默认值机制'的核心思想。

高级技巧：变量间接引用

有时候你需要通过一个变量的名字去访问另一个变量的值，这就叫'间接引用'。

使用 ${!var} 语法

name="Alice"
ref="name"
echo ${!ref} # 输出：Alice

动态构造变量名

prefix="user_"
for i in {1..3}; do
    var_name="${prefix}${i}"
    declare "$var_name=Person$i"
done
echo $user_1 # Person1
echo $user_2 # Person2
echo $user_3 # Person3

变量清理：unset 命令

不再需要的变量应及时清理，尤其是大型脚本中，避免命名冲突或内存浪费。

temp_data="some sensitive info"
echo $temp_data
unset temp_data
echo $temp_data # 输出为空

也可以一次删除多个变量：

unset var1 var2 var3

实战案例：构建配置加载器

下面我们编写一个简单的 Shell 脚本，从 .env 文件加载配置到环境变量中，类似 Docker Compose 的行为。

.env 文件内容：

DB_HOST=localhost
DB_PORT=5432
DB_USER=admin
DB_PASS=secret123
DEBUG=true

脚本 load_config.sh：

#!/bin/bash
CONFIG_FILE=".env"

if [[ ! -f "$CONFIG_FILE" ]]; then
    echo "配置文件 $CONFIG_FILE 不存在！"
    exit 1
fi

while IFS='=' read -r key value; do
    # 跳过空行和注释
    [[ -z "$key" ]] && continue
    [[ "$key" =~ ^[[:space:]]*# ]] && continue
    
    # 去除前后空格
    key=$(echo "$key" | xargs)
    value=$(echo "$value" | xargs)
    
    # 导出为环境变量
    export "$key=$value"
    echo "Loaded: $key = $value"
done < "$CONFIG_FILE"

echo "✅ 配置加载完成！共加载 $(printenv | grep -E '^(DB_|DEBUG)' | wc -l) 个变量。"

运行效果：

Loaded: DB_HOST = localhost
Loaded: DB_PORT = 5432
Loaded: DB_USER = admin
Loaded: DB_PASS = secret123
Loaded: DEBUG = true
✅ 配置加载完成！共加载 5 个变量。

Shell 变量常见陷阱与避坑指南

1. 空格陷阱

# 错误 ❌
name ="John"

# 正确 ✅
name="John"

2. 引号缺失导致单词分割

file_path="/home/user/my file.txt"
# 错误：会被当成两个参数
cat $file_path

# 正确：加引号保护空格
cat "$file_path"

3. 未初始化变量导致意外行为

# 若 count 未定义，$((count + 1)) 会变成 1，而不是报错
echo $((count + 1))

# 建议先初始化
count=0
echo $((count + 1))

4. 变量名拼写错误难以发现

usre_name="Bob" # 拼写错误
echo "Hello $username" # 输出空！

# 建议开启严格模式
set -u # 遇到未定义变量时报错

单元测试你的 Shell 变量逻辑

虽然 Shell 没有像 JUnit 那样的测试框架，但你可以用简单的 if 判断和 exit 来做基本验证。

#!/bin/bash

test_variable_default() {
    local test_val=${UNDEFINED_VAR:-"default"}
    if [[ "$test_val" != "default" ]]; then
        echo "❌ Test failed: expected 'default', got '$test_val'"
        exit 1
    fi
    echo "✅ Test passed: default value works"
}

test_variable_set_default() {
    unset TEST_VAR
    local result=${TEST_VAR:="fallback"}
    if [[ "$result" != "fallback" ]]; then
        echo "❌ Test failed: expected 'fallback', got '$result'"
        exit 1
    fi
    echo "✅ Test passed: set-default works"
}

test_variable_require() {
    unset REQUIRED
    if output=$({ require_var "REQUIRED" "Missing!";} 2>&1); then
        echo "❌ Test failed: should have thrown error"
        exit 1
    else
        echo "✅ Test passed: required variable check works"
    fi
}

require_var() {
    local var_name=$1
    local msg=$2
    if [[ -z "${!var_name}" ]]; then
        echo "$msg" >&2
        return 1
    fi
}

# 运行测试
test_variable_default
test_variable_set_default
test_variable_require
echo "🎉 All tests passed!"

Shell 变量在 DevOps 中的实际应用

在现代 DevOps 流程中，Shell 变量无处不在：

• CI/CD 流水线：Jenkins、GitLab CI 中通过环境变量传递构建参数
• 容器化部署：Docker、Kubernetes 使用环境变量配置服务
• 云平台集成：AWS CLI、Azure CLI 依赖环境变量认证
• 自动化脚本：备份、监控、日志清理等任务都依赖变量控制行为

例如，在 GitLab CI 中：

deploy_prod:
  script:
    - echo "Deploying version $CI_COMMIT_TAG to $DEPLOY_ENV"
    - ./deploy.sh --env $DEPLOY_ENV --version $CI_COMMIT_TAG
  environment:
    name: production

这里的 $CI_COMMIT_TAG 和 $DEPLOY_ENV 就是典型的 Shell 环境变量。

性能考量：变量 vs 命令替换

频繁使用命令替换会影响脚本性能：

# ❌ 不推荐：每次循环都执行 date 命令
for i in {1..1000}; do
    echo "Time: $(date)"
done

# ✅ 推荐：提前缓存结果
now=$(date)
for i in {1..1000}; do
    echo "Time: $now"
done

总结：Shell 变量的最佳实践

1. 命名清晰：使用有意义的小写变量名，如 backup_dir, max_retries
2. 及时初始化：避免未定义行为，尤其在算术运算中
3. 合理使用引号：防止单词分割和路径空格问题
4. 限制作用域：在函数中使用 local 避免污染全局空间
5. 清理无用变量：用 unset 释放资源
6. 启用严格模式：set -u、set -e 提高脚本健壮性
7. 善用默认值：${var:-default} 避免空值异常
8. 避免硬编码：把配置提取为变量，提高脚本复用性