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

谁借莪１个温暖的怀抱￠ 2024-03-30 17:21 70阅读 0赞

## 问： ##

我有一个非常简单的脚本，类似于以下内容：

#!/bin/bash
    
    VAR1="$1"
    MOREF='sudo run command against $VAR1 | grep name | cut -c7-'
    
    echo $MOREF

当我从命令行运行这个脚本并将参数传递给它时，我没有得到任何输出。但是，当我运行 $MOREF 变量中包含的命令时，我可以获得输出。

如何获取需要在脚本中运行的命令的结果，将其保存到变量中，然后将该变量输出到屏幕上？

## 答1: ##

> huntsbot.com高效搞钱，一站式跟进超10+任务平台外包需求

除了反引号 `command`，command substitution 可以用  ( c o m m a n d ) 或 " (command) 或 " (command)或"(command)" 完成，我发现它们更易于阅读，并且允许嵌套。

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

引用 (") 对保留 多行变量值 很重要；它在分配的右侧是可选的，如 word splitting is not performed，因此 OUTPUT=$(ls -1) 可以正常工作。

`我们可以为多行输出提供一些分隔符吗？`

`空白（或缺少空白）很重要`

`@timhc22，花括号无关紧要；只有引号才是重要的：在传递给 echo 命令之前，扩展结果是否是字符串拆分和全局扩展的。`

`啊谢谢！那么花括号有什么好处吗？`

`当变量后面紧跟着更多可以解释为变量名一部分的字符时，可以使用花括号。 例如 ${OUTPUT}foo。在对变量执行内联字符串操作时也需要它们，例如 ${OUTPUT/foo/bar}`

## 答2: ##

> huntsbot.com洞察每一个产品背后的需求与收益，从而捕获灵感

$(sudo run command)

如果要使用撇号，则需要 \`，而不是 '。这个字符被称为“反引号”（或“重音”）：

#!/bin/bash
    
    VAR1="$1"
    VAR2="$2"
    
    MOREF=`sudo run command against "$VAR1" | grep name | cut -c7-`
    
    echo "$MOREF"

`反引号语法已过时，您确实需要在 echo 中的变量插值周围加上双引号。`

`我要补充一点，您必须小心上面作业中“=”周围的空格。你不应该有任何空格，否则你会得到一个不正确的分配`

```Tripleeeee 的评论是正确的。在 cygwin（2016 年 5 月）中，`` 不起作用，而 $() 起作用。在我看到这个页面之前无法修复。```

`诸如更新（2018）示例之类的详细说明将不胜感激。`

`最初的 Bourne shell 支持 backticks，但不支持 $(...) 表示法。因此，如果您需要与较旧的 Unix 系统兼容，则需要使用反引号。`

## 答3: ##

> huntsbot.com聚合了超过10+全球外包任务平台的外包需求，寻找外包任务与机会变的简单与高效。

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

抱歉，答案很冗长，但因为 bash 是 shell，其主要目标是运行其他 unix 命令并对 result code 和/或 输出做出反应，（命令通常是管道 filter 等…）。

将命令输出存储在变量中是基本的事情。

因此，取决于

兼容性（posix）

输出类型（过滤器）

要设置的变量数（拆分或解释）

执行时间（监控）

错误捕获

请求的可重复性（进一步参见长期运行的后台进程）

交互性（在从另一个输入文件描述符读取时考虑用户输入）

我想念什么吗？

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

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

重击功能

读取多个变量（使用 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

（第一个 read \_ 将只是 drop 标题行。）这里，在 only one 命令中，您将填充 6 个不同的 变量（显示为按字母顺序）：

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")

（注意 Used 和 Blocks 在此处切换：read … dsk\[6\] dsk\[2\] dsk\[9\] …）

… 也适用于 关联数组：read \_ disk\[total\] disk\[used\] …

使用未命名 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}... read -u $list; ... {
        list}<inputfile) 可以让 STDIN 自由用于其他目的，例如用户交互。
    
     然后
    
     
    
    ```java
    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

这可以与静态文件一起使用，甚至可以与 /dev/tcp/xx.xx.xx.xx/yyy 一起使用，x 用于 IP 地址或主机名，y 用于端口号或命令输出：

{
        
        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

解析CSV文件的实用示例：

在 this answer to How to parse a CSV file in Bash? 中，我使用 未命名的 fifo 读取文件，使用 exec \{FD\}<“$file” 语法。和here is the same script, but using CSV as inline document。

填充一些变量的示例函数：

#!/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 … |切 …

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

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

shell=$(grep $USER |) 都意味着分叉。必须运行另一个进程，访问磁盘，库调用等。
    
     因此，使用 sed 作为示例，会将子进程限制为只有一个 fork：
    
     
    
    ```java
    shell=$(sed How do I split a string on a delimiter in Bash?的回答
    
     替代方案：通过使用后台长时间运行的任务来减少分叉
    
     为了防止多次分叉，例如
    
     
    
    ```java
    myPi=$(bc -l <<<'4*a(1)'
    myRay=12
    myCirc=$(bc -l <<<" 2 * $myPi * $myRay ")

或者

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

这项工作很好，但是运行许多分叉既重又慢。

而像 date 和 bc 这样的命令可以进行许多操作，逐行！！

看：

bc -l <<<$'3*4\n5*6'
    12
    30
    
    date -f - +%s < <(ps ho lstart 1 $$)
    1516030449
    1517853288

所以我们可以使用一个长时间运行的后台进程来完成许多工作，而不必为每个请求启动一个新的分叉。

您可以看看减少分叉如何使 Mandelbrot bash 从超过 8 小时缩短到不到 5 秒。

在 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

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

边界效应：当 bc 保持运行时，它们将保存所有寄存器，因此可以在 初始化 步骤定义一些变量或函数，如在启动任务后首先写入 $\{COPROC\[1\]\}（通过coproc)。

进入一个函数 newConnector

您可以在 GitHub.Com 或 my own site 上找到我的 newConnector 函数（GitHub 上的注意事项：我的站点上有两个文件。函数和演示捆绑到一个独特的文件中，可以获取该文件以供使用或仅运行演示.)

样本：

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 fd：
    
     
    
    ```java
    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 都会在主进程完成时关闭。

`上面的嵌套示例是我正在寻找的。可能有一种更简单的方法，但我正在寻找的是一种方法来找出一个 docker 容器是否已经存在，并在环境变量中给出了它的名称。所以对我来说：EXISTING_CONTAINER=$(docker ps -a | grep "$(echo $CONTAINER_NAME)") 是我正在寻找的语句。`

`@capricorn1 那是 useless use of echo;你只想grep "$CONTAINER_NAME"`

`看到这个sample using tput as background task for color rendering on terminal！！`

`而不是所有的“编辑”注释和删除线（这就是修订历史的用途），最好把它当作今天写的答案。如果有一些教训需要学习，可以记录在一个部分中，例如“不要做的事情”。`

`@Cadoiz 是的，有一些错别字... read _ 到 drop 不仅 skip... 等等... 答案已编辑，添加了指向 CSV 解析器示例的链接.谢谢！`

## 答4: ##

> 一个优秀的自由职业者，应该有对需求敏感和精准需求捕获的能力，而huntsbot.com提供了这个机会

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

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

`他们非常谨慎。 POSIX 很久以前就弃用了反引号；从这个千年开始，大多数 shell 都应该提供更现代的语法。 （仍然有一些遗留环境coughHP-UXcough 在九十年代初被牢牢地卡住了。）`

`不正确。 $() 与二十多年前标准化的 POSIX sh 完全兼容。`

`请注意，Solaris 10 上的 /bin/sh 仍然无法识别 $(…) — 而且 AFAIK 在 Solaris 11 上也是如此。`

`@JonathanLeffler 实际上，Solaris 11 不再是 /bin/sh 是 ksh93 的情况。`

`@tripleee - 回复晚了三年 :-) 但在过去的 10 多年里，我在 HP-UX 的 POSIX shell 中使用了 $()。`

## 答5: ##

> huntsbot.com聚合了超过10+全球外包任务平台的外包需求，寻找外包任务与机会变的简单与高效。

我知道三种方法：

函数适合这样的任务：\*\* func ()\{ ls -l \} 通过说 func 来调用它。另一个合适的解决方案可能是 eval： var=“ls -l” eval  v a r 第三个是直接使用变量： v a r = var 第三个是直接使用变量： var= var第三个是直接使用变量：var=(ls -l) OR var=`ls -l`

您可以很好地获得第三个解决方案的输出：

echo "$var"

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

echo $var

`前两个似乎没有回答目前的问题，第二个通常被认为是可疑的。`

`作为一个完全不熟悉 bash 的人，为什么 "$var" 好而 $var 讨厌？`

`@彼得stackoverflow.com/questions/10067266/…`

## 答6: ##

> huntsbot.com全球7大洲远程工作机会，探索不一样的工作方式

只是要与众不同：

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

## 答7: ##

> huntsbot.com聚合了超过10+全球外包任务平台的外包需求，寻找外包任务与机会变的简单与高效。

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

正确的：

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

将因错误“stuff: not found”或类似错误而失败

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

`带空格的版本表示不同的意思：var=value somecommand 在其环境中运行 somecommand，其中 var 的值为 value。因此，var= somecommand 在 somecommand 的环境中以空（零字节）值导出 var。`

`是的，一个 Bash 陷阱。`

## 答8: ##

> huntsbot.com提供全网独家一站式外包任务、远程工作、创意产品分享与订阅服务!

如果您想使用多行/多个命令/s 来执行此操作，则可以执行以下操作：

output=$( bash <heredoc，您可以通过将冗长的单行代码分解为多行代码来轻松简化事情。另一个例子：
    
     
    
    ```java
    output="$( ssh -p $port $user@$domain < huntsbot.com汇聚了国内外优秀的初创产品创意，可按收入、分类等筛选，希望这些产品与实践经验能给您带来灵感。
    
    你需要使用
    
     $(command-here)
    
     或者
    
     
    
    ```java
    `command-here`

例子

#!/bin/bash
    
    VAR1="$1"
    VAR2="$2"
    
    MOREF="$(sudo run command against "$VAR1" | grep name | cut -c7-)"
    
    echo "$MOREF"

`$() 比反引号好得多。请参阅：What is the benefit of using $() instead of backticks in shell scripts?`

`我不知道你可以嵌套，但这很有意义，非常感谢你提供的信息！`

## 答10: ##

> 保持自己快人一步,享受全网独家提供的一站式外包任务、远程工作、创意产品订阅服务–huntsbot.com

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

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

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

## 答11: ##

> 保持自己快人一步,享受全网独家提供的一站式外包任务、远程工作、创意产品订阅服务–huntsbot.com

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

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

`这不涉及 OP 的问题，这实际上是关于命令替换，而不是进程替换。`

原文链接：[https://www.huntsbot.com/qa/BB06/how-do-i-set-a-variable-to-the-output-of-a-command-in-bash?lang=zh\_CN&from=csdn][https_www.huntsbot.com_qa_BB06_how-do-i-set-a-variable-to-the-output-of-a-command-in-bash_lang_zh_CN_from_csdn]

> 打造属于自己的副业，开启自由职业之旅，从huntsbot.com开始!

[https_www.huntsbot.com_qa_BB06_how-do-i-set-a-variable-to-the-output-of-a-command-in-bash_lang_zh_CN_from_csdn]: https://www.huntsbot.com/qa/BB06/how-do-i-set-a-variable-to-the-output-of-a-command-in-bash?lang=zh_CN&from=csdn