Bash – When does the order of arguments matter

The cat file | command syntax is considered a Useless Use of Cat. Of all your options, it takes a performance hit because it has to spawn another process in the kernel. However insignificant this may turn out to be in the big picture, it's overhead the other forms don't have. This has been covered on questions such as: Should I care about unnecessary cats?

Between the other two forms there are virtually no performance differences. STDIN is a special file node that the process has to open and read just like any other. Passing a file name instead of STDIN just makes it open a different file.

The difference would be in what features / flexibility you are looking for.

• Passing the file name to the program would mean the input file was seekable. This may or may not matter to the program but some operations can be sped up if the stream is seekable.
• Knowing the actual input file allows your program to potentially write to it. For example sed -i for in-place editing. (Note: since this has to create a new file behind the scenes it's not a performance gain over other redirects but it is a convenience step.)
• Using shell redirects gives you the ability to concatenate multiple files or even use process redirection. sed [exp] < file1 file2 or even sed [exp] < <(grep command). Details of this use case can be found on this question: Process substitution and pipe

You can make bash do it without invoking other processes by redefining printf as a function:

printf() {  # add support for numbered conversion specifiers
    local -a args
    local opt=
    case $1 in
    -v) opt=-v$2; shift 2;;
    -*) opt=$1; shift;;
    esac
    local format=$1; shift
    while [[ $format =~ ((^|.*[^%])%)([0-9]+)\$(.*) ]]
    do
        args=("${!BASH_REMATCH[3]}" "${args[@]}")
        format=${BASH_REMATCH[1]}${BASH_REMATCH[4]}
    done
    let ${#args[@]} && set -- "${args[@]}"
    builtin printf $opt "$format" "$@"
}

This works by replacing numbered conversion specifiers in the format string with unnumbered ones while using the numbers to select arguments for a modified argument list. If no numbered conversion specifiers are present, the printf builtin will see the function's arguments as-is. Should be a drop-in replacement with very little surprising behaviour.

The possibly surprising ordering in the statement that builds the new argument list, with new arguments pushed onto the front of the args[] array instead of being appended, is needed because bash regex matching is greedy; each time around the while loop, the numbered conversion specifier it finds will be the last one remaining in the format string.

Also note that the format string recycling that the printf builtin normally performs when passed more arguments than the format string contains conversion specifiers for doesn't happen when numbered conversion specifiers are present; arguments that don't correspond to a numbered specifier are simply ignored. Given that POSIX describes the mixing of numbered and unnumbered conversion specifiers as undefined, I think that's reasonable.