The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Variables and Data Types

Next ►
►

In this section, we will delve into the fundamentals of variables and data types in shell scripting. Understanding these concepts is crucial for writing effective and efficient scripts.

What are Variables?

Variables are used to store data that can be referenced and manipulated within a script. They act as placeholders for values that can change or be reused throughout the script.

Declaring Variables

In shell scripting, you declare a variable by simply assigning a value to it. There is no need to specify the data type explicitly.

#!/bin/bash

# Declaring a variable
greeting="Hello, World!"

# Using the variable
echo $greeting

Rules for Naming Variables

  1. Variable names must start with a letter or an underscore (_).
  2. Variable names can contain letters, numbers, and underscores.
  3. Variable names are case-sensitive (VAR and var are different).
  4. Avoid using special characters and reserved keywords.

Best Practices

  • Use meaningful variable names.
  • Use uppercase letters for environment variables and lowercase for local variables.

Data Types

Shell scripting primarily deals with strings and numbers. Unlike other programming languages, shell scripting does not have explicit data types. However, understanding how to handle different types of data is essential.

Strings

Strings are sequences of characters. They can be enclosed in single quotes (') or double quotes (").

#!/bin/bash

# Single-quoted string
single_quote='This is a single-quoted string.'

# Double-quoted string
double_quote="This is a double-quoted string."

# Using variables in double-quoted strings
name="Alice"
greeting="Hello, $name!"

echo $single_quote
echo $double_quote
echo $greeting

Numbers

Numbers in shell scripting are typically treated as strings unless used in arithmetic operations.

Integer Arithmetic

You can perform arithmetic operations using the expr command or the $(( )) syntax.

#!/bin/bash

# Using expr
num1=5
num2=3
sum=$(expr $num1 + $num2)
echo "Sum using expr: $sum"

# Using $(( ))
sum=$((num1 + num2))
echo "Sum using \$(( )): $sum"

Floating-Point Arithmetic

For floating-point arithmetic, you can use the bc command.

#!/bin/bash

num1=5.5
num2=3.2
sum=$(echo "$num1 + $num2" | bc)
echo "Sum using bc: $sum"

Practical Examples

Example 1: Simple Calculator

Create a script that performs basic arithmetic operations.

#!/bin/bash

# Simple Calculator
echo "Enter first number: "
read num1
echo "Enter second number: "
read num2

sum=$((num1 + num2))
diff=$((num1 - num2))
prod=$((num1 * num2))
quot=$((num1 / num2))

echo "Sum: $sum"
echo "Difference: $diff"
echo "Product: $prod"
echo "Quotient: $quot"

Example 2: Greeting Script

Create a script that greets the user based on the time of day.

#!/bin/bash

# Greeting Script
hour=$(date +"%H")

if [ $hour -lt 12 ]; then
    greeting="Good morning"
elif [ $hour -lt 18 ]; then
    greeting="Good afternoon"
else
    greeting="Good evening"
fi

echo "$greeting! Welcome to the Linux scripting tutorial."

Exercises

Exercise 1: Variable Manipulation

Create a script that takes a user's name and age as input and prints a message.

Solution:

#!/bin/bash

# User Input
echo "Enter your name: "
read name
echo "Enter your age: "
read age

# Output Message
echo "Hello, $name! You are $age years old."

Exercise 2: Temperature Conversion

Create a script that converts a temperature from Celsius to Fahrenheit.

Solution:

#!/bin/bash

# Temperature Conversion
echo "Enter temperature in Celsius: "
read celsius

fahrenheit=$(echo "scale=2; $celsius * 9 / 5 + 32" | bc)
echo "$celsius°C is equal to $fahrenheit°F"

Common Mistakes and Tips

  • Uninitialized Variables: Always initialize variables before using them to avoid unexpected behavior.
  • Quoting Variables: Use double quotes around variables to prevent word splitting and globbing.
  • Arithmetic Operations: Remember that shell scripting treats numbers as strings unless explicitly used in arithmetic contexts.

Conclusion

In this section, we covered the basics of variables and data types in shell scripting. We learned how to declare and use variables, handle strings and numbers, and perform arithmetic operations. With these fundamentals, you are now equipped to write more complex and dynamic scripts. In the next section, we will explore control structures to add logic to your scripts.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved