#!/usr/bin/env bash
 # ------------------------------------------
 # Filename: hello.sh
 # Revision: 1.0
 # Date: 2020/10/22
 # Author: liupenghui
 # Email: 15094034633@163.com
 # Description: This is the first script
 # Copyright: 2020 liu
 # License: GPL
 # ------------------------------------------
 echo “hello world”

 # 主函数 []<-()                   <-------函数注释这样写
 function main(){
   local var="Hello World!!!"
   echo ${var}
 }
 # info级别的日志 []<-(msg:String)  <-------带入参的函数注释
 log_info(){
   echo "[$(date +'%Y-%m-%dT%H:%M:%S%z')][$$]: [info] $*" >&2
 }
 # error级别的日志 []<-(msg:String) <-------带入参的函数注释
 log_error(){
   # todo [error]用红色显示         <------函数内注释
   local msg=$1 # 将要输出的日志内容 <------变量的注释紧跟在变量的后面
   if [[ x"${msg}" != x"" ]];then
     # 注释                        <-------函数内注释 `#` 与缩进格式对整齐
     echo "[$(date +'%Y-%m-%dT%H:%M:%S%z')][$$]:[error] $*" >&2
   fi
 }

 #!/usr/bin/env bash
 # 脚本使用帮助文档 []<-()
 manual(){
   cat "$0"|grep -v "less \"\$0\"" \
           |grep -B1 "function "   \
           |grep -v "\\--"         \
           |sed "s/function //g"   \
           |sed "s/(){//g"         \
           |sed "s/#//g"           \
           |sed 'N;s/\n/ /'        \
           |column -t              \
           |awk '{print $1,$3,$2}' \
           |column -t
 }
 function search_user_info(){
   local result=$(httpclient_get --cookie "${cookie}" \
                                          "${url}/userName=${user_name}")
 }

 [root@oldboyedu-lnb ~]# name=f;(echo $name;name=z;echo $name);echo $name  # 小括号会开启子进程，赋予的变量，只在小括号内有效，执行完命令后，就会退出子进程。
 f
 z
 f
 [root@oldboyedu-lnb ~]# name=f;{ echo $name;name=z;echo $name; };echo $name  # 大括号不会开启子进程，在当前进程有效，执行完命令后，留在当前进程。
 f
 z
 z

 # 语法检测
 bash -n /path/to/script
 # 调试执行
 bash -x /path/to/script

 echo -e "\033[31malong\033[0m"        显示红色along
 echo -e "\033[1;31malong\033[0m"      高亮显示红色along
 echo -e "\033[41malong\033[0m"        显示背景色为红色的along
 echo -e "\033[31;5malong\033[0m"      显示闪烁的红色along
 ​
 color=$[$[RANDOM%7]+31]
 echo -ne "\033[1;${color};5m*\033[0m" 显示闪烁的随机色along

 var1="Hello World"   # 正确,推荐使用双引号
 var2=6.70            # 小数
 var3="${var1}"       # 推荐 双引号和大括号 包裹

 web="www.chen-shang.github.io"
 function main(){
   local name="chenshang" # 这里使用local定义一个局部变量
   local web="${web}"     # 这里${}内的web是全局变量,之后在函数中在使用web变量都是使用的局部变量
   local web2="${web}"    # 对于全局变量,虽然在使用的时候直接使用即可,但还是推荐使用一个局部变量进行接收，
然后使用局部变量，以防止在多线程操作的时候出现异常（相当于java中的静态变量在多线程中的时候需要注意线程安全一样，但常量除外）
 }

局部变量：生效范围为当前shell进程；对当前shell之外的其它shell进程，包括当前shell的子shell进程均无效
环境变量：生效范围为当前shell进程及其子进程
本地变量：生效范围为当前shell进程中某代码片断，通常指函数
位置变量：$1, $2, ...来表示，用于让脚本在脚本代码中调用通过命令行传递给它的参数
特殊变量：$?, $0, $*, $@, $#,$$

(1) 可以是直接字串：name=“root"
(2) 变量引用：name="$USER"
(3) 命令引用：name=`COMMAND`
            name=$(COMMAND)

    变量声明、赋值： export name=VALUE declare -x name=VALUE

    变量引用： $name, ${name}

    显示所有环境变量： env print env export declare -x

    删除变量：unset name

    bash内建的环境变量 PATH SHELL USER UID HOME PWD SHLVL LANG MAIL HOSTNAME HISTSIZE _ 下划线

    声明只读变量： readonly name declare -r name

    查看只读变量： readonly -p

$1, $2, ... 对应第1、第2等参数，shift [n]换位置，从$9以后需要加{}表示整体
set --     清空所有位置变量

  $0         脚本文件名称，如果全路径执行则带全路径，可以使用basename只获取名字
  $#         传递给脚本的参数的个数
  $*         传递给脚本的所有参数
  $@         传递给脚本的所有参数
  "$*"       全部参数合为一个字符串，可在循环中验证
  "$@"       每个参数为独立字符串，可在循环中验证
  $$         运行脚本的PID
  $!         上一个运行脚本的PID
  $_         当前命令行的最后一个参数, 类似于ESC .

[root@oldboyedu-lnb ~]#  basename /etc/passwd
passwd

0       代表成功
1－255  代表失败
$?      保存上一条命令的退出状态

ping -c1 -W1 hostdown &> /dev/null
echo $?

exit [n]     自定义退出状态码

[root@shell ~]# test='I am oldboy'
[root@shell ~]# url='www.baidu.com'

${var:n:x}切片

[root@shell ~]# echo ${test:2:2}  # (2,2+2]从第二个字符开始向后两位为止
am
[root@shell ~]# echo $test|awk '{print $2}'
am
[root@shell ~]# echo $test|cut -c3-4

am
${#var}字符长度

[root@shell ~]# echo ${#test}
11
[root@shell ~]# echo $test|wc -L
11
[root@shell ~]# expr length "$test"
11
[root@shell ~]# echo $test|awk '{print length}'
11

I am lzhenya teacher I am 18

[root@shell ~]# cat for.sh
for i in I am lzhenya teacher I am 18
do
		[ ${#i} -lt 3 ] && echo $i
done
[root@shell ~]# sh for.sh
I
am
I
am
18

[root@shell ~]# echo I am lzhenya teacher I am 18|xargs -n1|awk '{if(length<3)print}'
I
am
I
am
18

[root@shell ~]# echo I am lzhenya teacher I am 18|awk '{for(i=1;i<=NF;i++)if(length($i)<3)print $i}'
I
am
I
am
18

${var#}从前往后匹配，${var##}贪婪匹配

${var%}从后往前匹配，${var%%}贪婪匹配

[root@shell ~]# echo ${url#www.}
baidu.com
[root@shell ~]# echo ${url#*.}
baidu.com
[root@shell ~]# echo ${url#*.*.}
com
[root@shell ~]# echo ${url##*.}
com

[root@shell ~]# echo ${url%.com}
www.baidu
[root@shell ~]# echo ${url%.*}
www.baidu
[root@shell ~]# echo ${url%.*.*}
www
[root@shell ~]# echo ${url%%.*}
www

${var/a/b}替换匹配内容

${var//a/b}贪婪匹配

[root@shell ~]# echo ${url/w/W}
Www.baidu.com
[root@shell ~]# echo ${url//w/W}
WWW.baidu.com
[root@shell ~]# echo ${url/baidu/sina}
www.sina.com
[root@shell ~]# echo $url|sed 's#www#WWW#g'
WWW.baidu.com

(1) var=$(expr arg1 arg2 arg3 ...)
(2) var=$[算术表达式]
(3) var=$((算术表达式))
(4) let var=算术表达式
(5) declare –i var = 数值
(6) echo ‘算术表达式’ | bc

# 生成随机7个数（0-6）
echo $[RANDOM%7]
# 生成随机7个数（31-37）
echo $[$[RANDOM%7]+31]
  

cat /dev/urandom |tr -dc [:alnum:] |head -c 8
tr -dc ‘a-zA-Z0-9’</dev/urandom|head -c8 

+=, -=, *=, /=, %=
let var OPER value
例如:let count+=3   自加3后自赋值
自增，自减：
let var+=1
let var++
let var-=1
let var--
let var=i++   是赋值后加
let var=++i   是先加后赋值

echo -e  "\033[1;$[RANDOM%7+31]m 字符串\033[0m"

true, false
 1, 0
 与 &
 1 与 1 = 1
 1 与 0 = 0
 0 与 1 = 0
 0 与 0 = 0
 或 |
 1 或 1 = 1
 1 或 0 = 1
 0 或 1 = 1
 0 或 0 = 0
 非 ！
 ! 1 = 0 ! true
 ! 0 = 1 ! false
​

 短路与和短路或 
 [ $RANDOM%6 –eq 0 ] && rm –rf /* || echo “click”
 # 数字互换
 A=10;B=20;A=$[A^B];B=$[A^B];A=$[A^B];echo A=$A B=$B
 A=01010=10
 B=10100=20
 A=$[A^B]=11110=30
 A=11110=30
 B=10100=20=10
 B=$[A^B]=01010
 A=11110=30
 B=01010=10
 A=$[A^B]=10100=20
 [root@oldboyedu-lnb ~]# A=10;B=20;A=$[A^B];B=$[A^B];A=$[A^B];echo A=$A B=$B
 A=20 B=10

 test EXPRESSION
 [ EXPRESSION ]
 (( EXPRESSION ))    算术表达式
 [[ EXPRESSION ]]    不会发生文件名扩展或者单词分割，会发生参数扩展和命令替换
 注意：EXPRESSION 前后必须有空白字符

test -d "$HOME" ;echo $?
[ "abc" != "def" ];echo $?
test EXPRESSION && echo "exist" || echo "not exist"  更人性化地显示结果
test EXPRESSION && echo true || echo false           更人性化地显示结果
test -e file && echo "exist" || echo "not exist"
test 3 -gt 4 && echo true || echo false

  -gt 是否大于
  -ge 是否大于等于
  -eq 是否等于
  -ne 是否不等于
  -lt 是否小于
  -le 是否小于等于

=     是否等于
>     ascii码是否大于ascii码
<     是否小于
!=    是否不等于
=~    左侧字符串是否能够被右侧的 正则表达式 所匹配

    -a FILE：同 -e
    -e FILE: 文件存在性测试，存在为真，否则为假
存在性及类别测试
    -b FILE：是否存在且为块设备文件
    -c FILE：是否存在且为字符设备文件
    -d FILE：是否存在且为目录文件
    -f FILE：是否存在且为普通文件
    -h FILE 或 -L FILE：存在且为符号链接文件
    -p FILE：是否存在且为命名管道文件
    -S FILE：是否存在且为套接字文件

     -r FILE：是否存在且可读
    -w FILE: 是否存在且可写
    -x FILE: 是否存在且可执行

 -u FILE：是否存在且拥有suid权限 
 -g FILE：是否存在且拥有sgid权限 
 -k FILE：是否存在且拥有sticky权限

    -t fd: fd 文件描述符是否在某终端已经打开
    -N FILE：文件自从上一次被读取之后是否被修改过
    -O FILE：当前有效用户是否为文件属主
    -G FILE：当前有效用户是否为文件属组

EXPRESSION1 -a EXPRESSION2 并且，只能在test或[]中使用
EXPRESSION1 -o EXPRESSION2 或者，只能在test或[]中使用
! EXPRESSION 非

grep -q no_such_user /etc/passwd || echo 'No such user'
No such user

ping -c1 -W2 station1 &> /dev/null \
> && echo "station1 is up" \
> || (echo 'station1 is unreachable'; exit 1)
station1 is up

test "$A" = "$B" && echo "Strings are equal"
test “$A”-eq “$B” && echo "Integers are equal“
[ "$A" = "$B" ] && echo "Strings are equal"
[ "$A" -eq "$B" ] && echo "Integers are equal“
[ -f /bin/cat -a -x /bin/cat ] && cat /etc/fstab
# 判断字符串为空或者localhost.localdomain,则临时修改主机名为 www.magedu.com
[ -z “$HOSTNAME” -o $HOSTNAME "=="localhost.localdomain" ] && hostname www.magedu.com  

read           把输入值分配给一个或多个shell变量
     -a        后跟一个变量，该变量会被认为是个数组，然后给其赋值，默认是以空格为分割符
     -e 	   在输入的时候可以使用命令补全功能
     -r 	   屏蔽\的转义功能
     -u 	   后面跟fd，从文件描述符中读入，该文件描述符可以是exec新开启的
     -p        指定输入前打印提示信息
     -s        静默输入，输入的字符不在屏幕上显示，一般用于密码
     -n N      指定输入的字符长度最大为N
     -d ‘字符’  以输入的指定‘字符’作为结束符
     -t N      TIMEOUT为N秒，超时退出

read -p “Enter a filename: “

[root@shell ~]# cat hostname.sh 
#!/bin/bash 
eth0_cfg='/etc/sysconfig/network-scripts/ifcfg-eth0' 
old_ip=`ifconfig eth0|awk 'NR==2{print $2}'|awk -F. '{print $NF}'` 
read -p "please input hostname: " name read -p "please input New IP: " 
IP hostnamectl set-hostname $name sed -i "s#$old_ip#$IP#g" $eth0_cfg grep $IP $eth0_cfg 
[root@shell ~]# cat ping.sh read -p "Please Input URL: " url ping -c2 -W1 $url &>/dev/null [ $? -ne 0 ] && echo "ping不通" || echo "通了"

cat <<EOF、cat <<-EOF的区别

用于执行脚本的时候，需要往一个文件里自动输入N行内容。

    cat用于显示文本文件内容，全部输出。

    EOF是END Of File的缩写，表示自定义终止符，Ctrl-D就代表EOF。

man说明：

If the redirection operator is <<-, then all leading tab characters are stripped from input lines and the line containing delimiter.

翻译：

如果重定向的操作符是<<-，那么分界符（EOF）所在行的开头部分的制表符（Tab）都将被去除。

也就是说：

    cat <<EOF中EOF必须顶行写，前面不能用制表符或者空格。如果结束分解符EOF前有制表符或者空格，则EOF不会被当做结束分界符，只会继续被当做stdin来输入。

    cat <<-EOF中就算最后的EOF前面有多个制表符和空格，但仍然会被当做结束分界符，表示stdin的结束。

trap [-lp] [[arg] sigspec ...]
        -l    让shell打印一个命令名称和其相对应的编号的列表
       -p    如果有-p选项而没有提供arg参数，则会打印所有与sigspec指定信号相关联的的trap命令；
              如果没有提供任何参数或者仅有-p选项，trap命令将会打印与每一个信号有关联的命令的列表；
     
      [arg]参数缺省或者为“-”，每个接收到的sigspec信号都将会被重置为它们进入shell时的值
      [arg]参数是空字符串每一个由sigspec指定的信号都会被shell和它所调用的命令忽略；

trap "rm -f $WORKDIR/work1$ $WORKDIR/dataout$; exit" 1 2  收到指定信号后清理临时文件
trap '' 1 2 20                                            收到指定信号后忽略信号
trap '-' 1 2 20
trap 1 2 20                                               恢复信号的默认操作，重设陷阱

    如果sigspec是EXIT(0)，那么arg指定的命令将会在shell上执行退出命令时执行

    如果sigspec是DEBUG，那么arg指定的命令将会在以下每个命令执行之前执行：

    简单命令，for语句，case语句，select命令，算法命令，在函数内的第一条命令。

    如果sigspec是ERR，那么arg指定的命令将会在任何简单命名执行完后返回值为非零值时执行，但是也有以下例外情况，arg命令不会执行，这些规则同样适用于errexit选项：

    如果执行失败的命令是紧跟在while或者until关键字之后的一组命令中的一部分时

    如果执行失败的命令是if测试语句的一部分时，是 && 和 ||连接的列表中的一部分时

    如果执行失败的命令的返回值是被取反过的（通过!操作符）

    如果sigspec是RETURN，那么arg指定的命令在每次shell函数或者脚本用"."或者内置的命令执行完成后执行

#!/bin/bash
trap 'echo press ctrl+c' 2
for ((i=0;i<10;i++));do
        sleep 1
        echo $i
done

#!/bin/bash
trap '' 2
trap -p
for ((i=0;i<3;i++));do
        sleep 1
        echo $i
done
trap '-' SIGINT
for ((i=3;i<10;i++));do
        sleep 1
        echo $i
done

SIGHUP    1   /* Hangup (POSIX).  */                     终止进程  终端线路挂断
SIGINT    2   /* Interrupt (ANSI).  */                   终止进程  中断进程 Ctrl+C
SIGQUIT   3   /* Quit (POSIX).  */                       建立CORE文件终止进程，并且生成core文件 Ctrl+
SIGILL    4   /* Illegal instruction (ANSI).  */         建立CORE文件,非法指令
SIGTRAP   5   /* Trace trap (POSIX).  */                 建立CORE文件,跟踪自陷
SIGABRT   6   /* Abort (ANSI).  */
SIGIOT    6   /* IOT trap (4.2 BSD).  */                 建立CORE文件,执行I/O自陷
SIGBUS    7   /* BUS error (4.2 BSD).  */                建立CORE文件,总线错误
SIGFPE    8   /* Floating-point exception (ANSI).  */    建立CORE文件,浮点异常
SIGKILL   9   /* Kill, unblockable (POSIX).  */          终止进程  杀死进程
SIGUSR1   10  /* User-defined signal 1 (POSIX).  */      终止进程  用户定义信号1
SIGSEGV   11  /* Segmentation violation (ANSI).  */      建立CORE文件,段非法错误
SIGUSR2   12  /* User-defined signal 2 (POSIX).  */      终止进程  用户定义信号2
SIGPIPE   13  /* Broken pipe (POSIX).  */                终止进程  向一个没有读进程的管道写数据
SIGALARM  14  /* Alarm clock (POSIX).  */                终止进程  计时器到时
SIGTERM   15  /* Termination (ANSI).  */                 终止进程  软件终止信号
SIGSTKFLT 16  /* Stack fault.  */
SIGCHLD   17  /* Child status has changed (POSIX).  */   忽略信号  当子进程停止或退出时通知父进程
SIGCONT   18  /* Continue (POSIX).  */                   忽略信号  继续执行一个停止的进程
SIGSTOP   19  /* Stop, unblockable (POSIX).  */          停止进程  非终端来的停止信号
SIGTSTP   20  /* Keyboard stop (POSIX).  */              停止进程  终端来的停止信号 Ctrl+Z
SIGTTIN   21  /* Background read from tty (POSIX).  */   停止进程  后台进程读终端
SIGTTOU   22  /* Background write to tty (POSIX).  */    停止进程  后台进程写终端
SIGURG    23  /* Urgent condition on socket (4.2 BSD).*/ 忽略信号  I/O紧急信号
SIGXCPU   24  /* CPU limit exceeded (4.2 BSD).  */       终止进程  CPU时限超时
SIGXFSZ   25  /* File size limit exceeded (4.2 BSD).  */ 终止进程  文件长度过长
SIGVTALRM 26  /* Virtual alarm clock (4.2 BSD).  */      终止进程  虚拟计时器到时
SIGPROF   27  /* Profiling alarm clock (4.2 BSD).  */    终止进程  统计分布图用计时器到时
SIGWINCH  28  /* Window size change (4.3 BSD, Sun).  */  忽略信号  窗口大小发生变化
SIGIO     29  /* I/O now possible (4.2 BSD).  */         忽略信号  描述符上可以进行I/O
SIGPWR    30  /* Power failure restart (System V).  */
SIGSYS    31  /* Bad system call.  */

yum install expect -y

expect [选项] [ -c cmds ] [ [ -[f|b] ] cmdfile ] [ args ]
       -c：从命令行执行expect脚本，默认expect是交互地执行的
       -d：可以输出输出调试信息  

示例：
expect -c 'expect "\n" {send "pressed enter\n"}
expect -d ssh.exp

spawn：启动新的进程
send：用于向进程发送字符串
expect：从进程接收字符串
interact：允许用户交互，并停留在远程连接的主机上
exp_continue：匹配多个字符串在执行动作后加此命令

expect “hi” {send “You said hi\n"}

expect "hi" { send "You said hi\n" } \  
       "hehe" { send "Hehe yourself\n" } \  
       "bye" { send "Good bye\n" }

expect {  
           "hi" { send "You said hi\n"}  
           "hehe" { send "Hehe yourself\n"}  
           "bye" { send  " Good bye\n"}
}

#!/usr/bin/expect
set ip 192.168.7.100
set user root
set password centos
set timeout 10
# 登录 调用user和ip两个变量的值
spawn ssh $user@$ip
expect {
# 有发现yes/no 输入 yes\n
  "yes/no" { send "yes\n";exp_continue }
# 有发现password输入$password的值
  "password" { send "$password\n" }               
}
# 允许用户交互
interact

#!/bin/bash
ip=$1 
user=$2
password=$3
expect <<EOF   # 开启expect命令多行重定向
set timeout 20
spawn ssh $user@$ip
expect {        
        "yes/no" { send "yes\n";exp_continue }        
        "password" { send "$password\n" }
}
expect "]#" { send "useradd hehe\n" }
expect "]#" { send "echo centos |passwd --stdin hehe\n" }
expect "]#" { send "exit\n" }
expect eof   # 结束语
EOF

[root@oldboyedu-lnb ~]# cat >> iplist.txt << EOF
192.168.7.101
192.168.7.102
192.168.7.103
EOF

#!/bin/bash
while read ip;do
user=root
password=centos
expect <<EOF
set timeout 20
spawn ssh $user@$ip
expect {        
        "yes/no" { send "yes\n";exp_continue }        
        "password" { send "$password\n" }
}
expect "]#" { send "useradd hehe\n" }   # 远程ssh登录后创建用户名
expect "]#" { send "echo centos |passwd --stdin hehe\n" }  # 设置密码
expect "]#" { send "exit\n" }
expect eof
EOF 
done < iplist.txt

[root@oldboyedu-lnb ~]# cat >> iplist.txt << EOF
192.168.7.101  wangwang
192.168.7.102  centos
192.168.7.103  hahahaha
EOF

#!/bin/bash
ssh-keygen -t rsa -P "" -f /root/.ssh/id_rsa
while read ip password;do
user=root
set timeout 10
expect << EOF
spawn ssh-copy-id -i /root/.ssh/id_rsa.pub $user@$ip
expect {
"yes/no" { send "yes\n";exp_continue }
"password" { send "$password\n" }
}
expect eof
EOF
done <iplist.txt

 单分支
 if 判断条件;then
    条件为真的分支代码
 fi
 双分支
 if 判断条件; then
    条件为真的分支代码
 else
    条件为假的分支代码
 fi
 多分支
 if 判断条件1; then
    条件1为真的分支代码
 elif 判断条件2; then
    条件2为真的分支代码
 elif 判断条件3; then
    条件3为真的分支代码
 else
    以上条件都为假的分支代码
 fi

 if ping -c1 -W2 station1 &> /dev/null; then
     echo 'Station1 is UP'
 elif grep "station1" ~/maintenance.txt &> /dev/null; then
     echo 'Station1 is undergoing maintenance'
 else
     echo 'Station1 is unexpectedly DOWN!'
 exit 1
 fi

#!/bin/bash
read -p "Please input your age: " age
if [[ $age =~ [^0-9] ]] ;then
    echo "please input a int"
    exit 10
elif [ $age -ge 150 ];then
    echo "your age is wrong"
    exit 20
elif [ $age -gt 18 ];then
    echo "good good work,day day up"
else
    echo "good good study,day day up"
fi

#!/bin/bash
read -p "Please input your score: " score
if [[ $score =~ [^0-9] ]] ;then
    echo "please input a int"
    exit 10
elif [ $score -gt 100 ];then
    echo "Your score is wrong"
    exit 20
elif [ $score -ge 85 ];then
    echo "Your score is very good"
elif [ $score -ge 60 ];then
    echo "Your score is soso"
else
    echo "You are loser"
fi

case 变量引用 in
PAT1)
     分支1
     ;;
PAT2)
     分支2
     ;;
*)
     默认分支
     ;;
esac

#!/bin/bash
read -p "Please input yes or no: " anw
case $anw in
[yY][eE][sS]|[yY])
    echo yes
    ;;
[nN][oO]|[nN])
    echo no
    ;;
*)
    echo false
    ;;
esac

for (( i = 0; i < 10; i++ )); do
  循环体
done

for item in 列表; do
  循环体
done

#!/bin/bash
sum=0
read -p "Please input a positive integer: " num
if [[ ! $num =~ ^[1-9][0-9]* ]] ;then
    echo "input error"
else
    for i in `seq 1 $num` ;do
        sum=$[$sum+$i]
    done
    echo $sum
fi

while [[ 循环控制条件 ]]; do
  循环体
done

while read -r item ;do
  循环体
done < 'file_name'

cat 'file_name' | while read line; do
　　循环体
done

sum初始值为0，i的初始值为1；当i<=100时，进入循环，判断 i÷2取余，不为0时为奇数，sum=sum+i，i+1；为0时，i+1；循环结束，最后输出sum的值。
#!/bin/bash
sum=0
i=1
while [ $i -le 100 ] ;do
if [ $[$i%2] -ne 0 ];then
    let sum+=i
    let i++
else
    let i++
fi
done
echo "sum is $sum"

#!/bin/bash
cat << EOF
             1)gongbaojiding
             2)kaoya
             3)fotiaoqiang
             4)haishen
             5)baoyu
             6)quit
EOF
while read -p "please choose the number: " num;do
case $num in
    1)
     echo "gongbaojiding price is 30"
     ;;
    2)
     echo "kaoya price price is 80"
     ;;
    3)  
     echo "fotiaoqiang price is 200"
     ;;
    4)
     echo "haishen price is \$20"
     ;;
    5)
     echo "baoyu price is \$10"
     ;;
    6)
     break
     ;;
    *)
    echo "please input again"
esac
done

#!/bin/bash
# 其中access_log为访问日志，统计访问IP和次数，导出到文件iplist.txt中
sed -rn 's/^([^[:space:]]+).*/\1/p' access_log |sort |uniq -c > iplist.txt
# while read 逐行处理
while read count ip;do
    if [ $count -gt 100 ];then
        # 将统计后的日志导出到文件crack.log中
        echo from $ip access $count  >> crack.log
    fi
# while read 支持重定向，可以将要统计的文件导入到循环中
done < iplist.txt

#!/bin/bash
# 定义报警的磁盘使用率
WARNING=10
df | awk '{if($5>$WARNING)print $0}'

#!/bin/bash
# 定义报警的磁盘使用率
WARNING=10
df |sed -rn  '/^\/dev\/sd/s#^([^[:space:]]+).* ([[:digit:]]+)%.*$#\1 \2#p' | while read part use; do
    if [ $use -gt $WARNING ]; then
        echo $part will be full,use:$use
    fi
done

#!/bin/bash
# 定义报警的磁盘使用率
WARNING=10
df |awk -F"[[:space:]]+|%" '/dev\/sd/{print $1,$(NF-2)}' > disk.txt
while read part use; do
        if  [ $use -gt $WARNING ]; then
            echo $part will be full,use:$use
        fi
done < disk.txt

until [[ 循环控制条件 ]]; do
  循环体
done
进入条件：循环条件为false ；
退出条件：循环条件为true；
刚好和while相反，所以不常用，用while就行。

#!/bin/bash
# 发现test用户登录，条件为true，退出循环
until pgrep -u test &> /dev/null ;do
    # 每隔0.5秒扫描
    sleep 0.5
done
# 杀死test用户相关进程
pkill -9 -u test

select variable in list
do
　　循环体
done

#!/bin/bash
PS3="Please choose the menu: "
select menu in mifan huimian jiaozi babaozhou quit
do
        case $REPLY in
        1|4)
                echo "the price is 15"
                ;;
        2|3)
                echo "the price is 20"
                ;;
        5)
                break
                ;;
        *)
                echo "no the option"
        esac
done

while CONDTITON1; do
　　CMD1
if CONDITION2; then
　　continue / break
fi
　　CMD2
done

#!/bin/bash
sum=0
for i in {1..100} ;do
        [ $i -eq 51 ] && continue
        [ $[$i%2] -eq 1 ] && { let sum+=i;let i++; }
done
echo sum=$sum

#!/bin/bash
sum=0
for i in {1..100} ;do
        [ $i -eq 51 ] && break
        [ $[$i%2] -eq 1 ] && { let sum+=i;let i++; }
done
echo sum=$sum

$ cat run.sh
#!/bin/bash
while [ $# != 0 ];do
echo "第一个参数为：$1,参数个数为：$#"
shift
done 
$ sh run.sh a b c d e f 
第一个参数为：a,参数个数为：6
第一个参数为：b,参数个数为：5
第一个参数为：c,参数个数为：4
第一个参数为：d,参数个数为：3
第一个参数为：e,参数个数为：2
第一个参数为：f,参数个数为：1 

$ cat t.sh 
#!/bin/bash echo -e "./t.sh 
arg1 arg2 arg3 arg4 arg5 arg6" str1="${1},${2},${3}" 
echo "str1=$str1" shift 3 str2=$@ echo "str2=$str2" $ sh t.sh 1 2 3 4 5 6 7 str1=1,2,3 3.将参数从左到右逐个移动： 
$ cat shift.sh 
#!/bin/bash 
while [ $# -ne 0 ]
 do echo "第一个参数为:
 $1 参数个数为: $#" 
shift done $ sh shift.sh Lily Lucy Jake Mike 
第一个参数为: Lily 参数个数为: 4 
第一个参数为: Lucy 参数个数为: 3
 第一个参数为: Jake 参数个数为: 2 
第一个参数为: Mike 参数个数为: 1

#!/bin/bash
if [ $# -eq 0 ] ;then
        echo "Please input a arg(eg:`basename $0` arg1)"
        exit 1
else
        while [ -n "$1" ];do
                useradd $1 &> /dev/null
                echo "User:$1 is created"
                shift
        done
fi

 #!/bin/bash
 while (( $# > 0 ))
 do
     echo "$*"
     shift
 done

 [root@oldboyedu-lnb ~]# sh trian.sh 1 2 3
 1 2 3
 2 3
 3

while true ;do
　　循环体
done
# 或者
until false ;do
　　循环体
done

for name in 列表 ;do
　　{
　　循环体
　　}&
done
wait

read -p "Please input network (eg:192.168.0.0): " net
echo $net |egrep -o "\<(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\>"
[ $? -eq 0 ] || ( echo "input error";exit 10 )
IP=`echo $net |egrep -o "^([0-9]{1,3}\.){3}"`
for i in {1..254};do
        {
        ping -c 1 -w 1 $IP$i &> /dev/null && \
        echo "$IP$i is up"
        }&
done
wait

n!=1×2×3×...×n
阶乘亦可以递归方式定义：0!=1，n!=(n-1)!×n
n!=n(n-1)(n-2)...1
n(n-1)! = n(n-1)(n-2)!

fact.sh 
#!/bin/bash 
fact() 
{ if [ $1 -eq 0 -o $1 -eq 1 ]; 
then echo 1 
else echo $[$1*$(fact $[$1-1])] fi } 
fact $1

  $   （美元符号）   变量扩展（注意："$" 输出 $,仍有特殊含义）
  `   (反引号）      命令替换
  \   （反斜线）     禁止单个字符扩展
  !   （叹号）       历史命令替换

if

if [[ condition ]]; then
  # statements
fi

if [[ condition ]]; then
  # statements
else
  # statements
fi

if [[ condition ]]; then
  # statements
elif [[ condition ]]; then
  # statements
else
  # statements
fi

if 后面的判断 使用 双中括号[[]]
if [[ condition ]]; then 写在一行

while [[ condition ]]; do
  # statements
done

while read -r item ;do
  # statements
done < 'file_name'

until [[ condition ]]; do
  # statements
done

for (( i = 0; i < 10; i++ )); do
  # statements
done
for item in ${array}; do
  # statements
done

case $var in
  pattern )
    #statements
    ;;
    *)
    #statements
    ;;
esac

function main(){
  #函数执行的操作
  #函数的返回结果
}

或

main(){
  #函数执行的操作
  #函数的返回结果
}

或

function main {
  #函数执行的操作
  #函数的返回结果
}

# 重新设置DNS地址 []<-()
function set_name_server(){
  > /etc/resolv.conf
  echo nameserver 114.114.114.114 >> /etc/resolv.conf
  echo nameserver 8.8.8.8 >> /etc/resolv.conf
  cat /etc/resolv.conf
}
# info级别的日志 []<-(msg:String)
log_info(){
  echo -e "[$(date +'%Y-%m-%dT%H:%M:%S%z')][$$]: \033[32m [info] \033[0m $*" >&2
}
# error级别的日志 []<-(msg:String)
log_error(){
  # todo [error]用红色显示
  echo -e "[$(date +'%Y-%m-%dT%H:%M:%S%z')][$$]: \033[31m [error] \033[0m $*" >&2
}

#!/bin/bash
# 定义function func_os_version，在大括号里边定义命令，取出操作系统的版本号，类似于定义别名一样
func_os_version () {  
sed -nr 's/.* ([0-9]+)\..*/\1/p' /etc/redhat-release   
}
# 直接写上函数名，或者用echo加反引号输出结果
echo OS version is `func_os_version`  

 [root@centos-7 ~]# cat functions
 func_os_version () {
 sed -nr 's/.* ([0-9]+)\..*/\1/p' /etc/redhat-release
 }
 ​
 [root@centos-7 ~]# cat osversion.sh  
 #!/bin/bash
 # 在当前脚本加载 functions
 source functions
 # 调用函数
 func_os_version

# 对脚本osversion.sh加上执行权限

 [root@centos-7 ~]# chmod +x osversion.sh
 # 运行脚本
 [root@centos-7 ~]# ./osversion.sh
 7

（1）声明：export -f function_name

（2）查看：export -f 或 declare -xf

#!/usr/bin/env bash
# shellcheck disable=SC1091,SC2155
readonly local TRUE=0 && readonly local FALSE=1
# 脚本使用帮助文档
manual(){
  cat "$0"|grep -v "less \"\$0\"" \
          |grep -B1 "function "   \
          |grep -v "\\--"         \
          |sed "s/function //g"   \
          |sed "s/(){//g"         \
          |sed "s/#//g"           \
          |sed 'N;s/\n/ /'        \
          |column -t              \
          |awk '{print $1,$3,$2}' \
          |column -t
}
######################################################################
# 主函数
main(){
  (manual)
}
######################################################################
# 执行函数 [Any]<-(function_name:String,function_parameters:List<Any>)
execute(){
  function_name=$1
  shift # 参数列表以空格为分割左移一位,相当于丢弃掉第一个参数
  function_parameters=$*
  (${function_name} "${function_parameters}")
}
case $1 in
  "-h" | "--help" | "?") (manual);;
  "") (main) ;;
  *) (execute "$@") ;;
esac

# 主函数 []<-()                  <-------函数注释这样写
function main(){
  local var="Hello World!!!"
  echo ${var}
}
# info级别的日志 []<-(msg:String)  <-------带入参的函数注释
log_info(){
  echo "[$(date +'%Y-%m-%dT%H:%M:%S%z')][$$]: [info] $*" >&2
}

main函数的函数类型是 []<-() , <- 左侧表的是函数的返回值类型用[]包裹, 右侧是函数的参数类型用()包裹,多个参数用 ',' 分隔, 参数的描述是从 Scala 语言中偷过来, 先是参数名称, 然后是参数类型, 中间用:分隔

对于main函数的注释来说, # 顶格写,后面紧跟一个空格,其实这样写是遵循的markdown的语法, 后面再跟一个空格,然后是 []<-(),代表这个函数没有入参也没有返回值,这个函数的目的就是执行这个这个函数中的命令,但我不关心这个函数的返回值。也就是利用函数的副作用来完成我们想要的操作。

对于log_info也是一样不过最后的函数类型是 []<-(msg:String) 代表入参是一个string类型的信息,然后也没有返回值。 关于函数的返回值,我理解的函数的返回值有两种形式,一种是显示的return一种是隐式的echo

[]<-()
[String]<-(var1:String,var2:String)
[Boolean]<-(var1:String,var2:Int)
[]<-(var1:String)

$ pwd
/Users/chenshang

function main(){
  pwd
}

function main(){
  local dir=$(pwd)
  echo "dir is ${dir}"
}

function main(){
  local dir=$(pwd)
  local status=$?
  echo "pwd run status is ${status}" #这个stauts一定有值,且是int类型,取值范围在0-255之间
  echo "dir is ${dir}"
}

# 检查当前系统版本 [Integer]<-()
function check_version(){
  (log_info "check_version ...") # log_info是我写的工具类中的一个函数
  local version # 这里是先定义变量,在对变量进行赋值,我们往往是直接初始化,而不是像这样先定义在赋值,这里只是告诉大家可以这么用
  version=$(sed -r 's/.* ([0-9]+)\..*/\1/' /etc/redhat-release)
  (log_info "centos version is ${version}")
  return "${version}"
}

check_version
local version=$?
echo "${version}"

function check_network(){
  (log_info "check_network ...")
  for((i=1;i<=3;i++));do
    http_code=$(curl -I -m 10 -o /dev/null -s -w %\{http_code\}  www.baidu.com)
    if [[ ${http_code} -eq 200 ]];then
      (log_info "network is ok")
      return ${TRUE}
    fi
  done
  (log_error "network is not ok")
  return ${FALSE}
}
# 获取数组中指定元素的下标 [int]<-(TABLE:Array,target:String)
function get_index_of(){
  readonly local array=($1)
  local target=$2
  local index=-1 # -1其实是255
  local size=${#array[@]}
  for ((i=0;i<${size};i++));do
    if [[ ${array[i]} == ${target} ]];then
      return ${i}
    fi
  done
  return ${index}
}

[String]<-(json_string:String)
function json_format(){
  local json_string=$1
  echo "${json_string}"|jq . #jq是shell中处理json的一个工具
}

function json_format(){
  local json_string=$1
  echo "为格式化之前:${json_string}" # 其实新添加的只一句只是用来记录一行日志的
  echo "${json_string}"|jq . # jq是shell中处理json的一个工具
}

function json_format(){
  local json_string=$1
  (echo "为格式化之前:${json_string}") # 其实新添加的只一句只是用来记录一行日志的
  echo "${json_string}"|jq . # jq是shell中处理json的一个工具
}

[root@oldboyedu-lnb ~]# cat functions
func_is_digit(){
    # 判断参数$1不是空，就为真，取反，空为真
    if [ ! "$1" ];then
        # 请输入数字
        echo "Usage:func_is_digit number"
        return  10
    # 如果输入是数字，返回0
    elif [[ $1 =~ ^[[:digit:]]+$ ]];then
        return 0
    else
    # 否则提醒不是数字
        echo "Not a  digit"  
        return 1
    fi
}

 [root@oldboyedu-lnb ~]# cat score.sh
 #!/bin/bash
 source /data/functions
 read -p "Input your score:" SCORE
 func_is_digit $SCORE
 #判断上面的命令执行结果不等于0就退出
 if [ $? -ne 0 ];then
     exit
 else
     # 如果成功了，对成绩的三种判断如下。
     if [ $SCORE -lt 60 ];then
         echo "You are loser"
     elif [ $SCORE -lt 80 ];then
         echo "soso"
     else
         echo "very good"
     fi
 fi

 #!/bin/bash
 # Author:  liupengju
 # date:    2020-06-22
 # TEL:     xxxxxxxxxx
 # 代码发布与回滚
 set -e
 set -u
  
 # adx代码部署 定义变量
 ADX_DIR=/gnome/adx
 adx_new_version="gnome-adx-0.0.1-SNAPSHOT-jar-with-dependencies.jar"
 ADX_NEW_MD5=`md5sum $adx_new_version | awk '{ print $1 }'`
  
 # adx代码部署 cf平台的md5码
 ADX_CHK_MD5="43bcfe7594f083a8653126e0896b93ac"
  
 # directAd代码部署 定义变量
 direct_DIR=/gnome/directAd/
 direct_version="direct-ad-0.0.1-SNAPSHOT-jar-with-dependencies.jar"
 direct_MD5=`md5sum $direct_version | awk '{ print $1 }'`
 #direct_old_version=$(ls -l  |tail -n1 | awk '{print $9}')
  
 # directAd代码部署 cf平台的md5码
 direct_CHK_MD5="03c3c2fc62b2edfc92e548351010ee9f"
  
 ##########部署directAd代码#############################
 fun_copy_direct_code(){
     mv $direct_DIR/$direct_version  $direct_DIR/bak/${direct_version}_$(date +"%F-%T")
         echo "-----上一个版本已经移动到备份目录"
     cp /data/$direct_version  $direct_DIR  && echo "-----代码复制成功!!!"
 }
  
 fun_chk_direct_code(){
       if [[ "$direct_MD5" == "$direct_CHK_MD5" ]];then
            echo "-----代码校验成功" && echo "代码部署成功后MD5值为:$direct_MD5"
       else
            echo "-----代码校验失败" && exit
       fi
 }
  
 fun_deploy_direct_restart(){
     #$direct_DIR/restart.sh
     systemctl restart httpd
     systemctl restart nginx
     echo "后端服务重启成功!!!"
 }
 ​
 # 验证端口存活状态
 fun_chk_direct_port1(){
     PORT1=`ss -nlt|grep 8080 |awk -F"[[:space:]]+|:" '{ print $7}'`
     PORT2=`ss -nlt|grep 8182 |awk -F"[[:space:]]+|:" '{ print $7}'`
      for port in $PORT1 $PORT2;do
         echo "The port is:$port------监听端口正常"
      done
 }
 ​
 #############回滚directAd代码###################################
 fun_rollback_direct_code(){
     cd $direct_DIR/bak
 # 提取上一个版本的jar包
     direct_old_version=$(ls -l  |tail -n1 | awk '{print $9}')  
     mv $direct_DIR/${direct_version} $direct_DIR/bak/${direct_version}_$(date +"%F-%T")
     mv $direct_DIR/bak/${direct_old_version} $direct_DIR/${direct_version}
     echo "------旧版本代码移动成功"
     direct_old_MD5=$(md5sum $direct_DIR/${direct_version} |  awk '{print $1}')
     echo "代码回滚后MD5值为:$direct_old_MD5"
 }
  
 fun_rollback_direct_restart(){
     #$direct_DIR/restart.sh
     systemctl restart httpd
     systemctl restart nginx
     echo "--------后端服务重启成功"
 }
 ​
 # 验证端口存活状态 
 fun_chk_direct_port2(){
     PORT1=`ss -nlt|grep 8080 |awk -F"[[:space:]]+|:" '{ print $7}'`
     PORT2=`ss -nlt|grep 8182 |awk -F"[[:space:]]+|:" '{ print $7}'`
     for port in $PORT1 $PORT2;do
         echo "The port is:$port------端口监听正常"
     done
 }
 ​
 #####################adx代码部署########################################
 fun_copy_adx__code(){
     mv $ADX_DIR/$adx_new_version  $ADX_DIR/bak/${adx_new_version}_$(date +"%F-%T")
         echo "-----上一个版本已经移动到备份目录"
     cp /data/$adx_new_version  $ADX_DIR  && echo "-----代码复制成功!!!"
 }
  
 fun_chk_adx_code(){
     if [[ "$ADX_NEW_MD5" == "$ADX_CHK_MD5" ]];then
         echo "-----代码校验成功" && echo "代码部署成功后MD5值为:$ADX_NEW_MD5"
     else
             echo "-----代码校验失败" && exit
     fi
 }
  
 fun_deploy_adx_restart(){
     #$ADX_DIR/restart.sh
     systemctl restart httpd
     systemctl restart nginx
     echo "后端服务已经启动!!!"
 }
  
 # 验证端口存活状态
 fun_chk_adx_port1(){
     PORT1=`ss -nlt|grep 8080 |awk -F"[[:space:]]+|:" '{ print $7}'`
     PORT2=`ss -nlt|grep 8182 |awk -F"[[:space:]]+|:" '{ print $7}'`
       for port in $PORT1 $PORT2;do
           echo "The port is:$port------监听的端口正常启动"
       done
 }
  
 ###################################adx代码回滚###########################
 fun_rollback_adx_code(){
     cd $ADX_DIR/bak
     adx_old_version=$(ls -l  |tail -n1 | awk '{print $9}')
     mv $ADX_DIR/${adx_new_version} $ADX_DIR/bak/${adx_new_version}_$(date +"%F-%T")
     mv $ADX_DIR/bak/${adx_old_version} $ADX_DIR/${adx_new_version}
     echo "------旧版本代码移动成功"
     adx_old_MD5=$(md5sum $ADX_DIR/${adx_new_version} |  awk '{print $1}')
     echo "代码回滚后MD5值为:$adx_old_MD5"
 }
  
 fun_rollback_adx_restart(){
     #$ADX_DIR/restart.sh
     systemctl restart httpd
     systemctl restart nginx
     echo "--------后端服务已经启动"
 }
 ​
 # 验证端口存活状态
 fun_chk_adx_port2(){
     PORT1=`ss -nlt|grep 8080 |awk -F"[[:space:]]+|:" '{ print $7}'`
     PORT2=`ss -nlt|grep 8182 |awk -F"[[:space:]]+|:" '{ print $7}'`
     for port in $PORT1 $PORT2;do
         echo "The port is:$port-------端口监听正常"
     done
 }
  
 case $1 in
   direct_deploy)
      fun_copy_direct_code
      fun_chk_direct_code
      fun_deploy_direct_restart
      fun_chk_direct_port1
      ;;
   direct_rollback)
      fun_rollback_direct_code
      fun_rollback_direct_restart
      fun_chk_direct_port2
      ;;
   adx_deploy)
      fun_copy_adx__code
      fun_chk_adx_code
      fun_deploy_adx_restart
      fun_chk_adx_port1
      ;;
   adx_rollback)
     fun_rollback_adx_code
     fun_rollback_adx_restart
     fun_chk_adx_port2
      ;;
 esac

#!/bin/bash
# Auth:   liupenghui
# date:   2020-10-22
# TEL:    xxxxx
# 部署完成校验

fun_chk_adx_version(){
    ansible adx -m shell -a 'md5sum  
 /gnome/adx/gnome-adx-0.0.1-SNAPSHOT-jar-with-dependencies.jar' |awk '{print $1}'|sort |head -n62 |tee version_adx |cat -n    
adx_version=$(ansible adx -m shell -a 'md5sum /gnome/adx/gnome-adx-0.0.1-SNAPSHOT-jar-with-dependencies.jar'
 |awk '{print $1}'|sort |tail -n62 |uniq -c|awk '{print $2}')
    echo -e "\e[1;32m新发布的版本号为:$adx_version\e[0m"
    version1=$(diff metadata  version_adx)
        if [ -z $version1 ];then
           echo -e "\e[1;32m代码部署成功 \e[0m"
    else
           echo -e "\e[1;31m请检查错误  \e[0m"
    fi
}

fun_chk_direct_version(){ ansible adx -m shell -a ' md5sum /gnome/directAd/direct-ad-0.0.1-SNAPSHOT-jar-with-dependencies.jar'|awk '{print $1}'|sort |head -n62 |tee version_direct |
cat -n direct_version=$(ansible adx -m shell -a 'md5sum /gnome/directAd/direct-ad-0.0.1-SNAPSHOT-jar-with-dependencies.jar'|awk '{print $1}'|sort |tail -n62 |uniq -c|awk '{print $2}') echo -e "\e[1;32m
新发布的版本号为:$direct_version\e[0m" version2=$(diff metadata version_direct) if [ -z $version2 ];then echo -e "\e[1;32m
代码部署成功 \e[0m" else echo -e "\e[1;31m
请检查错误 \e[0m" fi } 
###验证8080端口状态############### 
fun_chk_8080_port(){ chk_ip_8080=$(ansible adx -m shell -a ' netstat -ntulp |grep 8080' |awk '{print $1}' |egrep "[0-9]+\.*" |sort | tee data_8080.bak |cat -n) 
DIR_8080=$(diff metadata data_8080.bak) if [ -z $DIR_8080 ];then echo -e "\e[1;32m端口检查成功,端口号:8080 \e[0m" else echo -e "\e[1;31m
请检查错误 \e[0m" fi } 
####验证8182端口状态############# 
fun_chk_8182_port(){ chk_ip_8182=$(ansible adx -m shell -a ' netstat -ntulp |grep 8182' |awk '{print $1}' |egrep "[0-9]+\.*" |sort |tee data_8182.bak |cat -n) DIR_8182=$(diff metadata data_8182.bak) if [ -z $DIR_8182 ];then echo -e "\e[1;32m
端口检查成功,端口号:8182 \e[0m" else echo -e "\e[1;31m
请检查错误 \e[0m" fi } case $1 in adx) fun_chk_adx_version fun_chk_8080_port fun_chk_8182_port ;; direct) fun_chk_direct_version fun_chk_8080_port fun_chk_8182_port ;; 
esac

/etc/profile
/etc/profile.d/*.sh
/etc/bashrc

~/.bash_profile 
~/.bashrc

/etc/profile --> /etc/profile.d/*.sh --> ~/.bash_profile --> ~/.bashrc --> /etc/bashrc

/etc/profile.d/*.sh --> /etc/bashrc --> ~/.bashrc

全局：/etc/profile, /etc/profile.d/*.sh
个人：~/.bash_profile

全局：/etc/bashrc
个人：~/.bashrc

[root@centos7 ~]# vim ~/.bash_logout
# ~/.bash_logout
rm -rf /data/test

/etc/profile -> (~/.bash_profile | ~/.bash_login | ~/.profile) -> ~/.bashrc -> /etc/bashrc -> ~/.bash_logout

~/.bash_history 
是bash shell的历史记录文件，里面记录了你在bash shell中输入的所有命令。

/etc/enviroment 是系统的环境变量，与登录用户无关，例如登录提示语言，没必要修改
/etc/profile    是所有用户的环境变量，与登录用户有关，变量冲突以用户的环境变量为准

 export PATH=$PATH:/opt/lamp/mysql/bin export CLASSPATH=./JAVA_HOME/lib;$JAVA_HOME/jre/lib

source /etc/profile   通知bash进程重新读取配置文件
. /etc/profile        执行配置文件
注销系统

set                  显示当前shell的变量，包括当前用户的变量（内部命令）
export               显示当前导出成用户变量的shell变量（内部命令）
env                  显示当前用户的环境变量（外部命令）
declare -x
printenv
echo $PATH  显示当前导出成用户变量shell的变量，包括当前用户的变量中的PATH

export [-fnp] [NAME]=[变量设置值]    当前导出成用户变量的shell变量
       -f 　               代表[NAME]中为函数名称。
       -n 　               删除指定的变量。变量实际上并未删除，只是不会输出到后续指令的执行环境中。
       -p 　               列出所有的shell赋予程序的环境变量。
Examples:
export MYENV=7             # 定义环境变量并赋值
export LANG=zh_CN.UTF-8    # 临时修改语言环境字符集中文

declare [-fFirx] [-p] [name[=value]]    显示所有shell变量（与 typeset 相同）
	    +/-       "-"可用来指定变量的属性，"+"则是取消变量所设的属性；
		  -p      将显示每个[name]的属性和值    
          -f      仅显示函数；
          -r      将[name]设置为只读；
          -x      指定的变量会成为用户环境变量，可供shell以外的程序来使用；env |grep [name]
          -i      [value]可以是数值，字符串或运算式。
		  -F      包含-f,禁止显示函数定义；只有函数名和属性会被显示
Examples:
declare -x MYENV=7                   # 定义环境变量并赋值
declare -i number=$RANDOM*100/32767  # 设置0~100之间的随机数变量number

shopt    列出当前shell中只能由shopt设置的选项
         cdspell       自动改正cd命令参数中的小错误
         hostcomplete  以@开头时，按tab键可进行主机名的自动完成
         dotgblob      以点开始的文件名被包含在路径名扩展中
         mailwarn      显示邮件警告信息
shopt -o 列出可由set命令设置的选项
         emacs         进入emacs编辑模式
         vi            进入vi编辑模式
         ignoreeof     不允许单独使用Ctrl+D退出的用法，要使用exit。与IGNOREEOF=10等价
         noclobber     不允许重定向覆盖已存在文件
         noglob        不允许扩展文件名通配符
         nounset       使用未定义的变量时给出错误
      -p 显示可设置选项及当前取值
      -s 设置每一选项为on
      -u 设置每一选项为off
      -q 不输出信息

set               显示所有shell变量
    -a            标示已修改的变量，导出至环境变量。echo $[name]
    -b            使被中止的后台程序立刻回报执行状态。
    -C            重定向所产生的文件无法覆盖已存在的文件。
    -d            Shell预设会用杂凑表记忆使用过的指令，以加速指令的执行。使用-d参数可取消。
    -e            若指令传回值不等于0，则立即退出shell。等同 set –o errexit
    -f            取消使用通配符。
    -h            自动记录函数命令的所在位置。hash下来
    -H,--history  可利用"!"加<指令编号>的方式来执行history中记录的指令。
    -k            指令所给的参数都会被视为此指令的环境变量。
    -l            记录for循环的变量名称。
    -m            使用监视模式。可以通过Job control来控制进程的停止、继续，后台或者前台执行等。
    -n            只读取指令，而不实际执行。
    -p            启动优先顺序模式。
    -P            启动-P参数后，执行指令时，会以实际的文件或目录来取代符号连接。
    -t            执行完随后的指令，即退出shell。
    -u            当执行时使用到未定义过的变量，则显示错误信息。等同 set –o nounset
    -v            显示shell所读取的输入值。
    -x            执行指令后，会先显示该指令及所下的参数
    -i，--interactive-comments  交互式 shell ，shell 脚本中默认关闭
    -B，braceexpand             大括号扩展命令，默认开启

unset [-f] [-v] [name ...]  删除shell变量 name
      -f                    仅删除函数
      -v                    仅删除变量

0~32767之间的随机整数

指定历史文件，默认为~/.bash_history

HISTTIMEFORMAT=“%F %T “ 显示时间

HISTIGNORE=“str1:str2*:… “ 忽略str1，str2开头的历史

         HISTCONTROL=            记录方式
            ignoredups             默认，忽略重复的命令，连续且相同为“重复”
            ignorespace            忽略所有以空白开头的命令
            ignoreboth             相当于 ignoredups,ignorespace 的组合
            erasedups              删除重复命令

LANG="en_US.UTF-8"
LANG="zh_CN.UTF-8"
Cent OS 6.x 配置文件
/etc/sysconfig/i18n
Cent OS 7.x 配置文件：
/etc/locale.conf
localectl set-locale LANG='en_US.UTF-8'

PS1 基本提示符 例如：export PS1="[\u@\h \w]\$ "
    \d ：代表日期，格式为weekday month date，例如：Wed Dec 12
    \H ：完整的主机名称。例如：hostname是debian.linux
    \h ：仅取主机的第一个名字，如上例，则为debian，.linux则被省略
    \t ：显示时间为24小时格式，如：HH：MM：SS
    \T ：显示时间为12小时格式
    \A ：显示时间为24小时格式：HH：MM
    \u ：当前用户的账号名称 如：root
    \v ：BASH的版本信息  如:3.2
    \w ：完整的工作目录名称。家目录会以~代替 如显示/etc/default/
    \W ：利用basename取得工作目录名称，只会列出最后一个目录。如上例则只显示default
    \# ：下达的第几个命令
    \$ ：提示字符，如果是root时，提示符为：# ，普通用户则为：$ 

                  stty              显示终端命令行的相关设置
                   -a              打印终端所有当前设置
	        iuclc              禁止输出大写，前加-开启
		olcuc              禁止输出小写，前加-开启
		size               打印出终端的行数和列数
		stty eof "string"  修改Ctrl+D快捷键
		echo               打开回显，前加-关闭
		igncr              忽略回车符，前加-关闭

当前用户的登录名 LANGUGE：
语言相关的环境变量，多语言可以修改此环境变量 MAIL：
当前用户的邮件存放目录 BASH：记录当前bash shell的路径。
BASH_SUBSHELL：记录当前子shell的层次。
BASH_SUBSHELL是从0开始计数的整数。
BASH_VERSINFO：是一个数组包含六个元素，这六个元素显示bash的版本信息。
BASH_VERSION：显示shell版本的信息。
DIRSTACK：记录了栈顶的目录值，初值为空。
GLOBLGNORE：是由冒号分割的模式列表，表示通配时忽略的文件名集合。
GROUPS：记录当前用户所属的组。
HOME：记录当前用户的家目录，由/etc/passwd的倒数第二个域决定。
HOSTNAME：记录主机名。
HOSTTYPE和MACHTYPE：都是记录系统的硬件架构。
IFS：用于设置指定shell域分隔符，默认情况下为空格。
OSTYPE:记录操作系统类型。
PPID：是创建当前进程的进程号，即当前进程的父进程号
RELY：REPLY变量与read和select有关。
SECONDS：记录脚本从开始到结束耗费的时间。
SHELL：显示当前所用的shell
SHELLOPTS：记录了处于“开”状态的shell选项列表，它只是一个只读变量。
SHLVL：记录了bash嵌套的层次，一般来说，我们启动第一个Shell时。$SHLVL=1。如果在这个Shell中执行脚本，脚本中的$SHLVL=2。
TMOUT：用来设置脚本过期的时间，比如TMOUT=3，表示该脚本3秒后过期。
UID: 已登用户的ID USER：显示当前用户名字

localectl list-locales      列出所有可用的 locale

localectl set-locale LANG=zh_CN.UTF-8 --- centos7修改字符集信息

export PS1='\[\e[36;1m\][\u@\h \W]\$ \[\e[1;37m\]'

#!/bin/bash

# 1
if [[ $# == 2 ]];then
  echo $1+$2=$(($1+$2))
  echo $1-$2=$(($1-$2))
  echo $1*$2=$(($1*$2))
  echo $1/$2=$(($1/$2))
  exit
fi
# 2
if [[ $# == 0 ]];then
  read -p "请输入参数1: " var1
  read -p "请输入参数2: " var2
  if [[ $var1 == "" || $var2 == "" ]];then
# 3
    var1=10
    var2=10
  fi
  echo $var1+$var2=$(($var1+$var2))
  echo $var1-$var2=$(($var1-$var2))
  echo $var1*$var2=$(($var1*$var2))
  echo $var1/$var2=$(($var1/$var2))
  exit
fi

echo 请输入2个参数!

rabbit_chook.sh

let

 #!/bin/bash
 read -p "please input head num: " head
 read -p "please input floot num: " floot
 let x=$floot/2-$head
 let y=$head-$x
 echo "rabbit=$x;chook=$y"

expr

 #!/bin/bash
 read -p "please input head num: " head
 read -p "please input floot num: " floot
 x=`expr $floot / 2 - $head`
 y=`expr $head - $x`
 echo "rabbit=$x;chook=$y"

$[ ]

#!/bin/bash
read -p "please input head num: " head
read -p "please input floot num: " floot
rabbit=$[(floot-2*head)/2]
chook=$[head-rabbit]
echo "rabbit=$rabbit;chook=$chook"

$(())

#!/bin/bash
read -p "please input head num: " head
read -p "please input floot num: " floot
rabbit=$((floot/2-head))
chook=$((head-rabbit))
echo "rabbit=$rabbit;chook=$chook"

#!/bin/bash
for a in {1..9};do
    for b in `seq 1 $a`;do
    let c=$a*$b ;echo -e "${a}x${b}=$c\t\c"
    done
    echo   
done

[root@oldboyedu-lnb ~]# sh 9x9.sh
1x1=1	
2x1=2	2x2=4	
3x1=3	3x2=6	3x3=9	
4x1=4	4x2=8	4x3=12	4x4=16	
5x1=5	5x2=10	5x3=15	5x4=20	5x5=25	
6x1=6	6x2=12	6x3=18	6x4=24	6x5=30	6x6=36	
7x1=7	7x2=14	7x3=21	7x4=28	7x5=35	7x6=42	7x7=49	
8x1=8	8x2=16	8x3=24	8x4=32	8x5=40	8x6=48	8x7=56	8x8=64	
9x1=9	9x2=18	9x3=27	9x4=36	9x5=45	9x6=54	9x7=63	9x8=72	9x9=81

#!/bin/bash
red="\033[1;41m  \033[0m"
yellow="\033[1;43m  \033[0m"
 
for i in {1..8};do
        if [ $[i%2] -eq 0 ];then
                for i in {1..4};do
                        echo -e -n "$red$yellow";
                done
                echo
        else
                for i in {1..4};do
                        echo -e -n "$yellow$red";
                done
                echo
        fi
done

#!/bin/bash
read -p "Please input a num: " num
if [[ $num =~ [^0-9] ]];then
        echo "input error"
else
        for i in `seq 1 $num` ;do
                xing=$[2*$i-1]
                for j in `seq 1 $[$num-$i]`;do
                        echo -ne " "
                done
                for k in `seq 1 $xing`;do
                        color=$[$[RANDOM%7]+31]
                        echo -ne "\033[1;${color};5m*\033[0m"
                done
                echo
        done
fi

[root@oldboyedu-lnb ~]# sh color_isosceles_triangle.sh
Please input a num: 5
    *
   ***
  *****
 *******
*********

systeminfo.sh

#! /usr/bin/sh
hn=`uname -nr | awk '{print $1}'`
ipv4=`ip route | grep -o 'src.*$' | awk '{print $2}'`
os=`cat /etc/redhat-release`
ke=`uname -nr | awk '{print $2}'`
cpu=`lscpu | grep 'Ven.*' | awk '{print $3}'`
me=`free -h | tail -1 | awk '{print $2}'`
sda=`fdisk -l | head -2 | awk '{print $3}' | tail -1`
echo "hostname:$hn"
echo "IPv4:$ipv4"
echo "OS version:$os"
echo "Kernel version:$ke"
echo "CPU model:$cpu"
echo "SWAP size:$me"
echo "Disk size:$sda G"

#!/usr/bin/env bash
# ------------------------------------------
# Filename: hello.sh
# Revision: 1.0
# Date: 2020/10/21
# Author: wu
# Email: wu@gmail.com
# Description: This is the first script
# Copyright (C): 2020 All rights reserved
# License: GPL
# ------------------------------------------
# RED is content color
# REDD is content color
RED="\033[1;31m"                                                     
REDD="\033[0m"
echo -e OS Version is $RED`cat /etc/centos-release`$REDD
echo -e Disk used is $RED`df | grep /dev/sd | tr -s " " |cut -d" " -f5 | sort -nr | head -n1`$REDD
echo -e Kernel is $RED`uname -r`$REDD
echo -e "Host name  is  $RED`hostname`"$REDD

#!/usr/bin/env bash
# ------------------------------------------
# Filename: hello.sh
# Revision: 1.0
# Date: 2020/10/21
# Author: wu
# Email: wu@gmail.com
# Description: create script and start
# Copyright (C): 2020 All rights reserved
# License: GPL
# ------------------------------------------
if [ $# -lt 1 ]; then
     echo '至少应该给一个参数！'
     exit 1
fi
cat > $1 <<EOF
#!/usr/bin/env bash
# ------------------------------------------
# Filename: $1
# Revision: 1.0
# Date: `date +%F`
# Author: wu
# Email: wu@gmail.com
# Description: This is the $1 script
# Copyright (C): 2020 All rights reserved
# License: GPL
# ------------------------------------------

EOF
chmod +x $1
vim + $1

#! /usr/bin/sh
if [[ ! -d '/backup' ]]; then
    mkdir /backup
fi
cp -af /etc/ /backup/etc$(date -d 'today' +'%Y%m-%d')
echo "/etc/已备份"

chmod u+x backup.sh
echo '00 0 9 * * * root /root/backup.sh #每天早上九点执行backup.sh该文件' >> /etc/crontab

#! /usr/bin/sh
getent passwd | grep -v /sbin/nologin

#! /usr/bin/sh
getent passwd | sort -t: -k3 -nr | head -n1

#! /usr/bin/sh
ps aux | sort -k4 -nr | head -n1

#! /usr/bin/sh
echo `df|egrep -o '[0-9]{1,3}%'|sort -nr|head -1`

#! /usr/bin/sh
echo `netstat -nt | awk '{print $4}' | egrep '[0-9.]' | cut -d: -f1 | sort | uniq -c | sort -nr`

#! /usr/bin/sh
echo `cut -d: -f3 /etc/passwd | sed -n '10p;20p' | awk '{sum += $1};END {print sum}'`

#! /usr/bin/sh
echo `cat $1 $2 | sed -n '/^$/p' | wc -l`

#! /usr/bin/sh
# c is Number of parameters
c=3
echo "`ll /etc /var /usr | wc -l` -($c*2+($c-1))" | bc

#! /usr/bin/sh
if [ $# -lt 1 ]; then
     echo '至少应该给一个参数！'
     exit 1
fi
cat $1 | sed -n '/^$/p' | wc -l

#! /usr/bin/sh
if [ $# -lt 1 ]; then
     echo '至少应该给一个参数！'
     exit 1
fi
if ping -c1 -W2 $1; then
     echo '该IP地址可访问'
else
     echo '该IP地址不可访问'
fi

#! /usr/bin/sh
ping -c1 -W2 $1
[ $? -eq 0 ] && echo '该IP地址可访问' || echo '该IP地址不可访问'

#!/bin/bash
NUM=`seq 1 254`

for IP in ${NUM};do
   HOST_IP="192.168.0.${IP}"
   ping -c 2 -w 3 ${HOST_IP} &> /dev/null
   if [ $? -eq 0 ];then
      echo "success!" && echo ${HOST_IP} >> /tmp/ip_success.txt
   else
      echo "fail!"  && echo ${HOST_IP} >> /tmp/ip_fail.txt
   fi
done

#!/bin/bash
IP=192.168.0
NUM=1

while [ $NUM -lt 255 ];do
  ping -c2 -W2 $IP.$NUM &> /dev/null
  if [ $? -eq 0 ];then
     echo "$IP.$NUM success!"
  else
     echo "$IP.$NUM fail!"
  fi
  let NUM++
done

#! /usr/bin/sh
sd=`df | egrep -o '[0-9]{1,3}%' | sort -nr | head -1 | egrep -o '[0-9]{1,3}'`
inode=`df -ih | egrep -o '[0-9]{1,3}%' | sort -nr | head -1 | egrep -o '[0-9]{1,3}'`
if [ $sd -gt 80 -o $inode -gt 80 ]; then
     wall 'Disk space will be full!'
else
     echo '磁盘分区空间和inode使用率正常'
fi

echo "*/10 * * * 1-5 /usr/bin/bash /server/script/checkdisk.sh" >> /var/spool/cron/root

#! /usr/bin/sh
sd=`df | egrep -o '[0-9]{1,3}%' | sort -nr | head -1`
cpu=`cat /proc/stat|grep '^cpu[0-9]'|awk '{used+=$2+$3+$4;tolused+=$2+$3+$4+$5+$6+$7+$8} END{printf ("%.0f",used/tolused*100)}'`
mem=`free -t | tail -1 | awk '{printf ("%.0f",$3/$2*100)}'`

if [ ${sd%\%} -gt 80 ]; then
    wall 'Disk space will be full!'
elif [ $inode -gt 80 ]; then
    wall 'CPU space will be full!'
elif [ $mem -gt 80 ]; then
    wall 'Mem space will be full!'
fi

echo "*/10 * * * * /usr/bin/bash /server/script/checkdisk.sh" >> /var/spool/cron/root

#!/bin/bash
while true;do
  awk '/Failed/{ip[$(NF-3)]++}
  END {
        for(i in ip)
        {
          if(ip[i]>=2)
          {
            system("echo sshd:"i" >> /etc/hosts.deny")
          }
        }
      }' /var/log/ssh.log
  sleep 5m
done

#!/bin/bash
while true;do
# 收集IP出现失败的次数
  ipnum=`awk '/Failed/{print $(NF-3)}'  /var/log/ssh.log  |uniq -c |awk '{print $1}'` 
# 统计IP地址
  ip=`awk '/Failed/{print $(NF-3)}'  /var/log/ssh.log  |uniq -c |awk '{print $2}'`
# 当IP地址出现次数大于等于3，将IP地址拉入黑名单。
  if [ $ipnum -ge 3 ] ;then
     echo "sshd:$ip" >> /etc/hosts.deny
  fi
  sleep 5m
done
执行方式：sleep 5分钟或者加入计划任务，每5分钟执行一次
$ crontab -l
*/5 * * * *  /server/script/checkip.sh

#!/bin/bash
# environment variable 
source /etc/profile 
iplist=$(ss -tan | awk -F "[[:space:]]+|:" '/ESTAB/{ip[$(NF-2)]++}END{
   for(i in ip)
   {print i,ip[i]}
  }' | awk '{if($2>100)print $1}')
for ip in $iplist
do
  iptables -I INPUT -s $ip -j DROP
  echo "$ip is drop!"
done

加入计划任务，每5分钟执行一次

$ crontab -l
*/5 * * * *  /server/script/checkDOS.sh

#! /usr/bin/sh
if [ -r $1 -a -w $1 ]; then
    echo "$1并非不可读并且不可写"
else
    echo "$1不可读并且不可写"
fi

#! /usr/bin/sh
if [[ -f $1 && `echo "$1" | cut -d. -f2` = sh ]]; then
    chmod a+x $1
else
    echo "$1非脚本文件"
fi

#! /usr/bin/sh
echo "System maintenance, no login." > /etc/nologin

#! /usr/bin/sh
\mv /etc/nologin /root/nologin

#! /usr/bin/sh
if id $1 &> /dev/null; then
    id $1
else
    useradd $1
    id $1
fi

#!/bin/bash
id $1 &> /dev/null
if [ $? -eq 0 ]; then
    id $1
else
    useradd -d $2 $1
    id $1
fi

#! /usr/bin/sh
read -p "Please input:yes/no: " name
if [ $name = yes ]; then
    echo 'You input: yes'
elif [ $name = no ]; then
    echo 'You input: no'
else
    echo 'You input: other info'
fi

#! /usr/bin/sh
if [ $# -lt 1 ]; then
    echo '至少应该给一个参数！'
    exit 1
elif [ -L $1 ]; then
    echo '$1 is a Symbolic link'
elif [ -d $1 ]; then
    echo '$1 is a directory'
elif [ -f $1 ]; then
    echo '$1 is a normal file'
else
    echo '$1 is a other file type'
fi

#! /usr/bin/sh
if [ $# -lt 1 ]; then
    echo '至少应该给一个参数！'
    exit 1
fi
if expr $1 + 1 &> /dev/null; then
    if [ $1 -ge 0 ]; then
    	echo "$1是正整数"
    fi
else
    echo "$1不是正整数"
fi

#! /bin/bash
if [ $# -gt 1  ];then
  echo "只能判断一个参数!"
  exit
fi
if [[ -z $1 ]];then
  echo "输入为空"
  exit
fi
if [[ $1 =~ ^[0-9-]?[0-9]+$ ]];then
  echo "输入为整数"
  exit
fi
echo "输入不是整数"

#! /usr/bin/sh
echo "export PATH=$PATH:/usr/local/apache/bin" >> /etc/profile
source /etc/profile

 rm='rm –i' cdnet='cd /etc/sysconfig/network-scripts/'

editnet='vim /etc/sysconfig/network-scripts/ifcfg-eth0'

editnet='vim /etc/sysconfig/network-scripts/ifcfg-eno16777736 或 ifcfg-ens33' (如果系统是CentOS7)

#! /usr/bin/sh
cat <<EOF>> /etc/profile
export PS1="\e[31m[\u@\h \W]\$ \e[0m"
alias rm='rm –i'
alias cdnet='cd /etc/sysconfig/network-scripts/'
alias editnet='vim /etc/sysconfig/network-scripts/ifcfg-eth0'
EOF

#! /usr/bin/sh
echo 'echo -e "\e[1;31mHi,dangerous！\e[0m"' >> /etc/profile

#!/bin/bash
if [[ $1 =~ ^[Oo][Nn]$ ]]; then
  sed -i 's/^SELINUX=.*/SELINUX=enforcing/' /etc/selinux/config &>/dev/null
  setenforce 1 &>  /dev/null 
elif [[ $1 =~ ^[Oo][Ff][Ff]$ ]]; then
  sed -i 's/^SELINUX=.*/SELINUX=disabled/' /etc/selinux/config &>/dev/null 
  setenforce 0 &>/dev/null
else
  echo "you are error,please input on or off !!!"
fi

#!/bin/bash
DATE=`date +%Y%m%d`
filename="ganglia-${DATE}.log"
prefix="ganglia-${DATE}"
hosts=`grep test@ /tmp/log/ganglia/${filename} | wc -l`
pids=`grep gmond.pid /tmp/log/ganglia/${filename} | wc -l`
if [ ${hosts} != 10 ]
then
    echo "Some hosts are offline!" >> /tmp/log/ganglia/error-${DATE}.log
fi

if [ ${hosts} != ${pids} ]
then
    echo "Some ganglia services have stopped!" >> /tmp/log/ganglia/error-${DATE}.log
    cd /tmp/log/ganglia/
    csplit /tmp/log/ganglia/${filename} /test@/ -n2 -s {*} -f ${prefix} -b ".log.%02d"
    rm ${prefix}.log.00
    for file in /tmp/log/ganglia/${prefix}.log.*
    do 
    if [ -f "${file}" ]
    then
        #echo "${file} is file"
        if [ `grep gmond.pid ${file} | wc -l` == 0 ]
        then
            echo `grep test@ ${file}` >> /tmp/log/ganglia/error-${DATE}.log
        fi
    fi
    done
fi

[root@linuxcool ~]# crontab -l 

0 0 * * * /usr/bin/parallel-ssh -h /home/test/hosts.txt -t 30 -i 'ps aux | grep gmond' > /tmp/log/ganglia/ganglia-`date +\%Y\%m\%d`.log

10 0 * * * /bin/bash /home/test/checkganglia.sh

tr [OPTION]... SET1 [SET2] 转换和删除字符
   -c –C --complement      取字符集的补集
   -d --delete             删除SET1的字符
   -s --squeeze-repeats    把连续重复的字符以单独一个字符表示
   -t --truncate-set1      将SET1转化为SET2
tr -d a < filename         删除文件filename标准输出中的a
tr -s '\n' < filename      删除文件filename标准输出中的空行
cat filename |tr a-z A-Z       将文件filename中标准输出的小写字母全部转换成大写字母
or
cat filename |tr [:lower:] [:upper:] 	
tr -cd '0-9a-zA-Z' < /dev/urandom | head -c8  # 生成8位随机数

wc story.txt
39 237 1901 story.txt
行数 字数 字节数
常用选项
-l 只计数行数
-w 只计数单词总数
-c 只计数字节总数
-m 只计数字符总数
-L 显示文件中最长行的长度

uniq命令：从输入中删除前后相接的重复的行
uniq [OPTION]... [FILE]...
-c: 显示每行重复出现的次数
-d: 仅显示重复过的行
-u: 仅显示不曾重复的行
注：连续且完全相同方为重复
常和sort 命令一起配合使用：
sort userlist.txt | uniq -c

-r 执行反方向（由上至下）整理
-R 随机排序
-n 执行按数字大小整理
-f 选项忽略（fold）字符串中的字符大小写
-u 选项（独特，unique）删除输出中的重复行
-t c 选项使用c做为字段界定符
-k X 选项按照使用c字符分隔的X列来整理能够使用多次

$echoYourcost:\$5.00
Yourcost:$5.00

$（美元符号）－变量扩展
（反引号）－命令替换
\（反斜线）－禁止单个字符扩展，转义单个字符
!（叹号）－历史命令替换

 nohup python3.5 test.py --redis --port --mysql --port -a xxxx &

ps axu|grep test.py |grep -v grep|awk '{print $2}'|xargs kill -9

  oldboy_age=18    # 全小写
  OLDBOY_AGE=25	   # 全大写 系统环境变量都大写
  oldboy_Age=30    # 小驼峰语法
  Oldboy_Age=35    # 大驼峰语法
  变量值的定义:  数字 字符串 和命令

  [root@shell ~]# test='I am lizhenya'	
  [root@shell ~]# oldboy_age=45
  [root@shell ~]# test=`pwd`		# 定义命令
  [root@shell ~]# echo $test		
  /root
  [root@shell ~]# test=$(ls)		# 定义命令
  [root@shell ~]# echo $test
  [root@shell ~]# ls
  test.sh

  [root@shell ~]# date
  Thu Oct 15 11:46:55 CST 2020
  [root@shell ~]# time=`date`
  [root@shell ~]# echo $time
  Thu Oct 15 11:47:00 CST 2020
  [root@shell ~]# echo $time
  Thu Oct 15 11:47:00 CST 2020
  [root@shell ~]# time="date +%F+%M+%S"

  $0
   [root@shell ~]# cat test.sh
     #!/bin/sh
     #print   hello world
     #Author  oldboy
     #date    20202020
     #version v1.0
       echo "Hello World!"
       echo $0
  [root@shell ~]# sh test.sh 
  Hello World!

$n # 代表了脚本的第n的参数 n为数字 如果是0呢 则为脚本名称 从1开始 从$9以后需要加{} 表示整体
-gt 是否大于
-ge 是否大于等于
-eq 是否等于
-ne 是否不等于
-lt 是否小于
-le 是否小于等于

[root@shell ~]# cat test.sh 
[ $# -ne 2 ] && echo "请输入两个参数" && exit
expr $1 + $2
[ $# -ne 2 ] && echo "请输入两个参数" && exit
echo $1
echo $2

[root@shell ~]# cat ping.sh 
ping -c2 -W1  www.baiduaaaaa.com &>/dev/null
[ $? -ne 0 ] && echo "ping不通" || echo "通了"

[root@shell ~]# cat test.sh 
#!/bin/sh
#print   hello world
#Author  oldboy
#date    20202020
#version v1.0
echo $$ > /tmp/nging.pid
sleep 300

$$      # 获取当前脚本的PID
$#      # 表示脚本传参的个数
$n 		  # 代表了脚本的第n的参数 n为数字 如果是0呢 则为脚本名称 从1开始 从$9以后需要加{} 表示整体
$0      #脚本名称
$?      # 判断上一条命令的结果是否正确 0为正确 非0失败
$!      # 获取上一个在后台运行脚本的PID号 排错使用
$_		  # 获取当前命令行的最后一个参数 类似于esc .
$*		  # 获取脚本传参的所有参数 在循环体中 不加双引号和$@相同 加双引号 把所有的参数当做一个参数	
$@      # 获取脚本传参的素有参数 在循环体中 不加双引号和$*相同 加双引号 把所有的参数当做独立的

[root@shell ~]# cat read.sh 
#!/bin/bash
read -p "请输入你的姓名: " name
echo "你输入的姓名是 $name"
[root@shell ~]# cat read.sh 
#!/bin/bash
read -p "请输入你的姓名和年龄: " name age
echo "你输入的姓名是: $name 年龄是: $age"
[root@shell ~]# sh read.sh
请输入你的姓名和年龄: oldboy 20
你输入的姓名是: oldboy 年龄是: 20
[root@shell ~]# cat read.sh
#!/bin/bash
read -p "请输入你的姓名: " name 
read -p "请输入你的年龄: " age
echo "你输入的姓名是: $name 年龄是: $age"
[root@shell ~]# sh read.sh
请输入你的姓名: oldboy
请输入你的年龄: 20
你输入的姓名是: oldboy 年龄是: 20
案例: 使用read传参的方式 修改主机名称为shell 并且修改eth0网卡IP地址为88
[root@shell ~]# cat hostname.sh 
#!/bin/bash
eth0_cfg='/etc/sysconfig/network-scripts/ifcfg-eth0'
old_ip=`ifconfig eth0|awk 'NR==2{print $2}'|awk -F. '{print $NF}'`
read -p "please input hostname: " name
read -p "please input New IP: " IP
hostnamectl set-hostname $name
sed -i "s#$old_ip#$IP#g" $eth0_cfg
grep $IP $eth0_cfg

[root@shell ~]# cat ping.sh 
read -p "Please Input URL: " url
ping -c2 -W1  $url &>/dev/null
[ $? -ne 0 ] && echo "ping不通" || echo "通了"
重复赋值
[root@shell ~]# cat dir.sh
#!/bin/sh
dir1=/etc
dir2=/tmp
read -p "请输入需要备份的目录: " dir2
echo $dir1
echo $dir2
[root@shell ~]# sh dir.sh
请输入需要备份的目录: /opt
/etc
/opt

nginx
[root@shell ~]# echo ${test:2:2}
am
[root@shell ~]# echo ${#test}
11

[root@shell ~]# echo $test|wc -L
11
[root@shell ~]# expr length "$test"
11
[root@shell ~]# echo $test|awk '{print length}'
11

I am lzhenya teacher I am 18
[root@shell ~]# cat for.sh
for i in I am lzhenya teacher I am 18
do
		[ ${#i} -lt 3 ] && echo $i
done	
[root@shell ~]# sh for.sh
I
am
I
am
18
[root@shell ~]# echo I am lzhenya teacher I am 18|xargs -n1|awk '{if(length<3)print}'
I
am
I
am
18

[root@shell ~]# echo I am lzhenya teacher I am 18|awk '{for(i=1;i<=NF;i++)if(length($i)<3)print $i}' I am I am 18

[root@shell ~]# echo ${url}
www.baidu.com	
[root@shell ~]# echo ${url}|awk -F "w." '{print $3 }'
baidu.com
[root@shell ~]# echo ${url}
www.baidu.com
[root@shell ~]# echo ${url#www.}
baidu.com
[root@shell ~]# echo ${url#*.}
baidu.com
[root@shell ~]# echo ${url#*.*.}
com

[root@shell ~]# echo ${url##*.}
com
[root@shell ~]# echo ${url%.com}
www.baidu
[root@shell ~]# echo ${url%.*}
www.baidu
[root@shell ~]# echo ${url%.*.*}
www
[root@shell ~]# echo ${url%%.*}
www
[root@shell ~]# test=%66
[root@shell ~]# echo $test
%66
[root@shell ~]# echo ${test#%}
66
[root@shell ~]# echo ${test##}
#66
[root@shell ~]# echo ${test#\#}
66

[root@shell ~]# echo $url www.baidu.com 
[root@shell ~]# echo $url|sed 's#www#WWW#g' WWW.baidu.com 
[root@shell ~]# echo $url www.baidu.com 
[root@shell ~]# echo ${url/w/W} Www.baidu.com 
[root@shell ~]# echo ${url//w/W} WWW.baidu.com 
[root@shell ~]# echo ${url/baidu/sina} www.sina.com
[root@shell ~]# expr 1 +1
expr: syntax error
[root@shell ~]# expr 10 - 5
5
[root@shell ~]# expr 10 * 5
expr: syntax error
[root@shell ~]# expr 10 \* 5
50
[root@shell ~]# expr 10 / 5
2
[root@shell ~]# expr length oldboy	# 统计字符串长度
6

[root@shell ~]# echo $[1+1]
2
[root@shell ~]# echo $[1+1.5]
-bash: 1+1.5: syntax error: invalid arithmetic operator (error token is ".5")
[root@shell ~]# echo $[1+10]
11
[root@shell ~]# echo $[1-10]
-9
[root@shell ~]# echo $[100*10]
1000
[root@shell ~]# echo $[100/10]
10
[root@shell ~]# #100*10=1000
[root@shell ~]# echo 100*10=1000
100*10=1000
[root@shell ~]# echo 100*10=$[100*10]
100*10=1000
[root@shell ~]# num1=100
[root@shell ~]# num2=10
[root@shell ~]# echo $num1*$num2
100*10
[root@shell ~]# echo $num1*$num2=$[$num1*$num2]
100*10=1000

  [root@shell ~]# echo $((1+1))
   2
  [root@shell ~]# echo $((1+1.5))
  -bash: 1+1.5: syntax error: invalid arithmetic operator (error token is ".5")
  [root@shell ~]# echo $((100-100))
  0
  [root@shell ~]# echo $((100*100))
  10000
  [root@shell ~]# echo $((100/100))
  1

[root@shell ~]# let sum=1+1
[root@shell ~]# echo $sum
2
[root@shell ~]# let sum=100-100
[root@shell ~]# echo $sum
0
[root@shell ~]# let sum=100*100
[root@shell ~]# echo $sum
10000
[root@shell ~]# let sum=100/100
[root@shell ~]# echo $sum
1
[root@shell ~]# let sum=$num1+$num2
[root@shell ~]# echo $sum
110
[root@shell ~]# let i++
[root@shell ~]# echo $i
1
[root@shell ~]# let i++
[root@shell ~]# echo $i
2
[root@shell ~]# let i++
[root@shell ~]# echo $i
3
[root@shell ~]# echo i++ ===== i=i+1
i++ ===== i=i+1
[root@shell ~]# unset i
[root@shell ~]# let i=i+1
[root@shell ~]# echo $i
1
[root@shell ~]# let i=i+1
[root@shell ~]# echo $i
2
[root@shell ~]# let i++
[root@shell ~]# let i++
[root@shell ~]# let i++

[root@shell ~]# echo 10*10|bc
100
[root@shell ~]# echo 10/10|bc
1
[root@shell ~]# echo 10-10|bc
0
[root@shell ~]# echo 10+10|bc
20
[root@shell ~]# echo 10+10.2|bc
20.2
[root@shell ~]# echo 10.5+10.2|bc
20.7
[root@shell ~]# echo 10.5*10.2|bc
107.1

[root@shell ~]# awk 'BEGIN{print 10*10}'
100
[root@shell ~]# awk 'BEGIN{print 10-10}'
0
[root@shell ~]# awk 'BEGIN{print 10/10}'
1
[root@shell ~]# awk 'BEGIN{print 10+10}'
20
[root@shell ~]# awk 'BEGIN{print 10^10}'
10000000000
[root@shell ~]# echo 10 10|awk '{print $1*$2}' 
100
[root@shell ~]# echo 10 10|awk '{print $1^$2}' 
10000000000

  10+10=20
  10-10=
  10*10=
  10/10=
[root@shell ~]# cat count.sh 
#!/bin/sh
[ $# -ne 2 ] && echo "输入两个参数多了不行" && exit

echo $1+$2=$[$1+$2]
echo $1-$2=$[$1-$2]
echo $1*$2=$[$1*$2]
echo $1/$2=$[$1/$2]

 num1=$1 num2=$2 
echo $num1+$num2=$[$num1+$num2] 
echo $num1-$num2=$[$num1-$num2] 
echo $num1*$num2=$[$num1*$num2]
 echo $num1/$num2=$[$num1/$num2] 

" num1 num2 echo $num1+$num2=$[$num1+$num2] 
echo $num1-$num2=$[$num1-$num2] 
echo $num1*$num2=$[$num1*$num2] 
echo $num1/$num2=$[$num1/$num2]

[root@shell ~]# test -e /etc/passwd
[root@shell ~]# echo $?
0
[root@shell ~]# test -e /etc/passwd;echo $?
0
[root@shell ~]# test -e /etc/passwdddddddd;echo $?
1
[root@shell ~]# test -e /etc/passwd && echo "文件存在" || echo "文件不存在"
文件存在
[root@shell ~]# test -f /etc/passwd && echo "文件存在" || echo "文件不存在"
文件存在
[root@shell ~]# test -d /etc/passwd && echo "文件存在" || echo "文件不存在"
0 文件不存在
[root@shell ~]# test -x /etc/passwd && echo "文件存在" || echo "文件不存在"
文件不存在
[root@shell ~]# test -r /etc/passwd && echo "文件存在" || echo "文件不存在"
文件存在
[root@shell ~]# test -w /etc/passwd && echo "文件存在" || echo "文件不存在"
文件存在
[root@shell ~]# [ -e /etc/hosts ] && echo "文件存在" || echo "文件不存在"
文件存在
[root@shell ~]# [ -f /etc/hosts ] && echo "文件存在" || echo "文件不存在"
文件存在
[root@shell ~]# [ -d /etc/hosts ] && echo "文件存在" || echo "文件不存在"
文件不存在
[root@shell ~]# [ -d /etc/ ] && echo "文件存在" || echo "文件不存在"
文件存在
[root@shell ~]# [ -r /etc/ ] && echo "文件存在" || echo "文件不存在"
文件存在
[root@shell ~]# [ -w /etc/hosts ] && echo "文件存在" || echo "文件不存在"
文件存在
[root@shell ~]# [ -x /etc/hosts ] && echo "文件存在" || echo "文件不存在"
文件不存在
[root@shell ~]# [ -x test.sh ] && echo "文件存在" || echo "文件不存在"
文件存在
判断中可以使用命令的方式进行取值判断
[root@shell ~]# [ -f `ls test.sh` ]
使用and和or判断多个文件
[root@shell ~]# [ -f /etc/hosts -a -f /etc/passwd ]
[root@shell ~]# [ -f /etc/hosts -a -f /etc/passwd ] && echo "文件存在" || echo "文件不存在"
文件存在
[root@shell ~]# [ -f /etc/hostsss -a -f /etc/passwd ] && echo "文件存在" || echo "文件不存在"
文件不存在
[root@shell ~]# [ -f /etc/hostsss -o -f /etc/passwd ] && echo "文件存在" || echo "文件不存在"
文件存在
[root@shell ~]# [ -f /etc/hostsss -o -f /etc/passwddd ] && echo "文件存在" || echo "文件不存在"
文件不存在

使用变量赋值一个目录,判断目录是否存在,如果存在则打包压缩,如果不存在则提示目录不存在
[root@shell ~]# dir=/etc/;[ -d $dir ] && tar zcvf test.tar.gz $dir || echo "文件不存在"

[root@shell ~]# [ -d /hehe ] && mkdir hehe 
[root@shell ~]# ll hehe ls: cannot access hehe: No such file or directory 
[root@shell ~]# ll /hehe ls: cannot access /hehe: No such file or directory 
[root@shell ~]# [root@shell ~]# [ -d hehe ] && mkdir hehe 
[root@shell ~]# ll hehe ls: cannot access hehe: No such file or directory 
[root@shell ~]# [ -d hehe ] || mkdir hehe
[root@shell ~]# ll hehe total 0

[root@shell ~]# cat test.sh 
#!/bin/sh
[ -f /etc/init.d/functions ] && . /etc/init.d/functions
ping -c2 $1 &>/dev/null
[ $? -eq 0 ] && action "ping $1 is ok" true || action "ping $1 is error" false

  [root@shell ~]# [[ $user =~ ^r ]] && echo "成立" || echo "不成立"
  成立
  [root@shell ~]# [[ user =~ ^r ]] && echo "成立" || echo "不成立"
  不成立
  [root@shell ~]# [[ user =~ user ]] && echo "成立" || echo "不成立"
  成立
  [root@shell ~]# [[ user =~ r$ ]] && echo "成立" || echo "不成立"
  成立
  [root@shell ~]# [[ user =~ r$ && oldboy =~ ^o ]] && echo "成立" || echo "不成立"
  成立
  [root@shell ~]# [[ user =~ r$ && oldboy =~ ^a ]] && echo "成立" || echo "不成立"
  不成立
  [root@shell ~]# [[ user =~ r$ || oldboy =~ ^a ]] && echo "成立" || echo "不成立"
  成立
  [root@shell ~]# [[ $num1 =~ ^[0-9]+$ ]] && echo "成立" || echo "不成立"
  不成立
  [root@shell ~]# cat count.sh 
  #!/bin/sh
  [ $# -ne 2 ] && echo "请输入两个参数" && exit
  [[ ! $1 =~ ^[0-9]+$ ]] && echo "请输入整数" && exit 
  [ $1 -gt $2 ] && echo "$1>$2"
  [ $1 -lt $2 ] && echo "$1<$2"
  [ $1 -eq $2 ] && echo "$1=$2"

[root@shell ~]# cat menu.sh 
#!/bin/sh
while true
do
                echo -e "\t\t\t##################"
		echo -e "\t\t\t#1. INSTLL PHP7.1#"
		echo -e "\t\t\t#2. INSTLL PHP7.2#"
		echo -e "\t\t\t#3. INSTLL PHP7.3#"
		echo -e "\t\t\t#4. INSTLL PHP7.4#"
		echo -e "\t\t\t#5. INSTLL MySQL #"
		echo -e "\t\t\t#6. exit         #"
		echo -e "\t\t\t##################"
		read -p "请输入需要安装的PHP的序号[1|2|3]: " num
		if [ $num -eq 1 ];then
		   echo yum7.1....................
		elif [ $num -eq 2 ];then
		   echo yum7.2...................
		elif [ $num -eq 3 ];then
		   echo yum7.3...................
		elif [ $num -eq 4 ];then
		   echo yum7.4...................
	elif [ $num -eq 5 ];then
	   echo MySQL...................
	elif [ $num -eq 6 ];then
	   exit
	fi
done

 [root@shell ~]# cat os_menu.sh 
	#!/bin/sh
	menu(){
	cat<<EOF
							1 f.  查看系统内存	
							2 u.  查看CPU负载
							3 w.  查看当前用户
							4 d.  查看当前磁盘
							5 e.  exit
							6 h.  显示当前菜单
	EOF
	}
	menu
	while true
	do
		read -p "请输入要查看系统信息的编号或字母[1|f]: " num
		if [ $num = 1 -o $num = "f" ];then
		   free -h
		elif [ $num = 2 -o $num = u ];then 
		   uptime
		elif [ $num = 3 -o $num = w ];then
		   w
		elif [ $num = 4 -o $num = d ];then
		   df -h
		elif [ $num = 6 -o $num = h ];then
		   menu
		else
		   exit
		fi
	done

case 变量 in
	  匹配变量1)
	     执行命令序列
		 ;;
      匹配变量2)
	     执行命令序列
		 ;;
	  匹配变量3)
	     执行命令序列
		 ;;
	  *)
	     执行命令序列
esac

 [root@shell ~]# cat case.sh 
	#!/bin/bash
	menu(){
	cat<<EOF
					d. 查看磁盘
					f. 查看内存
					w. 查看用户
					u. 查看负载
					h. 显示菜单
					e. 退出脚本
	EOF
	}
	menu
	while true
	do
		read -p "请输入内容[d|f|w]: " test
		case $test in
			   d)
				 df -h
			   ;;
			   f)
				 free -h
			   ;;
			   w)
				 w
			   ;;
			   h)
				 clear
				 menu
			   ;;
			   *)
				echo "请输入菜单显示的系统项"
		esac
	done

 [root@shell ~]# cat jumpserver.sh
 #!/bin/sh
 . /etc/init.d/functions
 WEB01=10.0.0.7
 WEB02=10.0.0.8
 LB01=172.16.1.5
 LB02=10.0.0.6
 MySQL=10.0.0.51
 NFS=10.0.0.31
 BACKUP=10.0.0.41
 menu1(){
 cat<<EOF
                         1. 运维
                         2. 开发
                         3. 测试   
                         4. 菜单
 EOF
 }
 menu1
 menu(){
 cat<<EOF
                         1. WEB01-10.0.0.7
                         2. WEB02-10.0.0.8
                         3. LB01-10.0.0.5
                         4. LB02-10.0.0.6
                         5. MySQL-10.0.0.51
                         6. NFS-10.0.0.31
                         7. 显示菜单
                         8. 返回上一级菜单
 EOF
 }
 menu2(){
 cat<<EOF
                         1.MySQL-10.0.0.51
                         2.LB01-10.0.0.5
                         3.显示菜单
                         4.返回上一级菜单
 EOF
 }
 trap "" INT TSTP HUP#禁止ctrl+c ctrl+d等
 while true
 do
 read -p "选择你的岗位:[1|2|3]: " jd
     if [[ ! $jd =~ ^[0-9]+$ ]];then
             echo "必须输入数字"
             continue
     fi
 if [ $jd -eq 1 ];then
      while true
      do
          let i++
          read -p "请输入运维的口令: " op
           [ -z $op ] && echo "请输入正确的口令,不允许为空" && continue
          if [ $op = "woxiangjinqu" ];then
              action "口令正确欢迎运维大神归来" /bin/true
              break
          else
             action "口令不对重新输入!!!" /bin/false
             if [ $i -ge 3 ];then
             /root/game.sh
             fi
          fi
      done
      menu
 while true
 do
 read -p "请输入你要连接的服务器的编号[1|2|3|4菜单]: " num
 ​
 case $num in
       1)
         ssh $WEB01
       ;;
       2)
         ssh $WEB02
       ;;
       3)
         ssh $LB01
       ;;
       4)
         ssh $LB02
       ;;
       5)
         ssh $MySQL
       ;;
       7)
         clear
         menu
       ;;
           houmen)
         exit
       ;;
       8)
       menu1     
          break
       ;;
       *) 
         echo "请输入正确的服务器编号"
 esac
 done
     elif [ $jd = 2 ];then
          while true
          do
                  read -p "请输入开发的口令: " dev
          [ -z $dev ] && echo "请输入正确的口令,不允许为空" && continue
                  if [ $dev = "wos" ];then
              action "口令正确欢迎代码搬运工" /bin/true
                      break
                  else
                     action "口令不对重新输入!!!" /bin/false
                  fi
          done   
     menu2 
     while true
     do
     read -p "请输入连接的服务器编号:[1|2]: " num2 
case $num2 in 
1) 
ssh $MySQL 
    ;; 
2) 
ssh $LB01 
    ;; 
3)  
      clear 
      menu2 
    ;; 
4) 
      men1 
      break 
    ;; 
houmen) 
      exit 
    ;; 
    *) 
echo "请输入正确的编号: [1|2]" 
esac 
done 
elif [ $jd = 4 ];then 
menu1 
fi 
done

[root@shell ~]# cat jump.sh
#!/bin/sh
. /etc/init.d/functions
WEB01=10.0.0.7
WEB02=10.0.0.8
LB01=172.16.1.5
LB02=10.0.0.6
MySQL=10.0.0.51
NFS=10.0.0.31
BACKUP=10.0.0.41
menu(){
cat<<EOF
						1. WEB01-10.0.0.7
						2. WEB02-10.0.0.8
						3. LB01-10.0.0.5
						4. LB02-10.0.0.6
						5. MySQL-10.0.0.51
						6. NFS-10.0.0.31
						7. 显示菜单
EOF
}
menu
trap "" INT TSTP HUP
while true
do
read -p "请输入你要连接的服务器的编号[1|2|3|4菜单]: " num
case $num in
	  1|web01)
		ssh $WEB01
	  ;;
	  2|web02)
		ssh $WEB02
	  ;;
	  3|lb01)
		ssh $LB01
	  ;;
	  4)
		ssh $LB02
	  ;;
	  5)
		ssh $MySQL
	  ;;
	  7)
		clear
		menu
	  ;;
		  houmen)
		exit
	  ;;
	  *) 
		echo "请输入正确的服务器编号"
esac
done

[root@shell ~]# /usr/sbin/nginx           # nginx启动方式
[root@shell ~]# /usr/sbin/nginx -s stop   # Nginx停止
[root@shell ~]# /usr/sbin/nginx -s reload # 重载
[root@shell ~]# /usr/sbin/nginx -s stop && /usr/sbin/nginx  # 先停止后启动
[root@shell ~]# cat start_nginx.sh
#!/bin/sh
. /etc/init.d/functions
case $1 in
	start)
		if [ `ps axu|grep nginx|grep master|wc -l` -eq 0 ];then
		 
			/usr/sbin/nginx
				if [ $? -eq 0 ];then
				action "Nginx $1 is"  /bin/true
				else
				action "Nginx $1 is"  /bin/false
				fi
	   else
			action "Nginx $1 is 已经在运行" /bin/true
	   fi
	;;
	stop)
	   /usr/sbin/nginx -s stop
	;;	
	reload)
	  /usr/sbin/nginx -s reload
	;;
	restart)
	 /usr/sbin/nginx -s stop
	sleep 1
	/usr/sbin/nginx
	;;
	status)  
		if [ `ps axu|grep nginx|grep master|wc -l` -eq 0 ];then
		echo "Nginx is not running......"
		else
		pid=`ps axu|grep nginx|grep master|awk '{print $2}'`
		port=`netstat -tnulp|grep nginx|grep master|grep 80|awk '{print $4}'`
		echo "当前的Nginx端口号为 $port"
		echo "当前的NgnxPID号为: $pid"
		fi
	;;
	*)
	 echo "USAGE: $0 [start|stop|restart|reload|status]"
esac

yum -y install expect
#!/usr/bin/expect
spawn ssh root@10.0.0.5
expect {
    "yes/no" { send "yes\r"; exp_continue }
    "password:" { send "centos\r" };
} 
interact

#!/usr/bin/expect
set ip 10.0.0.5
set user root
set password centos
set timeout 5

spawn ssh $user@$ip

expect {
    "yes/no" { send "yes\r"; exp_continue }
    "password:" { send "$password\r" };
} 

cat for_ip.sh 
#!/usr/bin/bash
#setup1 拿到IP地址
>ip.txt
for i in {1..10}
do
ip=10.0.0.$i
{
ping -c1 $ip &>/dev/null
if [ $? -eq 0 ];then
echo "$ip" >> ip.txt
 fi
 }&
done
#2.生成对应的密钥
if [ ! -f ~/.ssh/id_rsa ];then
ssh-keygen -P "" -f ~/.ssh/id_rsa
fi

 while read line
        do
/usr/bin/expect << EOF
                        set pass 1
                        set timeout 2
                        spawn ssh-copy-id  $line -f 
                        expect {
                                "yes/no" { send "yes\r"; exp_continue}
                                "password:" { send "1\r"}
                        }
                        expect eof 
EOF
done<ip.txt

for.sh

for i in 框子(苹果 梨子 香蕉 黄瓜)
do
	 echo $i 
	第一个循环:
	i=苹果
	echo 苹果
	第二次循环:
	i=梨子
	echo 梨子
	第四次循环
	i=黄瓜
	echo 黄瓜
done

[root@shell scripts]# cat for.sh 
for i in 1 10 20 30
do
	   echo $i
done

[root@shell scripts]# cat for.sh 
for i in `seq 10`
do
	   echo $i
done

[root@shell scripts]# cat for.sh
for i in `seq 5`
do
	   echo ok
done

[root@shell scripts]# cat for.sh 
for i in `seq 100`
do
	   sum=$[$sum+$i]
done
echo $sum
[root@shell scripts]# cat for.sh
for i in $(seq 100)
do 
         sum=$(($sum+$i))  or   sum=$((sum+i))
done
echo $sum
[root@shell scripts]# seq -s + 100|bc
5050
扩展使用awk
[root@shell scripts]# seq 100|awk '{i=i+$1}END{print i}'
5050
[root@shell scripts]# echo {1..100}| awk -F " " '{for(i=1;i<NF+1;i++){j=j+i;}print j;}'
5050

10.0.0.0/24  10.0.0.1-10.0.0.254

[root@shell scripts]# cat ping.sh 
#!/bin/sh
for i in {1..254}
do
	{
	IP=10.0.0.$i
	ping -c2 -W1 $IP &>/dev/null
	if [ $? -eq 0 ];then
	   echo "当前 $IP 在线"
	fi
	} &
done
wait
echo "完成在线取IP.........."

[root@shell scripts]# vim user.sh 
#!/bin/sh
for i in {1..10}
do
		useradd oldboy$i
done
[root@shell scripts]# cat user.sh
#!/bin/bash
for i in {1..10}
do
      userdel -r oldboy$i
done

[root@shell scripts]# cat user1.sh
#!/bin/sh
for i in {1..10}
do
	id oldboy$i &>/dev/null
		if [ $? -eq 0 ];then
	   echo "useradd: user oldboy$i already exists"
	else
	useradd   oldboy$i
	   if [ $? -eq 0 ];then
	   echo "Create oldboy$i is ok"
	   else
	   echo "Create oldboy$i is error"
	   fi
	fi
done

[root@shell scripts]# cat user2.sh
#!/bin/bash
for i in {1..10}
do 
id oldboy$i &>/dev/null
 if [ $? -eq 0 ];then
    echo "用户已经存在"
    else 
     useradd  oldboy$i
     if [ $? -eq 0 ];then
     echo "Create oldboy$i is ok"
     else
      echo "Create oldboy$i is error"
      fi
fi 
done

--------------------------
[root@shell scripts]# cat user.sh 
#!/bin/sh
> passwd.txt
for i in {1..10}
do
	pass=`date +%N|md5sum|cut -c1-8`
	id oldboy$i &>/dev/null
		if [ $? -eq 0 ];then
	   echo "useradd: user oldboy$i already exists"
	else
	useradd   oldboy$i
	   if [ $? -eq 0 ];then
	   echo "Create oldboy$i is ok"
			echo $pass|passwd --stdin oldboy$i &>/dev/null
			if [ $? -eq 0 ];then
			echo "设置密码成功"
			else
			echo "设置密码失败"
			fi
		   echo  "oldboy$i $pass" >>passwd.txt
	   else
	   echo "Create oldboy$i is error"
	   fi
	fi
done

[root@shell scripts]# cat user1.sh 
#!/bin/sh
read -p "请输入用户的前缀名称: " prefix
[ -z $prefix ] && echo "请输入用户前缀" && exit
read -p "请输入创建用户的个数: " num
if [[ ! $num =~ ^[0-9]+$ ]];then
	echo "请输入整数"
fi
for i in `seq $num`
do
	echo $prefix$i
done
read -p "你确定要创建以上的用户吗?[y|Y|yes|n|N|no]: " re
for a in `seq $num`
do
		  user=$prefix$a
case $re in
	  y|Y|yes)
			 id $user &>/dev/null
		 if [ $? -eq 0 ];then
			echo "用户存在"
		 else
			useradd $user &>/dev/null
			if [ $? -eq 0 ];then
			   echo "用户创建成功"
			else
			   echo "用户创建失败"
			fi
		 fi
		 ;;
	   n|N|no)
		  exit
		;;
		   *)
		  echo "USAGE: $0 [请输入前缀个数....]"

esac
done

[root@shell scripts]# cat while.sh
while true
do
	 echo ok
	 sleep 2
done

[root@shell scripts]# cat while.sh 
a=0
while [ $a -le 3 ]
do
	 let a++
	 echo ok
done
[root@shell scripts]# sh while1.sh 
ok
ok
ok
ok
[root@shell scripts]# cat while1.sh
a=1
while [ $a -le 3 ]
do 
  let a++
       echo ok
done
[root@shell scripts]# sh while1.sh 
ok
ok
ok

[root@shell scripts]# cat while.sh 
a=1
while [ $a -le 100 ]
do
	 sum=$[$sum+$a]
	 let a++
done
echo $sum

for循环取值方式: 按照空格取值
[root@shell scripts]# cat test.sh
#!/bin/sh
for i in `cat /etc/hosts`
do
echo $i
done
while循环取值方式: 按照行取值
while read line
do
echo $line
done</etc/hosts

    user.txt 
	zs1
	old2
	tes1
	test2
	lisi

[root@shell scripts]# cat while.sh 
#!/bin/sh
while read line
do
		user=`echo $line|awk '{print $1}'`
	pass=`echo $line|awk '{print $2}'`
	useradd $user
	echo $pass|passwd --stdin $user
done<user.txt

#!/bin/sh
while true
do
		echo ok
		continue
		echo hehe
done
echo done...............

exit 退出当前整个脚本
[root@shell scripts]# cat while2.sh
#!/bin/sh
for i in `seq 10`
do
	useradd oldboy$i &>/dev/null
		if [ $? -eq 0 ];then
		echo "Create oldboy$i success"
		else
		exit
	fi
done
break 跳出本层循环 
[root@shell scripts]# cat while2.sh
#!/bin/sh
for i in `seq 10`
do
	useradd oldboy$i &>/dev/null
		if [ $? -eq 0 ];then
		echo "Create oldboy$i success"
		else
		break
	fi
done
echo done................
[root@shell scripts]# sh while2.sh 
Create oldboy1 success
Create oldboy2 success
Create oldboy3 success
Create oldboy4 success
done................

 continue
   [root@shell scripts]# cat while2.sh 
	#!/bin/sh
	for i in `seq 10`
	do
		useradd oldboy$i &>/dev/null
			if [ $? -eq 0 ];then
			echo "Create oldboy$i success"
			else
			continue
		fi
	done
	echo done................
  [root@shell scripts]# sh while2.sh 
	Create oldboy1 success
	Create oldboy2 success
	Create oldboy3 success
	Create oldboy4 success
	Create oldboy6 success
	Create oldboy7 success
	Create oldboy8 success
	Create oldboy9 success
	Create oldboy10 success
	done................

function fun1(){
	echo "函数的第二种定义方式"
}

function fun2 {
	echo "函数的第三种定义方式"
}
fun
fun1
fun2
[root@shell scripts]# sh fun.sh 
函数的第一种定义方式
函数的第二种定义方式
函数的第三种定义方式

函数的传参 函数的传参第一种方式 在函数的后面调用

[root@shell scripts]# cat fun1.sh
	#!/bin/sh
	fun(){
		if [ -f $1 ];then
		  echo "文件存在"
		else
		  echo "文件不存在"
		fi
	}
	fun /etc/hosts
	[root@shell scripts]# sh -x fun1.sh /etc/passwd 
	+ fun /etc/hosts
	+ '[' -f /etc/hosts ']'
	+ echo 文件存在
	文件存在

[root@shell scripts]# cat fun1.sh
#!/bin/sh
fun(){
	if [ -f $1 ];then
	  echo "$1 文件存在"
	else
	  echo "$1 文件不存在"
	fi
}
fun $2
[root@shell scripts]# sh fun1.sh /etc/passwd /etc/hosts
/etc/hosts 文件存在

-------------------------
[root@shell scripts]# cat fun1.sh
#!/bin/sh
fun(){
	if [ -f $1 ];then
	  echo "$1 文件存在"
	else
	  echo "$1 文件不存在"
	fi
}
fun $2 $1
[root@shell scripts]# sh fun1.sh /etc/passwd /etc/hosts
/etc/hosts 文件存在

[root@shell scripts]# cat fun1.sh
#!/bin/sh
fun(){
	if [ -f $2 ];then
	  echo "$2 文件存在"
	else
	  echo "$2 文件不存在"
	fi
}
fun $2 $1
[root@shell scripts]# sh fun1.sh /etc/passwd /etc/hosts
/etc/passwd 文件存在

函数传参的第二种方式:
    调用当前shell中的变量

[root@shell scripts]# cat fun1.sh
#!/bin/sh
file=$1
fun(){
	if [ -f $file ];then
	  echo "$file 文件存在"
	else
	  echo "$file 文件不存在"
	fi
}
fun

函数的本地变量: 只能在函数体中生效 在其他的shell语句中不生效
local file=/etc/hosts
[root@shell scripts]# vim fun1.sh 
#!/bin/sh
fun(){
	local file=/etc/hosts
	if [ -f $file ];then
	  echo "$file 文件存在"
	else
	  echo "$file 文件不存在"
	fi
}
fun
echo $file

案例:
[root@shell scripts]# cat fun2.sh 
#!/bin/sh
num1=10
fun(){
	for i in `seq 10`
	do
	total=$[$i+$num1]
	done
}
fun
echo $total
[root@shell scripts]# sh fun2.sh
20	

注意变量位置
[root@shell scripts]# cat fun2.sh
#!/bin/sh
fun(){
	for i in `seq 10`
	do
	total=$[$i+$num1]
	done
}
num1=10
fun
echo $total
[root@shell scripts]# sh fun2.sh
20

[root@shell scripts]# cat fun2.sh
#!/bin/sh
fun(){
	for i in `seq 10`
	do
	total=$[$i+$1]
	done
	echo $total
}
fun $1
fun $2
fun $3
[root@shell scripts]# sh fun2.sh 10 20 30
20
30
40

 [root@shell scripts]# cat fun2.sh 
     #!/bin/sh
     fun(){
         for i in `seq 10`
         do
         total=$[$i+$1]
         done
         echo $total
     }
     fun $2 $1 $3
     [root@shell scripts]# sh fun2.sh 20 30 10
     40
 ​
 函数的返回值: return
     [root@shell scripts]# cat fun1.sh
     #!/bin/sh
         file=$1
     fun(){
         if [ -f $file ];then
           return 50
         else
           return 100
         fi
     }
     fun
     echo $?
     [root@shell scripts]# sh fun1.sh /etc/hostssss
     100
     [root@shell scripts]# sh fun1.sh /etc/hosts
     50
 ​
    [root@shell scripts]# cat fun1.sh 
     #!/bin/sh
         file=$1
     fun(){
         if [ -f $file ];then
           return 50
         else
           return 100
         fi
     }
     fun
     if [ $? -eq 50 ];then
         echo "文件存在"
     else
         echo "文件不存在"
     fi
   [root@shell scripts]# cat fun1.sh
     #!/bin/sh
         file=$1
     fun(){
           echo 50
           return 100
     }
     num=`fun`
     echo "当前函数的返回值为: $?"
     echo "当前函数的执行结果为: $num"
     [root@shell scripts]# sh fun1.sh /etc/hosts
     当前函数的返回值为: 100
     当前函数的执行结果为: 50
   [root@shell scripts]# cat fun1.sh
     #!/bin/sh
         file=$1
     fun(){
           echo 50
           return 100
     }
     num=`fun`
     name=oldboy
     echo "当前函数的返回值为: $?"
     echo "当前函数的执行结果为: $num"
     [root@shell scripts]# sh fun1.sh /etc/hosts
     当前函数的返回值为: 0
     当前函数的执行结果为: 50
 ​
 函数在其他shell中调用 类似变量
    [root@shell scripts]# cat fun.sh
       /bin/sh
     fun(){
         echo "函数的第一种定义方式"
     }

 function fun1(){
     echo "函数的第二种定义方式"
 }
 ​
 function fun2 {
     echo "函数的第三种定义方式"
 }
 [root@shell scripts]# fun
 -bash: fun: command not found
 [root@shell scripts]# . fun.sh
 [root@shell scripts]# fun
 函数的第一种定义方式
 [root@shell scripts]# fun1
 函数的第二种定义方式
 [root@shell scripts]# fun2
 函数的第三种定义方式

declare -a ARRAY_NAME
declare -A ARRAY_NAME 关联数组

[root@server ~]# N=NAME
[root@server ~]# NAME=wangxiaochun
[root@server ~]# N1=${!N}
[root@server ~]# echo $N1
wangxiaochun
[root@server ~]# eval N2=\$$N
[root@server ~]# echo $N2
wangxiaochun

install -m 700 -o wang -g admins srcfile desfile
install –m 770 –d /testdir/installdir

[root@shell scripts]# array[1]=cm
[root@shell scripts]# array[5]=zs
[root@shell scripts]# array[6]=ls

 [root@shell scripts]# array=(ll lz lw lz)

 [root@shell scripts]# array=(qq aa cc [20]=tt [22]=yy)

[root@shell scripts]# ls /tmp/
nging.pid  vmware-root_6223-1681855427
[root@shell scripts]# array=(`ls /tmp`)

 [root@shell scripts]# echo $array          # 默认只能查看下标为0的值
 mysql
 [root@shell scripts]# 
 [root@shell scripts]# echo ${array[*]} # 查看数组中的所有内容
 mysql shell redis
 [root@shell scripts]# echo ${array[@]}
 mysql shell redis
 [root@shell scripts]# echo ${!array[@]} # 查看所有的下标
 0 1 2
 [root@shell scripts]# echo ${array[1]}  # 通过下标查看值
 shell
 [root@shell scripts]# echo ${array[2]}
 redis
 [root@shell scripts]# echo ${array[0]}
 mysql
 [root@shell scripts]# echo ${#array[*]} # 查看元素的个数
 3

61.135.169.121 123.126.55.41 10.0.0.254 8.8.8.8

 [root@shell scripts]# IP=(61.135.169.121 123.126.55.41 10.0.0.254 8.8.8.8)

  [root@shell scripts]# echo ${IP[*]}
    61.135.169.121 123.126.55.41 10.0.0.254 8.8.8.8

  [root@shell scripts]# for i in ${IP[*]};do echo $i;done
     61.135.169.121
     123.126.55.41
     10.0.0.254
     8.8.8.8
   [root@shell scripts]# for i in ${IP[*]};do ping -c2 -W1 $i;done
   [root@shell scripts]# cat array.sh 
     #!/bin/sh
     IP=(
     61.135.169.121
     123.126.55.41
     10.0.0.254
     8.8.8.8
     10.0.0.51
     )
     for i in ${IP[*]}
     do
         ping -c2 -W1 $i &>/dev/null
             if [ $? -eq 0 ];then
            echo "ping $i is ok............"
         else
            echo "ping $i is error........."
         fi
     done

[root@shell scripts]# array[index1]=redis
[root@shell scripts]# array[index2]=mysql
[root@shell scripts]# array[index3]=shell
[root@shell scripts]# echo ${array[*]}
redis mysql shell

[root@shell scripts]# array=([0]=zabbix [index4]=kvm [index5]=mongo)
[root@shell scripts]# echo $array[*]
zabbix[*]
[root@shell scripts]# echo ${array[*]}
kvm mongo zabbix
[root@shell scripts]# echo ${!array[*]}
index4 index5 0

 cat sex.txt
 m
 f
 f
 m
 m
 m
 x
 [root@shell scripts]# sort sex.txt|uniq -c
 2 f
 4 m
 1 x
 [root@shell scripts]# sort sex.txt|uniq -c|sort -rn
 4 m
 2 f
 1 x
 [root@shell scripts]# cat sex.txt |uniq -c|sort -rn
 3 m
 2 f
 1 x
 1 m
 [root@shell scripts]# cat sex.txt |sort 
 f
 f
 m
 m
 m
 m
 x
 [root@shell scripts]# cat sex.txt |sort |uniq -c
 2 f
 4 m
 1 x
 [root@shell scripts]# cat sex.txt |sort |uniq -c|sort -rn
 4 m
 2 f
 1 x
 [root@shell scripts]# cat s.sh 
 for i in `cat sex.txt`
 do
 if [ $i = m ];then
 let m++
 elif [ $i = f ];then
 let f++
 else
 let x++
 fi 
 done
 echo "m出现了 $m 次"
 echo "f出现了 $f 次"
 echo "x出现了 $x 次"
 [root@shell scripts]# sh s.sh
 m出现了 4 次
 f出现了 2 次
 ​
 x出现了 1 次
 --------------------------
 ​
   [root@shell scripts]# let a++
     [root@shell scripts]# echo $a
     1
     [root@shell scripts]# let array[b]++
     [root@shell scripts]# echo ${array[b]}
     1
     [root@shell scripts]# let a++
     [root@shell scripts]# let b++
     [root@shell scripts]# let b++
     [root@shell scripts]# let a++
     [root@shell scripts]# let array[b]++
     [root@shell scripts]# let array[a]++
     [root@shell scripts]# let array[a]++
     [root@shell scripts]# 
     [root@shell scripts]# echo $a
     3
     [root@shell scripts]# echo ${array[b]}
     2
     [root@shell scripts]# echo ${array[a]}
 ​
     2
 -----------------------------
 ​
    cat s.sh         # 执行过程
    declare -A sex
     for i in `cat sex.txt`
     do
            let sex[$i]++
 ​
 --------------
 ​
 •          i=m
 •          let sex[m]++
 ​
 ---
 ​
 •          i=f
 •          let sex[f]++
 ​
 ---
 ​
 •          i=m
 •          let sex[m]++
 •   done
 •   echo "m出现了 $m 次"
 •   echo "f出现了 $f 次"
 •   echo "x出现了 $x 次"
  [root@shell scripts]# cat s.sh 
 •   declare -A sex
 •   for i in `cat sex.txt`
 •   do
 •          let sex[$i]++
 •   done
 •   echo "m出现了 ${sex[m]} 次"
 •   echo "f出现了 ${sex[f]} 次"
 •   echo "x出现了 ${sex[x]} 次"
 ​
 •    [root@shell scripts]# sh s.sh
 •    m出现了 4 次
 •    f出现了 2 次
 •    x出现了 1 次
 ​
    遍历数组:
    [root@shell scripts]# cat s.sh 
     declare -A sex
     for i in `cat sex.txt`
     do
            let sex[$i]++
     done
     #echo "m出现了 ${sex[m]} 次"
     #echo "f出现了 ${sex[f]} 次"
     #echo "x出现了 ${sex[x]} 次"
     for a in ${!sex[*]}
     do
          echo "$a 出现了 ${sex[$a]} 次"
     done
     [root@shell scripts]# sh s.sh
     f 出现了 2 次
     m 出现了 4 次
     x 出现了 1 次

   declare -A bash         # 执行过程
     while read line
     do
            let bash[`echo $line|awk -F: '{print $NF}'`]++
            root:x:0:0:root:/root:/bin/bash
            let bash[/bin/bash]++
     bin:x:1:1:bin:/bin:/sbin/nologin 
       let bash[/sbin/nologin]++ 
     
done</etc/passwd 
for a in ${!bash[*]} 
do 
echo "$a 出现了 ${bash[$a]} 次" 
done 
[root@shell scripts]# cat bash.sh  
declare -A bash 
while read line 
do 
       let bash[`echo $line|awk -F: '{print $NF}'`]++ 
done</etc/passwd 
for a in ${!bash[*]} 
do 
echo "$a 出现了 ${bash[$a]} 次" 
done 
[root@shell scripts]# sh bash.sh 
    /sbin/nologin 出现了 21 次 
    /bin/sync 出现了 1 次 
    /bin/bash 出现了 26 次 
    /sbin/shutdown 出现了 1 次 
    /sbin/halt 出现了 1 次

 [root@shell scripts]# cat ip.sh
     #!/bin/sh
     declare -A IP
     while read line
     do
     let IP[`echo $line|awk '{print $1}'`]++
     done</var/log/nginx/access.log
     for i in ${!IP[*]}
     do
         echo "$i 出现了 ${IP[$i]} 次"
     done 

 unset ARRAY
 [root@localhost ~]# unset array[1]
 [root@localhost ~]# echo ${array[*]}
 one three four
 [root@localhost ~]# unset array
 [root@localhost ~]# echo ${array[*]}

[root@localhost ~]# array=(0 1  2 3 4)
[root@localhost ~]# echo ${array[@]:1:3}
1 2 3
[root@localhost ~]# array=($(echo {a..z}))
[root@localhost ~]# echo ${array[@]}
a b c d e f g h i j k l m n o p q r s t u v w x y z
[root@localhost ~]# echo ${array[@]:1:3}
b c d
[root@localhost ~]# array=(1 2 3 4 5)
[root@localhost ~]# echo ${array[@]/3/three}
1 2 three 4 5

file=“var/log/messages”
${file#*/}: log/messages
${file##*/}: messages
 ${var%word*}：其中word可以是指定的任意字符
功能：自右而左，查找var变量所存储的字符串中，第一次出现的word, 删除字符串最后一个字符向左至第一次出现word字符串（含）之间的所有字符
file="/var/log/messages"
${file%/*}: /var/log
${var%%word*}：同上，只不过删除字符串最右侧的字符向左至最后一次出现word字符之间的所有字符
示例：
url=http://www.magedu.com:80
${url##*:} 80
${url%%:*} http       
 查找并删除
${var/pattern}：删除var表示的字符串中第一次被pattern匹配到的字符串
${var//pattern}：删除var表示的字符串中所有被pattern匹配到的字符串
${var/#pattern}：删除var表示的字符串中所有以pattern为行首匹配到的字符串
${var/%pattern}：删除var所表示的字符串中所有以pattern为行尾所匹配到的字符串
字符大小写转换
${var^^}：把var中的所有小写字母转换为大写
${var,,}：把var中的所有大写字母转换为小写 

元字符意义BRE，正则表达式实际就是一些特殊字符，赋予了他特定的含义。

正则表达式 描述

\    转义符，将特殊字符进行转义，忽略其特殊意义

^    匹配行首，awk中，^则是匹配字符串的开始 

$    匹配行尾，awk中，$则是匹配字符串的结尾

^$   表示空行

.    匹配除换行符\n之外的任意单个字符

.*   匹配所有

[ ]   匹配包含在[字符]之中的任意一个字符

[^ ]  匹配[^字符]之外的任意一个字符

[ - ]  匹配[]中指定范围内的任意一个字符

?    匹配之前的项1次或者0次

\+    匹配之前的项1次或者多次

\*    匹配之前的项0次或者多次, .*

()   匹配表达式，创建一个用于匹配的子串

{ n }  匹配之前的项n次，n是可以为0的正整数

{n,}  之前的项至少需要匹配n次

{n,m}  指定之前的项至少匹配n次，最多匹配m次，n<=m

|    交替匹配|两边的任意一项ab(c|d)匹配abc或abd

特定字符:

>[[:space:]]  空格
[[:digit:]]   [0-9]
[[:lower:]]   [a-z]
[[:upper:]]   [A-Z]
[[:alpha:]]   [a-Z]

I am lizhenya teacher!
I teach linux.
test
I like badminton ball ,billiard ball and chinese chess!
my blog is http: blog.51cto.com
our site is http:www.lizhenya.com
my qq num is 593528156
not 572891888887. 

[root@Shell ~]#** grep "^m" test.txt
my blog is http: blog.51cto.com
my qq num is 572891887.

[root@Shell ~]#** grep "m$" test.txt
my blog is http: blog.51cto.com
our site is http:www.lizhenya.com

[root@student ~]#grep -vn "^$" lizhenya.txt

[root@student ~]# grep "." lizhenya.txt

[root@student ~]# grep ".*" lizhenya.txt

 [root@node1 ~]# grep "lizhen.a" lizhenya.txt

 [root@student ~]# grep "\.$" lizhenya.txt

 [root@student ~]# grep -o "8*" lizhenya.txt

 [root@student ~]# grep "[abc]" lizhenya.txt

 [root@student ~]# grep "[0-9]" lizhenya.txt

[root@student ~]# grep "[a-z]" lizhenya.txt

 [root@student ~]# grep "8\{3\}" lizhenya.txt

 [root@student ~]# grep -E "8{3,5}" test.txt

 [root@student ~]# grep -E "8{1,}" lizhenya.txt

sed [options] 'command' file(s)

使用基本元字符集 ^, $, ., *, [], [^], < >, (), {}
使用扩展元字符集 ?, +, { }, |, ( )
使用扩展元字符的方式 + sed -r

-e 允许多项编辑
-n 取消默认的输出
-i 直接修改对应文件
-r 支持扩展元字符

a 在当前行后添加一行或多行
c 在当前行进行替换修改
d 在当前行进行删除操作
i 在当前行之前插入文本
p 打印匹配的行或指定行
n 读入下一输入行，从下一条命令进行处理
! 对所选行以外的所有行应用命令
h 把模式空间里的内容重定向到暂存缓冲区
H 把模式空间里的内容追加到暂存缓冲区
g 取出暂存缓冲区的内容，将其复制到模式空间，覆盖该处原有内容
G 取出暂存缓冲区的内容，将其复制到模式空间，追加在原有内容后面

[root@Shell ~]# sed '1,9d' passwd |sed 's#root#alex#g'

[root@Shell ~]# sed -e '1,9d' -e 's#root#alex#g' passwd

[root@Shell ~]# sed -n '/halt/p' passwd

[root@Shell ~]#** sed -n '2p' passwd
bin:x:1:1:bin:/bin:/sbin/nologin

[root@Shell ~]# sed -n '$p' passwd

[root@Shell ~]# sed -i '30a listen 80;' passwd

[root@Shell ~]# sed -i '7c SELINUX=Disabled' /etc/selinux/config

[root@Shell ~]# sed -i '/^SELINUX=/c SELINUX=Disabled' /etc/selinux/config

[root@Shell ~]# sed -ri '/UseDNS/cUseDNS no' /etc/ssh/sshd_config
[root@Shell ~]# sed -ri '/GSSAPIAuthentication/c#GSSAPIAuthentication no' /etc/ssh/sshd_config
[root@Shell ~]# sed -ri '/^SELINUX=/cSELINUX=disabled' /etc/selinux/config

[root@Shell ~]# sed '3d' passwd
[root@Shell ~]# sed '3{d}' passwd

[root@Shell ~]# sed '3,$d' passwd

[root@Shell ~]# sed '$d' passwd

[root@Shell ~]# sed '1,$d' passwd

[root@Shell ~]# sed /mail/d passwd

[root@Shell ~]# sed -i '30i listen 80;' passwd

[root@Shell ~]# sed -n '/root/w newfile' passwd

[root@Shell ~]# sed -n '2w newfile' passwd

[root@Shell ~]# sed '/root/{n;d}' passwd

[root@Shell ~]# sed '/root/{n; s/bin/test/}' passwd

g: 将hold space中的内容拷贝到pattern space中，原来pattern space里的内容被覆盖
G：将hold space中的内容append到pattern space\n后
h: 将pattern space中的内容拷贝到hold space中，原来hold space里的内容被覆盖
H: 将pattern space中的内容append到hold space\n后
d: 删除pattern中的所有行，并读入下一新行到pattern中
D: 删除multiline pattern中的第一行，读入下一行

[root@Shell ~]# sed '1h;$g' /etc/hosts

[root@Shell ~]# sed '1h;$G' /etc/hosts

[root@Shell ~]# sed -r '1{h;d};$G' /etc/hosts

[root@Shell ~]# sed -r '1h;2,$g' /etc/hosts

[root@Shell ~]# sed -r '1h; 2,3H; $G' /etc/hosts

g: 将hold space中的内容拷贝到pattern space中，原来pattern space里的内容被覆盖
G：将hold space中的内容append到pattern space\n后
h: 将pattern space中的内容拷贝到hold space中，原来hold space里的内容被覆盖
H: 将pattern space中的内容append到hold space\n后
d: 删除pattern中的所有行，并读入下一新行到pattern中
D: 删除multiline pattern中的第一行，不读入下一行

[root@localhost test]# cat file
1 1 1
2 2 2
3 3 3
[root@localhost test]# sed '1!G;h;$!d' file
3 3 3
2 2 2
1 1 1

[root@Shell ~]# sed -r '3!d' /etc/hosts

[root@Shell ~]# sed 's/root/alice/' passwd

[root@Shell ~]# sed 's/^root/alice/' passwd

[root@Shell ~]# sed -r 's/[0-9][0-9]$/& .5/' passwd

[root@Shell ~]# sed -r 's/root/alice/g' passwd

[root@Shell ~]# sed -r 's/root/alice/gi' /etc/passwd

[root@Shell ~]# sed -r 's#(Roo)#\1-alice#g' passwd
[root@Shell ~]# ifconfig eth0|sed -n '2p'|sed -r 's#(^.*et) (.*) (net.*$)#\2#g'

[root@lzy ~]# vim a.txt
/etc/abc/456
etc

[root@Shell ~]# sed -r '\/etc\/abc\/456/d' a.txt

[root@Shell ~]# sed -r 's#/etc/abc/456#/dev/null#g' a.txt
[root@Shell ~]# sed -r 's@/etc/abc/456@/dev/null@' a.txt 

[root@Shell ~]# sed '/^#/d' file

[root@Shell ~]# sed -r '/^[ \t]*#/d' file

[root@Shell ~]# sed -r '/^[ \t]*$/d' file

[root@Shell ~]# sed -r '/^[ \t]*#/d; /^[ \t]*$/d' /etc/vsftpd/vsftpd.conf
[root@Shell ~]# sed -r '/^[ \t]*#|^[ \t]*$/d' /etc/vsftpd/vsftpd.conf
[root@Shell ~]# sed -r '/^[ \t]*($|#)/d' /etc/vsftpd/vsftpd.conf 

[root@Shell ~]# sed '2,6s/^/#/' passwd

[root@Shell ~]# sed -r '2,6s/.*/#&/' passwd

[root@Shell ~]# sed -r '3,$ s/^#*/#/' passwd
# sed -r '30,50s/^[ \t]*#*/#/' /etc/nginx.conf 
# sed -r '2,8s/^[ \t#]*/#/' /etc/nginx.conf

awk [options] 'commands' filenames
awk [options] -f awk-script-file filenames

[root@Shell ~]# awk 'BEGIN{print 1/2}'
0.5

[root@Shell ~]# awk 'BEGIN{FS=":"} {print $1}' /etc/passwd

[root@Shell ~]# awk 'BEGIN{FS=":";OFS="---"} {print $1,$2}' /etc/passwd
[root@Shell ~]# awk 'BEGIN{print 1/2} {print "ok"} END {print "Game Over"}' /etc/hosts
0.5
ok
ok
ok
Game Over

[root@Shell ~]# awk '/root/' /etc/passwd

[root@Shell ~]# awk -F: '{print $1}' /etc/passwd

[root@Shell ~]# awk -F ':' '/root/ {print $1,$3}' /etc/passwd
[root@Shell ~]# awk 'BEGIN{FS=":"} /root/{print $1,$3}' /etc/passwd

[root@Shell ~]# df |awk '/\/$/ {if ($3>50000) print $4}'

# awk -F: '{print $1,$3}' /etc/passwd

[root@Shell ~]# awk '{print $0}' /etc/passwd

[root@Shell ~]# awk '{print NR,$0}' /etc/passwd
[root@Shell ~]# awk 'NR<=3' /etc/passwd

[root@Shell ~]# awk '{print NR,$0}' /etc/passwd /etc/hosts
[root@Shell ~]# awk '{print FNR,$0}' /etc/passwd /etc/hosts

[root@Shell ~]# awk -F ":" '{print NF,$NF}' /etc/passwd /etc/hosts

[root@Shell ~]# awk -F: '/root/{print $1,$3}' /etc/passwd
[root@Shell ~]# awk 'BEGIN{FS=":"} {print $1,$3}' /etc/passwd

[root@Shell ~]# awk -F'[ :\t]' '{print $1,$2,$3}' /etc/passwd

[root@Shell ~]# awk -F: '/root/{print $1,$2,$3,$4}' /etc/passwd
[root@Shell ~]# awk 'BEGIN{FS=":"; OFS="+++"} /^root/{print $1,$2}' /etc/passwd

[root@Shell ~]# awk -F: 'BEGIN{RS=" "} {print $0}' /etc/hosts

[root@Shell ~]# awk -F: 'BEGIN{ORS=" "} {print $0}' /etc/hosts

[root@Shell ~]# date|awk '{print $2,"5月份""\n",$NF,"今年"}'
[root@Shell ~]# awk -F: '{print "用户是:" $1 "\t 用户uid: " $3 "\t 用户gid:" $4}' /etc/passwd

[root@Shell ~]# awk -F: '{printf "%-15s %-10s %-15s\n", $1, $2, $3}' /etc/passwd

[root@Shell ~]# awk '/^root/' /etc/passwd
[root@Shell ~]# awk '$0 ~ /^root/' /etc/passwd

[root@Shell ~]# awk '$1~/^root/' /etc/passwd
[root@Shell ~]# awk '$NF !~ /bash$/' /etc/passwd

[root@Shell ~]# awk -F ":" '$3==0' /etc/passwd

[root@Shell ~]# awk -F: '$3 < 10' /etc/passwd

[root@Shell ~]# awk -F: '$7 == "/bin/bash" ' /etc/passwd

[root@Shell ~]# awk -F: '$1 == "alice" ' /etc/passwd

[root@Shell ~]# awk -F: '$1 ~ /alice/ ' /etc/passwd 
[root@Shell ~]# awk -F: '$1 !~ /alice/ ' /etc/passwd

[root@Shell ~]# df |awk '/\/$/'|awk '$3>1000000 {print $4}'

[root@Shell ~]# awk -F: '$3>300 {print $0}' /etc/passwd
[root@Shell ~]# awk -F: '{if($3>300) print $0}' /etc/passwd
[root@Shell ~]# awk -F: '{if($3>5555){print $3} else {print $1}}' /etc/passwd

[root@Shell ~]# awk -F: '$3 * 10 > 500000' /etc/passwd
[root@Shell ~]# awk -F: 'BEGIN{OFS="--"} { if($3*10>50000) {print $1,$3} } END {print "打印ok"}' /etc/passwd
[root@Shell ~]# awk '/southem/{print $5 + 10}' datafile 
[root@Shell ~]# awk '/southem/{print $5 + 10.56}' datafile
[root@Shell ~]# awk '/southem/{print $8 - 10}' datafile 
[root@Shell ~]# awk '/southem/{print $8 / 2 }' datafile 
[root@Shell ~]# awk '/southem/{print $8 * 2 }' datafile 
[root@Shell ~]# awk '/southem/{print $8 % 2 }' datafile

[root@Shell ~]# awk -F: '$1~/root/ && $3<=15' /etc/passwd

[root@Shell ~]# awk -F: '$1~/root/ || $3>=5000' /etc/passwd

# awk '/west/' datafile 
# awk '/^north/' datafile 
# awk '$3 ~ /^north/' datafile 
# awk '/^(no|so)/' datafile 
# awk '{print $3,$2}' datafile
# awk '{print $3 $2}' datafile 
# awk '{print $0}' datafile 
# awk '{print "Number of fields: "NF}' datafile 
# awk '/northeast/{print $3,$2}' datafile
# awk '/^[ns]/{print $1}' datafile 
# awk '$5 ~ /\. [7-9]+/' datafile 
# awk '$2 !~ /E/{print $1,$2}' datafile 
# awk '$3 ~ /^Joel/{print $3 "is a nice boy."}' datafile 
# awk '$8 ~ /[0-9][0-9]$/{print $8}' datafile
# awk '$4 ~ /Chin$/{print "The price is $" $8 "."}' datafile 
# awk '/Tj/{print $0}' datafile 
# awk -F: '{print "Number of fields: "NF}' /etc/passwd 
# awk -F"[ :]" '{print NF}' /etc/passwd 

[root@Shell ~]# cat b.txt 
lzy lizhenya:is a:good boy!
[root@Shell ~]# awk '{print NF}' b.txt
4
[root@Shell ~]# awk -F ':' '{print NF}' b.txt
3
[root@Shell ~]# awk -F"[ :]" '{print NF}' .txt
6

[root@Shell ~]# awk -F: '{ if($3==0){print $1 "is adminisitrator"} }' /etc/passwd

[root@Shell ~]# awk -F: '{ if($3>0 && $3<1000){i++}} END {print i}' /etc/passwd

[root@Shell ~]# awk -F: '{ if($3>1000){i++}} END {print i}' /etc/passwd 

# awk -F: '{if($3==0){print $1} else {print $7}}' /etc/passwd
# awk -F: '{if($3==0) {count++} else{i++} }' /etc/passwd
# awk -F: '{if($3==0){count++} else{i++}} 
END{print " 管理员个数: "count ; print " 系统用户数: "i}' /etc/passwd

[root@Shell ~]# awk -F: '{ if($3==0){i++} else if($3>0 && $3<1000){j++} else if($3>1000) {k++}} 
END {print i;print j;print k}' /etc/passwd

[root@Shell ~]# awk -F: '{ if($3==0){i++} else if($3>0 && $3<1000){j++} 
else if($3>1000) {k++}}
 END {print "管理员个数"i; print "系统用户个数" j; print "系统用户个 数" }' /etc/passwd
管理员个数1
系统用户个数29
0系统用户个数69

[root@Shell ~]# awk 'BEGIN{ i=1; while(i<=10){print i; i++} }'
[root@Shell ~]# awk -F: '{i=1; while(i<=NF){print $i; i++}}' /etc/passwd
[root@Shell ~]# awk -F: '{i=1; while(i<=10) {print $0; i++}}' /etc/passwd
[root@Shell ~]#cat b.txt
111 222
333 444 555
666 777 888 999
[root@Shell ~]# awk '{i=1; while(i<=NF){print $i; i++}}' b.txt

C 风格 for
[root@Shell ~]# awk 'BEGIN{for(i=1;i<=5;i++){print i} }' 
将每行打印 10 次
[root@Shell ~]# awk -F: '{ for(i=1;i<=10;i++) {print $0} }' passwd
[root@Shell ~]# awk -F: '{ for(i=1;i<=NF;i++) {print $i} }' passwd

# awk -F: '{shells[$NF]++} END{ for(i in shells){print i,shells[i]} }' /etc/passwd

[root@Shell ~]# ss -an|awk '/:80/{tcp[$2]++} END {for(i in tcp){print i,tcp[i]}}'

[root@Shell ~]# ss -an|awk -F ':' '/:80/{ips[$(NF-1)]++}
 END {for(i in ips){print i,ips[i]}}'

log_format main '$remote_addr - $remote_user [$time_local] "$request" '
           '$status $body_bytes_sent "$http_referer" '
           '"$http_user_agent" "$http_x_forwarded_for"';
52.55.21.59 - - [25/Jan/2018:14:55:36 +0800] "GET /feed/ HTTP/1.1" 404 162 "https:www.google.com/" 
"Opera/9.80 (Macintosh; Intel Mac OS X 10.6.8; U; de) Presto/2.9.168 Version/11.52" "-"

[root@Shell ~]# grep "25/Jan/2018" log.bjstack.log |wc -l
[root@Shell ~]# awk "/25\/Jan\/2018/" log.bjstack.log |wc -l
[root@Shell ~]# awk '/25\/Jan\/2018/ {ips[$1]++} END {for(i in ips) {sum+=ips[i]} {print sum}}' log.bjstack.log

[root@Shell ~]# awk '$4>="[25/Jan/2018:15:00:00" && $4<="[25/Jan/2018:19:00:00 {print $0}"' log.bjstack.log |wc -l

[root@Shell ~]# awk '/25\/Jan\/2018/ {ips[$1]++} END {for(i in ips){ print ips[i],i}}' log.bjstack.log |sort -rn|head

[root@Shell ~]# awk '$4>="[25/Jan/2018:15:00:00" && $4<="[25/Jan/2018:19:00:00"' log.bjstack.log 
|awk '{ips[$1]++} END {for(i in ips){print ips[i],i}}'|sort -rn|head

[root@Shell ~]# awk '/25\/Jan\/2018/ {ips[$1]++} END {for(i in ips){if(ips[i]>10){print i,ips[i]}}}' log.bjstack.log

[root@Shell ~]# awk '/25\/Jan\/2018/ {request[$7]++} END {for(i in request){print request[i],i}}' log.bjstack.log |sort -rn|head

[root@Shell ~]# awk '/25\/Jan\/2018/ {request[$7]++;size[$7]+=$10} END {for(i in request){print request[i],i,size[i]}}' log.bjstack.log |sort -rn|head

[root@Shell ~]# awk '{ip_code[$1 " " $9]++} END {for(i in ip_code){print ip_code[i],i}}' log.bjstack.log|sort -rn|head

[root@Shell ~]# grep "404" log.bjstack.log |wc -l
[root@Shell ~]# awk '{if($9=="404") code[$9]++}
 END {for(i in code){print i,code[i]}}' log.bjstack.log

[root@Shell ~]# awk '$4>="[25/Jan/2018:15:00:00" && $4<="[25/Jan/2018:19:00:00" && $9=="404" {code[$9]++} 
END {for(i in code){print i,code[i]}}' log.bjstack.log
[root@Shell ~]# awk '$9=="404" {code[$9]++} END {for(i in code){print i,code[i]}}' log.bjstack.log

[root@Shell ~]# awk '{code[$9]++} END {for(i in code){print i,code[i]}}' log.bjstack.log
[root@Shell ~]# awk '{if($9>=100 && $9<200) {i++}
else if ($9>=200 && $9<300) {j++}
else if ($9>=300 && $9<400) {k++}
else if ($9>=400 && $9<500) {n++}
else if($9>=500) {p++}}
END{print i,j,k,n,p,i+j+k+n+p}' log.bjstack.log