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

最新推荐文章于 2024-07-12 16:19:40 发布
最新推荐文章于 2024-07-12 16:19:40 发布
阅读量441 收藏
点赞数
分类专栏： linux 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别名。

[cpp]  view plain  copy
  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）与列表控制输入参数个数和返回状态码

[cpp]  view plain  copy
  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）或列表控制输入参数个数和返回状态码

[cpp]  view plain  copy
  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]}。

[cpp]  view plain  copy
  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中允许数组空缺元素，即可以不连续地给数组赋值。还可以用圆括号将一组值赋给数组。

[cpp]  view plain  copy
  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]}"  
[cpp]  view plain  copy
  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]=  
既然圆括号内允许对数组指定元素进行赋值，那么完全可以按照任意顺序指定任意元素对数组赋值。例如：

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

[cpp]  view plain  copy
  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  
[cpp]  view plain  copy
  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）数组的用法

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

[cpp]  view plain  copy
  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数组的一种重要操作：数组连接。

[cpp]  view plain  copy
  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。

[cpp]  view plain  copy
  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脚本语言用于定义二维数组和矩阵。

[cpp]  view plain  copy
  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

JackLiu16
关注
专栏目录
shell脚本变量的定义
b_______的博客
12-18 3422
浅谈shell中的变量环境定义以及设定方式 一、变量的定义 变量 变量即表示内存区域内一片地质 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warnings warnings.filter..
php无参数函数实现rce,浅谈无参数RCE
weixin_30568317的博客
04-02 1938
0x00 前言这几天做了几道无参数RCE的题目，这里来总结一下，以后忘了也方便再捡起来。首先先来解释一下什么是无参数RCE：形式：if(';' === preg_replace('/[^W]+((?R)?)/', '', $_GET['code'])) { eval($_GET['code']);}preg_replace('/[a-z]+((?R)?)/', NULL, $code)pre_ma...
Shell中创建序列和数组(list、array）的方法
09-15
主要介绍了Shell中创建序列和数组(list、array）的方法,本文讲解了seq方法生成以及通过内部{begin..end}生成法,需要的朋友可以参考下
shell 字符串列表操作
最新发布
tianyexing2008的博客
07-12 316
我的需求是这样的：编译多个模块的时候，把失败的模块添加到列表里，最后输出。这个列表类似这样：failModuleList="a b c d e"列表(List)：在Shell中，列表是由空格分隔的字符串序列。注意：shell 的语法，“=”、“+=” 两边都不能有空格。
shell 列表 数组
02-10 2485
shell的列表（数组?）绝对是让我最迷惑的语法（没有之一）。 在$*和$@和分号之间纠结已久。 忘了哪本书里有这句话，记下来了。 "${arr[*]}" returns all the items as a single word, whereas "${arr[@]}" returns each item as a separate word. 在做笔记前先写总结： 1)如果不确
Shell中创建序列和数组(list、array）
Golden_Chen的专栏
04-01 4997
这篇文章主要介绍了Shell中创建序列和数组(list、array）的方法, 一、seq方法生成： // seq [OPTION]... LAST // seq [OPTION]... FIRST LAST // seq [OPTION]... FIRST INCREMENT LAST [chengmo@centos5 ~]$ seq 1000 //起始默认是 1，间隔默认也是1 [chengmo@centos5 ~]$ seq 2 1000 //间隔默认是1 [chengmo@centos5 ~]
shell命令列表
Vay0721的博客
07-12 1120
1. ls： 列出文件名 2. cat 显示文本文件 3. less/more 分屏显示文件 4. rm 删除文件 5. cp 复制文件 mv 移动文件 mkdir 创建目录 rmdir 删除目录 cd  切换目录 find 查找文件 grep 查找字符串 head 显示文件开头 tail 显示文件结尾 sort 按次序显示文件 uni
JetBrains开发者日见闻(一)之Kotlin/Native 尝鲜篇
Mikyou的专栏
12-02 5901
简述: 今天我们来讲点Kotlin中比较时髦的东西，有的人可能会说:“不像你之前的风格啊，之前的文章不是一直在死扣语法以及语法糖背后秘密。当你还在死扣泛型语法的时候，别人的文章早就说了Kotlin/Native和Kotlin1.3的新特性”。瞬间感觉自己out了，今天我们就说说这些时髦的东西，也许你能看到一些和别人不一样的东西哦。 前段时间你们的熊猫小哥哥(也就是我)，由于对Kotlin过度热爱，...
ym——Andorid-15k+的面试题。
热门推荐
陈宇明
08-07 2万+
最近才开的博客，希望大家多多关注，andorid开发也做了3年有余了，也面试很多加企业，借此机会分享一下，我们中遇到过的问题以及解决方案吧，希望能够对正在找工作的andoird程序员有一定的帮助。学完本人博客发表《ym--andorid从零开始教程》+面试题目全理解，年薪18w以上绝对没问题。 特别献上整理过的50道面试题目 1.listView的优化方式 重用conve
【小甲鱼】python零基础入门学习笔记 03讲~43讲
Amor167的博客
01-12 4024
第003讲：插曲之变量和字符串 课堂笔记 变量 变量名就像我们现实社会的名字，把一个值赋值给一个名字时，TA会存储在内容中，称之为变量（variable），在大多数语言中，都把这种行为称为“给变量赋值”或“把值存储在变量中”。 不过python与大多数其他计算机语言的做法稍有不同，Ta并不是把值存储在变量中，而更像是把名字贴在值的上面。 所以有些python程序员会说“python”没有“变量”...
常用SHELL命令列表
08-23
ARM LINUX 开发中的常用命令，自己总结的，方便开发过程中查询。
Shell数组
qq_52914969的博客
04-19 492
0、字符串、列表、数组 "a b c d" 字符串 "a" "b" "c" "d" 列表 （"a" "b" "c" "d"） 数组 1、数组定义方法 列表输出方式 -------------------- 列表名="10 20 40 60" echo $列表名 -------------------- 列表名=（"a" "b" "c" "d"） 如果值为字符类型，需要加双引号或单引号 echo ${列表名[*]} 1.1、小括号法 数组名=（val...
SHELL脚本编程-普通数组(列表)和关联数组(字典)
qq_20990333的博客
08-15 640
root@node101.yinzhengjie.org.cn ~]# echo ${#title[@]} #由于数组依旧被删除了，长度自然也就为0啦~[root@node101.yinzhengjie.org.cn ~]# echo ${title[1]} 　　　　 #查看指定的元素下标。[root@node101.yinzhengjie.org.cn ~]# echo ${#title[@]}　　　　　　　　　　#查看数组的长度。
shell之列表的定义与循环
weixin_33971977的博客
01-07 2918
字符串列表定义方法1： a=(f1 f2 f3 f4)for i in ${a[*]}#遍历每一个列表值 for i in ${a[@]}#等价与上一句 实例： #!bin/basha=(f1 f2 f3 f4)for i in ${a[*]}; do echo ”$i“ if [ "$i" == "f1" ]; then#判断字符串是否相等，注意前后要有空格，否则变为赋值语句 e...
shell数组
陌上花开，静待绽放！
05-12 5039
人生本来就没有相欠;别人对你付出;是因为别人喜欢。你对别人付出，是因为自己甘愿;情出自愿;事过无悔。
shell 列表操作
iris_csdn的博客
02-27 9557
这是列表的各种添加方式，拷贝自他人博客。详细用法参考https://blog.csdn.net/asty9000/article/details/87103111 删除列表元素用法： unset array_name[index] 其中，array_name 表示数组名，index 表示数组下标。如果不写下标，写成下面这样就是删除整个数组： unset array_name 下图是我...
Shell编程之数组
Axic123的博客
05-10 1201
------方法一-------数组名 = （value0 value1 value2 .. .. .. .. ）-------方法二--------数组名 =([ 0 ] = value [ 1 ] = value [ 2 ] = value) -------方法三--------列表名 = “value0 value1 value2 .. .. .”数组名 = （$列表名）--------方法四--------
dc_shell(tcl)中集合(collection)(显示_selxx问题)，数组(array)，列表(list)的区别及操作
cy413026的博客
05-23 5010
目录 1.集合(collection) 2.数组(array) 3.列表(list) 首先集合的操作和数组以及列表是不一样的，集合无法直接echo显示，直接echo会输出_selxxx 集合无法像数组和列表一样使用foreach，而是使用foreach_in_collection来遍历。下面重点介绍集合的概念。 1.集合(collection) 一个collection是库,引脚,cells(单元)设计工程的集合,你可以用Synopsys命令来创建,查看,修改collection。在.
Linux网络——Shell编程之数组
weixin_67300995的博客
05-10 1129
定义数组的四种方式：数组名=（值0 值1 值2 ...）数组名=（[0]=值 [1]=值 [2]=值 ...）列表名="值0 值1 值2 ..."数组名=（$列表名）数组名[0]="值"数组名[1]="值"数组名[2]="值"...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值