Bash – Get the Expansion of an Alias in Bash and Zsh

aliasbashshellzsh

I want to get the expansion of an alias.

For example, if I have:

alias g=hub
alias cdh='cd $HOME'

I want to have:

expand_alias g == hub

expand_alias cdh == cd $HOME

The tricky thing is that the two shells have different output:
bash:

$ alias g cdh
alias g='git'
alias cdh='cd $HOME'

zsh:

% alias g cdh
g=hub
cdh='cd $HOME'

Note no alias prefix and no quotes around hub.

Best Answer

In zsh, you can just use

get_alias() {
  printf '%s\n' $aliases[$1]
}

With bash (assuming it's not in POSIX mode in which case its alias would give an output similar to zsh's), you could do:

get_alias() (
  eval '
    alias() { printf "%s\n" "${1#*=}"; }'"
    $(alias -- "$1")"
)

Basically, we evaluate the output of alias after having redefined alias as a function that prints what's on the right of the first = in its first argument.

You could use a similar approach for something compatible with most POSIX shells, zsh and bash:

get_alias() {
  eval "set -- $(alias -- "$1")"
  eval 'printf "%s\n" "${'"$#"'#*=}"'
}

1. ksh93

In ksh93, a function, at least one declared with the ksh syntax (function f {...}), follows static scoping.

Variables declared with typeset in a function are local variables of the function.
```
a=global_a
function f {
  typeset a=f_a
  g
}

function g {
  echo "$a"
}

f
```
would output global_a.

typeset -i var in a function changes the type of the local var variable, with instantiating it in the function scope if it wasn't already.
In ksh93, a function declared with the Bourne syntax (f() {...}) doesn't do scoping at all. In that regard, the code of the function appears as if embedded in the caller of the function, so any variable appearing in it will have the same scope as in the caller so either global or local to the top-most function declared with the ksh syntax in its call tree. typeset would declare the variable in that top-most function (or in the global scope if there was no ksh-syntax function in its call tree).

For example, since in ksh-syntax functions, all variables are either private or global, to implement our integer as in bash, we'd need to do it either like:
```
integer() { typeset -i "$1"; }
```
That is using the Bourne function syntax that doesn't do scoping at all.

Or using the ksh syntax:
```
function integer { typeset -i "$1"; }
```
but to be invoked as:
```
. integer var
```
(that is, by using ., the code of integer is interpreted in the context of the caller like when you call . (source) on a script).

Or using the ksh syntax:
```
function integer { typeset -ni "$1"; }
```
Where the variable is passed as a reference with -n like you would do in C or most other programming languages.

2. All the other Bourne-like shells

All the other Bourne-like shells (including ksh88, ksh93 was a complete rewrite and the change to static scoping was a (perceived at least) pre-requisite for the functionality to be ever included in the POSIX standard) implement dynamic scoping.

A variable declared with typeset without -g in a function has the local scope of the function.

For example, typeset -i var would declare the variable local (in the current function scope) and set the integer attribute.

For example, in the code at the top, they would all output f_a. That is, g does see the local variable of f.

For another example, if f calls g that calls h. If h does not declare the var variable local to its scope, it will see g's variable or possibly f's if g hasn't declared var local, or possibly the variable from the bottom-most scope.
In all of bash, zsh, yash, mksh, one can change the type or value of a variable in a function without making it local to that function using typeset -g. Like with that integer function in the example you quote. But it's done differently depending on the shell.
- In mksh, yash, zsh, typeset -g doesn't affect the variable at the bottom-most (global) scope, but at the scope it currently been defined.
  
  For example, while typeset -i var would declare the variable local (in the current function scope) and set the integer attribute, typeset -gi var just does the latter part (without affecting the scope of var).
  
  For example, when a function calls my integer function above to add the integer attribute to a variable, as in:
```
f() {
 local myvar
 integer myvar
 ...
}
```
  It does want integer to change the attributes of its myvar variable, not the one in the global scope which it has no knowledge of and may not be able to access.
- In bash, typeset -g affects the instance of the variable in the global (bottom-most) scope. While that's what the g stands for, it's not useful in shells with dynamic scoping like bash.
  
  For example, in the first example in your question, 1+1 being output shows that the integer attribute has not been added to the variable. It has been added to a variable a in the global scope, but not the one that the f function has access to.

Best Answer

Related Solutions

Bash – Difference between alias in zsh and alias in bash

Bash vs zsh: scoping and `typeset -g`

1. ksh93

2. All the other Bourne-like shells

Related Question