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:

$ bash o.sh
hello
there