Gibt es einen TRY CATCH-Befehl in Bash?

Ich Schreibe ein shell-Skript und brauchen, um zu überprüfen, die eine terminal-app installiert wurde. Ich möchte einen TRY/CATCH " - Befehl, um dies zu tun, es sei denn, es ist ein ordentlicher Weg.

InformationsquelleAutor der Frage Lee Probert | 2014-02-25

  1. 300

    Gibt es eine TRY-CATCH-Befehl in der Bash?

    Nicht.

    Bash nicht so viele Genussmittel wie kann man in vielen Programmiersprachen.

    Gibt es keine try/catch in der bash, aber damit kann man erreichen, ein ähnliches Verhalten mit && oder ||.

    Mit ||:

    wenn command1 fehlschlägt, dann command2 läuft wie folgt

    command1 || command2

    Ähnlich, mit &&command2 ausgeführt wird, wenn command1 erfolgreich ist

    Annäherung try/catch ist wie folgt

    { # try

    command1 &&
    #save your output

} || { # catch
    # save log for exception 
}

    Auch die bash enthält einige error-handling-Mechanismen, sowie 

    set -e

    Wird er sofort aufhören, Ihr Skript, wenn Sie einen einfachen Befehl zu einem Fehler. Ich denke, das sollte das Standard-Verhalten. Da solche Fehler fast immer bedeuten, etwas unerwartetes, es ist nicht wirklich 'gesund' zu halten, ausführen der folgenden Befehle.

    Und auch, warum nicht if...else. Es ist dein bester Freund.

    InformationsquelleAutor der Antwort Jayesh Bhoi

  2. 67

    Basierend auf einige Antworten, die ich hier gefunden habe, machte ich mir einen kleinen helper-Datei, Quelle für meine Projekte:

    trycatch.sh

    #!/bin/bash

function try()
{
    [[ $- = *e* ]]; SAVED_OPT_E=$?
    set +e
}

function throw()
{
    exit $1
}

function catch()
{
    export ex_code=$?
    (( $SAVED_OPT_E )) && set +e
    return $ex_code
}

function throwErrors()
{
    set -e
}

function ignoreErrors()
{
    set +e
}

    hier ist ein Beispiel, wie es aussieht, im Einsatz:

    #!/bin/bash
export AnException=100
export AnotherException=101

# start with a try
try
(   # open a subshell !!!
    echo "do something"
    [ someErrorCondition ] && throw $AnException

    echo "do something more"
    executeCommandThatMightFail || throw $AnotherException

    throwErrors # automaticatly end the try block, if command-result is non-null
    echo "now on to something completely different"
    executeCommandThatMightFail

    echo "it's a wonder we came so far"
    executeCommandThatFailsForSure || true # ignore a single failing command

    ignoreErrors # ignore failures of commands until further notice
    executeCommand1ThatFailsForSure
    local result = $(executeCommand2ThatFailsForSure)
    [ result != "expected error" ] && throw $AnException # ok, if it's not an expected error, we want to bail out!
    executeCommand3ThatFailsForSure

    echo "finished"
)
# directly after closing the subshell you need to connect a group to the catch using ||
catch || {
    # now you can handle
    case $ex_code in
        $AnException)
            echo "AnException was thrown"
        ;;
        $AnotherException)
            echo "AnotherException was thrown"
        ;;
        *)
            echo "An unexpected exception was thrown"
            throw $ex_code # you can rethrow the "exception" causing the script to exit if not caught
        ;;
    esac
}

    InformationsquelleAutor der Antwort Mathias Henze

  3. 50

    Hab ich entwickelte eine fast makellose try & fangen Umsetzung in der bash, das Ihnen erlaubt, code zu schreiben, wie:

    try 
    echo 'Hello'
    false
    echo 'This will not be displayed'

catch 
    echo "Error in $__EXCEPTION_SOURCE__ at line: $__EXCEPTION_LINE__!"

    Können Sie auch verschachteln von try-catch-Blöcke im inneren selbst!

    try {
    echo 'Hello'

    try {
        echo 'Nested Hello'
        false
        echo 'This will not execute'
    } catch {
        echo "Nested Caught (@ $__EXCEPTION_LINE__)"
    }

    false
    echo 'This will not execute too'

} catch {
    echo "Error in $__EXCEPTION_SOURCE__ at line: $__EXCEPTION_LINE__!"
}

    Der code ist ein Teil meiner bash boilerplate/Rahmen. Es erweitert die Idee von try & fangen Sie mit Dinge wie Fehlerbehandlung mit backtrace und Ausnahmen (plus einige andere nette features).

    Hier ist der code, der verantwortlich ist, nur für try & Fang:

    set -o pipefail
shopt -s expand_aliases
declare -ig __oo__insideTryCatch=0

# if try-catch is nested, then set +e before so the parent handler doesn't catch us
alias try="[[ \$__oo__insideTryCatch -gt 0 ]] && set +e;
           __oo__insideTryCatch+=1; ( set -e;
           trap \"Exception.Capture \${LINENO}; \" ERR;"
alias catch=" ); Exception.Extract \$? || "

Exception.Capture() {
    local script="${BASH_SOURCE[1]#./}"

    if [[ ! -f /tmp/stored_exception_source ]]; then
        echo "$script" > /tmp/stored_exception_source
    fi
    if [[ ! -f /tmp/stored_exception_line ]]; then
        echo "$1" > /tmp/stored_exception_line
    fi
    return 0
}

Exception.Extract() {
    if [[ $__oo__insideTryCatch -gt 1 ]]
    then
        set -e
    fi

    __oo__insideTryCatch+=-1

    __EXCEPTION_CATCH__=( $(Exception.GetLastException) )

    local retVal=$1
    if [[ $retVal -gt 0 ]]
    then
        # BACKWARDS COMPATIBILE WAY:
        # export __EXCEPTION_SOURCE__="${__EXCEPTION_CATCH__[(${#__EXCEPTION_CATCH__[@]}-1)]}"
        # export __EXCEPTION_LINE__="${__EXCEPTION_CATCH__[(${#__EXCEPTION_CATCH__[@]}-2)]}"
        export __EXCEPTION_SOURCE__="${__EXCEPTION_CATCH__[-1]}"
        export __EXCEPTION_LINE__="${__EXCEPTION_CATCH__[-2]}"
        export __EXCEPTION__="${__EXCEPTION_CATCH__[@]:0:(${#__EXCEPTION_CATCH__[@]} - 2)}"
        return 1 # so that we may continue with a "catch"
    fi
}

Exception.GetLastException() {
    if [[ -f /tmp/stored_exception ]] && [[ -f /tmp/stored_exception_line ]] && [[ -f /tmp/stored_exception_source ]]
    then
        cat /tmp/stored_exception
        cat /tmp/stored_exception_line
        cat /tmp/stored_exception_source
    else
        echo -e " \n${BASH_LINENO[1]}\n${BASH_SOURCE[2]#./}"
    fi

    rm -f /tmp/stored_exception /tmp/stored_exception_line /tmp/stored_exception_source
    return 0
}

    Fühlen Sie sich frei zu verwenden, Gabel und tragen - es ist auf GitHub.

    InformationsquelleAutor der Antwort niieani

  4. 11

    bash nicht zum Abbruch der Laufenden Ausführung im Falle sth erkennt einen Fehler-Zustand (es sei denn, Sie legen Sie die -e flag). Programmiersprachen bieten try/catch dies tun, um zu hemmen ein "bailing out", weil diese spezielle situation (daher in der Regel sogenannte "Ausnahme").

    In der bashsondern nur der Befehl in Frage gestellt wird beendet mit exit-code größer als 0 ist, was angibt, dass Fehler-Zustand. Sie können überprüfen, natürlich, aber da gibt es keine automatische die Rettung von nichts, ein try/catch - nicht sinnvoll. Es fehlt nur, dass der Kontext.

    Allerdings können Sie simulieren eine die Rettung durch Verwendung von sub-shells, die beendet werden können und an einem Punkt Sie sich entscheiden:

    (
  echo "Do one thing"
  echo "Do another thing"
  if some_condition
  then
    exit 3  # <-- this is our simulated bailing out
  fi
  echo "Do yet another thing"
  echo "And do a last thing"
)   # <-- here we arrive after the simulated bailing out, and $? will be 3 (exit code)
if [ $? = 3 ]
then
  echo "Bail out detected"
fi

    Statt, die some_condition mit einem if können Sie auch einfach einen Befehl auszuprobieren, und falls es fehl (hat einen exit-code größer als 0), bail out:

    (
  echo "Do one thing"
  echo "Do another thing"
  some_command || exit 3
  echo "Do yet another thing"
  echo "And do a last thing"
)
...

    Leider, mit dieser Technik sind Sie darauf beschränkt zu 255 unterschiedliche exit-codes (1..255) und kein vernünftiges exception-Objekte können verwendet werden.

    Wenn Sie mehr Informationen benötigen, um pass zusammen mit dem simulierten Ausnahme, können Sie die stdout von der Unterschalen, aber das ist ein bisschen kompliziert und vielleicht eine andere Frage 😉

    Indem Sie die oben genannten -e flag, um der shell kann man auch Streifen, die explizite exit Aussage:

    (
  set -e
  echo "Do one thing"
  echo "Do another thing"
  some_command
  echo "Do yet another thing"
  echo "And do a last thing"
)
...

    InformationsquelleAutor der Antwort Alfe

  5. 9

    Wie jeder sagt, bash nicht haben, eine angemessene Sprache-unterstützt von try/catch-syntax. Starten Sie die bash mit der -e argument oder verwenden Sie set -e im script zum Abbruch des gesamten bash-Prozesses, wenn ein Befehl mit einem nicht-null exit-code. (Sie können auch set +e vorübergehend zu erlauben, andernfalls Befehle.)

    So, einer Technik zur Simulation eines try/catch-block zu starten, ein sub-Prozess, um die Arbeit mit -e aktiviert. Dann in der main-Prozess, überprüfen Sie den return-code des sub-Prozesses.

    Bash unterstützt heredoc-strings, so dass Sie nicht haben, um zu schreiben, zwei separate Dateien, um diese zu bewältigen. In dem unten angeführten Beispiel, die VERSUCHEN heredoc wird in ein separates bash-Instanz, mit -e aktiviert, so dass der sub-Prozess zum Absturz bringen, wenn jeder Befehl gibt einen nicht-null exit-code. Dann, zurück in der main-Prozess, können wir prüfen den return-code zum behandeln von einem catch-block.

    #!/bin/bash

set +e
bash -e <<TRY
  echo hello
  cd /does/not/exist
  echo world
TRY
if [ $? -ne 0 ]; then
  echo caught exception
fi

    Es ist keine richtige Sprache-unterstützt try/catch-block, aber es kann kratzen, ein ähnliches Jucken Sie.

    InformationsquelleAutor der Antwort Dan Fabulich

  6. 6

    Können Sie trap:

    try { block A } catch { block B } finally { block C }

    übersetzt:

    (
  set -Ee
  function _catch {
    block B
    exit 0  # optional; use if you don't want to propagate (rethrow) error to outer shell
  }
  function _finally {
    block C
  }
  trap _catch ERR
  trap _finally EXIT
  block A
)

    InformationsquelleAutor der Antwort Mark K Cowan

  7. 4

    Und Sie fallen http://www.tldp.org/LDP/Bash-Beginners-Guide/html/sect_12_02.html das ist nicht das gleiche, aber andere Technik, die Sie für diesen Zweck verwenden können

    InformationsquelleAutor der Antwort Eran Ben-Natan

  8. 4

    Gibt es so viele ähnliche Lösungen, die wahrscheinlich funktionieren. Unten ist eine einfache und funktionierende Art und Weise zu erreichen, try/catch, mit Erklärung in den Kommentaren.

    #!/bin/bash

function a() {
  # do some stuff here
}
function b() {
  # do more stuff here
}

# this subshell is a scope of try
# try
(
  # this flag will make to exit from current subshell on any error
  # inside it (all functions run inside will also break on any error)
  set -e
  a
  b
  # do more stuff here
)
# and here we catch errors
# catch
errorCode=$?
if [ $errorCode -ne 0 ]; then
  echo "We have an error"
  # We exit the all script with the same error, if you don't want to
  # exit it and continue, just delete this line.
  exit $errorCode
fi

    InformationsquelleAutor der Antwort Kostanos

  9. 1

    Können Sie tun:

    #!/bin/bash
if <command> ; then # TRY
    <do-whatever-you-want>
else # CATCH
    echo 'Exception'
    <do-whatever-you-want>
fi

    InformationsquelleAutor der Antwort Davidson Lima

  10. 0

    Eine sehr einfache Sache, die ich benutze:

    try() {
    "$@" || (e=$?; echo "$@" > /dev/stderr; exit $e)
}

    InformationsquelleAutor der Antwort syberghost

Schreibe einen Kommentar