Everybody's seen redirection in bash commands, that's pretty common, but bash also allows you to define redirections when you define functions. This causes the redirections to be evaluated/executed whenever the function is called. This feature doesn't really give you any new features, just another way to express existing features.

The syntax for this is simple, you simply append the redirections onto the end of the function defintion:

function testy () { ... } < testy.in > testy.out 2> testy.err

Now whenever the function testy is called its input will come from testy.in , its output will go to testy.out and any errors will go to testy.err .

Since the redirections are evaluated when the function is called the redirection(s) can use variables and the variables are also evaluated when the function is called. So you could do something like this:

#!/bin/bash function testy () { echo testy westy } > $out out = jj1 testy out = jj2 testy

This causes the output of the function to go to a different file with each call. The first call's output goes to jj1 and the second's to jj2 :

$ bash j.sh; more jj? :::::::::::::: jj1 :::::::::::::: testy westy :::::::::::::: jj2 :::::::::::::: testy westy

As I mentioned earlier, there's not any real new capability here, you could also accomplish the same thing this way:

#!/bin/bash function testy () { echo testy westy } testy >jj1 testy >jj2

One possible use of this feature might be to put all your code inside a main function and then redirect it's error output so that you make sure it always gets captured:

#!/bin/bash log = kk function error () { echo "$*" >&2 } function testy () { error testy westy } function testy2 () { error testy2 westy2 } function main () { testy testy2 } 2> $log main

Running this produces:

$ bash k.sh ;cat kk testy westy testy2 westy2

Since bash also allows redirection to be included on {...} blocks/lists you could accomplish the same thing with the following:

#!/bin/bash log = mm function error () { echo "$*" >&2 } function testy () { error testy westy } function testy2 () { error testy2 westy2 } { testy testy2 } 2> $log

You can also use redirections on (...) blocks/lists but that causes the commands to be executed in a sub-shell, which isn't necessary here and which may cause problems since the sub-shell is a different process.

If you're wondering if you can override the redirections in the actual call, the answer is no. If you try to override them all that happens is that redirections in the call are executed/evaluated first then the ones in the function definition replace them. For example, in the following:

#!/bin/bash function testy () { echo testy westy } >nn1 testy >nn2

The output file specified in the call ( nn2 ) gets created but nothing gets written to it.

Also note that pipe "redirections" do not work, but here documents do:

#!/bin/bash function testy () { while read line do echo $line done } <<EOF hello there EOF testy

Running this produces: