A Document series by VIEH Group

Bash Scripting
Learn how to dance on terminal
 Disclaimer

Dear readers,
This document is provided by VIEH Group for educational purposes only.
While we strive for accuracy and reliability, we make no warranties or
representations regarding the completeness, accuracy, or usefulness of the
information presented herein. Any reliance you place on this document is at
your own risk. VIEH Group shall not be liable for any damages arising from
the use of or reliance on this document. We acknowledge and appreciate the
contribution of the source person.

also,
This document is not created by a professional content writer so any mistake
and error is a part of great design

Happy learning !!!

This document is credited to Adhyansh Jaiswal, whose exceptional insights

elevate its value. Their contribution is deeply appreciated, underscoring their
significant role in its creation.

Our newsletter: Cyber Arjun

Scan QR:

Social Media: @viehgroup viehgroup.com [email protected]

💡 Check Your Shell Type: Run the following command to identify your current
shell:
echo $0

🔹 How to Create a File and Use It?

Creating and editing files using the vi command is a core skill for working in
Unix and Linux environments. Here’s a step-by-step guide on creating a file,
entering content, and saving it with vi, as well as how to run your script and
view its output.

1. OpeningvitoCreateaNewFile
○Openyourterminal.

Type the following command to create or open a file in vi:

vi my_script.sh
○ Note: If my_script.sh doesn’t exist, vi will create a new file with
that name.

2. BasicviEditingCommands
When you open vi, you’re in command mode, where you can issue
commands to vi. Here’s how to enter insert mode to start writing:
○
Pressitoenterinsertmode.Youcannowtypecontentintothefile.

3. WritingContentinvi
Let’s create a simple script that prints "Hello, World!" and displays the
current date and time. With vi in insert mode, type the following script:

#!/bin/bash

# This script prints a greeting and the current date

and time

Social Media: @viehgroup viehgroup.com [email protected]

 echo "Hello, World!"

echo "The current date and time is:"

date

4. ExitInsertMode:
Press Esc to return to command mode.

5. SavingandExitinginvi
To save the file and exit vi:
○Type:wqandpressEnter.
:wq means "write (save) and quit."
Alternatively:
○ Tosavewithoutexiting,type:wandpressEnter.
○ Toquitwithoutsavingchanges,type:q!andpressEnter.

6. MakingtheScriptExecutable
Before running your script, you need to make it executable. In the
terminal, type:
chmod +x my_script.sh

7. RunningtheScriptandViewingOutput
Run the script by typing:
./my_script.sh

8. RuntheScriptWithoutMakingItExecutable:
You can directly run it with bash by typing:
bash my_script.sh

Social Media: @viehgroup viehgroup.com [email protected]

 View the Output:
When you execute the script, you should see output similar to this:
Hello, World!

The current date and time is:

Tue Nov 6 12:34:56 UTC 2023

🔹 Process Control Shortcuts

● Ctrl + C:Terminatesarunningprocessimmediately.Usefulfor
stopping commands or scripts that are running.
● Ctrl + Z:Pauses(stops)aprocessandsendsittothebackground.
Resume with fg (foreground) or bg (background).

🔹 Comments in Shell Scripting

Single-Line Comments:
Use the # symbol at the beginning of a line to create a single-line comment.

# This is a single-line comment

echo "Hello, World!" # This comment is on the same line as

a command

Multi-Line Comments:
Bash does not have a direct syntax for multi-line comments, but you can
simulate it using a here-document with <<.
: <<'COMMENT'

This is a multi-line comment.

You can add multiple lines here.

COMMENT

Social Media: @viehgroup viehgroup.com [email protected]

Alternatively, use the << syntax directly:

<<comment

This is a multi-line comment.

It won’t be executed.

comment

📜 Writing Your First Shell Script

💡 Getting Started with Scripting
A script is a series of commands executed sequentially. Here’s a simple example
that prints a message to the screen:
#!/bin/bash # Shebang to specify the interpreter

echo "Hello World!"

Output:
Hello World!

🖥 How to Run Your Script:

Make it Executable:
chmod +x script.sh

Execute the Script:

./script.sh

WhyShebang( #!/bin/bash)Matters
This line tells the system to use Bash to run the script, ensuring compatibility
across Linux environments.

Social Media: @viehgroup viehgroup.com [email protected]

📊 Working with Variables and Arrays
Variables and arrays allow data storage and manipulation in scripts, making
automation more flexible.

🔹 Variables: Define a variable and use $ to access its value.

NAME="Linux"

echo "Welcome to $NAME Scripting"

🔹 Constants: Make variables read-only with readonly.

readonly VERSION="1.0"

🔹 Arrays: Store multiple values.

myArray=(1 2 3 "Hello" "World")

echo "${myArray[1]}"

Outputs: 2

● Get the length of an array:

echo "${#myArray[@]}"
or echo "${#myArray[*]}"

This returns the total number of elements in the array.

● Get specific values from an array:

To get values starting from a specific index:
echo "${myArray[*]:1}"
This fetches all elements starting from the second element (index 1).

Social Media: @viehgroup viehgroup.com [email protected]

 ● To get a specific range of values:
echo "${myArray[*]:1:2}"
This fetches 2 elements starting from index 1.

Update an array (Add new elements):

●
myArray+=(5 6 8)

● Working with Associative Arrays

Declare and Initialize:

declare -A myArray

myArray=( [name]=Paul [age]=20 )

Access Values:
echo "${myArray[name]}"

Get Array Length:

echo "${#myArray[@]}"

Update Array:
myArray+=( [city]=NewYork )

💡 Arrays are handy for managing lists of values, such as filenames or

configurations.

Social Media: @viehgroup viehgroup.com [email protected]

🧩 String and Arithmetic Operations
String Manipulation Examples:
str="Shell Scripting"

Length:
echo ${#str}
Replace: Outputs: 15
echo ${str/Scripting/Programming} Outputs: Shell Programming
Extract Substring:
echo ${str:6:9}

Outputs: Scripting

Get the length of a string:

myVar="Hello World!"
length=${#myVar}
echo$length Output:12

Convert to uppercase:
upper=${myVar^^}
echo$upper Output:HELLOWORLD!

Convert to lowercase:
lower=${myVar,,}
echo$lower Output:helloworld!

Replace a substring:
replace=${myVar/World/Buddy}
echo $replace Output: Hello Buddy!

Extract a substring (slice):

slice=${myVar:6:5}
echo$slice Output:World

Social Media: @viehgroup viehgroup.com [email protected]

🔹 USER INTERACTIONS
Taking Input from the User in Shell Scripting

● BasicInput:
read var_name
echo "You entered: $var_name"

Example Output:
(User types "John")
You entered: John

● Input with Prompt:

read -p "Your name: " NAME
echo "Hello, $NAME!"
Example Output:
(Your name: User types "John")
Your name: John
Hello, John!

Key Difference:

● BasicInput:Takesinputwithoutaprompt.
● Input with Prompt: Displays a prompt to guide the user.

🔹 Arithmetic Operations
● Usingtheletcommand:
Increment:
let a++
This increments the value of a by1.

Social Media: @viehgroup viehgroup.com [email protected]

 Assignment with multiplication:
let a=5*10
echo$a Output:50

● Using (()) for arithmetic operations:

Increment:
((a++))

Assignment with multiplication:

((a=5*10))
echo$a Output:50

Key Difference:

● letismoretraditional,while(( ))ismoremodernandallowsformore
complex arithmetic expressions.

Use $((expression)) forcomplexcalculations:

echo $((5 * (3 + 2))) Output: 25

📈 Conditional Statements in Shell Scripting

if Statement:

if [ $a -gt $b ]; then
echo "a is greater than b"

fi

Social Media: @viehgroup viehgroup.com [email protected]

if-else Statement:
if [ $a -gt $b ]; then

echo "a is greater than b"

else

echo "a is not greater than b"

fi

elif (else if) Statement:

if [ $a -gt $b ]; then

echo "a is greater than b"

elif [ $a -eq $b ]; then

echo "a is equal to b"

else

echo "a is less than b"

fi

Case Statement:
case $a in

a) echo "a is 1" ;; b) echo "a is

2" ;; *) echo "a is neither 1 nor

2" ;;

esac

Social Media: @viehgroup viehgroup.com [email protected]

Key Notes:

● Alwaysputspacesaroundoperatorsinconditions.
● elif and else are optional but useful for handling multiple conditions.

Comparison Operators

Equalto: -eq or ==:Checksiftwovaluesareequal.

[ $a -eq $b ]

Greater Than or Equal to: -ge: Checks if the left operand is greater than or
equal to the right.
[ $a -ge $b ]

Less Than or Equal to: -le: Checks if the left operand is less than or equal to
the right.
[ $a -le $b ]

Not Equal to: -ne or !=: Checks if two values are not equal.
[ $a -ne $b ]

Greater Than: -gt : Checks if the left operand is greater than the right.
[ $a -gt $b ]

Less Than: -lt : Checks if the left operand is less than the right.
[ $a -lt $b ]

Social Media: @viehgroup viehgroup.com [email protected]

🔹 Logical Operators
Using && (AND) Operator:
a=10
b=5
if [ $a -gt 5 ] && [ $b -lt 10 ]; then
echo "Both conditions are true"
else
echo "One or both conditions are false"
fi

Using || (OR) Operator:

a=10 b=15 if [ $a -gt 5 ] || [ $b -lt
10 ]; then

echo "At least one condition is true"

else
echo "Neither condition is true"
fi

Combining && and || Operators:

a=10
b=5
c=15
if [ $a -gt 5 ] && [ $b -lt 10 ] || [ $c -eq 15 ]; then
echo "Condition met"
else
echo "Condition not met"
fi

Explanation:

● The&&ensuresbothconditionsmustbetrue.
● The||checksthesecondconditionifthefirstfails.

Social Media: @viehgroup viehgroup.com [email protected]

🔹Ternary Operator (One-liner If-Else)
Asimplewaytowritean if-else statementinoneline:

a=10
[ $a -gt 5 ] && echo "Greater" || echo "Not Greater"

Explanation:

● If$a -gt 5istrue,itprints"Greater".

● Otherwise,itprints"NotGreater".

🔄 For Loop
The for loop iterates over a list or a range of values and performs actions for
each item.
Syntax:

for item in list; do

# Commands to execute for each item

done

Example:
foriin123;do
echo "Number: $i"
done

Output:
Number: 1
Number: 2
Number: 3

Social Media: @viehgroup viehgroup.com [email protected]

Range Example:
for i in {1..3}; do
echo "Count: $i"
done

Output:
Count: 1
Count: 2
Count: 3

🔄 While Loop
The while loop runs as long as the specified condition is true.

Syntax:

while [ condition ]; do
# Commands to execute
done

Example:
count=1
while [ $count -le 3 ]; do
echo "Count is: $count"
((count++)) # Increment count
done

Output:
Count is: 1
Count is: 2
Count is: 3

Social Media: @viehgroup viehgroup.com [email protected]

🔄 Until Loop
The until loop continues to execute until the condition becomes true.

Syntax:

until [ condition ]; do
# Commands to execute
done

Example:
count=1
until [ $count -gt 3 ]; do
echo "Count is: $count"
((count++))
done

Output:
Count is: 1
Count is: 2
Count is: 3

🔄 Infinite Loop
An infinite loop continues running indefinitely until it is manually stopped (e.g.,
using Ctrl+C).
For Loop Infinite Example:

for (( ; ; )); do

echo "This is an infinite loop"

done

Social Media: @viehgroup viehgroup.com [email protected]

While Infinite Example:
while :; do

echo "Infinite loop with while"

done

Until Infinite Example:

until false; do

echo "Infinite loop with until"

done

Output (repeats indefinitely):

This is an infinite loop

This is an infinite loop

...

🖥 Select Loop
The select loop creates a simple menu system, which allows users to select an
option from a list. It's useful when you need a user-driven selection process.
Syntax:

select option in list; do

# Commands based on user choice

done

Social Media: @viehgroup viehgroup.com [email protected]

Example:
PS3="Choose a fruit: "
select fruit in Apple Banana Orange Exit; do
case $fruit in
Apple) echo "You chose Apple";;
Banana) echo "You chose Banana";;
Orange) echo "You chose Orange";;
Exit) break;; *) echo "Invalid
option";;
esac
done

Example Output:
1) Apple 2)
Banana 3) Orange
4) Exit Choose a
fruit: 2 You
chose Banana

Explanation:
●
PS3setsthepromptmessage.
● Theselectloopdisplaysoptions,andeachselectionrunsthe
corresponding case statement.
● Thebreakstatementexitstheloopwhentheuserselects"Exit."

Summary of Loop Types

●
ForLoop:Iteratesoveralistorrange.
● WhileLoop:Continuesaslongasaconditionistrue.
● Until Loop: Continues until a condition becomes true.
● InfiniteLoop:Runsindefinitelyuntilinterrupted.
● SelectLoop:Displaysamenuforuserselection.

Social Media: @viehgroup viehgroup.com [email protected]

💡 Tip:
Loops are powerful tools for automating repetitive tasks. You can use them for
various purposes like iterating over files, arrays, or ranges. For example, you can
rename all files in a directory using a loop.

🔄 Functions
1. DefiningFunctions:

You can define a function using either of these two syntaxes:

function function_name { ... }
or
function_name() { ... }

2. BasicFunction:

Functions are used to encapsulate reusable blocks of code.

greet() {
echo "Hello, welcome to the shell script!"
}
greet # Calling the function

3. Functions with Parameters:

Functions can accept arguments, which are accessed via $1, $2

, etc.

greet_user() {
echo "Hello, $1!"
}
greet_user "Adhyansh"

Social Media: @viehgroup viehgroup.com [email protected]

4. ReturnValues:

Functions return values via echo, and the output can be captured.

add_numbers() {
result=$(( $1 + $2 ))
echo $result
}
sum=$(add_numbers 3 5)
echo "The sum is: $sum"

5. Conditional Logic and Loops:

Functions can include conditions and loops.

check_even() {
if (( $1 % 2 == 0 )); then
echo "$1 is even"
else
echo "$1 is odd"
fi
}
check_even 7 output: "7 is odd"

6. Recursion:
Functions can call themselves recursively.
factorial() {
if [ $1 -le 1 ]; then
echo 1
else
prev=$(factorial $(( $1 - 1 )))
echo $(( $1 * prev ))
fi
}

Social Media: @viehgroup viehgroup.com [email protected]

 result=$(factorial 5)
echo "Factorial of 5 is: $result"

7. DefaultValues:

Set default values for arguments using ${1:-default_value}.

greet() {
local name=${1:-Guest}
echo "Hello, $name!"
}
greet"Adhyansh" Output:"Hello,Adhyansh!"
greet Output:"Hello,Guest!"

8. PassingArgumentsbyReference:

Bash doesn't directly support passing by reference but can simulate it using
eval.

modify_value() {
eval $1=\$2
}
modify_value var 100
echo "The value of var is now: $var" Output: "The
value of var is now: 100"

9. ArgumentPassing:

You can pass arguments to functions, and they can be accessed inside the
function.

■ PositionalArguments:$1,$2,$3,etc.(Accessindividual
arguments).

Social Media: @viehgroup viehgroup.com [email protected]

 ■ All Arguments: $@ (all arguments as separate words), $* (all
arguments as a single string).
■ Argument Count: $# (number of arguments passed).

1. Positional Arguments ($1, $2, $3, etc.)

● Theserepresentindividualargumentspassedtoafunctionorscript.
● $1isthefirstargument,$2isthesecond,andsoon.

Example:

greet() {
echo "Hello, $1! You are $2 years old."
}
greet "Adhyansh" 25

Output: Hello, Adhyansh! You are 25 years old.

2. All Arguments ($@

)

● Thisrepresentsalltheargumentspassedtoafunctionorscript.
● Eachargumentistreatedasaseparateword,whichisespeciallyuseful
when looping over the arguments.

Example:

print_all() {
for arg in "$@"; do
echo "$arg"
done
}
print_all "Apple" "Banana" "Cherry"
Output:
Apple
Banana
Cherry

Social Media: @viehgroup viehgroup.com [email protected]

3. All Arguments as a Single String ($*)

● Similarto$@,butittreatsallargumentsasasinglestring,meaningspaces
between arguments may be lost.

Example:

print_all_as_string() {
echo "$*"
}
print_all_as_string "Apple" "Banana" "Cherry"
Output: Apple Banana Cherry

4. Number of Arguments ($#)

● Thisgivesthecountoftheargumentspassedtoafunctionorscript.

Example:

count_args() {
echo "Number of arguments: $#"
}
count_args "Apple" "Banana" "Cherry"
Output: Number of arguments: 3

Summary

● Functions in shell scripts help organize code, making it modular and

reusable.
● Argumentscanbepassedtofunctions,accessedvia$1,$2,etc.,and
default values can be set.
● Youcanuseloopsandconditionalsinsidefunctionstoaddlogic.
● Functionsreturnvaluesusingecho,whichcanbecapturedinvariables.

Social Media: @viehgroup viehgroup.com [email protected]

🔄 shift Operator in Bash
The shift command in Bash allows you to move (shift) the positional parameters
(arguments) passed to a script or function. Here's a brief explanation of how it
works:

Syntax:

● shift:Shiftspositionalparametersleftbyoneposition.
● shift n:Shiftspositionalparametersleftbynpositions.

Example 1: Shifting Arguments (One Position)

shift_example() {
echo "Original arguments: $1, $2, $3"
shift
echo "After shift: $1, $2, $3"
}
shift_example "one" "two" "three"

Output:
Original arguments: one, two, three
After shift: two, three
After the shift, $1 becomes "two", and $2 becomes "three".

Example 2: Shifting Arguments Multiple Times

shift_multiple() {
echo "Original arguments: $1, $2, $3, $4"
shift 2
echo "After shifting 2 times: $1, $2"
}
shift_multiple "apple" "banana" "cherry" "date"

Social Media: @viehgroup viehgroup.com [email protected]

Output:
Original arguments: apple, banana, cherry, date
After shifting 2 times: cherry, date
After shifting 2 positions, "apple" and "banana" are discarded, and the remaining
arguments are shifted left.

Example 3: Using shift with a Loop

process_args() {
while [ "$#" -gt 0 ]; do
echo "Processing argument: $1"
shift
done
}
process_args "arg1" "arg2" "arg3" "arg4"

Output:
Processing argument: arg1 Processing argument: arg2
Processing argument: arg3 Processing argument: arg4
The loop processes each argument one by one by shifting the arguments left until
there are no more arguments ($# becomes 0).

Example 4: Combining shift with $# to Count Remaining Arguments

process_first_two() {
echo "First argument: $1"
echo "Second argument: $2"
shift 2
echo "Remaining arguments: $@"
}
process_first_two "apple" "banana" "cherry" "date"

Social Media: @viehgroup viehgroup.com [email protected]

Output:
First argument: apple
Second argument: banana
Remaining arguments: cherry date

After shifting by 2, the first two arguments are removed, and the remaining
arguments are accessible using $@.

Key Points:

● shift removes the first argument ($1) and shifts the remaining arguments
left.
● You can shift by multiple positions using shift n.
● The $# variable always reflects the remaining number of arguments.
● The shift command is useful in loops for processing a variable number of
arguments.

break Statement

● Purpose:Exitsaloopprematurely.
● Syntax:breakorbreak n(exitstheloopandcanexitmultiplenested
loops with n).

Example:

for i in {1..5}; do
if [ $i -eq 3 ]; then break; fi
echo $i
done

● Output:Loopsuntili=3,thenexits.

Social Media: @viehgroup viehgroup.com [email protected]

2. continue Statement

● Purpose:Skipsthecurrentloopiterationandmovestothenextone.
● Syntax:continueorcontinue n(skipscurrentiterationinnestedloops).

Example:

for i in {1..5}; do
if [ $i -eq 3 ]; then continue; fi
echo $i
done
● Output:Skipsiterationwhen i=3.

3. break and continue in Nested Loops

● break: break n can exit multiple levels of nested loops.

● continue:continue nskipsthecurrentiterationinmultiplenestedloops.

Example:

for i in {1..3}; do
for j in {1..3}; do
if [ $i -eq 2 ] && [ $j -eq 2 ]; then break 2; fi
echo "i=$i, j=$j"
done
done
● Output:Exitsbothloopswheni=2andj=2.

4. sleep Command

● Purpose:Pausesthescriptforaspecifiedtime.
● Syntax:sleep <duration>

Example:

sleep 5 # Pauses for 5 seconds

Social Media: @viehgroup viehgroup.com [email protected]

5. exit Command

● Purpose:Exitsascriptwithastatuscode(0forsuccess,non-zeroforerror).
● Syntax:exit <exit_code>

Example:

exit 1 # Exits with an error status

6. $? (Exit Status of Last Command)

● Purpose: Stores the exit status of the last executed command.

Example:

mkdir myfolder

echo $? # Returns 0 if successful, 1 if failed.

Summary

● break:Exitloops.
● continue:Skipsaniterationinloops.
● sleep:Pausesscriptexecution.
● exit:Terminatesascriptwithastatuscode.
● $?:Checkstheexitstatusofthelastcommand.

seq command

The seq command in Linux is used to generate a sequence of numbers. It's

commonly used in shell scripting or on the command line to generate numbers for
loops, lists, or ranges.

Social Media: @viehgroup viehgroup.com [email protected]

Basic Syntax:
seq [options] <start> <end>

● start:Thestartingnumberofthesequence.
● end:Theendingnumberofthesequence.

Examples of Using the seq Command:

Basic Sequence: Generate a sequence of numbers from 1 to 5:

seq 1 5

Output:
1 2 3 4 5
Custom Step Size: You can specify a step size between numbers. For example, to
generate numbers from 1 to 10 with a step size of 2:
seq 1 2 10
Output:

1
3
5
7
9

Generating a Sequence with Decimal Values: You can also use floating-point
numbers with seq. For example, generate numbers from 0 to 1 with a step size of
0.2:
seq 0 0.2 1

Social Media: @viehgroup viehgroup.com [email protected]

Output:
0.0 0.2 0.4 0.6 0.8 1.0
Reverse Sequence: You can reverse the order of the sequence by making the
start number greater than the end number:
seq 5 -1 1
Output:
5 4 3 2 1

Using seq with for Loop: You can use seq ina for loop. For example, printing
numbers from 1 to 5:

for i in $(seq 1 5); do

echo "Number: $i"
done

Output:
Number: 1
Number: 2
Number: 3
Number: 4
Number: 5

Social Media: @viehgroup viehgroup.com [email protected]

Common Options with seq:

-f: Format the output using a format string (like printf).

seq -f "Number: %.2f" 1 5

Output:
Number: 1.00 Number: 2.00 Number: 3.00 Number: 4.00 Number:
5.00
-s: Change the separator between numbers. By default, it’s a newline, but you can
change it:
seq -s "," 1 5
Output:
1,2,3,4,5
-w: Pad numbers with leading zeros to make them all the same width:
seq -w 1 5
Output:
01 02 03 04 05

Summary:

The seq command is a powerful and simple tool to generate sequences of

numbers, and it can be customized in many ways using options for formatting,
step size, and separators.

Social Media: @viehgroup viehgroup.com [email protected]

Brace Expansion is a feature in the shell (especially Bash) that allows you to
generate multiple text strings from a single expression. It is typically used to
create lists of strings or numbers, or to generate filenames with multiple variations.
Brace expansion is a simple and efficient way to generate multiple values without
having to manually list them.

Basic Syntax:

{item1,item2,item3}

This will generate a list containing the individual items within the braces.

Examples of Using Brace Expansion:

Creating a List of Words: You can generate a list of words by expanding a

comma-separated list inside braces:
echo {apple,banana,cherry}

Output:
apple banana cherry

Range of Numbers: You can create a sequence of numbers by using a range

inside the braces:

echo {1..5}

Output:
1 2 3 4 5
Range of Letters: You can also create a range of letters:
echo {a..e}
Output:
a b c d e

Social Media: @viehgroup viehgroup.com [email protected]

Range with Step Size: You can specify a step size by including it after the range:
echo {1..10..2}

Output:
1 3 5 7 9

Combining Text with Variables: You can use brace expansion to combine static
text with variables:

echo file{1..3}.txt

Output:
file1.txt file2.txt file3.txt

Nested Brace Expansion: You can also nest brace expansions to create more
complex patterns:
echo {A,B}{1,2}

Output:
A1 A2 B1 B2

Multiple Elements in a Single Expansion: You can combine multiple sets of values
within a single brace expansion:
echo {A,B,C}{1,2,3}

Output:
A1 A2 A3 B1 B2 B3 C1 C2 C3

Social Media: @viehgroup viehgroup.com [email protected]

Files and Directories: Brace expansion can also be used to generate multiple file
or directory names:
mkdir dir{1,2,3}

This will create the directories dir1, dir2, and dir3.

Important Points:

● Brace expansion happens before any other shell operation like variable
expansion or command substitution.
● It is not the same as parameter expansion or globbing. It is handled
directly by the shell before the command is executed.
● Nospacesbetweencommasinthebraces.Itshouldbe{item1,item2}
insteadof{item1, item2}.

Summary:

Brace expansion is a powerful feature in the shell that allows you to generate
sequences of strings, numbers, or characters without writing them out explicitly. It
can save time and reduce errors when generating repetitive patterns, filenames,
or arguments.

getopts command

The getopts command is used in shell scripting (primarily in Bash) to parse

command-line options (flags) and arguments passed to a script. It provides a way
to handle options and arguments in a structured and consistent manner, making
your script more flexible and user-friendly.

Basic Syntax:

getopts "option_string" variable

Social Media: @viehgroup viehgroup.com [email protected]

 ● option_string:Astringofvalidoptionletters.Ifanoptionrequiresan
argument, you append a colon (:) after the letter (e.g., a: means option a
expects an argument).
● variable:Thevariablewheretheparsedoptionwillbestored.

How getopts Works:

● getoptsprocessescommand-lineargumentsonebyone.
● Itsetsthevalueofthevariabletothecurrentoptionletter.
● Iftheoptionrequiresanargument,getoptswillassignthatargumenttoa
special variable, usually $OPTARG.

Example 1: Simple Options Parsing

This example shows how to handle single-letter options, such as -a or -b, in a

script.

Script Example (myscript.sh):

#!/bin/bash
while getopts "ab" option; do
case $option in
a) echo "Option A selected" ;; b)
echo "Option B selected" ;; \?) echo
"Invalid option"; exit 1 ;;
esac
done
Running the script:
$ ./myscript.sh -a
Option A selected

$ ./myscript.sh -b
Option B selected

Social Media: @viehgroup viehgroup.com [email protected]

Example 2: Options with Arguments

You can also specify options that require arguments (e.g., -f filename).

Script Example (myscript.sh):

#!/bin/bash
while getopts "f:n:" option; do
case $option in
f) echo "Option F selected with argument: $OPTARG" ;;
n) echo "Option N selected with argument: $OPTARG" ;;
\?) echo "Invalid option"; exit 1 ;;
esac
done

Running the script:

$ ./myscript.sh -f file.txt
Option F selected with argument: file.txt

$ ./myscript.sh -n 123
Option N selected with argument: 123

Example 3: Handling Long Options with Arguments

For options that have both short and long forms, you can use getopts to handle
short options (e.g., -f) but long options require additional parsing logic. Here's an
example for a simple long-option-like approach.

Script Example (myscript.sh):

#!/bin/bash
while getopts "f:n:" option; do
case $option in
f) echo "File option: $OPTARG" ;;
n) echo "Name option: $OPTARG" ;;

Social Media: @viehgroup viehgroup.com [email protected]

 \?) echo "Invalid option"; exit 1 ;;
esac
done

Running the script:

$ ./myscript.sh -f myfile.txt -n John
File option: myfile.txt
Name option: John

Explanation of Common getopts Usage:

● $OPTARG:Thisvariablecontainsthevalueoftheargumentpassedtoan
option (if any).
● $option:Thecurrentoptionbeingprocessed.
● \?: Used in the case statement to catch invalid options.

Example 4: Parsing Multiple Arguments and Options

In this example, we handle multiple options that require arguments:

ScriptExample( myscript.sh):
#!/bin/bash
while getopts "a:b:c:" option; do
case $option in
a) echo "Option A selected with value: $OPTARG" ;;
b) echo "Option B selected with value: $OPTARG" ;;
c) echo "Option C selected with value: $OPTARG" ;;
\?) echo "Invalid option"; exit 1 ;;
esac
done

Running the script:

$ ./myscript.sh -a 10 -b 20 -c 30

Social Media: @viehgroup viehgroup.com [email protected]

Option A selected with value: 10
Option B selected with value: 20
Option C selected with value: 30

Exiting When No Arguments Are Provided:

If no arguments are given or the getopts finds a missing or incorrect argument, it

will return ?, which can be caught to display an error or usage message.
Example:

#!/bin/bash

if [ $# -eq 0 ]; then

echo "No options provided."

exit 1

fi

while getopts "a:b:" option; do

case $option in

a) echo "Option A with argument: $OPTARG" ;;

b) echo "Option B with argument: $OPTARG" ;;

\?) echo "Invalid option"; exit 1 ;;

esac

done

Key Points:

● getopts is used to process options one by one.

Social Media: @viehgroup viehgroup.com [email protected]

 ● $OPTARG contains the value for options that take arguments.
● getopts does not handle long options (e.g., --option) directly; you’ll
need to process them manually if needed.
● Returncodes:
○0:Theoptionwassuccessfullyprocessed.
○ 1:Invalidoptionormissingargument.
Advantages:

● Providesasimpleandstandardwaytohandlecommand-lineoptions.
● Makesscriptsmoreuser-friendlyandinteractive.

1. basename:

● Stripsthedirectorypathandreturnsonlythefilename.Youcanalsoremove
a file extension if specified.
● Example:basename /home/user/file.txt → file.txt,and
basename /home/user/file.txt .txt → file.

2. dirname:

● Stripsthefilenameandreturnsthedirectorypath.
● Example:dirname /home/user/file.txt →/home/user.

3. realpath:

● Resolvesandreturnstheabsolutepathofafileordirectory,resolving
symbolic links.
● Example:realpath file.txt →
/home/user/Documents/file.txt.

Social Media: @viehgroup viehgroup.com [email protected]

4. File/Directory Existence Checks:

● -d <folder>:Checksifadirectoryexists.
● ! -d <folder>:Checksifadirectorydoesnotexist.
● -f <file>:Checksifafileexists.
● ! -f <file>:Checksifafiledoesnotexist.

Examples:
if [ -d /home/user/Documents ]; then echo "Directory
exists."; fi

if [ ! -f /home/user/nonexistentfile.txt ]; then echo "File

does not exist."; fi

5. RANDOM & UID:

● RANDOM:Generatesarandomnumberbetween0and32767.
● UID:StorestheuserIDofthecurrentlylogged-inuser.

Examples:
#Generatesarandomnumber
echo$RANDOM
echo $((RANDOM % 101)) # Random number between 0 and 100

echo$UID #UserIDofthelogged-inuser

These commands are essential tools for file path manipulation, file existence
checking, and working with system information in Bash scripts. Let me know if
you'd like further clarification or examples!

To continue running even after the terminal is closed, you can use nohup (short
for "no hang up"). This command is useful for running long-running processes or
scripts in the background, even if the terminal session is closed or disconnected.

Social Media: @viehgroup viehgroup.com [email protected]

 ❖ How to Use nohup:
To run a script in the background and keep it running after closing the
terminal,usethe nohup commandfollowedbythescriptorcommandand
an & torunitinthebackground.

nohup ./myscript.sh &

Example:
nohup bash myscript.sh &

This will run myscript.sh in the background, and the terminal can be closed
without interrupting the execution of the script. The standard output will be
redirected to a file called nohup.out unless you specify a different file.

❖ Redirecting Output:
If you don't want to see the output in the nohup.out file, you can redirect it
to /dev/null.

nohup ./myscript.sh > /dev/null 2>&1 &

❖ Checking Running Processes:

You can check if the script is running by using the ps command or jobs
command.
ps aux | grep myscript.sh
Or:
jobs

Social Media: @viehgroup viehgroup.com [email protected]

 ❖ Stopping Background Jobs:
To stop a background job, you can use the kill command with the
process ID (PID) of the job.
kill <PID>

Alternatively, you can bring the background job to the foreground using fg
andthenstopitwith Ctrl + C:
fg%1 # Bring job 1 to the foreground

Summary:

● nohup is used to run a command or script that will continue executing even
after the terminal is closed.
● The & operator runs the command in the background.
● You can redirect output to a file or /dev/null to suppress output.
● Use jobs and ps to check the status of background jobs.

Project: Simple Calculator

This calculator will support basic arithmetic operations like addition, subtraction,
multiplication, and division. The user can input the operation and two numbers,
and the script will return the result.

Steps:

1. Createanewfileforthescript:Openaterminalandcreateanewfile
named calculator.sh using a text editor.

vi calculator.sh

Social Media: @viehgroup viehgroup.com [email protected]

2. Add the script code: Below is the code for the calculator:

#!/bin/bash
# Function to add two numbers
add() {
echo "Result: $(($1 + $2))"
}

# Function to subtract two numbers

subtract() {
echo "Result: $(($1 - $2))"
}

# Function to multiply two numbers

multiply() {
echo "Result: $(($1 * $2))"
}

# Function to divide two numbers

divide() {
if [ $2 -eq 0 ]; then
echo "Error: Division by zero is not allowed!"
else
echo "Result: $(($1 / $2))"
fi
}

Social Media: @viehgroup viehgroup.com [email protected]

 # Menu to display options
echo "Simple Calculator"
echo "Choose operation:"
echo "1. Add" echo "2.
Subtract" echo "3.
Multiply" echo "4.
Divide"

read -p "Enter choice (1/2/3/4): " choice

read -p "Enter first number: " num1
read -p "Enter second number: " num2

# Perform the operation based on user's choice

case $choice in
1)
add $num1 $num2
;;
2)
subtract $num1 $num2
;;
3)
multiply $num1 $num2
;;
4)
divide $num1 $num2
;;
*)
echo "Invalid choice"
;;
esac

Social Media: @viehgroup viehgroup.com [email protected]

3. Make the script executable: After saving the script, make it executable by
running:
chmod +x calculator.sh

4. Run the script: Now you can run the calculator script using:
./calculator.sh

How the Script Works:

● The user is prompted to select an operation (addition, subtraction,

multiplication, or division).
● The script then asks for two numbers and performs the chosen operation.
● If division is selected and the second number is 0, the script will display an
error message instead of attempting to divide by zero.

Example Output:

$ ./calculator.sh Simple

Calculator Choose

operation: 1. Add 2.

Subtract 3. Multiply 4.

Divide Enter choice

(1/2/3/4): 1 Enter first

number: 10

Social Media: @viehgroup viehgroup.com [email protected]

 Enter second number: 5

Result: 15

This small project helps you understand basic conditional statements, user input
handling, and mathematical operations in Bash. You can expand this project by
adding more advanced operations (like square roots, exponents, etc.) or even a
loop to make the calculator run repeatedly.

**************************************************************************************

Social Media: @viehgroup viehgroup.com [email protected]

 Thanks for checking out, A lot of love
from VIEH Group

Jai hind

Social Media: @viehgroup viehgroup.com [email protected]