shell编程_shell编程入门 - CSDN
shell编程 订阅
shell 是操作系统的最外层。shell 合并编程语言以控制进程和文件,以及启动和控制其它程序。shell 通过提示您输入,向操作系统解释该输入,然后处理来自操作系统的任何结果输出来管理您与操作系统之间的交互。 展开全文
shell 是操作系统的最外层。shell 合并编程语言以控制进程和文件,以及启动和控制其它程序。shell 通过提示您输入,向操作系统解释该输入,然后处理来自操作系统的任何结果输出来管理您与操作系统之间的交互。
信息
类    别
操作系统
常    见
在ARM技术里有很广的应用
应    用
编程技术
外文名
shell
Shell编程基本概述
shell 提供了与操作系统通信的方式。此通信以交互的方式(来自键盘的输入立即操作)或作为一个 shell 脚本执行。shell 脚本是 shell 和操作系统命令的序列,它存储在文件中。当登录到系统中时,系统定位要执行的 shell 的名称。在它执行之后,shell 显示一个命令提示符。普通用户的此提示符通常是一个 $(美元符)。当提示符下输入命令并按下 Enter 键时,shell 对命令进行求值,并尝试执行它。取决于命令说明,shell 将命令输出写到屏幕或重定向到输出。然后它返回命令提示符,并等待您输入另一个命令。命令行是输入所在的行。它包含 shell 提示符。每行的基本格式如下:$ 命令参数(一个或多个)shell 视命令行的第一个字(直到第一个空白空格)为命令,所有后继字为自变量。在Windows环境下,不论是使用Visual C++还是Delphi或是其他一些软件开发工具开发的应用程序,尽管存在着差别,但有一点是相同的:都是运行于Windows操作系统之下的。在程序开发过程中也经常要在自己的应用程序中加入一些Windows系统本身就有的功能,比如文件的拷贝、删除、查找以及运行程序等等。而这些功能在Windows操作系统下都是具备的,显然如果能直接从系统中调用这些功能将不仅仅减少程序的大小和开发人员的工作量,而且由于是直接通过操作系统来完成这些功能,将会大大减小这部分程序出现异常错误的概率。Windows系统虽说也存在不少错误,但常用功能的错误还是比较少的,而且通过补丁程序可以更低限度减少系统错误,因此程序员可以将调试检错的注意力放在应用程序的其他地方,对于调用系统功能这部分代码则可以不必投入太大的精力去调试,因为这部分调试的工作在操作系统发布的时候就已经由微软做好了。本文通过外壳编程,实现了搜寻文件、运行程序、控制工具条、最大最小化窗口的功能。
收起全文
精华内容
参与话题
  • Linux Shell编程参考大全

    万次阅读 多人点赞 2017-01-02 11:10:19
    本文记录Linux Shell编程中常用基本知识,方便快速入门以及查询使用。

      本文记录Linux Shell编程中常用基本知识,方便快速入门以及查询使用。
      本文主要分为以下几个部分:

    一、Shell中的变量

      任何编程语言中,有关变量的定义,作用范围,赋值等都是最最基础的知识。

    0、默认变量

      首先介绍几个shell中的默认变量。
      

    变量 含义
    $0 当前脚本名称
    $1 脚本接收的第一个参数
    $2 脚本接收的第二个参数
    $# 脚本接收的所有参数个数
    $@ 脚本接收的所有参数
    $* 脚本接收的所有参数
    $? 前一行命令的执行状态

      示例如下:

    hadoop@client:~$ bash default_var.sh a b c d
    $0 ==>  default_var.sh
    $1 ==>  a
    $2 ==>  b
    $# ==>  4
    $@ ==>  a b c d
    $* ==>  a b c d
    $? ==>  0

    1、变量定义及赋值

    hadoop@client:~$ v1=hello
    hadoop@client:~$ echo $v1
    hello

      但是要注意的是,赋值处必须为一个整体,不能有空格。

    hadoop@client:~$ v2=hello world
    No command 'world' found, did you mean:
     Command 'tworld' from package 'tworld' (universe)
    world: command not found

      想要包含空格,需要用单引号或双引号包围,如

    hadoop@client:~$ v2="hello world"
    hadoop@client:~$ echo $v2
    hello world
    hadoop@client:~$ v3='hello world'
    hadoop@client:~$ echo $v3
    hello world

    2、单引号(')和双引号(")的区别

      上面的示例中看到hello world使用单引号或双引号包围再赋值给变量时,两者效果相同,但是其中的区别在哪里?

    hadoop@client:~$ a="hello"
    hadoop@client:~$ b="$a world"
    hadoop@client:~$ echo $b
    hello world
    hadoop@client:~$ c='$a world'
    hadoop@client:~$ echo $c
    $a world

      可以看到,单引号中的$a保持原样输出。而双引号中的$a会替换成其变量值。

    3、`符号

      这个符号在数字键1的左侧,与单引号很类似。但是其功能与单引号双引号都有不同。在该符号中的命令会被执行。

    hadoop@client:~$ d=`date`
    hadoop@client:~$ echo $d
    Wed Dec 28 06:31:13 PST 2016

      如果不想使用这个符号,可以用$()替换

    hadoop@client:~$ e=$(date)
    hadoop@client:~$ echo $e
    Wed Dec 28 06:31:48 PST 2016

    4、命令行交互read

      有时候我们希望在脚本运行时能根据用户的输入决定脚本后续执行逻辑,比如在安装插件的时候经常会让用户选择输入[N/Y]的时候。
      比如有一个脚本script_test.sh

    read -p "Please input [Y/N]: " yn
    
    if [ "$yn" == "N" -o "$yn" == "n" ]; then
      echo "NO"
    elif [ "$yn" == "Y" -o "$yn" == "y" ]; then
      echo "YES"
    fi

      在运行时根据用户的输入决定if分支的走向。运行结果如下

    hadoop@client:~$ sh script_test.sh
    Please input [Y/N]: y
    YES

      read命令的使用形式为

    read [-pt] variable
      参数p:后面可以接提示符
      参数t:后面可以接秒数

      例如,

    read -p "please input your name" -t 5 name

      表示将输入内容赋值给变量name,用户有5秒钟的输入时间。

    5、定义变量类型declare

      默认情况下,变量的赋值内容都是字符类型的。例如下面的代码,我们期望的是输出一个求和值,但是输出的是一个求和表达式。

    hadoop@client:~$ sum=100+300+500
    hadoop@client:~$ echo $sum
    100+300+500

      如果想要输出求和后的值,可以使用declare命令。

    hadoop@client:~$ declare -i sum=100+300+500
    hadoop@client:~$ echo $sum
    900

      declare命令的使用形式如下:

    declare [-aixr] variable
      参数a:将variable定义为数组
      参数i:将variable定义为整型(integer)
      参数x:将variable设置成环境变量,类似于export的作用
      参数r:variable为readonly类型,值不能被更改

    二、Shell中的集合类型

    1、数组(array)

    (1)数组定义和赋值

      数组中的元素用括号包围,各元素之间用空格隔开。例如

    hadoop@client:~$ array_name=(v0 v1 v2 v3)

     
      可以重新设置指定元素的内容,如下所示

    hadoop@client:~$ array_name[2]=v22
    hadoop@client:~$ echo ${array_name[2]}
    v22

      
    (2)数组元素访问

      输出该数组中所有元素:

    hadoop@client:~$ echo ${array_name[*]}
    v0 v1 v22 v3
    hadoop@client:~$ echo ${array_name[@]}
    v0 v1 v22 v3

      数组元素下标从0开始,想要访问指定位置的元素,使用[]指定下标值,如下所示

    hadoop@client:~$ echo ${array_name[0]}
    v0
    hadoop@client:~$ echo ${array_name[1]}
    v1
    hadoop@client:~$ echo ${array_name[3]}
    v3
    hadoop@client:~$ echo ${array_name[2]}
    v2
    hadoop@client:~$ echo ${array_name[4]}
    

     
    (3)获取数组长度

      获取数组长度使用如下命令

    hadoop@client:~$ echo ${#array_name[@]}
    4
    hadoop@client:~$ echo ${#array_name[*]}
    4

      获取数组中单个元素的长度使用如下命令

    hadoop@client:~$ echo ${#array_name[2]}
    3

    2、map

      map类型中存储的都是键值对。
      在Shell中定义map变量如下所示:

    declare -A m=(["a"]="1" ["b"]="2")

      输出所有的key

    hadoop@client:~$ echo ${!m[@]}
    a b

      输出所有的value

    hadoop@client:~$ echo ${m[@]}
    1 2

      输出指定key对应的value

    hadoop@client:~$ echo ${m["a"]}
    1
    hadoop@client:~$ echo ${m["c"]}
    

      添加元素

    hadoop@client:~$ m["c"]="3"
    hadoop@client:~$ echo ${m["c"]}
    3

      map中键值对的个数

    hadoop@client:~$ echo ${#m[@]}
    3

    三、Shell中的字符操作

      在任何语言中对字符串的操作都是非常频繁的。字符串的操作主要包括,字符串截取,字符串替换等。
      接下来的示例中,都以字符串http://blog.csdn.net/dabokele作为初始字符串。

    str="http://blog.csdn.net/dabokele"

    1、字符串删除

      删除前面的http://

    hadoop@client:~$ echo ${str#http://}
    blog.csdn.net/dabokele

      删除后面的dabokele

    hadoop@client:~$ echo ${str%/dabokele}
    http://blog.csdn.net

      #从前往后截取,%从后往前截取。

      示例中表示将符合的最短数据删除,如果使用两个#,或者两个%,则表示将符合的最长数据删除。

      如下所示,匹配最短时,会将https://csdn.ne删除,匹配最长时,会将全部字符删除。

    hadoop@client:~$ echo ${str#http://b*e}
    t/dabokele
    hadoop@client:~$ echo ${str##http://b*e}
    

    2、字符串截取

      可以从字符串的指定位置开始截取,同时可以指定截取的位数,如下所示:

    hadoop@client:~$ echo ${str:2}     // 从第二位开始截取到最末尾,第一个字符下标为0
    tp://blog.csdn.net/dabokele
    hadoop@client:~$ echo ${str:2:3}     // 从第二位开始顺序截取三个字符
    tp:
    hadoop@client:~$ echo ${str:(-6):3}     // 从倒数第六位开始,截取三个字符,最后一个字符下标为-1
    bok

    3、字符串替换

      将http替换成HTTP

    hadoop@client:~$ echo ${str/http/HTTP}
    HTTP://blog.csdn.net/dabokele
    • 使用一个斜杠(/)表示只替换第一个遇到的字符。
    • 使用两个斜杠(//)则表示替换全部符合的字符。
    • 使用#匹配以指定字符开头的字符串。
    • 使用%匹配以指定字符开头的字符串。
    hadoop@client:~$ echo ${str/e/E}
    http://blog.csdn.nEt/dabokele
    hadoop@client:~$ echo ${str//e/E}
    http://blog.csdn.nEt/dabokElE
    hadoop@client:~$ echo ${str/#h/H}     // 匹配开头的那个h
    Http://blog.csdn.net/dabokele
    hadoop@client:~$ echo ${str/e/E}
    http://blog.csdn.nEt/dabokele
    hadoop@client:~$ echo ${str/%e/E}     // 匹配最后那个E,前一个匹配中匹配的是net中的e
    http://blog.csdn.net/dabokelE

    4、字符串默认值

      假设以下这个场景,如果变量name没有赋过值,则给一个默认值default,否则使用指定的值。

    hadoop@client:~$ echo $name
    
    hadoop@client:~$ echo ${name-default}
    default
    hadoop@client:~$ name="ckm"
    hadoop@client:~$ echo ${name-default}
    ckm

      但是,如果已经将变量name设置成“”,则结果如下:

    hadoop@client:~$ name=""
    hadoop@client:~$ echo ${name-default}

      如果变量内容为“”或者变量未初始化则给默认值,可以在-前加个冒号,使用:-

    hadoop@client:~$ name=""
    hadoop@client:~$ echo ${name-default}
    
    hadoop@client:~$ echo ${name:-default}
    default

    5、字符串拼接

      字符串拼接如下所示

    hadoop@client:~$ echo "aaa""bbb"
    aaabbb
    hadoop@client:~$ echo "aaa"$str
    aaahttp://blog.csdn.net/dabokele
    hadoop@client:~$ echo "aaa$str"
    aaahttp://blog.csdn.net/dabokele

    6、字符串长度

      求字符串长度用#操作,如下所示

    hadoop@client:~$ echo ${#str}
    29

    7、字符串split成数组

      在以空格为分隔符分割字符串成数组时操作最简单。

    hadoop@client:~$ s="a b c d e"
    hadoop@client:~$ a=($s)
    hadoop@client:~$ echo ${a[*]}
    a b c d e
    hadoop@client:~$ echo ${a[2]}
    c

      所以,如果需要指定特定字符进行分割,而原字符串中又没有空格时,可以先将特定字符替换成空格,然后按照上述进行分割,如下所示,

    hadoop@client:~$ s="a,b,c,d,e"
    hadoop@client:~$ a=(${s//,/ })
    hadoop@client:~$ echo ${a[*]}
    a b c d e
    hadoop@client:~$ echo ${a[2]}
    c

      如果字符串中本身已有空格,并且期望的分隔符不是空格,按如下方法进行分割。首先将IFS变量替换成指定字符,分割后再将IFS更新为原字符。

    hadoop@client:~$ s="a b,c,d,e"
    hadoop@client:~$ old_ifs="$IFS"
    hadoop@client:~$ s="a b,c,d,e"
    hadoop@client:~$ OLD_IFS="$IFS"
    hadoop@client:~$ IFS=","
    hadoop@client:~$ a=($s)
    hadoop@client:~$ IFS="$OLD_IFS"
    hadoop@client:~$ echo ${a[*]}
    a b c d e
    hadoop@client:~$ echo ${a[0]}
    a b
    hadoop@client:~$ echo ${#a[*]}
    4

    8、字符串包含

      有时候需要判断字符串str1中是否包含字符串str2,使用=~操作符。
      

    str1="hello"
    str2="ell"
    if [[ $str1 =~ $str2 ]];then
     echo "$str1 contains $str2"
    fi

      查看运行结果
      

    hadoop@client~$ sh script_test.sh 
    hello contains ell

    四、Shell中的控制结构

    0、循环接收脚本参数shift

      测试脚本如下:

    echo '原始参数: ' $*
    shift
    echo 'shift后参数: ' $*
    shift 2
    echo 'shift 2后参数: ' $*

      查看脚本运行结果

    hadoop@client:~$ sh script_test.sh a b c d e f g
    原始参数:  a b c d e f g
    shift后参数:  b c d e f g     // 移除第一个参数a
    shift 2后参数:  d e f g     // 继续移除前两个参数b和c

    1、条件表达式

    (1)if … then
      判断表达式是经常用到的。整体结构如下所示,其中iffi是必须的,中间的elifelse是可选的。

    if [ 判断条件1 ]; then
      执行内容1
    elif [ 判断条件2 ]; then
      执行内容2
    else
      执行内容3
    fi

      
    a)算术运算符

      算术运算符的使用格式如下

    a=10
    b=20
    val=expr $a + $b

      常用的算术运算符包括

    运算符 说明 举例
    + 加法 expr $a + $b 结果为 30。
    - 减法 expr $a - $b 结果为 10。
    * 乘法 expr $a \* $b 结果为 200。
    / 除法 expr $b / $a 结果为 2。
    % 取余 expr $b % $a 结果为 0。
    = 赋值 a=$b将把变量 b 的值赋给 a。
    == 相等 用于比较两个数字,相同则返回 true。[ $a == $b ] 返回 false。
    != 不相等 用于比较两个数字,不相同则返回 true。[ $a != $b ] 返回 true。

      
    b)关系运算符
      关系运算符的使用格式如下

    a=10
    b=20
    $a -eq $b

      常用的关系运算符包括

    运算符 说明 举例
    -eq 检测两个数是否相等,相等返回 true。 [ $a -eq $b ] 返回 true。
    -ne 检测两个数是否相等,不相等返回 true。 [ $a -ne $b ] 返回 true。
    -gt 检测左边的数是否大于右边的,如果是,则返回 true。 [ $a -gt $b ] 返回 false。
    -lt 检测左边的数是否小于右边的,如果是,则返回 true。 [ $a -lt $b ] 返回 true。
    -ge 检测左边的数是否大等于右边的,如果是,则返回 true。 [ $a -ge $b ] 返回 false。
    -le 检测左边的数是否小于等于右边的,如果是,则返回 true。 [ $a -le $b ] 返回 true。

      
    c)布尔运算符
      常用的布尔运算符如下

    运算符 说明 举例
    ! 非运算,表达式为 true 则返回 false,否则返回 true。 [ ! false ] 返回 true。
    -o 或运算,有一个表达式为 true 则返回 true。 [ $a -lt 20 -o $b -gt 100 ] 返回 true。
    -a 与运算,两个表达式都为 true 才返回 true。 [ $a -lt 20 -a $b -gt 100 ] 返回 false。

      
    d)字符串运算符
      常用的字符串运算符如下

    运算符 说明 举例
    = 检测两个字符串是否相等,相等返回 true。 [ $a = $b ] 返回 false。
    != 检测两个字符串是否相等,不相等返回 true。 [ $a != $b ] 返回 true。
    -z 检测字符串长度是否为0,为0返回 true。 [ -z $a ] 返回 false。
    -n 检测字符串长度是否为0,不为0返回 true。 [ -n $a ] 返回 true。
    str 检测字符串是否为空,不为空返回 true。 [ $a ] 返回 true。

      
    e)文件测试运算符
      常用的文件测试运算符如下

    运算符 说明 举例
    -b file 检测文件是否是块设备文件,如果是,则返回 true。 [ -b $file ] 返回 false。
    -c file 检测文件是否是字符设备文件,如果是,则返回 true。 [ -b $file ] 返回 false。
    -d file 检测文件是否是目录,如果是,则返回 true。 [ -d $file ] 返回 false。
    -f file 检测文件是否是普通文件(既不是目录,也不是设备文件),如果是,则返回 true。 [ -f $file ] 返回 true。
    -g file 检测文件是否设置了 SGID 位,如果是,则返回 true。 [ -g $file ] 返回 false。
    -k file 检测文件是否设置了粘着位(Sticky Bit),如果是,则返回 true。 [ -k $file ] 返回 false。
    -p file 检测文件是否是具名管道,如果是,则返回 true。 [ -p $file ] 返回 false。
    -u file 检测文件是否设置了 SUID 位,如果是,则返回 true。 [ -u $file ] 返回 false。
    -r file 检测文件是否可读,如果是,则返回 true。 [ -r $file ] 返回 true。
    -w file 检测文件是否可写,如果是,则返回 true。 [ -w $file ] 返回 true。
    -x file 检测文件是否可执行,如果是,则返回 true。 [ -x $file ] 返回 true。
    -s file 检测文件是否为空(文件大小是否大于0),不为空返回 true。 [ -s $file ] 返回 true。
    -e file 检测文件(包括目录)是否存在,如果是,则返回 true。 [ -e $file ] 返回 true。

      
    (2)case … esac
      case表达式的使用格式如下

    case $变量 in
      "内容1")
          程序1
      ;;
      "内容2")
          程序2
      ;;
      *)     #匹配其他所有情况
          程序3
      ;;
    esac

      看一个示例,如果第一个参数为hello,则打印hello world。如果第一个参数是bye,则打印bye bye。如果是另外的情况,则输出该参数。

    case $$1 in
      "hello")
          echo "hello world"
      ;;
      "bye")
          echo "bye bye"
      ;;
      "*")
          echo $1
      ;;
    esac

      运行结果

    hadoop@client:~$ sh script_test.sh hello
    hello world
    hadoop@client:~$ sh script_test.sh bye
    bye bye
    hadoop@client:~$ sh script_test.sh hehe
    hehe

    2、循环表达式

    (1)while do done, untile do done
      while循环的格式如下

    while [ condition ]
    do
      程序
    done

      与while循环相反的是until循环。

    while [ condition ]
    do
      程序
    done

      在while循环中,当条件满足使,就执行其中的程序。而until循环中,当条件不成立时就终止循环。

      下面举例用两种循环来实现当输入为yes时跳出循环。
      
    a) while循环示例如下

    while [ "$yn" != "yes" ]
    do
      read -p "Please input yes to stop: " yn
    done
    
    echo "Stop!"

      运行结果

    hadoop@client:~$ sh script_test.sh
    Please input yes to stop: no
    Please input yes to stop: no
    Please input yes to stop: yes
    Stop!

      
    b) until循环示例如下

    until [ "$yn" == "yes" ]
    do
      read -p "Please input yes to stop: " yn
    done
    
    echo "Stop!"

      运行结果如下

    hadoop@client:~$ sh script_test.sh
    Please input yes to stop: no
    Please input yes to stop: yes
    Stop!

      
    (2)for … do … done
      for循环的格式如下

    for var in con1 con2 con3 ...
    do
      程序
    done

      下面这个示例循环打印输入参数列表

    for arg in $*
    do
      echo $arg
    done

      运行结果如下

    hadoop@client:~$ sh script_test.sh a b c d e
    a
    b
    c
    d
    e

      
    (3)for … do … done的另一种形式
      for循环的另一种个数如下

    for ((初始值; 目标值; 步长))
    do
      程序
    done

      循环输出110中的奇数

    for ((i=1; i<=10; i=i+2))
    do
      echo $i
    done

      运行结果如下

    hadoop@client:~$ bash script_test.sh
    1
    3
    5
    7
    9

    五、Shell中的函数

      在Shell中也可以像其他编程语言那样,将代码块封装成函数。Shell中的函数,需要注意以下两点:
      

    1、函数定义

      由于Shell是从上往下执行的,所以在定义函数之前就调用该函数的话,会提示command not found,例如
      

    echo "Before :" `printFunc`
    
    function printFunc() {
      echo "print function !"
    }
    
    echo "After :" `printFunc`

      运行结果如下,前一个函数调用处提示command not found  

    hadoop@client:~$ sh script_test.sh 
    2_script_test.sh: line 3: printFunc: command not found
    Before :
    After : print function !

    2、函数参数与shell参数

      在Shell中定义的函数,是可以传递和接收参数的。在子函数中,$1表示接收的第一个参数…,这里需要注意与shell参数的区别。
      但是测试后发现$0表示的仍然是shell名称。如果想要显示当前函数名,可以使用$FUNCNAME参数,如下所示,  

    function printStr() {
      echo "printStr function print: $FUNCNAME"
      echo "printStr function print: $*"
    }
    
    echo "main print: $0"
    echo "main print: $*"
    
    printStr f1 f2 f3

      运行结果如下,

    [hadoop@client ~]$ sh script_test.sh m1 m2 m3
    shell name : script_test.sh
    shell params : m1 m2 m3
    function name : printStr
    function params : f1 f2 f3

    六、vi快捷操作

      下面操作中出现大写字母,比如G表示需要同时按住ShiftG键。n表示输入的数字。其他比如text则表示字符串。

    1、跳转

    按键 说明
    gg 跳转到第一行
    G 跳转到最后一行
    ngg / nG 跳转到最后一行
    Ctrl+f 向下翻页
    Ctrl+b 向上翻页
    h 光标左移
    j 光标下移
    k 光标上移
    l 光标右移
    w 移到下一个单词的开头
    W 移到下一个单词的开头,忽略标点
    b 移到上一个单词的开头
    B 移到上一个单词的开头,忽略标点
    e 移到下一个单词的末尾
    E 移到下一个单词的末尾,忽略标点
    nw/nW/nb/nB 跳转n个单词
    L 移到当前屏幕最后一行
    M 移到当前屏幕中间行
    $ 到当前行最后一个字符
    ^ 到当前行第一个字符
    0 到当前行第一个字符
    n
    ( 到句子开头
    ) 到句子结尾
    { 到段落开头
    } 到段落结尾

    2、查找和替换

    (1)查找

    按键 说明
    /text 向后查找text字符
    ?text 向前查找text字符
    n 跳转至下一个text字符
    N 跳转至上一个text字符
    :set ic 查找时忽略大小写
    :set noic 查找时对大小写敏感

    (2)替换

    按键 说明
    :s/oldtext/newtext/ 替换当前行第一个oldtext为newtext
    :s/oldtext/newtext/g 替换当前行所有oldtext为newtext
    :m,ns/oldtext/newtext/ 在m行到n,用newtext替换第一个oldtext
    :1,$s/oldtext/newtext/ 在1行到最后一行,用newtext替换第一个oldtext
    :m,ns/oldtext/newtext/g 在m行到n,用newtext替换oldtext
    :1,$s/oldtext/newtext/g 在1行到最后一行,用newtext替换oldtext

      在最后输入一个(confirm),表示替换前弹出确认提示。按y则逐一替换当前光标处匹配的字符,n则跳过当前光标处字符,a替换全部匹配的字符。

    3、复制、删除、撤销、重复

    (1) 复制

    按键 说明
    yy 复制当前行
    nyy 复制当前及向下n行
    p 将复制内容黏贴到下一行
    P 将复制内容黏贴到上一行

      另外,输入y+跳转中的操作,可以为复制指定方向。比如yw,从当前位置复制到下一个单词的开头。这样可以进行复制一个单词的操作。

    (2)删除

    按键 说明
    dd 删除当前行(按p可黏贴)
    ndd 从当前行向下删除n行
    dG 从当前行删除到最后一行
    dgg 从当前行删除到第一行
    :n,md 从第n行删除到第m行
    x 删除当前字符
    nx 删除当前向后n个字符
    X 删除光标前的字符
    nx 删除当前向前n个字符

      另外,输入d+跳转中的操作,可以为删除指定方向。比如dw,从当前位置删除至下一个单词的开头。

    (3)撤销

    按键 说明
    u 撤销上一次操作
    U 撤销当前行所有操作
    . 重复最后一次操作

    (4)重复

    按键 说明
    . 重复最后一次操作

    4、其他

    按键 说明
    J 将下一行连接到本行末尾
    nJ 将下n行连接到本行末尾
    ~ 将当前字符切换大小写
    n~ 将当前向后n个字符切换大小写
    ~ 将当前字符切换大小写
    g~~ 切换当前行大小写
    u 列编辑模式下,选中列转换成小写
    U 列编辑模式下,选中列转换成大写
    guu 当前行转换成小写
    gUU 当前行转换成大写
    guw 当前单词转换成小写
    gUw 当前单词转换成大写

    5、列编辑

      按Ctrl + v,进入列编辑模式。
      
    (1)删除列
      进入列编辑模式,
      移动光标,选中需要删除的列,
      按d,则会删除选中内容。

    (2)插入列
      进入列编辑模式,
      移动光标选中需要插入内容的列。
      按shift + i,会在选中列的第一行输入想要插入的内容。
      连续按两次ESC,则会在选中的列处全部插入输入字符。

    展开全文
  • shell编程详解

    千次阅读 2019-12-09 21:55:23
    本文主要从以下8 个方面介绍Linux下的shell编程: 一、Shell 编程概述 二、Shell 关键字 三、Shell 变量 四、Shell 运算 五、Shell 语句 六、Shell 函数 七、Shell 调试 八、Shell 易错点 一、Shell 编程...

    本文摘要

    本文主要从以下8 个方面介绍Linux下的shell编程:

    • 一、Shell 编程概述
    • 二、Shell 关键字
    • 三、Shell 变量
    • 四、Shell 运算
    • 五、Shell 语句
    • 六、Shell 函数
    • 七、Shell 调试
    • 八、Shell 易错点

    一、Shell 编程概述

    shell编程是 Linux 下的一门脚本语言——Shell 脚本。这个脚本语言可以帮助我们简化很多工作,例如编写自定义命令等,所以还是很有必要学习它的基本用法的,一个简单的 hello.sh 脚本像下面这样,第一行 #!/bin/bash 标识该 Shell 脚本由哪个 Shell 解释

    #!/bin/bash 
    
    echo "Hello World!"

    可以有以下两种执行方式

    # 1.直接执行
    bash hello.sh
    sh   hello.sh
    
    # 2.赋予可执行权限后执行
    chmod a+x hello.sh
    # 执行
    ./hello.sh
    
    # 结果
    Hello World!

    Shell 的编写流程: 
    1. 编写 Shell 脚本 
    2. 执行 
    3. 调试

    下面来介绍具体的语法

    二、Shell 关键字

    常用的关键字如下: 
    1. echo:打印文字到屏幕 
    2. read:读标准输入 
    3. exec:执行另一个 Shell 脚本
    4. expr:对整数型变量进行算术运算 
    5. test:用于测试变量是否相等、 是否为空、文件类型等 
    6. exit:退出

    例如:

    #!/bin/bash 
    
    echo "Hello Shell\nInput number:"
    
    # 读入变量
    read VAR
    echo "VAR is $VAR"
    
    # 计算变量
    expr $VAR - 5
    
    # 测试字符串
    test "Hello"="HelloWorld"
    
    # 测试整数
    test $VAR -eq 10
    
    # 测试目录
    test -d ./Android
    
    # 执行其他 Shell 脚本
    exec ./othershell.sh
    
    # 退出
    exit

    运行前,你需要新建一个 othershell.sh 的文件,让它输出 I'm othershell,并且中途需要一次输入。

    运行结果:

    Hello Shell
    Input number:
    10
    VAR is 10
    5
    I'm othershell
    

    学习任何一门语言都要了解它的变量定义方法,Shell 也不例外。

    三、Shell 变量

    Shell 变量分为 3 种: 
    1. 用户变量 
    2. 系统变量 
    3. 环境变量

    1. 用户变量

    定义用户变量需要注意下面 2 点: 
    1. 等号前后不能有空格:num=10 
    2. 使用 $+变量名 调用变量

    常见有 3 个对用户变量进行操作的前缀: 

    1. unset:删除变量 
    2. readonly:标记只读变量 
    3. export:指定全局变量

    例如:

    #!/bin/bash 
    
    # 定义普通变量 str
    str=SHENZHEN
    
    # 定义全局变量 name
    export name=cdeveloper
    
    # 定义只读变量 num
    readonly num=21
    
    # 打印变量的值
    echo $str
    echo $name
    echo $num
    
    # 删除 str 变量
    unset str
    # 不会输出 SHENZHEN
    echo $str

    运行结果:

    SHENZHEN
    cdeveloper
    21
    
    

    2. 系统变量

    常用的系统变量有下面这些:

    1. $0 :当前程序的名称
    2. $n:第n个命令行参数(n从0开始计算)
    3. $# :命令行参数个数(除$0)
    4. $@ :所有命令行参数
    5. $* :所有命令行参数
    6. $? :前一个命令的退出状态,可用于获取函数返回值
    7. $$ :当前进程的 ID

    例如:(example.sh)

    #!/bin/bash 
    
    echo "print $"
    echo "\$0 = $0"
    echo "\$1 = $1"
    echo "\$2 = $2"
    echo "\$# = $#"
    echo "\$@ = $@"
    echo "\$* = $*"
    echo "\$? = $?"
    echo "\$$ = $$"

    执行./example.sh 1 2 3 4 5 的结果:

    print $
    $0 = ./example.sh  //程序名
    $1 = 1  //第一个参数
    $2 = 2  //第二个参数
    $# = 5  //命令行参数个数,这里一共5个
    $@ = 1 2 3 4 5  //所有命令行参数
    $* = 1 2 3 4 5  //所有命令行参数
    $? = 0  //之前没有执行其他命令或者函数
    $$ = 9450  //进程 ID

    3. 环境变量

    Shell 环境变量是所有 shell程序都会接受的一组参数,常用的有下面这几个: 
    1. HOME:用户主目录 
    2. PATH:系统环境变量 PATH 
    3. TERM:当前终端 
    4. UID:当前用户 ID 
    5. PWD:当前工作目录,绝对路径

    例如:

    #!/bin/bash
    
    echo "print ENV"
    
    echo "\$HOME = $HOME"
    echo "\$PATH = $PATH"
    echo "\$TERM = $TERM"
    echo "\$PWD = $PWD"
    echo "\$UID = $UID"

    运行结果:

    print EVN
    
    # 当前主目录
    $HOME = /root
    
    # PATH 环境变量
    $PATH = /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
    
    # 当前终端
    $TERM = xterm
    
    # 当前目录
    $PWD = /home/linux_shell
    
    # 用户 ID
    $UID = 1000

    四、Shell 运算

    1.算术比较运算

     

                 算术比较          内容                           结果
    expr1  -eq  expr2          ==   expr1 与 expr2 相等则结果为真
    expr1  -ne  expr2          !=   expr1 与 expr2 不相等则结果为真
    expr1  -gt  expr2          >   expr1 大于 expr2 则结果为真
    expr1  -ge  expr2          >=   expr1 大于或等于 expr2 则结果为真
    expr1  -lt  expr2          <   expr1 小于 expr2 则结果为真
    expr1  -le  expr2          <=   expr1 小于或等于 expr2 则结果为真


    2.算术计算

    下面是 4 种比较常见的运算方法,功能都是将 m + 1: 
    1. m=$[ m + 1 ] 
    2. m=`expr $m+1`  #一定要在两边加 ` 符号
    3. let m=m+1 
    4. m=$(( m + 1 ))

    例如:

    #!/bin/bash 
    
    m=1
    m=$[ m + 1 ]
    echo $m
    
    m=`expr $m + 1`    #注意:这个语法+号左右要加空格
    echo $m
    
    # 注意:这个语法+号左右不要加空格
    let m=m+1
    echo $m
    
    m=$((m + 1))
    echo $m

    运行结果:

    2
    3
    4
    5

    五、Shell 语句

    Shell 语句跟高级语言有些类似,也包括分支,跳转,循环等。

    1. if 语句

    shell 的 if 结构为 if then - elif then - else,if 的判断条件主要有两种形式,例如:

    #!/bin/bash 
    
    echo "Inpu a number:"
    read VAR
    
    # 下面这两种判断方法都可以,注意使用 
    
    if [ $VAR -lt 10 ]  #第一种,[] 左右一定要加空格
    then
        echo "小于10"
    elif test $VAR -eq 10  #第二种
    then
        echo "等于10"
    else
        echo "大于10"
    fi  

    2. case 语句

    case 语句有些复杂,要注意格式:

    #!/bin/bash 
    
    echo "Input a string:";
    read NAME
    # 格式有点复杂,一定要注意
    case $NAME in
        "Linux")
            echo "Linux";;  #若有多条语句只能在最后一条后面加;;
        "Unix")
            echo "Unix" ;;
        *)
            echo "Not Linux or Unix" ;;
    esac

    运行结果:

    root@ubuntu:/home/linux_shell# sh case.sh
    Input a string:
    Linux
    Linux
    
    root@ubuntu:/home/linux_shell# sh case.sh
    Input a string:
    Unix
    Unix
    
    root@ubuntu:/home/linux_shell# sh case.sh
    Input a string:
    1234
    Not Linux or Unix
    

    3. for 循环

    for 循环有以下两种基本使用方法:(以 do 和 done 表示循环范围)

    #!/bin/bash 
    
    # 第一种,一定是 ((  ))
    for ((i = 1; i <= 3; i++)) 
    do
        echo $i
    done
    
    # 第二种,VAR 依次代表每个元素 
    for VAR in 4 5 6
    do
        echo $VAR
    done

    运行结果:

    1
    2
    3
    4
    5
    6

    4. while 循环

    注意与 for 循环的区别:

    #!/bin/bash
    
    echo "请输入一个字符:"
    read ch
    
    while [ "1" = "1" ]  #while 的死循环
    do
       case $ch in
          "Y")
             echo "Right!"
             break;;
          "N")
             echo "Wrong!"
             break;;
          *)
             echo -e "\n输入有误!请重新输入:"
             read ch;;
       esac
    done

    运行结果:

    root@ubuntu:/home/linux_shell# bash while.sh 
    请输入一个字符:
    t
    
    输入有误!请重新输入:
    y
    
    输入有误!请重新输入:
    N
    Wrong!
    

    5. until 循环

    until 语句可译为 “直到...的时候”,与上面的循环的不同点是它的结束条件为:判断结果为1时结束

    #!/bin/bash 
    
    i=1
    
    # 直到 i 等于 5 时,循环结束 
    until [[ "$i" -eq 5 ]]     
    do  
        echo $i
        i=$[ $i + 1 ]
    done

    运行结果:

    1
    2
    3
    4

    6. break

    Shell 中的 break 用法与高级语言相同,都是跳出循环

    #!/bin/bash 
    
    for VAR in 1 2 3 4 5
    do
        if [ $VAR -eq 4 ]; then #不要忘了then
            break
        fi
    
        echo $VAR
    done

    运行结果:

    1
    2
    3

    7. continue

    continue 用来跳过本次循环,进入下一次循环,例如:

    #!/bin/bash 
    
    for VAR in 1 2 3 4 5
    do
    #   如果 VAR 等于 4,就跳过,直接进入下一次 VAR = 5 的循环 
        if [ $VAR -eq 4 ]
        then
            continue    
        fi
    
        echo $VAR
    done

    运行结果:

    1
    2
    3
    5

    每种编程语言中函数都占有重要地位,下面介绍 Shell 编程中比较重要的函数。

    六、Shell 函数

    函数可以用一句话解释:带有输入输出的具有一定功能的黑盒子,相信有过编程经验的同学不会陌生。那么,我们先来看看 Shell 中函数定义的格式。

    1. 定义函数

    有 2 种常见格式:

    #第一种
    function fun_name()
    {    }
    
    #第二种
    fun_name()
    {    }

    例如:

    #!/bin/bash 
    
    hello()
    {
        echo "hello function"
    }
    
    function hello_world()
    {
        echo "hello_world function"
        echo $1  $2   #打印第 1 2 个参数
        return 5
    }

    2. 调用函数

    如何调用上面的 2 个函数呢?

    # 1.直接用函数名调用函数,如
    hello
    hello_world 1 2  #有参数记得跟上参数列表
    
    # 2.使用 FUN=`函数名 [参数列表]` 来间接调用
    FUN1=`hello`
    FUN2=`hello_world 3 4`
    
    echo $FUN1
    echo $FUN2

    运行结果

    root@ubuntu:/home/linux_shell# bash function.sh 
    hello function
    hello_world function
    1 2
    hello function
    hello_world function 3 4
    

    3. 获取函数返回值

    如何获取 hello_world 函数的返回值呢?还记得 $? 吗?

    hello_world 1 2
    # $? 可用于获取前一个函数的返回值,这里结果是 5
    echo $?
    
    运行结果:
    root@ubuntu:/home/linux_shell# bash return.sh 
    hello_world function
    1 2
    5
    

    4.shell中默认为全局变量

    shell中变量默认为全局变量,例如:

    #!/bin/bash
    VAR=123
    
    #define function
    example()
    {
        VAR=456
    }
    
    echo $VAR  #改变前的VAR
    example    #调用函数
    echo $VAR  #改变后的VAR
    
    #运行结果:
    #123
    #456

    5. 定义本地变量

    使用 local 来在函数中定义本地变量:

    #!/bin/bash
    VAR=123
    
    #define function
    example()
    {
        local VAR=456
        echo $VAR
    }
    
    example    #调用函数
    echo $VAR  #调用后的VAR
    
    #运行结果:
    #456
    #123

    俗话说,程序 3 分靠写、7 分靠调,下面我们就来看看如何调试 Shell 程序。

    七、Shell 调试

    使用下面的命令来检查是否有语法错误

    sh -n script_name.sh

    使用下面的命令来执行并调试 Shell 脚本

    sh -x script_name.sh

    来看个实际的例子,我们来调试下面这个 test.sh 程序:

    #!/bin/bash
    
    for VAR in 1 2 3 4 5
    do
        if [ $VAR -eq 2 ]; then
            continue 
        elif [ $VAR -eq 4 ]; then
            continue   
        fi
        echo $VAR
    done

    首先检查有无语法错误:

    sh -n test.sh

    没有输出,说明没有错误,开始实际调试:

    sh -x test.sh

    调试结果如下:

    root@ubuntu:/home/linux_shell# bash -x debug.sh 
    + for VAR in 1 2 3 4 5
    + '[' 1 -eq 2 ']'
    + '[' 1 -eq 4 ']'
    + echo 1
    1
    + for VAR in 1 2 3 4 5
    + '[' 2 -eq 2 ']'
    + continue
    + for VAR in 1 2 3 4 5
    + '[' 3 -eq 2 ']'
    + '[' 3 -eq 4 ']'
    + echo 3
    3
    + for VAR in 1 2 3 4 5
    + '[' 4 -eq 2 ']'
    + '[' 4 -eq 4 ']'
    + continue
    + for VAR in 1 2 3 4 5
    + '[' 5 -eq 2 ']'
    + '[' 5 -eq 4 ']'
    + echo 5
    5
    

    其中带有 + 表示的是 Shell 调试器的输出不带 + 表示我们程序的输出

    八、Shell 易错点

    初学者在 Shell 编程时容易犯的大多都是语法错误: 
    1. [ ] 内不能嵌套 ( ),可以嵌套 [ ] 
    2. $[ val + 1 ] 是变量加 1 的常用方法 
    3. [ ] 在测试或者计算中里面的内容最好都加空格 
    4. 单引号和双引号差不多,单引号更加严格,双引号可以嵌套单引号 
    5. 一定要注意语句的格式,例如缩进、空格等.

     

     

     

    展开全文
  • Linux下Shell从入门到精通完整版

    千人学习 2020-02-26 17:50:00
    本套课程适用于初学者以及各类运维人员,我们可以通过本次的编程技术学习,明白并掌握企业里面的运维编程脚本,同时掌握企业运维到底要求会什么东西,有哪些是我们必须要掌握的知识。
  • Linux之shell编程

    万次阅读 2018-09-22 10:23:51
    shell编程 shell历史  Shell的作用是解释执行用户的命令,用户输入一条命令,Shell就解释执行一条,这种方式称为交互式(Interactive),Shell还有一种执行命令的方式称为批处理(Batch),用户事先写一个Shell...

    shell编程

    shell历史

           Shell的作用是解释执行用户的命令,用户输入一条命令,Shell就解释执行一条,这种方式称为交互式(Interactive),Shell还有一种执行命令的方式称为批处理(Batch),用户事先写一个Shell脚本(Script),其中有很多条命令,让Shell一次把这些命令执行完,而不必一条一条地敲命令。Shell脚本和编程语言很相似,也有变量和流程控制语句,但Shell脚本是解释执行的,不需要编译,Shell程序从脚本中一行一行读取并执行这些命令,相当于一个用户把脚本中的命令一行一行敲到Shell提示符下执行。

           由于历史原因,UNIX系统上有很多种Shell:

    1. sh(Bourne Shell):由Steve Bourne开发,各种UNIX系统都配有sh。
    2. csh(C Shell):由Bill Joy开发,随BSD UNIX发布,它的流程控制语句很像C语言,支持很多Bourne Shell所不支持的功能:作业控制,命令历史,命令行编辑。
    3. ksh(Korn Shell):由David Korn开发,向后兼容sh的功能,并且添加了csh引入的新功能,是目前很多UNIX系统标准配置的Shell,在这些系统上/bin/sh往往是指向/bin/ksh的符号链接。
    4. tcsh(TENEX C Shell):是csh的增强版本,引入了命令补全等功能,在FreeBSD、MacOS X等系统上替代了csh。
    5. bash(Bourne Again Shell):由GNU开发的Shell,主要目标是与POSIX标准保持一致,同时兼顾对sh的兼容,bash从csh和ksh借鉴了很多功能,是各种Linux发行版标准配置的Shell,在Linux系统上/bin/sh往往是指向/bin/bash的符号链接。虽然如此,bash和sh还是有很多不同的,一方面,bash扩展了一些命令和参数,另一方面,bash并不完全和sh兼容,有些行为并不一致,所以bash需要模拟sh的行为:当我们通过sh这个程序名启动bash时,bash可以假装自己是sh,不认扩展的命令,并且行为与sh保持一致。

    itcast$ vim /etc/passwd

           其中最后一列显示了用户对应的shell类型

            root:x:0:0:root:/root:/bin/bash

            nobody:x:65534:65534:nobody:/nonexistent:/bin/sh

            syslog:x:101:103::/home/syslog:/bin/false

            itcast:x:1000:1000:itcast,,,:/home/itcast:/bin/bash

            ftp:x:115:125:ftp daemon,,,:/srv/ftp:/bin/false

           用户在命令行输入命令后,一般情况下Shell会fork并exec该命令,但是Shell的内建命令例外,执行内建命令相当于调用Shell进程中的一个函数,并不创建新的进程。以前学过的cd、alias、umask、exit等命令即是内建命令,凡是用which命令查不到程序文件所在位置的命令都是内建命令,内建命令没有单独的man手册,要在man手册中查看内建命令,应该执行

    itcast$ man bash-builtins

           如export、shift、if、eval、[、for、while等等。内建命令虽然不创建新的进程,但也会有Exit Status,通常也用0表示成功非零表示失败,虽然内建命令不创建新的进程,但执行结束后也会有一个状态码,也可以用特殊变量$?读出。

    执行脚本

             编写一个简单的脚本test.sh:

    #! /bin/sh

    cd ..

    ls

            Shell脚本中用#表示注释,相当于C语言的//注释。但如果#位于第一行开头,并且是#!(称为Shebang)则例外,它表示该脚本使用后面指定的解释器/bin/sh解释执行。如果把这个脚本文件加上可执行权限然后执行:

    itcast$ chmod a+x test.sh

    itcast$ ./test.sh

           Shell会fork一个子进程并调用exec执行./test.sh这个程序,exec系统调用应该把子进程的代码段替换成./test.sh程序的代码段,并从它的_start开始执行。然而test.sh是个文本文件,根本没有代码段和_start函数,怎么办呢?其实exec还有另外一种机制,如果要执行的是一个文本文件,并且第一行用Shebang指定了解释器,则用解释器程序的代码段替换当前进程,并且从解释器的_start开始执行,而这个文本文件被当作命令行参数传给解释器。因此,执行上述脚本相当于执行程序

    itcast$ /bin/sh ./test.sh

            以这种方式执行不需要test.sh文件具有可执行权限。

            如果将命令行下输入的命令用()括号括起来,那么也会fork出一个子Shell执行小括号中的命令,一行中可以输入由分号;隔开的多个命令,比如:

    itcast$ (cd ..;ls -l)

             和上面两种方法执行Shell脚本的效果是相同的,cd ..命令改变的是子Shell的PWD,而不会影响到交互式Shell。然而命令

    itcast$ cd ..;ls -l

             则有不同的效果,cd ..命令是直接在交互式Shell下执行的,改变交互式Shell的PWD,然而这种方式相当于这样执行Shell脚本:

    itcast$ source ./test.sh

            或者

    itcast$ . ./test.sh

            source或者.命令是Shell的内建命令,这种方式也不会创建子Shell,而是直接在交互式Shell下逐行执行脚本中的命令。

    基本语法

    变量

    按照惯例,Shell变量通常由字母加下划线开头,由任意长度的字母、数字、下划线组成。有两种类型的Shell变量:

           1、环境变量

            环境变量可以从父进程传给子进程,因此Shell进程的环境变量可以从当前Shell进程传给fork出来的子进程。用printenv命令可以显示当前Shell进程的环境变量。

           2、本地变量

            只存在于当前Shell进程,用set命令可以显示当前Shell进程中定义的所有变量(包括本地变量和环境变量)和函数。

            环境变量是任何进程都有的概念,而本地变量是Shell特有的概念。在Shell中,环境变量和本地变量的定义和用法相似。在Shell中定义或赋值一个变量:

    itcast$ VARNAME=value

            注意等号两边都不能有空格,否则会被Shell解释成命令和命令行参数。

            一个变量定义后仅存在于当前Shell进程,它是本地变量,用export命令可以把本地变量导出为环境变量,定义和导出环境变量通常可以一步完成:

    itcast$ export VARNAME=value

              也可以分两步完成:

    itcast$ VARNAME=value

    itcast$ export VARNAME

             用unset命令可以删除已定义的环境变量或本地变量。

    itcast$ unset VARNAME

            如果一个变量叫做VARNAME,用 ' VARNAME ' 可以表示它的值,在不引起歧义的情况下也可以用VARNAME表示它的值。通过以下例子比较这两种表示法的不同:

    itcast$ echo $SHELL

           注意,在定义变量时不用“'”取变量值时要用。和C语言不同的是,Shell变量不需要明确定义类型,事实上Shell变量的值都是字符串,比如我们定义VAR=45,其实VAR的值是字符串45而非整数。Shell变量不需要先定义后使用,如果对一个没有定义的变量取值,则值为空字符串。

    文件名代换(Globbing)

             这些用于匹配的字符称为通配符(Wildcard),如:* ? [ ] 具体如下:

         * 匹配0个或多个任意字符

          ? 匹配一个任意字符

           [若干字符] 匹配方括号中任意一个字符的一次出现

     

    itcast$ ls /dev/ttyS*

    itcast$ ls ch0?.doc

    itcast$ ls ch0[0-2].doc

    itcast$ ls ch[012] [0-9].doc

            注意,Globbing所匹配的文件名是由Shell展开的,也就是说在参数还没传给程序之前已经展开了,比如上述ls ch0[012].doc命令,如果当前目录下有ch00.doc和ch02.doc,则传给ls命令的参数实际上是这两个文件名,而不是一个匹配字符串。

    命令代换

             由“`”反引号括起来的也是一条命令,Shell先执行该命令,然后将输出结果立刻代换到当前命令行中。例如定义一个变量存放date 命令的输出:

    itcast$ DATE=`date`

    itcast$ echo $DATE

            命令代换也可以用$()表示:

    itcast$ DATE=$(date)

    算术代换

            使用$(()),用于算术计算,(())中的Shell变量取值将转换成整数,同样含义的$[ ]等价例如:

    itcast$ VAR=45

    itcast$ echo $(($VAR+3)) 等价于 echo $[VAR+3]或 $[$VAR+3]

           $(())中只能用+-*/和()运算符,并且只能做整数运算。

           $[base#n],其中base表示进制,n按照base进制解释,后面再有运算数,按十进制解释。

    echo $[2#10+11]

    echo $[8#10+11]

    echo $[16#10+11]

    转义字符

           和C语言类似,\在Shell中被用作转义字符,用于去除紧跟其后的单个字符的特殊意义(回车除外),换句话说,紧跟其后的字符取字面值。例如:

    itcast$ echo $SHELL

    /bin/bash

    itcast$ echo \$SHELL

    $SHELL

    itcast$ echo \\

    \

            比如创建一个文件名为“$ $”的文件($间含有空格)可以这样:

    itcast$ touch \$\ \$

           还有一个字符虽然不具有特殊含义,但是要用它做文件名也很麻烦,就是-号。如果要创建一个文件名以-号开头的文件,这样是不正确的:

    itcast$ touch -hello

    touch: invalid option -- h

    Try `touch --help' for more information.

             即使加上\转义也还是报错:

    itcast$ touch \-hello

    touch: invalid option -- h

    Try `touch --help' for more information.

           因为各种UNIX命令都把-号开头的命令行参数当作命令的选项,而不会当作文件名。如果非要处理以-号开头的文件名,可以有两种办法:

    itcast$ touch ./-hello

           或者

    itcast$ touch -- -hello

           \还有一种用法,在\后敲回车表示续行,Shell并不会立刻执行命令,而是把光标移到下一行,给出一个续行提示符>,等待用户继续输入,最后把所有的续行接到一起当作一个命令执行。例如:

    itcast$ ls \

    > -l

    (ls -l命令的输出)

    单引号

            和C语言同,Shell脚本中的单引号和双引号一样都是字符串的界定符(双引号下一节介绍),而不是字符的界定符。单引号用于保持引号内所有字符的字面值,即使引号内的\和回车也不例外,但是字符串中不能出现单引号。如果引号没有配对就输入回车,Shell会给出续行提示符,要求用户把引号配上对。例如:

    itcast$ echo '$SHELL'

    $SHELL

    itcast$ echo 'ABC\(回车)

    > DE'(再按一次回车结束命令)

    ABC\

    DE

    双引号

              被双引号用括住的内容,将被视为单一字串。它防止通配符扩展,但允许变量扩展。这点与单引号的处理方式不同

    itcast$ DATE=$(date)

    itcast$ echo "$DATE"

    itcast$ echo '$DATE'

             再比如:

    itcast$ VAR=200

    itcast$ echo $VAR

    200

    itcast$ echo '$VAR'

    $VAR

    itcast$ echo "$VAR"

    200

     

    Shell脚本语法

    条件测试

             命令test或 [ 可以测试一个条件是否成立,如果测试结果为真,则该命令的Exit Status为0,如果测试结果为假,则命令的Exit Status为1(注意与C语言的逻辑表示正好相反)。例如测试两个数的大小关系:

    itcast@ubuntu:~$ var=2

    itcast@ubuntu:~$ test $var -gt 1

    itcast@ubuntu:~$ echo $?

    0

    itcast@ubuntu:~$ test $var -gt 3

    itcast@ubuntu:~$ echo $?

    1

    itcast@ubuntu:~$ [ $var -gt 3 ]

    itcast@ubuntu:~$ echo $?

    1

    itcast@ubuntu:~$

           虽然看起来很奇怪,但左方括号 [ 确实是一个命令的名字,传给命令的各参数之间应该用空格隔开,比如:$VAR、-gt、3、] 是 [ 命令的四个参数,它们之间必须用空格隔开。命令test或 [ 的参数形式是相同的,只不过test命令不需要 ] 参数。以 [ 命令为例,常见的测试命令如下表所示:

    [ -d DIR ] 如果DIR存在并且是一个目录则为真

    [ -f FILE ] 如果FILE存在且是一个普通文件则为真

    [ -z STRING ] 如果STRING的长度为零则为真

    [ -n STRING ] 如果STRING的长度非零则为真

    [ STRING1 = STRING2 ] 如果两个字符串相同则为真

    [ STRING1 != STRING2 ] 如果字符串不相同则为真

    [ ARG1 OP ARG2 ] ARG1和ARG2应该是整数或者取值为整数的变量,OP是-eq(等于)-ne(不等于)-lt(小于)-le(小于等于)-gt(大于)-ge(大于等于)之中的一个

             和C语言类似,测试条件之间还可以做与、或、非逻辑运算:

    [ ! EXPR ] EXPR可以是上表中的任意一种测试条件,!表示“逻辑反(非)”

    [ EXPR1 -a EXPR2 ] EXPR1和EXPR2可以是上表中的任意一种测试条件,-a表示“逻辑与”

    [ EXPR1 -o EXPR2 ] EXPR1和EXPR2可以是上表中的任意一种测试条件,-o表示“逻辑或”

           例如:

    $ VAR=abc

    $ [ -d Desktop -a $VAR = 'abc' ]

    $ echo $?

    0

            注意,如果上例中的$VAR变量事先没有定义,则被Shell展开为空字符串,会造成测试条件的语法错误(展开为[ -d Desktop -a = ‘abc’ ]),作为一种好的Shell编程习惯应该总是把变量取值放在双引号之中(展开为[ -d Desktop -a “” = ‘abc’ ]):

    $ unset VAR

    $ [ -d Desktop -a $VAR = 'abc' ]

    bash: [: too many arguments

    $ [ -d Desktop -a "$VAR" = 'abc' ]

    $ echo $?

    1

    分支

    if/then/elif/else/fi

           和C语言类似,在Shell中用if、then、elif、else、fi这几条命令实现分支控制。这种流程控制语句本质上也是由若干条Shell命令组成的,例如先前讲过的

    if [ -f ~/.bashrc ]; then

        . ~/.bashrc

    fi

          其实是三条命令,if [ -f ∼/.bashrc ]是第一条,then . ∼/.bashrc是第二条,fi是第三条。如果两条命令写在同一行则需要用;号隔开,一行只写一条命令就不需要写;号了,另外,then后面有换行,但这条命令没写完,Shell会自动续行,把下一行接在then后面当作一条命令处理。和[命令一样,要注意命令和各参数之间必须用空格隔开。if命令的参数组成一条子命令,如果该子命令的Exit Status为0(表示真),则执行then后面的子命令,如果Exit Status非0(表示假),则执行elif、else或者fi后面的子命令。if后面的子命令通常是测试命令,但也可以是其它命令。Shell脚本没有{}括号,所以用fi表示if语句块的结束。见下例:

    #! /bin/sh

     

    if [ -f /bin/bash ]

    then

           echo "/bin/bash is a file"

    else

           echo "/bin/bash is NOT a file"

    fi

    if :; then echo "always true"; fi

            “:”是一个特殊的命令,称为空命令,该命令不做任何事,但Exit Status总是真。此外,也可以执行/bin/true或/bin/false得到真或假的Exit Status。再看一个例子:

    #! /bin/sh

     

    echo "Is it morning? Please answer yes or no."

    read YES_OR_NO

    if [ "$YES_OR_NO" = "yes" ]; then

           echo "Good morning!"

    elif [ "$YES_OR_NO" = "no" ]; then

           echo "Good afternoon!"

    else

           echo "Sorry, $YES_OR_NO not recognized. Enter yes or no."

           exit 1

    fi

    exit 0

           上例中的read命令的作用是等待用户输入一行字符串,将该字符串存到一个Shell变量中。

           此外,Shell还提供了&&和||语法,和C语言类似,具有Short-circuit特性,很多Shell脚本喜欢写成这样:

    test "$(whoami)" != 'root' && (echo you are using a non-privileged account; exit 1)

            &&相当于“if…then…”,而||相当于“if not…then…”。&&和||用于连接两个命令,而上面讲的-a和-o仅用于在测试表达式中连接两个测试条件,要注意它们的区别,例如:

    test "$VAR" -gt 1 -a "$VAR" -lt 3

              和以下写法是等价的

    test "$VAR" -gt 1 && test "$VAR" -lt 3

    case/esac

           case命令可类比C语言的switch/case语句,esac表示case语句块的结束。C语言的case只能匹配整型或字符型常量表达式,而Shell脚本的case可以匹配字符串和Wildcard,每个匹配分支可以有若干条命令,末尾必须以;;结束,执行时找到第一个匹配的分支并执行相应的命令,然后直接跳到esac之后,不需要像C语言一样用break跳出。

    #! /bin/sh

     

    echo "Is it morning? Please answer yes or no."

    read YES_OR_NO

    case "$YES_OR_NO" in

    yes|y|Yes|YES)

            echo "Good Morning!";;

    [nN]*)

            echo "Good Afternoon!";;

    *)

             echo "Sorry, $YES_OR_NO not recognized. Enter yes or no."

             exit 1;;

    esac

    exit 0

           使用case语句的例子可以在系统服务的脚本目录/etc/init.d中找到。这个目录下的脚本大多具有这种形式(以/etc/init.d/nfs-kernel-server为例):

    case "$1" in

           start)

                 ...

           ;;

           stop)

                ...

            ;;

            reload | force-reload)

                ...

            ;;

           restart)

                ...

           *)

               log_success_msg"Usage: nfs-kernel-server {start|stop|status|reload|force-reload|restart}"

               exit 1

           ;;

    esac

            启动nfs-kernel-server服务的命令是

    $ sudo /etc/init.d/nfs-kernel-server start

           $1是一个特殊变量,在执行脚本时自动取值为第一个命令行参数,也就是start,所以进入start)分支执行相关的命令。同理,命令行参数指定为stop、reload或restart可以进入其它分支执行停止服务、重新加载配置文件或重新启动服务的相关命令。

    循环

    for/do/done

            Shell脚本的for循环结构和C语言很不一样,它类似于某些编程语言的foreach循环。例如:

    #! /bin/sh

     

    for FRUIT in apple banana pear; do

          echo "I like $FRUIT"

    done

            FRUIT是一个循环变量,第一次循环$FRUIT的取值是apple,第二次取值是banana,第三次取值是pear。再比如,要将当前目录下的chap0、chap1、chap2等文件名改为chap0~、chap1~、chap2~等(按惯例,末尾有~字符的文件名表示临时文件),这个命令可以这样写:

    $ for FILENAME in chap?; do mv $FILENAME $FILENAME~; done

            也可以这样写:

    $ for FILENAME in `ls chap?`; do mv $FILENAME $FILENAME~; done

    while/do/done

           while的用法和C语言类似。比如一个验证密码的脚本:

    #! /bin/sh

     

    echo "Enter password:"

    read TRY

    while [ "$TRY" != "secret" ]; do

           echo "Sorry, try again"

           read TRY

    done

              下面的例子通过算术运算控制循环的次数:

    #! /bin/sh

     

    COUNTER=1

    while [ "$COUNTER" -lt 10 ]; do

           echo "Here we go again"

           COUNTER=$(($COUNTER+1))

    done

            另,Shell还有until循环,类似C语言的do…while。如有兴趣可在课后自行扩展学习。

    break和continue

           break[n]可以指定跳出几层循环;continue跳过本次循环,但不会跳出循环。

           即break跳出,continue跳过。

           练习:将上面验证密码的程序修改一下,如果用户输错五次密码就报错退出。

    位置参数和特殊变量

           有很多特殊变量是被Shell自动赋值的,我们已经遇到了$?和$1。其他常用的位置参数和特殊变量在这里总结一下:

    $0 相当于C语言main函数的argv[0]

    $1、$2... 这些称为位置参数(Positional Parameter),相当于C语言main函数的argv[1]、argv[2]...

    $# 相当于C语言main函数的argc - 1,注意这里的#后面不表示注释

    $@ 表示参数列表"$1" "$2" ...,例如可以用在for循环中的in后面。

    $* 表示参数列表"$1" "$2" ...,同上

    $? 上一条命令的Exit Status

    $$ 当前进程号

           位置参数可以用shift命令左移。比如shift 3表示原来的$4现在变成$1,原来的$5现在变成$2等等,原来的$1、$2、$3丢弃,$0不移动。不带参数的shift命令相当于shift 1。例如:

    #! /bin/sh

     

    echo "The program $0 is now running"

    echo "The first parameter is $1"

    echo "The second parameter is $2"

    echo "The parameter list is $@"

    shift

    echo "The first parameter is $1"

    echo "The second parameter is $2"

    echo "The parameter list is $@"

    输入输出

    echo

           显示文本行或变量,或者把字符串输入到文件。

    echo [option] string

    -e 解析转义字符

    -n 不回车换行。默认情况echo回显的内容后面跟一个回车换行。

    echo "hello\n\n"

    echo -e "hello\n\n"

    echo "hello"

    echo -n "hello"

    管道

              可以通过 | 把一个命令的输出传递给另一个命令做输入。

    cat myfile | more

    ls -l | grep "myfile"

    df -k | awk '{print $1}' | grep -v "文件系统"

    df -k 查看磁盘空间,找到第一列,去除“文件系统”,并输出

    tee

             tee命令把结果输出到标准输出,另一个副本输出到相应文件。

    df -k | awk '{print $1}' | grep -v "文件系统" | tee a.txt

            tee -a a.txt表示追加操作。

    df -k | awk '{print $1}' | grep -v "文件系统" | tee -a a.txt

    文件重定向

    cmd > file 把标准输出重定向到新文件中

    cmd >> file 追加

    cmd > file 2>&1 标准出错也重定向到1所指向的file里

    cmd >> file 2>&1

    cmd < file1 > file2 输入输出都定向到文件里

    cmd < &fd 把文件描述符fd作为标准输入

    cmd > &fd 把文件描述符fd作为标准输出

    cmd < &- 关闭标准输入

    函数

            和C语言类似,Shell中也有函数的概念,但是函数定义中没有返回值也没有参数列表。例如:

    #! /bin/sh

     

    foo(){ echo "Function foo is called";}

    echo "-=start=-"

    foo

    echo "-=end=-"

           注意函数体的左花括号 { 和后面的命令之间必须有空格或换行,如果将最后一条命令和右花括号 } 写在同一行,命令末尾必须有分号;。但,不建议将函数定义写至一行上,不利于脚本阅读。

            在定义foo()函数时并不执行函数体中的命令,就像定义变量一样,只是给foo这个名一个定义,到后面调用foo函数的时候(注意Shell中的函数调用不写括号)才执行函数体中的命令。Shell脚本中的函数必须先定义后调用,一般把函数定义语句写在脚本的前面,把函数调用和其它命令写在脚本的最后(类似C语言中的main函数,这才是整个脚本实际开始执行命令的地方)。

           Shell函数没有参数列表并不表示不能传参数,事实上,函数就像是迷你脚本,调用函数时可以传任意个参数,在函数内同样是用$0、$1、$2等变量来提取参数,函数中的位置参数相当于函数的局部变量,改变这些变量并不会影响函数外面的$0、$1、$2等变量。函数中可以用return命令返回,如果return后面跟一个数字则表示函数的Exit Status。

          下面这个脚本可以一次创建多个目录,各目录名通过命令行参数传入,脚本逐个测试各目录是否存在,如果目录不存在,首先打印信息然后试着创建该目录。

    #! /bin/sh

     

    is_directory()

    {

          DIR_NAME=$1

           if [ ! -d $DIR_NAME ]; then

                    return 1

            else

                    return 0

             fi

    }

    for DIR in "$@"; do

          if is_directory "$DIR"

          then :

          else

                 echo "$DIR doesn't exist. Creating it now..."

                  mkdir $DIR > /dev/null 2>&1

                  if [ $? -ne 0 ]; then

                       echo "Cannot create directory $DIR"

                       exit 1

                  fi

          fi

    done

           注意:is_directory()返回0表示真返回1表示假。

    Shell脚本调试方法

    Shell提供了一些用于调试脚本的选项,如:

          -n 读一遍脚本中的命令但不执行,用于检查脚本中的语法错误。

          -v 一边执行脚本,一边将执行过的脚本命令打印到标准错误输出。

          -x 提供跟踪执行信息,将执行的每一条命令和结果依次打印出来。

    这些选项有三种常见的使用方法:

    1、在命令行提供参数。如:

    $ sh -x ./script.sh

    2、在脚本开头提供参数。如:

    #! /bin/sh -x

    3、在脚本中用set命令启用或禁用参数。如:

    #! /bin/sh

     

    if [ -z "$1" ]; then

        set -x

        echo "ERROR: Insufficient Args."

        exit 1

        set +x

    fi

           set -x和set +x分别表示启用和禁用-x参数,这样可以只对脚本中的某一段进行跟踪调试。

    正则表达式

            以前我们用grep在一个文件中找出包含某些字符串的行,比如在头文件中找出一个宏定义。其实grep还可以找出符合某个模式(Pattern)的一类字符串。例如找出所有符合xxxxx@xxxx.xxx模式的字符串(也就是email地址),要求x字符可以是字母、数字、下划线、小数点或减号,email地址的每一部分可以有一个或多个x字符,例如abc.d@ef.com、1_2@987-6.54,当然符合这个模式的不全是合法的email地址,但至少可以做一次初步筛选,筛掉a.b、c@d等肯定不是email地址的字符串。再比如,找出所有符合yyy.yyy.yyy.yyy模式的字符串(也就是IP地址),要求y是0-9的数字,IP地址的每一部分可以有1-3个y字符。

           如果要用grep查找一个模式,如何表示这个模式,这一类字符串,而不是一个特定的字符串呢?从这两个简单的例子可以看出,要表示一个模式至少应该包含以下信息:

            字符类(Character Class):如上例的x和y,它们在模式中表示一个字符,但是取值范围是一类字符中的任意一个。

           数量限定符(Quantifier): 邮件地址的每一部分可以有一个或多个x字符,IP地址的每一部分可以有1-3个y字符。

    各种字符类以及普通字符之间的位置关系:例如邮件地址分三部分,用普通字符@和.隔开,IP地址分四部分,用.隔开,每一部分都可以用字符类和数量限定符描述。为了表示位置关系,还有位置限定符(Anchor)的概念,将在下面介绍。

           规定一些特殊语法表示字符类、数量限定符和位置关系,然后用这些特殊语法和普通字符一起表示一个模式,这就是正则表达式(Regular Expression)。例如email地址的正则表达式可以写成[a-zA-Z0-9.-]+@[a-zA-Z0-9.-]+.[a-zA-Z0-9_.-]+,IP地址的正则表达式可以写成[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}。下一节介绍正则表达式的语法,我们先看看正则表达式在grep中怎么用。例如有这样一个文本文件testfile:

    192.168.1.1

    1234.234.04.5678

    123.4234.045.678

    abcde

    $ egrep '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' testfile

    192.168.1.1

    1234.234.04.5678

            egrep相当于grep -E,表示采用Extended正则表达式语法。grep的正则表达式有Basic和Extended两种规范,它们之间的区别下一节再解释。另外还有fgrep命令,相当于grep -F,表示只搜索固定字符串而不搜索正则表达式模式,不会按正则表达式的语法解释后面的参数。

            注意正则表达式参数用单引号括起来了,因为正则表达式中用到的很多特殊字符在Shell中也有特殊含义(例如),只有用单引号括起来才能保证这些字符原封不动地传给grep命令,而不会被Shell解释掉。

          192.168.1.1符合上述模式,由三个.隔开的四段组成,每段都是1到3个数字,所以这一行被找出来了,可为什么1234.234.04.5678也被找出来了呢?因为grep找的是包含某一模式的行,这一行包含一个符合模式的字符串234.234.04.567。相反,123.4234.045.678这一行不包含符合模式的字符串,所以不会被找出来。

            grep是一种查找过滤工具,正则表达式在grep中用来查找符合模式的字符串。其实正则表达式还有一个重要的应用是验证用户输入是否合法,例如用户通过网页表单提交自己的email地址,就需要用程序验证一下是不是合法的email地址,这个工作可以在网页的Javascript中做,也可以在网站后台的程序中做,例如PHP、Perl、Python、Ruby、Java或C,所有这些语言都支持正则表达式,可以说,目前不支持正则表达式的编程语言实在很少见。除了编程语言之外,很多UNIX命令和工具也都支持正则表达式,例如grep、vi、sed、awk、emacs等等。“正则表达式”就像“变量”一样,它是一个广泛的概念,而不是某一种工具或编程语言的特性。

    基本语法

           我们知道C的变量和Shell脚本变量的定义和使用方法很不相同,表达能力也不相同,C的变量有各种类型,而Shell脚本变量都是字符串。同样道理,各种工具和编程语言所使用的正则表达式规范的语法并不相同,表达能力也各不相同,有的正则表达式规范引入很多扩展,能表达更复杂的模式,但各种正则表达式规范的基本概念都是相通的。本节介绍egrep(1)所使用的正则表达式,它大致上符合POSIX正则表达式规范,详见regex(7)(看这个man page对你的英文绝对是很好的锻炼)。希望读者仿照上一节的例子,一边学习语法,一边用egrep命令做实验。

    字符类

    数量限定符

              再次注意grep找的是包含某一模式的行,而不是完全匹配某一模式的行。

              例如有如下文本:

    aaabc

    aad

    efg

           查找a*这个模式的结果。会发现,三行都被找了出来。

    $ egrep 'a*' testfile

    aaabc

    aad

    efg

            a匹配0个或多个a,而第三行包含0个a,所以也包含了这一模式。单独用a这样的正则表达式做查找没什么意义,一般是把a*作为正则表达式的一部分来用。

    位置限定符

          位置限定符可以帮助grep更准确地查找。

          例如上一节我们用[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}查找IP地址,找到这两行

    192.168.1.1

    1234.234.04.5678

           如果用^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$查找,就可以把1234.234.04.5678这一行过滤掉了。

    其它特殊字符

    Basic正则和Extended正则区别

            以上介绍的是grep正则表达式的Extended规范,Basic规范也有这些语法,只是字符?+{}|()应解释为普通字符,要表示上述特殊含义则需要加\转义。如果用grep而不是egrep,并且不加-E参数,则应该遵照Basic规范来写正则表达式。

    grep

    1、作用

               Linux系统中grep命令是一种强大的文本搜索工具,它能使用正则表达式搜索文本,并把匹 配的行打印出来。grep全称是Global Regular Expression Print,表示全局正则表达式版本,它的使用权限是所有用户。

              grep家族包括grep、egrep和fgrep。egrep和fgrep的命令只跟grep有很小不同。egrep是grep的扩展,支持更多的re元字符, fgrep就是fixed grep或fast grep,它们把所有的字母都看作单词,也就是说,正则表达式中的元字符表示回其自身的字面意义,不再特殊。linux使用GNU版本的grep。它功能更强,可以通过-G、-E、-F命令行选项来使用egrep和fgrep的功能。

    2、格式及主要参数

    grep [options]

    主要参数:  grep --help可查看

                     -c:只输出匹配行的计数。

                      -i:不区分大小写。

                      -h:查询多文件时不显示文件名。

                       -l:查询多文件时只输出包含匹配字符的文件名。

                      -n:显示匹配行及 行号。

                      -s:不显示不存在或无匹配文本的错误信息。

                     -v:显示不包含匹配文本的所有行。

                     --color=auto :可以将找到的关键词部分加上颜色的显示。

            pattern正则表达式主要参数:

    \: 忽略正则表达式中特殊字符的原有含义。

    ^:匹配正则表达式的开始行。

    $: 匹配正则表达式的结束行。

    \<:从匹配正则表达 式的行开始。

    \>:到匹配正则表达式的行结束。

    [ ]:单个字符,如[A]即A符合要求 。

    [ - ]:范围,如[A-Z],即A、B、C一直到Z都符合要求 。

    .:所有的单个字符。

    *:所有字符,长度可以为0。

    3、grep命令使用简单实例

    itcast$ grep ‘test’ d*

    显示所有以d开头的文件中包含 test的行

     

    itcast $ grep ‘test’ aa bb cc

    显示在aa,bb,cc文件中匹配test的行。

     

    itcast $ grep ‘[a-z]\{5\}’ aa

    显示所有包含每个字符串至少有5个连续小写字符的字符串的行。

     

    itcast $ grep ‘w\(es\)t.*\1′ aa

    如果west被匹配,则es就被存储到内存中,并标记为1,然后搜索任意个字符(.*),这些字符后面紧跟着 另外一个es(\1),找到就显示该行。如果用egrep或grep -E,就不用”\”号进行转义,直接写成’w(es)t.*\1′就可以了。

    4、grep命令使用复杂实例

    明确要求搜索子目录:

    grep -r

    或忽略子目录

    grep -d skip

    如果有很多输出时,您可以通过管道将其转到’less’上阅读:

    itcast$ grep magic /usr/src/Linux/Documentation/* | less

    这样,您就可以更方便地阅读。

    有一点要注意,您必需提供一个文件过滤方式(搜索全部文件的话用 *)。如果您忘了,’grep’会一直等着,直到该程序被中断。如果您遇到了这样的情况,按 ,然后再试。

    下面还有一些有意思的命令行参数:

    grep -i pattern files :不区分大小写地搜索。默认情况区分大小写,

    grep -l pattern files :只列出匹配的文件名,

    grep -L pattern files :列出不匹配的文件名,

    grep -w pattern files :只匹配整个单词,而不是字符串的一部分(如匹配’magic’,而不是’magical’),

    grep -C number pattern files :匹配的上下文分别显示[number]行,

    grep pattern1 | pattern2 files :显示匹配 pattern1 或 pattern2 的行,

    例如:grep "abc\|xyz" testfile 表示过滤包含abc或xyz的行

    grep pattern1 files | grep pattern2 :显示既匹配 pattern1 又匹配 pattern2 的行。

    grep -n pattern files 即可显示行号信息

    grep -c pattern files 即可查找总行数

    还有些用于搜索的特殊符号:\< 和 \> 分别标注单词的开始与结尾。

    例如:

    grep man * 会匹配 ‘Batman’、’manic’、’man’等,

    grep ‘\<man’ * 匹配’manic’和’man’,但不是’Batman’,

    grep ‘\<man\>’ 只匹配’man’,而不是’Batman’或’manic’等其他的字符串。

    ‘^’: 指匹配的字符串在行首,

    ‘$’: 指匹配的字符串在行 尾,

    find

    由于find具有强大的功能,所以它的选项也很多,其中大部分选项都值得我们花时间来了解一下。即使系统中含有网络文件系统( NFS),find命令在该文件系统中同样有效,只要你具有相应的权限。

    在运行一个非常消耗资源的find命令时,很多人都倾向于把它放在后台执行,因为遍历一个大的文件系统可能会花费很长的时间(这里是指30G字节以上的文件系统)。

    一、find 命令格式

    1、find命令的一般形式为

    find pathname -options [-print -exec -ok ...]

    2、find命令的参数;

    pathname: find命令所查找的目录路径。例如用.来表示当前目录,用/来表示系统根目录,递归查找。

    -print: find命令将匹配的文件输出到标准输出。

    -exec: find命令对匹配的文件执行该参数所给出的shell命令。相应命令的形式为'command' {} \;,注意{}内部无空格,和\;之间含有一个空格分隔符。

    -ok: 和-exec的作用相同,只不过以一种更为安全的模式来执行该参数所给出的shell命令,在执行每一个命令之前,都会给出提示,让用户来确定是否执行。

    3、find命令选项

    -name 按照文件名查找文件。

    -perm 按照文件权限来查找文件。

    -prune 使用这一选项可以使find命令不在当前指定的目录中查找,如果同时使用-depth选项,那么-prune将被

    find命令忽略。

    -user 按照文件属主来查找文件。

    -group 按照文件所属的组来查找文件。

    -mtime -n +n 按照文件的更改时间来查找文件,-n表示文件更改时间距现在n天以内,+n表示文件更改时间距现在

    n天以前。find命令还有-atime和-ctime 选项,但它们都和-m time选项。

    -nogroup 查找无有效所属组的文件,即该文件所属的组在/etc/groups中不存在。

    -nouser 查找无有效属主的文件,即该文件的属主在/etc/passwd中不存在。

    -newer file1 ! file2 查找更改时间比文件file1新但比文件file2旧的文件。

    -type 查找某一类型的文件,诸如:

    b - 块设备文件。

    d - 目录。

    c - 字符设备文件。

    p - 管道文件。

    l - 符号链接文件。

    f - 普通文件。

    -size n:[c] 查找文件长度为n块的文件,带有c时表示文件长度以字节计。

    -depth 在查找文件时,首先查找当前目录中的文件,然后再在其子目录中查找。

    -fstype 查找位于某一类型文件系统中的文件,这些文件系统类型通常可以在配置文件/etc/fstab中找到,该配

    置文件中包含了本系统中有关文件系统的信息。

    -mount 在查找文件时不跨越文件系统mount点。

    -follow 如果find命令遇到符号链接文件,就跟踪至链接所指向的文件。

    另外,下面三个的区别:

    -amin n 查找系统中最后N分钟访问的文件

    -atime n 查找系统中最后n*24小时访问的文件

    -cmin n 查找系统中最后N分钟被改变文件状态的文件

    -ctime n 查找系统中最后n*24小时被改变文件状态的文件

    -mmin n 查找系统中最后N分钟被改变文件数据的文件

    -mtime n 查找系统中最后n*24小时被改变文件数据的文件

    4、使用exec或ok来执行shell命令

            使用find时,只要把想要的操作写在一个文件里,就可以用exec来配合find查找,很方便的。

             在有些操作系统中只允许-exec选项执行诸如ls或ls -l这样的命令。大多数用户使用这一选项是为了查找旧文件并删除它们。建议在真正执行rm命令删除文件之前,最好先用ls命令看一下,确认它们是所要删除的文件。

             exec选项后面跟随着所要执行的命令或脚本,然后是一对儿{},一个空格和一个\,最后是一个分号。为了使用exec选项,必须要同时使用print选项。如果验证一下find命令,会发现该命令只输出从当前路径起的相对路径及文件名。

             例如:为了用ls -l命令列出所匹配到的文件,可以把ls -l命令放在find命令的-exec选项中

    # find . -type f -exec ls -l {} \;

            上面的例子中,find命令匹配到了当前目录下的所有普通文件,并在-exec选项中使用ls -l命令将它们列出。

           在/logs目录中查找更改时间在5日以前的文件并删除它们:

    $ find logs -type f -mtime +5 -exec rm {} \;

           记住:在shell中用任何方式删除文件之前,应当先查看相应的文件,一定要小心!当使用诸如mv或rm命令时,可以使用-exec选项的安全模式。它将在对每个匹配到的文件进行操作之前提示你。

           在下面的例子中, find命令在当前目录中查找所有文件名以.LOG结尾、更改时间在5日以上的文件,并删除它们,只不过在删除之前先给出提示。

    $ find . -name "*.conf" -mtime +5 -ok rm {} \;

    < rm ... ./conf/httpd.conf > ? n

            按y键删除文件,按n键不删除。

           任何形式的命令都可以在-exec选项中使用。

          在下面的例子中我们使用grep命令。find命令首先匹配所有文件名为“ passwd*”的文件,例如passwd、passwd.old、passwd.bak,然后执行grep命令看看在这些文件中是否存在一个itcast用户。

    # find /etc -name "passwd*" -exec grep "itcast" {} \;

    itcast:x:1000:1000::/home/itcast:/bin/bash

     

    二、find命令的例子;

    1、查找当前用户主目录下的所有文件:

    下面两种方法都可以使用

    $ find $HOME -print

    $ find ~ -print

    2、让当前目录中文件属主具有读、写权限,并且文件所属组的用户和其他用户具有读权限的文件;

    $ find . -type f -perm 644 -exec ls -l {} \;

    3、为了查找系统中所有文件长度为0的普通文件,并列出它们的完整路径;

    $ find / -type f -size 0 -exec ls -l {} \;

    4、查找/var/logs目录中更改时间在7日以前的普通文件,并在删除之前询问它们;

    $ find /var/logs -type f -mtime +7 -ok rm {} \;

    5、为了查找系统中所有属于root组的文件;

    $find . -group root -exec ls -l {} \;

    6、find命令将删除当目录中访问时间在7日以来、含有数字后缀的admin.log文件。

    该命令只检查三位数字,所以相应文件的后缀不要超过999。先建几个admin.log*的文件 ,才能使用下面这个命令

    $ find . -name "admin.log[0-9][0-9][0-9]" -atime -7 -ok rm {} \;

    7、为了查找当前文件系统中的所有目录并排序;

    $ find . -type d | sort

    三、xargs

    xargs - build and execute command lines from standard input

           在使用find命令的-exec选项处理匹配到的文件时, find命令将所有匹配到的文件一起传递给exec执行。但有些系统对能够传递给exec的命令长度有限制,这样在find命令运行几分钟之后,就会出现 溢出错误。错误信息通常是“参数列太长”或“参数列溢出”。这就是xargs命令的用处所在,特别是与find命令一起使用。

           find命令把匹配到的文件传递给xargs命令,而xargs命令每次只获取一部分文件而不是全部,不像-exec选项那样。这样它可以先处理最先获取的一部分文件,然后是下一批,并如此继续下去。

            在有些系统中,使用-exec选项会为处理每一个匹配到的文件而发起一个相应的进程,并非将匹配到的文件全部作为参数一次执行;这样在有些情况下就会出现进程过多,系统性能下降的问题,因而效率不高;

            而使用xargs命令则只有一个进程。另外,在使用xargs命令时,究竟是一次获取所有的参数,还是分批取得参数,以及每一次获取参数的数目都会根据该命令的选项及系统内核中相应的可调参数来确定。

            来看看xargs命令是如何同find命令一起使用的,并给出一些例子。

            下面的例子查找系统中的每一个普通文件,然后使用xargs命令来测试它们分别属于哪类文件

    #find . -type f -print | xargs file

    在当前目录下查找所有用户具有读、写和执行权限的文件,并收回相应的写权限:

    # ls -l

    # find . -perm -7 -print | xargs chmod o-w

    # ls -l

    用grep命令在所有的普通文件中搜索hello这个词:

    # find . -type f -print | xargs grep "hello"

    用grep命令在当前目录下的所有普通文件中搜索hello这个词:

    # find . -name \* -type f -print | xargs grep "hello"

             注意,在上面的例子中, \用来取消find命令中的*在shell中的特殊含义。

             find命令配合使用exec和xargs可以使用户对所匹配到的文件执行几乎所有的命令。

    四、find 命令的参数

               下面是find一些常用参数的例子,有用到的时候查查就行了,也可以用man。

    1、使用name选项

                文件名选项是find命令最常用的选项,要么单独使用该选项,要么和其他选项一起使用。

                可以使用某种文件名模式来匹配文件,记住要用引号将文件名模式引起来。

                不管当前路径是什么,如果想要在自己的根目录HOME中查找文件名符合∗.txt的文件,使用‘~’作为 ‘pathname’ 的参数,波浪号代表了你的HOME目录。

    $ find ~ -name "*.txt" -print

    想要在当前目录及子目录中查找所有的‘ *.txt’文件,可以用:

    $ find . -name "*.txt" -print

    想要的当前目录及子目录中查找文件名以一个大写字母开头的文件,可以用:

    $ find . -name "[A-Z]*" -print

    想要在/etc目录中查找文件名以host开头的文件,可以用:

    $ find /etc -name "host*" -print

    想要查找$HOME目录中的文件,可以用:

    $ find ~ -name "*" -print 或find . –print

    要想让系统高负荷运行,就从根目录开始查找所有的文件:

    $ find / -name "*" -print

    如果想在当前目录查找文件名以两个小写字母开头,跟着是两个数字,最后是.txt的文件,下面的命令就能够返回例如名为ax37.txt的文件:

    $find . -name "[a-z][a-z][0-9][0-9].txt" -print

    2、用perm选项

             按照文件权限模式用-perm选项,按文件权限模式来查找文件的话。最好使用八进制的权限表示法。

            如在当前目录下查找文件权限位为755的文件,即文件属主可以读、写、执行,其他用户可以读、执行的文件,可以用:

    $ find . -perm 755 -print

    还有一种表达方法:在八进制数字前面要加一个横杠-,表示都匹配,如-007就相当于777,-006相当于666

    # ls -l

    # find . -perm 006

    # find . -perm -006

    -perm mode:文件许可正好符合mode

    -perm +mode:文件许可部分符合mode

    -perm -mode: 文件许可完全符合mode

    3、忽略某个目录

           如果在查找文件时希望忽略某个目录,因为你知道那个目录中没有你所要查找的文件,那么可以使用-prune选项来指出需要忽略的目录。在使用-prune选项时要当心,因为如果你同时使用了-depth选项,那么-prune选项就会被find命令忽略。

            如果希望在/apps目录下查找文件,但不希望在/apps/bin目录下查找,可以用:

    $ find /apps -path "/apps/bin" -prune -o -print

    4、使用find查找文件的时候怎么避开某个文件目录

    比如要在/home/itcast目录下查找不在dir1子目录之内的所有文件

    find /home/itcast -path "/home/itcast/dir1" -prune -o -print

    避开多个文件夹

    find /home \( -path /home/itcast/f1 -o -path /home/itcast/f2 \) -prune -o -print

    注意(前的\,注意(后的空格。

    5、使用user和nouser选项

    按文件属主查找文件,如在$HOME目录中查找文件属主为itcast的文件,可以用:

    $ find ~ -user itcast -print

    在/etc目录下查找文件属主为uucp的文件:

    $ find /etc -user uucp -print

           为了查找属主帐户已经被删除的文件,可以使用-nouser选项。这样就能够找到那些属主在/etc/passwd文件中没有有效帐户的文件。在使用-nouser选项时,不必给出用户名;find命令能够为你完成相应的工作。

          例如,希望在/home目录下查找所有的这类文件,可以用:

    $ find /home -nouser -print

    6、使用group和nogroup选项

    就像user和nouser选项一样,针对文件所属于的用户组, find命令也具有同样的选项,为了在/apps目录下查找属于itcast用户组的文件,可以用:

    $ find /apps -group itcast -print

    要查找没有有效所属用户组的所有文件,可以使用nogroup选项。下面的find命令从文件系统的根目录处查找这样的文件

    $ find / -nogroup -print

    7、按照更改时间或访问时间等查找文件

            如果希望按照更改时间来查找文件,可以使用mtime,atime或ctime选项。如果系统突然没有可用空间了,很有可能某一个文件的长度在此期间增长迅速,这时就可以用mtime选项来查找这样的文件。

           用减号-来限定更改时间在距今n日以内的文件,而用加号+来限定更改时间在距今n日以前的文件。

          希望在系统根目录下查找更改时间在5日以内的文件,可以用:

    $ find / -mtime -5 -print

    为了在/var/adm目录下查找更改时间在3日以前的文件,可以用:

    $ find /var/adm -mtime +3 -print

    8、查找比某个文件新或旧的文件

    如果希望查找更改时间比某个文件新但比另一个文件旧的所有文件,可以使用-newer选项。它的一般形式为:

    newest_file_name ! oldest_file_name

    其中,!是逻辑非符号。

    9、使用type选项

    在/etc目录下查找所有的目录,可以用:

    $ find /etc -type d -print

    在当前目录下查找除目录以外的所有类型的文件,可以用:

    $ find . ! -type d -print

    在/etc目录下查找所有的符号链接文件,可以用

    $ find /etc -type l -print

    10、使用size选项

           可以按照文件长度来查找文件,这里所指的文件长度既可以用块(block)来计量,也可以用字节来计量。以字节计量文件长度的表达形式为N c;以块计量文件长度只用数字表示即可。

          在按照文件长度查找文件时,一般使用这种以字节表示的文件长度,在查看文件系统的大小,因为这时使用块来计量更容易转换。 在当前目录下查找文件长度大于1 M字节的文件:

    $ find . -size +1000000c -print

    在/home/apache目录下查找文件长度恰好为100字节的文件:

    $ find /home/apache -size 100c -print

    在当前目录下查找长度超过10块的文件(一块等于512字节):

    $ find . -size +10 -print

    11、使用depth选项

           在使用find命令时,可能希望先匹配所有的文件,再在子目录中查找。使用depth选项就可以使find命令这样做。这样做的一个原因就是,当在使用find命令向磁带上备份文件系统时,希望首先备份所有的文件,其次再备份子目录中的文件。

            在下面的例子中, find命令从文件系统的根目录开始,查找一个名为CON.FILE的文件。

            它将首先匹配所有的文件然后再进入子目录中查找。

    $ find / -name "CON.FILE" -depth -print

    12、使用mount选项

             在当前的文件系统中查找文件(不进入其他文件系统),可以使用find命令的mount选项。

             从当前目录开始查找位于本文件系统中文件名以XC结尾的文件:

    $ find . -name "*.XC" -mount -print

    练习:请找出你10天内所访问或修改过的.c和.cpp文件。

    sed

             sed意为流编辑器(Stream Editor),在Shell脚本和Makefile中作为过滤器使用非常普遍,也就是把前一个程序的输出引入sed的输入,经过一系列编辑命令转换为另一种格式输出。sed和vi都源于早期UNIX的ed工具,所以很多sed命令和vi的末行命令是相同的。

    sed命令行的基本格式为

    sed option 'script' file1 file2 ...

    sed option -f scriptfile file1 file2 ...

    选项含义:

    --version 显示sed版本。

    --help 显示帮助文档。

    -n,--quiet,--silent 静默输出,默认情况下,sed程序在所有的脚本指令执行完毕后,将自动打印模式空间中的内容,这些选项可以屏蔽自动打印。

    -e script 允许多个脚本指令被执行。

    -f script-file,

    --file=script-file 从文件中读取脚本指令,对编写自动脚本程序来说很棒!

    -i,--in-place 直接修改源文件,经过脚本指令处理后的内容将被输出至源文件(源文件被修改)慎用!

    -l N, --line-length=N 该选项指定l指令可以输出的行长度,l指令用于输出非打印字符。

    --posix 禁用GNU sed扩展功能。

    -r, --regexp-extended 在脚本指令中使用扩展正则表达式

    -s, --separate 默认情况下,sed将把命令行指定的多个文件名作为一个长的连续的输入流。而GNU sed则允许把他们当作单独的文件,这样如正则表达式则不进行跨文件匹配。

    -u, --unbuffered 最低限度的缓存输入与输出。

    以上仅是sed程序本身的选项功能说明,至于具体的脚本指令(即对文件内容做的操作)后面我们会详细描述,这里就简单介绍几个脚本指令操作作为sed程序的例子。

    a, append 追加

    i, insert 插入

    d, delete 删除

    s, substitution 替换

    如:$ sed "2a itcast" ./testfile 在输出testfile内容的第二行后添加"itcast"。

    $ sed "2,5d" testfile

           sed处理的文件既可以由标准输入重定向得到,也可以当命令行参数传入,命令行参数可以一次传入多个文件,sed会依次处理。sed的编辑命令可以直接当命令行参数传入,也可以写成一个脚本文件然后用-f参数指定,编辑命令的格式为:

    /pattern/action

              其中pattern是正则表达式,action是编辑操作。sed程序一行一行读出待处理文件,如果某一行与pattern匹配,则执行相应的action,如果一条命令没有pattern而只有action,这个action将作用于待处理文件的每一行。

    常用sed命令

    /pattern/p 打印匹配pattern的行

    /pattern/d 删除匹配pattern的行

    /pattern/s/pattern1/pattern2/ 查找符合pattern的行,将该行第一个匹配pattern1的字符串替换为pattern2

    /pattern/s/pattern1/pattern2/g 查找符合pattern的行,将该行所有匹配pattern1的字符串替换为pattern2

            使用p命令需要注意,sed是把待处理文件的内容连同处理结果一起输出到标准输出的,因此p命令表示除了把文件内容打印出来之外还额外打印一遍匹配pattern的行。比如一个文件testfile的内容是

    123

    abc

    456

    打印其中包含abc的行

    $ sed '/abc/p' testfile

    123

    abc

    abc

    456

    要想只输出处理结果,应加上-n选项,这种用法相当于grep命令

    $ sed -n '/abc/p' testfile

    abc

    使用d命令就不需要-n参数了,比如删除含有abc的行

    $ sed '/abc/d' testfile

    123

    456

    注意,sed命令不会修改原文件,删除命令只表示某些行不打印输出,而不是从原文件中删去。

    使用查找替换命令时,可以把匹配pattern1的字符串复制到pattern2中,比如:

    $ sed 's/bc/-&-/' testfile

    123

    a-bc-

    456

    pattern2中的&表示原文件的当前行中与pattern1相匹配的字符串

    再比如:

    $ sed 's/\([0-9]\)\([0-9]\)/-\1-~\2~/' testfile

    -1-~2~3

    abc

    -4-~5~6

    pattern2中的\1表示与pattern1的第一个()括号相匹配的内容,\2表示与pattern1的第二个()括号相匹配的内容。sed默认使用Basic正则表达式规范,如果指定了-r选项则使用Extended规范,那么()括号就不必转义了。如:

    sed -r 's/([0-9])([0-9])/-\1-~\2~/' out.sh

    替换结束后,所有行,含有连续数字的第一个数字前后都添加了“-”号;第二个数字前后都添加了“~”号。

    可以一次指定多条不同的替换命令,用“;”隔开:

    $ sed 's/yes/no/;s/static/dhcp/' ./testfile

    注:使用分号隔开指令。

    也可以使用 -e 参数来指定不同的替换命令,有几个替换命令需添加几个 -e 参数:

    $ sed -e 's/yes/no/' -e 's/static/dhcp/' testfile

    注:使用-e选项。

    如果testfile的内容是

    <html><head><title>Hello World</title></head>

    <body>Welcome to the world of regexp!</body></html>

    现在要去掉所有的HTML标签,使输出结果为:

    Hello World

    Welcome to the world of regexp!

    怎么做呢?如果用下面的命令

    $ sed 's/<.*>//g' testfile

    结果是两个空行,把所有字符都过滤掉了。这是因为,正则表达式中的数量限定符会匹配尽可能长的字符串,这称为贪心的(Greedy)。比如sed在处理第一行时,<.*>匹配的并不是<html>或<head>这样的标签,而是

    <html><head><title>Hello World</title>

    这样一整行,因为这一行开头是<,中间是若干个任意字符,末尾是>。那么这条命令怎么改才对呢?留给同学们思考练习。

    awk

           sed以行为单位处理文件,awk比sed强的地方在于不仅能以行为单位还能以列为单位处理文件。awk缺省的行分隔符是换行,缺省的列分隔符是连续的空格和Tab,但是行分隔符和列分隔符都可以自定义,比如/etc/passwd文件的每一行有若干个字段,字段之间以:分隔,就可以重新定义awk的列分隔符为:并以列为单位处理这个文件。awk实际上是一门很复杂的脚本语言,还有像C语言一样的分支和循环结构,但是基本用法和sed类似,awk命令行的基本形式为:

    awk option 'script' file1 file2 ...

    awk option -f scriptfile file1 file2 ...

             和sed一样,awk处理的文件既可以由标准输入重定向得到,也可以当命令行参数传入,编辑命令可以直接当命令行参数传入,也可以用-f参数指定一个脚本文件,编辑命令的格式为:

    /pattern/{actions}

    condition{actions}

          和sed类似,pattern是正则表达式,actions是一系列操作。awk程序一行一行读出待处理文件,如果某一行与pattern匹配,或者满足condition条件,则执行相应的actions,如果一条awk命令只有actions部分,则actions作用于待处理文件的每一行。比如文件testfile的内容表示某商店的库存量:

    ProductA 30

    ProductB 76

    ProductC 55

    打印每一行的第二列:

    $ awk '{print $2;}' testfile

    30

    76

    55

           自动变量$1、$2分别表示第一列、第二列等,类似于Shell脚本的位置参数,而$0表示整个当前行。再比如,如果某种产品的库存量低于75则在行末标注需要订货:

    $ awk '$2<75 {printf "%s\t%s\n", $0, "REORDER";} $2>=75 {print $0;}' testfile

    ProductA 30 REORDER

    ProductB 76

    ProductC 55 REORDER

           可见awk也有和C语言非常相似的printf函数。awk命令的condition部分还可以是两个特殊的condition-BEGIN和END,对于每个待处理文件,BEGIN后面的actions在处理整个文件之前执行一次,END后面的actions在整个文件处理完之后执行一次。

    awk命令可以像C语言一样使用变量(但不需要定义变量),比如统计一个文件中的空行数

    $ awk '/^ *$/ {x=x+1;} END {print x;}' testfile

    就像Shell的环境变量一样,有些awk变量是预定义的有特殊含义的:

    awk常用的内建变量

    FILENAME 当前输入文件的文件名,该变量是只读的

    NR 当前行的行号,该变量是只读的,R代表record

    NF 当前行所拥有的列数,该变量是只读的,F代表field

    OFS 输出格式的列分隔符,缺省是空格

    FS 输入文件的列分融符,缺省是连续的空格和Tab

    ORS 输出格式的行分隔符,缺省是换行符

    RS 输入文件的行分隔符,缺省是换行符

    例如打印系统中的用户帐号列表

    $ awk 'BEGIN {FS=":"} {print $1;}' /etc/passwd

    awk也可以像C语言一样使用if/else、while、for控制结构。可自行扩展学习。

    C程序中使用正则

            POSIX规定了正则表达式的C语言库函数,详见regex(3)。我们已经学习了很多C语言库函数的用法,读者应该具备自己看懂man手册的能力了。本章介绍了正则表达式在grep、sed、awk中的用法,学习要能够举一反三,请读者根据regex(3)自己总结正则表达式在C语言中的用法,写一些简单的程序,例如验证用户输入的IP地址或email地址格式是否正确。

            C语言处理正则表达式常用的函数有regcomp()、regexec()、regfree()和regerror(),一般分为三个步骤,如下所示:

            C语言中使用正则表达式一般分为三步:

    编译正则表达式 regcomp()

    匹配正则表达式 regexec()

    释放正则表达式 regfree()

           下边是对三个函数的详细解释

            这个函数把指定的正则表达式pattern编译成一种特定的数据格式compiled,这样可以使匹配更有效。函数regexec 会使用这个数据在目标文本串中进行模式匹配。执行成功返回0。

    int regcomp (regex_t *compiled, const char *pattern, int cflags)

     

             regex_t 是一个结构体数据类型,用来存放编译后的正则表达式,它的成员re_nsub 用来存储正则表达式中的子正则表达式的个数,子正则表达式就是用圆括号包起来的部分表达式。

             pattern 是指向我们写好的正则表达式的指针。

            cflags 有如下4个值或者是它们或运算(|)后的值:

                      REG_EXTENDED 以功能更加强大的扩展正则表达式的方式进行匹配。

                      REG_ICASE 匹配字母时忽略大小写。

                      REG_NOSUB 不用存储匹配后的结果,只返回是否成功匹配。如果设置该标志位,那么在regexec将忽略nmatch和pmatch两个参数。

                       REG_NEWLINE 识别换行符,这样'$'就可以从行尾开始匹配,'^'就可以从行的开头开始匹配。

           当我们编译好正则表达式后,就可以用regexec 匹配我们的目标文本串了,如果在编译正则表达式的时候没有指定cflags的参数为REG_NEWLINE,则默认情况下是忽略换行符的,也就是把整个文本串当作一个字符串处理。

           执行成功返回0。

           regmatch_t 是一个结构体数据类型,在regex.h中定义:

    typedef struct {

            regoff_t rm_so;

            regoff_t rm_eo;

    } regmatch_t;

           成员rm_so 存放匹配文本串在目标串中的开始位置,rm_eo 存放结束位置。通常我们以数组的形式定义一组这样的结构。因为往往我们的正则表达式中还包含子正则表达式。数组0单元存放主正则表达式位置,后边的单元依次存放子正则表达式位置。

    int regexec (regex_t *compiled, char *string, size_t nmatch, regmatch_t matchptr[], int eflags)

    compiled 是已经用regcomp函数编译好的正则表达式。

    string 是目标文本串。

    nmatch 是regmatch_t结构体数组的长度。

    matchptr regmatch_t类型的结构体数组,存放匹配文本串的位置信息。

    eflags 有两个值:

             REG_NOTBOL 让特殊字符^无作用

             REG_NOTEOL 让特殊字符$无作用

           当我们使用完编译好的正则表达式后,或者要重新编译其他正则表达式的时候,我们可以用这个函数清空compiled指向的regex_t结构体的内容,请记住,如果是重新编译的话,一定要先清空regex_t结构体。

    void regfree (regex_t *compiled)

            当执行regcomp 或者regexec 产生错误的时候,就可以调用这个函数而返回一个包含错误信息的字符串。

    size_t regerror (int errcode, regex_t *compiled, char *buffer, size_t length)

     

    errcode 是由regcomp 和 regexec 函数返回的错误代号。

    compiled 是已经用regcomp函数编译好的正则表达式,这个值可以为NULL。

    buffer 指向用来存放错误信息的字符串的内存空间。

    length 指明buffer的长度,如果这个错误信息的长度大于这个值,则regerror 函数会自动截断超出的字符串,但他仍然会返回完整的字符串的长度。所以我们可以用如下的方法先得到错误字符串的长度。

    例如: size_t length = regerror (errcode, compiled, NULL, 0);

    测试用例:

    #include <sys/types.h>
    #include <regex.h>
    #include <stdio.h>
    
    int main(int argc, char ** argv)
    {
    	if (argc != 3) {
    		printf("Usage: %s RegexString Text\n", argv[0]);
    		return 1;
    	}
    	const char * pregexstr = argv[1];
    	const char * ptext = argv[2];
    	regex_t oregex;
    	int nerrcode = 0;
    	char szerrmsg[1024] = {0};
    	size_t unerrmsglen = 0;
    	if ((nerrcode = regcomp(&oregex, pregexstr, REG_EXTENDED|REG_NOSUB)) == 0) {
    		if ((nerrcode = regexec(&oregex, ptext, 0, NULL, 0)) == 0)	{
    			printf("%s matches %s\n", ptext, pregexstr);
    			regfree(&oregex);
    			return 0;
    		}
    	}
    	unerrmsglen = regerror(nerrcode, &oregex, szerrmsg, sizeof(szerrmsg));
    	unerrmsglen = unerrmsglen < sizeof(szerrmsg) ? unerrmsglen : sizeof(szerrmsg) - 1;
    	szerrmsg[unerrmsglen] = '\0';
    	printf("ErrMsg: %s\n", szerrmsg);
    	regfree(&oregex);
    
    	return 1;
    }

    匹配网址:

    ./a.out "http:\/\/www\..*\.com" "http://www.taobao.com"

    匹配邮箱:

    ./a.out "^[a-zA-Z0-9]+@[a-zA-Z0-9]+.[a-zA-Z0-9]+" "itcast123@itcast.com"

    ./a.out "\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*" "itcast@qq.com"

    注:\w匹配一个字符,包含下划线

            匹配固话号码:请同学们自己编写。

            除了gnu提供的函数外,还常用PCRE处理正则,全称是Perl Compatible Regular Ex-pressions。从名字我们可以看出PCRE库是与Perl中正则表达式相兼容的一个正则表达式库。PCRE是免费开源的库,它是由C语言实现的,这里是它的官方主页:http://www.pcre.org/,感兴趣的朋友可以在这里了解更多的内容。 要得到PCRE库,可以从这里下载:http://sourceforge.net/projects/pcre/files/

         PCRE++是一个对PCRE库的C++封装,它提供了更加方便、易用的C++接口。这里是它的官方主页:http://www.daemon.de/PCRE,感兴趣的朋友可以在这里了解更多的内容。 要得到PCRE++库,可以从这里下载:http://www.daemon.de/PcreDownload

              另外c++中常用 boost regex。

    展开全文
  • 10小时全掌握Linux下shell编程

    千人学习 2020-02-06 14:14:51
    从没上过课的学渣 学了还不会的学弱 想学懂的学霸 10小时全掌握Linux下shell编程 工作、面试全没问题。
  • shell编程(1)

    千次阅读 2018-07-16 14:58:56
    一、shell简介1、概念 命令解释器2、常见的shell bash : linux标准的shell sh:早期shell,较简单 csh ,ksh ,tcsh :是unix 中的shell3、查看linux中支持的shell vi /etc/shells 4、shell脚本创建一个...

    一、shell简介

    1、概念

        命令解释器

    2、常见的shell

        bash :   linux标准的shell

        sh:早期shell,较简单

        csh ,ksh ,tcsh :是unix 中的shell

    3、查看linux中支持的shell

        vi /etc/shells  

    4、shell脚本

    创建一个shell脚本,并打印出来


            步骤

                1、在root目录下创建目录sh;mkdir sh

                2、进入sh目录下:cd sh/

                3、查看sh目录下文件:ls

                4、创建一个shell文件命名为hello.sh并进入编辑模式:vi hello.sh

                5、进入编辑模式后,按如下格式输入:(其中第一行是必须输入的,echo代表输出格式):

                                    #!/bin/bash

                                    echo  "hello,world!"

                6、退出编辑模式:先按esc,:wq

                脚本执行方式

                        先赋予其执行权限 :chmod 755 hello.sh

                    方法一:以绝对路径执行

                                    /root/sh/hello.sh

                                 以相对路径执行

                                    ./hello.sh

                        

                    方法二:用“bash 脚本名”直接执行(脚本不需要赋予执行权限)

                        bash  hello.sh

                        

                    方法三:用source命令执行,以当前默认Shell解释器执行

                    

    5、bash常见功能

        1)历史命令

        默认保存1000条历史命令

                vi  /etc/profile          修改环境变量配置文件,要生效,必须注销

                HISTSIZE=1000        修改默认历史命令条数

                history          查询系统历史命令

            历史命令保存文件

                    ~/.bash_history

                history  -w   把内存中命令历史,保存入文件

                history  -c   清空所有的历史命

        重复历史命令

         !n   重复执行第n条命令

         !str   重复执行最后一个以str开头的命令

                上箭头 调用上面的命令

        2)别名

                alias            查看系统中生效的别名

                alias  ls='ls  --color=never'         手工设定别名,临时生效

                把别名删掉:alias ls='ls --color=tty'

            vi  ~/.bashrc              写入别名,永久生效 


    3)输入输出重定向

                                 #设备文件名               #文件描述符              #默认设备

            标准输入         /dev/stdin                          0                          键盘

            标准输出          /dev/stdout                       1                         显示器

            标准错误输出    /dev/stderr                       2                         显示器

        

        a)输出重定向

                把应该输出到屏幕的输出,重定向到文件。

                        >                   覆盖

                        >>                 追加               

                        ls  >  aa          覆盖到aa(解释:把ls下的文件重定向到aa,查看aa下的文件,就是ls下的文件,这就是重定向。如下图

                    

                       ls  >>  aa          追加到aa  (示例如下图)   

                                       

                        ls  gdlslga  2>>aa          错误信息输出到aa        强调:错误输出,不能有空格(该命令是把错误命令追加到aa中)

                        ls  &>aa                         错误和正确都输入到aa,但是只能覆盖

                        ls  >> aa   2>>bb          正确信息输入aa,错误信息输入bb

                        ls  >>  aa   2>&1           错误和正确都输入到aa,可以追加

                        2>&1             把标准错误重定向到标准正确输出

         4)多命令顺序执行         

                    1)命令1  ;  命令2 ; 命令3                      命令123顺序执行。之间没有任何关系

                    2)命令1  &&  命令2                                  命令1正确执行后,命令2才会执行

                    3)命令1  ||  命令2                                      命令1执行不正确,命令2才会执行

                    ls aa && echo "exist" || echo "not exist!" 执行ls  aa,判断如果正确,输出“存在”。如果不存在,输出“不存在”

                 

                5)管道符

            命令1  |  命令2                               命令1的执行结果,作为命令2的执行条件

                                 netstat -tlun                               查询监听的端口

                                    

                                netstat -tlun | grep 80               查询监听的端口号,并查看80端口是否启动。

                                ls  -l  /etc/  |  more                     分屏显示ls内容

                                        

                                ls -l /etc/ | grep yum

    二 、变量 

         1、分类

                本地变量

                环境变量

                位置参数变量

                预定义变量

        2、本地变量

            1)声明

                      变量名=变量值              注意:=号左右不能有空格

                       aa=123

                                                

            2)调用

                        echo  $变量名

            3)查看变量

                        set          查看所有变量,包括环境变量和本地变量

            4)删除

                        unset  变量名

        3、变量设定规则

                1)变量以等号连接值,等号不能有空格

                2)变量名由数字、字母和下划线组成,不能以数字开头

                3)变量值中有空格,用引号括起来

                4)双引号内,有特殊字符。如$

                5)单引号中特殊字符无含义

                6)在变量值中,可以使用 \ 转义符

                7)变量值可以直接调用系统命令。 ‘命令’$(命令)

                8)变量值可以累加 aa=123   aa="$aa"456   echo $aa   --->123456

                        

                9)环境变量一定设为大写

         4、环境变量

                1)声明

                        export   变量名=变量值

                        export   a

                2)查看

                        set                     查看所有变量

                        env  export        只能查看环境变量

                        declare            声明变量类型的,如果不特别声明,所有变量为字符串型

                                    -i            声明为int

                                    -x            声明为环境变量

                3)删除

                        unset   变量名

                4)常见环境变量

        echo  $PATH                                                        /usr/keyberos/sbin:/usr/kerberos/bin:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/root/bin                   系统查找命令的路径

                        PATH="$PATH":/root/shell        在系统默认路径后,追加/root/shell目录作为命令查找路径

                5)环境变量配置文件

                        /etc/profile

                        /etc/bashrc              所有用户生效

                        ~/.bashrc

                        ~/.bash_profile        只对指定用户生效

        5、位置参数变量  

    位置参数变量说明
    $0命令自己
    $1第一个参数
    $2第二个参数
    ............
    $9第九个参数

            示例:输出位置参数变量,脚本后要接参数

    #!/bin/bash
    echo "the command is $0"
    echo "canshu1 is $1"
    echo "canshu2 is $2"

                

            步骤如下:        

                     1、创建一个shell文件命名为canshu.sh并进入编辑模式:vi canshu.sh

                     2、进入编辑模式后,按如下格式输入:(其中第一行是必须输入的,echo代表输出格式):

                                    #!/bin/bash

                                    echo  "the command is $0"

                                    echo  "canshu1 is $1"

                                    echo  "canshu1 is $1"

                    3、退出编辑模式:先按esc,:wq      

                    4、先赋予其执行权限 :chmod 755 canshu.sh

                    5、以相对路径执并赋初值1,2,3回车之后,即可看到运行结果:    ./canshu.sh 1 2 3

                    6、查看canshu.sh的内容用:cat canshu.sh

                        (由于canshu.sh中第一个参数是$0,所以赋值是命令本身(./canshu.sh),其他两个变量依次赋值1,2)

        6、预定义变量

                    $?           上一个命令的返回值。 如果返回值是 “0”  表示上一个命令正确执行,如果是非0,表示上一个命令没有正确执行

                        

                    $#            统计命令之后的参数个数

                    $*            返回所有参数

                    $n            位置参数变量

                    示例:输出预定义变量

    #!/bin/bash
    echo "canshu geshu is $#"
    echo "suoyou canshu zhi is $*"
    echo "$?"

                

            步骤如下:        

                     1、创建一个shell文件命名为canshu.sh并进入编辑模式:vi canshu2.sh

                     2、进入编辑模式后,按如下格式输入:(其中第一行是必须输入的,echo代表输出格式):

                                    #!/bin/bash

                                    echo  "canshu geshu is is $#"

                                    echo  "suoyou canshu zhi is $*"

                                    echo  "$?"

                    3、退出编辑模式:先按esc,:wq      

                    4、先赋予其执行权限 :chmod 755 canshu2.sh

                    5、以相对路径执并赋初值1,2,3,4,5回车之后,即可看到运行结果:    ./canshu2.sh 1 2 3 4 5

                    6、查看canshu2.sh的内容用:cat canshu2.sh

        7、键盘读取命令

                read   -p             "提示信息"    -t    等待时间       变量名

                示例:通过read读入变量值

    #!/bin/bash
    read -p "please inut numl:" -t 30 test1
    read -p "input num2:" -t 30 test2
    sum=$(($test1+$test2))
    echo "num1+num2=$sum"
                    

              步骤如下:        

                     1、创建一个shell文件命名为canshu.sh并进入编辑模式:vi read.sh

                     2、进入编辑模式后,按如下格式输入:(其中第一行是必须输入的,echo代表输出格式):

                                    #!/bin/bash

                                    read -p  "please input num1:" -t 30 test1

                                    read -p  "input num2:" -t 30 test2

                                    sum=$(($test1+$test2))

                                    echo  "num1+num2=$sum"

                    3、退出编辑模式:先按esc,:wq      

                    4、先赋予其执行权限 :chmod 755 read.sh

                    5、以相对路径执:    ./read.sh 

                    6、可以看到提示,并键盘输入

                    7、查看read.sh的内容用:cat read.sh

        8、数值运算

                

                变量值默认都是字符串型,要想进行数值运算,以下三种任选一种:

                1)declare  方法

                        num1=12

                        num2=14

                        declare  -i  sum=$num1+$num2

                2)sum=$(($num1+$num2))

                3)sum=$(expr $num1 + $num2)      (注意+号左右两边必须空格)

                    

                4)运算符

                        +      -        \*       /       %取余

    三、shell中常用命令

        1、行提取命令 grep

                选项:    -v        反向选择

                              -n        提取时,显示行号

                    

            举例:(用正则表达式匹配)

                    grep  “[^a-z]hen” test.txt               (在文档test.txt中匹配hen前不是小写字母的行匹配)注:和开头没有关系

                    grep    "\.$"  test.txt                           (在文档test.txt中匹配以.结尾的行)

                    grep    “^[^A-Za-z]” test.txt            (在test.txt中匹配不以字母开头的行)注:所有字母不能这样写A-z

                    grep    "oo*"   test.txt                            (匹配最少一个o)

                    grep    "^$"   test.txt                            (匹配空白行^代表行首,$代表行尾)

        2、列提取命令

                1)cut   格式:

                        cut  -d    “分隔符”    -f      提取列    文件名

                        

                       比如:

                                cat  /etc/passwd  |  grep "/bin/bash"  | cut -d  ":"  -f  1,3  (提取passwd文件中可以登录的用户的用户名和UID) (具体意思是:cat /etc/passwd是把passwd打开,| 表示管道符,grep "/bin/bash"是把打开的passwd中提取/bin/bash的行,在行的基础上提取第1,3列,cut -d  ":"  -f  1,3

                 2)awk

                        awk  '条件   {动作}'

                    last | awk '{printf  $1 "\t"  $3  "\n"}'            (提取last显示结果的第一和第三列,其中last表示最后登录的信息)

                

                \t        tab键

                \n        换行

                 \r        回车

                再比如:last中提取包含ip的行,在行中提取第一和第三列

                        last | grep "[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}"|awk '{printf $1 "\t" $3 "\n"}'

                    

                 awk 内置变量            FS指定分隔符

                more  /etc/passwd   |    awk   'BEGIN  {FS=":"}    {printf  $1  "\t"  $3   "\n"}'

                读取passwd文件,以“:”为分隔符,截取第一和第三列

                BEGIN    在截取前使分隔符生效。如果没有BEGIN,那么第一行自定义的分隔符不生效

        3、echo命令

                echo    -e    "输出内容"

                        -e    识别格式化打印内容

                echo    -e    “1\t2\t3”            打印tab键

                echo    -e    "\e[1;31m  this is red text  \e[0m"        输出红色字体

                

                        \e[            格式(以其开头,并以其为结尾)

                        1;31m        指定颜色

                        0m            恢复颜色(重置)

                        30m=黑色,31m=红色,32m=绿色,33m=黄色,34m=蓝色,35m=洋红,36m青色,37m=白色

                echo    -e    "\e[1;42m  background  \e[0m"        

                    

                        背景颜色:40=黑色,41=红色,42=绿色,43=黄色,44=蓝色,45=洋红,46=青色,47=白色

                

                实例:echo输出的小游戏

                            cat    -A     文件名                (显示文件,包括隐藏字符)

                            取消dos文档的回车符,有两种办法

                            1)dos2unix    文档名

                            2)vi    -b    文档

                                    :%s/^M//g       ^M使用ctrl+v+m输入


                数据备份: 

    #!/bin/bash
    DAY=`date +%Y%m%d`
    #定义日期变量
    SIZE='du -sh /var/lib/mysql'
    #定义mysql目录大学的变量
    echo "Date:$DAY">>/tmp/dbinfo.txt
    #把日期输入信息文档
    echo "Date Size:$SIZE">>/tmp/dbinfo.txt
    #把大学输入信息文档
    cd /opt/dbbak
    #切换目录
    tar zcvf mysqlbak-${DAY}.tar.gz /var/lib/mysql/tmp/dbinfo.txt
    #打包备份mysql目录,同时打包信息文档
    rm -f /tmp/dbinfo.txt

    下接shell编程(二)


    展开全文
  • shell编程

    千次阅读 2019-06-21 20:21:06
    shell编程shell简介shell种类shell文件执行shellshell变量变量规则变量类型使用变量只读变量删除变量字符串获取字符串长度提取子字符串查找子字符串Shell 数组定义数组读取数组获取数组的长度shell注释参数传递shell...
  • shell编程100例

    万次阅读 多人点赞 2020-04-04 21:42:30
    1、编写hello world脚本 #!/bin/bash # 编写hello world脚本 echo "Hello World!" 2、通过位置变量创建 Linux 系统账户及密码 ...#$1 是执行脚本的第一个参数,$2 是执行脚本的第二个参数 ...echo "$2" | ...
  • shell编程(一)

    千次阅读 2018-12-08 10:38:38
    因为shell编程中,有一些关键的字符,表达了某些意思,如果不用转义,会引起不同意思。  \\ 反斜杠\$ 美元符\" 双引号 \' 单引号 \* 星号\n 换行符(0xA) \r 回车符(0xD) \t 水平制表符 \v 垂直制表符 \...
  • Shell编程详解

    万次阅读 多人点赞 2016-04-19 00:40:07
    Shell编程详解       Shell简介   概述 Shell是一种具备特殊功能的程序,它提供了用户与内核进行交互操作的一种接口。它接收用户输入的命令,并把它送入内核去执行。内核是Linux系统的心脏,从开机自检就...
  • shell编程入门

    千次阅读 2018-12-10 09:24:23
    一、准备 最好自己本地装一台虚拟机,因为用阿里云或者腾讯云,无法查看系统现有的脚本。另外,需要有一定的Linux基础,vi命令,文件权限这些肯定要知道的。 我这里是用VMware装的centos 6.5 64位的...Shell 是...
  • 一、Shell编程--windows下的shell开发运行工具

    万次阅读 热门讨论 2018-04-28 22:34:51
    对于shell脚本使用vim在linux开发可能效率比较底下,而且大多都是windows开发,当然能够在windows下运行更好。1、开发工具:subli text 3 1)安装插件ShellScriptImproved,用于语法提示以及关键字高亮&lt;1&...
  • 《linux命令行与shell编程大全》--读书笔记

    千次阅读 多人点赞 2020-07-19 22:52:10
    1.初识Linux shell 2.走进shell 1.进入命令行,CLI(command line interface),也叫Linux控制台 通过Linux控制台终端访问CLI Ctrl+Alt+F1~F7 注:tty:teletypewriter,指一台用于...
  • Shell脚本编程35讲视频教程

    千次阅读 2017-04-23 19:22:44
    Shell脚本编程35讲视频教程 http://www.360doc.com/content/15/0502/19/3167194_467510602.shtml
  • 什么是shell和shell编程

    千次阅读 多人点赞 2018-04-12 00:13:35
    1.什么是shellshell是你(用户)和Linux(或者更准确的说,是你和Linux内核)之间的接口程序。你在提示符下输入的每个命令都由shell先解释然后传给Linux内核。 说到底,Shell是用户与内核进行交互操作的一种接口...
  • shell编程中如何计算使用除法

    千次阅读 2008-09-27 15:17:00
    (@转载请注明出处:http://blog.csdn.net/cmatch) shell编程中计算使用除法,基本上默认都是整除。比如:num1=33num2=22num3=`expr $num2 / $num1` 这个时候num3=0,是因为expr不支持浮点除法。 解决的方法:...
  • shell编程主要方便一些操作,有时候没有必要写python脚本,会shell就很方便。 具体请参考:https://www.zhihu.com/question/21747474
  • 写在前面   最近花了些时间学习Shell...第一部分 Shell基础编程——第一章 Shell简介 http://blog.csdn.net/wentasy/article/details/8702846   第一部分 Shell基础编程——第二章变量和运算符 http://blog.csdn.net
  • 前言学了东西就得用起来,学习任何东西都一样...用到了shell函数、while循环、if条件控制 等shell基本语法。脚本代码#!/bin/bash 99_table() { num=$1 row=1 while [ $row -le $num ] ;do col=1 while [ $col...
  • Shell编程-数值相加的三种方式

    万次阅读 2016-04-05 20:53:02
    Shell编程 数值求和
1 2 3 4 5 ... 20
收藏数 181,660
精华内容 72,664
关键字:

shell编程