shell脚本学习笔记

shell脚本学习笔记

1.Shell入门简介

Shell是操作系统的最外层， Shell可以合并编程语言以控制进程和文件，以及启动和控制其它程序。shell通过提示您输入，向操作系统解释该输入， 然后处理来自操作系统的任何结果输出来管理您与操作系统之间的交互。简单来说Shell就是一个用户跟操作系统之间的一个命令解释器。

Shell是用户与Linux操作系统之间沟通的桥梁。用户可以输入命令执行，又可以利用Shell脚本编程去运行。

kernel是内核，utilites是用户，用户通过shell脚本与内核进行交互。

Linux Shell种类非常多， 常见的有：

Bourne Shell （/usr/bin/sh 或/bin/sh）
Bourne Again Shell	（/bin/bash	）
C Shell（/usr/bin/csh	）
K Shell（/usr/bin/ksh	）
Shell for Root（/sbin/sh	）

不同的 Shell语言的语法有所不同，所以不能交换使用。

最常用的shell是 Bash，也就是Bourne Again Shell ，由于易用和免费， Bash在日常工作中被广泛使用，也是大多数Linux系统默认的 Shell 。接下来我们来写一个简单的shell脚本。(shell脚本一般文件名以 .sh 结尾，同时文件第一行定义该脚本为shell脚本)

vim	first_shell.sh  #创建first_shell.sh文件

#!/bin/bash                               //表示定义该脚本是一个shell脚本（固定格式）,会以shell格式运行该脚本
#This is my First shell           //	这里的#号属于注解，没有任何的意义，SHELL不会解析它。
#文件名filename：first_shell.sh
#用途 auto echo hello world
#作者 by authors                       //此为shell脚本标准注释

echo “Hello	World !	”       //shell脚本主命令，我们执行这个脚本讲看到 : Hello World !信息。

脚本编写完毕，如何来执行呢，首先执行 shell 脚本需要执行权限，赋予执行权限：

chmod o+x first_shell.sh	然后./first_shell.sh		执行即可 ; (在我的ubuntu18.04版本中没有成功)
也可以直接使用命令执行	: /bin/sh first_shell.sh	，显示效果一样。

2.Shell编程之变量详解

Shell编程语言是非类型的解释型语言 , 不像 C++/JAVA语言编程时需要事先声明变量，SHELL给一个变量赋值 , 实际上就是定义了变量, 在 Linux 支持的所有shell中, 都可以用赋值符号(=) 为变量赋值。

SHELL变量可分为两类：局部变量和环境变量。局部变量只在创建它们的shell脚本中使用。而环境变量则可以在创建它们的shell及其派生出来的任意子进程中使用。有些变量是用户创建的，其他的则是专用shell变量。

shell变量命名规则：

首个字符必须为字母（a-z，A-Z）。
中间不能有空格，可以使用下划线（_）。
不能使用标点符号。
不能使用bash里的关键字（可用help命令查看保留关键字）

例如在脚本里面定义A=123 , 定义这样一个变量，前面变量名， 后面是变量的值。引用变量可以使用$A，把变量放在脚本里面会出现什么样的效果呢？ 如下：

#!/bin/bash

#Author wugk 2014-06-10
A=123
echo	“Printf variables equal is $A	”    #$A相当于自己定义的局部变量

执行脚本： sh test.sh ，结果将会显示：

Printf variables equal is 123

简单的理解变量， 相当于定义一个别名 - 名称，引用的时候加上 $符号就可以了。

例如定义变量 name=hahaha

执行 echo $name 将会显示 hahaha

SHELL常见的系统变量(环境变量)解析 :

#在终端运行时前面加echo
$0	打印当前程序的名称
$n	打印当前程序的第n 个参数,n=1,2,	,	9
$*	打印当前程序的所有参数	( 不包括程序本身	)
$#	打印当前程序的参数个数	( 不包括程序本身	)
$?	命令或程序执行完后的状态，一般返回0 表示执行成功。上一个命令是否执行成功
$UID 打印当前用户的	ID
$PWD打印当前所在的目录

我们来测试一个常用变量的脚本：

vim auto_var.sh 

#!/bin/bash
#auto print variables 
#by wugk 2014-09
echo -e '\033[32m	\033[0m'
echo "This is $0 param !" 
echo "This \$1 is $1 param !" 
echo "This \$2 is $2 param !"
echo -e '\033[32m	\033[0m'
echo "This \$* is $* param !" 
echo "This \$# is $# param !" 
echo "This \$? is $? param !" 

shell脚本有颜色打印

格式是：

echo -e "\033[字背景颜色;字体颜色m 字符串 \033[0m"  或者
printf "\033[字背景颜色;字体颜色m 字符串 \033[0m"  或者
echo -e "\033[字背景颜色;字体颜色m;ascii码m 字符串 \033[0m 字符串(can null) \n" 

举例说明;

echo -e "\033[47;30;5m david use echo say \033[0m Hello World \n" 

-e是echo的一个可选项，用于激活特殊字符的解析器, 也就是对反斜线转义符（即\）的解释。\033引导非常规字符序列。意味着设置属性然后结束非常规字符序列，这里起效果的字符是47;30;5和0。修改47;30;5可以生成不同颜色的组合，数值和编码的前后顺序没有关系。

组合命令：

echo -e "\033[20;1H\033[1;4;32m david use echo say \033[0m Hello World \n"

这行命令首先\033[20;1H将光标移动到终端第20行第1列，之后的\033[1;4;32m将文本属性设置为高亮、带下划线且颜色为绿色，然后输出Hello,world；最后\033[0m将终端属性设为缺省，这样就不会看到连命令完成后的命令提示符也变了样儿了。

文本属性：

0 重新设置属性到缺省设置
1 设置粗体
2 设置一半亮度(模拟彩色显示器的颜色)
4 设置下划线(模拟彩色显示器的颜色)
5 设置闪烁
7 设置反向图象
8 消隐 
22 设置一般密度
24 关闭下划线
25 关闭闪烁
27 关闭反向图象

// 字体颜范围(前景颜色):30~39
30:黑 
31:红 
32:绿 
33:黄 
34:蓝色 
35:紫色 
36:深绿 
37:白色 

38:在缺省的前景颜色上设置下划线
39:在缺省的前景颜色上关闭下划线

// 字背景颜色范围(背景颜色):40~49 
40:黑 
41:深红 
42:绿 
43:黄色 
44:蓝色 
45:紫色 
46:深绿 
47:白色 

nA 光标上移n行 
nB 光标下移n行 
nC 光标右移n行 
nD 光标左移n行 
y;xH设置光标位置 
2J 清屏 
K 清除从光标到行尾的内容 
s 保存光标位置 
u 恢复光标位置 
?25l 隐藏光标 
?25h 显示光标

实例：

echo -e "\033[0m none \033[0m"
echo -e "\033[30m black \033[0m"
echo -e "\033[1;30m dark_gray \033[0m"
echo -e "\033[0;34m blue \033[0m"
echo -e "\033[1;34m light_blue \033[0m"
echo -e "\033[0;32m green \033[0m"
echo -e "\033[1;32m light_green \033[0m"
echo -e "\033[0;36m cyan \033[0m"
echo -e "\033[1;36m light_cyan \033[0m"

echo -e "\033[0;31m red \033[0m"
echo -e "\033[1;31m light_red \033[0m"
echo -e "\033[0;35m purple \033[0m"
echo -e "\033[1;35m light_purple \033[0m"
echo -e "\033[0;33m brown \033[0m"
echo -e "\033[1;33m yellow \033[0m"
echo -e "\033[0;37m light_gray \033[0m"
echo -e "\033[1;37m white \033[0m"
echo -e "\033[0m none \033[0m"
echo -e "\033[0m none \033[0m"
echo -e "\033[0m none \033[0m"
echo -e "\033[0m none \033[0m"
echo -e "\033[0m none \033[0m"

echo -e "\033[40;37m 黑底白字 \033[0m"
echo -e "\033[41;30m 红底黑字 \033[0m"
echo -e "\033[42;34m 绿底蓝字 \033[0m"
echo -e "\033[43;34m 黄底蓝字 \033[0m"
echo -e "\033[44;30m 蓝底黑字 \033[0m"
echo -e "\033[45;30m 紫底黑字 \033[0m"
echo -e "\033[46;30m 天蓝底黑字 \033[0m"
echo -e "\033[47;34m 白底蓝字 \033[0m"
echo -e "\033[4;31m 下划线红字 \033[0m"
echo -e "\033[5;31m 红字在闪烁 \033[0m"
echo -e "\033[8m 消隐 \033[0m "

紧接着我们来编写一个简单的 echo 打印菜单：

#!/bin/bash
#auto install httpd #by wugk 2014-09
echo -e '\033[32m	\033[0m'
FILES=httpd-2.2.17.tar.bz2 [URL=http://mirrors.cnnic.cn/apache/httpd/](http://mirrors.cnnic.cn/apache/httpd/) PREFIX=/usr/local/apache2/
echo -e "\033[36mPlease Select Install Menu:\033[0m"   #若将0m改为1m则以下文本均为此颜色
echo "1)	官方下载	Httpd	文件包."
echo "2)	解 压 apache 源 码 包 ." 
echo "3)	编译安装	Httpd	服务器."
echo "4)	启动 HTTPD服务器 ."
echo -e '\033[32m---------------------------------	\033[0m'
sleep 20

shell 脚本关键字&符号

shell概念

• "shell"既是一种解释型编程语言，也是一个这种编程语言的解释器的名字
• shell是解释型语言，就是解释器会一条一条的翻译每一条语句并执行，对比之下，C语言是编译型语言，编译器把整个工程编译成可执行文件才能执行
• 在没有续行符（\回车）的情况下，shell脚本的一条语句以"回车"为结束
• 任何一个shell脚本程序都必须在开头用#!标识使用的shell程序，如果用的是bash，那就是#!/bin/sh
• shell脚本一行中的#之后的部分为注释
• 刚刚写完的一个shell script程序通常是没有执行权限的，需要手动**$chmod +x filename.sh**来添加可执行权限
• shell语言本身并不包含linux内置的命令，那些命令本质上都是一个可以在shell环境中执行的程序，只是在shell环境中执行shell脚本可以调用这些程序而已。

特殊符号

$

表示取结果。和变量名一起使用表示取变量的值，和()一起使用表示取命令群组的执行结果

$tunset=123
$echo "$tunset"
123
$echo $(ls Downloads)
lukas-h.github.io-theme.zip youdao-dict_1.1.0-0-deepin_amd64.deb

( )

• 表示在"nested sub-shell"中划分一个命令群组(command group)，如果我们希望里面的命令对之前和之后的设定不影响的话，就要用()，反之，如果需要在当前shell(non-named command group)中执行相关命令，就要用{}表示命令群组。
• 在数学计算中就是数学中的()
• 定义数组

$cat shell.sh;./shell.sh 
#!/bin/bash

line="123 25 36532 454"
(
    line="wwww"
    echo "$line"
)
echo "$line"

wwww
123 25 36532 454
$arr=(0 1 2 var)    #定义一个数组
$echo "${arr[0]}"   #显示数组下标为0的元素
0

{ }

• 用作范围限定
• 标明在"non-named command shell"中执行的命令群组。shell函数就是使用{}的特性来定义的
• 配合：，-，+，=，#，/，%，？对变量进行操作

$echo $var
123
$echo $variable

$echo ${var}iable
123iable
$cat shell.sh;./shell.sh 
#!/bin/bash

line="123 25 36532 454"
{
    line="wwww"
    echo "$line"
}
echo "$line"


wwww
wwww
$file=/opt/ros/jade/include/image_view/ImageViewConfig.h 
#匹配+删除
$echo ${file#*/}                #从左侧开始匹配符合模式最短部分，将其剔除，返回剩下的
opt/ros/jade/include/image_view/ImageViewConfig.h
$echo ${file#*/*/}
ros/jade/include/image_view/ImageViewConfig.h
$echo ${file##*/}            #从左侧开始匹配符合模式的最长部分，将其剔除，返回剩下的
ImageViewConfig.h
$echo ${file%/*}            #从右侧开始匹配符合模式的最短部分，将其剔除，返回剩下的             
/opt/ros/jade/include/image_view
$echo ${file%%/i*}        #从右侧开始匹配符合模式的最长部分，将其剔除，返回剩下的
/opt/ros/jade
#按个数返回
$echo ${file:0:4}           
/opt
$echo ${file:4:9}            #将第4个字符当作第1个，计数9个， 返回   
/ros/jade
#匹配+替换
$echo ${file/opt/root}    #将file中的第一个opt替换为root
/root/ros/jade/include/image_view/ImageViewConfig.h
$echo ${file//i/++}          #将file中的所有i都替换为++
/opt/ros/jade/++nclude/++mage_v++ew/ImageV++ewConf++g.h
#根据变量状态操作，
$echo ${file-fault}            #只要设定了，就返回file，否则返回fault                
/opt/ros/jade/include/image_view/ImageViewConfig.h
$echo ${file1-fault}
fault
$echo ${file:-fault}            #只要设定了且非空，就返回file，否则返回fault
/opt/ros/jade/include/image_view/ImageViewConfig.h

$echo ${file+fault}            #只要设定了，就返回fault
fault
$echo ${file:+fault}           #只要设定了且非空，就返回fault
fault

$echo ${file=fault}            #只要file没设定，就将fault赋值给file并返回
/opt/ros/jade/include/image_view/ImageViewConfig.h
$echo ${file1}

$echo ${file1=fault}
fault
$echo ${file1}
fault

$echo ${file:=fault}           #只要file没设定或非空，就将fault赋值给file并返回
/opt/ros/jade/include/image_view/ImageViewConfig.h

$echo ${file?fault}             #只要file没设定，就将fault输出至STDERR
/opt/ros/jade/include/image_view/ImageViewConfig.h
$echo ${file:?fault}            #只要file没设定或为空，就将fault输出至STDERR
#统计字符数

$echo ${file}
/opt/ros/jade/include/image_view/ImageViewConfig.h
$echo ${#file}
50

(( ))

用作计算，shell支持十进制/十六进制/二进制的+ - * / % & += -= *= /= %= ++ – 等算术运算，以及| ^ ! > >= < <= !=等逻辑运算。同样的效果也可以使用expr ...来实现，但是expr是Linux的内置软件，并不是shell语言的关键字

$echo $((1 + 2))
3
$echo $((0xf + 1))
16
$cal=132
$echo $(($cal+1))
133

[ ]

• 用作取数组元素，使用${arr[n]}访问数组编号为n的元素

$arr=(0 1 2 var)
$echo "${arr[0]}"
0
$echo "${arr[3]}"
var

``

两个反单引号表示命令替换，和$()是等价的。个人觉得看着比$()清晰，但是如果多层嵌套的话可能需要转义，此时就没有$()看着易懂。在下面的嵌套结构中，我们本意是先执行cmd3，将执行结果传给cmd2，再将结果传给cmd1

cmd1 `cmd2 `cmd3``

但是其实被解析成了下面这个

cmd1 `cmd2`cmd3                   ``

为了解决这个问题，我们需要使用转义字符，写成下面这个样子才能正确的传达我们的意思

cmd `cmd2 \`cmd3\``

但如果我们使用$()，就可以让代码更清晰

$echo `echo`echo 12``   #被分解成了 echo `echo` echo 12``  
echo 12
$echo `echo \`echo 12\``    #这个才对
12
$echo $(echo $(echo 12))    #这个才对
12

|

管道表示将前一个命令的返回结果用作后一个命令的参数，管道的前后必须都是命令，管道是管理Linux十分有用的工具
$grep “test” file1.txt | wc -l

>>>

> 以新建的方式重定向，如果文件不存在就创建文件并将内容写入，如果文件存在就把文件清空再写入内容
>>以追加的方式重定向，如果文件不存在就创建文件并将内容写入，如果文件存在就在原文件后面写入内容

<

我们通常的操作就是文件，其实已经使用的输入重定向

2>

• 标准输入，标准输出，标准错误其实是三个完全不同的文件，虽然我们看起来标准输出和标准错误都输入到显示屏中显示，但是不能用输出重定向将错误重定向到其他文件
• 标准输入，标准输出，标准错误的文件描述符分别是0，1，2，这也是错误重定向2>的由来

&&

&&前的命令执行成功了就继续执行后面的命令

||

||前的命令执行失败了就去执行后面的命令

;

不论;前的命令执行成功与否都去执行后面的命令

关键字

readonly

相当于C中的const，readonly将变量设为只读模式，任何针对他们的赋值都是错误的

$readonly var=123
$var=345
bash: var: readonly variable

unset

删除变量

unset var_name 删除变量var_name
unset -v first middle last 删除其他变量
unset -f fcn 删除函数
$tunset=123
$echo $tunset
123
$unset tunset
$echo $tunset

$

shift

用来截去来自列表的位置参数，从左侧开始，一旦执行shift，$1的初始值就会永远消失，取而代之的是$2的旧值，依次类推，$#的值也会依次减1
shift也可以带一个参数，表示一次截取的个数

$cat shell.sh 
#!/bin/bash
echo "${1}"

shift

echo "${1}"
$./*.sh 123 456
123
456

set

设置新的位置参数

$set qq ww ee
$echo "${1}"
qq
$echo "${0}"
bash
$echo "${2}"
ww
$echo "$#"
3

export

添加变量到变量导出列表，即如果在shell中执行子shell，该变量将作为环境变量从而在子shell中变得可以使用。

$cat shell.sh 
#!/bin/bash
echo "$NEWENV"

$NEWENV=123
$./shell.sh 

$export NEWENV
$./shell.sh 
123

exit

提前结束标本

test

test 和[ ]既是一个linux缺省安装的软件命令，又是一个shell关键字。两者的功能都是一模一样的

3.if条件语句学习

在Linux编程中，if、for、while、case等条件流程控制语句用的非常多，把这些学好，对提升脚本功力有非常大的帮助。

下面将逐个讲解具体的用法：

If 条件判断语句

if	(	表达式)	#if ( Variable in Array )
	语 句 1    #if条件句语句空两格
else
	语 句 2
fi

案例一，测试数字大小

#!/bin/bash 
NUM=100
if (( $NUM > 4 )) ;then                               #两个括号在if中用来判断大小或计算
	echo	“ this num is $NUM greater	4 !	”
fi

案例二，测试目录是否存在，不存在则新建（注意，中括号之间必须要空格）

#!/bin/sh 
#judge dir exist

if	[ ! -d	/data/20140515 ];then     #[]中使用逻辑运算符，不能使用数学符号，表示条件测试   !与-d之间也有空格
	mkdir	-p /data/20140515 
else
	echo	“ This DIR is exist,Please exit	,	..	”
fi

注意：
1、[]表示条件测试，在[后面和]前面都必须要有空格
2、在shell中，then和fi是分开的语句。如果要在同一行里面输入，则需要用分号将他们隔开
3、注意if判断中对于变量的处理，需要加引号
4、判断是不支持浮点值的
5、如果只单独使用>或者<号，系统会认为是输出或者输入重定向，虽然结果显示正确，但是其实是错误的，因此要对这些符号进行转意
6、运行if语句中的命令所产生的错误信息会被默认出现在脚本的输出结果中
7、使用-z或者-n来检查长度的时候，没有定义的变量也为0
8、空变量和没有初始化的变量可能会对shell脚本测试产生灾难性的影响，因此如果不确定变量的内容，则应在正式使用脚本前用-n或者-z测试一下
9、? 变量包含了之前执行命令的退出状态（最近完成的前台进程），可以用于检测退出状态

逻辑运算符解析：

-f	判断文件是否存在	eg: if [ -f filename ]
-d	判断目录是否存在	eg: if [ -d dir	]
-eq	等于	应用于：整型比较
-ne	不等于	应用于：整型比较
-lt	小于	应用于：整型比较
-gt	大于	应用于：整型比较
-le	小于或等于	应用于：整型比较
-ge	大于或等于	应用于：整型比较
-a	双方都成立（ and）	逻辑表达式	– a	逻辑表达式
-o	单方成立（ or ）	逻辑表达式	–o	逻辑表达式
-z	空字符串

常用文件目录判断：

[ -a FILE ] 如果 FILE 存在则为真
[ -d FILE ] 如果 FILE 存在且是一个目录则返回为真
[ -e FILE ] 如果指定的文件或目录存在时返回为真
[ -f FILE ] 如果 FILE 存在且是一个普通文件则返回为真
[ -r FILE ] 如果 FILE 存在且是可读的则返回为真
[ -w FILE ] 如果 FILE 存在且是可写的则返回为真
[ -x FILE ] 如果 FILE 存在且是可执行的则返回为真

不常用文件目录判断：

[ -b FILE ] 如果 FILE 存在且是一个块文件则返回为真
[ -c FILE ] 如果 FILE 存在且是一个字符文件则返回为真
[ -g FILE ] 如果 FILE 存在且设置了SGID则返回为真
[ -h FILE ] 如果 FILE 存在且是一个软链接文件则返回为真
[ -k FILE ] 如果 FILE 存在且已经设置了冒险位则返回为真
[ -p FILE ] 如果 FILE 存并且是命令管道时返回为真
[ -s FILE ] 如果 FILE 存在且大小非0时为真则返回为真
[ -u FILE ] 如果 FILE 存在且设置了SUID位时返回为真
[ -O FILE ] 如果 FILE 存在且属有效用户ID则返回为真
[ -G FILE ] 如果 FILE 存在且默认组为当前组则返回为真
[ -L FILE ] 如果 FILE 存在且是一个符号链接则返回为真
[ -S FILE ] 如果 FILE 存在且是一个套接字则返回为真
[ FILE1 -nt FILE2 ] 如果 FILE1 比 FILE2 新, 或者 FILE1 存在但是 FILE2 不存在则返回为真
[ FILE1 -ot FILE2 ] 如果 FILE1 比 FILE2 老, 或者 FILE2 存在但是 FILE1 不存在则返回为真
[ FILE1 -ef FILE2 ] 如果 FILE1 和 FILE2 指向相同的设备和节点号则返回为真

字符串判断：

[ -z STRING ] 如果STRING的长度为零则返回为真，即空是真
[ -n STRING ] 如果STRING的长度非零则返回为真，即非空是真
[ STRING1 ]　 如果字符串不为空则返回为真,与-n类似
[ STRING1 == STRING2 ] 如果两个字符串相同则返回为真
[ STRING1 =~ pattern ] 字符串正则匹配
[ STRING1 != STRING2 ] 如果字符串不相同则返回为真
[ STRING1 < STRING2 ] 如果 “STRING1”字典排序在“STRING2”前面则返回为真。
[ STRING1 > STRING2 ] 如果 “STRING1”字典排序在“STRING2”后面则返回为真。

数值判断：

[ INT1 -eq INT2 ] INT1和INT2 两数相等 返回为真，=
[ INT1 -ne INT2 ] INT1和INT2 两数不等 返回为真 ，<>
[ INT1 -gt INT2 ] INT1 大于 INT2返回为真 ，>
[ INT1 -ge INT2 ] INT1 大于等于 INT2返回为真，>=
[ INT1 -lt INT2 ] INT1 小于 INT2返回为真 ，<
[ INT1 -le INT2 ] INT1 小于等于 INT2返回为真，<=

逻辑判断：

[ ! EXPR ] 逻辑非，如果 EXPR 是false则返回为真
[ EXPR1 -a EXPR2 ] 逻辑与，如果 EXPR1 与 EXPR2 全真则返回为真
[ EXPR1 -o EXPR2 ] 逻辑或，如果 EXPR1 或者 EXPR2 为真则返回为真
[ ] || [ ] 用OR来合并两个条件
[ ] && [ ] 用AND来合并两个条件

其他判断：

[ -t FD ] 如果文件描述符 FD（默认值为1）打开且指向一个终端则返回为真
[ -o optionname ] 如果shell选项optionname开启则返回为真

if高级特性：

• 双圆括号(( ))：表示数学表达式
  双圆括号提供更多的数学符号，而且在双圆括号里面的>与<号不需要转意。
• 双方括号[[ ]]：表示高级字符串处理函数
  双方括号中判断命令使用标准的字符串比较，还可以使用匹配模式，从而定义与字符串相匹配的正则表达式。

双括号的作用：
在shell中，不能写[ $a != 1 || $b = 2 ]，要写[ $a != 1 ] || [ $b = 2 ]，或者写[[ $a != 1 || $b = 2 ]]。又比如这个[ "$a" -lt "$b" ]，也可以改成双括号的形式(("$a" < "$b"))

案例三，多个条件测试判断

#!/bin/bash 

scores=80
if	[[ $scores -gt 85 ]]; then     
	echo "very good!"; 
elif [[ $scores -gt 75 ]]; then
	echo "good!";
elif [[ $scores -gt 60 ]]; then 
	echo "pass!";
else
	echo "no pass!"
fi

案例四，判断文件是否存在

#！/bin/bash
# auto test file
# by authors yuelai

files=/tmp/test.txt
if [ ! -f $files ];then
	echo "OK" >> $files    # >> 在文件中追加内存内容
else
	echo -e "\033[32m-------------------\033[1m"
	cat $files
fi

4.使用 if条件语句编写MySQL备份脚本

自动备份Mysql 数据库脚本

#!/bin/sh

#auto backup mysql #wugk	2012-12-12
#Define PATH 定义变量
BAKDIR=/data/backup/mysql/`date +%Y-%m-%d`   #``可以将内部内容当做命令来执行，这里是动态生成时间的作用
MYSQLDB=webapp
MYSQLPW=backup 
MYSQLUSR=backup
MYSQLCMD=/usr/bin/mysqldump

#must use root	user run scripts	必须使用	root	用户运行， $UID为系统变量
if [ $UID -ne 0 ];then
	echo This script must use the root user ! ! ! sleep 2
	exit 0
fi

#Define DIR and mkdir DIR	判断目录是否存在，不存在则新建
if [ ! -d $BAKDIR ];then 
	mkdir -p $BAKDIR
	echo -e"\033[32m The $BAKDIR create successful!\033[0m"
else
	echo This is $BAKDIR exists....
fi

#Use mysqldump backup mysql	使用 mysqldump备份数据库
$MYSQLCMD -u$MYSQLUSR -p$MYSQLPW -d$MYSQLDB >$BAKDIR/webapp_db.sql 
if [ $? -eq 0 ];then
	echo -e "\033[32mThe mysql backup $MYSQLDB successfully!\033[0m"
else
	echo -e "\033[32mThe mysql backup $MYSQLDB failed!pleasse check\033[0m"
fi

5.shell编程之LAMP一键安装脚本

通过 if 语句和之前变量的学习，今天我们将把我们所学的综合在一起来讲解一个实战运维脚本，一键安装 LAMP环境的脚本：

一键源码安装 LAMP脚本, 先分解脚本的各个功能：

打印菜单：

1）安装 apache WEB服务器

2）安装 Mysql DB 服务器

3） 安装 PHP服务器

4） 整合 LAMP架构并启动服务

1、Apache服务器安装部署。

下载 httpd-2.2.27.tar.gz 版本，下载URL，解压，进入安装目录， configure;make ;make install

2、Mysql 服务器的安装。

下载 mysql-5.5.20.tar.bz2 版本，下载URL，解压，进入安装目录， configure;make ;make install

3、PHP服务器安装。

下载 php-5.3.8.tar.bz2 版本，下载URL，解压，进入安装目录， configure;make ;make install

4、LAMP架构的整合和服务启动。

/usr/local/apache2/bin/apachectl start vi htdocs/index.php

vi auto_lamp.sh 内容如下：

#!/bin/bash
#auto install LAMP #by wugk 2014-11

#Httpd define path variable 
H_FILES=httpd-2.2.27.tar.bz2 
H_FILES_DIR=httpd-2.2.27
H_URL=http://mirrors.cnnic.cn/apache/httpd/](http://mirrors.cnnic.cn/apache/httpd/) H_PREFIX=/usr/local/apache2/

 #MySQL define path variable 
M_FILES=mysql-5.5.20.tar.gz 
M_FILES_DIR=mysql-5.5.20
[M_URL=http://down1.chinaunix.net/distfiles/](http://down1.chinaunix.net/distfiles/) 
M_PREFIX=/usr/local/mysql/

 #PHP define path variable 
P_FILES=php-5.3.28.tar.bz2 
P_FILES_DIR=php-5.3.28
P_URL=http://mirrors.sohu.com/php/](http://mirrors.sohu.com/php/) 
P_PREFIX=/usr/local/php5/

echo -e '\033[32m---------------------------------	\033[0m'

 
if [ -z "$1" ];then
	echo -e	"\033[36mPlease	Select	Install	Menufollow:\033[0m" 
	echo -e "\033[32m1)	编译安装	Apache服务器\033[1m"
	echo "2)	编译安装	MySQL服务器 " 
	echo "3)	编译安装	PHP服务器 "
	echo "4)	配置 index.php	并启动 LAMP服务"
	echo -e	"\033[31mUsage:	{	/bin/sh	$0 1|2|3|4|help}\033[0m" 
	exit
fi

if [[ "$1" -eq "help" ]];then
	echo -e "\033[36mPlease Select Install Menu follow:\033[0m"
	echo -e "\033[32m1)	编译安装	Apache 服务器\033[1m"
	echo "2)	编译安装	MySQL服务器 " 
	echo "3)	编译安装	PHP服务器 "
	echo "4)	配置 index.php	并启动 LAMP服务" 
	echo -e "\033[31mUsage: { /bin/sh $0 1|2|3|4|help}\033[0m" 
	exit
fi

 
#Install httpd web server 
if [[ "$1" -eq "1" ]];then
	wget -c $H_URL/$H_FILES &&	tar -jxvf $H_FILES && cd $H_FILES_DIR &&./configure --prefix=$H_PREFIX 
	if [ $? -eq 0 ];then
		make && make install
		echo -e "\033[32mThe $H_FILES_DIR Server Install Successfully !\033[0m"
	else
		echo -e "\033[32mThe $H_FILES_DIR Make or Make install ERROR,Please Check.\033[0m"
		exit 
	fi
fi

 
#Install Mysql DB server 
if [[ "$1" -eq "2" ]];then
	 wget -c $M_URL/$M_FILES &&	tar -xzvf $M_FILES && cd $M_FILES_DIR &&yum install cmake -y ;cmake .
	-DCMAKE_INSTALL_PREFIX=$M_PREFIX \
	-DMYSQL_UNIX_ADDR=/tmp/mysql.sock \
	-DMYSQL_DATADIR=/data/mysql \
	-DSYSCONFDIR=/etc \
	-DMYSQL_USER=mysql \
	-DMYSQL_TCP_PORT=3306 \
	-DWITH_XTRADB_STORAGE_ENGINE=1 \
	-DWITH_INNOBASE_STORAGE_ENGINE=1 \
	-DWITH_PARTITION_STORAGE_ENGINE=1 \
	-DWITH_BLACKHOLE_STORAGE_ENGINE=1 \
	-DWITH_MYISAM_STORAGE_ENGINE=1 \
	-DWITH_READLINE=1 \
	-DENABLED_LOCAL_INFILE=1 \
	-DWITH_EXTRA_CHARSETS=1 \
	-DDEFAULT_CHARSET=utf8 \
	-DDEFAULT_COLLATION=utf8_general_ci \
	-DEXTRA_CHARSETS=all \
	-DWITH_BIG_TABLES=1 \
	-DWITH_DEBUG=0
	make && make install

	/bin/cp support-files/my-small.cnf /etc/my.conf
	/bin/cp support-files/mysql.server /etc/init.d/mysqld 
	chmod +x /etc/init.d/mysqld
	chkconfig --add mysqld
	chkconfig mysqld on

	if [ $? -eq 0 ];then
		make && make install 
		echo -e 033[32m-----------------------------------------------------\033[0m"
		echo -e "\033[32mThe $M_FILES_DIR Server Install Success !\033[0m"
	else
		echo	-e "\033[32mThe	$M_FILES_DIRMakeor Make install ERROR,Please Check.	"
		exit 0
	fi
fi

 
#Install PHP server
if [[ "$1" -eq "3" ]];then
	wget -c $P_URL/$P_FILES &&	tar -jxvf $P_FILES && cd$P_FILES_DIR &&./configure --prefix=$P_PREFIX --with-config-file-path=$P_PREFIX/etc --with-mysql=$M_PREFIX --with-apxs2=$H_PREFIX/bin/apxs
	if [ $? -eq 0 ];then
		make ZEND_EXTRA_LIBS='-liconv' && make install
		echo -e "\033[32mThe $P_FILES_DIR Server Install Success !\033[0m"
	else
		echo	-e "\033[32mThe	$P_FILES_DIRMakeor Make install ERROR,Please Check.	"
		exit 0
	fi
fi
####################################

 if [[ "$1" -eq "4" ]];then
	sed -i '/DirectoryIndex/s/index.html/index.php index.html/g' $H_PREFIX/conf/httpd.conf $H_PREFIX/bin/apachectl restart
	echo "AddType  application/x-httpd-php .php" >>$H_PREFIX/conf/httpd.conf
	IP=`ifconfig eth1|grep "Bcast"|awk '{print $2}'|cut -d:-f2`
	echo "You can access http://$IP/"
cat >$H_PREFIX/htdocs/index.php <<EOF

EOF
fi

6.循环语句for

For	变量 in	字符串
	do
	语 句 1 
	done

案例一，打印 seq 数字循环

#!/bin/bash
for	i	in	`seq 15`
do
	echo	“NUM is $i	”
done 

案例二，求和 1-100 的 值

#!/bin/bash
#auto sum 1 100
j=0
for ((i=1;i<=100;i++))
do
	j=`expr $i + $j`             #expr在shell中表示两个数字求和
done 
echo $j

案例三，找到相关 log ，然后批量打包

#!/bin/bash
for	i	in	`find /var/log	-name	“ *.log	”` 
do
	tar	– czf	2014log.tgz $i 
done

案例四，远程主机批量传输文件：

#!/bin/bash
#auto scp files for client 
#by authors wugk 2014 

for i in `seq 100 200` 
do
	scp -r /tmp/test.txt  [email protected].$i:/data/webapps/www
done

案例五，远程主机批量执行命令：

#!/bin/bash
#auto scp files for client 
#by authors wugk 2014 
for i in `seq 100 200` 
do
	ssh -l	root 192.168.1.$i	‘ls /tmp	’
done

7. 循环语句while

 while	条件语句
do
	语 句 1
done

案例一， while 条件判断数字

 #!/bin/sh i=1;
while [[ $i -lt 10 ]];
do
	echo $i; 
	((i++));
done;

案例二，扩展讲解 linux read 命令

read -p	‘ Please Input number:	’ 

案例三， while逐行读取某个文件

#!/bin/bash
while read line
do
	echo	$line;
done	< /etc/hosts

综合脚本编写：

vim list.txt
192.168.1.1
192.168.1.2  
192.168.1.3 
192.168.1.4  
192.168.1.5 
192.168.1.6  
192.168.1.7
192.168.1.8

#!/bin/bash  #while循环实现
while read line
do
	echo -e "\033[32mscp-r /tmp/test.txt root@$line:/tmp \033[0m"
done <list.txt

#!/bin/bash        #for循环实现
for i in `cat list.txt`
do
	echo -e "\033[32mscp-r /tmp/test.txt root@$line:/tmp \033[0m"
done

8.Until 循环语句

until	条件
do
	action 
done
#直到满足条件，才退出。否则执行	action	。

案例一，条件判断数字

 #!/bin/sh 
 a=10;
until [[ $a -lt 0 ]];
do 
	echo $a;
	((a--));
done;

9.Case选择语句

case $arg in
	pattern1)
	语 句 1
	;;
	pattern2)
	语 句 2
	;;
	*)
	语 句 3
	;;
esac

案例一，创建选择参数脚本

#!/bin/bash 

case $1 in
	monitor_log) 
	monitor_log
	;;
	archive_log) 
	archive_log
	;;
	*	)
	echo "Usage:{$0 monitor_log | archive_log |help }"
	;;
esac

案例二，case创建选择菜单

#!/bin/bash
# auto install LAMP

case $1 in
	Apache )
	echo "wait install httpd server..."
	;;
	Mysql )
	echo "wait install mysql server..."
	;;
	Php )
	echo "wait install php server..."
	;;
	* )
	echo -e "\033[32musage:{$0 Apache|Mysql|Php|help } \033[0m"
	;;
esac

10.select 选择语句

Select 一般用于选择菜单的创建，可以配合PS3来做菜单的打印输出信息。

#!/bin/sh
PS3="What you like most of the open source system?" 
select i in "CentOS" "RedHat" "Ubuntu"
do
	echo "Your Select System: "$i 
done

案例一，select创建LAMP选择菜单

#!/bin/bash
PS3="select your will exer 	Menu" 
select i in "Apache" "Mysql" "Php"
do
	case $1 in
		Apache )
		echo "wait install httpd server..."
		;;
		Mysql )
		echo "wait install mysql server..."
		;;
		Php )
		echo "wait install php server..."
		;;
		* )
		echo -e "\033[32musage:{$0 Apache|Mysql|Php|help } \033[0m"
		;;
	esac
done

11.Shell 编程函数讲解

shell 允许将一组命令集或语句形成一个可用块，这些块称为shell 函数，定义函数的格式：

function name (){
		command1
		........
		}
name      #调用函数

编写一个自动安装ngnix的函数：

vim auto_ngnix.sh

#!/bin/bash
NGX_FILES=nginx-1.6.1.tar.gz
DWN_URL=http://ngnix.org/download/
MYSQL_FILES=mysql-5.1.17.tar.gz
PHP_FILES=php-5.3.3.tar.gz
function ngnix install()
{
wget -c $DWN_URL/${NGX_FILES}
tar -xzf $NGX_FILES;cd nginx-1.6.1; ./configure --prefix=/usr/local/nginx/  &&make  &&make install
if [ $? -eq 0 ];thrn
	echo "the ngnix install scuccessfully!"
fi
}

function mysql install()
{
tar -xzf $MYSQL_FILES;cd mysql-5.1.17; ./configure --prefix=/usr/local/mysql/  make; make install;
}

function php install()
{
	if [ -d /usr/local/mysql ];then
		tar -xzf $PHP_FILES;cd php-5.3.3; ./configure --prefix=/usr/local/php5 --with-mysql=/usr/local/mysql;  make;make install;
	else
		echo "please pre install mysql"
	fi	
}

PS3="Please select your install Menu" 
select i in "ngnix" "mysql " "php"
do
case $1 in
	ngnix )
	ngnix install
	;;
	mysql )
	 mysql install
	 ;;
	 php )
	 php install
	 ;;
	 * )
	 echo "usage: $0 {nginx | mysql | php | help}
	 ;;
esac
done

12.Shell 数组编程

数组，就是相同数据类型的元素按一定顺序排列的集合，就是把 有限个类型相同的变量用一个名字命名，然后用编号区分他们的变量的集合，这个名字成为数组名，编号成为下标。

今天这里我们来探讨一维数组的定义、统计、引用和删除等操作。

首先来定义一个一维数组：

A=( test1 test2 test3 ) ，定义数组一般以括号的方式来定义， 数组的值可以随机定义。如何来引用呢？

echo ${A[0]}，代表引用第一个数组变量，结果会显示test1, 数组引用从0 开始，代表第一个数组，依次类推。

echo ${A[1]}，代表引用第二个数组变量，结果会显示test2, 数组引用也是从0 开始计算的。

如何显示该数组所有参数呢？ echo ${A[@]} 将显示所有参数 test1 test2 test3 。

如何显示该数组参数个数呢？ echo ${#A[@]} 将显示该数组的参数个数 3。

如果替换某个数组呢？例如替换第二个 test2 数组为 test5 ：echo ${A[@]/test2/test5}

如何删除一个数组呢？例如删除 test3 数组命令为： unset A[2] ;echo ${A[@]} 查看效果。

那输入如何在编程来使用呢？请看下面例子：

 #!/bin/bash
 #Auto Make KVM Virtualization 
#Auto config bond scripts 

eth_bond()
{
 NETWORK=(
HWADDR=`ifconfig	eth0	|egrep	"HWaddr|Bcast"	|tr	"\n"	"	"|awk '{print $5,$7,$NF}'|sed -e 's/addr://g' -e 's/Mask://g'|awk'{print $1}'`
IPADDR=`ifconfig	eth0	|egrep	"HWaddr|Bcast"	|tr	"\n"	"	"|awk '{print $5,$7,$NF}'|sed -e 's/addr://g' -e 's/Mask://g'|awk'{print $2}'`
NETMASK=`ifconfig eth0 |egrep "HWaddr|Bcast" |tr "\n" " "|awk '{print $5,$7,$NF}'|sed -e 's/addr://g' -e 's/Mask://g'|awk '{print $3}'`
GATEWAY=`route -n|grep "UG"|awk '{print $2}'`
)

 cat >ifcfg-bond0<<EOF 
DEVICE=bond0 
BOOTPROTO=static
${NETWORK[1]}
${NETWORK[2]}
${NETWORK[3]} 
ONBOOT=yes 
TYPE=Ethernet 
NM_CONTROLLED=no 
EOF

如上脚本为定义三个数组变量，然后分别来引用， 这样让脚本可读性更强，更整洁。

案例一：

#!/bin/bash
soft=(
			nginx-1.6.1.tar.gz
			mysql-5.1.17.tar.gz
			php-5.3.3.tar.gz
			/etc/sysctl.conf
)
echo "this soft total ${#soft[@]}!"
tar -xzf ${soft[0]};cd nginx-1.6.1;./configure;make;make install

13.Shell编程之 awk、sed 等命令案例分析

在我们日常的 Shell 编程中我们会用到很多的一些语句，有的语句， 如果用好了， 可以让我们的脚本更上一层楼， 让我们的功能更容易满足企业的需求。

sed命令：

​ sed 预修改（缓存） sed -i （彻底修改）

解释：一种流编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”，接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾。文件内容并没有改变，除非你使用重定向存储输出。

1.基本用法

• sed [选项参数] ‘command’ filename

2.选项参数 功能

• -e 直接在指令列模式上进行sed的动作编辑。

3.命令功能描述

命令	功能描述
a	新增，a的后面可以接字符串，在下一行显示
d	删除
s	查找并替换

sed 's/192/10/g' test.txt	        #把文件里面的	192 字符替换为	10

在文件开头或者结尾添加字符：

案例一：找出数据中最大和最小的数字

vim number.txt
232
12 235 268 
52 56 589 56897
213 12 13 2
32 23 64 

cat number.txt  |sed 's/ /\n/g'       #把空格换为换行符（目的是每个数字一行）
cat number.txt  |sed 's/ /\n/g' |grep -v "^$"    #grep -v "^$" 把空格去除
cat number.txt  |sed 's/ /\n/g' |grep -v "^$" |sort   #排序
cat number.txt  |sed 's/ /\n/g' |grep -v "^$" |sort   -nr #从大到小排序
cat number.txt  |sed 's/ /\n/g' |grep -v "^$" |sort   -nr |sed -n '1p;$p' #打印第一个和最后一个（1代表第一个，$代表最后一个）

awk命令：

解释：一个强大的文本分析工具，把文件逐行的读入，以空格为默认分隔符将每行切片，切开的部分再进行分析处理。

1.基本用法

• awk [选项参数] ‘pattern1{action1} pattern2{action2}…’ filename
• pattern：表示AWK在数据中查找的内容，就是匹配模式
• action：在找到匹配内容时所执行的一系列命令

2.选项参数说明

选项参数	功能
-F	指定输入文件折分隔符
-v	赋值一个用户定义变量

3.awk 的内置变量

变量	说明
FILENAME	文件名
NR	已读的记录数
NF	浏览记录的域的个数(切割后，列的个数)

cat test.txt |awk '{print $4}' # 打印test.txt中第四列内容
cat test.txt |awk '{print $NF}' #打印test.txt中最后一个域
cat /etc/passwd | awk -F: '{print $1}' #打印文件中每一行第一列内容(将：去掉)
ifconfig eth1 |grep "Bcast" |awk '{print $2}' |sed 's/addr://g' #打印出ifconfig命令结果中的IP地址
ifconfig eth1 |grep "Bcast" |awk '{print $2}' |awk  -F: '{print $2}' #打印出ifconfig命令结果中的IP地址
cat test.txt |awk '{print $NF}' |sed 's/^/&01: /'#在test.txt文本中每行开头加上01：
cat test.txt |awk '{print  "01: " $NF}'  #在test.txt文本中每行开头加上01：

find 命令：

find . -maxdepth 1 -type f  -name "*.txt"         #找出一级目录中txt文件
find . -maxdepth 1 -type f  -name "*.txt"  -mtime  +30 #找出30天以前修改的
find . -maxdepth 1 -type f  -name "*.txt"  -mtime  -1 #找出一天以内修改的
find . -maxdepth 1 -type f  -name "*.txt"  -mtime  -1  -exec rm -rf {} \;  #删除一天以内修改的文件
find . -maxdepth 1 -type f  -name "*.txt"  -mtime  -5 -exec cp {} /tmp/ \; #拷贝5天以内修改的文件到tmp下
find . -size +20M #找到大于20M的文件

grep 正则：

grep "^10" test.txt   #匹配test.txt文件中以10开头的文本(只要开头是10，打印这一行)
grep "11$" test.txt   #匹配test.txt文件中以11结尾的文本 
grep "[0-9]" test.txt  #匹配含有数字的文本
grep "[a-z]" test.txt  #匹配含有小写字母的文本
grep "[A-Z]" test.txt  #匹配含有大写字母的文本
grep "168" test.txt #匹配含有168的文本
grep "^168$" test.txt #匹配168
cat test.txt | grep -E "([0-9]{1,3}\.){3}[0-9]{1,3}"  #匹配IP地址
cat -n test.txt #打印test.txt全部文本在左侧加了行号
grep -n "10" test.txt #打印test.txt中含有10的文本及其行号
egrep "11|haha" test.txt #匹配test.txt的11或haha并打印出来，匹配到一个即可打印

sout命令

解释：就是将文件进行排序，然后将结果输出出来

1.基本语法

• sort (选项)(参数)

2.选项

选项	说明
-n	依照数值的大小排序
-r	以相反的顺序来排序
-t	设置排序时所用的分隔字符
-k	指定需要排序的列

cut命令

解释：就是文件中负责剪切数据用的，从文件的每一行剪切字节，字符，和字段并输出等等

基本用法

• cut [选项参数] filename
• 说明：默认分隔符是制表符
• 参数：

选项参数	功能
-f	列号，提取第几列
-d	分隔符，按照指定分隔符分割列

read命令

基本语法
1.read (选项)(参数)
2.选项：

-p ： 指定读取值时的提示符
-t： 指定读取值时等待的时间(秒)

​ 3.参数：
​ 变量 ： 指定读取值得变量名
例子

read -t 7 -p "Enter your name in 7 seconds " NAME
echo $NAME

14.Linux系统全备份和增量备份脚本

在 Linux 中，我们经常需要备份系统重要文件，例如 /etc 、/boot 分区、重要网站数据等等，如果每天都完整备份的话，会占用很大的 空间，那我们改如何来备份呢？

这里采用如下方法来备份：

每周日进行完整备份，其余每天为增量备份。

那使用什么命令来备份呢，我们使用tar命令：

tar -g /tmp/snapshot -czvf /tmp/2014_full_system_data.tar.gz /data/sh/  #全备份
tar -g /tmp/snapshot -czvf /tmp/2014_add01_system_data.tar.gz /data/sh/ #增量备

#!/bin/sh
#Automatic Backup Linux System Files 
#Author wugk 2013-11-22
#Define Variable 
SOURCE_DIR=(
$*
)
TARGET_DIR=/data/backup/         #目标目录
YEAR=`date +%Y`                              #年
MONTH=`date +%m`                       #月
DAY=`date +%d`                                #日
WEEK=`date +%u`                            #周
A_NAME=`date +%H%M`               #名称
FILES=system_backup.tgz 
CODE=$?

if [ -z "$*" ];then
	echo	-e "\033[32mUsage:\nPlease   Enter	Your Backup Files	or Directories\n---------------------------	\n\nUsage: { $0 /boot /etc}\033[0m" 
	exit
fi

#Determine Whether the Target Directory Exists 
if [ ! -d $TARGET_DIR/$YEAR/$MONTH/$DAY ];then 
	mkdir -p $TARGET_DIR/$YEAR/$MONTH/$DAY 
	echo -e "\033[32mThe $TARGET_DIR Created Successfully !\033[0m" 
fi

#EXEC Full_Backup Function Command 
Full_Backup()
{
if [ "$WEEK" -eq "7" ];then
	rm -rf $TARGET_DIR/snapshot
	cd $TARGET_DIR/$YEAR/$MONTH/$DAY ;tar -g $TARGET_DIR/snapshot -czvf $FILES ${SOURCE_DIR[@]}[ "$CODE" == "0" ]&&echo -e  "------------------------" \n\033[32mThese Full_Backup System Files Backup Successfully !\033[0m" 
fi
}

#Perform incremental BACKUP Function Command Add_Backup()
{
if [ $WEEK -ne "7" ];then
	cd $TARGET_DIR/$YEAR/$MONTH/$DAY ;tar -g$TARGET_DIR/snapshot -czvf $A_NAME$FILES ${SOURCE_DIR[@]} [ "$CODE" == "0" ]&&echo -e "--------------------" \n\033[32mThese Add_Backup System Files
$TARGET_DIR/$YEAR/$MONTH/$DAY/${YEAR}_$A_NAME$FILES Backup Successfully !\033[0m"
fi
}
sleep 3 
Full_Backup;Add_Backup

15.Linux自动禁止恶意IP访问

​ 随着整个IT行业的发展，安全对于人们来说非常重要，小到个人电脑，到IT企业大数据存储，大到整个互联网安全，其实要做好安全，不能光看整体，有时候细节才是最重要的，相对而言，个人电脑的安全，需要我们从多方面来防御，然后结合自己上网的习惯，不要打开来历不明的东西等等。

​ 最为Linux SA ,我们最关心的是对于服务器级别的安全，该如何来保证服务器安全可靠呢？

​ 首先是服务器本身处在的机房环境安全，人为操作安全，以及操作系统方面的安全，禁止不必要的端口和服务、配备硬件防火墙，服务器自身的防火墙，例如：iptables,除了这些，服务器就安全了吗，就算我们做到这些，也只是相对安全，安全要靠长期和点滴来保证。

​ 配置了iptables防火墙，我们允许22端口对外网所有人访问，当然这也是为了方便，我们在任何地方都连接上，没有做VPN，也没有做SSH秘钥验证，但是我们的密码可以设置地非常复杂，大小写、特殊符号、数字32位，连自己都记不住，别人扫描没有3-5年是攻不破的。

​ 对所有用户开放了22端口，所以每天看/var/log/secure文件里面，全都是恶意攻击的IP，那怎么拒绝这些IP下次再攻击，或者怎么让这些IP尝试3-4次就拒绝访问22端口了呢？

脚本如下：

#!/bin/bash
#auto drop ssh failed IP address
#定义变量
SEC_FILE=/var/log/secure
#如下截取secure文件恶意IP远程登录22端口，大于等于4次就写入防火墙，禁止以后再登录服务器的22端口 ，egrep -0 "([0-9]{1,3}\.){3}[0-9]{1,3}"是匹配ip的意思，[0-9]表示任意一个数，{1,3}表示匹配1-3次
IP_ADDR=`tail -n 1000 /var/log/secure |grep "Failed password"|egrep -0 "([0-9]{1,3}\.){3}[0-9]{1,3}" |sort -nr |uniq -c |awk '$1>=4 {print $2}'`
IPTABLE_CONF=/etc/sysconfig/iptables
echo
cat <<EOF
++++++++++Welcome to use ssh login drop failed ip +++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++-----------------------------------------------------+++++++++
EOF
for i in `echo $IP_ADDR`
do
	#查看iptables配置文件是否含有提取的ip信息
	cat $IPTABLE_CONF |grep $i >/dev/null
if [ $? -ne 0 ];then
	#判断iptables配置文件里面是否存在已拒绝的ip，如果不存在，就不再添加相应条目，sed a参数的意思是匹配之后加入行
	sed -i "/lo/a -A INPUT -s $i -m state --state NEW -m tcp -p tcp --dport 22  -j DROP" $IPTABLE_CONF
else
	#如果存在的话，就打印提示信息即可
	echo "This is $i is exist in iptables,please exit..."
fi
done
#最后重启iptables生效
/etc/init.d/iptables restart

16.网站自动化部署及管理

批量拷贝文件至远程服务器

#!/bin/bash
#auto change server files
#SRC=/etc/
if [ ! -f ip.txt ];then
	echo -e "\033[31mPlease Create ip.txt Files,The ip.txt contents as follows: \033]0m"
cat <<EOF
192.168.149.128
192.168.149.129
EOF
	exit
fi

if [ -z "$1" ];then
	echo -e "\033[31mUsage:$0 command ,Example{Src_Files |Src_Dir Des_dir} \033]0m"
	exit
fi

count=`cat ip.txt |wc -l`
rm -rf ip.txt.swp
i=0
while ((i< $count))
do
i=`expr $i + 1`
sed "${i}s/^/&${i} /g" ip.txt >>ip.txt.swp
IP=`awk -v I="$I" '{IF(I==$1)print $2}' ip.txt.swp`
scp -r $1 root@${IP}:$2
#rsync -ap --delete $1 root@${IP}:$2     #与scp -r 功能相同
done

批量远程任务执行命令

#!/bin/bash
#auto change server files

if [ ! -f ip.txt ];then
	echo -e "\033[31mPlease Create ip.txt Files,The ip.txt contents as follows: \033[0m"
cat <<EOF
192.168.149.128
192.168.149.129
EOF
	exit
fi

if [ -z "$*" ];then
	echo -e "\033[31mUsage : $0 Command,Example {rm/tmp/test.txt | mkdir /tmp/20140228} \033[0m"
	exit
fi

	count=`cat ip.txt |wc -l`
	rm -rf ip.txt.swp
	i=0
while ((i< $count))
do
	i=`expr $i +1`
	sed "${i}s/^/&${i} /g" ip.txt >>ip.txt.swp
	IP=`awk -v I="$i" '{if(I==$1 print $2)}'  ip.txt.swp`
	ssh -q -1 root $IP "$*";echo -e "-----------------------------\nThe $IP Exec Command : $* success!";sleep 2''
done

Rsync + SSH批量自动化部署

#!/bin/bash
#auto change server files
#SRC=/etc/

flush()
{
if [ ! -f rsync.list ];then
	echo -e "\033[31mPlease Create  rsync.list Files,The rsync.list contents as follows: \033[0m"
cat <<EOF
192.168.149.128  src_dir  des_dir
192.168.149.129  src_dir  des_dir
EOF
	exit
fi
	rm -rf rsync.list.swp;cat rsync.list |grep -v "#" >rsync.list.swp
	COUNT=`cat rsync.list.swp |wc -l`
	NUM=0
while ((${NUM} < $COUNT))
do
	NUM=`expr $NUM + 1`
	Line=`sed -n "${NUM}p" rsync.list.swp`
	SRC=`echo $Line |awk '{print $2}'`
	DES=`echo $Line |awk '{print $3}'`
	IP=`echo $Line |awk '{print $1}'`
	rsync -av ${SRC} root@${IP}:${DES}
done
}

restart()
{
	rm -rf restart.list.swp;cat resstart.list |grep -v "#" >>restart.list.swp
	COUNT=`cat restart.list.swp |wc -l`
	NUM=0
while ((${NUM} < $COUNT))
do
	NUM=`expr $NUM + 1`
	Line=`sed -n "${NUM}p" restart.list.swp`
	Command=`echo $Line |awk '{print $2}'`
	IP=`echo $Line |awk '{print $1}'`
	ssh -1 root $IP "sh $Command;echo -e '-----------------------\nThe $IP Exec Command: sh $Command success!'"
done
}

case $1 in
	flush )
	flush
	;;
	restart )
	restart
	;;
	* )
	echo -e "\033[31mUsage:$0 command,example{flush |restart} \033[0m"
	;;
esac

重要脚本实例

1、编写hello world脚本

vim hello_world.sh
#!/bin/bash
# 编写hello world脚本
 
echo "Hello World!"

cat hello_world.sh #查看hello_world.sh中的内容
bash hello_world.sh   #运行此脚本

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

因为添加用户和设置密码需要root权限，所以在非root用户下需要使用sudo，但是sudo的每次使用会需要密码，为避免输入，在此把sudo设为免密码。

//进入/etc/sudoers文件
sudo vim /etc/sudoers
//为tseg用户设置免密码，在 “root   ALL=(ALL)  ALL” 之后添加或修改下面这句
tseg    ALL=(ALL)       NOPASSWD:ALL

创建用户，设置密码

#!/bin/sh

#设置变量name接收第一个参数（要创建的用户名），$n表示第n个参数，且=两边不能有空格
name=$1
#设置变量pass接收第二个参数（要为其设置的密码）
pass=$2
#echo语句会输出到控制台，${变量}或者 $变量 表示变量代表的字符串
echo "you are setting username : ${name}"
echo "you are setting password : $pass for ${name}"
#添加用户$name，此处sudo需要设置为无密码，后面将会作出说明
sudo useradd $name
#如果上一个命令正常运行，则输出成功，否则提示失败并以非正常状态退出程序
# $?表示上一个命令的执行状态，-eq表示等于，[ 也是一个命令
# if fi 是成对使用的，后面是前面的倒置，很多这样的用法。
if [ $? -eq 0 ];then
   echo "user ${name} is created successfully!!!"
else
   echo "user ${name} is created failly!!!"
   exit 1
fi
#sudo passwd $name会要求填入密码，下面将$pass作为密码传入
echo $pass | sudo passwd $name --stdin  &>/dev/null
if [ $? -eq 0 ];then
   echo "${name}'s password is set successfully"
else
   echo "${name}'s password is set failly!!!"
fi

3、备份日志

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

4.监控内存和磁盘容量，小于给定值时报警

#!/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

5.猜数字游戏

 #!/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

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

#!/bin/bash
# 检测本机当前用户是否为超级管理员,如果是管理员,则使用 yum 安装 vsftpd,如果不
# 是,则提示您非管理员(使用字串对比版本) 
if [ $USER == "root" ]
then
	yum ‐y install vsftpd
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
# 编写脚本,实现人机<石头,剪刀,布>游戏
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

10.编写脚本测试 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

11.编写脚本测试 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

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.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

14.使用 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

15.编写批量修改扩展名脚本

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

16.使用 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

17.点名器脚本

#!/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

18.查看有多少远程的 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

19.对 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"

20.统计 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

21.打印国际象棋棋盘

#!/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

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

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

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

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

24.统计/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"

25.自动为其他脚本添加解释器信息

#!/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

26.编写 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

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

 #!/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

28.切割 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

29.检测 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

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

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

31.检测 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

32.备份 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

33.将文件中所有的小写字母转换为大写字母

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

34.非交互自动生成 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

35.检查特定的软件包是否已经安装

#!/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

36.监控 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
 

37.自动添加防火墙规则,开启某些服务或端口(适用于 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

38.显示 CPU 厂商信息

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

39.删除某个目录下大小为 0 的文件

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

40.查找 Linux 系统中的僵尸进程

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

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

#!/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

42.生成随机密码(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

43.生成随机密码(字串截取版本)

#!/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

44.生成随机密码(UUID 版本,16 进制密码)

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

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

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

46.测试用户名与密码是否正确

#!/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

47.循环测试用户名与密码是否正确

#!/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"

48.Shell 脚本的 fork 炸弹

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

49.批量下载有序文件(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 选项指定下载文件另存到哪里.

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

 #!/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

51.制定目录路径,脚本自动将该目录使用 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

52.显示进度条(回旋镖版)

#!/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

53.循环关闭局域网中所有主机

#!/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

54.获取本机 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,因此将其屏蔽,不显示

55.修改 Linux 系统的最大打开文件数量

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

56.设置 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

57.自动修改计划任务配置文件

#!/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

58.使用脚本循环创建三位数字的文本文件(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

59.找出/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

60.统计/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

61.统计 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"

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

#!/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

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

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

64.显示进度条(数字版)

#!/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

65.打印斐波那契数列

#!/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[@]}

66.判断用户输入的是 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

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

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

68.将 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

69.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

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

#!/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"

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

#!/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[@]}"	

72.判断文件或目录是否存在

#!/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

73.打印各种格式的时间

#!/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"

74.生成签名私钥和证书

#!/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

75.Linux中使用shell实现字符串倒序输出(使用字符串切片)

#! /bin/bash
read -p "请输入倒序内容:" str
len=${#str}	# 获取字符串长度
for((i=$len;i>=0;i--))
do
        echo -e "${str:$i:1}\c"  # 其中 -e 是开启转义 \c 取消echo的换行
done
echo ""

76.Linux中使用shell实现字符串倒序输出(利用shell中的数组)

#! /bin/bash
read -p "请输入倒序内容:" s
str=`echo $s | sed 's/./& /g'` # 这里将字符串转化为数组格式 h e l l e v e r y o n e
array=($str)	# 将字符串转化为数组(h e l l e v e r y o n e)
len=${#array[@]}	# 获取数组长度 还有一种方式 len=${#array[*]}
for ((i=$len - 1;i>=0;i--))
do
        echo -e "${array[$i]}\c" # 其中 -e 是开启转义 \c 取消echo的换行
done
echo ""