LPIC-1 105.1 — Aliases, Functions, and Special Variables (Part 3)

Exam weight: 4 — LPIC-1 v5, Exam 102 | Part 3 of 105.1

Aliases — Advanced Usage

Quotes and Variables Inside an Alias

Commands with spaces, options, or chains must be quoted inside an alias. Otherwise Bash treats the first space as the end of the definition.

$ alias ll='ls -al'
$ alias greet='echo Hello world!'

A variable value can be embedded in an alias:

$ reptile=uromastyx
$ alias greet='echo Hello $reptile!'
$ greet
Hello uromastyx!

A variable can also be set inside the alias itself, separated by a semicolon:

$ alias greet='reptile=tortoise; echo Hello $reptile!'
$ greet
Hello tortoise!

Dynamic vs Static Expansion

The type of quotes determines when a variable is expanded.

Single quotes — defer expansion until the alias is invoked:

$ alias where?='echo $PWD'
$ where?
/home/user2
$ cd Music
$ where?
/home/user2/Music          # expands to current directory each time

Double quotes — expand the variable immediately when the alias is created, fixing the value:

$ alias where?="echo $PWD"
$ where?
/home/user2
$ cd Music
$ where?
/home/user2                # still the old directory

Simple rule: single quotes = dynamic, double quotes = static.

Alias Inside an Alias

An alias can call another alias by name:

$ alias where?='echo $PWD'
$ alias my_home=where?
$ my_home
/home/user2

Command Chain with Semicolons

An alias can run multiple commands separated by semicolons:

$ alias git_info='which git; git --version'
$ git_info
/usr/bin/git
git version 2.7.4

Bash Functions — Advanced Usage

Single-line Function Definition

A function can be written on one line. Semicolons separate commands, and a semicolon is required after the last command before the closing brace:

$ greet() { greeting="Hello world!"; echo $greeting; }
$ greet
Hello world!

When typing a function interactively line by line, Bash shows the > continuation prompt (PS2) until the block is closed:

$ greet() {
> greeting="Hello world!"
> echo $greeting
> }

Variables Inside Functions

A function works with both local shell variables and environment variables. Given a file funed with:

editors() {
    editor=emacs
    echo "My editor is: $editor. $editor is a fun text editor."
}

Source and call it:

$ . funed
$ editors
My editor is: emacs. emacs is a fun text editor.

The variable editor set inside the function remains in the current shell after the call:

$ echo $editor
emacs

Environment variables like $USER can also be used inside functions:

editors() {
    editor=emacs
    echo "The text editor of $USER is: $editor."
}
editors

If the function call is the last line of the file, sourcing the file immediately invokes it.

Positional Parameters in Functions

Parameters are passed either from the file itself or from the command line.

From the file:

editors() {
    editor=emacs
    echo "The text editor of $USER is: $editor."
    echo "Bash is not a $1 shell."
}
editors tortoise

From the command line (remove the invocation from the file, source just the definition, then call):

$ . funed
$ editors tortoise
The text editor of user2 is: emacs.
Bash is not a tortoise shell.

Aliases and Positional Parameters

Technically you can pass arguments to an alias, but they always go to the end of the expanded line, regardless of where $1 is placed:

$ alias great_editor='echo $1 is a great text editor'
$ great_editor emacs
is a great text editor emacs

For proper positional parameter handling, use functions, not aliases.

Special Built-in Bash Variables

These variables are read-only — you can read them but not assign to them directly.

$? — Last Exit Code

Stores the exit code of the last command. 0 means success:

$ ps aux | grep bash
user2  420  ... -bash
$ echo $?
0

Non-zero means an error:

$ ps aux | rep bash
-bash: rep: command not found
$ echo $?
127

$$ — Shell PID

Current shell’s process ID:

$ echo $$
420

$! — Background Job PID

PID of the last process started in the background with &:

$ ps aux | grep bash &
[1] 663
$ echo $!
663

Positional Parameters $0..$9

$0 — script or shell name. $1–$9 — arguments passed to a function or script:

$ special_vars() {
> echo $0
> echo $1
> echo $2
> echo $3
> }
$ special_vars debian ubuntu zorin
-bash
debian
ubuntu
zorin

Other Special Variables

Full list: man bash, section SPECIAL PARAMETERS.

Functions in Scripts

Functions appear most often inside Bash scripts. Converting the funed file to a script funed.sh takes two additions:

#!/bin/bash
editors() {
    editor=emacs
    echo "The text editor of $USER is: $editor."
    echo "Bash is not a $1 shell."
}
editors tortoise

What changed:

• The shebang #!/bin/bash on line 1 tells the kernel which interpreter to use.
• The last line calls the function. Without it, the script would only define it and exit.

Make it executable and run:

$ chmod +x funed.sh
$ ./funed.sh
The text editor of user2 is: emacs.
Bash is not a tortoise shell.

Function Inside an Alias

A function definition can be embedded in an alias, together with its invocation and self-cleanup:

$ alias great_editor='gr8_ed() { echo $1 is a great text editor; unset -f gr8_ed; }; gr8_ed'

How it works:

1. gr8_ed() { ... } defines the function.
2. unset -f gr8_ed inside the function removes it from the session after it runs.
3. ; gr8_ed at the end calls the function.

Test:

$ great_editor emacs
emacs is a great text editor

unset flags:

Function Inside a Function

One function can call another. Example: add to ~/.bashrc so that on login the user gets a greeting and a video folder check.

check_vids — lists mkv files and warns the user:

check_vids() {
    ls -1 ~/Video/*.mkv > /dev/null 2>&1
    if [ "$?" = "0" ]; then
        echo -e "Remember, you must not keep more than 5 video files in your Video folder.\nThanks."
    else
        echo -e "You do not have any videos in the Video folder. You can keep up to 5.\nThanks."
    fi
}

Step by step:

• > /dev/null 2>&1 redirects both stdout and stderr to /dev/null (the bit-bucket).
• [ "$?" = "0" ] checks whether the previous command succeeded.

editors — greets the user and calls check_vids:

editors() {
    editor=emacs
    echo "Hi, $USER!"
    echo "$editor is more than a text editor!"
    check_vids
}

editors

The last line of the file calls editors, which in turn calls check_vids.

Test by switching to the user:

# su - user2
Hi, user2!
emacs is more than a text editor!
Remember, you must not keep more than 5 video files in your Video folder.
Thanks.

Quick Reference

# Special variables
echo $?      # exit code of last command (0 = success)
echo $$      # PID of current shell
echo $!      # PID of last background process
echo $0      # script/shell name
echo $1      # first positional argument
echo $#      # number of arguments
echo $@      # all arguments

# unset
unset -v NAME   # remove variable
unset -f NAME   # remove function

# Alias with command chain
alias git_info='which git; git --version'

# Single-line function (semicolon required after last command)
greet() { greeting="Hello world!"; echo $greeting; }

# Shebang
#!/bin/bash

# Make script executable and run
chmod +x script.sh
./script.sh

# readonly function
readonly -f my_fun     # make function read-only
readonly -f            # list all read-only functions

Exam Questions

1. Difference between single and double quotes in alias definition? → Single quotes defer variable expansion until the alias is invoked. Double quotes expand the value immediately when the alias is created.
2. What does $? hold right after a successful command? → 0.
3. Difference between $$ and $!? → $$ is the PID of the current shell. $! is the PID of the last background process.
4. Why do positional parameters not work correctly in aliases? → Arguments always go to the end of the expanded alias string, regardless of where $1 appears. Use functions for positional parameters.
5. Which two flags of unset specify the type of entity to remove? → -v for variables, -f for functions.
6. What must the first line of a Bash script contain for it to run with the right interpreter? → A shebang: #!/bin/bash.
7. How to prevent a function defined inside an alias from persisting in the session? → Add unset -f funcname as the last command inside the function, and call the function at the end of the alias definition.
8. What does readonly -f do? → Makes a function read-only; it cannot be redefined or removed with unset -f.
9. What does $# hold? → The number of arguments passed to the function or script.
10. What does $@ expand to? → All positional arguments as a list.
11. What is $_? → The last argument of the previous command (or the script name at startup).

Exercises

Exercise 1 — Aliases vs functions capabilities

Fill in Yes or No.

Exercise 2 — List all aliases

alias

Exercise 3 — Alias logg for ogg files

Create alias logg that lists all ogg files in ~/Music, one per line.

alias logg='ls -1 ~/Music/*ogg'

Exercise 4 — Call the alias

logg

Exercise 5 — Extend logg to greet the user

Modify logg to first print the current username and a colon, then the list.

alias logg='echo $USER:; ls -1 ~/Music/*ogg'

Exercise 6 — Call the updated alias

logg

Exercise 7 — Verify logg is in the alias list

alias

Exercise 8 — Remove the alias

unalias logg

Exercise 9 — Match alias names to commands

Write correct definitions for these aliases.

alias b=bash
alias bash_info='which bash; echo "$BASH_VERSION"'
alias kernel_info='uname -r'
alias greet='echo Hi, $USER'
alias computer='pc=slimbook; echo My computer is a $pc'

Exercise 10 — Function my_fun in /etc/bash.bashrc

As root, write function my_fun that greets the user and prints their PATH. It should run on every login.

my_fun() {
    echo Hello, $USER!
    echo Your path is: $PATH
}
my_fun

function my_fun {
    echo Hello, $USER!
    echo Your path is: $PATH
}
my_fun

Exercise 11 — Switch to user2 to test

su - user2

Exercise 12 — Same function as a one-liner

my_fun() { echo "Hello, $USER!"; echo "Your path is: $PATH"; }

function my_fun { echo "Hello, $USER!"; echo "Your path is: $PATH"; }

Exercise 13 — Call the function

my_fun

Exercise 14 — Remove the function

unset -f my_fun

Exercise 15 — Predict the output of special_vars2

Function:

special_vars2() {
    echo $#
    echo $_
    echo $1
    echo $4
    echo $6
    echo $7
    echo $_
    echo $@
    echo $?
}

Call: special_vars2 crying cockles and mussels alive alive oh

Exercise 16 — Parameterized check_music function

Write check_music, a startup-script function based on check_vids. Make it accept positional parameters for: folder name, file extension, maximum count, file type label.

check_music() {
    ls -1 ~/$1/*.$2 > /dev/null 2>&1
    if [ "$?" = "0" ]; then
        echo -e "Remember, you must not keep more than $3 $4 files in your $1 folder.\nThanks."
    else
        echo -e "You do not have any $4 files in the $1 folder. You can keep up to $3.\nThanks."
    fi
}
check_music Music ogg 7 music

Exercise 17 — Read-only functions

How do you make a function read-only? How do you list all read-only functions?

readonly -f my_fun    # make read-only
readonly -f           # list all read-only functions

Exercise 18 — fyi function with system summary

Write a fyi function for a startup script that prints: username, home directory, hostname, OS type, PATH, mail directory, mail check interval, shell nesting level, and changes PS1 to <user>@<host-date>.

fyi() {
    echo -e "For your Information:\n
    Username: $USER
    Home directory: $HOME
    Host: $HOSTNAME
    Operating System: $OSTYPE
    Path for executable files: $PATH
    Your mail directory is $MAIL and is searched every $MAILCHECK seconds.
    The current level of your shell is: $SHLVL"
    PS1="\u@\h-\d "
}
fyi

LPIC-1 Study Notes | Topic 105: Shells and Shell Scripting