05-6-shell (3)脚本参数传递与数学运算

声明!

学习视频来自B站up主 泷羽sec ,有兴趣的师傅可以关注一下,如涉及侵权马上删除文章,笔记只是方便各位师傅的学习和探讨,文章所提到的网站以及内容,只做学习交流,其他均与本人以及泷羽sec团队无关,切勿触碰法律底线,否则后果自负!!!!

文章为个人学习笔记。

1、脚本参数传递

使用vim创建s.sh文件

vim s.sh

内容代码。

echo 执行的文件名是:$0
echo 第一个参数是:$1
echo 传递的参数作为一个字符串显示:$*
echo 传递的参数独立作为每个字符串显示:$@
echo 传递到脚本的参数个数是:$#
echo 最后命令的退出状态:$?
echo 脚本运行的当前进程ID是:$$
  1. ​echo 执行的文件名是:$0​

    • 这行代码用于输出当前执行的脚本文件名。$0​是一个特殊变量,它代表脚本本身的名称。

  2. ​echo 第一个参数是:$1​

    • 这行代码用于输出传递给脚本的第一个参数。$1​代表第一个参数。

  3. ​echo 传递的参数作为一个字符串显示:$*​

    • 这行代码将所有传递给脚本的参数作为一个单一的字符串显示。$*​会将所有参数视为一个整体。

  4. ​echo 传递的参数独立作为每个字符串显示:$@​

    • 这行代码将所有传递给脚本的参数分别显示,每个参数都是一个独立的字符串。$@​与$*​类似,但它们在双引号中的行为不同。$@​会将每个参数作为独立的单词处理,而$*​会将所有参数作为一个单词处理。

  5. ​echo 传递到脚本的参数个数是:$#​

    • 这行代码用于输出传递给脚本的参数数量。$#​是一个特殊变量,代表参数的数量。

  6. ​echo 最后命令的退出状态:$?​

    • 这行代码用于输出上一个命令的退出状态。$?​是一个特殊变量,代表上一个命令的退出状态码,通常0表示成功,非0表示有错误。

  7. ​echo 脚本运行的当前进程ID是:$$​

    • 这行代码用于输出当前脚本运行的进程ID。$$​是一个特殊变量,代表当前Shell进程的进程ID。

代码例子

运行代码1

参数为空,没有指定参数

┌──(root㉿kali)-[~/work]
└─# vim s.sh
                                                                                                                        
┌──(root㉿kali)-[~/work]
└─# sh s.sh                 
执行的文件名是:s.sh
第一个参数是:
传递的参数作为一个字符串显示:
传递的参数独立作为每个字符串显示:
传递到脚本的参数个数是:0
最后命令的退出状态:0
脚本运行的当前进程ID是:2652
                                  

运行代码2

传入第一个参数

┌──(root㉿kali)-[~/work]
└─# sh s.sh name
执行的文件名是:s.sh
第一个参数是:name
传递的参数作为一个字符串显示:name
传递的参数独立作为每个字符串显示:name
传递到脚本的参数个数是:1
最后命令的退出状态:0
脚本运行的当前进程ID是:4516

运行代码3

┌──(root㉿kali)-[~/work]
└─# sh s.sh 1 2 3   
执行的文件名是:s.sh
第一个参数是:1
传递的参数作为一个字符串显示:1 2 3
传递的参数独立作为每个字符串显示:1 2 3
传递到脚本的参数个数是:3
最后命令的退出状态:0
脚本运行的当前进程ID是:6029
                              

运行代码4

┌──(root㉿kali)-[~/work]
└─# cat s.sh        
echo 执行的文件名是:$0
echo 第一个参数是:$1
echo 第一个参数是:$2
echo 第一个参数是:$3
echo 传递的参数作为一个字符串显示:$*
echo 传递的参数独立作为每个字符串显示:$@
echo 传递到脚本的参数个数是:$#
echo 最后命令的退出状态:$?
echo 脚本运行的当前进程ID是:$$
  1. ​echo 执行的文件名是:$0​:这行命令会输出脚本本身的文件名。在Shell脚本中,$0​代表脚本的名称。

  2. ​echo 第一个参数是:$1​:这行命令会输出传递给脚本的第一个参数。

  3. ​echo 第二个参数是:$2​:这行命令会输出传递给脚本的第二个参数。

  4. ​echo 第三个参数是:$3​:这行命令会输出传递给脚本的第三个参数。

  5. ​echo 传递的参数作为一个字符串显示:$*​:这行命令会将所有传递给脚本的参数作为一个字符串输出。$*​会将所有参数视为一个整体。

  6. ​echo 传递的参数独立作为每个字符串显示:$@​:这行命令会将每个传递给脚本的参数独立输出,每个参数都会被双引号包围,防止参数中包含空格或特殊字符导致的问题。

  7. ​echo 传递到脚本的参数个数是:$#​:这行命令会输出传递给脚本的参数总数。

  8. ​echo 最后命令的退出状态:$?​:这行命令会输出脚本中最后执行的命令的退出状态。在脚本中,这通常用于检查上一个命令是否成功执行。

  9. ​echo 脚本运行的当前进程ID是:$$​:这行命令会输出脚本当前运行的进程ID,这是操作系统用来唯一标识一个运行中的进程的数字。

┌──(root㉿kali)-[~/work]
└─# sh s.sh 1 2 3
执行的文件名是:s.sh
第一个参数是:1
第一个参数是:2
第一个参数是:3
传递的参数作为一个字符串显示:1 2 3
传递的参数独立作为每个字符串显示:1 2 3
传递到脚本的参数个数是:3
最后命令的退出状态:0
脚本运行的当前进程ID是:9731

一个Shell脚本执行的结果,脚本名为s.sh​,并且在执行时传递了三个参数:1​、2​和3​。下面是对输出每一行的解释:

  1. ​┌──(root㉿kali)-[~/work]​:这是终端提示符,显示当前用户是root​,使用的系统是kali​,当前工作目录是~/work​。

  2. ​└─# sh s.sh 1 2 3​:这是用户在终端中输入的命令,用来执行s.sh​脚本,并传递了三个参数。

  3. ​执行的文件名是:s.sh​:脚本输出了它自己的文件名。

  4. ​第一个参数是:1​:脚本输出了第一个传递给它的参数。

  5. ​第二个参数是:2​:脚本输出了第二个传递给它的参数。

  6. ​第三个参数是:3​:脚本输出了第三个传递给它的参数。

  7. ​传递的参数作为一个字符串显示:1 2 3​:脚本将所有参数作为一个字符串输出。

  8. ​传递的参数独立作为每个字符串显示:1 2 3​:脚本将每个参数独立输出,显示它们作为独立的字符串。

  9. ​传递到脚本的参数个数是:3​:脚本输出了传递给它的参数的总数。

  10. ​最后命令的退出状态:0​:脚本执行成功,退出状态为0​,通常表示没有错误发生。

  11. ​脚本运行的当前进程ID是:9731​:脚本输出了它自己的进程ID,这是操作系统用来唯一标识一个运行中的进程的数字。

2、shell编程运算

在Shell脚本中,数学运算通常使用expr​命令或者$(( ))​来进行。

如何在Shell编程中进行数学运算?

  • Shell脚本中的数学运算相对Python来说比较麻烦,因为Shell本身并不直接支持数学表达式。

在Shell编程中利用expr​进行运算

加减

  • ​expr​是一个用于执行表达式求值的命令。它可以用来进行基本的数学运算。

​expr 5+10​ 回显 5+10

  • 这表示如果你直接使用expr 5+10​,它不会计算结果,而是字面意义上显示这个表达式。

    ┌──(root㉿kali)-[~/work]
    └─# expr 5+10
    5+10
    
    

那么该怎么运算呢?

  • 正确的使用方式是expr 5 + 10​。注意这里在数字和运算符之间有空格。expr​命令需要有空格来正确解析表达式。

    ┌──(root㉿kali)-[~/work]
    └─# expr 5 + 10
    15
    
    ┌──(root㉿kali)-[~/work]
    └─# expr 20 -  10
    10
    
    

乘法除法

  • 使用expr​可以进行加法和减法运算。

乘法反斜杠\​来转义

  • 直接使用expr​进行乘法运算会出错,因为expr​不支持乘法和除法。

    ┌──(root㉿kali)-[~/work]
    └─# expr 20 *  10
    expr: 语法错误:未预期的参数 "exam"
    
    

​expr 6 \* 6​(乘法是用\*​,Python直接*​就行了,要用\​进行转义)

  • 在Shell脚本中,乘法需要使用反斜杠\​来转义,因为*​在Shell中是一个通配符。

    ┌──(root㉿kali)-[~/work]
    └─# expr 20 \*  10
    200
    
    

除法就有两种方法:

除法可以使用/​运算符,但结果是整数。如果需要取余数,则使用%​运算符。

/​取整数

​expr 6 / 3​

  • 这个表达式会计算6除以3的结果,但只会返回整数部分,即2。

┌──(root㉿kali)-[~/work]
└─# expr 6 /  3
2     

取余数用%​

┌──(root㉿kali)-[~/work]
└─# expr 60 %  5
0

┌──(root㉿kali)-[~/work]
└─# expr 63 %  4
3
                        

混合运算

先乘除,后加减

┌──(root㉿kali)-[~/work]
└─# expr 5 + 10 \* 7
75

这个命令会先进行乘法运算,再进行加法运算,因为Shell会按照数学中的运算优先级来进行计算。结果是5 + 70 = 75​。

有括号

如果有括号这样直接运算就会报错,括号也要进行转义

在Shell脚本中,括号不是运算符,它们需要被转义才能被expr​正确识别。

┌──(root㉿kali)-[~/work]
└─# expr (5 + 10) \* 7
zsh: unknown file attribute: 5

正确方式:

┌──(root㉿kali)-[~/work]
└─# expr \(5 + 10 \) \* 7
expr: 参数不是整数
                                                                                                                                                          
┌──(root㉿kali)-[~/work]
└─# expr \( 5 + 10 \) \* 7
105

  • 通过在括号前加上反斜杠\​进行转义,这个命令可以正确执行。首先计算括号内的加法5 + 10 = 15​,然后乘7,结果是105。

运算与变量结合

使用括号

┌──(root㉿kali)-[~]
└─# num=$(expr 5 + 10)
                                                                                                                                                         
┌──(root㉿kali)-[~]
└─# echo $num
15
                                                                                                                                                         

使用let

┌──(root㉿kali)-[~]
└─# let re=2+3
                                                                                                                                                         
┌──(root㉿kali)-[~]
└─# echo $re 
5

使用反引号

┌──(root㉿kali)-[~]
└─# result=`expr 5 + 5`  
                                                                                                                                                         
┌──(root㉿kali)-[~]
└─# echo $result         
10
                        

加法运算与变量结合

#!/bin/bash

# 计算两个数的和
sum=$(expr 10 + 5)

# 输出结果
echo "The sum is: $sum"

┌──(root㉿kali)-[~/work]
└─# sum=$(expr 10 + 50) 
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# echo "The sum is : $sum"
The sum is : 60

减法运算与变量结合

#!/bin/bash

# 计算两个数的差
difference=$(expr 10 - 5)

# 输出结果
echo "The difference is: $difference"

┌──(root㉿kali)-[~/work]
└─# difference=$(expr 10 - 5)
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# echo "The difference is: $difference"
The difference is: 5

乘法运算与变量结合

#!/bin/bash

# 计算两个数的乘积
product=$(expr 3 \* 7)

# 输出结果
echo "The product is: $product"

┌──(root㉿kali)-[~/work]
└─# product=$(expr 3 \* 7)
                                                                                                                
┌──(root㉿kali)-[~/work]
└─# echo "The product is: $product"
The product is: 21

除法运算与变量结合

#!/bin/bash

# 计算两个数的商
quotient=$(expr 10 / 5)

# 输出结果
echo "The quotient is: $quotient"

┌──(root㉿kali)-[~/work]
└─# quotient=$(expr 10 / 5)
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# echo "The quotient is: $quotient"
The quotient is: 2

混合运算与变量结合

#!/bin/bash

# 计算混合运算的结果
result=$(expr \( 10 + 5 \) \* 2)

# 输出结果
echo "The result of the expression (10 + 5) * 2 is: $result"

┌──(root㉿kali)-[~/work]
└─# result=$(expr \( 10 + 5 \) \* 2)

┌──(root㉿kali)-[\~/work]
└─# echo "The result of the expression (10 + 5) \* 2 is: \$result"
The result of the expression (10 + 5) \* 2 is: 30

用变量进行运算

#!/bin/bash

# 定义两个变量
a=10
b=5

# 使用变量进行加法运算
sum=$(expr $a + $b)

# 输出结果
echo "The sum of $a and $b is: $sum"

┌──(root㉿kali)-[~/work]
└─# a=10     
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# b=5              
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# sum=$(expr $a + $b)
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# echo "The sum of $a and $b is: $sum"
The sum of 10 and 5 is: 15
                                                

使用双括号进行算术扩展(Bash 3.0+)

#!/bin/bash

# 定义两个变量
a=10
b=5

# 使用双括号进行加法运算
sum=$(( a + b ))

# 输出结果
echo "The sum of $a and $b is: $sum"

┌──(root㉿kali)-[~/work]
└─# c=10 
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# d=50                   
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# sum=$((a + b))   
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# echo "The sum of $a and $b is: $sum"
The sum of 10 and 5 is: 15
                                         

请注意,expr​命令在现代Shell脚本中较少使用,因为它的功能有限且使用起来不够直观。在Bash 3.0及以上版本中,推荐使用双括号(( ))​进行算术扩展,因为它更简洁且易于阅读。此外,双括号还支持更复杂的数学运算,如指数、模运算等。

指数、模运算

在Shell脚本中,使用expr​命令进行指数和模运算比较有限,因为expr​本身并不直接支持这些操作。但是,可以使用bc​(一个任意精度的计算器语言)或者awk​来执行这些运算。

安装bc
┌──(root㉿kali)-[~/work]
└─# apt install bc     
使用bc​进行指数运算
#!/bin/bash

# 计算指数
power=$(echo "10^2" | bc)

# 输出结果
echo "10 raised to the power of 2 is: $power"

┌──(root㉿kali)-[~/work]
└─# power=$(echo "10^2" | bc)
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# echo "10 raised to the power of 2 is: $power"
10 raised to the power of 2 is: 100

  • ​echo "10^2"​:输出了字符串"10^2",其中^​是bc​中用来表示指数运算的符号。

  • ​| bc​:将echo​命令的输出通过管道传递给bc​命令。bc​是一个任意精度的计算器语言,它可以处理包括指数在内的复杂数学运算。

  • ​power=...​:将bc​命令的输出结果赋值给变量power​。

  • 使用echo​来输出一个字符串,其中包含了变量power​的值。由于power​变量在上一步中被赋值为100(即10的平方)

使用awk​进行指数运算
#!/bin/bash

# 计算指数
power=$(awk 'BEGIN{print 10**2}')

# 输出结果
echo "10 raised to the power of 2 is: $power"

┌──(root㉿kali)-[~/work]
└─# power=$(awk 'BEGIN{print 10**2}')
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# echo "10 raised to the power of 2 is: $power"
10 raised to the power of 2 is: 100

  • ​awk 'BEGIN{print 10**2}'​:awk​是一个强大的文本处理工具,它也可以用来执行数学运算。在这里,BEGIN​是一个特殊的模式,它在awk​程序开始执行时处理一次。print 10**2​是awk​中的一个表达式,**​是awk​用来表示指数运算的符号。

  • ​power=...​:将awk​命令的输出结果赋值给变量power​。由于10**2​计算的是10的平方,结果是100,所以power​变量被赋值为100。

  • 使用echo​来输出一个字符串,其中包含了变量power​的值。由于power​变量在上一步中被赋值为100,

使用bc​进行模运算
#!/bin/bash

# 计算模
mod=$(echo "10 % 3" | bc)

# 输出结果
echo "The modulus of 10 divided by 3 is: $mod"

┌──(root㉿kali)-[~/work]
└─# mod=$(echo "10 % 3" | bc)
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# echo "The modulus of 10 divided by 3 is: $mod"
The modulus of 10 divided by 3 is: 1

  • ​echo "10 % 3"​:输出了字符串 "10 % 3",其中 %​ 是 bc​ 中用来表示模运算(求余数)的符号。

  • ​| bc​:将 echo​ 命令的输出通过管道传递给 bc​ 命令。bc​ 是一个任意精度的计算器语言,它可以处理包括模运算在内的复杂数学运算。

  • ​mod=...​:将 bc​ 命令的输出结果赋值给变量 mod​。

  • 使用 echo​ 来输出一个字符串,其中包含了变量 mod​ 的值。由于 10 % 3​ 计算的是 10 除以 3 的余数,结果是 1,所以 mod​ 变量被赋值为 1。

使用awk​进行模运算
#!/bin/bash

# 计算模
mod=$(awk 'BEGIN{print 10 % 3}')

# 输出结果
echo "The modulus of 10 divided by 3 is: $mod"

┌──(root㉿kali)-[~/work]
└─# mod=$(awk 'BEGIN{print 10 % 3}')
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# echo "The modulus of 10 divided by 3 is: $mod"
The modulus of 10 divided by 3 is: 1

  • ​awk 'BEGIN{print 10 % 3}'​:awk​是一个强大的文本处理工具,它也可以用来执行数学运算。在这里,BEGIN​是一个特殊的模式,它在awk​程序开始执行时处理一次。print 10 % 3​是awk​中的一个表达式,%​是awk​用来表示模运算(求余数)的符号。

  • ​mod=...​:将awk​命令的输出结果赋值给变量mod​。由于10 % 3​计算的是10除以3的余数,结果是1,所以mod​变量被赋值为1。

  • 使用echo​来输出一个字符串,其中包含了变量mod​的值。由于mod​变量在上一步中被赋值为1

结合变量使用bc​进行指数运算
#!/bin/bash

# 定义变量
base=2
exponent=3

# 计算指数
power=$(echo "$base^$exponent" | bc)

# 输出结果
echo "$base raised to the power of $exponent is: $power"

┌──(root㉿kali)-[~/work]
└─# base=2
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# exponent=3
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# power=$(echo "$base^$exponent" | bc)
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# echo "$base raised to the power of $exponent is: $power"
2 raised to the power of 3 is: 8
                                                        
  • ​echo "$base^$exponent"​:输出了字符串,其中包含了变量base​和exponent​的值,以及^​符号,这是bc​中用来表示指数运算的符号。

  • ​| bc​:将echo​命令的输出通过管道传递给bc​命令。bc​是一个任意精度的计算器语言,它可以处理包括指数在内的复杂数学运算。

  • ​power=...​:将bc​命令的输出结果赋值给变量power​。由于2^3​计算的是2的3次方,结果是8,所以power​变量被赋值为8。

  • 使用echo​来输出一个字符串,其中包含了变量base​、exponent​和power​的值。由于这些变量分别被赋值为2、3和8

结合变量使用awk​进行模运算
#!/bin/bash

# 定义变量
dividend=10
divisor=3

# 计算模
mod=$(awk -v d=$dividend -v v=$divisor 'BEGIN{print d % v}')

# 输出结果
echo "The modulus of $dividend divided by $divisor is: $mod"

请注意,awk​命令中的-v​选项用于传递外部变量到awk​脚本中。

┌──(root㉿kali)-[~/work]
└─# dividend=10
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# divisor=3   
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# mod=$(awk -v d=$dividend -v v=$divisor 'BEGIN{print d % v}')
                                                                                                                  
┌──(root㉿kali)-[~/work]
└─# echo "The modulus of $dividend divided by $divisor is: $mod"
The modulus of 10 divided by 3 is: 1
                                   
  • ​-v d=$dividend -v v=$divisor​:awk​命令的-v​选项用于将外部变量的值传递到awk​脚本中。这里,d​和v​是awk​脚本中的变量,分别被赋值为dividend​和divisor​的值。

  • ​'BEGIN{print d % v}'​:这是awk​脚本的一部分,BEGIN​是一个特殊的模式,它在awk​程序开始执行时处理一次。print d % v​是awk​中的一个表达式,%​是awk​用来表示模运算(求余数)的符号。

  • ​mod=...​:将awk​命令的输出结果赋值给变量mod​。由于10 % 3​计算的是10除以3的余数,结果是1,所以mod​变量被赋值为1。

  • 使用echo​来输出一个字符串,其中包含了变量dividend​、divisor​和mod​的值。由于这些变量分别被赋值为10、3和1

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值