Is there a TRY CATCH command in Bash

Question

I m writing a shell script and need to check that a terminal app has been installed  I want to use a TRY CATCH command to do this unless there is a neater way

User · Answer

Below is an example of a script which implements try/catch/finally in bash.

Like other answers to this question, exceptions must be caught after exiting a subprocess.

The example scripts start by creating an anonymous fifo, which is used to pass string messages from a command exception or throw to end of the closest try block. Here the messages are removed from the fifo and placed in an array variable. The status is returned through return and exit commands and placed in a different variable. To enter a catch block, this status must not be zero. Other requirements to enter a catch block are passed as parameters. If the end of a catch block is reached, then the status is set to zero. If the end of the finally block is reached and the status is still nonzero, then an implicit throw containing the messages and status is executed. The script requires the calling of the function trycatchfinally which contains an unhandled exception handler.

The syntax for the trycatchfinally command is given below.

trycatchfinally [-cde] [-h ERR_handler] [-k] [-o debug_file] [-u unhandled_handler] [-v variable] fifo function

The -c option adds the call stack to the exception messages.
The -d option enables debug output.
The -e option enables command exceptions.
The -h option allows the user to substitute their own command exception handler.
The -k option adds the call stack to the debug output.
The -o option replaces the default output file which is /dev/fd/2.
The -u option allows the user to substitute their own unhandled exception handler.
The -v option allows the user the option to pass back values though the use of Command Substitution.
The fifo is the fifo filename.
The function function is called by trycatchfinally as a subprocess.

Note: The cdko options were removed to simplify the script.

The syntax for the catch command is given below.

catch [[-enoprt] list ...] ...

The options are defined below. The value for the first list is the status. Subsquent values are the messages. If the there are more messages than lists, then the remaining messages are ignored.

-e means [[ $value == "$string" ]] (the value has to match at least one string in the list)
-n means [[ $value != "$string" ]] (the value can not match any of the strings in the list)
-o means [[ $value != $pattern ]] (the value can not match any of the patterns in the list)
-p means [[ $value == $pattern ]] (the value has to match at least one pattern in the list)
-r means [[ $value =~ $regex ]] (the value has to match at least one extended regular expression in the list)
-t means [[ ! $value =~ $regex ]] (the value can not match any of the extended regular expressions in the list)

The try/catch/finally script is given below. To simplify the script for this answer, most of the error checking was removed. This reduced the size by 64%. A complete copy of this script can be found at my other answer.

shopt -s expand_aliases
alias try='{ common.Try'
alias yrt='EchoExitStatus; common.yrT; }'
alias catch='{ while common.Catch'
alias hctac='common.hctaC; done; }'
alias finally='{ common.Finally'
alias yllanif='common.yllaniF; }'

DefaultErrHandler() {
    echo "Orginal Status: $common_status"
    echo "Exception Type: ERR"
}

exception() {
    let "common_status = 10#$1"
    shift
    common_messages=()
    for message in "$@"; do
        common_messages+=("$message")
    done
}

throw() {
    local "message"
    if [[ $# -gt 0 ]]; then
        let "common_status = 10#$1"
        shift
        for message in "$@"; do
            echo "$message" >"$common_fifo"
        done
    elif [[ ${#common_messages[@]} -gt 0 ]]; then
        for message in "${common_messages[@]}"; do
            echo "$message" >"$common_fifo"
        done
    fi
    chmod "0400" "$common_fifo"
    exit "$common_status"
}

common.ErrHandler() {
    common_status=$?
    trap ERR
    if [[ -w "$common_fifo" ]]; then
        if [[ $common_options != *e* ]]; then
            common_status="0"
            return
        fi
        eval "${common_errHandler:-} \"${BASH_LINENO[0]}\" \"${BASH_SOURCE[1]}\" \"${FUNCNAME[1]}\" >$common_fifo <$common_fifo"
        chmod "0400" "$common_fifo"
    fi
    if [[ common_trySubshell -eq BASH_SUBSHELL ]]; then
        return   
    else
        exit "$common_status"
    fi
}

common.Try() {
    common_status="0"
    common_subshell="$common_trySubshell"
    common_trySubshell="$BASH_SUBSHELL"
    common_messages=()
}

common.yrT() {
    local "status=$?"
    if [[ common_status -ne 0 ]]; then    
        local "message=" "eof=TRY_CATCH_FINALLY_END_OF_MESSAGES_$RANDOM"
        chmod "0600" "$common_fifo"
        echo "$eof" >"$common_fifo"
        common_messages=()
        while read "message"; do
            [[ $message != *$eof ]] || break
            common_messages+=("$message")
        done <"$common_fifo"
    fi
    common_trySubshell="$common_subshell"
}

common.Catch() {
    [[ common_status -ne 0 ]] || return "1"
    local "parameter" "pattern" "value"
    local "toggle=true" "compare=p" "options=$-"
    local -i "i=-1" "status=0"
    set -f
    for parameter in "$@"; do
        if "$toggle"; then
            toggle="false"
            if [[ $parameter =~ ^-[notepr]$ ]]; then
                compare="${parameter#-}"
                continue 
            fi
        fi
        toggle="true"
        while "true"; do
            eval local "patterns=($parameter)"
            if [[ ${#patterns[@]} -gt 0 ]]; then
                for pattern in "${patterns[@]}"; do
                    [[ i -lt ${#common_messages[@]} ]] || break
                    if [[ i -lt 0 ]]; then
                        value="$common_status"
                    else
                        value="${common_messages[i]}"
                    fi
                    case $compare in
                    [ne]) [[ ! $value == "$pattern" ]] || break 2;;
                    [op]) [[ ! $value == $pattern ]] || break 2;;
                    [tr]) [[ ! $value =~ $pattern ]] || break 2;;
                    esac
                done
            fi
            if [[ $compare == [not] ]]; then
                let "++i,1"
                continue 2
            else
                status="1"
                break 2
            fi
        done
        if [[ $compare == [not] ]]; then
            status="1"
            break
        else
            let "++i,1"
        fi
    done
    [[ $options == *f* ]] || set +f
    return "$status"
} 

common.hctaC() {
    common_status="0"
}

common.Finally() {
    :
}

common.yllaniF() {
    [[ common_status -eq 0 ]] || throw
}

caught() {
    [[ common_status -eq 0 ]] || return 1
}

EchoExitStatus() {
    return "${1:-$?}"
}

EnableThrowOnError() {
    [[ $common_options == *e* ]] || common_options+="e"
}

DisableThrowOnError() {
    common_options="${common_options/e}"
}

GetStatus() {
    echo "$common_status"
}

SetStatus() {
    let "common_status = 10#$1"
}

GetMessage() {
    echo "${common_messages[$1]}"
}

MessageCount() {
    echo "${#common_messages[@]}"
}

CopyMessages() {
    if [[ ${#common_messages} -gt 0 ]]; then
        eval "$1=(\"\${common_messages[@]}\")"
    else
        eval "$1=()"
    fi
}

common.GetOptions() {
    local "opt"
    let "OPTIND = 1"
    let "OPTERR = 0"
    while getopts ":cdeh:ko:u:v:" opt "$@"; do
        case $opt in
        e)  [[ $common_options == *e* ]] || common_options+="e";;
        h)  common_errHandler="$OPTARG";;
        u)  common_unhandled="$OPTARG";;
        v)  common_command="$OPTARG";;
        esac
    done
    shift "$((OPTIND - 1))"
    common_fifo="$1"
    shift
    common_function="$1"
    chmod "0600" "$common_fifo"
}

DefaultUnhandled() {
    local -i "i"
    echo "-------------------------------------------------"
    echo "TryCatchFinally: Unhandeled exception occurred"
    echo "Status: $(GetStatus)"
    echo "Messages:"
    for ((i=0; i<$(MessageCount); i++)); do
        echo "$(GetMessage "$i")"
    done
    echo "-------------------------------------------------"
}

TryCatchFinally() {
    local "common_errHandler=DefaultErrHandler"
    local "common_unhandled=DefaultUnhandled"
    local "common_options="
    local "common_fifo="
    local "common_function="
    local "common_flags=$-"
    local "common_trySubshell=-1"
    local "common_subshell"
    local "common_status=0"
    local "common_command="
    local "common_messages=()"
    local "common_handler=$(trap -p ERR)"
    [[ -n $common_handler ]] || common_handler="trap ERR"
    common.GetOptions "$@"
    shift "$((OPTIND + 1))"
    [[ -z $common_command ]] || common_command+="=$"
    common_command+='("$common_function" "$@")'
    set -E
    set +e
    trap "common.ErrHandler" ERR
    try
        eval "$common_command"
    yrt
    catch; do
        "$common_unhandled" >&2
    hctac
    [[ $common_flags == *E* ]] || set +E
    [[ $common_flags != *e* ]] || set -e
    [[ $common_flags != *f* || $- == *f* ]] || set -f
    [[ $common_flags == *f* || $- != *f* ]] || set +f
    eval "$common_handler"
}

Below is an example, which assumes the above script is stored in the file named simple. The makefifo file contains the script described in this answer. The assumption is made that the file named 4444kkkkk does not exist, therefore causing an exception to occur. The error message output from the ls 4444kkkkk command is automatically suppressed until inside the appropriate catch block.

#!/bin/bash
#

if [[ $0 != ${BASH_SOURCE[0]} ]]; then
    bash "${BASH_SOURCE[0]}" "$@"
    return
fi

source simple
source makefifo

MyFunction3() {
    echo "entered MyFunction3" >&4
    echo "This is from MyFunction3"
    ls 4444kkkkk
    echo "leaving MyFunction3" >&4
}

MyFunction2() {
    echo "entered MyFunction2" >&4
    value="$(MyFunction3)"
    echo "leaving MyFunction2" >&4
}

MyFunction1() {
    echo "entered MyFunction1" >&4
    local "flag=false"
    try 
    (
        echo "start of try" >&4
        MyFunction2
        echo "end of try" >&4
    )
    yrt
    catch "[1-3]" "*" "Exception\ Type:\ ERR"; do
        echo 'start of catch "[1-3]" "*" "Exception\ Type:\ ERR"'
        local -i "i"
        echo "-------------------------------------------------"
        echo "Status: $(GetStatus)"
        echo "Messages:"
        for ((i=0; i<$(MessageCount); i++)); do
            echo "$(GetMessage "$i")"
        done
        echo "-------------------------------------------------"
        break
        echo 'end of catch "[1-3]" "*" "Exception\ Type:\ ERR"'
    hctac >&4
    catch "1 3 5" "*" -n "Exception\ Type:\ ERR"; do
        echo 'start of catch "1 3 5" "*" -n "Exception\ Type:\ ERR"'
        echo "-------------------------------------------------"
        echo "Status: $(GetStatus)"
        [[ $(MessageCount) -le 1 ]] || echo "$(GetMessage "1")"
        echo "-------------------------------------------------"
        break
        echo 'end of catch "1 3 5" "*" -n "Exception\ Type:\ ERR"'
    hctac >&4
    catch; do
        echo 'start of catch' >&4
        echo "failure"
        flag="true"
        echo 'end of catch' >&4
    hctac
    finally
        echo "in finally"
    yllanif >&4
    "$flag" || echo "success"
    echo "leaving MyFunction1" >&4
} 2>&6

ErrHandler() {
    echo "EOF"
    DefaultErrHandler "$@"
    echo "Function: $3"
    while read; do
        [[ $REPLY != *EOF ]] || break
        echo "$REPLY"
    done
}

set -u
echo "starting" >&2
MakeFIFO "6"
TryCatchFinally -e -h ErrHandler -o /dev/fd/4 -v result /dev/fd/6 MyFunction1 4>&2
echo "result=$result"
exec >&6-

The above script was tested using GNU bash, version 3.2.57(1)-release (x86_64-apple-darwin17). The output, from running this script, is shown below.

starting
entered MyFunction1
start of try
entered MyFunction2
entered MyFunction3
start of catch "[1-3]" "*" "Exception\ Type:\ ERR"
-------------------------------------------------
Status: 1
Messages:
Orginal Status: 1
Exception Type: ERR
Function: MyFunction3
ls: 4444kkkkk: No such file or directory
-------------------------------------------------
start of catch
end of catch
in finally
leaving MyFunction1
result=failure

Another example which uses a throw can be created by replacing function MyFunction3 with the script shown below.

MyFunction3() {
    echo "entered MyFunction3" >&4
    echo "This is from MyFunction3"
    throw "3" "Orginal Status: 3" "Exception Type: throw"
    echo "leaving MyFunction3" >&4
}

The syntax for the throw command is given below. If no parameters are present, then status and messages stored in the variables are used instead.

throw [status] [message ...]

The output, from executing the modified script, is shown below.

starting
entered MyFunction1
start of try
entered MyFunction2
entered MyFunction3
start of catch "1 3 5" "*" -n "Exception\ Type:\ ERR"
-------------------------------------------------
Status: 3
Exception Type: throw
-------------------------------------------------
start of catch
end of catch
in finally
leaving MyFunction1
result=failure

User · Answer

There are so many similar solutions which probably work  Below is a simple and working way to accomplish try catch  with explanation in the comments      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

User · Answer

Assuming the terminal app in question is named  app   and you expect it to be in your  PATH   if       which app      then       run code if app not installed else       run code if app is installed fi

User · Answer

bash does not abort the running execution in case something detects an error state  unless you set the -e flag    Programming languages which offer try catch do this in order to inhibit a  bailing out  because of this special situation  hence typically called  exception     In the bash  instead  only the command in question will exit with an exit code greater than 0  indicating that error state   You can check for that of course  but since there is no automatic bailing out of anything  a try catch does not make sense   It is just lacking that context   You can  however  simulate a bailing out by using sub shells which can terminate at a point you decide       echo  Do one thing    echo  Do another thing    if some condition   then     exit 3     lt -- this is our simulated bailing out   fi   echo  Do yet another thing    echo  And do a last thing         lt -- here we arrive after the simulated bailing out  and    will be 3  exit code  if        3   then   echo  Bail out detected  fi   Instead of that some condition with an if you also can just try a command  and in case it fails  has an exit code greater than 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          Unfortunately  using this technique you are restricted to 255 different exit codes  1  255  and no decent exception objects can be used   If you need more information to pass along with your simulated exception  you can use the stdout of the subshells  but that is a bit complicated and maybe another question  -   Using the above mentioned -e flag to the shell you can even strip that explicit exit statement       set -e   echo  Do one thing    echo  Do another thing    some command   echo  Do yet another thing    echo  And do a last thing

User · Answer

You can use trap   try   block A   catch   block B   finally   block C    translates to       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

User · Answer

You can do      bin bash if  lt command gt    then   TRY      lt do-whatever-you-want gt  else   CATCH     echo  Exception       lt do-whatever-you-want gt  fi

User · Answer

As everybody says  bash doesn t have a proper language-supported try catch syntax  You can launch bash with the -e argument or use set -e inside the script to abort the entire bash process if any command has a non-zero exit code   You can also set  e to temporarily allow failing commands    So  one technique to simulate a try catch block is to launch a sub-process to do the work with -e enabled  Then in the main process  check the return code of the sub-process   Bash supports heredoc strings  so you don t have to write two separate files to handle this  In the below example  the TRY heredoc will run in a separate bash instance  with -e enabled  so the sub-process will crash if any command returns a non-zero exit code  Then  back in the main process  we can check the return code to handle a catch block      bin bash  set  e bash -e  lt  lt TRY   echo hello   cd  does not exist   echo world TRY if      -ne 0    then   echo caught exception fi   It s not a proper language-supported try catch block  but it may scratch a similar itch for you

User · Answer

Below is an complete copy of the simplified script used in my other answer  Beyond additional error checking  there is an alias which allows the user to change the name of an existing alias  The syntax is given below  If the new alias parameter is omitted  then the alias is removed   ChangeAlias old alias  new alias    The complete script is given below   common GetAlias         local  oldname   1 -0       if     oldname      0-9     amp  amp  oldname 1 -lt    FUNCNAME         then         oldname    FUNCNAME oldname   1        fi     name  common   oldname common        echo     name - oldname      common Alias         if       -ne 2    -z  1    -z  2     then         echo    common GetAlias   The must be only two parameters of nonzero length   gt  amp 2         return 1      fi     eval  alias  1   2       local  f   2   common        f    f           local  v common  f      f  common  f      if    -n    v -      then         echo    common GetAlias    1  Function    f  already paired with name      v     gt  amp 2         return 1      fi     shopt -s expand aliases     eval   v    1       common ChangeAlias         if       -lt 1       -gt 2     then         echo  usage    common GetAlias  old name  new name    gt  amp 2         return  1      elif   alias   1   amp  gt   dev null   then         echo    common GetAlias    1  Name not found   gt  amp 2         return 1      fi     local  s   alias   1         s    s alias  1          s    s          local  f   s   common        f    f           local  v common  f      f  common  f      if       v -       1      then         echo    common GetAlias    1  Name not paired with a function    f    gt  amp 2         return 1      elif       -gt 1     then         eval  alias  2   s           eval   v    2        else         unset   v      fi     unalias   1     common Alias exception              common Exception  common Alias throw                  common Throw  common Alias try                      if common Try  then  common Alias yrt                    common EchoExitStatus  fi  common yrT     common Alias catch                    while common Catch  common Alias hctac                  common hctaC -r  done  common hctaC     common Alias finally                  if common Finally  then  common Alias yllanif                fi  common yllaniF     common Alias caught                 common Caught  common Alias EchoExitStatus         common EchoExitStatus  common Alias EnableThrowOnError     common EnableThrowOnError  common Alias DisableThrowOnError    common DisableThrowOnError  common Alias GetStatus              common GetStatus  common Alias SetStatus              common SetStatus  common Alias GetMessage             common GetMessage  common Alias MessageCount           common MessageCount  common Alias CopyMessages           common CopyMessages  common Alias TryCatchFinally        common TryCatchFinally  common Alias DefaultErrHandler      common DefaultErrHandler  common Alias DefaultUnhandled       common DefaultUnhandled  common Alias CallStack              common CallStack  common Alias ChangeAlias            common ChangeAlias  common Alias TryCatchFinallyAlias   common Alias   common CallStack         local -i  i   j   k   subshell   2 -0    wi   wl   wn      local  format    s    s   - s   s n   name      eval local  lineno       BASH LINENO           for    i   1 -0  j wi wl wn 0  i lt    FUNCNAME        i   j     do           name    common GetAlias   i            let  wi      j   gt  wi   wi      j    wi          let  wl      lineno i    gt  wl   wl      lineno i     wl          let  wn      name   gt  wn   wn      name    wn      done     for    i   1 -0  j 0  i lt    FUNCNAME        i   j     do           let  k      FUNCNAME     - i - 1          name    common GetAlias   i            printf   format    wi    j    wl     lineno i      wn    name     BASH SOURCE i        done    common Echo             common options     d        echo       gt   common file     common DefaultErrHandler         echo  Orginal Status   common status      echo  Exception Type  ERR     common Exception         common TryCatchFinallyVerify    return     if       -eq 0     then         echo    common GetAlias   At least one parameter is required   gt  amp 2         return  1               elif       1  -gt 16    -n   1   0-9       10  1 -lt 1    10  1 -gt 255     then         echo    common GetAlias    1  First parameter was not an integer between 1 and 255   gt  amp 2         return  1      fi     let  common status   10  1      shift     common messages        for message in       do         common messages     message       done     if     common options     c      then         echo  Call Stack    gt   common fifo          common CallStack  2   gt   common fifo      fi    common Throw         common TryCatchFinallyVerify    return     local  message      if   common TryCatchFinallyExists  then         echo    common GetAlias   No Try-Catch-Finally exists   gt  amp 2         return  1              elif       -eq 0  amp  amp  common status -eq 0     then         echo    common GetAlias   No previous unhandled exception   gt  amp 2          return  1      elif       -gt 0  amp  amp       1  -gt 16    -n   1   0-9       10  1 -lt 1    10  1 -gt 255       then         echo    common GetAlias    1  First parameter was not an integer between 1 and 255   gt  amp 2         return  1      fi     common Echo -n  In Throw    common status       common Echo  try  common trySubshell subshell  BASH SUBSHELL           if     common options     k      then         common CallStack  2   gt   common file      fi     if       -gt 0     then         let  common status   10  1          shift         for message in       do             echo   message   gt   common fifo          done         if     common options     c      then             echo  Call Stack    gt   common fifo              common CallStack  2   gt   common fifo          fi     elif       common messages     -gt 0     then         for message in    common messages       do             echo   message   gt   common fifo          done     fi     chmod  0400    common fifo      common Echo  Still in Throw    common status subshell  BASH SUBSHELL      -  -      exit   common status     common ErrHandler         common status        trap ERR     common Echo -n  In ErrHandler    common status debug  common options       common Echo  try  common trySubshell subshell  BASH SUBSHELL order  common order      if    -w   common fifo      then         if     common options     e      then             common Echo  ErrHandler is ignoring              common status  0              return   common status    value is ignored         fi         if     common options     k      then             common CallStack  2   gt   common file          fi         common Echo  Calling   common errHandler -           eval    common errHandler -      BASH LINENO 0         BASH SOURCE 1         FUNCNAME 1      gt  common fifo  lt  common fifo          if     common options     c      then             echo  Call Stack    gt   common fifo              common CallStack  2   gt   common fifo          fi         chmod  0400    common fifo      fi     common Echo  Still in ErrHandler    common status subshell  BASH SUBSHELL -  -      if    common trySubshell -eq BASH SUBSHELL     then         return   common status    value is ignored        else         exit   common status      fi    common Token         local  name      case  1 in     b  name  before        t  name   common Try        y  name   common yrT        c  name   common Catch        h  name   common hctaC        f  name   common yllaniF        l  name   common Finally           name  unknown        esac     echo   name     common TryCatchFinallyNext         common ShellInit     local  previous  common order   errmsg      common order   2      if     previous     1     then         errmsg    BASH SOURCE 2    line   BASH LINENO 1    syntax error near unexpected token     common Token   2             echo   errmsg   gt  amp 2             dev fd 2 -ef  common file       echo   errmsg   gt   common file          kill -s INT 0         return  1              fi    common ShellInit         if    common initSubshell -ne BASH SUBSHELL     then         common initSubshell   BASH SUBSHELL          common order  b      fi    common Try         common TryCatchFinallyVerify    return     common TryCatchFinallyNext   byhl    t     return      common status  0      common subshell   common trySubshell      common trySubshell   BASH SUBSHELL      common messages        common Echo  ------------- gt  Setting try  common trySubshell at subshell  BASH SUBSHELL     common yrT         local  status         common TryCatchFinallyVerify    return     common TryCatchFinallyNext   t    y     return      common Echo -n  Entered yrT    status status  common status       common Echo  try  common trySubshell subshell  BASH SUBSHELL      if    common status -ne 0     then              common Echo  Build message array     common status  subshell  BASH SUBSHELL          local  message    eof TRY CATCH FINALLY END OF MESSAGES  RANDOM          chmod  0600    common fifo          echo   eof   gt   common fifo          common messages            while read  message   do              common Echo  ---- gt   message                   message      eof       break             common messages     message           done  lt   common fifo      fi      common Echo  In ytT status  common status      common trySubshell   common subshell     common Catch         common TryCatchFinallyVerify    return     common TryCatchFinallyNext   yh    c     return         common status -ne 0       return  1      local  parameter   pattern   value      local  toggle true   compare p   options  -      local -i  i -1   status 0      set -f     for parameter in       do         if   toggle   then             toggle  false              if     parameter     - notepr       then                 compare    parameter -                   continue              fi         fi         toggle  true          while  true   do             eval local  patterns   parameter               if       patterns     -gt 0     then                 for pattern in    patterns       do                        i -lt    common messages           break                     if    i -lt 0     then                         value   common status                      else                         value    common messages i                        fi                     case  compare in                      ne         value      pattern        break 2                        op         value     pattern       break 2                        tr         value     pattern       break 2                       esac                 done             fi             if     compare     not      then                 let    i 1                  continue 2             else                 status  1                  break 2             fi         done         if     compare     not      then             status  1              break         else             let    i 1          fi     done         options     f        set  f     return   status      common hctaC         common TryCatchFinallyVerify    return     common TryCatchFinallyNext   c    h     return            -ne 1     1    -r       common status  0     common Finally         common TryCatchFinallyVerify    return     common TryCatchFinallyNext   ych    f     return     common yllaniF         common TryCatchFinallyVerify    return     common TryCatchFinallyNext   f    l     return         common status -eq 0       common Throw    common Caught         common TryCatchFinallyVerify    return        common status -eq 0       return 1    common EchoExitStatus         return    1 -        common EnableThrowOnError         common TryCatchFinallyVerify    return         common options     e        common options   e     common DisableThrowOnError         common TryCatchFinallyVerify    return     common options    common options e      common GetStatus         common TryCatchFinallyVerify    return     echo   common status     common SetStatus         common TryCatchFinallyVerify    return     if       -ne 1     then         echo    common GetAlias       Wrong number of parameters   gt  amp 2         return  1               elif       1  -gt 16    -n   1   0-9       10  1 -lt 1    10  1 -gt 255     then         echo    common GetAlias    1  First parameter was not an integer between 1 and 255   gt  amp 2         return  1      fi     let  common status   10  1     common GetMessage         common TryCatchFinallyVerify    return     local  upper    common messages          if    upper -eq 0     then         echo    common GetAlias    1  There are no messages   gt  amp 2         return  1      elif       -ne 1     then         echo    common GetAlias       Wrong number of parameters   gt  amp 2         return  1               elif       1  -gt 16    -n   1   0-9       10  1 -ge upper     then         echo    common GetAlias    1  First parameter was an invalid index   gt  amp 2         return  1      fi     echo    common messages  1       common MessageCount         common TryCatchFinallyVerify    return     echo     common messages         common CopyMessages         common TryCatchFinallyVerify    return     if       -ne 1     then         echo    common GetAlias       Wrong number of parameters   gt  amp 2         return  1               elif       common messages  -gt 0     then         eval   1       common messages             else         eval   1         fi    common TryCatchFinallyExists              common fifo -u     u       common TryCatchFinallyVerify         local  name      if   common TryCatchFinallyExists  then         echo    common GetAlias  1    No Try-Catch-Finally exists   gt  amp 2         return  2              fi    common GetOptions         local  opt      local  name   common GetAlias  1        if common TryCatchFinallyExists  then         echo   name  A Try-Catch-Finally already exists   gt  amp 2         return  1              fi     let  OPTIND   1      let  OPTERR   0      while getopts   cdeh ko u v   opt       do         case  opt in         c       common options     c        common options   c            d       common options     d        common options   d            e       common options     e        common options   e            h   common errHandler   OPTARG            k       common options     k        common options   k            o   common file   OPTARG            u   common unhandled   OPTARG            v   common command   OPTARG                 echo  Invalid option  - OPTARG   gt  amp 2             echo   name  Illegal option   OPTARG   gt  amp 2             return  1                echo   name  Option requires an argument   OPTARG   gt  amp 2             return  1                echo   name  An error occurred while parsing options    gt  amp 2             return  1            esac     done      shift     OPTIND - 1        if       -lt 1     then         echo   name  The fifo file parameter is missing   gt  amp 2         return  1      fi     common fifo   1      if      -p  common fifo     then         echo   name   1  The fifo file is not an open FIFO   gt  amp 2         return  1        fi      shift     if       -lt 1     then         echo   name  The function parameter is missing   gt  amp 2         return  1      fi     common function   1      if   chmod  0600    common fifo   then         echo   name   common fifo  Can not change file mode to 0600   gt  amp 2         return  1      fi      local  message    eof TRY CATCH FINALLY END OF FILE  RANDOM        echo   eof   gt   common fifo     2 gt   dev null      if       -ne 0     then         echo   name   common fifo  Can not write   gt  amp 2         return  1      fi          while     message      eof     do         read  message      done  lt   common fifo     2 gt   dev null      if       -ne 0     then         echo   name   common fifo  Can not read   gt  amp 2         return  1      fi         return  0     common DefaultUnhandled         local -i  i      echo  -------------------------------------------------      echo    common GetAlias  common TryCatchFinally    Unhandeled exception occurred      echo  Status    GetStatus       echo  Messages       for   i 0  i lt   MessageCount   i      do         echo    GetMessage   i        done     echo  -------------------------------------------------     common TryCatchFinally         local  common file  dev fd 2      local  common errHandler common DefaultErrHandler      local  common unhandled common DefaultUnhandled      local  common options       local  common fifo       local  common function       local  common flags  -      local  common trySubshell -1      local  common initSubshell -1      local  common subshell      local  common status 0      local  common order b      local  common command       local  common messages         local  common handler   trap -p ERR          -n  common handler       common handler  trap ERR       common GetOptions         return          shift     OPTIND   1            -z  common command       common command           common command      common function              set -E     set  e     trap  common ErrHandler  ERR     if true  then         common Try          eval   common command          common EchoExitStatus         common yrT     fi     while common Catch  do           common unhandled   gt  amp 2         break         common hctaC -r     done     common hctaC         common flags     E        set  E         common flags     e        set -e         common flags     f      -     f        set -f         common flags     f      -     f        set  f     eval   common handler      return     common status 2 0

User · Answer

I can recommend this in  quot bash -ue quot  mode  set -ue     false  amp  amp  RET       RET     echo  quot expecting 1  got   RET  quot  true  amp  amp  RET       RET     echo  quot expecting 0  got   RET  quot   echo  quot test try   catch quot  false  amp  amp  RET       RET     if     RET  -ne 0    then   echo  quot caught error   RET  quot  fi  echo  quot beware  using      before   amp  amp   fails quot  echo  quot   - gt  memory aid   A nd before  O r in the alphabet quot  false    RET     amp  amp  RET     echo  quot expecting 1  got   RET  quot  true    RET     amp  amp  RET     echo  quot expecting 0  got   RET  quot

User · Answer

And you have traps http   www tldp org LDP Bash-Beginners-Guide html sect 12 02 html which is not the same  but other technique you can use for this purpose

User · Answer

A very simple thing I use   try                  e     echo       gt   dev stderr  exit  e

User · Answer

Based on some answers I found here  I made myself a small helper file to source for my projects  trycatch sh    bin bash  function try             -    e      SAVED OPT E        set  e    function throw         exit  1    function catch         export ex code            SAVED OPT E     amp  amp  set  e     return  ex code    function throwErrors         set -e    function ignoreErrors         set  e    here is an example how it looks like in use     bin bash export AnException 100 export AnotherException 101    start with a try try       open a subshell         echo  quot do something quot        someErrorCondition    amp  amp  throw  AnException      echo  quot do something more quot      executeCommandThatMightFail    throw  AnotherException      throwErrors   automaticatly end the try block  if command-result is non-null     echo  quot now on to something completely different quot      executeCommandThatMightFail      echo  quot it s a wonder we came so far quot      executeCommandThatFailsForSure    true   ignore a single failing command      ignoreErrors   ignore failures of commands until further notice     executeCommand1ThatFailsForSure     local result     executeCommand2ThatFailsForSure        result     quot expected error quot     amp  amp  throw  AnException   ok  if it s not an expected error  we want to bail out      executeCommand3ThatFailsForSure      echo  quot finished quot      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  quot AnException was thrown quot                      AnotherException              echo  quot AnotherException was thrown quot                                    echo  quot An unexpected exception was thrown quot              throw  ex code   you can rethrow the  quot exception quot  causing the script to exit if not caught                esac

User · Answer

I ve developed an almost flawless try  amp  catch implementation in bash  that allows you to write code like   try      echo  Hello      false     echo  This will not be displayed   catch      echo  Error in    EXCEPTION SOURCE   at line     EXCEPTION LINE       You can even nest the try-catch blocks inside themselves   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         The code is a part of my bash boilerplate framework  It further extends the idea of try  amp  catch with things like error handling with backtrace and exceptions  plus some other nice features     Here s the code that s responsible just for try  amp  catch   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     amp  amp  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   gt   tmp stored exception source     fi     if      -f  tmp stored exception line     then         echo   1   gt   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     amp  amp     -f  tmp stored exception line     amp  amp     -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     Feel free to use  fork and contribute - it s on GitHub

User · Answer

Is there a TRY CATCH command in Bash    No     Bash doesn t have as many luxuries as one can find in many programming languages   There is no try catch in bash  however  one can achieve similar behavior using  amp  amp  or      Using      if command1 fails then command2 runs as follows  command1    command2   Similarly  using  amp  amp   command2 will run if command1 is successful  The closest approximation of try catch is as follows      try      command1  amp  amp       save your output           catch       save log for exception      Also bash contains some error handling mechanisms  as well   set -e   it stops your script if any simple command fails    And also why not if   else  It is your best friend

[bash] Is there a TRY CATCH command in Bash

Examples related to bash

Examples related to shell

Examples related to error-handling