shell数组

数组是一种特殊的变量类型，可以存储多个值。

数组定义方法

(30 20 10 60 50 40)
  0  1  2  3  4  5
  
方法一：
数组名=(value0 value1 value2 ...)

方法二：
数组名=([0]=value [1]=value [2]=value ...)

方法三：
列表名="value0 value1 value2 ..."
数组名=($列表名)

方法四：
数组名[0]="value"
数组名[1]="value"
数组名[2]="value"

数组包括的数据类型

在编程中，数组可以包含任何数据类型的元素，包括但不限于整数、浮点数、字符串和其他数组。不同的编程语言可能对数组元素的数据类型有所限制，例如在一些静态类型语言中，数组必须包含相同类型的元素，而在动态类型语言中则通常允许混合类型的数组。因此，具体的数据类型限制取决于所使用的编程语言。
●数值类型
●字符类型：
使用" "或' '定义

获取数组长度

arr_number=(1 2 3 4 5)
arr_length=${#arr_number[*]}

查看数组添加#键
           ${#arr_number[@]}
           
echo $arr_length

获取数组数据列表

echo ${arr_number[*]}
echo ${arr_number[@]}

根据数字对应位置的下标来提取数组的位置

获取数组下标列表
echo ${!arr_number[*]}

下表列表从零开始到四结束

读取某下标赋值
arr_index2=${arr_number[2]}
echo $arr_index2

数组遍历

#!/bin/bash
arr_number=(1 2 3 4 5)
for v in ${arr_number[@]}
do
echo $v
done

使用shell脚本的方式来编译数组

数组切片

arr=(1 2 3 4 5)
echo ${arr[@]}            #输出整个数组

echo ${arr[@]:0:2}        #获取 ${数组名[@或*]:起始位置:长度} 的值

echo ${arr1[*]:1:3}

echo ${arr[@]:2:3}

编译数组

输出数组

获取下标到指定下标位置的数

获取下标1到下标3的数值

获取从下标2开始往后三个下标的数值

数组替换

arr=(1 2 3 4 5)

echo ${arr[@]/4/66}     #${数组名[@或*]/查找字符/替换字符}
echo ${arr[@]}            #并不会替换数组原有内容

使用替换并不会改变数组的原有内容

arr=(${arr[@]/4/66})    #要实现改变原有数组，可通过重新赋值实现

可以使用重新赋值的方法来实现对数组的定义
echo ${arr[@]}

数组删除

arr=(1 2 3 4 5)
unset arr                #删除数组
echo ${arr[*]}

使用命令unset加上数组名可以实现对数组的删除

arr=(1 2 3 4 5)
unset arr[2]            #删除第三个元素

删除下标数为2的字段
echo ${arr[*]}

数组追加元素

方法一：
array_name[index]=value

方法二：
array_name[${#array_name[@]}]=value

仅适用于完整的数组

方法三：
array_name=("${array_name[@]}" value1 ... valueN)
双引号不能省略，否则，当数组array_name中存在包含空格的元素时会按空格将元素拆分成多个
不能将“@”替换为“*”，如果替换为“*”，不加双引号时与“@”的表现一致，加双引号时，会将数组array_name中的所有元素作为一个元素添加到数组中

for i in "${array_name[@]}"; do echo $i; done

方法四：
array_name+=(value1 ... valueN)

在原有的数组后面添加新的数组
待添加元素必须用“()”包围起来，并且多个元素用空格分隔

向函数传数组参数

如果将数组变量作为函数参数，函数只会取数组变量的第一个值。
test1() {
  echo "接收到的参数列表：$@"
  newarrary=($1)
  echo "新数组的值为：${newarrary[*]}"
}

array=(3 2 1 4 5)
echo "原始数组的值为：${array[*]}"
test1 $array

解决这个问题则需要将数组变量的值分解成单个的值，然后将这些值作为函数参数使用。在函数内部，再将所有的参数重新组合成一个新的数组变量。
test2() {
  newarrary=($(echo $@))
  echo "新数组的值为：${newarrary[*]}"

testArray(){

echo "函数入参为：$@"

}

myarray=(1 2 3 4)

echo "原始数据为：${myarray[*]}"

testArray $myarray

输出为：

testArray(){

echo "函数入参为：$@"

local newarray

newarray=($(echo "$@"))

echo "函数新的入参为：${newarray[*]}"

}

myarray=(1 2 3 4)

}

array=(3 2 1 4 5)
echo "原始数组的值为：${array[*]}"
test2 ${array[*]}

                                         
从函数返回数组
test2() {
  newarrary=($@)

  sum=0
  for value in ${newarrary[*]}
  do
    sum=$[$sum + $value]
  done
  echo $sum
}

test3() {
  newarrary=(`echo $@`)
  for ((i=0; i<=$[$# - 1]; i++))
  {
    newarrary[$i]=$[${newarrary[$i]} * 2]
  }
  echo ${newarrary[*]}
}

array=(3 2 1 4 5)
echo "原始数组的值为：${array[*]}"
result1=`test2 ${array[*]}`
echo "新数组的和为：$result1"

result2=(`test3 ${array[*]}`)
echo "新数组的值为：${result2[*]}"

数组排序算法

冒泡排序

类似气泡上涌的动作，会将数据在数组中从小到大或者从大到小不断的向前移动。

基本思想：
冒泡排序的基本思想是对比相邻的两个元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。

算法思路
冒泡算法由双层循环实现，其中外部循环用于控制排序轮数，一般为要排序的数组长度减1次，因为最后一次循环只剩下一个数组元素，不需要对比，同时数组已经完成排序了。而内部循环主要用于对比数组中每个相邻元素的大小，以确定是否交换位置，对比和交换次数随排序轮数而减少。

#!/bin/bash
array=(63 4 24 1 3 15)
echo "old_array：${array[*]}"
length=${#array[*]}
#定义比较轮数，比较轮数为数组长度减1，从1开始
for ((i=1; i<$length; i++))
do
  #确定比较元素的位置，比较相邻两个元素，较大的数往后放，比较次数随比较轮数而减少
  for ((j=0; j<$length-i; j++))
  do
    #定义第一个元素的值
    first=${array[$j]}
    #定义第二个元素的值
    k=$[$j+1]
    second=${array[$k]}
    #如果第一个元素比第二个元素大就互换
    if [ $first -gt $second ]
    then
      #把第一个元素值保存到临时变量中
      temp=$first
      #把第二个元素值赋给第一个元素
      array[$j]=$second
      #把临时变量（也就是第一个元素原值）赋给第二个元素
      array[$k]=$temp
    fi
  done
done
#输出排序后的数组
echo "new_array：${array[*]}"

直接选择排序

与冒泡排序相比，直接选择排序的交换次数更少，所以速度会快些。

基本思想：
将指定排序位置与其它数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换（如从最后一个元素开始排序），这样排序好的位置逐渐扩大，最后整个数组都成为已排序好的格式。

#!/bin/bash
array=(63 4 24 1 3 15)
length=${#array[*]}
#定义排序轮数
for ((i=1; i<$length; i++))
do
  index=0
  #确定用于比较的第一个元素的索引范围
  for ((j=1; j<=$length-i; j++))
  do
    #通过比较获取最大值元素的索引位置
    if [ ${array[$j]} -gt ${array[$index]} ];then
       index=$j
    fi
  done
  #获取每轮最后一个元素的索引 
  last=$[$length-$i]
  #把当前轮次的最后一个元素的值保存在临时变量中
  temp=${array[$last]}
  #把最大的元素的值赋给最后一个元素
  array[$last]=${array[$index]}
  #把原最后一个元素的值赋给原最大值的位置的元素
  array[$index]=$temp
done

echo ${array[*]}

反转排序

以相反的顺序把原有数组的内容重新排序。

基本思想：
把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以此类推，直到把所有数组元素反转替换。

#!/bin/bash
array=(10 20 30 40 50 60)
length=${#array[*]}
for ((i=0; i<$length/2; i++))
do
  temp=${array[$i]}
  array[$i]=${array[$length-$i-1]}
  array[$length-$i-1]=$temp
done

echo ${array[*]}