bash - historico - shell script variaveis




Como definir uma variável para a saída de um comando no Bash? (9)

Eu tenho um script bem simples que é algo como o seguinte: 

#!/bin/bash

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

echo $MOREF

Quando executo esse script a partir da linha de comando e passo os argumentos, não obtenho nenhuma saída. No entanto, quando executo os comandos contidos na variável $MOREF , consigo obter a saída.

Gostaria de saber como é possível obter os resultados de um comando que precisa ser executado em um script, salvá-lo em uma variável e, em seguida, gerar essa variável na tela?

Alguns truques bash eu uso para definir variáveis ​​de comandos

2nd Edit 2018-02-12: Adicionando uma maneira especial, veja na parte inferior desta!

2018-01-25 Editar: adicionar função de amostra (para preencher vars sobre o uso do disco)

Primeira maneira simples e antiga compatível 

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

Principalmente compatível, segunda maneira

Como o aninhamento pode se tornar pesado, parênteses foram implementados para este 

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

Amostra aninhada: 

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

lendo mais de uma variável (com bashisms ) 

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

Se eu quiser apenas o valor usado : 

array=($(df -k /))

você pode ver a variável array : 

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

Então: 

echo ${array[9]}
529020

Mas eu prefiro isso: 

{ read foo ; read filesystem size used avail prct mountpoint ; } < <(df -k /)
echo $used
529020

A primeira read foo irá simplesmente pular a linha de cabeçalho (a variável $foo conterá algo como o Filesystem 1K-blocks Used Available Use% Mounted on )

Função de amostra para preencher algumas variáveis: 

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

Nota: declare linha não é obrigatória, apenas por questões de legibilidade.

Sobre o sudo cmd | grep ... | cut ... sudo cmd | grep ... | cut ... 

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

(Por favor, evite cat inútil! Então, isso é apenas um garfo a menos: 

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

Todos os tubos ( | ) implicam garfos. Onde outro processo tem que ser executado, acessando disco, bibliotecas chama e assim por diante.

Portanto, usar sed para amostra limitará o subprocesso a apenas um fork : 

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

E com os bashisms :

Mas para muitas ações, principalmente em arquivos pequenos, o bash poderia fazer o trabalho sozinho: 

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

ou 

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

Indo mais longe sobre a divisão variável ...

Dê uma olhada na minha resposta para Como dividir uma string em um delimitador no Bash?

Alternativa: reduzindo garfos usando tarefas executadas em segundo plano

2nd Edit 2018-02-12: A fim de evitar vários garfos como 

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

ou 

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

E porque date e bc poderiam trabalhar linha por linha : 

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

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

Poderíamos usar o processo de segundo plano em execução longa para realizar trabalhos repetidamente, sem precisar iniciar o novo fork para cada solicitação: 

mkfifo /tmp/myFifoForBc
exec 5> >(bc -l >/tmp/myFifoForBc)
exec 6</tmp/myFifoForBc
rm /tmp/myFifoForBc

(é claro que os FD 5 e 6 não podem ser usados!) ... A partir daí, você pode usar este processo: 

echo "3*4" >&5
read -u 6 foo
echo $foo
12

echo >&5 "pi=4*a(1)"
echo >&5 "2*pi*12"
read -u 6 foo
echo $foo
75.39822368615503772256

Em uma função newConnector

Você pode encontrar minha função newConnector no GitHub.Com ou no meu próprio site (Nota no github, há dois arquivos, no meu site, função e demo são empacotados em um arquivo que pode ser usado para uso ou apenas executado para demonstração)

Amostra: 

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

A função myBc permite usar a tarefa em segundo plano com uma sintaxe simples e, por data: 

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

A partir daí, se você quiser terminar um dos processos em segundo plano, basta fechar seu 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

que não é necessário, porque todos os fd fecham quando o processo principal termina.

Além de backticks ( `command` ), você pode usar $(command) , que eu acho mais fácil de ler, e permite aninhamento. 

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

Citar ( " ) é importante para preservar valores de várias linhas.

Ao definir uma variável, certifique-se de ter NO Spaces antes e / ou após o sinal = . Literalmente passou uma hora tentando descobrir isso, tentando todos os tipos de soluções! Isso não é legal.

Corrigir: 

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

Irá falhar com erro: (coisas: não encontrado ou similar) 

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

Apenas para ser diferente: 

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

Como eles já indicaram para você, você deve usar 'backticks'.

A alternativa proposta por $(command) funciona, e também é mais fácil de ler, mas note que ela é válida apenas com shells bash ou korn (e shells derivados deles), então se seus scripts tiverem que ser realmente portáveis ​​em vários Unix sistemas, você deve preferir a antiga notação de backticks.

Essa é outra maneira, boa de usar com alguns editores de texto que não conseguem realçar corretamente todos os códigos intrincados que você cria. 

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

Se você quiser fazer isso com multiline / multiple command / s, você pode fazer isso: 

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

Ou: 

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

Exemplo: 

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

Saída: 

first
second
third

Usando o heredoc você pode simplificar as coisas com bastante facilidade, dividindo seu longo código de linha única em multilinha. Outro exemplo: 

output="$( ssh -p $port [email protected]$domain <<EOF 
#breakdown your long ssh command into multiline here.
EOF
)"

Você pode usar back-ticks (também conhecido como acento grave) ou $() . Como- 

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

Ambos têm o mesmo efeito. Mas OUTPUT = $ (x + 2) é mais legível e o mais recente.

Atualização (2018): o caminho certo é 

$(sudo run command)

Você está usando o tipo errado de apóstrofo. Você precisa ` , não ' . Esse caractere é chamado de "backticks" (ou "acento grave").

Como isso: 

#!/bin/bash

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

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

echo "$MOREF"



variaveis   script   historico   exemplos   comandos   comando   bash   shell   command-line  


command-line