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编程实例合集

    千次阅读 2019-07-04 20:38:22
    1.创建hello shell 脚本。 #!/bin/bash echo "hello shell!" 2、通过位置参数创建用户,添加密码 。 #!/bin/bash #创建用户 useradd "$1" #创建密码 echo "$2" | passwd --stdin "$1" 3.备份/var/log下的所有日志...

    1.创建hello shell 脚本。

    #!/bin/bash
    echo "hello shell!"
    

    2、通过位置参数创建用户,添加密码 。

    #!/bin/bash
    #创建用户
    useradd "$1"
    #创建密码
    echo "$2" | passwd --stdin "$1"
    

    3.备份/var/log下的所有日志,日志名按当前日期命名,并每小时备份。

    #!/bin/bash
    #备份命名
    tar	-czf	log-`date +%Y%m%d`.tar.gz	/var/log
    #crontab -e 编辑计划任务执行备份脚本,  /后是备份脚本的路径
    0  */1 * * *  /backup.sh   
    

    4.检测磁盘容量,小于指定值报警给管理员。

    #!/bin/bash
    #提取根分区剩余的空间
    disk_size=$(df / | awk '/\//{print $4}')
    #查看内存剩余空间
    mem_size=$(free | awk '/Mem/{print $4}')
    while :
    do
    #注意空间大小是kb为单位,磁盘小于500m内存小于100m
    if  [  $disk_size -le 512000 -a $mem_size -le 1024000  ]
    then
        mail  ‐s  "Warning"  root  <<EOF
    	Insufficient resources,资源不足
    EOF
    fi
    done
    

    5.猜数字游戏

     #!/bin/bash
    #生成100以内的随机数 提示用户猜测 猜对为止
    #random 系统自带,值为0-32767任意数
    #随机数1-100
    num=$[RANDOM%100+1]
    echo "$num"
    #read 提示用户猜数字
    #if判断
    while  :
    do
    	read -p "计算机生成了一个 1‐100 的随机数,你猜: " cai
        if [ $cai -eq $num ]
        then
           	echo "恭喜,猜对了"
           	exit
        	elif [ $cai -gt $num ]
        	then
               	echo "Oops,猜大了"
          	else
               	echo "Oops,猜小了"
     	fi
    

    6、检测本机当前用户是否为root,如果是root,则使用 yum 安装 httpd,如果不是,则提示您非root

    #!/bin/bash
    # 检测本机当前用户是否为root用户,如果是root则使用 yum 安装 apache服务器,如果不
    # 是,则提示您非root管理员用户(使用字串对比版本)
    if [ $USER == "root" ]
    then
    	yum ‐y install httpd
    else
        echo "您不是管理员,没有权限安装软件"
    fi
    

    7.检测本机当前用户是否为超级管理员,如果是管理员,则使用 yum 安装 vsftpd,如果不是,则提示您非管理员(使用 UID 数字对比版本)

    #!/bin/bash
    # 检测本机当前用户是否为超级管理员,如果是管理员,则使用 yum 安装 vsftpd,如果不
    # 是,则提示您非管理员(使用 UID 数字对比版本)
    if [ $UID -eq 0 ];then
        yum ‐y install vsftpd
    else
        echo "您不是管理员,没有权限安装软件"
    fi
    

    8、编写脚本:提示用户输入用户名和密码,脚本自动创建相应的账户及配置密码。如果用户不输入账户名,则提示必须输入账户名并退出脚本;如果用户不输入密码,则统一使用默认的 123456 作为默认密码。

    #!/bin/bash
    # 编写脚本:提示用户输入用户名和密码,脚本自动创建相应的账户及配置密码。如果用户
    # 不输入账户名,则提示必须输入账户名并退出脚本;如果用户不输入密码,则统一使用默
    # 认的 123456 作为默认密码。
     
    read -p "请输入用户名: " user
    #使用‐z 可以判断一个变量是否为空,如果为空,提示用户必须输入账户名,并退出脚本,退出码为 2
    #没有输入用户名脚本退出后,使用$?查看的返回码为 2
    if [ -z $user ];then
       	echo "您必须输入账户名"
     	exit 2
    fi
    #使用 stty ‐echo 关闭 shell 的回显功能
    #使用 stty  echo 打开 shell 的回显功能
    stty -echo
    read -p "请输入密码: " pass
    stty echo
    pass=${pass:‐123456}
    useradd "$user"
    echo "$pass" | passwd ‐‐stdin "$user"
    

    9.输入三个数进行升序排序

    #!/bin/bash
    # 依次提示用户输入 3 个整数,脚本根据数字大小依次排序输出 3 个数字
    read -p "请输入一个整数:" num1
    read -p "请输入一个整数:" num2
    read -p "请输入一个整数:" num3
    # 不管谁大谁小,最后都打印 echo "$num1,$num2,$num3"
    # num1 中永远存最小的值,num2 中永远存中间值,num3 永远存最大值
    # 如果输入的不是这样的顺序,则改变数的存储顺序,如:可以将 num1 和 num2 的值对调
    tmp=0
    # 如果 num1 大于 num2,就把 num1 和和 num2 的值对调,确保 num1 变量中存的是最小值
    if [ $num1 -gt $num2 ];then   
    	tmp=$num1
    	num1=$num2
    	num2=$tmp
    fi
    # 如果 num1 大于 num3,就把 num1 和 num3 对调,确保 num1 变量中存的是最小值
    if [ $num1 -gt $num3 ];then   
      	tmp=$num1
      	num1=$num3
      	num3=$tmp
    fi
    # 如果 num2 大于 num3,就把 num2 和 num3 对标,确保 num2 变量中存的是小一点的值
    if [ $num2 -gt $num3 ];then
      	tmp=$num2
      	num2=$num3
      	num3=$tmp
    fi
    echo "排序后数据(从小到大)为:$num1,$num2,$num3"
    

    10、石头、剪刀、布游戏

    #!/bin/bash
    # 编写脚本,实现人机<石头,剪刀,布>游戏
    game=(石头 剪刀 布)
    num=$[RANDOM%3]
    computer=${game[$num]}
    # 通过随机数获取计算机的出拳
    # 出拳的可能性保存在一个数组中,game[0],game[1],game[2]分别是 3 中不同的可能
     
    echo "请根据下列提示选择您的出拳手势"
    echo "1.石头"
    echo "2.剪刀"
    echo "3.布"
     
    read -p "请选择 1‐3:" person
    case  $person  in
    1)
      if [ $num -eq 0 ]
      then
        echo "平局"
        elif [ $num -eq 1 ]
        then
          echo "你赢"
      else
        echo "计算机赢"
      fi;;
    2)   
      if [ $num -eq 0 ]
      then
        echo "计算机赢"
        elif [ $num -eq 1 ]
        then
          echo "平局"
      else
        echo "你赢"
      fi;;
    3)
      if [ $num -eq 0 ]
      then
        echo "你赢"
        elif [ $num -eq 1 ]
        then
          echo "计算机赢"
      else
        echo "平局"
      fi;;
    *)
      echo "必须输入 1‐3 的数字"
    esac
    

    11、编写脚本测试 192.168.4.0/24 整个网段中哪些主机处于开机状态,哪些主机处于关机状态(for 版本)

    #!/bin/bash
    # 编写脚本测试 192.168.4.0/24 整个网段中哪些主机处于开机状态,哪些主机处于关机
    # 状态(for 版本)
    for i in {1..254}
    do
    	# 每隔0.3秒ping一次,一共ping2次,并以1毫秒为单位设置ping的超时时间
       	ping ‐c 2 ‐i 0.3 ‐W 1 192.168.4.$i  &>/dev/null
        if  [ $? -eq 0 ];then
           	echo "192.168.4.$i is up"
       	else
           	echo  "192.168.4.$i is down"
       	fi
    done
    

    12、编写脚本测试 192.168.4.0/24 整个网段中哪些主机处于开机状态,哪些主机处于关机状态(多进程版)

    #!/bin/bash
    # 编写脚本测试 192.168.4.0/24 整个网段中哪些主机处于开机状态,哪些主机处于关机
    # 状态(多进程版)
     
    #定义一个函数,ping 某一台主机,并检测主机的存活状态
    myping(){
    ping ‐c 2 ‐i 0.3 ‐W 1 $1  &>/dev/null
    if  [ $? -eq 0 ];then
    	echo "$1 is up"
    else
    	echo "$1 is down"
    fi
    }
    for i in {1..254}
    do
       	myping 192.168.4.$i &
    done
    # 使用&符号,将执行的函数放入后台执行
    # 这样做的好处是不需要等待ping第一台主机的回应,就可以继续并发ping第二台主机,依次类推。
    

    13、编写脚本,显示进度条

    #!/bin/bash
    # 编写脚本,显示进度条
    
    jindu(){
    while :
    do
       	echo -n '#'
       	sleep 0.2
    done
    }
    jindu &
    cp -a $1 $2
    killall $1
    echo "拷贝完成"
    

    *14、进度条,动态时针版本;定义一个显示进度的函数,屏幕快速显示| / ‐ *

    #!/bin/bash
    # 进度条,动态时针版本
    # 定义一个显示进度的函数,屏幕快速显示|  / ‐ \
    rotate_line(){
    INTERVAL=0.5  #设置间隔时间
    COUNT="0"     #设置4个形状的编号,默认编号为 0(不代表任何图像)
    while :
    do
      COUNT=`expr $COUNT + 1` #执行循环,COUNT 每次循环加 1,(分别代表4种不同的形状)
      case $COUNT in          #判断 COUNT 的值,值不一样显示的形状就不一样
      "1")                    #值为 1 显示‐
              echo -e '‐'"\b\c"
              sleep $INTERVAL
              ;;
        "2")                  #值为 2 显示\\,第一个\是转义
              echo -e '\\'"\b\c"
              sleep $INTERVAL
              ;;
        "3")                  #值为 3 显示|
              echo -e "|\b\c"
              sleep $INTERVAL
              ;;
       "4")                   #值为 4 显示/
              echo -e "/\b\c"
              sleep $INTERVAL
              ;;
        *)                    #值为其他时,将 COUNT 重置为 0
              COUNT="0";;
        esac
    done
    }
    rotate_line
    

    15、99乘法表

    #!/bin/bash
    # 9*9 乘法表(编写 shell 脚本,打印 9*9 乘法表) 
    for i in `seq 9`
    do
      	for j in `seq $i`
       	do
           	echo -n "$j*$i=$[i*j]  "
       	done
        echo
    done
    

    16、使用死循环实时显示 eth0 网卡发送的数据包流量

        #!/bin/bash
        # 使用死循环实时显示 eth0 网卡发送的数据包流量 
         
        while :
        do
         	echo  '本地网卡 eth0 流量信息如下: '
          	ifconfig eth0 | grep "RX pack" | awk '{print $5}'
            ifconfig eth0 | grep "TX pack" | awk '{print $5}'
           	sleep 1
       done
    

    17、使用 user.txt 文件中的人员名单,在计算机中自动创建对应的账户并配置初始密码本脚本执行,需要提前准备一个 user.txt 文件,该文件中包含有若干用户名信息

    #!/bin/bash
    # 使用 user.txt 文件中的人员名单,在计算机中自动创建对应的账户并配置初始密码
    # 本脚本执行,需要提前准备一个 user.txt 文件,该文件中包含有若干用户名信息
    for i in `cat user.txt`
    do
       	useradd  $i
       	echo "123456" | passwd ‐‐stdin $i
    done
    

    18、编写批量修改扩展名脚本

    #!/bin/bash
    # 编写批量修改扩展名脚本,如批量将 txt 文件修改为 doc 文件 
    # 执行脚本时,需要给脚本添加位置参数
    # 脚本名  txt  doc(可以将 txt 的扩展名修改为 doc)
    # 脚本名  doc  jpg(可以将 doc 的扩展名修改为 jpg)
     
    for i in "ls *.$1"
    do
       	mv $i ${i%.*}.$2
    

    19、 # 使用 expect 工具自动交互密码远程其他主机安装 httpd 软件

    #!/bin/bash
    # 使用 expect 工具自动交互密码远程其他主机安装 httpd 软件 
     
    # 删除~/.ssh/known_hosts 后,ssh 远程任何主机都会询问是否确认要连接该主机
    rm  ‐rf  ~/.ssh/known_hosts
    expect <<EOF
    spawn ssh 192.168.4.254
     
    expect "yes/no" {send "yes\r"}
    # 根据自己的实际情况将密码修改为真实的密码字串
    expect "password" {send  "密码\r"}
    expect "#" {send  "yum ‐y install httpd\r"}
    expect "#" {send  "exit\r"}
    EOF
    

    20、一键部署 LNMP(源码安装版本)

    #!/bin/bash
    # 一键部署 LNMP(源码安装版本)
    
    menu()
    {
    clear
    echo "  ##############‐‐‐‐Menu‐‐‐‐##############"
    echo "# 1. Install Nginx"
    echo "# 2. Install MySQL"
    echo "# 3. Install PHP"
    echo "# 4. Exit Program"
    echo "  ########################################"
    }
     
    choice()
    {
      read -p "Please choice a menu[1‐9]:" select
    }
     
    install_nginx()
    {
      id nginx &>/dev/null
      if [ $? -ne 0 ];then
        useradd -s /sbin/nologin nginx
      fi
      if [ -f nginx‐1.8.0.tar.gz ];then
        tar -xf nginx‐1.8.0.tar.gz
        cd nginx‐1.8.0
        yum -y install  gcc pcre‐devel openssl‐devel zlib‐devel make
        ./configure ‐‐prefix=/usr/local/nginx ‐‐with‐http_ssl_module
        make
        make install
        ln -s /usr/local/nginx/sbin/nginx /usr/sbin/
        cd ..
      else
        echo "没有 Nginx 源码包"
      fi
    }
     
    install_mysql()
    {
      yum -y install gcc gcc‐c++ cmake ncurses‐devel perl
      id mysql &>/dev/null
      if [ $? -ne 0 ];then
        useradd -s /sbin/nologin mysql
      fi
      if [ -f mysql‐5.6.25.tar.gz ];then
        tar -xf mysql‐5.6.25.tar.gz
        cd mysql‐5.6.25
        cmake .
        make
        make install
        /usr/local/mysql/scripts/mysql_install_db ‐‐user=mysql ‐‐datadir=/usr/local/mysql/data/
    ‐‐basedir=/usr/local/mysql/
        chown -R root.mysql /usr/local/mysql
        chown -R mysql /usr/local/mysql/data
        /bin/cp -f /usr/local/mysql/support‐files/mysql.server /etc/init.d/mysqld
        chmod +x /etc/init.d/mysqld
        /bin/cp -f /usr/local/mysql/support‐files/my‐default.cnf /etc/my.cnf
        echo "/usr/local/mysql/lib/" >> /etc/ld.so.conf
        ldconfig
        echo 'PATH=\$PATH:/usr/local/mysql/bin/' >> /etc/profile
        export PATH
      else
        echo  "没有 mysql 源码包"
        exit
      fi
    }
     
    install_php()
    {
    #安装 php 时没有指定启动哪些模块功能,如果的用户可以根据实际情况自行添加额外功能如‐‐with‐gd 等
    yum  -y  install  gcc  libxml2‐devel
    if [ -f mhash‐0.9.9.9.tar.gz ];then
      tar -xf mhash‐0.9.9.9.tar.gz
      cd mhash‐0.9.9.9
      ./configure
      make
      make install
      cd ..
    if [ ! ‐f /usr/lib/libmhash.so ];then
      ln -s /usr/local/lib/libmhash.so /usr/lib/
    fi
    ldconfig
    else
      echo "没有 mhash 源码包文件"
      exit
    fi
    if [ -f libmcrypt‐2.5.8.tar.gz ];then
      tar -xf libmcrypt‐2.5.8.tar.gz
      cd libmcrypt‐2.5.8
      ./configure
      make
      make install
      cd ..
      if [ ! -f /usr/lib/libmcrypt.so ];then  
        ln -s /usr/local/lib/libmcrypt.so /usr/lib/
      fi
      ldconfig
    else
      echo "没有 libmcrypt 源码包文件"
      exit
    fi
    if [ -f php‐5.4.24.tar.gz ];then
      tar -xf php‐5.4.24.tar.gz
      cd php‐5.4.24
      ./configure  ‐‐prefix=/usr/local/php5  ‐‐with‐mysql=/usr/local/mysql  ‐‐enable‐fpm    ‐‐
      enable‐mbstring  ‐‐with‐mcrypt  ‐‐with‐mhash  ‐‐with‐config‐file‐path=/usr/local/php5/etc  ‐‐with‐
      mysqli=/usr/local/mysql/bin/mysql_config
      make && make install
      /bin/cp -f php.ini‐production /usr/local/php5/etc/php.ini
      /bin/cp -f /usr/local/php5/etc/php‐fpm.conf.default /usr/local/php5/etc/php‐fpm.conf
      cd ..
    else
      echo "没有 php 源码包文件"
      exit
    fi 
    }
     
    while :
    do
      menu
      choice
      case $select in
      1)
        install_nginx
        ;;
      2)
        install_mysql
        ;;
      3)
        install_php
        ;;
      4)
        exit
        ;;
      *)
        echo Sorry!
      esac
    done
    

    21、编写脚本快速克隆 KVM 虚拟机

    #!/bin/bash
    
    # 编写脚本快速克隆 KVM 虚拟机
     
    # 本脚本针对 RHEL7.2 或 Centos7.2
    # 本脚本需要提前准备一个 qcow2 格式的虚拟机模板,
    # 名称为/var/lib/libvirt/images  /.rh7_template 的虚拟机模板
    # 该脚本使用 qemu‐img 命令快速创建快照虚拟机
    # 脚本使用 sed 修改模板虚拟机的配置文件,将虚拟机名称、UUID、磁盘文件名、MAC 地址
    # exit code:  
    #    65 ‐> user input nothing
    #    66 ‐> user input is not a number
    #    67 ‐> user input out of range
    #    68 ‐> vm disk image exists
     
    IMG_DIR=/var/lib/libvirt/images
    BASEVM=rh7_template
    read -p "Enter VM number: " VMNUM
    if [ $VMNUM -le 9 ];then
    VMNUM=0$VMNUM
    fi
     
    if [ -z "${VMNUM}" ]; then
        echo "You must input a number."
        exit 65
    elif [[  ${VMNUM} =~ [a‐z]  ]; then
        echo "You must input a number."
        exit 66
    elif [ ${VMNUM} -lt 1 -o ${VMNUM} -gt 99 ]; then
        echo "Input out of range"
        exit 67
    fi
     
    NEWVM=rh7_node${VMNUM}
     
    if [ -e $IMG_DIR/${NEWVM}.img ]; then
        echo "File exists."
        exit 68
    fi
     
    echo -en "Creating Virtual Machine disk image......\t"
    qemu‐img create -f qcow2 ‐b $IMG_DIR/.${BASEVM}.img $IMG_DIR/${NEWVM}.img &> /dev/null
     
    echo -e "\e[32;1m[OK]\e[0m"
     
    #virsh dumpxml ${BASEVM} > /tmp/myvm.xml
    cat /var/lib/libvirt/images/.rhel7.xml > /tmp/myvm.xml
    sed -i "/<name>${BASEVM}/s/${BASEVM}/${NEWVM}/" /tmp/myvm.xml
    sed -i "/uuid/s/<uuid>.*<\/uuid>/<uuid>$(uuidgen)<\/uuid>/" /tmp/myvm.xml
    sed -i "/${BASEVM}\.img/s/${BASEVM}/${NEWVM}/" /tmp/myvm.xml
     
    # 修改 MAC 地址,本例使用的是常量,每位使用该脚本的用户需要根据实际情况修改这些值 
    # 最好这里可以使用便利,这样更适合于批量操作,可以克隆更多虚拟机 
    sed -i "/mac /s/a1/0c/" /tmp/myvm.xml
     
    echo -en "Defining new virtual machine......\t\t"
    virsh define /tmp/myvm.xml &> /dev/null
    echo -e "\e[32;1m[OK]\e[0m"
    

    22、点名器脚本

    #!/bin/bash
    # 编写一个点名器脚本
     
    # 该脚本,需要提前准备一个 user.txt 文件
    # 该文件中需要包含所有姓名的信息,一行一个姓名,脚本每次随机显示一个姓名
    while :
    do
    #统计 user 文件中有多少用户
    line=`cat user.txt |wc ‐l`
    num=$[RANDOM%line+1]
    sed -n "${num}p"  user.txt
    sleep 0.2
    clear
    done
    

    23.100以内求和

    #!/bin/bash
    # 对 100 以内的所有正整数相加求和(1+2+3+4...+100)
     
    #seq 100 可以快速自动生成 100 个整数
    sum=0
    for i in `seq 100`
    do
      	sum=$[sum+i]
    done
    echo "总和是:$sum"
    

    24、统计 13:30 到 14:30 所有访问 apache 服务器的请求有多少个

    #!/bin/bash
    # 统计 13:30 到 14:30 所有访问 apache 服务器的请求有多少个
     
    # awk 使用‐F 选项指定文件内容的分隔符是/或者:
    # 条件判断$7:$8 大于等于 13:30,并且要求,$7:$8 小于等于 14:30
    # 最后使用 wc ‐l 统计这样的数据有多少行,即多少个
    awk -F "[ /:]" '$7":"$8>="13:30" && $7":"$8<="14:30"' /var/log/httpd/access_log
    

    25、 统计 13:30 到 14:30 所有访问本机 Aapche 服务器远程 IP 地址是什么

    #!/bin/bash
    # 统计 13:30 到 14:30 所有访问本机 Aapche 服务器的远程 IP 地址是什么 
    # awk 使用‐F 选项指定文件内容的分隔符是/或者:
    # 条件判断$7:$8 大于等于 13:30,并且要求,$7:$8 小于等于 14:30
    # 日志文档内容里面,第 1 列是远程主机的 IP 地址,使用 awk 单独显示第 1 列即可
    awk -F "[ /:]" '$7":"$8>="13:30" && $7":"$8<="14:30"{print $1}' /var/log/httpd/access_log
    

    26、打印国际象棋棋盘

    #!/bin/bash
    # 打印国际象棋棋盘
    # 设置两个变量,i 和 j,一个代表行,一个代表列,国际象棋为 8*8 棋盘
    # i=1 是代表准备打印第一行棋盘,第 1 行棋盘有灰色和蓝色间隔输出,总共为 8 列
    # i=1,j=1 代表第 1 行的第 1 列;i=2,j=3 代表第 2 行的第 3 列
    # 棋盘的规律是 i+j 如果是偶数,就打印蓝色色块,如果是奇数就打印灰色色块
    # 使用 echo ‐ne 打印色块,并且打印完成色块后不自动换行,在同一行继续输出其他色块
    for i in {1..8}
    do
      	for j in {1..8}
      	do
      		sum=$[i+j]
    		if [  $[sum%2] -eq 0 ];then
     			echo -ne "\033[46m  \033[0m"
    		else
    			echo -ne "\033[47m  \033[0m"
    		fi
      	done
      	echo
    done
    

    27、统计每个远程 IP 访问了本机 apache 几次?

    **

    #!/bin/bash
    # 统计每个远程 IP 访问了本机 apache 几次? 
    awk  '{ip[$1]++}END{for(i in ip){print ip[i],i}}'  /var/log/httpd/access_log
    

    **
    28、统计当前 Linux 系统中可以登录计算机的账户有多少个

    #!/bin/bash
    # 统计当前 Linux 系统中可以登录计算机的账户有多少个
    #方法 1:
    grep "bash$" /etc/passwd | wc -l
    #方法 2:
    awk -f: '/bash$/{x++}end{print x}'  /etc/passwd
    #方法3
    cat /etc/passwd |grep -v nologin|wc -l
    

    29、统计/var/log 有多少个文件,并显示这些文件名

        #!/bin/bash
        # 统计/var/log 有多少个文件,并显示这些文件名 
        # 使用 ls 递归显示所有,再判断是否为文件,如果是文件则计数器加 1
        cd  /var/log
        sum=0
        for i in `ls -r *`
        do
         	if [ -f $i ];then
             	let sum++
               	echo "文件名:$i"
           	fi
        done
        echo "总文件数量为:$sum"
    

    30、自动为其他脚本添加解释器信息

    #!/bin/bash
    # 自动为其他脚本添加解释器信息#!/bin/bash,如脚本名为 test.sh 则效果如下: 
    # ./test.sh  abc.sh	自动为 abc.sh 添加解释器信息
    # ./test.sh  user.sh	自动为 user.sh 添加解释器信息
     
    # 先使用 grep 判断对象脚本是否已经有解释器信息,如果没有则使用 sed 添加解释器以及描述信息
    if  !  grep  -q  "^#!"  $1; then
    sed  '1i #!/bin/bash'  $1
    sed  '2i #Description: '
    fi
    # 因为每个脚本的功能不同,作用不同,所以在给对象脚本添加完解释器信息,以及 Description 后还希望
    # 继续编辑具体的脚本功能的描述信息,这里直接使用 vim 把对象脚本打开,并且光标跳转到该文件的第 2 行
    vim +2 $1
    

    31、自动化部署 varnish 源码包软件

    #!/bin/bash
    # 
    
    自动化部署 varnish 源码包软件 
    # 本脚本需要提前下载 varnish‐3.0.6.tar.gz 这样一个源码包软件,该脚本即可用自动源码安装部署软件
     
    yum -y install gcc readline‐devel pcre‐devel
    useradd -s /sbin/nologin varnish
    tar -xf varnish‐3.0.6.tar.gz
    cd varnish‐3.0.6
     
    # 使用 configure,make,make install 源码安装软件包
    ./configure ‐‐prefix=/usr/local/varnish
    make && make install
     
    # 在源码包目录下,将相应的配置文件拷贝到 Linux 系统文件系统中
    # 默认安装完成后,不会自动拷贝或安装配置文件到 Linux 系统,所以需要手动 cp 复制配置文件
    # 并使用 uuidgen 生成一个随机密钥的配置文件
     
    cp redhat/varnish.initrc /etc/init.d/varnish
    cp redhat/varnish.sysconfig /etc/sysconfig/varnish
    cp redhat/varnish_reload_vcl /usr/bin/
    ln -s /usr/local/varnish/sbin/varnishd /usr/sbin/
    ln -s /usr/local/varnish/bin/* /usr/bin
    mkdir /etc/varnish
    cp /usr/local/varnish/etc/varnish/default.vcl /etc/varnish/
    uuidgen > /etc/varnish/secret
    

    32、编写 nginx 启动脚本

    #!/bin/bash
    # 编写 nginx 启动脚本 
    # 本脚本编写完成后,放置在/etc/init.d/目录下,就可以被 Linux 系统自动识别到该脚本
    # 如果本脚本名为/etc/init.d/nginx,则 service nginx start 就可以启动该服务
    # service nginx stop 就可以关闭服务
    # service nginx restart 可以重启服务
    # service nginx status 可以查看服务状态
     
    program=/usr/local/nginx/sbin/nginx
    pid=/usr/local/nginx/logs/nginx.pid
    start(){
    if [ -f $pid ];then
      echo  "nginx 服务已经处于开启状态"
    else
      $program
    fi
    stop(){
    if [ -! -f $pid ];then
      echo "nginx 服务已经关闭"
    else
      $program -s stop
      echo "关闭服务 ok"
    fi
    }
    status(){
    if [ -f $pid ];then
      echo "服务正在运行..."
    else
      echo "服务已经关闭"
    fi
    }
     
    case $1 in
    start)
      start;;
    stop)
      stop;;
    restart)
      stop
      sleep 1
      start;;
    status)
      status;;
    *)
      echo  "你输入的语法格式错误"
    esac
    
    展开全文
  • shell编程100例

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

    1、编写hello world脚本

    #!/bin/bash
    
    # 编写hello world脚本
    
    echo "Hello World!"

    2、通过位置变量创建 Linux 系统账户及密码

    #!/bin/bash
    
    # 通过位置变量创建 Linux 系统账户及密码
    
    #$1 是执行脚本的第一个参数,$2 是执行脚本的第二个参数
    useradd    "$1" 
    echo "$2"  |  passwd  ‐‐stdin  "$1"

    3、备份日志

    #!/bin/bash
    # 每周 5 使用 tar 命令备份/var/log 下的所有日志文件
    # vim  /root/logbak.sh
    # 编写备份脚本,备份后的文件名包含日期标签,防止后面的备份将前面的备份数据覆盖
    # 注意 date 命令需要使用反引号括起来,反引号在键盘<tab>键上面
    tar	-czf	log-`date +%Y%m%d`.tar.gz	/var/log 
     
    # crontab ‐e	#编写计划任务,执行备份脚本
    00	03	*	*	5	/root/logbak.sh

    4、一键部署 LNMP(RPM 包版本)

    #!/bin/bash
    # 一键部署 LNMP(RPM 包版本)
    # 使用 yum 安装部署 LNMP,需要提前配置好 yum 源,否则该脚本会失败
    # 本脚本使用于 centos7.2 或 RHEL7.2
    yum ‐y install httpd
    yum ‐y install mariadb mariadb‐devel mariadb‐server
    yum ‐y install php  php‐mysql
     
    systemctl start httpd mariadb
    systemctl enable httpd mariadb

    5、监控内存和磁盘容量,小于给定值时报警

    #!/bin/bash
    
    # 实时监控本机内存和硬盘剩余空间,剩余内存小于500M、根分区剩余空间小于1000M时,发送报警邮件给root管理员
    
    # 提取根分区剩余空间
    disk_size=$(df / | awk '/\//{print $4}')
    
    # 提取内存剩余空间
    mem_size=$(free | awk '/Mem/{print $4}')
    while :
    do
    # 注意内存和磁盘提取的空间大小都是以 Kb 为单位
    if  [  $disk_size -le 512000 -a $mem_size -le 1024000  ]
    then
        mail  ‐s  "Warning"  root  <<EOF
    	Insufficient resources,资源不足
    EOF
    fi
    done

    6、猜数字游戏

     #!/bin/bash
    
    # 脚本生成一个 100 以内的随机数,提示用户猜数字,根据用户的输入,提示用户猜对了,
    # 猜小了或猜大了,直至用户猜对脚本结束。
    
    # RANDOM 为系统自带的系统变量,值为 0‐32767的随机数
    # 使用取余算法将随机数变为 1‐100 的随机数
    num=$[RANDOM%100+1]
    echo "$num"
     
    # 使用 read 提示用户猜数字
    # 使用 if 判断用户猜数字的大小关系:‐eq(等于),‐ne(不等于),‐gt(大于),‐ge(大于等于),
    # ‐lt(小于),‐le(小于等于)
    while  :
    do
    	read -p "计算机生成了一个 1‐100 的随机数,你猜: " cai
        if [ $cai -eq $num ]
        then
           	echo "恭喜,猜对了"
           	exit
        	elif [ $cai -gt $num ]
        	then
               	echo "Oops,猜大了"
          	else
               	echo "Oops,猜小了"
     	fi
    done

    7、检测本机当前用户是否为超级管理员,如果是管理员,则使用 yum 安装 vsftpd,如果不是,则提示您非管理员(使用字串对比版本)

    #!/bin/bash
    
    # 检测本机当前用户是否为超级管理员,如果是管理员,则使用 yum 安装 vsftpd,如果不
    # 是,则提示您非管理员(使用字串对比版本) 
    if [ $USER == "root" ]
    then
    	yum ‐y install vsftpd
    else
        echo "您不是管理员,没有权限安装软件"
    fi

    8、检测本机当前用户是否为超级管理员,如果是管理员,则使用 yum 安装 vsftpd,如果不是,则提示您非管理员(使用 UID 数字对比版本)

    #!/bin/bash
    
    # 检测本机当前用户是否为超级管理员,如果是管理员,则使用 yum 安装 vsftpd,如果不
    # 是,则提示您非管理员(使用 UID 数字对比版本)
    if [ $UID -eq 0 ];then
        yum ‐y install vsftpd
    else
        echo "您不是管理员,没有权限安装软件"
    fi

    9、编写脚本:提示用户输入用户名和密码,脚本自动创建相应的账户及配置密码。如果用户不输入账户名,则提示必须输入账户名并退出脚本;如果用户不输入密码,则统一使用默认的 123456 作为默认密码。

    #!/bin/bash
    
    # 编写脚本:提示用户输入用户名和密码,脚本自动创建相应的账户及配置密码。如果用户
    # 不输入账户名,则提示必须输入账户名并退出脚本;如果用户不输入密码,则统一使用默
    # 认的 123456 作为默认密码。
    
    read -p "请输入用户名: " user
    #使用‐z 可以判断一个变量是否为空,如果为空,提示用户必须输入账户名,并退出脚本,退出码为 2
    #没有输入用户名脚本退出后,使用$?查看的返回码为 2
    if [ -z $user ];then
       	echo "您不需输入账户名"
     	exit 2
    fi
    #使用 stty ‐echo 关闭 shell 的回显功能
    #使用 stty  echo 打开 shell 的回显功能
    stty -echo
    read -p "请输入密码: " pass
    stty echo
    pass=${pass:‐123456}
    useradd "$user"
    echo "$pass" | passwd ‐‐stdin "$user"

    10、输入三个数并进行升序排序

    #!/bin/bash
    
    # 依次提示用户输入 3 个整数,脚本根据数字大小依次排序输出 3 个数字
    read -p "请输入一个整数:" num1
    read -p "请输入一个整数:" num2
    read -p "请输入一个整数:" num3
    # 不管谁大谁小,最后都打印 echo "$num1,$num2,$num3"
    # num1 中永远存最小的值,num2 中永远存中间值,num3 永远存最大值
    # 如果输入的不是这样的顺序,则改变数的存储顺序,如:可以将 num1 和 num2 的值对调
    tmp=0
    # 如果 num1 大于 num2,就把 num1 和和 num2 的值对调,确保 num1 变量中存的是最小值
    if [ $num1 -gt $num2 ];then   
    	tmp=$num1
    	num1=$num2
    	num2=$tmp
    fi
    # 如果 num1 大于 num3,就把 num1 和 num3 对调,确保 num1 变量中存的是最小值
    if [ $num1 -gt $num3 ];then   
      	tmp=$num1
      	num1=$num3
      	num3=$tmp
    fi
    # 如果 num2 大于 num3,就把 num2 和 num3 对标,确保 num2 变量中存的是小一点的值
    if [ $num2 -gt $num3 ];then
      	tmp=$num2
      	num2=$num3
      	num3=$tmp
    fi
    echo "排序后数据(从小到大)为:$num1,$num2,$num3"

    11、石头、剪刀、布游戏

    #!/bin/bash
    
    # 编写脚本,实现人机<石头,剪刀,布>游戏
    game=(石头 剪刀 布)
    num=$[RANDOM%3]
    computer=${game[$num]}
    # 通过随机数获取计算机的出拳
    # 出拳的可能性保存在一个数组中,game[0],game[1],game[2]分别是 3 中不同的可能
     
    echo "请根据下列提示选择您的出拳手势"
    echo "1.石头"
    echo "2.剪刀"
    echo "3.布"
     
    read -p "请选择 1‐3:" person
    case  $person  in
    1)
      if [ $num -eq 0 ]
      then
        echo "平局"
        elif [ $num -eq 1 ]
        then
          echo "你赢"
      else
        echo "计算机赢"
      fi;;
    2)   
      if [ $num -eq 0 ]
      then
        echo "计算机赢"
        elif [ $num -eq 1 ]
        then
          echo "平局"
      else
        echo "你赢"
      fi;;
    3)
      if [ $num -eq 0 ]
      then
        echo "你赢"
        elif [ $num -eq 1 ]
        then
          echo "计算机赢"
      else
        echo "平局"
      fi;;
    *)
      echo "必须输入 1‐3 的数字"
    esac

    12、编写脚本测试 192.168.4.0/24 整个网段中哪些主机处于开机状态,哪些主机处于关机状态(for 版本)

    #!/bin/bash
    
    # 编写脚本测试 192.168.4.0/24 整个网段中哪些主机处于开机状态,哪些主机处于关机
    # 状态(for 版本)
    for i in {1..254}
    do
    	# 每隔0.3秒ping一次,一共ping2次,并以1毫秒为单位设置ping的超时时间
       	ping ‐c 2 ‐i 0.3 ‐W 1 192.168.4.$i  &>/dev/null
        if  [ $? -eq 0 ];then
           	echo "192.168.4.$i is up"
       	else
           	echo  "192.168.4.$i is down"
       	fi
    done

    13、编写脚本测试 192.168.4.0/24 整个网段中哪些主机处于开机状态,哪些主机处于关机状态(while 版本) 

    #!/bin/bash
    
    # 编写脚本测试 192.168.4.0/24 整个网段中哪些主机处于开机状态,哪些主机处于关机
    # 状态(while 版本) 
    i=1
    while [ $i -le 254 ]
    do
       	ping ‐c 2 ‐i 0.3 ‐W 1 192.168.4.$i  &>/dev/null
       	if  [ $? -eq 0 ];then
           	echo "192.168.4.$i is up"
        else
           	echo  "192.168.4.$i is down"
       	fi
       	let i++
    done

    14、编写脚本测试 192.168.4.0/24 整个网段中哪些主机处于开机状态,哪些主机处于关机状态(多进程版)

    #!/bin/bash
    
    # 编写脚本测试 192.168.4.0/24 整个网段中哪些主机处于开机状态,哪些主机处于关机
    # 状态(多进程版)
    
    #定义一个函数,ping 某一台主机,并检测主机的存活状态
    myping(){
    ping ‐c 2 ‐i 0.3 ‐W 1 $1  &>/dev/null
    if  [ $? -eq 0 ];then
    	echo "$1 is up"
    else
    	echo "$1 is down"
    fi
    }
    for i in {1..254}
    do
       	myping 192.168.4.$i &
    done
    # 使用&符号,将执行的函数放入后台执行
    # 这样做的好处是不需要等待ping第一台主机的回应,就可以继续并发ping第二台主机,依次类推。

    15、编写脚本,显示进度条

    #!/bin/bash
    
    # 编写脚本,显示进度条
    jindu(){
    while :
    do
       	echo -n '#'
       	sleep 0.2
    done
    }
    jindu &
    cp -a $1 $2
    killall $0
    echo "拷贝完成"

    16、进度条,动态时针版本;定义一个显示进度的函数,屏幕快速显示|  / ‐ \

    #!/bin/bash
    
    # 进度条,动态时针版本
    # 定义一个显示进度的函数,屏幕快速显示|  / ‐ \
    rotate_line(){
    INTERVAL=0.5  #设置间隔时间
    COUNT="0"     #设置4个形状的编号,默认编号为 0(不代表任何图像)
    while :
    do
      COUNT=`expr $COUNT + 1` #执行循环,COUNT 每次循环加 1,(分别代表4种不同的形状)
      case $COUNT in          #判断 COUNT 的值,值不一样显示的形状就不一样
      "1")                    #值为 1 显示‐
              echo -e '‐'"\b\c"
              sleep $INTERVAL
              ;;
        "2")                  #值为 2 显示\\,第一个\是转义
              echo -e '\\'"\b\c"
              sleep $INTERVAL
              ;;
        "3")                  #值为 3 显示|
              echo -e "|\b\c"
              sleep $INTERVAL
              ;;
       "4")                   #值为 4 显示/
              echo -e "/\b\c"
              sleep $INTERVAL
              ;;
        *)                    #值为其他时,将 COUNT 重置为 0
              COUNT="0";;
        esac
    done
    }
    rotate_line

    17、9*9 乘法表

    #!/bin/bash
    
    # 9*9 乘法表(编写 shell 脚本,打印 9*9 乘法表) 
    for i in `seq 9`
    do
      	for j in `seq $i`
       	do
           	echo -n "$j*$i=$[i*j]  "
       	done
        echo
    done

    18、使用死循环实时显示 eth0 网卡发送的数据包流量

    #!/bin/bash
    
    # 使用死循环实时显示 eth0 网卡发送的数据包流量 
    
    while :
    do
     	echo  '本地网卡 eth0 流量信息如下: '
      	ifconfig eth0 | grep "RX pack" | awk '{print $5}'
        ifconfig eth0 | grep "TX pack" | awk '{print $5}'
       	sleep 1
    done

    19、使用 user.txt 文件中的人员名单,在计算机中自动创建对应的账户并配置初始密码本脚本执行,需要提前准备一个 user.txt 文件,该文件中包含有若干用户名信息

    #!/bin/bash
    
    # 使用 user.txt 文件中的人员名单,在计算机中自动创建对应的账户并配置初始密码
    # 本脚本执行,需要提前准备一个 user.txt 文件,该文件中包含有若干用户名信息
    for i in `cat user.txt`
    do
       	useradd  $i
       	echo "123456" | passwd ‐‐stdin $i
    done

    20、编写批量修改扩展名脚本

    #!/bin/bash
    
    # 编写批量修改扩展名脚本,如批量将 txt 文件修改为 doc 文件 
    # 执行脚本时,需要给脚本添加位置参数
    # 脚本名  txt  doc(可以将 txt 的扩展名修改为 doc)
    # 脚本名  doc  jpg(可以将 doc 的扩展名修改为 jpg)
     
    for i in `ls *.$1`
    do
       	mv $i ${i%.*}.$2
    done

    21、使用 expect 工具自动交互密码远程其他主机安装 httpd 软件

    #!/bin/bash
    
    # 使用 expect 工具自动交互密码远程其他主机安装 httpd 软件 
    
    # 删除~/.ssh/known_hosts 后,ssh 远程任何主机都会询问是否确认要连接该主机
    rm  ‐rf  ~/.ssh/known_hosts
    expect <<EOF
    spawn ssh 192.168.4.254
    
    expect "yes/no" {send "yes\r"}
    # 根据自己的实际情况将密码修改为真实的密码字串
    expect "password" {send  "密码\r"}
    expect "#" {send  "yum ‐y install httpd\r"}
    expect "#" {send  "exit\r"}
    EOF

    22、一键部署 LNMP(源码安装版本)

    #!/bin/bash
    
    # 一键部署 LNMP(源码安装版本)
    menu()
    {
    clear
    echo "  ##############‐‐‐‐Menu‐‐‐‐##############"
    echo "# 1. Install Nginx"
    echo "# 2. Install MySQL"
    echo "# 3. Install PHP"
    echo "# 4. Exit Program"
    echo "  ########################################"
    }
     
    choice()
    {
      read -p "Please choice a menu[1‐9]:" select
    }
     
    install_nginx()
    {
      id nginx &>/dev/null
      if [ $? -ne 0 ];then
        useradd -s /sbin/nologin nginx
      fi
      if [ -f nginx‐1.8.0.tar.gz ];then
        tar -xf nginx‐1.8.0.tar.gz
        cd nginx‐1.8.0
        yum -y install  gcc pcre‐devel openssl‐devel zlib‐devel make
        ./configure ‐‐prefix=/usr/local/nginx ‐‐with‐http_ssl_module
        make
        make install
        ln -s /usr/local/nginx/sbin/nginx /usr/sbin/
        cd ..
      else
        echo "没有 Nginx 源码包"
      fi
    }
     
    install_mysql()
    {
      yum -y install gcc gcc‐c++ cmake ncurses‐devel perl
      id mysql &>/dev/null
      if [ $? -ne 0 ];then
        useradd -s /sbin/nologin mysql
      fi
      if [ -f mysql‐5.6.25.tar.gz ];then
        tar -xf mysql‐5.6.25.tar.gz
        cd mysql‐5.6.25
        cmake .
        make
        make install
        /usr/local/mysql/scripts/mysql_install_db ‐‐user=mysql ‐‐datadir=/usr/local/mysql/data/
    ‐‐basedir=/usr/local/mysql/
        chown -R root.mysql /usr/local/mysql
        chown -R mysql /usr/local/mysql/data
        /bin/cp -f /usr/local/mysql/support‐files/mysql.server /etc/init.d/mysqld
        chmod +x /etc/init.d/mysqld
        /bin/cp -f /usr/local/mysql/support‐files/my‐default.cnf /etc/my.cnf
        echo "/usr/local/mysql/lib/" >> /etc/ld.so.conf
        ldconfig
        echo 'PATH=\$PATH:/usr/local/mysql/bin/' >> /etc/profile
        export PATH
      else
        echo  "没有 mysql 源码包"
        exit
      fi
    }
     
    install_php()
    {
    #安装 php 时没有指定启动哪些模块功能,如果的用户可以根据实际情况自行添加额外功能如‐‐with‐gd 等
    yum  -y  install  gcc  libxml2‐devel
    if [ -f mhash‐0.9.9.9.tar.gz ];then
      tar -xf mhash‐0.9.9.9.tar.gz
      cd mhash‐0.9.9.9
      ./configure
      make
      make install
      cd ..
    if [ ! ‐f /usr/lib/libmhash.so ];then
      ln -s /usr/local/lib/libmhash.so /usr/lib/
    fi
    ldconfig
    else
      echo "没有 mhash 源码包文件"
      exit
    fi
    if [ -f libmcrypt‐2.5.8.tar.gz ];then
      tar -xf libmcrypt‐2.5.8.tar.gz
      cd libmcrypt‐2.5.8
      ./configure
      make
      make install
      cd ..
      if [ ! -f /usr/lib/libmcrypt.so ];then  
        ln -s /usr/local/lib/libmcrypt.so /usr/lib/
      fi
      ldconfig
    else
      echo "没有 libmcrypt 源码包文件"
      exit
    fi
    if [ -f php‐5.4.24.tar.gz ];then
      tar -xf php‐5.4.24.tar.gz
      cd php‐5.4.24
      ./configure  ‐‐prefix=/usr/local/php5  ‐‐with‐mysql=/usr/local/mysql  ‐‐enable‐fpm    ‐‐
      enable‐mbstring  ‐‐with‐mcrypt  ‐‐with‐mhash  ‐‐with‐config‐file‐path=/usr/local/php5/etc  ‐‐with‐
      mysqli=/usr/local/mysql/bin/mysql_config
      make && make install
      /bin/cp -f php.ini‐production /usr/local/php5/etc/php.ini
      /bin/cp -f /usr/local/php5/etc/php‐fpm.conf.default /usr/local/php5/etc/php‐fpm.conf
      cd ..
    else
      echo "没有 php 源码包文件"
      exit
    fi 
    }
     
    while :
    do
      menu
      choice
      case $select in
      1)
        install_nginx
        ;;
      2)
        install_mysql
        ;;
      3)
        install_php
        ;;
      4)
        exit
        ;;
      *)
        echo Sorry!
      esac
    done

    23、编写脚本快速克隆 KVM 虚拟机

    #!/bin/bash
    
    # 编写脚本快速克隆 KVM 虚拟机
    
    # 本脚本针对 RHEL7.2 或 Centos7.2
    # 本脚本需要提前准备一个 qcow2 格式的虚拟机模板,
    # 名称为/var/lib/libvirt/images  /.rh7_template 的虚拟机模板
    # 该脚本使用 qemu‐img 命令快速创建快照虚拟机
    # 脚本使用 sed 修改模板虚拟机的配置文件,将虚拟机名称、UUID、磁盘文件名、MAC 地址
    # exit code:  
    #    65 ‐> user input nothing
    #    66 ‐> user input is not a number
    #    67 ‐> user input out of range
    #    68 ‐> vm disk image exists
     
    IMG_DIR=/var/lib/libvirt/images
    BASEVM=rh7_template
    read -p "Enter VM number: " VMNUM
    if [ $VMNUM -le 9 ];then
    VMNUM=0$VMNUM
    fi
     
    if [ -z "${VMNUM}" ]; then
        echo "You must input a number."
        exit 65
    elif [[  ${VMNUM} =~ [a‐z]  ]; then
        echo "You must input a number."
        exit 66
    elif [ ${VMNUM} -lt 1 -o ${VMNUM} -gt 99 ]; then
        echo "Input out of range"
        exit 67
    fi
     
    NEWVM=rh7_node${VMNUM}
     
    if [ -e $IMG_DIR/${NEWVM}.img ]; then
        echo "File exists."
        exit 68
    fi
     
    echo -en "Creating Virtual Machine disk image......\t"
    qemu‐img create -f qcow2 ‐b $IMG_DIR/.${BASEVM}.img $IMG_DIR/${NEWVM}.img &> /dev/null
    
    echo -e "\e[32;1m[OK]\e[0m"
     
    #virsh dumpxml ${BASEVM} > /tmp/myvm.xml
    cat /var/lib/libvirt/images/.rhel7.xml > /tmp/myvm.xml
    sed -i "/<name>${BASEVM}/s/${BASEVM}/${NEWVM}/" /tmp/myvm.xml
    sed -i "/uuid/s/<uuid>.*<\/uuid>/<uuid>$(uuidgen)<\/uuid>/" /tmp/myvm.xml
    sed -i "/${BASEVM}\.img/s/${BASEVM}/${NEWVM}/" /tmp/myvm.xml
     
    # 修改 MAC 地址,本例使用的是常量,每位使用该脚本的用户需要根据实际情况修改这些值 
    # 最好这里可以使用便利,这样更适合于批量操作,可以克隆更多虚拟机 
    sed -i "/mac /s/a1/0c/" /tmp/myvm.xml
     
    echo -en "Defining new virtual machine......\t\t"
    virsh define /tmp/myvm.xml &> /dev/null
    echo -e "\e[32;1m[OK]\e[0m"

    24、点名器脚本

    #!/bin/bash
    
    # 编写一个点名器脚本
    
    # 该脚本,需要提前准备一个 user.txt 文件
    # 该文件中需要包含所有姓名的信息,一行一个姓名,脚本每次随机显示一个姓名
    while :
    do
    #统计 user 文件中有多少用户
    line=`cat user.txt |wc ‐l`
    num=$[RANDOM%line+1]
    sed -n "${num}p"  user.txt
    sleep 0.2
    clear
    done

    25、查看有多少远程的 IP 在连接本机

    #!/bin/bash
    
    # 查看有多少远程的 IP 在连接本机(不管是通过 ssh 还是 web 还是 ftp 都统计) 
    
    # 使用 netstat ‐atn 可以查看本机所有连接的状态,‐a 查看所有,
    # -t仅显示 tcp 连接的信息,‐n 数字格式显示
    # Local Address(第四列是本机的 IP 和端口信息)
    # Foreign Address(第五列是远程主机的 IP 和端口信息)
    # 使用 awk 命令仅显示第 5 列数据,再显示第 1 列 IP 地址的信息
    # sort 可以按数字大小排序,最后使用 uniq 将多余重复的删除,并统计重复的次数
    netstat -atn  |  awk  '{print $5}'  | awk  '{print $1}' | sort -nr  |  uniq -c

    26、对 100 以内的所有正整数相加求和(1+2+3+4...+100)

    #!/bin/bash
    
    # 对 100 以内的所有正整数相加求和(1+2+3+4...+100)
     
    #seq 100 可以快速自动生成 100 个整数
    sum=0
    for i in `seq 100`
    do
      	sum=$[sum+i]
    done
    echo "总和是:$sum"

    27、统计 13:30 到 14:30 所有访问 apache 服务器的请求有多少个

    #!/bin/bash
    
    # 统计 13:30 到 14:30 所有访问 apache 服务器的请求有多少个
    
    # awk 使用‐F 选项指定文件内容的分隔符是/或者:
    # 条件判断$7:$8 大于等于 13:30,并且要求,$7:$8 小于等于 14:30
    # 最后使用 wc ‐l 统计这样的数据有多少行,即多少个
    awk -F "[ /:]" '$7":"$8>="13:30" && $7":"$8<="14:30"' /var/log/httpd/access_log |wc -l

    28、统计 13:30 到 14:30 所有访问本机 Aapche 服务器的远程 IP 地址是什么 

    #!/bin/bash
    
    # 统计 13:30 到 14:30 所有访问本机 Aapche 服务器的远程 IP 地址是什么 
    # awk 使用‐F 选项指定文件内容的分隔符是/或者:
    # 条件判断$7:$8 大于等于 13:30,并且要求,$7:$8 小于等于 14:30
    # 日志文档内容里面,第 1 列是远程主机的 IP 地址,使用 awk 单独显示第 1 列即可
    awk -F "[ /:]" '$7":"$8>="13:30" && $7":"$8<="14:30"{print $1}' /var/log/httpd/access_log

    29、打印国际象棋棋盘

    #!/bin/bash
    
    # 打印国际象棋棋盘
    # 设置两个变量,i 和 j,一个代表行,一个代表列,国际象棋为 8*8 棋盘
    # i=1 是代表准备打印第一行棋盘,第 1 行棋盘有灰色和蓝色间隔输出,总共为 8 列
    # i=1,j=1 代表第 1 行的第 1 列;i=2,j=3 代表第 2 行的第 3 列
    # 棋盘的规律是 i+j 如果是偶数,就打印蓝色色块,如果是奇数就打印灰色色块
    # 使用 echo ‐ne 打印色块,并且打印完成色块后不自动换行,在同一行继续输出其他色块
    for i in {1..8}
    do
      	for j in {1..8}
      	do
      		sum=$[i+j]
    		if [  $[sum%2] -eq 0 ];then
     			echo -ne "\033[46m  \033[0m"
    		else
    			echo -ne "\033[47m  \033[0m"
    		fi
      	done
      	echo
    done

    30、统计每个远程 IP 访问了本机 apache 几次?

    #!/bin/bash
    
    # 统计每个远程 IP 访问了本机 apache 几次? 
    awk  '{ip[$1]++}END{for(i in ip){print ip[i],i}}'  /var/log/httpd/access_log

    31、统计当前 Linux 系统中可以登录计算机的账户有多少个

    #!/bin/bash
    
    # 统计当前 Linux 系统中可以登录计算机的账户有多少个
    #方法 1:
    grep "bash$" /etc/passwd | wc -l
    #方法 2:
    awk -f: '/bash$/{x++}end{print x}'  /etc/passwd

    32、统计/var/log 有多少个文件,并显示这些文件名

    #!/bin/bash
    
    # 统计/var/log 有多少个文件,并显示这些文件名 
    # 使用 ls 递归显示所有,再判断是否为文件,如果是文件则计数器加 1
    cd  /var/log
    sum=0
    for i in `ls -r *`
    do
     	if [ -f $i ];then
         	let sum++
           	echo "文件名:$i"
       	fi
    done
    echo "总文件数量为:$sum"

    33、自动为其他脚本添加解释器信息

    #!/bin/bash
    
    # 自动为其他脚本添加解释器信息#!/bin/bash,如脚本名为 test.sh 则效果如下: 
    # ./test.sh  abc.sh	自动为 abc.sh 添加解释器信息
    # ./test.sh  user.sh	自动为 user.sh 添加解释器信息
    
    # 先使用 grep 判断对象脚本是否已经有解释器信息,如果没有则使用 sed 添加解释器以及描述信息
    if  !  grep  -q  "^#!"  $1; then
    sed  '1i #!/bin/bash'  $1
    sed  '2i #Description: '
    fi
    # 因为每个脚本的功能不同,作用不同,所以在给对象脚本添加完解释器信息,以及 Description 后还希望
    # 继续编辑具体的脚本功能的描述信息,这里直接使用 vim 把对象脚本打开,并且光标跳转到该文件的第 2 行
    vim +2 $1

    34、自动化部署 varnish 源码包软件

    #!/bin/bash
    
    # 自动化部署 varnish 源码包软件 
    # 本脚本需要提前下载 varnish‐3.0.6.tar.gz 这样一个源码包软件,该脚本即可用自动源码安装部署软件
     
    yum -y install gcc readline‐devel pcre‐devel
    useradd -s /sbin/nologin varnish
    tar -xf varnish‐3.0.6.tar.gz
    cd varnish‐3.0.6
     
    # 使用 configure,make,make install 源码安装软件包
    ./configure ‐‐prefix=/usr/local/varnish
    make && make install
     
    # 在源码包目录下,将相应的配置文件拷贝到 Linux 系统文件系统中
    # 默认安装完成后,不会自动拷贝或安装配置文件到 Linux 系统,所以需要手动 cp 复制配置文件
    # 并使用 uuidgen 生成一个随机密钥的配置文件
     
    cp redhat/varnish.initrc /etc/init.d/varnish
    cp redhat/varnish.sysconfig /etc/sysconfig/varnish
    cp redhat/varnish_reload_vcl /usr/bin/
    ln -s /usr/local/varnish/sbin/varnishd /usr/sbin/
    ln -s /usr/local/varnish/bin/* /usr/bin
    mkdir /etc/varnish
    cp /usr/local/varnish/etc/varnish/default.vcl /etc/varnish/
    uuidgen > /etc/varnish/secret

    35、编写 nginx 启动脚本

    #!/bin/bash
    
    # 编写 nginx 启动脚本 
    # 本脚本编写完成后,放置在/etc/init.d/目录下,就可以被 Linux 系统自动识别到该脚本
    # 如果本脚本名为/etc/init.d/nginx,则 service nginx start 就可以启动该服务
    # service nginx stop 就可以关闭服务
    # service nginx restart 可以重启服务
    # service nginx status 可以查看服务状态
     
    program=/usr/local/nginx/sbin/nginx
    pid=/usr/local/nginx/logs/nginx.pid
    start(){
    if [ -f $pid ];then
      echo  "nginx 服务已经处于开启状态"
    else
      $program
    fi
    stop(){
    if [ -! -f $pid ];then
      echo "nginx 服务已经关闭"
    else
      $program -s stop
      echo "关闭服务 ok"
    fi
    }
    status(){
    if [ -f $pid ];then
      echo "服务正在运行..."
    else
      echo "服务已经关闭"
    fi
    }
     
    case $1 in
    start)
      start;;
    stop)
      stop;;
    restart)
      stop
      sleep 1
      start;;
    status)
      status;;
    *)
      echo  "你输入的语法格式错误"
    esac

    36、自动对磁盘分区、格式化、挂载

     #!/bin/bash
    
    # 自动对磁盘分区、格式化、挂载
    # 对虚拟机的 vdb 磁盘进行分区格式化,使用<<将需要的分区指令导入给程序 fdisk
    # n(新建分区),p(创建主分区),1(分区编号为 1),两个空白行(两个回车,相当于将整个磁盘分一个区)
    # 注意:1 后面的两个回车(空白行)是必须的!
    fdisk /dev/vdb << EOF
    n
    p
    1
     
     
    wq
    EOF
     
    #格式化刚刚创建好的分区
    mkfs.xfs   /dev/vdb1
     
    #创建挂载点目录
    if [ -e /data ]; then
    exit
    fi
    mkdir /data
     
    #自动挂载刚刚创建的分区,并设置开机自动挂载该分区
    echo '/dev/vdb1     /data    xfs    defaults        1 2'  >> /etc/fstab
    mount -a
    

    37、自动优化 Linux 内核参数

    #!/bin/bash
    
    # 自动优化 Linux 内核参数
    
    #脚本针对 RHEL7
    cat >> /usr/lib/sysctl.d/00‐system.conf <<EOF
    fs.file‐max=65535
    net.ipv4.tcp_timestamps = 0
    net.ipv4.tcp_synack_retries = 5
    net.ipv4.tcp_syn_retries = 5
    net.ipv4.tcp_tw_recycle = 1
    net.ipv4.tcp_tw_reuse = 1
    net.ipv4.tcp_fin_timeout = 30
    #net.ipv4.tcp_keepalive_time = 120
    net.ipv4.ip_local_port_range = 1024  65535
    kernel.shmall = 2097152
    kernel.shmmax = 2147483648
    kernel.shmmni = 4096
    kernel.sem = 5010 641280 5010 128
    net.core.wmem_default=262144
    net.core.wmem_max=262144
    net.core.rmem_default=4194304
    net.core.rmem_max=4194304
    net.ipv4.tcp_fin_timeout = 10
    net.ipv4.tcp_keepalive_time = 30
    net.ipv4.tcp_window_scaling = 0
    net.ipv4.tcp_sack = 0
    EOF
     
    sysctl –p
    

    38、切割 Nginx 日志文件(防止单个文件过大,后期处理很困难)

    #mkdir  /data/scripts
    #vim   /data/scripts/nginx_log.sh  
    #!/bin/bash
    
    # 切割 Nginx 日志文件(防止单个文件过大,后期处理很困难) 
    logs_path="/usr/local/nginx/logs/"
    mv ${logs_path}access.log ${logs_path}access_$(date -d "yesterday" +"%Y%m%d").log
    kill -USR1  `cat /usr/local/nginx/logs/nginx.pid`
     
    # chmod +x  /data/scripts/nginx_log.sh
    # crontab  ‐e                    #脚本写完后,将脚本放入计划任务每天执行一次脚本
    0  1  *  *   *   /data/scripts/nginx_log.sh

    39、检测 MySQL 数据库连接数量

    #!/bin/bash
    
    # 检测 MySQL 数据库连接数量 
    
    # 本脚本每 2 秒检测一次 MySQL 并发连接数,可以将本脚本设置为开机启动脚本,或在特定时间段执行
    # 以满足对 MySQL 数据库的监控需求,查看 MySQL 连接是否正常
    # 本案例中的用户名和密码需要根据实际情况修改后方可使用
    log_file=/var/log/mysql_count.log
    user=root
    passwd=123456
    while :
    do
        sleep 2
        count=`mysqladmin  -u  "$user"  -p  "$passwd"   status |  awk '{print $4}'`
        echo "`date +%Y‐%m‐%d` 并发连接数为:$count" >> $log_file
    done

    40、根据 md5 校验码,检测文件是否被修改

    #!/bin/bash
    
    # 根据 md5 校验码,检测文件是否被修改 
    # 本示例脚本检测的是/etc 目录下所有的 conf 结尾的文件,根据实际情况,您可以修改为其他目录或文件
    # 本脚本在目标数据没有被修改时执行一次,当怀疑数据被人篡改,再执行一次
    # 将两次执行的结果做对比,MD5 码发生改变的文件,就是被人篡改的文件
    for i in $(ls /etc/*.conf)
    do
    	md5sum "$i" >> /var/log/conf_file.log
    done

    41、检测 MySQL 服务是否存活

    #!/bin/bash
    
    # 检测 MySQL 服务是否存活 
    
    # host 为你需要检测的 MySQL 主机的 IP 地址,user 为 MySQL 账户名,passwd 为密码
    # 这些信息需要根据实际情况修改后方可使用
    host=192.168.51.198
    user=root
    passwd=123456
    mysqladmin -h '$host' -u '$user' -p'$passwd' ping &>/dev/null
    if [ $? -eq 0 ]
    then
            echo "MySQL is UP"
    else
            echo "MySQL is down"
    fi
    

    42、备份 MySQL 的 shell 脚本(mysqldump版本)

    #!/bin/bash
    
    # 备份 MySQL 的 shell 脚本(mysqldump版本) 
    
    # 定义变量 user(数据库用户名),passwd(数据库密码),date(备份的时间标签)
    # dbname(需要备份的数据库名称,根据实际需求需要修改该变量的值,默认备份 mysql 数据库)
     
    user=root
    passwd=123456
    dbname=mysql
    date=$(date +%Y%m%d)
     
    # 测试备份目录是否存在,不存在则自动创建该目录
    [ ! -d /mysqlbackup ] && mkdir /mysqlbackup
    # 使用 mysqldump 命令备份数据库
    mysqldump -u "$user" -p "$passwd" "$dbname" > /mysqlbackup/"$dbname"-${date}.sql

    43、将文件中所有的小写字母转换为大写字母

    #!/bin/bash
    
    # 将文件中所有的小写字母转换为大写字母 
    
    # $1是位置参数,是你需要转换大小写字母的文件名称
    # 执行脚本,给定一个文件名作为参数,脚本就会将该文件中所有的小写字母转换为大写字母
    tr "[a‐z]" "[A‐Z]" < $1

    44、非交互自动生成 SSH 密钥文件

    #!/bin/bash
    
    # 非交互自动生成 SSH 密钥文件 
    
    # ‐t 指定 SSH 密钥的算法为 RSA 算法;‐N 设置密钥的密码为空;‐f 指定生成的密钥文件>存放在哪里
    rm  -rf  ~/.ssh/{known_hosts,id_rsa*}
    ssh‐keygen -t RSA -N '' -f ~/.ssh/id_rsa
    

    45、检查特定的软件包是否已经安装

    #!/bin/bash
    
    # 检查特定的软件包是否已经安装 
    if [ $# -eq 0 ];then
      echo "你需要制定一个软件包名称作为脚本参数"
      echo "用法:$0 软件包名称 ..."
    fi
    # $@提取所有的位置变量的值,相当于$*
    for package in "$@"
    do
      	if rpm -q ${package} &>/dev/null ;then
    		echo -e "${package}\033[32m 已经安装\033[0m"
      	else
    		echo -e "${package}\033[34;1m 未安装\033[0m"
      	fi
    done

    46、监控 HTTP 服务器的状态(测试返回码)

    #!/bin/bash
    
    # 监控 HTTP 服务器的状态(测试返回码)
    
    # 设置变量,url为你需要检测的目标网站的网址(IP 或域名),比如百度
    url=http://http://183.232.231.172/index.html
    
    # 定义函数 check_http:
    # 使用 curl 命令检查 http 服务器的状态
    # ‐m 设置curl不管访问成功或失败,最大消耗的时间为 5 秒,5 秒连接服务为相应则视为无法连接
    # ‐s 设置静默连接,不显示连接时的连接速度、时间消耗等信息
    # ‐o 将 curl 下载的页面内容导出到/dev/null(默认会在屏幕显示页面内容)
    # ‐w 设置curl命令需要显示的内容%{http_code},指定curl返回服务器的状态码
    check_http()
    {
            status_code=$(curl -m 5 -s -o /dev/null -w %{http_code} $url)
    }
    
    while :
    do
            check_http
            date=$(date +%Y%m%d‐%H:%M:%S)
    
    # 生成报警邮件的内容
            echo "当前时间为:$date
            $url 服务器异常,状态码为${status_code}.
            请尽快排查异常." > /tmp/http$$.pid
    
    # 指定测试服务器状态的函数,并根据返回码决定是发送邮件报警还是将正常信息写入日志
            if [ $status_code -ne 200 ];then
                    mail -s Warning root < /tmp/http$$.pid
            else
                    echo "$url 连接正常" >> /var/log/http.log
            fi
            sleep 5
    done
    
    

    47、自动添加防火墙规则,开启某些服务或端口(适用于 RHEL7)

    #!/bin/bash
    
    # 自动添加防火墙规则,开启某些服务或端口(适用于 RHEL7)
    # 
    # 设置变量定义需要添加到防火墙规则的服务和端口号
    # 使用 firewall‐cmd ‐‐get‐services 可以查看 firewall 支持哪些服务
    service="nfs http ssh"
    port="80 22 8080"
     
    # 循环将每个服务添加到防火墙规则中
    for i in $service
    do
      	echo "Adding $i service to firewall"
      	firewall‐cmd  --add-service=${i}
    done
     
    #循环将每个端口添加到防火墙规则中
    for i in $port
    do
      	echo "Adding $i Port to firewall"
      	firewall‐cmd --add-port=${i}/tcp
    done
    #将以上设置的临时防火墙规则,转换为永久有效的规则(确保重启后有效)
    firewall‐cmd  --runtime-to-permanent

    48、使用脚本自动创建逻辑卷

    #!/bin/bash
    
    # 使用脚本自动创建逻辑卷 
    
    # 清屏,显示警告信息,创建将磁盘转换为逻辑卷会删除数据
    clear
    echo -e "\033[32m           !!!!!!警告(Warning)!!!!!!\033[0m"
    echo
    echo "+++++++++++++++++++++++++++++++++++++++++++++++++"
    echo "脚本会将整个磁盘转换为 PV,并删除磁盘上所有数据!!!"
    echo "This Script will destroy all data on the Disk"
    echo "+++++++++++++++++++++++++++++++++++++++++++++++++"
    echo
    read -p "请问是否继续 y/n?:" sure
    
    # 测试用户输入的是否为 y,如果不是则退出脚本
    [ $sure != y ] && exit
     
    # 提示用户输入相关参数(磁盘、卷组名称等数据),并测试用户是否输入了这些值,如果没有输入,则脚本退出
    read -p "请输入磁盘名称,如/dev/vdb:" disk
    [ -z $disk ] && echo "没有输入磁盘名称" && exit
    read -p "请输入卷组名称:" vg_name
    [ -z $vg_name ] && echo "没有输入卷组名称" && exit
    read -p "请输入逻辑卷名称:" lv_name
    [ -z $lv_name ] && echo "没有输入逻辑卷名称" && exit
    read -p "请输入逻辑卷大小:" lv_size
    [ -z $lv_size ] && echo "没有输入逻辑卷大小" && exit
     
    # 使用命令创建逻辑卷
    pvcreate $disk
    vgcreate $vg_name $disk
    lvcreate -L ${lv_size}M -n ${lv_name}  ${vg_name}

    49、显示 CPU 厂商信息

    #!/bin/bash
    
    # 显示 CPU 厂商信息 
    awk '/vendor_id/{print $3}' /proc/cpuinfo | uniq

    50、删除某个目录下大小为 0 的文件

    #!/bin/bash
    
    # 删除某个目录下大小为 0 的文件
    
    #/var/www/html 为测试目录,脚本会清空该目录下所有 0 字节的文件
    dir="/var/www/html"
    find $dir -type f -size 0 -exec rm -rf {} \;

    51、查找 Linux 系统中的僵尸进程

    #!/bin/bash
    
    # 查找 Linux 系统中的僵尸进程
    
    # awk 判断 ps 命令输出的第 8 列为 Z 是,显示该进程的 PID 和进程命令
    ps aux | awk '{if($8 == "Z"){print $2,$11}}'

    52、提示用户输入年份后判断该年是否为闰年

    #!/bin/bash
    
    # 提示用户输入年份后判断该年是否为闰年
    
    # 能被4整除并且并不能被100整除的年份是闰年
    # 能被400整除的年份也是闰年
    read -p "请输入一个年份:" year
     
    if [ "$year" = "" ];then
        echo "没有输入年份"
        exit
    fi
    #使用正则测试变量 year 中是否包含大小写字母
    if [[ "$year" =~ [a‐Z] ]];then
        echo "你输入的不是数字"
        exit
    fi
    # 判断是否为闰年
    if [ $[year % 4] -eq 0 ] && [ $[year % 100] -ne 0 ];then
        echo "$year年是闰年"  
    elif [ $[year % 400] -eq 0 ];then
        echo "$year年是闰年"
    else
        echo "$year年不是闰年"
    fi

    53、生成随机密码(urandom 版本)

    #!/bin/bash
    
    # 生成随机密码(urandom 版本) 
    
    # /dev/urandom 文件是 Linux 内置的随机设备文件
    # cat /dev/urandom 可以看看里面的内容,ctrl+c 退出查看
    # 查看该文件内容后,发现内容有些太随机,包括很多特殊符号,我们需要的密码不希望使用这些符号
    # tr ‐dc '_A‐Za‐z0‐9' < /dev/urandom
    # 该命令可以将随机文件中其他的字符删除,仅保留大小写字母,数字,下划线,但是内容还是太多
    # 我们可以继续将优化好的内容通过管道传递给 head 命令,在大量数据中仅显示头 10 个字节
    # 注意 A 前面有个下划线
    tr -dc '_A‐Za‐z0‐9' </dev/urandom | head -c 10

    54、生成随机密码(字串截取版本)

    #!/bin/bash
    
    # 生成随机密码(字串截取版本) 
    
    # 设置变量 key,存储密码的所有可能性(密码库),如果还需要其他字符请自行添加其他密码字符
    # 使用$#统计密码库的长度
    key="0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    num=${#key}
    # 设置初始密码为空
    pass=''
    # 循环 8 次,生成随机密码
    # 每次都是随机数对密码库的长度取余,确保提取的密码字符不超过密码库的长度
    # 每次循环提取一位随机密码,并将该随机密码追加到 pass 变量的最后
    for i in {1..8}
    do  
      index=$[RANDOM%num]
      pass=$pass${key:$index:1}
    done
    echo $pass

    55、生成随机密码(UUID 版本,16 进制密码)

    #!/bin/bash
    
    # 生成随机密码(UUID 版本,16 进制密码) 
    uuidgen

    56、生成随机密码(进程 ID 版本,数字密码)

    #!/bin/bash
    
    # 生成随机密码(进程 ID 版本,数字密码)
    echo $$

    57、测试用户名与密码是否正确

    #!/bin/bash
    
    # 测试用户名与密码是否正确
    
    #用户名为 tom 并且密码为 123456,则提示登录成功,否则提示登录失败
    read -p "请输入用户名:"  user
    read -p "请输入密码:"    pass
    if [ "$user" == 'tom' -a "$pass" == '123456' ];then
    	echo "Login successful"
    else
    	echo "Login Failed"
    fi

    58、循环测试用户名与密码是否正确

    #!/bin/bash
    
    # 循环测试用户名与密码是否正确 
    
    # 循环测试用户的账户名和密码,最大测试 3 次,输入正确提示登录成功,否则提示登录失败
    # 用户名为 tom 并且密码为 123456  
    for i in {1..3}
    do
    	read -p "请输入用户名:" user
    	read -p "请输入密码:"   pass
    if [ "$user" == 'tom' -a "$pass" == '123456' ];then
      	echo "Login successful"
       	exit
    fi
    done
    echo "Login Failed"

    59、Shell 脚本的 fork 炸弹

    #!/bin/bash
    
    # Shell 脚本的 fork 炸弹 
    
    # 快速消耗计算机资源,致使计算机死机
    # 定义函数名为.(点), 函数中递归调用自己并放入后台执行
    .() { .|.& };.

    60、批量下载有序文件(pdf、图片、视频等等)

    #!/bin/bash
    
    # 批量下载有序文件(pdf、图片、视频等等)
    
    # 本脚本准备有序的网络资料进行批量下载操作(如 01.jpg,02.jpg,03.jpg)
    # 设置资源来源的域名连接
    url="http://www.baidu.com/"
    echo  "开始下载..."
    sleep 2
    type=jpg
    for i in `seq 100`
       	echo "正在下载$i.$type"
    	curl $url/$i.$type -o /tmp/${i}$type
       	sleep 1
    done
    #curl 使用-o 选项指定下载文件另存到哪里.

    61、显示当前计算机中所有账户的用户名称

     #!/bin/bash
    
    # 显示当前计算机中所有账户的用户名称
    
    # 下面使用3种不同的方式列出计算机中所有账户的用户名
    # 指定以:为分隔符,打印/etc/passwd 文件的第 1 列
    awk -F: '{print $1}' /etc/passwd
     
    # 指定以:为分隔符,打印/etc/passwd 文件的第 1 列
    cut -d: -f1 /etc/passwd
     
    # 使用 sed 的替换功能,将/etc/passwd 文件中:后面的所有内容替换为空(仅显示用户名)
    sed 's/:.*//' /etc/passwd

    62、制定目录路径,脚本自动将该目录使用 tar 命令打包备份到/data目录

    #!/bin/bash
    
    # 制定目录路径,脚本自动将该目录使用 tar 命令打包备份到/data目录 
    
    [ ! -d /data ] && mkdir /data
    [ -z $1 ] && exit
    if [ -d $1 ];then
    	tar -czf /data/$1.-`date +%Y%m%d`.tar.gz $1
    else
      	echo "该目录不存在"
    fi

    63、显示进度条(回旋镖版)

    #!/bin/bash
    
    # 显示进度条(回旋镖版)
    
    while :
    do
    	clear
    	for i in {1..20}
    	do
    		echo ‐e "\033[3;${i}H*"
    		sleep 0.1
      	done
      	clear
      	for i in {20..1}
      	do
    		echo ‐e "\033[3;${i}H*"
    		sleep 0.1
      	done
      	clear
    done

    64、安装 LAMP 环境(yum 版本)

    #!/bin/bash
    
    # 安装 LAMP 环境(yum 版本) 
    
    # 本脚本适用于 RHEL7(RHEL6 中数据库为 mysql)
    yum makecache &>/dev/null
    num=$(yum repolist | awk '/repolist/{print $2}' | sed 's/,//')
    if [ $num -lt 0 ];then
    	yum -y install httpd
    	yum -y install mariadb mariadb-server mariadb-devel
    	yum -y install php php-mysql
    else
    	echo "未配置 yum 源..."
    fi

    65、循环关闭局域网中所有主机

    #!/bin/bash
    
    # 循环关闭局域网中所有主机 
    
    # 假设本机为 192.168.4.100,编写脚本关闭除自己外的其他所有主机
    # 脚本执行,需要提前给所有其他主机传递 ssh 密钥,满足无密码连接
    for i in {1..254}
    do
    	[ $i -eq 100 ] && continue
    	echo "正在关闭 192.168.4.$i..."
    	ssh 192.168.4.$i poweroff
    done

    66、获取本机 MAC 地址

    #!/bin/bash
    
    # 获取本机 MAC 地址
    ip a s | awk 'BEGIN{print  " 本 机 MAC 地 址 信 息 如 下 :"}/^[0‐9]/{print $2;getline;if($0~/link\/ether/){print $2}}' | grep -v lo:
     
    # awk 读取 ip 命令的输出,输出结果中如果有以数字开始的行,先显示该行的地 2 列(网卡名称),
    # 接着使用 getline 再读取它的下一行数据,判断是否包含 link/ether
    # 如果保护该关键词,就显示该行的第 2 列(MAC 地址)
    # lo 回环设备没有 MAC,因此将其屏蔽,不显示

    67、自动配置 rsynd 服务器的配置文件 rsyncd.conf

    #!/bin/bash
    
    # 自动配置 rsynd 服务器的配置文件 rsyncd.conf
    
    # See rsyncd.conf man page for more options.
     
    [ ! -d /home/ftp ] && mkdir /home/ftp
    echo 'uid = nobody
    gid = nobody
    use chroot = yes
    max connections = 4
    pid file = /var/run/rsyncd.pid
    exclude = lost+found/
    transfer logging = yes
    timeout = 900
    ignore nonreadable = yes
    dont compress   = *.gz *.tgz *.zip *.z *.Z *.rpm *.deb *.bz2
    [ftp]
        path = /home/ftp
        comment = share' > /etc/rsyncd.conf

    68、修改 Linux 系统的最大打开文件数量

    #!/bin/bash
    
    # 修改 Linux 系统的最大打开文件数量 
    
    # 往/etc/security/limits.conf 文件的末尾追加两行配置参数,修改最大打开文件数量为 65536
    cat >> /etc/security/limits.conf <<EOF
    * soft nofile  65536
    * hard nofile  65536
    EOF

    69、设置 Python 支持自动命令补齐功能

    #!/bin/bash
    
    # 设置 Python 支持自动命令补齐功能 
    
    # Summary:Enable tab complete for python
    # Description:
    
    Needs import readline and rlcompleter module
    #
    import readline
    #
    import rlcompleter
    #
    help(rlcompleter) display detail: readline.parse_and_bind('tab: complete')
    #
    man python display detail: PYTHONSTARTUP variable
     
    if  [ ! -f /usr/bin/tab.py ];then
    	cat >> /usr/bin/tab.py <<EOF
    import readline
    import rlcompleter
    readline.parse_and_bind('tab: complete')
    EOF
    fi
    sed  -i '$a export PYTHONSTARTUP=/usr/bin/tab.py' /etc/profile
    source /etc/profile

    70、自动修改计划任务配置文件

    #!/bin/bash
    
    # 自动修改计划任务配置文件 
    
    read -p "请输入分钟信息(00‐59):" min
    read -p "请输入小时信息(00‐24):" hour
    read -p "请输入日期信息(01‐31):" date
    read -p "请输入月份信息(01‐12):" month
    read -p "请输入星期信息(00‐06):" weak
    read -p "请输入计划任务需要执行的命令或脚本:" program
    echo "$min $hour $date $month $weak $program" >> /etc/crontab

    71、使用脚本循环创建三位数字的文本文件(111-999 的文件)

    #!/bin/bash
    
    # 使用脚本循环创建三位数字的文本文件(111-999 的文件) 
    
    for i in {1..9}
    do
    	for j in {1..9}
    	do
    		for k in {1..9}
    		do
    			touch /tmp/$i$j$k.txt
    		done
      	done
    done

    72、找出/etc/passwd 中能登录的用户,并将对应在/etc/shadow 中第二列密码提出处理

    #!/bin/bash
    
    # 找出/etc/passwd 中能登录的用户,并将对应在/etc/shadow 中第二列密码提出处理
    
    user=$(awk -F: '/bash$/{print $1}' /etc/passwd)
    for i in $user
    do
    	awk -F: -v x=$i '$1==x{print $1,$2}' /etc/shadow
    done

    73、统计/etc/passwd 中 root 出现的次数

    #!/bin/bash
    
    # 统计/etc/passwd 中 root 出现的次数 
    
    #每读取一行文件内容,即从第 1 列循环到最后 1 列,依次判断是否包含 root 关键词,如果包含则 x++
    awk -F: '{i=1;while(i<=NF){if($i~/root/){x++};i++}} END{print "root 出现次数为"x}' /etc/passwd

    74、统计 Linux 进程相关数量信息

    #!/bin/bash
    
    # 统计 Linux 进程相关数量信息 
    
    running=0
    sleeping=0
    stoped=0
    zombie=0
    # 在 proc 目录下所有以数字开始的都是当前计算机正在运行的进程的进程 PID
    # 每个 PID 编号的目录下记录有该进程相关的信息
    for pid in /proc/[1‐9]*
    do
    	procs=$[procs+1]
    	stat=$(awk '{print $3}' $pid/stat)
    # 每个 pid 目录下都有一个 stat 文件,该文件的第 3 列是该进程的状态信息
      	case $stat in
      	R)
    		running=$[running+1]
    		;;
      	T)
    		stoped=$[stoped+1]
    		;;
      	S)
    		sleeping=$[sleeping+1]
    		;;
      	Z)
     		zombie=$[zombie+1]
     		;;
      	esac
    done
    echo "进程统计信息如下"
    echo "总进程数量为:$procs"
    echo "Running 进程数为:$running"
    echo "Stoped 进程数为:$stoped"
    echo "Sleeping 进程数为:$sleeping"
    echo "Zombie 进程数为:$zombie"

    75、从键盘读取一个论坛积分,判断论坛用户等级

    #!/bin/bash
    
    # 从键盘读取一个论坛积分,判断论坛用户等级
    
    #等级分类如下:
    #  大于等于 90				神功绝世
    #  大于等于 80,小于 90       登峰造极
    #  大于等于 70,小于 80       炉火纯青
    #  大于等于 60,小于 70       略有小成
    #  小于 60         			初学乍练
    read -p "请输入积分(0‐100):" JF
    if [ $JF -ge 90 ] ; then
    	echo "$JF 分,神功绝世"
    elif [ $JF -ge 80 ] ; then
        echo "$JF 分,登峰造极"
    elif [ $JF -ge 70 ] ; then
        echo "$JF 分,炉火纯青"
    elif [ $JF -lt 60 ] ; then
        echo "$JF 分,略有小成"
    else
        echo "$JF 分,初学乍练"
    fi

    76、判断用户输入的数据类型(字母、数字或其他) 

    #!/bin/bash
    
    # 判断用户输入的数据类型(字母、数字或其他) 
    read -p "请输入一个字符:" KEY
    case "$KEY" in
    	[a‐z]|[A‐Z])
    		echo "字母" 
    		;;
    	[0‐9])
    		echo "数字" 
    		;;
    	*)
    		echo "空格、功能键或其他控制字符"
    esac

    77、显示进度条(数字版) 

    #!/bin/bash
    
    # 显示进度条(数字版) 
    # echo 使用‐e 选项后,在打印参数中可以指定 H,设置需要打印内容的 x,y 轴的定位坐标
    # 设置需要打印内容在第几行,第几列
    for i in {1..100}
    do
      	echo -e "\033[6;8H["
      	echo -e "\033[6;9H$i%"
      	echo -e "\033[6;13H]"
      	sleep 0.1
    done

    78、打印斐波那契数列

    #!/bin/bash
    
    # 打印斐波那契数列(该数列的特点是后一个数字,永远都是前 2 个数字之和) 
    
    # 斐波那契数列后一个数字永远是前 2 个数字之和
    # 如:0  1  1  2  3  5  8  13 ... ...
    list=(0 1)
    for i in `seq 2 11`
    do
    	list[$i]=`expr ${list[‐1]} + ${list[‐2]}`
    done
    echo ${list[@]}

    79、判断用户输入的是 Yes 或 NO

    #!/bin/bash
    
    # 判断用户输入的是 Yes 或 NO 
    
    read -p  "Are you sure?[y/n]:"  sure
    case  $sure  in
    	y|Y|Yes|YES)  
    		echo "you enter $a"
    		;;
        n|N|NO|no)
     		echo "you enter $a"
     		;;
        *)
     		echo "error";;
    esac

    80、显示本机 Linux 系统上所有开放的端口列表

    #!/bin/bash
    
    # 显示本机 Linux 系统上所有开放的端口列表 
    
    # 从端口列表中观测有没有没用的端口,有的话可以将该端口对应的服务关闭,防止意外的攻击可能性
    ss -nutlp | awk '{print $1,$5}' | awk -F"[: ]" '{print "协议:"$1,"端口号:"$NF}' | grep "[0‐9]" | uniq

    81、将 Linux 系统中 UID 大于等于 1000 的普通用户都删除

    #!/bin/bash
    
    # 将 Linux 系统中 UID 大于等于 1000 的普通用户都删除 
    
    # 先用 awk 提取所有 uid 大于等于 1000 的普通用户名称
    # 再使用 for 循环逐个将每个用户删除即可
    user=$(awk -F: '$3>=1000{print $1}' /etc/passwd)
    for i in $user
    do
       	userdel -r $i
    done

    82、使用脚本开启关闭虚拟机

    #!/bin/bash
    
    # 使用脚本开启关闭虚拟机 
    
    # 脚本通过调用virsh命令实现对虚拟机的管理,如果没有该命令,需要安装 libvirt‐client 软件包
    # $1是脚本的第1个参数,$2是脚本的第2个参数
    # 第1个参数是你希望对虚拟机进行的操作指令,第2个参数是虚拟机名称
    case $1 in
      list)
        virsh list --all
        ;;
      start)
        virsh start $2
        ;;
      stop)
        virsh destroy $2
        ;;
      enable)
        virsh autostart $2
        ;;
      disable)
        virsh autostart --disable $2
        ;;
      *)
        echo "Usage:$0 list"
        echo "Usage:$0 [start|stop|enable|disable]  VM_name"
        cat << EOF
        #list      显示虚拟机列表
        #start     启动虚拟机
        #stop      关闭虚拟机
        #enable    设置虚拟机为开机自启
        #disable   关闭虚拟机开机自启功能
        EOF
        ;;
    esac

    83、调整虚拟机内存参数的 shell 脚本 

    #!/bin/bash
    
    # 调整虚拟机内存参数的 shell 脚本 
    
    # 脚本通过调用 virsh 命令实现对虚拟机的管理,如果没有该命令,需要安装 libvirt‐client 软件包
    cat << EOF
    1.调整虚拟机最大内存数值
    2.调整实际分配给虚拟机的内存数值
    EOF
    read -p "请选择[1‐2]:" select
    case $select in
    	1)
      		read -p "请输入虚拟机名称" name
      		read -p "请输入最大内存数值(单位:k):" size
      		virsh setmaxmem $name --size $size --config
      		;;
    	2)
      		read -p "请输入虚拟机名称" name
      		read -p "请输入实际分配内存数值(单位:k):" size
      		virsh setmem $name $size
      		;;
    	*)
      		echo "Error"
      		;;
    esac

    84、查看 KVM 虚拟机中的网卡信息(不需要进入启动或进入虚拟机) 

    #!/bin/bash
    
    # 查看 KVM 虚拟机中的网卡信息(不需要进入启动或进入虚拟机) 
    
    # 该脚本使用 guestmount 工具,可以将虚拟机的磁盘系统挂载到真实机文件系统中
    # Centos7.2 中安装 libguestfs‐tools‐c 可以获得 guestmount 工具
    # 虚拟机可以启动或者不启动都不影响该脚本的使用
    # 将虚拟机磁盘文件挂载到文件系统后,就可以直接读取磁盘文件中的网卡配置文件中的数据
    clear
    mountpoint="/media/virtimage"
    [ ! -d $mountpoint ] && mkdir $mountpoint
    read -p "输入虚拟机名称:" name
    echo "请稍后..."
    # 如果有设备挂载到该挂载点,则先 umount 卸载
    if mount | grep -q "$mountpoint" ;then
    	umount $mountpoint
    fi
    # 只读的方式,将虚拟机的磁盘文件挂载到特定的目录下,这里是/media/virtimage 目录
    guestmount -r -d $name -i $mountpoint
    echo
    echo "‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐"
    echo -e "\033[32m$name 虚拟机中网卡列表如下:\033[0m"
    dev=$(ls /media/virtimage/etc/sysconfig/network‐scripts/ifcfg-* |awk -F"[/‐]" '{print $9}')
    echo $dev
    echo "‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐"
    echo
    echo
    echo "+++++++++++++++++++++++++++++++++++++++++++"
    echo -e "\033[32m 网卡 IP 地址信息如下:\033[0m"
    for i in $dev
    do
      echo -n "$i:"
      grep -q "IPADDR" /media/virtimage/etc/sysconfig/network‐scripts/ifcfg-$i || echo "未配置 IP地址"
      awk -F= '/IPADDR/{print $2}' /media/virtimage/etc/sysconfig/network-scripts/ifcfg-$i
    done
    echo "+++++++++++++++++++++++++++++++++++++++++++"

    85、不登陆虚拟机,修改虚拟机网卡 IP 地址

    #!/bin/bash
    
    # 不登陆虚拟机,修改虚拟机网卡 IP 地址 
    
    # 该脚本使用 guestmount 工具,Centos7.2 中安装 libguestfs‐tools‐c 可以获得 guestmount 工具
    # 脚本在不登陆虚拟机的情况下,修改虚拟机的 IP 地址信息
    # 在某些环境下,虚拟机没有 IP 或 IP 地址与真实主机不在一个网段
    # 真实主机在没有 virt‐manger 图形的情况下,远程连接虚拟机很麻烦
    # 该脚本可以解决类似的问题
    read -p "请输入虚拟机名称:" name
    if virsh domstate $name | grep -q running ;then
    	echo "修改虚拟机网卡数据,需要关闭虚拟机"
    	virsh destroy $name
    fi
    mountpoint="/media/virtimage"
    [ ! -d $mountpoint ] && mkdir $mountpoint
    echo "请稍后..."
    if mount | grep -q "$mountpoint" ;then
    	umount $mountpoint
    fi
    guestmount  -d $name -i $mountpoint
    read -p "请输入需要修改的网卡名称:" dev
    read -p "请输入 IP 地址:" addr
    # 判断原本网卡配置文件中是否有 IP 地址,有就修改该 IP,没有就添加一个新的 IP 地址
    if grep -q "IPADDR"  $mountpoint/etc/sysconfig/network‐scripts/ifcfg‐$dev ;then
    	sed -i "/IPADDR/s/=.*/=$addr/"  $mountpoint/etc/sysconfig/network‐scripts/ifcfg‐$dev
    else
    	echo "IPADDR=$addr" >> $mountpoint/etc/sysconfig/network‐scripts/ifcfg‐$dev
    fi
    # 如果网卡配置文件中有客户配置的 IP 地址,则脚本提示修改 IP 完成
    awk -F= -v x=$addr '$2==x{print "完成..."}'  $mountpoint/etc/sysconfig/network‐scripts/ifcfg-$dev

    86、破解虚拟机密码,无密码登陆虚拟机系统

    #!/bin/bash
    
    # 破解虚拟机密码,无密码登陆虚拟机系统 
    
    # 该脚本使用 guestmount 工具,Centos7.2 中安装 libguestfs‐tools‐c 可以获得 guestmount 工具
    
    read -p "请输入虚拟机名称:" name
    if virsh domstate $name | grep -q running ;then
    	echo "破解,需要关闭虚拟机"
    	virsh destroy $name
    fi
    mountpoint="/media/virtimage"
    [ ! -d $mountpoint ] && mkdir $mountpoint
    echo "请稍后..."
    if mount | grep -q "$mountpoint" ;then
    	umount $mountpoint
    fi
    guestmount -d $name -i $mountpoint
    # 将 passwd 中密码占位符号 x 删除,该账户即可实现无密码登陆系统
    sed -i "/^root/s/x//" $mountpoint/etc/passwd

    87、Shell 脚本对信号的处理,执行脚本后,按键盘 Ctrl+C 无法终止的脚本

    #!/bin/bash
    
    # Shell 脚本对信号的处理,执行脚本后,按键盘 Ctrl+C 无法终止的脚本 
    
    # 使用 trap 命令可以拦截用户通过键盘或 kill 命令发送过来的信号
    # 使用 kill ‐l 可以查看 Linux 系统中所有的信号列表,其中 2 代表 Ctrl+C
    # trap 当发现有用户 ctrl+C 希望终端脚本时,就执行 echo "暂停 10s";sleep 10 这两条命令
    # 另外用户使用命令:[ kill ‐2 脚本的 PID ] 也可以中断脚本和 Ctrl+C 一样的效果,都会被 trap 拦截
    trap 'echo "暂停 10s";sleep 10' 2
    while :
    do
    	echo "go go go"
    done

    88、一键部署 memcached

    #!/bin/bash
    
    # 一键部署 memcached 
    
    # 脚本用源码来安装 memcached 服务器
    # 注意:如果软件的下载链接过期了,请更新 memcached 的下载链接
    wget http://www.memcached.org/files/memcached-1.5.1.tar.gz
    yum -y install gcc
    tar -xf  memcached‐1.5.1.tar.gz
    cd memcached‐1.5.1
    ./configure
    make
    make install

    89、一键配置 VNC 远程桌面服务器(无密码版本)

    #!/bin/bash
    
    # 一键配置 VNC 远程桌面服务器(无密码版本)
    
    # 脚本配置的 VNC 服务器,客户端无需密码即可连接
    # 客户端仅有查看远程桌面的权限,没有鼠标和键盘的操作权限
    
    rpm --quiet -q tigervnc‐server
    if [  $? -ne  0 ];then
    	yum  -y  tigervnc‐server
    fi
    x0vncserver AcceptKeyEvents=0 AlwaysShared=1 \
    AcceptPointerEvents=0 SecurityTypes=None  rfbport=5908

    90、关闭 SELinux

    #!/bin/bash
    
    # 关闭 SELinux 
    
    sed -i  '/^SELINUX/s/=.*/=disabled/' /etc/selinux/config
    setenforce 0

    91、查看所有虚拟机磁盘使用量以及CPU使用量信息

    #!/bin/bash
    
    # 查看所有虚拟机磁盘使用量以及CPU使用量信息 
    
    virt‐df
    read -n1 "按任意键继续" key
    virt‐top

    92、使用 shell 脚本打印图形

    #!/bin/bash
    
    # 使用 shell 脚本打印如下图形: 
    
    # 打印第一组图片
    # for(())为类 C 语言的语法格式,也可以使用 for i  in;do  ;done 的格式替换
    # for((i=1;i<=9;i++))循环会执行 9 次,i 从 1 开始到 9,每循环一次 i 自加 1
    clear
    for (( i=1; i<=9; i++ ))
    do
      for (( j=1; j<=i; j++ ))
      do
        echo -n "$i"
      done
      echo ""
    done
    read  -n1  "按任意键继续"  key
    #打印第二组图片
    clear
    for (( i=1; i<=5; i++ )) 
    do
      for (( j=1; j<=i; j++ ))
      do
        echo -n " |"
      done
      echo "_ "
    done
    read  -n1  "按任意键继续"  key
    #打印第三组图片
    clear
    for (( i=1; i<=5; i++ ))
    do
      for (( j=1; j<=i; j++ ))
      do
        echo -n " *"
      done
      echo ""
    done
    for (( i=5; i>=1; i‐‐ ))
    do
      for (( j=1; j<=i; j++ ))
      do
        echo -n " *"
      done
      echo ""
    done

    93、根据计算机当前时间,返回问候语,可以将该脚本设置为开机启动

    #!/bin/bash
    
    # 根据计算机当前时间,返回问候语,可以将该脚本设置为开机启动 
    
    # 00‐12 点为早晨,12‐18 点为下午,18‐24 点为晚上
    # 使用 date 命令获取时间后,if 判断时间的区间,确定问候语内容
    tm=$(date +%H)
    if [ $tm -le 12 ];then
    	msg="Good Morning $USER"
    elif [ $tm -gt 12 -a $tm -le 18 ];then
      	msg="Good Afternoon $USER"
    else
      	msg="Good Night $USER"
    fi
    echo "当前时间是:$(date +"%Y‐%m‐%d %H:%M:%S")"
    echo -e "\033[34m$msg\033[0m"

    94、读取用户输入的账户名称,将账户名写入到数组保存

    #!/bin/bash
    
    # 读取用户输入的账户名称,将账户名写入到数组保存 
    
    # 定义数组名称为 name,数组的下标为 i,小标从 0 开始,每输入一个账户名,下标加 1,继续存下一个账户
    # 最后,输入 over,脚本输出总结性信息后脚本退出
    i=0
    while :
    do
    	read -p "请输入账户名,输入 over 结束:" key
    	if [ $key == "over" ];then 
    		break
      	else
    		name[$i]=$key
    		let i++
      	fi
    done
    echo "总账户名数量:${#name[*]}"
    echo "${name[@]}"

    95、判断文件或目录是否存在

    #!/bin/bash
    
    # 判断文件或目录是否存在 
    
    if [ $# -eq 0 ] ;then
    echo "未输入任何参数,请输入参数"
    echo "用法:$0 [文件名|目录名]"
    fi
    if [ -f $1 ];then
    	echo "该文件,存在"
    	ls -l $1
    else
    	echo "没有该文件"
    fi
    if [ -d  $1 ];then
       	echo "该目录,存在"
       	ls -ld  $2
    else
       	echo "没有该目录"
    fi

    96、打印各种格式的时间

    #!/bin/bash
    
    # 打印各种时间格式 
    
    echo "显示星期简称(如:Sun)"
    date +%a
    echo "显示星期全称(如:Sunday)"
    date +%A
    echo "显示月份简称(如:Jan)"
    date +%b
    echo "显示月份全称(如:January)"
    date +%B
    echo "显示数字月份(如:12)"
    date +%m
    echo "显示数字日期(如:01 号)"
    date +%d
    echo "显示数字年(如:01 号)"
    date +%Y echo "显示年‐月‐日"
    date +%F
    echo "显示小时(24 小时制)"
    date +%H
    echo "显示分钟(00..59)"
    date +%M
    echo "显示秒"
    date +%S
    echo "显示纳秒"
    date +%N
    echo "组合显示"
    date +"%Y%m%d %H:%M:%S"

    97、使用 egrep 过滤 MAC 地址

    #!/bin/bash
    
    # 使用 egrep 过滤 MAC 地址 
    
    # MAC 地址由 16 进制组成,如 AA:BB:CC:DD:EE:FF
    # [0‐9a‐fA‐F]{2}表示一段十六进制数值,{5}表示连续出现5组前置:的十六进制
    egrep "[0‐9a‐fA‐F]{2}(:[0‐9a‐fA‐F]{2}){5}" $1

    98、统计双色球各个数字的中奖概率

    #!/bin/bash
    
    # 统计双色球各个数字的中奖概率 
    
    # 往期双色球中奖号码如下:
    # 01 04 11 28 31 32  16
    # 04 07 08 18 23 24  02
    # 02 05 06 16 28 29  04
    # 04 19 22 27 30 33  01
    # 05 10 18 19 30 31  03
    # 02 06 11 12 19 29  06
    # 统计篮球和红球数据出现的概率次数(篮球不分顺序,统计所有篮球混合在一起的概率)
    awk '{print $1"\n"$2"\n"$3"\n"$4"\n"$5"\n"$6}' 1.txt | sort | uniq -c | sort
    awk '{print $7}' 1.txt | sort | uniq -c | sort

    99、生成签名私钥和证书

    #!/bin/bash
    
    # 生成签名私钥和证书 
    
    read -p "请输入存放证书的目录:" dir
    if [ ! -d $dir ];then
    	echo "该目录不存在"
    	exit
    fi
    read -p "请输入密钥名称:" name
    # 使用 openssl 生成私钥
    openssl genrsa -out ${dir}/${name}.key
    # 使用 openssl 生成证书 #subj 选项可以在生成证书时,非交互自动填写 Common Name 信息
    openssl req -new -x509 -key ${dir}/${name}.key -subj "/CN=common" -out ${dir}/${name}.crt

    100、使用awk编写的wc程序

    #!/bin/bash
    
    # 使用awk编写的wc程序 
    
    # 自定义变量 chars 变量存储字符个数,自定义变量 words 变量存储单词个数
    # awk 内置变量 NR 存储行数
    # length()为 awk 内置函数,用来统计每行的字符数量,因为每行都会有一个隐藏的$,所以每次统计后都+1
    # wc 程序会把文件结尾符$也统计在内,可以使用 cat ‐A 文件名,查看该隐藏字符
    awk '{chars+=length($0)+1;words+=NF} END{print NR,words,chars}' $1

    注:本篇文章是根据王森的博客整理而来,仅供学习参考!

    展开全文
  • 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编程语言(一)

    千次阅读 2018-08-25 15:00:58
    一. 什么是Shell ...Shell还是一个功能相当强大的编程语言,易编写,易调试,灵活性较强。Shell是解释执行的脚本语言,在Shell中可以直接调用Linux系统命令。  Shell具体可描述为:外层应用...
  • 一、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是用户与内核进行交互操作的一种接口...
  • 《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编程中如何计算使用除法

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

    万次阅读 2016-04-05 20:53:02
    Shell编程 数值求和
  • shell编程主要方便一些操作,有时候没有必要写python脚本,会shell就很方便。 具体请参考:https://www.zhihu.com/question/21747474
  • Shell编程基础

    万次阅读 2019-04-20 00:09:14
    Shell编程基础(一) 如果经常使用linux系统,不会点shell编程,很难让你工作高效起来。我觉得shell脚本是这个世界上最简单的脚本语言。 学习shell,你无需搭建相关开发环境,只要有一台linux服务器即可。下面通过...
  • 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.切换目录...
1 2 3 4 5 ... 20
收藏数 181,742
精华内容 72,696
关键字:

shell编程