Skip to content
石头软件测试技术分享石头软件测试技术分享
主页
github icon
  • 辅助技能

    • 编程语言
      • 环境部署

        • linux常用命令
          • shell
            • shell介绍
              • shell变量
                • 定义变量
                  • 使用变量
                  • 字符串操作
                    • 拼接字符串
                      • 获取字符串长度
                        • 提取字符串
                        • shell数组
                          • 定义数组
                            • 使用数组
                              • 获取数组长度
                              • 注释
                                • 单行注释
                                  • 多行注释
                                  • shell运算符
                                    • 算数运算
                                      • 关系运算符
                                        • 布尔运算符
                                          • 逻辑运算符
                                          • shell流程控制
                                            • if-else
                                              • if if-eles eles
                                                • for 循环
                                                  • while
                                                    • case ... esac
                                                      • break
                                                        • continue
                                                      • docker
                                                        • nginx
                                                          • redis
                                                            • mysql
                                                              • allure
                                                                • sonarqube部署
                                                                • 工具

                                                                  • adb
                                                                    • git的使用
                                                                      • 抓包工具
                                                                        • 资源监控

                                                                      shell

                                                                      author icon石头calendar icon2022年1月17日category icon
                                                                      • 测试辅助技能
                                                                      tag icon
                                                                      • shell
                                                                      timer icon大约 3 分钟

                                                                      此页内容
                                                                      • shell介绍
                                                                      • shell变量
                                                                        • 定义变量
                                                                        • 使用变量
                                                                      • 字符串操作
                                                                        • 拼接字符串
                                                                        • 获取字符串长度
                                                                        • 提取字符串
                                                                      • shell数组
                                                                        • 定义数组
                                                                        • 使用数组
                                                                        • 获取数组长度
                                                                      • 注释
                                                                        • 单行注释
                                                                        • 多行注释
                                                                      • shell运算符
                                                                        • 算数运算
                                                                        • 关系运算符
                                                                        • 布尔运算符
                                                                        • 逻辑运算符
                                                                      • shell流程控制
                                                                        • if-else
                                                                        • if if-eles eles
                                                                        • for 循环
                                                                        • while
                                                                        • case ... esac
                                                                        • break
                                                                        • continue

                                                                      # shell

                                                                      # shell介绍

                                                                      Shell 是一个用 C 语言编写的程序,它是用户使用 Linux 的桥梁。Shell 既是一种命令语言,又是一种程序设计语言。

                                                                      # shell变量

                                                                      # 定义变量

                                                                      your_name="Stone"
                                                                      
                                                                      1

                                                                      # 使用变量

                                                                      echo $your_name
                                                                      echo ${your_name}
                                                                      
                                                                      1
                                                                      2

                                                                      # 字符串操作

                                                                      # 拼接字符串

                                                                      greetring="hello, "$your_name" "
                                                                      greetring='hello, '$your_name' '
                                                                      
                                                                      1
                                                                      2

                                                                      # 获取字符串长度

                                                                      string="abcd"
                                                                      echo ${#string}
                                                                      
                                                                      1
                                                                      2

                                                                      # 提取字符串

                                                                      string="runoob is a great site"
                                                                      echo ${string:1:4}
                                                                      
                                                                      1
                                                                      2

                                                                      # shell数组

                                                                      # 定义数组

                                                                      # 方法1
                                                                      number_list=(1 2 3 4)
                                                                      # 方法2
                                                                      number_list=(
                                                                      1
                                                                      2
                                                                      3
                                                                      4
                                                                      )
                                                                      # 方法3
                                                                      number_list[0]=1
                                                                      number_list[1]=2
                                                                      number_list[2]=3
                                                                      number_list[3]=4
                                                                      
                                                                      1
                                                                      2
                                                                      3
                                                                      4
                                                                      5
                                                                      6
                                                                      7
                                                                      8
                                                                      9
                                                                      10
                                                                      11
                                                                      12
                                                                      13
                                                                      14

                                                                      # 使用数组

                                                                      value=${number_list[0]}
                                                                      # @获取所有元素
                                                                      echo ${number_list[@]}
                                                                      
                                                                      1
                                                                      2
                                                                      3

                                                                      # 获取数组长度

                                                                      length=${#number_list[@]}
                                                                      length=${#number_list[*]}
                                                                      
                                                                      1
                                                                      2

                                                                      # 注释

                                                                      # 单行注释

                                                                      # 这是单行注释
                                                                      
                                                                      1

                                                                      # 多行注释

                                                                      # :<<后面可使用任意符号
                                                                      :<<EOF
                                                                      注释内容
                                                                      注释内容
                                                                      注释内容
                                                                      EOF
                                                                      
                                                                      1
                                                                      2
                                                                      3
                                                                      4
                                                                      5
                                                                      6

                                                                      # shell运算符

                                                                      # 算数运算

                                                                      val=`expr 2 + 2`
                                                                      echo "两数之和为 : $val"
                                                                      
                                                                      1
                                                                      2

                                                                      # 关系运算符

                                                                      a=10
                                                                      b=20
                                                                      if [ $a -eq $b ]
                                                                      then
                                                                         echo "$a -eq $b : a 等于 b"
                                                                      else
                                                                         echo "$a -eq $b: a 不等于 b"
                                                                      fi
                                                                      
                                                                      1
                                                                      2
                                                                      3
                                                                      4
                                                                      5
                                                                      6
                                                                      7
                                                                      8
                                                                      运算符说明举例
                                                                      -eq检测两个数是否相等,相等返回 true[ $a -eq $b ] 返回 false
                                                                      -ne检测两个数是否不相等,不相等返回 true[ $a -ne $b ] 返回 true
                                                                      -gt检测左边的数是否大于右边的,如果是,则返回 true[ $a -gt $b ] 返回 false。
                                                                      -lt检测左边的数是否小于右边的,如果是,则返回 true[ $a -lt $b ] 返回 true。
                                                                      -ge检测左边的数是否大于等于右边的,如果是,则返回 true[ $a -ge $b ] 返回 false。
                                                                      -le检测左边的数是否小于等于右边的,如果是,则返回 true[ $a -le $b ] 返回 true。

                                                                      # 布尔运算符

                                                                      a=10
                                                                      b=20
                                                                      if [ $a != $b ]
                                                                      then
                                                                         echo "$a != $b : a 不等于 b"
                                                                      else
                                                                         echo "$a == $b: a 等于 b"
                                                                      fi
                                                                      
                                                                      1
                                                                      2
                                                                      3
                                                                      4
                                                                      5
                                                                      6
                                                                      7
                                                                      8
                                                                      运算符说明举例
                                                                      !非运算,表达式为 true 则返回 false,否则返回 true[ ! false ] 返回 true
                                                                      -o或运算,有一个表达式为 true 则返回 true[ $a -lt 20 -o $b -gt 100 ] 返回 true
                                                                      -a与运算,两个表达式都为 true 才返回 true[ $a -lt 20 -a $b -gt 100 ] 返回 false

                                                                      # 逻辑运算符

                                                                      a=10
                                                                      b=20
                                                                      
                                                                      if [[ $a -lt 100 && $b -gt 100 ]]
                                                                      then
                                                                         echo "返回 true"
                                                                      else
                                                                         echo "返回 false"
                                                                      fi
                                                                      
                                                                      if [[ $a -lt 100 || $b -gt 100 ]]
                                                                      then
                                                                         echo "返回 true"
                                                                      else
                                                                         echo "返回 false"
                                                                      fi
                                                                      
                                                                      1
                                                                      2
                                                                      3
                                                                      4
                                                                      5
                                                                      6
                                                                      7
                                                                      8
                                                                      9
                                                                      10
                                                                      11
                                                                      12
                                                                      13
                                                                      14
                                                                      15
                                                                      16
                                                                      运算符说明举例
                                                                      &&逻辑的 AND[[ $a -lt 100 && $b -gt 100 ]] 返回 false
                                                                      ||逻辑的 OR[[ $a -lt 100 || $b -gt 100 ]] 返回 true

                                                                      # shell流程控制

                                                                      # if-else

                                                                      if condition
                                                                      then
                                                                          command1 
                                                                          command2
                                                                          ...
                                                                          commandN
                                                                      else
                                                                          command
                                                                      fi
                                                                      
                                                                      1
                                                                      2
                                                                      3
                                                                      4
                                                                      5
                                                                      6
                                                                      7
                                                                      8
                                                                      9

                                                                      # if if-eles eles

                                                                      if condition1
                                                                      then
                                                                          command1
                                                                      elif condition2 
                                                                      then 
                                                                          command2
                                                                      else
                                                                          commandN
                                                                      fi
                                                                      
                                                                      1
                                                                      2
                                                                      3
                                                                      4
                                                                      5
                                                                      6
                                                                      7
                                                                      8
                                                                      9

                                                                      # for 循环

                                                                      for var in item1 item2 ... itemN
                                                                      do
                                                                          command1
                                                                          command2
                                                                          ...
                                                                          commandN
                                                                      done
                                                                      
                                                                      1
                                                                      2
                                                                      3
                                                                      4
                                                                      5
                                                                      6
                                                                      7

                                                                      # while

                                                                      while condition
                                                                      do
                                                                          command
                                                                      done
                                                                      
                                                                      1
                                                                      2
                                                                      3
                                                                      4

                                                                      # case ... esac

                                                                      case 值 in
                                                                      模式1)
                                                                          command1
                                                                          command2
                                                                          ...
                                                                          commandN
                                                                          ;;
                                                                      模式2)
                                                                          command1
                                                                          command2
                                                                          ...
                                                                          commandN
                                                                          ;;
                                                                      esac
                                                                      
                                                                      1
                                                                      2
                                                                      3
                                                                      4
                                                                      5
                                                                      6
                                                                      7
                                                                      8
                                                                      9
                                                                      10
                                                                      11
                                                                      12
                                                                      13
                                                                      14

                                                                      # break

                                                                      break命令允许跳出所有循环(终止执行后面的所有循环)。

                                                                      # continue

                                                                      continue命令与break命令类似,只有一点差别,它不会跳出所有循环,仅仅跳出当前循环。

                                                                      提示

                                                                      内容正在完善中,请耐心等待...

                                                                      上一页
                                                                      linux常用命令
                                                                      下一页
                                                                      docker
                                                                      Copyright © 2021-present Evan You 石头 | 备案号 : 蜀ICP备2021021200号-2 | 友情链接 : APP开发者工具