linux shell编程学习——数组使用

linux的shell的编程方面很强大,最近在写脚本的时候,需要用到shell的数组。下面对最近的学习和使用做个简单的总结。

定义

linux的数组分两种,一种是普通的下标数组,一种是关联数组。前者和其他语言的数据一样通过下标进行访问。关联数组,可以通过key来获取值,key可以是数字或字符串。两者比较像高级语言Java里面的array和map。

关联数组

关联数据可以使用declare -A 声明。

shuanghu@shuanghu:tmp$ cat array.sh 
declare -A arr;
arr["a"]=b;
echo ${arr["a"]};
shuanghu@shuanghu:tmp$ ./array.sh 
b

普通数组

普通数组,可以通过declare -a声明。

shuanghu@shuanghu:tmp$ cat ./array2.sh 
declare -a arr;
arr[0]=b;
echo ${arr[0]};
shuanghu@shuanghu:tmp$ ./array2.sh 
b

赋值与引用

定义完数组之后,当然就是使用了,shell里数组都是通过下标进行赋值和引用。赋值语法:数组名[下标]=字符串 。在赋值的时候,等号左右是不能有空格的,shell是空格敏感的, 下标和字符串,引号不是必须的

引用数组元素,则使用${数组名[下标]}

关联数组

关联数组的下标,可以使字符串,也可以是数字。如果下标存在,则会覆盖之前的值,如果下标不存在,则会添加新的下标。在引用的时候,如果下标不存在,不会报任何错误,只会返回空字符串。

shuanghu@shuanghu:tmp$ cat ./map_arr.sh 
declare -A arr;
echo ${arr[ab]}
arr[ab]="letter_a"
echo ${arr[ab]}
arr[ab]="letter_b"
echo ${arr[ab]}
shuanghu@shuanghu:tmp$ ./map_arr.sh 

letter_a
letter_b

普通数组

普通数组的赋值和引用,也是通过下标进行的,但普通数组只能使用数组作为下标,如果使用非数字,则默认为0。普通数组,不一定需要从0开始赋值。

shuanghu@shuanghu:tmp$ cat index_arr.sh 
declare -a arr;
echo ${arr[0]}
arr[1]="one"
echo ${arr[1]}
arr[aa]="zero"
echo ${arr[0]}
shuanghu@shuanghu:tmp$ ./index_arr.sh 

one
zero

获取全部key

可以一次性输出数组的所有值;通过: [] {数组名[@]}

shuanghu@shuanghu:tmp$ cat index_arr.sh 
declare -a arr;
echo "all element:"${arr[*]}
arr[1]="one"
echo "all element:"${arr[*]}
arr[aa]="zero"
echo "all element:"${arr[*]}
arr[1]="one_1"
echo "all element:"${arr[@]}
shuanghu@shuanghu:tmp$ ./index_arr.sh 
all element:
all element:one
all element:zero one
all element:zero one_1

获取长度

获取数组长度,和获取数组全部值相比,多个#号。
通过:${#数组名[*]} 或 ${#数组名[@]} 可以得到数组的长度。
shell中,也可以获取数组元素的长度;通过:echo ${#数组名[下标]}

shuanghu@shuanghu:tmp$ cat index_arr.sh 
declare -a arr;
echo ${#arr[*]}
arr[1]="one"
echo ${#arr[*]}
arr[aa]="zero"
echo ${#arr[*]}
arr[1]="one_1"
echo ${#arr[@]}

declare -A arr2;
echo ${#arr2[@]}
arr2["a"]="aa"
echo "arr2 length:${#arr2[@]}"
echo "arr2[a] length:${#arr2[a]}"
shuanghu@shuanghu:tmp$ ./index_arr.sh 
0
1
2
2
0
arr2 length:1
arr2[a] length:2

获取全部下标key

获取数组全部key,语法:
![] {!数组名[@]}

shuanghu@shuanghu:tmp$ cat index_arr.sh 
declare -a arr;
echo ${!arr[*]}
arr[1]="one"
echo ${!arr[*]}
arr[aa]="zero"
echo ${!arr[*]}

declare -A arr2;
arr2[aa]="value"
echo ${!arr2[*]}
shuanghu@shuanghu:tmp$ ./index_arr.sh 

1
0 1
aa

从上面的代码,可以看出,如果对普通数据使用非数字下标,则相对于对于下标0进行操作。

括号操作()

在linux bash中,有个特殊的变量,叫IFS(Internal Field Separator),当shell需要对字符串进行分割时,则使用IFS值作为分割符。该字段的默认值为空格,回车和tab符。shell中将字符串放在括号内,则会将字符串分割成数组。

shuanghu@shuanghu:tmp$ cat index_arr.sh 
arr=(aa bb cc)
echo "key:"${!arr[*]}
echo "val:"${arr[*]}
shuanghu@shuanghu:tmp$ ./index_arr.sh 
key:0 1 2
val:aa bb cc

IFS的值,也是可以改变,因为IFS是个全局变量。改变IFS值后,在使用结束后,最好将IFS值改回默认值,这样避免其他使用IFS默认值的脚本不会产生bug。下面是一种改变IFS值的方法。

OLD_IFS=$IFS
IFS=","
IFS=$OLD_IFS

遍历数据

  1. 普通数组遍历,得到长度,然后使用下标进行变量
shuanghu@shuanghu:tmp$ cat list_array.sh 
declare -a arr=(a b c);
for (( i=0; i<${#arr[@]}; ++i));do
    echo ${arr[$i]};
done
shuanghu@shuanghu:tmp$ ./list_array.sh 
a
b
c
  1. 使用for in方式进行变量
shuanghu@shuanghu:tmp$ cat list_array.sh 
declare -a arr=(a b c);
for val in ${arr[*]};do
    echo ${val}
done

declare -A arr2;
arr2["a"]=aa
arr2["b"]=bb
arr2["c"]=cc
for val in ${arr2[@]};do
    echo ${val};
done
shuanghu@shuanghu:tmp$ ./list_array.sh 
a
b
c
aa
bb
cc

删除元素

使用unset关键字可以删除整个数组,或者数组内的某个元素。

shuanghu@shuanghu:tmp$ cat unset_array.sh 
arr=(a b c)
echo ${!arr[*]},${arr[*]}
unset arr[1]
echo ${!arr[*]},${arr[*]}
unset arr
echo ${!arr[*]},${arr[*]}

echo "-------------"

declare -A arr2;
arr2["a"]=aa
arr2["b"]=bb
arr2["c"]=cc
echo ${!arr2[*]},${arr2[*]}
unset arr2[a]
echo ${!arr2[*]},${arr2[*]}
unset arr2
echo ${!arr2[*]},${arr2[*]}

shuanghu@shuanghu:tmp$ ./unset_array.sh 
0 1 2,a b c
0 2,a c
,
-------------
a b c,aa bb cc
b c,bb cc
,

切片操作

shell中的数组,支持切片操作。通过:${数组名[@或*]:起始位置:长度} 可以进行数组的切片操作;
切片操作返回一个以空格分隔的字符串,原数组数据不变。如果想把结果转成数组,则可以使用上面介绍的括号操作。

shuanghu@shuanghu:tmp$ cat index_arr_slice.sh 
arr=(1 2 3 4 5)
echo ${arr[@]:0:3}
echo ${arr[@]:6:3}
echo ${arr[@]:1:7}
echo ${arr[@]:-1:7}
echo ${arr[@]:-1:2}

echo "------"

declare -a arr2;
arr2[1]=2
arr2[3]=4
echo ${arr2[@]:0:1}
echo ${arr2[@]:1:2}
echo ${arr2[@]:2:2}
echo ${arr2[@]:3:2}

echo "-------"
new_arr=(${arr[@]:0:3})
echo ${new_arr[*]}
shuanghu@shuanghu:tmp$ ./index_arr_slice.sh 
1 2 3

2 3 4 5
1 2 3 4 5
1 2 3 4 5
------
2
2 4
4
4
-------
1 2 3

从上面的测试程序输出结果,可以看出,shell的数组下标,不一定需要从0开始,但在进行切片的时候,shell数组会自动跳过那些不存在的下标。

替换操作

shell数组,支持替换操作,可以通过:${数组名[@]/待替换字符串/替换字符串} 进行数组替换操作。
将数组的所有值都输出,相当于一个字符串,对于数组的替换,其实和shell字符串的替换操作是一样的,具体可以参考
[ linux shell编程学习–字符串的使用和操作 ](
http://blog.csdn.net/shuanghujushi/article/details/51298672 )

shuanghu@shuanghu:tmp$ cat replace_arr.sh 
declare -A arr2;
arr2["a"]=aa
arr2["b"]=bb
arr2["c"]=cc

echo ${arr2[@] /a/d}
echo ${arr2[@] //b/e}
shuanghu@shuanghu:tmp$ ./replace_arr.sh 
da bb cc
aa ee cc

你可能感兴趣的:(linux运维操作,shell,数组,数组切片)