Fatal编程技术网
  • bash/
  • 如何在Bash中将变量设置为命令的输出？

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

bash shell command-line unix

如何在Bash中将变量设置为命令的输出？,bash,shell,command-line,unix,posix,Bash,Shell,Command Line,Unix,Posix,我有一个非常简单的脚本，如下所示： #!/bin/bash VAR1="$1" MOREF='sudo run command against $VAR1 | grep name | cut -c7-' echo $MOREF 当我从命令行运行这个脚本并将参数传递给它时，我没有得到任何输出。但是，当我运行$MOREF变量中包含的命令时，我能够获得输出 如何将需要在脚本中运行的命令的结果保存到变量中，然后在屏幕上输出该变量 $(sudo run command) 如果要使用撇号，则需要`

我有一个非常简单的脚本，如下所示：

#!/bin/bash

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

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

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

$(sudo run command)
如果要使用撇号，则需要
`
，而不是
'
。此字符称为“背景音”（或“重重音”）：

除了反勾号
`command`
，还可以使用
$（command）
或
“$（command）”
完成，我发现这更易于阅读，并且允许嵌套

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

MULTILINE=$(ls \
   -1)
echo "${MULTILINE}"
引用（
“
）对保留多行变量值很重要；它在赋值的右侧是可选的，因此
输出=$（ls-1）
可以正常工作。

只是为了不同：

MOREF=$(sudo run command against $VAR1 | grep name | cut -c7-)
正如他们已经向您指出的，您应该使用“backticks”

另外提出的
$（command）
也可以使用，而且更易于阅读，但请注意，它仅对Bash或KornShell（以及从它们派生的shell）有效，
因此，如果您的脚本必须在各种Unix系统上真正可移植，您应该更喜欢旧的backticks表示法。

我知道三种方法：

  • 功能适用于以下任务：**

    func (){
    ls -l
}
    通过说
    func
    调用它

  • 另外，另一个合适的解决方案可以是eval：

    var="ls -l"
eval $var
  • 第三种是直接使用变量：

    var=$(ls -l)

    OR

var=`ls -l`
    • 您可以很好地获得第三个解决方案的输出：

    echo "$var"
    还有一种令人讨厌的方式：

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

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

    read-r-d''str<如果要使用多行/多命令/s执行此操作，则可以执行以下操作：
    

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

    
例如：
    

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

    
使用，您可以通过将长的单行代码分解为多行代码来简化工作。另一个示例：
    

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

    

    output=“$（ssh-p$port$user@$domain有些人可能会觉得这很有用。
变量替换中的整数值，技巧是使用
    $（（））
    双括号：
    

    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

    

    N=3
M=3
计数=$N-1
ARR[0]=3
ARR[1]=2
ARR[2]=4
ARR[3]=1
而（（计数<${ARR[@]}））
做
ARR[$COUNT]=$（（ARR[COUNT]*M））
（（计数=$COUNT+N））
完成

    您可以使用反勾号（也称为重音graves）或
    $（）
    
比如：
    

    两者都有相同的效果。但OUTPUT=$（x+2）更具可读性，而且是最新版本。
    这里还有两种方法：
    
请记住，在Bash中，空间是非常重要的。因此，如果您希望您的命令能够运行，请按原样使用，而不要引入更多的空间
    

  • 下面将
    harshil
    分配给
    L
    ，然后将其打印出来
    

    L=$"harshil"
echo "$L"

    

    • 

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

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

    

    • 
我使用一些技巧从命令设置变量
很抱歉，这里有一个很长的答案，但正如a一样，主要目标是运行其他命令并对resut代码和/或输出作出反应（命令通常是管道过滤器等）
    
将命令输出存储在变量中是一件基本的事情
    
因此，取决于
    

      

    • 兼容性（）
      • 

    • 输出类型（滤波器）
      • 

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

    • 执行时间（监控）
      • 

    • 错误捕获
      • 

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

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

    • 我错过什么了吗
      • 

    
第一种简单、古老且兼容的方式
基本兼容，第二种方式
由于嵌套可能变得繁重，因此为此实现了括号
    

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

    
特征
读取多个变量（使用bashims）
如果我只想要一个已使用的值：
    
您可以看到一个数组变量：
    

    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]="/")'

    
然后：
    
但我经常这样说：
或
    
甚至：
    

    { read foo ; 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")

    

    使用这种方法（
    …read-u$list；…{list}在设置变量时，确保在
    =
    符号之前和/或之后没有空格。我花了一个小时试图弄明白这一点，尝试各种解决方案！这并不酷
    
正确：
    
将失败并出现错误“stuff:not found”或类似错误
    

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

    
你需要使用其中一种
    

    $（此处命令）
    
或
    
例子

    如果您尝试执行的命令失败，它会将输出写入错误流，然后输出到控制台
    
要避免此错误，必须重定向错误流：
    

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

    

    我们能为多行输出提供一些分隔符吗？空白（或缺少空白） matters@timhc22，大括号是不相关的；只有引号才是重要的：在传递给
    echo
    命令之前，是否对扩展结果进行字符串拆分和全局扩展。啊，谢谢！大括号有什么好处吗？当变量后面紧跟着更多字符时，可以使用大括号可以将其解释为变量名称的一部分。例如，
    ${OUTPUT}foo
    。在对变量执行内联字符串操作时，也需要它们，例如
    ${OUTPUT/foo/bar}
    他们非常谨慎。Backticks早就被POSIX弃用了；从本世纪开始，在大多数shell中应该可以使用更现代的语法。（仍有一些遗留环境在90年代初就被牢牢地卡住了。）不正确。
    $（）
    与POSIX sh完全兼容，这是二十多年前标准化的。请注意，Solaris 10上的
    /bin/sh
    仍然无法识别
    $（…）myPi=$(bc -l <<<'4*a(1)')

    

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

    

    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 foo ; read filesystem size using avail prct mountpoint ; } < <(df -k /)
echo $using
529020

    

    declare -p avail filesystem foo mountpoint prct size using
declare -- avail="401488"
declare -- filesystem="/dev/dm-0"
declare -- foo="Filesystem     1K-blocks   Used Available Use% Mounted on"
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 foo ; 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")

    

    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

    

    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

    

    {
    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

    

    #!/bin/bash

declare free=0 total=0 used=0

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

getDiskStat $1
echo $total $used $free

    

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

    

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

    

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

    

    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 ...

    

    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)

    

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

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

    

    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

    

    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"

    

    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

    

    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

    

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

    

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

    

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