Differences between revisions 5 and 6
Revision 5 as of 2008-11-22 14:09:52
Size: 2321
Editor: localhost
Comment: converted to 1.6 markup
Revision 6 as of 2008-11-22 23:28:52
Size: 2331
Editor: GreyCat
Comment: first-line and }}}
Deletions are marked like this. Additions are marked like this.
Line 3: Line 3:

Functions in Bash (as well as all the other Bourne-family shells) work like commands; that is, they only "return" an exit status, which is an integer from 0 to 255 inclusive. This is intended to be used only for signaling errors, not for returning the results of computations, or other data.
Functions in Bash (as well as all the other Bourne-family shells) work like commands: that is, they only "return" an exit status, which is an integer from 0 to 255 inclusive. This is intended to be used only for signaling errors, not for returning the results of computations, or other data.
Line 14: Line 13:
  echo "foo returned '$x'"}}}   echo "foo returned '$x'"
  
}}}
Line 23: Line 23:
  echo "foo returned '$RETURN'"}}}   echo "foo returned '$RETURN'"
  
}}}
Line 37: Line 38:
  # would have been error checking, and a trap.}}}   # would have been error checking, and a trap.
  
}}}

How do I return a string from a function? "return" only lets me give a number.

Functions in Bash (as well as all the other Bourne-family shells) work like commands: that is, they only "return" an exit status, which is an integer from 0 to 255 inclusive. This is intended to be used only for signaling errors, not for returning the results of computations, or other data.

If you need to send back arbitrary data from a function to its caller, there are at least three methods by which this can be achieved:

  • You may have your function write the data to stdout, and then have the caller capture stdout.
    •   foo() {
           echo "this is my data"
        }
        x=$(foo)
        echo "foo returned '$x'"

    The drawback of this method is that the function is executed in a SubShell, which means that any variable assignments, etc. performed in the function will not take effect in the caller's environment. This may or may not be a problem, depending on the needs of your program and your function.

  • You may assign data to global variables, and then refer to those variables in the caller.
    •   foo() {
           RETURN="this is my data"
        }
        foo
        echo "foo returned '$RETURN'"

    The drawback of this method is that, if the function is executed in a subshell, then the assignment to a global variable inside the function will not be seen by the caller. This means you would not be able to use the function in a pipeline, for example.

  • Your function may write its data to a file, from which the caller can read it.
    •   foo() {
           echo "this is my data" > "$1"
        }
        # This is NOT solid code for handling temp files!
        TMPFILE=$(mktemp)   # GNU/Linux
        foo "$TMPFILE"
        echo "foo returned '$(<"$TMPFILE")'"
        rm "$TMPFILE"
        # In the event that this were a real program, there
        # would have been error checking, and a trap.
    The drawbacks of this method should be obvious: you need to manage a temporary file, which is always inconvenient; there must be a writable directory somewhere, and sufficient space to hold the data therein; etc. On the positive side, it will work regardless of whether your function is executed in a subshell.

    For more information about handling temporary files within a shell script, see FAQ 62.

BashFAQ/084 (last edited 2022-11-14 19:36:10 by GreyCat)