Linux 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/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

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

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

j=1 
j=`expr $j + 1` 
echo $j ==>output:2

#! /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 ))

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