Estoy confundido acerca de un script bash.

Tengo el siguiente código:

function grep_search() {
    magic_way_to_define_magic_variable_$1=`ls | tail -1`
    echo $magic_variable_$1
}

Quiero poder crear un nombre de variable que contenga el primer argumento del comando y que tenga el valor de, por ejemplo, la última línea de ls.

Entonces, para ilustrar lo que quiero:

$ ls | tail -1
stack-overflow.txt

$ grep_search() open_box
stack-overflow.txt

Entonces, ¿cómo debo definir / declarar $magic_way_to_define_magic_variable_$1y cómo debo llamarlo dentro del script?

He tratado eval, ${...}, \$${...}, pero todavía estoy confundido.

Use una matriz asociativa, con nombres de comandos como claves.

# Requires bash 4, though
declare -A magic_variable=()

function grep_search() {
    magic_variable[$1]=$( ls | tail -1 )
    echo ${magic_variable[$1]}
}

Si no puede usar matrices asociativas (por ejemplo, debe admitir bash3), puede usar declarepara crear nombres de variables dinámicas:

declare "magic_variable_$1=$(ls | tail -1)"

y use la expansión de parámetros indirectos para acceder al valor.

var="magic_variable_$1"
echo "${!var}"

Ver BashFAQ: Indirección - Evaluación de variables indirectas / de referencia .

He estado buscando una mejor manera de hacerlo recientemente. La matriz asociativa sonó como una exageración para mí. Mira lo que he encontrado:

suffix=bzz
declare prefix_$suffix=mystr

...y entonces...

varname=prefix_$suffix
echo ${!varname}

Más allá de las matrices asociativas, hay varias formas de lograr variables dinámicas en Bash. Tenga en cuenta que todas estas técnicas presentan riesgos, que se analizan al final de esta respuesta.

En los siguientes ejemplos, supondré que i=37y desea alias la variable var_37cuyo nombre es el valor inicial lolilol.

Método 1. Usando una variable "puntero"

Simplemente puede almacenar el nombre de la variable en una variable de indirección, no muy diferente de un puntero en C. Bash luego tiene una sintaxis para leer la variable con alias: se ${!name}expande al valor de la variable cuyo nombre es el valor de la variable name. Puedes pensarlo como una expansión de dos etapas: se ${!name}expande a $var_37, que se expande a lolilol.

name="var_$i"
echo "$name"         # outputs “var_37”
echo "${!name}"      # outputs “lolilol”
echo "${!name%lol}"  # outputs “loli”
# etc.

Desafortunadamente, no hay una sintaxis equivalente para modificar la variable con alias. En cambio, puede lograr la asignación con uno de los siguientes trucos.

1a. Asignando coneval

evales malo, pero también es la forma más simple y portátil de lograr nuestro objetivo. Debe escapar con cuidado del lado derecho de la tarea, ya que se evaluará dos veces . Una manera fácil y sistemática de hacer esto es evaluar el lado derecho de antemano (o usar printf %q).

Y debe verificar manualmente que el lado izquierdo es un nombre de variable válido o un nombre con índice (¿y si lo fuera evil_code #?). Por el contrario, todos los otros métodos a continuación lo hacen cumplir automáticamente.

# check that name is a valid variable name:
# note: this code does not support variable_name[index]
shopt -s globasciiranges
[[ "$name" == [a-zA-Z_]*([a-zA-Z_0-9]) ]] || exit

value='babibab'
eval "$name"='$value'  # carefully escape the right-hand side!
echo "$var_37"  # outputs “babibab”

Desventajas:

• no verifica la validez del nombre de la variable.
• eval es malvado
• eval es malvado
• eval es malvado

1b. Asignando conread

La función readincorporada le permite asignar valores a una variable a la que le da el nombre, un hecho que puede explotarse junto con las siguientes cadenas:

IFS= read -r -d '' "$name" <<< 'babibab'
echo "$var_37"  # outputs “babibab\n”

La IFSparte y la opción -raseguran que el valor se asigne tal cual, mientras que la opción -d ''permite asignar valores de varias líneas. Debido a esta última opción, el comando regresa con un código de salida distinto de cero.

Tenga en cuenta que, dado que estamos usando una cadena aquí, se agrega un carácter de nueva línea al valor.

Desventajas:

• algo oscuro;
• regresa con un código de salida distinto de cero;
• agrega una nueva línea al valor.

1c. Asignando conprintf

Desde Bash 3.1 (lanzado en 2005), el printfincorporado también puede asignar su resultado a una variable cuyo nombre se le da. A diferencia de las soluciones anteriores, simplemente funciona, no se necesita ningún esfuerzo adicional para escapar de las cosas, evitar la división, etc.

printf -v "$name" '%s' 'babibab'
echo "$var_37"  # outputs “babibab”

Desventajas:

• Menos portátil (pero, bueno).

Método 2. Usando una variable de "referencia"

Desde Bash 4.3 (lanzado en 2014), el declareincorporado tiene una opción -npara crear una variable que es una "referencia de nombre" a otra variable, muy similar a las referencias de C ++. Al igual que en el Método 1, la referencia almacena el nombre de la variable con alias, pero cada vez que se accede a la referencia (ya sea para leerla o asignarla), Bash resuelve automáticamente la indirección.

Además, Bash tiene un especial y una sintaxis muy confuso para conseguir el valor de la misma referencia, juez en solitario: ${!ref}.

declare -n ref="var_$i"
echo "${!ref}"  # outputs “var_37”
echo "$ref"     # outputs “lolilol”
ref='babibab'
echo "$var_37"  # outputs “babibab”

Esto no evita las trampas que se explican a continuación, pero al menos simplifica la sintaxis.

Desventajas:

• No es portatil.

Riesgos

Todas estas técnicas de alias presentan varios riesgos. El primero es ejecutar código arbitrario cada vez que resuelve la indirección (ya sea para leer o para asignar) . De hecho, en lugar de un nombre de variable escalar, como var_37, también puede alias un subíndice de matriz, como arr[42]. Pero Bash evalúa el contenido de los corchetes cada vez que se necesita, por lo que el alias arr[$(do_evil)]tendrá efectos inesperados ... Como consecuencia, solo use estas técnicas cuando controle la procedencia del alias .

function guillemots() {
  declare -n var="$1"
  var="«${var}»"
}

arr=( aaa bbb ccc )
guillemots 'arr[1]'  # modifies the second cell of the array, as expected
guillemots 'arr[$(date>>date.out)1]'  # writes twice into date.out
            # (once when expanding var, once when assigning to it)

El segundo riesgo es crear un alias cíclico. Como las variables de Bash se identifican por su nombre y no por su alcance, puede crear inadvertidamente un alias para sí mismo (mientras piensa que alias una variable de un alcance adjunto). Esto puede suceder en particular cuando se usan nombres de variables comunes (como var). Como consecuencia, solo use estas técnicas cuando controle el nombre de la variable con alias .

function guillemots() {
  # var is intended to be local to the function,
  # aliasing a variable which comes from outside
  declare -n var="$1"
  var="«${var}»"
}

var='lolilol'
guillemots var  # Bash warnings: “var: circular name reference”
echo "$var"     # outputs anything!

Fuente:

• BashFaq / 006: ¿Cómo puedo usar variables variables (variables indirectas, punteros, referencias) o matrices asociativas?
• BashFAQ / 048: comando eval y problemas de seguridad

El siguiente ejemplo devuelve el valor de $ name_of_var

var=name_of_var
echo $(eval echo "\$$var")

Esto debería funcionar:

function grep_search() {
    declare magic_variable_$1="$(ls | tail -1)"
    echo "$(tmpvar=magic_variable_$1 && echo ${!tmpvar})"
}
grep_search var  # calling grep_search with argument "var"

Esto también funcionará

my_country_code="green"
x="country"

eval z='$'my_"$x"_code
echo $z                 ## o/p: green

En tu caso

eval final_val='$'magic_way_to_define_magic_variable_"$1"
echo $final_val

Según BashFAQ / 006 , se puede utilizar readcon aquí sintaxis de cadena para la asignación de las variables indirectas:

function grep_search() {
  read "$1" <<<$(ls | tail -1);
}

Uso:

$ grep_search open_box
$ echo $open_box
stack-overflow.txt

Utilizar declare

No es necesario usar prefijos como en otras respuestas, ni matrices. Utilice sólo declare, comillas dobles , y la expansión de parámetros .

A menudo utilizo el siguiente truco para analizar listas de argumentos que contienen one to nargumentos formateados como key=value otherkey=othervalue etc=etc, Me gusta:

# brace expansion just to exemplify
for variable in {one=foo,two=bar,ninja=tip}
do
  declare "${variable%=*}=${variable#*=}"
done
echo $one $two $ninja 
# foo bar tip

Pero expandiendo la lista argv como

for v in "$@"; do declare "${v%=*}=${v#*=}"; done

Consejos extra

# parse argv's leading key=value parameters
for v in "$@"; do
  case "$v" in ?*=?*) declare "${v%=*}=${v#*=}";; *) break;; esac
done
# consume argv's leading key=value parameters
while (( $# )); do
  case "$v" in ?*=?*) declare "${v%=*}=${v#*=}";; *) break;; esac
  shift
done

¡Guau, la mayor parte de la sintaxis es horrible! Aquí hay una solución con una sintaxis más simple si necesita hacer referencia indirectamente a matrices:

#!/bin/bash

foo_1=("fff" "ddd") ;
foo_2=("ggg" "ccc") ;

for i in 1 2 ;
do
    eval mine=( \${foo_$i[@]} ) ;
    echo ${mine[@]} ;
done ;

Para casos de uso más simples, recomiendo la sintaxis descrita en la Guía avanzada de secuencias de comandos Bash .

Para las matrices indexadas, puede hacer referencia a ellas de esta manera:

foo=(a b c)
bar=(d e f)

for arr_var in 'foo' 'bar'; do
    declare -a 'arr=("${'"$arr_var"'[@]}")'
    # do something with $arr
    echo "\$$arr_var contains:"
    for char in "${arr[@]}"; do
        echo "$char"
    done
done

Las matrices asociativas se pueden referenciar de manera similar, pero necesitan -Aactivarse en declarelugar de -a.

Un método adicional que no depende de la versión de shell / bash que tiene es mediante el uso envsubst. Por ejemplo:

newvar=$(echo '$magic_variable_'"${dynamic_part}" | envsubst)

Quiero poder crear un nombre de variable que contenga el primer argumento del comando

script.sh expediente:

#!/usr/bin/env bash
function grep_search() {
  eval $1=$(ls | tail -1)
}

Prueba:

$ source script.sh
$ grep_search open_box
$ echo $open_box
script.sh

Según help eval:

Ejecute argumentos como un comando de shell.

También puede usar ${!var}la expansión indirecta de Bash , como ya se mencionó, sin embargo, no admite la recuperación de índices de matriz.

Para más información o ejemplos, consulte BashFAQ / 006 sobre Indirección .

No conocemos ningún truco que pueda duplicar esa funcionalidad en POSIX o Bourne shells sin ella eval, lo que puede ser difícil de hacer de forma segura. Por lo tanto, considere esto como un uso bajo su propio riesgo .

Sin embargo, debe volver a considerar el uso de la indirección según las siguientes notas.

Normalmente, en las secuencias de comandos bash, no necesitará referencias indirectas en absoluto. En general, las personas ven esto como una solución cuando no entienden o conocen las matrices de Bash o no han considerado completamente otras características de Bash, como las funciones.

Poner nombres de variables o cualquier otra sintaxis bash dentro de los parámetros con frecuencia se realiza de manera incorrecta y en situaciones inapropiadas para resolver problemas que tienen mejores soluciones. Viola la separación entre el código y los datos y, como tal, lo coloca en una pendiente resbaladiza hacia errores y problemas de seguridad. La indirecta puede hacer que su código sea menos transparente y más difícil de seguir.

para el varname=$prefix_suffixformato, solo use:

varname=${prefix}_suffix