Snippet Collections

This snippet demonstrates piping both the standard output (`stdout`) and standard error (`stderr`) of `COMMAND_1` to `COMMAND_2` using the `|&` operator in Bash. This is useful for capturing and processing both output streams in a single pipeline.

Redirect both standard output and standard error of a `COMMAND` to `/dev/null`, effectively silencing all output. This is useful for suppressing unwanted output from commands.

Redirect both standard output (`stdout`) and standard error (`stderr`) of a `COMMAND` to a `FILE`. This is a common pattern in Bash for capturing all output (both normal and error messages) into a single file.

This code attempts to create a lock file `my.lock` using the `noclobber` option to prevent overwriting. If the file already exists, it outputs "Failed to create lock file". This demonstrates a simple way to implement file-based locking in Bash.

This code demonstrates the use of `PIPESTATUS` in Bash to check the exit status of commands in a pipeline. It pipes the string `'foo'` through `grep` and `sed`, then uses `PIPESTATUS` to retrieve the exit status of a specific command in the pipeline (e.g., `grep` or `sed`). This is useful for debugging or conditional logic based on pipeline command success.

This code reads two inputs, `name` and `age`, and checks if `name` is "Steve" and `age` is 15 using the `&&` operator within an `if` statement. If both conditions are true, it prints a message. This demonstrates using multiple pairs of square brackets for compound conditions in Bash.

Display help documentation for Bash shell built-in commands using the `help` command. This snippet demonstrates how to access detailed information about built-ins like `for`, `return`, `source`, and `.`.

This snippet demonstrates the use of `sudo` to execute a command as the superuser. It first retrieves the current user with `whoami`, then uses `sudo whoami` to retrieve the superuser's username, and prints both results. This shows how `sudo` elevates privileges to perform commands as the superuser.

The `trap` command is used to execute `rm $TEMP_FILE; exit` when the script receives `SIGHUP`, `SIGINT`, or `SIGTERM` signals. This ensures the temporary file is cleaned up and the script exits gracefully upon receiving these signals. This demonstrates handling signals to perform cleanup operations.

Define a function `bar` that prints "Another way to declare functions!" and returns `0`. This demonstrates an alternative way to declare and call functions in Bash.

Define a function `foo` that accepts arguments and prints them, along with a message. The function also returns a value using `return`. This demonstrates how to define and call functions in Bash, handle arguments, and retrieve return values.

This code demonstrates a `while` loop in Bash that runs indefinitely (`while [ true ]`). Inside the loop, it prints "loop body here..." and then immediately breaks out of the loop using the `break` statement. This results in the loop executing only once. This is an example of a `while` loop with an immediate exit condition.

This code iterates over all `.markdown` files in the current directory and prints their contents using the `cat` command. This demonstrates how to use patterns in Bash to process multiple files matching a specific extension.

This code iterates over the output of the `ls` command, treating each file or directory name as a separate item, and uses `cat` to display the contents of each file. This demonstrates how to process the output of a command in a loop.

This code iterates over a list of files (`file1` and `file2`) and runs the `cat` command on each file to display its contents. This demonstrates how to use a `for` loop to process multiple files in Bash.

This code demonstrates a traditional C-style `for` loop in Bash, iterating from 1 to 3 and printing each value. This is an example of using a `for` loop with a counter in Bash.

This code uses a `for` loop to iterate over a range of numbers from 1 to 3, printing each number on a new line. This demonstrates how `for` loops can iterate over a sequence of values.

This code demonstrates the use of a `case` statement in Bash, which functions similarly to a `switch` statement in Java and C++. It checks the value of `$Variable` and executes different commands based on whether it matches `0`, `1`, or any other value (`*`). This is an example of pattern matching and conditional execution in Bash.

This code prints the number of items in the current directory by using `ls | wc -l` within backticks. It demonstrates an alternative to using `$(...)` for command substitution, though backticks cannot be nested.

This code uses command substitution to count and display the number of items (files and directories) in the current directory. The `ls` command lists the items, and `wc -l` counts them, with the result embedded in the `echo` statement. This demonstrates how to substitute commands within other commands using `$(...)`.