Can ${var} parameter expansion expressions be nested in bash?

What I have is this:

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

Can this be nested (or not) into one line, i.e. a single expression?

I'm trying to strip the path and extension off of a script name so that only the base name is left. The above two lines work fine. My 'C' nature is simply driving me to obfuscate these even more.

Bash supports indirect expansion:

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

This should support the nesting you are looking for.

If by nest, you mean something like this:

#!/bin/bash




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




echo ${${HELLO}WORLD}
echo ${${HELLO}WORLD}

Then no, you can't nest ${var} expressions. The bash syntax expander won't understand it.

However, if I understand your problem right, you might look at using the basename command - it strips the path from a given filename, and if given the extension, will strip that also. For example, running basename /some/path/to/script.sh .sh will return script.

The following option has worked for me:

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

Output is:

par2

An old thread but perhaps the answer is the use of Indirection:${!PARAMETER}

For e.g., consider the following lines:

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

This nesting does not appear to be possible in bash, but it works in zsh:

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

Expressions like ${${a}} do not work. To work around it, you can use eval:

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

Output is

value

Actually it is possible to create nested variables in bash, using two steps.

Here is a test script based upon the post by Tim, using the idea suggested by user1956358.

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

The output is:

Hello, world!

There are lots of neat tricks explained by running 'info bash' from the command line, then searching for 'Shell Parameter Expansion'. I've been reading a few myself today, just lost about 20 minutes of my day, but my scripts are going to get a lot better...

Update: After more reading I suggest this alternative per your initial question.

progname=${0##*/}

It returns

bash

There is a 1 line solution to the OP's original question, the basename of a script with the file extension stripped:

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

Here's another, but, using a cheat for basename:

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

Other answers have wandered away from the OP's original question and focused on whether it's possible to just expand the result of expressions with ${!var} but came across the limitation that var must explicitly match an variable name. Having said that, there's nothing stopping you having a 1-liner answer if you chain the expressions together with a semicolon.

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

If you want to make this appear like a single statement, you can nest it in a subshell, i.e.

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

An interesting usage is indirection works on arguments of a bash function. Then, you can nest your bash function calls to achieve multilevel nested indirection because we are allowed to do nested commands:

Here's a demonstration of indirection of an expression:

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

Here's a demonstration of multi level indirection thru nested commands:

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

As there is already a lot of answer there, I just want to present two different ways for doing both: nesting parameter expansion and variable name manipulation. (So you will find four different answer there:).

Parameter expansion not really nested, but done in one line:

Without semicolon (;) nor newline:

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

Another way: you could use a fork to basename

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

This will make the job.

About concatenating variable name

If you want to construct varname, you could

use indirect expansion

foobar="baz"
varname="foo"
varname+="bar"
echo ${!varname}
baz

or use nameref

foobar="baz"
bar="foo"
declare -n reffoobar=${bar}bar
echo $reffoobar
baz

I know this is an ancient thread, but here are my 2 cents.

Here's an (admittedly kludgy) bash function which allows for the required functionality:

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

Here's a short test script:

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

The output is, as expected:

ABC = 12
DEF = 34

It will work if you follow the bellow shown way of taking on intermediate step :

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

varname=${HELLO}WORLD
echo ${!varname}

The basename bultin could help with this, since you're specifically splitting on / in one part:

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

It's not really faster than the two line variant, but it is just one line using built-in functionality. Or, use zsh/ksh which can do the pattern nesting thing. :)

Though this is a very old thread, this device is ideal for either directly or randomly selecting a file/directory for processing (playing tunes, picking a film to watch or book to read, etc).

In bash I believe it is generally true that you cannot directly nest any two expansions of the same type, but if you can separate them with some different kind of expansion, it can be done.

e=($(find . -maxdepth 1 -type d))
c=${2:-${e[$((RANDOM%${#e[@]}))]}}

Explanation: e is an array of directory names, c the selected directory, either named explicitly as $2,

${2:-...}  

where ... is the alternative random selection given by

${e[$((RANDOM%${#e[@]}))]}  

where the

$((RANDOM%...))  

number generated by bash is divided by the number of items in array e, given by

${#e[@]}  

yielding the remainder (from the % operator) that becomes the index to array e

${e[...]}

Thus you have four nested expansions.

If the motivation is to "obfuscate" (I would say streamline) array processing in the spirit of Python's "comprehensions", create a helper function that performs the operations in sequence.

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

You can use the result with a nice one-liner.

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

eval will allow you to do what you are wanting:

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

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

Output: Hello, world