Skip to content
Snippets Groups Projects
Commit 56067c71 authored by Dong Cao's avatar Dong Cao
Browse files

add Bash reference sheet (also includes regex)

parent caecdd96
Branches
No related merge requests found
# Bash cheatsheet
## Basics
* **Ctrl + A**: moves cursor to the beginning of the line
* **Ctrl + E**: moves cursor to the end of the line
* `$ echo <something>`: returns whatever you type at the shell prompt, similar to `print()` .
* `$ date`: displays the current time and date.
* `$ clear` or **Ctrl + L**: clears the terminal
* Common shorthand:
* `.`: (current) working directory
* `..`: parent of the working directory
* `../..`: grandparent of the working directory
* `~`: home directory
* `$ pwd`: prints working directory
* `$ ls`: lists the contents of the working directory
* `$ ls <particular-directory>` : lists the contents of a particular directory.
* `$ ls -a`: lists all the hidden objects in a directory
* `$ ls -l`: prints out a longer and more detailed listing of the contents.
* `$ ls <pattern` : lists all the objects matching the given pattern (see **Regular expressions**).
* `$ cd <to-directory>`: jumps to the given directory
* `$ mkdir <new-directory>`: makes a new directory
* `$ mv <things-to-move> <new-location>`: move objects to a given location. It can also be used to rename objects. In that case, the `<new-location>` will be the new name.
* `$ touch <new-file-name>`: creates a new file
* `$ rm <file-name>`: removes a file
* `$ rm *`: removes all files in the working directory.
* `$ rm -r *`: removes all files in the working directory and its children directories (`-r` stands for "recursively").
* `$ rmdir <empty-directory>`: removes an empty directory. By default, a directory cannot be removed unless it has been emptied.
* `$ cat <file1> <file2> <...>`: reads and outputs the entire content of the given file(s).
* `$ less <file-name>`: views the content of the given file, one screen at a time. Press:
* **Spacebar** : to go to the next screen
* **b**: to go to the previous screen
* **/**: to search for a specific word
* **q**: quit
* `$ man <command>`: displays the manual for the given command
* `$ man bash`: displays the entire manual
## History
* **Up Arrow** or **Ctrl+P**: goes to the previous command(s) in your history.
* **Down Arrow** or **Ctrl+N**: goes to the next command(s) in your history.
* **Ctrl+R**: recalls the last command matching the characters you provide. Press this shortcut and start typing to search your bash history for a command.
* **Ctrl+O**: Run the command you found with Ctrl+R.
* **Ctrl+G**: Leave the history searching mode without running a command.
* `$ history`: prints your entire bash history to the screen
## Regular Expressions
* `*`: wildcard to match any other character within a given pattern.
* Example: `$ ls 5*.txt` lists all `.txt` files whose names start with the number 5.
* `X*`: matches zero or more of `X`
`X+`: matches one or more of `X`
`X?`: matches zero or one of `X`
`X{3, 5}`: matches from 3 to 5 of `X`
* `[0-9]`: matches any digit
`[a-z]`: matches any lowercase letter
`[A-Z]`: matches any uppercase letter
`[a-zA-Z]`: matches any letter
* `(<group>)`: declares a group
* Example: `([a-z]+)@([a-z]+).com`
* `^`: signifies the beginning of the line
`$`: signifies the end of the line
* `$ egrep '<pattern>' <file1> [file2]`: prints any line from a file that contains a specific pattern of characters.
* Example: `$ egrep '([a-z]+)12([a-z]+)' doc.txt` prints the lines from `doc.txt` which include the number 12 with at least one character on both sides.
* `$ egrep -w '<pattern>' *`: only searches for whole words in all the files of the current directory.
* `$ egrep -i '<pattern>' <file1>`: makes the search case-insensitive.
* `$ egrep -c '<pattern>' <file1>`: counts the number of matches.
* `$ egrep -v '<pattern>' <file1>`: excludes the lines that match the given pattern.
## Pipes and Redirection
* `$ command1 | command2`: sends the output of one command as input to another command
* Example: `$ cat document.txt | wc -l` returns the number of lines in `document.txt`.
* `$ command > file-name`: saves the output of one command to the given file.
* Example: `$ cat document.txt | wc -l > lines-count.dat` writes the number of lines of `documents.txt` to `lines-count.dat`.
**Notice** that the file will be overwritten.
* `$ command < file-name`: sends the given file as input to the command.
* Example: `$ cat < documents.txt` is the same as `$ cat document.txt`.
## Bash Scripting
* Variables:
```bash
name="John"
echo $name
echo "Hi $name"
echo "Hey ${name}!"
echo ${name/J/j} #=> "john" (substitution)
echo ${name:0:2} #=> "Jo" (slicing)
echo ${name::2} #=> "Jo" (slicing)
echo ${name::-1} #=> "Joh" (slicing)
echo ${name:(-1)} #=> "n" (slicing from right)
echo ${name:(-2):1} #=> "h" (slicing from right)
echo ${food:-Cake} #=> $food or "Cake"
emoji="haha"
echo ${emoji#*h} #=> "aha" (dropping substr from start of string up to 1st occurrence)
echo ${emoji##*h} #=> "a" (dropping substr from start of string up to last occurrence)
echo ${emoji%h*} #=> "ha" (dropping substr from last occurrence to end of string)
echo ${var%%a*} #=> "h" (dropping substr from first occurrence to end of string)
```
* For loop: `for <...>; do <command1>; [<command2>;] done`
* `for char in a b c x y z; do echo $char; done`
* `for filename in *.dat; do echo $filename; done`
* `for i in {1..100}; do echo $RANDOM; done | cat -n > file`: makes a file with 100 random numbers
* You can write and store a script in a file with the `.sh` extension. To make the script executable: `$ chmod +x <script-file-name>`. You can then run it with the syntax: `$ ./<script-file-name>`. The more general syntax to run a script is: `$ /path/to/script.sh`.
## Job Control
* On the shell, multiple processes can be joined together into a pipeline, where each process's output becomes the next process's input. A pipeline created this way is a single job even though it contains multiple processes. So think of a job as a process group. Notice that a job may contain only one single process. (credit to [Brian Bi](https://www.quora.com/What-is-the-difference-between-jobs-and-processes-on-Unix))
* To list all the current active jobs: `$ jobs [-l]`.
To list the currently running processes: `$ ps`.
* To run a command in the background, add the `&` symbol: `$ <command> &`
To keep a process running after the shell exits: `$ nohup <command> &`
Both the commands above print out the shell job ID (in brackets) and the process ID (PID), e.g. `[1] 25177`.
* To send foreground jobs to the background: `$ bg %jobID_1 [%jobID_2]`. You can replace the job ID with the command string or use the PID directly (the `%` symbol is not needed): `$ bg PID_1` .
To `fg` command is used similarly to bring background jobs to the foreground.
## Module
* `$ module list`: lists currently loaded modules
* `$ module avail`: lists available packages
* `$ module load <module-file>`: loads module or specifies which dependencies have not been loaded.
* E.g. `$ module load python/3.6`
* `$ module unload <module-file>`: unloads the specified module from the environment.
* `$ module purge`: unloads all loaded modules.
## Miscellaneous
* `$ tar -czvf archive-name.tar.gz /path/to/dir-or-file`: compresses an entire directory or a single file.
`$ tar -xzvf archive-name.tar.gz`: extracts an archive.
* `$ diff <file1> <file2>`: finds the differences between the two files.
\ No newline at end of file
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment