shell学习笔记汇总——1

一、shell学习笔记

1.shell脚本中函数使用

函数定义在前，调用在后，顺序反了就没有效果了。
函数调用为：函数名参数列表

函数内部通过以下变量访问函数的参数：
shell脚本函数中：
　　$0: 这个脚本的名字
　　$n: 这个脚本传入的参数值,n取1..9
　　$*: 这个脚本所有参数
　　$#: 这个脚本参数个数
　　$$: 这个脚本运行时的PID
　　$!: 执行上一个背景指令的PID
　　$?: 执行上一个指令的返回值

举例说：
脚本名称叫test.sh 入参三个: 1 2 3
运行test.sh 1 2 3后
　　$*为"1 2 3"（一起被引号包住）
　　$@为"1" "2" "3"（分别被包住）注意:"$@"必须被引用.
　　$#为3（参数数量）

$* 和 $@ 的区别:
$* 和 $@ 都表示传递给函数或脚本的所有参数，不被双引号(" ")包含时，都以"$1" "$2" … "$n" 的形式输出所有参数。
但是当它们被双引号(" ")包含时，"$*" 会将所有的参数作为一个整体，以"$1 $2 … $n"的形式输出所有参数；"$@" 会将各个参数分开，以"$1" "$2" … "$n" 的形式输出所有参数。
下面的例子可以清楚的看到 $* 和 $@ 的区别：

#!/bin/bash
echo "\$*=" $*
echo "\"\$*\"=" "$*"
echo "\$@=" $@
echo "\"\$@\"=" "$@"
echo "print each param from \$*"
for var in $*
do
echo "$var"
done
echo "print each param from \$@"
for var in $@
do
echo "$var"
done
echo "print each param from \"\$*\""
for var in "$*"
do
echo "$var"
done
echo "print each param from \"\$@\""
for var in "$@"
do
echo "$var"
done

执行 ./test.sh "a" "b" "c" "d"，看到下面的结果：

$*=  a b c d
"$*"= a b c d
$@=  a b c d
"$@"= a b c d
print each param from $*
a
b
c
d
print each param from $@
a
b
c
d
print each param from "$*"
a b c d
print each param from "$@"
a
b
c
d

2. shell脚本中判断上一个命令是否执行成功

shell中使用符号“$?”来显示上一条命令执行的返回值，如果为0则代表执行成功，其他表示失败。
结合if-else语句实现判断上一个命令是否执行成功。

示例：
if [ $? -ne 0 ]; then
echo "failed"
else
echo "succeed"
fi

或者：
if [ $? -eq 0 ]; then
echo "succeed"
else
echo "failed"
fi

3.shell脚本中的if条件测试

(1)整数变量表达式

if [ int1 -eq int2 ] 如果int1等于int2
if [ int1 -ne int2 ] 如果不等于
if [ int1 -ge int2 ] 如果>=
if [ int1 -gt int2 ] 如果>
if [ int1 -le int2 ] 如果<=
if [ int1 -lt int2 ] 如果<

(2)字符串变量表达式

if [ $a = $b ] 如果string1等于string2 字符串允许使用赋值号做等号(通过‘=’两端是否有空格来判断)
if [ $string1 != $string2 ] 如果string1不等于string2
if [ -n $string ] 如果 string 为非空(非0）空则为真
if [ -z $string ] 如果 string 为空则为真
if [ $sting ] 如果string 非空，返回0 (和-n类似)
if [ STRING1 == STRING2 ] 如果2个字符串相同则为真。
if [ STRING1 != STRING2 ] 如果字符串不相等则为真。
if [ STRING1 < STRING2 ] 如果“STRING1”在当前语言环境中按字典顺序排序“STRING2”之后则为真。
if [ STRING1 > STRING2 ] 如果“STRING1”在当前语言环境中按字典顺序排序“STRING2”之前则为真。

#!/bin/sh

a="Liuyifei"
b="Yangying"

if [ $a > $b ]
then
 echo "a > b"
else
 echo "a < b"
fi

# 打印：a > b

(3)文件表达式

①判断文件(夹)是否存在
[ -a FILE ] 如果 FILE 存在则为真。
[ -d FILE ] 如果 FILE 存在且是一个目录则为真。
[ -e FILE ] 如果 FILE 存在则为真。
[ -g FILE ] 如果 FILE 存在且已经设置了SGID则为真。
[ -k FILE ] 如果 FILE 存在且已经设置了粘制位则为真。
[ -u FILE ] 如果 FILE 存在且设置了SUID (set user ID)则为真。
[ -O FILE ] 如果 FILE 存在且属有效用户ID则为真。
[ -G FILE ] 如果 FILE 存在且属有效用户组则为真。
[ -s FILE ] 如果 FILE 存在且大小不为0则为真。

②文件权限检查
[ -w FILE ] 如果 FILE 如果 FILE 存在且是可写的则为真。
[ -x FILE ] 如果 FILE 存在且是可执行的则为真。
[ -r FILE ] 如果 FILE 存在且是可读的则为真。
[ -s FILE ] 如果 FILE 存在且是非空白文件则为真。

③判断两个文件的新旧
[ FILE1 -nt FILE2 ] 如果 FILE1 比 FILE2 新，或者 FILE1 存在且 FILE2 不存在则为真。
[ FILE1 -ot FILE2 ] 如果 FILE1 比 FILE2 旧，或者 FILE2 存在且 FILE1 不存在则为真。

②判断文件是否为特殊文件
[ -f FILE ] 如果 FILE 存在且是一个普通文件则为真。
[ -b FILE ] 如果 FILE 存在且是一个块设备文件则为真。
[ -c FILE ] 如果 FILE 存在且是一个字符设备文件则为真。
[ -S FILE ] 如果 FILE 存在且是一个套接字文件则为真。
[ -p FILE ] 如果 FILE 存在且是一个名管道则为真。
[ -L FILE ] 如果 FILE 存在且是一个符号连接则为真。
[ -h FILE ] 如果 FILE 存在且是一个符号连接则为真。

③其它
[ -t FD ] 如果文件描述符 FD 打开且指向一个终端则为真。
[ -N FILE ] 如果 FILE 存在且已经被修改则为真。
[ FILE1 -ef FILE2 ] 如果 FILE1 和 FILE2 指向相同的设备和节点号则为真，主要判断两个文件是否均指向同一个inode，就是判断是否为同一个文件，可用于判断硬连接。

(4) 多重判断条件（test -r file -a -w file）

[ -r FILE1 -a -w FILE1] 如果 FILE1 可读且可写则为真，-a表示且。
[ -r FILE1 -o -w FILE1] 如果 FILE1 可读或可写则为真，-o表示或。
[ -! -x FILE1] 如果 FILE1 不具有可执行权限则为真，-!表示取反。

(5)变量与值的判断
if [ "$VAR" = "y" -o "$VAR" = "Y" ] 如果变量 VAR 的的值是"y"或"Y"则为真。

(6)运算符的使用
① "==", " = ", "!="运算符

#!/bin/bash

a=10
b=20

if [ $a == $b ] #或if [ $a = $b ]
then
  echo "a=b"
fi
if [ $a != $b ]
then
   echo "a!=b"
else
    :    # 表示什么也不做
fi

(7)使用&&判断

PPID=12882
for p in `ls /proc/$PPID/task/`;
do
    Thread=`cat /proc/$PPID/task/$p/comm`
    if [ "$Thread" != "com.tencent.tt" ] && [ "$Thread" != "com.tencent.mm" ]; then
        cat /proc/$PPID/task/$p/comm
    fi
done;

(8) 字符串模糊匹配比较

P=XXXX
for T in `ls /proc/$P/task`
do
    C=`cat /proc/$P/task/$T/comm`
    if [[ $C == Thread-* ]]; then
        chrt -f -p $T 1 #RT prio: 99-1=98
    fi
done;

4.使用sh执行和source执行脚本的区别

(1)sh script.sh、./script.sh、bash script.sh 方式执行脚本：
sh script.sh、./script.sh、bash script.sh 方式执行脚本是等效的，会在当前shell进程下生成一个子shell进程，在子shell中执行script.sh脚本。
脚本执行完毕，退出子shell，回到当前shell。

(2)source script.sh 和 . script.sh 方式执行脚本：
source script.sh 和 . script.sh 方式执行脚本是等效的，会在当前shell上下文中执行脚本，不会生成新的进程。脚本执行完毕，回到当前shell。
就相当于在命令行中逐条执行script.sh中的指令。

(3)exec方式
使用exec command方式，会用command进程替换当前shell进程，并且保持PID不变。执行完毕，直接退出，不回到之前的shell环境。

测试Demo1: 对比sh和source执行下面脚本打印进程号，可以使用htop工具查看进程树。
#!/bin/sh
while [ 1 = 1 ]; do
　　echo $$
　　sleep 1
done

前两种方式对环境变量的获取
# name = zhangshan
# $ cat test.sh
#!/bin/sh
echo $name
若是使用source执行，变量name对脚本test.sh可见,因为在同一个进程中执行的，若是使用sh test.sh执行，则变量name对脚本test.sh不可见，
因为不在同一个进程中。在一个脚本中执行另一个脚本也是类似情况。

5.shell中对/dev/null 和 /dev/zero的使用

　　①/dev/null ： /dev/null，称空设备，是一个特殊的设备文件，它丢弃一切写入其中的数据（但报告写入操作成功），读取它则会立即得到一个EOF。Unix行话中，/dev/null 被称为位桶(bit bucket)或者黑洞(black hole)。空设备通常被用于丢弃不需要的输出流，或作为用于输入流的空文件。这些操作通常由重定向完成。
　　 # cat /dev/null > /var/log/messages 清除文件的内容而不删除文件本身
　　 # : > /var/log/messages 有同样的效果，但不会产生新的进程。（内建的）
　　 # ln -s /dev/null test.c 往test.c中写任何内容都不会得到保存

　　②/dev/zero ： /dev/zero 是一个特殊的文件，当你读它的时候，它会提供无限的空字符(NULL, ASCII NUL, 0x00)。其中的一个典型用法是用它提供的字符流来覆盖信息，另一个常见用法是产生一个特定大小的空白文件。

6.使用 echo $? 查看上条命令的退出码：0为命令正常执行，1-255为有出错。
　　# dd if=/dev/zero of=/dev/sdb bs=4M 来给整个U盘清零。

7.echo $$ 打印运行当前脚本的进程的PID

8.要求以root身份来运行

ROOT_UID=0      　　　 # Root 用户的 $UID 是 0. 
E_WRONG_USER=65 　　　 # 不是 root? 
if [ "$UID" -ne "$ROOT_UID" ] 
then 
　　echo; echo "You must be root to run this script."; echo 
　　exit $E_WRONG_USER 
fi

或者：

E_NON_ROOT_USER=70      # 必须用root来运行. 

ROOTUSER_NAME=root 
username=`id -nu` 
if [ "$username" != "$ROOTUSER_NAME" ] 
then 
　　echo "Must be root to run ""`basename $0`""." 
　　exit $E_NON_ROOT_USER 
fi

9.单引号、双引号和反引号的区别

(1)单引号 ( '' )

当shell碰到第一个单引号时，它忽略掉其后直到右引号的所有特殊字符

(2)双引号 ( " " )
双引号作用与单引号类似，区别是它没有那么严格。单引号告诉shell忽略所有特殊字符，而双引号只要求忽略大多数特殊字符，
具体说，括在双引号中的三种特殊字符不被忽略：$,\,` ,即双引号会解释字符串的特别意思,而单引号直接使用字符串.如果使用
双引号将字符串赋给变量并反馈它，实际上与直接反馈变量并无差别。
如果要查询包含空格的字符串，经常会用到双引号。
# x=*
# echo $x
hello.sh menus.sh misc.sh phonebook tshift.sh
# echo '$x'
$x
# echo "$x"
*
这个例子可以看出无引号、单引号和双引号之间的区别。
在最后一种情况中，双引号告诉shell在引号内照样进行变量名替换，所以shell把$x替换为＊，因为双引号中不做文件名替换，所以
就把＊作为要显示的值传递给echo。
对于第一种情况需要进一步说明，shell在给变量赋值时不进行文件名替换（这从第三种情况中也能看出来），各步骤发生的精确次序如下：
shell扫描命令行，把x的值设为星号＊；
shell再次扫描命令行，碰到星号＊，把它替换成当前目录下的文件清单；
shell启动执行echo命令，把文件清单作为参数传递给echo.
这个赋值的先后次序非常重要：shell先作变量替换，然后作文件名替换，最后把这行处理为参数

(3)反引号(``)
命令替换是指shell能够将一个命令的标准输出插在一个命令行中任何位置。
shell中有两种方法作命令替换：把shell命令用反引号或者$(...)结构括起来，其中，$(...)格式受到POSIX标准支持，也利于嵌套。
# echo The date and time is `date`
The date and time is 三 6月 15 06:10:35 CST 2005
# echo Your current working directory is $(pwd)
Your current working directory is /home/howard/script

10.反斜杠 backslash-escaped( \ )
反斜杠一般用作转义字符,或称逃脱字符,linux如果echo要让转义字符发生作用,就要使用-e选项,且转义字符要使用双引号
echo -e "\n"

反斜杠的另一种作用,就是当反斜杠用于一行的最后一个字符时，shell把行尾的反斜杠作为续行，这种结构在分几行输入长命令时经常使用。

总结：
单引号：把里面的所有内容当作字符串
双引号：把除了$,\,` ,这三个字符以外的字符当作字符串，值进行变量字符串值替换，不进行变量含义替换
反引号：将一个命令的标准输出插在一个命令行中任何位置

11.shell中的export命令

功能说明：设置或显示环境变量。
语　　法：export [-fnp][变量名称]=[变量设置值]
参　　数：
　-f 　代表[变量名称]中为函数名称。
　-n 　删除指定的变量。变量实际上并未删除，只是不会输出到后续指令的执行环境中。
　-p 　列出所有的shell赋予程序的环境变量
注意：
1、执行脚本时是在一个子shell环境运行的，脚本执行完后该子shell自动退出；
2、一个shell中的系统环境变量才会被复制到子shell中（用export定义的变量）；
3、一个shell中的系统环境变量只对该shell或者它的子shell有效，该shell结束时变量消失（并不能返回到父shell中）。
4、不用export定义的变量只对该shell有效，对子shell也是无效的。

补充说明：
1.在shell中执行程序时，shell会提供一组环境变量。export可新增，修改或删除环境变量，供后续执行的程序使用。export的效力仅及于该此登陆操作。
2.export把自己的参数创建为一个环境变量，而这个环境变量可以被当前程序调用的其他脚本和程序看见，被导出变量构成从该shell衍生的任何子进程的环境变量

3. export 也是 bash 的一个内置命令。它主要是用来将父 shell 里的变量导出供子 shell 使用。它有如下特征：
(1) 用 export 导出的变量放在“导出变量列表”中，它可以被子 shell (子 shell 的子 shell 也是如此)拷贝并使用。
(2) 被 export 出来的变量虽然可以被子 shell 使用，但它也只是一个拷贝，而不会影响到父 shell 中的值以及其它子 shell 中的值。

但反过来，父shell再次更改此变量时，子 shell 再去读时，读到的是新值，而不是原来的值。

若子shell想要影响父shell，可以通过有名管道进行通信，类似进程间通信。

12.shell中的语句

(1) for语句

#!/bin/sh

for file in $(ls /home/hello/mytest/shell_test |grep sh)
do
    echo $file
done

for i in 0 1 2 3 4 5 6 7 8 9 #输出10次
do
    echo $i
done

for i in "0 1 2 3 4 5 6 7 8 9" #只循环1次，“”中的是一个变量
do
    echo $i
done

(2) until语句

END_CONDITION=end

until [ "$var1" = "$END_CONDITION" ]
do
    echo "Input variable #1 "
    echo "($END_CONDITION to exit)"
    read var1
    echo "variable #1 = $var1"
    echo
done 

exit 0

(3) if语句

#!/bin/bash

echo "Input a number #1 "
read num #从命令行中获取一个参数给num
echo "variable #1 = $num"
if [ $num -lt 60 ]
then
echo "you are not pass"
elif [ $num -lt 70 ] && [ $num -ge 60 ] #多个条件的判断
then
echo "pass"
elif [[ $num -lt 85 && $num -ge 70 ]] #如果放在一起，要注意是双方括号，不要写成[ $num -lt 85 && $num -ge 70 ]
then
echo "good"
elif (( $num <= 100 )) && (( $num >= 85 )) #对于有语言基础的人来说，这种写法让人觉得很舒服，不要忘了是双小括号
then
echo "very good"
else
echo "num is wrong"
fi #if要有结束标签的，根XML很像,不闭合，就报错
exit 0

(4) case语句

#!/bin/sh

#useage:./shell_case.sh start/stop/restart

case $1 in
start)
    echo "start ok"
;; #注意一点，要注意是双分号
stop)
    echo "stop ok"
;;
restart)
    echo "restart ok"
;;
*)
    echo "no param"
;;
esac #注意闭合标签

exit 0

(5) while语句

#!/system/bin/sh
i=0
while true
do
    let i++
    echo "============= i=$i ===============" >> tmp.txt
    sleep 0.1
done

# nohup /system/bin/sh while.sh & //使用nohup,拔掉adb线也可以运行
[1] 7047
杀掉：
fg
Ctrl+C

#!/system/bin/sh
i=0
while true
do
    let i++
    echo "============= i=$i ===============" > tmp.txt #数据条数是一直递增的！！
    sleep 0.1
done

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

#!/system/bin/sh
i=0
while true
do
    let i++
    echo "============= i=$i ==============="
    sleep 0.1
done > 1tmp.txt  #数据条数也是一直递增的

补充：

1. 查看命令是不是shell内建的

~/origin_tmp/test/shell_test$ type -a break continue
break is a shell builtin
continue is a shell builtin

2. for使用数组进行枚举

#!/bin/sh

for V in {1..10..2}
do
    if [[ $V -eq 9 ]]; then echo "is 9"; fi
    echo "V=$V";
done

/*
~/origin_tmp/test/shell_test$ ./break_continue.sh 
V=1
V=3
V=5
V=7
is 9
V=9
*/

14.shell中的函数

(1) shell中函数定义

function_name ()
{
    ...
}
或者:
function function_name()
{
   ...
}

(2) 函数调用

function_name parm1 parm2

(3) 函数的返回值

(1)return来返回某个0-255之间的整数值(在Shell中，return语句只能返回某个0-255之间的整数值)。
(2)在函数中将要返回的数据写入到标准输出(stout),通常这个操作是使用echo语句来完成的，然后在调用程序中将函数的执行结果赋值给一个变量。

#! /bin/bash

function sum()
{
  ret=$(( $1 + $2 ))
  return $ret
}

sum 22 4    #若是sum 253 4, 执行结果就是1，回滚了。

echo $?

#! /bin/bash

function length()
{
  str=$1
  result=0
  if [ "$str" != "" ] ; then
      result=${#str}
  fi
  echo "$result"
}

len=$(length "abc123")

echo "The string's length is $len "        #执行结果：The string's length is 6

注意：“$@”表示向一个函数传参的列表，eg:

#! /bin/bash

length()
{
  echo "$@"
}

length aaaaaaa bbbbbb cccccc dddd mmmm ddd nnnn

# $ ./return.sh 
# aaaaaaa bbbbbb cccccc dddd mmmm ddd nnnn

15.算数运算符
　　原生bash不支持简单的数学运算，但是可以通过其他的命令实现，例如awk和expr，expr最常用expr是一款表达式计算工具，使用它能完成表达式的求值操作。表达式和运算符之间要有空格，例如2+2是不对的，必须写成2 + 2，完整的表达式要被反引号括住。

四则运算符实例：

#!/bin/bash

a=10
b=20

val=`expr $a + $b`
echo "a+b:$val"

val=`expr $a - $b`
echo "a-b:$val"

val=`expr $a \* $b`
echo "a*b :$val"

val=`expr $b / $a`
echo "b / a:$val"

val=`expr $b % $a`
echo "b % a:$val"

if [ $a == $b ]
then
  echo "a=b"
fi
if [ $a != $b ]
then
   echo "a!=b"
fi


执行结果：
# ./test.sh 
a+b:30
a-b:-10
a*b :200
b / a:2
b % a:0
a!=b

关系运算符使用:

#!/bin/bash
a=10
b=20

if [ $a != $b ]
then
 echo "$a !=$b:a != b"
else
 echo "$a !=$b:a = b"
fi

if [ $a -lt 100 -a $b -gt 15 ]
then
 echo "$a 小于 100 且 $b 大于 15 : 返回 true"
else
 echo "$a 小于 100 且 $b 大于 15 : 返回 false"
fi

if [ $a -lt 100 -o $b -gt 100 ]
then
 echo "$a 小于 100 或 $b 大于 100 : 返回 true"
else
 echo "$a 小于 100 或 $b 大于 100 : 返回 false"
fi

if [ $a -lt 5 -o $b -gt 100 ]
then
 echo "$a 小于 5 或 $b 大于 100 : 返回 true"
else
 echo "$a 小于 5 或 $b 大于 100 : 返回 false"
fi


试验结果
# ./test.sh 
10 !=20:a != b
10 小于 100 且 20 大于 15 : 返回 true
10 小于 100 或 20 大于 100 : 返回 true
10 小于 5 或 20 大于 100 : 返回 false

16. shell中的注释

1. 单行注释使用“#”

2. 多行注释如下

$ cat test.sh 
#!/bin/sh

:<<EOF
echo "========= 1 ========="
echo "========= 2 ========="
echo "========= 3 ========="
EOF

echo "========= 4 ========="
$ ./test.sh
========= 4 =========

17. 在一个脚本中 source的子shell脚本中可以使用父shell脚本中定义的变量，父shell中./直接执行的子shell脚本中是不可以访问父shell脚本中定义的变量的。

18. Shell脚本中利用##* %%* 进行变量处理

假设我们定义了一个变量为：file=/dir1/dir2/dir3/my.file.txt 可以用${ }分别替换得到不同的值：

${file#*/}：删掉第一个/ 及其左边的字符串：dir1/dir2/dir3/my.file.txt
${file##*/}：删掉最后一个/ 及其左边的字符串：my.file.txt
${file#*.}：删掉第一个. 及其左边的字符串：file.txt
${file##*.}：删掉最后一个. 及其左边的字符串：txt
${file%/*}：删掉最后一个 / 及其右边的字符串：/dir1/dir2/dir3
${file%%/*}：删掉第一个/ 及其右边的字符串：(空值)
${file%.*}：删掉最后一个 . 及其右边的字符串：/dir1/dir2/dir3/my.file
${file%%.*}：删掉第一个 . 及其右边的字符串：/dir1/dir2/dir3/my

例子：

#!/bin/sh

val=/dir1/dir2/dir3/my.test.txt

echo ${val#*/}        # dir1/dir2/dir3/my.test.txt
echo ${val##*/}        # my.test.txt
echo ${val#*.}        # test.txt
echo ${val##*.}        # txt
echo ${val%/*}        # /dir1/dir2/dir3
echo ${val%%/*}        # 
echo ${val%.*}        # /dir1/dir2/dir3/my.test
echo ${val%%.*}        # /dir1/dir2/dir3/my

参考： https://www.jianshu.com/p/86111df650de

18. shell脚本中的全局变量与局部变量

(1) Shell脚本中定义的变量是global的，其作用域从被定义的地方开始，到shell结束或被显示删除的地方为止。
(2) Shell函数中定义的变量默认也是global的，其作用域从“函数被调用时执行变量定义的地方”开始，到shell结束或被显示删除处为止。若想在函数内部定义局部变量，使用local关键字修饰，此时其作用域局限于函数内。
(3) 如果同名，Shell函数定义的local变量会屏蔽脚本定义的global变量。

#!/bin/bash

test_func1()
{
   echo $v1
   v1=200
}
v1=100
test_func1
echo $v1
#---------------------

test_func2()
{
   v2=200
}
test_func2
echo $v2
#---------------------

test_func3()
{
   local v3=200
}
test_func3
echo $v3
#---------------------

test_func4()
{
   echo $v4
   local v4=200
   echo $v4
}
v4=100
test_func4
echo $v4


$ ./4local.sh 
100
200
200

100
200
100

19.使用数组

#!/bin/sh

#eas_small_big_toggle
test_case=(
ls
lsusb
)

echo > ./eas_test_pass.txt
echo > ./eas_test_fail.txt

function loop_running()
{
    for line in ${test_case[@]}  #使用数组
    do
        echo "start test case: $line"
        count=0
        pass_count=0
        fail_count=0

        while [ $count -lt $1 ]
        do
            $line > ./tmp.txt 2>& 1 #执行命令
            
            if [[ `cat ./tmp.txt | grep "passed" | tr -cd "[0-9]"`"" -eq "1" ]]
            then
                let ++pass_count
                cat ./tmp.txt >> ./eas_test_pass.txt
            else
                let ++fail_count
                cat ./tmp.txt >> ./eas_test_fail.txt
            fi

            let ++count
            sleep 0.2
        done
        #echo "\033[33m$line test passed: $pass_count, failed: $fail_count \033[0m"
        echo -e ""
    done

    return 0
}

loop_running $1

二、shell脚本工具

1. dump sysfs文件状态

#!/system/bin/sh

function read_dir(){
    path=$1
    for file in `ls $path`
    do
        path_name=$path"/"$file
        if [ -h $path_name ]; then # ignore link
            return
        fi

        if [ -d $path_name ]; then
            read_dir $path_name
        elif [ -r $path_name -a -f $path_name ]; then
            echo $path_name": "`cat $path_name`
        else
            echo "$path_name is none"
        fi
    done
}

sleep 5 # set according to scene

read_dir $1

三、shell循环控制语句

1. break 跳出整个循环

用法：break n

n 表示跳出循环的层数，如果省略 n，则表示跳出当前的循环。break 关键字通常和 if 语句一起使用，即满足条件时便跳出循环。

2. continue 跳出本次循环，继续下一次循环

用法：continue n

n 表示循环的层数，如果省略 n，则表示 continue 只对当前层次的循环语句有效，遇到 continue 会跳过本次循环，忽略本次循环的剩余代码，直接进入下一次循环。
如果带上 n，比如 n 的值为 2，那么 continue 对内层和外层循环语句都有效，不但内层会跳过本次循环，外层也会跳过本次循环，其效果相当于内层循环和外层循环同时执行了不带 n 的 continue。

3. return 表示函数返回值

用法：return n

注意 retrun 命令不能直接用在脚本的主程序里，主要用途是使得shell函数退出并返回数值，如果没有指定 n 的值，则默认为函数最后一条命令执行的返回状态。如果你指定的参数大于255或小于0，那么会通过加或减256的方式
使得返回值总是处于0到255之间。在函数外执行return语句会返回失败。$? 可以接收这个返回值。

#!/bin/bash

example() {
  return 259
}
example

echo $? # 显示3    （259-256=3）

4. exit 退出shell程序，并返回n值

exit 是一个 Shell 内置命令，用来退出当前 Shell 进程，并返回一个退出状态；使用$?可以接收这个退出状态。exit 命令可以接受一个整数值作为参数，代表退出状态。如果不指定，默认状态值是 0。一般情况下，退出状态为 0
表示成功，退出状态为非 0 表示执行失败（出错）了。exit 退出状态只能是一个介于 0~255 之间的整数，其中只有 0 表示成功，其它值都表示失败。
Shell 进程执行出错时，可以根据退出状态来判断具体出现了什么错误，比如打开一个文件时，我们可以指定 1 表示文件不存在，2 表示文件没有读取权限，3 表示文件类型不对。

return 与 exit 的区别：
exit用于在程序运行的过程中随时结束程序，exit的参数是返回给OS的。exit是结束一个进程，它将删除进程使用的内存空间，同时把错误信息返回父进程。而return是返回函数值并退出函数
return是语言级别的，它表示了调用堆栈的返回；而exit是系统调用级别的，它表示了一个进程的结束。
使用方法不用。return一般用在函数方法体内，exit可以出现在Shell脚本中的任意位置。

4. 实验

打印乘法表：

#!/bin/bash

for((i=1; i<=9; i++)); do
    for((j=1; j<=i; j++)); do
        if((j==5)); then
            : #什么都不做，以免报错
            #continue   #1.丢掉了5这一列
            #break      #2.丢掉5之后的所有列
            
            #printf "\n"
            #continue 2 #3.丢掉5之后的所有列
            #break 2    #丢掉5之后的所有行和列
        fi
        printf "%d*%d=%-4d" $j $i $((i*j))
    done
    printf "\n"
done


1*1=1   
1*2=2   2*2=4   
1*3=3   2*3=6   3*3=9   
1*4=4   2*4=8   3*4=12  4*4=16  
1*5=5   2*5=10  3*5=15  4*5=20  5*5=25  
1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36  
1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49  
1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64  
1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81

注：使用(())可以像使用C语言一样使用shell脚本。

参考：
https://blog.csdn.net/focus_lyh/article/details/112319193

优秀资料：
shell专栏：https://blog.csdn.net/focus_lyh/category_10666356.html

hellokitty2