Obtention du dernier argument passé à un script shell

$1est le premier argument.
$@est tous.

Comment trouver le dernier argument passé à un script shell?

C'est un peu un hack:

for last; do true; done
echo $last

Celui-ci est également assez portable (encore une fois, devrait fonctionner avec bash, ksh et sh) et il ne modifie pas les arguments, ce qui pourrait être agréable.

Il utilise le fait que les forboucles sont implicitement répétées si vous ne lui dites pas quoi boucler, et le fait que les variables de boucle ne sont pas délimitées: elles conservent la dernière valeur à laquelle elles ont été définies.

C'est uniquement Bash:

echo "${@: -1}"

$ set quick brown fox jumps

$ echo ${*: -1:1} # last argument
jumps

$ echo ${*: -1} # or simply
jumps

$ echo ${*: -2:1} # next to last
fox

L'espace est nécessaire pour qu'il ne soit pas interprété comme une valeur par défaut .

Notez que c'est uniquement bash.

La réponse la plus simple pour bash 3.0 ou supérieur est

_last=${!#}       # *indirect reference* to the $# variable
# or
_last=$BASH_ARGV  # official built-in (but takes more typing :)

C'est tout.

$ cat lastarg
#!/bin/bash
# echo the last arg given:
_last=${!#}
echo $_last
_last=$BASH_ARGV
echo $_last
for x; do
   echo $x
done

La sortie est:

$ lastarg 1 2 3 4 "5 6 7"
5 6 7
5 6 7
1
2
3
4
5 6 7

Utilisez l'indexation combinée à la longueur de:

echo ${@:${#@}} 

Notez que c'est uniquement bash.

Ce qui suit fonctionnera pour vous. Le @ est pour un tableau d'arguments. : signifie à. $ # est la longueur du tableau d'arguments. Le résultat est donc le dernier élément:

${@:$#} 

Exemple:

function afunction{
    echo ${@:$#} 
}
afunction -d -o local 50
#Outputs 50

Notez que c'est uniquement bash.

Trouvé ceci en cherchant à séparer le dernier argument de tous les précédents. Bien que certaines des réponses obtiennent le dernier argument, elles ne sont pas très utiles si vous avez également besoin de tous les autres arguments. Cela fonctionne beaucoup mieux:

heads=${@:1:$#-1}
tail=${@:$#}

Notez que c'est uniquement bash.

Cela fonctionne dans tous les shells compatibles POSIX:

eval last=\${$#}

Source: http://www.faqs.org/faqs/unix-faq/faq/part2/section-12.html

Voici ma solution:

• assez portable (tous les POSIX sh, bash, ksh, zsh) devraient fonctionner
• ne décale pas les arguments d'origine (décale une copie).
• n'utilise pas le mal eval
• ne parcourt pas toute la liste
• n'utilise pas d'outils externes

Code:

ntharg() {
    shift $1
    printf '%s\n' "$1"
}
LAST_ARG=`ntharg $# "$@"`

Des solutions les plus anciennes aux plus récentes:

La solution la plus portable, encore plus ancienne sh(fonctionne avec des espaces et des caractères globaux) (pas de boucle, plus rapide):

eval printf "'%s\n'" "\"\${$#}\""

Depuis la version 2.01 de bash

$ set -- The quick brown fox jumps over the lazy dog

$ printf '%s\n'     "${!#}     ${@:(-1)} ${@: -1} ${@:~0} ${!#}"
dog     dog dog dog dog

Pour ksh, zsh et bash:

$ printf '%s\n' "${@: -1}    ${@:~0}"     # the space beetwen `:`
                                          # and `-1` is a must.
dog   dog

Et pour "l'avant-dernier":

$ printf '%s\n' "${@:~1:1}"
lazy

Utilisation de printf pour contourner tous les problèmes avec des arguments qui commencent par un tiret (comme -n).

Pour tous les shells et pour les plus anciens sh(fonctionne avec des espaces et des caractères globaux) est:

$ set -- The quick brown fox jumps over the lazy dog "the * last argument"

$ eval printf "'%s\n'" "\"\${$#}\""
The last * argument

Ou, si vous souhaitez définir un lastvar:

$ eval last=\${$#}; printf '%s\n' "$last"
The last * argument

Et pour "l'avant-dernier":

$ eval printf "'%s\n'" "\"\${$(($#-1))}\""
dog

Si vous utilisez Bash> = 3.0

echo ${BASH_ARGV[0]}

Car bash, ce commentaire suggérait le très élégant:

echo "${@:$#}"

En prime, cela fonctionne également dans zsh.

shift `expr $# - 1`
echo "$1"

Cela décale les arguments du nombre d'arguments moins 1 et renvoie le premier (et le seul) argument restant, qui sera le dernier.

J'ai seulement testé en bash, mais cela devrait aussi fonctionner en sh et ksh.

Si vous voulez le faire de manière non destructive, une façon consiste à passer tous les arguments à une fonction et à renvoyer le dernier:

#!/bin/bash

last() {
        if [[ $# -ne 0 ]] ; then
            shift $(expr $# - 1)
            echo "$1"
        #else
            #do something when no arguments
        fi
}

lastvar=$(last "$@")
echo $lastvar
echo "$@"

pax> ./qq.sh 1 2 3 a b
b
1 2 3 a b

Si vous ne vous souciez pas vraiment de conserver les autres arguments, vous n'en avez pas besoin dans une fonction, mais j'ai du mal à penser à une situation où vous ne voudriez jamais conserver les autres arguments à moins qu'ils n'aient déjà été traités, auquel cas j'utiliserais la méthode process / shift / process / shift / ... pour les traiter séquentiellement.

Je suppose ici que vous souhaitez les conserver car vous n'avez pas suivi la méthode séquentielle. Cette méthode gère également le cas où il n'y a pas d'arguments, en retournant "". Vous pouvez facilement ajuster ce comportement en insérant la elseclause commentée .

Pour tcsh:

set X = `echo $* | awk -F " " '{print $NF}'`
somecommand "$X"

Je suis tout à fait sûr que ce serait une solution portable, à l'exception de l'affectation.

J'ai trouvé la réponse de @ AgileZebra (plus le commentaire de @ starfry) la plus utile, mais elle prend headsun scalaire. Un tableau est probablement plus utile:

heads=( "${@:1:$(($# - 1))}" )
tail=${@:${#@}}

Notez que c'est uniquement bash.

Une solution utilisant eval:

last=$(eval "echo \$$#")

echo $last

Après avoir lu les réponses ci-dessus, j'ai écrit un script shell Q&D (devrait fonctionner sur sh et bash) pour exécuter g ++ sur PGM.cpp pour produire une image exécutable PGM. Il suppose que le dernier argument de la ligne de commande est le nom du fichier (.cpp est facultatif) et tous les autres arguments sont des options.

#!/bin/sh
if [ $# -lt 1 ]
then
    echo "Usage: `basename $0` [opt] pgm runs g++ to compile pgm[.cpp] into pgm"
    exit 2
fi
OPT=
PGM=
# PGM is the last argument, all others are considered options
for F; do OPT="$OPT $PGM"; PGM=$F; done
DIR=`dirname $PGM`
PGM=`basename $PGM .cpp`
# put -o first so it can be overridden by -o specified in OPT
set -x
g++ -o $DIR/$PGM $OPT $DIR/$PGM.cpp

Ce qui suit prendra le LASTdernier argument sans changer l'environnement actuel:

LAST=$({
   shift $(($#-1))
   echo $1
})
echo $LAST

Si d'autres arguments ne sont plus nécessaires et peuvent être déplacés, il peut être simplifié pour:

shift $(($#-1))
echo $1

Pour des raisons de portabilité suivantes:

shift $(($#-1));

peut être remplacé par:

shift `expr $# - 1`

Remplaçant également $()par des guillemets, nous obtenons:

LAST=`{
   shift \`expr $# - 1\`
   echo $1
}`
echo $LAST

echo $argv[$#argv]

Maintenant, j'ai juste besoin d'ajouter du texte parce que ma réponse était trop courte pour être publiée. J'ai besoin d'ajouter plus de texte à modifier.

Cela fait partie de ma fonction de copie:

eval echo $(echo '$'"$#")

Pour l'utiliser dans des scripts, procédez comme suit:

a=$(eval echo $(echo '$'"$#"))

Explication (la plus imbriquée en premier):

1. $(echo '$'"$#")renvoie $[nr]où [nr]est le nombre de paramètres. Par exemple, la chaîne $123(non développée).
2. echo $123 renvoie la valeur du 123ème paramètre, lorsqu'elle est évaluée.
3. evalse développe simplement $123à la valeur du paramètre, par exemple last_arg. Ceci est interprété comme une chaîne et renvoyé.

Fonctionne avec Bash à partir de la mi-2015.

#! /bin/sh

next=$1
while [ -n "${next}" ] ; do
  last=$next
  shift
  next=$1
done

echo $last

Essayez le script ci-dessous pour trouver le dernier argument

 # cat arguments.sh
 #!/bin/bash
 if [ $# -eq 0 ]
 then
 echo "No Arguments supplied"
 else
 echo $* > .ags
 sed -e 's/ /\n/g' .ags | tac | head -n1 > .ga
 echo "Last Argument is: `cat .ga`"
 fi

Production:

 # ./arguments.sh
 No Arguments supplied

 # ./arguments.sh testing for the last argument value
 Last Argument is: value

Merci.

Il existe une manière beaucoup plus concise de procéder. Les arguments d'un script bash peuvent être introduits dans un tableau, ce qui rend le traitement des éléments beaucoup plus simple. Le script ci-dessous imprimera toujours le dernier argument passé à un script.

  argArray=( "$@" )                        # Add all script arguments to argArray
  arrayLength=${#argArray[@]}              # Get the length of the array
  lastArg=$((arrayLength - 1))             # Arrays are zero based, so last arg is -1
  echo ${argArray[$lastArg]}

Exemple de sortie

$ ./lastarg.sh 1 2 buckle my shoe
shoe

Utilisation de l'expansion des paramètres (supprimer le début correspondant):

args="$@"
last=${args##* }

Il est également facile d'obtenir tout avant-dernier:

prelast=${args% *}

Pour renvoyer le dernier argument de la dernière commande utilisée, utilisez le paramètre spécial:

$_

Dans ce cas, cela fonctionnera s'il est utilisé dans le script avant qu'une autre commande ait été invoquée.

Utilisez simplement !$.

$ mkdir folder
$ cd !$ # will run: cd folder