Last word in argument

args=${*:3} flattens your argument list. You don’t want to do that. Consider following the pattern given below instead:

# this next line sets "$@" for testing purposes; you don't need it in real life
set -- 
  "first argument" 
  "second argument" 
  "third argument" 
  "fourth argument" 
  "fifth argument"

# trim the first two
args=( "${@:2}" )

# trim the last one
args=( "${args[@]:1:$(( ${#args[@]} - 2 ))}" )

# demonstrate the output content
printf '<%s>n' "${args[@]}"

Running the above yields the following output:

<third argument>
<fourth argument>

…and, by doing so, demonstrates that it’s correctly keeping arguments together, even when they contain spaces or wildcard characters.

For a shell completion script, you might also consider:

printf '%q ' "${args[@]}"

…which quotes content in such a way as to be eval’able by the shell.

TL;DR: In the case of export FOO=bar, bash invokes its temporary environment creation, sets FOO=bar in that environment, then yields a final command of export FOO. At that point, FOO is taken as the last argument.

Ah, the much-abused $_:

($_, an underscore.) At shell startup, set to the absolute pathname used to invoke the shell or shell script being executed as passed in the environment or argument list. Subsequently, expands to the last argument to the previous command, after expansion. Also set to the full pathname used to invoke each command executed and placed in the environment exported to that command. When checking mail, this parameter holds the name of the mail file.

Let’s look at a few variations:

$ man; echo $_
What manual page do you want?
man
$ man foo; echo $_
No manual entry for foo
foo
$ echo; echo $_

echo
$ echo bar foo; echo $_
bar foo
foo
$ foo=x eval 'echo $foo'; echo $_
x
echo $foo
$ bar() { man $1; }; echo $_
foo
$ for (( i=0; $i<0; i=i+1 )); do echo $i; done; echo $_
foo
$ bar; echo $_
What manual page do you want?
man
$ bar foo; echo $_
No manual entry for foo
foo
$ MANPATH=/tmp; echo $_

$ export MANPATH=/tmp; echo $_
MANPATH

So we see three patterns here:

• Commands invoked from the filesystem, functions, and built-ins behave as generally expected: $_ is set to the command name itself if no arguments, otherwise the last of the presented arguments.
• After function definitions, loops, and other logical constructions: $_ is not modified.
• Everything else: $_ is set to something not quite expected; weird.

I’ve instrumented the code to provide some insight into the weirdness.

$ ./bash --noprofile --norc -c 'man foo'
lastword=[man]
lastarg=[foo]
$ ./bash --noprofile --norc -c 'export FOO=bar'
lastword=[export]
lastarg=[FOO=bar]
bind_variable, name=[FOO], value=[bar]
before bind_lastarg, lastarg=[FOO]
bind_lastarg, arg=[FOO]
bind_variable, name=[_], value=[FOO]
$ ./bash --noprofile --norc -c 'declare FOO=bar'
lastword=[declare]
lastarg=[FOO=bar]
bind_variable, name=[FOO], value=[(null)]
before bind_lastarg, lastarg=[FOO=bar]
bind_lastarg, arg=[FOO=bar]
bind_variable, name=[_], value=[FOO=bar]

You can see that the parser sees the expected last argument (lastarg=) in all cases, but what happens thereafter depends on what bash thinks should happen. See execute_cmd.c, execute_simple_command().

In the case of export FOO=bar, bash makes the assignment and then exports the variable. This seems consistent with the documentation’s assertion that last argument calculated after expansion.