zoukankan      html  css  js  c++  java

  • 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
    View Code

    执行 ./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
    View Code

    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
    View Code

    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
    View Code

    (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
    View Code

    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
    View Code

    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 " "

    反斜杠的另一种作用,就是当反斜杠用于一行的最后一个字符时，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/sfl/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
    View Code

    (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
    View Code

    (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
    View Code

    (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
    View Code

    (5) while语句

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

    # 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  #数据条数也是一直递增的
    View Code

    14.shell中的函数

    (1) shell中函数定义

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

    (2) 函数调用

    function_name parm1 parm2
    View Code

    (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 $?
    View Code
    #! /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
    View Code

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

    #! /bin/bash

length()
{
  echo "$@"
}

length aaaaaaa bbbbbb cccccc dddd mmmm ddd nnnn

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

    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
    View Code

    关系运算符使用:

    #!/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
    View Code
    j=1
j=`expr $j + 1`
echo $j ==>output:2
    View Code
    #! /bin/bash
#
read -p '请输入数：' a                  //输入
read -p '请输入数：' b
echo '$a+$b=' $(( a +  b ))            //输出
echo '$a-$b=' $(( a -  b ))
echo '$a*$b=' $(( a *  b ))
echo '$a/$b=' $(( a /  b ))
echo '$a%$b=' $(( a %  b ))
    View Code

    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
    View Code

    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 "33[33m$line test passed: $pass_count, failed: $fail_count 33[0m"
        echo -e ""
    done

    return 0
}

loop_running $1
    View Code

    二、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
    View Code

    相关资料：

    Linux C编程一站式学习： https://akaedu.github.io/book/ch33s03.html#id2884876
  • 相关阅读:
    离鞘剑（四）
    Node.js 蚕食计划（四）—— Express + SQL Server 搭建电影网站
    离鞘剑（三）
    python数据类型（第三弹）
    python数据类型（第二弹）
    python数据类型（第一弹）
    开发工具的安装与使用（总结篇）
    开发工具的安装与使用（第四弹）
    PriorityQueue和PriorityBlockingQueue
    一文弄懂java中的Queue家族
  • 原文地址：https://www.cnblogs.com/hellokitty2/p/8531784.html
Copyright © 2011-2022 走看看