Cómo hacer eco de los comandos de shell a medida que se ejecutan

En un script de shell, ¿cómo hago eco de todos los comandos de shell llamados y expando los nombres de variables?

Por ejemplo, dada la siguiente línea:

ls $DIRNAME

Me gustaría que el script ejecute el comando y muestre lo siguiente

ls /full/path/to/some/dir

El propósito es guardar un registro de todos los comandos de shell llamados y sus argumentos. ¿Existe tal vez una mejor manera de generar tal registro?

set -xo set -o xtraceexpande variables e imprime un pequeño signo + antes de la línea.

set -vo set -o verboseno expande las variables antes de imprimir.

Use set +xy set +vpara desactivar la configuración anterior.

En la primera línea del guión, se puede poner #!/bin/sh -x(o -v) para tener el mismo efecto que set -x(o -v) más adelante en el guión.

Lo anterior también funciona con /bin/sh.

Vea la wiki de bash-hackers sobre setatributos y depuración .

$ cat shl
#!/bin/bash                                                                     

DIR=/tmp/so
ls $DIR

$ bash -x shl 
+ DIR=/tmp/so
+ ls /tmp/so
$

set -x te dará lo que quieres

Aquí hay un ejemplo de script de shell para demostrar:

#!/bin/bash
set -x #echo on

ls $PWD

Esto expande todas las variables e imprime los comandos completos antes de la salida del comando.

Salida:

+ ls /home/user/
file1.txt file2.txt

Yo uso una función para hacer eco y ejecutar el comando:

#!/bin/bash
# Function to display commands
exe() { echo "\$ $@" ; "$@" ; }

exe echo hello world

Que salidas

$ echo hello world
hello world

Para tuberías de comandos más complicadas, etc., puede usar eval:

#!/bin/bash
# Function to display commands
exe() { echo "\$ ${@/eval/}" ; "$@" ; }

exe eval "echo 'Hello, World!' | cut -d ' ' -f1"

Que salidas

$  echo 'Hello, World!' | cut -d ' ' -f1
Hello

También puede alternar esto para seleccionar líneas en su secuencia de comandos envolviéndolas set -xy set +x, por ejemplo,

#!/bin/bash
...
if [[ ! -e $OUT_FILE ]];
then
   echo "grabbing $URL"
   set -x
   curl --fail --noproxy $SERV -s -S $URL -o $OUT_FILE
   set +x
fi

La respuesta de shuckc para hacer eco de las líneas de selección tiene algunas desventajas: terminas haciendo que se repita también el siguiente set +xcomando y pierdes la capacidad de probar el código de salida, $?ya que se sobrescribe con el set +x.

Otra opción es ejecutar el comando en una subshell:

echo "getting URL..."
( set -x ; curl -s --fail $URL -o $OUTFILE )

if [ $? -eq 0 ] ; then
    echo "curl failed"
    exit 1
fi

que le dará salida como:

getting URL...
+ curl -s --fail http://example.com/missing -o /tmp/example
curl failed

Sin embargo, esto conlleva la sobrecarga de crear una nueva subshell para el comando.

Otra opción es poner "-x" en la parte superior de su script en lugar de en la línea de comando:

$ cat ./server
#!/bin/bash -x
ssh user@server

$ ./server
+ ssh user@server
user@server's password: ^C
$

De acuerdo con la Guía Bash de TLDP para principiantes: Capítulo 2. Escritura y depuración de scripts :

2.3.1. Depuración de todo el script

$ bash -x script1.sh

...

Ahora hay un depurador completo para Bash, disponible en SourceForge . Estas funciones de depuración están disponibles en la mayoría de las versiones modernas de Bash, a partir de 3.x.

2.3.2. Depuración en parte (s) del script

set -x            # Activate debugging from here
w
set +x            # Stop debugging from here

...

Tabla 2-1. Descripción general de las opciones de depuración establecidas

    Short  | Long notation | Result
    -------+---------------+--------------------------------------------------------------
    set -f | set -o noglob | Disable file name generation using metacharacters (globbing).
    set -v | set -o verbose| Prints shell input lines as they are read.
    set -x | set -o xtrace | Print command traces before executing command.

...

Alternativamente, estos modos se pueden especificar en el script en sí mismo, agregando las opciones deseadas a la declaración de shell de la primera línea. Las opciones se pueden combinar, como suele ser el caso con los comandos UNIX:

#!/bin/bash -xv

Escriba "bash -x" en la línea de comando antes del nombre del script Bash. Por ejemplo, para ejecutar foo.sh, escriba:

bash -x foo.sh

Puede ejecutar un script Bash en modo de depuración con la -xopción .

Esto hará eco de todos los comandos.

bash -x example_script.sh

# Console output
+ cd /home/user
+ mv text.txt mytext.txt

También puede guardar la opción -x en el script . Simplemente especifique la -xopción en el shebang.

######## example_script.sh ###################
#!/bin/bash -x

cd /home/user
mv text.txt mytext.txt

##############################################

./example_script.sh

# Console output
+ cd /home/user
+ mv text.txt mytext.txt

Para zsh, echo

 setopt VERBOSE

Y para depurar,

 setopt XTRACE

Para cshy tcsh, puede set verboseo set echo(o incluso puede configurar ambos, pero puede resultar en alguna duplicación la mayor parte del tiempo).

La verboseopción imprime más o menos la expresión de shell exacta que escribe.

La echoopción es más indicativa de lo que se ejecutará durante el desove.

http://www.tcsh.org/tcsh.html/Special_shell_variables.html#verbose

http://www.tcsh.org/tcsh.html/Special_shell_variables.html#echo

Special shell variables

verbose If set, causes the words of each command to be printed, after history substitution (if any). Set by the -v command line option.

echo If set, each command with its arguments is echoed just before it is executed. For non-builtin commands all expansions occur before echoing. Builtin commands are echoed before command and filename substitution, because these substitutions are then done selectively. Set by the -x command line option.

$ cat exampleScript.sh
#!/bin/bash
name="karthik";
echo $name;

bash -x exampleScript.sh

La salida es la siguiente:

Para permitir que los comandos compuestos se repitan, utilizo evalmás la exefunción de Soth para hacer eco y ejecutar el comando. Esto es útil para los comandos canalizados que de otro modo solo mostrarían ninguno o solo la parte inicial del comando canalizado.

Sin eval:

exe() { echo "\$ $@" ; "$@" ; }
exe ls -F | grep *.txt

Salidas:

$
file.txt

Con eval:

exe() { echo "\$ $@" ; "$@" ; }
exe eval 'ls -F | grep *.txt'

Que salidas

$ exe eval 'ls -F | grep *.txt'
file.txt