How would you exit out of a function if a condition is true without killing the whole script, just return back to before you called the function.
Example
# Start script
Do scripty stuff here
Ok now lets call FUNCT
FUNCT
Here is A to come back to
function FUNCT {
if [ blah is false ]; then
exit the function and go up to A
else
keep running the function
fi
}
Use:
return [n]
From help return
return: return [n]
Return from a shell function. Causes a function or sourced script to exit with the return value specified by N. If N is omitted, the return status is that of the last command executed within the function or script. Exit Status: Returns N, or failure if the shell is not executing a function or script.
set -e set at the top of your script and your return 1 or any other number besides 0, your entire script will exit.
|| then it's possible to return a nonzero code and still have the script continue to execute.set -e and returning non-zero values, as that caught me by surprise in the past.Use return operator:
function FUNCT {
if [ blah is false ]; then
return 1 # or return 0, or even you can omit the argument.
else
keep running the function
fi
}
EDIT: The following hack does exit the entire script. It's only useful in interactive settings.
If you want to return from an outer function with an error without exiting you can use this trick:
do-something-complex() {
# Using `return` here would only return from `fail`, not from `do-something-complex`.
# Using `exit` would close the entire shell.
# So we (ab)use a different feature. :)
fail() { : "${__fail_fast:?$1}"; }
nested-func() {
try-this || fail "This didn't work"
try-that || fail "That didn't work"
}
nested-func
}
Trying it out:
$ do-something-complex
try-this: command not found
bash: __fail_fast: This didn't work
This has the added benefit/drawback that you can optionally turn off this feature: __fail_fast=x do-something-complex.
Note that this causes the outermost function to return 1.
fail, what is the colon doing here?
: is a built-in bash operator that is a "no-op". It evaluates the expression but doesn't do anything with it. I'm using it to do variable substitution that will fail if the variable isn't defined, which it obviously isn't.
My use case is to run the function unless it's already running. I'm doing
mkdir /tmp/nice_exit || return 0
And then at the end of the function
rm -rf /tmp/nice_exit
rmdir instead of rm -rf. Your function will also never run anymore if an unexpected error or oversight causes it to stop without deleting that directory (function returns, program or system exits/crashes/is powered off...) For these reasons you might want to use a lock file with flock(1) instead.
I found the above examples incomplete. And tbh confusing.
function test() { [[ 5 -eq 5 ]] && return 0 || return 1 ; } ; test ; echo $?
function test() { [[ 5 -eq 3 ]] && return 0 || return 1 ; } ; test ; echo $?
will print
0
1
funcname() without function to have modern POSIX syntax, or function funcname without () for 80s ksh syntax.test() { [[ 5 -eq 5 ]]; }, or the second from test() { ! [[ 5 -eq 5 ]]; } -- all the && and || in this answer is completely redundant. (The default return value of a function is always $?; that's also true when you call return with no arguments)