Bash scripting: Last line - "exit" - necessary?

Question

another basic, innocent question: When you make a bash script, you could close it with, you could type in as last line of the script, exit,

echo "Hello world!"
exit

, is it advised, should one generally close a script with exit?

I could imagine, that basically from IT-security perspective it's better to set a definitive end to a script. I could imagine, that otherwise it would be an open end, never closing, always luring in the background, and potentially could be exploited somehow, or simply just wasting resources…

Answer 1

An exit statement on the last line of a script is not necessary unless you want the script to terminate with some specific exit status, in which case you may want to use e.g. exit 0 to signal "success" or exit 1 to signal "failure", to the caller.

Without an argument, exit will terminate the script with whatever value $? is, i.e., with the exit status of whatever was the last command to execute (echo in your example). This also happens by default when the script runs to its end. An explicit exit or exit "$?" is therefore never needed.

This also applies to return in shell functions and in "dot-scripts" (scripts executed via . or the non-standard source). That is, the exit status of a shell function call or a dot-script is the exit status of the last executed command. An explicit return without argument is never necessary at the end of a shell function or dot-script. You would only use return to exit the function before its end and/or to exit the function with an explicit exit status.

Answer 2

That's not really useful and can be counterproductive.

When a shell reaches the end of its input, it exits already with the exit status of the last command that it ran. exit without a number also exits with the exit status of the last run command.

If you add that exit, then that script can't be sourced any longer as exit would exit the shell that sources your script.

Or it would prevent bash from interpreting another-script in:

cat that-script another-script | bash

IIRC, there used to be some old versions of some shells where the EXIT trap would only be run upon an actual exit call, so using exit could have been useful there.

Using exit could be useful in some use cases where you want to be able to instrument your script for a reason or another. In POSIX sh implementations, exit can't be redefined as a function as it's a special builtin. It can be redefined as an alias though. In bash, unless in POSIX mode, alias expansion is not performed in non-interactive invocations (such as in scripts) unless turned on explicitly, but, if POSIX mode is not enabled, it will let you redefine exit as a function, and even inherit an exit function from the environment.

So for instance, running your script as:

env 'BASH_FUNC_exit%%=() {
      echo>&2 "Exiting now."
      builtin exit "$@"
    }' ./your-script

Would output Exiting now. upon any exit, including the one added at the end.

Using exit can be useful when written:

#! /bin/bash -
{
  # contents of the script here
  ...
  exit
}

That kind of trick is useful when you want to guard against the script being overwritten whilst it's being run. Here, bash needs to read the script up to the closing } (and store its interpreted code in memory) before doing anything, and because of that trailing exit, after it has done that, it will not read the script any more.