J'ai un script assez simple qui ressemble à ceci:

#!/bin/bash

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

echo $MOREF

Lorsque j'exécute ce script à partir de la ligne de commande et lui transmets les arguments, je n'obtiens aucune sortie. Cependant, lorsque j'exécute les commandes contenues dans la $MOREFvariable, je peux obtenir une sortie.

Comment prendre les résultats d'une commande qui doit être exécutée dans un script, l'enregistrer dans une variable, puis afficher cette variable à l'écran?

En plus des raccourcis `command`, la substitution de commandes peut être effectuée avec $(command)ou "$(command)", que je trouve plus facile à lire, et permet l'imbrication.

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

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

Quoting ( ") importe pour conserver les valeurs des variables multilignes ; il est facultatif sur le côté droit d'une affectation, car le fractionnement de mot n'est pas effectué , donc OUTPUT=$(ls -1)cela fonctionnerait bien.

La bonne façon est

$(sudo run command)

Si vous allez utiliser une apostrophe, vous en avez besoin `, non '. Ce personnage est appelé "backticks" (ou "grave accent").

Comme ça:

#!/bin/bash

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

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

echo "$MOREF"

Quelques astuces Bash que j'utilise pour définir des variables à partir de commandes

2nd Edit 2018-02-12: Ajouté une manière différente, recherchez en bas de celui-ci pour les tâches de longue durée !

25-01-2018 Édition: ajout d'un exemple de fonction (pour remplir les variables sur l'utilisation du disque)

Première méthode simple, ancienne et compatible

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

Principalement compatible, deuxième voie

L'imbrication pouvant devenir lourde, des parenthèses ont été mises en place pour cette

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

Échantillon imbriqué:

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

Lecture de plus d'une variable (avec bashismes )

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

Si je veux juste une valeur utilisée :

array=($(df -k /))

vous pouvez voir une variable de tableau :

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

Alors:

echo ${array[9]}
529020

Mais je préfère ceci:

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

La première sauteraread foo simplement la ligne d'en-tête, mais dans une seule commande, vous remplirez 7 variables différentes :

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"

Ou même:

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

... fonctionnera également avec les tableaux associatifs :read foo disk[total] disk[used] ...

Exemple de fonction pour remplir certaines variables:

#!/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: la declareligne n'est pas requise, juste pour la lisibilité.

À propos de sudo cmd | grep ... | cut ...

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

(S'il vous plaît éviter inutile cat! Donc, c'est juste une fourche de moins:

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

Tous les tuyaux ( |) impliquent des fourches. Où un autre processus doit être exécuté, accès au disque, aux appels de bibliothèques, etc.

Donc, utiliser sedpour exemple, limitera le sous-processus à une seule fourchette :

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

Et avec les bashismes :

Mais pour de nombreuses actions, principalement sur de petits fichiers, Bash pourrait faire le travail lui-même:

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

Pour en savoir plus sur le fractionnement variable ...

Jetez un œil à ma réponse à Comment diviser une chaîne sur un délimiteur dans Bash?

Alternative: réduction des fourches en utilisant des tâches de longue durée en arrière-plan

2nd Edit 2018-02-12:

Afin d'éviter plusieurs fourches comme

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)

Cela fonctionne bien, mais l'exécution de nombreuses fourches est lourde et lente.

Et des commandes comme dateet bcpourraient faire de nombreuses opérations, ligne par ligne !!

Voir:

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

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

Nous pourrions donc utiliser un processus d'arrière-plan de longue durée pour effectuer de nombreux travaux, sans avoir à initier un nouveau fork pour chaque demande.

Nous avons juste besoin de descripteurs de fichiers et de fifos pour le faire correctement:

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

(Bien sûr, FD 5et 6doivent être inutilisés!) ... À partir de là, vous pouvez utiliser ce processus en:

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

Dans une fonction newConnector

Vous pouvez trouver ma newConnectorfonction sur GitHub.Com ou sur mon propre site (Remarque sur GitHub: il y a deux fichiers sur mon site. La fonction et la démo sont regroupées dans un seul fichier qui pourrait être recherché pour être utilisé ou simplement exécuté pour la démo.)

Échantillon:

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

La fonction myBcvous permet d'utiliser la tâche d'arrière-plan avec une syntaxe simple et pour la date:

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

De là, si vous souhaitez mettre fin à l'un des processus d'arrière-plan, il vous suffit de fermer son 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

ce qui n'est pas nécessaire, car tous les fd se ferment à la fin du processus principal.

Comme ils vous l'ont déjà indiqué, vous devez utiliser des «backticks».

L'alternative proposée $(command)fonctionne également, et elle est également plus facile à lire, mais notez qu'elle n'est valable qu'avec Bash ou KornShell (et les shells dérivés de ceux-ci), donc si vos scripts doivent être vraiment portables sur divers systèmes Unix, vous devriez préférer l'ancienne notation backticks.

Je connais trois façons de le faire:

1. Les fonctions conviennent à de telles tâches: **

   func (){
       ls -l
   }

   Invoquez-le en disant func.

2. Une autre solution appropriée pourrait également être évaluée:

   var="ls -l"
   eval $var

3. Le troisième utilise directement des variables:

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

Vous pouvez obtenir la sortie de la troisième solution dans le bon sens:

echo "$var"

Et aussi de façon désagréable:

echo $var

Juste pour être différent:

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

Lorsque vous définissez une variable, assurez-vous de n'avoir AUCUN espace avant et / ou après le signe = . J'ai littéralement passé une heure à essayer de comprendre cela, à essayer toutes sortes de solutions! Ce n'est pas cool.

Correct:

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

Échouera avec l'erreur "stuff: not found" ou similaire

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

Si vous voulez le faire avec une ou plusieurs commandes multilignes / multiples, vous pouvez le faire:

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

Ou:

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

Exemple:

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

Production:

first
second
third

En utilisant heredoc , vous pouvez simplifier les choses assez facilement en décomposant votre long code de ligne unique en un code multiligne. Un autre exemple:

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

Vous devez utiliser soit

$(command-here)

ou

`command-here`

Exemple

#!/bin/bash

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

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

echo "$MOREF"

C'est une autre façon et est utile à utiliser avec certains éditeurs de texte qui ne peuvent pas mettre correctement en surbrillance chaque code complexe que vous créez:

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

Vous pouvez utiliser des backticks (également appelés tombes d'accent) ou $().

Comme:

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

Les deux ont le même effet. Mais OUTPUT = $ (x + 2) est plus lisible et le dernier.

Si la commande que vous essayez d'exécuter échoue, elle écrira la sortie sur le flux d'erreur et sera ensuite imprimée sur la console.

Pour l'éviter, vous devez rediriger le flux d'erreur:

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

Certains peuvent trouver cela utile. Valeurs entières dans la substitution de variable, où l'astuce consiste à utiliser $(())des crochets doubles:

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

Voici deux autres façons:

Veuillez garder à l'esprit que l'espace est très important dans Bash. Donc, si vous voulez que votre commande s'exécute, utilisez-la telle quelle sans introduire plus d'espace.

1. Cédant suivant harshilà Lpuis imprime

   L=$"harshil"
   echo "$L"

2. Ce qui suit affecte la sortie de la commande trà L2. trest opéré sur une autre variable, L1.

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