Bash – Fix Bash Aliases Not Expanding with Shopt Expand_Aliases

aliasbash

I want to run an alias inside a bash -c construct.

The bash manual says:

Aliases are not expanded when the shell is not interactive, unless the expand_aliases shell option is set using shopt

In this example, why is the alias hi not found when setting expand_aliases explicitly?

% bash -O expand_aliases -c "alias hi='echo hello'; alias; shopt expand_aliases; hi"
alias hi='echo hello'
expand_aliases  on
bash: hi: command not found

I'm running GNU bash, version 5.0.0(1)-release (x86_64-pc-linux-gnu).

Context: I want to be able to run an alias at idle priority, eg a script containing:

#!/bin/bash
exec chrt -i 0 nice -n 19 ionice -c 3 bash -c ". ~/.config/bash/aliases; shopt -s expand_aliases; $(shell-quote "$@")"

I want to avoid using bash -i as I don't want my .bashrc to be read.

Best Answer

It doesn't seem work if you set the alias on the same line as it's used. Probably something to do with how aliases are expanded really early in the command line processing, before the actual parsing stage. On an interactive shell:

$ alias foo
bash: alias: foo: not found
$ alias foo='echo foo'; foo         # 2 
bash: foo: command not found
$ alias foo='echo bar'; foo         # 3
foo
$ foo
bar

Note how the alias used is one line late: on the second command it doesn't find the alias just set, and on the third command it uses the one that was previously set.

So, it works if we put a newline within the -c string:

$ bash -c $'shopt -s expand_aliases; alias foo="echo foo";\n foo'
foo

(You could also use bash -O expand_aliases -c ... instead of using shopt within the script, not that it helps with the newline.)

Alternatively, you could use a shell function instead of an alias, they're much better in other ways, too:

$ bash -c 'foo() { echo foo; }; foo'
foo

Related Solutions

When to Use Alias, Script, or Function in Bash

An alias should effectively not (in general) do more than change the default options of a command. It is nothing more than simple text replacement on the command name. It can't do anything with arguments but pass them to the command it actually runs. So if you simply need to add an argument at the front of a single command, an alias will work. Common examples are

# Make ls output in color by default.
alias ls="ls --color=auto"
# make mv ask before overwriting a file by default
alias mv="mv -i"

A function should be used when you need to do something more complex than an alias but that wouldn't be of use on its own. For example, take this answer on a question I asked about changing grep's default behavior depending on whether it's in a pipeline:

grep() { 
    if [[ -t 1 ]]; then 
        command grep -n "$@"
    else 
        command grep "$@"
    fi
}

It's a perfect example of a function because it is too complex for an alias (requiring different defaults based on a condition), but it's not something you'll need in a non-interactive script.

If you get too many functions or functions too big, put them into separate files in a hidden directory, and source them in your ~/.bashrc:

if [ -d ~/.bash_functions ]; then
    for file in ~/.bash_functions/*; do
        . "$file"
    done
fi

A script should stand on its own. It should have value as something that can be re-used, or used for more than one purpose.

Bash – Which of the following shell operations are performed inside the function body when running a function definition and when calling a function

<rant>
“running a function definition” and “running the definition of a function” are not common idioms. I expect that most people would refer to that simply as “defining a function”. OK, that phrase might be interpreted to refer to

conceptually specifying the characteristics and interfaces (parameters and other inputs, processing, and outputs) of a function (this is an activity performed by a person, or a group of people)

choosing the implementation of a function; i.e., what commands to use in the function body. This is an activity performed by a person, or a group of people, possibly using paper, whiteboards, and/or blackboards.

typing the implementation of a function into a text editor or directly into an interactive shell (this, of course, is also an activity performed by a person, or possibly a group of people, or possibly a very intelligent and dexterous cat, dog or monkey)

If you fear confusion with the above, you might be better served by phrases like “reading a function definition” and “processing the definition of a function”.

You say, “A function definition is a command.” It’s not clear what a claim like that even means — it’s a matter of semantics — but, at the semantic level, it’s debatable. Section 3.2 of the Bash manual (Shell Commands) lists six kinds of shell commands: Simple Commands, Pipelines, Lists, Compound Commands, Coprocesses, and GNU Parallel. Function definitions don’t fit well into any of those categories.
</rant>

Getting to your question, and looking at the seven steps / operations,

Reading input obviously has to happen before anything else can happen. It’s, again, a matter of semantics — you could say that reading input from a file or other stream text source is part of “reading a function definition” or that it is a prerequisite / prelude to “processing the definition of a function”.
Breaking the input into words and operators is clearly part of “processing the definition of a function”.
- Breaking the input into tokens is, of course, a prerequisite / prelude to parsing the tokens (step 3, below).
- The manual says, “Alias expansion is performed by this step,” and you show in the question that you know that alias expansion happens when the function definition is read.
Parsing the tokens. This must at least start during the “processing the definition of a function” phase for the shell to realize that it is looking at a function definition and not a simple command. Beyond that, we can do this simple experiment: type either of the following into a shell:
```
myfunc1() {                     myfunc2() {
    <               or              ;
}                               }
```
It will fail with a “syntax error” before you get a chance to type the }. (> and & produce the same effect.) So clearly this step is part of processing the definition of the function.

Performing the various shell expansions is part of calling the function.
- You show in the question that you know that parameter expansion does not happen when the function definition is read.
- It’s equally trivial to demonstrate that pathname / filename expansion does not happen when the function definition is read. In your example, change echo $var (which should be echo "$var", but that’s another matter) to echo *.
  - If you look at the function definition, you’ll see that it still says echo * and has not been expanded.
  - Change directory (cd) and/or create file(s) and/or delete file(s) and/or rename file(s), and then call (execute) the function. You’ll see that it outputs the current list of files¹ in the current directory, and doesn’t reflect the contents of the directory where/when you defined the function.
Performing redirections is part of calling the function. This is also trivial to verify. In your example, change echo $var to echo hello > myfile.
- If you look at the function definition, you’ll see that it still says > myfile.
- Check the directory, and you’ll see that myfile has not been created (yet).
Executing the command — do you really need to ask?
Waiting for the command to complete can’t possibly happen until the command has been executed (step 6), so this obviously is performed only when calling the function.

In other words, exactly what @ilkkachu said.

The one exceptional special case I can think of is that steps 2 and 3 (lexical analysis and parsing) occur (again) when executing a function if the function contains eval statements — but I believe that that’s outside the scope of what your question is really asking.
____________
¹ excluding hidden (dot-) files, unless you have said shopt -s dotglob

Best Answer

Related Solutions

When to Use Alias, Script, or Function in Bash

Bash – Which of the following shell operations are performed inside the function body when running a function definition and when calling a function

Related Question