So geben Sie Shell-Befehle wieder, wenn sie ausgeführt werden

Wie kann ich in einem Shell-Skript alle aufgerufenen Shell-Befehle wiedergeben und Variablennamen erweitern?

Zum Beispiel in der folgenden Zeile:

ls $DIRNAME

Ich möchte, dass das Skript den Befehl ausführt und Folgendes anzeigt

ls /full/path/to/some/dir

Der Zweck besteht darin, ein Protokoll aller aufgerufenen Shell-Befehle und ihrer Argumente zu speichern. Gibt es vielleicht eine bessere Möglichkeit, ein solches Protokoll zu erstellen?

set -xoder set -o xtraceerweitert Variablen und druckt ein kleines + Zeichen vor der Zeile.

set -voder set -o verboseerweitert die Variablen vor dem Drucken nicht.

Verwenden Sie set +xund set +v, um die obigen Einstellungen zu deaktivieren.

In der ersten Zeile des Skripts kann man #!/bin/sh -x(oder -v) setzen, um den gleichen Effekt wie set -x(oder -v) später im Skript zu erzielen .

Das obige funktioniert auch mit /bin/sh.

Informationen zu setAttributen und zum Debuggen finden Sie im Wiki der Bash-Hacker .

$ cat shl
#!/bin/bash                                                                     

DIR=/tmp/so
ls $DIR

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

set -x wird dir geben, was du willst.

Hier ist ein Beispiel für ein Shell-Skript, das Folgendes demonstriert:

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

ls $PWD

Dies erweitert alle Variablen und druckt die vollständigen Befehle vor der Ausgabe des Befehls.

Ausgabe:

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

Ich benutze eine Funktion, um den Befehl zu wiederholen und auszuführen:

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

exe echo hello world

Welche Ausgänge

$ echo hello world
hello world

Für kompliziertere Befehlspipes usw. können Sie eval verwenden:

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

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

Welche Ausgänge

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

Sie können dies auch für ausgewählte Zeilen in Ihrem Skript umschalten, indem Sie sie einschließen set -xund set +xbeispielsweise

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

Die Antwort von shuckc für das Echo ausgewählter Zeilen hat einige Nachteile: Am Ende wird auch der folgende set +xBefehl wiederholt, und Sie verlieren die Möglichkeit, den Exit-Code zu testen, $?da er von der überschrieben wird set +x.

Eine andere Möglichkeit besteht darin, den Befehl in einer Subshell auszuführen:

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

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

Das gibt Ihnen Ausgabe wie:

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

Dies verursacht jedoch den Aufwand für das Erstellen einer neuen Subshell für den Befehl.

Eine andere Möglichkeit besteht darin, "-x" am Anfang Ihres Skripts anstatt in der Befehlszeile einzufügen:

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

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

Nach TLDP ‚s Bash Leitfaden für Anfänger: Kapitel 2. Schreiben und Debuggen von Skripten :

2.3.1. Debuggen des gesamten Skripts

$ bash -x script1.sh

...

Es gibt jetzt einen vollwertigen Debugger für Bash, der bei SourceForge erhältlich ist . Diese Debugging-Funktionen sind in den meisten modernen Versionen von Bash ab 3.x verfügbar.

2.3.2. Debuggen von Teilen des Skripts

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

...

Tabelle 2-1. Übersicht über die festgelegten Debugging-Optionen

    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.

...

Alternativ können diese Modi im Skript selbst angegeben werden, indem die gewünschten Optionen zur Shell-Deklaration in der ersten Zeile hinzugefügt werden. Optionen können kombiniert werden, wie dies normalerweise bei UNIX-Befehlen der Fall ist:

#!/bin/bash -xv

Geben Sie "bash -x" in die Befehlszeile vor dem Namen des Bash-Skripts ein. Geben Sie zum Ausführen von foo.sh beispielsweise Folgendes ein:

bash -x foo.sh

Mit der Option können Sie ein Bash-Skript im Debug-Modus ausführen .-x

Dadurch werden alle Befehle wiedergegeben.

bash -x example_script.sh

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

Sie können die Option -x auch im Skript speichern . -xGeben Sie einfach die Option im Shebang an.

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

Für zsh echo

 setopt VERBOSE

Und zum Debuggen,

 setopt XTRACE

Für cshund tcshkönnen Sie set verboseoder set echo(oder Sie können sogar beide festlegen, dies kann jedoch die meiste Zeit zu Duplikaten führen).

Die verboseOption gibt so ziemlich den genauen Shell-Ausdruck aus, den Sie eingeben.

Die echoOption zeigt eher an, was durch das Laichen ausgeführt wird.

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

Die Ausgabe ist wie folgt:

Damit zusammengesetzte Befehle wiedergegeben werden können, verwende ich evaldie exeFunktion von plus Soth, um den Befehl wiederzugeben und auszuführen. Dies ist nützlich für Piped-Befehle, bei denen sonst nur keiner oder nur der erste Teil des Piped-Befehls angezeigt wird.

Ohne Bewertung:

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

Ausgänge:

$
file.txt

Mit eval:

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

Welche Ausgänge

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