{"id":240883,"date":"2022-09-30T14:56:00","date_gmt":"2022-09-30T21:56:00","guid":{"rendered":"https:\/\/virtual-dba.com\/?p=240883"},"modified":"2024-03-21T11:27:20","modified_gmt":"2024-03-21T18:27:20","slug":"the-elements-of-a-bash-script","status":"publish","type":"post","link":"https:\/\/virtual-dba.com\/blog\/the-elements-of-a-bash-script\/","title":{"rendered":"The Elements of a Bash Script"},"content":{"rendered":"\n
Database administrators need to know databases as well as the operating system (OS) their database is running on. Bash scripting is where the two merge. For the beginner, bash scripting can be intimidating, but all have the same basic structure: a beginning, middle, and end.<\/p>\n\n\n\n
Disclaimer: I am not a bash scripting expert. This blog will provide an elementary approach to bash scripts with some scripting and debugging tips. It is most beneficial for those with some knowledge in computer languages trying to get started interpreting and writing bash scripts.<\/p>\n\n\n\n
The Beginning<\/h2>\n\n\n\n
This is the first line in the bash script where it lets the OS know that it is a bash script. The OS reads this line and knows the subsequent code should be run by the bash shell interpreter found in the \/bin directory.<\/p>\n\n\n\n
There are two ways to do this in a Unix-like OS, shown below. Each starts with a #!, often called sha-bang or hashbang. The first example is often used when the path of the bash interpreter is found in the user’s \/bin directory. The second example is used when the path of the bash interpreter is unknown.<\/p>\n\n\n
<\/p>\n
# Used when the bash interpreter is in the user's \/bin directory\n#!\/bin\/bash \n\n# Used when the path to the bash interpreter is unknown\n#!\/usr\/bin\/env bash<\/code><\/pre>\n
<\/p>\n\n\n
The Middle<\/h2>\n\n\n\n
The middle part is the bulkiest part of the bash script. This is where the executable commands go and the magic happens (when the script works) or doesn’t (when the script is not working).<\/p>\n\n\n\n
Scripts are as unique as the creator. Best practice is to use comments to help explain the code so anyone can understand it. Additionally, it is a good way to create an outline of steps when building a script. The example below is how I started a script that enabled the slow query log for 15 minutes, then disabled it.<\/p>\n\n\n
#!\/bin\/bash\n\n# Set variables\n\n# Enable slow query log\n\n# Sleep for 15 minutes\n\n# Disable slow query log<\/code><\/pre>\n\n\n
Starting from scratch might be too ambitious for some beginners. It is common to take components from another script to make your own. Moreover, a lot can be learned from reverse engineering someone else’s script. The table below briefly describes components of a bash script to help you understand and identify them.<\/p>\n\n\n\n
Components<\/td>
Function<\/td>
Syntax<\/td><\/tr>
Variables<\/td>
Used to store data (numeric or string) to make a script more versatile.<\/td>
2 ways to assign them: declare — var=value var=value
Evoking them: $var<\/td><\/tr>
Functions<\/td>
Values are passed into functions, usually through variables, to be executed with the commands inside the brackets.<\/td>
2 ways to write them: function function_name { Command }
function_name ( ) { command }
Evoking them: function_name<\/td><\/tr>
Arrays<\/td>
They store data like strings and integers. Arrays can hold more than one value.\u00a0\u00a0
There are 2 types of arrays: Indexed: keys have ordered indexes starting with [0]
Associative: have key:value pairs<\/td>
Creating indexed arrays: declare -a arr arr=(values)
Adding values to array: arr[0]=first_value arr[1]=second_value
Evoking values: ${arr[index]}
Creating associative arrays: declare -A arr
Adding values to array: arr[key]=value
Evoking values: ${arr[key]} <\/td><\/tr>
Boolean Operators<\/td><\/tr>
Or<\/td>
Used to execute a command when one of two conditions need to be met to execute a command.
If the first condition isn’t met, the second condition must be true for the command to be run.<\/td>
||<\/code><\/td><\/tr>
And<\/td>
Used to execute a command when two conditions need to be met to execute a command.
If the first condition isn’t met, the command is not executed. If the first condition is met and the second one isn’t, the command is not executed.<\/td>
&&<\/code><\/td><\/tr>
Conditional Statements<\/td><\/tr>
If<\/td>
Used when a command should only be run if the specified test condition is met.\u00a0
Test condition often uses operators such as || and &&.
When brackets are used, the -gt(greater than) or\u00a0 -lt (less than) are used.\u00a0
When double parentheses are used, > or < can be used instead.<\/td>
2 ways to write them: if [test_condition]; then command fi
if (( test_condition )); then command fi <\/td><\/tr>
if\/else<\/td>
It’s an extension of the if statement. The else statement executes a command when the if statement returns false.<\/td>
2 ways to write them: if [test_condition]; then command else command fi
if (( test_condition )); then command else command fi <\/td><\/tr>
case<\/td>
When there are multiple test conditions to be met to execute different commands, a case command can be used instead of a series of if\/else statements.
Test conditions usually use match operators like =<\/code>, ||<\/code>, or &&<\/code>.<\/td>
case var in test_condition) command ;; Another test_condition) command ;; Another test_condition) command ;; esac <\/td><\/tr>
Loops<\/td><\/tr>
while<\/td>
Can be used with arrays or conditional statements. It will run commands while the test condition returns true.<\/td>
while test_condition do command(s) done <\/td><\/tr>
until<\/td>
Similar to while loops but commands will run until the test condition returns true.<\/td>
until test_condition do command(s) done <\/td><\/tr>
for<\/td>
Starts the value that is initiated (i=value)<\/code> and will iterate up or down depending on the direction set by the executable (i++<\/code> or i--<\/code>) until the test condition is met. The variable used is i and incorporated into the command that is being executed.<\/td>
for (( iniated_cal; test_condition; executable )); do command(s); done <\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
The executable code might include any of the above components. The good thing is that other computer languages have these components and the principles are basically the same with some tweaking of the syntax. Variables and arrays, for instance, are often used in computer languages to hold data. Likewise, conditional statements and loops are used in computer languages like JavaScript. If these concepts are new, there are plenty of learning modules to explore as a beginner bash scripter. I did a bash script online course from Pluralsight, Shell Scripting with Bash and Z Shell.<\/p>\n\n\n\n
The End<\/h2>\n\n\n\n
There is no official way to end a bash script. It might just end with the last executable command. The best practice is using an exit command that exits the script when the last command is successful (returns 0) .<\/p>\n\n\n\n
exit 0<\/code><\/pre>\n\n\n\n
Debugging<\/h2>\n\n\n\n
Before you start testing, you need to make sure that the script is executable. The below command can be used.<\/p>\n\n\n\n
$ chmod u+x <filename><\/code><\/pre>\n\n\n\n
If the bash script is not working, adding -v or -x options to the she-bang line will print out every line as the script runs. It will give you an idea of where the code is breaking. I prefer the -x because it also prints the values of all the variables as well.<\/p>\n\n\n\n
# will print every line before it runs\n#!\/bin\/bash -v \n\n# will print every line and the values in the script before it runs\n#!\/bin\/bash -x <\/code><\/pre>\n\n\n\n
![\"Bash](\"https:\/\/virtual-dba.com\/wp-content\/uploads\/bash-scripting-shellcheck-output.png\")
<\/figure>\n\n\n\n