Shell——数组

ZZDICT

已于 2024-06-03 18:56:44 修改

阅读量520

点赞数 29

分类专栏： SHELL 文章标签： Shell 索引数组关联数组 Liunx

于 2024-06-03 14:06:54 首次发布

本文链接：https://blog.csdn.net/Lzcsfg/article/details/139413157

版权

SHELL 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

索引数组（Indexed Array）

——索引数组的索引是整数，从 0 开始。

一. 定义数组的方式

你可以通过三种方式定义数组：

1.定义带初值的数组
隐式声明
# 使用括号和空格分隔元素
my_array=(value1 value2 value3)
2.定义空数组并逐个添加元素
# 初始化一个空数组
my_array=()

# 逐个添加元素
my_array[0]=value1
my_array[1]=value2
my_array[2]=value3
3.通过declare -a 来定义索引数组
显式声明
# 使用 declare -a 定义
declare -a my_array
my_array=("apple" "banana" "cherry")
二. 访问数组元素

1.访问数组中的特定元素

可以使用下标。下标从 0 开始：
# 访问第一个元素
echo ${my_array[0]}  # 输出 value1

# 访问第二个元素
echo ${my_array[1]}  # 输出 value2
2.访问整个数组

可以使用 @ 或 * 访问整个数组：
# 访问整个数组
echo ${my_array[@]}  # 输出：value1 value2 value3
echo ${my_array[*]}  # 输出：value1 value2 value3
3.获取数组长度

使用特殊符号 ${#array[@]} 来获取数组的长度：
# 获取数组长度
length=${#my_array[@]}
echo $length  # 输出：3
4.遍历数组

使用 for 循环来遍历数组每个元素：
# 遍历数组
for element in "${my_array[@]}"; do
    echo $element
done
三. 删除数组

1.删除单个数组元素

可以使用 unset 命令删除数组中的单个元素。需要了解的是，删除一个元素并不会重新排列数组的索引。删除后的索引将会出现空位。
# 删除数组中的第二个元素
unset my_array[1]
2.删除多个特定元素

可以使用循环结合 unset 来删除多个特定元素。
# 定义数组
my_array=("apple" "banana" "cherry" "date" "fig" "grape")

# 要删除的索引列表
indices_to_remove=(1 3 4)  # 删除 "banana", "date", 和 "fig"

# 删除多个特定索引的元素
for index in "${indices_to_remove[@]}"; do
    unset my_array[$index]
done
3.删除整个数组

可以使用 unset 命令删除整个数组
# 删除整个数组
unset my_array
4.清空数组 (保留数组但删除所有元素)

可以使用空括号 () 重新定义数组来清空所有元素，同时保留数组本身。
#清空数据
my_array=()
5.保留特定元素（删除不在特定列表中的元素）

有时可能希望保留数组中的某些特定元素，而删除所有不在这些元素中的元素。
# 定义数组
my_array=("apple" "banana" "cherry" "date" "fig" "grape")

# 要保留的索引列表
indices_to_keep=(0 2 5)  # 保留 "apple", "cherry", 和 "grape"

# 创建一个新的数组来保存保留的元素
new_array=()

# 添加保留的元素到新的数组
for index in "${indices_to_keep[@]}"; do
    new_array+=("${my_array[$index]}")
done

# 使用新数组替换原始数组
my_array=("${new_array[@]}")
四. 添加数组

1.使用下标添加单个元素

可以直接使用一个具体的下标位置来添加或更新数组中的元素。
# 在指定位置添加元素
my_array[0]="apple"
my_array[1]="banana"
2.使用追加的方式添加元素

可以使用 += 运算符来向数组末尾追加元素。
# 追加新元素到数组末尾
my_array+=("cherry")
my_array+=("date")
3.一次性添加多个元素

可以使用 += 运算符并结合括号一次性添加多个元素。
# 追加多个新元素到数组末尾
my_array+=("cherry" "date" "fig")
4.使用循环添加元素

如果你有一个列表，需要通过循环逐个添加到数组中，可以使用 for 循环。
#!/bin/bash

# 定义一个初始数组
my_array=("apple" "banana")

# 定义一个待添加元素的列表
new_elements=("cherry" "date" "fig")

# 通过循环添加新元素
for element in "${new_elements[@]}"; do
    my_array+=("$element")
done

# 打印数组以展示追加效果
echo "数组内容: ${my_array[@]}"  # 输出: apple bana
示例脚本

以下是一个更完整的脚本示例，展示了如何通过不同方式向数组添加元素：
#!/bin/bash

# 定义一个初始数组
my_array=("apple" "banana")

# 追加单个新元素
my_array+=("cherry")

# 追加多个新元素
my_array+=("date" "fig")

# 在特定位置添加元素
my_array[1]="blueberry"  # 替换第二个元素

# 打印数组以展示追加效果
echo "数组内容: ${my_array[@]}"

# 打印数组长度
echo "数组长度: ${#my_array[@]}"

关联数组（Associative Array）

——关联数组的索引是字符串（此功能在 Bash 4 及以上版本中可用）。

1.定义关联数组

可以使用 declare -A 关键字来定义关联数组。

declare -A fruit_colors=(
        ["apple"]="red"
        ["banana"]="yellow"
        ["cherry"]="red"
        ["date"]="brown"
    )

2.定义和初始化关联数组

#!/bin/bash

# 定义关联数组
declare -A fruit_colors

# 添加键值对
fruit_colors["apple"]="red"
fruit_colors["banana"]="yellow"
fruit_colors["cherry"]="red"
fruit_colors["date"]="brown"

3.访问关联数组元素

可以使用 ${array[key]} 访问关联数组中的元素。

示例：

# 访问关联数组元素
echo ${fruit_colors["apple"]}   # 输出: red
echo ${fruit_colors["banana"]}  # 输出: yellow
echo ${fruit_colors["cherry"]}  # 输出: red

4.遍历关联数组

可以使用 for 循环遍历关联数组中的所有键值对。

示例：

# 遍历关联数组的所有键
for key in "${!fruit_colors[@]}"; do
    echo "$key: ${fruit_colors[$key]}"
done

# 输出:
# apple: red
# banana: yellow
# cherry: red
# date: brown

5.获取关联数组的长度

使用 ${#array[@]} 获取关联数组的长度。

示例：

# 获取关联数组长度
length=${#fruit_colors[@]}
echo "关联数组的长度: $length"  # 输出: 4

6.删除关联数组元素

可以使用 unset 命令删除特定键的元素。

示例：

# 删除键为 "banana" 的元素
unset fruit_colors["banana"]

# 打印关联数组内容以展示删除效果
for key in "${!fruit_colors[@]}"; do
    echo "$key: ${fruit_colors[$key]}"
done

# 输出:
# apple: red
# cherry: red
# date: brown

示例：

通过函数定义多个关联数组

#!/bin/bash

# 定义函数来批量声明和初始化关联数组
function define_multiple_associative_arrays() {
    declare -A fruit_colors=(
        ["apple"]="red"
        ["banana"]="yellow"
        ["cherry"]="red"
        ["date"]="brown"
    )

    declare -A fruit_prices=(
        ["apple"]="1.2"
        ["banana"]="0.5"
        ["cherry"]="2.5"
        ["date"]="3.0"
    )

    declare -A fruit_origins=(
        ["apple"]="USA"
        ["banana"]="Ecuador"
        ["cherry"]="Turkey"
        ["date"]="Saudi Arabia"
    )
    
    # 将数组传递作为全局变量可选地返回给调用者
    export -n fruit_colors
    export -n fruit_prices
    export -n fruit_origins
}

# 调用函数来定义关联数组
define_multiple_associative_arrays

# 打印每个关联数组的内容
echo "水果颜色:"
for key in "${!fruit_colors[@]}"; do
    echo "$key: ${fruit_colors[$key]}"
done

echo "水果价格:"
for key in "${!fruit_prices[@]}"; do
    echo "$key: ${fruit_prices[$key]}"
done

echo "水果产地:"
for key in "${!fruit_origins[@]}"; do
    echo "$key: ${fruit_origins[$key]}"
done

批量添加和初始化关联数组的改进示例

也可以通过一个函数来初始化所有的关联数组，从而避免重复的代码。

示例：

#!/bin/bash

# 定义函数来初始化多个关联数组
function initialize_arrays() {
    local -n colors_ref=$1
    local -n prices_ref=$2
    local -n origins_ref=$3

    # 初始化第一个关联数组
    colors_ref["apple"]="red"
    colors_ref["banana"]="yellow"
    colors_ref["cherry"]="red"
    colors_ref["date"]="brown"

    # 初始化第二个关联数组
    prices_ref["apple"]="1.2"
    prices_ref["banana"]="0.5"
    prices_ref["cherry"]="2.5"
    prices_ref["date"]="3.0"

    # 初始化第三个关联数组
    origins_ref["apple"]="USA"
    origins_ref["banana"]="Ecuador"
    origins_ref["cherry"]="Turkey"
    origins_ref["date"]="Saudi Arabia"
}

# 定义关联数组
declare -A fruit_colors
declare -A fruit_prices
declare -A fruit_origins

# 调用函数来初始化关联数组
initialize_arrays fruit_colors fruit_prices fruit_origins

# 打印每个关联数组的内容
echo "水果颜色:"
for key in "${!fruit_colors[@]}"; do
    echo "$key: ${fruit_colors[$key]}"
done

echo "水果价格:"
for key in "${!fruit_prices[@]}"; do
    echo "$key: ${fruit_prices[$key]}"
done

echo "水果产地:"
for key in "${!fruit_origins[@]}"; do
    echo "$key: ${fruit_origins[$key]}"
done

说明：

declare -A 用于定义关联数组。
函数 initialize_arrays 接受三个参数，这些参数是传递给局部变量的引用，这样函数内部的修改将会反映到外部数组。
local -n 用于创建引用。这种方式可以把多个数组传递给函数并进行初始化。

总结

索引数组

索引类型: 使用整数作为索引
定义方式:
隐式声明: array_name=("value1" "value2" "value3")
显式声明: declare -a array_name
访问方式: 通过整数索引访问，例：${array_name[index]}
遍历方式: 使用 ${array_name[@]} 或者循环
删除元素: unset array_name[index]
获取长度: ${#array_name[@]}

关联数组

索引类型: 使用字符串作为索引
定义方式: 必须显式声明，用 declare -A array_name
访问方式: 通过字符串索引访问，例： ${array_name["key"]}
遍历方式: 使用 ${!array_name[@]} 或者循环
删除元素: unset array_name["key"]
获取长度: ${#array_name[@]}

索引数组和关联数组的主要区别在于索引的类型（整数 vs. 字符串），以及声明方式。

扩展：

在Bash脚本中，符号 !、@ 和 # 用在数组变量旁边时，具有不同的特殊含义。这些符号常用来处理数组的索引和内容。以下是这些符号的含义和区别：

1. ${array[@]} 和 ${array[*]}:

示例：

返回数组中所有元素。

@ 和 * 之间的区别在于引用处理上。${array[@]} 保留数组元素的分隔，${array[*]} 会将数组元素视为一个单独的字符串。
   array=("one" "two" "three")
   echo "${array[@]}"  # 输出: one two three
   echo "${array[*]}"  # 输出: one two three
2. ${!array[@]}:

返回数组中所有元素的索引（即数组的下标）。
示例：
   array=("one" "two" "three")
   echo "${!array[@]}"  # 输出: 0 1 2
3. ${#array[@]}:

示例：

返回数组中元素的个数（即数组的长度）。
   array=("one" "two" "three")
   echo "${#array[@]}"  # 输出: 3
4. ${#array[index]}:

示例：

返回数组中的某个元素的长度。
   array=("one" "two" "three")
   echo "${#array[0]}"  # 输出: 3
   echo "${#array[2]}"  # 输出: 5

ZZDICT

关注

29
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
Shell——数组

隐式声明# 使用括号和空格分隔元素# 初始化一个空数组# 逐个添加元素显式声明# 使用 declare -a 定义可以使用declare -A关键字来定义关联数组。/bin/bash# 定义关联数组# 添加键值对索引类型: 使用整数作为索引定义方式隐式声明显式声明访问方式遍历方式: 使用或者循环删除元素获取长度。
复制链接

扫一扫