shall 2-13

1.用一句话概括Shell
 Shell是一个解释器，介于应用程序（用户）和操作系统之间的一个桥梁，负责命令的解释

2.Shell的编程语言
编译型语言:
 程序在执行之前需要个专门的编译过程，把程序编译成为机器语言文件，运行时不需要重新翻译，直接使用编译的结果就行了。程序执行效率高，依养编译器，跨平台性差些。如C、C++、java
 
解释型语言:
 程序不需要编译，程序在运行时由解释器翻译成机器语言，每执行一次都要翻译一次。因此效率比较低。比如Python/javaScript/Shell等都是解释型语言。
 
Shell的解析器：
 /bin/sh       是bash的一个快捷方式
 /bin/bash（最多）     bash是大多数Linux默认的shell，包含的功能几乎可以涵盖shell所有的功能
 /sbin/nologin   表示非交互，不能登录操作系统
 /bin/dash     小巧，高效，功能相比少一些

/bin/tcsh     具有C语言风格的一种shell，具有许多特性，但是也有一些缺陷
 /bin/csh      是csh的增强版本，完全兼容csh
 
 [ljh@Linux2 ~]$ ll /bin | grep bash
 -rwxr-xr-x. 1 root root 942200 3月  23 2017 bash
 lrwxrwxrwx. 1 root root      4 2月   3 23:07 sh -> bash
 
Shell编程语言目的：
 写脚本
学习Shell语言的方法：
 最简单的语言、技巧（多看、多读、借鉴、思考）
使用场景：
 完成自动化的工作：自动化部署、自动化的分析等 （ 自动化运维 ）

什么是脚本？
 脚本就是将需要执行的命令保存到文本中，按照顺序执行（由上往下执行），它是解释型的，不需要编译。
 
布置一个简单的任务：(执行mkdir -p class22/test)
 1.删除class22中的test文件夹
 2.在class22文件夹中新建一个test2 文件夹，在test2中新建dir1、dir2、dir3三个子目录
 3.在dir2中新建一个class22.txt文件,
 4.往class22.txt文件中写入libai
 5.打印一句话"任务执行完毕 2020-2-12 10:24"
 
 写一个脚本
 step1在第一行（指明解析器）：#!/bin/bash 或者 #!/bin/env bash
 step2添加描述信息：（脚本名称、路径、描述、创建时间、修改时间、编辑人）
 step3编写脚本主体代码
 
 #!/bin/bash
 #NAME:test03.sh
 #DESC:第一个脚本任务
 #CREATETIME:2020-2-12 10：44
 #CREATE:wangwu
 #PATH:/root/class22_shell
 <<EOF
 asnckas
 jsacbsal
 EOF
 <<!
 a KD
 asc las
 !

#1.删除class22中的test文件夹
 rm -rf /root/class22_shell/class22/test
 #2.在class22文件夹中新建一个test2 文件夹，在test2中新建dir1、dir2、dir3三个子目录
 mkdir -p /root/class22_shell/class22/test2/dir{1..3} 
 #3.在dir2中新建一个class22.txt文件
 touch /root/class22_shell/class22/test2/dir2/class22.txt
 #4.往class22.txt文件中写入libai
 echo libai >>  /root/class22_shell/class22/test2/dir2/class22.txt
 #5.打印一句话"任务执行完毕 2020-2-12 10:24"
 echo "任务执行完毕 `date "+%Y-%m-%d %H:%M:%S"`"
 
 step4:执行脚本
  执行方式一：
   sh/bash 绝对路径|相对路径
   source 绝对路径|相对路径
   
  执行方式二：（注意脚本中的指定的解析器一定不要写错）
   推荐的执行方式：给脚本添加执行权限
    chmod +x 脚本名称
   执行：./脚本名称
  
   如果需要在任意地方执行脚本，需要将脚本移动至/bin目录
   执行：脚本名称
   
  扩展命令
  bash -n test03.sh 检查脚本语法错误
  bash -x test03.sh 查看脚本的执行流程（步骤）
  
Shell中的变量
 JAVA中的变量：
  修饰符 类型 变量名称
  private string name="张三";

1.系统变量
  $HOME、$PWD、$SHELL、$USER等
 2.自定义变量(shell中的变量没有明显的数据类型区分)
 普通变量
  定义变量：变量名=值 （注意：1.等号两边不要出现空格 2.变量名称不要有特殊字符 3.变量名称不能以数字和特殊字符开头）
  读取变量：echo $变量名
  撤销变量：unset 变量名
  静态变量（一旦创建，只可读）: readonly 变量名=值
  
  变量的作用域（只在当前会话和当前用户下有效）
  
 全局环境变量（export）
  定义变量：export 变量名=值
  全局环境变量的作用域（只在当前会话下的所有用户有效）
 
 系统环境变量
  vim /etc/profile
   #系统环境变量
   export CLASS22=ljh
  一定要激活：source /etc/profile
  系统环境变量的作用域（针对于所有会话下的所有用户都有效）
  
 查看所有变量
  使用set命令
  
 特殊的变量
  #!/bin/bash

<<EOF
  特殊变量介绍和使用
  $n 功能描述：n为数字，$0代表该脚本名称，$1-$9代表第一到第九个参数，十以上的参数，十以上的参数需要用大括号包含，如${10}

$#:获取所有输入参数个数，常用于循环

$*:这个变量代表命令行中所有的参数，$*把所有的参数看成一个整体
  $@:这个变量也代表命令行中所有的参数，不过$@把每个参数区分对待
  $?:表示读取命令的直接结果状态，返回的变量值为0，说明执行成功，非0则失败
  EOF

echo $0 $1 $2 ${11}

echo "参数的个数为:" $#

echo "$/*" $*
  echo "$/@" $@
  
==================================Shell中的数组
JAVA中的数组：
 String[] fields={"a","b","c",....}
 
Shell中的数组：
 数组名=(元素 元素 元素 元素 元素) 元素之间以空格分割,索引从0开始，自增
  arr=(1 2 3 4 5 6 7)
 根据索引读取数组元素：echo ${arr[0]}
 获取数据组的长度：echo ${#arr[*]} | echo ${#arr[@]}
 获取数组中所有的元素：echo ${arr[*]} | echo ${arr[@]}
 修改数组：
  (1)可以直接给变量重新赋值
  (2)可以根据所有修改数组例如：arr[1]=c
 
 for循环遍历数组
  #!/bin/bash
  myarray=(1 2 3 4 5 6 7 8 9)
  for i in ${myarray[@]}
  do
   echo $i
  done

================运算符
JAVA中的运算：
 private int num1=6
 private int num2=3
 int result=num1/num2
 
Shell中的运算：
 “$((运算式))”或“$[运算式]”  + , - , *,  /,  %    加，减，乘，除，取余
  echo $(($A/$B)) | echo $[$A/$B]
  echo $(($A+$B)) | echo $[$A+$B]
  echo $(($A-$B)) | echo $[$A-$B]
  echo $(($A%$B)) | echo $[$A%$B]
  
  echo $[(3+5)*$A]
 
 expr  + , - , \*,  /,  %    加，减，乘，除，取余
  注意：expr运算符间要有空格
  expr $A \* $B
  
  expr `expr 3 + 5 ` \* $A
  
 小数运算格式
  echo $(echo "scale=1;5/2" | bc)
  
==========Shell中的条件判断
JAVA中的条件判断
 private int num1=6
 private int num2=3
 if(num1>num2){
  sout(.....)
 }else{
  sout(.....)
 }
Shell中的条件判断
 [ condition ]（注意condition前后要有空格）
 注意：条件非空即为true，[ jinghang ]返回true，[] 返回false。
 
 （1）两个整数之间比较
  = 字符串比较
  -lt 小于（less than）   -le 小于等于（less equal）
  -eq 等于（equal）    -gt 大于（greater than）
  -ge 大于等于（greater equal） -ne 不等于（Not equal）
  
  [ $A -lt $B ] :比较变量A是否小于变量B
  
 （2）按照文件权限进行判断
  -r 有读的权限（read）   -w 有写的权限（write）
  -x 有执行的权限（execute）
  
  [ -w test06.sh ] ： 判断文件是否有可写权限
  
 （3）按照文件类型进行判断
  -f 文件存在并且是一个常规的文件（file）
  -e 文件存在（existence）  -d 文件存在并是一个目录（directory）
  
  [ -f test04.sh ] ：判断文件是否存在，并且是一个常规文件
  
 多条件判断：多条件判断（&& 表示前一条命令执行成功时，才执行后一条命令，|| 表示上一条命令执行失败后，才执行下一条命令）
 [root@Linux2 class22_shell]# [ -e test100.sh ] || echo "FALSE"
  FALSE
  
 [root@Linux2 class22_shell]# [ -e test04.sh ] && echo "TRUE"
  TRUE
  
Shell重中之重点（流程控制）
JAVA if条件判断
 private int num1=6
 private int num2=3
 if(num1>num2){
  sout(.....)
 }else{
  sout(.....)
 }
Shell中的条件判断
 if [ 条件判断式 ]
 then
  主体代码
 fi
 ------------------------
 if [ 条件判断式 ]
 then
  主体代码
 elif [条件判断式]
 then
  主体代码
 else
  主体代码
 fi
 ------------------------------
 if [ 条件判断式 ]
 then
  主体代码
 else
  主体代码
 fi
 
 ---------------------
 （1）[ 条件判断式 ]，中括号和条件判断式之间必须有空格
 （2）if后要有空格
 
 完成一个脚本，传入一个文件的名称，如果改文件是一个常规文件
 （1）往这个常规文件中写入 bbbb
 （2）如果不是常规文件,打印该文件不是常规文件
 
 #!/bin/bash
 if [ -f $1 ]
 then
  echo bbbb >> $1
 else
  echo "这个文件不是一个常规文件"
 fi
 
 完成一个脚本，传入两个参数，
 判断参数大小，用大的减小的，
 如果相等，则输出两个数值相同
 #!/bin/bash
 if [ $1 -gt  $2 ]
 then
  echo $[$1-$2]
 elif [ $1 -lt $2 ]
 then
  echo $[$2-$1]
 else
  echo "两个参数的数值相同"
 fi

=======shell中case的使用
JAVA中的switch
 int a = 111;
 switch(a){
  case 111:
   .....;
   break;
  case 222:
   .....;
   break;
  ....
  default：
  .....;
   break;
 }

shell中case的使用
 注意事项：
 1)case行尾必须为单词“in”，每一个模式匹配必须以右括号“）”结束。
 2)双分号“;;”表示命令序列结束，相当于java中的break。
 3)最后的“*）”表示默认模式，相当于java中的default。
 
 写一个脚本
 如果传入的数字是2；打印2
 如果传入的数字是3；打印3
 如果传入的数字是4；打印4
 其他的数字：打印"其他"
 
 #!/bin/bash
 case $1 in
  1)
  echo "1"
  ;;
  2)
  echo "2"
  ;;
  3)
  echo "3"
  ;;
  *)
  echo "其他"
  ;;
 esac
 
 
=======for循环====================
JAVA中的for循环
 for(i=0;i<100;i++){

}

for xxx in xxx{

}

Shell中的for循环
 写法一
 sum=0
 for((i=0;i<=100;i++))
 do
   sum=$[$sum+$i]
 done

echo $sum
 
 写法二
 <<EOF
        $*:读取传入脚本中的全部参数,把参数看作一个整体
        $@:读取传入脚本中的全部参数,把参数区分对待
 EOF

for i in "$*"
 do
   echo "$/*" $i
 done

for j in "$@"
 do
   echo "$/@" $j
 done
 
======while循环
JAVA中的while循环
 while(i<100){
  主体代码
 }
 
Shell中的while循环
 while [ 条件判断式 ]
   do
  程序
   done
  
  样例：
  #!/bin/bash
  <<EOF
  while 循环完成1到100之间的所有基数的和
  EOF

i=1
  sum=0
  while [ $i -le 100 ]
  do
   if [ $[$i%2] -ne 0 ]
   then
    sum=$[$sum+$i]
   fi
   i=$[$i+1]  
  done
  echo $sum

流程控制：if case for while

=========read读取控制台输入的参数========
 #!/bin/bash
 read -t 5 -p "请输入一个数字" A
 echo $A

#判断参数存不存在
 if [ ! -n "$A" ]
 then
  echo "没有获取到参数"
 else
  i=1
  sum=0
  while [ $i -le $A ]
  do
   if [ $[$i%2] -ne 0 ]
   then
    sum=$[$sum+$i]
   fi
   i=$[$i+1]  
  done
  echo $sum
 fi

==========================函数===============
系统函数
basename作用：从文件的绝对路径中，获取文件的名称，可以去除文件的后缀
 [root@Linux2 class22_shell]# basename /root/class22_shell/while12.sh
 while12.sh
 [root@Linux2 class22_shell]# basename /root/class22_shell/while12.sh .sh
 while12
dirname 文件绝对路径  （功能描述：从给定的包含绝对路径的文件名中去除文件名（非目录的部分），然后返回剩下的路径（目录的部分））
[root@Linux2 class22_shell]# dirname /root/class22_shell/while12.sh
/root/class22_shell

自定义函数

#!/bin/bash
 <<EOF
 使用Shell中的函数完成两个数字的累加
 EOF
 函数的创建
 function print()
 {
  echo "hello word"
  return 2
 }
 函数的创建
 function add()
 {
  sum=0
  sum=$[$1+$2]
  echo $sum
 }

read -t 5 -p "请输入第一个参数" arg1
 read -t 5 -p "请输入第一个参数" arg2
 
 函数的调用
 add $arg1 $arg2
 print
 
 注意：调用函数时，直接写函数名完成调用，一定要注意，调用一定要在函数下
 1.无参无返回值
 2.无参数，有返回值 （返回值使用return，0~255之间）
 3.有参，有返回值
 4.有参，无返回值
 
================正则表达式======
单字符匹配
 . 匹配除了换行符之外的任意字符
 \d 匹配数字0~9 =>[0-9]
 \D 匹配非数字  => [^0-9]
 [a-z] 匹配字符a-z
 \s 匹配空白字符
 \S 表示匹配非空白字符
 \w 表示匹配单词字符[a-zA-Z0-9_]
 \W 表示匹配非单词字符
 ....
 ^ 表示匹配以...开头
 $ 表示匹配以...结尾
多字符匹配(贪婪模式,尽可能多的匹配)
 * ：表示匹配*号前的字符(表达式)任意次（0~无限次）
 + ：表示匹配*号前的字符(表达式)至少1次
 ？：表示匹配？号前的字符(表达式)0~1次
 {n}: 表示匹配{n}号前的字符n次
 {n,m}: 表示匹配{n,m}号前的字符n~m次
非贪婪模式（尽可能少的匹配）
 *？
 +？
 ??
其他
 |  或
 () 分组

1.用一句话概括Shell
 Shell是一个解释器，介于应用程序（用户）和操作系统之间的一个桥梁，负责命令的解释

2.Shell的编程语言
编译型语言:
 程序在执行之前需要个专门的编译过程，把程序编译成为机器语言文件，运行时不需要重新翻译，直接使用编译的结果就行了。程序执行效率高，依养编译器，跨平台性差些。如C、C++、java
 
解释型语言:
 程序不需要编译，程序在运行时由解释器翻译成机器语言，每执行一次都要翻译一次。因此效率比较低。比如Python/javaScript/Shell等都是解释型语言。
 
Shell的解析器：
 /bin/sh       是bash的一个快捷方式
 /bin/bash（最多）     bash是大多数Linux默认的shell，包含的功能几乎可以涵盖shell所有的功能
 /sbin/nologin   表示非交互，不能登录操作系统
 /bin/dash     小巧，高效，功能相比少一些

/bin/tcsh     具有C语言风格的一种shell，具有许多特性，但是也有一些缺陷
 /bin/csh      是csh的增强版本，完全兼容csh
 
 [ljh@Linux2 ~]$ ll /bin | grep bash
 -rwxr-xr-x. 1 root root 942200 3月  23 2017 bash
 lrwxrwxrwx. 1 root root      4 2月   3 23:07 sh -> bash
 
Shell编程语言目的：
 写脚本
学习Shell语言的方法：
 最简单的语言、技巧（多看、多读、借鉴、思考）
使用场景：
 完成自动化的工作：自动化部署、自动化的分析等 （ 自动化运维 ）

什么是脚本？
 脚本就是将需要执行的命令保存到文本中，按照顺序执行（由上往下执行），它是解释型的，不需要编译。
 
布置一个简单的任务：(执行mkdir -p class22/test)
 1.删除class22中的test文件夹
 2.在class22文件夹中新建一个test2 文件夹，在test2中新建dir1、dir2、dir3三个子目录
 3.在dir2中新建一个class22.txt文件,
 4.往class22.txt文件中写入libai
 5.打印一句话"任务执行完毕 2020-2-12 10:24"
 
 写一个脚本
 step1在第一行（指明解析器）：#!/bin/bash 或者 #!/bin/env bash
 step2添加描述信息：（脚本名称、路径、描述、创建时间、修改时间、编辑人）
 step3编写脚本主体代码
 
 #!/bin/bash
 #NAME:test03.sh
 #DESC:第一个脚本任务
 #CREATETIME:2020-2-12 10：44
 #CREATE:wangwu
 #PATH:/root/class22_shell
 <<EOF
 asnckas
 jsacbsal
 EOF
 <<!
 a KD
 asc las
 !

#1.删除class22中的test文件夹
 rm -rf /root/class22_shell/class22/test
 #2.在class22文件夹中新建一个test2 文件夹，在test2中新建dir1、dir2、dir3三个子目录
 mkdir -p /root/class22_shell/class22/test2/dir{1..3} 
 #3.在dir2中新建一个class22.txt文件
 touch /root/class22_shell/class22/test2/dir2/class22.txt
 #4.往class22.txt文件中写入libai
 echo libai >>  /root/class22_shell/class22/test2/dir2/class22.txt
 #5.打印一句话"任务执行完毕 2020-2-12 10:24"
 echo "任务执行完毕 `date "+%Y-%m-%d %H:%M:%S"`"
 
 step4:执行脚本
  执行方式一：
   sh/bash 绝对路径|相对路径
   source 绝对路径|相对路径
   
  执行方式二：（注意脚本中的指定的解析器一定不要写错）
   推荐的执行方式：给脚本添加执行权限
    chmod +x 脚本名称
   执行：./脚本名称
  
   如果需要在任意地方执行脚本，需要将脚本移动至/bin目录
   执行：脚本名称
   
  扩展命令
  bash -n test03.sh 检查脚本语法错误
  bash -x test03.sh 查看脚本的执行流程（步骤）
  
Shell中的变量
 JAVA中的变量：
  修饰符 类型 变量名称
  private string name="张三";

1.系统变量
  $HOME、$PWD、$SHELL、$USER等
 2.自定义变量(shell中的变量没有明显的数据类型区分)
 普通变量
  定义变量：变量名=值 （注意：1.等号两边不要出现空格 2.变量名称不要有特殊字符 3.变量名称不能以数字和特殊字符开头）
  读取变量：echo $变量名
  撤销变量：unset 变量名
  静态变量（一旦创建，只可读）: readonly 变量名=值
  
  变量的作用域（只在当前会话和当前用户下有效）
  
 全局环境变量（export）
  定义变量：export 变量名=值
  全局环境变量的作用域（只在当前会话下的所有用户有效）
 
 系统环境变量
  vim /etc/profile
   #系统环境变量
   export CLASS22=ljh
  一定要激活：source /etc/profile
  系统环境变量的作用域（针对于所有会话下的所有用户都有效）
  
 查看所有变量
  使用set命令
  
 特殊的变量
  #!/bin/bash

<<EOF
  特殊变量介绍和使用
  $n 功能描述：n为数字，$0代表该脚本名称，$1-$9代表第一到第九个参数，十以上的参数，十以上的参数需要用大括号包含，如${10}

$#:获取所有输入参数个数，常用于循环

$*:这个变量代表命令行中所有的参数，$*把所有的参数看成一个整体
  $@:这个变量也代表命令行中所有的参数，不过$@把每个参数区分对待
  $?:表示读取命令的直接结果状态，返回的变量值为0，说明执行成功，非0则失败
  EOF

echo $0 $1 $2 ${11}

echo "参数的个数为:" $#

echo "$/*" $*
  echo "$/@" $@
  
==================================Shell中的数组
JAVA中的数组：
 String[] fields={"a","b","c",....}
 
Shell中的数组：
 数组名=(元素 元素 元素 元素 元素) 元素之间以空格分割,索引从0开始，自增
  arr=(1 2 3 4 5 6 7)
 根据索引读取数组元素：echo ${arr[0]}
 获取数据组的长度：echo ${#arr[*]} | echo ${#arr[@]}
 获取数组中所有的元素：echo ${arr[*]} | echo ${arr[@]}
 修改数组：
  (1)可以直接给变量重新赋值
  (2)可以根据所有修改数组例如：arr[1]=c
 
 for循环遍历数组
  #!/bin/bash
  myarray=(1 2 3 4 5 6 7 8 9)
  for i in ${myarray[@]}
  do
   echo $i
  done

================运算符
JAVA中的运算：
 private int num1=6
 private int num2=3
 int result=num1/num2
 
Shell中的运算：
 “$((运算式))”或“$[运算式]”  + , - , *,  /,  %    加，减，乘，除，取余
  echo $(($A/$B)) | echo $[$A/$B]
  echo $(($A+$B)) | echo $[$A+$B]
  echo $(($A-$B)) | echo $[$A-$B]
  echo $(($A%$B)) | echo $[$A%$B]
  
  echo $[(3+5)*$A]
 
 expr  + , - , \*,  /,  %    加，减，乘，除，取余
  注意：expr运算符间要有空格
  expr $A \* $B
  
  expr `expr 3 + 5 ` \* $A
  
 小数运算格式
  echo $(echo "scale=1;5/2" | bc)
  
==========Shell中的条件判断
JAVA中的条件判断
 private int num1=6
 private int num2=3
 if(num1>num2){
  sout(.....)
 }else{
  sout(.....)
 }
Shell中的条件判断
 [ condition ]（注意condition前后要有空格）
 注意：条件非空即为true，[ jinghang ]返回true，[] 返回false。
 
 （1）两个整数之间比较
  = 字符串比较
  -lt 小于（less than）   -le 小于等于（less equal）
  -eq 等于（equal）    -gt 大于（greater than）
  -ge 大于等于（greater equal） -ne 不等于（Not equal）
  
  [ $A -lt $B ] :比较变量A是否小于变量B
  
 （2）按照文件权限进行判断
  -r 有读的权限（read）   -w 有写的权限（write）
  -x 有执行的权限（execute）
  
  [ -w test06.sh ] ： 判断文件是否有可写权限
  
 （3）按照文件类型进行判断
  -f 文件存在并且是一个常规的文件（file）
  -e 文件存在（existence）  -d 文件存在并是一个目录（directory）
  
  [ -f test04.sh ] ：判断文件是否存在，并且是一个常规文件
  
 多条件判断：多条件判断（&& 表示前一条命令执行成功时，才执行后一条命令，|| 表示上一条命令执行失败后，才执行下一条命令）
 [root@Linux2 class22_shell]# [ -e test100.sh ] || echo "FALSE"
  FALSE
  
 [root@Linux2 class22_shell]# [ -e test04.sh ] && echo "TRUE"
  TRUE
  
Shell重中之重点（流程控制）
JAVA if条件判断
 private int num1=6
 private int num2=3
 if(num1>num2){
  sout(.....)
 }else{
  sout(.....)
 }
Shell中的条件判断
 if [ 条件判断式 ]
 then
  主体代码
 fi
 ------------------------
 if [ 条件判断式 ]
 then
  主体代码
 elif [条件判断式]
 then
  主体代码
 else
  主体代码
 fi
 ------------------------------
 if [ 条件判断式 ]
 then
  主体代码
 else
  主体代码
 fi
 
 ---------------------
 （1）[ 条件判断式 ]，中括号和条件判断式之间必须有空格
 （2）if后要有空格
 
 完成一个脚本，传入一个文件的名称，如果改文件是一个常规文件
 （1）往这个常规文件中写入 bbbb
 （2）如果不是常规文件,打印该文件不是常规文件
 
 #!/bin/bash
 if [ -f $1 ]
 then
  echo bbbb >> $1
 else
  echo "这个文件不是一个常规文件"
 fi
 
 完成一个脚本，传入两个参数，
 判断参数大小，用大的减小的，
 如果相等，则输出两个数值相同
 #!/bin/bash
 if [ $1 -gt  $2 ]
 then
  echo $[$1-$2]
 elif [ $1 -lt $2 ]
 then
  echo $[$2-$1]
 else
  echo "两个参数的数值相同"
 fi

=======shell中case的使用
JAVA中的switch
 int a = 111;
 switch(a){
  case 111:
   .....;
   break;
  case 222:
   .....;
   break;
  ....
  default：
  .....;
   break;
 }

shell中case的使用
 注意事项：
 1)case行尾必须为单词“in”，每一个模式匹配必须以右括号“）”结束。
 2)双分号“;;”表示命令序列结束，相当于java中的break。
 3)最后的“*）”表示默认模式，相当于java中的default。
 
 写一个脚本
 如果传入的数字是2；打印2
 如果传入的数字是3；打印3
 如果传入的数字是4；打印4
 其他的数字：打印"其他"
 
 #!/bin/bash
 case $1 in
  1)
  echo "1"
  ;;
  2)
  echo "2"
  ;;
  3)
  echo "3"
  ;;
  *)
  echo "其他"
  ;;
 esac
 
 
=======for循环====================
JAVA中的for循环
 for(i=0;i<100;i++){

}

for xxx in xxx{

}

Shell中的for循环
 写法一
 sum=0
 for((i=0;i<=100;i++))
 do
   sum=$[$sum+$i]
 done

echo $sum
 
 写法二
 <<EOF
        $*:读取传入脚本中的全部参数,把参数看作一个整体
        $@:读取传入脚本中的全部参数,把参数区分对待
 EOF

for i in "$*"
 do
   echo "$/*" $i
 done

for j in "$@"
 do
   echo "$/@" $j
 done
 
======while循环
JAVA中的while循环
 while(i<100){
  主体代码
 }
 
Shell中的while循环
 while [ 条件判断式 ]
   do
  程序
   done
  
  样例：
  #!/bin/bash
  <<EOF
  while 循环完成1到100之间的所有基数的和
  EOF

i=1
  sum=0
  while [ $i -le 100 ]
  do
   if [ $[$i%2] -ne 0 ]
   then
    sum=$[$sum+$i]
   fi
   i=$[$i+1]  
  done
  echo $sum

流程控制：if case for while

=========read读取控制台输入的参数========
 #!/bin/bash
 read -t 5 -p "请输入一个数字" A
 echo $A

#判断参数存不存在
 if [ ! -n "$A" ]
 then
  echo "没有获取到参数"
 else
  i=1
  sum=0
  while [ $i -le $A ]
  do
   if [ $[$i%2] -ne 0 ]
   then
    sum=$[$sum+$i]
   fi
   i=$[$i+1]  
  done
  echo $sum
 fi

==========================函数===============
系统函数
basename作用：从文件的绝对路径中，获取文件的名称，可以去除文件的后缀
 [root@Linux2 class22_shell]# basename /root/class22_shell/while12.sh
 while12.sh
 [root@Linux2 class22_shell]# basename /root/class22_shell/while12.sh .sh
 while12
dirname 文件绝对路径  （功能描述：从给定的包含绝对路径的文件名中去除文件名（非目录的部分），然后返回剩下的路径（目录的部分））
[root@Linux2 class22_shell]# dirname /root/class22_shell/while12.sh
/root/class22_shell

自定义函数

#!/bin/bash
 <<EOF
 使用Shell中的函数完成两个数字的累加
 EOF
 函数的创建
 function print()
 {
  echo "hello word"
  return 2
 }
 函数的创建
 function add()
 {
  sum=0
  sum=$[$1+$2]
  echo $sum
 }

read -t 5 -p "请输入第一个参数" arg1
 read -t 5 -p "请输入第一个参数" arg2
 
 函数的调用
 add $arg1 $arg2
 print
 
 注意：调用函数时，直接写函数名完成调用，一定要注意，调用一定要在函数下
 1.无参无返回值
 2.无参数，有返回值 （返回值使用return，0~255之间）
 3.有参，有返回值
 4.有参，无返回值
 
================正则表达式======
单字符匹配
 . 匹配除了换行符之外的任意字符
 \d 匹配数字0~9 =>[0-9]
 \D 匹配非数字  => [^0-9]
 [a-z] 匹配字符a-z
 \s 匹配空白字符
 \S 表示匹配非空白字符
 \w 表示匹配单词字符[a-zA-Z0-9_]
 \W 表示匹配非单词字符
 ....
 ^ 表示匹配以...开头
 $ 表示匹配以...结尾
多字符匹配(贪婪模式,尽可能多的匹配)
 * ：表示匹配*号前的字符(表达式)任意次（0~无限次）
 + ：表示匹配*号前的字符(表达式)至少1次
 ？：表示匹配？号前的字符(表达式)0~1次
 {n}: 表示匹配{n}号前的字符n次
 {n,m}: 表示匹配{n,m}号前的字符n~m次
非贪婪模式（尽可能少的匹配）
 *？
 +？
 ??
其他
 |  或
 () 分组

1.用一句话概括Shell
 Shell是一个解释器，介于应用程序（用户）和操作系统之间的一个桥梁，负责命令的解释

2.Shell的编程语言
编译型语言:
 程序在执行之前需要个专门的编译过程，把程序编译成为机器语言文件，运行时不需要重新翻译，直接使用编译的结果就行了。程序执行效率高，依养编译器，跨平台性差些。如C、C++、java
 
解释型语言:
 程序不需要编译，程序在运行时由解释器翻译成机器语言，每执行一次都要翻译一次。因此效率比较低。比如Python/javaScript/Shell等都是解释型语言。
 
Shell的解析器：
 /bin/sh       是bash的一个快捷方式
 /bin/bash（最多）     bash是大多数Linux默认的shell，包含的功能几乎可以涵盖shell所有的功能
 /sbin/nologin   表示非交互，不能登录操作系统
 /bin/dash     小巧，高效，功能相比少一些

/bin/tcsh     具有C语言风格的一种shell，具有许多特性，但是也有一些缺陷
 /bin/csh      是csh的增强版本，完全兼容csh
 
 [ljh@Linux2 ~]$ ll /bin | grep bash
 -rwxr-xr-x. 1 root root 942200 3月  23 2017 bash
 lrwxrwxrwx. 1 root root      4 2月   3 23:07 sh -> bash
 
Shell编程语言目的：
 写脚本
学习Shell语言的方法：
 最简单的语言、技巧（多看、多读、借鉴、思考）
使用场景：
 完成自动化的工作：自动化部署、自动化的分析等 （ 自动化运维 ）

什么是脚本？
 脚本就是将需要执行的命令保存到文本中，按照顺序执行（由上往下执行），它是解释型的，不需要编译。
 
布置一个简单的任务：(执行mkdir -p class22/test)
 1.删除class22中的test文件夹
 2.在class22文件夹中新建一个test2 文件夹，在test2中新建dir1、dir2、dir3三个子目录
 3.在dir2中新建一个class22.txt文件,
 4.往class22.txt文件中写入libai
 5.打印一句话"任务执行完毕 2020-2-12 10:24"
 
 写一个脚本
 step1在第一行（指明解析器）：#!/bin/bash 或者 #!/bin/env bash
 step2添加描述信息：（脚本名称、路径、描述、创建时间、修改时间、编辑人）
 step3编写脚本主体代码
 
 #!/bin/bash
 #NAME:test03.sh
 #DESC:第一个脚本任务
 #CREATETIME:2020-2-12 10：44
 #CREATE:wangwu
 #PATH:/root/class22_shell
 <<EOF
 asnckas
 jsacbsal
 EOF
 <<!
 a KD
 asc las
 !

#1.删除class22中的test文件夹
 rm -rf /root/class22_shell/class22/test
 #2.在class22文件夹中新建一个test2 文件夹，在test2中新建dir1、dir2、dir3三个子目录
 mkdir -p /root/class22_shell/class22/test2/dir{1..3} 
 #3.在dir2中新建一个class22.txt文件
 touch /root/class22_shell/class22/test2/dir2/class22.txt
 #4.往class22.txt文件中写入libai
 echo libai >>  /root/class22_shell/class22/test2/dir2/class22.txt
 #5.打印一句话"任务执行完毕 2020-2-12 10:24"
 echo "任务执行完毕 `date "+%Y-%m-%d %H:%M:%S"`"
 
 step4:执行脚本
  执行方式一：
   sh/bash 绝对路径|相对路径
   source 绝对路径|相对路径
   
  执行方式二：（注意脚本中的指定的解析器一定不要写错）
   推荐的执行方式：给脚本添加执行权限
    chmod +x 脚本名称
   执行：./脚本名称
  
   如果需要在任意地方执行脚本，需要将脚本移动至/bin目录
   执行：脚本名称
   
  扩展命令
  bash -n test03.sh 检查脚本语法错误
  bash -x test03.sh 查看脚本的执行流程（步骤）
  
Shell中的变量
 JAVA中的变量：
  修饰符 类型 变量名称
  private string name="张三";

1.系统变量
  $HOME、$PWD、$SHELL、$USER等
 2.自定义变量(shell中的变量没有明显的数据类型区分)
 普通变量
  定义变量：变量名=值 （注意：1.等号两边不要出现空格 2.变量名称不要有特殊字符 3.变量名称不能以数字和特殊字符开头）
  读取变量：echo $变量名
  撤销变量：unset 变量名
  静态变量（一旦创建，只可读）: readonly 变量名=值
  
  变量的作用域（只在当前会话和当前用户下有效）
  
 全局环境变量（export）
  定义变量：export 变量名=值
  全局环境变量的作用域（只在当前会话下的所有用户有效）
 
 系统环境变量
  vim /etc/profile
   #系统环境变量
   export CLASS22=ljh
  一定要激活：source /etc/profile
  系统环境变量的作用域（针对于所有会话下的所有用户都有效）
  
 查看所有变量
  使用set命令
  
 特殊的变量
  #!/bin/bash

<<EOF
  特殊变量介绍和使用
  $n 功能描述：n为数字，$0代表该脚本名称，$1-$9代表第一到第九个参数，十以上的参数，十以上的参数需要用大括号包含，如${10}

$#:获取所有输入参数个数，常用于循环

$*:这个变量代表命令行中所有的参数，$*把所有的参数看成一个整体
  $@:这个变量也代表命令行中所有的参数，不过$@把每个参数区分对待
  $?:表示读取命令的直接结果状态，返回的变量值为0，说明执行成功，非0则失败
  EOF

echo $0 $1 $2 ${11}

echo "参数的个数为:" $#

echo "$/*" $*
  echo "$/@" $@
  
==================================Shell中的数组
JAVA中的数组：
 String[] fields={"a","b","c",....}
 
Shell中的数组：
 数组名=(元素 元素 元素 元素 元素) 元素之间以空格分割,索引从0开始，自增
  arr=(1 2 3 4 5 6 7)
 根据索引读取数组元素：echo ${arr[0]}
 获取数据组的长度：echo ${#arr[*]} | echo ${#arr[@]}
 获取数组中所有的元素：echo ${arr[*]} | echo ${arr[@]}
 修改数组：
  (1)可以直接给变量重新赋值
  (2)可以根据所有修改数组例如：arr[1]=c
 
 for循环遍历数组
  #!/bin/bash
  myarray=(1 2 3 4 5 6 7 8 9)
  for i in ${myarray[@]}
  do
   echo $i
  done

================运算符
JAVA中的运算：
 private int num1=6
 private int num2=3
 int result=num1/num2
 
Shell中的运算：
 “$((运算式))”或“$[运算式]”  + , - , *,  /,  %    加，减，乘，除，取余
  echo $(($A/$B)) | echo $[$A/$B]
  echo $(($A+$B)) | echo $[$A+$B]
  echo $(($A-$B)) | echo $[$A-$B]
  echo $(($A%$B)) | echo $[$A%$B]
  
  echo $[(3+5)*$A]
 
 expr  + , - , \*,  /,  %    加，减，乘，除，取余
  注意：expr运算符间要有空格
  expr $A \* $B
  
  expr `expr 3 + 5 ` \* $A
  
 小数运算格式
  echo $(echo "scale=1;5/2" | bc)
  
==========Shell中的条件判断
JAVA中的条件判断
 private int num1=6
 private int num2=3
 if(num1>num2){
  sout(.....)
 }else{
  sout(.....)
 }
Shell中的条件判断
 [ condition ]（注意condition前后要有空格）
 注意：条件非空即为true，[ jinghang ]返回true，[] 返回false。
 
 （1）两个整数之间比较
  = 字符串比较
  -lt 小于（less than）   -le 小于等于（less equal）
  -eq 等于（equal）    -gt 大于（greater than）
  -ge 大于等于（greater equal） -ne 不等于（Not equal）
  
  [ $A -lt $B ] :比较变量A是否小于变量B
  
 （2）按照文件权限进行判断
  -r 有读的权限（read）   -w 有写的权限（write）
  -x 有执行的权限（execute）
  
  [ -w test06.sh ] ： 判断文件是否有可写权限
  
 （3）按照文件类型进行判断
  -f 文件存在并且是一个常规的文件（file）
  -e 文件存在（existence）  -d 文件存在并是一个目录（directory）
  
  [ -f test04.sh ] ：判断文件是否存在，并且是一个常规文件
  
 多条件判断：多条件判断（&& 表示前一条命令执行成功时，才执行后一条命令，|| 表示上一条命令执行失败后，才执行下一条命令）
 [root@Linux2 class22_shell]# [ -e test100.sh ] || echo "FALSE"
  FALSE
  
 [root@Linux2 class22_shell]# [ -e test04.sh ] && echo "TRUE"
  TRUE
  
Shell重中之重点（流程控制）
JAVA if条件判断
 private int num1=6
 private int num2=3
 if(num1>num2){
  sout(.....)
 }else{
  sout(.....)
 }
Shell中的条件判断
 if [ 条件判断式 ]
 then
  主体代码
 fi
 ------------------------
 if [ 条件判断式 ]
 then
  主体代码
 elif [条件判断式]
 then
  主体代码
 else
  主体代码
 fi
 ------------------------------
 if [ 条件判断式 ]
 then
  主体代码
 else
  主体代码
 fi
 
 ---------------------
 （1）[ 条件判断式 ]，中括号和条件判断式之间必须有空格
 （2）if后要有空格
 
 完成一个脚本，传入一个文件的名称，如果改文件是一个常规文件
 （1）往这个常规文件中写入 bbbb
 （2）如果不是常规文件,打印该文件不是常规文件
 
 #!/bin/bash
 if [ -f $1 ]
 then
  echo bbbb >> $1
 else
  echo "这个文件不是一个常规文件"
 fi
 
 完成一个脚本，传入两个参数，
 判断参数大小，用大的减小的，
 如果相等，则输出两个数值相同
 #!/bin/bash
 if [ $1 -gt  $2 ]
 then
  echo $[$1-$2]
 elif [ $1 -lt $2 ]
 then
  echo $[$2-$1]
 else
  echo "两个参数的数值相同"
 fi

=======shell中case的使用
JAVA中的switch
 int a = 111;
 switch(a){
  case 111:
   .....;
   break;
  case 222:
   .....;
   break;
  ....
  default：
  .....;
   break;
 }

shell中case的使用
 注意事项：
 1)case行尾必须为单词“in”，每一个模式匹配必须以右括号“）”结束。
 2)双分号“;;”表示命令序列结束，相当于java中的break。
 3)最后的“*）”表示默认模式，相当于java中的default。
 
 写一个脚本
 如果传入的数字是2；打印2
 如果传入的数字是3；打印3
 如果传入的数字是4；打印4
 其他的数字：打印"其他"
 
 #!/bin/bash
 case $1 in
  1)
  echo "1"
  ;;
  2)
  echo "2"
  ;;
  3)
  echo "3"
  ;;
  *)
  echo "其他"
  ;;
 esac
 
 
=======for循环====================
JAVA中的for循环
 for(i=0;i<100;i++){

}

for xxx in xxx{

}

Shell中的for循环
 写法一
 sum=0
 for((i=0;i<=100;i++))
 do
   sum=$[$sum+$i]
 done

echo $sum
 
 写法二
 <<EOF
        $*:读取传入脚本中的全部参数,把参数看作一个整体
        $@:读取传入脚本中的全部参数,把参数区分对待
 EOF

for i in "$*"
 do
   echo "$/*" $i
 done

for j in "$@"
 do
   echo "$/@" $j
 done
 
======while循环
JAVA中的while循环
 while(i<100){
  主体代码
 }
 
Shell中的while循环
 while [ 条件判断式 ]
   do
  程序
   done
  
  样例：
  #!/bin/bash
  <<EOF
  while 循环完成1到100之间的所有基数的和
  EOF

i=1
  sum=0
  while [ $i -le 100 ]
  do
   if [ $[$i%2] -ne 0 ]
   then
    sum=$[$sum+$i]
   fi
   i=$[$i+1]  
  done
  echo $sum

流程控制：if case for while

=========read读取控制台输入的参数========
 #!/bin/bash
 read -t 5 -p "请输入一个数字" A
 echo $A

#判断参数存不存在
 if [ ! -n "$A" ]
 then
  echo "没有获取到参数"
 else
  i=1
  sum=0
  while [ $i -le $A ]
  do
   if [ $[$i%2] -ne 0 ]
   then
    sum=$[$sum+$i]
   fi
   i=$[$i+1]  
  done
  echo $sum
 fi

==========================函数===============
系统函数
basename作用：从文件的绝对路径中，获取文件的名称，可以去除文件的后缀
 [root@Linux2 class22_shell]# basename /root/class22_shell/while12.sh
 while12.sh
 [root@Linux2 class22_shell]# basename /root/class22_shell/while12.sh .sh
 while12
dirname 文件绝对路径  （功能描述：从给定的包含绝对路径的文件名中去除文件名（非目录的部分），然后返回剩下的路径（目录的部分））
[root@Linux2 class22_shell]# dirname /root/class22_shell/while12.sh
/root/class22_shell

自定义函数

#!/bin/bash
 <<EOF
 使用Shell中的函数完成两个数字的累加
 EOF
 函数的创建
 function print()
 {
  echo "hello word"
  return 2
 }
 函数的创建
 function add()
 {
  sum=0
  sum=$[$1+$2]
  echo $sum
 }

read -t 5 -p "请输入第一个参数" arg1
 read -t 5 -p "请输入第一个参数" arg2
 
 函数的调用
 add $arg1 $arg2
 print
 
 注意：调用函数时，直接写函数名完成调用，一定要注意，调用一定要在函数下
 1.无参无返回值
 2.无参数，有返回值 （返回值使用return，0~255之间）
 3.有参，有返回值
 4.有参，无返回值
 
================正则表达式======
单字符匹配
 . 匹配除了换行符之外的任意字符
 \d 匹配数字0~9 =>[0-9]
 \D 匹配非数字  => [^0-9]
 [a-z] 匹配字符a-z
 \s 匹配空白字符
 \S 表示匹配非空白字符
 \w 表示匹配单词字符[a-zA-Z0-9_]
 \W 表示匹配非单词字符
 ....
 ^ 表示匹配以...开头
 $ 表示匹配以...结尾
多字符匹配(贪婪模式,尽可能多的匹配)
 * ：表示匹配*号前的字符(表达式)任意次（0~无限次）
 + ：表示匹配*号前的字符(表达式)至少1次
 ？：表示匹配？号前的字符(表达式)0~1次
 {n}: 表示匹配{n}号前的字符n次
 {n,m}: 表示匹配{n,m}号前的字符n~m次
非贪婪模式（尽可能少的匹配）
 *？
 +？
 ??
其他
 |  或
 () 分组