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系统虽说也存在不少错误,但常用功能的错误还是比较少的,而且通过补丁程序可以更低限度减少系统错误,因此程序员可以将调试检错的注意力放在应用程序的其他地方,对于调用系统功能这部分代码则可以不必投入太大的精力去调试,因为这部分调试的工作在操作系统发布的时候就已经由微软做好了。本文通过外壳编程,实现了搜寻文件、运行程序、控制工具条、最大最小化窗口的功能。
收起全文
精华内容
参与话题
  • shell编程

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

    shell简介

    Shell 是一个用 C 语言编写的程序,它是用户使用 Linux 的桥梁。

    shell种类

    • Bourne Shell(/usr/bin/sh或/bin/sh)
    • Bourne Again Shell(/bin/bash)
    • C Shell(/usr/bin/csh)
    • K Shell(/usr/bin/ksh)
    • Shell for Root(/sbin/sh)
    • ……
      本教程关注的是 Bash,也就是 Bourne Again Shell,由于易用和免费,Bash 在日常工作中被广泛使用。同时,Bash 也是大多数Linux 系统默认的 Shell。

    shell文件

    shell文件的第一行: #!/bin/sh 或 #!/bin/bash
    #! 符号能够被内核识别成是一个脚本的开始,这一行必须位于脚本的首行。
    /bin/bash 是bash程序的绝对路径,在这里表示后续的内容将通过bash程序解释执行。

    执行shell

    1.作为可执行程序

    chmod +x ./test.sh  #使脚本具有执行权限
    ./test.sh  #执行脚本
    

    2.作为解释器参数

    /bin/bash test.sh
    /bin/sh test.sh
    

    shell变量

    变量规则

    • 命名只能使用英文字母、数字和下划线,首个字符不能以数字开头。
    • 中间不能有空格,可以使用下划线。
    • 不能使用标点符号。
    • 不能使用bash中的关键字(可使用help命令查看保留关键字)。
    • 赋值时,变量名和等号之间不能有空。
      例:
    BOOK="shell命令"
    

    变量类型

    • 局部变量 局部变量在脚本或命令中定义,仅在当前shell实例中有效,其他shell启动的程序不能访问局部变量。
    • 环境变量 所有的程序,包括shell启动的程序,都能访问环境变量,有些程序需要环境变量来保证其正常运行。必要的时候shell脚本也可以定义环境变量。
    • shell变量 shell变量是由shell程序设置的特殊变量。shell变量中有一部分是环境变量,有一部分是局部变量,这些变量保证了shell的正常运行

    使用变量

    使用一个定义过的变量,只要在变量名前面加美元符号即可
    例:

    name="jiangdoc"
    echo $name
    
    • 在拼接字符串中使用变量
      变量名加花括号是为了帮助解释器识别变量的边界。
      例:
    #!/bin/bash
    name="jiangdoc"
    echo "i name is $namess"
    echo "i name is ${name}ss"
    

    输出结果:
    i name is
    i name is jiangdocss

    只读变量

    使用 readonly 命令可以将变量定义为只读变量,只读变量的值不能被改变。
    例:

    #!/bin/bash
    myUrl="http://www.google.com"
    readonly myUrl
    myUrl="http://www.ss.com"
    

    运行结果:
    /bin/sh: NAME: This variable is read only.

    删除变量

    使用 unset 命令可以删除变量。语法:

    unset variable_name
    

    变量被删除后不能再次使用。unset 命令不能删除只读变量。

    字符串

    字符串是shell编程中最常用最有用的数据类型。字符串可以用单引号,也可以用双引号,也可以不用引号。

    • 单引号字符串的限制:
      • 单引号里的任何字符都会原样输出,单引号字符串中的变量是无效的
      • 单引号字串中不能出现单独一个的单引号(对单引号使用转义符后也不行),但可成对出现,作为字符串拼接使用。
    • 双引号的优点
      • 双引号里可以有变量
      • 双引号里可以出现转义字符

    获取字符串长度

    string="abcd"
    echo ${#string} #输出 4
    

    提取子字符串

    以下实例从字符串第 2 个字符开始截取 4 个字符:

    string="runoob is a great site"
    echo ${string:1:4} # 输出 unoo
    

    查找子字符串

    查找字符 i 或 o 的位置(哪个字母先出现就计算哪个):

    string="runoob is a great site"
    echo `expr index "$string" io`  # 输出 4
    

    Shell 数组

    bash支持一维数组(不支持多维数组),并且没有限定数组的大小。

    类似于 C 语言,数组元素的下标由 0 开始编号。获取数组中的元素要利用下标,下标可以是整数或算术表达式,其值应大于或等于 0。

    定义数组

    在 Shell 中,用括号来表示数组,数组元素用"空格"符号分割开。定义数组的一般形式为:

    数组名=(值1 值2 ... 值n)
    

    例:

    array_name=(value0 value1 value2 value3)
    

    还可以单独定义数组的各个分量:

    array_name[0]=value0
    array_name[1]=value1
    array_name[n]=valuen
    

    可以不使用连续的下标,而且下标的范围没有限制。

    读取数组

    读取数组元素值的一般格式是:

    ${数组名[下标]}
    

    例如:

    valuen=${array_name[n]}
    

    使用 @ 符号可以获取数组中的所有元素,例如:

    echo ${array_name[@]}
    

    获取数组的长度

    获取数组长度的方法与获取字符串长度的方法相同,例如:

    # 取得数组元素的个数
    length=${#array_name[@]}
    # 或者
    length=${#array_name[*]}
    # 取得数组单个元素的长度
    lengthn=${#array_name[n]}
    

    shell注释

    • 单行注释
    # 这是一行注释
    
    • 多行注释
    :<<EOF
    注释内容...
    注释内容...
    注释内容...
    EOF
    
    :<<'
    注释内容...
    注释内容...
    注释内容...
    '
    
    :<<!
    注释内容...
    注释内容...
    注释内容...
    !
    

    参数传递

    我们可以在执行 Shell 脚本时,向脚本传递参数,脚本内获取参数的格式为:$n。n 代表一个数字,1 为执行脚本的第一个参数,2 为执行脚本的第二个参数,以此类推……
    例:以下实例我们向脚本传递三个参数,并分别输出,其中 $0 为执行的文件名:

    #!/bin/bash
    # author:菜鸟教程
    # url:www.runoob.com
    
    echo "Shell 传递参数实例!";
    echo "执行的文件名:$0";
    echo "第一个参数为:$1";
    echo "第二个参数为:$2";
    echo "第三个参数为:$3";
    

    为脚本设置可执行权限,并执行脚本,输出结果如下所示:

    $ chmod +x test.sh 
    $ ./test.sh 1 2 3
    Shell 传递参数实例!
    执行的文件名:./test.sh
    第一个参数为:1
    第二个参数为:2
    第三个参数为:3
    

    特殊参数:

    参数处理 说明
    $# 传递到脚本的参数个数
    $* 以一个单字符串显示所有向脚本传递的参数。
    如"$*“用「”」括起来的情况、以"$1 $2 … $n"的形式输出所有参数。
    $$ 脚本运行的当前进程ID号
    $! 后台运行的最后一个进程的ID号
    $@ 与$*相同,但是使用时加引号,并在引号中返回每个参数。
    如"$@“用「”」括起来的情况、以"$1" “2&quot;&quot;2&quot; … &quot;n” 的形式输出所有参数。
    $- 显示Shell使用的当前选项,与set命令功能相同。
    $? 显示最后命令的退出状态。0表示没有错误,其他任何值表明有错误。

    $* 与 $@ 区别:

    • 相同点:都是引用所有参数。
    • 不同点:只有在双引号中体现出来。假设在脚本运行时写了三个参数 1、2、3,,则 " * " 等价于 “1 2 3”(传递了一个参数),而 “@” 等价于 “1” “2” “3”(传递了三个参数)。

    shell基本运算

    • 算数运算符
    • 关系运算符
    • 布尔运算符
    • 字符串运算符
    • 文件测试运算符
      原生bash不支持简单的数学运算,但是可以通过其他命令来实现,例如 awk 和 expr,expr 最常用。
      expr 是一款表达式计算工具,使用它能完成表达式的求值操作。
      例:
    #!/bin/bash 
    val=`expr 2 + 2`
    echo "两数之和为 : $val"
    
    • 两点注意:
      • 表达式和运算符之间要有空格,例如 2+2 是不对的,必须写成 2 + 2,这与我们熟悉的大多数编程语言不一样。
      • 完整的表达式要被 ` `包含,注意这个字符不是常用的单引号,在 Esc 键下边。

    算术运算符

    下表列出了常用的算术运算符,假定变量 a 为 10,变量 b 为 20:

    运算符 举例
    + 加法 `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。

    注意:条件表达式要放在方括号之间,并且要有空格,例如: [a==a==b] 是错误的,必须写成 [ $a == $b ]。

    关系运算符

    关系运算符只支持数字,不支持字符串,除非字符串的值是数字

    下表列出了常用的关系运算符,假定变量 a 为 10,变量 b 为 20:

    运算符 说明 举例
    -eq 检测两个数是否相等,相等返回 true。 [ $a -eq $b ] 返回 false。
    -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。

    布尔运算符

    表列出了常用的布尔运算符,假定变量 a 为 10,变量 b 为 20:

    运算符 说明 举例
    ! 非运算,表达式为 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。

    逻辑运算符

    以下介绍 Shell 的逻辑运算符,假定变量 a 为 10,变量 b 为 20:

    运算符 说明 举例
    && 逻辑的 AND [[ $a -lt 100 && $b -gt 100 ]] 返回 false
    || 逻辑的 OR [[ $a -lt 100

    字符串运算符

    下表列出了常用的字符串运算符,假定变量 a 为 “abc”,变量 b 为 “efg”:

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

    文件测试运算符

    文件测试运算符用于检测 Unix 文件的各种属性。

    属性检测描述如下:

    运算符 说明 举例
    -b file 检测文件是否是块设备文件,如果是,则返回 true。 [ -b $file ] 返回 false。
    -c file 检测文件是否是字符设备文件,如果是,则返回 true。 [ -c $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。

    其他检查符:

    • S: 判断某文件是否 socket。
    • L: 检测文件是否存在并且是一个符号链接。

    printf命令

    printf语法:

    printf format-string [ arguments … ]

    • format-string : 为格式控制字符串
    • arguments : 为参数列表

    %s %c %d %f都是格式替代符
    %-10s 指一个宽度为10个字符(-表示左对齐,没有则表示右对齐),任何字符都会被显示在10个字符宽的字符内,如果不足则自动以空格填充,超过也会将内容全部显示出来。

    %-4.2f 指格式化为小数,其中.2指保留2位小数。
    printf的转义序列

    序列 说明
    \a 警告字符,通常为ASCII的BEL字符
    \b 后退
    \c 抑制(不显示)输出结果中任何结尾的换行字符(只在%b格式指示符控制下的参数字符串中有效),而且,任何留在参数里的字符、任何接下来的参数以及任何留在格式字符串中的字符,都被忽略
    \f 换页(formfeed)
    \n 换行
    \r 回车(Carriage return)
    \t 水平制表符
    \v 垂直制表符
    \ 一个字面上的反斜杠字符
    \ddd 表示1到3位数八进制值的字符。仅在格式字符串中有效
    \0ddd 表示1到3位的八进制值字符
    展开全文
  • 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。

    展开全文
  • Shell编程语言(一)

    千次阅读 2018-08-25 15:00:58
    一. 什么是Shell ...Shell还是一个功能相当强大的编程语言,易编写,易调试,灵活性较强。Shell是解释执行的脚本语言,在Shell中可以直接调用Linux系统命令。  Shell具体可描述为:外层应用...

    一. 什么是Shell

    Shell是一个命令行解释器,它为用户提供了一个面向Linux内核发送请求以便运行程序的界面系统级程序,用户可以用Shell来启动、挂起、停止甚至是编写一些程序。

    Shell还是一个功能相当强大的编程语言,易编写,易调试,灵活性较强。Shell是解释执行的脚本语言,在Shell中可以直接调用Linux系统命令。

           Shell具体可描述为:外层应用程序是一些命令,是非机器语言,比如ls , useradd等;而内核则识别的是机器语言0和1,让Shell解释器当一个“中介”,由非机器语言通过Shell解释器向机器语言的转化,转化后内核将命令传递给硬件执行。更直白的说,Shell就是我们操控的Linux终端界面,输入命令得到想要的功能。

     

    二. Shell分类

      Linux 的 Shell 种类众多,常见的有:

    • Bourne Shell(/usr/bin/sh或/bin/sh)
    • Bourne Again Shell(/bin/bash)
    • C Shell(/usr/bin/csh)
    • K Shell(/usr/bin/ksh)
    • Shell for Root(/sbin/sh)
    • ……

    本文主要介绍的是Bourne Again Shell ,也就是Bash。Bash 是大多数Linux 系统默认的 Shell。

     

    三. shell脚本的执行方式

    1. echo输出命令

    echo        [输出内容]                                    ------------输出内容

    2.  写一个脚本

    vi   hello.sh                                                   -------开始写脚本(以.sh结尾的文件就是shell脚本)

    #!/bin/bash                                                   --------注意一下,Shell脚本的必备开头

    #hurenxiang   (18917734365@163.com)    ----下面的#开头的都是注释(也就是说这一句话是解释作用)

    echo   "hurenxiang  is   a   goog   boy"        --------输出内容

    :wq                                                               -----------保存退出

    3. 脚本执行

    ①  赋予执行权限,直接运行(推荐)

          chmod  755  hello.sh             -------------先赋予脚本权限

          ./hello.sh                                -------------再执行脚本

    ②  通过Bash调用执行脚本

          bash  hello.sh

    展开全文
  • Shell编程基础

    万次阅读 多人点赞 2012-06-08 16:13:39
    写之前我们先来搞清楚为什么要学shell,学习要有目的性 shell简单、灵活、高效,特别适合处理一些系统管理方面的小问题 shell可以实现自动化管理,让系统管理员的工作变得容易、简单、高效 shell脚本可移植性好,在...

    写之前我们先来搞清楚为什么要学shell,学习要有目的性
    shell简单、灵活、高效,特别适合处理一些系统管理方面的小问题
    shell可以实现自动化管理,让系统管理员的工作变得容易、简单、高效
    shell脚本可移植性好,在unix/linux系统中可灵活移植,几乎不用任何设置就能正常运行
    shell脚本可轻松方便读取和修改源代码,不需要编译
    掌握shell可以帮你解决一些故障问题,比如脚本引起的故障问题
    掌握shell是一个中级以上系统工程师必需要会的
    掌握shell是你系统管理进阶的必经之路
    掌握shell是你面试更高级职位的一块敲门砖
    那什么时候不使用Shell 脚本?
    资源密集型的任务,尤其在需要考虑效率时(比如排序,hash 等)
    需要处理大任务的数学操作,尤其是浮点运算,精确运算,或者复杂的算术运算(这种情况一般使用C++或FORTRAN 来处理)
    有跨平台移植需求(一般使用C 或Java)
    复杂的应用,在必须使用结构化编程的时候(需要变量的类型检查,函数原型,等等)
    对于影响系统全局性的关键任务应用。
    对于安全有很高要求的任务,比如你需要一个健壮的系统来防止入侵,破解,恶意破坏等等.
    项目由连串的依赖的各个部分组成。
    需要大规模的文件操作
    需要多维数组的支持
    需要数据结构的支持,比如链表或数等数据结构
    需要产生或操作图形化界面 GUI
    需要直接操作系统硬件
    需要 I/O 或socket 接口
    需要使用库或者遗留下来的老代码的接口
    私人的,闭源的应用(shell 脚本把代码就放在文本文件中,全世界都能看到)
     如果你的应用符合上边的任意一条,那么就考虑一下更强大的语言吧--或许是Perl,Python,Ruby, 或者是更高层次的编译语言比如C/C++,Java.

    1.介绍shell脚本

    简单的说shell就是一个包含若干行Shell或者Linux命令的文件。对于一次编写,多次使用的大量命令,就可以使用单独的文件保存下来,

    以便日后使用。通常shell脚本以.sh为后缀。在编写shell时,第一行一定要指明系统需要哪种shell解释用户的shell程序,如:#!/bin/sh,#!/bin/bash,#!/bin/csh,,#!/bin/tcsh和,#!/bin/ksh等。下面的run.sh则指明使用bash执行。

    #!bin/bash

    ls -l

    通常,shell脚本会以#!/bin/sh作为默认的shell程序。执行shell的方式有两种:第一种是为shell脚本加上可执行权限并执行第二种通过sh命令执行shell脚本,例如执行当前目录下的run.sh脚本,命令如下:

    //为shell脚本直接加上可执行权限并执行

    chmod 755 run.sh

    ./run.sh

    //通过sh命令执行shell脚本

    sh run.sh

    注意:那为何『 sh shell.sh 』也可以运行呢?

    这是因为 /bin/sh 其实就是 /bin/bash(连结档),使用 sh shell.sh 亦即告诉系统,我想要直接以 bash 的功能来运行 shell.sh 这个文件内的相关命令的意思,所以此时你的 shell.sh 只要有 r 的权限即可被运行喔而我们也可以利用 sh 的参数,如 -n 及 -x 来检查与追踪 shell.sh 的语法是否正确

    2。输入输出重定向

    Linux使用标准输入stdin和标准输出stdout,来表示每个命令的输入和输出,还使用一个标准错误输出stderr用于输出错误信息。这三个标准输入输出系统默认与控制终端设备相联系在一起的。因此,在标准情况下,每个命令通常从它的控制终端中获取输入,将输出打印到控制终端的屏幕上。

    但是可以重新定义程序的输入stdin和输出stdout,将它们重定向。最基本的方法就是将它们重定义到一个文件上去,从一个文件获取输入/输出到另外的文件中等。

    2.1输入重定向

    输入重定向使用小于号“<”可以实现。显示文件的cat命令就是将标准输入重定向到文件实现的。

    //将/etc/fstab作为输入,重定向到cat命令

    # cat /etc/fstab

    LABEL=/                 /                       ext3    defaults        1 1
    LABEL=/boot             /boot                   ext3    defaults        1 2
    none                    /dev/pts                devpts  gid=5,mode=620  0 0
    none                    /proc                   proc    defaults        0 0
    none                    /dev/shm                tmpfs   defaults        0 0
    /dev/hda3               swap                    swap    defaults        0 0
    /dev/cdrom              /mnt/cdrom              udf,iso9660 noauto,owner,kudzu,ro 0 0
    /dev/fd0                /mnt/floppy             auto    noauto,owner,kudzu 0 0

    2.2输出重定向

    输出重定向有两种方式,一种是直接输出,使用一个大于号“>”实现;另一种是以附加的方式输出,使用两个大于号“>>”实现。前者会覆盖原始的输出内容,而后者会添加到文件最后。以下通过实例说明其区别。

    //ls命令重定向到/root/dir.txt并显示

    ls >dir.txt

    cat < dir.txt

    anaconda-ks.cfg

    install.log

    install.log.syslog

    //ls -l命令以附加的方式重定向到/root/dir.txt并显示

    ls -l >>dir.txt

    cat < dir.txt

    anaconda-ks.cfg

    install.log

    install.log.syslog

    总用量 24

    -rw-r--r--  1   root   root   1245    7月22    21:07    anaconda-ks.cfg

    -rw-r--r--  1   root   root   14522  7月22    21:01    intall.log

    -rw-r--r--  1   root   root   2906    7月22     21:00   install.log.syslog

    3。管道

    管道和输入输出重定向十分类似。管道的作用是在一个命令的标准输出和另一个命令的标准输入之间建立一个通道。例如下面命令就是将ps -aux的标准输出传递给grep作为输入。

    ps -aux | grep httpd

     

    4.shell里的特殊字符

    和其他编程语言一样,shell里也有特殊字符。常见的有美元符号($),反斜线(\)和引号

    1。美元符号

    美元符号表示变量替换,即用其后面指定的变量的值来代替变量。反斜线“\”为转义字符,转义字符告诉shell不要对其后面的那个字符进行特殊处理,只是当做普通字符。而shell下的引号情况比较复杂,分为三种:双引号("),单引号(')和倒引号(`)。他们的作用都不尽相同,以下一一说明。

    2。双引号(")

    双引号括起来的字符除$,倒引号(`)和反斜线(\)仍保留其特殊功能外,其余字符均作为普通字符对待。

    3。单引号(')

    由单引号括起来的字符都作为普通字符出现。

    4。倒引号(`)

    倒引号括起来的字符串被shell解释为命令行,在执行时,shell会先执行该命令,并以它的标准输出结果取代整个引号部分

    示例1的代码及输出如下:

    #echo "My current directory is `pwd` and logname is $LOGNAME"【双引号中的倒引号和美元符号保持原来的功能】

    My current directory is /root and logname is root

     

    示例2的代码及输出如下:

    #echo "My current directory is `pwd` and logname is \$LOGNAME"【双引号中的转义字符保持原来的功能】

    My current directory is /root and logname is $LOGNAME

    示例3的代码及输出如下:

    #echo 'My current directory is `pwd` and logname is $LOGNAME'【单引号里面的内容不变】

    My current directory is `pwd`and logname is $LOGNAME

    5。shell脚本的注释

    shell脚本和其它编程语言一样,也拥有注释。注释方法为在注释行前加#号。

    例如以下脚本:

    #!/bin/sh
    #Filename: comment.sh
    #Description:this script explains how to make a comment
     
    echo “This script explains how to make a comment ”

    创建脚本时,脚本的第一行通常称为shbang(#!)行。当脚本启动后,UNIX内核检查文件的第一行以决定将要执行的程序类型。

    shbang符号(#!)后面的路径是用来解释此脚本的shell位置。要正确使用这个特性,#!必须是文件中最前面的两个字符。如果

    文件头部有空格字符或者空白行,则此特性被忽略,该行被解释为普通的注释行

    6shell脚本的注释后-f的作用

    之前是见过这样的写法:

    #!/bin/csh -f
    #Filename: comment.sh
    #Description:this script explains how to make a comment
    echo “This script explains how to make a comment ”


    通常称作快速启动选项,-f开关通知shell启动时不加载.cshrc文件。

    对ksh其shbang行可能为!/bin/ksh -p

    对于bash可能!/bin/bash --noprofile
    7.shell脚本中运算符


    范例:


    展开全文
  • Shell 编程入门(一)

    千次阅读 2019-09-27 17:28:01
    Shell 简介 什么是 Shellshell 是操作系统提供给我们用户来访问系统资源的一个接口。 shell 同时还是一个 Linux 下的命令行解释器,类似 Windows 下的 cmd。 shell 同时还是解释型的脚本语言:运行时翻译,...
  • Shell编程详解

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

    千次阅读 2019-04-15 10:00:13
    shell编程100例 https://blog.csdn.net/yugemengjing/article/details/82469785
  • 《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编程--windows下的shell开发运行工具

    万次阅读 热门讨论 2018-04-28 22:34:51
    对于shell脚本使用vim在linux开发可能效率比较底下,而且大多都是windows开发,当然能够在windows下运行更好。1、开发工具:subli text 3 1)安装插件ShellScriptImproved,用于语法提示以及关键字高亮&lt;1&...
  • 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编程 数值求和
  • LINUX Shell脚本编程实例详解(一)上

    千次阅读 2018-08-22 10:32:37
    LINUX Shell脚本编程实例详解(一)上 ping命令测试网段内主机的2例详解 使用linux已经有10来年了但是一直止于各种服务器的搭建和环境的调优,能力不能得到提升,今天突然下定决心学习Shell脚本编程,因此以网上...
  • 学习 shell 有什么好书推荐?

    千次阅读 2017-05-10 19:04:04
    《Linux Shell脚本攻略》《Linux Shell脚本攻略》 是Linux Shell 编程的实战秘籍,程序员的独门攻略:准备,动手,一举成功!对新手而言,本书的内容由浅入深且紧贴实践,使得他们能够快速地学以致用,而专业人士也...
  • linux shell编程之菜单选择(一)

    万次阅读 2012-11-30 12:16:33
    编一个shell 编写一个shell程序,使用shell编写一个菜单,分别实现列出以下内容:(1)目录内 容、(2)切换目录、(3)创建文件、(4)编辑文件、(5)删除文件的功能 #!/bin/sh until echo "1.目录内容" echo "2.切换目录...
  • Shell编程-三种方法实现九九乘法表

    千次阅读 2018-01-10 16:54:36
    方法一、 主要用的until eg: until((测试条件)) do 命令表 done i=1; until ((i>9)) do let j=1; until ((j>i)) do let "temp=i*j" echo -ne "$i*$j=$temp\t" let j++; done ...用到
1 2 3 4 5 ... 20
收藏数 181,522
精华内容 72,608
关键字:

shell编程