How to get the last argument to a /bin/sh function

Question

What's a better way to implement print_last_arg?

#!/bin/sh

print_last_arg () {
    eval "echo \${$#}"  # this hurts
}

print_last_arg foo bar baz
# baz

(If this were, say, #!/usr/bin/zsh instead of #!/bin/sh I'd know what to do. My problem is finding a reasonable way to implement this for #!/bin/sh.)

EDIT: The above is only a silly example. My goal is not to print the last argument, but rather to have a way to refer to the last argument within a shell function.

---

EDIT2: I apologize for such an unclearly worded question. I hope to get it right this time.

If this were /bin/zsh instead of /bin/sh, I could write something like this

#!/bin/zsh

print_last_arg () {
    local last_arg=$argv[$#]
    echo $last_arg
}

The expression $argv[$#] is an example of what I described in my first EDIT as a way to refer to the last argument within a shell function.

Therefore, I really should have written my original example like this:

print_last_arg () {
    local last_arg=$(eval "echo \${$#}")   # but this hurts even more
    echo $last_arg
}

...to make it clear that what I'm after is a less awful thing to put to the right of the assignment.

Note, however, that in all the examples, the last argument is accessed non-destructively. IOW, the accessing of the last argument leaves the positional arguments as a whole unaffected.

Answer 1

Given the example of the opening post (positional arguments without spaces):

print_last_arg foo bar baz

For the default IFS=' \t\n', how about:

args="$*" && printf '%s\n' "${args##* }"

For a safer expansion of "$*", set IFS (per @StéphaneChazelas):

( IFS=' ' args="$*" && printf '%s\n' "${args##* }" )

But the above will fail if your positional arguments can contain spaces. In that case, use this instead:

for a in "$@"; do : ; done && printf '%s\n' "$a"

Note that these techniques avoid the use of eval and do not have side-effects.

Tested at shellcheck.net

Answer 2

Although this question is just over 2 years old, I thought I’d share a somewhat compacter option.

print_last_arg () {
    echo "${@:${#@}:${#@}}"
}

Let’s run it

print_last_arg foo bar baz
baz

Bash shell parameter expansion.

Edit

Even more concise: echo "${@: -1}"

(Mind the space)

Source

Tested on macOS 10.12.6 but should also return the last argument on most available *nix flavors...

Hurts much less ¯\_(ツ)_/¯

Answer 3

Here's a simplistic way:

print_last_arg () {
  if [ "$#" -gt 0 ]
  then
    s=$(( $# - 1 ))
  else
    s=0
  fi
  shift "$s"
  echo "$1"
}

(updated based on @cuonglm's point that the original failed when passed no arguments; this now echos a blank line -- change that behavior in the else clause if desired)

Answer 4

POSIXly:

while [ "$#" -gt 1 ]; do
  shift
done

printf '%s\n' "$1"

(This approach also works in old Bourne shell)

With other standard tools:

awk 'BEGIN{print ARGV[ARGC-1]}' "$@"

(This won't work with old awk, which did not have ARGV)

Answer 5

This should work with any POSIX compliant shell and will work too with the pre POSIX legacy Solaris Bourne shell:

do=;for do do :;done;printf "%s\n" "$do"

and here is a function based on the same approach:

print_last_arg()
  if [ "$*" ]; then
    for do do :;done
    printf "%s\n" "$do"
  else
    echo
  fi

PS: don't tell me I forgot the curly braces around the function body ;-)

Answer 6

From "Unix - Frequently Asked Questions"

(1)

unset last
if    [ $# -gt 0 ]
then  eval last=\${$#}
fi
echo  "$last"

If the number of arguments could be zero, then argument zero $0 (usually the name of the script) will be assigned to $last. That's the reason for the if.

(2)

unset last
for   last
do    :
done
echo  "$last"

(3)

for     i
do
        third_last=$second_last
        second_last=$last
        last=$i
done
echo    "$last"

To avoid printing an empty line when there are no arguments, replace the echo "$last" for:

${last+false} || echo "${last}"

A zero argument count is avoided by if [ $# -gt 0 ].

This is a not an exact copy of what is in the linked in the page, some improvements were added.

Answer 7

eval printf %s${1+"'\n' \"the last arg is \${$#"\}\"}

...will either print the string the last arg is followed by a <space>, the value of the last argument, and a trailing <newline> if there is at least 1 argument, or else, for zero arguments, it will print nothing at all.

If you did:

eval ${1+"lastarg=\${$#"\}}

...then either you would assign the value of the last argument to the shell variable $lastarg if there is at least 1 argument, or you would do nothing at all. Either way, you would do it safely, and it ought to be portable even to ye Olde Bourne shell, I think.

Here's another one that would work similarly, though it does require copying the whole arg array twice (and requires a printf in $PATH for the Bourne shell):

if   [ "${1+:}" ]
then set "$#" "$@" "$@"
     shift    "$1"
     printf %s\\n "$1"
     shift
fi

Answer 8

A simple concept, no arithmetic, no loop, no eval, just functions.
Remember that Bourne shell had no arithmetic (needed external expr). If wanting to get an arithmetic free, eval free choice, this is an option. Needing functions means SVR3 or above (no overwrite of parameters).
Look below for a more robust version with printf.

printlast(){
    shift "$1"
    echo "$1"
}
printlast "$#" "$@"          ### you may use ${1+"$@"} here to allow
                             ### a Bourne empty list of arguments,
                             ### but wait for a correct solution below.

This structure to call printlast is fixed, the arguments need to be set in the list of shell arguments $1, $2, etc. (the argument stack) and the call done as given.

If the list of arguments needs to be changed, just set them:

set -- o1e t2o t3r f4u
printlast "$#" "$@"

Or create an easier to use function (getlast) that could allow generic arguments (but not as fast, arguments are passed two times).

getlast(){ printlast "$#" "$@"; }
getlast o1e t2o t3r f4u

Please note that arguments (of getlast, or all included in $@ for printlast) could have spaces, newlines, etc. But not NUL.

Better

This version does not print 0 when the list of arguments is empty, and use the more robust printf (fall back to echo if external printf is not available for old shells).

printlast(){ shift  "$1"; printf '%s' "$1"; }
getlast  ()  if     [ $# -gt 0 ]
             then   printlast "$#" "$@"
                    echo    ### optional if a trailing newline is wanted.
             fi
### The {} braces were removed on purpose.
getlast 1 2 3 4    # will print 4

Using EVAL.

If the Bourne shell is even older and there are no functions, or if for some reason using eval is the only option:

To print the value:

if    [ $# -gt 0 ]
then  eval printf "'1%s\n'" \"\$\{$#\}\"
fi

To set the value in a variable:

if    [ $# -gt 0 ]
then  eval 'last_arg='\"\$\{$#\}\"
fi

If that needs to be done in a function, the arguments need to be copied to the function:

print_last_arg () {
    local last_arg                ### local only works on more modern shells.
    eval 'last_arg='\"\$\{$#\}\"
    echo "last_arg3=$last_arg"
}
print_last_arg "$@"               ### Shell arguments are sent to the function.

Answer 9

This should work on all systems with perl installed (so most UNICES):

print_last_arg () {
    printf '%s\0' "$@" | perl -0ne 's/\0//;$l=$_;}{print "$l\n"'
}

The trick is to use printf to add a \0 after each shell argument and then perl's -0 switch which sets its record separator to NULL. Then we iterate over the input, remove the \0 and saving each NULL-terminated line as $l. The END block (that's what the }{ is) will be executed after all input has been read so will print the last "line": the last shell argument.

Answer 10

Here's a version using recursion. No idea how POSIX compliant this is though...

print_last_arg()
{
    if [ $# -gt 1 ] ; then
        shift
        echo $( print_last_arg "$@" )
    else
        echo "$1"
    fi
}

Answer 11

This comment suggested to use the very elegant:

echo "${@:$#}"