Variables & Scope in Shell Scripting

This module introduces the foundational building blocks of Shell Scripting in Linux DevOps environments. It covers workspace initialization, interpreter declaration via the Shebang directive, single-line and multi-line commenting techniques, and the core concept of dynamic variables.

1. Environment & Workspace Setup

Before writing scripts, DevOps engineers establish structured directory hierarchies to isolate distinct tasks and daily exercises.

In a Linux terminal environment (such as an AWS EC2 instance), navigate to your target project folder and create a dedicated directory for the module tasks:

# Navigate to the main shell scripting directory
cd shell-scripting-for-devops

# Create and enter the workspace directory for Day 2
mkdir day2
cd day2

# Create the script file using the touch command or a terminal editor
touch jethalal_ki_duniya.sh

2. The Shebang Directive (#!/bin/bash)

Every robust shell script begins with the Shebang directive on line 1. The word "Shebang" derives from the combination of the sharp symbol (#, also called hash) and the bang symbol (!, exclamation mark).

#!/bin/bash

Technical Purpose

• Interpreter Resolution: Informs the Linux kernel which binary executable should interpret and execute the commands contained within the file.
• Standardization: Ensures consistent script behavior across different Unix-like environments regardless of the default shell assigned to the executing user.

Note: Without a Shebang, the script executes using the current user's default shell (e.g., standard /bin/sh or /bin/zsh), which may lack specific Bash features.

3. Single-Line Commenting

Comments are non-executable text annotations used to document script logic, mark author intent, and make codebase maintenance easier for team members.

In Bash, single-line comments are prefixed with the # symbol:

# This is Jethalal Ki Duniya script
# Author: DevOps Engineering Team

When the Bash parser encounters # outside of quotes, it ignores everything following it on that specific line during execution.

4. Multi-Line Commenting via Here-Doc Syntax

Prefixing # on dozens of consecutive lines can become tedious. Bash allows block commenting through Here-Doc (Here-Document) redirection blocks.

Syntax Structure

<< comment
Anything written here
will not be executed by the Bash interpreter.
Multiple lines can be written here freely.
comment

How It Works

• << acts as an inline redirection operator.
• comment serves as an arbitrary delimiter word indicating the start and end of the block.
• The interpreter treats the delimited block as stdin input to a no-op evaluation, effectively rendering it a non-executed block comment.

5. Introduction to Variables

Variables act as named memory locations designed to hold dynamic data that can change during script execution.

Core Mental Model

Think of a variable as a labeled container or slot. The variable name remains fixed, while the data held inside changes dynamically based on user input, system conditions, or API responses.

Real-Life Analogy

Just as a person's identifier slot (Name) can store different values (Shubham, Rahul, Rohit) depending on context, a script variable holds dynamic strings, integers, or command outputs.

6. Execution Flow Walkthrough

The conceptual flow of how a Linux shell processes a newly created script from initialization to variable declaration:

7. Initial Script Code

Below is the consolidated code construct demonstrated in the module:

#!/bin/bash

# Single-line comment: Script title annotation
# This is Jethalal ki duniya

<< comment
Multi-line comment block:
This script contains characters and workflows centered around
the core script logic. Anything written inside this block
will be skipped during execution.
comment

# Variable declaration (dynamic placeholder demonstration)
name="Shubham"

echo "Script initialized for user: $name"

Summary and Key Takeaways

• Workspace Organization: Always segregate shell scripting tasks into dedicated project subdirectories using mkdir and cd.
• Shebang Requirement: Include #!/bin/bash at line 1 of every script to force execution via the standard Bash binary.
• Single-Line Comments: Use # for short, inline documentation and logic clarity.
• Multi-Line Comments: Utilize Here-Doc syntax (<< delimiter ... delimiter) to safely comment out entire blocks without repetitive # tags.
• Variable Concept: Variables serve as dynamic memory containers, allowing scripts to process variable inputs (like usernames, IPs, or build IDs) flexibly.