J'essaye d'écrire une fonction en bash qui accédera aux arguments de ligne de commande de scripts, mais ils sont remplacés par les arguments positionnels de la fonction. Existe-t-il un moyen pour la fonction d'accéder aux arguments de ligne de commande s'ils ne sont pas passés explicitement?

# Demo function
function stuff {
  echo $0 $*
}

# Echo's the name of the script, but no command line arguments
stuff

# Echo's everything I want, but trying to avoid
stuff $*

Ma lecture du manuel bash ref dit que ce truc est capturé dans BASH_ARGV, bien qu'il parle beaucoup de "la pile".

#!/bin/bash

function argv {
    for a in ${BASH_ARGV[*]} ; do
      echo -n "$a "
    done
    echo
}

function f {
    echo f $1 $2 $3
    echo -n f ; argv
}

function g {
    echo g $1 $2 $3
    echo -n g; argv
    f
}

f boo bar baz
g goo gar gaz

Enregistrer dans f.sh

$ ./f.sh arg0 arg1 arg2
f boo bar baz
farg2 arg1 arg0 
g goo gar gaz
garg2 arg1 arg0 
f
farg2 arg1 arg0 

Si vous voulez avoir vos arguments de style C (tableau d'arguments + nombre d'arguments) vous pouvez utiliser $@et $#.

$#vous donne le nombre d'arguments.
$@vous donne tous les arguments. Vous pouvez transformer cela en un tableau en args=("$@").

Donc par exemple:

args=("$@")
echo $# arguments passed
echo ${args[0]} ${args[1]} ${args[2]}

Notez qu'il ${args[0]}s'agit en fait du 1er argument et non du nom de votre script.

#!/usr/bin/env bash

echo name of script is $0
echo first argument is $1
echo second argument is $2
echo seventeenth argument is $17
echo number of arguments is $#

Edit: s'il vous plaît voir mon commentaire sur la question

Le commentaire de Ravi est essentiellement la réponse. Les fonctions prennent leurs propres arguments. Si vous voulez qu'ils soient identiques aux arguments de ligne de commande, vous devez les transmettre. Sinon, vous appelez clairement une fonction sans arguments.

Cela dit, vous pouvez, si vous le souhaitez, stocker les arguments de ligne de commande dans un tableau global à utiliser dans d'autres fonctions:

my_function() {
    echo "stored arguments:"
    for arg in "${commandline_args[@]}"; do
        echo "    $arg"
    done
}

commandline_args=("$@")

my_function

Vous devez accéder aux arguments de ligne de commande par la commandline_argsvariable non $@, $1, $2, etc., mais ils sont disponibles. Je ne connais aucun moyen d'assigner directement le tableau d'arguments, mais si quelqu'un en connaît un, veuillez m'éclairer!

Notez également la façon dont j'ai utilisé et cité $@- c'est ainsi que vous vous assurez que les caractères spéciaux (espaces blancs) ne sont pas salis.

# Save the script arguments
SCRIPT_NAME=$0
ARG_1=$1
ARGS_ALL=$*

function stuff {
  # use script args via the variables you saved
  # or the function args via $
  echo $0 $*
} 


# Call the function with arguments
stuff 1 2 3 4

On peut aussi le faire comme ça

#!/bin/bash
# script_name function_test.sh
function argument(){
for i in $@;do
    echo $i
done;
}
argument $@

Maintenant, appelez votre script comme

./function_test.sh argument1 argument2

Vous pouvez utiliser le mot-clé shift (opérateur?) Pour les parcourir. Exemple:

#!/bin/bash
function print()
{
    while [ $# -gt 0 ]
    do
        echo $1;
        shift 1;
    done
}
print $*;

Ma solution:

Créez un script de fonction appelé plus tôt que toutes les autres fonctions sans lui passer d'arguments, comme ceci:

! / bin / bash

fonction init () {ORIGOPT = "- $ @ -"}

Après cela, vous pouvez appeler init et utiliser la variable ORIGOPT au besoin, en plus, j'attribue toujours une nouvelle variable et copie le contenu d'ORIGOPT dans mes nouvelles fonctions, de cette façon vous pouvez vous assurer que personne ne la touchera ou changes le.

J'ai ajouté des espaces et des tirets pour faciliter son analyse avec «sed -E» aussi bash ne le passera pas comme référence et fera grandir ORIGOPT à mesure que les fonctions sont appelées avec plus d'arguments.