shell判断文件是否为空 shell判断一个文件是否为空

linux 编写一个awk脚本,针对etc/passwd/文件统计每一种shell的用户个数

使用下面的命令来执行并调试 Shell 脚本-x：

你的理解错误了

shell判断文件是否为空 shell判断一个文件是否为空

shell判断文件是否为空 shell判断一个文件是否为空

{local

begin{fs=":"}

表示以:分隔字段

句，如果个字段含有root,

输出该行

～表print示匹配

～/root/表示匹配root字符串

$1～/root/表示个字段匹配root字符串

如果true,

defualt

第二句，如果个字段非空，输出该行

（而不是你说的输出个域）

我在看shell脚本的时候遇到了类似于-en这样的option

file1 -nt file2 测试以判断个文件是否比第二个文件更新（由修改日期决定）

-b file 如果文件为一个块特殊文件，则为真

-c file 如果文件为一个字符特殊文件，则为真

-d file 如果文件为一个目录，则为真

-e file 如果文件存在，则为真

-f file 如果文件为一个普通文件，则为真

-g file 如果设置了文件的 SGID 位，则为真

-G file 如果文件存在且归该组所有，则为真

-k file 如果设置了文件的粘着位，则为真

-O file 如果文件存在并且归该用户所有，则为真^[ --> 一个特殊转义符用于返回命令行模式。写脚本时按ctrl+v再按就能自动打出这个字符。

-p file 如果文件为一个命名管道，则为真

-r file 如果文件可读，则为真

-s file 如果文件echo $1的长度不为零，则为真

-S file 如果文件为一个套接字特殊文件，则为真

-t fd 如果 fd 是一个与终端相连的打开的文件描述符（fd 默认为 1），则为真

-u file 如果设置了文件的 SUID 位，则为真

-w file 如果文件可写，则为真

-x file 如果文件可执行，则为真

file1 -ot file2 测试以判断个文件是否比第二个文件更旧

int1 -eq int2 如果 int1 等于 int2，则为真

int1 -ge int2 如果 int1 大于或等于 int2，则为真

int1 -gt int2 如果 int1 大于 int2，则为真

int1 -le int2 如果 int1 小于或等于 int2，则为真

int1 -lt int2 如果 int1 小于 int2，则为真

int1 -ne int2 如果 int1 不等于 int2，则为真

-z string 测试以判断字符串是否为空；字符串必须为 test 所识别

string1 = string2 测试以判断 string1 是否与 string2 相同

0string1 != string2 测试以判断 string1 是否与 string2 不同

! expr 如果表达式评估为，则为真

expr1 -a expr2 如果 expr1 和 expr2 评估为真，则为真

expr1 -o expr2 如果 expr1 或 expr2 评估为真，则为真

你man test就能看到所有的帮助

Linux Shell正则表达式如何匹配1~3位数字

lines=$1

grep '^[0-9]{1,3}$' test.txt | grep '^[1-9]'

那么什么是shell脚本呢？

如果是变量

④bash把双中括号中的表达式看作一个单独的元素，并返回一个退出状态码。

echo $var | grep '^[0-9]{1,3}$' | grep '^[1-9]'

$表示行尾

这个正则不匹配 12a 这样的字符串

你的变量内容是什么样的？

我用来测试的 test.txt 的内容：

123

321

123212

001

010

100

10000

0011

10101

12

311

22

33

1a

2a

lx@LxUbuntu:~/bash/tmp$ cat 123

123

321

123212

001

010

100

10000

0011

10101

lx@LxUbuntu:~/bash/tmp$ sed -n '/^[1-9][0-9].$/p' 123

123

321

100

这样可以吗？

用shell脚本批量创建30个用户，用户名为exam1~exam30，用户密码统一为gdlclinux。

else

写好了，还在测试，测试好了就给你。

写好了，通过测试了。

########################################################################

#注：本脚本中使用了函数模块，以方便修改和调试

#

# 2011年12月10日 初稿

#

# 2011年12月11日 测试 问题：密码修改函数尚未实现

#

# 2011年12月11日 定稿 密码修改函数实现

#

# by bmw88661@126 12.11.2011

########################################################################

#设置变量

username=exam

password=gdlclinux

rmso=$(tput rmso)

so=$(tput so)

#此处可添加要求输入用户名和密码的项

#错误判断函数

SEA()

{location=$( which useradd ) #查找useradd的路径

if [ ( "$location" = "" ) -o ( -s "$location" ) ] #判断是否找到useradd文件，或着找到的文件为空

then

echo "Useradd was not found,job terminated $so unsuccessfully$rmso!"

exit

if [ -x "$location" ] #若useradd文件存在且不为空，判断是否具有可执行权限

then

echo "Command useradd doesn't he excution(x) mode"

exit

else echo ${#name}; # 输出为4 #无法确定问题原因

echo "Script terminated by some unknown problem,Please check it!"

exit

fi

fi

}#提示信息函数

casemsg()

{#判断passwd执行的返回值，并进入case分支

case "$y" in

0) echo "Set password for $so $username$i$rmso successfully"

;;

1) echo "Permission denied when set password for $so $username$i$rmso"

exit 1 ;;

2) echo "Invalid combination ofy=$? options for command passwd"

exit 2 ;;

3) echo "Unexpected failure, nothing done"

exit 3 ;;

4) echo "Unexpected failure, passwd file missing"

exit 4 ;;

5) echo "Passwd file busy, try again"

exit 5 ;;

6) echo "Invalid argument to option"

exit 6 ;;

esac

}#用户创建函数

usercreate()

{useradd -m $username$i #如果需要其他功能，请参照useradd帮助手册修改此行,如：设置uid

x=$?

}#密码修改函数

#这里如果你的系统里有chpasswd这个批修改工具的话，就不用这么麻烦了。

MOVpassword()

{( echo "$password";sleep 1;echo "$password" )|passwd $username$i #若useradd执行成功，则调用passwd设置密码

}#主循环

while [ "$i" -ge 1 -a "$i" -le 30 ]

do

usercreate #调用usercreate函数创建用户

if [ "$x" -eq 0 ] #判断useradd是否执行成功

then

echo "User $so $username$i$rmso he been create successfully!"

MOVpassword #调用MOVpassword修改密码

casemsg #调用casemsg函数

if [ "$y" = 0 ] #如果MOVpassword的返回值为0，则将i加1

then

let i++

fi

SEA #调用错误判断函数

fi

done

unset i x y location rmso so username password #释放所有设定的变量

#/bin/bash

for ((i=1;i<=10;i++));

echo gdlclinux | pw useradd exam$i

done

求助shell编程高手

调试count_odd_number.sh 程序案例：

一、小括号,园括号（）

1、单小括号 ()

①命令组。括号中的命令将会新开一个子shell顺序执行，所以括号中的变量不能够被脚本余下的部分使用。括号中多个命令之间用分号隔开，一个命令可以没有分号，各命令和括号之间不必有空格。

②命令替换。等同于`cmd`，shell扫描一遍命令行，发现了$(cmd)结构，便将$(cmd)中的cmd执行一次，得到其标准输出，再将此输出放到原来命令。有些shell不支持，如tcsh。

③用于初始化数组。如：array=(a b c d)

2、双小括号 (( ))

①整数扩展。这种扩展计算是整数型的计算，不支持浮点型。((exp))结构扩展并计算一个算术表达式的值，如果表达式的结果为0，那么返回的退出状态码为1，或者 是""，而一个非零值的表达式所返回的退出状态码将为0，或者是"true"。若是逻辑判断，表达式exp为真则为1,则为0。

②只要括号中的运算符、表达式符合C语言运算规则，都可用在$((exp))中，甚至是三目运算符。作不同进位(如二进制、八进制、local十六进制)运算时，输出结果全都自动转化成了十进制。如：echo $((16#5f)) 结果为95 (16进位转十进制)

③单纯用 (( )) 也可重定义变量值，比如 a=5; ((a++)) 可将 $a 重定义为6

④双括号中的变量可以不使用$符号前缀。括号内支持多个表达式用逗号分开。 if ($i<5)

if [ $i -lt 5 ]

if [ $a -ne 1 -a $a != 2 ]

if [ $a -ne 1] && [ $a != 2 ]

if [[ $a != 1 && $a != 2 ]]

for i in $(seq 0 4);do echo $i;done

for i in `seq 0 4`;do echo $i;done

for ((i=0;i<5;i++));do echo $i;done

for i in {0..4};do echo $i;done二）中括号，方括号[]

1、单中括号 []

①bash 的内部命令，[和test是等同的。如果我们不用路径指明，通常我们用的都是bash自带的命令。if/test结构中的左中括号是调用test的命令标识，右中括号是关闭条件判断的。这个命令把它的参数作为比较表达式或者作为文件测试，并且根据比较的结果来返回一个退出状态码。if/test结构中并不是必须右中括号，但是新版的Bash中要求必须这样。

②Test和[]中可用的比较运算符只有==和!=，两者都是用于字符串比较的，不可用于整数比较，整数比较只能使用-eq，-gt这种形式。无论是字符串比较还是整数比较都不支持大于号小于号。如果实在想用，对于字符串比较可以使用转义形式，如果比较"ab"和"bc"：[ ab < bc ]，结果为真，也就是返回状态为0。[ ]中的逻辑与和逻辑或使用-a 和-o 表示。

③字符范围。用作正则表达式的一部分，描述一个匹配的字符范围。作为test用途的中括号内不能使用正则。

④在一个array 结构的上下文中，中括号用来引用数组中每个元素的编号。

2、双中括号[[ ]]

①[[是 bash 程序语言的关键字。并不是一个命令，[[ ]] 结构比[ ]结构更加通用。在[[和]]之间所有的字符都不会发生文件名扩展或者单词分割，但是会发生参数扩展和命令替换。

②支持字符串的模式匹配，使用=~作符时甚至支持shell的正则表达式。字符串比较时可以把右边的作为一个模式，而不仅仅是一个字符串，比如[[ hello == hell? ]]，结果为真。[[ ]] 中匹配字符串或通配符，不需要引号。

③使用[[ ... ]]条件判断结构，而不是[ ... ]，能够防止脚本中的许多逻辑错误。比如，&&、||、<和> 作符能够正常存在于[[ ]]条件判断结构中，但是如果出现在[ ]结构中的话，会报错。

三）大括号、花括号 {}

1、常规用法。

①大括号拓展。(通c：Char 字符 对应位置参数必须是字符串或者字符型 否则报错配(globbing))将对大括号中的文件名做扩展。在大括号中，不允许有空白，除非这个空白被引用或转义。种：对大括号中的以逗号分割的文件列表进行拓展。如 touch {a,b}.txt 结果为a.txt b.txt。第二种：对大括号中以点点（..）分割的顺序文件列表起拓展作用，如：touch {a..d}.txt 结果为a.txt b.txt c.txt d.txt bogon:/home/bash # ls {ex1,ex2}.sh

ex1.sh ex2.sh

bogon:/home/bash # ls {ex{1..3},ex4}.sh

ex1.sh ex2.sh ex3.sh ex4.sh

bogon:/home/bash # ls {ex[1-3],ex4}.sh

ex1.sh ex2.sh ex3.sh ex4.sh ②代码块，又被称为内部组，这个结构事实上创建了一个匿名函数 。与小括号中的命令不同，大括号内的命令不会新开一个子shell运行，即脚本余下部分仍可使用括号内变量。括号内的命令间用分号隔开，一个也必须有分号。{}的个命令和左括号之间必须要有一个空格。

2）几种特殊的替换结构：${var:-string},${var:+string},${var:=string},${var:?string}

A,${var:-string}和${var:=string}:若变量var为空，则用在命令行中用string来替换${var:-string}，否则变量var不为空时，则用变量var的值来替换${var:-string}；对于${var:=string}的替换规则和${var:-string}是一样的，所不同之处是${var:=string}若var为空时，用string替换${var:=string}的同时，把string赋给变量var： ${var:=string}很常用的一种用法是，判断某个变量是否赋值，没有的话则给它赋上一个默认值。

B. ${var:+string}的替换规则和上面的相反，即只有当var不是空的时候才替换成string，若var为空时则不替换或者说是替换成变量 var的值，即空值。(因为变量var此时为空，所以这两种说法是等价的)

C,${var:?string}替换规则为：若变量var不为空，则用变量var的值来替换${var:?string}；若变量var为空，则把string输出到标准错误中，并从脚本中退出。我们可利用此特性来检查是否设置了变量的值。

补充扩展：在上面这五种替换结构中string不一定是常值的，可用另外一个变量的值或是一种命令的输出。

3）四种模式匹配替换结构：${var%pattern},${var%%pattern},${var#pattern},${var##pattern}

种模式：${variable%pattern}，这种模式时，shell在variable中查找，看它是否一给的模式pattern结尾，如果是，就从命令行把variable中的内容去掉右边短的匹配模式

第二种模式： ${variable%%pattern}，这种模式时，shell在variable中查找，看它是否一给的模式pattern结尾，如果是，就从命令行把variable中的内容去掉右边长的匹配模式

第三种模式：${variable#pattern} 这种模式时，shell在variable中查找，看它是否一给的模式pattern开始，如果是，就从命令行把variable中的内容去掉左边短的匹配模式

第四种模式： ${variable##pattern} 这种模式时，shell在variable中查找，看它是否一给的模式pattern结尾，如果是，就从命令行把variable中的内容去掉右边长的匹配模式

这四种模式中都不会改变variable的值，其中，只有在pattern中使用了匹配符号时，%和%%，#和##才有区别。结构中的pattern支持通配符，表示零个或多个任意字符，?表示零个或一个任意字符，[...]表示匹配中括号里面的字符，[!...]表示不匹配中括号里面的字符 bogon:/home/bash # var=testcase

bogon:/home/bash # echo $var

testcase

bogon:/home/bash # echo ${var%se}

testca

bogon:/home/bash # echo $var

testcase

bogon:/home/bash # echo ${var%%se}

te

bogon:/home/bash # echo ${var#?e}

stcase

bogon:/home/bash # echo ${var##?e}

stcase

bogon:/home/bash # echo ${var##e}

bogon:/home/bash # echo ${var##s}

ebogon:/home/bash # echo ${var##test}

case

shell/bash 两个变量的提取和判断，即：实现两个条件同时存在

shell变量：shell变量是由shell程序设置的特殊变量。shell变量中有一部分是环境变量，有一部分是局部变量，这些变量保证了shell的正常运行

#!/bin/bash

one=`grep 1234 test.txt`

two=`grep qwer test.txt`

if [ ! -z $one ] && [ -z $two ] ;

then

echo exit下表列出了常用的布尔运算符，定变量 a 为 10，变量 b 为 20： $E_NOTROOT"期望的输出信息"

fi

谁帮我看看这段shell是什么意思吧，谢谢。尤其这一段 if [ -n "$1" ]

[[]] 和 (()) 分别是[ ]的针对数学比较表达式和字符串表达式的加强版。

#/bin/bash

ROOT_UID=0

LINES=50

E_XCD=86

E_NOTROOT=87

if [ "$UID" -ne "$ROOT_UID" ]

then

echo "Must be root to run this script."

fii=1

自定义了几个变量外加判断目前用户是否为root..

if [ -n "$1" ]

then

lines=$LINES

fi

判断目前的程序的位置参数$1是否非空 非空为真 空为 非空把$1带入到lines里。如果为空就把上边定义过的$lines带入到lines里。

cd $LOG_DIR

ifile1 -ef file2测试以判断两个文件是否与同一个设备相连，是否拥有相同的 inode 编号f [ "pwd" !="$LOG_DIR" ]

then

echo "Cant't change to $LOG_DIR."

exit $E_XCD

fi

然后进入 日志目录 这个目录应该是一个环境变量，判断所在目录是否为所定义的目录。

tail -n $lines messages > mesg.temp

mv mesg.temp messages

exit 0

从后显示 messages文件里 第$lines行的内容 写到 mesg.temp里

修改mesg.temp 为messages

退出

一句大概意思是一直保持messages内容为的记录。

自动清理以前不需要的内容。

说实话。。我也只能顺序读出来。没怎么领悟原作者具体想干什么。

ubuntu编写一个shell脚本，要求：删除目录及子目录下2019.02.14之前创建的文件或目录

你选择IE工具栏上的工具----internet选项------高级-----设置项里在“禁用脚本调试(internet)”和“其它脚本调试”打勾。如果还不好使用电脑管家之类的软件修复一下IE。

Linux下使用

+ (( 1%2 == 1 ))

Shell脚本

删除一个目录下的所有

子目录

和文件

#!/bin/sh

#FileName:deleteDir.sh

#Version:V0.1

#Author:Sunrier

#Date:2012-08-0echo1

CURRPATH=$PWD

#DESTPATH为删除的目标目录

DESTPATH="/home/Sunrier/Trash"

#isNullDir函数判断进入的目录下是否存在下级子目录或者文件

#存在返回1,不存在返回0

NewCurrentPath=$PWD

NewDirName=$1

cd

NewFileList=`ls

2>/dev/null`

#-n

:如果字符串不为空,则结果为真

if

[-n

"$NewFileList"

]then

"目录$NewDirName下列表信息为$NewFileList"

cd

$NewCurrentPath

return

1else

"目录$NewDirName为空目录"

cd

$NewCurrentPath

return

fi

}

下面写着停止脚本是什么意思呢？

This is line 2 --> 编辑输入的文本行内容

搬砖

1101

如果是IE9的浏览器，其它解决方案如下。

请关闭所有IE9浏览器窗口。

接着请你重置IE9，步骤：

1. 关闭所有Internet Explorer窗口。

2. 单击开始，在搜索框内输入inetcpl.cpl，按回车。

3. 点击高级选项卡，点击重置，勾选删除个性化设置，点击重置。

4. 点击关闭。

这样做过后，看看能不能正常使用IE?

你也可以尝试无加载项启动IE9，以测试是否是加载项造成了IE9无常使用?

无加载项启动IE9，请通过：

依次单击“开始”按钮 、“所有程序”、“附件”、“系统工具”，然后单击“Internet Explorer (无加载项)”。

shell是外壳的意思，就是作系统的外壳。我们可以通过shell命令来作和控制作系统，比如Linux中的Shell命令就包括ls、cd、pwd等等。总结来说，Shell是一个命令解释器，它通过接受用户输入的Shell命令来启动、暂停、停止程序的运行或对计算机进行控制。

shell 是一个应用程序，它连接了用户和 Linux 内核，让用户能够更加高效、安全、低成本地使用 Linux 内核，这就是 Shell 的本质。

shell 本身并不是内核的一部分，它只是站在内核的基础上编写的一个应用程序。

shell脚本就是由Shell命令组成的执行文件，将一些命令整合到一个文件中，进行处理业务逻辑，脚本不用编译即可运行。它通过解释器解释运行，所以速度相对来说比较慢。

shell脚本中重要的就是对shell命令的使用与组合，再使用shell脚本支持的一些语言特性，完成想要的功能。

注释

“# ”开头的就是注释，被编译器忽略

单行注释： #

多行注释： :<

变量

变量类型

运行shell时，会同时存在三种变量：

局部变量：局部变量在脚本或命令中定义，仅在当前shell实例中有效，其他shell启动的程序不能访问局部变量。

环境变量：所有的程序，包括shell启动的程序，都能访问环境变量，有些程序需要环境变量来保证其正常运行。必要的时候shell脚本也可以定义环境变量。

变量作

创建普通变量： name="test" （=两边不可有空格）

创建只可函数体中使用的局部变量： local name="test" （使用local修饰的变量在函数体外无法访问，并且local只能在函数体内使用）

使用变量： echo $name 或者 echo ${name} （使用大括号版）

变量重新赋值： name="new_test" （将原值覆盖）

只读变量： name="only_read" -> readonly name （使用readonly标识后的变量，不可被修改）

删除变量： unset name; （删除之后不可访问，删除不掉只读变量）

字符串变量

1）单引号

单引号变量var='test' ，只能原样输出，变量无效

单引号中不能出现一个单独的单引号，转义也不可以

2）双引号

双引号变量var="my name is ${name}"，变量有效

可出现转义符

3）拼接字符串

中间无任何+，之类的字符

name="this is"" my name"; name="this is my name"; name="this" is "my name" 等效

4）获取字符串长度

在${}中使用“#”获取长度

name="test";

5）提取子字符串

1:4 从第2个开始 往后截取4个字符

::4 从个字符开始 往后截取4个字符

name="this is my name";

echo ${name:1:4} #输出 is i

echo ${name::4} #输出 this

数组

bash只支持一维数组，不支持数组

定义数组：array_name=(li wang xiang zhang) （小括号做边界、使用空格分离）

单独定义数组的元素： array_para[0]="w"; array_para[3]="s" （定义时下标不连续也可以）

赋值数组元素：array_name[0]="zhao";

获取数组元素：

array_name[0]="li"

array_name[3]="zhang"

echo ${array_name[0]} # 输出"li"

echo ${array_name[1]} # 输出" "

echo ${array_name[3]} # 输出"zhang"

echo ${array_name[@]} # 输出"li zhang" 输出数组所有元素，没有元素的下标省略

取得元素个数：${#array_name[@]} 或者 ${#array_name

}取得单个元素长度：${#array_name[1]}

参数传递

获取参数值：

$0 ： 固定，代表执行的文件名

$1 ： 代表传入的第1个参数

$n ： 代表传入的第n个参数

$#：参数个数

$： 以一个单字符串显示所有向脚本传递的参数。如"$"用「"」括起来的情况、以"$1 $2 … $n"的形式输出所有参数

$@：与$相同，但是使用时加引号，并在引号中返回每个参数。

$$：脚本运行的当前进程号

$！：后台运行的一个进程的ID

$?： 显示命令的退出状态。0表示没有错误，其他任何值表明有错误。

$ 与 $@ 区别

相同点：都是引用所有参数。

不同点：只有在双引号中体现出来。设在脚本运行时写了三个参数 1、2、3，，则 " " 等价于 "1 2 3"（传递了一个参数），而 "@" 等价于 "1" "2" "3"（传递了三个参数）。

运算符

算数运算

+ 、-、、 ： 乘号前必须加进行转义才可以进行乘法运算

加法运算

val=`expr 2 + 2` （使用linux命令expr进行辅助运算）

val=$[2+2] （4个空格不是必要的，不同于条件判断）

val=$((2+2))

数字关系运算符

关系运算符只支持数字，不支持字符串，除非字符串的值是数字。

下面定变量 a 为 10，变量 b 为 20

-eq ：检测两个数是否相等，相等返回 true。 [ $a -eq $b ] 返回 false。

-ne： 检测两个数是否不相等，不相等返回 true。 [ $a -ne $b ] 返回 true。

-gt： 检测左边的数是否大于右边的，如果是，则返回 true。 [ $a -gt $b ] 返回 false。

-lt ： 检测左边的数是否小于右边的，如果是，则返回 true。 [ $a -lt $b ] 返回 true。

-ge： 检测左边的数是否大于等于右边的，如果是，则返回 true。 [ $a -ge $b ] 返回 false。

-le ： 检测左边的数是否小于等于右边的，如果是，则返回 true。 [ $a -le $b ] 返回 true。

字符串运算符

下表列出了常用的字符串运算符，定变量 a 为 "abc"，变量 b 为 "efg"：

= ：检测两个字符串是否相等，相等返回 true。 [ $a = $b ] 返回 false。

!= ：检测两个字符串是否相等，不相等返回 true。 [ $a != $b ] 返回 true。

-z ：检测字符串长度是否为0，为0返回 true。 [ -z $a ] 返回 false。

-n ：检测字符串长度是否为0，不为0返回 true。 [ -n "$a" ] 返回 true。

$ ：检测字符串是否为空，不为空返回 true。 [ $a ] 返回 true。

布尔运算符

! ：非运算，表达式为 true 则返回 false，否则返回 true。 [ ! false ] 返回 true。

-o ：或运算，有一个表达式为 true 则返回 true。 [ $a -lt 20 -o $b -gt 100 ] 返回 true。

-a ：与运算，两个表达式都为 true 才返回 true。 [ $a -lt 20 -a $b -gt 100 ] 返回 false。

逻辑运算符

以下介绍 Shell 的逻辑运算符，定变量 a 为 10，变量 b 为 20:

&& ：逻辑的 AND [[ $a -lt 100 && $b -gt 100 ]] 返回 false

|| ：逻辑的 OR [[ $a -lt 100 || $b -gt 100 ]] 返回 true

文件运算符

-b file ：检测文件是否是块设备文件，如果是，则返回 true。 [ -b $file ] 返回 false。

-c file ：检测文件是否是字符设备文件，如果是，则返回 true。 [ -c $file ] 返回 false。

-d file ：检测文件是否是目录，如果是，则返回 true。 [ -d $file ] 返回 false。

-f file ：检测文件是否是普通文件（既不是目录，也不是设备文件），如果是，则返回 true。 [ -f $file ] 返回 true。

-g file ：检测文件是否设置了 SGID 位，如果是，则返回 true。 [ -g $file ] 返回 false。

-k file ：检测文件是否设置了粘着位(Sticky Bit)，如果是，则返回 true。 [ -k $file ] 返回 false。

-p file ：检测文件是否是有名管道，如果是，则返回 true。 [ -p $file ] 返回 false。

-u file ：检测文件是否设置了 SUID 位，如果是，则返回 true。 [ -u $file ] 返回 false。

-r file ：检测文件是否可读，如果是，则返回 true。 [ -r $file ] 返回 true。

-w file ：检测文件是否可写，如果是，则返回 true。 [ -w $file ] 返回 true。

-x file ：检测文件是否可执行，如果是，则返回 true。 [ -x $file ] 返回 true。

-s file ：检测文件是否为空（文件大小是否大于0），不为空返回 true。 [ -s $file ] 返回 true。

-e file ：检测文件（包括目录）是否存在，如果是，则返回 true。 [ -e $file ] 返回 true。

执行相关

命令替换与变量替换不多，都是用来重组命令行的，先完成引号里的命令行，然后将其结果替换出来，再重组成新的命令行。

执行命令：

`ls /etc` ： 反引号 （所有的unix系统都支持）

$(ls /etc) ： $+() （部分unix系统不支持）

多个嵌套使用时，从内向外执行for file in s /etc 或 for file in $(ls /etc) 循环中使用

`dirname $0` 获取脚本文件所在的目录

path=$(cd `dirname $0`;pwd) ： 获取脚本当前所在目录，并且执行cd命令到达该目录，使用pwd获取路径并赋值到path变量

算术运算

$[ ] : 加减乘除,不必添加空格

$(( )) ：加减乘除等,不必添加空格

逻辑判断

[ ] ： 中括号旁边和运算符两边必须添加空格 （可以使用，不）

[[ ]]：中括号旁边和运算符两边必须添加空格 （字符串验证时，使用）

(()) ： 中括号旁边和运算符两边必须添加空格 （数字验证时，使用）

使用[[ ... ]]条件判断结构，而不是[ ... ]，能够防止脚本中的许多逻辑错误。比如，&&、||、<和> 作符能够正常存在于[[ ]]条件判断结构中，但是如果出现在[ ]结构中的话，会报错。比如可以直接使用if [[ $a != 1 && $a != 2 ]], 如果不适用双括号, 则为if [ $a -ne 1] && [ $a != 2 ]或者if [ $a -ne 1 -a $a != 2 ]。

[[ ]]中增加模式匹配；

(( ))不需要再将表达式里面的大小于符号转义，除了可以使用标准的数算符外，还增加了以下符号

输出

仅用于字符串的输出，没有使用printf作为输出的移植性好，建议使用printf

printf

printf 不会像 echo 自动添加换行符，我们可以手动添加 n

无大括号，直接以空格分隔

格式：printf format-string [arguments...] 其中（format-string: 格式控制字符串、arguments: 参数列表）

案例：printf "%-10s %-8s %-4.2fn" 郭靖 男 66.1234

%s %c %d %f 都是格式替代符

d：Decimal 十进制整数 对应位置参数必须是十进制整数，否则报错!

s：String 字符串 对应位置参数必须是字符串或者字符型 否则报错

%-10s ： 指一个宽度为10个字符（-表示左对齐，没有则表示右对齐），任何字符都会被显示在10个字符宽的字符内，如果不足则自动以空格填充，超过也会将内容全部显示出来。

%-4.2f ：指格式化为小数，宽度为4个字符，其中.2指保留2位小数。

转义符：

a ：字符，通常为ASCII的BEL字符

b ：后退

c ：抑制（不显示）输出结果中任何结尾的换行字符（只在%b格式指示符控制下的参数字符串中有效），而且，任何留在参数里的字符、任何接下来的参数以及任何留在格式字符串中的字符，都被忽略

f ：换页（formfeed）

n ：换行

r ：回车（Carriage return）

t ：水平制表符

v ：垂直制表符

：一个字面上的反斜杠字符

ddd ：表示1到3位数八进制值的字符。仅在格式字符串中有效

0ddd ：表示1到3位的八进制值字符

流程控制

和Ja、PHP等语言不一样，sh的流程控制不可为空，即if或者else的大括号中无任何语句

if else

ifif condition then command1 command2 ... commandN fi

if elseif condition then command1 command2 ... commandN else command fi

if else-if elseif condition1 then command1 elif condition2 then command2 else commandN fi

for

for var in 1 2 ... N do command1 command2 ... commandN done

while

while conditionwhile condition do command done

while 无限循环while : do command done

until

until 循环执行一系列命令直至条件为 true 时停止。

until condition do command done

case

Shell case语句为多选择语句。可以用case语句匹配一个值与一个模式，如果匹配成功，执行相匹配的命令。

case需要一个esac（就是case反过来）作为结束标记，每个case分支用右圆括号，用两个分号表示break，其中“;;”不是跳出循环，是不在去匹配下面的模式

case语句格式如下：

case 值 in 模式1) command1 command2 ... commandN ;; 模式2） command1 command2 ... commandN ;; esac

跳出循环

break ：跳出总循环

continue：跳出当前循环，继续下一次循环

定义函数

可以带function fun() 定义，也可以直接fun() 定义,不带任何参数。

函数定义[ function ] funname() { action; [return int;] }

参数传递

调用函数: fun_name 2 3 4

函数中使用：和shell取用函数相同 $n $# $ $? 或者加上{}funWithParam(){ echo "个参数为 $1 !" echo "第二个参数为 $2 !" echo "第十个参数为 $10 !" echo "第十个参数为 ${10} !" echo "第十一个参数为 ${11} !" echo "参数总数有 $# 个!" echo "作为一个字符串输出所有参数 $ !"} funWithParam 1 2 3 4 5 6 7 8 9 34 73 echo $? # 判断执行是否成功

函数返回值

return 只能为 return [0-255]，此处的返回可作为函数执行的状态，通过$?获取的便是这个返回值

如果不加return ， 则默认一条语句的执行状态所为函数执行状态的返回值，如果一条语句执行成功，则$?为0，否则不为0

使用函数返回值（Janusgraph图数据库启动服务脚本片段）

return返回的数字，只是作为函数执行状态的返回值，也就是接下来$?获取的值

对于类似于下面的BIN=abs_path``语句，获取的是函数体内所有的echo、printf输出组合成的一个字符串 abs_path() { SOURCE="${BASH_SOURCE[0]}" while [ -h "$SOURCE" ]; do DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )" SOURCE="$(readlink "$SOURCE")" [[ $SOURCE != / ]] && SOURCE="$DIR/$SOURCE" done echo "test" echo "$( cd -P "$( dirname "$SOURCE" )" && pwd )" # 此函数的两个echo输出会组合成一个字符串作为下述BIN的值 }

BIN=abs_path # BIN赋值函数返回值，如果没有return，则函数中所有的echo、printf输出组合成一个字符串传入BIN

path=${BIN}/nodetool # 可直接使用

#### 输入输出重定向

一般情况下，每个 Unix/Linux 命令运行时都会打开三个文件：

标准输入文件(stdin)：stdin的文件描述符为0，Unix程序默认从stdin读取数据。

标准输出文件(stdout)：stdout 的文件描述符为1，Unix程序默认向stdout输出数据。

标准错误文件(stderr)：stderr的文件描述符为2，Unix程序会向stderr流中写入错误信息。

默认情况下，command > file 将 stdout 重定向到 file，command < file 将stdin 重定向到 file。

如果希望执行某个命令，但又不希望在屏幕上显示输出结果，那么可以将输出重定向到 /dev/null：

输入重定向

1. bash.sh < file ： 将脚本的输入重定向到file，由file提供参数

输出重定向

1. bash.sh > file ： 将脚本的输出数据重定向到file中，覆盖数据

2. bash.sh >> file ： 将脚本的输出数据重定向到file中，追加数据

3. command >> file 2>&1 ： 将 stdout 和 stderr 合并后重定向到 file

#### 读取外部输入

命令：`read arg` （脚本读取外部输入并赋值到变量上）

在shell脚本执行到上述命令时，停止脚本执行并等待外部输入，将外部输入赋值到arg变量上，继续执行脚本

#### 文件引用

引用其他的文件之后，可以使用其变量、函数等等，相当于将引用的文件包含进了当前文件

两种方式：

1. . file_pathfile_name

2. source file_pathfile_name

#### 颜色标识

```shell

printf "033[32m SUCCESS: yay 033[0mn";

printf "033[33m WARNING: hmm 033[0mn";

printf "033[31m ERROR: fubar 033[0mn";

输出结果：

长句换行

在shell中为避免一个语句过长，可以使用“”进行换行

使用“”换行，在脚本执行过程中还是当做一行一个语句执行，不同于enter直接换行

注意： 前添加一个空格 。 后无空格直接换行。

/mysql/bin/mysql -h test_host -P 000 -u test_user -ptest_password ;

shell作mysql

下面案例为登录mysql，并选择作数据库，之后进行导入数据

/mysql/mysql/bin/mysql -h test_host -P 000 -u test_user -ptest_password -e"use test_database; source data_faile; " # -e 代表执行sql语句

-u 用户名

-p 用户密码

-h ip地址

-D 连接的数据库

-N 不输出列信息

-B 使用tab键 代替 分隔符

退出脚本命令：exit

在退出脚本时使用不同的错误码，这样可以根据错误码来判断发生了什么错误。

在绝大多数 shell 脚本中，exit 0 表示执行成功，exit 1 表示发生错误。

对错误与错误码进行一对一的映射，这样有助于脚本调试。

命令：set -e 或者 set +e

set -e表示从当前位置开始，如果出现任何错误都将触发exit。相反，set +e表示不管出现任何错误继续执行脚本。

如果脚本是有状态的（每个后续步骤都依赖前一个步骤），那么请使用set -e，在脚本出现错误时立即退出脚本。

如果要求所有命令都要执行完（很少会这样），那么就使用set +e。

shell脚本调试

检查是否有语法错误-n：

bash -x script_name.sh

#!/usr/bin.env bash

# 用于计算数组中奇数的和

# @author liyangyang

# @time 2019/09/17

sum=0

for num in 1 2 3 4;do

re=${num}%2

if (( ${re} == 1 ));then

sum=$[${sum}+${num}]

fi

done

echo ${sum}

首先检查有无语法错误：

bash -n count_odd_number.sh

没有输出，说明没有错误，开始实际调试：

bash -x count_odd_number.sh

调试结果如下：

+ sum=0

+ for num in 1 2 3 4

+ re=1%2

+ sum=1

+ for num in 1 2 3 4

+ (( 2%2 == 1 ))

+ for num in 1 2 3 4

+ re=3%2

+ (( 3%2 == 1 ))

+ sum=4

+ for num in 1 2 3 4

+ re=4%2

+ (( 4%2 == 1 ))

+ echo 4

until 循环与 while 循环在处理方式上刚好相反。4