Bash & Shell Scripting.

A terminal shows text and passes your keystrokes along, while a shell is the command-line interpreter that reads them as commands and runs them. The terminal never works out what ls means.

The shell does that work. It expands variables and wildcards, then starts the programs you asked for. It also manages environment variables and job control.

The two are independent. One terminal can host any shell, and a shell needs no terminal when cron runs a script with it. Common shells include Bash and Zsh. Fish and Dash are two more. Today's terminals are terminal emulators, software versions of the hardware terminals early Unix machines used.

Run chmod +x script.sh to give the file execute permission, then start it with ./script.sh. The ./ is needed because the shell looks up bare command names only on PATH, which does not normally include the current directory.

chmod +x script.sh
# Or using octal notation
chmod 755 script.sh

+x adds the execute bit and leaves the read and write bits alone. The octal form 755 sets every bit at once. The owner can read, write and execute, and everyone else can read and execute.

The first line of the script should also be a shebang, which tells the kernel which interpreter runs the file.

#!/bin/bash
# or
#!/usr/bin/env bash

Execute permission only matters when you run the file directly. bash script.sh works without it, because Bash is the program being run and it just reads the file as input.

The shebang is #! followed by an interpreter's path, and it tells the kernel which program runs the script. It must be the very first line of the file. With #!/bin/bash there, running ./deploy.sh makes the kernel run /bin/bash ./deploy.sh.

Each line below is a separate choice, and a script uses only one.

#!/bin/bash
#!/usr/bin/env bash
#!/bin/zsh
#!/usr/bin/env python3

#!/usr/bin/env bash runs the first bash on PATH, which is more portable than a fixed path. The other two lines choose zsh by a fixed path and python3 through env. Without a shebang, the calling shell runs the file itself, which breaks when the script needs a different shell.

Keep comments off the shebang line. Linux passes everything after the interpreter as one argument, so #!/usr/bin/env bash # comment fails to start.

Assign with name=value, with no spaces around the =, and read the value back with $name or ${name}. The spaces matter, because name = value makes Bash run a command called name with = and value as its arguments.

# Declaration
name="John"
age=25

# Usage
echo "Name: $name, Age: $age"
echo "Name: ${name}, Age: ${age}"  # Preferred syntax

The braces mark where the name ends, so ${name}_backup works where $name_backup would look for a variable called name_backup. Wrap each use in double quotes, as in "$name", so a value with spaces stays one word.

A variable you create stays in the current shell, and programs the script starts do not see it. export passes it to them through the environment. local limits a variable to the function that declares it and the functions that function calls. readonly stops later changes anywhere in the script.