Advanced Bash-Scripting Guide

https://tldp.org/LDP/abs/html/
Admin
An in-depth exploration and comprehensive reference guide covering shell scripting techniques, bash...
Tokens:509,257
Snippets:3,478
Trust Score:9.9
Update:7 months ago
Show doc for...
Tokens:
Raw
### Install and Query RPM Packages (Bash)

Source: https://tldp.org/LDP/abs/html/filearchiv.html

Provides examples of using the 'rpm' command in Bash for package management on Red Hat-based systems. It shows how to install a package, identify the package a file belongs to, and list all installed packages. This is essential for software management.

```Bash
# Install a package
rpm -i package_name.rpm

# Identify which package a file originates from
rpm -qf /bin/ls

# List all installed rpm packages
rpm -qa

# List a specific package
rpm -qa package_name
```

--------------------------------

### Using Shebang for Executable Documentation Files

Source: https://tldp.org/LDP/abs/html/sha-bang.html

This example shows how to create a self-listing documentation file by starting a file with `#!/bin/more` and making it executable. This leverages the `more` command to display the file's content.

```shell
#!/bin/more

This is the content of the documentation file.
It will be displayed when the script is executed.
```

--------------------------------

### sed: Example with Insertion and Output

Source: https://tldp.org/LDP/abs/html/x23170.html

A practical example demonstrating the use of sed's 'i' command for insertion, combined with piping input from 'echo'.

```shell
echo "Working on it." | sed -e '1i How far are you along?'
# Prints "How far are you along?" as the first line, followed by "Working on it."
```

--------------------------------

### Example Data File for Game of Life (gen0)

Source: https://tldp.org/LDP/abs/html/contributed-scripts.html

This is an example 'generation 0' start-up file for the 'life.sh' script. It defines a 10x10 grid using '.' for live cells and '_' for dead cells. Lines starting with '#' are treated as comments and ignored by the script.

```text
# gen0
#
# This is an example "generation 0" start-up file for "life.sh".
# --------------------------------------------------------------
#  The "gen0" file is a 10 x 10 grid using a period (.), for live cells,
#+ and an underscore (_) for dead ones. We cannot simply use spaces
#+ for dead cells in this file because of a peculiarity in Bash arrays.
#  [Exercise for the reader: explain this.]
#
# Lines beginning with a '#' are comments, and the script ignores them.
__.__..___
__.._.____
____.___..
_._______. 
____._____
..__...___
____._____
___...____
__.._..___
_..___..__
```

--------------------------------

### Download URL Content using /dev/tcp

Source: https://tldp.org/LDP/abs/html/devref1.html

This example demonstrates downloading the content of a URL by opening a TCP connection to the web server on port 80 using Bash's /dev/tcp pseudo-device, sending an HTTP GET request, and then reading the response.

```bash
exec 5<>/dev/tcp/www.net.cn/80
echo -e "GET / HTTP/1.0\n" >&5
cat <&5
```

--------------------------------

### Bash Localization Setup with gettext

Source: https://tldp.org/LDP/abs/html/localization.html

This snippet demonstrates the basic setup for localizing Bash scripts using gettext. It includes setting the TEXTDOMAINDIR and TEXTDOMAIN environment variables and compiling a .po file into a .mo file using msgfmt.

```bash
# Example of setting text domain variables
TEXTDOMAINDIR=/usr/local/share/locale
TEXTDOMAIN=localized.sh

# Command to compile a .po file to a .mo file
msgfmt -o localized.sh.mo fr.po
```

--------------------------------

### Create Filesystem in a File (Bash)

Source: https://tldp.org/LDP/abs/html/index.html

Demonstrates how to create a file and then format it with a filesystem, effectively creating a virtual disk. This is useful for testing or creating loopback devices.

```bash
#!/bin/bash

# Creating a filesystem in a file

filename="virtual_disk.img"
size=10M

# Create an empty file of a specific size
dd if=/dev/zero of="$filename" bs=1 count=0 seek="$size"

# Format the file with an ext4 filesystem (requires root privileges)
# mkfs.ext4 "$filename"

echo "Created empty file '$filename' of size $size. Filesystem creation requires root privileges."
```

--------------------------------

### Bash Substring Extraction

Source: https://tldp.org/LDP/abs/html/parameter-substitution.html

Extracts portions of a string using offsets and lengths. The first example shows stripping a fixed number of characters from the beginning of a string. The second example extracts a substring of a specific length starting from a given offset.

```bash
t=${path_name:11}
echo "$path_name, with first 11 chars stripped off = $t"
t=${path_name:11:5}
echo "$path_name, with first 11 chars stripped off, length 5 = $t"
```

--------------------------------

### System Initialization Script Examples Using Command Substitution

Source: https://tldp.org/LDP/abs/html/commandsub.html

Provides excerpts from a system initialization script (`/etc/rc.d/rc.sysinit`) showcasing practical applications of command substitution for reading system configuration files and kernel information into variables.

```bash
#  Excerpts from system file, /etc/rc.d/rc.sysinit
#+ (on a Red Hat Linux installation)


if [ -f /fsckoptions ]; then
        fsckoptions=`cat /fsckoptions`
...
fi
#
#
if [ -e "/proc/ide/${disk[$device]}/media" ] ; then
             hdmedia=`cat /proc/ide/${disk[$device]}/media`
...
fi
#
#
if [ ! -n "`uname -r | grep -- "-"`" ]; then
       ktag="`cat /proc/version`"
...
fi
#
#
if [ $usb = "1" ]; then
    sleep 5
    mouseoutput=`cat /proc/bus/usb/devices 2>/dev/null|grep -E "^I.*Cls=03.*Prot=02"`
    kbdoutput=`cat /proc/bus/usb/devices 2>/dev/null|grep -E "^I.*Cls=03.*Prot=01"`
...
fi
```

--------------------------------

### Check Bash Version using $BASH_VERSION

Source: https://tldp.org/LDP/abs/html/internalvariables.html

Demonstrates how to check the installed Bash version using the $BASH_VERSION environment variable. This is useful for determining shell compatibility and features. It shows examples for both Bash and Tcsh shells.

```bash
echo $BASH_VERSION
```

--------------------------------

### Get Time from NIST Server using /dev/tcp

Source: https://tldp.org/LDP/abs/html/devref1.html

This example shows how to retrieve the current time from a NIST time server by establishing a TCP connection to port 13 on time.nist.gov using Bash's /dev/tcp pseudo-device.

```bash
cat </dev/tcp/time.nist.gov/13
```

--------------------------------

### Create Lock File with lockfile Command (Bash)

Source: https://tldp.org/LDP/abs/html/system.html

The lockfile command creates a lock file, which acts as a semaphore to control access to a resource. The first example creates a write-protected lock file prefixed with the script's name. The second example is a safer version that uses parameter expansion to get the base name of the script.

```bash
lockfile /home/bozo/lockfiles/$0.lock
# Creates a write-protected lockfile prefixed with the name of the script.

lockfile /home/bozo/lockfiles/${0##*/}.lock
# A safer version of the above, as pointed out by E. Choroba.
```

--------------------------------

### Bash Script Example: Detailed getopts Usage

Source: https://tldp.org/LDP/abs/html/internal.html

A comprehensive Bash script example demonstrating the 'getopts' command for parsing various command-line options, including those requiring arguments. It shows how to handle different scenarios and provides comments explaining the process and potential outcomes.

```bash
#!/bin/bash
# ex33.sh: Exercising getopts and OPTIND

NO_ARGS=0 
E_OPTERROR=85

if [ $# -eq "$NO_ARGS" ]
then
  echo "Usage: `basename $0` options (-mnopqrs)"
  exit $E_OPTERROR
fi

while getopts ":mnopq:rs" Option
do
  case $Option in
    m     ) echo "Scenario #1: option -m-   [OPTIND=${OPTIND}]";;
    n | o ) echo "Scenario #2: option -$Option-   [OPTIND=${OPTIND}]";;
    p     ) echo "Scenario #3: option -p-   [OPTIND=${OPTIND}]";;
    q     ) echo "Scenario #4: option -q-\
                  with argument \"$OPTARG\"   [OPTIND=${OPTIND}]";;
    r | s ) echo "Scenario #5: option -$Option-";;
    *     ) echo "Unimplemented option chosen.";;
  esac
done

shift $(($OPTIND - 1))

exit $?
```

--------------------------------

### Bash Substring Extraction with Positional Parameters (Bash 4+)

Source: https://tldp.org/LDP/abs/html/bashver4.html

Demonstrates substring extraction from positional parameters in Bash version 4 and later, where `$0` is included as the zero-index. This example shows how to display all parameters starting from `$0`.

```bash
#!/bin/bash
# show-params.bash
# Requires version 4+ of Bash.

# Invoke this scripts with at least one positional parameter.

E_BADPARAMS=99

if [ -z "$1" ]
then
  echo "Usage $0 param1 ..."
  exit $E_BADPARAMS
fi

echo ${@:0}

# bash3 show-params.bash4 one two three
# one two three

# bash4 show-params.bash4 one two three
# show-params.bash4 one two three

# $0                $1  $2  $3
```

--------------------------------

### Create Dummy File (Bash)

Source: https://tldp.org/LDP/abs/html/index.html

Generates a simple dummy file with a specified number of lines, often used for testing purposes. This example creates a 2-line file.

```bash
#!/bin/bash

# dummyfile: Creates a 2-line dummy file

echo "Line 1" > dummyfile.txt
echo "Line 2" >> dummyfile.txt

echo "Created dummyfile.txt with 2 lines."
```

--------------------------------

### Prepare Bootable SD Card for Raspberry Pi (Bash)

Source: https://tldp.org/LDP/abs/html/index.html

Provides instructions or a script to prepare an SD card for use with a Raspberry Pi, typically involving partitioning and formatting. This requires root privileges.

```bash
#!/bin/bash

# Preparing a bootable SD card for the Raspberry Pi
# NOTE: This is a conceptual example and requires careful execution.
# Ensure you have the correct device path (e.g., /dev/sdX).

# Example: Assuming sdX is the SD card and image.img is the OS image
# sudo dd bs=4M if=image.img of=/dev/sdX conv=fsync status=progress

echo "This is a placeholder for Raspberry Pi SD card preparation."
```

--------------------------------

### Bash: randomBetween Function Example Usage

Source: https://tldp.org/LDP/abs/html/randomvar.html

Demonstrates how to use the 'randomBetween' Bash function with specific parameters for minimum, maximum, and divisibility. It also shows the setup for an array to test the distribution of generated random numbers.

```bash
# Let's test the function.
min=-14
max=20
divisibleBy=3


#  Generate an array of expected answers and check to make sure we get
#+ at least one of each answer if we loop long enough.

declare -a answer
minimum=${min}
maximum=${max}
   if [ $((minimum/divisibleBy*divisibleBy)) -ne ${minimum} ]; then 
      if [ ${minimum} -lt 0 ]; then
         minimum=$((minimum/divisibleBy*divisibleBy))
      else
         minimum=$((((minimum/divisibleBy)+1)*divisibleBy))
      fi
   fi


   #  If max is itself not evenly divisible by $divisibleBy,
   #+ then fix the max to be within range.

   if [ $((maximum/divisibleBy*divisibleBy)) -ne ${maximum} ]; then 
      if [ ${maximum} -lt 0 ]; then
         maximum=$((((maximum/divisibleBy)-1)*divisibleBy))
      else
         maximum=$((maximum/divisibleBy*divisibleBy))
      fi
   fi


#  We need to generate only positive array subscripts,
#+ so we need a displacement that that will guarantee
#+ positive results.

disp=$((0-minimum))
for ((i=${minimum}; i<=${maximum}; i+=divisibleBy)); do
   answer[i+disp]=0
done

```

--------------------------------

### Setup Blacklist Servers from File or Argument (Bash)

Source: https://tldp.org/LDP/abs/html/contributed-scripts.html

The `setup_servers` function handles the second command-line argument, which specifies the blacklist servers. If the argument is a readable file, it loads the server names into the `list_server` array. Otherwise, it treats the argument as a single blacklist server name and stores it in the `list_server` array.

```bash
setup_servers() {
    if [ -e ${1} ] && [ -r ${1} ]  # Name of a readable file
    then
        file_to_array ${1} list_server
        echo 'Using filename >'${1}'< as blacklist server list.'
    else
        list_server=( ${1} )
        echo 'Using blacklist server >'${1}'<'
    fi
    return 0
}
```

--------------------------------

### Stop a System Service with service command

Source: https://tldp.org/LDP/abs/html/system.html

The `service` command is used to start, stop, or restart system services managed by init scripts. These scripts are typically located in `/etc/init.d` or `/etc/rc.d`. This example demonstrates stopping the `iptables` service.

```bash
#!/bin/bash

# Stop the iptables service
/sbin/service iptables stop

exit 0
```

--------------------------------

### Parse Command-Line Options with getopt (Bash)

Source: https://tldp.org/LDP/abs/html/index.html

Illustrates how to use the `getopt` command to parse command-line options and arguments in a Bash script. This is crucial for creating user-friendly scripts that accept various flags and parameters.

```bash
#!/bin/bash

# Using getopt to parse command-line options

TEMP=$(getopt -o ab:c --long alpha,beta:,gamma -n '$0' -- "$@")

if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi

eval set -- "$TEMP"

while true; do
    case "$1" in
        -a | --alpha)
            echo "Option alpha"
            shift
            ;;
        -b | --beta)
            echo "Option beta with argument $2"
            shift 2
            ;;
        -c | --gamma)
            echo "Option gamma"
            shift
            ;;
        --)
            shift
            break
            ;;
        *)
            break
            ;;
    esac
done

echo "Remaining arguments: $@"
```

--------------------------------

### Find anagrams using 'anagram', 'grep' in Bash

Source: https://tldp.org/LDP/abs/html/assortedtips.html

An example script that finds anagrams of a given set of letters using the 'anagram' utility and filters the results using multiple 'grep' commands. It demonstrates filtering by length, starting characters, and avoiding specific endings.

```bash
#!/bin/bash
# agram.sh: Playing games with anagrams.

# Find anagrams of...
LETTERSET=etaoinshrdlu
FILTER='.......'       # How many letters minimum?
#       1234567

anagram "$LETTERSET" | # Find all anagrams of the letterset...
grep "$FILTER" |       # With at least 7 letters,
grep '^is' |           # starting with 'is'
grep -v 's$' |         # no plurals
grep -v 'ed$'

exit 0                 # End of code.

```

--------------------------------

### Demonstrate basename and dirname Usage

Source: https://tldp.org/LDP/abs/html/filearchiv.html

This script demonstrates the usage of both `basename` and `dirname` commands on a file path and also on the tilde (~) shortcut for the home directory.

```bash
#!/bin/bash

address=/home/bozo/daily-journal.txt

echo "Basename of /home/bozo/daily-journal.txt = `basename $address`"
echo "Dirname of /home/bozo/daily-journal.txt = `dirname $address`"
echo
echo "My own home is `basename ~/`."
# `basename ~` also works.
echo "The home of my home is `dirname ~/`."
# `dirname ~`  also works.

exit 0

```

--------------------------------

### Creating menus using select in Bash

Source: https://tldp.org/LDP/abs/html/index.html

Illustrates how to create interactive command-line menus using the 'select' command in Bash. It presents a list of options and prompts the user for input.

```Bash
#!/bin/bash

PS3='Please choose an option: '
options=("Option 1" "Option 2" "Option 3" "Quit")
select opt in "${options[@]}"
do
    case $opt in
        "Option 1")
            echo "You chose Option 1"
            ;;
        "Option 2")
            echo "You chose Option 2"
            ;;
        "Option 3")
            echo "You chose Option 3"
            ;;
        "Quit")
            break
            ;;
        *)
            echo "Invalid option $REPLY"
            ;;
    esac
done
```

--------------------------------

### Get String Length (Bash)

Source: https://tldp.org/LDP/abs/html/parameter-substitution.html

Demonstrates how to get the length of a string variable in Bash using the ${#var} syntax. It also shows how to get the number of command-line arguments using ${#*} and ${#@}.

```bash
#!/bin/bash
# length.sh

E_NO_ARGS=65

if [ $# -eq 0 ]  # Must have command-line args to demo script.
then
  echo "Please invoke this script with one or more command-line arguments."
  exit $E_NO_ARGS
fi  

var01=abcdEFGH28ij
echo "var01 = ${var01}"
echo "Length of var01 = ${#var01}"
# Now, let's try embedding a space.
var02="abcd EFGH28ij"
echo "var02 = ${var02}"
echo "Length of var02 = ${#var02}"

echo "Number of command-line arguments passed to script = ${#@}"
echo "Number of command-line arguments passed to script = ${#*}"

exit 0
```

--------------------------------

### Create a Filesystem in a File using loopback device

Source: https://tldp.org/LDP/abs/html/system.html

This snippet shows how to create a filesystem within a file using loopback devices. It involves creating a file of a specified size, setting it up as a loopback device, creating an ext2 filesystem on it, and then mounting it. This is useful for creating virtual disk images.

```bash
SIZE=1000000  # 1 meg

head -c $SIZE < /dev/zero > file  # Set up file of designated size.
losetup /dev/loop0 file           # Set it up as loopback device.
mke2fs /dev/loop0                 # Create filesystem.
mount -o loop /dev/loop0 /mnt     # Mount it.

# Thanks, S.C.
```

--------------------------------

### Bash: Run parallel processes in subshells

Source: https://tldp.org/LDP/abs/html/subshells.html

This example demonstrates how to execute commands in parallel using subshells running in the background. Two separate processes are started in subshells to merge and sort different sets of lists simultaneously. The 'wait' command ensures that the parent script pauses until both background subshells have completed before proceeding.

```bash
	(cat list1 list2 list3 | sort | uniq > list123) &
	(cat list4 list5 list6 | sort | uniq > list456) &
	# Merges and sorts both sets of lists simultaneously.
	# Running in background ensures parallel execution.
	#
	# Same effect as
	#   cat list1 list2 list3 | sort | uniq > list123 &
	#   cat list4 list5 list6 | sort | uniq > list456 &
	
	wait   # Don't execute the next command until subshells finish.
	
diff list123 list456
```

--------------------------------

### Setup Live Logging with SPAMMER_TRACE

Source: https://tldp.org/LDP/abs/html/contributed-scripts.html

Configures a live logging mechanism by checking the SPAMMER_TRACE environment variable. If set, it attempts to create or clear a log file specified by the variable. It handles file creation and write permissions, exiting with an error if the file cannot be prepared. Dependencies include `pend_func`, `pend_release`, and `echo`.

```shell
live_log_die() {
    if [ ${SPAMMER_TRACE:=} ]    # Wants trace log?
    then
        if [ ! -e ${SPAMMER_TRACE} ]
        then
            if ! touch ${SPAMMER_TRACE} 2>/dev/null
            then
                pend_func echo $(printf '%q\n'
                'Unable to create log file >'${SPAMMER_TRACE}'<')
                pend_release
                exit 1
            fi
            _log_file=${SPAMMER_TRACE}
            _pend_hook_=trace_logger
            _log_dump=dump_log
        else
            if [ ! -w ${SPAMMER_TRACE} ]
            then
                pend_func echo $(printf '%q\n'
                'Unable to write log file >'${SPAMMER_TRACE}'<')
                pend_release
                exit 1
            fi
            _log_file=${SPAMMER_TRACE}
            echo '' > ${_log_file}
            _pend_hook_=trace_logger
            _log_dump=dump_log
        fi
    fi
    return 0
}
```

--------------------------------

### Count lines containing 'total' using wc and awk

Source: https://tldp.org/LDP/abs/html/textproc.html

This command counts the total size of files whose names start with letters 'd' through 'h'. It uses 'wc' to get file sizes, 'grep' to filter for 'total', and 'awk' to extract the third field (the total size).

```bash
wc [d-h]* | grep total | awk '{print $3}'
```

--------------------------------

### Bash Example: Testing Command-Line Parameters with Case

Source: https://tldp.org/LDP/abs/html/testbranch.html

Illustrates using the Bash 'case' statement to process command-line arguments. It checks the first argument ($1) to determine if it's empty (displaying usage), starts with a dash (prefixing with './'), or is a regular filename. This is useful for handling script options and filenames.

```bash
#! /bin/bash

case "$1" in
  "") echo "Usage: ${0##*/} <filename>"; exit $E_PARAM;; # No command-line parameters,
                      # or first parameter empty.
# Note that ${0##*/} is ${var##pattern} param substitution.
                      # Net result is $0.

  -*) FILENAME=./$1;;   #  If filename passed as argument ($1)
                      #+ starts with a dash,
                      #+ replace it with ./$1
                      #+ so further commands don't interpret it
                      #+ as an option.

  * ) FILENAME=$1;;     # Otherwise, $1.
esac
```

--------------------------------

### Compiling and Running a C Program (Bash)

Source: https://tldp.org/LDP/abs/html/commandsub.html

This snippet shows the command-line steps to compile a C program named `hello.c` using `gcc` and then execute the resulting binary `hello`. It demonstrates a typical workflow for C development in a shell environment.

```bash
bash$ ``**gcc -o hello hello.c**`
```

--------------------------------

### Exercise dd Command (Bash)

Source: https://tldp.org/LDP/abs/html/index.html

Demonstrates the usage of the `dd` command for low-level copying and conversion of files. This example might show creating a file of a specific size or copying data blocks.

```bash
#!/bin/bash

# Exercising dd

# Create a 1MB file filled with zeros
dd if=/dev/zero of=dummyfile bs=1M count=1

echo "Created dummyfile (1MB) using dd."
```

--------------------------------

### Using zenity for GTK+ Widgets in Shell Scripts

Source: https://tldp.org/LDP/abs/html/assortedtips.html

This bash script demonstrates how to use 'zenity' to create GTK+ dialog widgets from a shell script. The example defines a function 'get_info' that uses '--entry' to pop up a query window and captures the user's input to standard output. The captured output is then stored in a variable.

```bash
get_info ()
{
  zenity --entry       #  Pops up query window . .
                       #+ and prints user entry to stdout.

                       #  Also try the --calendar and --scale options.
}

answer=$( get_info )   #  Capture stdout in $answer variable.

echo "User entered: "$answer""
```

--------------------------------

### Sed: Delete Lines Matching a Pattern with Variable Expansion

Source: https://tldp.org/LDP/abs/html/x23170.html

This example demonstrates deleting lines from a file that start with a specific pattern stored in a variable. It highlights the difference in behavior between double quotes (allowing variable expansion) and single quotes (preventing variable expansion) when defining the `sed` command. Double quotes are necessary here for `$pattern` to be correctly interpreted.

```bash
filename=file1.txt
pattern=BEGIN

  sed "/^$pattern/d" "$filename"  # Works as specified.
# sed '/^$pattern/d' "$filename"    has unexpected results.
#        In this instance, with strong quoting (' ... '),
#+      "$pattern" will not expand to "BEGIN".
```

--------------------------------

### Self-Deleting Script Example

Source: https://tldp.org/LDP/abs/html/sha-bang.html

This example demonstrates a self-deleting script. The shebang line points to '/bin/rm', which, when executed, will remove the script file itself. This is a demonstration of how the shebang can specify any executable.

```bash
#!/bin/rm
# Self-deleting script.
```

--------------------------------

### Bash Process Substitution: Comparing Command Output with diff

Source: https://tldp.org/LDP/abs/html/process-sub.html

A straightforward example showing how to use `diff` with process substitution to compare the output of two arbitrary commands.

```bash
diff <(command1) <(command2)
```

--------------------------------

### Get Terminal Information with tput

Source: https://tldp.org/LDP/abs/html/terminalccmds.html

The 'tput' command retrieves terminal information from the terminfo database. It can be used to get the long name of the terminal, which is useful for scripting and configuration.

```bash
`bash$ ``**tput longname**`
`xterm terminal emulator (X Window System)`
	      
```

--------------------------------

### Bash Process Substitution: Network Data Piping and MD5 Checksumming

Source: https://tldp.org/LDP/abs/html/process-sub.html

An advanced example showing how process substitution can be used with `tee` to pipe network data, compress it, and simultaneously calculate MD5 checksums for both the original and compressed data.

```bash
# Scan the port to make sure nothing nefarious is going on.
netcat -l $PORT | tee>(md5sum ->mydata-orig.md5) | gzip | tee>(md5sum - | sed 's/-$/mydata.lz2/'>mydata-gz.md5)>mydata.gz

# Check the decompression:
gzip -d<mydata.gz | md5sum -c mydata-orig.md5)
```

--------------------------------

### Bash 'date' command examples for day of year and time formatting

Source: https://tldp.org/LDP/abs/html/timedate.html

Presents concise examples of the 'date' command in Bash for specific formatting needs. It shows how to echo the day of the year using '+%j' and how to display the hour and minute in a 24-hour format as a single string using '+%k%M'.

```bash
date +%j
# Echoes day of the year (days elapsed since January 1).

date +%k%M
# Echoes hour and minute in 24-hour format, as a single digit string.



# The 'TZ' parameter permits overriding the default time zone.
date                 # Mon Mar 28 21:42:16 MST 2005
TZ=EST date          # Mon Mar 28 23:42:16 EST 2005

```

--------------------------------

### List Installed Hardware Devices with 'lsdev'

Source: https://tldp.org/LDP/abs/html/system.html

The 'lsdev' command lists installed hardware devices, showing details such as DMA channels, IRQ lines, and I/O port addresses.

```bash
lsdev
```

--------------------------------

### Creating menus using case statement in Bash

Source: https://tldp.org/LDP/abs/html/index.html

Shows how to build interactive menus using the 'case' statement in Bash. User input is matched against patterns to execute corresponding actions.

```Bash
#!/bin/bash

PS3='Please choose your favorite programming language: '
options=("C" "C++" "Java" "Python" "Ruby" "Quit")
select opt in "${options[@]}" "Quit"; do
    case $REPLY in
        1)
            echo "You chose $opt"
            ;;
        2)
            echo "You chose $opt"
            ;;
        3)
            echo "You chose $opt"
            ;;
        4)
            echo "You chose $opt"
            ;;
        5)
            echo "You chose $opt"
            ;;
        6)
            echo "Exiting."
            break
            ;;
        *)
            echo "Invalid option $REPLY"
            ;;
    esac
done
```

--------------------------------

### Example PO File for French Localization

Source: https://tldp.org/LDP/abs/html/localization.html

An example of a `fr.po` file, which contains the translated strings for the French locale. It maps original message IDs (`msgid`) to their French translations (`msgstr`).

```po
fr.po:
#: a:6
msgid "Can't cd to $var."
msgstr "Impossible de se positionner dans le repertoire $var."
#: a:7
msgid "Enter the value: "
msgstr "Entrez la valeur : "
```

--------------------------------

### Graph-Viz Name to Address Edge Example

Source: https://tldp.org/LDP/abs/html/contributed-scripts.html

This code snippet shows an example of how a name-to-address relationship (edge) is represented in a Graph-Viz description file. It indicates a connection between a domain name and an IP address.

```dot
# Known name->address edges

NA0000 third.guardproof.info. 61.141.32.197
```

--------------------------------

### Sending Files to Printer with lp in Bash

Source: https://tldp.org/LDP/abs/html/extmisc.html

This example demonstrates the basic usage of the `lp` command to send a file to the printer queue. It also shows how to pipe formatted output from `pr` or processing results from `groff` or `gs` to `lp`.

```bash
lp file1.txt
# or
lp <file1.txt
# or
pr -options file1.txt | lp
# or
groff -Tascii file.tr | lp
# or
gs -options | lp file.ps
```

--------------------------------

### Graph-Viz Address Node Definition Example

Source: https://tldp.org/LDP/abs/html/contributed-scripts.html

This code snippet provides an example of how IP address nodes are defined in a Graph-Viz description file. It illustrates the structure for labeling nodes with IP addresses.

```dot
A0000 [label="61.141.32.197"] ;
```

--------------------------------

### Continuous Output Emulation with 'yes' in Bash

Source: https://tldp.org/LDP/abs/html/extmisc.html

This example shows how to emulate the `yes` command in Bash to continuously output a specified string or a default 'y'. It's useful for scripting scenarios where a program expects repeated input, but caution is advised for potentially destructive commands.

```bash
yes () {
  # Trivial emulation of "yes" ...
  local DEFAULT_TEXT="y"
  while [ true ]   # Endless loop.
  do
    if [ -z "$1" ]
    then
      echo "$DEFAULT_TEXT"
    else           # If argument ...
      echo "$1"    # ... expand and echo it.
    fi
  done             #  The only things missing are the
}                  #+ --help and --version options.
```

--------------------------------

### Bash Array Element Access

Source: https://tldp.org/LDP/abs/html/special-chars.html

Shows how to access elements of a Bash array using bracket notation for the index. Array indices start from 0 by default, but can be assigned starting from 1.

```bash
Array[1]=slot_1
echo ${Array[1]}
```

--------------------------------

### Bash Comments (#)

Source: https://tldp.org/LDP/abs/html/special-chars.html

Lines starting with '#' are treated as comments and are not executed by the shell. Comments can appear at the beginning of a line, after a command, or even within pipes. Quoted or escaped '#' characters do not start comments.

```bash
# This line is a comment.

```

```bash
echo "A comment will follow." # Comment here.
#                            ^ Note whitespace before #

```

```bash
     # A tab precedes this comment.

```

```bash
initial=( `cat "$startfile" | sed -e '/#/d' | tr -d '\n' |
# Delete lines containing '#' comment character.
           sed -e 's/\./\. /g' -e 's/_/_ /g'` )
# Excerpt from life.sh script

```

```bash
echo "The # here does not begin a comment."
echo 'The # here does not begin a comment.'
echo The \# here does not begin a comment.
echo The # here begins a comment.

echo ${PATH#*:}       # Parameter substitution, not a comment.
echo $(( 2#101011 ))  # Base conversion, not a comment.

# Thanks, S.C.

```

--------------------------------

### cdl Command Examples: Navigating History

Source: https://tldp.org/LDP/abs/html/contributed-scripts.html

Demonstrates how to use the 'cdl' command to navigate through directory history. It shows examples of listing history, changing to specific history entries, and accessing special entries.

```bash
/home/phil$ @
# List the entries with the @
History:
# Output of the @ command
.....
# Skipped these entries for brevity
1 /home/phil/ummdev               S1 /home/phil/perl
# Most recent two history entries
0 /home/phil/perl/eg              S0 /home/phil/umm/ummdev
# and two special entries are shown

/home/phil$ cd /home/phil/utils/Cdll
# Now change directories
/home/phil/utils/Cdll$ @
# Prompt reflects the directory.
History:
# New history
.....   
1 /home/phil/perl/eg              S1 /home/phil/perl
# History entry 0 has moved to 1
0 /home/phil                      S0 /home/phil/umm/ummdev
# and the most recent has entered
   
To go to a history entry:

/home/phil/utils/Cdll$ cd 1
# Go to history entry 1.
/home/phil/perl/eg$
# Current directory is now what was 1

To go to a special entry:

/home/phil/perl/eg$ cd -s1
# Go to special entry 1
/home/phil/umm/ummdev$
# Current directory is S1
```

--------------------------------

### Bash Tab Completion Examples

Source: https://tldp.org/LDP/abs/html/tabexpansion.html

Demonstrates the basic usage of Bash's programmable completion feature. Pressing the Tab key after typing a partial command, variable, or path attempts to auto-complete the input. If multiple possibilities exist, they are listed.

```bash
bash$ xtra[Tab]
xtraceroute       xtrapin           xtrapproto
 xtraceroute.real  xtrapinfo         xtrapreset
 xtrapchar         xtrapout          xtrapstats

bash$ xtrac[Tab]
xtraceroute       xtraceroute.real

bash$ xtraceroute.r[Tab]
xtraceroute.real
```

```bash
bash$ echo $BASH[Tab]
$BASH                 $BASH_COMPLETION      $BASH_SUBSHELL
 $BASH_ARGC            $BASH_COMPLETION_DIR  $BASH_VERSINFO
 $BASH_ARGV            $BASH_LINENO          $BASH_VERSION
 $BASH_COMMAND         $BASH_SOURCE

bash$ echo /usr/local/[Tab]
bin/     etc/     include/ libexec/ sbin/    src/     
doc/     games/   lib/     man/     share/
```
Tokens:
Raw