如何在 Bash 中将变量设置为命令的输出？

$(sudo run command)

---

如果你要使用撇号，你需要 ，而不是 。这个字符被称为“backticks”（或“严重口音”）：`'

#!/bin/bash

VAR1="$1"
VAR2="$2"

MOREF=`sudo run command against "$VAR1" | grep name | cut -c7-`

echo "$MOREF"

除了反引号之外，命令替换还可以用 or 来完成，我发现它更容易阅读，并且允许嵌套。`command`$(command)"$(command)"

OUTPUT=$(ls -1)
echo "${OUTPUT}"

MULTILINE=$(ls \
   -1)
echo "${MULTILINE}"

引号 （） 对于保留多行变量值很重要;它在作业的右侧是可选的，因为不执行单词拆分，所以可以正常工作。"OUTPUT=$(ls -1)

只是为了与众不同：

MOREF=$(sudo run command against $VAR1 | grep name | cut -c7-)

正如他们已经向您指出的那样，您应该使用“反引号”。

建议的替代方案也有效，并且也更容易阅读，但请注意，它仅适用于 Bash 或 KornShell（以及从中派生的 shell）， 因此，如果你的脚本必须在各种 Unix 系统上真正可移植，你应该更喜欢旧的反引号表示法。$(command)

我知道有三种方法可以做到这一点：

1. 功能适用于此类任务：**

   func (){
       ls -l
   }
   

   通过说 来调用它。func

2. 另一个合适的解决方案可能是 evalu：

   var="ls -l"
   eval $var
   

3. 第三种是直接使用变量：

   var=$(ls -l)
   
       OR
   
   var=`ls -l`
   

你可以以一种很好的方式获得第三个解决方案的输出：

echo "$var"

而且以一种令人讨厌的方式：

echo $var

这是另一种方式，非常适合与一些文本编辑器一起使用，这些编辑器无法正确突出显示您创建的每个复杂代码：

read -r -d '' str < <(cat somefile.txt)
echo "${#str}"
echo "$str"

如果你想用多行/多命令来做，那么你可以这样做：

output=$( bash <<EOF
# Multiline/multiple command/s
EOF
)

艺术

output=$(
# Multiline/multiple command/s
)

例：

#!/bin/bash
output="$( bash <<EOF
echo first
echo second
echo third
EOF
)"
echo "$output"

输出：

first
second
third

使用 heredoc，您可以通过将长单行代码分解为多行代码来简化事情。另一个例子：

output="$( ssh -p $port $user@$domain <<EOF
# Breakdown your long ssh command into multiline here.
EOF
)"

有些人可能会觉得这很有用。 变量替换中的整数值，其中诀窍是使用双括号：$(())

N=3
M=3
COUNT=$N-1
ARR[0]=3
ARR[1]=2
ARR[2]=4
ARR[3]=1

while (( COUNT < ${#ARR[@]} ))
do
  ARR[$COUNT]=$((ARR[COUNT]*M))
  (( COUNT=$COUNT+$N ))
done

您可以使用反引号（也称为重音坟墓）或 .$()

喜欢：

OUTPUT=$(x+2);
OUTPUT=`x+2`;

两者具有相同的效果。但是 OUTPUT=$（x+2） 更具可读性，并且是最新的。

这里还有两种方法：

请记住，空间在 Bash 中非常重要。因此，如果您希望您的命令运行，请按原样使用，不要再引入任何空格。

1. 以下内容分配给它，然后打印它harshilL

   L=$"harshil"
   echo "$L"
   

2. 下面将命令的输出分配给 L2。 正在对另一个变量 L1 进行操作。trtr

   L2=$(echo "$L1" | tr [:upper:] [:lower:])
   

编辑 2023：添加特殊字符和......mapfile

我用来从命令设置变量的一些 Bash 技巧

对不起，有一个圆滚滚的答案。但是由于 bash 是一个 shell，其主要目标是运行其他 unix 命令并对结果代码和/或输出做出反应（命令通常是管道过滤器等），将命令输出存储在变量中是基本和基本的东西。

因此，取决于

• 兼容性 （POSIX)
• 输出类型（过滤器）
• 要设置的变量数（拆分或解释）
• 执行时间（监控）
• 错误捕获
• 请求的可重复性（详见长时间运行的后台进程）
• 交互性（在从另一个输入文件描述符读取时考虑用户输入）)
• 特殊字符的处理。（2023 年新品）
• 我错过了什么吗？

您可以查看函数 - 一个复杂的示例，解析用于构建的输出：1 个用于解析 SUBJECT 字段的关联数组，1 个用于解析替代名称和将日期存储到 UNIXEPOCH 的标准数组。（使用单个 fork 命令将两个日期转换在一起） - 在如何从 PEM 证书确定 SSL 证书到期日期？showCertopenssldate

第一种简单、陈旧（过时）且兼容的方式

myPi=`echo '4*a(1)' | bc -l`
echo $myPi 
3.14159265358979323844

兼容，第二种方式

由于嵌套可能会变得很重，因此为此实施了括号

myPi=$(bc -l <<<'4*a(1)')

今天要避免在脚本中使用反引号。

嵌套示例：

SysStarted=$(date -d "$(ps ho lstart 1)" +%s)
echo $SysStarted 
1480656334

Bash 功能

读取多个变量（使用 Bashisms)

df -k /
Filesystem     1K-blocks   Used Available Use% Mounted on
/dev/dm-0         999320 529020    401488  57% /

如果我只想要一个已使用的值：

array=($(df -k /))

你可以看到一个数组变量：

declare -p array

declare -a array='([0]="Filesystem" [1]="1K-blocks" [2]="Used" [3]="Available" [
4]="Use%" [5]="Mounted" [6]="on" [7]="/dev/dm-0" [8]="999320" [9]="529020" [10]=
"401488" [11]="57%" [12]="/")'

然后：

echo ${array[9]}
529020

但我经常用这个：

{ read -r _;read -r filesystem size using avail prct mountpoint ; } < <(df -k /)
echo $using
529020

（第一个只会删除标题行。在这里，只需一个命令，您将填充 6 个不同的变量（按字母顺序显示）：read _

declare -p avail filesystem mountpoint prct size using

declare -- avail="401488"
declare -- filesystem="/dev/dm-0"
declare -- mountpoint="/"
declare -- prct="57%"
declare -- size="999320"
declare -- using="529020"

或

{ read -a head;varnames=(${head[@]//[K1% -]});varnames=(${head[@]//[K1% -]});
  read ${varnames[@],,} ; } < <(LANG=C df -k /)

然后：

declare -p varnames ${varnames[@],,} 

declare -a varnames=([0]="Filesystem" [1]="blocks" [2]="Used" [3]="Available" [4]="Use" [5]="Mounted" [6]="on")
declare -- filesystem="/dev/dm-0"
declare -- blocks="999320"
declare -- used="529020"
declare -- available="401488"
declare -- use="57%"
declare -- mounted="/"
declare -- on=""

甚至：

{ read _ ; read filesystem dsk[{6,2,9}] prct mountpoint ; } < <(df -k /)
declare -p mountpoint dsk

declare -- mountpoint="/"
declare -a dsk=([2]="529020" [6]="999320" [9]="401488")

（注意并在那里切换：UsedBlocksread ... dsk[6] dsk[2] dsk[9] ...)

...也可以与关联数组一起使用：read _ disk[total] disk[used] ...

其他相关示例：解析输出：和 Firefox 选项卡的末尾，大小为 x% 的显示大小？ 或 AskUbuntu.com 解析 xrandr 输出xrandr

使用未命名 fifo 的专用 fd：

有一种优雅的方式！在此示例中，我将读取文件：/etc/passwd

users=()
while IFS=: read -u $list user pass uid gid name home bin ;do
    ((uid>=500)) &&
        printf -v users[uid] "%11d %7d %-20s %s\n" $uid $gid $user $home
done {list}</etc/passwd

使用这种方式 （） 使 STDIN 免费用于其他目的，例如用户交互。... read -u $list; ... {list}<inputfile

然后

echo -n "${users[@]}"
       1000    1000 user         /home/user
...
      65534   65534 nobody       /nonexistent

和

echo ${!users[@]}
1000 ... 65534

echo -n "${users[1000]}"
      1000    1000 user       /home/user

这可以用于静态文件，甚至可以用于 for ip 地址或主机名以及端口号或命令的输出：/dev/tcp/xx.xx.xx.xx/yyyxy

{
    read -u $list -a head          # read header in array `head`
    varnames=(${head[@]//[K1% -]}) # drop illegal chars for variable names
    while read -u $list ${varnames[@],,} ;do
        ((pct=available*100/(available+used),pct<10)) &&
            printf "WARN: FS: %-20s on %-14s %3d <10 (Total: %11u, Use: %7s)\n" \
                "${filesystem#*/mapper/}" "$mounted" $pct $blocks "$use"
     done
 } {list}< <(LANG=C df -k)

当然，对于内联文档：

while IFS=\; read -u $list -a myvar ;do
    echo ${myvar[2]}
done {list}<<"eof"
foo;bar;baz
alice;bob;charlie
$cherry;$strawberry;$memberberries
eof

特殊字符的处理

一个常见的问题是正确处理文件名（用于示例） 特殊字符，如古拉丁语编码与较差的 UTF8 混合（包含换行符或制表的文件名）。

为此，可以使用命令来分隔由 null 字节0x00找到的文件名。find-print0

若要使用 bash 正确处理此输出，可以：

while IFS='' read -r -d '' filename; do
    size=$(stat -c %s "$filename")
    printf ' %13d %q\n' $size "$filename"
done < <(
  find . \( -type f -o -type d \) -print0
) 

使用mapfile

对于少量的条目，您可以使用（或他的系统名称：）来创建一个数组，在之前 处理他的元素：mapfilereadarray

mapfile -t -d '' entries < <( find . \( -type f -o -type d \) -print0)
for entry in "${entries[@]}";do
    size=$(stat -c %s "$entry")
    printf ' %13d %q\n' $size "$entry"
done

这可以用于拆分以 null 分隔的特殊条目，例如 file：procfsenviron

mapfile -d '' env_$$ </proc/$$/environ
declare -p ${!env_*}

解析 CSV 文件的实用示例：

由于这个答案已经足够了，对于这一段， 我只是让你参考这个答案 如何在 Bash 中解析 CSV 文件？，我使用未命名的 fifo 读取文件，使用如下语法：

exec {FD}<"$file"   # open unnamed fifo for read
IFS=',' read -ru $FD -a headline
while IFS=',' read -ru $FD -a row ;do ...

...但是使用 bash 可加载的 CSV 模块。看看在 bash 下使用可加载模块解析 CSV 文件

在我的网站上，您可能会找到相同的脚本，将 CSV 作为内联文档读取。

用于填充某些变量的示例函数：

#!/bin/bash

declare free=0 total=0 used=0 mpnt='??'

getDiskStat() {
    {
        read _
        read _ total used free _ mpnt
    } < <(
        df -k ${1:-/}
    )
}

getDiskStat $1
echo "$mpnt: Tot:$total, used: $used, free: $free."

注意：行不是必需的，只是为了可读性。declare

大约sudo cmd | grep ... | cut ...

shell=$(cat /etc/passwd | grep $USER | cut -d : -f 7)
echo $shell
/bin/bash

（请避免无用！所以这只是少了一个分叉：cat

shell=$(grep $USER </etc/passwd | cut -d : -f 7)

所有管道 （） 都意味着分叉。必须运行另一个进程、访问磁盘、库调用等。|

因此，使用 for sample 会将子进程限制为只有一个 fork：sed

shell=$(sed </etc/passwd "s/^$USER:.*://p;d")
echo $shell

和 Bashisms：

但是对于许多操作，主要是在小文件上，Bash 可以自己完成这项工作：

while IFS=: read -a line ; do
    [ "$line" = "$USER" ] && shell=${line[6]}
  done </etc/passwd
echo $shell
/bin/bash

或

while IFS=: read loginname encpass uid gid fullname home shell;do
    [ "$loginname" = "$USER" ] && break
  done </etc/passwd
echo $shell $loginname ...

进一步讨论变量拆分...

看看我的答案 如何在 Bash 中拆分分隔符上的字符串？

替代方法：使用后台长时间运行的任务来减少分叉

为了防止多个分叉，比如

myPi=$(bc -l <<<'4*a(1)'
myRay=12
myCirc=$(bc -l <<<" 2 * $myPi * $myRay ")

或者要获得系统启动时间和当前 shell 启动时间，两者都作为 UNIX EPOCH，我可以做两个嵌套的分叉：

myStarted=$(date -d "$(ps ho lstart 1)" +%s)
mySessStart=$(date -d "$(ps ho lstart $$)" +%s)

这工作正常，但运行许多分叉又重又慢。

并且命令喜欢并且可以逐行进行许多操作！datebc

看：

bc -l <<<$'3*4\n5*6'
12
30

date -f - +%s < <(ps ho lstart 1 $$)
1516030449
1517853288

因此，构建我的两个变量：并且可以在一个操作中完成：$myStarted$mySessStart

{
    read -r myStarted
    read -r mySessStart
} < <(
    date -f - +%s < <(
        ps ho lstart 1 $$
    )
)

可以写在一行上：

{ read -r myStarted;read -r mySessStart;}< <(date -f- +%s< <(ps ho lstart 1 $$))

后台任务

但是，我们可以使用长时间运行的后台进程来发出任意数量的请求，而不必为每个请求启动新的分支。

你可以看看减少叉子是如何使曼德布洛特猛烈抨击的，从八个多小时提高到不到五个秒。

在 bash 下，有一个内置函数：coproc

coproc bc -l
echo 4*3 >&${COPROC[1]}
read -u $COPROC answer
echo $answer
12

echo >&${COPROC[1]} 'pi=4*a(1)'
ray=42.0
printf >&${COPROC[1]} '2*pi*%s\n' $ray
read -u $COPROC answer
echo $answer
263.89378290154263202896

printf >&${COPROC[1]} 'pi*%s^2\n' $ray
read -u $COPROC answer
echo $answer
5541.76944093239527260816

准备就绪，在后台运行，I/O 也已准备就绪，没有延迟，无需加载、打开、关闭、操作前或操作后。只有操作自己！这比每次操作都必须分叉要快得多！bcbc

小小的额外：（小而强大！在保持运行的同时，他们将持有他所有的寄存器。因此，变量或函数可以在初始化步骤中定义，就像在启动任务后第一次写入 一样（...甚至在任何时候）。bc${COPROC[1]}

变成函数newConnector

您可以在 GitHub.Com 或我自己的网站上找到我的函数（GitHub 上的注意：我的网站上有两个文件。函数和演示捆绑到一个唯一的文件中，该文件可以用于使用，也可以仅用于演示。newConnector

样本：

source shell_connector.sh

tty
/dev/pts/20

ps --tty pts/20 fw
    PID TTY      STAT   TIME COMMAND
  29019 pts/20   Ss     0:00 bash
  30745 pts/20   R+     0:00  \_ ps --tty pts/20 fw

newConnector /usr/bin/bc "-l" '3*4' 12

ps --tty pts/20 fw
    PID TTY      STAT   TIME COMMAND
  29019 pts/20   Ss     0:00 bash
  30944 pts/20   S      0:00  \_ /usr/bin/bc -l
  30952 pts/20   R+     0:00  \_ ps --tty pts/20 fw

declare -p PI
bash: declare: PI: not found

myBc '4*a(1)' PI
declare -p PI
declare -- PI="3.14159265358979323844"

该函数允许您使用语法简单的后台任务。myBc

然后是日期：

newConnector /bin/date '-f - +%s' @0 0
myDate '2000-01-01'
  946681200
myDate "$(ps ho lstart 1)" boottime
myDate now now
read utm idl </proc/uptime
myBc "$now-$boottime" uptime
printf "%s\n" ${utm%%.*} $uptime
  42134906
  42134906

ps --tty pts/20 fw
    PID TTY      STAT   TIME COMMAND
  29019 pts/20   Ss     0:00 bash
  30944 pts/20   S      0:00  \_ /usr/bin/bc -l
  32615 pts/20   S      0:00  \_ /bin/date -f - +%s
   3162 pts/20   R+     0:00  \_ ps --tty pts/20 fw

从那里，如果你想结束一个后台进程，你只需要关闭它的 fd：

eval "exec $DATEOUT>&-"
eval "exec $DATEIN>&-"
ps --tty pts/20 fw
    PID TTY      STAT   TIME COMMAND
   4936 pts/20   Ss     0:00 bash
   5256 pts/20   S      0:00  \_ /usr/bin/bc -l
   6358 pts/20   R+     0:00  \_ ps --tty pts/20 fw

这不是必需的，因为所有 FD 在主进程完成时都会关闭。

设置变量时，请确保符号前后没有空格。我真的花了一个小时试图弄清楚这一点，尝试了各种解决方案！这并不酷。=

正确：

WTFF=`echo "stuff"`
echo "Example: $WTFF"

将失败，出现错误“stuff： not found”或类似错误

WTFF= `echo "stuff"`
echo "Example: $WTFF"

您需要使用

$(command-here)

或

`command-here`

例

#!/bin/bash

VAR1="$1"
VAR2="$2"

MOREF="$(sudo run command against "$VAR1" | grep name | cut -c7-)"

echo "$MOREF"

如果尝试执行的命令失败，它会将输出写入错误流，然后打印到控制台。

为了避免这种情况，您必须重定向错误流：

result=$(ls -l something_that_does_not_exist 2>&1)

Mac/OSX 现在带有旧的 Bash 版本，即 .在这种情况下，可以使用：GNU bash, version 3.2.57(1)-release (arm64-apple-darwin21)

new_variable="$(some_command)"

一个具体的例子：

newvar="$(echo $var | tr -d '123')"

请注意 ，而不是 Bash 4 中通常的 。(){}

如果您使用 ： 对于您通过管道有多个命令并且需要它们的结果和退出状态的情况，还有另一个很好的解决方案。从以下示例中应该可以清楚地看出：bash

# This saves all the results into the RES variable
grep -E "\S" "file.txt" | sort | uniq | read -d '' RES
# 'read' exit status 1 means all input was read till EOF, we're OK with that
if (( PIPESTATUS[0] > 1 || PIPESTATUS[1] > 0 || PIPESTATUS[2] > 0 || PIPESTATUS[3] > 1 )); then
  echo "ERROR"
else
  echo "$RES"
fi

为了让它起作用，你需要启用（仅适用于AFAIK！），另外，如果你在交互式会话中，你需要通过禁用作业控制（默认情况下在脚本中不需要）。shopt -s lastpipebashset +m

有关更多详细信息，请参阅另一个线程中的这篇文章。