Forem: Oliver Quynh

Linux basics - Begin bash scripting

Oliver Quynh — Tue, 11 Feb 2025 07:43:32 +0000

Bash (Bourne Again Shell) is a powerful Unix shell and command language interpreter, serving as the default shell for most Linux distributions and macOS. It provides a command-line interface for interacting with the operating system, executing commands, and automating tasks through shell scripts. Bash supports variables, control structures, functions, and command substitution, making it versatile for system administration, DevOps tasks, and general-purpose scripting. Its ability to pipe commands, redirect input/output, and utilize a vast array of built-in commands and utilities makes it an essential tool for developers and system administrators in managing and automating workflows in Unix-like environments.

According to DevOps roadmap, Bash is a must have skill for everyone who wants to jump into DevOps area. So I've researched and used it. In this article, I'll list down things that I use the most and keep them as my short notes. Hope they'll help you, too.

Strings and comments

In Bash, most elements, such as variables, command names, and function names, are treated as strings by default unless used in a specific context (e.g., arithmetic or file descriptors). If a string contains spaces or special characters, it must be enclosed in single or double quotes to ensure it is treated as a single entity. Single quotes preserve the literal value of the string, while double quotes allow for variable expansion and command substitution. If a string does not contain spaces or special characters, it can be used without quotes. Here are examples.

Hello
'Hello World!'
"I'm learning Bash."

To print or display them in the terminal, use echo command.

echo Hello

NAME='Quynh Nguyen'

echo "Hello! My name is $NAME."

echo "It's nice to meet you."

echo 'Nice to meet you, too.'

A comment starts with # symbol, and is ignored by the interpreter.

# This is just a comment, it does nothing else.

Variables

A variable is a named storage that holds a value, typically a string, in a Bash program. Its value can be changed at any point during the execution of the program. A variable name can contain alphanumeric characters (letters and digits) and underscores (_), but it must begin with a letter or an underscore. It cannot start with a digit or contain spaces or special characters.

SUBJECT="Bash Scripting"

export CHAPTER="Variables"

Without export keyword, a variable is local to the current shell session and is not accessible to child processes or sub shell sessions. While using export allows it to be inherited by all child processes or sub shell sessions.

Although we can name variables with lowercase, it's a common convention in Bash to name them with uppercase, especially for environment variables or constants. This makes them stand out from regular shell commands or function names, which are typically lowercase. For example, APP_NAME and app_name are both allowed, but we should stick to APP_NAME.

APP_NAME=LARAVEL

app_name=laravel

For variables in a function or a block, I define each of them with an underscore as the prefix. It helps me figure out their scope immediately.

greet() {
    local _NAME=$1

    echo "Hello $_NAME"
}

if [ ! -f hello.txt ]; then
    _FILE=hello.txt

    touch $_FILE
fi

Using local makes a variable scope only inside the function.

There are a few special variables managed/assigned by the shell itself. E.g. $@, $?, $#,... For more information, please visit here.

Functions

In Bash, define and call a function is simple as this following example.

# greet is the function name.
# it is followed by ()
# the function body is enclosed in {}
greet() {
    if [ -z "$1" ]; then
        echo "Hello, World!"
    else
        echo "Hello, $1!"
    fi
}

Call function greet without any parameters.

# 'Hello, World!' is displayed

greet

Call function greet with a parameter.

# 'Hello, Alice!' is displayed

greet "Alice"

As you can see, when calling a function, we can pass parameters into it by placing them after the function name (separated by spaces).

Inside the function, we have $1-$9 special variables depending on the number of parameters passed in runtime, up to 9 parameters.

concat_words() {
    echo "Do you know $1 $2 $3?"
}

# $1 is "Bash"
# $2 is "is"
# #3 is "cool"
# "Do you know Bash is cool?" is printed
concat_words "Bash" "is" "cool"

Expressions

Because most elements are treated as strings, expressions are designed to interact with numbers. An expression is enclosed in $(( and ))

A=9
B=3

SUM=$((A + B))
DIFFERENCE=$((A - B))
MULTIPLICATION=$((A * B))
DIVISION=$((A / B))

echo "A + B = $SUM"
echo "A - B = $DIFFERENCE"
echo "A * B = $MULTIPLICATION"
echo "A / B = $DIVISION"

The result will be:

A + B = 12
A - B = 6
A * B = 27
A / B = 3

if / else statements

Syntax

You've already seen if / else in previous sections. It's syntax like this.

if condition; then
    # Do something if the condition is true
fi

if condition; then
    # Do something if the condition is true
else
   # If condition is false
fi


if first_condition; then
    # Do something if the first_condition is true
elif second_condition; then
    # Do something if the second_condition is true
else
    # Do something if neither first or second condition is true
fi

See this example for more details.

debug() {
    if [ -z "$1" ]; then
        echo "The debug mode is not set."
    elif [ "$1" = "on" ]; then
        echo "The debug mode is enabled."
    elif [ "$1" = "off" ]; then
        echo "The debug mode is disabled."
    else
        echo "The debug mode is invalid. Please use on/off."
    fi
}

debug
debug invalid
debug on
debug off

Conditions

Check if a variable is not set using -z

if [ -z "$MESSAGE" ]; then
    echo "MESSAGE is not set."
fi

! operator negates the condition.

if [ ! -z "$MESSAGE" ]; then
    echo "MESSAGE is set."
fi

Check if a file or a directory exists.

if [ -d /var/log ]; then
    echo "/var/log exists as a directory."
fi

if [ -f /var/log/alternatives.log ]; then
    echo "/var/log/alternatives.log exists as a file."
fi

Check if a function exists.

if declare -F greet > /dev/null ; then
    echo "greet is a function"
else
    echo "greet is not a function"
fi

Check if a variable equals a string or another variable.

if [ "$BRANCH" = "main" ]; then
    echo "On main branch"
fi

if [ "$BRANCH" = "$REMOTE_BRANCH" ]; then
    echo "BRANCH and REMOTE_BRANCH have the same value."
fi

! operator negates the condition.

if [ "$BRANCH" != "main" ]; then
    echo "Not on main branch"
fi

Number comparisons.

# -ne : not equal
if [ "$NUMBER" -ne 0 ]; then
    echo "NUMBER is not 0."
fi

# -eq : equal
if [ "$NUMBER" -eq 0 ]; then
    echo "NUMBER = 0"
fi

# -gt : greater than
if [ "$NUMBER" -gt 0 ]; then
    echo "NUMBER > 0"
fi

# -lt : less than
if [ "$NUMBER" -lt 0 ]; then
    echo "NUMBER < 0"
fi

Switch case

Switch case syntax in Bash is like this example.

case $CHOICE in
    'y')
        echo 'You type "y".'
    ;;
    'n')
        echo 'You type "n".'
    ;;
    *)
        echo 'Please type "y" or "n".'
    ;;
esac

Loops

For loop syntax in Bash is like this example.

for COLOR in red green blue
do
    echo $COLOR
done

While loop syntax in Bash is like this example.

CHOICE=y

# The loop will not stop until we type "exit".
while [ "$CHOICE" != 'exit' ]
do
    echo 'What is your choice?'
    read -r CHOICE
done

Conclusion

These are all things about Bash I'm currently using. They help me automate my development and CI workflows easily. I think it's enough for now. If you have any other helpful cases, please share with me. I may update the post later when I found other things cool. :)

Linux basics - Working with files and directories

Oliver Quynh — Thu, 06 Feb 2025 06:41:19 +0000

In this article, I will list commands that help interact with files and directories on a Linux system, along with the most common use cases. I write them down here as a short note. This article may be updated over time.

Print working directory

pwd

Change working directory

Use an absolute path.

cd /var/log

Use a relative path.

cd apt

I'm already in /var/log directory, it goes inside /var/log/apt

Go to the user home directory.

cd

cd ~

Go back the previous directory.

cd -

List items

List items in the current directory.

ls

List items in a specific directory.

ls /etc/

Add more options to the ls command.
- -l: Use a long listing format.
- -a: Display all items including one starts with dot (.)
- -h: Display sizes in 1K, 2M, etc, which is easy to read.
- --group-directories-first: Display directories first, then files.

ls -lah --group-directories-first /etc/

Create an empty file

If hello.txt doesn't exist, it'll be created. Otherwise, it's modified time will be changed.

touch hello.txt

Copy

Copy 1.txt to one.txt in the current directory.

cp 1.txt one.txt

Copy one.txt to the /tmp directory.

cp one.txt /tmp

Copy /var/log directory to /tmp directory.

cp -r /var/log /tmp/

Copy /var/log to /tmp, and change it's name to cp-log.

cp -r /var/log /tmp/cp-log

Move or rename

Rename hello.txt to hello-world.txt. If hello-world.txt exists, it'll be override.

mv hello.txt hello-world.txt

Move a directory or file to new location.

mv hello-world.txt /tmp/
mv example /tmp/

Make directories

Use -p option to create nested directories or keep silent if directories already exist.

mkdir example
mkdir -p example/foo/bar/baz

Remove directories or files

Add -f option to force to remove without confirmation or raising errors if they does not exist.

rm hello.txt

rm -r greetings/

rmdir can only remove an empty directory, so I've never used it.

I finally tried Pest for PHP & Laravel, then made the switch

Oliver Quynh — Tue, 26 Nov 2024 04:58:54 +0000

I started learning pure PHP in the middle of 2015. Then, I got familiar with CodeIgniter 3 and Laravel 5.1. Through the years, Laravel is my framework of choice, and I'm still sticking with it. Such as other popular PHP projects, I see PHPUnit is the only choice for unit testing. But there was a little change in 2021 when Pest came. It's created by Nuno Maduro - an engineer at Laravel, who also makes lots of great projects/packages widely used in PHP and Laravel community.

Since the very first day of Pest, I haven't cared about it because PHPUnit is enough for me and I feel lazy to learn this new test tool. But the more Laravel community grows, the more Pest is recommended. Many Laravel projects/packages from Spatie, Livewire, Filament, ... use Pest. So the problem is when testing things related to them, I have to port to PHPUnit. I seem to have no choice. It's time for me to take a look at Pest.

The first look

Following the installation section, I create my first PHP project using Pest.

mkdir ~/Herd/lerning-pest

cd ~/Herd/learning-pest

composer require pestphp/pest --dev --with-all-dependencies

./vendor/bin/pest --init

The directory structure is almost the same as PHPUnit. The different thing is how a test looks. It's closure-based instead of class-based.

<?php

// tests/Unit/ExampleTest.php

test('example', function () {
    expect(true)->toBeTrue();
});

I know using Closure that can lazily attach methods to an object in runtime. So this may be re-written in PHPUnit like that.

<?php

// tests/Unit/ExampleTest.php

class ExampleTest extends \PHPUnit\Framework\TestCase
{
    public function test_example()
    {
        $this->assertTrue(true);
    }
}

It says Pest assertion syntax is inspired by Ruby's Rspec and Jest, which I don't know. So, I'm also not too much interested in them. For me, it doesn't matter how assertion syntax is.

I just like the result displayed when running tests. It's much prettier and cleaner than PHPUnit, I think.

Assertions

These are assertions I used the most in PHPUnit.

$this->assertSame($expected, $actual);
$this->assertTrue($condition);
$this->assertFalse($condition);
$this->assertNull($actual);
$this->assertEmpty($array);
$this->assertCount($count, $countable);
$this->assertInstanceof($type, $instance);

They can be easily re-written in Pest.

expect($actual)->toBe($expected);
expect($condition)->toBeTrue();
expect($condition)->toBeFalse();
expect($actual)->toBeNull();
expect($actual)->toBeEmpty();
expect($actual)->toBeInstanceOf($type);

As I mentioned earlier, Pest assertion syntax is fine, but I'm currently sticking with PHPUnit because I don't need to study new APIs. Anyway, I prefer PHPUnit assertions and only use things that are unique in Pest. Architecture Testing is an example. My test file looks like this.

<?php

test("all PHP files in LearningPest namespace must have strict mode enabled", function () {
    arch()
        ->expect('LearningPest')
        ->toUseStrictTypes();
});

test('all PHPUnit assertions are available for Pest', function () {
    $instance = new \stdClass();

    $getInstance = function () use ($instance) {
        return $instance;
    };

    $this->assertSame($instance, $getInstance());

    $this->assertInstanceOf(stdClass::class, $instance);

    $this->assertTrue(1 < 2);
    $this->assertFalse(1 > 2);

    $value = null;

    $this->assertNull($value);

    $this->assertEmpty([]);

    $array = [1, 2, 3];

    $this->assertCount(3, $array);
});

Compulsory features

There are a number of compulsory features that allow me to work in Pest identically to PHPUnit. Here they are:

PHPUnit has data provider. Pest has datasets.
PHPUnit has setUp, tearDown, setUpBeforeClass and tearDownAfterClass. Pest has beforeEach, afterEach, beforeAll and afterAll.
Both have exception checks and can skip/group/filter tests.

Mockery is a standalone library, so I don't list it here.

On the other hand, Pest has lots of things may come in handy such as architecture, snapshot or stress testing and plugins. I'll discover them when writing tests.

Conclusion

Pest is built on top of PHPUnit, widely used and recommended in PHP and Laravel community recently.
Using Pest, I can work in the nearly same way before, but with prettier CLI and more helpful features.
Now, Pest's the default testing framework for my PHP and Laravel applications.

If you are a PHP developer who hasn't used Pest, give it a try.