标签 Bash 下的文章

here 文档 here document (LCTT 译注:here 文档又称作 heredoc )不是什么特殊的东西,只是一种 I/O 重定向方式,它告诉 bash shell 从当前源读取输入,直到读取到只有分隔符的行。

redirect output of here document to a text file

这对于向 ftp、cat、echo、ssh 和许多其他有用的 Linux/Unix 命令提供指令很有用。 此功能适用于 bash 也适用于 Bourne、Korn、POSIX 这三种 shell。

here 文档语法

语法是:

command <<EOF
cmd1
cmd2 arg1
EOF

或者允许 shell 脚本中的 here 文档使用 EOF<<- 以自然的方式缩进:

command <<-EOF
  msg1
  msg2 
  $var on line 
EOF

或者

command <<'EOF'
 cmd1
 cmd2 arg1
 $var won't expand as parameter substitution turned off
 by single quoting
EOF

或者 重定向并将其覆盖 到名为 my_output_file.txt 的文件中:

command <<EOF > my_output_file.txt
 mesg1
 msg2
 msg3
 $var on $foo
EOF

重定向并将其追加到名为 my_output_file.txt 的文件中:

command <<EOF >> my_output_file.txt
 mesg1
 msg2
 msg3
 $var on $foo
EOF

示例

以下脚本将所需内容写入名为 /tmp/output.txt 的文件中:

#!/bin/bash
OUT=/tmp/output.txt

echo "Starting my script..."
echo "Doing something..."

cat <<EOF >$OUT
  Status of backup as on $(date)
  Backing up files $HOME and /etc/
EOF

echo "Starting backup using rsync..."

你可以使用cat命令查看/tmp/output.txt文件:

$ cat /tmp/output.txt

示例输出:

 Status of backup as on Thu Nov 16 17:00:21 IST 2017
 Backing up files /home/vivek and /etc/

禁用路径名/参数/变量扩展、命令替换、算术扩展

$HOME 这类变量和像 $(date) 这类命令在脚本中会被解释为替换。 要禁用它,请使用带有 'EOF' 这样带有单引号的形式,如下所示:

#!/bin/bash
OUT=/tmp/output.txt

echo "Starting my script..."
echo "Doing something..."
# No parameter and variable expansion, command substitution, arithmetic expansion, or pathname expansion is performed on word.  
# If any part of word is quoted, the delimiter  is  the  result  of  quote removal  on word, and the lines in the here-document 
# are not expanded. So EOF is quoted as follows
cat <<'EOF' >$OUT
  Status of backup as on $(date)
  Backing up files $HOME and /etc/
EOF

echo "Starting backup using rsync..."

你可以使用 cat 命令查看 /tmp/output.txt 文件:

$ cat /tmp/output.txt

示例输出:

 Status of backup as on $(date)
 Backing up files $HOME and /etc/

关于 tee 命令的使用

语法是:

tee /tmp/filename <<EOF >/dev/null
line 1
line 2
line 3
$(cmd)
$var on $foo
EOF

或者通过在单引号中引用 EOF 来禁用变量替换和命令替换:

tee /tmp/filename <<'EOF' >/dev/null
line 1
line 2
line 3
$(cmd)
$var on $foo
EOF

这是我更新的脚本:

#!/bin/bash
OUT=/tmp/output.txt

echo "Starting my script..."
echo "Doing something..."

tee $OUT <<EOF >/dev/null
  Status of backup as on $(date)
  Backing up files $HOME and /etc/
EOF

echo "Starting backup using rsync..."

关于内存 here 文档的使用

这是我更新的脚本:

#!/bin/bash
OUT=/tmp/output.txt

## in memory here docs 
## thanks https://twitter.com/freebsdfrau
exec 9<<EOF
  Status of backup as on $(date)
  Backing up files $HOME and /etc/
EOF

## continue
echo "Starting my script..."
echo "Doing something..."

## do it
cat <&9 >$OUT

echo "Starting backup using rsync..."

via: https://www.cyberciti.biz/faq/using-heredoc-rediection-in-bash-shell-script-to-write-to-file/

作者:Vivek Gite 译者:Flowsnow 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

对 Bash 长命令使用压缩的版本来更有效率。

你有多少次在命令行上输入一个长命令,并希望有一种方法可以保存它以供日后使用?这就是 Bash 别名派上用场的地方。它们允许你将长而神秘的命令压缩为易于记忆和使用的东西。需要一些例子来帮助你入门吗?没问题!

要使用你创建的 Bash 别名,你需要将其添加到 .bash_profile 中,该文件位于你的家目录中。请注意,此文件是隐藏的,并只能从命令行访问。编辑此文件的最简单方法是使用 Vi 或 Nano 之类的东西。

10 个方便的 Bash 别名

1、 你有几次遇到需要解压 .tar 文件但无法记住所需的确切参数?别名可以帮助你!只需将以下内容添加到 .bash_profile 中,然后使用 untar FileName 解压缩任何 .tar 文件。

alias untar='tar -zxvf '

2、 想要下载的东西,但如果出现问题可以恢复吗?

alias wget='wget -c '

3、 是否需要为新的网络帐户生成随机的 20 个字符的密码?没问题。

alias getpass="openssl rand -base64 20"

4、 下载文件并需要测试校验和?我们也可做到。

alias sha='shasum -a 256 '

5、 普通的 ping 将永远持续下去。我们不希望这样。相反,让我们将其限制在五个 ping

alias ping='ping -c 5'

6、 在任何你想要的文件夹中启动 Web 服务器。

alias www='python -m SimpleHTTPServer 8000'

7、 想知道你的网络有多快?只需下载 Speedtest-cli 并使用此别名即可。你可以使用 speedtest-cli --list 命令选择离你所在位置更近的服务器。

alias speed='speedtest-cli --server 2406 --simple'

8、 你有多少次需要知道你的外部 IP 地址,但是不知道如何获取?我也是。

alias ipe='curl ipinfo.io/ip'

9、 需要知道你的本地 IP 地址?

alias ipi='ipconfig getifaddr en0'

10、 最后,让我们清空屏幕。

alias c='clear'

如你所见,Bash 别名是一种在命令行上简化生活的超级简便方法。想了解更多信息?我建议你 Google 搜索“Bash 别名”或在 Github 中看下。


via: https://opensource.com/article/18/9/handy-bash-aliases

作者:Patrick H.Mullins 选题:lujun9972 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

函数是一段可复用的代码。我们通常把重复的代码放进函数中并且在不同的地方去调用它。库是函数的集合。我们可以在库中定义经常使用的函数,这样其它脚本便可以不再重复代码而使用这些函数。

本文我们将讨论诸多关于函数的内容和一些使用技巧。为了方便演示,我将在 Ubuntu 系统上使用 Bourne Again SHell (Bash)

调用函数

在 Shell 中调用函数和调用其它命令是一模一样的。例如,如果你的函数名称为 my_func,你可以在命令行中像下面这样执行它:

$ my_func

如果你的函数接收多个参数,那么可以像下面这样写(类似命令行参数的使用):

$ my_func arg1 arg2 arg3

定义函数

我们可以用下面的语法去定义一个函数:

function function_name {
    Body of function
}

函数的主体可以包含任何有效的命令、循环语句和其它函数或脚本。现在让我们创建一个简单的函数,它向屏幕上显示一些消息(注:直接在命令行里写)。

function print_msg {
    echo "Hello, World"
}

现在,让我们执行这个函数:

$ print_msg
Hello, World

不出所料,这个函数在屏幕上显示了一些消息。

在上面的例子中,我们直接在终端里创建了一个函数。这个函数也可以保存到文件中。如下面的例子所示。

#!/bin/bash
function print_msg {
    echo "Hello, World"
}
print_msg

我们已经在 function.sh 文件中定义了这个函数。现在让我们执行这个脚本:

$ chmod +x function.sh
$ ./function.sh
Hello, World

你可以看到,上面的输出和之前的是一模一样的。

更多函数用法

在上一小节中我们定义了一个非常简单的函数。然而在软件开发的过程中,我们需要更多高级的函数,它可以接收多个参数并且带有返回值。在这一小节中,我们将讨论这种函数。

向函数传递参数

我们可以像调用其它命令那样给函数提供参数。我们可以在函数里使用美元 $ 符号访问到这些参数。例如,$1 表示第一个参数,$2 代表第二个参数,以此类推。

让我们修改下之前的函数,让它以参数的形式接收信息。修改后的函数就像这样:

function print_msg {
    echo "Hello $1"
}

在上面的函数中我们使用 $1 符号访问第一个参数。让我们执行这个函数:

$ print_msg "LinuxTechi"

执行完后,生成如下信息:

Hello LinuxTechi

从函数中返回数值

跟其它编程语言一样,Bash 提供了返回语句让我们可以向调用者返回一些数值。让我们举例说明:

function func_return_value {
    return 10
}

上面的函数向调用者返回 10。让我们执行这个函数:

$ func_return_value
$ echo "Value returned by function is: $?"

当你执行完,将会产生如下的输出结果:

Value returned by function is: 10

提示:在 Bash 中使用 $? 去获取函数的返回值。

函数技巧

目前我们已经对 Bash 中的函数有了一些了解。现在让我们创建一些非常有用的 Bash 函数,它们可以让我们的生活变得更加轻松。

Logger

让我们创建一个 logger 函数,它可以输出带有日期和时间的 log 信息。

function log_msg {
    echo "[`date '+ %F %T'` ]: $@"
}

执行这个函数:

$ log_msg "This is sample log message"

执行完,就会生成如下信息:

[ 2018-08-16 19:56:34 ]: This is sample log message

显示系统信息

让我们创建一个显示 GNU/Linux 信息的函数

function system_info {
    echo "### OS information ###"
    lsb_release -a

    echo
    echo "### Processor information ###"
    processor=`grep -wc "processor" /proc/cpuinfo`
    model=`grep -w "model name" /proc/cpuinfo  | awk -F: '{print $2}'`
    echo "Processor = $processor"
    echo "Model     = $model"

    echo
    echo "### Memory information ###"
    total=`grep -w "MemTotal" /proc/meminfo | awk '{print $2}'`
    free=`grep -w "MemFree" /proc/meminfo | awk '{print $2}'`
    echo "Total memory: $total kB"
    echo "Free memory : $free kB"
}

执行完后会生成以下信息:

### OS information ###
No LSB modules are available.
Distributor ID:           Ubuntu
Description:   Ubuntu 18.04.1 LTS
Release:         18.04
Codename:    bionic

### Processor information ###
Processor = 1
Model     =  Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz

### Memory information ###
Total memory: 4015648 kB
Free memory : 2915428 kB

在当前目录下查找文件或者目录

下面的函数从当前目录下查找文件或者目录:

function search {
    find . -name $1
}

让我们使用下面的命令查找 dir4 这个目录:

$ search dir4

当你执行完命令后,将会产生如下输出:

./dir1/dir2/dir3/dir4

数字时钟

下面的函数在终端里创建了一个简单的数字时钟:

function digital_clock {
    clear
    while [ 1 ]
    do
        date +'%T'
        sleep 1
        clear
    done
}

函数库

库是函数的集合。将函数定义在文件里并在当前环境中导入那个文件,这样可以创建函数库。

假设我们已经在 utils.sh 中定义好了所有函数,接着在当前的环境下使用下面的命令导入函数:

$ source utils.sh

之后你就可以像调用其它 Bash 命令那样执行库中任何的函数了。

总结

本文我们讨论了诸多可以提升效率的实用技巧。我希望这篇文章能够启发你去创造自己的技巧。


via: https://www.linuxtechi.com/define-use-functions-linux-shell-script/

作者:Pradeep Kumar 选题:lujun9972 译者:LuuMing 校对:pityonline

本文由 LCTT 原创编译,Linux中国 荣誉推出

使 Bash 工作的更好的技巧。

每个行业都有一个该行业的大师们最常使用的工具。 对于许多系统管理员来说,这个工具就是他们的 shell。 在大多数 Linux 和其他类 Unix 系统上,默认的 shell 是 Bash。

Bash 是一个相当古老的程序——它起源于 20 世纪 80 年代后期——但它建立在更多更老的 shell 上,比如 C shell(csh),csh 至少是它 10 年前的前辈了。 因为 shell 的概念是那么古老,所以有大量的神秘知识等待着系统管理员去吸收领悟,使其生活更轻松。

我们来看看一些基础知识。

在某些时候,谁曾经无意中以 root 身份运行命令并导致某种问题? 举手

我很确定我们很多人一度都是那个人。 这很痛苦。 这里有一些非常简单的技巧可以防止你再次碰上这类问题。

使用别名

首先,为 mvrm 等命令设置别名,指向 mv -irm -i。 这将确保在运行 rm -f /boot 时至少需要你确认。 在 Red Hat 企业版 Linux 中,如果你使用 root 帐户,则默认设置这些别名。

如果你还要为普通用户帐户设置这些别名,只需将这两行放入家目录下名为 .bashrc 的文件中(这些也适用于 sudo ):

alias mv='mv -i'
alias rm='rm -i'

让你的 root 提示符脱颖而出

你可以采取的防止意外发生的另一项措施是确保你很清楚在使用 root 帐户。 在日常工作中,我通常会让 root 提示符从日常使用的提示符中脱颖而出。

如果将以下内容放入 root 的家目录中的 .bashrc 文件中,你将看到一个黑色背景上的红色的 root 提示符,清楚地表明你(或其他任何人)应该谨慎行事。

export PS1="\[$(tput bold)$(tput setab 0)$(tput setaf 1)\]\u@\h:\w # \[$(tput sgr0)\]"

实际上,你应该尽可能避免以 root 用户身份登录,而是通过 sudo 运行大多数系统管理命令,但这是另一回事。

使用了一些小技巧用于防止使用 root 帐户时的“不小心的副作用”之后,让我们看看 Bash 可以帮助你在日常工作中做的一些好事。

控制你的历史

你可能知道在 Bash 中你按向上的箭头时能看见和重新使用你之前所有(好吧,大多数)的命令。这是因为这些命令已经保存到了你家目录下的名为 .bash_history 的文件中。这个历史文件附带了一组有用的设置和命令。

首先,你可以通过键入 history 来查看整个最近的命令历史记录,或者你可以通过键入 history 30 将其限制为最近 30 个命令。不过这技巧太平淡无奇了(LCTT 译注: vanilla 原为香草,后引申没拓展的、标准、普通的,比如 vanilla C++ compiler 意为标准 C++ 编译器)。 你可以更好地控制 Bash 保存的内容以及保存方式。

例如,如果将以下内容添加到 .bashrc,那么任何以空格开头的命令都不会保存到历史记录列表中:

HISTCONTROL=ignorespace

如果你需要以明文形式将密码传递给一个命令,这就非常有用。 (是的,这太可怕了,但它仍然会发生。)

如果你不希望经常执行的命令充斥在历史记录中,请使用:

HISTCONTROL=ignorespace:erasedups

这样,每次使用一个命令时,都会从历史记录文件中删除之前出现的所有相同命令,并且只将最后一次调用保存到历史记录列表中。

我特别喜欢的历史记录设置是 HISTTIMEFORMAT 设置。 这将在历史记录文件中在所有的条目前面添加上时间戳。 例如,我使用:

HISTTIMEFORMAT="%F %T  "

当我输入 history 5 时,我得到了很好的完整信息,如下所示:

1009  2018-06-11 22:34:38  cat /etc/hosts
1010  2018-06-11 22:34:40  echo $foo
1011  2018-06-11 22:34:42  echo $bar
1012  2018-06-11 22:34:44  ssh myhost
1013  2018-06-11 22:34:55  vim .bashrc

这使我更容易浏览我的命令历史记录并找到我两天前用来建立到我家实验室的 SSH 连接(我一次又一次地忘记......)。

Bash 最佳实践

我将在编写 Bash 脚本时最好的(或者至少是好的,我不要求无所不知)11 项实践列出来。

11、 Bash 脚本可能变得复杂,不过注释也很方便。 如果你在考虑是否要添加注释,那就添加一个注释。 如果你在周末之后回来并且不得不花时间搞清楚你上周五想要做什么,那你是忘了添加注释。

10、 用花括号括起所有变量名,比如 ${myvariable}。 养成这个习惯可以使用 ${variable}_suffix 这种用法了,还能提高整个脚本的一致性。

9、 计算表达式时不要使用反引号;请改用 $() 语法。 所以使用:

for  file in $(ls); do

而不使用:

for  file in `ls`; do

前一个方式是可嵌套的,更易于阅读的,还能让一般的系统管理员群体感到满意。 不要使用反引号。

8、 一致性是好的。 选择一种风格并在整个脚本中坚持下去。 显然,我喜欢人们选择 $() 语法而不是反引号,并将其变量包在花括号中。 我更喜欢人们使用两个或四个空格而不是制表符来缩进,但即使你选择了错误的方式,也要一贯地错下去。

7、 为 Bash 脚本使用适当的 释伴 shebang (LCTT 译注:Shebang,也称为 Hashbang ,是一个由井号和叹号构成的字符序列 #! ,其出现在文本文件的第一行的前两个字符。 在文件中存在释伴的情况下,类 Unix 操作系统的程序载入器会分析释伴后的内容,将这些内容作为解释器指令,并调用该指令,并将载有释伴的文件路径作为该解释器的参数)。 因为我正在编写Bash脚本,只打算用 Bash 执行它们,所以我经常使用 #!/usr/bin/bash 作为我的释伴。 不要使用 #!/bin/sh#!/usr/bin/sh。 你的脚本会被执行,但它会以兼容模式运行——可能会产生许多意外的副作用。 (当然,除非你想要兼容模式。)

6、 比较字符串时,在 if 语句中给变量加上引号是个好主意,因为如果你的变量是空的,Bash 会为这样的行抛出一个错误:

if [ ${myvar} == "foo" ]; then
  echo "bar"
fi

对于这样的行,将判定为 false

if [ "${myvar}" == "foo" ]; then
  echo "bar"
fi

此外,如果你不确定变量的内容(例如,在解析用户输入时),请给变量加引号以防止解释某些特殊字符,并确保该变量被视为单个单词,即使它包含空格。

5、 我想这是一个品味问题,但我更喜欢使用双等号( == ),即使是比较 Bash 中的字符串。 这是一致性的问题,尽管对于字符串比较,只有一个等号会起作用,我的思维立即变为“单个 = 是一个赋值运算符!”

4、 使用适当的退出代码。 确保如果你的脚本无法执行某些操作,则会向用户显示已写好的失败消息(最好提供解决问题的方法)并发送非零退出代码:

# we have failed
echo "Process has failed to complete, you need to manually restart the whatchamacallit"
exit 1

这样可以更容易地以编程方式从另一个脚本调用你的脚本并验证其成功完成。

3、 使用 Bash 的内置机制为变量提供合理的默认值,或者如果未定义你希望定义的变量,则抛出错误:

# this sets the value of $myvar to redhat, and prints 'redhat'
echo ${myvar:=redhat}
# this throws an error reading 'The variable myvar is undefined, dear reader' if $myvar is undefined
${myvar:?The variable myvar is undefined, dear reader}

2、 特别是如果你正在编写大型脚本,或者是如果你与其他人一起开发该大型脚本,请考虑在函数内部定义变量时使用 local 关键字。 local 关键字将创建一个局部变量,该变量只在该函数中可见。 这限制了变量冲突的可能性。

1、 每个系统管理员有时必须这样做:在控制台上调试一些东西,可能是数据中心的真实服务器,也可能是虚拟化平台的虚拟服务器。 如果你必须以这种方式调试脚本,你会感谢你自己记住了这个:不要让你的脚本中的行太长!

在许多系统上,控制台的默认宽度仍为 80 个字符。 如果你需要在控制台上调试脚本并且该脚本有很长的行,那么你将成为一个悲伤的熊猫。 此外,具有较短行的脚本—— 默认值仍为 80 个字符——在普通编辑器中也更容易阅读和理解!

我真的很喜欢 Bash。 我可以花几个小时写这篇文章或与其他爱好者交流优秀的技巧。 就希望你们能在评论中留下赞美。


via: https://opensource.com/article/18/7/admin-guide-bash

作者:Maxim Burgerhout 选题:lujun9972 译者:Flowsnow 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

进入这个古怪而神奇的 Bash 数组的世界。

尽管软件工程师常常使用命令行来进行各种开发,但命令行中的数组似乎总是一个模糊的东西(虽然不像正则操作符 =~ 那么复杂隐晦)。除开隐晦和有疑问的语法,Bash 数组其实是非常有用的。

稍等,这是为什么?

写 Bash 相关的东西很难,但如果是写一篇像手册那样注重怪异语法的文章,就会非常简单。不过请放心,这篇文章的目的就是让你不用去读该死的使用手册。

真实(通常是有用的)示例

为了这个目的,想象一下真实世界的场景以及 Bash 是怎么帮忙的:你正在公司里面主导一个新工作,评估并优化内部数据管线的运行时间。首先,你要做个参数扫描分析来评估管线使用线程的状况。简单起见,我们把这个管道当作一个编译好的 C++ 黑盒子,这里面我们能够调整的唯一的参数是用于处理数据的线程数量:./pipeline --threads 4

基础

我们首先要做的事是定义一个数组,用来容纳我们想要测试的 --threads 参数:

allThreads=(1 2 4 8 16 32 64 128)

本例中,所有元素都是数字,但参数并不一定是数字,Bash 中的数组可以容纳数字和字符串,比如 myArray=(1 2 "three" 4 "five") 就是个有效的表达式。就像 Bash 中其它的变量一样,确保赋值符号两边没有空格。否则 Bash 将会把变量名当作程序来执行,把 = 当作程序的第一个参数。

现在我们初始化了数组,让我们解析它其中的一些元素。仅仅输入 echo $allThreads ,你能发现,它只会输出第一个元素。

要理解这个产生的原因,需要回到上一步,回顾我们一般是怎么在 Bash 中输出变量。考虑以下场景:

type="article"
echo "Found 42 $type"

假如我们得到的变量 $type 是一个单词,我们想要添加在句子结尾一个 s。我们无法直接把 s 加到 $type 里面,因为这会把它变成另一个变量,$types。尽管我们可以利用像 echo "Found 42 "$type"s" 这样的代码形变,但解决这个问题的最好方法是用一个花括号:echo "Found 42 ${type}s",这让我们能够告诉 Bash 变量名的起止位置(有趣的是,JavaScript/ES6 在 template literals 中注入变量和表达式的语法和这里是一样的)

事实上,尽管 Bash 变量一般不用花括号,但在数组中需要用到花括号。这反而允许我们指定要访问的索引,例如 echo ${allThreads[1]} 返回的是数组中的第二个元素。如果不写花括号,比如 echo $allThreads[1],会导致 Bash 把 [1] 当作字符串然后输出。

是的,Bash 数组的语法很怪,但是至少他们是从 0 开始索引的,不像有些语言(说的就是你,R 语言)。

遍历数组

上面的例子中我们直接用整数作为数组的索引,我们现在考虑两种其他情况:第一,如果想要数组中的第 $i 个元素,这里 $i 是一个代表索引的变量,我们可以这样 echo ${allThreads[$i]} 解析这个元素。第二,要输出一个数组的所有元素,我们把数字索引换成 @ 符号(你可以把 @ 当作表示 all 的符号):echo ${allThreads[@]}

遍历数组元素

记住上面讲过的,我们遍历 $allThreads 数组,把每个值当作 --threads 参数启动管线:

for t in ${allThreads[@]}; do
  ./pipeline --threads $t
done

遍历数组索引

接下来,考虑一个稍稍不同的方法。不遍历所有的数组元素,我们可以遍历所有的索引:

for i in ${!allThreads[@]}; do
  ./pipeline --threads ${allThreads[$i]}
done

一步一步看:如之前所见,${allThreads[@]} 表示数组中的所有元素。前面加了个感叹号,变成 ${!allThreads[@]},这会返回数组索引列表(这里是 0 到 7)。换句话说。for 循环就遍历所有的索引 $i 并从 $allThreads 中读取第 $i 个元素,当作 --threads 选项的参数。

这看上去很辣眼睛,你可能奇怪为什么我要一开始就讲这个。这是因为有时候在循环中需要同时获得索引和对应的值,例如,如果你想要忽视数组中的第一个元素,使用索引可以避免额外创建在循环中累加的变量。

填充数组

到目前为止,我们已经能够用给定的 --threads 选项启动管线了。现在假设按秒计时的运行时间输出到管线。我们想要捕捉每个迭代的输出,然后把它保存在另一个数组中,因此我们最终可以随心所欲的操作它。

一些有用的语法

在深入代码前,我们要多介绍一些语法。首先,我们要能解析 Bash 命令的输出。用这个语法可以做到:output=$( ./my_script.sh ),这会把命令的输出存储到变量 $output 中。

我们需要的第二个语法是如何把我们刚刚解析的值添加到数组中。完成这个任务的语法看起来很熟悉:

myArray+=( "newElement1" "newElement2" )

参数扫描

万事具备,执行参数扫描的脚步如下:

allThreads=(1 2 4 8 16 32 64 128)
allRuntimes=()
for t in ${allThreads[@]}; do
  runtime=$(./pipeline --threads $t)
  allRuntimes+=( $runtime )
done

就是这个了!

还有什么能做的?

这篇文章中,我们讲过使用数组进行参数扫描的场景。我敢保证有很多理由要使用 Bash 数组,这里就有两个例子:

日志警告

本场景中,把应用分成几个模块,每一个都有它自己的日志文件。我们可以编写一个 cron 任务脚本,当某个模块中出现问题标志时向特定的人发送邮件:

# 日志列表,发生问题时应该通知的人
logPaths=("api.log" "auth.log" "jenkins.log" "data.log")
logEmails=("jay@email" "emma@email" "jon@email" "sophia@email")

# 在每个日志中查找问题标志
for i in ${!logPaths[@]};
do
  log=${logPaths[$i]}
  stakeholder=${logEmails[$i]}
  numErrors=$( tail -n 100 "$log" | grep "ERROR" | wc -l )

  # 如果近期发现超过 5 个错误,就警告负责人
  if [[ "$numErrors" -gt 5 ]];
  then
    emailRecipient="$stakeholder"
    emailSubject="WARNING: ${log} showing unusual levels of errors"
    emailBody="${numErrors} errors found in log ${log}"
    echo "$emailBody" | mailx -s "$emailSubject" "$emailRecipient"
  fi
done

API 查询

如果你想要生成一些分析数据,分析你的 Medium 帖子中用户评论最多的。由于我们无法直接访问数据库,SQL 不在我们考虑范围,但我们可以用 API!

为了避免陷入关于 API 授权和令牌的冗长讨论,我们将会使用 JSONPlaceholder,这是一个面向公众的测试服务 API。一旦我们查询每个帖子,解析出每个评论者的邮箱,我们就可以把这些邮箱添加到我们的结果数组里:

endpoint="https://jsonplaceholder.typicode.com/comments"
allEmails=()

# 查询前 10 个帖子
for postId in {1..10};
do
  # 执行 API 调用,获取该帖子评论者的邮箱
  response=$(curl "${endpoint}?postId=${postId}")
  
  # 使用 jq 把 JSON 响应解析成数组
  allEmails+=( $( jq '.[].email' <<< "$response" ) )
done

注意这里我是用 jq 工具 从命令行里解析 JSON 数据。关于 jq 的语法超出了本文的范围,但我强烈建议你了解它。

你可能已经想到,使用 Bash 数组在数不胜数的场景中很有帮助,我希望这篇文章中的示例可以给你思维的启发。如果你从自己的工作中找到其它的例子想要分享出来,请在帖子下方评论。

请等等,还有很多东西!

由于我们在本文讲了很多数组语法,这里是关于我们讲到内容的总结,包含一些还没讲到的高级技巧:

语法效果
arr=()创建一个空数组
arr=(1 2 3)初始化数组
${arr[2]}取得第三个元素
${arr[@]}取得所有元素
${!arr[@]}取得数组索引
${#arr[@]}计算数组长度
arr[0]=3覆盖第 1 个元素
arr+=(4)添加值
str=$(ls)ls 输出保存到字符串
arr=( $(ls) )ls 输出的文件保存到数组里
${arr[@]:s:n}取得从索引 s 开始的 n 个元素

最后一点思考

正如我们所见,Bash 数组的语法很奇怪,但我希望这篇文章让你相信它们很有用。只要你理解了这些语法,你会发现以后会经常使用 Bash 数组。

Bash 还是 Python?

问题来了:什么时候该用 Bash 数组而不是其他的脚本语法,比如 Python?

对我而言,完全取决于需求——如果你可以只需要调用命令行工具就能立马解决问题,你也可以用 Bash。但有些时候,当你的脚本属于一个更大的 Python 项目时,你也可以用 Python。

比如,我们可以用 Python 来实现参数扫描,但我们只用编写一个 Bash 的包装:

import subprocess

all_threads = [1, 2, 4, 8, 16, 32, 64, 128]
all_runtimes = []

# 用不同的线程数字启动管线
for t in all_threads:
  cmd = './pipeline --threads {}'.format(t)

  # 使用子线程模块获得返回的输出
  p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)
  output = p.communicate()[0]
  all_runtimes.append(output)

由于本例中没法避免使用命令行,所以可以优先使用 Bash。

羞耻的宣传时间

如果你喜欢这篇文章,这里还有很多类似的文章! 在此注册,加入 OSCON,2018 年 7 月 17 号我会在这做一个主题为 你所不了解的 Bash 的在线编码研讨会。没有幻灯片,不需要门票,只有你和我在命令行里面敲代码,探索 Bash 中的奇妙世界。

本文章由 [Medium] 首发,再发布时已获得授权。


via: https://opensource.com/article/18/5/you-dont-know-bash-intro-bash-arrays

作者:Robert Aboukhalil 选题:lujun9972 译者:BriFuture 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

有个简单实用的技巧可以让你的 bash 脚本更稳健 -- 确保总是执行必要的收尾工作,哪怕是在发生异常的时候。要做到这一点,秘诀就是 bash 提供的一个叫做 EXIT 的伪信号,你可以 trap 它,当脚本因为任何原因退出时,相应的命令或函数就会执行。我们来看看它是如何工作的。

基本的代码结构看起来像这样:

#!/bin/bash
function finish {
  # 你的收尾代码
}
trap finish EXIT

你可以把任何你觉得务必要运行的代码放在这个 finish 函数里。一个很好的例子是:创建一个临时目录,事后再删除它。

#!/bin/bash
scratch=$(mktemp -d -t tmp.XXXXXXXXXX)
function finish {
  rm -rf "$scratch"
}
trap finish EXIT

这样,在你的核心代码中,你就可以在这个 $scratch 目录里下载、生成、操作中间或临时数据了。 注1

# 下载所有版本的 linux 内核…… 为了科学研究!
for major in {1..4}; do
  for minor in {0..99}; do
    for patchlevel in {0..99}; do
      tarball="linux-${major}-${minor}-${patchlevel}.tar.bz2"
      curl -q "http://kernel.org/path/to/$tarball" -o "$scratch/$tarball" || true
      if [ -f "$scratch/$tarball" ]; then
        tar jxf "$scratch/$tarball"
      fi
    done
  done
done
# 整合成单个文件
# 复制到目标位置
cp "$scratch/frankenstein-linux.tar.bz2" "$1"
# 脚本结束, scratch 目录自动被删除

比较一下如果不用 trap ,你是怎么删除 scratch 目录的:

#!/bin/bash
# 别这样做!

scratch=$(mktemp -d -t tmp.XXXXXXXXXX)

# 在这里插入你的几十上百行代码

# 都搞定了,退出之前把目录删除
rm -rf "$scratch"

这有什么问题么?很多:

  • 如果运行出错导致脚本提前退出, scratch 目录及里面的内容不会被删除。这会导致资料泄漏,可能引发安全问题。
  • 如果这个脚本的设计初衷就是在脚本末尾以前退出,那么你必须手动复制粘贴 rm 命令到每一个出口。
  • 这也给维护带来了麻烦。如果今后在脚本某处添加了一个 exit ,你很可能就忘了加上删除操作 -- 从而制造潜在的安全漏洞。

无论如何,服务要在线

另外一个场景: 想象一下你正在运行一些自动化系统运维任务,要临时关闭一项服务,最后这项服务需要重启,而且要万无一失,即使脚本运行出错。那么你可以这样做:

function finish {
    # 重启服务
    sudo /etc/init.d/something start
}
trap finish EXIT
sudo /etc/init.d/something stop
# 主要任务代码

# 脚本结束,执行 finish 函数重启服务

一个具体的实例:比如 Ubuntu 服务器上运行着 MongoDB ,你要为 crond 写一个脚本来临时关闭服务并做一些日常维护工作。你应该这样写:

function finish {
    # 重启服务
    sudo service mongdb start
}
trap finish EXIT
# 关闭 mongod 服务
sudo service mongdb stop
# (如果 mongod 配置了 fork ,比如 replica set ,你可能需要执行 “sudo killall --wait /usr/bin/mongod”)

控制开销

有一种情况特别能体现 EXIT trap 的价值:如果你的脚本运行过程中需要初始化一下成本高昂的资源,结束时要确保把它们释放掉。比如你在 AWS (Amazon Web Services) 上工作,要在脚本中创建一个镜像。

(名词解释: 在亚马逊云上的运行的服务器叫“实例”。实例从 亚马逊机器镜像 Amazon Machine Image 创建而来,通常被称为 “AMI” 或 “镜像” 。AMI 相当于某个特殊时间点的服务器快照。)

我们可以这样创建一个自定义的 AMI :

  1. 基于一个基准 AMI 运行一个实例(例如,启动一个服务器)。
  2. 在实例中手动或运行脚本来做一些修改。
  3. 用修改后的实例创建一个镜像。
  4. 如果不再需要这个实例,可以将其删除。

最后一步相当重要。如果你的脚本没有把实例删除掉,它会一直运行并计费。(到月底你的账单让你大跌眼镜时,恐怕哭都来不及了!)

如果把 AMI 的创建封装在脚本里,我们就可以利用 trap EXIT 来删除实例了。我们还可以用上 EC2 的命令行工具:

#!/bin/bash
# 定义基准 AMI 的 ID
ami=$1
# 保存临时实例的 ID
instance=''
# 作为 IT 人,让我们看看 scratch 目录的另类用法
scratch=$(mktemp -d -t tmp.XXXXXXXXXX)
function finish {
    if [ -n "$instance" ]; then
        ec2-terminate-instances "$instance"
    fi
    rm -rf "$scratch"
}
trap finish EXIT
# 创建实例,将输出(包含实例 ID )保存到 scratch 目录下的文件里
ec2-run-instances "$ami" > "$scratch/run-instance"
# 提取实例 ID
instance=$(grep '^INSTANCE' "$scratch/run-instance" | cut -f 2)

脚本执行到这里,实例(EC2 服务器)已经开始运行 注2 。接下来你可以做任何事情:在实例中安装软件,修改配置文件等,然后为最终版本创建一个镜像。实例会在脚本结束时被删除 -- 即使脚本因错误而提前退出。(请确保实例创建成功后再运行业务代码。)

更多应用

这篇文章只讲了些皮毛。我已经使用这个 bash 技巧很多年了,现在还能不时发现一些有趣的用法。你也可以把这个方法应用到你自己的场景中,从而提升你的 bash 脚本的可靠性。

尾注

  • 注1. mktemp 的选项 -t 在 Linux 上是可选的,在 OS X 上是必需的。带上此选项可以让你的脚本有更好的可移植性。
  • 注2. 如果只是为了获取实例 ID ,我们不用创建文件,直接写成 instance=$(ec2-run-instances "$ami" | grep '^INSTANCE' | cut -f 2) 就可以。但把输出写入文件可以记录更多有用信息,便于调试 ,代码可读性也更强。

作者简介:美国加利福尼亚旧金山的作家,软件工程师,企业家。Powerful Python 的作者,他的 blog


via: http://redsymbol.net/articles/bash-exit-traps/

作者:aaron maxwell 译者:Dotcra 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出