Estoy intentando escribir una función en bash que acceda a los argumentos de la línea de comandos de los scripts, pero se reemplazan con los argumentos posicionales de la función. ¿Hay alguna forma de que la función acceda a los argumentos de la línea de comando si no se pasan explícitamente?

# 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 $*

Mi lectura del manual bash ref dice que estas cosas están capturadas en BASH_ARGV, aunque habla mucho de "la pila".

#!/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

Guardar en 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 desea tener sus argumentos en estilo C (matriz de argumentos + número de argumentos) puede usar $@y $#.

$#te da el número de argumentos.
$@te da todos los argumentos. Puede convertir esto en una matriz mediante args=("$@").

Así por ejemplo:

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

Tenga en cuenta que aquí ${args[0]}está el primer argumento y no el nombre de su 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 $#

Editar: consulte mi comentario sobre la pregunta

El comentario de Ravi es esencialmente la respuesta. Las funciones toman sus propios argumentos. Si desea que sean los mismos que los argumentos de la línea de comandos, debe pasarlos. De lo contrario, claramente está llamando a una función sin argumentos.

Dicho esto, si lo desea, puede almacenar los argumentos de la línea de comandos en una matriz global para usarlos en otras funciones:

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

commandline_args=("$@")

my_function

Usted tiene que acceder a los argumentos de línea de comandos a través de la commandline_argsvariable no $@, $1, $2, etc, pero están disponibles. No conozco ninguna forma de asignar directamente a la matriz de argumentos, pero si alguien conoce una, ¡ilumíneme!

Además, observe la forma en que he usado y citado $@: así es como se asegura de que los caracteres especiales (espacios en blanco) no se estropeen.

# 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

Uno puede hacerlo así también

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

Ahora llama a tu guión como

./function_test.sh argument1 argument2

Puede utilizar la palabra clave shift (¿operador?) Para recorrerlos. Ejemplo:

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

Mi solución:

Cree un script de función que se llame antes que todas las demás funciones sin pasarle ningún argumento, como este:

! / bin / bash

función init () {ORIGOPT = "- $ @ -"}

Después de eso, puede llamar a init y usar la var ORIGOPT según sea necesario, como un plus, siempre asigno una nueva var y copio el contenido de ORIGOPT en mis nuevas funciones, de esa manera puede asegurarse de que nadie lo tocará o cambialo.

Agregué espacios y guiones para que sea más fácil analizarlo con 'sed -E', además, bash no lo pasará como referencia y hará que ORIGOPT crezca a medida que las funciones se llaman con más argumentos.