• shell脚本基础

    摘自：一篇教会你写90%的shell脚本

    1.注释：

            单行注释：#

            多行注释： (注意第一种注释方法的 “:"后面有一个空格）

    1. : '
    2. 多行注释内容
    3. '
    4.  
    5. <<block
    6. 多行注释内容
    7. block

    2.变量：局部变量，环境变量（全局变量），shell变量有环境变量也有局部变量。

    3.变量操作：

    1. #创建普通变量：name="test"            #等号两边不允许有空格
    2. #创建局部变量：local name="test" 
    3. #创建只读变量：readonly name ="test"  #只读不可被修改、删除
    4. #变量重定义：name="new test"
    5. #使用变量：$name 或 ${name}           #eg:echo ${name}
    6. #删除变量：unset name

     4.字符串变量

    1. #!/bin/bash
    2. #----1).单引号：定义无效变量，且引号之间不允许有单独的单引号
    3. #    下述代码输出结果为：hello $name
    4. name="Hello"
    5. echo 'hello $name'
    6.  
    7. #----2).双引号：定义有效变量，
    8. #    下述代码输出结果为：hello Hello
    9. echo "hello $name" 
    10.  
    11. #----3).拼接字符串
    12. #    下述代码输出结果均为：Hello123456
    13. ID="123456"
    14. str=$name$ID
    15.  
    16. name="Hello""123456"
    17.  
    18. name='Hello''123456'
    19.  
    20. #-----4).获取字符串长度,使用 # 获取长度
    21. #    下述代码输出结果为：11
    22. echo ${#name}
    23.  
    24. #-----5).提取子字符串，${str:m:n} 截取str的从第m个字符开始的n个字符  M不写则默认为0
    25. #    下述代码输出结果为：12
    26. echo ${name:5:2}

     5.数组（bash仅支持一维数组）

    1. #!/bin/bash
    2.  
    3. #------1).定义数组：小括号做边界、空格做元素分割
    4. array_name=(dao ke dao fei chang dao)
    5.  
    6. #------2).对数组某个变量赋值
    7. array_name[0]="daode"
    8.  
    9. #------3).输出数组单个元素      输出：daode
    10. echo ${array_name[0]}
    11.  
    12. #------4).输出数组所有元素      输出：daode ke dao fei chang dao
    13. echo ${array_name[@]}
    14.  
    15. #------5).获取数组中元素个数    输出：6
    16. echo ${#array_name[@]}
    17. echo ${#array_name[*]}
    18.  
    19. #------6).获取单个元素长度      输出：3 5
    20. echo ${#array_name[3]}
    21. echo ${#array_name}            #这里相当于获取数组首个元素的长度

     6.参数传递

    1. #!/bin/bash
    2.  
    3. #获取命令行中的参数以用来计算
    4. #我们以命令行输入:  ./test.sh A=8 B=10 为例
    5. str0=$0         #一般为："./test,.sh" 当bash执行时为:"test.sh"
    6. str1=$1         #获取指令的第1个参数:A=8
    7. str2=$2         #获取指令的第2个参数:B=10
    8. a=${str1:2:2}   #截取参数中的值:8
    9. b=${str2:2:2}   #截取参数中的值:10
    10.  
    11. ((sum=a+b))
    12.  
    13. echo "执行的文件是：$0"         #输出结果：./test.sh
    14. echo "第一个参数：$1"           #输出第一个参数：A=8
    15. echo "第二个参数：$2"           #输出第二个参数：B=10
    16. echo "参数个数：$#"             #传入的参数个数
    17. echo "A+B=$sum"
    18. echo "当前脚本进程号：$$"               #当前运行的脚本的进程号
    19. echo "后台最后一个脚本进程号：$!"       #后台运行的最后一个进程的ID
    20. echo "显示脚本是否正常退出：$?"         #显示最后命令是否正常推出 0表示正常
    21. echo "*********************************"
    22. # $* :以字符串形式传递参数，每个参数都是独立的元素
    23. for var in $*
    24. do
    25.         echo ${var}
    26. done
    27. echo "-----------------------------"
    28. # $@ :以字符串形式传递参数，每个参数都是独立的元素
    29. for var in $@
    30. do
    31.         echo ${var}
    32. done
    33. echo "-----------------------------"
    34. # "$*" :将所有参数作为一个参数传递，
    35. for var in "$*"
    36. do
    37.         echo ${var}
    38. done
    39. echo "-----------------------------"
    40. # "$@" :以字符串形式传递参数，每个参数仍旧相对独立
    41. for var in "$@"
    42. do
    43.         echo ${var}
    44. done
    45. echo "********************************"

    7.七种数学计算方式

    (1) 使用let命令进行算术运算，只支持整数运算。
    (2) 使用expr命令进行算术运算，只支持整数运算。他的算式每个元素之间需要加空格
    (3) 使用运算语法：$[算术表达式]，只支持整数运算。
    (4) 使用运算语法：$((算术表达式))，只支持整数运算。常用。
    (5) 在初始化变量时declare -i，将变量定义为"整数"类型，则可直接进行整数运算。
    (6) 使用bc命令进行算术运算，支持整数和小数运算。
    (7) 使用awk命令进行算数运算，支持整数和小数运算。

    1. #!/bin/bash
    2.  
    3. a=10
    4. b=15
    5. #-----1). (())  最常用的效率也高的
    6. ((sum=a+b*54-8))        #符号内进行基本运算，变量名前不加$,
    7. sum=$((a+b+32))         #通过 $ 符号直接传递计算结果
    8. sum=$((a>b && b>=0))    #做一些逻辑运算，可用于if、while等判断语句
    9. ((sum1=a+b,sum2=a-b))   #通过 ，分割并计算多个表达式
    10. sum=$((a+b,a/b))        #这种情况，会以最后一个表达式的结果作为输出结果
    11. sum=$((--a))            #可以做自减、自增计算
    12.  
    13. #-----2). let   与(())用法类似
    14. let sum1=a+b sum2=a*b   #与(())不同，这里用 空格 分割多个计算式
    15.  
    16. #-----3). $[]   与(())用法类似
    17. sum=$[u=a+b,u2=a-b]     #同(())一样，都是用 空格 分割多个计算式
    18.  
    19. #-----4). expr  也可处理字符串。
    20. #       在shell脚本中要用 ` 符号括起来，ESC键下面那个键。
    21. #       语句中每一项都需 空格 隔开。
    22. sum=`expr 10 \* 5`                      #做乘法运算时*前要加/
    23.  
    24. #-----5). bc    用于整数和小数
    25. #       基本格式：echo "expression" | bc
    26. #       表达式默认用双引号括起来，用单引号变量会被当作字符处理。
    27. echo "10^2+sqrt(5)"|bc                  #直接输出结果
    28. sum=$(echo "15+5" | bc)                 #通过 $ 传递输出结果
    29. sum=$(echo "scale=2;($a+1)/3"|bc)       #scale 定义保留几位小数
    30. sum=$(echo "ibase=16;AA" |bc)           #进制转换，这里将16进制转换为10进制
    31. sum=$(echo "obase=16;255" |bc)          #进制转换，将十进制转换为16进制
    32.  
    33. #-----6). declare -i    直接将变量声明为整数，然后直接进行“算数计算”
    34. declare -i s            #声明 s 为证整数型变量，可直接进行运算
    35. s=$a+$b
    36. declare +i s            #取消声明。
    37.  
    38. #-----7).awk    是一个强大的文本的分析工具，少用于计算
    39. sum=$(awk 'BEGIN{print '$b'+3 }')               #算数运算，变量加单引号
    40. sum=$(awk 'BEGIN{print ('$a'+1)/3}')            #没设置保留小数位
    41. sum=$(awk 'BEGIN{printf "%.9f\n",'$b'/9}')      #printf 设置保留的小数位

    8.算术运算符

    1. #!/bin/bash
    2.  
    3. a=8
    4. b=6
    5. #算术运算符简单例子
    6. s0=$((a+b-b*a+a/b-a%b))
    7. s1=$((a**b))
    8. s2=$((a<=b))
    9. s3=$((a|=(1<
    10. s4=$((!(a>b && a<0)))
    11. s5=$((--b))
    12. echo "$s0,$s1,$s2,$s3,$s4,$s5"

    9.关系运算符（仅支持数字,用于条件判断语句）

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

    1. #!/bin/bash
    2.  
    3. a=10
    4. b=8
    5. if [ $a -eq $b ] #中括号两边和运算符两边都需要添加空格
    6. then
    7.         echo "YES"
    8. else
    9.         echo "NO"
    10. fi

    10.字符串运算符(用于条件判断语句）

    = ：检测两个字符串是否相等         [ $str1 = $str2 ] 
    != ：检测两个字符串是否相等        [ $str1 != $str2 ] 
    -z ：检测字符串长度是否为0          [ -z $str1 ] 
    -n ：检测字符串长度是否为0          [ -n "$str2" ] 
    $  ：检测字符串是否为空                 [ $str1 ] 

    11.布尔运算符(用于条件判断语句）

    !   ：非运算，!true即为false
    -o ：或运算，多个判定条件一个为true,则结果为true         [ $a -lt 20 -o $b -gt 100 ]
    -a ：与运算， 多个判定条件一个为false,则结果为false     [ $a -lt 20 -a $b -gt 100 ] 

    12.逻辑运算符 (用于条件判断语句）与布尔运算符的不同在于需要双中括号。

    &&  ：逻辑的 AND       [[ $a -lt 100 && $b -gt 100 ]] 

    ||     ：逻辑的 OR         [[ $a -lt 100 || $b -gt 100 ]] 

    13.文件测试运算符

     14.命令替换（即将命令执行的结果传递给某个变量）

    两种方式： `命令` ，$(命令) 。

    两种命令效果相同但是，$()可以嵌套使用。

    1. #!/bin/bash
    2.  
    3. s0=$((3+4))
    4. s1=`ls /home`
    5. s2=$(date)
    6. sleep 10s
    7. s3=$(echo "北京时间为: $(date)")
    8.  
    9. echo $s0
    10. echo $s3
    11. echo $s2
    12. echo $s1

    15.逻辑判断中符号注意事项

    1. [ ] ： 中括号旁边和运算符两边必须添加空格 （可以使用，不推荐）
    2. [[ ]]：中括号旁边和运算符两边必须添加空格 （字符串验证时，推荐使用）
    3. (()) ： 中括号旁边和运算符两边必须添加空格 （数字验证时，推荐使用）
    4. [[]] 和 (()) 分别是[ ]的针对数学比较表达式和字符串表达式的加强版。

    注：-o、-a可以直接在 [] 结构中正常运行。但是 || 、&&则必须在 [[]] 或 (()) 中运行。 

    16.echo 和 printf

    echo：仅用于字符串的输出，没有使用printf的移植性好

    printf：不会自动换行、需要添加 '\n'。eg:printf "%-10s=%d\n" 3+5^2 $((3+5**2))。

           格式符：
                    %s  ：对应位置的参数 以字符串格式输出
                    %c  ：对应位置的参数 以字符格式输出
                    %d  ：对应位置的参数 以十进制整数输出
                    %f   ：对应位置的参数 以十进制数输出
                    %b  ：对应位置的参数用引号括起来时会识别其中的转义符。

            %-10s ： 指一个宽度为10个字符（-表示左对齐，没有则表示右对齐），任何字符都会被显示在10个字符宽的字符内，如果不足则自动以空格填充，超过也会将内容全部显示出来。

            %-4.2f ：指格式化为小数，宽度为4个字符，其中.2指保留2位小数。

            转义符：
                \a        ：警告字符，通常为ASCII的BEL字符
                \b        ：后退
                \c        ：%b格式替换的内容中含有\c时，\c后的内容会被忽略。见下附代码：
                \f         ：换页（formfeed）
                \n        ：换行
                \r         ：回车（Carriage return）
                \t         ：水平制表符
                \v        ：垂直制表符
                \          ：一个字面上的反斜杠字符
                \ddd    ：表示1到3位数八进制值的字符。仅在格式字符串中有效
                \0ddd  ：表示1到3位的八进制值字符

                    

    1. #!/bin/bash
    2.  
    3. printf "%-10s=%d %b aa\n" test $((3+5**2)) "He\cllo"
    4. : '输出结果：
    5. test      =28 He    #注意：输出内容没有进行换行
    6. '

    17.流程控制 (cmd指操作，可以有多个操作）

            1).if的使用。与其他语言不同，sh中操作不可为空，即cmd部分不可为空。格式如下：

    -----------------------------------------
    :'if：
    if condition
    then
        cmd
    fi
    '
    ---------------------------------------
    :'if else：
    if condition
    then
        cmd
    else
        cmd
    fi
    '
    ----------------------------------------
    :'if else-if else：
    if condition
    then
        cmd
    elif condition
    then
        cmd
    else
        cmd
    fi
    '

            2).for的使用：

     注：当for的列表值中有 引号 存在时需要用双引号括起来或用反斜线 \ 转义

    1. for var in item1 item2 ... itemN (或((i<0;i<10;i++))这种格式）
    2. do
    3.     cmd
    4. done

            3).while的使用

    1. while condition
    2. do
    3.     cmd
    4. done

            4).until循环的使用

    1. until condition
    2. do
    3.     command
    4. done

             5).case多分支结构的使用：

    1. case $关键字 in
    2. 关键字1)
    3.     cmd;;
    4. 关键字2）
    5.     cmd;;
    6. *）
    7.     echo "error!";;    
    8. esac

            6).无限循环

    1. while :        (或写成 while true)
    2. do
    3.     command
    4. done

    for (( ; ; ))

            7).跳出循环：

    break:允许跳出高一级的循环

    continue:仅跳出当前

    1. #!/bin/bash
    2.  
    3. j=0
    4. while :
    5. do
    6.         ((j++))
    7.         echo -n "$j a "
    8.  
    9.         if ((j>5 && j<8))
    10.         then
    11.                 echo "b"
    12.                 continue
    13.                 echo "?"
    14.         fi
    15.  
    16.         if ((j>10))
    17.         then
    18.                 echo "over"
    19.                 break
    20.                 echo "!"
    21.         fi
    22.  
    23.         echo "c"
    24. done

    18.自定义函数

            注意：所有函数在使用前必须定义。这意味着必须将函数放在脚本开始部分，直至shell解释器首次发现它时，才可以使用。调用函数仅使用其函数名即可。

    function name    #或者是: name() 这种格式
    {
        action
        return int                    #return返回值的范围：0-255一般用作返回状态码，不加return则会将最后一条命令执行状态作为返回值0：执行成功。返回值可通过 $? 获取。
    }

    1. #!/bin/bash
    2.  
    3. fun()
    4. {
    5. 	local sum=$(($1+$2))
    6. 	return $sum
    7. }
    8. fun 3 4
    9. echo $?    #显示的是fun函数的返回值
    10. echo $?    #则为上一条语句即“echo $?"的执行状态
    11.  
    12. function fun
    13. {
    14. 	str=$1
    15. 	local sum=${#str}
    16. 	echo $sum
    17. }
    18. result=$(fun hello)   #类似于这种获取函数返回值需要使用echo 或 ptintf
    19. echo $result

  • 相关阅读:
    Linux下编译和安装ffmpeg
    pytorch初学笔记（七）：神经网络基本骨架 torch.nn.Module
    关于JavaScript 异步方案 async/await
    计算机毕业设计ssm达梦商城-跨平台多商户电商平台nc9f0系统+程序+源码+lw+远程部署
    测试驱动编程(4)模拟消除依赖
    【无标题】
    C++ STL: std::vector与std::array的深入对比
    JavaScript中常用的事件
    循环神经网络的主要特点,循环神经网络应用举例
    【写文章神器】标记语言Markdown的使用
  • 原文地址：https://blog.csdn.net/qq_41675998/article/details/118521089