Snippet Collections

This code demonstrates the use of a here-document (heredoc) in Bash to pass multiple lines of text to a command like `cat`. It shows three examples: basic heredoc usage, heredoc with variable expansion, and heredoc with suppressed variable expansion. This illustrates how to handle multi-line input and control variable expansion in heredocs.

This code prints "a" and then iterates over the items "b" and "c", printing each one. This demonstrates the use of a semicolon (`;`) to separate commands in a single line.

This code uses the `!` operator to negate the result of the `grep` command, which searches for the string `value` in `file.txt`. The `echo "$?"` command then prints the exit status of the negated `grep` command. This demonstrates how to negate the result of a command and check its exit status.

Enable debugging mode in a Bash script, which prints each command and its arguments as they are executed. This is useful for debugging scripts by tracing their execution.

Create a directory named `dir` and change into it. If either operation fails, print "Failed to create directory". This demonstrates command chaining using `&&` and `||` operators.

Set the environment variable `MY_VAR` to the value `"value"` using the `export` command. This demonstrates how to manipulate environment variables in a shell session.

Exit the script with a custom exit code of `42`. This demonstrates how to use custom exit codes in Bash scripts.

This code changes the current directory to `/tmp` within a subshell and lists its contents. The subshell ensures that the directory change does not affect the parent shell's environment. This demonstrates the use of subshells to isolate changes.

Run the `sleep` command in the background for 10 seconds. This demonstrates how to execute a command in the background using the `&` operator.

Assign the current date and time to the variable `current_date` using command substitution. This demonstrates capturing the output of a command into a variable.

Declare an associative array `my_array` and assign the value `"value"` to the key `"key"`. This demonstrates the use of associative arrays in Bash.

This snippet sets up a trap to catch the `SIGINT` signal (typically triggered by pressing `Ctrl+C`). When the signal is received, the script prints "Script interrupted" and exits with a status code of 1. This demonstrates handling interruptions gracefully in a Bash script.

This code demonstrates line continuation in Bash using a backslash (`\`). It prints "Hello" by continuing the `echo` command on the next line. This shows how to split a command across multiple lines for better readability.

Print the strings `a` and `b` on separate lines using the `-e` flag to enable interpretation of backslash escapes in `echo`. This demonstrates how to output multiple lines in a single `echo` command.

This code executes a Bash command that echoes "bash is executed: arg1". It demonstrates piping a command string into `bash -s` to execute it with an argument. This shows how to dynamically execute Bash commands with arguments.

This code navigates up two levels in the directory hierarchy by using `cd ..` twice. The first command moves to the parent directory, and the second command moves to the grandparent directory. This demonstrates navigating to parent directories in the file system.

Compare the output of two `echo` commands using `diff` and process substitution. This demonstrates how to use process substitution to compare the output of commands directly without creating temporary files.

This snippet demonstrates how to save and restore the cursor position in a terminal using `tput sc` (save cursor) and `tput rc` (restore cursor). It also uses `tput el` to clear the line before printing new content, ensuring that the previous line is overwritten cleanly. This is useful for updating terminal output dynamically without leaving residual text.

Extract and manipulate file extensions and names in Bash. The code demonstrates how to: - Extract the file extension using `${file##*.}`. - Get the file name without the extension using `${file%.*}`. - Replace the file extension with a new one using `${file%txt}gif`. This showcases string manipulation techniques in Bash for file paths.

The code uses `tee` to split the output of `echo "Hi"` into two parallel `xargs echo` processes, then pipes the result to another `xargs echo` to demonstrate process substitution and parallel command execution in Bash. This showcases how to utilize process substitution and parallel command execution in Bash.