Linuxshell学习笔记（5）

变量修饰词

感谢Zsh 开发指南（第八篇 变量修饰语） - 知乎 (zhihu.com)对我学习过程中的帮助！！！

        格式

${(x)var}
${var:x}

其中 var 是变量名，x 是 一个或多个字母，不同字母的功能不同。第二行的冒号也可能是其他符号。${var} 和 $var 基本相同，大括号用于避免变量名中的字符和后边的字符粘连，通常情况是不需要加大括号的。但如果使用变量修饰语，大括号就必不可少。 

        常见使用场景

大小写 

转成大写，(U) 和 :u 两种用法效果一样；转成小写，(L) 和 :l 两种用法效果一样。

查找方向

（i）：从左到右，若没找到则放回长度+1；

（I）：从右到左，若没找到返回0。

去重

（u）:去除数组中相同的元素 

分隔

（f）：将字符串以换行符分隔成数组

 反转效果

（M）：反转后面执行语句的效果

排序

（o）：升序  （O）：降序   （n）：按数字大小排序   （i）：忽略大小写

嵌套使用 

变量修饰语可以嵌套使用。因为加了修饰语的变量依然是变量，可以和正常的变量一样处理。

% str=abc
% echo ${(U)str}
ABC
% echo ${(C)${(U)str}}
Abc

% echo ${${a:u}:l}
abc

# 可以简化成
% echo ${a:u:l}
abc

# 可以两种风格嵌套在一起
% echo ${(C)${a:u}}
Abc

这里要注意 $ 之后全程不能有空格，否则会有语法错误。也就是说不能通过加空格来避免因为字符挤在一起造成的可读性变差。但熟悉了格式后，就可以比较容易识别出代码的功能。比较复杂的逻辑可以换行继续写，而没必要一定嵌套使用。

变量默认值

和变量默认值（读取变量时如果变量为空或者不存在，使用的默认值）相关的操作，变量可以是任何类型的。

% var=123

# 如果变量有值，就输出变量值
% echo ${var:-abc}
123

# 如果变量没有值（变量不存在，为空字符串、空数组、空哈希表等），输出 abc
% echo ${varr:-abc}
abc


% var=""
# 和 :- 类似，但只有变量不存在时才替换成默认值
% echo ${var-abc}
% echo ${varr-abc}
abc


% var=""
# 和 :- 类似，但如果变量没有值，则赋值为 abc
% echo ${var:=abc}
abc
% echo $var
abc


% var=abc
# 不管 var 有没有值，都赋值为 123
% echo ${var::=123}
123
% echo $var
123


% var=""
# 如果 var 没有值，直接报错
% echo ${var:?error}
zsh: var: error


% var=abc
# 如果 var 有值，输出 123
% echo ${var:+123}
123
% echo ${varr:+123}

记：(以下str都指自己设定的字符串，即所谓的默认值）

        1.var:-str   如果变量var有值，就输出变量值，反之输出str；

        2.var-str    只有变量var不存在时才替换成默认值str；

        3.var:=str  如果变量var没有值，则赋默认值str；

        4.var::=str 不管 变量var 有没有值，都赋默认值str；

        5.var:?str   如果 var 没有值，直接报错；

        6.var:+str   如果 var 有值，输出默认值str；

数组拼接成字符串

% array=(aa bb cc dd)

# 用换行符拼接
% echo ${(F)array}
aa
bb
cc
dd

# 用空格拼接
% str=$array
% echo $str
aa bb cc dd

# 使用其他字符或字符串拼接
% echo ${(j:-=:)array}
aa-=bb-=cc-=dd

记：（F）  用换行符拼接 

字符串切分成数组

% str=a##b##c##d

% array=(${(s:##:)str})
% print -l $array
a
b
c
d

输出变量类型 （t）

# 注意如果不加 integer 或者 float，都为字符串，但计算时会自动转换类型
% integer i=1
% float f=1.2
% str=abc
% array=(a b c)
% local -A table=(k1 v1 k2 v2)

% echo ${(t)i} ${(t)f} ${(t)str} ${(t)array} ${(t)table}
integer float scalar array association

 

字符串、数组或哈希表嵌套取值

可以嵌套多层。

% str=abcde
% echo ${${str[3,5]}[3]}
e

% array=(aa bb cc dd)
% echo ${${array[2,3]}[2]}
cc
# 如果只剩一个元素了，就取字符串的字符
% echo ${${array[2]}[2]}
b

% local -A table=(k1 v1 k2 v2 k3 v3)
% echo ${${table[k1]}[2]}
1

字符串内容作为变量名再取值 （P）

不需要再通过繁琐的 eval 来做这个。

% var=abc
% abc=123

% echo ${(P)var}
123

对齐或截断数组中的字符串

% array=(abc bcde cdefg defghi)

# 只取每个字符串的最后两个字符，第一个是小写l，不是1
% echo ${(l:2:)array}
bc de fg hi

# 用空格补全字符串并且右对齐
% print -l ${(l:7:)array}
    abc
   bcde
  cdefg
 defghi

# 用指定字符补全
% print -l ${(l:7::0:)array}
0000abc
000bcde
00cdefg
0defghi

# 用指定字符补全，第二个字符只用一次
% print -l ${(l:7::0::1:)array}
0001abc
001bcde
01cdefg
1defghi

# 左对齐
% print -l ${(r:7::0::1:)array}
abc1000
bcde100
cdefg10
defghi1

记： （l:n:）str   第一个为小写的L，中间的n是你想要的截断or对齐的字符数，str为你操作的字符串对象，对齐的方向为左对齐；

        （r:n:） str        对齐方向为右对齐。

函数与脚本

Zsh 中函数和脚本基本上一样的，可以认为脚本就是以文件名为函数名的函数。脚本和函数的编写方法基本相同。

函数定义

# 一个很简单的函数
func() {
    echo right
}

# 也可以在前边加一个 function 关键字
function func() {
    echo right
}

这样就可以定义一个函数了。小括号一定是空的，即使函数有参数，也无需在里边写参数列表。

直接输入函数名即可调用函数。

func() {
    echo right
}

% func
right

用 unfunction 可以删除函数。

func() {
    echo right
}

% unfunction fun
% fun
zsh: command not found: fun

参数处理

函数可以有参数，但 zsh 中无需显式注明有几个参数，直接读取即可。

fun() {
    echo $1 $2 $3
    echo $#
}

% fun aa
aa
1
% fun aa bb cc
aa bb cc
3
% fun aa bb cc dd
aa bb cc
4

$n 是第 n 个参数，$# 是参数个数。如果读取的时候没有对应参数传进来，那和读取一个未定义的变量效果是一样的。函数的参数只能是字符串类型，如果把整数、浮点数传进函数里，也会被转成字符串。可以把数组传给函数，然后数组中的元素会依次成为各个参数。

fun() {
    echo $1 $2 $3
    echo $#
}

% array=(aa bb cc)
% fun $array
aa bb cc
3

这样用的好处是可以更方便地处理带空格的参数。

# 遍历所有参数，$* 是包含所有参数的数组
fun() {
    for i ($*) {
        echo $i
    }
}

% fun a b c
a
b
c

$* 是包含所有参数的数组； 

可以用 $+n 快速判断第 n 个参数是否存在。

fun() {
    (($+1)) && {
        echo $1
    }
}

关于 $* 和 $@。在 bash 中， $* 和 $@ 的区别是一个比较麻烦的事情，但在 zsh 中，通常没有必要使用 $@，所以不用踩这个坑。Bash 中需要使用 $@ 的原因是如果使用 $* 并且参数中有空格的话，就分不清哪些空格是参数里的，哪些空格是参数之间的间隔符（bash 里的 $* 是一个字符串）。而如果使用 "$*" 的话，所有的参数都合并成一个字符串了。而 "$@" 可以保留参数中的空格，所以通常使用 "$@"。但是有些时候需要把所有参数拼接成一个字符串，那么又要使用 "$*"，所以很混乱。

而 zsh 中的 $* 会包括参数中的空格（zsh 里的 $* 是一个数组），所以效果和 bash 的 "$@" 是差不多的。另外在 zsh 中用 "$*" 和在 bash 中的 "$*" 效果一样，所以只用 $* 和 "$*" 就足够了。

函数嵌套

函数可以嵌套定义。

fun() {
    fun2() {
        echo $2
    }

    fun2 $1 $2
}

% fun aa bb
bb

fun2 函数是在 fun 执行过才会被定义的，但最外边也能直接访问 fun2 函数。如果想要最外边访问不了，可以在 fun 结束前调用 unfunction fun2 删除 fun2 函数。

 

返回值

函数需要返回一个代表函数是否正确执行的返回值，如果是 0，代表正确执行，如果不是 0，代表有错误。

#!/usr/bin/env zsh

fun() {
    (($+1)) && {
        return
    }

    return 1
}

% fun 111 && echo good
good
% fun || echo bad
bad

% fun
# 也可以用 $? 获取函数返回值
% echo $?

遇到 return 后，函数立即结束。return 即 return 0。

注意返回值不是用来返回数据的，如果函数需要将字符串、整数、浮点数等返回给调用者，直接用 echo 或者 print 等命令输出即可，然后调用者用 $(fun) 获取。如果需要返回数组或者哈希表，只能通过变量（全局变量或者函数所在层次的局部变量）传递。

fun() {
    echo 123.456
}

% echo $(($(fun) * 2))  # *后面有无空格无所谓
246.91200000000001

通过全局变量返回。

array=()
fun() {
    array=(aa bb)
}

% fun
% echo $array
aa bb

局部变量

在函数中可以直接读写函数外边的变量，并且在函数中定义的新变量在函数退出后依然存在。

str1=abcd

fun() {
    echo $str1
    str2=1234
}

% fun
abcd
% echo $str2
1234

这通常是不符合预期的。为了避免函数内的变量“渗透”到函数外，可以使用局部变量，使用 local 定义变量。

str1=abcd

fun() {
    echo $str1
    local str2=1234
}

% fun
abcd
% echo $str2

函数中的变量，除非确实需要留给外部使用，不然最好全部使用局部变量，避免引发 bug。

脚本

可以认为脚本也是一个函数，但它是单独写到一个文件里的。

 

test.zsh 内容。（标准格式）

#!/usr/bin/env zsh

echo good

这是一个非常简单的脚本文件。第一行是固定的，供系统找到 zsh 解释器，#! 后加 zsh 的绝对路径即可。如果需要使用环境变量访问，可以用 #!/bin/env zsh （或者 !/usr/bin/env zsh，如果 env 在 /usr/bin/ 里边）。

脚本的参数和返回值的处理方法，和函数的完全一样，这里就不举例了。

但函数和脚本中执行的时候是有区别的，函数是在当前的 zsh 进程里执行（也可以调用的时候加小括号在子进程执行），而脚本是在新的子进程里执行，执行完子进程即退出了，所以脚本中的变量值外界是访问不到的，无需使用 local 定义（使用也没问题）。

exit 命令

脚本可以使用 return 返回，也可以使用 exit 命令。exit 命令用法和 return 差不多，如果不加参数则返回 0。但在代码的任何地方，调用 exit 命令即退出脚本，即使是在一个嵌套很深的函数里边理调用的。

用 getopts 命令处理命令行选项

有时我们写的脚本需要支持比较复杂的命令行选项，比如 demo -i aa -t bb -cx ccc ddd，这样的话，手动处理就会很麻烦。可以使用内置的 getopts 命令。

#!/usr/bin/env zsh

# i: 代表可以接受一个带参数的 -i 选项
# c 代表可以接受一个不带参数的 -c 选项
while {getopts i:t:cv arg} {
    case $arg {
        (i)+
        # $OPTARG 存放选项对应的参数
        echo $arg option with arg: $OPTARG
        ;;

        (t)
        echo $arg option with arg: $OPTARG
        ;;

        (c)
        echo $arg option
        ;;

        (v)
        echo version: 0.1
        ;;

        (?)
        echo error
        return 1
        ;;
    }
}

# $OPTIND 指向剩下的第一个未处理的参数
echo $*[$OPTIND,-1]

# 或者用 shift 把之前用过的参数移走
# shift $((OPTIND - 1))
# echo $*

运行结果：

% ./demo -i aaa -t bbb -cv ccc ddd
i option with arg: aaa
t option with arg: bbb
c option
version: 0.1
ccc ddd

# 可以只加部分选项
% ./demo -i aaa -v bbb ccc
i option with arg: aaa
version: 0.1
bbb ccc

# 可以一个选项也不加
% ./demo aaa bbb
aaa bbb

# 如果选项不带参数，多个选项可以合并到一个 - 后
% ./demo -i aaa -cv bbb ccc
i option with arg: aaa
c option
version: 0.1
bbb ccc

# 如果该带参数的选项不带参数，会报错
% ./demo -i aaa -t
i option with arg: aaa
./demo:3: argument expected after -t option
error

# 加了不支持的选项也会报错
% ./demo -i aaa -a bbb ccc
i option with arg: aaa
./demo:3: bad option: -a
error

# 如果该带参数的选项不带参数，然后后边紧接着另一个选项，那么选项会被当作参数
% ./demo -i -c aaa bbb
i option with arg: -c
aaa bbb

getopts 的使用还是很方便的，但它不支持长选项（如 --log aaa）。如果需要使用长选项，可以用 getopt 命令，它是一个外部命令。