Comment stocker une commande dans une variable dans un script shell?

Je voudrais stocker une commande à utiliser ultérieurement dans une variable (pas la sortie de la commande, mais la commande elle-même)

J'ai un script simple comme suit:

command="ls";
echo "Command: $command"; #Output is: Command: ls

b=`$command`;
echo $b; #Output is: public_html REV test... (command worked successfully)

Cependant, lorsque j'essaye quelque chose d'un peu plus compliqué, cela échoue. Par exemple, si je fais

command="ls | grep -c '^'";

La sortie est:

Command: ls | grep -c '^'
ls: cannot access |: No such file or directory
ls: cannot access grep: No such file or directory
ls: cannot access '^': No such file or directory

Une idée de la façon dont je pourrais stocker une telle commande (avec des tuyaux / plusieurs commandes) dans une variable pour une utilisation ultérieure?

Utilisez eval:

x="ls | wc"
eval "$x"
y=$(eval "$x")
echo "$y"

Ne pas utiliser eval! Il présente un risque majeur d'introduire une exécution de code arbitraire.

BashFAQ-50 - J'essaie de mettre une commande dans une variable, mais les cas complexes échouent toujours.

Mettez - le dans un tableau et développer tous les mots avec des guillemets doubles "${arr[@]}"pour ne pas laisser IFSdiviser les mots en raison de césure de mots .

cmdArgs=()
cmdArgs=('date' '+%H:%M:%S')

et voir le contenu du tableau à l'intérieur. Le declare -pvous permet de voir le contenu du tableau à l'intérieur avec chaque paramètre de commande dans des index séparés. Si l'un de ces arguments contient des espaces, les guillemets à l'intérieur lors de l'ajout au tableau l'empêcheront de se diviser en raison de Word-Splitting.

declare -p cmdArgs
declare -a cmdArgs='([0]="date" [1]="+%H:%M:%S")'

et exécutez les commandes comme

"${cmdArgs[@]}"
23:15:18

(ou) utiliser une bashfonction pour exécuter la commande,

cmd() {
   date '+%H:%M:%S'
}

et appelez la fonction comme juste

cmd

POSIX shn'a pas de tableaux, donc le plus proche est de construire une liste d'éléments dans les paramètres de position. Voici une shfaçon POSIX d'exécuter un programme de messagerie

# POSIX sh
# Usage: sendto subject address [address ...]
sendto() {
    subject=$1
    shift
    first=1
    for addr; do
        if [ "$first" = 1 ]; then set --; first=0; fi
        set -- "$@" --recipient="$addr"
    done
    if [ "$first" = 1 ]; then
        echo "usage: sendto subject address [address ...]"
        return 1
    fi
    MailTool --subject="$subject" "$@"
}

Notez que cette approche ne peut gérer que des commandes simples sans redirections. Il ne peut pas gérer les redirections, les pipelines, les boucles for / while, les instructions if, etc.

Un autre cas d'utilisation courant est lors de l'exécution curlavec plusieurs champs d'en-tête et une charge utile. Vous pouvez toujours définir des arguments comme ci-dessous et les invoquer curlsur le contenu du tableau étendu

curlArgs=('-H' "keyheader: value" '-H' "2ndkeyheader: 2ndvalue")
curl "${curlArgs[@]}"

Un autre exemple,

payload='{}'
hostURL='http://google.com'
authToken='someToken'
authHeader='Authorization:Bearer "'"$authToken"'"'

maintenant que les variables sont définies, utilisez un tableau pour stocker vos arguments de commande

curlCMD=(-X POST "$hostURL" --data "$payload" -H "Content-Type:application/json" -H "$authHeader")

et maintenant faire une expansion citée appropriée

curl "${curlCMD[@]}"

var=$(echo "asdf")
echo $var
# => asdf

En utilisant cette méthode, la commande est immédiatement évaluée et sa valeur de retour est stockée.

stored_date=$(date)
echo $stored_date
# => Thu Jan 15 10:57:16 EST 2015
# (wait a few seconds)
echo $stored_date
# => Thu Jan 15 10:57:16 EST 2015

Idem avec backtick

stored_date=`date`
echo $stored_date
# => Thu Jan 15 11:02:19 EST 2015
# (wait a few seconds)
echo $stored_date
# => Thu Jan 15 11:02:19 EST 2015

Utiliser eval dans le $(...)ne le fera pas évaluer plus tard

stored_date=$(eval "date")
echo $stored_date
# => Thu Jan 15 11:05:30 EST 2015
# (wait a few seconds)
echo $stored_date
# => Thu Jan 15 11:05:30 EST 2015

En utilisant eval, il est évalué lorsqu'il evalest utilisé

stored_date="date" # < storing the command itself
echo $(eval "$stored_date")
# => Thu Jan 15 11:07:05 EST 2015
# (wait a few seconds)
echo $(eval "$stored_date")
# => Thu Jan 15 11:07:16 EST 2015
#                     ^^ Time changed

Dans l'exemple ci-dessus, si vous devez exécuter une commande avec des arguments, placez-les dans la chaîne que vous stockez

stored_date="date -u"
# ...

Pour les scripts bash, c'est rarement pertinent, mais une dernière remarque. Soyez prudent avec eval. Évaluer uniquement les chaînes que vous contrôlez, jamais les chaînes provenant d'un utilisateur non approuvé ou créées à partir d'une entrée utilisateur non approuvée.

• Merci à @CharlesDuffy de m'avoir rappelé de citer la commande!

Pour bash, stockez votre commande comme ceci:

command="ls | grep -c '^'"

Exécutez votre commande comme ceci:

echo $command | bash

J'ai essayé différentes méthodes:

printexec() {
  printf -- "\033[1;37m$\033[0m"
  printf -- " %q" "$@"
  printf -- "\n"
  eval -- "$@"
  eval -- "$*"
  "$@"
  "$*"
}

Production:

$ printexec echo  -e "foo\n" bar
$ echo -e foo\\n bar
foon bar
foon bar
foo
 bar
bash: echo -e foo\n bar: command not found

Comme vous pouvez le voir, seul le troisième a "$@"donné le résultat correct.

Soyez prudent lors de l'enregistrement d'une commande auprès du: X=$(Command)

Celui-ci est toujours exécuté avant même d'être appelé. Pour vérifier et confirmer cela, vous pouvez faire:

echo test;
X=$(for ((c=0; c<=5; c++)); do
sleep 2;
done);
echo note the 5 seconds elapsed

#!/bin/bash
#Note: this script works only when u use Bash. So, don't remove the first line.

TUNECOUNT=$(ifconfig |grep -c -o tune0) #Some command with "Grep".
echo $TUNECOUNT                         #This will return 0 
                                    #if you don't have tune0 interface.
                                    #Or count of installed tune0 interfaces.

Il n'est pas nécessaire de stocker des commandes dans des variables même si vous devez l'utiliser plus tard. exécutez-le simplement comme d'habitude. Si vous stockez dans une variable, vous auriez besoin d'une sorte d' evalinstruction ou d'appeler un processus shell inutile pour "exécuter votre variable".