shell基本运算(转载)

shell 比较运算符一览表

运算符描述示例
文件比较运算符 
-e filename如果 filename 存在,则为真[-e /var/log/syslog]
-s filename如果 filename 存在且不为空,则为真[-s /var/log/syslog]
-d filename如果 filename 为目录,则为真[-d /tmp/mydir]
-f filename如果 filename 为常规文件,则为真[-f /usr/bin/grep]
-L filename如果 filename 为符号链接,则为真[-L /usr/bin/grep]
-r filename如果 filename 可读,则为真[-r /var/log/syslog]
-w filename如果 filename 可写,则为真[-w /var/mytmp.txt]
-x filename如果 filename 可执行,则为真[-L /usr/bin/grep]
filename1 -nt filename2如果 filename1 比 filename2 新,则为真[/tmp/install/etc/services -nt /etc/services]
filename1 -ot filename2如果 filename1 比 filename2 旧,则为真[/boot/bzImage -ot arch/i386/boot/bzImage]
字符串比较运算符 (请注意引号的使用,这是防止空格扰乱代码的好方法)
-z string如果 string 长度为零,则为真[-z "$myvar"]
-n string如果 string 长度非零,则为真[-n "$myvar"]
string1 = string2如果 string1 与 string2 相同,则为真["$myvar" = "one two three"]
string1 != string2如果 string1 与 string2 不同,则为真["$myvar" != "one two three"]
算术比较运算符
num1 -eq num2等于[3 -eq $mynum]
num1 -ne num2不等于[3 -ne $mynum]
num1 -lt num2小于[3 -lt $mynum]
num1 -le num2小于或等于[3 -le $mynum]
num1 -gt num2大于[3 -gt $mynum]
num1 -ge num2大于或等于[3 -ge $mynum]

算术运算符

      • / % 表示加、减、乘、除、取余运算

+=、 -=、 *=、 /= 同 C 语言中的含义

位操作符

= 表示位左右移一位操作

& &= | |= 表示按位与、位或操作

~ ! 表示非操作

^ ^= 表示异或操作

关系运算符

= == != 表示大于、小于、大于等于、小于等于、等于、不等于操作

&& || 逻辑与、逻辑或操作

测试命令

test 命令用于检查某个条件是否成立,它可以进行数值、字符和文件 3 个方面的测试,其测试符和相应的功能分别如下

(1)数值测试:

-eq 等于则为真。

-ne 不等于则为真。

-gt 大于则为真。

-ge 大于等于则为真。

-lt 小于则为真。

-le 小于等于则为真。

(2)字串测试:

= 等于则为真。

!= 不相等则为真。

-z 字串 字串长度为 0,则为真。

-n 字串 字串长度不为 0,则为真。

(3)文件测试:

-e 文件名,如果文件存在,则为真。

-r 文件名,如果文件存在且可读,则为真。

-w 文件名,如果文件存在且可写,则为真。

-x 文件名,如果文件存在且可执行,则为真。

-s 文件名,如果文件存在且至少有一个字符则为真。

-d 文件名,如果文件存在且为目录,则为真。

-f 文件名,如果文件存在且为普通文件,则为真。

-c 文件名,如果文件存在且为字符型特殊文件,则为真。

-b 文件名,如果文件存在且为块特殊文件,则为真

条件变量替换

Bash Shell 可以进行变量的条件替换,既只有某种条件发生时才进行替换,替换条件放在 {} 中.

(1) ${value:-$word}

当变量未定义或者值为空时,返回值为 word 的内容,否则返回变量的值.

## value 未赋值场景
$ value=""
$ word="hello"
$ echo ${value:-$word}   # value为空, 返回word赋值
hello
$ echo $value

## value 有赋值场景
$ value="mimvp.com"
$ word="hello"
$ echo ${value:-$word}   # value不为空, 返回value赋值
mimvp.com
$ echo $value
mimvp.com

(2) ${value:=$word}

与前者类似,只是若变量未定义或者值为空时,在返回 word 的值的同时将 word 赋值给 value

## value 未赋值场景
$ value=""
$ word="hello"
$ echo ${value:=$word}   # value为空, 返回word赋值, 并把word赋值给value
hello
$ echo $value            # value为空, 已获得了赋值 【区分点】
hello

## value 有赋值场景
$ value="mimvp.com"
$ word="hello"
$ echo ${value:=$word}   # value不为空, 返回value赋值
mimvp.com
$ echo $value
mimvp.com

(3) ${value:?$message}

若变量已赋值的话,则正常替换。否则将消息 message 送到标准错误输出 (若此替换出现在 Shell 程序中,那么该程序将终止运行)

## value 有赋值场景
$ value="mimvp.com"
$ message="you are blank, i love you"
$ echo ${value:?$message}     # value有赋值, 返回value赋值
mimvp.com

## value 未赋值场景
$ value=""
$ message="you are blank, i love you"
$ echo ${value:?$message}     # value无赋值, 返回message提示信息
-bash: value: you are blank, i love you

(4) ${value:+$word}

若变量已赋值的话,才用 word 去赋值,否则不进行任何赋值。注意:value 值一直不会变

示例:

## value 未赋值场景
$ value=""
$ echo $value

$ echo ${value:+"hello world"}   # value 未赋值,条件不成立,不进行赋值

$ echo $value

## value 有赋值场景
$ value="mimvp.com"           
$ echo $value      
mimvp.com
$ echo ${value:+"hello world"}   # value 有赋值,条件成立,进行赋值
hello world
$ echo $value      # value 本身不变 【切记!】
mimvp.com

(5) ${value:offset:length}

${value:offset:length} 从变量中提取子串,这里 offset 和 length 可以是算术表达式.

offset 下标从 0 开始计算,表示第一个字符。

$ value="mimvp.com"
$ echo ${value:2:3}   # 下标从0开始, 第三个字符串开始截取, 截取长度为3
mvp

(6) ${#value}   变量的字符个数

示例:

$ value="mimvp.com"
$ echo ${#value}      # 获取字符串的长度
9
$ echo ${#value[@]}   # 获取数组的长度
1
$ echo ${#value[*]}   # 获取数组的长度
1

(7) ${value#pattern}  ${value##pattern}

二者都是去掉 value 中与 pattern 相匹配的部分,条件是 value 的开头与 pattern 相匹配

#与 ## 的区别在于:

前者是最短匹配模式,删除第一个匹配符左侧的内容

后者是最长匹配模式,删除 最末个匹配府左侧的内容

示例:

$ value="mimvp.com mimvp.cn"
$ pattern="mimvp
$ 
$ echo $value
mimvp.com mimvp.cn

$ echo $pattern
mimvp
$ 
$ echo ${value#*.}    # 从左侧第一个匹配, 删除左侧内容
com mimvp.cn
$ echo ${value##*.}   # 从左侧最末个匹配, 删除左侧内容
cn
$
$ echo ${value%.*}    # 从右侧第一个匹配, 删除右侧内容
mimvp.com mimvp
$ echo ${value%%.*}   # 从右侧最末个匹配, 删除右侧内容
mimvp

用法详解,请见米扑博客:Shell 提取文件路径中的文件名、后缀、目录

(8) ${value%pattern}  ${value%%pattern}

与 (7) 用法类似,只是是从 value 的尾部与 pattern 相匹配,% 与 %% 的区别与 #与## 一样

(9) ${value/pattern/string}   ${value//pattern/string}

进行变量内容的替换,把与 pattern 匹配的部分替换为 string 的内容,

/ 与 // 的区别: / 只匹配第一个并替换; // 匹配所有的并全部替换

示例:

$ value="mimvp.com mimvp.cn"
$ pattern="mimvp"
$
$ echo $value
mimvp.com mimvp.cn
$ echo $pattern
mimvp
$
$ echo ${value/m/*}     # / 只匹配第一个并替换
*imvp.com mimvp.cn
$
$ echo ${value//m/*}    # // 匹配所有的并全部替换
*i*vp.co* *i*vp.cn


小结

上述字符串的条件变量替换中,除 (2) 外,其余均不影响变量本身的值

逻辑运算符 -a -o

#!/bin/bash

var1="1"
var2="2"

下面是 “” 运算符 -a,另外注意,用一个 test 命令就可以了,还有 if 条件后面的分号

if test $var1 = "1"-a $var2 = "2" ; then
   echo "equal"
fi

兼容性更好的用法格式:

if [ c1 ] && [ c2 ]; then
…
fi

实例应用(算术比较,非字符串比较):

#if [ -n "$1" -a "$1" -eq "1" ]; then       ### 报错 
if [ -n "$1" ] && [ "$1" -eq "1" ]; then   ### 正确
    is_force_run_server=$1
fi
#if [ -n "$2" -a "$2" -eq "1" ]; then       ### 报错 
if [ -n "$2" ] && [ "$2" -eq "1" ]; then   ### 正确
    is_force_kill_firefox=$2
fi

下面是 “” 运算符 -o,有一个为真就可以

if test $var1 != "1" -o $var2 != "3" ; then
   echo "not equal"
fi

兼容性更好的用法格式:

if [ c1 ] || [  c2 ]; then
…
fi

实例应用:

a=0
b=1
if [ $a = 1 ] || [ $b = 1 ]; then
	echo "good"
fi

test 多逻辑判断的完整示例:

#!/bin/bash

var1="1"
var2="2"
var3="3"

if test $var1 = "1" -o $var2 = "2"; then
    echo "equal"
else
    echo "no equal"
fi

if test $var1 = "1" -o $var2 = $var3; then
    echo "no equal"
fi

运行结果:

equal

no equal

“非” 运算符 !

if 条件是为真的时候执行,如果使用!运算符,那么原表达式必须为 false

if ! test $var1 != "1"; then
   echo "not 1"
fi

以上三个 if 都为真,所以三个 echo 都会打印

示例:

#!/bin/sh

aa="August 15, 2012"
bb="August 15, 20122"
cc="123"
dd="123"

# -o
if [ "$aa" = "$bb" -o "$cc" = "$dd" ]; then
	echo "yes"
else
	echo "no"
fi

# -a and !
if [ "$aa" != "$bb" -a "$cc" = "$dd" ]; then
	echo "yes"
else
	echo "no"
fi

运行结果:

true

Shell 字符串比较、判断是否为数字

二元比较操作符,比较字符串或者比较数字,注意数字与字符串的区别.

1、 整数比较

-eq       等于,如: if ["$a" -eq "$b"]

-ne       不等于,如: if ["$a" -ne "$b"]

-gt       大于,如: if ["$a" -gt "$b"]

-ge       大于等于,如: if ["$a" -ge "$b"]

-lt       小于,如: if ["$a" -lt "$b"]

-le       小于等于,如: if ["$a" -le "$b"]

<小于 (需要双括号),如: (("$a" < "$b"))

<=       小于等于 (需要双括号),如: (("$a" <= "$b"))

大于 (需要双括号),如: (("$a" > "$b"))

=       大于等于 (需要双括号),如: (("$a" >= "$b"))

小数据比较可使用 AWK,借助 bc 计算浮点数值。

整数比较实例

#!/bin/bash


file='folder_url_top24/url_usa_top24_0'
fileSize=`ls -l folder_url_top24/url_usa_top24_0 | awk -F '[" "]' '{print $5}'`
FILESIZE=1000
#while [ ! -f $file -o "$fileSize" -lt "$FILESIZE" ]
#while [ ! -f $file -o "$fileSize" -lt 1000 ]
while (("$fileSize" < 1000)) 
do
    echo "down again..."
done

其中,下面三种整数比较都成立:

1) while [! -f $file -o "$fileSize" -lt "$FILESIZE"]

2) while [! -f $file -o "$fileSize" -lt 1000]

3) (("$fileSize" < 1000))

推荐使用第一种

2、 浮点数比较

shell(bash) 本身没有小数、浮点数计算,但可以借助 bc 命令(高精度的计算器工具)实现浮点数计算,也可以利用 awk 进行浮点数计算

bc – An arbitrary precision calculator language

例如,我们要计算 linux 服务器的负载情况,获取 5 分钟平均负载情况,大于 5 则杀死一些进程

1)top 查看负载

top -b | head -n1

top - 13:14:54 up 47 days, 18:40,  1 user,  load average: 1.32, 0.81, 0.05

2) awk 获取 5 分钟平均负载

top -b | head -n1 | awk '{print $12}' | cut -d ',' -f1

1.32

解释命令:

a) top -b 获取文本格式,否则会报错  shell illegal character: ^[

b)awk '{print $12}'  获取第 12 个字段(起始下标为 1),即 5 分钟平均负载值

c) cut -d ',' -f1   分割 5 分钟平均负载值(1.32,)注意:第 12 个字段有一个逗号

3)bc 计算浮点数

常量示例:

if [ `echo "1.1 > 1" | bc` -eq 1 ];then
    echo "OK"
fi

变量示例:

load_average_num=`top -b | head -n1 | awk '{print $12}' | cut -d ',' -f1`
load_average_MaxNUM=5
if [ $(echo "$load_average_num > $load_average_MaxNUM"|bc) -eq 1 ]; then
    echo "kill python..." >> $log
    ps -ef | grep -v grep | grep 'python' | awk '{print $2}' | xargs kill -9
    ps -ef | grep -v grep | grep 'main.py' | awk '{print $2}' | xargs kill -9
fi

实际应用的完整示例:

######  monitor load average  by  mimvp.com  ######
load_average_num=`top -b | head -n1 | awk '{print $12}' | cut -d ',' -f1`
load_average_MaxNUM=5
echo "load_average_num: $load_average_num"
echo "load_average_num: $load_average_num" >> $log

#while [ `echo "1.1 > 1" | bc` -eq 1 ]; do
#while [ `echo "$load_average_num > $load_average_MaxNUM" | bc` -eq 1 ]; do
while [ $(echo "$load_average_num > $load_average_MaxNUM"|bc) -eq 1 ]; do
    echo "load_average_num: $load_average_num > load_average_MaxNUM: $load_average_MaxNUM" >> $log
    echo "kill python, firefox..." >> $log

    ps -ef | grep -v grep | grep 'python' | awk '{print $2}' | xargs kill -9
    ps -ef | grep -v grep | grep 'main.py' | awk '{print $2}' | xargs kill -9
    ps -ef | grep -v grep | grep 'firefox' | awk '{print $2}' | xargs kill -9
    ps -ef | grep -v grep | grep 'Xvfb' | awk '{print $2}' | xargs kill -9
    sleep 10

    load_average_num=`top -b | head -n1 | awk '{print $12}' | cut -d ',' -f1`
    echo "restart load_average_num: $load_average_num" >> $log
done

3、 字符串比较

=       等于,如: if ["$a" = "$b"]

==     等于,如: if ["$a" == "$b"] ,与 = 等价

注意:== 的功能在 [[]] 和 [] 中的行为是不同的,如下:

1 [[$a == z*]]    # 如果 $a 以 "z" 开头 (模式匹配) 那么将为 true

2 [[$a == "z*"]] # 如果 $a 等于 z*(字符匹配),那么结果为 true

3

4 [$a == z*]      # File globbing 和 word splitting 将会发生

5 ["$a" == "z*"] # 如果 $a 等于 z*(字符匹配), 那么结果为 true

一点解释,关于 File globbing 是一种关于文件的速记法,比如 "*.c" 就是,再如~ 也是.

但是 file globbing 并不是严格的正则表达式, 虽然绝大多数情况下结构比较像.

!=  不等于,如: if ["$a" != "$b"]

这个操作符将在 [[]] 结构中使用模式匹配.

< 小于

在 ASCII 字母顺序下,如:

if [[ "$a" < "$b" ]]

if [ "$a" \< "$b" ]

注意:在 [] 结构中 "<" 需要被转义,推荐使用双中括号 [[]]

> 大于

在 ASCII 字母顺序下. 如:

if [[ "$a" > "$b" ]]

if [ "$a" \> "$b" ]

注意:在 [] 结构中 ">" 需要被转义,推荐使用双中括号 [[ ]]

应用例子

-z  字符串为 "null",就是长度为 0

-n  字符串不为 "null",长度不为 0(实际是大于 0)

判断 shell 传入的参数个数是否为空:

#!/bin/bash

port=6379		# 命令行没参数,默认指定端口号为 6379
if [ $# -ge 1 ]; then	# 命令行参数个数大于等于1,则使用传入的参数port
	port=$1		# 获取指定端口号
fi
	
echo "redis port: $port"
redis-cli -h 172.1628.10.114 -p $port

字符串比较实例:

if [ "$var1" = "$var2" ]

代码:

#!/bin/sh

aa="August 15, 2012"
bb="August 15, 2012"

if [ "$aa" = "$bb" ]; then
	echo "yes"
else
	echo "no"
fi

判断子字符串包含关系: =~

代码:

a1="ithomer"
a2="ithomer.net"
a3="blog.ithomer.net"

if [[ "$a3" =~ "$a1" ]]; then
         echo "$a1是$a3的子串!"
else
         echo "$a1不是$a3的子串!"
fi

if [[ "$a3" =~ "$a2" ]];then
         echo "$a2是$a3的子串!"
else
         echo "$a2不是$a3的子串!"
fi

注意:

使用 - n 在 [] 结构中测试必须要用 "" 把变量引起来.

使用一个未被 ""的字符串来使用! -z 或者就是未用"" 引用的字符串本身,放到 [] 结构中。

虽然一般情况下可以工作,但这是不安全的。习惯于使用 "" 来测试字符串是一种好习惯.

awk '{print $2}' class.txt | grep '^[0-9.]' > res

Shell 中 if 做比较

1、shell 判断数组中是否包含某个元素

ary=(1 2 3)
a=2
if [[ "${ary[@]}" =~ "$a" ]] ; then
    echo "a in ary"
else
    echo "a not in ary"
fi

2、判读字符串 ($str) 是否包含另一个字符串($str1)

方法 1:

if [  `echo $str | grep -e '$str1'`  ] ; then
    echo yes
fi

方法 2:

如果 $str1 在判断中直接使用字符串而不是变量,则不能加引号,如 if [[$str =~ ^dx]] 判读字符串 $str 是否以 dx 开头,^dx 不能加引号:

if [[ $str =~ $str1 ]] ; then
    echo yes
fi

3、比较两个字符串是否相等的办法是:

if ["$test"x = "test"x]; then

这里的关键有几点:

1)使用单个等号

2)注意到等号两边各有一个空格:这是 unix shell 的要求

3)注意到 "$test"x 最后的 x,这是特意安排的,因为当 $test 为空的时候,上面的表达式就变成了 x = testx,显然是不相等的。而如果没有这个 x,表达式就会报错:[: =: unary operator expected

if 判断式

if [条件判断一] && (||) [ 条件判断二 ]; then

elif [条件判断三] && (||) [ 条件判断四 ]; then

else

执行第三段內容程式

fi

示例 1:

flag=0
webip=''
retry_NUM=3
retry_idx=0

while [ "$flag" -gt "0" -a "$retry_idx" -lt "$retry_NUM" ] || [ -z "$webip" -a "$retry_idx" -lt "$retry_NUM" ]
do
    retry_idx=`expr $retry_idx + 1`
    sleep $retry_idx

    echo "flag: $flag , webip: $webip , retry_NUM: $retry_NUM , retry_idx: $retry_idx  "
done

运行结果:

flag: 0 , webip:  , retry_NUM: 3 , retry_idx: 1 
flag: 0 , webip:  , retry_NUM: 3 , retry_idx: 2 
flag: 0 , webip:  , retry_NUM: 3 , retry_idx: 3

示例 2:

# a=0
# b=0
# c=5         
# if [ $a = 0 -a $b = 0 ]&&[ $c != 0 ]; then
> echo success
> fi
success

Linux Shell if 判断写成一行

示例:

[[ $? -eq 0 ]] && echo "backup $i success" || exit

判断上一个命令是否执行正确,退出状态码若为 0,则执行 echo

否则,会认为 [[$? -eq 0]] && echo "backup $i success" 这一段执行错误,不会执行 echo,会退出

Linux Shell 脚步获取当前的函数名

在 C/C++ 中,__FUNCTION__常量记录当前函数的名称。有时候,在日志输出的时候包含这些信息是非常有用的。

在 Bash 中,同样有这样一个常量 FUNCNAME,但是有一点区别是,它是一个数组而非字符串,其中数组的第一个元素为当前函数的名称。

为什么 FUNCNAME 要是一个数组呢?看看下面的例子,你就明白了。

示例代码:

#!/bin/bash

function test_func()
{
    echo "Current $FUNCNAME, \$FUNCNAME => (${FUNCNAME[@]})"
    another_func
    echo "Current $FUNCNAME, \$FUNCNAME => (${FUNCNAME[@]})"
}

function another_func()
{
    echo "Current $FUNCNAME, \$FUNCNAME => (${FUNCNAME[@]})"
}

echo "Out of function, \$FUNCNAME => (${FUNCNAME[@]})"
test_func
echo "Out of function, \$FUNCNAME => (${FUNCNAME[@]})"

运行结果:

Out of function, $FUNCNAME => ()
Current test_func, $FUNCNAME => (test_func main)
Current another_func, $FUNCNAME => (another_func test_func main)
Current test_func, $FUNCNAME => (test_func main)
Out of function, $FUNCNAME => ()

所以,更加准确地说,FUNCNAME 是一个数组,但是 bash 中会将它维护成类似一个堆栈的形式。

if 使用的表达式

[-a 文件] 如果文件存在为真。

[-b 文件] 如果 文件 存在 而且 是一个 块 - 特殊 文件为真。

[-c 文件] 为真 如果 文件 存在 而且 是一个 字 - 特殊 文件。

[-d 文件] 为真 如果 文件 存在 而且 是一个 目录。

[-e 文件] 为真 如果 文件 存在。

[-f 文件] 为真 如果 文件 存在 而且 是一个 普通 文件。

[-g 文件] 为真 如果 文件 存在 而且 已经设置了他的 SGID 位。

[-h 文件] 为真 如果 文件 存在 而且 是一个 符号连接。

[-k 文件] 为真 如果 文件 存在 而且 他的粘住位已经设置。

[-p 文件] 为真 如果 文件 存在 而且 是一个 已经命名的管道 (F 如果 O)。

[-r 文件] 为真 如果 文件 存在 而且 是可读的。

[-s 文件] 为真 如果 文件 存在 而且 比零字节大。

[-t FD] 为真 如果 文件 文件描述符已经打开 而且 指向一个终端。

[-u 文件] 为真 如果 文件 存在 而且 已经设置了他的 SUID (set user ID) 位。

[-w 文件] 为真 如果 文件 为真 如果 文件 存在 而且 是可写的。

[-x 文件] 为真 如果 文件 存在 而且 是可执行的。

[-O 文件] 为真 如果 文件 存在 而且 属于有效用户 ID。

[-G 文件] 为真 如果 文件 存在 而且 属于有效组 ID。

[-L 文件] 为真 如果 文件 存在 而且 是一个 符号连接。

[-N 文件] 为真 如果 文件 存在 而且 has been mod 如果 ied since it was last read。

[-S 文件] 为真 如果 文件 存在 而且 是一个 socket。

[文件 1 -nt 文件 2] 为真 如果 文件 1 has been changed more recently than 文件 2, or 如果文件 1 存在 而且文件 2 does not

[文件 1 -ot 文件 2] 为真 如果 文件 1 比 文件 2 旧, 或者 文件 2 存在而且 文件 1 不存在。

[文件 1 -ef 文件 2] 为真 如果 文件 1 而且 文件 2 refer to the same device 而且 inode numbers。

[-o 选项名] 为真 如果 shell 选项 "选项名" 开启。

[-z STRING] 为真 如果 "STRING" 的长度是零。

[-n STRING] 或者 [ STRING ] 为真 "STRING" 的长度是非零值。

[STRING1 == STRING2] 如果两个字符串相等为真。 "=" may be used instead of "==" for strict POSIX compliance。

[STRING1 != STRING2] 为真 如果 两两个字符串不相等。

[STRING1 < STRING2] 为真 如果 "STRING1" sorts before "STRING2" lexicographically in the current locale。

[STRING1> STRING2 ] 为真 如果 "STRING1" sorts after "STRING2" lexicographically in the current locale。

[ARG1 OP ARG2]

"OP" 是 -eq, -ne, -lt, -le, -gt or -ge 其中一个。 These arithmetic binary operators return 为真 如果 "ARG1" is equal to, not equal to, less than, less than or equal to, greater than, or greater than or equal to "ARG2", respectively。 "ARG1" 而且 "ARG2" are integers。

表达式可以借以下操作符组合起来, listed in decreasing order of precedence:

操作符效果

[! EXPR] 如果 EXPR 为假则为真。

[( EXPR) ] 返回 EXPR 的值。 这样可以用来忽略正常的操作符优先级。

[表达式 1 -a 表达式 2] 如果表达式 1 而且表达式 2 同时为真则为真 。

[表达式 1 -o 表达式 2] 如果表达式 1 或者表达式 2 其中之一为真则为真。

shell 中变量间接引用:

假设 a=b,b=123, 如何通过 a 获得 123 呢,通过变量间接引用可以做到:eval a=$$b (bash 版本 2 中 a=${!b} 也可以做到)

Linux Shell 中 \w \s \d \b ^ $ 等常用匹配用法

正则表达式 \w \s \d \b 用法:

. 匹配除换行符以外的任意字符 
\w 匹配字母或数字或下划线 
\s 匹配任意的空白符 
\d 匹配数字,等价于 [0-9]
\D 匹配非数字字符
\b 匹配单词的开始或结束 
^ 匹配字符串的开始 
$ 匹配字符串的结束

其中,[^A-Z] 表示除了不包含大写字母,^ 取反;[1] 表示以大写字母开头

示例:

grep -P "^test\s" /etc/ppp/chap-secrets

只匹配 test 开头且其后为空白的字符串行,不匹配 test2 , test_3 这样的字符串行

例如:

grep -P "^test\s+" /etc/ppp/chap-secrets

test        *       Test201205      *     此行匹配
test2       *       Test201205      *    不匹配
test3       *       Test201205      *    不匹配

Repressed:20210530
转载自 :米扑博客 blog.mimvp.com


  1. A-Z ↩︎

comments powered by Disqus