精华内容
下载资源
问答
  • 一、小括号,园括号() ...1、单小括号 () ...括号中的命令将会新开一个子shell...括号中多个命令之间用分号隔开,最后一个命令可以没有分号,各命令和括号之间不必有空格。  ②命令替换。等同于`cmd`,shell扫描一

    http://justcoding.iteye.com/blog/2252338


    一、小括号,园括号()

     

    1、单小括号 ()

        ①命令组。括号中的命令将会新开一个子shell顺序执行,所以括号中的变量不能够被脚本余下的部分使用。括号中多个命令之间用分号隔开,最后一个命令可以没有分号,各命令和括号之间不必有空格。
        ②命令替换。等同于`cmd`,shell扫描一遍命令行,发现了$(cmd)结构,便将$(cmd)中的cmd执行一次,得到其标准输出,再将此输出放到原来命令。有些shell不支持,如tcsh。
        ③用于初始化数组。如:array=(a b c d)
    • 命令替换$(cmd)

    命令替换$(cmd)和符号`cmd`(注意这不是单引号,在美式键盘上,`是ESC下面的那个键)有相同之处

    C代码  收藏代码
    1. $ ls   
    2. a b c   
    3. $ echo $(ls)   
    4. a b c   
    5. $ echo `ls`   
    6. a b c  

     

    我们来分析一下命令echo $(ls),以便理解所谓命令替换是什么意思:
    shell扫描一遍命令行,发现了$(cmd)结构,便将$(cmd)中的cmd执行一次,得到其标准输出,再将此输出放到原来命令echo $(ls)中的$(ls)位置,即替换了$(ls),再执行echo命令。
    如下:
    echo $(ls)被替换成了echo a b c
    这里要注意的是$(cmd)中的命令的错误输出是不会被替换的,替换的只是标准输出:
    $ var=$(cat d) ###文件d在当前目录不存在
    cat: d: 没有那个文件或目录
    $ echo $var

    $ ###显然var变量的值是空的

     

    2、双小括号 ((  ))

        ①整数扩展。这种扩展计算是整数型的计算,不支持浮点型。((exp))结构扩展并计算一个算术表达式的值,如果表达式的结果为0,那么返回的退出状态码 为1,或者 是"假",而一个非零值的表达式所返回的退出状态码将为0,或者是"true"。若是逻辑判断,表达式exp为真则为1,假则为0。
        ②只要括号中的运算符、表达式符合C语言运算规则,都可用在$((exp))中,甚至是三目运算符。作不同进位(如二进制、八进制、十六进制)运算时,输出结果全都自动转化成了十进制。如:echo $((16#5f)) 结果为95 (16进位转十进制)
        ③单纯用 (( )) 也可重定义变量值,比如 a=5; ((a++)) 可将 $a 重定义为6

        ④双括号中的变量可以不使用$符号前缀。括号内支持多个表达式用逗号分开。

    C代码  收藏代码
    1. if ($i<5)  
    2. if [ $i -lt 5 ]  
    3. if [ $a -ne 1 -a $a != 2 ]  
    4. if [ $a -ne 1] && [ $a != 2 ]  
    5. if [[ $a != 1 && $a != 2 ]]  
    6.    
    7. for i in $(seq 0 4);do echo $i;done  
    8. for i in `seq 0 4`;do echo $i;done  
    9. for ((i=0;i<5;i++));do echo $i;done  
    10. for i in {0..4};do echo $i;done  

     

    • POSIX标准的扩展计算:$((exp))

    这种计算是符合C语言的运算符,也就是说只要符合C的运算符都可用在$((exp)),甚至是三目运算符。
    注意:这种扩展计算是整数型的计算,不支持浮点型.若是逻辑判断,表达式exp为真则为1,假则为0。

    C代码  收藏代码
    1. $ echo $((3+2))   
    2. 5   
    3. $ echo $((3>2))   
    4. 1   
    5. $ echo $((25<3 ? 2:3))   
    6. 3   
    7. $ echo $var  
    8.   
    9. $ echo $((var=2+3))   
    10. 5   
    11. $ echo $var   
    12. 5   
    13. $ echo $((var++))   
    14. 5   
    15. $ echo $var   
    16. 6   
    17. $  

     

    二)中括号,方括号[]

     

    1、单中括号 []

        ①bash 的内部命令,[和test是等同的。如果我们不用绝对路径指明,通常我们用的都是bash自带的命令。if/test结构中的左中括号是调用test的命 令标识,右中括号是关闭条件判断的。这个命令把它的参数作为比较表达式或者作为文件测试,并且根据比较的结果来返回一个退出状态码。if/test结构中 并不是必须右中括号,但是新版的Bash中要求必须这样。
        ②Test和[]中可用的比较运算符只有==和!=,两者都是用于字符串比较的,不可用于整数比较,整数比较只能使用-eq,-gt这种形式。无论是字符 串比较还是整数比较都不支持大于号小于号。如果实在想用,对于字符串比较可以使用转义形式,如果比较"ab"和"bc":[ ab < bc ],结果为真,也就是返回状态为0。[ ]中的逻辑与和逻辑或使用-a 和-o 表示。
        ③字符范围。用作正则表达式的一部分,描述一个匹配的字符范围。作为test用途的中括号内不能使用正则。
        ④在一个array 结构的上下文中,中括号用来引用数组中每个元素的编号。

     

    2、双中括号[[ ]]

        ①[[是 bash 程序语言的关键字。并不是一个命令,[[ ]] 结构比[ ]结构更加通用。在[[和]]之间所有的字符都不会发生文件名扩展或者单词分割,但是会发生参数扩展和命令替换。
        ②支持字符串的模式匹配,使用=~操作符时甚至支持shell的正则表达式。字符串比较时可以把右边的作为一个模式,而不仅仅是一个字符串,比如[[ hello == hell? ]],结果为真。[[ ]] 中匹配字符串或通配符,不需要引号。
        ③使用[[ ... ]]条件判断结构,而不是[ ... ],能够防止脚本中的许多逻辑错误。比如,&&、||、<和> 操作符能够正常存在于[[ ]]条件判断结构中,但是如果出现在[ ]结构中的话,会报错。
        ④bash把双中括号中的表达式看作一个单独的元素,并返回一个退出状态码。

     

    三)大括号、花括号 {}

     

    1、常规用法。

        ①大括号拓展。(通配(globbing))将对大括号中的文件名做扩展。在大括号中,不允许有空白,除非这个空白被引用或转义。第一种:对大括号中的以 逗号分割的文件列表进行拓展。如 touch {a,b}.txt 结果为a.txt b.txt。第二种:对大括号中以点点(..)分割的顺序文件列表起拓展作用,如:touch {a..d}.txt 结果为a.txt b.txt c.txt d.txt

    C代码  收藏代码
    1. bogon:/home/bash # ls {ex1,ex2}.sh  
    2. ex1.sh  ex2.sh  
    3. bogon:/home/bash # ls {ex{1..3},ex4}.sh  
    4. ex1.sh  ex2.sh  ex3.sh  ex4.sh  
    5. bogon:/home/bash # ls {ex[1-3],ex4}.sh  
    6. ex1.sh  ex2.sh  ex3.sh  ex4.sh  

     

        ②代码块,又被称为内部组,这个结构事实上创建了一个匿名函数 。与小括号中的命令不同,大括号内的命令不会新开一个子shell运行,即脚本余下部分仍 可使用括号内变量。括号内的命令间用分号隔开,最后一个也必须有分号。{}的第一个命令和左括号之间必须要有一个空格。

       

    2)几种特殊的替换结构:${var:-string},${var:+string},${var:=string},${var:?string}

          A,${var:-string}和${var:=string}:若变量var为空,则用在命令行中用string来替换${var:- string},否则变量var不为空时,则用变量var的值来替换${var:-string};对于${var:=string}的替换规则 和${var:-string}是一样的,所不同之处是${var:=string}若var为空时,用string替换${var:=string}的 同时,把string赋给变量var: ${var:=string}很常用的一种用法是,判断某个变量是否赋值,没有的话则给它赋上一个默认值。
    B. ${var:+string}的替换规则和上面的相反,即只有当var不是空的时候才替换成string,若var为空时则不替换或者说是替换成变量 var的值,即空值。(因为变量var此时为空,所以这两种说法是等价的)
    C,${var:?string}替换规则为:若变量var不为空,则用变量var的值来替换${var:?string};若变量var为空,则把string输出到标准错误中,并从脚本中退出。我们可利用此特性来检查是否设置了变量的值。
    补充扩展:在上面这五种替换结构中string不一定是常值的,可用另外一个变量的值或是一种命令的输出。

     

    3)四种模式匹配替换结构:${var%pattern},${var%%pattern},${var#pattern},${var##pattern}

    第一种模式:${variable%pattern},这种模式时,shell在variable中查找,看它是否一给的模式pattern结尾,如果是,就从命令行把variable中的内容去掉右边最短的匹配模式
    第二种模式: ${variable%%pattern},这种模式时,shell在variable中查找,看它是否一给的模式pattern结尾,如果是,就从命令行把variable中的内容去掉右边最长的匹配模式
    第三种模式:${variable#pattern} 这种模式时,shell在variable中查找,看它是否一给的模式pattern开始,如果是,就从命令行把variable中的内容去掉左边最短的匹配模式
    第四种模式: ${variable##pattern} 这种模式时,shell在variable中查找,看它是否一给的模式pattern结尾,如果是,就从命令行把variable中的内容去掉右边最长的匹配模式
    这四种模式中都不会改变variable的值,其中,只有在pattern中使用了*匹配符号时,%和%%,#和##才有区别。结构中的pattern 支持通配符,*表示零个或多个任意字符,?表示零个或一个任意字符,[...]表示匹配中括号里面的字符,[!...]表示不匹配中括号里面的字符

    C代码  收藏代码
    1. bogon:/home/bash # var=testcase  
    2. bogon:/home/bash # echo $var  
    3. testcase  
    4. bogon:/home/bash # echo ${var%s*e}  
    5. testca  
    6. bogon:/home/bash # echo $var  
    7. testcase  
    8. bogon:/home/bash # echo ${var%%s*e}  
    9. te  
    10. bogon:/home/bash # echo ${var#?e}  
    11. stcase  
    12. bogon:/home/bash # echo ${var##?e}  
    13. stcase  
    14. bogon:/home/bash # echo ${var##*e}  
    15.   
    16. bogon:/home/bash # echo ${var##*s}  
    17. e  
    18. bogon:/home/bash # echo ${var##test}  
    19. case  

     

    • Shell中变量的原形:${var}

    大家常见的变量形式都是$var,如

    C代码  收藏代码
    1. $ var=test   
    2. $ echo $var   
    3. test  

     

    但当你要显示变量值加随意的字符(我这里用AA)时,就会出错,如下:

    C代码  收藏代码
    1. $ echo $varAA  
    2.   
    3. $  

     

    这时应该用变量的原形:${var},即是加一个大括号来限定变量名称的范围,如下

    C代码  收藏代码
    1. $ echo ${var}AA   
    2. testAA   
    3. $  

     

    以这个特性,我们可以很方便地写一个批量改后缀名的程序,我把它命名为mymv,程序如下:

    C代码  收藏代码
    1. #!/bin/bash  
    2.   
    3. tail=$1   
    4. for filename in `ls`   
    5. do   
    6. mv $filename ${filename}.$tail   
    7. done  

     

    程序需要提供一个后缀名,如c,表示改为后缀为c的C程序文件,看下面的测试:

    C代码  收藏代码
    1. $ ls   
    2. a b c   
    3. $ mymv c   
    4. $ ls   
    5. a.c b.c c.c   
    6. $  

     

    看样子程序运行的很好,但这是不完善的程序,有2个要注意的问题:
    A,目录下没有子目录,如果有一个目录,假设为dir,则也会被改为dir.c,这显然不是我们想要的,应该修正这个程序能识别目录。


    B,没有帮助对程序的参数进行处理,程序应该足够友好,在用户没有给定后缀名时应能处理,像上面的将直接给文件加上了一个点(.),这显然也不是我们想要的。

    因为我们的目的是说明${var},这样已经足够了,因此这里不会再对上面的程序进行修正。

    • 一串的命令执行()和{}

    ()和{}都是对一串的命令进行执行,但有所区别:
    A,()只是对一串命令重新开一个子shell进行执行
    B,{}对一串命令在当前shell执行
    C,()和{}都是把一串的命令放在括号里面,并且命令之间用;号隔开
    D,()最后一个命令可以不用分号
    E,{}最后一个命令要用分号
    F,{}的第一个命令和左括号之间必须要有一个空格
    G,()里的各命令不必和括号有空格
    H,()和{}中括号里面的某个命令的重定向只影响该命令,但括号外的重定向则影响到括号里的所有命令

    我们来看几个例子:

    C代码  收藏代码
    1. $ var=test   
    2. $ (var=notest; echo $var) ###变量var值为notest,此是在子shell中有效   
    3. notest   
    4. $ echo $var ###父shell中值仍为test   
    5. test   
    6. $ { var=notest; echo $var;} ###注意左括号和var之间要有一个空格   
    7. notest   
    8. $ echo $var ###父shell中的var变量的值变为了notest   
    9. notest   
    10. $ { var1=test1;var2=test2;echo $var1>a;echo $var2;} ###输出test1被重定向到文件a中,   
    11. test2 ###而test2输出则仍输出到标准输出中。   
    12. $ cat a   
    13. test1   
    14. $ { var1=test1;var2=test2;echo $var1;echo $var2;}>a ###括号内命令的标准输出全部被重定向到文件a中   
    15. $ cat a   
    16. test1   
    17. test2  

     

    下面是一个脚步例子:

    C代码  收藏代码
    1. (  
    2.     echo "1"  
    3.     echo "2"  
    4. ) | awk '{print NR,$0}'  

     

    • 几种特殊的替换结构:${var:-string},${var:+string},${var:=string},${var:?string}

    A,${var:-string}和${var:=string}
    若变量var为空,则用在命令行中用string来替换${var:-string},否则变量var不为空时,则用变量var的值来替换${var:-string}
    如:

    C代码  收藏代码
    1. $ echo $newvar  
    2.   
    3. $ echo ${newvar:-a}   
    4. a   
    5. $ echo $newvar ###变量newvar的值仍然是空,但上一命令行中${newvar:-a}被替换成了a  
    6.   
    7. $ newvar=b   
    8. $ echo ${newvar:-a} ###变量newvar的值不为空时,此命令行中的${newvar:-b}被替换为$newvar,即b   
    9. b   
    10. $  

     

    对于${var:=string}的替换规则和${var:-string}是一样的,所不同之处是${var:=string}若var为空时,用string替换${var:=string}的同时,把string赋给变量var:

    C代码  收藏代码
    1. $ echo $newvar  
    2.   
    3. $ echo ${newvar:=a}   
    4. a   
    5. $ echo $newvar ###变量newvar被赋值为a,同时${newvar:=a}被替换成a   
    6. a   
    7. $ echo ${newvar:=b} ###变量newvar不为空(其值已被赋为a),则${newvar:=b}被替换为newvar的值(即b)   
    8. a   
    9. $ echo $newvar   
    10. a  

     

    ${var:=string}很常用的一种用法是,判断某个变量是否赋值,没有的话则给它赋上一个默认值。
    如设置默认的编辑器:
    PHP 代码:
    echo You use editor: ${EDITOR:=/bin/vi}

    B,${var:+string}
    ${var:+string}的替换规则和上面的相反,即只有当var不是空的时候才替换成string,若var为空时则不替换或者说是替换成变量 var的值,即空值。(因为变量var此时为空,所以这两种说法是等价的)

    C代码  收藏代码
    1. $ echo $newvar   
    2. a   
    3. $ echo ${newvar:+b}   
    4. b   
    5. $ echo $newvar   
    6. a   
    7. $ newvar=   
    8. $ echo ${newvar:+b}  
    9.   
    10. $  

     

    C,${var:?string}
    替换规则为:若变量var不为空,则用变量var的值来替换${var:?string};若变量var为空,则把string输出到标准错误中,并从脚本中退出。我们可利用此特性来检查是否设置了变量的值。

    C代码  收藏代码
    1. $ newvar=   
    2. $ echo ${newvar:?没有设置newvar的值}   
    3. bash: newvar: 没有设置newvar的值   
    4. $ newvar=a   
    5. $ echo ${newvar:?没有设置newvar的值}   
    6. a   
    7. $  

     

    补充扩展:在上面这五种替换结构中string不一定是常值的,可用另外一个变量的值或是一种命令的输出。

    C代码  收藏代码
    1. $ echo ${var:-`date`} 日 3月 6 02:10:39 CST 2005   
    2. $ echo ${var:-$(date)} 日 3月 6 02:11:46 CST 2005   
    3. $ a=test   
    4. $ echo ${var:-$a}   
    5. test   
    6. $  

     

    • 四种模式匹配替换结构:${var%pattern},${var%%pattern},${var#pattern},${var##pattern}

    这 四种结构的意义是:${var%pattern}和${var%%pattern} 表示从最右边(即结尾)匹配的,${var#pattern} 和${var##pattern}从最左边(即开头)匹配的。其中${var%pattern}和${var#pattern}是最短匹 配,${var%%pattern}和${var##pattern}是最长匹配。只有在pattern中使用了通配符才能有最长最短的匹配,否则没有最 长最短匹配之分。

    结构中的pattern支持通配符,*表示零个或多个任意字符,?表示零个或一个任意字符,[...]表示匹配中括号里面的字符,[!...]表示不匹配中括号里面的字符。

    C代码  收藏代码
    1. $ var=aabbbccbbdbb   
    2. $ echo ${var%b}   
    3. aabbbccbbdb   
    4. $ echo ${var%%b}   
    5. aabbbccbbdb   
    6. $ echo ${var#a}   
    7. abbbccbbdbb   
    8. $ echo ${var##a}   
    9. abbbccbbdbb   
    10. $ echo ${var%*b}   
    11. aabbbccbbdb   
    12. $ echo ${var%%*b}  
    13.   
    14. $ echo ${var#a*}   
    15. abbbccbbdbb   
    16. $ echo ${var##a*}  
    17.   
    18. $  

     

    上面是简单的例举四种模式匹配替换结构的用法。

    • 其他(见man bash中的Parameter Expansion)
    ${parameter/pattern/string}
                  Pattern substitution.  The pattern is expanded to produce a pat‐
                  tern  just  as in pathname expansion.  Parameter is expanded and
                  the longest match of pattern against its value is replaced  with
                  string.   If  pattern  begins with /, all matches of pattern are
                  replaced  with  string.   Normally  only  the  first  match   is
                  replaced.  If pattern begins with #, it must match at the begin‐
                  ning of the expanded value of parameter.  If pattern begins with
                  %,  it must match at the end of the expanded value of parameter.
                  If string is null, matches of pattern are deleted and the / fol‐
                  lowing pattern may be omitted.  If parameter is @ or *, the sub‐
                  stitution operation is applied to each positional  parameter  in
                  turn,  and the expansion is the resultant list.  If parameter is
                  an array variable subscripted with  @  or  *,  the  substitution
                  operation  is  applied  to each member of the array in turn, and
                  the expansion is the resultant list.

     

    总结:

    Shell中的括号有其特殊的用法, 现总结如下:

     

    1. 符号$后的括号
    ${a} 变量a的值, 在不引起歧义的情况下可以省略大括号.
    $(cmd) 命令替换, 结果为shell命令cmd的输出, 和`cmd`效果相同, 不过某些Shell版本不支持$()形式的命令替换, 如tcsh.
    $((exp)) 和`expr exp`效果相同, 计算数学表达式exp的数值, 其中exp只要符合C语言的运算规则即可, 甚至三目运算符和逻辑表达式都可以计算.

     

    2. 多条命令执行
    (cmd1;cmd2;cmd3) 新开一个子shell顺序执行命令cmd1,cmd2,cmd3, 各命令之间用分号隔开, 最后一个命令后可以没有分号.
    { cmd1;cmd2;cmd3;} 在当前shell顺序执行命令cmd1,cmd2,cmd3, 各命令之间用分号隔开, 最后一个命令后必须有分号, 第一条命令和左括号之间必须用空格隔开.
    对{}和()而言, 括号中的重定向符只影响该条命令, 而括号外的重定向符影响到括号中的所有命令.

     

    3. 双括号的特殊用法
    (()) 增强括号的用法, 常用于算术运算比较. 双括号中的变量可以不使用$符号前缀, 只要括号中的表达式符合C语言运算规则, 支持多个表达式用逗号分开.
    比如可以直接使用for((i=0;i<5;i++)), 如果不使用双括号, 则为for i in `seq 0 4`或者for i in {0..4}.
    再如可以直接使用if (($i<5)), 如果不使用双括号, 则为if [ $i -lt 5 ].
    [[]] 增强方括号用法, 常用于字符串的比较. 主要用于条件测试, 双括号中的表达式可以使用&&, ||, <, >等C语言语法.
    比如可以直接使用if [[ $a != 1 && $a != 2 ]], 如果不适用双括号, 则为if [ $a -ne 1] && [ $a != 2 ]或者if [ $a -ne 1 -a $a != 2 ].

     

    转自:shell中的括号(小括号,中括号,大括号/花括号)



    展开全文
  • 在这里我想说的是几种shell里的小括号,大括号结构括号的变量,命令的用法,如下:  1.${var}  2.$(cmd)  3.(){}  4.${var:-string},${var:+string},${var:=string},${var:?string}  5.$((exp))  ...

     

    在这里我想说的是几种shell里的小括号,大括号结构和有括号的变量,命令的用法,如下: 

    1.${var} 
    2.$(cmd) 
    3.()和{} 
    4.${var:-string},${var:+string},${var:=string},${var:?string} 
    5.$((exp)) 
    6.$(var%pattern),$(var%%pattern),$(var#pattern),$(var##pattern)


    现在分述如下:

    • 1.Shell中变量的原形:${var}

    大家常见的变量形式都是$var,如 

    $ var=test 
    $ echo $var 
    test

    但当你要显示变量值加随意的字符(我这里用AA)时,就会出错,如下: 

    $ echo $varAA

    $

    这时应该用变量的原形:${var},即是加一个大括号来限定变量名称的范围,如下 
    $ echo ${var}AA 
    testAA 
    $

    以这个特性,我们可以很方便地写一个批量改后缀名的程序,我把它命名为mymv,程序如下: 
    #!/bin/bash

    tail=$1 
    for filename in `ls` 
    do 
    mv $filename ${filename}.$tail 
    done

    程序需要提供一个后缀名,如c,表示改为后缀为c的C程序文件,看下面的测试: 
    $ ls 
    a b c 
    $ mymv c 
    $ ls 
    a.c b.c c.c 
    $

    看样子程序运行的很好,但这是不完善的程序,有2个要注意的问题:
    A,目录下没有子目录,如果有一个目录,假设为dir,则也会被改为dir.c,这显然不是我们想要的,应该修正这个程序能识别目录。
    B,没有帮助对程序的参数进行处理,程序应该足够友好,在用户没有给定后缀名时应能处理,像上面的将直接给文件加上了一个点(.),这显然也不是我们想要的。

    因为我们的目的是说明${var},这样已经足够了,因此这里不会再对上面的程序进行修正。

    • 2.命令替换$(cmd)

    命令替换$(cmd)和符号`cmd`(注意这不是单引号,在美式键盘上,`是ESC下面的那个键)有相同之处 
    $ ls 
    a b c 
    $ echo $(ls) 
    a b c 
    $ echo `ls` 
    a b c

    我们来分析一下命令echo $(ls),以便理解所谓命令替换是什么意思:
    shell扫描一遍命令行,发现了$(cmd)结构,便将$(cmd)中的cmd执行一次,得到其标准输出,再将此输出放到原来命令echo $(ls)中的$(ls)位置,即替换了$(ls),再执行echo命令。
    如下:
    echo $(ls)被替换成了echo a b c
    这里要注意的是$(cmd)中的命令的错误输出是不会被替换的,替换的只是标准输出: 
    $ var=$(cat d) ###文件d在当前目录不存在 
    cat: d: 没有那个文件或目录 
    $ echo $var

    $ ###显然var变量的值是空的

    • 3.一串的命令执行()和{}

    ()和{}都是对一串的命令进行执行,但有所区别:
    A,()只是对一串命令重新开一个子shell进行执行
    B,{}对一串命令在当前shell执行
    C,()和{}都是把一串的命令放在括号里面,并且命令之间用;号隔开
    D,()最后一个命令可以不用分号
    E,{}最后一个命令要用分号
    F,{}的第一个命令和左括号之间必须要有一个空格
    G,()里的各命令不必和括号有空格
    H,()和{}中括号里面的某个命令的重定向只影响该命令,但括号外的重定向则影响到括号里的所有命令

    我们来看几个例子: 
    $ var=test 
    $ (var=notest; echo $var) ###变量var值为notest,此是在子shell中有效 
    notest 
    $ echo $var ###父shell中值仍为test 
    test 
    $ { var=notest; echo $var;} ###注意左括号和var之间要有一个空格 
    notest 
    $ echo $var ###父shell中的var变量的值变为了notest 
    notest 
    $ { var1=test1;var2=test2;echo $var1>a;echo $var2;} ###输出test1被重定向到文件a中, 
    test2 ###而test2输出则仍输出到标准输出中。 
    $ cat a 
    test1 
    $ { var1=test1;var2=test2;echo $var1;echo $var2;}>a ###括号内命令的标准输出全部被重定向到文件a中 
    $ cat a 
    test1 
    test2

    下面是一个脚步例子:

    (
        echo "1"
        echo "2"
    ) | awk '{print NR,$0}'

    • 4,几种特殊的替换结构:${var:-string},${var:+string},${var:=string},${var:?string}

    A,${var:-string}和${var:=string}
    若变量var为空,则用在命令行中用string来替换${var:-string},否则变量var不为空时,则用变量var的值来替换${var:-string}
    如: 
    $ echo $newvar

    $ echo ${newvar:-a} 

    $ echo $newvar ###变量newvar的值仍然是空,但上一命令行中${newvar:-a}被替换成了a

    $ newvar=b 
    $ echo ${newvar:-a} ###变量newvar的值不为空时,此命令行中的${newvar:-b}被替换为$newvar,即b 

    $

    对于${var:=string}的替换规则和${var:-string}是一样的,所不同之处是${var:=string}若var为空时,用string替换${var:=string}的同时,把string赋给变量var:


    $ echo $newvar

    $ echo ${newvar:=a} 

    $ echo $newvar ###变量newvar被赋值为a,同时${newvar:=a}被替换成a 

    $ echo ${newvar:=b} ###变量newvar不为空(其值已被赋为a),则${newvar:=b}被替换为newvar的值(即b) 

    $ echo $newvar 
    a

    ${var:=string}很常用的一种用法是,判断某个变量是否赋值,没有的话则给它赋上一个默认值。
    如设置默认的编辑器: 
    PHP 代码:
    echo You use editor: ${EDITOR:=/bin/vi}

    B,${var:+string}
    ${var:+string}的替换规则和上面的相反,即只有当var不是空的时候才替换成string,若var为空时则不替换或者说是替换成变量 var的值,即空值。(因为变量var此时为空,所以这两种说法是等价的) 
    $ echo $newvar 

    $ echo ${newvar:+b} 

    $ echo $newvar 

    $ newvar= 
    $ echo ${newvar:+b}

    $

    C,${var:?string}
    替换规则为:若变量var不为空,则用变量var的值来替换${var:?string};若变量var为空,则把string输出到标准错误中,并从脚本中退出。我们可利用此特性来检查是否设置了变量的值。 
    $ newvar= 
    $ echo ${newvar:?没有设置newvar的值} 
    bash: newvar: 没有设置newvar的值 
    $ newvar=a 
    $ echo ${newvar:?没有设置newvar的值} 

    $

    补充扩展:在上面这五种替换结构中string不一定是常值的,可用另外一个变量的值或是一种命令的输出。 
    $ echo ${var:-`date`} 
    日 3月 6 02:10:39 CST 2005 
    $ echo ${var:-$(date)} 
    日 3月 6 02:11:46 CST 2005 
    $ a=test 
    $ echo ${var:-$a} 
    test 
    $

    • 5.POSIX标准的扩展计算:$((exp))

    这种计算是符合C语言的运算符,也就是说只要符合C的运算符都可用在$((exp)),甚至是三目运算符。
    注意:这种扩展计算是整数型的计算,不支持浮点型.若是逻辑判断,表达式exp为真则为1,假则为0。 
    $ echo $((3+2)) 

    $ echo $((3>2)) 

    $ echo $((25<3 ? 2:3)) 

    $ echo $var

    $ echo $((var=2+3)) 

    $ echo $var 

    $ echo $((var++)) 

    $ echo $var 

    $

    好了,上面的例子足够了,这也表明了这种扩展运算是很强大的。

    • 6.四种模式匹配替换结构:${var%pattern},${var%%pattern},${var#pattern},${var##pattern}

    这四种结构的意义是:${var%pattern}和${var%%pattern}表示从最右边(即结尾)匹配的,${var#pattern} 和${var##pattern}从最左边(即开头)匹配的。其中${var%pattern}和${var#pattern}是最短匹 配,${var%%pattern}和${var##pattern}是最长匹配。只有在pattern中使用了通配符才能有最长最短的匹配,否则没有最 长最短匹配之分。

    结构中的pattern支持通配符,*表示零个或多个任意字符,?表示零个或一个任意字符,[...]表示匹配中括号里面的字符,[!...]表示不匹配中括号里面的字符。 
    $ var=aabbbccbbdbb 
    $ echo ${var%b} 
    aabbbccbbdb 
    $ echo ${var%%b} 
    aabbbccbbdb 
    $ echo ${var#a} 
    abbbccbbdbb 
    $ echo ${var##a} 
    abbbccbbdbb 
    $ echo ${var%*b} 
    aabbbccbbdb 
    $ echo ${var%%*b}

    $ echo ${var#a*} 
    abbbccbbdbb 
    $ echo ${var##a*}

    $

    上面是简单的例举四种模式匹配替换结构的用法。

    • 其他(见man bash中的Parameter Expansion)

    ${parameter/pattern/string}
                  Pattern substitution.  The pattern is expanded to produce a pat‐
                  tern  just  as in pathname expansion.  Parameter is expanded and
                  the longest match of pattern against its value is replaced  with
                  string.   If  pattern  begins with /, all matches of pattern are
                  replaced  with  string.   Normally  only  the  first  match   is
                  replaced.  If pattern begins with #, it must match at the begin‐
                  ning of the expanded value of parameter.  If pattern begins with
                  %,  it must match at the end of the expanded value of parameter.
                  If string is null, matches of pattern are deleted and the / fol‐
                  lowing pattern may be omitted.  If parameter is @ or *, the sub‐
                  stitution operation is applied to each positional  parameter  in
                  turn,  and the expansion is the resultant list.  If parameter is
                  an array variable subscripted with  @  or  *,  the  substitution
                  operation  is  applied  to each member of the array in turn, and
                  the expansion is the resultant list.
    展开全文
  • 在这里我想说的是几种shell里的小括号,大括号结构括号的变量,命令的用法,如下: 1.${var} 2.$(cmd) 3.(){} 4.${var:-string},${var:+string},${var:=string},${var:?string} 5.$((e
    如果变量名后面要跟如下内容:非小写字符串(包括大小字符串)、数字或下划线,那么变量名就一定要用大括号包起来
    在这里我想说的是几种shell里的小括号,大括号结构和有括号的变量,命令的用法,如下:

    1.${var}
    2.$(cmd)
    3.()和{}
    4.${var:-string},${var:+string},${var:=string},${var:?string}
    5.$((exp))
    6.$(var%pattern),$(var%%pattern),$(var#pattern),$(var##pattern)


    现在分述如下:
    1.Shell中变量的原形:${var}
    大家常见的变量形式都是$var,如

    $ var=test
    $ echo $var
    test

    但当你要显示变量值加随意的字符(我这里用AA)时,就会出错,如下:

    $ echo $varAA

    $

    这时应该用变量的原形:${var},即是加一个大括号来限定变量名称的范围,如下
    $ echo ${var}AA
    testAA
    $

    以这个特性,我们可以很方便地写一个批量改后缀名的程序,我把它命名为mymv,程序如下:
    #!/bin/bash

    tail=$1
    for filename in `ls`
    do
    mv $filename ${filename}.$tail
    done

    程序需要提供一个后缀名,如c,表示改为后缀为c的C程序文件,看下面的测试:
    $ ls
    a b c
    $ mymv c
    $ ls
    a.c b.c c.c
    $

    看样子程序运行的很好,但这是不完善的程序,有2个要注意的问题:
    A,目录下没有子目录,如果有一个目录,假设为dir,则也会被改为dir.c,这显然不是我们想要的,应该修正这个程序能识别目录。
    B,没有帮助对程序的参数进行处理,程序应该足够友好,在用户没有给定后缀名时应能处理,像上面的将直接给文件加上了一个点(.),这显然也不是我们想要的。

    因为我们的目的是说明${var},这样已经足够了,因此这里不会再对上面的程序进行修正。

    2.命令替换$(cmd)
    命令替换$(cmd)和符号`cmd`(注意这不是单引号,在美式键盘上,`是ESC下面的那个键)有相同之处
    $ ls
    a b c
    $ echo $(ls)
    a b c
    $ echo `ls`
    a b c

    我们来分析一下命令echo $(ls),以便理解所谓命令替换是什么意思:
    shell扫描一遍命令行,发现了$(cmd)结构,便将$(cmd)中的cmd执行一次,得到其标准输出,再将此输出放到原来命令echo $(ls)中的$(ls)位置,即替换了$(ls),再执行echo命令。
    如下:
    echo $(ls)被替换成了echo a b c
    这里要注意的是$(cmd)中的命令的错误输出是不会被替换的,替换的只是标准输出:
    $ var=$(cat d) ###文件d在当前目录不存在
    cat: d: 没有那个文件或目录
    $ echo $var

    $ ###显然var变量的值是空的

    3.一串的命令执行()和{}
    ()和{}都是对一串的命令进行执行,但有所区别:
    A,()只是对一串命令重新开一个子shell进行执行
    B,{}对一串命令在当前shell执行
    C,()和{}都是把一串的命令放在括号里面,并且命令之间用;号隔开
    D,()最后一个命令可以不用分号
    E,{}最后一个命令要用分号
    F,{}的第一个命令和左括号之间必须要有一个空格
    G,()里的各命令不必和括号有空格
    H,()和{}中括号里面的某个命令的重定向只影响该命令,但括号外的重定向则影响到括号里的所有命令

    我们来看几个例子:
    $ var=test
    $ (var=notest; echo $var) ###变量var值为notest,此是在子shell中有效
    notest
    $ echo $var ###父shell中值仍为test
    test
    $ { var=notest; echo $var;} ###注意左括号和var之间要有一个空格
    notest
    $ echo $var ###父shell中的var变量的值变为了notest
    notest
    $ { var1=test1;var2=test2;echo $var1>a;echo $var2;} ###输出test1被重定向到文件a中,
    test2 ###而test2输出则仍输出到标准输出中。
    $ cat a
    test1
    $ { var1=test1;var2=test2;echo $var1;echo $var2;}>a ###括号内命令的标准输出全部被重定向到文件a中
    $ cat a
    test1
    test2

    下面是一个脚步例子:

    (
     
       echo "1"
     
       echo "2"
    ) | awk '{print NR,$0}'

    4,几种特殊的替换结构:${var:-string},${var:+string},${var:=string},${var:?string}
    A,${var:-string}和${var:=string}
    若变量var为空,则用在命令行中用string来替换${var:-string},否则变量var不为空时,则用变量var的值来替换${var:-string}
    如:
    $ echo newvar

    $ echo ${newvar:-a}
    a
    $ echo newvar ###变量newvar的值仍然是空,但上一命令行中${newvar:-a}被替换成了a

    $ newvar=b
    $ echo ${newvar:-a} ###变量newvar的值不为空时,此命令行中的${newvar:-b}被替换为$newvar,即b
    b
    $

    对于${var:=string}的替换规则和${var:-string}是一样的,所不同之处是${var:=string}若var为空时,用string替换${var:=string}的同时,把string赋给变量var:


    $ echo newvar

    $ echo ${newvar:=a}
    a
    $ echo newvar ###变量newvar被赋值为a,同时${newvar:=a}被替换成a
    a
    $ echo ${newvar:=b} ###变量newvar不为空(其值已被赋为a),则${newvar:=b}被替换为newvar的值(即b)
    a
    $ echo $newvar
    a

    ${var:=string}很常用的一种用法是,判断某个变量是否赋值,没有的话则给它赋上一个默认值。
    如设置默认的编辑器:
    PHP 代码:
    echo You use editor: ${EDITOR:=/bin/vi}

    B,${var:+string}
    ${var:+string}的替换规则和上面的相反,即只有当var不是空的时候才替换成string,若var为空时则不替换或者说是替换成变量 var的值,即空值。(因为变量var此时为空,所以这两种说法是等价的)
    $ echo $newvar
    a
    $ echo ${newvar:+b}
    b
    $ echo $newvar
    a
    $ newvar=
    $ echo ${newvar:+b}

    $

    C,${var:?string}
    替换规则为:若变量var不为空,则用变量var的值来替换${var:?string};若变量var为空,则把string输出到标准错误中,并从脚本中退出。我们可利用此特性来检查是否设置了变量的值。
    $ newvar=
    $ echo ${newvar:?没有设置newvar的值}
    bash: newvar: 没有设置newvar的值
    $ newvar=a
    $ echo ${newvar:?没有设置newvar的值}
    a
    $

    补充扩展:在上面这五种替换结构中string不一定是常值的,可用另外一个变量的值或是一种命令的输出。
    $ echo ${var:-`date`}
    日 3月 6 02:10:39 CST 2005
    $ echo ${var:-$(date)}
    日 3月 6 02:11:46 CST 2005
    $ a=test
    $ echo ${var:-$a}
    test
    $

    5.POSIX标准的扩展计算:$((exp))
    这种计算是符合C语言的运算符,也就是说只要符合C的运算符都可用在$((exp)),甚至是三目运算符。
    注意:这种扩展计算是整数型的计算,不支持浮点型.若是逻辑判断,表达式exp为真则为1,假则为0。
    $ echo $((3+2))
    5
    $ echo $((3>2))
    1
    $ echo $((25<3 ? 2:3))
    3
    $ echo $var

    $ echo $((var=2+3))
    5
    $ echo $var
    5
    $ echo $((var++))
    5
    $ echo $var
    6
    $

    好了,上面的例子足够了,这也表明了这种扩展运算是很强大的。

    6.四种模式匹配替换结构:${var%pattern},${var%%pattern},${var#pattern},${var##pattern}
    这四种结构的意义是:${var%pattern}和${var%%pattern}表示从最右边(即结尾)匹配的,${var#pattern} 和${var##pattern}从最左边(即开头)匹配的。其中${var%pattern}和${var#pattern}是最短匹 配,${var%%pattern}和${var##pattern}是最长匹配。只有在pattern中使用了通配符才能有最长最短的匹配,否则没有最 长最短匹配之分。

    结构中的pattern支持通配符,*表示零个或多个任意字符,?表示零个或一个任意字符,[...]表示匹配中括号里面的字符,[!...]表示不匹配中括号里面的字符。
    $ var=aabbbccbbdbb
    $ echo ${var%b}
    aabbbccbbdb
    $ echo ${var%%b}
    aabbbccbbdb
    $ echo ${var#a}
    abbbccbbdbb
    $ echo ${var##a}
    abbbccbbdbb
    $ echo ${var%*b}
    aabbbccbbdb
    $ echo ${var%%*b}

    $ echo ${var#a*}
    abbbccbbdbb
    $ echo ${var##a*}

    $


    转自:http://blog.163.com/lj_2005/blog/static/458654220124142467963/

    展开全文
  • 在这里我想说的是几种shell里的小括号,大括号结构括号的变量,命令的用法,如下:  1.${var}  2.$(cmd)  3.(){}  4.${var:-string},${var:+string},${var:=string},${var:?string}  5.$((exp))  ...

    在这里我想说的是几种shell里的小括号,大括号结构和有括号的变量,命令的用法,如下: 

    1.${var} 
    2.$(cmd) 
    3.()和{} 
    4.${var:-string},${var:+string},${var:=string},${var:?string} 
    5.$((exp)) 
    6.$(var%pattern),$(var%%pattern),$(var#pattern),$(var##pattern)


    现在分述如下:

    • 1.Shell中变量的原形:${var}

    大家常见的变量形式都是$var,如 

    $ var=test 
    $ echo $var 
    test

    但当你要显示变量值加随意的字符(我这里用AA)时,就会出错,如下: 

    $ echo $varAA

    $

    这时应该用变量的原形:${var},即是加一个大括号来限定变量名称的范围,如下 
    $ echo ${var}AA 
    testAA 
    $

    以这个特性,我们可以很方便地写一个批量改后缀名的程序,我把它命名为mymv,程序如下: 
    #!/bin/bash

    tail=$1 
    for filename in `ls` 
    do 
    mv $filename ${filename}.$tail 
    done

    程序需要提供一个后缀名,如c,表示改为后缀为c的C程序文件,看下面的测试: 
    $ ls 
    a b c 
    $ mymv c 
    $ ls 
    a.c b.c c.c 
    $

    看样子程序运行的很好,但这是不完善的程序,有2个要注意的问题:
    A,目录下没有子目录,如果有一个目录,假设为dir,则也会被改为dir.c,这显然不是我们想要的,应该修正这个程序能识别目录。
    B,没有帮助对程序的参数进行处理,程序应该足够友好,在用户没有给定后缀名时应能处理,像上面的将直接给文件加上了一个点(.),这显然也不是我们想要的。

    因为我们的目的是说明${var},这样已经足够了,因此这里不会再对上面的程序进行修正。

    • 2.命令替换$(cmd)

    命令替换$(cmd)和符号`cmd`(注意这不是单引号,在美式键盘上,`是ESC下面的那个键)有相同之处 
    $ ls 
    a b c 
    $ echo $(ls) 
    a b c 
    $ echo `ls` 
    a b c

    我们来分析一下命令echo $(ls),以便理解所谓命令替换是什么意思:
    shell扫描一遍命令行,发现了$(cmd)结构,便将$(cmd)中的cmd执行一次,得到其标准输出,再将此输出放到原来命令echo $(ls)中的$(ls)位置,即替换了$(ls),再执行echo命令。
    如下:
    echo $(ls)被替换成了echo a b c
    这里要注意的是$(cmd)中的命令的错误输出是不会被替换的,替换的只是标准输出: 
    $ var=$(cat d) ###文件d在当前目录不存在 
    cat: d: 没有那个文件或目录 
    $ echo $var

    $ ###显然var变量的值是空的

    • 3.一串的命令执行()和{}

    ()和{}都是对一串的命令进行执行,但有所区别:
    A,()只是对一串命令重新开一个子shell进行执行
    B,{}对一串命令在当前shell执行
    C,()和{}都是把一串的命令放在括号里面,并且命令之间用;号隔开
    D,()最后一个命令可以不用分号
    E,{}最后一个命令要用分号
    F,{}的第一个命令和左括号之间必须要有一个空格
    G,()里的各命令不必和括号有空格
    H,()和{}中括号里面的某个命令的重定向只影响该命令,但括号外的重定向则影响到括号里的所有命令

    我们来看几个例子: 
    $ var=test 
    $ (var=notest; echo $var) ###变量var值为notest,此是在子shell中有效 
    notest 
    $ echo $var ###父shell中值仍为test 
    test 
    $ { var=notest; echo $var;} ###注意左括号和var之间要有一个空格 
    notest 
    $ echo $var ###父shell中的var变量的值变为了notest 
    notest 
    $ { var1=test1;var2=test2;echo $var1>a;echo $var2;} ###输出test1被重定向到文件a中, 
    test2 ###而test2输出则仍输出到标准输出中。 
    $ cat a 
    test1 
    $ { var1=test1;var2=test2;echo $var1;echo $var2;}>a ###括号内命令的标准输出全部被重定向到文件a中 
    $ cat a 
    test1 
    test2

    下面是一个脚步例子:

    (
        echo "1"
        echo "2"
    ) | awk '{print NR,$0}'

    • 4,几种特殊的替换结构:${var:-string},${var:+string},${var:=string},${var:?string}

    A,${var:-string}和${var:=string}
    若变量var为空,则用在命令行中用string来替换${var:-string},否则变量var不为空时,则用变量var的值来替换${var:-string}
    如: 
    $ echo $newvar

    $ echo ${newvar:-a} 

    $ echo $newvar ###变量newvar的值仍然是空,但上一命令行中${newvar:-a}被替换成了a

    $ newvar=b 
    $ echo ${newvar:-a} ###变量newvar的值不为空时,此命令行中的${newvar:-b}被替换为$newvar,即b 

    $

    对于${var:=string}的替换规则和${var:-string}是一样的,所不同之处是${var:=string}若var为空时,用string替换${var:=string}的同时,把string赋给变量var:


    $ echo $newvar

    $ echo ${newvar:=a} 

    $ echo $newvar ###变量newvar被赋值为a,同时${newvar:=a}被替换成a 

    $ echo ${newvar:=b} ###变量newvar不为空(其值已被赋为a),则${newvar:=b}被替换为newvar的值(即b) 

    $ echo $newvar 
    a

    ${var:=string}很常用的一种用法是,判断某个变量是否赋值,没有的话则给它赋上一个默认值。
    如设置默认的编辑器: 
    PHP 代码:
    echo You use editor: ${EDITOR:=/bin/vi}

    B,${var:+string}
    ${var:+string}的替换规则和上面的相反,即只有当var不是空的时候才替换成string,若var为空时则不替换或者说是替换成变量 var的值,即空值。(因为变量var此时为空,所以这两种说法是等价的) 
    $ echo $newvar 

    $ echo ${newvar:+b} 

    $ echo $newvar 

    $ newvar= 
    $ echo ${newvar:+b}

    $

    C,${var:?string}
    替换规则为:若变量var不为空,则用变量var的值来替换${var:?string};若变量var为空,则把string输出到标准错误中,并从脚本中退出。我们可利用此特性来检查是否设置了变量的值。 
    $ newvar= 
    $ echo ${newvar:?没有设置newvar的值} 
    bash: newvar: 没有设置newvar的值 
    $ newvar=a 
    $ echo ${newvar:?没有设置newvar的值} 

    $

    补充扩展:在上面这五种替换结构中string不一定是常值的,可用另外一个变量的值或是一种命令的输出。 
    $ echo ${var:-`date`} 
    日 3月 6 02:10:39 CST 2005 
    $ echo ${var:-$(date)} 
    日 3月 6 02:11:46 CST 2005 
    $ a=test 
    $ echo ${var:-$a} 
    test 
    $

    • 5.POSIX标准的扩展计算:$((exp))

    这种计算是符合C语言的运算符,也就是说只要符合C的运算符都可用在$((exp)),甚至是三目运算符。
    注意:这种扩展计算是整数型的计算,不支持浮点型.若是逻辑判断,表达式exp为真则为1,假则为0。 
    $ echo $((3+2)) 

    $ echo $((3>2)) 

    $ echo $((25<3 ? 2:3)) 

    $ echo $var

    $ echo $((var=2+3)) 

    $ echo $var 

    $ echo $((var++)) 

    $ echo $var 

    $

    好了,上面的例子足够了,这也表明了这种扩展运算是很强大的。

    • 6.四种模式匹配替换结构:${var%pattern},${var%%pattern},${var#pattern},${var##pattern}

    这四种结构的意义是:${var%pattern}和${var%%pattern}表示从最右边(即结尾)匹配的,${var#pattern} 和${var##pattern}从最左边(即开头)匹配的。其中${var%pattern}和${var#pattern}是最短匹 配,${var%%pattern}和${var##pattern}是最长匹配。只有在pattern中使用了通配符才能有最长最短的匹配,否则没有最 长最短匹配之分。

    结构中的pattern支持通配符,*表示零个或多个任意字符,?表示零个或一个任意字符,[...]表示匹配中括号里面的字符,[!...]表示不匹配中括号里面的字符。 
    $ var=aabbbccbbdbb 
    $ echo ${var%b} 
    aabbbccbbdb 
    $ echo ${var%%b} 
    aabbbccbbdb 
    $ echo ${var#a} 
    abbbccbbdbb 
    $ echo ${var##a} 
    abbbccbbdbb 
    $ echo ${var%*b} 
    aabbbccbbdb 
    $ echo ${var%%*b}

    $ echo ${var#a*} 
    abbbccbbdbb 
    $ echo ${var##a*}

    $

    上面是简单的例举四种模式匹配替换结构的用法。

    • 其他(见man bash中的Parameter Expansion)

    ${parameter/pattern/string}

                  Pattern substitution.  The pattern is expanded to produce a pat‐

                  tern  just  as in pathname expansion.  Parameter is expanded and

                  the longest match of pattern against its value is replaced  with

                  string.   If  pattern  begins with /, all matches of pattern are

                  replaced  with  string.   Normally  only  the  first  match   is

                  replaced.  If pattern begins with #, it must match at the begin‐

                  ning of the expanded value of parameter.  If pattern begins with

                  %,  it must match at the end of the expanded value of parameter.

                  If string is null, matches of pattern are deleted and the / fol‐

                  lowing pattern may be omitted.  If parameter is @ or *, the sub‐

                  stitution operation is applied to each positional  parameter  in

                  turn,  and the expansion is the resultant list.  If parameter is

                  an array variable subscripted with  @  or  *,  the  substitution

                  operation  is  applied  to each member of the array in turn, and

                  the expansion is the resultant list.


    展开全文
  • scala map 小括号大括号

    千次阅读 2018-04-15 19:00:24
    好一番搜索看到这样的答案:下面的问题,表面上看是小括号与花括号的问题。// map方法这样写不能编译通过scala&gt; List(2).map( case 2 =&gt; "OK" )// 换做花括号就可以了scala...
  • 在这里我想说的是几种shell里的小括号,大括号结构括号的变量,命令的用法,如下: 1.${var} 2.$(cmd) 3.(){} 4.${var:-string},${var:+string},${var:=string},${var:?string} 5.$((exp)) 6.$(var%pattern),$...
  • shell括号(小括号大括号/花括号) http://my.oschina.net/xiangxw/blog/11407 在这里我想说的是几种shell里的小括号,大括号结构括号的变量,命令的用法,如下:  1.${var}  2.$(cmd)  3.(){}...
  • shell中括号使用总结

    2013-06-23 23:04:16
    在这里我想说的是几种shell里的小括号,大括号结构括号的变量,命令的用法,如下:  1.${var}  2.$(cmd)  3.(){}  4.${var:-string},${var:+string},${var:=string},${var:?string}  5.$((exp))  ...
  • 在这里我想说的是几种shell里的小括号,大括号结构括号的变量,命令的用法,如下:  1.${var}  2.$(cmd)  3.(){}  4.${var:-string},${var:+string},${var:=string},${var:?string}  5.$((exp))  6.$(var...
  • 《scala雾风景(2): 小括号与花括号》 下面的问题,表面上看是小括号与花括号的问题。 // map方法这样写不能编译通过 scala> List(2).map( case 2 => "OK" ) // 换做花括号就可以了 scala> Lis...
  • linux shell 括号的各种用法

    千次阅读 2013-06-20 15:01:38
    括号和大括号用法 在这里我想说的是几种shell里的小括号,大括号结构和有括号的变量,命令的用法,如下: 1.${var} 2.$(cmd) 3.()和{} 4.${var:-string},${var:+string},${var:=string},${var:?str
  • 几种shell里的小括号,大括号结构括号的变量,命令的用法,如下: 1.${var} 2.$(cmd) 3.(){} 4.${var:-string},${var:+string},${var:=string},${var:?string} 5.$((exp)) 6.$(var%pattern),$...
  • 题目大致是这个样子 console.log($element);//{BranchId: "0003", CHName: "哈哈哈", ShortName: "嘻嘻嘻"} console.log(CacheData.columns[0])//BranchId; console.log(CacheData.columns[1]
  • 转自http://hi.baidu.com/nnsvc/blog/item/88f0fc1ae8f23ff2ae513369.html 在这里我想说的是几种shell里的小括号,大括号结构括号的变量,命令的用法,如下:  1.${var}  2.$(cmd)
  • if (OK.Text.Contains("运费")) {//像这样子,这个大括号不是直接在IF下,而是跟在后面 工具--》选项--》文本编辑器--》C# --》格式设置--》新行 这里面的大括号的新行选项,可以全部勾选上就OK了 转载于:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,709
精华内容 15,483
关键字:

中括号和大括号的样子