{"id":18427,"date":"2024-05-08T13:53:18","date_gmt":"2024-05-08T20:53:18","guid":{"rendered":"https:\/\/ioflood.com\/blog\/?p=18427"},"modified":"2024-05-15T15:31:17","modified_gmt":"2024-05-15T22:31:17","slug":"bash-syntax-cheat-sheet","status":"publish","type":"post","link":"https:\/\/ioflood.com\/blog\/bash-syntax-cheat-sheet\/","title":{"rendered":"Bash Syntax Cheat Sheet"},"content":{"rendered":"
\n
\"Artistic<\/figure>\n<\/div>\n

Managing dedicated servers<\/a> and performing system administration tasks at IOFLOOD<\/a> requires a solid understanding of Bash syntax to efficiently automate processes and troubleshoot issues. Drawing from our experience in server management and software deployment, we’ve compiled this comprehensive Bash reference guide.<\/p>\n

This Bash Cheat Sheet<\/strong> is your concise companion in the vast world of Bash programming. With a dedicated reference section for commands and key programming concepts, followed by practical example code snippets<\/strong>, this cheat sheet is designed to assist both beginners and seasoned professionals alike.<\/p>\n

So, let’s set sail on this exciting journey to unlock the full potential of Bash. Ready your terminals, and let\u2019s dive into Bash!<\/p>\n

Command Reference Section<\/h2>\n

Before diving into practical examples, let’s explore the various commands and concepts of Bash. This reference section will also provide explanations and example usage cases<\/strong> when applicable. These topics will serve as key tools while scripting in Bash and will also deepen your understanding of the following Sample Code.<\/p>\n

Command Chaining<\/h2>\n\n\n\n\n\n\n\n\n\n
Command\/Concept<\/th>\nDescription<\/th>\nSyntax Example<\/th>\n<\/tr>\n<\/thead>\n
&&<\/code><\/td>\nExecutes a secondary command<\/a> only if the first command succeeds.<\/td>\ncommand1 && command2<\/code><\/td>\n<\/tr>\n
||<\/code><\/td>\nOr Operator<\/a> executes secondary command only if the first command fails.<\/td>\ncommand1 || command2<\/code><\/td>\n<\/tr>\n
;<\/code><\/td>\nExecutes all commands in sequence, regardless of their exit status.<\/td>\ncommand1; command2<\/code><\/td>\n<\/tr>\n
|<\/code><\/td>\nPipes the output<\/a> of the first command to the input of the second command.<\/td>\ncommand1 \\| command2<\/code><\/td>\n<\/tr>\n
&<\/code><\/td>\nRuns the command in the background, allowing the terminal to accept new commands immediately.<\/td>\ncommand1 &<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Common Commands<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Command<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
ls<\/code><\/td>\nLists the contents of a directory.<\/td>\nls -l<\/code> lists in long format.<\/td>\n<\/tr>\n
cd<\/code><\/td>\nChanges the current directory.<\/td>\ncd \/home<\/code> changes to the \/home directory.<\/td>\n<\/tr>\n
pwd<\/code><\/td>\nPrints the current working directory<\/a>.<\/td>\npwd<\/code> displays the current directory path.<\/td>\n<\/tr>\n
mkdir<\/code><\/td>\nCreates a new directory<\/a>.<\/td>\nmkdir new_dir<\/code> creates a new directory named new_dir<\/code>.<\/td>\n<\/tr>\n
rm<\/code><\/td>\nRemoves files or directories<\/a>.<\/td>\nrm file.txt<\/code> removes file.txt<\/code>. Use -r<\/code> for directories.<\/td>\n<\/tr>\n
echo<\/code><\/td>\nDisplays a line of text.<\/td>\necho \"Hello World\"<\/code> prints Hello World.<\/td>\n<\/tr>\n
cat<\/code><\/td>\nConcatenates and displays files.<\/td>\ncat file.txt<\/code> displays the contents of file.txt<\/code>.<\/td>\n<\/tr>\n
touch<\/code><\/td>\nCreates an empty file<\/a> or updates the timestamp.<\/td>\ntouch new_file.txt<\/code> creates or updates new_file.txt<\/code>.<\/td>\n<\/tr>\n
cp<\/code><\/td>\nCopies files and directories<\/a>.<\/td>\ncp source.txt dest.txt<\/code> copies source.txt<\/code> to dest.txt<\/code>.<\/td>\n<\/tr>\n
mv<\/code><\/td>\nMoves or renames files<\/a> and directories.<\/td>\nmv old_name.txt new_name.txt<\/code> renames\/moves a file.<\/td>\n<\/tr>\n
grep<\/code><\/td>\nSearches for patterns<\/a> in files.<\/td>\ngrep \"search_term\" file.txt<\/code> searches for “search_term” in file.txt<\/code>.<\/td>\n<\/tr>\n
find<\/code><\/td>\nSearches for files<\/a> in a directory hierarchy.<\/td>\nfind . -name \"file.txt\"<\/code> finds all file.txt<\/code> in the current directory and subdirectories.<\/td>\n<\/tr>\n
chmod<\/code><\/td>\nChanges the file mode (permissions).<\/td>\nchmod 755 script.sh<\/code> sets script.sh<\/code> to be readable and executable by everyone, but only writable by the file owner.<\/td>\n<\/tr>\n
chown<\/code><\/td>\nChanges file owner and group.<\/td>\nchown user:group file.txt<\/code> changes the owner and group of file.txt<\/code>.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Command Modifiers<\/h2>\n

Modifier Flags for ls<\/code><\/h3>\n\n\n\n\n\n\n\n\n\n
Flag<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
-l<\/code><\/td>\nLists files in long format, showing detailed information.<\/td>\nls -l<\/code><\/td>\n<\/tr>\n
-a<\/code><\/td>\nIncludes directory entries whose names begin with a dot (.).<\/td>\nls -a<\/code><\/td>\n<\/tr>\n
-h<\/code><\/td>\nHuman-readable format, with file sizes.<\/td>\nls -lh<\/code><\/td>\n<\/tr>\n
-r<\/code><\/td>\nReverses the order of the sort.<\/td>\nls -lr<\/code><\/td>\n<\/tr>\n
-t<\/code><\/td>\nSorts by modification time, newest first.<\/td>\nls -lt<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Modifier Flags for grep<\/code><\/h3>\n\n\n\n\n\n\n\n\n\n
Flag<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
-i<\/code><\/td>\nIgnores case distinctions in both the pattern and the input files.<\/td>\ngrep -i \"pattern\" file<\/code><\/td>\n<\/tr>\n
-v<\/code><\/td>\nInverts the match, showing lines that do not match the given pattern.<\/td>\ngrep -v \"pattern\" file<\/code><\/td>\n<\/tr>\n
-c<\/code><\/td>\nCounts the number of lines that match the pattern.<\/td>\ngrep -c \"pattern\" file<\/code><\/td>\n<\/tr>\n
-n<\/code><\/td>\nPrefixes each line of output with the line number within its input file.<\/td>\ngrep -n \"pattern\" file<\/code><\/td>\n<\/tr>\n
-r<\/code><\/td>\nRecursively searches for the pattern in all files under the specified directory.<\/td>\ngrep -r \"pattern\" directory<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Modifier Flags for mkdir<\/code><\/h3>\n\n\n\n\n\n\n
Flag<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
-m<\/code><\/td>\nSets the file mode (permissions) of the newly created directory<\/a>.<\/td>\nmkdir -m 755 newdir<\/code><\/td>\n<\/tr>\n
-p<\/code><\/td>\nCreates parent directories as needed and does not return an error if the directory already exists<\/a>.<\/td>\nmkdir -p \/path\/to\/newdir<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Modifier Flags for rm<\/code><\/h3>\n\n\n\n\n\n\n\n
Flag<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
-r<\/code> or -R<\/code><\/td>\nRemoves directories and their contents recursively.<\/td>\nrm -r folderName<\/code><\/td>\n<\/tr>\n
-f<\/code><\/td>\nForces deletion without prompting for confirmation.<\/td>\nrm -f filename<\/code><\/td>\n<\/tr>\n
-i<\/code><\/td>\nPrompts for confirmation before deleting each file.<\/td>\nrm -i filename<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Modifier Flags for echo<\/code><\/h3>\n\n\n\n\n\n\n
Flag<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
-n<\/code><\/td>\nDo not output the trailing newline.<\/td>\necho -n \"text\"<\/code><\/td>\n<\/tr>\n
-e<\/code><\/td>\nEnable interpretation of backslash escapes.<\/td>\necho -e \"Line 1\\nLine 2\"<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Modifier Flags for cat<\/code><\/h3>\n\n\n\n\n\n\n\n
Flag<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
-n<\/code><\/td>\nNumber all output lines.<\/td>\ncat -n file<\/code><\/td>\n<\/tr>\n
-b<\/code><\/td>\nNumber non-empty output lines.<\/td>\ncat -b file<\/code><\/td>\n<\/tr>\n
-s<\/code><\/td>\nSuppress repeated empty output lines.<\/td>\ncat -s file<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Modifier Flags for touch<\/code><\/h3>\n\n\n\n\n\n\n\n
Flag<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
-a<\/code><\/td>\nChanges only the access time.<\/td>\ntouch -a file<\/code><\/td>\n<\/tr>\n
-m<\/code><\/td>\nChanges only the modification time.<\/td>\ntouch -m file<\/code><\/td>\n<\/tr>\n
-c<\/code><\/td>\nDoes not create any files that do not already exist.<\/td>\ntouch -c file<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Modifier Flags for cp<\/code><\/h3>\n\n\n\n\n\n\n\n\n
Flag<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
-r<\/code> or -R<\/code><\/td>\nRecursively copies directories.<\/td>\ncp -r sourceDir targetDir<\/code><\/td>\n<\/tr>\n
-i<\/code><\/td>\nPrompts before overwrite.<\/td>\ncp -i sourceFile targetFile<\/code><\/td>\n<\/tr>\n
-v<\/code><\/td>\nVerbose mode, shows files as they are copied.<\/td>\ncp -v sourceFile targetFile<\/code><\/td>\n<\/tr>\n
-a<\/code><\/td>\nArchives files, copying all file attributes, including permissions and symbolic links.<\/td>\ncp -a sourceDir targetDir<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Modifier Flags for mv<\/code><\/h3>\n\n\n\n\n\n\n\n
Flag<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
-i<\/code><\/td>\nPrompts before overwrite.<\/td>\nmv -i oldName newName<\/code><\/td>\n<\/tr>\n
-v<\/code><\/td>\nVerbose mode, shows files as they are moved.<\/td>\nmv -v oldLocation newLocation<\/code><\/td>\n<\/tr>\n
-u<\/code><\/td>\nMoves only when the source file is newer than the destination file or when the destination file does not exist.<\/td>\nmv -u oldFile newFile<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Modifier Flags for find<\/code><\/h3>\n\n\n\n\n\n\n\n\n\n\n\n
Flag<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
-name<\/code><\/td>\nSearch for files by name.<\/td>\nfind . -name \"filename.txt\"<\/code><\/td>\n<\/tr>\n
-type<\/code><\/td>\nSearch for files of a particular type (e.g., d<\/code> for directories, f<\/code> for regular files).<\/td>\nfind . -type f<\/code><\/td>\n<\/tr>\n
-perm<\/code><\/td>\nSearch for files with specific permissions.<\/td>\nfind . -perm 644<\/code><\/td>\n<\/tr>\n
-user<\/code><\/td>\nSearch for files owned by a specific user.<\/td>\nfind . -user username<\/code><\/td>\n<\/tr>\n
-mtime<\/code><\/td>\nSearch for files modified a certain number of days ago.<\/td>\nfind . -mtime +7<\/code><\/td>\n<\/tr>\n
-exec<\/code><\/td>\nExecute a command on each file found.<\/td>\nfind . -type f -exec chmod 644 {} \\;<\/code><\/td>\n<\/tr>\n
-size<\/code><\/td>\nFinds files of a specific size (e.g., +50M<\/code> for files over 50MB, -50M<\/code> for files under 50MB).<\/td>\nfind . -size +50M<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Modifier Flags for chmod<\/code><\/h3>\n\n\n\n\n\n\n\n\n\n\n\n
Flag<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
+<\/code><\/td>\nAdds a permission<\/a> to a file or directory.<\/td>\nchmod +x file<\/code><\/td>\n<\/tr>\n
-<\/code><\/td>\nRemoves a permission from a file or directory.<\/td>\nchmod -x file<\/code><\/td>\n<\/tr>\n
r<\/code><\/td>\nRead permission.<\/td>\nchmod +r file<\/code> (adds read permission)<\/td>\n<\/tr>\n
w<\/code><\/td>\nWrite permission.<\/td>\nchmod +w file<\/code> (adds write permission)<\/td>\n<\/tr>\n
x<\/code><\/td>\nExecute permission.<\/td>\nchmod +x file<\/code> (adds execute permission)<\/td>\n<\/tr>\n
u<\/code>, g<\/code>, o<\/code><\/td>\nSet permissions for the user (u), group (g), or others (o).<\/td>\nchmod u+x file.txt<\/code><\/td>\n<\/tr>\n
a<\/code><\/td>\nSet permissions for all users.<\/td>\nchmod a+w file.txt<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Modifier Flags for chown<\/code><\/h3>\n\n\n\n\n\n\n\n\n\n
Flag<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
--recursive<\/code> or -R<\/code><\/td>\nChange file owner and group recursively.<\/td>\nchown -R user:group directory<\/code><\/td>\n<\/tr>\n
--verbose<\/code><\/td>\nOutput a diagnostic for every file processed.<\/td>\nchown --verbose user file<\/code><\/td>\n<\/tr>\n
--from<\/code><\/td>\nChanges the owner and\/or group of each given file only if its current owner and\/or group match those specified.<\/td>\nchown --from=current_user:current_group new_user:new_group file<\/code><\/td>\n<\/tr>\n
-c<\/code><\/td>\nLike verbose but report only when a change is made.<\/td>\nchown -c new_user file<\/code><\/td>\n<\/tr>\n
-v<\/code><\/td>\nVerbose mode. Outputs a diagnostic for every file processed.<\/td>\nchown -v new_user file<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Flags<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Flag<\/th>\nDescription<\/th>\n<\/tr>\n<\/thead>\n
-e<\/code><\/td>\nExit immediately<\/a> if a command exits with a non-zero status.<\/td>\n<\/tr>\n
-x<\/code><\/td>\nPrint commands and their arguments as they are executed.<\/td>\n<\/tr>\n
-u<\/code><\/td>\nTreat unset variables as an error when substituting.<\/td>\n<\/tr>\n
-o pipefail<\/code><\/td>\nCauses a pipeline to return the exit status of the last command in the pipe that failed.<\/td>\n<\/tr>\n
-v<\/code><\/td>\nPrint shell input lines as they are read.<\/td>\n<\/tr>\n
-n<\/code><\/td>\nRead commands but do not execute them (syntax check).<\/td>\n<\/tr>\n
-f<\/code><\/td>\nDisable filename expansion (globbing).<\/td>\n<\/tr>\n
-i<\/code><\/td>\nInteractive mode – even if the input is not coming from a terminal.<\/td>\n<\/tr>\n
-c<\/code><\/td>\nRead and execute commands from the following string.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Command Line Parameters<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Parameter<\/th>\nDescription<\/th>\n<\/tr>\n<\/thead>\n
$0<\/code><\/td>\nThe filename of the current script.<\/td>\n<\/tr>\n
$1<\/code> to $9<\/code><\/td>\nThe positional parameters, representing arguments passed to the script. $1<\/code> is the first argument, $2<\/code> is the second, and so on.<\/td>\n<\/tr>\n
${10}<\/code>, ${11}<\/code>, …<\/td>\nFor positional parameters beyond 9, curly braces are used to delimit the parameter number.<\/td>\n<\/tr>\n
$#<\/code><\/td>\nThe number of positional parameters passed to the script.<\/td>\n<\/tr>\n
$*<\/code><\/td>\nAll positional parameters seen as a single word. Useful when you need to pass all parameters to another command.<\/td>\n<\/tr>\n
$@<\/code><\/td>\nAll positional parameters<\/a> as separate strings. When quoted as \"$@\"<\/code>, each parameter is quoted separately, which is useful for preserving spaces in parameters.<\/td>\n<\/tr>\n
$?<\/code><\/td>\nThe exit status of the last command<\/a> executed.<\/td>\n<\/tr>\n
$$<\/code><\/td>\nThe process ID (PID) of the current script.<\/td>\n<\/tr>\n
$!<\/code><\/td>\nThe PID of the last background command.<\/td>\n<\/tr>\n
$-<\/code><\/td>\nThe current options set for the shell.<\/td>\n<\/tr>\n
$IFS<\/code><\/td>\nThe Internal Field Separator that is used by the shell to determine how it recognizes fields, or word boundaries, in a string.<\/td>\n<\/tr>\n
shift<\/code><\/td>\nShifts positional parameters to the left by 1, decreasing the positional parameters count ($#<\/code>). Useful for iterating over all arguments.<\/td>\n<\/tr>\n
set<\/code><\/td>\nUsed to set or unset options and positional parameters<\/a>. set --<\/code> can be used to overwrite all positional parameters.<\/td>\n<\/tr>\n
getopts<\/code><\/td>\nA utility to parse positional parameters. Used in scripts to process command-line options and flags<\/a>.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Sorting Methods<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n
Technique\/Command<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
sort<\/code> Command<\/td>\nSorts the lines of a text file<\/a>. Supports numerical, reverse, and case-insensitive sorting among others.<\/td>\nsort file.txt<\/code> for alphabetical sorting.
sort -n file.txt<\/code> for numerical sorting.<\/td>\n<\/tr>\n
sort<\/code> with Unique<\/td>\nCombines sorting with removing duplicate lines.<\/td>\nsort -u file.txt<\/code> to sort and remove duplicates.<\/td>\n<\/tr>\n
Array Sorting<\/td>\nBash does not natively support array sorting, but you can use external commands or custom functions<\/a>.<\/td>\nIFS=$'\\n' sorted=($(sort <<<\"${array[*]}\"))<\/code><\/td>\n<\/tr>\n
sort<\/code> with Reverse Order<\/td>\nSorts in reverse order.<\/td>\nsort -r file.txt<\/code> for reverse alphabetical sorting.<\/td>\n<\/tr>\n
sort<\/code> with Custom Field<\/td>\nSorts based on a specific field or column.<\/td>\nsort -k2,2 file.txt<\/code> to sort by the second column.<\/td>\n<\/tr>\n
Using awk<\/code> for Sorting<\/td>\nPreprocessing with awk<\/code> before sorting, useful for complex data manipulation.<\/td>\nawk '{print $2, $1}' file.txt | sort<\/code> to swap columns before sorting.<\/td>\n<\/tr>\n
Numeric Sort<\/td>\nSpecifically sorts lines by numerical value.<\/td>\nsort -n file.txt<\/code><\/td>\n<\/tr>\n
Version Sort<\/td>\nSorts lines by version number, useful for filenames or version tags.<\/td>\nsort -V files.txt<\/code> for version sorting.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Data Types<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n
Data Type<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
String<\/td>\nText or characters. Bash does not distinguish between strings and numbers, but strings can contain any character.<\/td>\nstr=\"Hello World\"<\/code><\/td>\n<\/tr>\n
Integer<\/td>\nWhole numbers. Bash supports integer operations and comparisons.<\/td>\nint=42; let \"int2 = int * 2\"<\/code><\/td>\n<\/tr>\n
Array<\/td>\nIndexed or associative collections of values.<\/td>\nIndexed: arr=(one two three)<\/code>
Associative: declare -A assoc_arr=([\"key\"]=\"value\")<\/code><\/td>\n<\/tr>\n
Command Substitution<\/td>\nExecutes a command and substitutes its output.<\/td>\nresult=$(ls)<\/code><\/td>\n<\/tr>\n
Arithmetic Expansion<\/td>\nEvaluates an arithmetic expression and substitutes the result.<\/td>\ntotal=$((3 + 2))<\/code><\/td>\n<\/tr>\n
File Descriptor<\/td>\nA reference to an open file. Bash scripts can read from and write to file descriptors.<\/td>\nexec 3<file.txt<\/code> (opens file.txt<\/code> on FD 3)<\/td>\n<\/tr>\n
Here Document<\/td>\nA type of redirection that feeds a command list or a script a literal block of text.<\/td>\ncat <<EOF<\/code>
Example text<\/code>
EOF<\/code><\/td>\n<\/tr>\n
Here String<\/td>\nA form of redirection that feeds a string into the standard input of a command.<\/td>\ngrep \"search\" <<< \"search in this string\"<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Boolean Operations<\/h2>\n\n\n\n\n\n\n\n\n\n\n
Concept<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
Boolean Variables<\/a><\/td>\nBash doesn’t have a built-in Boolean type. Use strings or exit statuses to represent Booleans.<\/td>\nis_true=\"true\"; if [ \"$is_true\" = \"true\" ]; then echo \"True\"; fi<\/code><\/td>\n<\/tr>\n
Conditional Execution<\/td>\nUse &&<\/code> for AND and ||<\/code> for OR in command sequences.<\/td>\n[[ $a -eq $b ]] && echo \"Equal\"<\/code>
[[ $a -ne $b ]] || echo \"Not equal\"<\/code><\/td>\n<\/tr>\n
if<\/code> Statements<\/td>\nEvaluate conditions using if<\/code>. Combine with &&<\/code>, ||<\/code>, -eq<\/code>, -ne<\/code>, etc., for Boolean logic.<\/td>\nif [[ $a -gt $b ]] && [[ $c -eq 10 ]]; then echo \"True\"; fi<\/code><\/td>\n<\/tr>\n
test<\/code> or '[ ]'<\/code><\/td>\nThe test<\/code> command or '[ ]'<\/code> evaluates an expression and returns an exit status.<\/td>\ntest $a -lt $b; echo $?<\/code>
[ $a -lt $b ]; echo $?<\/code><\/td>\n<\/tr>\n
[[ ]]<\/code> for Advanced Conditions<\/td>\nAdvanced test command that allows for pattern matching and more complex expressions.<\/td>\n[[ $a -gt $b && $c -eq 10 ]]<\/code><\/td>\n<\/tr>\n
Exit Statuses<\/td>\nUse the exit status of commands as Boolean expressions. A status of 0 (success) is true; non-zero is false.<\/td>\ncommand; if [ $? -eq 0 ]; then echo \"Success\"; fi<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Function Structure<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n
Part<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
Function Declaration<\/td>\nDefines a function<\/a>. Can use the function<\/code> keyword or simply name the function directly.<\/td>\nfunction myFunc() { echo \"Hello, World!\"; }<\/code>
myFunc() { echo \"Hello, World!\"; }<\/code><\/td>\n<\/tr>\n
Calling a Function<\/td>\nExecutes the function by specifying its name followed by parentheses.<\/td>\nmyFunc()<\/code><\/td>\n<\/tr>\n
Passing Arguments<\/td>\nFunctions can accept arguments<\/a> that are passed to them when called. Arguments within functions are accessed via $1<\/code>, $2<\/code>, etc.<\/td>\nmyFunc() { echo \"Hello, $1!\"; }<\/code>
myFunc \"World\"<\/code><\/td>\n<\/tr>\n
Return Statement<\/td>\nExits the function with an optional return status (0-255). The return status can be captured with $?<\/code>.<\/td>\nmyFunc() { return 1; }<\/code>
myFunc<\/code>
echo $?<\/code><\/td>\n<\/tr>\n
Local Variables<\/td>\nVariables within a function that are only accessible within that function, declared with local<\/code>.<\/td>\nmyFunc() { local localVar=\"I'm local\"; echo $localVar; }<\/code><\/td>\n<\/tr>\n
Function Output<\/td>\nFunctions can generate output that can be captured or used by the rest of the script.<\/td>\nmyFunc() { echo \"Function output\"; }<\/code>
result=$(myFunc)<\/code><\/td>\n<\/tr>\n
Recursion<\/td>\nFunctions can call themselves, a technique known as recursion.<\/td>\nrecursiveFunc() { echo \"$1\"; if [ $1 -gt 0 ]; then recursiveFunc $(( $1 - 1 )); fi }<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Variables<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Concept<\/th>\nDescription<\/th>\nExample<\/th>\n<\/tr>\n<\/thead>\n
Variable Declaration and Assignment<\/a><\/td>\nAssigning a value to a named variable.<\/td>\nmyVar=\"Hello World\"<\/code><\/td>\n<\/tr>\n
Environment Variables<\/td>\nPredefined global variables used by the operating system and applications.<\/td>\necho $PATH<\/code><\/td>\n<\/tr>\n
Positional Parameters<\/td>\nVariables that represent the arguments passed to a script<\/a>.<\/td>\n$1<\/code> for the first argument<\/td>\n<\/tr>\n
Special Variables<\/td>\nVariables with specific functions in Bash.<\/td>\n$$<\/code> for the script’s PID<\/td>\n<\/tr>\n
String Variables<\/td>\nOperations on strings, such as extraction and concatenation.<\/td>\nConcatenation: greeting=\"Hello,\"; name=\"Alice\"; echo \"$greeting $name\"<\/code><\/td>\n<\/tr>\n
Numeric Variables<\/td>\nPerforming arithmetic operations<\/a>.<\/td>\nlet sum=5+3; echo $sum<\/code><\/td>\n<\/tr>\n
Arrays<\/td>\nWorking with indexed and associative arrays<\/a>.<\/td>\nIndexed: arr=(one two three); echo ${arr[1]}<\/code>
Associative: declare -A arr; arr[\"key\"]=\"value\"; echo ${arr[\"key\"]}<\/code><\/td>\n<\/tr>\n
Read-only Variables<\/td>\nCreating immutable variables.<\/td>\ndeclare -r myVar=\"fixed value\"<\/code><\/td>\n<\/tr>\n
Exporting Variables<\/td>\nMaking variables available to subshell processes.<\/td>\nexport VAR=\"value\"<\/code><\/td>\n<\/tr>\n
Local Variables in Functions<\/td>\nVariables scoped within a function.<\/td>\nfunction myFunc() { local localVar=\"I'm local\"; }<\/code><\/td>\n<\/tr>\n
Variable Expansion<\/td>\nExpanding variables to their values.<\/td>\necho \"Your home directory is: $HOME\"<\/code><\/td>\n<\/tr>\n
Indirect References<\/td>\nAccessing the value of a variable using the name stored in another variable.<\/td>\nrefVar=\"myVar\"; echo \"${!refVar}\"<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Environment Variables<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Environment Variable<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
PATH<\/code><\/td>\nA colon-separated list of directories in which the shell looks for commands.<\/td>\necho $PATH<\/code><\/td>\n<\/tr>\n
HOME<\/code><\/td>\nThe current user’s home directory.<\/td>\necho $HOME<\/code><\/td>\n<\/tr>\n
PWD<\/code><\/td>\nThe current working directory.<\/td>\necho $PWD<\/code><\/td>\n<\/tr>\n
USER<\/code><\/td>\nThe name of the current user.<\/td>\necho $USER<\/code><\/td>\n<\/tr>\n
HOSTNAME<\/code><\/td>\nThe name of the computer.<\/td>\necho $HOSTNAME<\/code><\/td>\n<\/tr>\n
SHELL<\/code><\/td>\nThe path to the current user’s shell.<\/td>\necho $SHELL<\/code><\/td>\n<\/tr>\n
EDITOR<\/code><\/td>\nThe default file editor to be used.<\/td>\nexport EDITOR=\/usr\/bin\/vim<\/code><\/td>\n<\/tr>\n
LANG<\/code><\/td>\nThe current locale setting.<\/td>\necho $LANG<\/code><\/td>\n<\/tr>\n
HISTSIZE<\/code><\/td>\nThe number of commands to remember in the command history.<\/td>\necho $HISTSIZE<\/code><\/td>\n<\/tr>\n
UID<\/code><\/td>\nThe numeric user ID of the current user.<\/td>\necho $UID<\/code><\/td>\n<\/tr>\n
TERM<\/code><\/td>\nThe current terminal emulation.<\/td>\necho $TERM<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Operators<\/h2>\n

Arithmetic Operators<\/h3>\n\n\n\n\n\n\n\n\n\n\n
Operator<\/th>\nDescription<\/th>\nSyntax Example<\/th>\n<\/tr>\n<\/thead>\n
+<\/code><\/td>\nAddition<\/td>\nexpr $a + $b<\/code><\/td>\n<\/tr>\n
-<\/code><\/td>\nSubtraction<\/td>\nexpr $a - $b<\/code><\/td>\n<\/tr>\n
*<\/code><\/td>\nMultiplication<\/td>\nexpr $a \\* $b<\/code><\/td>\n<\/tr>\n
\/<\/code><\/td>\nDivision<\/td>\nexpr $a \/ $b<\/code><\/td>\n<\/tr>\n
%<\/code><\/td>\nModulus<\/td>\nexpr $a % $b<\/code><\/td>\n<\/tr>\n
**<\/code><\/td>\nExponentiation<\/td>\nexpr $a ** $b<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Assignment Operators<\/h3>\n\n\n\n\n\n\n\n\n\n\n
Operator<\/th>\nDescription<\/th>\nSyntax Example<\/th>\n<\/tr>\n<\/thead>\n
=<\/code><\/td>\nAssigns value from right side operands to left side operand<\/td>\na=$b<\/code><\/td>\n<\/tr>\n
+=<\/code><\/td>\nAddition assignment<\/a><\/td>\na+=b<\/code> (equivalent to a=$a+$b<\/code>)<\/td>\n<\/tr>\n
-=<\/code><\/td>\nSubtraction assignment<\/td>\na-=b<\/code> (equivalent to a=$a-$b<\/code>)<\/td>\n<\/tr>\n
*=<\/code><\/td>\nMultiplication assignment<\/td>\na*=b<\/code> (equivalent to a=$a*$b<\/code>)<\/td>\n<\/tr>\n
\/=<\/code><\/td>\nDivision assignment<\/td>\na\/=b<\/code> (equivalent to a=$a\/$b<\/code>)<\/td>\n<\/tr>\n
%=<\/code><\/td>\nModulus assignment<\/td>\na%=b<\/code> (equivalent to a=$a%$b<\/code>)<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Logical Operators<\/h3>\n\n\n\n\n\n\n\n
Operator<\/th>\nDescription<\/th>\nSyntax Example<\/th>\n<\/tr>\n<\/thead>\n
&&<\/code><\/td>\nLogical AND<\/td>\n[ $a -lt 20 && $b -gt 100 ]<\/code><\/td>\n<\/tr>\n
||<\/code><\/td>\nLogical OR<\/td>\n[ $a -lt 20 || $b -gt 100 ]<\/code><\/td>\n<\/tr>\n
!<\/code><\/td>\nLogical NOT<\/a><\/td>\n[ !$a -lt 20 ]<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Relational Operators<\/h3>\n\n\n\n\n\n\n\n\n\n\n
Operator<\/th>\nDescription<\/th>\nSyntax Example<\/th>\n<\/tr>\n<\/thead>\n
-eq<\/code><\/td>\nEqual<\/td>\n[ $a -eq $b ]<\/code><\/td>\n<\/tr>\n
-ne<\/code><\/td>\nNot equal<\/td>\n[ $a -ne $b ]<\/code><\/td>\n<\/tr>\n
-gt<\/code><\/td>\nGreater than<\/td>\n[ $a -gt $b ]<\/code><\/td>\n<\/tr>\n
-ge<\/code><\/td>\nGreater than or equal to<\/td>\n[ $a -ge $b ]<\/code><\/td>\n<\/tr>\n
-lt<\/code><\/td>\nLess than<\/td>\n[ $a -lt $b ]<\/code><\/td>\n<\/tr>\n
-le<\/code><\/td>\nLess than or equal to<\/td>\n[ $a -le $b ]<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Data Structures<\/h2>\n\n\n\n\n\n\n\n\n\n\n
Data Structure<\/th>\nCharacteristics<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
Scalars<\/td>\nHold a single value, such as a number or a string.<\/td>\nvar=\"Hello World\"<\/code><\/td>\n<\/tr>\n
Indexed Arrays<\/td>\nOrdered collections of values accessed by a numerical index.<\/td>\narr=(apple banana cherry)<\/code>; access with ${arr[1]}<\/code><\/td>\n<\/tr>\n
Associative Arrays<\/td>\nCollections of key-value pairs accessed by string key. Requires Bash 4+.<\/td>\ndeclare -A arr; arr[\"key\"]=\"value\"<\/code>; access with ${arr[key]}<\/code><\/td>\n<\/tr>\n
Strings<\/td>\nA sequence of characters treated as a single value. Extensive manipulation options<\/a>.<\/td>\nstr=\"Bash Scripting\"<\/code>; manipulate with ${str:0:4}<\/code><\/td>\n<\/tr>\n
Here Documents<\/td>\nDirect a block of text into the input of a command.<\/td>\ncat <<EOF > file.txt<\/code><\/td>\n<\/tr>\n
Here Strings<\/td>\nDirect a single line string into the input of a command.<\/td>\ngrep 'pattern' <<< \"search in this string\"<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Statements and Loops<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Statement Type<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
if<\/code> Statement<\/td>\nEvaluates a condition<\/a> and executes a block of code if the condition is true.<\/td>\nif [ $a -eq $b ]; then echo \"Equal\"; fi<\/code><\/td>\n<\/tr>\n
else<\/code><\/td>\nSpecifies the block of code that is executed if the if<\/code> condition is false.<\/td>\nif [ $a -eq $b ]; then echo \"Equal\"; else echo \"Not Equal\"; fi<\/code><\/td>\n<\/tr>\n
elif<\/code><\/td>\nAllows for multiple conditions<\/a> to be evaluated in an if-else<\/code> block.<\/td>\nif [ $a -eq $b ]; then echo \"Equal\"; elif [ $a -gt $b ]; then echo \"Greater\"; else echo \"Less\"; fi<\/code><\/td>\n<\/tr>\n
case<\/code> Statement<\/td>\nSelects a block of code to execute based on the value of a variable<\/a>.<\/td>\ncase $var in pattern1) command1 ;; pattern2) command2 ;; esac<\/code><\/td>\n<\/tr>\n
for<\/code> Loop<\/td>\nIterates over a list<\/a> of values.<\/td>\nfor i in {1..5}; do echo \"Number $i\"; done<\/code><\/td>\n<\/tr>\n
while<\/code> Loop<\/td>\nExecutes a block of code as long as a condition is true<\/a>.<\/td>\nwhile [ $a -le 5 ]; do echo $a; a=$((a+1)); done<\/code><\/td>\n<\/tr>\n
until<\/code> Loop<\/td>\nExecutes a block of code until a condition becomes true.<\/td>\nuntil [ $a -gt 5 ]; do echo $a; a=$((a+1)); done<\/code><\/td>\n<\/tr>\n
select<\/code> Statement<\/td>\nGenerates a menu from a list and executes code based on user selection.<\/td>\nselect ans in \"Choice1\" \"Choice2\"; do case $ans in Choice1) echo \"1\"; break;; Choice2) echo \"2\"; break;; esac done<\/code><\/td>\n<\/tr>\n
break<\/code><\/td>\nExits from a loop.<\/td>\nfor i in {1..10}; do if [ $i -eq 5 ]; then break; fi; echo $i; done<\/code><\/td>\n<\/tr>\n
continue<\/code><\/td>\nSkips the rest of the loop iteration and proceeds with the next iteration.<\/td>\nfor i in {1..10}; do if [ $i -eq 5 ]; then continue; fi; echo $i; done<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Internal Field Separator (IFS)<\/h2>\n\n\n\n\n\n\n\n\n\n
Concept<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
IFS<\/td>\nSpecial shell variable<\/a> used to determine how Bash recognizes word boundaries. By default, it is set to space, tab, and newline.<\/td>\nN\/A<\/td>\n<\/tr>\n
Customizing IFS for Input Field Separation<\/td>\nTemporarily adjusting IFS to split input into fields based on a custom delimiter.<\/td>\nIFS=',' read -r first second third <<< \"a,b,c\"<\/code><\/td>\n<\/tr>\n
Restoring Original IFS<\/td>\nIt’s good practice to restore IFS to its original state after modifying it to avoid unexpected behavior in script execution.<\/td>\noldIFS=\"$IFS\"; IFS=','; ...; IFS=\"$oldIFS\"<\/code><\/td>\n<\/tr>\n
Using IFS in Loops<\/td>\nCustomizing IFS to loop through lines or entries separated by specific delimiters.<\/td>\nIFS=$'\\n'; for line in $(cat file.txt); do echo \"$line\"; done<\/code><\/td>\n<\/tr>\n
Splitting Strings into Arrays<\/a><\/td>\nUtilizing IFS to split a string into an array based on a delimiter.<\/td>\nIFS=':'; read -ra ADDR <<< \"$PATH\"; echo \"${ADDR[0]}\"<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

String Manipulation<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Method<\/th>\nDescription<\/th>\nExample<\/th>\n<\/tr>\n<\/thead>\n
Concatenation<\/td>\nCombining strings.<\/td>\nstr1=\"Hello,\"; str2=\"World\"; echo \"$str1 $str2\"<\/code><\/td>\n<\/tr>\n
Substring<\/td>\nExtracting parts of a string<\/a>.<\/td>\n${string:position:length}<\/code><\/td>\n<\/tr>\n
Replace<\/a><\/td>\nReplacing part of a string.<\/td>\n${string\/substring\/replacement}<\/code><\/td>\n<\/tr>\n
Length<\/td>\nGetting the length of a string<\/a>.<\/td>\n${#string}<\/code><\/td>\n<\/tr>\n
Uppercase Conversion<\/td>\nConverting a string to uppercase.<\/td>\n${string^^}<\/code><\/td>\n<\/tr>\n
Lowercase Conversion<\/td>\nConverting a string<\/a> to lowercase.<\/td>\n${string,,}<\/code><\/td>\n<\/tr>\n
Trim Whitespaces<\/a><\/td>\nTrimming whitespaces from both ends of a string.<\/td>\nstring=\" some text \"; trimmed=$(echo -e \"$string\" | sed 's\/^[[:space:]]*\/\/;s\/[[:space:]]*$\/\/')<\/code><\/td>\n<\/tr>\n
Split String into Array<\/td>\nSplitting a string into an array using a delimiter.<\/td>\nIFS='delimiter' read -ra ADDR <<< \"$str\"; echo \"${ADDR[0]}\"<\/code><\/td>\n<\/tr>\n
Check if String Contains Substring<\/a><\/td>\nChecking if a string contains a specific substring.<\/td>\n[[ $str == *\"$substring\"* ]] && echo \"Found\" || echo \"Not found\"<\/code><\/td>\n<\/tr>\n
Extracting Strings<\/a> Using Regex<\/td>\nExtracting parts of a string based on a regular expression<\/a>.<\/td>\n[[ $str =~ regex ]] && echo \"${BASH_REMATCH[1]}\"<\/code><\/td>\n<\/tr>\n
Splitting Strings<\/a><\/td>\nDividing a string into parts based on a delimiter.<\/td>\nIFS='delimiter'; read -ra parts <<< \"$str\"; echo \"${parts[0]}\"<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Regex & Pattern Matching<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Concept<\/th>\nDescription<\/th>\nExample<\/th>\n<\/tr>\n<\/thead>\n
grep<\/code><\/td>\nSearches for patterns in files or input.<\/td>\ngrep 'pattern' filename<\/code>
echo \"text\" | grep 'pattern'<\/code> | Use -E<\/code> for extended regex, -i<\/code> for case-insensitive search.<\/td>\n<\/tr>\n
sed<\/code><\/td>\nStream editor for filtering and transforming text<\/a>.<\/td>\nsed 's\/pattern\/replacement\/' filename<\/code> | Useful for find-and-replace operations with regex.<\/td>\n<\/tr>\n
awk<\/code><\/td>\nText processing<\/a> language that supports regex.<\/td>\nawk '\/pattern\/ { action }' filename<\/code> | Great for data extraction and reporting.<\/td>\n<\/tr>\n
Pattern Expansion<\/td>\nBash feature for filename matching using wildcards.<\/td>\nls *.txt<\/code> | *<\/code>, ?<\/code>, and [abc]<\/code> are common wildcards.<\/td>\n<\/tr>\n
*<\/code> (PE)<\/td>\nMatches any string of characters.<\/td>\nls *<\/code><\/td>\n<\/tr>\n
?<\/code> (PE)<\/td>\nMatches any single character.<\/td>\nls ?.txt<\/code><\/td>\n<\/tr>\n
[abc]<\/code> (PE)<\/td>\nMatches any one character in the specified set.<\/td>\nls [a-c].txt<\/code><\/td>\n<\/tr>\n
Extended Globbing<\/td>\nAdditional pattern matching capabilities in Bash.<\/td>\nls !(exclude).txt<\/code> | Enable with shopt -s extglob<\/code>. Patterns like ?<\/code> and *<\/code> become available.<\/td>\n<\/tr>\n
?<\/code> (EG)<\/td>\nMatches zero or one occurrence of the pattern.<\/td>\nls ?(a).txt<\/code> (with shopt -s extglob<\/code>)<\/td>\n<\/tr>\n
*<\/code> (EG)<\/td>\nMatches zero or more occurrences of the pattern.<\/td>\nls *(a).txt<\/code><\/td>\n<\/tr>\n
+<\/code> (EG)<\/td>\nMatches one or more occurrences of the pattern.<\/td>\nls +(a).txt<\/code><\/td>\n<\/tr>\n
@<\/code> (EG)<\/td>\nMatches exactly one of the patterns.<\/td>\nls @(a).txt<\/code><\/td>\n<\/tr>\n
!<\/code> (EG)<\/td>\nMatches anything except the pattern.<\/td>\nls !(a).txt<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Date and Time<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n
Command\/Technique<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
date<\/code><\/td>\nDisplay or set the system’s date and time<\/a>.<\/td>\ndate \"+%Y-%m-%d %H:%M:%S\"<\/code><\/td>\n<\/tr>\n
sleep<\/code><\/td>\nPauses script execution for a specified time.<\/td>\nsleep 5<\/code><\/td>\n<\/tr>\n
Arithmetic with date<\/code><\/td>\nCalculations with dates to find past or future dates.<\/td>\ndate -d \"yesterday\"<\/code>
date -d \"+1 week\"<\/code><\/td>\n<\/tr>\n
Epoch Time (date +%s<\/code>)<\/td>\nUse seconds since the Unix Epoch for calculations.<\/td>\ndate +%s<\/code>
date -d @1609459200<\/code><\/td>\n<\/tr>\n
Using date<\/code> with Files<\/td>\nSet or compare file timestamps.<\/td>\ntouch -d \"1 Jan 2020\" file.txt<\/code><\/td>\n<\/tr>\n
timedatectl<\/code><\/td>\n(systemd only) View\/set system time and date.<\/td>\ntimedatectl set-timezone Asia\/Tokyo<\/code><\/td>\n<\/tr>\n
hwclock<\/code><\/td>\nAccess or adjust the hardware clock (RTC).<\/td>\nhwclock --show<\/code><\/td>\n<\/tr>\n
Bash Scripting with printf<\/code><\/td>\nFormat date<\/a> and time outputs in scripts.<\/td>\nprintf \"Today is %s.\\n\" \"$(date '+%Y-%m-%d')\"<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Text Color and Formatting<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Code\/Command<\/th>\nType<\/th>\nDescription<\/th>\nExample Usage<\/th>\n<\/tr>\n<\/thead>\n
30<\/code>–37<\/code><\/td>\nText Color<\/a><\/td>\nSet text color (30: Black, …, 37: White)<\/td>\n\\e[32mGreen Text\\e[0m<\/code><\/td>\n<\/tr>\n
40<\/code>–47<\/code><\/td>\nBackground Color<\/td>\nSet background color (40: Black, …, 47: White)<\/td>\n\\e[44mBlue Background\\e[0m<\/code><\/td>\n<\/tr>\n
0<\/code><\/td>\nFormatting<\/td>\nReset all attributes<\/td>\n\\e[0mReset<\/code><\/td>\n<\/tr>\n
1<\/code><\/td>\nFormatting<\/td>\nBold text<\/td>\n\\e[1mBold Text\\e[0m<\/code><\/td>\n<\/tr>\n
2<\/code><\/td>\nFormatting<\/td>\nDim text<\/td>\n\\e[2mDim Text\\e[0m<\/code><\/td>\n<\/tr>\n
4<\/code><\/td>\nFormatting<\/td>\nUnderlined text<\/td>\n\\e[4mUnderlined Text\\e[0m<\/code><\/td>\n<\/tr>\n
5<\/code><\/td>\nFormatting<\/td>\nBlinking text<\/td>\n\\e[5mBlinking Text\\e[0m<\/code> (Note: may not work in all terminals)<\/td>\n<\/tr>\n
7<\/code><\/td>\nFormatting<\/td>\nReverse colors<\/td>\n\\e[7mReversed Colors\\e[0m<\/code><\/td>\n<\/tr>\n
8<\/code><\/td>\nFormatting<\/td>\nHidden text<\/td>\n\\e[8mHidden Text\\e[0m<\/code><\/td>\n<\/tr>\n
tput<\/code><\/td>\nCommand<\/td>\nPortable way to use terminal capabilities<\/td>\ntput setaf 1; echo \"Red Text\"; tput sgr0<\/code><\/td>\n<\/tr>\n
Custom Function<\/td>\nTechnique<\/td>\nSimplify color usage in scripts<\/td>\nDefine a function: red_text() { echo -e \"\\e[31m$1\\e[0m\"; }<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Common Errors<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Error<\/th>\nDescription & Cause<\/th>\nSolution<\/th>\n<\/tr>\n<\/thead>\n
Command Not Found<\/code><\/td>\nThe system can’t locate the script or command<\/a> being executed. Caused by a typo, the command not being installed, or a PATH issue.<\/td>\nCheck for typos, ensure the command is installed, or verify the PATH variable.<\/td>\n<\/tr>\n
Unary Operator Expected<\/code><\/td>\nBash expected a unary operator<\/a> (like -z<\/code><\/a> or -n<\/code>), often due to missing quotes around a variable that might become an empty string.<\/td>\nEnsure variables are quoted when used in test expressions.<\/td>\n<\/tr>\n
Bad Substitution<\/code><\/td>\nSyntax error<\/a>, usually because of a typo or misuse of brace expansion or variable substitution features.<\/td>\nCheck the syntax for brace expansions or variable references. Use ${var}<\/code> for variables.<\/td>\n<\/tr>\n
sudo: Command Not Found<\/code><\/td>\nThe sudo<\/code> command isn’t installed<\/a> on the system, common in minimal installations or certain Docker images.<\/td>\nInstall sudo<\/code> with the package manager, e.g., apt-get install sudo<\/code> for Debian\/Ubuntu.<\/td>\n<\/tr>\n
Permission Denied<\/code><\/td>\nLack of execution permissions on a script or attempt to access a file\/directory without the necessary permissions<\/a>.<\/td>\nUse chmod<\/code> to add execute permission to the script chmod +x script.sh<\/code> or correct file permissions.<\/td>\n<\/tr>\n
No Such File or Directory<\/code><\/td>\nThe script or the file path specified doesn’t exist<\/a>, possibly due to a wrong path or a typo.<\/td>\nCheck the path and the filename for typos. Ensure the file exists<\/a> in the specified location.<\/td>\n<\/tr>\n
Syntax Error Near Unexpected Token<\/code><\/td>\nSyntax error caused by incorrect use of Bash syntax, like a misplaced or missing fi<\/code> for an if<\/code> statement.<\/td>\nReview the script for syntax errors, paying close attention to loops, conditionals, and function definitions.<\/td>\n<\/tr>\n
Integer Expression Expected<\/code><\/td>\nA test command or condition expects an integer, but is given a string or a variable that doesn’t hold an integer.<\/td>\nEnsure that variables used in arithmetic tests are integers or quoted if they might be empty.<\/td>\n<\/tr>\n
Too Many Arguments<\/code><\/td>\nA test expression receives more arguments than expected, often due to unquoted variables expanding into multiple words.<\/td>\nQuote variables in test expressions to prevent word splitting, especially when a variable could contain spaces.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Script Comments<\/h2>\n\n\n\n\n\n\n
Topic<\/th>\nDescription<\/th>\nExample<\/th>\n<\/tr>\n<\/thead>\n
Single-line Comment<\/a><\/td>\nUses the #<\/code> symbol to mark the remainder of the line as a comment.<\/td>\n# This is a comment<\/code><\/td>\n<\/tr>\n
Multi-line Comment<\/td>\nSimulated using : '...'<\/code> for multiple lines<\/a> not directly supported.<\/td>\n: 'This is a multi-line comment'<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Script Output<\/h2>\n\n\n\n\n\n\n\n\n
Topic<\/th>\nDescription<\/th>\nExample<\/th>\n<\/tr>\n<\/thead>\n
Echo<\/a><\/td>\nUses echo<\/code> command to display a line of text\/string<\/a>.<\/td>\necho \"Hello World\"<\/code><\/td>\n<\/tr>\n
Printf<\/td>\nUses printf<\/code> for formatted output<\/a>, similar to the C function.<\/td>\nprintf \"Name: %s\\nAge: %d\\n\" \"John\" 25<\/code><\/td>\n<\/tr>\n
Here Document<\/td>\nDirects a block of text into an input stream.<\/td>\ncat <<EOF >file.txt\\nText\\nEOF<\/code><\/td>\n<\/tr>\n
Redirection<\/td>\nRedirects output to a file or another command using ><\/code>, >><\/code>, or |<\/code>.<\/td>\necho \"Text\" > file.txt<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Networking Commands<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n
Command<\/th>\nDescription<\/th>\nExample<\/th>\n<\/tr>\n<\/thead>\n
ping<\/code><\/td>\nChecks the network connectivity<\/a> to another host.<\/td>\nping google.com<\/code><\/td>\n<\/tr>\n
ifconfig<\/code> \/ ip<\/code><\/td>\nDisplays or configures the network interface<\/a> settings.<\/td>\nip addr show<\/code><\/td>\n<\/tr>\n
netstat<\/code><\/td>\nDisplays network connections, routing tables, and interface statistics.<\/td>\nnetstat -tuln<\/code><\/td>\n<\/tr>\n
curl<\/code> \/ wget<\/code><\/td>\nDownloads files<\/a> from the network.<\/td>\ncurl -O http:\/\/example.com\/file.txt<\/code><\/td>\n<\/tr>\n
ssh<\/code><\/td>\nSecurely connects to a remote machine.<\/td>\nssh user@host<\/code><\/td>\n<\/tr>\n
scp<\/code><\/td>\nSecurely copies files<\/a> between hosts.<\/td>\nscp file.txt user@host:\/path<\/code><\/td>\n<\/tr>\n
nslookup<\/code> \/ dig<\/code><\/td>\nQueries DNS<\/a> to obtain domain name or IP address mapping.<\/td>\ndig example.com<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Debugging and Error Handling<\/h2>\n\n\n\n\n\n\n\n\n\n\n
Topic<\/th>\nDescription<\/th>\nExample<\/th>\n<\/tr>\n<\/thead>\n
set -e<\/code><\/td>\nExits the script if any command returns a non-zero exit status.<\/td>\nset -e<\/code><\/td>\n<\/tr>\n
set -u<\/code><\/td>\nTreats unset variables and parameters as an error.<\/td>\nset -u<\/code><\/td>\n<\/tr>\n
set -x<\/code><\/td>\nDisplays commands and their arguments as they are executed.<\/td>\nset -x<\/code><\/td>\n<\/tr>\n
trap<\/code><\/td>\nCatches or intercepts a signal and executes a specified command.<\/td>\ntrap 'echo \"Error\"' ERR<\/code><\/td>\n<\/tr>\n
Custom Error Messages<\/td>\nUses conditional statements to check command success and displays custom error messages.<\/td>\ncommand || echo \"Command failed\"<\/code><\/td>\n<\/tr>\n
Debugging Tools<\/td>\nUtilizes external tools like bashdb<\/code> for debugging Bash scripts<\/a>.<\/td>\nN\/A (usage depends on the tool installation)<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Bash Sample Script & Syntax<\/h2>\n

In this section, we’ll walk through a straightforward Bash script that demonstrates how different Bash scripting concepts come together. The following script will provide practical syntax examples, followed by echo<\/code> statements to showcase what the codeblocks would output. Before the Script, we will instruct you on how to prepare an environment, so that you may run the code yourself!<\/p>\n

Setting Up Your Environment<\/h3>\n

To prepare your environment for running Bash scripts, follow these streamlined steps:<\/p>\n

    \n
  1. Choose an IDE or Editor:<\/strong>
    \n Pick your preferred editor like Visual Studio Code, Atom, Sublime Text, or a terminal-based editor like Vim<\/a> or Emacs for writing Bash scripts.<\/p>\n<\/li>\n
  2. \n

    Ensure Bash is Available:<\/strong>
    \n     Linux<\/a>\/macOS: Bash is typically pre-installed.
    \n Windows: Install Windows Subsystem for Linux (WSL), Git Bash, or Cygwin.<\/p>\n<\/li>\n

  3. \n

    Create and Open Your Bash Script:<\/strong>
    \n Open your editor, create a new file, paste the Bash script, and save it with a .sh extension, e.g., myscript.sh.<\/p>\n<\/li>\n

  4. \n

    Set Execute Permissions:<\/strong>
    \n Open a terminal, navigate to your script’s directory, and run: chmod +x myscript.sh.<\/p>\n<\/li>\n

  5. \n

    Run Your Script:<\/strong>
    \n In the terminal, execute the script by typing: .\/myscript.sh [arg1].
    \n Note: This script expects an integer as a command-line argument, provide it as such:<\/em><\/p>\n<\/li>\n<\/ol>\n

    .\/myscript.sh [integer]\n<\/code><\/pre>\n
    That’s it! You’re ready to execute Bash scripts.<\/p>\n
    Bash Sample Script<\/h3>\n
    Below, we present a sample Bash script designed to showcase a range of Bash scripting techniques. This example should also provide insight into scripting best practices and how various commands can be used together. Refer to this segment to understand more about how the commands and concepts previously discussed are applied in actual coding scenarios.<\/p>\n
    #!\/bin\/bash\n# The above line is called a shebang. It tells the system this script should\n# be executed using Bash, the Bourne Again SHell, regardless of which shell \n# the user might be using. It specifies the path to the Bash interpreter.\n\n# Variable assignment\nname=\"World\"\necho \"Hello, $name\"\n# Output: Hello, World\n\n# Command-line Parameters\nnumber=$1\n\nif [ $number -eq 10 ]; then # Compare the parameter to 10\n    echo \"Your number is equal to 10.\"\nelif [ $number -lt 10 ]; then\n    echo \"Your number is less than 10.\"\nelse\n    echo \"Your number is greater than 10.\"\nfi\n# Output will depend on number used when calling the script\n# If the number \"5\" was passed, output would be:\n# Your number is less than 10.\n\n# printf for formatted output\nname=\"Alice\"\nage=30\nprintf \"Name: %s, Age: %d\\n\" \"$name\" \"$age\"\n# Output: Name: Alice, Age: 30\n\n# Environment Variables\necho \"Your home directory is: $HOME\"\n# Outputs the path to the user's home directory\n\n# Setting a new environment variable\nexport MY_VAR=\"Hello World\"\necho $MY_VAR\n# Outputs: Hello World\n\n# Using an environment variable in a command\nmkdir \"$MY_VAR\"\n# Creates a new directory named \"Hello World\"\n\n# String Concatenation\nstr1=\"Hello\"\nstr2=\"World\"\nconcatenatedStr=\"$str1, $str2!\"\necho \"Concatenated string: $concatenatedStr\"\n# Output: Concatenated string: Hello, World!\n\n# String Length\nstr=\"Hello World\"\nlength=${#str}\necho \"Length of '$str': $length\"\n# Output: Length of 'Hello World': 11\n\n# Substring Extraction\n# Extracting 'World' from 'Hello World'\nextractedStr=${str:6:5}\necho \"Extracted substring: $extractedStr\"\n# Output: Extracted substring: World\n\n# Case Conversion\n# Converting to uppercase\nupperStr=${str^^}\necho \"Uppercase conversion: $upperStr\"\n# Output: Uppercase conversion: HELLO WORLD\n\n# Replace in String\n# Replacing 'World' with 'Bash'\nreplacedStr=${str\/World\/Bash}\necho \"Replaced String: $replacedStr\"\n# Output: Replaced String: Hello Bash\n\n# Split string based on delimiter (space in this example)\nstring=\"one two three\"\nIFS=' ' read -r -a str_array <<< \"$string\"\necho \"First element after split: ${str_array[0]}\" # Outputs \"First element after split: one\"\n\n# Array usage\nfruits=(\"apple\" \"banana\" \"cherry\")\necho \"First fruit: ${fruits[0]}\" # Output: First fruit: apple\n\n# Associative array\ndeclare -A capitals\ncapitals[\"France\"]=\"Paris\"\ncapitals[\"Germany\"]=\"Berlin\"\necho \"The capital of France is: ${capitals[France]}\" # Output: The capital of France is: Paris\n\n# Reading a file line by line\nwhile IFS= read -r line; do\n  echo \"Line: $line\"\ndone < myfile.txt # Output: Lines from myfile.txt\n\n# Check if a file exists\nfile=\"myfile.txt\"\nif [ -f \"$file\" ]; then\n  echo \"$file exists.\"\nelse\n  echo \"$file does not exist.\"\nfi # Output depends on if myfile.txt exists\n\n# Sorting lines of text in a file alphabetically\necho -e \"banana\\napple\\nfig\" > fruits.txt\nsort fruits.txt\n# This will output:\n# apple\n# banana\n# fig\n\n# Numerical sort with -n flag\necho -e \"10\\n2\\n1\" > numbers.txt\nsort -n numbers.txt\n# This will output:\n# 1\n# 2\n# 10\n\n# Using Here Document to create a configuration file\ncat << EOF > myconfig.conf\n# My Application Configuration File\nHOST=localhost\nPORT=8080\nEOF\n\necho \"Configuration file created with the following content:\"\ncat myconfig.conf\n\n# Text color and formatting w\/ ANSI escape codes\necho -e \"\\e[31mThis text is red\\e[0m\" # Red text\necho -e \"\\e[1;34mThis text is bold and blue\\e[0m\" # Bold and blue text\n\ncurrent_date=$(date)\necho \"Current date and time: $current_date\"\n\n# Show date and time one week later\ndate_one_week_later=$(date -d \"$current_date + 1 week\") # '-d' flag used for date manipulation, allowing for manipulation like \"1 week\" to be performed\"\necho \"Date and time one week later: $date_one_week_later\"\n\n# Conditional statement\nif [ \"$name\" = \"World\" ]; then\n  echo \"The condition is true.\"\nelse\n  echo \"The condition is false.\"\nfi \n# Output: The condition is true.\n\n# Case statement\ncolor=\"red\"\ncase $color in\n  red)\n    echo \"Red color selected.\"\n    ;;\n  blue)\n    echo \"Blue color selected.\"\n    ;;\n  *)\n    echo \"Unknown color.\"\n    ;;\nesac # Output: Red color selected.\n\n# For Loop\nfor i in {1..3}; do\n  echo \"Loop iteration: $i\"\ndone \n# Output: Loop iteration: 1 (then 2, then 3)\n\n# While loop\ncount=3\nwhile [ $count -gt 0 ]; do\n  echo \"Countdown: $count\"\n  ((count--))\ndone \n# Output: Countdown: 3 (then 2, then 1)\n\n# Using Break and Continue in Loops\nfor i in {1..5}; do # Loop through numbers 1 to 5\n  if [ \"$i\" -eq 3 ]; then\n    echo \"Skipping number $i\"\n    continue # Skip the rest of the loop at 3 and continue with the next iteration\n  fi\n  if [ \"$i\" -eq 4 ]; then\n    echo \"Stopping at number $i\"\n    break # Exit the loop at number 4\n  fi\n  echo \"Number $i\" # Will output \"Number 1\" then \"Number 2\"\ndone\n\n# Use of parameters ($@)\necho \"Script parameters: $@\"\n# When running: .\/script.sh param1 param2\n# Output: Script parameters: param1 param2\n\n# Assignment Operators and Arithmetic\na=10\nb=0\necho \"Initial value of a: $a\" # 10\n\n# Assignment\na=$b\necho \"Assigned value of b to a: $a\" # Value of b\n\n# Addition assignment\n((a+=5))\necho \"After addition assignment: $a\" # 5\n\n# Subtraction assignment\n((a-=3))\necho \"After subtraction assignment: $a\" # 2\n\n# Multiplication assignment\n((a*=2))\necho \"After multiplication assignment: $a\" # 4\n\n# Logical Operators\na=true\nb=false\n\n# Logical AND\nif [[ $a && $b ]]; then\n    echo \"Both are true.\"\nelse\n    echo \"a AND b is false.\"\nfi # a AND b is false.\n\n# Logical OR\nif [[ $a || $b ]]; then\n    echo \"At least one is true.\"\nelse\n    echo \"Both are false.\"\nfi # At least one is true.\n\n# Logical NOT\nif [[ ! $b ]]; then\n    echo \"b is not true.\"\nelse\n    echo \"b is true.\"\nfi # b is not true.\n\n# Relational Operators\na=10\nb=20\n\nif [ $a -eq $b ]; then\n    echo \"a is equal to b.\"\nelif [ $a -ne $b ]; then\n    echo \"a is not equal to b.\" # This will be executed\nfi\n\nif [ $a -lt $b ]; then\n    echo \"a is less than b.\" # This will be executed\nelif [ $a -gt $b ]; then\n    echo \"a is greater than b.\"\nfi\n\nif [ $a -le $b ]; then\n    echo \"a is less than or equal to b.\" # This will be executed\nelif [ $a -ge $b ]; then\n    echo \"a is greater than or equal to b.\"\nfi\n\n# Simple Regex Matching in Conditional\nif [[ \"Hello World!\" =~ ^Hello ]]; then # Checks if the string starts with \"Hello\"\n  echo \"Pattern found in string\" # This will be the output\nelse\n  echo \"Pattern not found in string\"\nfi\n\n# Extracting Parts of String Using Regex\nversionString=\"Version: 5.0.17\"\nif [[ $versionString =~ Version:\\ ([0-9]+)\\.([0-9]+)\\.([0-9]+) ]]; then\n  majorVersion=${BASH_REMATCH[1]}\n  minorVersion=${BASH_REMATCH[2]}\n  patchVersion=${BASH_REMATCH[3]}\n  echo \"Major: $majorVersion, Minor: $minorVersion, Patch: $patchVersion\" # Major: 5, Minor: 0, Patch: 17\nfi\n\n# Pattern Matching with Globbing\nfiles=(*.sh)\necho \"Shell script files: ${files[@]}\" # Lists .sh files in the current directory\n\n# Using Extended Globbing\nshopt -s extglob # Enable extended globbing\nfiles=(!(*.sh))\necho \"Non-shell script files: ${files[@]}\" # Lists files not ending with .sh\nshopt -u extglob # Disable extended globbing\n\n# Flags and Modifier Flags\n# Use 'set -e' to exit the script when any command fails\nset -e\necho \"Set -e: Exit on first error. Next command will fail, exiting the script early.\"\ncat nonexistentfile.txt\n# Use 'set +e' to disable exit on first error\nset +e\n\n# Use 'set -u' to treat unset variables as an error\nset -u\necho \"Set -u: Treating unset variables as an error.\"\necho $UNSET_VARIABLE\n# Use 'set +u' to disable treating unset variables as an error\nset +u\n\n# Redirecting stderr to stdout and filtering through grep\nls valid_file.txt non_existent_file.txt 2>&1 | grep \"No such file\" || echo \"One or more files do not exist.\"\n\n# Using the -f flag with grep to read patterns from a file\necho \"Error\" > patterns.txt\ngrep -f patterns.txt log.txt || echo \"Pattern not found in log.txt.\"\n\n# Command chaining with logical AND (&&) and OR (||)\nmkdir temp_directory && echo \"Directory created successfully.\" || echo \"Failed to create directory.\"\n\n# Redirecting command output to a file while checking for command success\ncp source.txt destination.txt && echo \"Copy successful.\" > operation_status.txt || echo \"Copy failed.\" > operation_status.txt\n\n# Using the exec command with redirection to globally redirect script output\nexec 3>&1 4>&2 # Saving file descriptors\nexec 1>log_all_output.txt 2>&1 # Redirecting all output to log file\necho \"This output will be logged in the file.\"\nexec 1>&3 2>&4 # Restoring file descriptors\n\n# Function definition and call\ngreet() {\n  local person=\"$1\" # Local variable\n  echo \"Hello, $person\"\n}\ngreet \"Alice\" # Output: Hello, Alice\n\n# A function to display basic system information and store it into a log file\nsystem_info() {\n  echo \"System Information Report:\"\n\n  # Display current date and time\n  echo \"Current Date and Time: $(date)\"\n\n  # Show system uptime\n  echo \"System Uptime: $(uptime -p)\"\n\n  # Disk space usage\n  echo \"Disk Space Usage:\"\n  df -h | grep \"^\/dev\" # Shows disk space usage for devices starting with \/dev\n\n  # Memory usage\n  echo \"Memory Usage:\"\n  free -h # Display human-readable memory usage\n}\n\n# Calling the system_info function and redirecting output to a file with a timestamp\nsystem_info | tee \"system_info_$(date \"+%Y-%m-%d_%H-%M-%S\").txt\"\n\n# File and Directory Manipulation\n# Define directory and file names\ndirName=\"exampleDir\"\nfileName=\"exampleFile.txt\"\n\n# Create a new directory\nmkdir $dirName\n\n# Navigate into the directory\ncd $dirName\n\n# Create a new file and write to it\necho \"This is a sample text.\" > $fileName\n\n# Display the content of the file\necho \"Contents of $fileName:\"\ncat $fileName\n\n# Navigate back to the original directory\ncd ..\n\n# Clean up: Remove the directory and its contents\nrm -r $dirName\n\n# Error Handling and Conditional Execution\n# Attempt to read from a non-existent file and check exit status\ncat non_existent_file.txt\nif [ $? -ne 0 ]; then\n  echo \"Failed to read file.\" # This message is shown if the file doesn't exist.\nfi\n\n# Using conditional execution to echo \"Error\" if a command fails\nls non_existent_directory || echo \"Error: Directory does not exist.\"\n\n# Using && for success execution\necho \"Checking for \/tmp directory existence...\" && ls \/tmp || echo \"Error: \/tmp directory does not exist.\"\n\n# Explicitly setting an exit status\nfalse\nif [ $? -eq 0 ]; then\n  echo \"Command succeeded.\"\nelse\n  echo \"Command failed.\"\nfi\n<\/code><\/pre>\n
    The example code provided above showcased a variety of Bash scripting techniques, from basic command execution to more complex structures like loops<\/a> and conditionals<\/a>. Remember, the reference section is there to support you; use it to revisit any concepts covered in the script or to clarify details as you experiment with Bash on your own!<\/p>\n
    Conclusion<\/h2>\n
    In this article, we’ve equipped you with a handy Bash command reference and demonstrated these concepts through a practical code example. It’s our hope that these tools will bolster your Bash scripting journey, enhancing both your understanding and efficiency. As you move forward, we wish you the best of luck with your future Bash endeavors. Happy scripting!<\/p>\n","protected":false},"excerpt":{"rendered":"
    Managing dedicated servers and performing system administration tasks at IOFLOOD requires a solid understanding of Bash syntax to efficiently automate processes and troubleshoot issues. Drawing from our experience in server management and software deployment, we’ve compiled this comprehensive Bash reference guide. This Bash Cheat Sheet is your concise companion in the vast world of Bash […]<\/p>\n","protected":false},"author":1,"featured_media":18547,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[124,3,121],"tags":[],"class_list":["post-18427","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-bash","category-linux","category-programming-coding","cat-124-id","cat-3-id","cat-121-id","has_thumb"],"_links":{"self":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/18427","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/comments?post=18427"}],"version-history":[{"count":65,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/18427\/revisions"}],"predecessor-version":[{"id":19736,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/18427\/revisions\/19736"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/media\/18547"}],"wp:attachment":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/media?parent=18427"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/categories?post=18427"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/tags?post=18427"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}