Les expressions d'expansion de paramètres $ {var} peuvent-elles être imbriquées dans bash?

Question

Ce que j'est ceci:

progname=${0%.*} 
progname=${progname##*/} 

peut-il être imbriquées (ou non) en une seule ligne, à savoir une seule expression?

J'essaie de supprimer le chemin et l'extension d'un nom de script afin que seul le nom de base reste. Les deux lignes ci-dessus fonctionnent bien. La nature de mon «C» me pousse simplement à masquer ces choses encore plus.

Answer 1

Si par nid, vous voulez dire quelque chose comme ceci:

#!/bin/bash 

export HELLO="HELLO" 
export HELLOWORLD="Hello, world!" 

echo ${${HELLO}WORLD}

Alors non, vous pouvez 't nest ${var} expressions. L'expéditeur de syntaxe bash ne le comprendra pas. Cependant, si je comprends bien votre problème, vous pouvez utiliser la commande basename - elle supprime le chemin d'accès d'un nom de fichier donné et, en cas d'extension de l'extension, va également le dépouiller. Par exemple, l'exécution basename /some/path/to/script.sh .sh renverra script.

Answer 2

Cette imbrication ne semble pas être possible dans bash, mais il travaille dans zsh:

progname=${${0%.*}##*/} 

Answer 3

Le bultin basename pourrait aider à cela, puisque vous partagez spécifiquement sur/dans une partie:

user@host# var=/path/to/file.extension 
user@host# basename ${var%%.*} 
file 
user@host# 

Ce n'est pas vraiment plus rapide que la variante deux lignes, mais il est juste une ligne à l'aide intégré dans la fonctionnalité. Ou, utilisez zsh/ksh qui peut faire l'imbrication du motif. :)

Answer 4

Je sais que c'est un fil ancien, mais voici mes 2 cents.

Voici un (certes kludgy) fonction bash qui permet la fonctionnalité requise:

read_var() { 
    set | grep ^$1\\b | sed s/^$1=// 
} 

Voici un script de test court:

#!/bin/bash 

read_var() { 
    set | grep ^$1\\b | sed s/^$1=// 
} 

FOO=12 
BAR=34 

ABC_VAR=FOO 
DEF_VAR=BAR 

for a in ABC DEF; do 
    echo $a = $(read_var $(read_var ${a}_VAR)) 
done 

La sortie est, comme prévu:

ABC = 12 
DEF = 34 

Answer 5

Bash prend en charge l'expansion indirecte:

$ FOO_BAR="foobar" 
$ foo=FOO 
$ foobar=${foo}_BAR 
$ echo ${foobar} 
FOO_BAR 
$ echo ${!foobar} 
foobar 

Ceci devrait soutenir l'imbrication que vous recherchez.

Answer 6

En fait, il est possible de créer des variables imbriquées dans bash, en utilisant deux étapes.

Voici un script de test basé sur le message de Tim, en utilisant l'idée suggérée par l'utilisateur1956358.

#!/bin/bash 
export HELLO="HELLO" 
export HELLOWORLD="Hello, world!" 

# This command does not work properly in bash 
echo ${${HELLO}WORLD} 

# However, a two-step process does work 
export TEMP=${HELLO}WORLD 
echo ${!TEMP} 

La sortie est:

Hello, world! 

Il y a beaucoup de trucs soignées expliqué en exécutant 'd'info bash' de la ligne de commande, la recherche puis pour 'extension paramètre Shell'. J'en ai lu quelques-uns aujourd'hui, j'ai perdu environ 20 minutes de ma journée, mais mes scripts vont s'améliorer ...

Mise à jour: Après une lecture plus approfondie, je suggère cette alternative par question initiale.

progname=${0##*/} 

Il retourne

bash 

Answer 7

expressions comme ${${a}} ne fonctionnent pas. Pour contourner, vous pouvez utiliser eval:

b=value 
a=b 
eval aval=\$$a 
echo $aval 

sortie est

value

Answer 8

Si la motivation est de « obscurcir » (je dirais Streamline) le traitement du tableau dans l'esprit de Python " compréhensions ", créer une fonction d'assistance qui effectue les opérations en séquence.

function fixupnames() 
    { 
    pre=$1 ; suf=$2 ; shift ; shift ; args=($@) 
    args=(${args[@]/#/${pre}-}) 
    args=(${args[@]/%/-${suf}}) 
    echo ${args[@]} 
    } 

Vous pouvez utiliser le résultat avec un joli liner.

$ echo $(fixupnames a b abc def ghi) 
a-abc-b a-def-b a-ghi-b 

Answer 9

Un vieux fil, mais peut-être la réponse est l'utilisation de Indirection: {! PARAMETER} $

Pour exemple, tenez compte des lignes suivantes:

H="abc" 
PARAM="H" 
echo ${!PARAM} #gives abc 

Answer 10

L'option suivante a travaillé pour moi:

NAME="par1-par2-par3" 
    echo $(TMP=${NAME%-*};echo ${TMP##*-}) 

sortie est:

par2 

Answer 11

eval vous permettra de faire ce que vous voulez:

export HELLO="HELLO" 
export HELLOWORLD="Hello, world!" 

eval echo "\${${HELLO}WORLD}" 

Sortie: Hello, world

Answer 12

Il y a une solution à 1 ligne à la question initiale de l'OP, le nom de base d'un script avec le fichier l'extension dépouillé:

progname=$(tmp=${0%.*} ; echo ${tmp##*/}) 

Voici une autre, mais, en utilisant un tricheur pour basename:

progname=$(basename ${0%.*}) 

D'autres réponses sont égarés loin de la question initiale de l'OP et vise à déterminer s'il est possible d'élargir simplement le résultat des expressions avec ${!var} mais il est venu à travers la limitation que var doit correspondre explicitement un nom de variable.Cela dit, rien ne vous empêche d'avoir une réponse 1-ligne si vous enchaînez les expressions avec un point-virgule.

ANIMAL=CAT 
BABYCAT=KITTEN 
tmp=BABY${ANIMAL} ; ANSWER=${!tmp} # ANSWER=KITTEN 

Si vous voulez faire cela apparaître comme une seule déclaration, vous pouvez imbriquer dans un sous-shell, à savoir

ANSWER=$(tmp=BABY${ANIMAL) ; echo ${!tmp}) # ANSWER=KITTEN 

Une utilisation intéressante est celle des travaux indirection sur des arguments d'une fonction bash. Ensuite, vous pouvez imbriquer votre fonction bash appelle à réaliser indirection imbriquée à plusieurs niveaux parce que nous sommes autorisés à faire des commandes imbriquées:

Voici une démonstration de indirection d'une expression:

deref() { echo ${!1} ; } 
ANIMAL=CAT 
BABYCAT=KITTEN 
deref BABY${ANIMAL} # Outputs: KITTEN 

Voici une démonstration de plusieurs niveaux indirection par le biais de commandes imbriquées:

deref() { echo ${!1} ; } 
export AA=BB 
export BB=CC 
export CC=Hiya 
deref AA # Outputs: BB 
deref $(deref AA) # Outputs: CC 
deref $(deref $(deref AA)) # Outputs: Hiya