精华内容
下载资源
问答
  • 括号<>表明这个文件是一个工程或标准头文件。查找过程会首先检查预定义的目录,我们可以通过设置搜索路径环境变量或命令选项来修改这些目录。 如果文件名用一对引号括“”起来,则表明该文件是用户名提供的...

    尖括号<>表明这个文件是一个工程或标准头文件。查找过程会首先检查预定义的目录,我们可以通过设置搜索路径环境变量或命令选项来修改这些目录。

    如果文件名用一对引号括“”起来,则表明该文件是用户名提供的头文件,查找该文件时将从当前文件目录(或文件名制定的其他目录)中寻找文件,然后在标准位置寻找文件。

    展开全文
  • <>表明这个文件是一个工程或标准文件,比如: #include <...""表明该文件是用户提供的头文件,查找该文件时将从当前文件目录(或文件名指定的其他目录)中寻找文件,然后在标准位置寻找文件 ...

    <>表明这个文件是一个工程或标准文件,比如:

    #include <iostream>
    

    查找这种头文件的过程中会首先检查预定义的目录,我们可以通过设置搜索路径环境变量或命令行选项来修改这些目录

    ""表明该文件是用户提供的头文件,查找该文件时将从当前文件目录(或文件名指定的其他目录)中寻找文件,然后在标准位置寻找文件

    展开全文
  • 括号中的命令将会新开一个子shell顺序执行,所以括号中的变量不能够被脚本余下的部分使用。括号中多个命令之间用分号隔开,最后一个命令可以没有分号,各命令和括号之间不必有空格。  ②命令替换。等同于`cmd`,...

    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中各种括号的作用()、(())、[]、[[]]、{}

    万次阅读 多人点赞 2014-09-26 11:13:40
    一、小括号,园括号() 1、单小括号 () ①命令组。括号中的命令将会新开一个子shell顺序执行,所以括号中的变量不能够被脚本余下的部分使用。括号中多个命令之间用分号隔开,最后一个命令可以没有分号,各命令和...

    一、小括号,圆括号()

    1、单小括号 ()

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

     2、双小括号 (( ))

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

    二、中括号,方括号[]

      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? ]],结果为真。[[ ]] 中匹配字符串或通配符,不需要引号。
        ③使用[[ ... ]]条件判断结构,而不是[ ... ],能够防止脚本中的许多逻辑错误。比如,&&、||、<和> 操作符能够正常存在于[[ ]]条件判断结构中,但是如果出现在[ ]结构中的话,会报错。比如可以直接使用if [[ $a != 1 && $a != 2 ]], 如果不适用双括号, 则为if [ $a -ne 1] && [ $a != 2 ]或者if [ $a -ne 1 -a $a != 2 ]。
        ④bash把双中括号中的表达式看作一个单独的元素,并返回一个退出状态码。
    例子:
        if ($i<5)      此处有问题,改为if (($i<5))
        if [ $i -lt 5 ]  
        if [ $a -ne 1 -a $a != 2 ]  
        if [ $a -ne 1] && [ $a != 2 ]  
        if [[ $a != 1 && $a != 2 ]]  
           
        for i in $(seq 0 4);do echo $i;done  
        for i in `seq 0 4`;do echo $i;done  
        for ((i=0;i<5;i++));do echo $i;done  
        for i in {0..4};do echo $i;done  

    三、大括号、花括号 {}

    1、常规用法

        ①大括号拓展。(通配(globbing))将对大括号中的文件名做扩展。在大括号中,不允许有空白,除非这个空白被引用或转义。第一种:对大括号中的以逗号分割的文件列表进行拓展。如 touch {a,b}.txt 结果为a.txt b.txt。第二种:对大括号中以点点(..)分割的顺序文件列表起拓展作用,如:touch {a..d}.txt 结果为a.txt b.txt c.txt d.txt
        # ls {ex1,ex2}.sh  
        ex1.sh  ex2.sh  
        # ls {ex{1..3},ex4}.sh  
        ex1.sh  ex2.sh  ex3.sh  ex4.sh  
        # ls {ex[1-3],ex4}.sh  
        ex1.sh  ex2.sh  ex3.sh  ex4.sh  
        ②代码块,又被称为内部组,这个结构事实上创建了一个匿名函数 。与小括号中的命令不同,大括号内的命令不会新开一个子shell运行,即脚本余下部分仍可使用括号内变量。括号内的命令间用分号隔开,最后一个也必须有分号。{}的第一个命令和左括号之间必须要有一个空格。
     
     

      2、几种特殊的替换结构

    ${var:-string},${var:+string},${var:=string},${var:?string}

          ①${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}很常用的一种用法是,判断某个变量是否赋值,没有的话则给它赋上一个默认值。
          ② ${var:+string}的替换规则和上面的相反,即只有当var不是空的时候才替换成string,若var为空时则不替换或者说是替换成变量 var的值,即空值。(因为变量var此时为空,所以这两种说法是等价的) 
          ③${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支持通配符,*表示零个或多个任意字符,?表示仅与一个任意字符匹配,[...]表示匹配中括号里面的字符,[!...]表示不匹配中括号里面的字符
        # var=testcase  
        # echo $var  
        testcase  
        # echo ${var%s*e} 
        testca  
        # echo $var  
        testcase 
        # echo ${var%%s*e} 
        te
        # echo ${var#?e}  
        stcase
        # echo ${var##?e}  
        stcase
        # echo ${var##*e}  
    
        # echo ${var##*s}  
        e  
        # echo ${var##test}  
        case  

     

     4、字符串提取和替换

    ${var:num},${var:num1:num2},${var/pattern/pattern},${var//pattern/pattern}

           第一种模式:${var:num},这种模式时,shell在var中提取第num个字符到末尾的所有字符。若num为正数,从左边0处开始;若num为负数,从右边开始提取字串,但必须使用在冒号后面加空格或一个数字或整个num加上括号,如${var: -2}、${var:1-3}或${var:(-2)}。        
            第二种模式:${var:num1:num2},num1是位置,num2是长度。表示从$var字符串的第$num1个位置开始提取长度为$num2的子串。不能为负数。
           第三种模式:${var/pattern/pattern}表示将var字符串的第一个匹配的pattern替换为另一个pattern。。        
           第四种模式:${var//pattern/pattern}表示将var字符串中的所有能匹配的pattern替换为另一个pattern。
    [root@centos ~]# var=/home/centos
    [root@centos ~]# echo $var
    /home/centos
    [root@centos ~]# echo ${var:5}
    /centos
    [root@centos ~]# echo ${var: -6}
    centos
    [root@centos ~]# echo ${var:(-6)}
    centos
    [root@centos ~]# echo ${var:1:4}
    home
    [root@centos ~]# echo ${var/o/h}
    /hhme/centos
    [root@centos ~]# echo ${var//o/h}
    /hhme/cenths

     

    四、符号$后的括号

    (1)${a} 变量a的值, 在不引起歧义的情况下可以省略大括号。

    (2)$(cmd) 命令替换,和`cmd`效果相同,结果为shell命令cmd的输,过某些Shell版本不支持$()形式的命令替换, 如tcsh。

    (3)$((expression)) 和`exprexpression`效果相同, 计算数学表达式exp的数值, 其中exp只要符合C语言的运算规则即可, 甚至三目运算符和逻辑表达式都可以计算。

    五、使用

    1、多条命令执行

    (1)单小括号,(cmd1;cmd2;cmd3) 新开一个子shell顺序执行命令cmd1,cmd2,cmd3, 各命令之间用分号隔开, 最后一个命令后可以没有分号。

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

     

    展开全文
  • shell中的括号(小括号,中括号,大括号

    万次阅读 多人点赞 2013-09-16 17:39:20
    一、小括号,园括号()  1、单小括号 ()  ①命令组。括号中的命令将会新开一个子shell顺序执行,所以括号中的变量不能够被脚本余下的部分使用。括号中多个命令之间用分号隔开,最后一个命令可以没有分号,各命令...
  • 括号()和大括号{} 主要包括一下几种 ${var} $(cmd) ()和{} $((exp)) ${var:-string},${var:+string},${var:=string},${var:?string} $(var%pattern),$(var%%p
  • 一、小括号,园括号() 1、单小括号 () ①命令组。括号中的命令将会新开一个子shell顺序执行,所以括号中的变量不能够被脚本余下的部分使用。括号中多个命令之间用分号隔开,最后一个命令可以没有分号,各命令和...
  • #include <>格式:引用标准库头文件,编译器从标准库目录开始...#include <stdio> 文件名放在尖括号中 #include “mystuff.h” 文件名放在双引号中 尖括号< 和> 括起来表明这个文件是一个工程或标准头文件。查
  • 更高级一点的说法是:如果此文件被认定为标准的或项目专属的头文件,便以尖括号文件名括住,编译器搜索此文件时,会现在默认的磁盘目录中寻找。如果文件名由成对的引号括住,此文件便被认为是一个用户文件,搜索此...
  • BASH 中单括号和双括号

    千次阅读 2013-08-26 11:28:31
     bash [ ] 单双括号 基本要素: Ø [ ] 两个符号左右都要有空格分隔 Ø 内部操作符与操作变量之间要有空格:如 [ “a” = “b” ] Ø 字符串比较中,> \ Ø [ ] 中字符串或者${}变量尽量使用"" 双引号...
  • bash下的单方括号和双方括号

    千次阅读 2017-07-18 15:54:23
    bash下的单方括号和双方括号概念以及用法:一、bash[ ] 单括号 [ ]两个符号左右都要有空格分隔 内部操作与操作变量之间要有空格: [ val−gt10]字符串比较,><要进行转义,>\<[]中字符串或者val -gt 10 ] 字符串...
  • 摘要:很多人和我一样对于shell的各种括号的各种用法肯定不是很清楚,有时候看见别人脚本都不知道是什么意思,今天就来说说bash中的大中小括号的用法和解释,本人常用bash所以也只能用bash来说明了,若其他shell有...
  • 一、文件名匹配文件名匹配使得您不必一一写出名称,就可以指定多个文件。您将用到一些特殊的字符,称为通配符(wildcards)。假设您想用rm命令删除目录下所有以字符串.bak结尾的文件。除了在rm后跟上所有文件名作为...
  • shell中的各种括号

    2014-03-10 18:10:13
    在编写shell scripts时,经常会用到括号,各种括号,各种用法。 一、括号、圆括号() 1、单小括号。  ①命令组。括号中的命令将会新开一个子shell顺序执行,所以括号中的变量不能够被脚本余下的部分...
  • 在编写shell scripts时,经常会用到括号,各种括号,各种用法。 一、括号、圆括号()  1、单小括号。  ①命令组。括号中的命令将会新开一个子shell顺序执行,所以括号中的变量不能够被脚本余下的部分使用...
  • Shell脚本中各种括号用法

    千次阅读 2017-08-28 20:15:16
    一、小括号,圆括号() 1、单小括号 () ①命令组。括号中的命令将会新开一个子shell顺序执行,所以括号中的变量不能够被脚本余下的部分使用。括号中多个命令之间用分号隔开,最后一个命令可以没有分号,各命令和...
  • C#检查文件名的合法正则表达式

    千次阅读 2015-01-29 13:49:20
    引用 了网友的内容(http://tyllxx.iteye.com/blog/1411669),不过有点小问题,经本人测试,作者原来的代码,无法检查,半角的双引号、大于号以及小于号,本人小改了一下,希望本文能帮到需要用到的朋友 ...
  • shell中的括号(小括号,中括号,大括号) linux中的(),(()),[],[[]],{}的作用 博客转载自 http://www.cnblogs.com/yasmi/articles/5129571.html 一、小括号,园括号() 1、单小括号 () ①命令组。括号中的命令将会...
  • Linux中小括号()和大括号{}都是对其中的一串命令进行执行,但有一定的区别,其区别如下: 1 小括号() ①命令组。括号中的命令新开一个子shell程序,括号中的变量为本地变量 ,不能够在脚本其他部分使用。...
  • 设置 里面找到settings.json,在文件的花括号里加入如下代码 "less.compile": { "out": "${workspaceRoot}\\less\\css\\test" } 其中,${workspaceRoot}是工作台的根路径,\后面的是你的文件夹路径,最后一...
  • php 正则匹配小括号

    2020-10-09 15:57:15
    // 文件名中存在多层序号,组装正则表达式时对序号的括号进行转义,避免影响匹配。如文件名aaa(1)(2) // 例:aaa(1)(2)(22)中匹配到aaa(1)(2)后且为字符串尾的最大序号22 $file_name = 'aaa(1)(2)'; $pattern = ...
  • 命令替换个人理解就是在一个命令里边执行夹杂的其它命令例: touch file-$(date +%F-%H-%M-%S).txt反引号`` 是Tab键上边的那个键 也可用来命令...不完成变量替换 强引用 个人不太理解此两项等以后再做解释文件名通配...
  • 规范内容一般包括:函数命名格式、变量命名格式、大小写、缩进、花括号位置、特殊含义的前缀或后缀、注释格式等。 避免写出“一次性代码” 有的代码,让人一看就想删除了,然后重新实现,重新编码。这就是有一个...
  • shell脚本中各种括号的区别以及用法

    千次阅读 2018-08-19 14:55:33
    最近学到了shell脚本编程,觉得脚本中的不同括号有不同的用处,以及有些括号的格式也有特殊要求,下面我就总结一下各种括号的用法。 一、小括号();双小括号(())  1、单小括号 ()  1:命令替换。等同于`comm`,...
  • shell中的括号

    2015-01-24 15:05:51
    在编写shell scripts时,经常会用到括号,各种括号,各种用法。 一、括号、圆括号()  1、单小括号。  ①命令组。括号中的命令将会新开一个子shell顺序执行,所以括号中的变量不能够被脚本余下的部分使用...
  • bash 中的括号

    千次阅读 2015-12-26 21:15:07
    一、小括号,园括号()  1、单小括号 ()  ①命令组。括号中的命令将会新开一个子shell顺序执行,所以括号中的变量不能够被脚本余下的部分使用。括号中多个命令之间用分号隔开,最后一个命令可以没有分号,各...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 63,073
精华内容 25,229
关键字:

引用文件名的括号