shell变量与运算

@(0003 shell编程)

变量存在于内存中。假设变量str，设置或修改变量属性时，不带$号，只有引用变量的值时才使用$号。也就是说在内存中，标记变量的变量名称是str，而不是$str。

变量数据的存储方式本身是有类型之分的，分为数据（整数、浮点型）和字符，在java等一些语言中，需要提前声明变量是哪种类型。但是，在bash中变量比较宽松，不需要这么做。

即，变量可以这么分为：

• 强类型：变量不经过强制转换，它永远是这个数据类型，不允许隐式的类型转换。一般定义变量时必须指定类型、参与运算必须符合类型要求；调用未声明变量会产生错误。如java，c#
• 弱类型：语言的运行时会隐式做数据类型转换。无须指定类型，默认均为字符型；参与运算会自动进行隐式类型转换；变量无须事先定义可直接调用。
  
  如：bash 不支持浮点数，php

变量命名法则：

1、不能使程序中的保留字：例如if, for

2、只能使用数字、字母及下划线，且不能以数字开头

3、见名知义

4、统一命名规则：驼峰命名法

驼峰命名法：将变量名首字母大写，可以全部单词的首字母大写，也可以部分单词的首字母大写，方便识别。如：StudentName。

一、变量类型

1.1 局部变量

生效范围为当前shell进程；对当前shell之外的其它shell进程，包括当前shell的子shell进程均无效。

查看进程编号：

echo $$     # 当前进程的进程编号

echo $PPID  #父进程的进程编号

也可以通过

pstree -p  # 查看父子进程树

如：NAME=songtai，这个变量只对当前的shell有用，子shell或父shell无法使用。退出当前shell用exit命令

1、变量赋值：name=‘value’ 。

注意：注意等号左右没有空格。如果有空格就是进行比较运算符的比较运算了。要想保留空格作为一个整体字符串，用“”括起来。如：STR=“test space”。

注意：变量赋值也可以直接应用变量或命令：

1.直接引用字符串：name=“root"

2.变量：name="$USER"

3.命令：name=`COMMAND` 或 name=$(COMMAND)

2、变量引用：：${name} 或$name

如：

[root@CentOS6 ~]#NAME="hello world"    

[root@CentOS6 ~]#echo "we will say $NAME"

we will say hello world

3、释放变量：unset name ，注意变量名前不加前缀$。

一般赋值完一个变量后，如果后边不在使用该变量的话，直接释放该变量。

4、查看所有的变量：不接任何参数的set或者declare命令，输出结果中包含了普通变量和环境变量。

5、临时将普通变量升级为环境（全局）变量： export name 或者赋值时 export name="value" ，这样$name就可以在当前shell和子shell中使用，但是退出脚本或者重新登录shell都会取消export效果。

6、定义只读变量： readonly name 。这时将无法修改变量值也无法unset变量，只有重新登录shell才能继续使用只读变量。

1.2环境变量（全局变量）

生效范围为当前shell进程及其子进程。常用大写字母

env export printenv可以查看当前用户的环境变量。

常见的环境变量：HOSTNAME、SHELL、HISTSIZE、USER、PATH、PWD、LANG、HOME、LOGNAME。

变量声明、赋值：

export  name=VALUE

declare  -x  name=VALUE

注意：局部变量通过export升级为全局变量，并且对子shell产生影响，但是对父shell不产生影响，父shell仍是原来的赋值。

set查看全部变量，包括局部变量、全局变量。

1.3只读变量

只能声明，但不能修改和删除

声明只读变量：

• readonly name
• declare -r name

查看只读变量：

• readonly –p

1.4 补充：（）、{ }的用处

（ list ）：一次性执行执行(相当于开了个子进程bash，执行后又回到父进程

[root@CentOS7 ~]#( umask 666;touch /data/f1 )   #相当于开了一个子shell，umask改为666后创建了一个文件f1，然后再返回到父shell

[root@CentOS7 ~]#ll -d /data/f1

----------. 1 root root 0 Nov 29 14:49 /data/f1

[root@CentOS7 ~]#( name=songtai;echo $name )

songtai

{ list }：大括号直接作用于当前shell

[root@CentOS7 ~]#name=songtai

[root@CentOS7 ~]#(  name=sun;echo $name  )

sun

[root@CentOS7 ~]#echo $name

songtai

[root@CentOS7 ~]#{  name=sst;echo $name;  }    # 注意后边跟；号

sst

[root@CentOS7 ~]#x=1;echo $$;( echo $$;echo $x;x=2;echo $x );echo $x

13196

13196    # 注意;两个子进程号相同，说明（）开的子进程与重新开个子shell还是有不同

1

2

1

1.5位置变量和特殊变量

位置变量：在脚本代码中调用通过命令行传递给脚本的参数

$?：上一条代码执行的回传指令，回传0表示标准输出，即正确执行，否则为标准错误输出。

对于脚本中的回传指令是0还是其他，看脚本的最后一条命令，如果有标准输出就是0.否则是其他数值；注意语法错误与命令错误的区分。

exit [n]：自定义退出状态码

$$：当前shell的PID。除了执行bash命令和shell脚本时，$$不会继承父shell的值，其他类型的子shell都继承。

$BASHPID：当前shell的PID，这和"$$"是不同的，因为每个shell的$BASHPID是独立的。而"$$"有时候会继承父shell的值。

$!：最近一次执行的后台进程PID。

$#：统计参数的个数。

$@：所有单个参数，如"a""b""c""d"。

$*：所有参数的整体，如“abcd”。

$0：脚本名。 注意：对软链接，$0 显示的是软链接的名称

$1……$n：参数位置。

示例：

vim  /bin/args.sh     # 编写脚本 /bin/args.sh

#!/bin/bash

echo "1st arg is $1"

echo "2st arg is $2"

echo "3st arg is $3"

echo "4st arg is $4"

echo "all args is  $*"

echo "all args is $@"

echo "the args number is $#"

echo "the script is `basename $0`"

[root@CentOS7 ~]#args.sh   aaa nne  ewd  q

1st arg is aaa

2st arg is nne

3st arg is ewd

4st arg is q

all args is  aaa nne ewd q

all args is aaa nne ewd q

the args numbers is 4

the script is args.sh

练习：写一脚本，通过命令传递两个文本文件路径给脚本，计算其空白行数之和；

#!/bin/bash

file1_lines=$(grep ^[[:space:]]$  $1 |wc -l)

file2_lines=$(grep ^[[:space:]]$  $2 |wc -l)

echo "the total blank lines: $[$file1_lines+$file2_lines]"

shfit 换位置，默认换一个。

示例：

vim args.sh     # 编辑脚本

#!/bin/bash

echo "1st arg is $1"

echo "2st arg is $2"

echo "3st arg is $3"

echo "4st arg is $4"

echo "all args is  $*"

echo "all args is $@"

echo "the args numbers is $#"

echo "the script is $0"

shift

echo "1st arg is $1"

echo "2st arg is $2"

echo "3st arg is $3"

echo "4st arg is $4"

echo "all args is  $*"

echo "all args is $@"

echo "the args numbers is $#"

echo "the script is $0"

shift

echo "1st arg is $1"

echo "2st arg is $2"

echo "3st arg is $3"

echo "4st arg is $4"

echo "all args is  $*"

echo "all args is $@"

echo "the args numbers is $#"

echo "the script is $0"

shift                                      # 保存退出脚本

[root@CentOS7 bin]#args.sh  a b c d       # 执行脚本args.sh  a b c d

1st arg is a

2st arg is b

3st arg is c

4st arg is d

all args is  a b c d

all args is a b c d

the args numbers is 4          # 4个参数

the script is /root/bin/args.sh

1st arg is b

2st arg is c

3st arg is d

4st arg is

all args is  b c d

all args is b c d

the args numbers is 3         # 第一个参数去掉，后3个参数依次向前

the script is /root/bin/args.sh

1st arg is c

2st arg is d

3st arg is

4st arg is

all args is  c d

all args is c d

the args numbers is 2        # 依上一步的参数，第一个仍然去掉，后2个依次向前

the script is /root/bin/args.sh

注意：当参数达到10以上时，用 ${10} 表示第10个参数 ，否则系统会将10都城

字符1和0的组合。

实验：编写脚本/root/bin/sumid.sh，计算/etc/passwd文件中的第10个用户和第20用户的ID之和。

#!/bin/bash

UID1="`head -n$1 /etc/passwd | cut -d: -f3 |tail -n1`"

UID2="`head -n$2 /etc/passwd | cut -d: -f3 |tail -n1`"

sumid=$[$UID1+$UID2]

echo $sumid

此脚本有个问题，直接执行sumid.sh不跟参数的话会报错。改良如下：

#!/bin/bash

[ $# -ne 2 ] && echo "Args num must be 2" && exit   # 参数数量为2个，则接着运行后边的命令；参数数量不为2，则运行“Args num must be 2”，然后退出！

UID1="`head -n$1 /etc/passwd | cut -d: -f3 |tail -n1`"

UID2="`head -n$2 /etc/passwd | cut -d: -f3 |tail -n1`"

sumid=$[$UID1+$UID2]

echo $sumid

继续改良：

#!/bin/bash

[ $# -ne 2 ] && echo "Args num must be 2" && exit

[[ ! "$1" =~ ^[0-9]+$ ]] && echo "$1 is not digital" && exit

[[ ! "$2" =~ ^[0-9]+$ ]] && echo "$2 is not digital" && exit

UID1="`head -n$1 /etc/passwd | cut -d: -f3 |tail -n1`"

UID2="`head -n$2 /etc/passwd | cut -d: -f3 |tail -n1`"

sumid=$[$UID1+$UID2]

echo $sumid

1.6 条件选择if语句

• 顺序执行：逐条运行；
• 选择执行：
  • 代码有一个分支：条件满足时才会执行；
  • 两个或以上的分支：只会执行其中一个满足条件的分支；
• 循环执行：
  
  代码片断（循环体）要执行0、1或多个来回；

选择执行：

# 单分支的if语句：

if  测试条件；then

	条件为真时分支代码

fi

# 双分支的if语句：

if 判断条件; then

	条件为真的分支代码

else

	条件为假的分支代码

fi

示例：通过参数传递一个用户名给脚本，此用户不存时，则添加之；

#!/bin/bash

if [ $# -lt 1 ] ;then

	ehco "at lease one username"

fi

if id $1 &>/dev/dull ;then

	echo "user $1 exits"

else

	useradd $1

	echo $1 | passwd  --stdin $1  &>/dev/dell

	echo "user $1 was finished"

fi

二、运算

2.1算术预算

bash中的算术运算:help、let

+, -,*, /, %取模（取余）, **（乘方）

实现算术运算：

(1) let var=算术表达式

x=10

y=20

let z=x+y  或  let z=\$x+\$y

echo  $z

30

let x++

echo $x

11

let ++x

echo $x

12

(2) var=$[算术表达式]

n=8

m=5

sum=$[n+m]   或   sum=$[$n+$m]

echo $sum

13

(3) var=$((算术表达式))

(4) var=$(expr arg1 arg2 arg3 ...)

注意：

expr 1 + 2 字符之间有空格

expr 1 * 2 *需要转义符\

(5) declare –i var = 数值

declare -i x=10

declare -i y=20

echo -i z=x+y

echo $z

30

(6) echo ‘算术表达式’ | bc

注意：乘法符号有些场景中需要转义

(7)bash有内建的随机数生成器：$RANDOM（0-32767）

echo $[$RANDOM%50] ：0-49之间随机数

示例：

COLOR=$[RANDOM%7+31]  或  COLOR=$((RANDOM%7+31))

echo $COLOR  一直是一个数值，除非再执行一次上一条命令，就会换一个数值？？？？

echo -e "\e[1;${COLOR}mcolor\e[0m"

COLOR="$[RANDOM%7+31]";echo -e "\e[1;${COLOR}mcolor\e[0m" color随机变色

(8) 赋值

增强型赋值：+=, -=, *=, /=, %=

例如：

let x+=2 表示为x+2后自赋值

自增，自减：

let var+=1

let var++ x+1后自赋值

let var-=1

let var--

2.2 逻辑运算

1.真假表示

true ： 1

false ：0

非：！

！0=1

！1=0

2.&、| 运算

&： and，与运算；有一个假就全假，全是真才为真

0 & 0 = 0

0 & 1 = 0

1 & 0 = 0

1 & 1 = 1

| ： or，或运算；全是假才是假，有一个真就是真

0 | 0 = 0

0 | 1 = 1

1 | 0 = 1

1 | 1 = 1

3.&& 短路与；|| 短路或

&& 短路与

0 && 0 = 0

0 && 1 = 0

1 && 0 = 0

1 && 1 = 1

cmd1 && cmd2 ：

• cmd1若为假，那么cmd2就不需要执行，因为最终结果都为假
• cmd1若为真，那么cmd2需要执行，才能判断最终结果。

|| 短路或

0 || 0 = 0

0 || 1 = 1

1 || 0 = 1

1 || 1 = 1

cmd1 || cmd2 ：

• cmd1若为假，那么cmd2需要执行，才能判断最终结果。
• cmd1若为真，那么cmd2不需要执行，因为最终结果都为真。

cmd1 && cmd2 || cmd3

cmd1为假，那么cmd1&&cmd2 的结果必为假，所以需要执行cmd3，才能判断最终结果。

cmd1为真，那么要执行cmd2，才能判断cmd1 && cmd2的结果，若cmd2为真，不执行cmd3，若cmd2为假，执行cmd3.

x=haha;y=xixi;[ $x = $y ] && echo equal || echo qual

cmd1 || { cmd2 ; cmd3; } cmd1为假时，运行cmd2和cmd3

^ XOR，抑或：

1 ^ 0 = 1

1 ^ 1 = 0

0 ^ 1 = 1

0 ^ 0 = 0

^异或的两个值,相同为假，不同为真

^ 的应用示例：两个数互换

a=4     # 4二进制表示为 100

b=6    #  6二进制表示为 110

let c=a^b

echo  $c

1

a、b的值互换示例：

a=4

b=6

a=$[a^b];b=$[a^b];a=[a^b];echo $a $b    # 第一个分号左侧a为a^b的值；第二个分号左侧b为第一个a的值与b抑或为4（a）；第三个分号的[]中，a为a^b的值，b为4，所以左侧的a为6（b）。

6 4

2.3 test

• test EXPRESSION
• [ EXPRESSION ]
• [[ EXPRESSION ]]
  
  注意：EXPRESSION前后必须有空白字符

(1)比较字符串

option:

-z STRING True if string is empty.空为真，不空为假

-n STRING True if string is not empty.

STRING1 == STRING2 True if the strings are equal.

STRING1 != STRING2 True if the strings are not equal. 不等于

STRING1 < STRING2 True if STRING1 sorts before STRING2 lexicographically. ascii码是否小于ascii码

STRING1 > STRING2 True if STRING1 sorts after STRING2 lexicographically.

STRING1 =~ STRING2 左侧字符串是否能够被右侧的PATTERN所匹配，PATTERN可使用扩展正则表达式

注意: 字符串比较尽量用于[[ ]]中；扩展的正则表达式；字符串尽量加引号引用

str1=aaa

str2=bbb

test $str1  $str2

echo $?

1

注意：

test $str1  $str2

[ $str1 = str2 ]

[[ str1 = str2 ]]    #这个三个表达式的效果相同，注意第二个与第三个里面的空格！

实验：判断一个字符串是否为空的字符串：

[ -z string ]

[ x"$string" =  "x" ]

[ $string =   ]

(2)比较数字

-eq equal，相等

-ne not equal，不想等

-lt less than，小于

-le less equal，小于等于

-gt graeter than 大于

-ge greater equal 大于等于

实验：写脚本，磁盘利用率大于80报警；

#!/bin/bash

DF_USER="`df | grep  "dev/sd" | tr -s " " % | cut -d% -f5 |sort -nr | head -n1`"

[ "$DF_USER" -ge 80 ] && echo warmming!!   # 注意：[] 内的变量要用“”引起来！！

(3) 文件比较

存在性测试：

-a FILE : True if file exists.

-e FILE : True if file exists.

是否存在及类型测试：

-b FILE : True if file is block special.

-c FILE : True if file is character special.

-d FILE : True if file is a directory.

-f FILE : True if file exists and is a regular file.

-p FILE : True if file is a named pipe.

-h FILE : True if file is a symbolic link.

-L FILE : True if file is a symbolic link.

-S FILE : True if file is a socket.

文件权限测试：

-r FILE : True if file is readable by you.

-w FILE : True if the file is writable by you. 是否有写权限

-x FILE : True if the file is executable by you.

特殊权限测试：

-u FILE：是否存在并且 拥有suid权限

-g FILE：是否存在并且 拥有sgid权限；

-k FILE：是否存在并且 拥有sticky权限；

文件是否有内容：

-s FILE : True if file exists and is not empty.

时间戳：

-N FILE：文件自从上一次读操作后是否被修改过；

从属关系测试：

-O FILE：True if the file is effectively owned by you.当前用户是否为文件的属主；

-G FILE：rue if the file is effectively owned by your group.当前用户是否属于文件的属组；

双目测试：

FILE1 -ef FILE2：True if file1 is a hard link to file2；FILE1与FILE2是否指向同一个文件系统的相同inode的硬链接；

FILE1 -nt FILE2：True if file1 is newer than file2 (according to modification date)；FILE1是否新于FILE2；

FILE1 -ot FILE2： True if file1 is older than file2；FILE1是否旧于FILE2；

是否被打开：

-t FD: True if FD is opened on a terminal.文件描述符是否在某终端已经打开

实验：创建用户，如果该用户存在则不创建，如果不存在创建之，并将“magedu”作为其密码。

#1/bin/bash

[ $# -ne 1 ] &&  echo "your args is wrong" && exit

id $1 &> /dev/null && echo "$1 is exist" && exit  || useradd $1 && echo "magedu" | passwd --stdin  $1

或

#!/bin/bash

id $1 &> /dev/null

[ $? -eq 0 ] && echo "$1 is exist" && exit

useradd $1 && echo magedu | passwd --stdin $1

(4) bash的组合测试文件

第一种方式：

COMMAND1 && COMMAND2 并且

COMMAND1 || COMMAND2 或者

! COMMAND 非

如：[[ -r FILE ]] && [[ -w FILE ]]

第二种方式：

EXPRESSION1 -a EXPRESSION2 并且

EXPRESSION1 -o EXPRESSION2 或者

! EXPRESSION

必须使用测试命令进行

示例：

[ -z “$HOSTNAME” -o $HOSTNAME "==\"localhost.localdomain" ] && hostname www.magedu.com

[ -f /bin/cat -a -x /bin/cat ] && cat /etc/fstab

补充：脚本的状态返回值：

• 默认是脚本中执行的最后一条件命令的状态返回值；
• 自定义状态退出状态码：
  
  exit [n]：n为自己指定的状态码；

注意：shell进程遇到exit时，即会终止，因此，整个脚本执行即为结束；

三、read

使用read来把输入值分配给一个或多个shell变量

-p 指定要显示的提示

-s 静默输入，一般用于密码

-n N 指定输入的字符长度N

-d ‘字符’ 输入结束符

-t N TIMEOUT为N秒

echo a b c > file1

read x y z <file1

echo $x

a

echo $y

b

echo $z

c

也可以

read x y z <<<  "i j k"

#!/bin/bash

read -p  "please input your name: " name

echo your name is $name

#!/bin/bash

read -p  "please input your name: " name

read -s -p "please input your passwd: " passwd

echo your name is $name

echo your passwd is $passwd

实验：鸡兔同笼；输入总的头数和总的脚数，算出鸡、兔分别有几只。

#!/bin/bash

read -p "please input heads num: " H

read -p "please input feets num: " F

C=$[(4*H-F)/2]

R=$[(F-2*H)/2]

echo "the chicken num is $C"

echo "the rabbir num is $R"

四、$- 变量

echo $-

himBH

h：hashall，打开这个选项后，Shell 会将命令所在的路径hash下来，避免每次都要查询。通过set +h将h选项关闭

i：interactive-comments，包含这个选项说明当前的 shell 是一个交互式的 shell。所谓的交互式shell,在脚本中，i选项是关闭的。

m：monitor，打开监控模式，就可以通过Job control来控制进程的停止、继续，后台或者前台执行等。

B：braceexpand，大括号扩展

H：history，H选项打开，可以展开历史列表中的命令，可以通过!感叹号来完成，例如“!!”返回上最近的一个历史命令，“!n”返回第 n 个历史命令

五、练习题

1、编写脚本/root/bin/systeminfo.sh,显示当前主机系统信息，包括主机名，IPv4地址，操作系统版本，内核版本，CPU型号，内存大小，硬盘大小

#!/bin/bash

echo -e "\e[1;35mThis computer is hosted by: \e[0m"

hostname

echo "    "

echo -e  "\e[1;35mMy ip addr is:\e[0m"

ifconfig  | sed -n '2p'|sed -r  's@.*inet (.*) net.*@\1@'

echo "     "

#

echo -e  "\e[1;35mMy OS version is:\e[0m"

cat /etc/centos-release

echo "  "

echo -e "\e[1;35mMy CPU is: \e[0m"

lscpu

echo "   "

echo -e "\e[1;35mMy memory is: \e[0m"

free -m

echo " "

echo -e "\e[1;35mMy disk is: \e[0m"

lsblk | sed -n  '2p'

2、编写脚本/root/bin/backup.sh，可实现每日将/etc/目录备份到/root/etcYYYY-mm-dd中

#!/bin/bash

echo -e "\e[1;35mbackup ing.... \e[0m"

sleep 3

cp -av  /etc/  /data/etc`date +%F`

echo -e  "\e[1;35mbackup is done \e[0m"

3、编写脚本/root/bin/disk.sh,显示当前硬盘分区中空间利用率最大的值

#!/bin/bash

echo -e "\e[1;35mThe biggst ratio of your disk's space is \e[0m"

df | grep "/dev/sd"  | tr -s " " %   | cut -d% -f5 | sort -nr |   head -n1

4、编写脚本/root/bin/links.sh,显示正连接本主机的每个远程主机的IPv4地址和连接数，并按连接数从大到小排序

---

---

5、编写脚本/root/bin/sumid.sh，计算/etc/passwd文件中的第10个用户和第20用户的ID之和

#!/bin/bash

[ $# -ne 2 ] && echo "Args num must be 2" && exit

[[ ! "$1" =~ ^[0-9]+$ ]] && echo "$1 is not digital" && exit

[[ ! "$2" =~ ^[0-9]+$ ]] && echo "$2 is not digital" && exit

UID1="`head -n$1 /etc/passwd | cut -d: -f3 |tail -n1`"

UID2="`head -n$2 /etc/passwd | cut -d: -f3 |tail -n1`"

sumid=$[$UID1+$UID2]

echo $sumid

6、编写脚本/root/bin/sumspace.sh，传递两个文件路径作为参数给脚本，计算这两个文件中所有空白行之和

#!/bin/bash

echo -e "\e[1;35mThe files's blankline is : \e[0m"

grep ^$ $1 $2 | wc -l

7、编写脚本/root/bin/sumfile.sh,统计/etc, /var, /usr目录*有多少个一级子目录和文件

#!/bin/bash

echo -e "\e[1;35mThe number of /etc /var /usr is : \e[0m"

a="`find /etc -maxdepth 1 |wc -l`"

b="`find /usr -maxdepth 1 |wc -l`"

c="`find /var -maxdepth 1 |wc -l`"

sum=$[a+b+c]

echo $sum

---

---

8、编写脚本/root/bin/argsnum.sh，接受一个文件路径作为参数；如果参数个数小于1，则提示用户“至少应该给一个参数”，并立即退出；如果参数个数不小于1，则显示第一个参数所指向的文件中的空白行数

#!/bin/bash

[ $# -lt 1 ] && echo -e "\e[1;33m至少应该有一个参数 \e[0m"  && exit

[ $# -ge 1 ] && grep ^$ $1 $2 $3 |wc -l

9、编写脚本/root/bin/hostping.sh，接受一个主机的IPv4地址做为参数，测试是否可连通。如果能ping通，则提示用户“该IP地址可访问”；如果不可ping通，则提示用户“该IP地址不可访问”

10、编写脚本/root/bin/checkdisk.sh，检查磁盘分区空间和inode使用率，如果超过80%，就发广播警告空间将满

#!/bin/bash

a="`df | grep "/dev/sd.*" | tr -s " " % |cut -d% -f5 | sort -nr | head -n1`"

b="`df -i | grep "/dev/sd.*" | tr -s " " % |cut -d% -f5 | sort -nr | head -n1`"

[ $a -ge 80 ] && echo -e "\e[1;35mYour disk space is warmming!! \e[0m"

[ $b -ge 80 ] && echo -e "\e[1;35mYour inode numbers is warmming!! \e[0m"

---

---

11、编写脚本/bin/per.sh,判断当前用户对指定的参数文件，是否不可读并且不可写

#!/bin/bash

[ -r $1 -a -w $1 ] ||  echo -e "\e[1;35m您对此文件无读写权限 \e[0m"

12、编写脚本/root/bin/excute.sh ，判断参数文件是否为sh后缀的普通文件，如果是，添加所有人可执行权限，否则提示用户非脚本文件

#!/bin/bash

[[ $1 =~  \.sh$   ]] && [[ -f $1 ]] || { echo -e "\e[1;35m该文件非脚本文件 \e[0m" ; exit;  }

chmod +x $1

echo -e "\e[1;35m该文件已添加X权限 \e[0m"

13、编写脚本/root/bin/nologin.sh和login.sh,实现禁止和充许普通用户登录系统

nologin.sh

#!/bin/bash

echo -e "\e[1;35mYOU WILL OPEN NOLOGIN,PLEASE WAIT \e[0m"

[ -a /etc/nologin ] && exit  || touch /etc/nologin

echo -e "\e[1;35mdone!!!\e[0m"

login.sh

#!/bin/bash

[ -e /etc/nologin ] && `rm -f /etc/nologin` || echo -e "\e[1;35mnow,you can login \e[0m"

14.通过命令行参数给定两个数字，输出其中较大的数值；

#!/bin/bash

# which num is the max of two

if [ $# -ne 2 ] ;then

    echo "please input two num"

    exit

fi

if [ $1 -gt $2 ] ;then

    echo "the max num is $1"

else

    echo "the max num is $2"

fi

# 或者

#!/bin/bash

if [ $# -lt 2 ]; then

	echo "Two integers."

	exit 2

fi

declare -i max=$1

if [ $1 -lt $2 ]; then

	max=$2

fi

echo "Max number: $max."

15.通过命令行参数给定一个用户名，判断其ID号是偶数还是奇数；

#!/bin/bash

if [ $# -ne 1 ] ;then

    echo "please input one args"

    exit

fi

if ! id $1 &>/dev/dull ;then

    useradd $1

fi

idnum=$(id -u $1)

idnum_yu=$[idnum%2]

if [ "$idnum_yu" -eq 1 ];then

    echo "用户$1的id是奇数"

else

    echo "用户$1的id是偶数"

fi

16.通过命令行参数给定两个文本文件名，如果某文件不存在，则结束脚本执行；都存在时返回每个文件的行数，并说明其中行数较多的文件；

#!/bin/bash

#

if [ $# -ne 2 ] ;then

    echo "please input two fileadd"

    exit

fi

if [ -a $1 -a -a $2 ];then

    echo "the two files are exits "

else

    echo "the file $1 or $2 is not exits;please input again"

    exit

fi

file1_lines=$(cat $1 |wc -l)

file2_lines=$(cat $2 |wc -l)

if [ "$file1_lines" -gt "$file2_lines" ];then

    echo "the $1's lines is more then $2"

else

    echo "the $2's lines is more then $1"

fi