shell函数与数组（有趣的冒泡）

最新推荐文章于 2022-12-31 11:01:20 发布

一颗橙子lio

最新推荐文章于 2022-12-31 11:01:20 发布

阅读量134

点赞数

文章标签： bash linux 开发语言

本文链接：https://blog.csdn.net/weixin_43554927/article/details/125600845

版权

函数和数组

一、函数的作用

（两种方式）

function 函数名 {

command

}       #这是一种规范写法

函数名（）{     #最常用因为最简洁

command

}

函数定义完之后并不会自动执行，需要调用才行，好处在于可以写一段功能代码作为函数，有需要就直接调用
定义的时候哪怕出现语法错误也没关系，不调用就不会报错
当然我们写函数最终目的还是为了调用，为了实现某个功能块

二、函数返回值

return表示退出函数并返回一个退出值，脚本中可以用 $? 变量显示该值使用原则 : 1 、函数一结束就取返回值，因为$ ?变量只返回执行的最后一条命令的退出状态码
2、退出状态码必须是0~255，超出时值将为取余256
例
444 % 256

三、函数的调用

直接在脚本里定义函数的代码块后写函数名即可完成调用

#!/bin/bash
function fun1 {     #定义了一个函数叫做fun1
echo "this is a function!"    #函数体的功能是打印"this is a function!
}

fun1    #直接写函数名就会运行函数体内的代码

[root@server myscripts]# . fun.sh

this is a function!

注意①：函数名必须是唯一，如果先定义了一个，再用同样的名称定义，第二个会覆盖第一个的功能，出现了你不想要的结果，所以这里一定要注意不要重名！

#!/bin/bash
f1 (){
echo hello
}

f1 (){
echo world
}

f1
[root@localhost ~]# . f1.sh 

world

注意②：调用函数之前必须先进行定义！

#!/bin/bash
f1 (){
echo hello
}

f3 (){
echo "$(f1) $(f2)"
}

f2 (){
echo world
}

f3

[root@localhost ~]# bash f1.sh   #因为f3函数里调用了f2，调用了f3的时候并不能知道f2的定义，因为f2在f3运行之后才被定义，所以运行的脚本会报错
f1.sh:行8: f2: 未找到命令
hello

#!/bin/bash
f1 (){
echo hello
}
f3 (){
echo "$(f1) $(f2)"    #这里虽然提前调用了f2，但是f2的函数还是在运行f3之前定义的所以他能够找到
}
f2 (){
echo world
}
f3

注意③：不一定要在脚本开头就定义函数，只要调用之前定义就可以

如果是在其他地方嵌套调用等情况，不可以直接写函数的值，避免无法识别，可以用反撇号引起来，相当于是调用函数的结果
#!/bin/bash
f1 (){
echo hello
}

f2 (){
echo world
}

f3 (){
echo "`f1` `f2`"    #这里如果直接是f1和f2的话，打印出来的不会是hello world而会是f1 f2
}

f3

cat <<EOF >/etc/yum.repos.d/local.repo
[local]
name=local
baseurl=file:#/mnt
enabled=1
gpgcheck=0
EOF

vim localrepo. sh
#!/bin/bash
function backuprepo {
cd /etc/yum.repo.d
mkdir repo.bak
mv * .repo repo.bak
mount /dev/sr0 /mnt > /dev/null
}

makelocalrepo() {
echo '[local]
name= local
baseurl=file: ///mnt
enabled=1
gpgcheck=0' > local.repo

}

uselocal repo (){
yum clean all > /dev/null
yum makecache > /dev/null
yum install -y httpd > /dev/null
}

#===main=======
backuprepo
makelocalrepo
uselocalrepo

1、return

#!/bin/bash
function test1 {
read -p "请输入一个数字" num
return $[$num*2]
}
test1
echo $?

test2 () {
read -P "请输入值2:" NUM
echo $[$NUM*2]
}
res=$(test2)
echo $[$res *2]

2、函数传参

1.两个数求和
#!/bin/bash 
sum(){
read -p "请输入第一个数：" NUM1 
read -p "请输入第二个数：" NUM2
echo "你输入的两个数为： $NUM1 和 $NUM2 "
SUM=$(($NUM1+$NUM2))    #$(())引用可不加$
echo “两个数的和为： $SUM”
}
sum

四、函数的作用范围

在 Shell 脚本中函数的执行并不会开启一个新的子 Shell，而是仅在当前定义的 Shell 环境中有效。如果Shell脚本中的变量没有经过特殊设定，默认在整个脚本中都是有效的。在编写脚本时，有时需要将变量的值限定在函数内部，可以通过内置命令local来实现。函数内部变量的使用，可以避免函数内外同时出现同名变量对脚本结果的影响。

【全局、本地】

shell脚本中变量默认脚本内部全局有效
local命令：将变量限定在函数内部使用

[root@localhost ~]# vim myfun.sh
myfun ()
{
local i 
i=8 
echo $i
}
i=9 
myfun 
echo $i

上述脚本中myfun 函数内部使用了local命令设置变量i，其作用是将变量i限定在函数内部。myfun 函数外部同样定义了变量i，内部变量i和全局变量i互不影响。脚本执行时先调用了函数myfun，函数内部变量i为8，所以输出结果是8。调用完函数之后，给变量i赋值为9，再打印外部变量i，所以又输出 9

myfunc() {
a=8 
echo $a
}
myfunc
echo $a

#!/bin/bash
myfunc() {
a=8
echo $a
myfunc
a=9
echo $a I

1、函数的参数

函数的传参

函数的参数
计算位置变量$1和$2的和

#!/bin/bash
add (){
let sum=$1+$2   #这里的位置变量是函数的位置变量，所以要写在调用函数的后面，如果是调用脚本时使用则不能成功
echo $sum
}

add 4 5

脚本的参数

#!/bin/bash
add (){
let sum=$1+$2
echo $sum
}

add $1 $2   #这里相当于调用了脚本的参数了，然后把脚本的位置变量传递给函数进行计算

通过脚本传递参数给函数中的位置参数$1

#!/bin/bash
fun1(){
rm -rf $1
}
fun1 $1

调用函数时直接传递参数

#!/bin/bash fun1(){
rm -rf $1
}
fun1 /root/a.txt

函数中多参数传递和使用方法

案例：阶乘

#!/bin/bash
jiecheng (){
cheng=1
for i in {1..6}
do
let cheng=$i*$cheng
done
echo $cheng
}

jiecheng

优化版：根据用户需求算几的阶乘

#!/bin/bash
jiecheng (){
cheng=1
read -p "请问您想算几的阶乘：" num  #①给用户提示输入
for i in `seq $num`
do
let cheng=$i*$cheng
done
echo $cheng
}

jiecheng

#!/bin/bash
jiecheng (){
cheng=1
for i in `seq $1`    #②用位置变量的方式
do
let cheng=$i*$cheng
done
echo $cheng
}

jiecheng $1

2、函数的返回值

用return来自定义返回码
函数的返回值就是函数当中运行最后一条命令的状态码，默认成功为0，失败为非0值，可以通过$?查看
但是可以自己自定义返回码，用return
1、return的值范围是0-255
2、遇到return即结束函数不会再往下执行

#!/bin/bash
HELLO (){
echo "hello world"
}

HELLO    //执行成功 echo $?为0

#!/bin/bash
HELLO (){
echo "hello world"
ls xxxx
}

HELLO    //执行失败 echo $?为非0，因为没有xxxx的文件

#!/bin/bash
HELLO (){
echo "hello world"
return 11
}

HELLO    //执行成功 echo $?为11

#!/bin/bash
HELLO (){
echo "hello world"
return 11    //返回码为11，不会执行下面的命令了
ls xxxxx
return 22
}

HELLO

例1：测试文件是否存在

#!/bin/bash
file=/etc/xxxx

f1 (){
if [ -f $file ];then
return 100
else
return 200
fi
}

f1
echo $?   //返回码为200，我们可以根据返回值来判断我们想要的结果

例2：两个数之和

#!/bin/bash
SUM (){
let sum=$1+$2
echo $sum
return 100
}

SUM 5 5
echo $?

[root@localhost ~]# . re2.sh 
10
100

#!/bin/bash
SUM (){
let sum=$1+$2
echo $sum
return 100
}

SUM 5 5
num=`SUM 5 5`    //注意这里函数是有参数的
echo $?
echo $num
这个脚本返回码为
10         //先执行了函数，函数的结果是10
100       //执行函数之后返回码是100
10          //把函数的结果10赋值给了$num，所以是10

3、本地变量与全局变量

在脚本里定义的变量或者在函数体没有声明为本地变量的都为全局变量，意思是在当前shell环境都识别
如果需要这个变量只在函数中使用则可以在函数中用local关键字声明，这样即使函数体外有个重名的变量也没关系，不影响在函数体的使用
如果是用source执行脚本的话就能看出差别

[root@localhost ~]# a=nihao
#!/bin/bash     //写一个函数，首先打印a的值，然后改变a的值再打印
f1 (){
echo $a
a=world
echo $a
}

f1
[root@localhost ~]# source f1.sh     //用source执行脚本，会发现a的值改变了
nihao
world
[root@localhost ~]# echo $a
world

在函数体中用local定义变量a的值

#!/bin/bash
f1 (){
echo $a
local a=world
echo $a
}

f1
[root@localhost ~]# source f1.sh   //执行脚本发现a的值并没有改变
world
world

#!/bin/bash
f1 (){
echo $a
local a=world
echo $a
}

f1
echo $a

[root@localhost ~]# a=hello
[root@localhost ~]# source f1.sh   //可以看成变量a的值在函数体设为了本地变量所以只在函数体中生效
hello
world
hello

#!/bin/bash
function fun1 {
num1=$[var1*2]
}
read -p "input a num:" var1 fun1
echo the new value is: $num1

通过一个简单的例子感受一下函数的用法：
将之前写过的算数字总和和算奇数和偶数和的脚本融合在一个脚本中并用函数根据用户的输入来调用它们

#!/bin/bash
SUM (){
sum=0
read -p "计算1到几的和：" num
for i in `seq $num`
do
let sum=$i+$sum
let i++
done
echo $sum
}

oushu (){
sum=0
read -p "计算1到几的偶数和：" num
for i in `seq $num`
do
if [ $((i%2)) -eq 0 ];then
let sum=$i+$sum
fi
let i++
done
echo $sum
}

if [ $1 == SUM ];then
SUM
elif [ $1 == oushu ];then
oushu
else
        echo "参数错误"
fi

4、函数的递归

函数自己调用自己的本身
列出目录内文件列表，目录用蓝色表示，文件显示层级关系

#!/bin/bash
list(){
for i in $1/*
do
        if [ -d $i ];then
        echo -e "\e[34m$i\e[0m"
        list $i " $2"
        else
        echo "$2$i"
fi
done
}
list $1 $2

====================

扩展tips

#!/bin/bash



#下面是字体输出颜色及终端格式控制

#字体色范围：30-37

echo -e "\033[30m 黑色字 \033[0m"

echo -e "\033[31m 红色字 \033[0m"

echo -e "\033[32m 绿色字 \033[0m"

echo -e "\033[33m 黄色字 \033[0m"

echo -e "\033[34m 蓝色字 \033[0m"

echo -e "\033[35m 紫色字 \033[0m"

echo -e "\033[36m 天蓝字 \033[0m"

echo -e "\033[37m 白色字 \033[0m"

#字背景颜色范围：40-47

echo -e "\033[40;37m 黑底白字 \033[0m"

echo -e "\033[41;30m 红底黑字 \033[0m"

echo -e "\033[42;34m 绿底蓝字 \033[0m"

echo -e "\033[43;34m 黄底蓝字 \033[0m"

echo -e "\033[44;30m 蓝底黑字 \033[0m"

echo -e "\033[45;30m 紫底黑字 \033[0m"

echo -e "\033[46;30m 天蓝底黑字 \033[0m"

echo -e "\033[47;34m 白底蓝字 \033[0m"

#控制选项说明

#\033[0m 关闭所有属性

#\033[1m 设置高亮度

#\033[4m 下划线

echo -e "\033[4;31m 下划线红字 \033[0m"

#闪烁

echo -e "\033[5;34m 红字在闪烁 \033[0m"

#反影

echo -e "\033[8m 消隐 \033[0m "

\#\033[30m-\033[37m 设置前景色

\#\033[40m-\033[47m 设置背景色

\#\033[nA光标上移n行

\#\033[nB光标下移n行

echo -e "\033[4A 光标上移4行 \033[0m"

\#\033[nC光标右移n行

\#\033[nD光标左移n行

\#\033[y;xH设置光标位置

\#\033[2J清屏

\#\033[K清除从光标到行尾的内容

echo -e "\033[K 清除光标到行尾的内容 \033[0m"

\#\033[s 保存光标位置

\#\033[u 恢复光标位置

\#\033[?25| 隐藏光标

\#\033[?25h 显示光标

echo -e "\033[?25l 隐藏光标 \033[0m"

echo -e "\033[?25h 显示光标 \033[0m"
```

计算5的阶乘
#阶乘 5！ 54321ls

#!/bin/bash
fa () {
if [ $1 -eq  1 ]
then
echo 1
else
 local tp=$[ $1 - 1]
 local res=$(fa $tp)
 echo $[ $1 * $res ]
 5 * $res(4*$res(3*$res(2*$res(1)))) 

fi

}

5
fa 5 $1=5 tp=4 res=fa 4 echo 5 * fa 4    5*4*3*2*1
fa 4 $1=4 tp=3 res=fa 3 echo 4 * fa 3    4*3*2*1
fa 3 $1=3 tp=2 res=fa 2 echo 3 * fa 2    3*2*1
fa 2 $1=2 tp=1 res=fa 1 echo 2 * fa 1	 2*1
fa 1 $1=1               echo 1  



read -p "请输入："  num
res=$(fa $num)
echo $res

#!/bin/bash
function list_files()
{
for f in `ls $1`; 
do
if [ -d "$1/$f" ]; then 
echo "$2$f"
list_files "$1/$f" "$2"
else 
echo "$2$f"
fi

done
}

list_files "/var/log" ""

小结：
函数的用法：
1、定义方式：
function函数名{}
函数名($1$2$3){}
2、返回值
return[数字]：表示的意思是自return以下的部分忽略，并且结束当前函数的指令，最后抛出指定的(return的值)返回值
3、函数中的本地变量和全局变量
正常一个脚本中定义变量的时候，都是在这个脚本的全局生效
但是我们可以在函数体中，定义1oc1[变量名]，然后让此变量生效的范围仅在函数体内

ps:调用脚本时，以绝对路径的方式运行的话，脚本仅使用一个进程来管理，并且在进程所空的的环境中执行，不会影响到centos的环境变量，但是，如果实用source的话，系统则会把脚本中的所有执行操作，跑在自身环境中，而此时，脚本中的执行，就会影响到整个环境

（以上也可以理解为：本地变量和全局变量）

4、函数的使用方式
定义多组函数，每个函数视为一种独立的功能，（一般我们可以称为模块化）

五、数组的定义

数组是存放相同类型数据的集合，在内存中开辟了连续的空间，通常配合循环使用

1、数组的分类

普通数组：不需要声明直接定义，下标索引只能是整数
关联数组：需要用declare -A声明否则系统不识别，索引可以是字符串

数组的定义方式
(30 20 10 60 50 40)
0 1 2 3 4 5 （数组下标，索引下标）

在shell语句中，使用、遍历数组的时候，数组格式要写成 ${arr[@]} 或 ${arr[*]}

num=(1 2 3 4 5)
[root@localhost]# echo ${num[0]}
1
[root@localhost]# echo ${num[4]}
5
[root@localhost]# echo ${num[*]}
1 2 3 4 5
[root@localhost]# echo ${num[@]}
1 2 3 4 5

2、定义数组

第一种：直接把要加入数组的元素用小括号括起来，中间用空格分开
num=(11 22 33 44）
${#num} 显示字符串长度
数组名= (value0 value1 value2)

[*]和[@]都代表所有

[root@localhost]# num=(1 11 111 1111)
[root@localhost]# echo ${#num[1]}
2
[root@localhost]# echo ${#num[3]}
4

第二种：精确的给每一个下标索引定义一个值加入数组，索引数字可以不连续
num=([0]=55 [1]=66 [2]=77 [4]=88)

数组名=([0]=value [1] =value [2] =value…)

[root@localhost ~]# num=([0]=55 [1]=66 [2]=77 [4]=88)
[root@localhost ~]# echo ${num[*]}
55 66 77 88
[root@localhost ~]# echo ${#num[*]}
4
[root@localhost ~]# echo ${num[3]}
##此处无输出

第三种：先把要加入数组的元素全部先赋值给一个变量，然后引用这个变量加入到数组
list=“11 12 13 14”
num=($list)

方法三:
列表名="value0 value1 value2…”
数组名=($列表名)

第四种根据下标定义
数组名[0]=“11”
数组名[0]=“22”
数组名[0]=“33”

数组名[0]=“value”
数组名[1]=“value”
数组名[2]=“value”

[root@localhost ~]# a[0]=1
[root@localhost ~]# a[1]=2
[root@localhost ~]# echo ${a[*]}
1 2

3、数组包括的数据类型

数值类型
字符类型：
使用“ ” 或 ‘ ’ 定义

获取数组的长度

arr_number=(10 20 30 40 50)
arr_length=${#arr_number[*]}
${#arr_number[@]}

[root@localhost ~]# arr_number=(10 20 30 40 50)
[root@localhost ~]# arr_length=${#arr_number[*]}
[root@localhost ~]# echo $arr_length
5

获取数据列表

echo ${arr_number[*]}
echo ${arr_number[@]}

读取某下标赋

arr_index2=${arr_number[2]}
echo $arr_index2

数组元素遍历

#!/bin/bash
arr=(1 2 3 4 5 6)
for i in ${arr[*]}   或for i in ${arr[@]}
do
echo $i
done

元素切片

arr=(1 2 3 4 5 6 7 8)
echo ${arr[*]} #输出整个数组
echo ${arr[*]:2:3} #提取从索引2开始的3个元素

echo ${arr[@]:2:2}

echo ${arr[*]:0:2}

[root@localhost ~]# arr=(1 2 3 4 5 6 7 8)
[root@localhost ~]# echo ${arr[*]}  
1 2 3 4 5 6 7 8
[root@localhost ~]# echo ${arr[*]:0:2}  
1 2
[root@localhost ~]# echo ${arr[*]:0:3}  
1 2 3
[root@localhost ~]# echo ${arr[*]:3:3}  
4 5 6

数组（元素）替换

arr=(1 2 3 4 5)
echo ${arr[@]/3/55} //$ {数组名[@或*]/查找字符/替换字符}
echo ${arr[@]} //并不会替换数组原有内容 arr=($ {arr[@]/3/55}) //要实现改变原有数组，可通过重新赋值实现 arr= ${arr[@]/3/55} arr=($ {arr[@]/3/55})
echo ${arr[@]}

arr=(5 1 2 3 4 5) 定义下标修改

[root@localhost ~]# arr=(1 2 3 4 5)
[root@localhost ~]# echo ${arr[@]/3/55} #输出时替换第三个元素
1 2 55 4 5
[root@localhost ~]# echo ${arr[@]}   
1 2 3 4 5
[root@localhost ~]# arr=(${arr[@]/3/55}) #重新赋值，替换第三个元素
[root@localhost ~]# echo ${arr[@]}
1 2 55 4 5

数组删除

arr=(1 2 3 45)
unset arr //删除数组
echo $ { arr[* ]}

arr=(1 2 3 4 5)
unset arr[4] //删除第四个元素
echo $ {arr[*]}

[root@localhost ~]# arr=(1 2 3 45)
[root@localhost ~]# unset arr     #删除数组
[root@localhost ~]# echo ${arr[*]}

[root@localhost ~]# arr=(1 2 3 4 5)
[root@localhost ~]# unset arr[2]   #删除下标2的元素
[root@localhost ~]# echo ${arr[*]}
1 2 4 5

小结：

六、数组排序算法:冒泡排序

类似气泡上涌的动作，会将数据在数组中从小到大或者从大到小不断的向前移动。
基本思想:
冒泡排序的基本思想是对比相邻的两个元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面(也就是交换两个元素的位置)，这样较小的元素就像气泡一样从底部上升到顶部。
算法思路：
冒泡算法由双层循环实现，其中外部循环用于控制排序轮数，一般为要排序的数组长度减1次，因为最后一次循环只剩下一个数组元素，不需要对比，同时数组已经完成排序了。而内部循环主要用于对比数组中每个相邻元素的大小，以确定是否交换位置，对比和交换次数随排序轮数而减少。

算法1

#!/bin/bash
array=(90 70 60 40 50 30)
echo "old_array：${array[*]}"
lt=${#array[*]}
#定义比较轮数，比较轮数为数组长度减1，从1开始
for ((i=1; i<$lt; i++))
do
  #确定比较元素的位置，比较相邻两个元素，较大的数往后放，比较次数随比较轮数而减少
  for ((j=0; j<$lt-i; j++))
  do
    #定义第一个元素的值
    first=${array[$j]}
	#定义第二个元素的值
	k=$[$j+1]
	second=${array[$k]}
	#如果第一个元素比第二个元素大就互换
    if [ $first -gt $second ]
    then
	  #把第一个元素值保存到临时变量中
	  temp=$first
	  #把第二个元素值赋给第一个元素
      array[$j]=$second
	  #把临时变量（也就是第一个元素原值）赋给第二个元素
      array[$k]=$temp
    fi
  done
done
#输出排序后的数组
echo "new_array：${array[*]}"

算法2


#!/bin/bash
a=(90 70 60 40 50 30)
temp=0
echo "原数组是：${a[*]}"
lt=${#a[*]}
#定义比较轮数，比较轮数为数组长度减1，从1开始
for((i=1; i<$lt; i++))
do
#确定比较元素的位置，比较相邻两个元素，较大的数往后放，比较次数随比>较轮数而减少
  for((j=0; j<$lt-i; j++))
  do
    if [ ${a[j]} -gt ${a[j+1]} ];then
          #把第二个元素值保存到临时变量中
          temp=${a[j+1]}
          #把第一个元素值赋给第二个元素
          a[j+1]=${a[j]}
          #把临时变量赋给第一个元素
          a[j]=$temp
    fi
  done
done
#输出排序后的数组
echo "新的数组：${a[*]}"
~

99乘法表数组

a=(1 2 3 4 5 6 7 8 9)
b=(1 2 3 4 5 6 7 8 9)

c=0
while [ $c -lt 9 ]
do
        d=0
        while [ $d -le $c ]
        do
        num=$[${b[$d]}*${a[$c]}]
        echo -e -n "${b[$d]}*${a[$c]}=$num \t" 
        let ++d
        done
let ++c
echo
done

存入元素,输出从小到达元素

#!/bin/bash
#存入元素
k=0
while true
do
read -p "是否存入元素(yes/no):" doing
if [ $doing == "no" ];then
break
elif [ $doing == "yes" ];then
read -p "请输入第$[$k+1]个元素:" key
score[$k]=$key
let k++
else
echo "请输入yes/no"
fi
done
#外层循环
for ((i=1;i<${#score[*]};i++));do
#内层循环
  for ((j=0;j<${#score[*]}-i;j++));do
#交换
    if [ ${score[$j]} -gt ${score[$j+1]} ];then
    tmp=${score[$j+1]}
    score[$j+1]=${score[$j]}
    score[$j]=$tmp
    fi
  done
done
echo ${score[*]}

do
if [ ${a[j]} -gt $KaTeX parse error: Expected 'EOF', got '#' at position 27: \dotsthen #̲把第二个元素值保存到临时变量中\dots$ {a[j+1]}
#把第一个元素值赋给第二个元素
a[j+1]= $KaTeX parse error: Expected 'EOF', got '#' at position 18: \dots[j]} #̲把临时变量赋给第一个元素 \dots$ temp
fi
done
done
#输出排序后的数组
echo “新的数组：${a[*]}”
~


#### 99乘法表数组

```bash
a=(1 2 3 4 5 6 7 8 9)
b=(1 2 3 4 5 6 7 8 9)

c=0
while [ $c -lt 9 ]
do
        d=0
        while [ $d -le $c ]
        do
        num=$[${b[$d]}*${a[$c]}]
        echo -e -n "${b[$d]}*${a[$c]}=$num \t" 
        let ++d
        done
let ++c
echo
done

存入元素,输出从小到达元素

#!/bin/bash
#存入元素
k=0
while true
do
read -p "是否存入元素(yes/no):" doing
if [ $doing == "no" ];then
break
elif [ $doing == "yes" ];then
read -p "请输入第$[$k+1]个元素:" key
score[$k]=$key
let k++
else
echo "请输入yes/no"
fi
done
#外层循环
for ((i=1;i<${#score[*]};i++));do
#内层循环
  for ((j=0;j<${#score[*]}-i;j++));do
#交换
    if [ ${score[$j]} -gt ${score[$j+1]} ];then
    tmp=${score[$j+1]}
    score[$j+1]=${score[$j]}
    score[$j]=$tmp
    fi
  done
done
echo ${score[*]}

一颗橙子lio

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
shell函数与数组（有趣的冒泡）

（两种方式）函数定义完之后并不会自动执行，需要调用才行，好处在于可以写一段功能代码作为函数，有需要就直接调用定义的时候哪怕出现语法错误也没关系，不调用就不会报错当然我们写函数最终目的还是为了调用，为了实现某个功能块return表示退出函数并返回一个退出值，脚本中可以用?变量显示该值使用原则:1、函数一结束就取返回值，因为?变量显示该值使用原则:1、函数一结束就取返回值，因为?变量显示该值使用原则:1、函数一结束就取返回值，因为?变量只返回执行的最后一条命令的退出状态码2、退出状态码必须是0~2
复制链接

扫一扫