shell浅谈之十一别名、列表及数组

d[root@centos5 ~]# ./testarry 
a b c b
a b c b
4
0 1 2 3
[root@centos5 ~]# cat testarry 
#!/bin/bash
c=(a b c b)
echo ${c[@]}
echo ${c[*]}
echo ${#c[@]}
echo ${!c[@]}
[root@centos5 ~]# 

一、简介

       Shell中别名可以对命令进行重新命名,方便用户记忆长命名和定制自己熟悉的工作环境;列表是一组命名以逻辑与、逻辑或的关系串在一起,实现脚本程序的逻辑控制;数组是一重点,涉及数组的赋值、操作和字符串的处理,以及利用数组实现堆栈和二维数组等数据结构的存储。

二、详解

1、别名

       对linux命令重新命名,主要考虑到很多linux命令带有冗长的选项和参数,频繁使用这些长命令极易造成用户使用上的不便。别名的命令关键字是alias,基本格式为alias name='original-command'(等号两边不能有空格)。如alias ipconfig=ifconfig。若要删除已经设置的别名,使用内建命令unalias,unalias -a表示删除所有已设置的别名,unalias alias-name表示仅删除alias-name别名。

  1. #!/bin/bash  
  2.   
  3. shopt -s expand_aliases   #打开expand_aliases选项  
  4. alias detail="ls -l"  
  5. detail /root/in*          #别名支持通配符*  
  6. echo  
  7. directory=/root/  
  8. prefix=in*  
  9. alias vardetail="ls -l $directory$prefix"   #双引号和单引号在处理空格时是等价的,  
  10.                                             #但设置vardetail引用了变量,此处只能使用双引号  
  11. vardetail  
  12.   
  13. echo "Deleting all aliases:"  
  14. unalias -a                #删除所有的别名  
  15. detail  
  16. vardetail  
      若要在脚本中使用别名功能,必须在脚本使用shopt -s expand_aliases命令打开expand_aliases(表示别名可以被扩展)选项,未打开,alias命令建立的别名不会执行。

      要注意的是:在诸如if/then结构、循环和函数等混合型结构中不能使用alias命令设置别名,但可以执行在混合型结构之外所设置的别名。

2、列表

(1)shell中列表是由一串命令用与运算(&&)和或运算(||)连接而成,分别称为与列表和或列表。与列表的格式为:命令1 &&命令2&& 命令3 &&... &&命令n,从左到右依次执行命名,直到某命令返回FALSE时(退出状态为非0)与列表执行终止。或列表的格式为:命令1 || 命令2 || 命令3 ||... ||命令n,从左到右依次执行命名,但是当某命令返回TRUE时(退出状态为0)或列表执行终止。

(2)与列表控制输入参数个数和返回状态码

  1. #!/bin/bash  
  2.   
  3. MAXARGS=3  
  4. ERROR=68  
  5. test $# -ne $MAXARGS  && echo "Usage: `basename $0` $MAXARGS arguments" && exit $ERROR  
  6. echo "Less than $MAXARGS arguments are passed to this script."  
  7. exit 0  

(3)或列表控制输入参数个数和返回状态码

  1. #!/bin/bash  
  2.   
  3. MAXARGS=3  
  4. ERROR=68  
  5. test $# -eq $MAXARGS  || (echo "Usage: `basename $0` $MAXARGS arguments" && false) || exit $ERROR  
  6. echo "Correct arguments are passed to this script."  
  7. exit 0  
      可以对比或列表和与列表的语句,由于echo命令总是返回TRUE,要将echo和false进行与运算从而返回FALSE值。其中test命令实际上是或列表的嵌套,在使用与或列表嵌套时需要利用圆括号区分逻辑运算的优先级。

3、数组

 (1)赋值和取值

       数组(Array)是一个由若干同类型变量组成的集合,数组均由连续的存储单元组成,最低地址对应于数组的第一个元素,最高地址对应于最后一个元素。Shell只支持一维数组,array[x]表示array数组的第x+1个元素,支持的最大数值标号是599 147 937 791。shell取得数组值(引用数组元素)格式是:${array[x]}

  1. #!/bin/bash  
  2.   
  3. city[0]=Nanjing      #对第1、2个数组元素赋值  
  4. city[1]=Beijing  
  5. city[9]=Melbourne    #对第10个数组元素赋值  
  6. city[15]=NewYork     #对第16个数组元素赋值  
  7.   
  8. echo "city[0]=${city[0]}"  
  9. echo "city[1]=${city[1]}"  
  10. echo "city[9]=${city[9]}"  
  11. echo "city[15]=${city[15]}"  
  12. echo "city[2]=${city[2]}"    #未初始化数组的值为空  
  13. echo "city[10]=${city[10]}"  

Shell中允许数组空缺元素,即可以不连续地给数组赋值。还可以用圆括号将一组值赋给数组。

  1. #!/bin/bash  
  2.   
  3. city=(Nanjing Beijing Melbourne NewYork)    #圆括号内以空格为分隔符,依次赋给数组元素  
  4.   
  5. echo "city[0]=${city[0]}"  
  6. echo "city[1]=${city[1]}"  
  7. echo "city[2]=${city[2]}"  
  8. echo "city[3]=${city[3]}"  
  9. echo "city[4]=${city[4]}"       #未被初始化输出空  
  10. echo "city[5]=${city[5]}"  
  1. #!/bin/bash  
  2.   
  3. city=(Nanjing [10]=Atlanta Massachusetts Marseilles)  #指定所赋元素的标号,并以此标号为起点继续赋值  
  4.   
  5. echo "city[0]=${city[0]}"       #city[0]=Nanjing  
  6. echo "city[1]=${city[1]}"       #city[1]=  
  7. echo "city[10]=${city[10]}"     #city[10]=Atlanta  
  8. echo "city[11]=${city[11]}"     #city[11]=Massachusetts  
  9. echo "city[12]=${city[12]}"     #city[12]=Marseilles  
  10. echo "city[13]=${city[13]}"     #city[13]=  
既然圆括号内允许对数组指定元素进行赋值,那么完全可以按照任意顺序指定任意元素对数组赋值。例如:

  1. city=([2]=Nanjing [10]=Atlanta [1]=Massachusetts [5]=Marseilles)  
(2)位置参数中$@和$*都表示传递到脚本的所有参数,在数组中@和*的应用是打印数组的所有元素。

  1. #!/bin/bash  
  2.   
  3. city=(Nanjing Beijing Melbourne NewYork)  
  4.   
  5. for i in ${city[@]}  #等价于  for i in ${city[*]}  
  6. do                   #打印数组的所有元素  
  7. echo $i  
  8. done  
  1. #!/bin/bash  
  2.   
  3. city[1]="Hong Kong"       #用引号包含空格的字符串  
  4. city[100]=Massachusetts  
  5. city[101]="New York"  
  6. city[10000]=Atlanta  
  7.   
  8. for i in "${city[@]}"  
  9. do  
  10. echo $i  
  11. done  
      由于city数组元素包含了空格,因此需要使用引号将${city[@]}引起来,for循环和@只打印被赋值的元素而不打印未赋值的元素。

      注意:"${city[@]}"将数组的所有元素分行打印,而"${city[*]}"只能将数组的所有元素打印在一行内且中间以IFS分隔。不用引号时${city[@]}和${city[*]}是等价的,使用引号时,@和*只是打印数组的方式存在差异。
(3)数组的用法

       数组的字符串操作与字符串操作的符号和意义完全一致,数组字符串操作特殊之处在于所有的操作都是针对所有的数组元素逐个进行的。

  1. #数组的字符串操作  
  2. #!/bin/bash  
  3.   
  4. city=(Nanjing Atlanta Massachusetts MaseillesMas)  
  5.   
  6. echo "Extracting Substring"  #抽取字串  
  7. echo ${city[*]:0}            #抽取整个数组  Nanjing Atlanta Massachusetts Marseilles  
  8. echo ${city[*]:1}            #抽取从第1个元素到结束的数组  Atlanta Massachusetts Marseilles  
  9. echo ${city[*]:3}            #抽取从第3个元素到结束的数组  Marseilles  
  10. echo ${city[*]:0:2}          #抽取从第0个元素开始的两个元素  Nanjing Atlanta  
  11. echo  
  12. echo "Removing Substring"    #删除字串  
  13. echo ${city[*]#M*a}          #删除匹配M*a的最短字串  Nanjing Atlanta ssachusetts rseilles  
  14. echo ${city[*]##M*a}         #删除匹配M*a的最长字串  Nanjing Atlanta chusetts rseilles  
  15. echo  
  16. echo "Replcing Substring"    #替换子串功能  
  17. echo ${city[*]/M*s/Year}     #替换第1次与M*a匹配的子串  Nanjing Atlanta Year Year  
  18. echo ${city[*]//Mas/Year}    #替换所有与Mas匹配的子串   Nanjing Atlanta Yearsachusetts YeareillesYear  
  19.                              #替换的正则为最长匹配  
      数组也可以存放read命令所读入的用户输入参数,declare -a city(并不是必须的)将city申明为数组,用read -a city命令将输入存储到city数组之中,输入以空格分开。可以使用unset city[0]命令清空一个元素,和unset city清空整个数组。使用${#city[@]}获取数组的长度。

      shell数组的一种重要操作:数组连接。

  1. #!/bin/bash  
  2.   
  3. city=(Beijing Nanjing Shanghai)  
  4. person=(Cai [5]=Wu Tang)             #数组不连续地赋值  
  5.   
  6. declare -a combine                   #声明combine数组  
  7. combine=(${city[@]} ${person[@]})    #combine是数组city和person的连接,连接操作将不连续的元素按序存放到combine数组中  
  8.   
  9. element_count=${#combine[@]}         #while循环输出combine数组  
  10. index=0  
  11. while [ "$index" -lt "$element_count" ]  
  12. do  
  13.    echo "Element[$index]=${combine[$index]}"  #数组标号与值的对应关系  
  14.    let "index=$index+1"  
  15. done  
  16. ###################  
  17. echo  
  18. unset combine                                 #清空combine数组  
  19. combine[0]=${city[@]}                         #将city数组赋给combine[0]的一个元素  
  20. combine[1]=${person[@]}                       #将person数组赋给combine[1]的一个元素  
  21. element_count=${#combine[@]}  
  22. index=0  
  23. while [ "$index" -lt "$element_count" ]  
  24. do  
  25.    echo "Element[$index]=${combine[$index]}"  
  26.    let "index=$index+1"  
  27. done  
  28. ###################  
  29. echo  
  30. declare -a subcombine=${combine[1]}          #声明数组时赋值  
  31. element_count=${#subcombine[@]}  
  32. index=0  
  33. while [ "$index" -lt "$element_count" ]  
  34. do  
  35.    echo "Element[$index]=${subcombine[$index]}"  
  36.    let "index=$index+1"  
  37. done  

(4)数组实现简单的数据结构

      数据结构是指相互之间存在一种或多种特定关系的数据元素的集合,它直接影响到程序的运行速度和存储效率。Shell不直接支持如堆栈、队列、链表等数据结构,但可以很容易实现线性数据结构。对于树形、图等复杂的数据结构,shell理论上可以实现,但难度角度。

      利用数组实现堆栈操作。push函数将字符串压入堆栈,pop函数能弹出栈顶元素,status函数打印当前堆栈的状态信息。其中shift命令完成两个功能:第一,所有位置参数左移1位,即$2移动到$1的位置,$3移动到$2的位置,依次类推($0不变);第二,$#变量值减1。

  1. #!/bin/bash  
  2.   
  3. MAXTOP=50               #堆栈能存放元素的最大值  
  4.   
  5. TOP=$MAXTOP             #栈顶指针,初始值是$MAXTOP  
  6.   
  7. TEMP=  
  8. declare -a STACK        #全局数组STACK  
  9.   
  10. push()                  #push进栈操作,可同时将多个元素压入堆栈  
  11. {  
  12.         if [ -z "$1" ]      #无参数,返回  
  13.         then  
  14.              return  
  15.         fi  
  16.   
  17.         #for ((i=1; i<=$#; i++))  
  18.         until [ $# -eq 0 ]   #until循环将push函数的所有参数都压入堆栈  
  19.         do  
  20.                 let TOP=TOP-1    #栈顶指针减1  
  21.   
  22.                 STACK[$TOP]=$1  
  23.                 shift            #脚本参数除$0外左移1位,$#参数总个数减1  
  24.         done  
  25.   
  26.         return  
  27. }  
  28.   
  29. pop()                     #pop出栈操作,执行pop函数使栈顶元素出栈  
  30. {  
  31.         TEMP=  
  32.   
  33.         if [ "$TOP" -eq "$MAXTOP" ]   #若堆栈为空,返回  
  34.         then  
  35.          return  
  36.         fi  
  37.   
  38.         TEMP=${STACK[$TOP]}           #栈顶元素出栈  
  39.         unset STACK[$TOP]           
  40.         let TOP=TOP+1                 #栈顶指针加1  
  41.         return  
  42. }  
  43.   
  44. status()                          #显示当前堆栈内的元素,以及TOP指针和TEMP变量  
  45. {  
  46.         echo "==========STACK=========="  
  47.         for i in ${STACK[@]}                                  
  48.         do  
  49.         echo $i  
  50.         done  
  51.         echo "Stack Pointer=$TOP"  
  52.         echo "Just popped \""$TEMP"\" off the stack"  
  53.         echo "=========================="  
  54. }  
  55.   
  56. push one              #1个元素入栈  
  57. status                #显示状态  
  58. push two three four   #3个元素入栈  
  59. status  
  60.   
  61. pop                   #出栈  
  62. pop  
  63. status  
  64. push five six  
  65. status  

     利用一维数组模拟实现二维数组,二维数组仍存储在一维数组中,只是通过行号和列号计算出数组的索引而已。可以采用该方法使shell脚本语言用于定义二维数组和矩阵。

  1. #创建一个二维数组,并以逐行打印及旋转45度打印的两种方式将它打印出来  
  2. #!/bin/bash  
  3.   
  4. #定义行数、列数,及数组名  
  5. ROW=5  
  6. COL=5  
  7. declare -a MATRIX      #申明MATRIX数组  
  8.    
  9. load_alpha ()  
  10. {  
  11.         local rc=0  
  12.         local index  
  13.           
  14.         #for循环将A-Y这25个字符存储到MATRIX数组  
  15.         for i in A B C D E F G H I J K L M N O P Q R S T U V W X Y  
  16.         do  
  17.                 local row=`expr $rc / $COL`  
  18.                 local column=`expr $rc % $ROW`  
  19.                 let "index = $row * $ROW + $column"  
  20.                 MATRIX[$index]=$i  
  21.                 let "rc += 1"  
  22.         done    
  23. }  
  24.     
  25. print_alpha ()  
  26. {  
  27.         local row=0  
  28.         local index  
  29.           
  30.         #逐行打印MATRIX数组  
  31.         while [ "$row" -lt "$ROW" ]   
  32.         do                             
  33.                 local column=0  
  34.                 echo -n "       "   
  35.                 while [ "$column" -lt "$COL" ]  
  36.                 do  
  37.                         let "index = $row * $ROW + $column"  
  38.                         echo -n "${MATRIX[index]} "   
  39.                         let "column += 1"  
  40.                 done  
  41.                 let "row += 1"  
  42.                 echo  
  43.         done  
  44.       echo  
  45. }  
  46.     
  47. filter ()     # 过滤掉负的数组下标.   
  48. {  
  49.         echo -n "  "  # 产生倾斜.   
  50.                       # 解释一下, 这是怎么做到的.   
  51.           
  52.         if [[ "$1" -ge 0 &&  "$1" -lt "$ROW" && "$2" -ge 0 && "$2" -lt "$COL" ]]  
  53.         then  
  54.             let "index = $1 * $ROW + $2"  
  55.             # 现在, 按照旋转方向进行打印.   
  56.             echo -n " ${MATRIX[index]}"  
  57.             # alpha[$row][$column]  
  58.         fi      
  59. }  
  60.    
  61. rotate ()  # 将数组旋转45度 --  
  62. {          #+ 从左下角进行"平衡".   
  63.         local row  
  64.         local column  
  65.           
  66.         for (( row = ROW; row > -ROW; row-- ))  
  67.           do    
  68.           for (( column = 0; column < COL; column++ ))  
  69.           do  
  70.                   if [ "$row" -ge 0 ]  
  71.                   then  
  72.                     let "t1 = $column - $row"  
  73.                     let "t2 = $column"  
  74.                   else  
  75.                     let "t1 = $column"  
  76.                     let "t2 = $column + $row"  
  77.                   fi    
  78.                   filter $t1 $t2   # 将负的数组下标过滤出来  
  79.          done  
  80.        
  81.         echo; echo  
  82.         done   
  83. }  
  84.    
  85.  #下面利用上述函数创建二维数组,逐行和旋转45°打印数组  
  86.  load_alpha     # 加载数组  
  87.  print_alpha    # 打印数组  
  88.  rotate         # 逆时针旋转45°打印  

三、总结

(1)别名、列表及数组这三个知识点是相对独立的,可分开理解。

(2)数组是重点,会使用数组字符串的操作,以及利用数组实现堆栈和二维数组等数据结构。


出处:https://blog.csdn.net/taiyang1987912/article/details/39897547

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页