Linux Shell 脚本编程（4）—控制流结构

最新推荐文章于 2021-05-16 01:19:38 发布
原创 最新推荐文章于 2021-05-16 01:19:38 发布 · 426 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#linux shell #for #case #test #while

本文介绍了Shell脚本中的控制流结构，包括条件测试、循环控制、分支选择等关键概念，并通过具体实例展示了if-then-else语句、case语句、until及while循环的使用方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

shell控制流结构

控制结构    
  if then else语句    
  case语句    
  until循环

  while循环   
  break控制   
  confinue控制

一、 流控制的目的

#!/bin/bash
#创建一个目录
make /home/jianliu/shelltest/txt
#复制所有txt文件到指定目录
cp *.txt /home/jianliu/shelltest/txt
rm -f *.txt

1.该脚本运行存在问题：很可能创建目录失败，后续操作无法执行。
2. 若目录创建失败，该如何处理；成功又该如何处理；
3. 文件拷贝失败如何处理
—-》因此引用流控制结构来控制脚本的有效运行。

1. 条件测试（判断）—test

  • 有时判断字符串是否相等或检查文件状态或是数字测试等。Test命令用于测试字符串，文件状态和数字。

  • Test 判断的结果如何正确的判断？不要直接用直觉，注意test后面的表达式是一个整体，注意这个整体的结果是成功还是失败，成功返回0，失败返回1

  • 【1】 文件状态测试

===== 格式（两种写法）

格式注意事项
test condition
[ condition ]使用方括号时，要注意在条件两边加上空格!!!
格式（两种写法）   
     test condition    
     [    condition   ]  #使用方括号时，要注意在条件两边加上空格。
         eg: [ -x file ] (正确）    [-x file]（错误！！）

文件测试状态 ：测试的结果可以用$?的值来判断，0表示成功，其他为失败

-d       目录                -s         文件长度大于0、非空
-f       正规文件            -w         可写
-L       符号链接            -u         文件有suid位设置
-r       可读                -x         可执行
-z        字符串为空          -e         文件是否存在

—–实例：

jianliu@ubuntu:~/aa$ ls -a
.  ..  2.c  a1.c  app2  b1.c  b3.c  b4.c  bb  hello.c  shell02.sh

jianliu@ubuntu:~/aa$ ls -a -ls
total 36
 4 drwxrwxr-x  3 jianliu jianliu 4096 Oct  7 20:07 .
 4 drwxr-xr-x 24 jianliu jianliu 4096 Oct  7 19:51 ..
 0 lrwxrwxrwx  1 jianliu jianliu    3 Oct  7 20:07 2.c -> 1.c
 4 -rw-rw-r--  1 jianliu jianliu   79 Oct  3 05:05 a1.c
12 -rwxrwxr-x  1 jianliu jianliu 8501 Oct  6 19:26 app2
 0 lrwxrwxrwx  1 jianliu jianliu    4 Oct  7 20:07 b3.c -> b1.c
 0 lrwxrwxrwx  1 jianliu jianliu    4 Oct  7 20:07 b4.c -> b1.c
 4 drwxrwxr-x  3 jianliu jianliu 4096 Oct  3 06:44 bb
 4 -rw-rw-r--  1 jianliu jianliu   94 Oct  4 04:20 hello.c
 4 -rwxr-xr-x  1 jianliu jianliu  109 Oct  6 19:15 shell02.sh

jianliu@ubuntu:~/aa$ test -d bb
jianliu@ubuntu:~/aa$ echo $?
0    #bb为目录文件

jianliu@ubuntu:~/aa$ test -L 2.c
jianliu@ubuntu:~/aa$ echo $?
0   #2.c为link文件

jianliu@ubuntu:~/aa$ test -x shell02.sh
jianliu@ubuntu:~/aa$ echo $?
0  #shell02.sh为可执行文件

jianliu@ubuntu:~/aa$ [ -x shell02.sh ]
jianliu@ubuntu:~/aa$ echo $?
0
#脚本文件  test.sh  测试文件（$1所指向的文件）是否可写。
#!/bin/bash
echo "test use 1"
test -w $1
if [ $? -eq "0" ]; then
        echo "success ";
else
        echo "error: not success";
fi
echo "return value:" $?
echo "test use 2 : using [] -- begin"
[ -w $1 ]
echo  "return value:" $?


#测试---------------------------------------------
#新建一个自读文件 ：rd_file
-r--r--r--  1 jianliu jianliu    0 Oct  7 20:25 rd_file
#新建一个可写文件：hello.c
4 -rw-rw-r--  1 jianliu jianliu   94 Oct  4 04:20 hello.c

jianliu@ubuntu:~/aa$ ./test.sh rd_file
test use 1
error: not success
return value: 0
test use 2 : using [] -- begin
return value: 1

jianliu@ubuntu:~/aa$ ./test.sh hello.c
test use 1
success 
return value: 0
test use 2 : using [] -- begin
return value: 0

—–测试时使用逻辑操作符

操作符作用说明
-a逻辑与（and）操作符两边均为真，结果为真，否则为假。
-o逻辑或（or）操作符两边一边为真，结果为真，否则为假。
!逻辑否条件为假，结果为真。
#测试实例： 
   #逻辑与操作： 测试文件a1.c 与b1.c是否均可读
   jianliu@ubuntu:~/aa$ [ -w b1.c -a -w a1.c ]
   jianliu@ubuntu:~/aa$ echo $?
   0

   #逻辑或操作 ：  测试test.sh 是否可执行 或者 a1.c是否可写
    jianliu@ubuntu:~/aa$ [ -x test.sh -o -w a1.c ]
    jianliu@ubuntu:~/aa$ echo $?
    0

  • 【2】 字符状态测试

    测试两个字符是否相等。退出状态变量 $?，0表示成功，1表示失败。

    #格式-----------------------： 
     （1） test string
     （2） test [operator] string
     （3） test string_1 [operator] string_2
     （4） [ [operator] string ]
     （5） [ string_1 [operator] string_2 ]

—- 操作数 operator 说明

操作数作用说明
=两个字符串相等
!=两个字符串不等
-z空串
-n非空串

*注意!!! =，!=都是针对字符串操作，而不是数值*

—–测试实例

jianliu@ubuntu:~/aa$  test "string"
jianliu@ubuntu:~/aa$ echo $?
0

jianliu@ubuntu:~/aa$ test -n "string"
jianliu@ubuntu:~/aa$ echo $?
0

jianliu@ubuntu:~/aa$ test  "string1" = "string2"
jianliu@ubuntu:~/aa$ echo $?
1

jianliu@ubuntu:~/aa$ [ -n "string" ]
jianliu@ubuntu:~/aa$ echo $?
0

jianliu@ubuntu:~/aa$ [ "string1" = "string2" ]
jianliu@ubuntu:~/aa$ echo $?
1

jianliu@ubuntu:~/aa$ declare AAA="aaa"
jianliu@ubuntu:~/aa$ declare BBB="bbb"
jianliu@ubuntu:~/aa$ [ $AAA = $BBB ]
jianliu@ubuntu:~/aa$ echo $?
1

jianliu@ubuntu:~/aa$ [ 1 = 1 ]    #看做字符
jianliu@ubuntu:~/aa$ echo $?
0
  • 【3】 数值测试
----格式---------------------
  （1） number1 [operator] number2
  （2） [ number1  [operator] number2 ]

—- 操作数 operator 说明

操作数作用说明
-eq数值相等
-ne数值不相等
-gt第一个数大于第二个数。
-lt第一个数小于第二个数。
-le第一个数小于等于第二个数。
-ge第一个数大于等于第二个数。

—–实例—————-

jianliu@ubuntu:~/aa$ NUM1=12
jianliu@ubuntu:~/aa$ NUM2=34

jianliu@ubuntu:~/aa$ test $NUM1 -ne $NUM2
jianliu@ubuntu:~/aa$ echo $?
0

jianliu@ubuntu:~/aa$ [ $NUM1 -gt $NUM2 ]
jianliu@ubuntu:~/aa$ echo $?
1

jianliu@ubuntu:~/aa$ NUM3=130
jianliu@ubuntu:~/aa$ [ "$NUM3" -eq "130" ]
jianliu@ubuntu:~/aa$ echo $?
0

  • 【4】expr数值运算

    格式： expr argument1 [operator] argument2

    ——-注意！——-
    （1） [operator] 前后都要有空格！！
    （2） 这个表达式是命令！！！！ 

        #eg------------------------:      
        VAR3=`expr $VAR1  \*  $VAR2`    #正确！！
        VAR3=expr $VAR1  \*  $VAR2      #错误！！

——-（3） 乘法操作： [operator] = \*

==========实例test===================

#加法操作
jianliu@ubuntu:~/aa$ expr 10 + 10
20

#减法操作
jianliu@ubuntu:~/aa$ expr 15 - 10
5

#除法操作
jianliu@ubuntu:~/aa$ expr 30 / 3
10
jianliu@ubuntu:~/aa$ expr 30 /2   #错误！！！
expr: syntax error
jianliu@ubuntu:~/aa$ expr 30/3  
30/3
jianliu@ubuntu:~/aa$ expr 30 / 3 / 2
5

#乘法操作
jianliu@ubuntu:~/aa$ expr 30 \* 3   #\* 转义字符
90
jianliu@ubuntu:~/aa$ expr 30 * 3   #错误
expr: syntax error


#----------------------------------------------------
jianliu@ubuntu:~/aa$ MY_VAR1=21
jianliu@ubuntu:~/aa$ MY_VAR2=34
jianliu@ubuntu:~/aa$ MY_VAR3=`expr $MY_VAR1 + $MY_VAR2`  #反引号！！，命令！！
jianliu@ubuntu:~/aa$ MY_VAR4=`expr $MY_VAR1 \* $MY_VAR2`

jianliu@ubuntu:~/aa$ echo $MY_VAR3
55
jianliu@ubuntu:~/aa$ echo $MY_VAR4
714
  • 【5】 理论提高（man test）
man test

TEST(1)                          User Commands                         TEST(1)

       -n STRING
              the length of STRING is nonzero

       STRING equivalent to -n STRING

       -z STRING
              the length of STRING is zero

       STRING1 = STRING2
              the strings are equal

       STRING1 != STRING2
              the strings are not equal

       INTEGER1 -eq INTEGER2
              INTEGER1 is equal to INTEGER2

       INTEGER1 -ge INTEGER2
              INTEGER1 is greater than or equal to INTEGER2

       INTEGER1 -gt INTEGER2
              INTEGER1 is greater than INTEGER2

       INTEGER1 -le INTEGER2
              INTEGER1 is less than or equal to INTEGER2

       INTEGER1 -lt INTEGER2
              INTEGER1 is less than INTEGER2

       INTEGER1 -ne INTEGER2
              INTEGER1 is not equal to INTEGER2

       FILE1 -ef FILE2
              FILE1 and FILE2 have the same device and inode numbers

       FILE1 -nt FILE2
              FILE1 is newer (modification date) than FILE2

       FILE1 -ot FILE2
              FILE1 is older than FILE2

       -b FILE
              FILE exists and is block special

       -c FILE
              FILE exists and is character special

       -d FILE
              FILE exists and is a directory

       -e FILE
              FILE exists

       -f FILE
              FILE exists and is a regular file

       -g FILE
              FILE exists and is set-group-ID

       -G FILE
              FILE exists and is owned by the effective group ID

       -h FILE
              FILE exists and is a symbolic link (same as -L)

       -k FILE
              FILE exists and has its sticky bit set

       -L FILE
              FILE exists and is a symbolic link (same as -h)

       -O FILE
              FILE exists and is owned by the effective user ID

       -p FILE
              FILE exists and is a named pipe

       -r FILE
              FILE exists and read permission is granted

       -s FILE
              FILE exists and has a size greater than zero

       -S FILE
              FILE exists and is a socket

       -t FD  file descriptor FD is opened on a terminal

       -u FILE
              FILE exists and its set-user-ID bit is set

       -w FILE
              FILE exists and write permission is granted

       -x FILE
              FILE exists and execute (or search) permission is granted

2. if then else fi 语句

  • 语法1
if [ 条件 ]
then 命令
fi  #终止符号
#注意if语句必须以fi终止

#---练习：----------------
#if test
if [ "13" -lt "12" ]  # "13" 前一个空格，“13”后也有一个空格。
then
        echo "yes 13 is less then 12"
else
        echo "NO"
fi
  • 语法2
if [ 条件1 ]
then 
     命令1
elif [ 条件2 ]
then 
     命令2
else
     命令3
fi
  • 综合练习——-
#脚本文件   判断输入字符是否空空串
#!/bin/bash
#if then fi

VAR=$1

if [ -z $VAR ]
then 
    echo "success1"
else
    echo "failure1"
fi

if test -z $VAR   #不建议使用这种格式！！！
then 
    echo "success2"
else
    echo "failure2"
fi

#运行结果
jianliu@ubuntu:~/aa$ ./test.sh 
success1
success2
jianliu@ubuntu:~/aa$ ./test.sh ""
success1
success2
jianliu@ubuntu:~/aa$ ./test.sh "haha"
failure1
failure2

#脚本  判断一个文件是否存在
#!/bin/bash
#if test
#this is a comment line
echo "Enter your filename:"
read myfile
if [ -e $myfile ] #判断文件是否存在
then
   if [ -s $myfile ]  #判断文件内容长度是否>=0
   then   
      echo "$myfile exist and size greater than zero"
   else
      echo "$myfile exist but size is zero"
   fi
else
echo "file no exist"
fi

#运行结果：-----------------------------------
jianliu@ubuntu:~/aa$ ./test.sh 
Enter your filename:
c1.c
file no exist

jianliu@ubuntu:~/aa$ touch efile  #新建一个空文件
jianliu@ubuntu:~/aa$ ./test.sh 
Enter your filename:
efile
efile exist but size is zero

jianliu@ubuntu:~/aa$ ./test.sh 
Enter your filename:
b1.c
b1.c exist and size greater than zero

3. case 多选择语句

—-类似于C语言中switch语句,但是在脚本中case处理的是字符串！！！

case多选择语句格式：

    case 值(变量$VAR） in         
    模式1 )
        命令1
        ;;         #用两个;;表示结束一个内部case,代表break.
    模式2 )
        命令2
        ;;
    esac

   #等价于switch语句---
   switch(int VAR)  //输入VAR是整型！！
   {
       case var1(对应于模式1） :
           do something;
           break;
       case var2（对应于模式2）:
           do something;
           break;
       default :
           break;
   }

  • 1) case取值后面必须为单词 in；每一模式必须以右括号结束

  • 2) 取值可以为变量或常数。匹配发现取值符合某一模式后，其后的所有命令开始执行，直到;;

  • 3) 模式

模式匹配作用说明
*表示任意字符（字符串）
?表示任意单字符
[..]表示类或范围中任意字符
  • 4) 重要说明
   //【1】范围case  -----------------------------                           
   case val in           
   a|b|c)  
       echo "[ ]"
       ;;       

   //--等价于->
   switch(var){
       case a :
       case b :
       case c :
           printf("[ ]");
           break;
   }
//【2】 *来实现default功能  -----------------------------
 case val in           
   。。。。
   *)
       echo "default"
       ;;

   //--等价于->
   switch(var){
      。。。。。
       default :
           printf("default");
           break;
   }
  • case 的要点
    a)  条件处理的是字符串
    b)  每一个分支以“;;”作为结束
    c)  条件分支一esac结束
    d)  通配符*,?,[]
  • 实例—————-
    通过read从键盘读入一个字符串，如果输入的是数字，如果范围在1～3，进入相应的处理分支，如果输入E或e ,屏幕输出一行：“EXIT！”，如果是其他字符，那么输出：“非法输入+输入的字符串”
#脚本
#!/bin/bash

echo "please input str:\n"
read STR

case $STR in
1|2|3)
    echo "your select: $STR"
    ;;
y|Y)
    echo "you agree"
    ;;
E|e)
    echo "exit!"
    exit
    ;;
*)
    echo "invalid input:$STR"
    ;;
esac


#运行结果
jianliu@ubuntu:~/aa$ ./test.sh 
please input str:\n
e 
exit!
jianliu@ubuntu:~/aa$ ./test.sh 
please input str:\n
2
your select: 2
jianliu@ubuntu:~/aa$ ./test.sh y
please input str:\n
y
you agree

4. for 循环

  • 语法格式
#该命令在/etc/profile中
#for循环一般格式
for 变量名 in 列表
do 
    命令1
    命令2
done

  1. 当变量值在列表里，for循环即执行依次所有命令，使用变量名访问列表中取值。

  2. 命令可为任何有效的shell命令和语句。变量名为任意单词。

  3. in 列表用法是可选择，如果不用它，for循环使用命令行的位置参数。
  4. in 列表可以包含替换、字符串和文件名

—-实例测试————-

jianliu@ubuntu:~/aa$ cat test.sh
#!/bin/bash

for i in 1 2 3 4 5
do
    echo $i
done

jianliu@ubuntu:~/aa$ ./test.sh
1
2
3
4
5
#留心观察输出结果的区别！！！！！！！
jianliu@ubuntu:~/aa$ cat test.sh
#!/bin/bash

echo "test 1"
for i in "aa bb cc dd"
do
    echo $i
done

echo "test 2"
for i in aaa bbb ccc ddd
do
    echo $i
done

jianliu@ubuntu:~/aa$ ./test.sh
test 1
aa bb cc dd
test 2
aaa
bbb
ccc
ddd

#注意 in后为 命令 反引号--------------------
jianliu@ubuntu:~/aa$ cat test.sh
#!/bin/bash

for loop in `cat test.sh`
do 
    echo $loop
done

#注意：打印文件内容按照 行+空格 为一行
jianliu@ubuntu:~/aa$ ./test.sh
#!/bin/bash
for
loop
in
`cat
test.sh`
do
echo
$loop
done

#如果in后没有语句，此时语句等价于： in $@ -------------
jianliu@ubuntu:~/aa$ cat test.sh
#!/bin/bash

#for_noion

i=1

for param
do  echo "param #$i is $param"
    i=$[$i+1]
done

jianliu@ubuntu:~/aa$ ./test.sh aa bbb ccc
param #1 is aa
param #2 is bbb
param #3 is ccc

5. until 循环

#语法格式   until循环格式

until [条件]
do  
    命令1
    命令2
done
#例子   test.sh
#!/bin/bash

VAR=0

until [ $VAR -gt 90 ]
do 
    echo $VAR
    sleep 1
    let VAR+=5
done 

jianliu@ubuntu:~/aa$ ./test.sh
0
5
10
15
20
25
30
35
40
45
50
55
60
65
70
75
80
85
90
  • 条件可以为任意测试条件，测试发生在循环末尾，因此循环至少执行一次
#脚本文件    循环等待直到指定文件exe.app能够被执行，停止程序
#!/bin/bash

until [ -x exe.app ]
do 
    sleep 2
    echo " file exe.app can not be executed!,wait..."
done 

echo "now this file can be executed!"

jianliu@ubuntu:~/aa$ ls -l
total 52
-rw-rw-r-- 1 jianliu jianliu    0 Oct 10 05:26 exe.app

jianliu@ubuntu:~/aa$ nohup ./test.sh &
[1] 3963

#查看所有任务（test.sh脚本在后台执行）
jianliu@ubuntu:~/aa$ jobs
[1]+  Running                 nohup ./test.sh & 

jianliu@ubuntu:~/aa$ chmod a+x exe.app   #改变exe.app的可执行位标志

#test.sh脚本执行完成。
jianliu@ubuntu:~/aa$ jobs
[1]+  Done                    nohup ./test.sh

6. while 循环

#语法格式
while 命令 （可以是一个命令也可以是多个，做条件测试）
do
      命令1
      命令2
      ...
done
  • 注：在while和do之间虽然通常是一个命令，但可以放几个命令。
    命令通常用作测试条件。
#输入名称，直到按下Ctrl+d按键，结束。
#!/bin/bash 

echo "ctrl+d quit"
while echo -n "please enter name:"; read Name
do 
    echo "yeah,i got your name: $Name"
done

jianliu@ubuntu:~/aa$ ./test.sh
ctrl+d quit
please enter name:kangkang
yeah,i got your name: kangkang
please enter name:bingbing
yeah,i got your name: bingbing
#从文本name.txt中读取每一行信息，输出到终端显示。
jianliu@ubuntu:~/aa$ cat test.sh
#!/bin/bash 

while read LINE
do 
    echo $LINE
done < names.txt
#------------------------------------------------------  

jianliu@ubuntu:~/aa$ ./test.sh
kangkang
bingbing
licaiting
wuhaoao
wanboa
dianfeng
kb536

#！！----错误写法----
#!/bin/bash
#这样写是不对的 ，需要把<name.txt 放在 while循环后面
while read LINE < names.txt   
do
        echo $LINE
done
  • 备注：如果从文件中读入量<filename要放到done后.

7. break 和 continue

break [n]
    退出循环
    如果是在一个嵌入循环里，可以指定n来跳出循环个数
continue
    跳出循环步

注意：continue命令类似于break命令，只有一点重要差别，它不会跳出循环，只是跳出这个循环步
总结：break跳出 continue跳过

jianliu@ubuntu:~/aa$ ./test.sh
Enter any num[1...5:]3
you enter a num between 1 and 5
Enter any num[1...5:]7
wrong num, bye
jianliu@ubuntu:~/aa$ cat ./test.sh
#!/bin/bash
while :   #死循环
do
    echo -n "Enter any num[1...5:]"
    read num
    case $num in
    1|2|3|4|5)
        echo "you enter a num between 1 and 5"
        ;;
    *)
        echo "wrong num, bye"
        break;    #如果不加这一句，while就永远退不出去！！！！！
        ;;
    esac
done

#---------------------------------------------------------------   

jianliu@ubuntu:~/aa$ ./test.sh
Enter any num[1...5:]2
you enter a num between 1 and 5
Enter any num[1...5:]3
you enter a num between 1 and 5
Enter any num[1...5:]6
wrong num, bye
jianliu@ubuntu:~/aa$ 

jianliu@ubuntu:~/aa$ cat test.sh
#!/bin/bash
while :
do
    echo  -n "please input num[1..5]:"
    read num
    case $num in
    1|2|3|4|5)
        echo "your slection is $num, between 1 and 5"
        ;;
    *)
        echo "wrong num, is continue?(y/n)?"
        read IS_CONTINUE
        case $IS_CONTINUE in
        y|yes|Yes|YES)
            continue;
            ;;
        *)
            break;
            ;;
        esac
        ;;
    esac
done
#------------------------------------------------------

jianliu@ubuntu:~/aa$ ./test.sh
please input num[1..5]:2
your slection is 2, between 1 and 5
please input num[1..5]:3
your slection is 3, between 1 and 5
please input num[1..5]:5
your slection is 5, between 1 and 5
please input num[1..5]:7
wrong num, is continue?(y/n)?
n
jianliu@ubuntu:~/aa$ ./test.sh
please input num[1..5]:2
your slection is 2, between 1 and 5
please input num[1..5]:3
your slection is 3, between 1 and 5
please input num[1..5]:6
wrong num, is continue?(y/n)?
y
please input num[1..5]:7
wrong num, is continue?(y/n)?
n
jianliu@ubuntu:~/aa$
Linux之shell脚本编程
weixin_57975238的博客
05-01 2778
•。
浅谈shell脚本中的控制流结构
09-15
在Shell脚本编程中，控制流结构是编写逻辑复杂脚本的关键部分，它允许程序员根据不同的条件执行不同的代码块。本文将深入浅谈Shell脚本中的控制流结构，包括`if`、`for`、`while`循环以及`case`语句等。 首先，我们...
linux shell 控制流结构
01-12
linux shell 控制流结构
LINUX-C成长之路（五）：控制流
林世霖的技术博客
12-20 1859
C 语言是一种 “高级” 语言，所谓的高级，就是拥有逻辑控制语句，可以使得我们实现诸如 循环、分支、跳转等操作。我们来逐一分析。 第一，循环语句。 C语言中，总共有3种循环语句，它们分别是 while 循环， do_while 循环 ， 和 for 循环。 1，while循环，下面是示例代码： int a = 0; while( a < 100 ) // 每循环一次a加1，总
shell脚本控制流
qwerty1372431588的博客
12-08 641
控制流forwhileuntilif for - 格式 - for 定义变量 - do 使用变量，执行动作 - done 结束标志 - 格式1： - #!/bin/bash - for WESTOS in `seq 1 2 10` ##表示从1到10，步长为2 - do - echo $WESTOS - done - 格式2： - for WESTOS in 1 2 3 - do - echo $WESTOS - done - 格式3： - for n
Linux Shell编程002--控制流结构
youran02100210的专栏
08-17 210
一、if语句        语句格式：       if 条件       then       elif 条件       then       else       fi #!/bin/bash echo -n "Please enter your name:" read NAME echo if [ -z $NAME ] echo $NAME if [ -z $NAME ...
Linux笔记——控制流
kanwoerzi
06-25 187
列表： Linux笔记——vim常用操作及扩展补充[手册] Linux笔记——linux常用命令集合 Linux笔记——命令：awk Linux笔记——命令:sed Linux笔记——命令：grep Linux笔记——命令：find Linux笔记——命令:Sort,uniq,join,cut,paste,split Linux笔记——shell基础：变量&amp;本地变...
Shell脚本编程：控制流结构详解
这篇教程主要关注的是Shell脚本编程，特别是控制流结构。在Unix/Linux系统中，Shell是一种强大的命令行解释器，它允许用户通过输入命令和参数来执行任务，并接收命令的执行结果。常见的Shell类型包括Bourne Shell、...
Linux Shell脚本编程－－sed命令详解.zip_shell sed_命令介绍_脚本 shell
09-24
在Linux系统中，Shell脚本编程是日常自动化任务和系统管理的重要工具，而`sed`（流编辑器，Stream Editor）则是Shell脚本中的一个强大工具。本文将深入讲解`sed`命令的基本概念、功能以及在Shell脚本中的具体应用。 ...
linux shell结构,linux——Shell的控制结构（附shell编写代码和运行结果）
weixin_39657249的博客
05-16 276
针对shell的控制结构，也就是shell编程时所需要的三种控制流程，顺序/分支和循环。在bash中，顺序可由简单的输入输出命令组成；分支语句由if、case实现；循环语句用for、while和until来实现。一、if语句1、基本的if语句语句格式：if conditionthensatementselsestatementsfi输出结果：2、elif语句elif语句格式：if conditio...
linux shell编程指南第十八章------控制流结构
西北风的专栏
12-08 1824
在书写正确脚本前，大概讲一下退出状态。任何命令进行时都将返回一个退出状态。如 果要观察其退出状态，使用最后状态命令： $ echo $? 主要有4种退出状态。前面已经讲到了两种，即最后命令退出状态$ ?和控制次序命令（ $ $、 | |）。其余两种是处理s h e l l脚本或s h e l l退出及相应退出状态或函数返回码。在第1 9章讲到函数 时，也将提到其返回码。 要退出当前进程
Linux Shell编程（四）－－Shell控制结构
jyl_static的专栏
03-27 317
if结构 if 表达式 then 命令表 [elif 表达式 then 命令表] [else 命令表] fi 可以把if和then放在同一行，用分号“;”分隔： if 表达式; then 命令表 fi case结构 case 表达式 in   模式11 [ |模式12 ]...) 命令表1;;   模式22 [ |模式22 ]...) 命令表2;;
Linux控制流④：信号控制
一只老风铃
10-20 256
异常控制流发生在程序控制权转移到其它位置时，异常控制可能发出自硬件层面（IO设备中断）、内核层面（系统调用）、以及软件层面（即Linux信号） 允许进程和内核中断其它进程。它是一种更高级的控制。 一个信号即一条简短的消息，它通知进程系统发生了某种类型的事件。 每种信号对应于某种特定事件的发生，典型地，它们通常是某种硬件设备发出，（在中断中，将会发出硬件中断信号，处理器切换到中断上下文执行），而这一切对于应用程序是未知，Linux信号提供这样一类实现：通知用户进程发生了这些事件。 序号 名称
shell脚本－－流控制
热门推荐
lovefef4的专栏
11-14 1万+
if 变量赋值，等号之间不能有空格 条件判断是中括号要留有空格 ＃语法结构 ＃如果ｉｆ条件判断中有多条命令，则根据最后一条命令的执行结果进行评估 if command;then command elif command;then command else command fi#!/bin/bash x=5 if [ $x = 5 ];then ech
【Linux基础】shell控制结构
u010926630的专栏
06-11 888
shell程序设计语言的基础是对条件进行测试判断，根据不同的测试结果采取相应的程序处理。因此，下面我们将会先来分析在shell脚本程序中可以使用的判断条件，然后再来学习使用这些条件的控制结构。 1. 4.3.2.1 判断条件 /************************************************/ 1 条件测试 条件测试有二种常用形式： 第一种是用tes
linux硬件控制流,异常控制流
weixin_32466167的博客
05-14 218
异常控制流系统需要能够对系统状态的改变做出反应，这些系统状态不是被内部程序变量捕获的，而且也不一定和程序的执行相关。如:一个硬件定时器定期产生信号，这个事件必须得到处理。包到达网络适配器，必须放在内存中。程序向磁盘请求数据，然后休眠，直到被通知数据已经就绪。子进程终止时，创造这些子检查点父进程必须得到通知现代系统通过使控制流突变来对这些情况做出反应，把这些突变称为异常控制流(ECF).异常控制流发...
Linux bash脚本编程学习基础，控制结构
karelcn的博客
10-11 303
if 判断语句 1. 单分支 if 条件判断; then 条件为真执行 代码块 fi 2. 双分支 if 条件判断; then 条件为真执行 代码块 else 条件为假执行 代码块 fi 3. 多分支 if 条件判断1; then 符合条件1执行 代码块 elif 条件判断2; then 符合条件2执行 代码块 elif 条件判断n; t...
shell脚本 流程控制
_Tsun 的博客
12-13 356
一 条件判断式 语句 两种判断格式 test -e /root/install.log [ -e /root/install.log ] 1.文件类型判断 -b 文件 判断文件是否存在，并且是否为块设备文件 -c 文件 判断文件是否存在，并且是否为字符设备文件 ## 常用 -d 文件 判断文件是否存在，并且是否为目录 -e 文件 判断文件是否存在 -f 文件 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值