linux bash脚本编程知识点

bash变量类型：
环境变量
本地变量(局部变量)
位置变量
特殊变量

本地变量：
set VARNAME=VALUE: 作用域为整个bash进程；
引用变量 $(varname)
局部变量：
local VARNAME=VALUE：作用域为当前代码段；

环境变量：作用域为当前shell进程及其子进程；
export VARNAM
E=VALUE
VARNAME=VALUE
export VARNAME
“导出”
脚本在执行时会启动一个子shell进程
命令行中启动的脚本会继承当前shell环境变量
系统自动执行的脚本（非命令行启动）就需要自我定义需要各环境变量

位置变量：
$1, $2, ...

$?: 保存上一个命令的执行状态返回值；

程序执行，可能有两类返回值：
程序执行结果
程序状态返回代码（0-255）
0: 正确执行
1-255：错误执行，1，2，127系统预留；

撤消变量：
unset VARNAME

查看当shell中变量：
set

查看当前shell中的环境变量：
printenv
env
export

脚本：命令的堆砌，按实际需要，结合命令流程控制机制实现的源程序

shebang: 魔数
#!/bin/bash
# 注释行，不执行

/dev/null: 软件设备， bit bucket，数据黑洞

脚本在执行时会启动一个子shell进程；
命令行中启动的脚本会继承当前shell环境变量；
；

练习：写一个脚本，完成以下任务
1、添加5个用户, user1,..., user5
2、每个用户的密码同用户名，而且要求，添加密码完成后不显示passwd命令的执行结果信息；
3、每个用户添加完成后，都要显示用户某某已经成功添加；
useradd user1
echo "user1" | passwd --stdin user1 &> /dev/null
echo "Add user1 successfully."

条件判断：
如果用户不存在
添加用户，给密码并显示添加成功；
否则
显示如果已经没在，没有添加；

bash中如何实现条件判断？
条件测试类型：
整数测试
字符测试
文件测试

条件测试的表达式：
[ expression ]
[[ expression ]]
test expression

整数比较:
-eq: 测试两个整数是否相等；比如 $A -eq $B
-ne: 测试两个整数是否不等；不等，为真；相等，为假；
-gt: 测试一个数是否大于另一个数；大于，为真；否则，为假；
-lt: 测试一个数是否小于另一个数；小于，为真；否则，为假；
-ge: 大于或等于
-le：小于或等于

命令的间逻辑关系：
逻辑与： &&
第一个条件为假时，第二条件不用再判断，最终结果已经有；
第一个条件为真时，第二条件必须得判断；
逻辑或： ||

如果用户user6不存在，就添加用户user6
! id user6 && useradd user6
id user6 || useradd user6

如果/etc/inittab文件的行数大于100，就显示好大的文件；
[ `wc -l /etc/inittab | cut -d' ' -f1` -gt 100 ] && echo "Large file."

变量名称：
1、只能包含字母、数字和下划线，并且不能数字开头；
2、不应该跟系统中已有的环境变量重名；
3、最好做到见名知义；

如果用户存在，就显示用户已存在；否则，就添加此用户；
id user1 && echo "user1 exists." || useradd user1

如果用户不存在，就添加；否则，显示其已经存在；
! id user1 && useradd user1 || echo "user1 exists."

如果用户不存在，添加并且给密码；否则，显示其已经存在；
! id user1 && useradd user1 && echo "user1" | passwd --stdin user1 || echo "user1 exists."

练习，写一个脚本，完成以下要求：
1、添加3个用户user1, user2, user3；但要先判断用户是否存在，不存在而后再添加；
2、添加完成后，显示一共添加了几个用户；当然，不能包括因为事先存在而没有添加的；
3、最后显示当前系统上共有多少个用户；

如果 UID为0；那么
显示为管理员
否则
显示为普通用户

NAME=user16
USERID=`id -u $NAME`
if [ $USERID -eq 0 ]; then
echo "Admin"
else
echo "common user."
fi//结束

NAME=user16
if [ `id -u $NAME` -eq 0 ]; then
echo "Admin"
else
echo "common user."
fi

练习：写一个脚本
判断当前系统上是否有用户的默认shell为bash；
如果有，就显示有多少个这类用户；否则，就显示没有这类用户；
#!/bin/bash
#
grep "\<bash$" /etc/passwd &> /dev/null
RETVAL=$?
if [ $RETVAL -eq 0 ]; then
grep "\<bash$" /etc/passwd | wc -l
else
echo "No such user."
fi

练习：写一个脚本
给定一个文件，比如/etc/inittab
判断这个文件中是否有空白行；
如果有，则显示其空白行数；否则，显示没有空白行。
#!/bin/bash
A=`grep '^$' /etc/inittab | wc -l`
if [ $A -gt 0 ]; then
echo "$A"
else
echo "meiyoukongbaihang"
fi

#!/bin/bash
FILE=/etc/inittab
if [ ! -e $FILE ]; then
echo "No $FILE."
exit 8
fi

if grep "^$" $FILE &> /dev/null; then
echo "Total blank lines: `grep "^$" $FILE | wc -l`."
else
echo "No blank line."
fi

练习：写一个脚本
给定一个用户，判断其UID与GID是否一样
如果一样，就显示此用户为“good guy”；否则，就显示此用户为“bad guy”。
#!/bin/bash
USERNAME=user1
USERID=`id -u $USERNAME`
GROUPID=`id -g $USERNAME`
if [ $USERID -eq $GROUPID ]; then
echo "Good guy."
else
echo "Bad guy."
fi

进一步要求：不使用id命令获得其id号；

#!/bin/bash
#
USERNAME=user1
if ! grep "^$USERNAME\>" /etc/passwd &> /dev/null; then
echo "No such user: $USERNAME."
exit 1
fi

USERID=`grep "^$USERNAME\>" /etc/passwd | cut -d: -f3`
GROUPID=`grep "^$USERNAME\>" /etc/passwd | cut -d: -f4`
if [ $USERID -eq $GROUPID ]; then
echo "Good guy."
else
echo "Bad guy."
fi

练习：写一个脚本
给定一个用户，获取其密码警告期限；
而后判断用户密码使用期限是否已经小于警告期限；
提示：计算方法，最长使用期限减去已经使用的天数即为剩余使用期限；

如果小于，则显示“Warning”；否则，就显示“OK”。

圆整：丢弃小数点后的所有内容

#!/bin/bash
W=`grep "student" /etc/shadow | cut -d: -f6`
S=`date +%s`
T=`expr $S/86400`
L=`grep "^student" /etc/shadow | cut -d: -f5`
N=`grep "^student" /etc/shadow | cut -d: -f3`
SY=$[$L-$[$T-$N]]

if [ $SY -lt $W ]; then
echo 'Warning'
else
echo 'OK'
fi

练习：写一个脚本
判定命令历史中历史命令的总条目是否大于1000；如果大于，则显示“Some command will gone.”；否则显示“OK”。

shell中如何进行算术运算：
A=3
B=6
1、let 算术运算表达式
let C=$A+$B
2、$[算术运算表达式]
C=$[$A+$B]
3、$((算术运算表达式))
C=$(($A+$B))
4、expr 算术运算表达式，表达式中各操作数及运算符之间要有空格，而且要使用命令引用
C=`expr $A + $B`

条件判断，控制结构：

单分支if语句
if 判断条件; then
statement1
statement2
...
fi

双分支的if语句：
if 判断条件; then
statement1
statement2
...
else
statement3
statement4
...
fi

多分支的if语句：
if 判断条件1; then
statement1
...
elif 判断条件2; then
statement2
...
elif 判断条件3; then
statement3
...
else
statement4
...
fi

测试方法：
[ expression ]
[[ expression ]]
test expression

bash中常用的条件测试有三种：
整数测试：
-eq: 测试两个整数是否相等；比如 $A -eq $B
-ne: 测试两个整数是否不等；不等，为真；相等，为假；
-gt: 测试一个数是否大于另一个数；大于，为真；否则，为假；
-lt: 测试一个数是否小于另一个数；小于，为真；否则，为假；
-ge: 大于或等于
-le：小于或等于

INT1=63
INT2=77
[ $INT1 -eq $INI2 ]
[[ $INT1 -eq $INT2 ]]
test $INT1 -eq $INT2

文件测试：
-e FILE：测试文件是否存在
-f FILE: 测试文件是否为普通文件
-d FILE: 测试指定路径是否为目录
-r FILE: 测试当前用户对指定文件是否有读取权限；
-w
-x

[ -e /etc/inittab ]
[ -x /etc/rc.d/rc.sysinit ]

练习：写一个脚本
给定一个文件：
如果是一个普通文件，就显示之；
如果是一个目录，亦显示之；
否则，此为无法识别之文件；

定义脚本退出状态码

exit: 退出脚本
exit #
如果脚本没有明确定义退出状态码，那么，最后执行的一条命令的退出码即为脚本的退出状态码；

测试脚本是否有语法错误：
bash -n 脚本

bash -x 脚本：单步执行

bash变量的类型：
本地变量：
set VARNAME=VALUE: 作用域为整个bash进程；
引用变量 $(varname)
局部变量：
local VARNAME=VALUE：作用域为当前代码段；

环境变量：作用域为当前shell进程及其子进程；
export VARNAME=VALUE
VARNAME=VALUE
export VARNAME
“导出”
脚本在执行时会启动一个子shell进程
命令行中启动的脚本会继承当前shell环境变量
系统自动执行的脚本（非命令行启动）就需要自我定义需要各环境变量
位置变量:
$1, $2, ...
shift
特殊变量：
$?
$#：参数的个数
$*: 参数列表
$@：参数列表

./filetest.sh /etc/fstab /etc/inittab
$1: /etc/fstab
$2: /etc/inittab

练习：写一脚本
能接受一个参数(文件路径)
判定：此参数如果是一个存在的文件，就显示“OK.”；否则就显示"No such file."

练习：写一个脚本
给脚本传递两个参数(整数)；
显示此两者之和，之乘积；
#!/bin/bash
#
if [ $# -lt 2 ]; then
echo "Usage: cacl.sh ARG1 ARG2"
exit 8
fi

echo "The sum is: $[$1+$2]."
echo "The prod is: $[$1*$2]."

练习：写一个脚本，完成以下任务
1、使用一个变量保存一个用户名；
2、删除此变量中的用户，且一并删除其家目录；
3、显示“用户删除完成”类的信息

bash:

引用变量：${VARNAME}, 括号有时可省略。

整型，8bit: 256
0-255，溢出

变量：
1，10000
10：16bit
10: 1010, 8bit

编程能力：
脚本编程

#abc
# hello world
# hi world

练习：
传递一个用户名参数给脚本，判断此用户的用户名跟其基本组的组名是否一致，并将结果显示出来。

字符测试：
==：测试是否相等，相等为真，不等为假
!=: 测试是否不等，不等为真，等为假
>
<
-n string: 测试指定字符串是否为空，空则真，不空则假
-z string: 测试指定字符串是否不空，不空为真，空则为假

练习：写一个脚本
传递一个参数(单字符就行)给脚本，如参数为q，就退出脚本；否则，就显示用户的参数；

练习：写一个脚本
传递一个参数(单字符就行)给脚本，如参数为q、Q、quit或Quit，就退出脚本；否则，就显示用户的参数；
#!/bin/bash
#
if [ $1 = 'q' ];then
echo "Quiting..."
exit 1
elif [ $1 = 'Q' ];then
echo "Quiting..."
exit 2
elif [ $1 = 'quit' ];then
echo "Quiting..."
exit 3
elif [ $1 = 'Quit' ];then
echo "Quiting..."
exit 4
else
echo $1
fi

练习：
if [ $# -lt 2 ];
传递三个参数给脚本，第一个为整数，第二个为算术运算符，第三个为整数，将计算结果显示出来，要求保留两位精度。形如：
./calc.sh 5 / 2

#!/bin/bash
#
A=$1
x=$2
B=$3
result= echo "scale=2;$A$x$B;"|bc
echo $result

etco "scale=2;111/22" | bc //结果为5.04

练习：
传递3个参数给脚本，参数均为用户名。将此些用户的帐号信息提取出来后放置于/tmp/testusers.txt文件中，并要求每一行行首有行号。
egrep “$1|$2|$3” /etc/passwd >>/tmp/a
cat ?n /tmp/a > /tmp/test0
rm ?rf a

写一个脚本：
判断当前主机的CPU生产商，其信息在/proc/cpuinfo文件中vendor id一行中。
如果其生产商为AuthenticAMD，就显示其为AMD公司；
如果其生产商为GenuineIntel，就显示其为Intel公司；
否则，就说其为非主流公司；
#!/bin/bash
VENDOR_ID=`grep vendor_id /proc/cpuinfo | head -1 | cut -d' ' -f2`
if [ $VENDOR_ID == "AuthenticAMD" ]; then
echo "AMD company"
elif [ $VENDOR_ID == "GenuineIntel" ]; then
echo "Intel company"
fi

写一个脚本：
给脚本传递三个整数，判断其中的最大数和最小数，并显示出来。
MAX=0
MAX -eq $1
MAX=$1
MAX -lt $2
MAX=$2
例：比较三个数的大小

echo -n "Enter three number:"
read a b c
if [ $a -gt $b ];then
t=$a;a=$b;b=$t;
fi
if [ $a -gt $c ];then
t=$a;a=$c;c=$t;
fi
if [ $b -gt $c ];then
t=$b;b=$c;c=$t;
fi
echo "From small to big:$a,$b,$c"

例：求1到100的和
#!/bin/bash
declare -i SUM=0
for I in {1..100};do
SUM=$[$SUM+$I]
done
echo “The SUM is :$SUM。”

循环：进入条件，退出条件
for
while
until

for 变量 in 列表; do
循环体
done

for I in 1 2 3 4 5 6 7 8 9 10; do
加法运算
done

遍历完成之后，退出；

如何生成列表：
{1..100}
`seq [起始数 [步进长度]] 结束数`

1,...,100

declare -i SUM=0
integer
-x//环境变量

写一个脚本：
1、设定变量FILE的值为/etc/passwd
2、依次向/etc/passwd中的每个用户问好，并显示对方的shell，形如：
Hello, root, your shell: /bin/bash
#!/bin/bash
for I in `cat /etc/passwd |grep 'bash'`;do
echo"hello `echo $I |cut -d: -f1` your bash"
done
3、统计一共有多少个用户

for I in `seq 1 $LINES`; do echo "Hello, `head -n $I /etc/passwd | tail -1 | cut -d: -f1`"; done

只向默认shell为bash的用户问声好

写一个脚本：
1、添加10个用户user1到user10，密码同用户名；但要求只有用户不存在的情况下才能添加；
#!/bin/bash
if [ $1 == add];then
for I in{1..10};do
! id user$I &&useradd user$I -puser$I
done
elif [ $1 == del];then
for I in {1..10};do
id user$I >/dev/null &&userdel user$I
done
else
echo "paramiter wrong"
fi
扩展：
接受一个参数：
add: 添加用户user1..user10
del: 删除用户user1..user10
其它：退出
adminusers user1,user2,user3,hello,hi

写一个脚本：
计算100以内所有能被3整除的正整数的和；
取模，取余:%
3%2=1
100%55=45

写一个脚本：
let I=$[$I+1]
SUM=$[$SUM+$I]

let SUM+=$I

let I+=1 相当于 let I++

-=
let I-=1 相当于 let I--

++I, --I

*=
/=
%=

测试：
整数测试：
-eq: 测试两个整数是否相等；比如 $A -eq $B
-ne: 测试两个整数是否不等；不等，为真；相等，为假；
-gt: 测试一个数是否大于另一个数；大于，为真；否则，为假；
-lt: 测试一个数是否小于另一个数；小于，为真；否则，为假；
-ge: 大于或等于
-le：小于或等于
字符测试：
==：测试是否相等，相等为真，不等为假
!=: 测试是否不等，不等为真，等为假
>
<
-n string: 测试指定字符串是否为空，空则真，不空则假
-z string: 测试指定字符串是否不空，不空为真，空则为假

if [ $# -gt 1 ]; then

组合测试条件
-a: 与关系
-o: 或关系
!：非关系

if [ $# -gt 1 -a $# -le 3 ]
if [ $# -gt 1 ] && [ $# -le 3 ]

生成随机数
RANDOM: 0-32768

随机数生成器：熵池
/dev/random:
/dev/urandom:

写一个脚本，利用RANDOM生成10个随机数，并找出其中的最大值，和最小值；
#!/bin/bash
#
declare -i MAX=0
declare -i MIN=0

for I in {1..10}; do
MYRAND=$RANDOM
[ $I -eq 1 ] && MIN=$MYRAND
if [ $I -le 9 ]; then
echo -n "$MYRAND,"
else
echo "$MYRAND"
fi
[ $MYRAND -gt $MAX ] && MAX=$MYRAND
[ $MYRAND -lt $MIN ] && MIN=$MYRAND
done

echo $MAX, $MIN

面向过程
控制结构
顺序结构
选择结构
循环结构

选择结构：
if: 单分支、双分支、多分支
if CONDITION; then
statement
...
fi

if CONDITION; then
statement
...
else
statement
...
fi

if CONDITION1; then
statement
...
elif CONDITION2; then
statement
...
esle
statement
...
fi

case语句：选择结构

case SWITCH in
value1)
statement
...
;;
value2)
statement
...
;;
*)
statement
...
;;
esac

a-z
A-Z
0-9
[abc]

只接受参数start,stop,restart,status其中之一
#!/bin/bash
#
DEBUG=0
ADD=0
DEL=0

for I in `seq 0 $#`; do
if [ $# -gt 0 ]; then
case $1 in
-v|--verbose)
DEBUG=1
shift ;;
-h|--help)
echo "Usage: `basename $0` --add USER_LIST --del USER_LIST -v|--verbose -h|--help"
exit 0
;;
--add)
ADD=1
ADDUSERS=$2
shift 2
;;
--del)
DEL=1
DELUSERS=$2
shift 2
;;
*)
echo "Usage: `basename $0` --add USER_LIST --del USER_LIST -v|--verbose -h|--help"
exit 7
;;
esac
fi
done

if [ $ADD -eq 1 ]; then
for USER in `echo $ADDUSERS | sed 's@,@ @g'`; do
if id $USER &> /dev/null; then
[ $DEBUG -eq 1 ] && echo "$USER exists."
else
useradd $USER
[ $DEBUG -eq 1 ] && echo "Add user $USER finished."
fi
done
fi

if [ $DEL -eq 1 ]; then
for USER in `echo $DELUSERS | sed 's@,@ @g'`; do
if id $USER &> /dev/null; then
userdel -r $USER
[ $DEBUG -eq 1 ] && echo "Delete $USER finished."
else
[ $DEBUG -eq 1 ] && echo "$USER not exist."
fi
done
fi

练习：写一个脚本showlogged.sh，其用法格式为：
showlogged.sh -v -c -h|--help
其中，-h选项只能单独使用，用于显示帮助信息；-c选项时，显示当前系统上登录的所有用户数；如果同时使用了-v选项，则既显示同时登录的用户数，又显示登录的用户的相关信息；如
Logged users: 4.

They are:
root tty2 Feb 18 02:41
root pts/1 Mar 8 08:36 (172.16.100.177)
root pts/5 Mar 8 07:56 (172.16.100.177)
hadoop pts/6 Mar 8 09:16 (172.16.100.177)

#!/bin/bash
#
declare -i SHOWNUM=0
declare -i SHOWUSERS=0

if [ $SHOWNUM -eq 1 ]; then
echo "Logged users: `who | wc -l`."
if [ $SHOWUSERS -eq 1 ]; then
echo "They are:"
who
fi
fi

脚本编程：
顺序结构
选择结构
if
case
循环结构
for
while
until

while循环：适用于循环次数未知的场景，要有退出条件
语法：
while CONDITION; do
statement
...
done

计算100以内所有正整数的和

#!/bin/bash
declare -i I=1
declare -i SUM=0

while [ $I -le 100 ]; do
let SUM+=$I
let I++
done

echo $SUM

练习：转换用户输入的字符为大写，除了quit:
#!/bin/bash
#
read -p "Input something: " STRING

while [ $STRING != 'quit' ]; do
echo $STRING | tr 'a-z' 'A-Z'
read -p "Input something: " STRING
done

练习：每隔5秒查看hadoop用户是否登录，如果登录，显示其登录并退出；否则，显示当前时间，并说明hadoop尚未登录：
#!/bin/bash
#
who | grep "hadoop" &> /dev/null
RETVAL=$?

while [ $RETVAL -ne 0 ]; do
echo "`date`, hadoop is not log."
sleep 5
who | grep "hadoop" &> /dev/null
RETVAL=$?
done

echo "hadoop is logged in."

read -p "Again, your choice: " CHOICE
done

脚本编程控制结构：
顺序
选择
if
case
循环
for
while
until

while CONDITION; do
statment
done

进入循环：条件满足
退出循环：条件不满足

until CONDITION; do
statement
...
done

进入循环：条件不满足
退出循环：条件满足

for 变量 in 列表; do
循环体
done

for (( expr1 ; expr2 ; expr3 )); do
循环体
done

写一个脚本：
1、通过ping命令测试192.168.0.151到192.168.0.254之间的所有主机是否在线，
如果在线，就显示"ip is up."，其中的IP要换为真正的IP地址，且以绿色显示；
如果不在线，就显示"ip is down."，其中的IP要换为真正的IP地址，且以红色显示；

要求：分别使用while，until和for(两种形式)循环实现。

函数：功能, function

代码重用：

库：so

脚本编程之函数：

function: 功能

结构化编程，不能独立运行，需要调用时执行，可以被多次调用

定义一个函数：
function FUNCNAME {
command
}

FUNCNAME() {
command
}

自定义执行状态返回值：
return #
0-255

接受参数的函数：
./a.sh m n
$1: m
$2: n

sum()
{
echo $1+$2
TWOINT 5 6

$1: 5
$2: 6

练习：写一个脚本，判定192.168.0.200-192.168.0.254之间的主机哪些在线。要求：
1、使用函数来实现一台主机的判定过程；
2、在主程序中来调用此函数判定指定范围内的所有主机的在线情况。

#!/bin/bash
#
PING() {
for I in {200..254};do
if ping -c 1 -W 1 192.168.0.$I &> /dev/null; then
echo "192.168.0.$I is up."
else
echo "192.168.0.$I is down."
fi
done
}

PING

#!/bin/bash
#
PING() {
if ping -c 1 -W 1 $1 &> /dev/null; then
echo "$1 is up."
else
echo "$1 is down."
fi
}

for I in {200..254}; do
PING 192.168.0.$I
done

#!/bin/bash
#
PING() {
if ping -c 1 -W 1 $1 &> /dev/null; then
return 0
else
return 1
fi
}

for I in {200..254}; do
PING 192.168.0.$I
if [ $? -eq 0 ]; then
echo "192.168.0.$I is up."
else
echo "192.168.0.$I is down."
fi
done

写一个脚本：使用函数完成
1、函数能够接受一个参数，参数为用户名；
判断一个用户是否存在
如果存在，就返回此用户的shell和UID；并返回正常状态值；
如果不存在，就说此用户不存在；并返回错误状态值；
2、在主程序中调用函数；

扩展1：在主程序中，让用户自己输入用户名后，传递给函数来进行判断；
扩展2：在主程序中，输入用户名判断后不退出脚本，而是提示用户继续输入下一个用户名；如果用户输入的用户不存在，请用户重新输入；但如果用户输入的是q或Q就退出；

#!/bin/bash
#
user () {
if id $1 &> /dev/null ;then
echo "`grep ^$1 /etc/passwd | cut -d: -f3,7`"
return 0
else
echo "no $1"
return 1
fi
}
read -p "please input username:" username
until [ $username == q -o $username == Q ]; do
user $username
if [ $? == 0 ];then
read -p "please input again:" username
else
read -p "no $username,please input again:" username
fi
done

函数也可以接受参数, 即可以向函数传递参数

函数接受一个用户名参数，显示此用户的shell和UID；

写一个函数：接受一命令参数ls

/bin/ls, /mnt/sysroot/bin/ls

/sbin/ifconfig, /mnt/sysroot/sbin/ifconfig

脚本编程知识点：
1、变量中字符的长度：${#VARNAME}
2、变量赋值等：
${parameter:-word}：如果parameter为空或未定义，则变量展开为“word”；否则，展开为parameter的值；
${parameter:+word}：如果parameter为空或未定义，不做任何操作；否则，则展开为“word”值；
${parameter:=word}：如果parameter为空或未定义，则变量展开为“word”，并将展开后的值赋值给parameter；
${parameter:offset}
${parameter:offset:length}：取子串，从offset处的后一个字符开始，取lenth长的子串；

3、脚本配置文件
/etc/rc.d/init.d/服务脚本
服务脚本支持配置文件：/etc/sysconfig/服务脚本同名的配置文件
.conf为配置文件。
#!/bin/bash
#
./root/a.conf //把a.conf这个文件加载进来
4、局部变量
local VAR_NAME=//必须用local

a=1

test() {
a=$[3+4]
}

test
for I in `seq $a 10`; do
echo $I
done

5、命令mktemp
创建临时文件或目录

mktemp /tmp/file.XX
-d: 创建为临时目录

6、信号
kill -SIG（NAL） PID
1: HUP
2: INT//终止
9: KILL
15: TERM

脚本中，能实现信号捕捉，但9和15无法捕捉

Ctrl+c: SIGINT

trap命令：
trap 'COMMAND' 信号列表

7、一行执行多个语句，语句间用分号分隔

linux bash脚本编程知识点相关推荐

Linux shell脚本编程(三)
Linux shell脚本编程 -------------------------------------------------------------------- 注:如果你对python感兴趣 ...
Linux shell脚本编程(二)
Linux shell脚本编程(二) -------------------------------------------------------------------- 注:如果你对python ...
Linux shell脚本编程(一)
-------------------------------------------------------------------- 注:如果你对python感兴趣,我这有个学习Python基地, ...
高级Bash脚本编程指南《Advanced Bash-Scripting Guide》 in Chinese
<Advanced Bash-Scripting Guide> in Chinese <高级Bash脚本编程指南>Revision 10中文版在线阅读链接:http://ww ...
bash脚本编程入门_Bash编程入门
bash脚本编程入门对Unix的最初希望之一是,它将使日常的计算机用户能够微调其计算机以适应其独特的工作风格. 在过去的几十年中,对计算机定制的期望已经降低,许多用户将他们收集的应用程序和网站视为他 ...
Linux Shell脚本编程基础
2 Linux Shell脚本编程基础发表于: Linux, Shell, UNIX, 资源分享 | 作者: 谋万世全局者标签: Linux,Shell,编程基础,脚本本文作者:Leal 授权许 ...
Linux shell 脚本编程-实战篇（三）
继: Linux shell 脚本编程-实战篇(二) 3. 一些小有意思的脚本 3.1 发送消息 3.1.1 功能分析对于这种简单的脚本,需要的功能不多.涉及的一些命令很常见,下面了解脚本所需的几个 ...
Linux shell 脚本编程-实战篇（二）
继: Linux shell 脚本编程-实战篇(一) 2. 创建与数据库.Web及电子邮件相关的脚本 2.1 MySQL 数据库 2.1.1 MySQL 数据库安装到 http://repo.mys ...
linux shell 脚本编程基本语法
linux shell脚本编程基本语法 Shell script是利用shell的功能所写的一个"程序",这个程序是使用纯文本文件,将一些Linux Shell的语法与命令(含外部 ...

linux bash脚本编程知识点

linux bash脚本编程知识点相关推荐

最新文章

热门文章